pavolmarko@480: /* ======== SourceHook ======== pavolmarko@733: * Copyright (C) 2004-2010 Metamod:Source Development Team pavolmarko@480: * No warranties of any kind pavolmarko@480: * pavolmarko@480: * License: zlib/libpng pavolmarko@480: * pavolmarko@480: * Author(s): Pavol "PM OnoTo" Marko pavolmarko@480: * Contributor(s): Borja "faluco" Ferav (many thanks for assitance!) pavolmarko@480: * David "BAILOPAN" Anderson pavolmarko@480: * ============================ pavolmarko@480: */ pavolmarko@480: pavolmarko@480: // recommended literature: pavolmarko@480: // http://www.cs.umbc.edu/~chang/cs313.s02/stack.shtml pavolmarko@480: // http://www.angelcode.com/dev/callconv/callconv.html pavolmarko@480: // http://www.arl.wustl.edu/~lockwood/class/cs306/books/artofasm/Chapter_6/CH06-1.html pavolmarko@480: dvander@534: #include pavolmarko@480: #include "sourcehook_impl.h" pavolmarko@480: #include "sourcehook_hookmangen.h" pavolmarko@480: #include "sourcehook_hookmangen_x86.h" pavolmarko@480: #include "sh_memory.h" pavolmarko@480: #include // we might need the address of vsnprintf pavolmarko@480: pavolmarko@480: #if SH_COMP == SH_COMP_MSVC pavolmarko@480: # define GCC_ONLY(x) pavolmarko@480: # define MSVC_ONLY(x) x pavolmarko@480: #elif SH_COMP == SH_COMP_GCC pavolmarko@480: # define GCC_ONLY(x) x pavolmarko@480: # define MSVC_ONLY(x) pavolmarko@480: #endif pavolmarko@480: pavolmarko@480: // :TODO: test BIG vtable indices pavolmarko@480: pavolmarko@480: namespace SourceHook pavolmarko@480: { pavolmarko@480: namespace Impl pavolmarko@480: { pavolmarko@480: CPageAlloc GenBuffer::ms_Allocator(16); pavolmarko@480: pavolmarko@480: template pavolmarko@480: jit_int32_t DownCastPtr(T ptr) pavolmarko@480: { pavolmarko@480: return reinterpret_cast(ptr); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_uint32_t DownCastSize(size_t size) pavolmarko@480: { pavolmarko@480: return static_cast(size); pavolmarko@480: } pavolmarko@480: pavolmarko@480: GenContext::GenContext(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx, ISourceHook *pSHPtr) pavolmarko@480: : m_GeneratedPubFunc(NULL), m_OrigProto(proto), m_Proto(proto), m_VtblOffs(vtbl_offs), pavolmarko@480: m_VtblIdx(vtbl_idx), m_SHPtr(pSHPtr), m_pHI(NULL), m_HookfuncVfnptr(NULL), m_RegCounter(0) pavolmarko@480: { pavolmarko@480: m_pHI = new void*; pavolmarko@480: m_HookfuncVfnptr = new void*; pavolmarko@480: m_BuiltPI = new ProtoInfo; pavolmarko@480: m_BuiltPI_Params = NULL; pavolmarko@480: m_BuiltPI_Params2 = NULL; pavolmarko@480: } pavolmarko@480: pavolmarko@480: GenContext::~GenContext() pavolmarko@480: { pavolmarko@480: Clear(); pavolmarko@480: delete m_pHI; pavolmarko@480: delete m_HookfuncVfnptr; pavolmarko@480: delete m_BuiltPI; pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::Clear() pavolmarko@480: { pavolmarko@480: m_HookFunc.clear(); pavolmarko@480: m_PubFunc.clear(); pavolmarko@480: if (m_BuiltPI_Params) pavolmarko@480: { pavolmarko@490: delete [] m_BuiltPI_Params; pavolmarko@480: m_BuiltPI_Params = NULL; pavolmarko@480: } pavolmarko@480: if (m_BuiltPI_Params2) pavolmarko@480: { pavolmarko@490: delete [] m_BuiltPI_Params2; pavolmarko@480: m_BuiltPI_Params2 = NULL; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::BuildProtoInfo() pavolmarko@480: { pavolmarko@480: m_BuiltPI->convention = m_Proto.GetConvention(); pavolmarko@480: m_BuiltPI->numOfParams = m_Proto.GetNumOfParams(); pavolmarko@480: pavolmarko@480: m_BuiltPI->retPassInfo.size = m_Proto.GetRet().size; pavolmarko@480: m_BuiltPI->retPassInfo.type = m_Proto.GetRet().type; pavolmarko@480: m_BuiltPI->retPassInfo.flags = m_Proto.GetRet().flags; pavolmarko@480: m_BuiltPI->retPassInfo2.pNormalCtor = m_Proto.GetRet().pNormalCtor; pavolmarko@480: m_BuiltPI->retPassInfo2.pCopyCtor = m_Proto.GetRet().pCopyCtor; pavolmarko@480: m_BuiltPI->retPassInfo2.pDtor = m_Proto.GetRet().pDtor; pavolmarko@480: m_BuiltPI->retPassInfo2.pAssignOperator = m_Proto.GetRet().pAssignOperator; pavolmarko@480: pavolmarko@480: if (m_BuiltPI_Params) pavolmarko@480: delete m_BuiltPI_Params; pavolmarko@480: m_BuiltPI_Params = new PassInfo[m_BuiltPI->numOfParams + 1]; pavolmarko@480: if (m_BuiltPI_Params2) pavolmarko@480: delete m_BuiltPI_Params2; pavolmarko@480: m_BuiltPI_Params2 = new PassInfo::V2Info[m_BuiltPI->numOfParams + 1]; pavolmarko@480: pavolmarko@480: m_BuiltPI_Params[0].size = 1; // Version 1 pavolmarko@480: m_BuiltPI_Params[0].type = 0; pavolmarko@480: m_BuiltPI_Params[0].flags = 0; pavolmarko@480: pavolmarko@480: for (int i = 0; i < m_Proto.GetNumOfParams(); ++i) pavolmarko@480: { pavolmarko@480: m_BuiltPI_Params[i+1].size = m_Proto.GetParam(i).size; pavolmarko@480: m_BuiltPI_Params[i+1].type = m_Proto.GetParam(i).type; pavolmarko@480: m_BuiltPI_Params[i+1].flags = m_Proto.GetParam(i).flags; pavolmarko@480: pavolmarko@480: m_BuiltPI_Params2[i+1].pNormalCtor = m_Proto.GetParam(i).pNormalCtor; pavolmarko@480: m_BuiltPI_Params2[i+1].pCopyCtor = m_Proto.GetParam(i).pCopyCtor; pavolmarko@480: m_BuiltPI_Params2[i+1].pDtor = m_Proto.GetParam(i).pDtor; pavolmarko@480: m_BuiltPI_Params2[i+1].pAssignOperator = m_Proto.GetParam(i).pAssignOperator; pavolmarko@480: } pavolmarko@480: pavolmarko@480: m_BuiltPI->paramsPassInfo = m_BuiltPI_Params; pavolmarko@480: m_BuiltPI->paramsPassInfo2 = m_BuiltPI_Params2; pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::GetRealSize(const IntPassInfo &info) pavolmarko@480: { pavolmarko@480: if (info.flags & (PassInfo::PassFlag_ByRef | PassFlag_ForcedByRef)) pavolmarko@480: { pavolmarko@480: return SIZE_PTR; pavolmarko@480: } pavolmarko@480: return static_cast(info.size); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::AlignSize(jit_int32_t x, jit_int32_t boundary) pavolmarko@480: { pavolmarko@480: if (x % boundary != 0) pavolmarko@480: x = (x & ~(boundary-1)) + boundary; pavolmarko@480: return x; pavolmarko@480: } pavolmarko@480: pavolmarko@480: // Computes size on the stack pavolmarko@480: jit_int32_t GenContext::GetParamStackSize(const IntPassInfo &info) pavolmarko@480: { pavolmarko@480: // Align up to 4 byte boundaries pavolmarko@480: return AlignSize(GetRealSize(info), 4); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int8_t GenContext::NextRegEBX_ECX_EDX() pavolmarko@480: { pavolmarko@480: switch ((m_RegCounter++) % 3) pavolmarko@480: { pavolmarko@480: case 0: pavolmarko@480: return REG_EBX; pavolmarko@480: case 1: pavolmarko@480: return REG_ECX; pavolmarko@480: case 2: pavolmarko@480: default: pavolmarko@480: m_RegCounter = 0; pavolmarko@480: return REG_EDX; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::BitwiseCopy_Setup() pavolmarko@480: { pavolmarko@480: //cld pavolmarko@480: //push edi pavolmarko@480: //push esi pavolmarko@480: pavolmarko@480: IA32_Cld(&m_HookFunc); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDI); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ESI); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::BitwiseCopy_Do(size_t size) pavolmarko@480: { pavolmarko@480: jit_uint32_t dwords = DownCastSize(size) / 4; pavolmarko@480: jit_uint32_t bytes = DownCastSize(size) % 4; pavolmarko@480: pavolmarko@480: //if dwords pavolmarko@480: // mov ecx, pavolmarko@480: // rep movsd pavolmarko@480: //if bytes pavolmarko@480: // mov ecx, pavolmarko@480: // rep movsb pavolmarko@480: //pop esi pavolmarko@480: //pop edi pavolmarko@480: pavolmarko@480: if (dwords) pavolmarko@480: { pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, dwords); pavolmarko@480: IA32_Rep(&m_HookFunc); pavolmarko@480: IA32_Movsd(&m_HookFunc); pavolmarko@480: } pavolmarko@480: if (bytes) pavolmarko@480: { pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, bytes); pavolmarko@480: IA32_Rep(&m_HookFunc); pavolmarko@480: IA32_Movsb(&m_HookFunc); pavolmarko@480: } pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_ESI); pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_EDI); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::AlignStackBeforeCall(int paramsize, int flags) pavolmarko@480: { pavolmarko@480: paramsize += pavolmarko@480: GCC_ONLY( ((flags & AlignStack_GCC_ThisOnStack)!=0 ? SIZE_PTR : 0) + ) pavolmarko@480: MSVC_ONLY( ((flags & AlignStack_MSVC_ThisOnStack)!=0 ? SIZE_PTR : 0) + ) pavolmarko@480: ((flags & AlignStack_MemRet)!=0 ? SIZE_PTR : 0); pavolmarko@480: pavolmarko@480: // At the beginning of the hookfunc, the stack is aligned to a 16 bytes boundary. pavolmarko@480: // Then, m_BytesPushedAfterInitialAlignment were pushed (can also be 0). pavolmarko@480: pavolmarko@480: // After this function is called, paramsize bytes will be pushed onto the stack pavolmarko@480: // After that, the alignment has to be a 16 bytes boundary again. pavolmarko@480: pavolmarko@480: pavolmarko@480: // How many bytes we would subtract if the alignment was alright now: pavolmarko@480: int subtractFromEsp = 16 - (paramsize % 16); pavolmarko@480: if (subtractFromEsp == 16) pavolmarko@480: subtractFromEsp = 0; pavolmarko@480: pavolmarko@480: // But: there might be bytes pushed alreay! pavolmarko@480: subtractFromEsp -= m_BytesPushedAfterInitialAlignment; pavolmarko@480: pavolmarko@480: // For example: paramsize was 0 and m_BytesPushedAfterInitialAlignment was 4. pavolmarko@480: // we then have to push another 12 bytes to reach 16 bytes alignment again. pavolmarko@480: pavolmarko@480: if (subtractFromEsp < 0) pavolmarko@480: subtractFromEsp = 16 - ((-subtractFromEsp) % 16); pavolmarko@480: pavolmarko@480: if (subtractFromEsp != 0) pavolmarko@480: IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, subtractFromEsp, MOD_REG); pavolmarko@480: pavolmarko@480: return subtractFromEsp; pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::AlignStackAfterCall(jit_int32_t numofbytes) pavolmarko@480: { pavolmarko@480: if (numofbytes != 0) pavolmarko@480: IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, numofbytes, MOD_REG); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::CheckAlignmentBeforeCall() pavolmarko@480: { pavolmarko@480: #if 0 pavolmarko@480: IA32_Test_Rm_Imm32(&m_HookFunc, REG_ESP, 15, MOD_REG); pavolmarko@480: IA32_Jump_Cond_Imm8(&m_HookFunc, CC_Z, 1); pavolmarko@480: IA32_Int3(&m_HookFunc); pavolmarko@480: #endif pavolmarko@480: } pavolmarko@480: pavolmarko@480: short GenContext::GetParamsTotalStackSize() pavolmarko@480: { pavolmarko@480: short acc = 0; pavolmarko@480: for (int i = 0; i < m_Proto.GetNumOfParams(); ++i) pavolmarko@480: { pavolmarko@480: acc += GetParamStackSize(m_Proto.GetParam(i)); pavolmarko@480: } pavolmarko@480: pavolmarko@480: return acc; pavolmarko@480: } pavolmarko@480: pavolmarko@480: short GenContext::GetForcedByRefParamOffset(int p) pavolmarko@480: { pavolmarko@480: short off = 0; pavolmarko@480: for (int i = 0; i < p; ++i) pavolmarko@480: { pavolmarko@480: if (m_Proto.GetParam(i).flags & PassFlag_ForcedByRef) pavolmarko@480: off += AlignSize(static_cast(m_Proto.GetParam(i).size), 4); pavolmarko@480: } pavolmarko@480: return off; pavolmarko@480: } pavolmarko@480: pavolmarko@480: short GenContext::GetForcedByRefParamsSize() pavolmarko@480: { pavolmarko@480: return GetForcedByRefParamOffset(m_Proto.GetNumOfParams()); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::PushRef(jit_int32_t param_offset, const IntPassInfo &pi) pavolmarko@480: { pavolmarko@480: // push [ebp+] pavolmarko@480: IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_offset); pavolmarko@480: pavolmarko@480: return SIZE_PTR; pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::PushBasic(jit_int32_t param_offset, const IntPassInfo &pi) pavolmarko@480: { pavolmarko@480: int reg; pavolmarko@480: int reg2; pavolmarko@480: pavolmarko@480: switch (pi.size) pavolmarko@480: { pavolmarko@480: default: pavolmarko@480: SH_ASSERT(0, ("Unsupported!")); pavolmarko@480: return 0; pavolmarko@480: case 1: pavolmarko@480: reg = NextRegEBX_ECX_EDX(); pavolmarko@480: //movzx reg, BYTE PTR [ebp+] pavolmarko@480: //push reg pavolmarko@480: IA32_Movzx_Reg32_Rm8_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, reg); pavolmarko@480: pavolmarko@480: return 4; pavolmarko@480: case 2: pavolmarko@480: reg = NextRegEBX_ECX_EDX(); pavolmarko@480: //movzx reg, WORD PTR [ebp+] pavolmarko@480: //push reg pavolmarko@480: m_HookFunc.write_ubyte(IA32_16BIT_PREFIX); pavolmarko@480: IA32_Movzx_Reg32_Rm16_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, reg); pavolmarko@480: pavolmarko@480: return 4; pavolmarko@480: case 4: pavolmarko@480: reg = NextRegEBX_ECX_EDX(); pavolmarko@480: //mov reg, DWORD PTR [ebp+] pavolmarko@480: //push reg pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, reg); pavolmarko@480: pavolmarko@480: return 4; pavolmarko@480: case 8: pavolmarko@480: reg = NextRegEBX_ECX_EDX(); pavolmarko@480: reg2 = NextRegEBX_ECX_EDX(); pavolmarko@480: //mov reg, DWORD PTR [ebp++4] pavolmarko@480: //mov reg2, DWORD PTR [ebp+] pavolmarko@480: //push reg pavolmarko@480: //push reg2 pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset+4); pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg2, REG_EBP, param_offset); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, reg); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, reg2); pavolmarko@480: pavolmarko@480: return 8; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::PushFloat(jit_int32_t param_offset, const IntPassInfo &pi) pavolmarko@480: { pavolmarko@480: switch (pi.size) pavolmarko@480: { pavolmarko@480: default: pavolmarko@480: SH_ASSERT(0, ("Unsupported!")); pavolmarko@480: return 0; pavolmarko@480: case 4: pavolmarko@480: //fld DWORD PTR [ebp+] pavolmarko@480: //push reg pavolmarko@480: //fstp DWORD PTR [esp] pavolmarko@480: IA32_Fld_Mem32_DispAuto(&m_HookFunc, REG_EBP, param_offset); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, NextRegEBX_ECX_EDX()); pavolmarko@480: IA32_Fstp_Mem32_ESP(&m_HookFunc); pavolmarko@480: return 4; pavolmarko@480: case 8: pavolmarko@480: //fld QWORD PTR [ebp+] pavolmarko@480: //sub esp, 8 pavolmarko@480: //fstp QWORD PTR [esp] pavolmarko@480: IA32_Fld_Mem64_DispAuto(&m_HookFunc, REG_EBP, param_offset); pavolmarko@480: IA32_Sub_Rm_Imm8(&m_HookFunc, REG_ESP, 8, MOD_REG); pavolmarko@480: IA32_Fstp_Mem64_ESP(&m_HookFunc); pavolmarko@480: return 8; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::PushObject(jit_int32_t param_offset, const IntPassInfo &pi, jit_int32_t place_fbrr) pavolmarko@480: { pavolmarko@480: if ((pi.flags & PassFlag_ForcedByRef) == 0) pavolmarko@480: { pavolmarko@480: // make room on the stack pavolmarko@480: // sub esp, pavolmarko@480: IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, GetParamStackSize(pi), MOD_REG); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // if there is a copy constructor.. pavolmarko@480: if (pi.pCopyCtor) pavolmarko@480: { pavolmarko@480: // :TODO: alignment here? pavolmarko@480: // can't use normal alignment methods pavolmarko@480: // because an unknown number of bytes has been pushed already (the other params) pavolmarko@480: pavolmarko@480: // save eax pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // compute dest addr to ECX pavolmarko@480: // = forcedbyref ? ebp+place_fbrr : esp+12 pavolmarko@480: if (pi.flags & PassFlag_ForcedByRef) pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr); pavolmarko@480: else pavolmarko@480: IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_ECX, REG_NOIDX, REG_ESP, NOSCALE, 4); pavolmarko@480: pavolmarko@480: // compute src addr to EAX pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_offset); pavolmarko@480: pavolmarko@480: // push params (gcc: also this) pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: // call pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(pi.pCopyCtor)); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: pavolmarko@480: // gcc: clean up stack pavolmarko@480: GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG)); pavolmarko@480: pavolmarko@480: // restore eax pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // bitwise copy pavolmarko@480: pavolmarko@480: BitwiseCopy_Setup(); pavolmarko@480: pavolmarko@480: //if forcedbyref: pavolmarko@480: // lea edi, [ebp_place_fbrr] pavolmarko@480: //else pavolmarko@480: // lea edi, [esp+8] - bc_setup pushed two regs onto the stack! pavolmarko@480: //lea esi, [ebp+] pavolmarko@480: if (pi.flags & PassFlag_ForcedByRef) pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, place_fbrr); pavolmarko@480: else pavolmarko@480: IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_EDI, REG_NOIDX, REG_ESP, NOSCALE, 8); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, param_offset); pavolmarko@480: pavolmarko@480: BitwiseCopy_Do(pi.size); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // forcedref: push reference to ebp+place_fbrr pavolmarko@480: if (pi.flags & PassFlag_ForcedByRef) pavolmarko@480: { pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: return SIZE_PTR; pavolmarko@480: } pavolmarko@480: pavolmarko@480: return GetParamStackSize(pi); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::DestroyParams(jit_int32_t fbrr_base) pavolmarko@480: { pavolmarko@480: for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i) pavolmarko@480: { pavolmarko@480: const IntPassInfo &pi = m_Proto.GetParam(i); pavolmarko@480: if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) && pavolmarko@480: (pi.flags & PassInfo::PassFlag_ByVal) && (pi.flags & PassFlag_ForcedByRef)) pavolmarko@480: { pavolmarko@480: // Actually, this is only for GCC (see line above: ForcedByRef) pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, fbrr_base + GetForcedByRefParamOffset(i)); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: // May not touch eax! pavolmarko@480: jit_int32_t GenContext::PushParams(jit_int32_t param_base_offset, jit_int32_t save_ret_to, int v_place_for_memret, pavolmarko@480: jit_int32_t v_place_fbrr_base) pavolmarko@480: { pavolmarko@480: jit_int32_t added_to_stack = 0; pavolmarko@480: jit_int32_t ret = 0; pavolmarko@480: pavolmarko@480: // compute the offset _after_ the last parameter pavolmarko@480: jit_int32_t cur_offset = param_base_offset; pavolmarko@480: for (int i = 0; i < m_Proto.GetNumOfParams(); ++i) pavolmarko@480: { pavolmarko@480: cur_offset += GetParamStackSize(m_Proto.GetParam(i)); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // push parameters in reverse order pavolmarko@480: for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i) pavolmarko@480: { pavolmarko@480: const IntPassInfo &pi = m_Proto.GetParam(i); pavolmarko@480: cur_offset -= GetParamStackSize(pi); pavolmarko@480: if (pi.flags & PassInfo::PassFlag_ByVal) pavolmarko@480: { pavolmarko@480: switch (pi.type) pavolmarko@480: { pavolmarko@480: case PassInfo::PassType_Basic: pavolmarko@480: ret = PushBasic(cur_offset, pi); pavolmarko@480: break; pavolmarko@480: case PassInfo::PassType_Float: pavolmarko@480: ret = PushFloat(cur_offset, pi); pavolmarko@480: break; pavolmarko@480: case PassInfo::PassType_Object: pavolmarko@480: ret = PushObject(cur_offset, pi, v_place_fbrr_base + GetForcedByRefParamOffset(i)); pavolmarko@480: break; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: else if (pi.flags & PassInfo::PassFlag_ByRef) pavolmarko@480: { pavolmarko@480: ret = PushRef(cur_offset, pi); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: SH_ASSERT(0, ("Unsupported!")); pavolmarko@480: } pavolmarko@480: added_to_stack += ret; pavolmarko@480: } pavolmarko@480: pavolmarko@480: return added_to_stack; pavolmarko@480: } pavolmarko@480: pavolmarko@480: // It is IMPORTANT that PushMemRetPtr doesn't touch ecx and eax pavolmarko@480: jit_int32_t GenContext::PushMemRetPtr(jit_int32_t save_ret_to, jit_int32_t v_place_for_memret) pavolmarko@480: { pavolmarko@480: // Memory return support pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) pavolmarko@480: { pavolmarko@480: // push address where to save it! pavolmarko@480: int reg = REG_EDX; pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, reg, REG_EBP, pavolmarko@480: MemRetWithTempObj() ? v_place_for_memret : save_ret_to); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, reg); pavolmarko@480: pavolmarko@480: return (SH_COMP==SH_COMP_MSVC) ? 4 : 0; // varargs funcs on msvc might need this. pavolmarko@480: // gcc doesn't: callee cleans the memret ptr, caller the other params :s pavolmarko@480: } pavolmarko@480: return 0; pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::SaveRetVal(int v_where, int v_place_for_memret) pavolmarko@480: { pavolmarko@480: size_t size = GetRealSize(m_Proto.GetRet()); pavolmarko@480: if (size == 0) pavolmarko@480: { pavolmarko@480: // No return value -> nothing pavolmarko@480: return; pavolmarko@480: } pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef) pavolmarko@480: { pavolmarko@480: // mov [ebp + v_plugin_ret], eax pavolmarko@480: IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where); pavolmarko@480: return; pavolmarko@480: } pavolmarko@480: // else: ByVal pavolmarko@480: pavolmarko@480: pavolmarko@480: // Memory return: pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) pavolmarko@480: { pavolmarko@480: if (MemRetWithTempObj()) pavolmarko@480: { pavolmarko@480: // *v_where = *v_place_for_memret pavolmarko@480: pavolmarko@480: // if we have an assign operator, use that pavolmarko@480: if (m_Proto.GetRet().pAssignOperator) pavolmarko@480: { pavolmarko@480: // lea edx, [ebp + v_place_for_memret] <-- src addr pavolmarko@480: // lea ecx, [ebp + v_where] <-- dest addr pavolmarko@480: // push edx pavolmarko@480: // gcc: push ecx pavolmarko@480: // call it pavolmarko@480: // gcc: clean up pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_place_for_memret); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_where); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG)); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // bitwise copy pavolmarko@480: BitwiseCopy_Setup(); pavolmarko@480: pavolmarko@480: //lea edi, [evp+v_where] <-- destination pavolmarko@480: //lea esi, [ebp+v_place_for_memret] <-- src pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_where); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_place_for_memret); pavolmarko@480: pavolmarko@480: BitwiseCopy_Do(m_Proto.GetRet().size); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // Then: destruct *v_place_for_memret if required pavolmarko@480: if (m_Proto.GetRet().pDtor) pavolmarko@480: { pavolmarko@480: //lea ecx, [ebp+v_place_for_memret] pavolmarko@480: //gcc: push ecx pavolmarko@480: //call it pavolmarko@480: //gcc: clean up pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_place_for_memret); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // Already copied to correct address -> we're done pavolmarko@480: return; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().type == PassInfo::PassType_Float) pavolmarko@480: { pavolmarko@480: if (size == 4) pavolmarko@480: IA32_Fstp_Mem32_DispAuto(&m_HookFunc, REG_EBP, v_where); pavolmarko@480: else if (size == 8) pavolmarko@480: IA32_Fstp_Mem64_DispAuto(&m_HookFunc, REG_EBP, v_where); pavolmarko@480: } pavolmarko@480: else if (m_Proto.GetRet().type == PassInfo::PassType_Basic) pavolmarko@480: { pavolmarko@480: if (size <= 4) pavolmarko@480: { pavolmarko@480: // size <= 4: return in EAX pavolmarko@480: // We align <4 sizes up to 4 pavolmarko@480: pavolmarko@480: pavolmarko@480: // mov [ebp + v_plugin_ret], eax pavolmarko@480: IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where); pavolmarko@480: } pavolmarko@480: else if (size <= 8) pavolmarko@480: { pavolmarko@480: // size <= 4: return in EAX:EDX pavolmarko@480: // We align 4 8 !")); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: bool GenContext::MemRetWithTempObj() pavolmarko@480: { pavolmarko@480: // Memory return AND (has destructor OR has assign operator) pavolmarko@480: return ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) pavolmarko@480: && (m_Proto.GetRet().flags & (PassInfo::PassFlag_ODtor | PassInfo::PassFlag_AssignOp))); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::ProcessPluginRetVal(int v_cur_res, int v_pContext, int v_plugin_ret) pavolmarko@480: { pavolmarko@480: // only for non-void functions! pavolmarko@480: if (m_Proto.GetRet().size == 0) pavolmarko@480: return; pavolmarko@480: pavolmarko@480: // if (cur_res >= MRES_OVERRIDE) pavolmarko@480: // *reinterpret_cast(pContext->GetOverrideRetPtr()) = plugin_ret; pavolmarko@480: pavolmarko@480: // eax = cur_res pavolmarko@480: // cmp eax,MRES_OVERRIDE pavolmarko@480: // jnge thelabel pavolmarko@480: // pContext->GetOverrideRetPtr() --> overrideretptr in eax pavolmarko@480: // *eax = plugin_ret pavolmarko@480: // thelabel: pavolmarko@480: // pavolmarko@480: pavolmarko@480: jitoffs_t tmppos, counter; pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res); pavolmarko@480: pavolmarko@480: IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_OVERRIDE); pavolmarko@480: tmppos = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NGE, 0); pavolmarko@480: m_HookFunc.start_count(counter); pavolmarko@480: pavolmarko@480: // eax = pContext->GetOverrideRetPtr() no alignment needs pavolmarko@480: // ECX = pContext pavolmarko@480: // gcc: push ecx pavolmarko@480: // eax = [ecx] pavolmarko@480: // eax = [eax + 4] pavolmarko@480: // call eax pavolmarko@480: // gcc: clean up pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: // vtbloffs=0, vtblidx=1 pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG); pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 4); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: pavolmarko@480: // *eax = plugin_ret pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef) pavolmarko@480: { pavolmarko@480: // mov ecx, [ebp+v_plugin_ret] pavolmarko@480: // mov [eax], ecx pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret); pavolmarko@480: IA32_Mov_Rm_Reg(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: if (m_Proto.GetRet().pAssignOperator) pavolmarko@480: { pavolmarko@480: // lea edx, [ebp + v_plugin_ret] pavolmarko@480: // push edx <-- src addr pavolmarko@480: // msvc: ecx = eax <-- dest addr pavolmarko@480: // gcc: push eax <-- dest addr pavolmarko@480: // call it pavolmarko@480: // gcc: clean up pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_plugin_ret); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: #if SH_COMP == SH_COMP_MSVC pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG); pavolmarko@480: #elif SH_COMP == SH_COMP_GCC pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: #endif pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG)); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // bitwise copy pavolmarko@480: BitwiseCopy_Setup(); pavolmarko@480: pavolmarko@480: //mov edi, eax <-- destination pavolmarko@480: //lea esi, [ebp+v_plugin_ret] <-- src pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDI, REG_EAX, MOD_REG); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_plugin_ret); pavolmarko@480: pavolmarko@480: BitwiseCopy_Do(m_Proto.GetRet().size); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: m_HookFunc.end_count(counter); pavolmarko@480: m_HookFunc.rewrite(tmppos, static_cast(counter)); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::PrepareReturn(int v_status, int v_pContext, int v_retptr) pavolmarko@480: { pavolmarko@480: // only for non-void functions! pavolmarko@480: if (m_Proto.GetRet().size == 0) pavolmarko@480: return; pavolmarko@480: pavolmarko@480: // retptr = status >= MRES_OVERRIDE ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr() pavolmarko@480: pavolmarko@480: // OverrideRetPtr: vtblidx = 1 pavolmarko@480: // OrigRetPtr: vtbldix = 2 pavolmarko@480: // vtblidx = (status >= MRES_OVERRIDE) ? 1 : 2 pavolmarko@480: pavolmarko@480: // pavolmarko@480: // eax = pContext->GetOverrideRetPtr() pavolmarko@480: // ECX = pContext pavolmarko@480: // gcc: push ecx pavolmarko@480: pavolmarko@480: // eax = (status < MRES_OVERRIDE) ? 1 : 0 pavolmarko@480: // xor eax, eax pavolmarko@480: // cmp [ebp + v_status], MRES_OVERRIDE pavolmarko@480: // setl al <-- setcc optimization for ternary operators, pavolmarko@480: pavolmarko@480: pavolmarko@480: // lea eax, [4*eax + 0x4] pavolmarko@480: pavolmarko@480: // edx = [ecx] pavolmarko@480: // add edx, eax pavolmarko@480: // mov edx, [edx] pavolmarko@480: pavolmarko@480: // call edx pavolmarko@480: // gcc: clean up pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Xor_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG); pavolmarko@480: IA32_Cmp_Rm_Disp8_Imm8(&m_HookFunc, REG_EBP, v_status, MRES_OVERRIDE); pavolmarko@480: IA32_SetCC_Rm8(&m_HookFunc, REG_EAX, CC_L); pavolmarko@480: pavolmarko@480: IA32_Lea_Reg_RegMultImm32(&m_HookFunc, REG_EAX, REG_EAX, SCALE4, 4); pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_MEM_REG); pavolmarko@480: IA32_Add_Reg_Rm(&m_HookFunc, REG_EDX, REG_EAX, MOD_REG); pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_MEM_REG); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_retptr); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::DoReturn(int v_retptr, int v_memret_outaddr) pavolmarko@480: { pavolmarko@480: size_t size = m_Proto.GetRet().size; pavolmarko@480: if (!size) pavolmarko@480: return; pavolmarko@480: pavolmarko@480: // Get real ret pointer into ecx pavolmarko@480: // mov ecx, [ebp + v_ret_ptr] pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_retptr); pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef) pavolmarko@480: { pavolmarko@480: // mov eax, [ecx] pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG); pavolmarko@480: return; pavolmarko@480: } pavolmarko@480: // else: byval pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().type == PassInfo::PassType_Float) pavolmarko@480: { pavolmarko@480: if (size == 4) pavolmarko@480: IA32_Fld_Mem32(&m_HookFunc, REG_ECX); pavolmarko@480: else if (size == 8) pavolmarko@480: IA32_Fld_Mem64(&m_HookFunc, REG_ECX); pavolmarko@480: } pavolmarko@480: else if (m_Proto.GetRet().type == PassInfo::PassType_Basic || pavolmarko@480: ((m_Proto.GetRet().type == PassInfo::PassType_Object) && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)) ) pavolmarko@480: { pavolmarko@480: if (size <= 4) pavolmarko@480: { pavolmarko@480: // size <= 4: return in EAX pavolmarko@480: // We align <4 sizes up to 4 pavolmarko@480: pavolmarko@480: // mov eax, [ecx] pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG); pavolmarko@480: } pavolmarko@480: else if (size <= 8) pavolmarko@480: { pavolmarko@480: // size <= 4: return in EAX:EDX pavolmarko@480: // We align 48: return in memory pavolmarko@480: // handled later pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) pavolmarko@480: { pavolmarko@480: // *memret_outaddr = plugin_ret pavolmarko@480: if (m_Proto.GetRet().pCopyCtor) pavolmarko@480: { pavolmarko@480: // mov edx, ecx <-- src ( we set ecx to [ebp+v_retptr] before ) pavolmarko@480: // push edx <-- src addr pavolmarko@480: // msvc: ecx = [ebp + v_memret_outaddr] <-- dest addr pavolmarko@480: // gcc: push [ebp + v_memret_outaddr] <-- dest addr pavolmarko@480: // call it pavolmarko@480: // gcc: clean up pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_REG); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: pavolmarko@480: #if SH_COMP == SH_COMP_MSVC pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_memret_outaddr); pavolmarko@480: #elif SH_COMP == SH_COMP_GCC pavolmarko@480: IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, v_memret_outaddr); pavolmarko@480: #endif pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pCopyCtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG)); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // bitwise copy pavolmarko@480: BitwiseCopy_Setup(); pavolmarko@480: pavolmarko@480: //mov edi, [ebp+v_memret_outaddr] <-- destination pavolmarko@480: //mov esi, ecx <-- src ( we set ecx to [ebp+v_retptr] before ) pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDI, REG_EBP, v_memret_outaddr); pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESI, REG_ECX, MOD_REG); pavolmarko@480: pavolmarko@480: BitwiseCopy_Do(m_Proto.GetRet().size); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // In both cases: return the pointer in EAX pavolmarko@480: // mov eax, [ebp + v_memret_outaddr] pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_memret_outaddr); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter, pavolmarko@480: 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) pavolmarko@480: { pavolmarko@480: jitoffs_t counter, tmppos; pavolmarko@480: jitoffs_t counter2, tmppos2; pavolmarko@480: pavolmarko@480: jitoffs_t loop_begin_counter; pavolmarko@480: pavolmarko@480: // prev_res = MRES_IGNORED pavolmarko@480: IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_prev_res); pavolmarko@480: pavolmarko@480: m_HookFunc.start_count(loop_begin_counter); pavolmarko@480: pavolmarko@480: // eax = pContext->GetNext() pavolmarko@480: // ECX = pContext pavolmarko@480: // gcc: push ecx pavolmarko@480: // eax = [ecx] pavolmarko@480: // eax = [eax] pavolmarko@480: // call eax pavolmarko@480: // gcc: clean up pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: // vtbloffs=0, vtblidx=0 pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG); pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_MEM_REG); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: // quit on zero pavolmarko@480: // test eax, eax pavolmarko@480: // jz exit pavolmarko@480: IA32_Test_Rm_Reg(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG); pavolmarko@480: tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0); pavolmarko@480: m_HookFunc.start_count(counter); pavolmarko@480: pavolmarko@480: // prev_res = MRES_IGNORED pavolmarko@480: IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_cur_res); pavolmarko@480: pavolmarko@480: // iter->call() pavolmarko@480: // push params pavolmarko@480: // ecx = eax pavolmarko@480: // gcc: push ecx pavolmarko@480: // eax = [ecx] pavolmarko@480: // eax = [eax+2*SIZE_PTR] pavolmarko@480: // call eax pavolmarko@480: // gcc: clean up pavolmarko@480: pavolmarko@480: jit_int32_t caller_clean_bytes = 0; // gcc always, msvc never (hooks never have varargs!) pavolmarko@480: pavolmarko@480: jit_int32_t alignBytes = AlignStackBeforeCall( pavolmarko@480: GetParamsTotalStackSize() + ((m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)!=0 ? SIZE_PTR : 0), pavolmarko@480: AlignStack_GCC_ThisOnStack | ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) == 0 ? 0 : AlignStack_MemRet) pavolmarko@480: ); pavolmarko@480: pavolmarko@480: // vafmt: push va_buf pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) pavolmarko@480: { pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: caller_clean_bytes += SIZE_PTR; pavolmarko@480: } pavolmarko@480: pavolmarko@480: caller_clean_bytes += PushParams(base_param_offset, v_plugin_ret, v_place_for_memret, v_place_fbrr_base); pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG); pavolmarko@480: if (SH_COMP == SH_COMP_GCC) pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: caller_clean_bytes += PushMemRetPtr(v_plugin_ret, v_place_for_memret); pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG); pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 2*SIZE_PTR); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(alignBytes); pavolmarko@480: pavolmarko@480: // cleanup (gcc only) pavolmarko@480: // params + thisptr pavolmarko@480: if (SH_COMP == SH_COMP_GCC) pavolmarko@480: IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, caller_clean_bytes + SIZE_PTR, MOD_REG); pavolmarko@480: pavolmarko@480: DestroyParams(v_place_fbrr_base); pavolmarko@480: pavolmarko@480: SaveRetVal(v_plugin_ret, v_place_for_memret); pavolmarko@480: pavolmarko@480: // process meta return: pavolmarko@480: // prev_res = cur_res pavolmarko@480: // if (cur_res > status) status = cur_res; pavolmarko@480: // pavolmarko@480: // eax = cur_res pavolmarko@480: // edx = status pavolmarko@480: // prev_res = eax pavolmarko@480: // cmp eax,edx pavolmarko@480: // jng thelabel pavolmarko@480: // status = eax pavolmarko@480: // thelabel: pavolmarko@480: // pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res); pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDX, REG_EBP, v_status); pavolmarko@480: IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_prev_res); pavolmarko@480: pavolmarko@480: IA32_Cmp_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_REG); pavolmarko@480: tmppos2 = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NG, 0); pavolmarko@480: m_HookFunc.start_count(counter2); pavolmarko@480: pavolmarko@480: IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_status); pavolmarko@480: pavolmarko@480: m_HookFunc.end_count(counter2); pavolmarko@480: m_HookFunc.rewrite(tmppos2, static_cast(counter2)); pavolmarko@480: pavolmarko@480: // process retval for non-void functions pavolmarko@480: ProcessPluginRetVal(v_cur_res, v_pContext, v_plugin_ret); pavolmarko@480: pavolmarko@480: // jump back to loop begin pavolmarko@480: tmppos2 = IA32_Jump_Imm32(&m_HookFunc, 0); pavolmarko@480: m_HookFunc.end_count(loop_begin_counter); pavolmarko@515: m_HookFunc.rewrite(tmppos2, -static_cast(loop_begin_counter)); pavolmarko@480: pavolmarko@480: m_HookFunc.end_count(counter); pavolmarko@480: m_HookFunc.rewrite(tmppos, static_cast(counter)); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this, pavolmarko@480: 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) pavolmarko@480: { pavolmarko@480: jitoffs_t counter, tmppos; pavolmarko@480: jitoffs_t counter2, tmppos2; pavolmarko@480: jitoffs_t counter3, tmppos3; pavolmarko@480: pavolmarko@480: // if (status != MRES_SUPERCEDE && pConteext->ShouldCallOrig()) pavolmarko@480: // *v_orig_ret = orig_call() pavolmarko@480: // else pavolmarko@480: // *v_orig_ret = *v_override_ret pavolmarko@480: pavolmarko@480: // mov eax, status pavolmarko@480: // cmp eax, MRES_SUPERCEDE pavolmarko@480: // je dont_call pavolmarko@480: // call pContext->ShouldCallOrig() pavolmarko@480: // test al, al !! important: al, not eax! bool is only stored in the LSbyte pavolmarko@480: // jz dont_call pavolmarko@480: // pavolmarko@480: // orig_call() pavolmarko@480: // SaveRet(v_orig_ret) pavolmarko@480: // jmp skip_dont_call: pavolmarko@480: // pavolmarko@480: // dont_call: pavolmarko@480: // *v_orig_ret = *v_override_ret pavolmarko@480: // skip_dont_call: pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_status); pavolmarko@480: IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_SUPERCEDE); pavolmarko@480: pavolmarko@480: tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_E, 0); pavolmarko@480: m_HookFunc.start_count(counter); pavolmarko@480: pavolmarko@480: // eax = pContext->ShouldCallOrig() pavolmarko@480: // ECX = pContext pavolmarko@480: // gcc: push ecx pavolmarko@480: // eax = [ecx] pavolmarko@480: // eax = [eax + 3*SIZE_PTR] pavolmarko@480: // call eax pavolmarko@480: // gcc: clean up pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: // vtbloffs=0, vtblidx=3 pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG); pavolmarko@480: IA32_Mov_Reg_Rm_Disp8(&m_HookFunc, REG_EAX, REG_EAX, 3*SIZE_PTR); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: IA32_Test_Rm_Reg8(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG); pavolmarko@480: tmppos2 = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0); pavolmarko@480: m_HookFunc.start_count(counter2); pavolmarko@480: pavolmarko@480: jit_int32_t caller_clean_bytes = 0; // gcc always, msvc when cdecl-like (varargs) pavolmarko@480: pavolmarko@480: jit_int32_t alignBytes = AlignStackBeforeCall( pavolmarko@480: GetParamsTotalStackSize() + ((m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)!=0 ? 2*SIZE_PTR : 0), pavolmarko@480: AlignStack_GCC_ThisOnStack | pavolmarko@480: ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) == 0 ? 0 : AlignStack_MemRet) | pavolmarko@480: ((m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) == 0 ? 0 : AlignStack_MSVC_ThisOnStack) pavolmarko@480: ); pavolmarko@480: pavolmarko@480: // vafmt: push va_buf, then "%s" pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) pavolmarko@480: { pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: IA32_Push_Imm32(&m_HookFunc, DownCastPtr("%s")); pavolmarko@480: caller_clean_bytes += 2*SIZE_PTR; pavolmarko@480: } pavolmarko@480: pavolmarko@480: // push params pavolmarko@480: caller_clean_bytes += PushParams(param_base_offs, v_orig_ret, v_place_for_memret, v_place_fbrr_base); pavolmarko@480: pavolmarko@480: // thisptr pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this); pavolmarko@480: if (SH_COMP == SH_COMP_GCC) pavolmarko@480: { pavolmarko@480: // on gcc/mingw, this is the first parameter pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: // on msvc without varargs, simply leave it in ecx pavolmarko@480: pavolmarko@480: // actually, if we're returning in memory, this pointer is the second param pavolmarko@480: // and the memret pointer is the real first parameter pavolmarko@480: caller_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // On msvc, if we're returning in memory, the memret pointer is the first parameter pavolmarko@480: caller_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret); pavolmarko@480: pavolmarko@480: // actually, with varargs, the this pointer is the first param and the memret ptr pavolmarko@480: // is the second one pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) pavolmarko@480: { pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: // call pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_vfnptr_origentry); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(alignBytes); pavolmarko@480: pavolmarko@480: // cleanup pavolmarko@480: if (SH_COMP == SH_COMP_GCC || (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)) pavolmarko@480: IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, caller_clean_bytes + SIZE_PTR, MOD_REG); pavolmarko@480: pavolmarko@480: DestroyParams(v_place_fbrr_base); pavolmarko@480: pavolmarko@480: // save retval pavolmarko@480: SaveRetVal(v_orig_ret, v_place_for_memret); pavolmarko@480: pavolmarko@480: // Skip don't call variant pavolmarko@480: tmppos3 = IA32_Jump_Imm32(&m_HookFunc, 0); pavolmarko@480: m_HookFunc.start_count(counter3); pavolmarko@480: pavolmarko@480: pavolmarko@480: // don't call: pavolmarko@480: m_HookFunc.end_count(counter); pavolmarko@480: m_HookFunc.rewrite(tmppos, static_cast(counter)); pavolmarko@480: pavolmarko@480: m_HookFunc.end_count(counter2); pavolmarko@480: m_HookFunc.rewrite(tmppos2, static_cast(counter2)); pavolmarko@480: pavolmarko@480: // *v_orig_ret = *v_override_ret pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef) pavolmarko@480: { pavolmarko@480: // mov ecx, [ebp + v_override_ret] pavolmarko@480: // mov [ebp + v_orig_ret], ecx pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret); pavolmarko@480: IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_ECX, v_orig_ret); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: if (m_Proto.GetRet().pAssignOperator) pavolmarko@480: { pavolmarko@480: // lea edx, [ebp + v_override_ret] <-- src addr pavolmarko@480: // lea ecx, [ebp + v_orig_ret] <-- dest addr pavolmarko@480: // push edx <-- src addr pavolmarko@480: // gcc: push ecx pavolmarko@480: // call it pavolmarko@480: // gcc: clean up pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_override_ret); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG)); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // bitwise copy pavolmarko@480: BitwiseCopy_Setup(); pavolmarko@480: pavolmarko@480: //lea edi, [ebp+v_orig_ret] <-- destination pavolmarko@480: //lea esi, [ebp+v_override_ret] <-- src pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_orig_ret); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_override_ret); pavolmarko@480: pavolmarko@480: BitwiseCopy_Do(m_Proto.GetRet().size); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: // skip don't call label target: pavolmarko@480: m_HookFunc.end_count(counter3); pavolmarko@480: m_HookFunc.rewrite(tmppos3, static_cast(counter3)); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // Sets *v_pContext to return value pavolmarko@480: void GenContext::CallSetupHookLoop(int v_orig_ret, int v_override_ret, pavolmarko@480: int v_cur_res, int v_prev_res, int v_status, int v_vfnptr_origentry, pavolmarko@480: int v_this, int v_pContext) pavolmarko@480: { pavolmarko@480: // call shptr->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast(this), pavolmarko@480: // &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret); pavolmarko@480: // The last two params are null for void funcs. pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().size == 0) pavolmarko@480: { pavolmarko@480: // void pavolmarko@480: IA32_Push_Imm8(&m_HookFunc, 0); // orig_ret pavolmarko@480: IA32_Push_Imm8(&m_HookFunc, 0); // override_ret pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // orig_ret and override_ret pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, v_override_ret); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_orig_ret); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // cur_res and prev_res pavolmarko@480: IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res); pavolmarko@480: IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_prev_res); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: pavolmarko@480: // status and vfnptr_origentry pavolmarko@480: IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_status); pavolmarko@480: IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_vfnptr_origentry); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: pavolmarko@480: // this pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_this); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // our vfn ptr pavolmarko@480: // *(this + vtbloffs) + SIZE_PTR*vtblidx pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this); // get this into ecx (gcc!) pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, m_VtblOffs); pavolmarko@480: IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_EAX, m_VtblIdx * SIZE_PTR, MOD_REG); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // *m_pHI pavolmarko@480: IA32_Mov_Rm_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG); pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_MEM_REG); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // set up thisptr pavolmarko@480: #if SH_COMP == SH_COMP_GCC pavolmarko@480: // on gcc/mingw, this is the first parameter pavolmarko@480: GCC_ONLY(IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr))); pavolmarko@480: #elif SH_COMP == SH_COMP_MSVC pavolmarko@480: // on msvc, it's ecx pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr)); pavolmarko@480: #endif pavolmarko@480: pavolmarko@480: // call the function. vtbloffs = 0, vtblidx = 19 pavolmarko@480: // get vtptr into edx -- we know shptr on jit time -> dereference it here! pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, pavolmarko@480: (*reinterpret_cast(m_SHPtr))[19]); pavolmarko@480: pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // on gcc/mingw, we have to clean up after the call pavolmarko@480: // 9 params + hidden thisptr param pavolmarko@480: GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 10*SIZE_PTR, MOD_REG)); pavolmarko@480: pavolmarko@480: // store return value pavolmarko@480: IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_pContext); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::CallEndContext(int v_pContext) pavolmarko@480: { pavolmarko@480: // call endcontext: pavolmarko@480: // shptr->EndContext(pContex) pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_pContext); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // thisptr pavolmarko@480: #if SH_COMP == SH_COMP_GCC pavolmarko@480: // on gcc/mingw, this is the first parameter pavolmarko@480: IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr)); pavolmarko@480: #elif SH_COMP == SH_COMP_MSVC pavolmarko@480: // on msvc, it's ecx pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr)); pavolmarko@480: #endif pavolmarko@480: pavolmarko@480: // get vtptr into edx -- we know shptr on jit time -> dereference it here! pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, pavolmarko@480: (*reinterpret_cast(m_SHPtr))[20]); pavolmarko@480: pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // on gcc/mingw, we have to clean up after the call pavolmarko@480: // 1 param + hidden thisptr param pavolmarko@480: GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG)); pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::ResetFrame(jit_int32_t startOffset) pavolmarko@480: { pavolmarko@480: m_HookFunc_FrameOffset = startOffset; pavolmarko@480: m_HookFunc_FrameVarsSize = 0; pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::AddVarToFrame(jit_int32_t size) pavolmarko@480: { pavolmarko@480: m_HookFunc_FrameOffset -= size; pavolmarko@480: m_HookFunc_FrameVarsSize += size; pavolmarko@480: return m_HookFunc_FrameOffset; pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t GenContext::ComputeVarsSize() pavolmarko@480: { pavolmarko@480: return m_HookFunc_FrameVarsSize; pavolmarko@480: } pavolmarko@480: pavolmarko@480: void * GenContext::GenerateHookFunc() pavolmarko@480: { pavolmarko@480: // prologue pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EBP); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EBX); pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_EBP, REG_ESP, MOD_REG); pavolmarko@480: pavolmarko@480: jit_int32_t v_this = 0; pavolmarko@480: jit_int32_t param_base_offs = 0; pavolmarko@480: if (SH_COMP == SH_COMP_GCC || (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)) pavolmarko@480: { pavolmarko@480: // gcc or msvc with varargs: pavolmarko@480: v_this = 12; // first param pavolmarko@480: param_base_offs = 16; pavolmarko@480: ResetFrame(0); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // on msvc without varargs, save thisptr pavolmarko@480: v_this = -4; pavolmarko@480: param_base_offs = 12; pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: ResetFrame(-4); // start placing local vars on offset -4 pavolmarko@480: // because there already is the thisptr variable pavolmarko@480: } pavolmarko@480: pavolmarko@480: // ********************** stack frame ********************** pavolmarko@480: // MSVC without varargs pavolmarko@480: // second param (gcc: first real param) ebp + 16 pavolmarko@480: // first param (gcc: thisptr) ebp + 12 pavolmarko@480: // ret address: ebp + 8 pavolmarko@480: // caller's ebp ebp + 4 pavolmarko@480: // saved ebx ebp pavolmarko@480: // MSVC ONLY: current this ebp - 4 pavolmarko@480: // void *vfnptr_origentry ebp - 4 -4 pavolmarko@480: // META_RES status = MRES_IGNORED ebp - 8 -4 pavolmarko@480: // META_RES prev_res ebp - 12 -4 pavolmarko@480: // META_RES cur_res ebp - 16 -4 pavolmarko@480: // IMyDelegate *iter ebp - 20 -4 pavolmarko@480: // IHookContext *pContext ebp - 24 -4 pavolmarko@480: // == 3 ptrs + 3 enums = 24 bytes pavolmarko@480: // pavolmarko@480: // non-void: add: pavolmarko@480: // my_rettype *ret_ptr ebp - 28 -4 pavolmarko@480: // my_rettype orig_ret ebp - 28 - sizeof(my_rettype) -4 pavolmarko@480: // my_rettype override_ret ebp - 28 - sizeof(my_rettype)*2 -4 pavolmarko@480: // my_rettype plugin_ret ebp - 28 - sizeof(my_rettype)*3 -4 pavolmarko@480: // == + 3 * sizeof(my_rettype) bytes pavolmarko@480: pavolmarko@480: // if required: pavolmarko@480: // my_rettype place_for_memret ebp - 28 - sizeof(my_rettype)*4 -4 pavolmarko@480: pavolmarko@480: // gcc only: if required: pavolmarko@480: // place forced byref params ebp - 28 - sizeof(my_rettype)*{4 or 5} pavolmarko@480: // pavolmarko@480: // varargs: pavolmarko@480: // va_list argptr pavolmarko@480: // char va_buf[something]; pavolmarko@480: pavolmarko@480: pavolmarko@480: const jit_int8_t v_vfnptr_origentry = AddVarToFrame(SIZE_PTR); pavolmarko@480: const jit_int8_t v_status = AddVarToFrame(sizeof(META_RES)); pavolmarko@480: const jit_int8_t v_prev_res = AddVarToFrame(sizeof(META_RES)); pavolmarko@480: const jit_int8_t v_cur_res = AddVarToFrame(sizeof(META_RES)); pavolmarko@480: const jit_int8_t v_iter = AddVarToFrame(SIZE_PTR); pavolmarko@480: const jit_int8_t v_pContext = AddVarToFrame(SIZE_PTR); pavolmarko@480: pavolmarko@480: // Memory return: first param is the address pavolmarko@480: jit_int32_t v_memret_addr = 0; pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) pavolmarko@480: { pavolmarko@480: if (SH_COMP == SH_COMP_GCC) pavolmarko@480: { pavolmarko@480: // gcc: now: first param = mem ret addr pavolmarko@480: // second param = this pointer pavolmarko@480: // third param = actual first param pavolmarko@480: v_memret_addr = 12; pavolmarko@480: v_this += 4; pavolmarko@480: param_base_offs += SIZE_PTR; pavolmarko@480: } pavolmarko@480: else // MSVC pavolmarko@480: { pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) pavolmarko@480: { pavolmarko@480: // varargs -> cdecl pavolmarko@480: // msvc: now: pavolmarko@480: // first param = this pointer pavolmarko@480: // second param = mem ret addr pavolmarko@480: // third param = actual first param pavolmarko@480: pavolmarko@480: // params_base_offs is already updated to point to after the this pointer pavolmarko@480: v_memret_addr = param_base_offs; pavolmarko@480: param_base_offs += SIZE_PTR; pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: v_memret_addr = param_base_offs; pavolmarko@480: param_base_offs += SIZE_PTR; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t v_ret_ptr = 0; pavolmarko@480: jit_int32_t v_orig_ret = 0; pavolmarko@480: jit_int32_t v_override_ret = 0; pavolmarko@480: jit_int32_t v_plugin_ret = 0; pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().size != 0) pavolmarko@480: { pavolmarko@480: v_ret_ptr = AddVarToFrame(SIZE_PTR); pavolmarko@480: v_orig_ret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet())); pavolmarko@480: v_override_ret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet())); pavolmarko@480: v_plugin_ret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet())); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t v_place_for_memret = 0; pavolmarko@480: if (MemRetWithTempObj()) pavolmarko@480: { pavolmarko@480: v_place_for_memret = AddVarToFrame(GetParamStackSize(m_Proto.GetRet())); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t v_place_fbrr_base = 0; pavolmarko@480: if (SH_COMP == SH_COMP_GCC && GetForcedByRefParamsSize()) pavolmarko@480: { pavolmarko@480: v_place_fbrr_base = AddVarToFrame(GetForcedByRefParamsSize()); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // Only exists for varargs functions pavolmarko@480: jit_int32_t v_va_argptr = 0; pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) pavolmarko@480: { pavolmarko@480: v_va_argptr = AddVarToFrame(SIZE_PTR); pavolmarko@480: } pavolmarko@480: pavolmarko@480: jit_int32_t v_va_buf = 0; pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) pavolmarko@480: { pavolmarko@480: v_va_buf = AddVarToFrame(SourceHook::STRBUF_LEN); pavolmarko@480: } pavolmarko@480: pavolmarko@480: IA32_Sub_Rm_Imm32(&m_HookFunc, REG_ESP, ComputeVarsSize(), MOD_REG); pavolmarko@480: pavolmarko@480: // Initial stack alignment pavolmarko@480: IA32_And_Rm_Imm32(&m_HookFunc, REG_ESP, MOD_REG, -16); pavolmarko@480: m_BytesPushedAfterInitialAlignment = 0; pavolmarko@480: pavolmarko@480: // init status localvar pavolmarko@480: IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_status); pavolmarko@480: pavolmarko@480: // VarArgs: init argptr & format pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) pavolmarko@480: { pavolmarko@480: // argptr = first vararg param pavolmarko@480: // lea eax, [ebp + param_base_offs + paramssize] pavolmarko@480: // mov argptr, eax pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_base_offs + GetParamsTotalStackSize() + SIZE_PTR); // +SIZE_PTR: last const char * is not in protoinfo pavolmarko@480: IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_va_argptr); pavolmarko@480: } pavolmarko@480: if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt) pavolmarko@480: { pavolmarko@480: // vsnprintf pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(SIZE_PTR*3 + sizeof(size_t), 0); pavolmarko@480: pavolmarko@480: // push valist, fmt param, maxsize, buffer pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_base_offs + GetParamsTotalStackSize()); // last given param (+4-4, see above) pavolmarko@480: IA32_Push_Imm32(&m_HookFunc, SourceHook::STRBUF_LEN - 1); pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_ECX); pavolmarko@480: pavolmarko@480: // call pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(&vsnprintf)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // Clean up (cdecl) pavolmarko@480: IA32_Add_Rm_Imm32(&m_HookFunc, REG_ESP, 0x10, MOD_REG); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: pavolmarko@480: // Set trailing zero pavolmarko@480: IA32_Xor_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_REG); pavolmarko@480: IA32_Mov_Rm8_Reg8_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_va_buf + SourceHook::STRBUF_LEN - 1); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // Call constructors for ret vars if required pavolmarko@480: if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) && pavolmarko@480: m_Proto.GetRet().pNormalCtor) pavolmarko@480: { pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: // orig_reg pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: // override_reg pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: // plugin_ret pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: pavolmarko@480: // _don't_ call a constructor for v_place_for_memret ! pavolmarko@480: } pavolmarko@480: pavolmarko@480: // ********************** SetupHookLoop ********************** pavolmarko@480: CallSetupHookLoop(v_orig_ret, v_override_ret, v_cur_res, v_prev_res, v_status, v_vfnptr_origentry, pavolmarko@480: v_this, v_pContext); pavolmarko@480: pavolmarko@480: // ********************** call pre hooks ********************** pavolmarko@480: GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs, pavolmarko@480: v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf); pavolmarko@480: pavolmarko@480: // ********************** call orig func ********************** pavolmarko@480: GenerateCallOrig(v_status, v_pContext, param_base_offs, v_this, v_vfnptr_origentry, v_orig_ret, pavolmarko@480: v_override_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf); pavolmarko@480: pavolmarko@480: // ********************** call post hooks ********************** pavolmarko@480: GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs, pavolmarko@480: v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf); pavolmarko@480: pavolmarko@480: // ********************** end context and return ********************** pavolmarko@480: pavolmarko@480: PrepareReturn(v_status, v_pContext, v_ret_ptr); pavolmarko@480: pavolmarko@480: CallEndContext(v_pContext); pavolmarko@480: pavolmarko@480: // Call destructors of byval object params which have a destructor pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: jit_int32_t cur_param_pos = param_base_offs; pavolmarko@480: for (int i = 0; i < m_Proto.GetNumOfParams(); ++i) pavolmarko@480: { pavolmarko@480: const IntPassInfo &pi = m_Proto.GetParam(i); pavolmarko@480: // GCC: NOT of forced byref params. the caller destructs those. pavolmarko@480: if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) && pavolmarko@480: (pi.flags & PassInfo::PassFlag_ByVal) && !(pi.flags & PassFlag_ForcedByRef)) pavolmarko@480: { pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, cur_param_pos); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor)); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: } pavolmarko@480: cur_param_pos += GetParamStackSize(pi); pavolmarko@480: } pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: pavolmarko@480: DoReturn(v_ret_ptr, v_memret_addr); pavolmarko@480: pavolmarko@480: // Call destructors of orig_ret/ ... pavolmarko@480: if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) && pavolmarko@480: m_Proto.GetRet().pDtor) pavolmarko@480: { pavolmarko@480: // Preserve return value in EAX(:EDX) pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: IA32_Push_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: pavolmarko@480: m_BytesPushedAfterInitialAlignment += 8; pavolmarko@480: pavolmarko@480: jit_int32_t tmpAlign = AlignStackBeforeCall(0, AlignStack_GCC_ThisOnStack); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret); pavolmarko@480: GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor)); pavolmarko@480: CheckAlignmentBeforeCall(); pavolmarko@480: IA32_Call_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX)); pavolmarko@480: pavolmarko@480: AlignStackAfterCall(tmpAlign); pavolmarko@480: pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_EDX); pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_EAX); pavolmarko@480: pavolmarko@480: m_BytesPushedAfterInitialAlignment -= 8; pavolmarko@480: } pavolmarko@480: pavolmarko@480: // epilogue pavolmarko@480: IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESP, REG_EBP, MOD_REG); pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_EBX); pavolmarko@480: IA32_Pop_Reg(&m_HookFunc, REG_EBP); pavolmarko@480: pavolmarko@480: if (SH_COMP == SH_COMP_MSVC && !(m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)) pavolmarko@480: { pavolmarko@480: // msvc without varargs: pavolmarko@480: // callee cleans the stack pavolmarko@480: pavolmarko@480: short cleansize = GetParamsTotalStackSize(); pavolmarko@480: // Memory return: address is first param pavolmarko@480: if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem) pavolmarko@480: cleansize += SIZE_PTR; pavolmarko@480: pavolmarko@480: IA32_Return_Popstack(&m_HookFunc, cleansize); pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // gcc or msvc with varargs: caller cleans the stack pavolmarko@480: // exception: gcc removes the memret addr on memret: pavolmarko@480: if (SH_COMP == SH_COMP_GCC && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)) pavolmarko@480: IA32_Return_Popstack(&m_HookFunc, SIZE_PTR); pavolmarko@480: else pavolmarko@480: IA32_Return(&m_HookFunc); pavolmarko@480: } pavolmarko@480: pavolmarko@480: pavolmarko@480: // Store pointer for later use pavolmarko@480: // m_HookfuncVfnPtr is a pointer to a void* because SH expects a pointer pavolmarko@480: // into the hookman's vtable pavolmarko@480: *m_HookfuncVfnptr = reinterpret_cast(m_HookFunc.GetData()); pavolmarko@480: pavolmarko@480: m_HookFunc.SetRE(); pavolmarko@480: pavolmarko@480: return m_HookFunc.GetData(); pavolmarko@480: } pavolmarko@480: pavolmarko@480: // Pre-condition: GenerateHookFunc() has been called! pavolmarko@480: void * GenContext::GeneratePubFunc() pavolmarko@480: { pavolmarko@480: jitoffs_t counter, tmppos; pavolmarko@480: pavolmarko@480: // The pubfunc is a static cdecl function. pavolmarko@480: // C Code: pavolmarko@480: // int HookManPubFunc( pavolmarko@480: // bool store, ebp + 8 pavolmarko@480: // IHookManagerInfo *hi ebp + 12 pavolmarko@480: // ) pavolmarko@480: // { pavolmarko@480: // if (store) pavolmarko@480: // *m_pHI = hi; pavolmarko@480: // if (hi) pavolmarko@480: // hi->SetInfo(HOOKMAN_VERSION, m_VtblOffs, m_VtblIdx, m_Proto.GetProto(), m_HookfuncVfnptr) pavolmarko@480: // } pavolmarko@480: pavolmarko@480: // prologue pavolmarko@480: IA32_Push_Reg(&m_PubFunc, REG_EBP); pavolmarko@480: IA32_Mov_Reg_Rm(&m_PubFunc, REG_EBP, REG_ESP, MOD_REG); pavolmarko@480: pavolmarko@480: pavolmarko@480: // save store in eax, hi in ecx pavolmarko@480: IA32_Movzx_Reg32_Rm8_Disp8(&m_PubFunc, REG_EAX, REG_EBP, 8); pavolmarko@480: IA32_Mov_Reg_Rm_DispAuto(&m_PubFunc, REG_ECX, REG_EBP, 12); pavolmarko@480: pavolmarko@480: // Check for store == 0 pavolmarko@480: IA32_Test_Rm_Reg8(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG); pavolmarko@480: tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0); pavolmarko@480: m_PubFunc.start_count(counter); pavolmarko@480: pavolmarko@480: // nonzero -> store hi pavolmarko@480: IA32_Mov_Rm_Imm32(&m_PubFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG); pavolmarko@480: IA32_Mov_Rm_Reg(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG); pavolmarko@480: pavolmarko@480: // zero pavolmarko@480: m_PubFunc.end_count(counter); pavolmarko@480: m_PubFunc.rewrite(tmppos, static_cast(counter)); pavolmarko@480: pavolmarko@480: // check for hi == 0 pavolmarko@480: IA32_Test_Rm_Reg(&m_PubFunc, REG_ECX, REG_ECX, MOD_REG); pavolmarko@480: tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0); pavolmarko@480: m_PubFunc.start_count(counter); pavolmarko@480: pavolmarko@480: // nonzero -> call vfunc pavolmarko@480: // push params in reverse order pavolmarko@480: IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_HookfuncVfnptr)); pavolmarko@480: IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_BuiltPI)); pavolmarko@480: IA32_Push_Imm32(&m_PubFunc, m_VtblIdx); pavolmarko@480: IA32_Push_Imm32(&m_PubFunc, m_VtblOffs); pavolmarko@480: IA32_Push_Imm32(&m_PubFunc, SH_HOOKMAN_VERSION); pavolmarko@480: pavolmarko@480: // hi == this is in ecx pavolmarko@480: // on gcc/mingw, ecx is the first parameter pavolmarko@480: #if SH_COMP == SH_COMP_GCC pavolmarko@480: IA32_Push_Reg(&m_PubFunc, REG_ECX); pavolmarko@480: #endif pavolmarko@480: pavolmarko@480: // call the function. vtbloffs = 0, vtblidx = 0 pavolmarko@480: // get vtptr into edx pavolmarko@480: IA32_Mov_Reg_Rm(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG); pavolmarko@480: // get funcptr into eax pavolmarko@480: IA32_Mov_Reg_Rm(&m_PubFunc, REG_EAX, REG_EDX, MOD_MEM_REG); pavolmarko@480: pavolmarko@480: IA32_Call_Reg(&m_PubFunc, REG_EAX); pavolmarko@480: pavolmarko@480: // on gcc/mingw, we have to clean up after the call pavolmarko@480: #if SH_COMP == SH_COMP_GCC pavolmarko@480: // 5 params + hidden thisptr param pavolmarko@480: IA32_Add_Rm_Imm8(&m_PubFunc, REG_ESP, 6*SIZE_MWORD, MOD_REG); pavolmarko@480: #endif pavolmarko@480: pavolmarko@480: // zero pavolmarko@480: m_PubFunc.end_count(counter); pavolmarko@480: m_PubFunc.rewrite(tmppos, static_cast(counter)); pavolmarko@480: pavolmarko@480: // return value pavolmarko@480: IA32_Xor_Reg_Rm(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG); pavolmarko@480: pavolmarko@480: // epilogue pavolmarko@480: IA32_Mov_Reg_Rm(&m_PubFunc, REG_ESP, REG_EBP, MOD_REG); pavolmarko@480: IA32_Pop_Reg(&m_PubFunc, REG_EBP); pavolmarko@480: IA32_Return(&m_PubFunc); pavolmarko@480: pavolmarko@480: m_PubFunc.SetRE(); pavolmarko@480: pavolmarko@480: return m_PubFunc; pavolmarko@480: } pavolmarko@480: pavolmarko@480: bool GenContext::PassInfoSupported(const IntPassInfo &pi, bool is_ret) pavolmarko@480: { pavolmarko@480: // :TODO: Error returns pavolmarko@480: if (pi.type != PassInfo::PassType_Basic && pavolmarko@480: pi.type != PassInfo::PassType_Float && pavolmarko@480: pi.type != PassInfo::PassType_Object) pavolmarko@480: { pavolmarko@480: return false; pavolmarko@480: } pavolmarko@480: pavolmarko@480: if (pi.type == PassInfo::PassType_Object && pavolmarko@480: (pi.flags & PassInfo::PassFlag_ByVal)) pavolmarko@480: { pavolmarko@480: if ((pi.flags & PassInfo::PassFlag_CCtor) && !pi.pCopyCtor) pavolmarko@480: { pavolmarko@480: return false; pavolmarko@480: } pavolmarko@480: pavolmarko@480: if ((pi.flags & PassInfo::PassFlag_ODtor) && !pi.pDtor) pavolmarko@480: { pavolmarko@480: return false; pavolmarko@480: } pavolmarko@480: pavolmarko@480: if ((pi.flags & PassInfo::PassFlag_AssignOp) && !pi.pAssignOperator) pavolmarko@480: { pavolmarko@480: return false; pavolmarko@480: } pavolmarko@480: pavolmarko@480: if ((pi.flags & PassInfo::PassFlag_OCtor) && !pi.pNormalCtor) pavolmarko@480: { pavolmarko@480: return false; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: if ((pi.flags & (PassInfo::PassFlag_ByVal | PassInfo::PassFlag_ByRef)) == 0) pavolmarko@480: { pavolmarko@480: return false; // Neither byval nor byref! pavolmarko@480: } pavolmarko@480: return true; pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::AutoDetectRetType() pavolmarko@480: { pavolmarko@480: IntPassInfo &pi = m_Proto.GetRet(); pavolmarko@480: pavolmarko@480: // Only relevant for byval types pavolmarko@480: if (pi.flags & PassInfo::PassFlag_ByVal) pavolmarko@480: { pavolmarko@480: // Basic + float: pavolmarko@480: if (pi.type == PassInfo::PassType_Basic || pavolmarko@480: pi.type == PassInfo::PassType_Float) pavolmarko@480: { pavolmarko@480: // <= 8 bytes: pavolmarko@480: // _always_ in registers, no matter what the user says pavolmarko@480: if (pi.size <= 8) pavolmarko@480: { pavolmarko@480: pi.flags &= ~PassInfo::PassFlag_RetMem; pavolmarko@480: pi.flags |= PassInfo::PassFlag_RetReg; pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // Does this even exist? No idea, if it does: in memory! pavolmarko@480: pi.flags &= ~PassInfo::PassFlag_RetReg; pavolmarko@480: pi.flags |= PassInfo::PassFlag_RetMem; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: // Object: pavolmarko@480: else if (pi.type == PassInfo::PassType_Object) pavolmarko@480: { pavolmarko@480: // If the user says nothing, auto-detect pavolmarko@480: if ((pi.flags & (PassInfo::PassFlag_RetMem | PassInfo::PassFlag_RetReg)) == 0) pavolmarko@480: { pavolmarko@480: #if SH_COMP == SH_COMP_MSVC pavolmarko@480: // MSVC seems to return _all_ structs, classes, unions in memory pavolmarko@480: pi.flags |= PassInfo::PassFlag_RetMem; pavolmarko@480: #elif SH_COMP == SH_COMP_GCC ds@685: #if SH_SYS == SH_SYS_APPLE ds@685: // Apple GCC returns in memory if size isn't a power of 2 or > 8 ds@685: if ((pi.size & (pi.size - 1)) == 0 && pi.size <= 8) ds@685: { ds@685: pi.flags |= PassInfo::PassFlag_RetReg; ds@685: } ds@685: else ds@685: #endif ds@685: { ds@685: // GCC on Linux does same thing as MSVC ds@685: pi.flags |= PassInfo::PassFlag_RetMem; ds@685: } pavolmarko@480: #endif pavolmarko@480: } pavolmarko@480: } pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: // byref: make sure that the flag is _not_ set pavolmarko@480: pi.flags &= ~PassInfo::PassFlag_RetMem; pavolmarko@480: pi.flags |= PassInfo::PassFlag_RetReg; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: void GenContext::AutoDetectParamFlags() pavolmarko@480: { pavolmarko@480: #if SH_COMP == SH_COMP_GCC pavolmarko@480: // On GCC, all objects are passed by reference if they have a destructor pavolmarko@480: for (int i = 0; i < m_Proto.GetNumOfParams(); ++i) pavolmarko@480: { pavolmarko@480: IntPassInfo &pi = m_Proto.GetParam(i); pavolmarko@480: if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ByVal) && pavolmarko@480: (pi.flags & PassInfo::PassFlag_ODtor)) pavolmarko@480: { pavolmarko@480: pi.flags |= PassFlag_ForcedByRef; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: #endif pavolmarko@480: } pavolmarko@480: pavolmarko@480: HookManagerPubFunc GenContext::Generate() pavolmarko@480: { pavolmarko@480: Clear(); pavolmarko@480: pavolmarko@480: // Check conditions: pavolmarko@480: // -1) good proto version pavolmarko@480: // 0) we don't support unknown passtypes, convention, ... pavolmarko@480: // 1) we don't support functions which return objects by value or take parameters by value pavolmarko@480: // that have a constructor, a destructor or an overloaded assignment op pavolmarko@480: // (we wouldn't know how to call it!) pavolmarko@480: pavolmarko@480: if (m_Proto.GetVersion() < 1) pavolmarko@480: { pavolmarko@480: return NULL; pavolmarko@480: } pavolmarko@480: pavolmarko@480: AutoDetectRetType(); pavolmarko@480: AutoDetectParamFlags(); pavolmarko@480: pavolmarko@480: // Basically, we only support ThisCall/thiscall with varargs pavolmarko@480: if ((m_Proto.GetConvention() & (~ProtoInfo::CallConv_HasVafmt)) != ProtoInfo::CallConv_ThisCall) pavolmarko@480: { pavolmarko@480: return NULL; pavolmarko@480: } pavolmarko@480: pavolmarko@480: pavolmarko@480: if (m_Proto.GetRet().size != 0 && !PassInfoSupported(m_Proto.GetRet(), true)) pavolmarko@480: { pavolmarko@480: return NULL; pavolmarko@480: } pavolmarko@480: pavolmarko@480: for (int i = 0; i < m_Proto.GetNumOfParams(); ++i) pavolmarko@480: { pavolmarko@480: if (!PassInfoSupported(m_Proto.GetParam(i), false)) pavolmarko@480: return NULL; pavolmarko@480: } pavolmarko@480: pavolmarko@480: BuildProtoInfo(); pavolmarko@480: GenerateHookFunc(); pavolmarko@480: return fastdelegate::detail::horrible_cast(GeneratePubFunc()); pavolmarko@480: } pavolmarko@480: pavolmarko@480: HookManagerPubFunc GenContext::GetPubFunc() pavolmarko@480: { pavolmarko@480: if (m_GeneratedPubFunc == 0) pavolmarko@480: m_GeneratedPubFunc = Generate(); pavolmarko@480: pavolmarko@480: return m_GeneratedPubFunc; pavolmarko@480: } pavolmarko@480: pavolmarko@480: bool GenContext::Equal(const CProto &proto, int vtbl_offs, int vtbl_idx) pavolmarko@480: { pavolmarko@480: return (m_OrigProto.ExactlyEqual(proto) && m_VtblOffs == vtbl_offs && m_VtblIdx == vtbl_idx); pavolmarko@480: } pavolmarko@480: pavolmarko@480: bool GenContext::Equal(HookManagerPubFunc other) pavolmarko@480: { pavolmarko@480: return m_GeneratedPubFunc == other; pavolmarko@480: } pavolmarko@480: pavolmarko@480: // *********************************** class GenContextContainer pavolmarko@480: CHookManagerAutoGen::CHookManagerAutoGen(ISourceHook *pSHPtr) : m_pSHPtr(pSHPtr) pavolmarko@480: { pavolmarko@480: } pavolmarko@480: pavolmarko@480: CHookManagerAutoGen::~CHookManagerAutoGen() pavolmarko@480: { pavolmarko@480: for (List::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter) pavolmarko@480: { pavolmarko@480: delete iter->m_GenContext; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: int CHookManagerAutoGen::GetIfaceVersion() pavolmarko@480: { pavolmarko@480: return SH_HOOKMANAUTOGEN_IFACE_VERSION; pavolmarko@480: } pavolmarko@480: pavolmarko@480: int CHookManagerAutoGen::GetImplVersion() pavolmarko@480: { pavolmarko@480: return SH_HOOKMANAUTOGEN_IMPL_VERSION; pavolmarko@480: } pavolmarko@480: pavolmarko@480: HookManagerPubFunc CHookManagerAutoGen::MakeHookMan(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx) pavolmarko@480: { pavolmarko@480: CProto mproto(proto); pavolmarko@480: for (List::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter) pavolmarko@480: { pavolmarko@480: if (iter->m_GenContext->Equal(mproto, vtbl_offs, vtbl_idx)) pavolmarko@480: { pavolmarko@480: iter->m_RefCnt++; pavolmarko@480: return iter->m_GenContext->GetPubFunc(); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: // Not found yet -> new one pavolmarko@480: StoredContext sctx; pavolmarko@480: sctx.m_RefCnt = 1; pavolmarko@480: sctx.m_GenContext = new GenContext(proto, vtbl_offs, vtbl_idx, m_pSHPtr); pavolmarko@480: pavolmarko@480: if (sctx.m_GenContext->GetPubFunc() == NULL) pavolmarko@480: { pavolmarko@480: return NULL; pavolmarko@480: } pavolmarko@480: else pavolmarko@480: { pavolmarko@480: m_Contexts.push_back(sctx); pavolmarko@480: return sctx.m_GenContext->GetPubFunc(); pavolmarko@480: } pavolmarko@480: } pavolmarko@480: pavolmarko@480: void CHookManagerAutoGen::ReleaseHookMan(HookManagerPubFunc pubFunc) pavolmarko@480: { pavolmarko@480: for (List::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter) pavolmarko@480: { pavolmarko@480: if (iter->m_GenContext->Equal(pubFunc)) pavolmarko@480: { pavolmarko@480: iter->m_RefCnt--; pavolmarko@480: if (iter->m_RefCnt == 0) pavolmarko@480: { pavolmarko@480: delete iter->m_GenContext; pavolmarko@480: m_Contexts.erase(iter); pavolmarko@480: } pavolmarko@480: break; pavolmarko@480: } pavolmarko@480: } pavolmarko@480: } pavolmarko@480: } pavolmarko@480: }