1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/core/sourcehook/sourcehook_hookmangen.cpp Fri Nov 14 04:04:02 2008 -0600
1.3 @@ -0,0 +1,2030 @@
1.4 +/* ======== SourceHook ========
1.5 +* Copyright (C) 2004-2008 Metamod:Source Development Team
1.6 +* No warranties of any kind
1.7 +*
1.8 +* License: zlib/libpng
1.9 +*
1.10 +* Author(s): Pavol "PM OnoTo" Marko
1.11 +* Contributor(s): Borja "faluco" Ferav (many thanks for assitance!)
1.12 +* David "BAILOPAN" Anderson
1.13 +* ============================
1.14 +*/
1.15 +
1.16 +// recommended literature:
1.17 +// http://www.cs.umbc.edu/~chang/cs313.s02/stack.shtml
1.18 +// http://www.angelcode.com/dev/callconv/callconv.html
1.19 +// http://www.arl.wustl.edu/~lockwood/class/cs306/books/artofasm/Chapter_6/CH06-1.html
1.20 +
1.21 +#include <stdio.h>
1.22 +#include "sourcehook_impl.h"
1.23 +#include "sourcehook_hookmangen.h"
1.24 +#include "sourcehook_hookmangen_x86.h"
1.25 +#include "sh_memory.h"
1.26 +#include <stdarg.h> // we might need the address of vsnprintf
1.27 +
1.28 +#if SH_COMP == SH_COMP_MSVC
1.29 +# define GCC_ONLY(x)
1.30 +# define MSVC_ONLY(x) x
1.31 +#elif SH_COMP == SH_COMP_GCC
1.32 +# define GCC_ONLY(x) x
1.33 +# define MSVC_ONLY(x)
1.34 +#endif
1.35 +
1.36 +// :TODO: test BIG vtable indices
1.37 +
1.38 +namespace SourceHook
1.39 +{
1.40 + namespace Impl
1.41 + {
1.42 + CPageAlloc GenBuffer::ms_Allocator(16);
1.43 +
1.44 + template <class T>
1.45 + jit_int32_t DownCastPtr(T ptr)
1.46 + {
1.47 + return reinterpret_cast<jit_int32_t>(ptr);
1.48 + }
1.49 +
1.50 + jit_uint32_t DownCastSize(size_t size)
1.51 + {
1.52 + return static_cast<jit_uint32_t>(size);
1.53 + }
1.54 +
1.55 + GenContext::GenContext(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx, ISourceHook *pSHPtr)
1.56 + : m_GeneratedPubFunc(NULL), m_OrigProto(proto), m_Proto(proto), m_VtblOffs(vtbl_offs),
1.57 + m_VtblIdx(vtbl_idx), m_SHPtr(pSHPtr), m_pHI(NULL), m_HookfuncVfnptr(NULL), m_RegCounter(0)
1.58 + {
1.59 + m_pHI = new void*;
1.60 + m_HookfuncVfnptr = new void*;
1.61 + m_BuiltPI = new ProtoInfo;
1.62 + m_BuiltPI_Params = NULL;
1.63 + m_BuiltPI_Params2 = NULL;
1.64 + }
1.65 +
1.66 + GenContext::~GenContext()
1.67 + {
1.68 + Clear();
1.69 + delete m_pHI;
1.70 + delete m_HookfuncVfnptr;
1.71 + delete m_BuiltPI;
1.72 + }
1.73 +
1.74 + void GenContext::Clear()
1.75 + {
1.76 + m_HookFunc.clear();
1.77 + m_PubFunc.clear();
1.78 + if (m_BuiltPI_Params)
1.79 + {
1.80 + delete [] m_BuiltPI_Params;
1.81 + m_BuiltPI_Params = NULL;
1.82 + }
1.83 + if (m_BuiltPI_Params2)
1.84 + {
1.85 + delete [] m_BuiltPI_Params2;
1.86 + m_BuiltPI_Params2 = NULL;
1.87 + }
1.88 + }
1.89 +
1.90 + void GenContext::BuildProtoInfo()
1.91 + {
1.92 + m_BuiltPI->convention = m_Proto.GetConvention();
1.93 + m_BuiltPI->numOfParams = m_Proto.GetNumOfParams();
1.94 +
1.95 + m_BuiltPI->retPassInfo.size = m_Proto.GetRet().size;
1.96 + m_BuiltPI->retPassInfo.type = m_Proto.GetRet().type;
1.97 + m_BuiltPI->retPassInfo.flags = m_Proto.GetRet().flags;
1.98 + m_BuiltPI->retPassInfo2.pNormalCtor = m_Proto.GetRet().pNormalCtor;
1.99 + m_BuiltPI->retPassInfo2.pCopyCtor = m_Proto.GetRet().pCopyCtor;
1.100 + m_BuiltPI->retPassInfo2.pDtor = m_Proto.GetRet().pDtor;
1.101 + m_BuiltPI->retPassInfo2.pAssignOperator = m_Proto.GetRet().pAssignOperator;
1.102 +
1.103 + if (m_BuiltPI_Params)
1.104 + delete m_BuiltPI_Params;
1.105 + m_BuiltPI_Params = new PassInfo[m_BuiltPI->numOfParams + 1];
1.106 + if (m_BuiltPI_Params2)
1.107 + delete m_BuiltPI_Params2;
1.108 + m_BuiltPI_Params2 = new PassInfo::V2Info[m_BuiltPI->numOfParams + 1];
1.109 +
1.110 + m_BuiltPI_Params[0].size = 1; // Version 1
1.111 + m_BuiltPI_Params[0].type = 0;
1.112 + m_BuiltPI_Params[0].flags = 0;
1.113 +
1.114 + for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1.115 + {
1.116 + m_BuiltPI_Params[i+1].size = m_Proto.GetParam(i).size;
1.117 + m_BuiltPI_Params[i+1].type = m_Proto.GetParam(i).type;
1.118 + m_BuiltPI_Params[i+1].flags = m_Proto.GetParam(i).flags;
1.119 +
1.120 + m_BuiltPI_Params2[i+1].pNormalCtor = m_Proto.GetParam(i).pNormalCtor;
1.121 + m_BuiltPI_Params2[i+1].pCopyCtor = m_Proto.GetParam(i).pCopyCtor;
1.122 + m_BuiltPI_Params2[i+1].pDtor = m_Proto.GetParam(i).pDtor;
1.123 + m_BuiltPI_Params2[i+1].pAssignOperator = m_Proto.GetParam(i).pAssignOperator;
1.124 + }
1.125 +
1.126 + m_BuiltPI->paramsPassInfo = m_BuiltPI_Params;
1.127 + m_BuiltPI->paramsPassInfo2 = m_BuiltPI_Params2;
1.128 + }
1.129 +
1.130 + jit_int32_t GenContext::GetRealSize(const IntPassInfo &info)
1.131 + {
1.132 + if (info.flags & (PassInfo::PassFlag_ByRef | PassFlag_ForcedByRef))
1.133 + {
1.134 + return SIZE_PTR;
1.135 + }
1.136 + return static_cast<jit_int32_t>(info.size);
1.137 + }
1.138 +
1.139 + jit_int32_t GenContext::AlignSize(jit_int32_t x, jit_int32_t boundary)
1.140 + {
1.141 + if (x % boundary != 0)
1.142 + x = (x & ~(boundary-1)) + boundary;
1.143 + return x;
1.144 + }
1.145 +
1.146 + // Computes size on the stack
1.147 + jit_int32_t GenContext::GetParamStackSize(const IntPassInfo &info)
1.148 + {
1.149 + // Align up to 4 byte boundaries
1.150 + return AlignSize(GetRealSize(info), 4);
1.151 + }
1.152 +
1.153 + jit_int8_t GenContext::NextRegEBX_ECX_EDX()
1.154 + {
1.155 + switch ((m_RegCounter++) % 3)
1.156 + {
1.157 + case 0:
1.158 + return REG_EBX;
1.159 + case 1:
1.160 + return REG_ECX;
1.161 + case 2:
1.162 + default:
1.163 + m_RegCounter = 0;
1.164 + return REG_EDX;
1.165 + }
1.166 + }
1.167 +
1.168 + void GenContext::BitwiseCopy_Setup()
1.169 + {
1.170 + //cld
1.171 + //push edi
1.172 + //push esi
1.173 +
1.174 + IA32_Cld(&m_HookFunc);
1.175 + IA32_Push_Reg(&m_HookFunc, REG_EDI);
1.176 + IA32_Push_Reg(&m_HookFunc, REG_ESI);
1.177 + }
1.178 +
1.179 + void GenContext::BitwiseCopy_Do(size_t size)
1.180 + {
1.181 + jit_uint32_t dwords = DownCastSize(size) / 4;
1.182 + jit_uint32_t bytes = DownCastSize(size) % 4;
1.183 +
1.184 + //if dwords
1.185 + // mov ecx, <dwords>
1.186 + // rep movsd
1.187 + //if bytes
1.188 + // mov ecx, <bytes>
1.189 + // rep movsb
1.190 + //pop esi
1.191 + //pop edi
1.192 +
1.193 + if (dwords)
1.194 + {
1.195 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, dwords);
1.196 + IA32_Rep(&m_HookFunc);
1.197 + IA32_Movsd(&m_HookFunc);
1.198 + }
1.199 + if (bytes)
1.200 + {
1.201 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, bytes);
1.202 + IA32_Rep(&m_HookFunc);
1.203 + IA32_Movsb(&m_HookFunc);
1.204 + }
1.205 + IA32_Pop_Reg(&m_HookFunc, REG_ESI);
1.206 + IA32_Pop_Reg(&m_HookFunc, REG_EDI);
1.207 + }
1.208 +
1.209 + jit_int32_t GenContext::AlignStackBeforeCall(int paramsize, int flags)
1.210 + {
1.211 + paramsize +=
1.212 + GCC_ONLY( ((flags & AlignStack_GCC_ThisOnStack)!=0 ? SIZE_PTR : 0) + )
1.213 + MSVC_ONLY( ((flags & AlignStack_MSVC_ThisOnStack)!=0 ? SIZE_PTR : 0) + )
1.214 + ((flags & AlignStack_MemRet)!=0 ? SIZE_PTR : 0);
1.215 +
1.216 + // At the beginning of the hookfunc, the stack is aligned to a 16 bytes boundary.
1.217 + // Then, m_BytesPushedAfterInitialAlignment were pushed (can also be 0).
1.218 +
1.219 + // After this function is called, paramsize bytes will be pushed onto the stack
1.220 + // After that, the alignment has to be a 16 bytes boundary again.
1.221 +
1.222 +
1.223 + // How many bytes we would subtract if the alignment was alright now:
1.224 + int subtractFromEsp = 16 - (paramsize % 16);
1.225 + if (subtractFromEsp == 16)
1.226 + subtractFromEsp = 0;
1.227 +
1.228 + // But: there might be bytes pushed alreay!
1.229 + subtractFromEsp -= m_BytesPushedAfterInitialAlignment;
1.230 +
1.231 + // For example: paramsize was 0 and m_BytesPushedAfterInitialAlignment was 4.
1.232 + // we then have to push another 12 bytes to reach 16 bytes alignment again.
1.233 +
1.234 + if (subtractFromEsp < 0)
1.235 + subtractFromEsp = 16 - ((-subtractFromEsp) % 16);
1.236 +
1.237 + if (subtractFromEsp != 0)
1.238 + IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, subtractFromEsp, MOD_REG);
1.239 +
1.240 + return subtractFromEsp;
1.241 + }
1.242 +
1.243 + void GenContext::AlignStackAfterCall(jit_int32_t numofbytes)
1.244 + {
1.245 + if (numofbytes != 0)
1.246 + IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, numofbytes, MOD_REG);
1.247 + }
1.248 +
1.249 + void GenContext::CheckAlignmentBeforeCall()
1.250 + {
1.251 +#if 0
1.252 + IA32_Test_Rm_Imm32(&m_HookFunc, REG_ESP, 15, MOD_REG);
1.253 + IA32_Jump_Cond_Imm8(&m_HookFunc, CC_Z, 1);
1.254 + IA32_Int3(&m_HookFunc);
1.255 +#endif
1.256 + }
1.257 +
1.258 + short GenContext::GetParamsTotalStackSize()
1.259 + {
1.260 + short acc = 0;
1.261 + for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1.262 + {
1.263 + acc += GetParamStackSize(m_Proto.GetParam(i));
1.264 + }
1.265 +
1.266 + return acc;
1.267 + }
1.268 +
1.269 + short GenContext::GetForcedByRefParamOffset(int p)
1.270 + {
1.271 + short off = 0;
1.272 + for (int i = 0; i < p; ++i)
1.273 + {
1.274 + if (m_Proto.GetParam(i).flags & PassFlag_ForcedByRef)
1.275 + off += AlignSize(static_cast<jit_int32_t>(m_Proto.GetParam(i).size), 4);
1.276 + }
1.277 + return off;
1.278 + }
1.279 +
1.280 + short GenContext::GetForcedByRefParamsSize()
1.281 + {
1.282 + return GetForcedByRefParamOffset(m_Proto.GetNumOfParams());
1.283 + }
1.284 +
1.285 + jit_int32_t GenContext::PushRef(jit_int32_t param_offset, const IntPassInfo &pi)
1.286 + {
1.287 + // push [ebp+<offset>]
1.288 + IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_offset);
1.289 +
1.290 + return SIZE_PTR;
1.291 + }
1.292 +
1.293 + jit_int32_t GenContext::PushBasic(jit_int32_t param_offset, const IntPassInfo &pi)
1.294 + {
1.295 + int reg;
1.296 + int reg2;
1.297 +
1.298 + switch (pi.size)
1.299 + {
1.300 + default:
1.301 + SH_ASSERT(0, ("Unsupported!"));
1.302 + return 0;
1.303 + case 1:
1.304 + reg = NextRegEBX_ECX_EDX();
1.305 + //movzx reg, BYTE PTR [ebp+<offset>]
1.306 + //push reg
1.307 + IA32_Movzx_Reg32_Rm8_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
1.308 + IA32_Push_Reg(&m_HookFunc, reg);
1.309 +
1.310 + return 4;
1.311 + case 2:
1.312 + reg = NextRegEBX_ECX_EDX();
1.313 + //movzx reg, WORD PTR [ebp+<offset>]
1.314 + //push reg
1.315 + m_HookFunc.write_ubyte(IA32_16BIT_PREFIX);
1.316 + IA32_Movzx_Reg32_Rm16_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
1.317 + IA32_Push_Reg(&m_HookFunc, reg);
1.318 +
1.319 + return 4;
1.320 + case 4:
1.321 + reg = NextRegEBX_ECX_EDX();
1.322 + //mov reg, DWORD PTR [ebp+<offset>]
1.323 + //push reg
1.324 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
1.325 + IA32_Push_Reg(&m_HookFunc, reg);
1.326 +
1.327 + return 4;
1.328 + case 8:
1.329 + reg = NextRegEBX_ECX_EDX();
1.330 + reg2 = NextRegEBX_ECX_EDX();
1.331 + //mov reg, DWORD PTR [ebp+<offset>+4]
1.332 + //mov reg2, DWORD PTR [ebp+<offset>]
1.333 + //push reg
1.334 + //push reg2
1.335 +
1.336 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset+4);
1.337 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg2, REG_EBP, param_offset);
1.338 + IA32_Push_Reg(&m_HookFunc, reg);
1.339 + IA32_Push_Reg(&m_HookFunc, reg2);
1.340 +
1.341 + return 8;
1.342 + }
1.343 + }
1.344 +
1.345 + jit_int32_t GenContext::PushFloat(jit_int32_t param_offset, const IntPassInfo &pi)
1.346 + {
1.347 + switch (pi.size)
1.348 + {
1.349 + default:
1.350 + SH_ASSERT(0, ("Unsupported!"));
1.351 + return 0;
1.352 + case 4:
1.353 + //fld DWORD PTR [ebp+<offset>]
1.354 + //push reg
1.355 + //fstp DWORD PTR [esp]
1.356 + IA32_Fld_Mem32_DispAuto(&m_HookFunc, REG_EBP, param_offset);
1.357 + IA32_Push_Reg(&m_HookFunc, NextRegEBX_ECX_EDX());
1.358 + IA32_Fstp_Mem32_ESP(&m_HookFunc);
1.359 + return 4;
1.360 + case 8:
1.361 + //fld QWORD PTR [ebp+<offset>]
1.362 + //sub esp, 8
1.363 + //fstp QWORD PTR [esp]
1.364 + IA32_Fld_Mem64_DispAuto(&m_HookFunc, REG_EBP, param_offset);
1.365 + IA32_Sub_Rm_Imm8(&m_HookFunc, REG_ESP, 8, MOD_REG);
1.366 + IA32_Fstp_Mem64_ESP(&m_HookFunc);
1.367 + return 8;
1.368 + }
1.369 + }
1.370 +
1.371 + jit_int32_t GenContext::PushObject(jit_int32_t param_offset, const IntPassInfo &pi, jit_int32_t place_fbrr)
1.372 + {
1.373 + if ((pi.flags & PassFlag_ForcedByRef) == 0)
1.374 + {
1.375 + // make room on the stack
1.376 + // sub esp, <size>
1.377 + IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, GetParamStackSize(pi), MOD_REG);
1.378 + }
1.379 +
1.380 + // if there is a copy constructor..
1.381 + if (pi.pCopyCtor)
1.382 + {
1.383 + // :TODO: alignment here?
1.384 + // can't use normal alignment methods
1.385 + // because an unknown number of bytes has been pushed already (the other params)
1.386 +
1.387 + // save eax
1.388 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.389 +
1.390 + // compute dest addr to ECX
1.391 + // = forcedbyref ? ebp+place_fbrr : esp+12
1.392 + if (pi.flags & PassFlag_ForcedByRef)
1.393 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
1.394 + else
1.395 + IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_ECX, REG_NOIDX, REG_ESP, NOSCALE, 4);
1.396 +
1.397 + // compute src addr to EAX
1.398 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_offset);
1.399 +
1.400 + // push params (gcc: also this)
1.401 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.402 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.403 +
1.404 + // call
1.405 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(pi.pCopyCtor));
1.406 + IA32_Call_Reg(&m_HookFunc, REG_EDX);
1.407 +
1.408 + // gcc: clean up stack
1.409 + GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
1.410 +
1.411 + // restore eax
1.412 + IA32_Pop_Reg(&m_HookFunc, REG_EAX);
1.413 + }
1.414 + else
1.415 + {
1.416 + // bitwise copy
1.417 +
1.418 + BitwiseCopy_Setup();
1.419 +
1.420 + //if forcedbyref:
1.421 + // lea edi, [ebp_place_fbrr]
1.422 + //else
1.423 + // lea edi, [esp+8] - bc_setup pushed two regs onto the stack!
1.424 + //lea esi, [ebp+<offs>]
1.425 + if (pi.flags & PassFlag_ForcedByRef)
1.426 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, place_fbrr);
1.427 + else
1.428 + IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_EDI, REG_NOIDX, REG_ESP, NOSCALE, 8);
1.429 +
1.430 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, param_offset);
1.431 +
1.432 + BitwiseCopy_Do(pi.size);
1.433 + }
1.434 +
1.435 + // forcedref: push reference to ebp+place_fbrr
1.436 + if (pi.flags & PassFlag_ForcedByRef)
1.437 + {
1.438 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
1.439 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.440 + return SIZE_PTR;
1.441 + }
1.442 +
1.443 + return GetParamStackSize(pi);
1.444 + }
1.445 +
1.446 + void GenContext::DestroyParams(jit_int32_t fbrr_base)
1.447 + {
1.448 + for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
1.449 + {
1.450 + const IntPassInfo &pi = m_Proto.GetParam(i);
1.451 + if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
1.452 + (pi.flags & PassInfo::PassFlag_ByVal) && (pi.flags & PassFlag_ForcedByRef))
1.453 + {
1.454 + // Actually, this is only for GCC (see line above: ForcedByRef)
1.455 + jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack);
1.456 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, fbrr_base + GetForcedByRefParamOffset(i));
1.457 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.458 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
1.459 + CheckAlignmentBeforeCall();
1.460 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.461 + IA32_Pop_Reg(&m_HookFunc, REG_ECX);
1.462 +
1.463 + AlignStackAfterCall(tmpAlign);
1.464 + }
1.465 + }
1.466 + }
1.467 +
1.468 + // May not touch eax!
1.469 + jit_int32_t GenContext::PushParams(jit_int32_t param_base_offset, jit_int32_t save_ret_to, int v_place_for_memret,
1.470 + jit_int32_t v_place_fbrr_base)
1.471 + {
1.472 + jit_int32_t added_to_stack = 0;
1.473 + jit_int32_t ret = 0;
1.474 +
1.475 + // compute the offset _after_ the last parameter
1.476 + jit_int32_t cur_offset = param_base_offset;
1.477 + for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1.478 + {
1.479 + cur_offset += GetParamStackSize(m_Proto.GetParam(i));
1.480 + }
1.481 +
1.482 + // push parameters in reverse order
1.483 + for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
1.484 + {
1.485 + const IntPassInfo &pi = m_Proto.GetParam(i);
1.486 + cur_offset -= GetParamStackSize(pi);
1.487 + if (pi.flags & PassInfo::PassFlag_ByVal)
1.488 + {
1.489 + switch (pi.type)
1.490 + {
1.491 + case PassInfo::PassType_Basic:
1.492 + ret = PushBasic(cur_offset, pi);
1.493 + break;
1.494 + case PassInfo::PassType_Float:
1.495 + ret = PushFloat(cur_offset, pi);
1.496 + break;
1.497 + case PassInfo::PassType_Object:
1.498 + ret = PushObject(cur_offset, pi, v_place_fbrr_base + GetForcedByRefParamOffset(i));
1.499 + break;
1.500 + }
1.501 + }
1.502 + else if (pi.flags & PassInfo::PassFlag_ByRef)
1.503 + {
1.504 + ret = PushRef(cur_offset, pi);
1.505 + }
1.506 + else
1.507 + {
1.508 + SH_ASSERT(0, ("Unsupported!"));
1.509 + }
1.510 + added_to_stack += ret;
1.511 + }
1.512 +
1.513 + return added_to_stack;
1.514 + }
1.515 +
1.516 + // It is IMPORTANT that PushMemRetPtr doesn't touch ecx and eax
1.517 + jit_int32_t GenContext::PushMemRetPtr(jit_int32_t save_ret_to, jit_int32_t v_place_for_memret)
1.518 + {
1.519 + // Memory return support
1.520 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1.521 + {
1.522 + // push address where to save it!
1.523 + int reg = REG_EDX;
1.524 + IA32_Lea_DispRegImmAuto(&m_HookFunc, reg, REG_EBP,
1.525 + MemRetWithTempObj() ? v_place_for_memret : save_ret_to);
1.526 + IA32_Push_Reg(&m_HookFunc, reg);
1.527 +
1.528 + return (SH_COMP==SH_COMP_MSVC) ? 4 : 0; // varargs funcs on msvc might need this.
1.529 + // gcc doesn't: callee cleans the memret ptr, caller the other params :s
1.530 + }
1.531 + return 0;
1.532 + }
1.533 +
1.534 + void GenContext::SaveRetVal(int v_where, int v_place_for_memret)
1.535 + {
1.536 + size_t size = GetRealSize(m_Proto.GetRet());
1.537 + if (size == 0)
1.538 + {
1.539 + // No return value -> nothing
1.540 + return;
1.541 + }
1.542 +
1.543 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
1.544 + {
1.545 + // mov [ebp + v_plugin_ret], eax
1.546 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
1.547 + return;
1.548 + }
1.549 + // else: ByVal
1.550 +
1.551 +
1.552 + // Memory return:
1.553 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1.554 + {
1.555 + if (MemRetWithTempObj())
1.556 + {
1.557 + // *v_where = *v_place_for_memret
1.558 +
1.559 + // if we have an assign operator, use that
1.560 + if (m_Proto.GetRet().pAssignOperator)
1.561 + {
1.562 + // lea edx, [ebp + v_place_for_memret] <-- src addr
1.563 + // lea ecx, [ebp + v_where] <-- dest addr
1.564 + // push edx
1.565 + // gcc: push ecx
1.566 + // call it
1.567 + // gcc: clean up
1.568 +
1.569 + jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack);
1.570 +
1.571 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_place_for_memret);
1.572 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_where);
1.573 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.574 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.575 +
1.576 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
1.577 + CheckAlignmentBeforeCall();
1.578 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.579 + GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
1.580 +
1.581 + AlignStackAfterCall(tmpAlign);
1.582 + }
1.583 + else
1.584 + {
1.585 + // bitwise copy
1.586 + BitwiseCopy_Setup();
1.587 +
1.588 + //lea edi, [evp+v_where] <-- destination
1.589 + //lea esi, [ebp+v_place_for_memret] <-- src
1.590 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_where);
1.591 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_place_for_memret);
1.592 +
1.593 + BitwiseCopy_Do(m_Proto.GetRet().size);
1.594 + }
1.595 +
1.596 + // Then: destruct *v_place_for_memret if required
1.597 + if (m_Proto.GetRet().pDtor)
1.598 + {
1.599 + //lea ecx, [ebp+v_place_for_memret]
1.600 + //gcc: push ecx
1.601 + //call it
1.602 + //gcc: clean up
1.603 +
1.604 + jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack);
1.605 +
1.606 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_place_for_memret);
1.607 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.608 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1.609 + CheckAlignmentBeforeCall();
1.610 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.611 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.612 +
1.613 + AlignStackAfterCall(tmpAlign);
1.614 + }
1.615 + }
1.616 + else
1.617 + {
1.618 + // Already copied to correct address -> we're done
1.619 + return;
1.620 + }
1.621 + }
1.622 +
1.623 + if (m_Proto.GetRet().type == PassInfo::PassType_Float)
1.624 + {
1.625 + if (size == 4)
1.626 + IA32_Fstp_Mem32_DispAuto(&m_HookFunc, REG_EBP, v_where);
1.627 + else if (size == 8)
1.628 + IA32_Fstp_Mem64_DispAuto(&m_HookFunc, REG_EBP, v_where);
1.629 + }
1.630 + else if (m_Proto.GetRet().type == PassInfo::PassType_Basic)
1.631 + {
1.632 + if (size <= 4)
1.633 + {
1.634 + // size <= 4: return in EAX
1.635 + // We align <4 sizes up to 4
1.636 +
1.637 +
1.638 + // mov [ebp + v_plugin_ret], eax
1.639 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
1.640 + }
1.641 + else if (size <= 8)
1.642 + {
1.643 + // size <= 4: return in EAX:EDX
1.644 + // We align 4<x<8 sizes up to 8
1.645 +
1.646 + // mov [ebp + v_plugin_ret], eax
1.647 + // mov [ebp + v_plugin_ret + 4], edx
1.648 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
1.649 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
1.650 + }
1.651 + }
1.652 + else if (m_Proto.GetRet().type == PassInfo::PassType_Object)
1.653 + {
1.654 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)
1.655 + {
1.656 + if (size <= 4)
1.657 + {
1.658 + // size <= 4: return in EAX
1.659 + // We align <4 sizes up to 4
1.660 +
1.661 + // mov [ebp + v_plugin_ret], eax
1.662 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
1.663 + }
1.664 + else if (size <= 8)
1.665 + {
1.666 + // size <= 4: return in EAX:EDX
1.667 + // We align 4<x<8 sizes up to 8
1.668 +
1.669 + // mov [ebp + v_plugin_ret], eax
1.670 + // mov [ebp + v_plugin_ret + 4], edx
1.671 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
1.672 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
1.673 + }
1.674 + else
1.675 + {
1.676 + SH_ASSERT(0, ("RetReg and size > 8 !"));
1.677 + }
1.678 + }
1.679 + }
1.680 + }
1.681 +
1.682 + bool GenContext::MemRetWithTempObj()
1.683 + {
1.684 + // Memory return AND (has destructor OR has assign operator)
1.685 + return ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1.686 + && (m_Proto.GetRet().flags & (PassInfo::PassFlag_ODtor | PassInfo::PassFlag_AssignOp)));
1.687 + }
1.688 +
1.689 + void GenContext::ProcessPluginRetVal(int v_cur_res, int v_pContext, int v_plugin_ret)
1.690 + {
1.691 + // only for non-void functions!
1.692 + if (m_Proto.GetRet().size == 0)
1.693 + return;
1.694 +
1.695 + // if (cur_res >= MRES_OVERRIDE)
1.696 + // *reinterpret_cast<my_rettype*>(pContext->GetOverrideRetPtr()) = plugin_ret;
1.697 +
1.698 + // eax = cur_res
1.699 + // cmp eax,MRES_OVERRIDE
1.700 + // jnge thelabel
1.701 + // pContext->GetOverrideRetPtr() --> overrideretptr in eax
1.702 + // *eax = plugin_ret
1.703 + // thelabel:
1.704 + //
1.705 +
1.706 + jitoffs_t tmppos, counter;
1.707 +
1.708 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
1.709 +
1.710 + IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_OVERRIDE);
1.711 + tmppos = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NGE, 0);
1.712 + m_HookFunc.start_count(counter);
1.713 +
1.714 + // eax = pContext->GetOverrideRetPtr() no alignment needs
1.715 + // ECX = pContext
1.716 + // gcc: push ecx
1.717 + // eax = [ecx]
1.718 + // eax = [eax + 4]
1.719 + // call eax
1.720 + // gcc: clean up
1.721 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
1.722 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.723 +
1.724 + // vtbloffs=0, vtblidx=1
1.725 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.726 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 4);
1.727 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.728 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.729 +
1.730 +
1.731 + // *eax = plugin_ret
1.732 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
1.733 + {
1.734 + // mov ecx, [ebp+v_plugin_ret]
1.735 + // mov [eax], ecx
1.736 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1.737 + IA32_Mov_Rm_Reg(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.738 + }
1.739 + else
1.740 + {
1.741 + if (m_Proto.GetRet().pAssignOperator)
1.742 + {
1.743 + // lea edx, [ebp + v_plugin_ret]
1.744 + // push edx <-- src addr
1.745 + // msvc: ecx = eax <-- dest addr
1.746 + // gcc: push eax <-- dest addr
1.747 + // call it
1.748 + // gcc: clean up
1.749 +
1.750 + jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack);
1.751 +
1.752 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_plugin_ret);
1.753 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.754 +#if SH_COMP == SH_COMP_MSVC
1.755 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
1.756 +#elif SH_COMP == SH_COMP_GCC
1.757 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.758 +#endif
1.759 +
1.760 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
1.761 + CheckAlignmentBeforeCall();
1.762 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.763 + GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
1.764 +
1.765 + AlignStackAfterCall(tmpAlign);
1.766 + }
1.767 + else
1.768 + {
1.769 + // bitwise copy
1.770 + BitwiseCopy_Setup();
1.771 +
1.772 + //mov edi, eax <-- destination
1.773 + //lea esi, [ebp+v_plugin_ret] <-- src
1.774 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDI, REG_EAX, MOD_REG);
1.775 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_plugin_ret);
1.776 +
1.777 + BitwiseCopy_Do(m_Proto.GetRet().size);
1.778 + }
1.779 + }
1.780 +
1.781 + m_HookFunc.end_count(counter);
1.782 + m_HookFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1.783 + }
1.784 +
1.785 + void GenContext::PrepareReturn(int v_status, int v_pContext, int v_retptr)
1.786 + {
1.787 + // only for non-void functions!
1.788 + if (m_Proto.GetRet().size == 0)
1.789 + return;
1.790 +
1.791 + // retptr = status >= MRES_OVERRIDE ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()
1.792 +
1.793 + // OverrideRetPtr: vtblidx = 1
1.794 + // OrigRetPtr: vtbldix = 2
1.795 + // vtblidx = (status >= MRES_OVERRIDE) ? 1 : 2
1.796 +
1.797 + //
1.798 + // eax = pContext->GetOverrideRetPtr()
1.799 + // ECX = pContext
1.800 + // gcc: push ecx
1.801 +
1.802 + // eax = (status < MRES_OVERRIDE) ? 1 : 0
1.803 + // xor eax, eax
1.804 + // cmp [ebp + v_status], MRES_OVERRIDE
1.805 + // setl al <-- setcc optimization for ternary operators,
1.806 +
1.807 +
1.808 + // lea eax, [4*eax + 0x4]
1.809 +
1.810 + // edx = [ecx]
1.811 + // add edx, eax
1.812 + // mov edx, [edx]
1.813 +
1.814 + // call edx
1.815 + // gcc: clean up
1.816 +
1.817 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
1.818 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.819 + IA32_Xor_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
1.820 + IA32_Cmp_Rm_Disp8_Imm8(&m_HookFunc, REG_EBP, v_status, MRES_OVERRIDE);
1.821 + IA32_SetCC_Rm8(&m_HookFunc, REG_EAX, CC_L);
1.822 +
1.823 + IA32_Lea_Reg_RegMultImm32(&m_HookFunc, REG_EAX, REG_EAX, SCALE4, 4);
1.824 +
1.825 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1.826 + IA32_Add_Reg_Rm(&m_HookFunc, REG_EDX, REG_EAX, MOD_REG);
1.827 +
1.828 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_MEM_REG);
1.829 + IA32_Call_Reg(&m_HookFunc, REG_EDX);
1.830 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.831 +
1.832 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_retptr);
1.833 + }
1.834 +
1.835 + void GenContext::DoReturn(int v_retptr, int v_memret_outaddr)
1.836 + {
1.837 + size_t size = m_Proto.GetRet().size;
1.838 + if (!size)
1.839 + return;
1.840 +
1.841 + // Get real ret pointer into ecx
1.842 + // mov ecx, [ebp + v_ret_ptr]
1.843 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_retptr);
1.844 +
1.845 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
1.846 + {
1.847 + // mov eax, [ecx]
1.848 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.849 + return;
1.850 + }
1.851 + // else: byval
1.852 +
1.853 + if (m_Proto.GetRet().type == PassInfo::PassType_Float)
1.854 + {
1.855 + if (size == 4)
1.856 + IA32_Fld_Mem32(&m_HookFunc, REG_ECX);
1.857 + else if (size == 8)
1.858 + IA32_Fld_Mem64(&m_HookFunc, REG_ECX);
1.859 + }
1.860 + else if (m_Proto.GetRet().type == PassInfo::PassType_Basic ||
1.861 + ((m_Proto.GetRet().type == PassInfo::PassType_Object) && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)) )
1.862 + {
1.863 + if (size <= 4)
1.864 + {
1.865 + // size <= 4: return in EAX
1.866 + // We align <4 sizes up to 4
1.867 +
1.868 + // mov eax, [ecx]
1.869 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.870 + }
1.871 + else if (size <= 8)
1.872 + {
1.873 + // size <= 4: return in EAX:EDX
1.874 + // We align 4<x<8 sizes up to 8
1.875 +
1.876 + // mov eax, [ecx]
1.877 + // mov edx, [ecx+4]
1.878 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.879 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, 4);
1.880 + }
1.881 + else
1.882 + {
1.883 + // size >8: return in memory
1.884 + // handled later
1.885 + }
1.886 + }
1.887 +
1.888 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1.889 + {
1.890 + // *memret_outaddr = plugin_ret
1.891 + if (m_Proto.GetRet().pCopyCtor)
1.892 + {
1.893 + // mov edx, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
1.894 + // push edx <-- src addr
1.895 + // msvc: ecx = [ebp + v_memret_outaddr] <-- dest addr
1.896 + // gcc: push [ebp + v_memret_outaddr] <-- dest addr
1.897 + // call it
1.898 + // gcc: clean up
1.899 +
1.900 + jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack);
1.901 +
1.902 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_REG);
1.903 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.904 +
1.905 +#if SH_COMP == SH_COMP_MSVC
1.906 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_memret_outaddr);
1.907 +#elif SH_COMP == SH_COMP_GCC
1.908 + IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, v_memret_outaddr);
1.909 +#endif
1.910 +
1.911 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pCopyCtor));
1.912 + CheckAlignmentBeforeCall();
1.913 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.914 + GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
1.915 +
1.916 + AlignStackAfterCall(tmpAlign);
1.917 + }
1.918 + else
1.919 + {
1.920 + // bitwise copy
1.921 + BitwiseCopy_Setup();
1.922 +
1.923 + //mov edi, [ebp+v_memret_outaddr] <-- destination
1.924 + //mov esi, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
1.925 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDI, REG_EBP, v_memret_outaddr);
1.926 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESI, REG_ECX, MOD_REG);
1.927 +
1.928 + BitwiseCopy_Do(m_Proto.GetRet().size);
1.929 + }
1.930 +
1.931 + // In both cases: return the pointer in EAX
1.932 + // mov eax, [ebp + v_memret_outaddr]
1.933 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_memret_outaddr);
1.934 + }
1.935 + }
1.936 +
1.937 + void GenContext::GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter,
1.938 + int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base, jit_int32_t v_va_buf)
1.939 + {
1.940 + jitoffs_t counter, tmppos;
1.941 + jitoffs_t counter2, tmppos2;
1.942 +
1.943 + jitoffs_t loop_begin_counter;
1.944 +
1.945 + // prev_res = MRES_IGNORED
1.946 + IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_prev_res);
1.947 +
1.948 + m_HookFunc.start_count(loop_begin_counter);
1.949 +
1.950 + // eax = pContext->GetNext()
1.951 + // ECX = pContext
1.952 + // gcc: push ecx
1.953 + // eax = [ecx]
1.954 + // eax = [eax]
1.955 + // call eax
1.956 + // gcc: clean up
1.957 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
1.958 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.959 +
1.960 + // vtbloffs=0, vtblidx=0
1.961 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.962 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_MEM_REG);
1.963 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.964 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.965 +
1.966 + // quit on zero
1.967 + // test eax, eax
1.968 + // jz exit
1.969 + IA32_Test_Rm_Reg(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
1.970 + tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
1.971 + m_HookFunc.start_count(counter);
1.972 +
1.973 + // prev_res = MRES_IGNORED
1.974 + IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_cur_res);
1.975 +
1.976 + // iter->call()
1.977 + // push params
1.978 + // ecx = eax
1.979 + // gcc: push ecx
1.980 + // eax = [ecx]
1.981 + // eax = [eax+2*SIZE_PTR]
1.982 + // call eax
1.983 + // gcc: clean up
1.984 +
1.985 + jit_int32_t caller_clean_bytes = 0; // gcc always, msvc never (hooks never have varargs!)
1.986 +
1.987 + jit_int32_t alignBytes = AlignStackBeforeCall(
1.988 + GetParamsTotalStackSize() + ((m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)!=0 ? SIZE_PTR : 0),
1.989 + AlignStack_GCC_ThisOnStack | ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) == 0 ? 0 : AlignStack_MemRet)
1.990 + );
1.991 +
1.992 + // vafmt: push va_buf
1.993 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
1.994 + {
1.995 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf);
1.996 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.997 + caller_clean_bytes += SIZE_PTR;
1.998 + }
1.999 +
1.1000 + caller_clean_bytes += PushParams(base_param_offset, v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
1.1001 +
1.1002 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
1.1003 + if (SH_COMP == SH_COMP_GCC)
1.1004 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.1005 + caller_clean_bytes += PushMemRetPtr(v_plugin_ret, v_place_for_memret);
1.1006 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.1007 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 2*SIZE_PTR);
1.1008 + CheckAlignmentBeforeCall();
1.1009 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1010 +
1.1011 + AlignStackAfterCall(alignBytes);
1.1012 +
1.1013 + // cleanup (gcc only)
1.1014 + // params + thisptr
1.1015 + if (SH_COMP == SH_COMP_GCC)
1.1016 + IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, caller_clean_bytes + SIZE_PTR, MOD_REG);
1.1017 +
1.1018 + DestroyParams(v_place_fbrr_base);
1.1019 +
1.1020 + SaveRetVal(v_plugin_ret, v_place_for_memret);
1.1021 +
1.1022 + // process meta return:
1.1023 + // prev_res = cur_res
1.1024 + // if (cur_res > status) status = cur_res;
1.1025 + //
1.1026 + // eax = cur_res
1.1027 + // edx = status
1.1028 + // prev_res = eax
1.1029 + // cmp eax,edx
1.1030 + // jng thelabel
1.1031 + // status = eax
1.1032 + // thelabel:
1.1033 + //
1.1034 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
1.1035 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDX, REG_EBP, v_status);
1.1036 + IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_prev_res);
1.1037 +
1.1038 + IA32_Cmp_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_REG);
1.1039 + tmppos2 = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NG, 0);
1.1040 + m_HookFunc.start_count(counter2);
1.1041 +
1.1042 + IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_status);
1.1043 +
1.1044 + m_HookFunc.end_count(counter2);
1.1045 + m_HookFunc.rewrite(tmppos2, static_cast<jit_uint8_t>(counter2));
1.1046 +
1.1047 + // process retval for non-void functions
1.1048 + ProcessPluginRetVal(v_cur_res, v_pContext, v_plugin_ret);
1.1049 +
1.1050 + // jump back to loop begin
1.1051 + tmppos2 = IA32_Jump_Imm32(&m_HookFunc, 0);
1.1052 + m_HookFunc.end_count(loop_begin_counter);
1.1053 + m_HookFunc.rewrite(tmppos2, -static_cast<jit_int32_t>(loop_begin_counter));
1.1054 +
1.1055 + m_HookFunc.end_count(counter);
1.1056 + m_HookFunc.rewrite(tmppos, static_cast<jit_int32_t>(counter));
1.1057 + }
1.1058 +
1.1059 + void GenContext::GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this,
1.1060 + int v_vfnptr_origentry, int v_orig_ret, int v_override_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base, jit_int32_t v_va_buf)
1.1061 + {
1.1062 + jitoffs_t counter, tmppos;
1.1063 + jitoffs_t counter2, tmppos2;
1.1064 + jitoffs_t counter3, tmppos3;
1.1065 +
1.1066 + // if (status != MRES_SUPERCEDE && pConteext->ShouldCallOrig())
1.1067 + // *v_orig_ret = orig_call()
1.1068 + // else
1.1069 + // *v_orig_ret = *v_override_ret
1.1070 +
1.1071 + // mov eax, status
1.1072 + // cmp eax, MRES_SUPERCEDE
1.1073 + // je dont_call
1.1074 + // call pContext->ShouldCallOrig()
1.1075 + // test al, al !! important: al, not eax! bool is only stored in the LSbyte
1.1076 + // jz dont_call
1.1077 + //
1.1078 + // orig_call()
1.1079 + // SaveRet(v_orig_ret)
1.1080 + // jmp skip_dont_call:
1.1081 + //
1.1082 + // dont_call:
1.1083 + // *v_orig_ret = *v_override_ret
1.1084 + // skip_dont_call:
1.1085 +
1.1086 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_status);
1.1087 + IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_SUPERCEDE);
1.1088 +
1.1089 + tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_E, 0);
1.1090 + m_HookFunc.start_count(counter);
1.1091 +
1.1092 + // eax = pContext->ShouldCallOrig()
1.1093 + // ECX = pContext
1.1094 + // gcc: push ecx
1.1095 + // eax = [ecx]
1.1096 + // eax = [eax + 3*SIZE_PTR]
1.1097 + // call eax
1.1098 + // gcc: clean up
1.1099 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
1.1100 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1101 +
1.1102 + // vtbloffs=0, vtblidx=3
1.1103 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1.1104 + IA32_Mov_Reg_Rm_Disp8(&m_HookFunc, REG_EAX, REG_EAX, 3*SIZE_PTR);
1.1105 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1106 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1107 +
1.1108 + IA32_Test_Rm_Reg8(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
1.1109 + tmppos2 = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
1.1110 + m_HookFunc.start_count(counter2);
1.1111 +
1.1112 + jit_int32_t caller_clean_bytes = 0; // gcc always, msvc when cdecl-like (varargs)
1.1113 +
1.1114 + jit_int32_t alignBytes = AlignStackBeforeCall(
1.1115 + GetParamsTotalStackSize() + ((m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)!=0 ? 2*SIZE_PTR : 0),
1.1116 + AlignStack_GCC_ThisOnStack |
1.1117 + ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) == 0 ? 0 : AlignStack_MemRet) |
1.1118 + ((m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) == 0 ? 0 : AlignStack_MSVC_ThisOnStack)
1.1119 + );
1.1120 +
1.1121 + // vafmt: push va_buf, then "%s"
1.1122 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
1.1123 + {
1.1124 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf);
1.1125 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.1126 + IA32_Push_Imm32(&m_HookFunc, DownCastPtr("%s"));
1.1127 + caller_clean_bytes += 2*SIZE_PTR;
1.1128 + }
1.1129 +
1.1130 + // push params
1.1131 + caller_clean_bytes += PushParams(param_base_offs, v_orig_ret, v_place_for_memret, v_place_fbrr_base);
1.1132 +
1.1133 + // thisptr
1.1134 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this);
1.1135 + if (SH_COMP == SH_COMP_GCC)
1.1136 + {
1.1137 + // on gcc/mingw, this is the first parameter
1.1138 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.1139 + // on msvc without varargs, simply leave it in ecx
1.1140 +
1.1141 + // actually, if we're returning in memory, this pointer is the second param
1.1142 + // and the memret pointer is the real first parameter
1.1143 + caller_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret);
1.1144 + }
1.1145 + else
1.1146 + {
1.1147 + // On msvc, if we're returning in memory, the memret pointer is the first parameter
1.1148 + caller_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret);
1.1149 +
1.1150 + // actually, with varargs, the this pointer is the first param and the memret ptr
1.1151 + // is the second one
1.1152 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1.1153 + {
1.1154 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.1155 + }
1.1156 + }
1.1157 +
1.1158 + // call
1.1159 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_vfnptr_origentry);
1.1160 + CheckAlignmentBeforeCall();
1.1161 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1162 +
1.1163 + AlignStackAfterCall(alignBytes);
1.1164 +
1.1165 + // cleanup
1.1166 + if (SH_COMP == SH_COMP_GCC || (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs))
1.1167 + IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, caller_clean_bytes + SIZE_PTR, MOD_REG);
1.1168 +
1.1169 + DestroyParams(v_place_fbrr_base);
1.1170 +
1.1171 + // save retval
1.1172 + SaveRetVal(v_orig_ret, v_place_for_memret);
1.1173 +
1.1174 + // Skip don't call variant
1.1175 + tmppos3 = IA32_Jump_Imm32(&m_HookFunc, 0);
1.1176 + m_HookFunc.start_count(counter3);
1.1177 +
1.1178 +
1.1179 + // don't call:
1.1180 + m_HookFunc.end_count(counter);
1.1181 + m_HookFunc.rewrite(tmppos, static_cast<jit_uint32_t>(counter));
1.1182 +
1.1183 + m_HookFunc.end_count(counter2);
1.1184 + m_HookFunc.rewrite(tmppos2, static_cast<jit_uint32_t>(counter2));
1.1185 +
1.1186 + // *v_orig_ret = *v_override_ret
1.1187 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
1.1188 + {
1.1189 + // mov ecx, [ebp + v_override_ret]
1.1190 + // mov [ebp + v_orig_ret], ecx
1.1191 +
1.1192 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1.1193 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_ECX, v_orig_ret);
1.1194 + }
1.1195 + else
1.1196 + {
1.1197 + if (m_Proto.GetRet().pAssignOperator)
1.1198 + {
1.1199 + // lea edx, [ebp + v_override_ret] <-- src addr
1.1200 + // lea ecx, [ebp + v_orig_ret] <-- dest addr
1.1201 + // push edx <-- src addr
1.1202 + // gcc: push ecx
1.1203 + // call it
1.1204 + // gcc: clean up
1.1205 +
1.1206 + jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack);
1.1207 +
1.1208 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_override_ret);
1.1209 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1.1210 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.1211 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1212 +
1.1213 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
1.1214 + CheckAlignmentBeforeCall();
1.1215 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1216 + GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
1.1217 +
1.1218 + AlignStackAfterCall(tmpAlign);
1.1219 + }
1.1220 + else
1.1221 + {
1.1222 + // bitwise copy
1.1223 + BitwiseCopy_Setup();
1.1224 +
1.1225 + //lea edi, [ebp+v_orig_ret] <-- destination
1.1226 + //lea esi, [ebp+v_override_ret] <-- src
1.1227 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_orig_ret);
1.1228 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_override_ret);
1.1229 +
1.1230 + BitwiseCopy_Do(m_Proto.GetRet().size);
1.1231 + }
1.1232 + }
1.1233 +
1.1234 + // skip don't call label target:
1.1235 + m_HookFunc.end_count(counter3);
1.1236 + m_HookFunc.rewrite(tmppos3, static_cast<jit_uint32_t>(counter3));
1.1237 + }
1.1238 +
1.1239 + // Sets *v_pContext to return value
1.1240 + void GenContext::CallSetupHookLoop(int v_orig_ret, int v_override_ret,
1.1241 + int v_cur_res, int v_prev_res, int v_status, int v_vfnptr_origentry,
1.1242 + int v_this, int v_pContext)
1.1243 + {
1.1244 + // call shptr->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this),
1.1245 + // &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret);
1.1246 + // The last two params are null for void funcs.
1.1247 +
1.1248 + if (m_Proto.GetRet().size == 0)
1.1249 + {
1.1250 + // void
1.1251 + IA32_Push_Imm8(&m_HookFunc, 0); // orig_ret
1.1252 + IA32_Push_Imm8(&m_HookFunc, 0); // override_ret
1.1253 + }
1.1254 + else
1.1255 + {
1.1256 + // orig_ret and override_ret
1.1257 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, v_override_ret);
1.1258 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_orig_ret);
1.1259 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1260 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.1261 + }
1.1262 +
1.1263 + // cur_res and prev_res
1.1264 + IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
1.1265 + IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_prev_res);
1.1266 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1267 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.1268 +
1.1269 + // status and vfnptr_origentry
1.1270 + IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_status);
1.1271 + IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_vfnptr_origentry);
1.1272 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1273 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.1274 +
1.1275 + // this
1.1276 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_this);
1.1277 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1278 +
1.1279 + // our vfn ptr
1.1280 + // *(this + vtbloffs) + SIZE_PTR*vtblidx
1.1281 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this); // get this into ecx (gcc!)
1.1282 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, m_VtblOffs);
1.1283 + IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_EAX, m_VtblIdx * SIZE_PTR, MOD_REG);
1.1284 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1285 +
1.1286 + // *m_pHI
1.1287 + IA32_Mov_Rm_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1.1288 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1.1289 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1290 +
1.1291 + // set up thisptr
1.1292 +#if SH_COMP == SH_COMP_GCC
1.1293 + // on gcc/mingw, this is the first parameter
1.1294 + GCC_ONLY(IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr)));
1.1295 +#elif SH_COMP == SH_COMP_MSVC
1.1296 + // on msvc, it's ecx
1.1297 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1.1298 +#endif
1.1299 +
1.1300 + // call the function. vtbloffs = 0, vtblidx = 19
1.1301 + // get vtptr into edx -- we know shptr on jit time -> dereference it here!
1.1302 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX,
1.1303 + (*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[19]);
1.1304 +
1.1305 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1306 +
1.1307 + // on gcc/mingw, we have to clean up after the call
1.1308 + // 9 params + hidden thisptr param
1.1309 + GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 10*SIZE_PTR, MOD_REG));
1.1310 +
1.1311 + // store return value
1.1312 + IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_pContext);
1.1313 + }
1.1314 +
1.1315 + void GenContext::CallEndContext(int v_pContext)
1.1316 + {
1.1317 + // call endcontext:
1.1318 + // shptr->EndContext(pContex)
1.1319 + IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_pContext);
1.1320 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1321 +
1.1322 + // thisptr
1.1323 +#if SH_COMP == SH_COMP_GCC
1.1324 + // on gcc/mingw, this is the first parameter
1.1325 + IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr));
1.1326 +#elif SH_COMP == SH_COMP_MSVC
1.1327 + // on msvc, it's ecx
1.1328 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1.1329 +#endif
1.1330 +
1.1331 + // get vtptr into edx -- we know shptr on jit time -> dereference it here!
1.1332 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX,
1.1333 + (*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[20]);
1.1334 +
1.1335 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1336 +
1.1337 + // on gcc/mingw, we have to clean up after the call
1.1338 + // 1 param + hidden thisptr param
1.1339 + GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
1.1340 + }
1.1341 +
1.1342 + void GenContext::ResetFrame(jit_int32_t startOffset)
1.1343 + {
1.1344 + m_HookFunc_FrameOffset = startOffset;
1.1345 + m_HookFunc_FrameVarsSize = 0;
1.1346 + }
1.1347 +
1.1348 + jit_int32_t GenContext::AddVarToFrame(jit_int32_t size)
1.1349 + {
1.1350 + m_HookFunc_FrameOffset -= size;
1.1351 + m_HookFunc_FrameVarsSize += size;
1.1352 + return m_HookFunc_FrameOffset;
1.1353 + }
1.1354 +
1.1355 + jit_int32_t GenContext::ComputeVarsSize()
1.1356 + {
1.1357 + return m_HookFunc_FrameVarsSize;
1.1358 + }
1.1359 +
1.1360 + void * GenContext::GenerateHookFunc()
1.1361 + {
1.1362 + // prologue
1.1363 + IA32_Push_Reg(&m_HookFunc, REG_EBP);
1.1364 + IA32_Push_Reg(&m_HookFunc, REG_EBX);
1.1365 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_EBP, REG_ESP, MOD_REG);
1.1366 +
1.1367 + jit_int32_t v_this = 0;
1.1368 + jit_int32_t param_base_offs = 0;
1.1369 + if (SH_COMP == SH_COMP_GCC || (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs))
1.1370 + {
1.1371 + // gcc or msvc with varargs:
1.1372 + v_this = 12; // first param
1.1373 + param_base_offs = 16;
1.1374 + ResetFrame(0);
1.1375 + }
1.1376 + else
1.1377 + {
1.1378 + // on msvc without varargs, save thisptr
1.1379 + v_this = -4;
1.1380 + param_base_offs = 12;
1.1381 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.1382 + ResetFrame(-4); // start placing local vars on offset -4
1.1383 + // because there already is the thisptr variable
1.1384 + }
1.1385 +
1.1386 + // ********************** stack frame **********************
1.1387 + // MSVC without varargs
1.1388 + // second param (gcc: first real param) ebp + 16
1.1389 + // first param (gcc: thisptr) ebp + 12
1.1390 + // ret address: ebp + 8
1.1391 + // caller's ebp ebp + 4
1.1392 + // saved ebx ebp
1.1393 + // MSVC ONLY: current this ebp - 4
1.1394 + // void *vfnptr_origentry ebp - 4 -4
1.1395 + // META_RES status = MRES_IGNORED ebp - 8 -4
1.1396 + // META_RES prev_res ebp - 12 -4
1.1397 + // META_RES cur_res ebp - 16 -4
1.1398 + // IMyDelegate *iter ebp - 20 -4
1.1399 + // IHookContext *pContext ebp - 24 -4
1.1400 + // == 3 ptrs + 3 enums = 24 bytes
1.1401 + //
1.1402 + // non-void: add:
1.1403 + // my_rettype *ret_ptr ebp - 28 -4
1.1404 + // my_rettype orig_ret ebp - 28 - sizeof(my_rettype) -4
1.1405 + // my_rettype override_ret ebp - 28 - sizeof(my_rettype)*2 -4
1.1406 + // my_rettype plugin_ret ebp - 28 - sizeof(my_rettype)*3 -4
1.1407 + // == + 3 * sizeof(my_rettype) bytes
1.1408 +
1.1409 + // if required:
1.1410 + // my_rettype place_for_memret ebp - 28 - sizeof(my_rettype)*4 -4
1.1411 +
1.1412 + // gcc only: if required:
1.1413 + // place forced byref params ebp - 28 - sizeof(my_rettype)*{4 or 5}
1.1414 + //
1.1415 + // varargs:
1.1416 + // va_list argptr
1.1417 + // char va_buf[something];
1.1418 +
1.1419 +
1.1420 + const jit_int8_t v_vfnptr_origentry = AddVarToFrame(SIZE_PTR);
1.1421 + const jit_int8_t v_status = AddVarToFrame(sizeof(META_RES));
1.1422 + const jit_int8_t v_prev_res = AddVarToFrame(sizeof(META_RES));
1.1423 + const jit_int8_t v_cur_res = AddVarToFrame(sizeof(META_RES));
1.1424 + const jit_int8_t v_iter = AddVarToFrame(SIZE_PTR);
1.1425 + const jit_int8_t v_pContext = AddVarToFrame(SIZE_PTR);
1.1426 +
1.1427 + // Memory return: first param is the address
1.1428 + jit_int32_t v_memret_addr = 0;
1.1429 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1.1430 + {
1.1431 + if (SH_COMP == SH_COMP_GCC)
1.1432 + {
1.1433 + // gcc: now: first param = mem ret addr
1.1434 + // second param = this pointer
1.1435 + // third param = actual first param
1.1436 + v_memret_addr = 12;
1.1437 + v_this += 4;
1.1438 + param_base_offs += SIZE_PTR;
1.1439 + }
1.1440 + else // MSVC
1.1441 + {
1.1442 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1.1443 + {
1.1444 + // varargs -> cdecl
1.1445 + // msvc: now:
1.1446 + // first param = this pointer
1.1447 + // second param = mem ret addr
1.1448 + // third param = actual first param
1.1449 +
1.1450 + // params_base_offs is already updated to point to after the this pointer
1.1451 + v_memret_addr = param_base_offs;
1.1452 + param_base_offs += SIZE_PTR;
1.1453 + }
1.1454 + else
1.1455 + {
1.1456 + v_memret_addr = param_base_offs;
1.1457 + param_base_offs += SIZE_PTR;
1.1458 + }
1.1459 + }
1.1460 + }
1.1461 +
1.1462 + jit_int32_t v_ret_ptr = 0;
1.1463 + jit_int32_t v_orig_ret = 0;
1.1464 + jit_int32_t v_override_ret = 0;
1.1465 + jit_int32_t v_plugin_ret = 0;
1.1466 +
1.1467 + if (m_Proto.GetRet().size != 0)
1.1468 + {
1.1469 + v_ret_ptr = AddVarToFrame(SIZE_PTR);
1.1470 + v_orig_ret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet()));
1.1471 + v_override_ret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet()));
1.1472 + v_plugin_ret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet()));
1.1473 + }
1.1474 +
1.1475 + jit_int32_t v_place_for_memret = 0;
1.1476 + if (MemRetWithTempObj())
1.1477 + {
1.1478 + v_place_for_memret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet()));
1.1479 + }
1.1480 +
1.1481 + jit_int32_t v_place_fbrr_base = 0;
1.1482 + if (SH_COMP == SH_COMP_GCC && GetForcedByRefParamsSize())
1.1483 + {
1.1484 + v_place_fbrr_base = AddVarToFrame(GetForcedByRefParamsSize());
1.1485 + }
1.1486 +
1.1487 + // Only exists for varargs functions
1.1488 + jit_int32_t v_va_argptr = 0;
1.1489 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1.1490 + {
1.1491 + v_va_argptr = AddVarToFrame(SIZE_PTR);
1.1492 + }
1.1493 +
1.1494 + jit_int32_t v_va_buf = 0;
1.1495 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
1.1496 + {
1.1497 + v_va_buf = AddVarToFrame(SourceHook::STRBUF_LEN);
1.1498 + }
1.1499 +
1.1500 + IA32_Sub_Rm_Imm32(&m_HookFunc, REG_ESP, ComputeVarsSize(), MOD_REG);
1.1501 +
1.1502 + // Initial stack alignment
1.1503 + IA32_And_Rm_Imm32(&m_HookFunc, REG_ESP, MOD_REG, -16);
1.1504 + m_BytesPushedAfterInitialAlignment = 0;
1.1505 +
1.1506 + // init status localvar
1.1507 + IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_status);
1.1508 +
1.1509 + // VarArgs: init argptr & format
1.1510 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1.1511 + {
1.1512 + // argptr = first vararg param
1.1513 + // lea eax, [ebp + param_base_offs + paramssize]
1.1514 + // mov argptr, eax
1.1515 +
1.1516 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_base_offs + GetParamsTotalStackSize() + SIZE_PTR); // +SIZE_PTR: last const char * is not in protoinfo
1.1517 + IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_va_argptr);
1.1518 + }
1.1519 + if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
1.1520 + {
1.1521 + // vsnprintf
1.1522 +
1.1523 + jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR*3 + sizeof(size_t), 0);
1.1524 +
1.1525 + // push valist, fmt param, maxsize, buffer
1.1526 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1527 + IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_base_offs + GetParamsTotalStackSize()); // last given param (+4-4, see above)
1.1528 + IA32_Push_Imm32(&m_HookFunc, SourceHook::STRBUF_LEN - 1);
1.1529 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf);
1.1530 + IA32_Push_Reg(&m_HookFunc, REG_ECX);
1.1531 +
1.1532 + // call
1.1533 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(&vsnprintf));
1.1534 + CheckAlignmentBeforeCall();
1.1535 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1536 +
1.1537 + // Clean up (cdecl)
1.1538 + IA32_Add_Rm_Imm32(&m_HookFunc, REG_ESP, 0x10, MOD_REG);
1.1539 +
1.1540 + AlignStackAfterCall(tmpAlign);
1.1541 +
1.1542 + // Set trailing zero
1.1543 + IA32_Xor_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_REG);
1.1544 + IA32_Mov_Rm8_Reg8_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_va_buf + SourceHook::STRBUF_LEN - 1);
1.1545 + }
1.1546 +
1.1547 + // Call constructors for ret vars if required
1.1548 + if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1.1549 + m_Proto.GetRet().pNormalCtor)
1.1550 + {
1.1551 + jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack);
1.1552 +
1.1553 + // orig_reg
1.1554 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1.1555 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1556 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1.1557 + CheckAlignmentBeforeCall();
1.1558 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1559 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1560 +
1.1561 + // override_reg
1.1562 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1.1563 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1564 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1.1565 + CheckAlignmentBeforeCall();
1.1566 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1567 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1568 +
1.1569 + // plugin_ret
1.1570 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1.1571 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1572 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1.1573 + CheckAlignmentBeforeCall();
1.1574 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1575 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1576 +
1.1577 + AlignStackAfterCall(tmpAlign);
1.1578 +
1.1579 + // _don't_ call a constructor for v_place_for_memret !
1.1580 + }
1.1581 +
1.1582 + // ********************** SetupHookLoop **********************
1.1583 + CallSetupHookLoop(v_orig_ret, v_override_ret, v_cur_res, v_prev_res, v_status, v_vfnptr_origentry,
1.1584 + v_this, v_pContext);
1.1585 +
1.1586 + // ********************** call pre hooks **********************
1.1587 + GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1.1588 + v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf);
1.1589 +
1.1590 + // ********************** call orig func **********************
1.1591 + GenerateCallOrig(v_status, v_pContext, param_base_offs, v_this, v_vfnptr_origentry, v_orig_ret,
1.1592 + v_override_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf);
1.1593 +
1.1594 + // ********************** call post hooks **********************
1.1595 + GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1.1596 + v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf);
1.1597 +
1.1598 + // ********************** end context and return **********************
1.1599 +
1.1600 + PrepareReturn(v_status, v_pContext, v_ret_ptr);
1.1601 +
1.1602 + CallEndContext(v_pContext);
1.1603 +
1.1604 + // Call destructors of byval object params which have a destructor
1.1605 +
1.1606 + jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack);
1.1607 +
1.1608 + jit_int32_t cur_param_pos = param_base_offs;
1.1609 + for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1.1610 + {
1.1611 + const IntPassInfo &pi = m_Proto.GetParam(i);
1.1612 + // GCC: NOT of forced byref params. the caller destructs those.
1.1613 + if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
1.1614 + (pi.flags & PassInfo::PassFlag_ByVal) && !(pi.flags & PassFlag_ForcedByRef))
1.1615 + {
1.1616 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, cur_param_pos);
1.1617 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
1.1618 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1619 + CheckAlignmentBeforeCall();
1.1620 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1621 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1622 + }
1.1623 + cur_param_pos += GetParamStackSize(pi);
1.1624 + }
1.1625 +
1.1626 + AlignStackAfterCall(tmpAlign);
1.1627 +
1.1628 + DoReturn(v_ret_ptr, v_memret_addr);
1.1629 +
1.1630 + // Call destructors of orig_ret/ ...
1.1631 + if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1.1632 + m_Proto.GetRet().pDtor)
1.1633 + {
1.1634 + // Preserve return value in EAX(:EDX)
1.1635 + IA32_Push_Reg(&m_HookFunc, REG_EAX);
1.1636 + IA32_Push_Reg(&m_HookFunc, REG_EDX);
1.1637 +
1.1638 + m_BytesPushedAfterInitialAlignment += 8;
1.1639 +
1.1640 + jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack);
1.1641 +
1.1642 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1.1643 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1644 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1.1645 + CheckAlignmentBeforeCall();
1.1646 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1647 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1648 +
1.1649 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1.1650 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1651 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1.1652 + CheckAlignmentBeforeCall();
1.1653 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1654 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1655 +
1.1656 + IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1.1657 + GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1.1658 + IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1.1659 + CheckAlignmentBeforeCall();
1.1660 + IA32_Call_Reg(&m_HookFunc, REG_EAX);
1.1661 + GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1.1662 +
1.1663 + AlignStackAfterCall(tmpAlign);
1.1664 +
1.1665 + IA32_Pop_Reg(&m_HookFunc, REG_EDX);
1.1666 + IA32_Pop_Reg(&m_HookFunc, REG_EAX);
1.1667 +
1.1668 + m_BytesPushedAfterInitialAlignment -= 8;
1.1669 + }
1.1670 +
1.1671 + // epilogue
1.1672 + IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESP, REG_EBP, MOD_REG);
1.1673 + IA32_Pop_Reg(&m_HookFunc, REG_EBX);
1.1674 + IA32_Pop_Reg(&m_HookFunc, REG_EBP);
1.1675 +
1.1676 + if (SH_COMP == SH_COMP_MSVC && !(m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs))
1.1677 + {
1.1678 + // msvc without varargs:
1.1679 + // callee cleans the stack
1.1680 +
1.1681 + short cleansize = GetParamsTotalStackSize();
1.1682 + // Memory return: address is first param
1.1683 + if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1.1684 + cleansize += SIZE_PTR;
1.1685 +
1.1686 + IA32_Return_Popstack(&m_HookFunc, cleansize);
1.1687 + }
1.1688 + else
1.1689 + {
1.1690 + // gcc or msvc with varargs: caller cleans the stack
1.1691 + // exception: gcc removes the memret addr on memret:
1.1692 + if (SH_COMP == SH_COMP_GCC && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem))
1.1693 + IA32_Return_Popstack(&m_HookFunc, SIZE_PTR);
1.1694 + else
1.1695 + IA32_Return(&m_HookFunc);
1.1696 + }
1.1697 +
1.1698 +
1.1699 + // Store pointer for later use
1.1700 + // m_HookfuncVfnPtr is a pointer to a void* because SH expects a pointer
1.1701 + // into the hookman's vtable
1.1702 + *m_HookfuncVfnptr = reinterpret_cast<void*>(m_HookFunc.GetData());
1.1703 +
1.1704 + m_HookFunc.SetRE();
1.1705 +
1.1706 + return m_HookFunc.GetData();
1.1707 + }
1.1708 +
1.1709 + // Pre-condition: GenerateHookFunc() has been called!
1.1710 + void * GenContext::GeneratePubFunc()
1.1711 + {
1.1712 + jitoffs_t counter, tmppos;
1.1713 +
1.1714 + // The pubfunc is a static cdecl function.
1.1715 + // C Code:
1.1716 + // int HookManPubFunc(
1.1717 + // bool store, ebp + 8
1.1718 + // IHookManagerInfo *hi ebp + 12
1.1719 + // )
1.1720 + // {
1.1721 + // if (store)
1.1722 + // *m_pHI = hi;
1.1723 + // if (hi)
1.1724 + // hi->SetInfo(HOOKMAN_VERSION, m_VtblOffs, m_VtblIdx, m_Proto.GetProto(), m_HookfuncVfnptr)
1.1725 + // }
1.1726 +
1.1727 + // prologue
1.1728 + IA32_Push_Reg(&m_PubFunc, REG_EBP);
1.1729 + IA32_Mov_Reg_Rm(&m_PubFunc, REG_EBP, REG_ESP, MOD_REG);
1.1730 +
1.1731 +
1.1732 + // save store in eax, hi in ecx
1.1733 + IA32_Movzx_Reg32_Rm8_Disp8(&m_PubFunc, REG_EAX, REG_EBP, 8);
1.1734 + IA32_Mov_Reg_Rm_DispAuto(&m_PubFunc, REG_ECX, REG_EBP, 12);
1.1735 +
1.1736 + // Check for store == 0
1.1737 + IA32_Test_Rm_Reg8(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1.1738 + tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1.1739 + m_PubFunc.start_count(counter);
1.1740 +
1.1741 + // nonzero -> store hi
1.1742 + IA32_Mov_Rm_Imm32(&m_PubFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1.1743 + IA32_Mov_Rm_Reg(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1.1744 +
1.1745 + // zero
1.1746 + m_PubFunc.end_count(counter);
1.1747 + m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1.1748 +
1.1749 + // check for hi == 0
1.1750 + IA32_Test_Rm_Reg(&m_PubFunc, REG_ECX, REG_ECX, MOD_REG);
1.1751 + tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1.1752 + m_PubFunc.start_count(counter);
1.1753 +
1.1754 + // nonzero -> call vfunc
1.1755 + // push params in reverse order
1.1756 + IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_HookfuncVfnptr));
1.1757 + IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_BuiltPI));
1.1758 + IA32_Push_Imm32(&m_PubFunc, m_VtblIdx);
1.1759 + IA32_Push_Imm32(&m_PubFunc, m_VtblOffs);
1.1760 + IA32_Push_Imm32(&m_PubFunc, SH_HOOKMAN_VERSION);
1.1761 +
1.1762 + // hi == this is in ecx
1.1763 + // on gcc/mingw, ecx is the first parameter
1.1764 +#if SH_COMP == SH_COMP_GCC
1.1765 + IA32_Push_Reg(&m_PubFunc, REG_ECX);
1.1766 +#endif
1.1767 +
1.1768 + // call the function. vtbloffs = 0, vtblidx = 0
1.1769 + // get vtptr into edx
1.1770 + IA32_Mov_Reg_Rm(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1.1771 + // get funcptr into eax
1.1772 + IA32_Mov_Reg_Rm(&m_PubFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1.1773 +
1.1774 + IA32_Call_Reg(&m_PubFunc, REG_EAX);
1.1775 +
1.1776 + // on gcc/mingw, we have to clean up after the call
1.1777 +#if SH_COMP == SH_COMP_GCC
1.1778 + // 5 params + hidden thisptr param
1.1779 + IA32_Add_Rm_Imm8(&m_PubFunc, REG_ESP, 6*SIZE_MWORD, MOD_REG);
1.1780 +#endif
1.1781 +
1.1782 + // zero
1.1783 + m_PubFunc.end_count(counter);
1.1784 + m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1.1785 +
1.1786 + // return value
1.1787 + IA32_Xor_Reg_Rm(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1.1788 +
1.1789 + // epilogue
1.1790 + IA32_Mov_Reg_Rm(&m_PubFunc, REG_ESP, REG_EBP, MOD_REG);
1.1791 + IA32_Pop_Reg(&m_PubFunc, REG_EBP);
1.1792 + IA32_Return(&m_PubFunc);
1.1793 +
1.1794 + m_PubFunc.SetRE();
1.1795 +
1.1796 + return m_PubFunc;
1.1797 + }
1.1798 +
1.1799 + bool GenContext::PassInfoSupported(const IntPassInfo &pi, bool is_ret)
1.1800 + {
1.1801 + // :TODO: Error returns
1.1802 + if (pi.type != PassInfo::PassType_Basic &&
1.1803 + pi.type != PassInfo::PassType_Float &&
1.1804 + pi.type != PassInfo::PassType_Object)
1.1805 + {
1.1806 + return false;
1.1807 + }
1.1808 +
1.1809 + if (pi.type == PassInfo::PassType_Object &&
1.1810 + (pi.flags & PassInfo::PassFlag_ByVal))
1.1811 + {
1.1812 + if ((pi.flags & PassInfo::PassFlag_CCtor) && !pi.pCopyCtor)
1.1813 + {
1.1814 + return false;
1.1815 + }
1.1816 +
1.1817 + if ((pi.flags & PassInfo::PassFlag_ODtor) && !pi.pDtor)
1.1818 + {
1.1819 + return false;
1.1820 + }
1.1821 +
1.1822 + if ((pi.flags & PassInfo::PassFlag_AssignOp) && !pi.pAssignOperator)
1.1823 + {
1.1824 + return false;
1.1825 + }
1.1826 +
1.1827 + if ((pi.flags & PassInfo::PassFlag_OCtor) && !pi.pNormalCtor)
1.1828 + {
1.1829 + return false;
1.1830 + }
1.1831 + }
1.1832 +
1.1833 + if ((pi.flags & (PassInfo::PassFlag_ByVal | PassInfo::PassFlag_ByRef)) == 0)
1.1834 + {
1.1835 + return false; // Neither byval nor byref!
1.1836 + }
1.1837 + return true;
1.1838 + }
1.1839 +
1.1840 + void GenContext::AutoDetectRetType()
1.1841 + {
1.1842 + IntPassInfo &pi = m_Proto.GetRet();
1.1843 +
1.1844 + // Only relevant for byval types
1.1845 + if (pi.flags & PassInfo::PassFlag_ByVal)
1.1846 + {
1.1847 + // Basic + float:
1.1848 + if (pi.type == PassInfo::PassType_Basic ||
1.1849 + pi.type == PassInfo::PassType_Float)
1.1850 + {
1.1851 + // <= 8 bytes:
1.1852 + // _always_ in registers, no matter what the user says
1.1853 + if (pi.size <= 8)
1.1854 + {
1.1855 + pi.flags &= ~PassInfo::PassFlag_RetMem;
1.1856 + pi.flags |= PassInfo::PassFlag_RetReg;
1.1857 + }
1.1858 + else
1.1859 + {
1.1860 + // Does this even exist? No idea, if it does: in memory!
1.1861 + pi.flags &= ~PassInfo::PassFlag_RetReg;
1.1862 + pi.flags |= PassInfo::PassFlag_RetMem;
1.1863 + }
1.1864 + }
1.1865 + // Object:
1.1866 + else if (pi.type == PassInfo::PassType_Object)
1.1867 + {
1.1868 + // If the user says nothing, auto-detect
1.1869 + if ((pi.flags & (PassInfo::PassFlag_RetMem | PassInfo::PassFlag_RetReg)) == 0)
1.1870 + {
1.1871 +#if SH_COMP == SH_COMP_MSVC
1.1872 + // MSVC seems to return _all_ structs, classes, unions in memory
1.1873 + pi.flags |= PassInfo::PassFlag_RetMem;
1.1874 +#elif SH_COMP == SH_COMP_GCC
1.1875 + // Same goes for GCC :)
1.1876 + pi.flags |= PassInfo::PassFlag_RetMem;
1.1877 +#endif
1.1878 + }
1.1879 + }
1.1880 + }
1.1881 + else
1.1882 + {
1.1883 + // byref: make sure that the flag is _not_ set
1.1884 + pi.flags &= ~PassInfo::PassFlag_RetMem;
1.1885 + pi.flags |= PassInfo::PassFlag_RetReg;
1.1886 + }
1.1887 + }
1.1888 +
1.1889 + void GenContext::AutoDetectParamFlags()
1.1890 + {
1.1891 +#if SH_COMP == SH_COMP_GCC
1.1892 + // On GCC, all objects are passed by reference if they have a destructor
1.1893 + for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1.1894 + {
1.1895 + IntPassInfo &pi = m_Proto.GetParam(i);
1.1896 + if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ByVal) &&
1.1897 + (pi.flags & PassInfo::PassFlag_ODtor))
1.1898 + {
1.1899 + pi.flags |= PassFlag_ForcedByRef;
1.1900 + }
1.1901 + }
1.1902 +#endif
1.1903 + }
1.1904 +
1.1905 + HookManagerPubFunc GenContext::Generate()
1.1906 + {
1.1907 + Clear();
1.1908 +
1.1909 + // Check conditions:
1.1910 + // -1) good proto version
1.1911 + // 0) we don't support unknown passtypes, convention, ...
1.1912 + // 1) we don't support functions which return objects by value or take parameters by value
1.1913 + // that have a constructor, a destructor or an overloaded assignment op
1.1914 + // (we wouldn't know how to call it!)
1.1915 +
1.1916 + if (m_Proto.GetVersion() < 1)
1.1917 + {
1.1918 + return NULL;
1.1919 + }
1.1920 +
1.1921 + AutoDetectRetType();
1.1922 + AutoDetectParamFlags();
1.1923 +
1.1924 + // Basically, we only support ThisCall/thiscall with varargs
1.1925 + if ((m_Proto.GetConvention() & (~ProtoInfo::CallConv_HasVafmt)) != ProtoInfo::CallConv_ThisCall)
1.1926 + {
1.1927 + return NULL;
1.1928 + }
1.1929 +
1.1930 +
1.1931 + if (m_Proto.GetRet().size != 0 && !PassInfoSupported(m_Proto.GetRet(), true))
1.1932 + {
1.1933 + return NULL;
1.1934 + }
1.1935 +
1.1936 + for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1.1937 + {
1.1938 + if (!PassInfoSupported(m_Proto.GetParam(i), false))
1.1939 + return NULL;
1.1940 + }
1.1941 +
1.1942 + BuildProtoInfo();
1.1943 + GenerateHookFunc();
1.1944 + return fastdelegate::detail::horrible_cast<HookManagerPubFunc>(GeneratePubFunc());
1.1945 + }
1.1946 +
1.1947 + HookManagerPubFunc GenContext::GetPubFunc()
1.1948 + {
1.1949 + if (m_GeneratedPubFunc == 0)
1.1950 + m_GeneratedPubFunc = Generate();
1.1951 +
1.1952 + return m_GeneratedPubFunc;
1.1953 + }
1.1954 +
1.1955 + bool GenContext::Equal(const CProto &proto, int vtbl_offs, int vtbl_idx)
1.1956 + {
1.1957 + return (m_OrigProto.ExactlyEqual(proto) && m_VtblOffs == vtbl_offs && m_VtblIdx == vtbl_idx);
1.1958 + }
1.1959 +
1.1960 + bool GenContext::Equal(HookManagerPubFunc other)
1.1961 + {
1.1962 + return m_GeneratedPubFunc == other;
1.1963 + }
1.1964 +
1.1965 + // *********************************** class GenContextContainer
1.1966 + CHookManagerAutoGen::CHookManagerAutoGen(ISourceHook *pSHPtr) : m_pSHPtr(pSHPtr)
1.1967 + {
1.1968 + }
1.1969 +
1.1970 + CHookManagerAutoGen::~CHookManagerAutoGen()
1.1971 + {
1.1972 + for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1.1973 + {
1.1974 + delete iter->m_GenContext;
1.1975 + }
1.1976 + }
1.1977 +
1.1978 + int CHookManagerAutoGen::GetIfaceVersion()
1.1979 + {
1.1980 + return SH_HOOKMANAUTOGEN_IFACE_VERSION;
1.1981 + }
1.1982 +
1.1983 + int CHookManagerAutoGen::GetImplVersion()
1.1984 + {
1.1985 + return SH_HOOKMANAUTOGEN_IMPL_VERSION;
1.1986 + }
1.1987 +
1.1988 + HookManagerPubFunc CHookManagerAutoGen::MakeHookMan(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx)
1.1989 + {
1.1990 + CProto mproto(proto);
1.1991 + for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1.1992 + {
1.1993 + if (iter->m_GenContext->Equal(mproto, vtbl_offs, vtbl_idx))
1.1994 + {
1.1995 + iter->m_RefCnt++;
1.1996 + return iter->m_GenContext->GetPubFunc();
1.1997 + }
1.1998 + }
1.1999 +
1.2000 + // Not found yet -> new one
1.2001 + StoredContext sctx;
1.2002 + sctx.m_RefCnt = 1;
1.2003 + sctx.m_GenContext = new GenContext(proto, vtbl_offs, vtbl_idx, m_pSHPtr);
1.2004 +
1.2005 + if (sctx.m_GenContext->GetPubFunc() == NULL)
1.2006 + {
1.2007 + return NULL;
1.2008 + }
1.2009 + else
1.2010 + {
1.2011 + m_Contexts.push_back(sctx);
1.2012 + return sctx.m_GenContext->GetPubFunc();
1.2013 + }
1.2014 + }
1.2015 +
1.2016 + void CHookManagerAutoGen::ReleaseHookMan(HookManagerPubFunc pubFunc)
1.2017 + {
1.2018 + for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1.2019 + {
1.2020 + if (iter->m_GenContext->Equal(pubFunc))
1.2021 + {
1.2022 + iter->m_RefCnt--;
1.2023 + if (iter->m_RefCnt == 0)
1.2024 + {
1.2025 + delete iter->m_GenContext;
1.2026 + m_Contexts.erase(iter);
1.2027 + }
1.2028 + break;
1.2029 + }
1.2030 + }
1.2031 + }
1.2032 + }
1.2033 +}