1 /* ======== SourceHook ========
2 * Copyright (C) 2004-2007 Metamod:Source Development Team
3 * No warranties of any kind
7 * Author(s): Pavol "PM OnoTo" Marko
8 * Contributor(s): Borja "faluco" Ferav (many thanks for assitance!)
9 * David "BAILOPAN" Anderson
10 * ============================
13 // recommended literature:
14 // http://www.cs.umbc.edu/~chang/cs313.s02/stack.shtml
15 // http://www.angelcode.com/dev/callconv/callconv.html
16 // http://www.arl.wustl.edu/~lockwood/class/cs306/books/artofasm/Chapter_6/CH06-1.html
18 #include "sourcehook_impl.h"
19 #include "sourcehook_hookmangen.h"
20 #include "sourcehook_hookmangen_x86.h"
21 #include "sh_memory.h"
23 #if SH_COMP == SH_COMP_MSVC
25 # define MSVC_ONLY(x) x
26 #elif SH_COMP == SH_COMP_GCC
27 # define GCC_ONLY(x) x
31 // :TODO: test BIG vtable indices
37 CPageAlloc GenBuffer::ms_Allocator;
40 jit_int32_t DownCastPtr(T ptr)
42 return reinterpret_cast<jit_int32_t>(ptr);
45 jit_uint32_t DownCastSize(size_t size)
47 return static_cast<jit_uint32_t>(size);
50 GenContext::GenContext(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx, ISourceHook *pSHPtr)
51 : m_GeneratedPubFunc(NULL), m_Proto(proto), m_VtblOffs(vtbl_offs), m_VtblIdx(vtbl_idx), m_SHPtr(pSHPtr),
52 m_pHI(NULL), m_HookfuncVfnptr(NULL), m_RegCounter(0)
55 m_HookfuncVfnptr = new void*;
56 m_BuiltPI = new ProtoInfo;
57 m_BuiltPI_Params = NULL;
58 m_BuiltPI_Params2 = NULL;
61 GenContext::~GenContext()
65 delete m_HookfuncVfnptr;
69 void GenContext::Clear()
75 delete m_BuiltPI_Params;
76 m_BuiltPI_Params = NULL;
78 if (m_BuiltPI_Params2)
80 delete m_BuiltPI_Params2;
81 m_BuiltPI_Params2 = NULL;
85 void GenContext::BuildProtoInfo()
87 m_BuiltPI->convention = m_Proto.GetConvention();
88 m_BuiltPI->numOfParams = m_Proto.GetNumOfParams();
90 m_BuiltPI->retPassInfo.size = m_Proto.GetRet().size;
91 m_BuiltPI->retPassInfo.type = m_Proto.GetRet().type;
92 m_BuiltPI->retPassInfo.flags = m_Proto.GetRet().flags;
93 m_BuiltPI->retPassInfo2.pNormalCtor = m_Proto.GetRet().pNormalCtor;
94 m_BuiltPI->retPassInfo2.pCopyCtor = m_Proto.GetRet().pCopyCtor;
95 m_BuiltPI->retPassInfo2.pDtor = m_Proto.GetRet().pDtor;
96 m_BuiltPI->retPassInfo2.pAssignOperator = m_Proto.GetRet().pAssignOperator;
99 delete m_BuiltPI_Params;
100 m_BuiltPI_Params = new PassInfo[m_BuiltPI->numOfParams + 1];
101 if (m_BuiltPI_Params2)
102 delete m_BuiltPI_Params2;
103 m_BuiltPI_Params2 = new PassInfo::V2Info[m_BuiltPI->numOfParams + 1];
105 m_BuiltPI_Params[0].size = 1; // Version 1
106 m_BuiltPI_Params[0].type = 0;
107 m_BuiltPI_Params[0].flags = 0;
109 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
111 m_BuiltPI_Params[i+1].size = m_Proto.GetParam(i).size;
112 m_BuiltPI_Params[i+1].type = m_Proto.GetParam(i).type;
113 m_BuiltPI_Params[i+1].flags = m_Proto.GetParam(i).flags;
115 m_BuiltPI_Params2[i+1].pNormalCtor = m_Proto.GetParam(i).pNormalCtor;
116 m_BuiltPI_Params2[i+1].pCopyCtor = m_Proto.GetParam(i).pCopyCtor;
117 m_BuiltPI_Params2[i+1].pDtor = m_Proto.GetParam(i).pDtor;
118 m_BuiltPI_Params2[i+1].pAssignOperator = m_Proto.GetParam(i).pAssignOperator;
121 m_BuiltPI->paramsPassInfo = m_BuiltPI_Params;
122 m_BuiltPI->paramsPassInfo2 = m_BuiltPI_Params2;
125 jit_int32_t GenContext::GetRealSize(const IntPassInfo &info)
127 if (info.flags & PassInfo::PassFlag_ByRef)
131 return static_cast<jit_int32_t>(info.size);
134 // Computes size on the stack
135 jit_int32_t GenContext::GetStackSize(const IntPassInfo &info)
137 // Align up to 4 byte boundaries
138 jit_int32_t rs = GetRealSize(info);
140 rs = (rs & ~(3)) + 4;
144 jit_int8_t GenContext::NextRegEBX_ECX_EDX()
146 switch ((m_RegCounter++) % 3)
159 void GenContext::BitwiseCopy_Setup()
165 IA32_Cld(&m_HookFunc);
166 IA32_Push_Reg(&m_HookFunc, REG_EDI);
167 IA32_Push_Reg(&m_HookFunc, REG_ESI);
170 void GenContext::BitwiseCopy_Do(size_t size)
172 jit_uint32_t dwords = DownCastSize(size) / 4;
173 jit_uint32_t bytes = DownCastSize(size) % 4;
186 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, dwords);
187 IA32_Rep(&m_HookFunc);
188 IA32_Movsd(&m_HookFunc);
192 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, bytes);
193 IA32_Rep(&m_HookFunc);
194 IA32_Movsb(&m_HookFunc);
196 IA32_Pop_Reg(&m_HookFunc, REG_ESI);
197 IA32_Pop_Reg(&m_HookFunc, REG_EDI);
200 short GenContext::GetParamsStackSize()
203 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
205 acc += GetStackSize(m_Proto.GetParam(i));
208 // Memory return: address is first param
209 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
212 // :TODO: cdecl: THIS POINTER AS FIRST PARAM!!!
217 short GenContext::GetForcedByRefParamOffset(int p)
220 for (int i = 0; i < p; ++i)
222 if (m_Proto.GetParam(i).flags & PassFlag_ForcedByRef)
223 off += GetStackSize(m_Proto.GetParam(i));
228 short GenContext::GetForcedByRefParamsSize()
230 return GetForcedByRefParamOffset(m_Proto.GetNumOfParams());
233 jit_int32_t GenContext::PushRef(jit_int32_t param_offset, const IntPassInfo &pi)
235 // push [ebp+<offset>]
236 IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_offset);
241 jit_int32_t GenContext::PushBasic(jit_int32_t param_offset, const IntPassInfo &pi)
249 SH_ASSERT(0, ("Unsupported!"));
252 reg = NextRegEBX_ECX_EDX();
253 //movzx reg, BYTE PTR [ebp+<offset>]
255 IA32_Movzx_Reg32_Rm8_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
256 IA32_Push_Reg(&m_HookFunc, reg);
260 reg = NextRegEBX_ECX_EDX();
261 //movzx reg, WORD PTR [ebp+<offset>]
263 m_HookFunc.write_ubyte(IA32_16BIT_PREFIX);
264 IA32_Movzx_Reg32_Rm16_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
265 IA32_Push_Reg(&m_HookFunc, reg);
269 reg = NextRegEBX_ECX_EDX();
270 //mov reg, DWORD PTR [ebp+<offset>]
272 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
273 IA32_Push_Reg(&m_HookFunc, reg);
277 reg = NextRegEBX_ECX_EDX();
278 reg2 = NextRegEBX_ECX_EDX();
279 //mov reg, DWORD PTR [ebp+<offset>+4]
280 //mov reg2, DWORD PTR [ebp+<offset>]
284 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset+4);
285 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg2, REG_EBP, param_offset);
286 IA32_Push_Reg(&m_HookFunc, reg);
287 IA32_Push_Reg(&m_HookFunc, reg2);
293 jit_int32_t GenContext::PushFloat(jit_int32_t param_offset, const IntPassInfo &pi)
298 SH_ASSERT(0, ("Unsupported!"));
301 //fld DWORD PTR [ebp+<offset>]
303 //fstp DWORD PTR [esp]
304 IA32_Fld_Mem32_DispAuto(&m_HookFunc, REG_EBP, param_offset);
305 IA32_Push_Reg(&m_HookFunc, NextRegEBX_ECX_EDX());
306 IA32_Fstp_Mem32_ESP(&m_HookFunc);
309 //fld QWORD PTR [ebp+<offset>]
311 //fstp QWORD PTR [esp]
312 IA32_Fld_Mem64_DispAuto(&m_HookFunc, REG_EBP, param_offset);
313 IA32_Sub_Rm_Imm8(&m_HookFunc, REG_ESP, 8, MOD_REG);
314 IA32_Fstp_Mem64_ESP(&m_HookFunc);
319 jit_int32_t GenContext::PushObject(jit_int32_t param_offset, const IntPassInfo &pi, jit_int32_t place_fbrr)
321 if ((pi.flags & PassFlag_ForcedByRef) == 0)
323 // make room on the stack
325 IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, GetStackSize(pi), MOD_REG);
328 // if there is a copy constructor..
333 // this= target addr = forcedbyref ? ebp+place_fbrr : esp+12
334 // call copy constructor
337 IA32_Push_Reg(&m_HookFunc, REG_EAX);
339 if (pi.flags & PassFlag_ForcedByRef)
340 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
342 IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_ECX, REG_NOIDX, REG_ESP, NOSCALE, 4);
344 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_offset);
345 IA32_Push_Reg(&m_HookFunc, REG_EAX);
346 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
347 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(pi.pCopyCtor));
348 IA32_Call_Reg(&m_HookFunc, REG_EDX);
349 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
350 IA32_Pop_Reg(&m_HookFunc, REG_EAX);
360 // lea edi, [ebp_place_fbrr]
362 // lea edi, [esp+8] - bc_setup pushed two regs onto the stack!
363 //lea esi, [ebp+<offs>]
364 if (pi.flags & PassFlag_ForcedByRef)
365 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, place_fbrr);
367 IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_EDI, REG_NOIDX, REG_ESP, NOSCALE, 8);
369 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, param_offset);
371 BitwiseCopy_Do(pi.size);
374 // forcedref: push reference to ebp+place_fbrr
375 if (pi.flags & PassFlag_ForcedByRef)
377 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
378 IA32_Push_Reg(&m_HookFunc, REG_ECX);
382 return DownCastSize(pi.size);
385 void GenContext::DestroyParams(jit_int32_t fbrr_base)
387 for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
389 const IntPassInfo &pi = m_Proto.GetParam(i);
390 if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
391 (pi.flags & PassInfo::PassFlag_ByVal) && (pi.flags & PassFlag_ForcedByRef))
393 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, fbrr_base + GetForcedByRefParamOffset(i));
394 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
395 IA32_Call_Reg(&m_HookFunc, REG_EAX);
400 // May not touch eax!
401 jit_int32_t GenContext::PushParams(jit_int32_t param_base_offset, jit_int32_t save_ret_to, int v_place_for_memret,
402 jit_int32_t v_place_fbrr_base)
404 jit_int32_t added_to_stack = 0;
407 // compute the offset _after_ the last parameter
408 jit_int32_t cur_offset = param_base_offset;
409 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
411 cur_offset += GetStackSize(m_Proto.GetParam(i));
414 // push parameters in reverse order
415 for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
417 const IntPassInfo &pi = m_Proto.GetParam(i);
418 cur_offset -= GetStackSize(pi);
419 if (pi.flags & PassInfo::PassFlag_ByVal)
423 case PassInfo::PassType_Basic:
424 ret = PushBasic(cur_offset, pi);
426 case PassInfo::PassType_Float:
427 ret = PushFloat(cur_offset, pi);
429 case PassInfo::PassType_Object:
430 ret = PushObject(cur_offset, pi, v_place_fbrr_base + GetForcedByRefParamOffset(i));
434 else if (pi.flags & PassInfo::PassFlag_ByRef)
436 PushRef(cur_offset, pi);
440 SH_ASSERT(0, ("Unsupported!"));
442 added_to_stack += ret;
445 return added_to_stack;
448 // It is IMPORTANT that PushMemRetPtr doesn't touch ecx and eax
449 jit_int32_t GenContext::PushMemRetPtr(jit_int32_t save_ret_to, jit_int32_t v_place_for_memret)
451 // Memory return support
452 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
454 // push address where to save it!
456 IA32_Lea_DispRegImmAuto(&m_HookFunc, reg, REG_EBP,
457 MemRetWithTempObj() ? v_place_for_memret : save_ret_to);
458 IA32_Push_Reg(&m_HookFunc, reg);
460 return (SH_COMP==SH_COMP_MSVC) ? 4 : 0; // varargs funcs on msvc might need this.
461 // gcc doesn't: callee cleans the memret ptr, caller the other params :s
466 void GenContext::SaveRetVal(int v_where, int v_place_for_memret)
468 size_t size = GetRealSize(m_Proto.GetRet());
471 // No return value -> nothing
475 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
477 // mov [ebp + v_plugin_ret], eax
478 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
485 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
487 if (MemRetWithTempObj())
489 // *v_where = *v_place_for_memret
491 // if we have an assign operator, use that
492 if (m_Proto.GetRet().pAssignOperator)
494 // lea edx, [ebp + v_place_for_memret] <-- src addr
495 // lea ecx, [ebp + v_where] <-- dest addr
501 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_place_for_memret);
502 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_where);
503 IA32_Push_Reg(&m_HookFunc, REG_EDX);
504 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
506 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
507 IA32_Call_Reg(&m_HookFunc, REG_EAX);
508 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
515 //lea edi, [evp+v_where] <-- destination
516 //lea esi, [ebp+v_place_for_memret] <-- src
517 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_where);
518 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_place_for_memret);
520 BitwiseCopy_Do(m_Proto.GetRet().size);
523 // Then: destruct *v_place_for_memret if required
524 if (m_Proto.GetRet().pDtor)
526 //lea ecx, [ebp+v_place_for_memret]
531 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_place_for_memret);
532 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
533 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
534 IA32_Call_Reg(&m_HookFunc, REG_EAX);
535 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
540 // Already copied to correct address -> we're done
545 if (m_Proto.GetRet().type == PassInfo::PassType_Float)
548 IA32_Fstp_Mem32_DispAuto(&m_HookFunc, REG_EBP, v_where);
550 IA32_Fstp_Mem64_DispAuto(&m_HookFunc, REG_EBP, v_where);
552 else if (m_Proto.GetRet().type == PassInfo::PassType_Basic)
556 // size <= 4: return in EAX
557 // We align <4 sizes up to 4
560 // mov [ebp + v_plugin_ret], eax
561 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
565 // size <= 4: return in EAX:EDX
566 // We align 4<x<8 sizes up to 8
568 // mov [ebp + v_plugin_ret], eax
569 // mov [ebp + v_plugin_ret + 4], edx
570 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
571 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
574 else if (m_Proto.GetRet().type == PassInfo::PassType_Object)
576 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)
580 // size <= 4: return in EAX
581 // We align <4 sizes up to 4
583 // mov [ebp + v_plugin_ret], eax
584 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
588 // size <= 4: return in EAX:EDX
589 // We align 4<x<8 sizes up to 8
591 // mov [ebp + v_plugin_ret], eax
592 // mov [ebp + v_plugin_ret + 4], edx
593 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
594 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
598 SH_ASSERT(0, ("RetReg and size > 8 !"));
604 bool GenContext::MemRetWithTempObj()
606 // Memory return AND (has destructor OR has assign operator)
607 return ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
608 && (m_Proto.GetRet().flags & (PassInfo::PassFlag_ODtor | PassInfo::PassFlag_AssignOp)));
611 void GenContext::ProcessPluginRetVal(int v_cur_res, int v_pContext, int v_plugin_ret)
613 // only for non-void functions!
614 if (m_Proto.GetRet().size == 0)
617 // if (cur_res >= MRES_OVERRIDE)
618 // *reinterpret_cast<my_rettype*>(pContext->GetOverrideRetPtr()) = plugin_ret;
621 // cmp eax,MRES_OVERRIDE
623 // pContext->GetOverrideRetPtr() --> overrideretptr in eax
628 jitoffs_t tmppos, counter;
630 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
632 IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_OVERRIDE);
633 tmppos = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NGE, 0);
634 m_HookFunc.start_count(counter);
636 // eax = pContext->GetOverrideRetPtr()
643 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
644 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
646 // vtbloffs=0, vtblidx=1
647 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
648 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 4);
649 IA32_Call_Reg(&m_HookFunc, REG_EAX);
650 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
654 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
656 // mov ecx, [ebp+v_plugin_ret]
658 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
659 IA32_Mov_Rm_Reg(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
663 if (m_Proto.GetRet().pAssignOperator)
665 // lea edx, [ebp + v_plugin_ret]
666 // push edx <-- src addr
667 // msvc: ecx = eax <-- dest addr
668 // gcc: push eax <-- dest addr
672 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_plugin_ret);
673 IA32_Push_Reg(&m_HookFunc, REG_EDX);
674 #if SH_COMP == SH_COMP_MSVC
675 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
676 #elif SH_COMP == SH_COMP_GCC
677 IA32_Push_Reg(&m_HookFunc, REG_EAX);
680 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
681 IA32_Call_Reg(&m_HookFunc, REG_EAX);
682 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
689 //mov edi, eax <-- destination
690 //lea esi, [ebp+v_plugin_ret] <-- src
691 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDI, REG_EAX, MOD_REG);
692 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_plugin_ret);
694 BitwiseCopy_Do(m_Proto.GetRet().size);
698 m_HookFunc.end_count(counter);
699 m_HookFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
702 void GenContext::PrepareReturn(int v_status, int v_pContext, int v_retptr)
704 // only for non-void functions!
705 if (m_Proto.GetRet().size == 0)
708 // retptr = status >= MRES_OVERRIDE ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()
710 // OverrideRetPtr: vtblidx = 1
711 // OrigRetPtr: vtbldix = 2
712 // vtblidx = (status >= MRES_OVERRIDE) ? 1 : 2
715 // eax = pContext->GetOverrideRetPtr()
719 // eax = (status < MRES_OVERRIDE) ? 1 : 0
721 // cmp [ebp + v_status], MRES_OVERRIDE
722 // setl al <-- setcc optimization for ternary operators,
725 // lea eax, [4*eax + 0x4]
734 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
735 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
736 IA32_Xor_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
737 IA32_Cmp_Rm_Disp8_Imm8(&m_HookFunc, REG_EBP, v_status, MRES_OVERRIDE);
738 IA32_SetCC_Rm8(&m_HookFunc, REG_EAX, CC_L);
740 IA32_Lea_Reg_RegMultImm32(&m_HookFunc, REG_EAX, REG_EAX, SCALE4, 4);
742 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
743 IA32_Add_Reg_Rm(&m_HookFunc, REG_EDX, REG_EAX, MOD_REG);
745 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_MEM_REG);
746 IA32_Call_Reg(&m_HookFunc, REG_EDX);
747 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
749 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_retptr);
752 void GenContext::DoReturn(int v_retptr, int v_memret_outaddr)
754 size_t size = m_Proto.GetRet().size;
758 // Get real ret pointer into ecx
759 // mov ecx, [ebp + v_ret_ptr]
760 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_retptr);
762 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
765 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
770 if (m_Proto.GetRet().type == PassInfo::PassType_Float)
773 IA32_Fld_Mem32(&m_HookFunc, REG_ECX);
775 IA32_Fld_Mem64(&m_HookFunc, REG_ECX);
777 else if (m_Proto.GetRet().type == PassInfo::PassType_Basic ||
778 ((m_Proto.GetRet().type == PassInfo::PassType_Object) && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)) )
782 // size <= 4: return in EAX
783 // We align <4 sizes up to 4
786 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
790 // size <= 4: return in EAX:EDX
791 // We align 4<x<8 sizes up to 8
795 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
796 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, 4);
800 // size >8: return in memory
805 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
807 // *memret_outaddr = plugin_ret
808 if (m_Proto.GetRet().pCopyCtor)
810 // mov edx, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
811 // push edx <-- src addr
812 // msvc: ecx = [ebp + v_memret_outaddr] <-- dest addr
813 // gcc: push [ebp + v_memret_outaddr] <-- dest addr
817 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_REG);
818 IA32_Push_Reg(&m_HookFunc, REG_EDX);
820 #if SH_COMP == SH_COMP_MSVC
821 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_memret_outaddr);
822 #elif SH_COMP == SH_COMP_GCC
823 IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, v_memret_outaddr);
826 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pCopyCtor));
827 IA32_Call_Reg(&m_HookFunc, REG_EAX);
828 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
835 //mov edi, [ebp+v_memret_outaddr] <-- destination
836 //mov esi, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
837 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDI, REG_EBP, v_memret_outaddr);
838 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESI, REG_ECX, MOD_REG);
840 BitwiseCopy_Do(m_Proto.GetRet().size);
843 // In both cases: return the pointer in EAX
844 // mov eax, [ebp + v_memret_outaddr]
845 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_memret_outaddr);
849 void GenContext::GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter,
850 int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base)
852 jitoffs_t counter, tmppos;
853 jitoffs_t counter2, tmppos2;
855 jitoffs_t loop_begin_counter;
857 // prev_res = MRES_IGNORED
858 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_prev_res);
860 m_HookFunc.start_count(loop_begin_counter);
862 // eax = pContext->GetNext()
869 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
870 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
872 // vtbloffs=0, vtblidx=0
873 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
874 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_MEM_REG);
875 IA32_Call_Reg(&m_HookFunc, REG_EAX);
876 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
881 IA32_Test_Rm_Reg(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
882 tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
883 m_HookFunc.start_count(counter);
885 // prev_res = MRES_IGNORED
886 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_cur_res);
893 // eax = [eax+2*SIZE_PTR]
897 jit_int32_t gcc_clean_bytes = PushParams(base_param_offset, v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
899 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
900 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
901 gcc_clean_bytes += PushMemRetPtr(v_plugin_ret, v_place_for_memret);
902 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
903 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 2*SIZE_PTR);
904 IA32_Call_Reg(&m_HookFunc, REG_EAX);
906 DestroyParams(v_place_fbrr_base);
908 SaveRetVal(v_plugin_ret, v_place_for_memret);
911 #if SH_COMP == SH_COMP_GCC
912 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, gcc_clean_bytes + SIZE_PTR, MOD_REG);
917 // process meta return:
918 // prev_res = cur_res
919 // if (cur_res > status) status = cur_res;
929 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
930 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDX, REG_EBP, v_status);
931 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_prev_res);
933 IA32_Cmp_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_REG);
934 tmppos2 = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NG, 0);
935 m_HookFunc.start_count(counter2);
937 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_status);
939 m_HookFunc.end_count(counter2);
940 m_HookFunc.rewrite(tmppos2, static_cast<jit_uint8_t>(counter2));
942 // process retval for non-void functions
943 ProcessPluginRetVal(v_cur_res, v_pContext, v_plugin_ret);
945 // jump back to loop begin
946 tmppos2 = IA32_Jump_Imm32(&m_HookFunc, 0);
947 m_HookFunc.end_count(loop_begin_counter);
948 m_HookFunc.rewrite(tmppos2, -static_cast<jit_int32_t>(loop_begin_counter));
950 m_HookFunc.end_count(counter);
951 m_HookFunc.rewrite(tmppos, static_cast<jit_int32_t>(counter));
954 void GenContext::GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this,
955 int v_vfnptr_origentry, int v_orig_ret, int v_override_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base)
957 jitoffs_t counter, tmppos;
958 jitoffs_t counter2, tmppos2;
959 jitoffs_t counter3, tmppos3;
961 // if (status != MRES_SUPERCEDE && pConteext->ShouldCallOrig())
962 // *v_orig_ret = orig_call()
964 // *v_orig_ret = *v_override_ret
967 // cmp eax, MRES_SUPERCEDE
969 // call pContext->ShouldCallOrig()
970 // test al, al !! important: al, not eax! bool is only stored in the LSbyte
974 // SaveRet(v_orig_ret)
975 // jmp skip_dont_call:
978 // *v_orig_ret = *v_override_ret
981 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_status);
982 IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_SUPERCEDE);
984 tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_E, 0);
985 m_HookFunc.start_count(counter);
987 // eax = pContext->ShouldCallOrig()
991 // eax = [eax + 3*PTR_SIZE]
994 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
995 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
997 // vtbloffs=0, vtblidx=3
998 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
999 IA32_Mov_Reg_Rm_Disp8(&m_HookFunc, REG_EAX, REG_EAX, 3*SIZE_PTR);
1000 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1001 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1003 IA32_Test_Rm_Reg8(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
1004 tmppos2 = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
1005 m_HookFunc.start_count(counter2);
1008 jit_int32_t gcc_clean_bytes = PushParams(param_base_offs, v_orig_ret, v_place_for_memret, v_place_fbrr_base);
1011 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this);
1012 #if SH_COMP == SH_COMP_GCC
1013 // on gcc/mingw, this is the first parameter
1014 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1015 // on msvc, simply leave it in ecx
1017 gcc_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret);
1020 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_vfnptr_origentry);
1021 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1024 #if SH_COMP == SH_COMP_GCC
1025 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, gcc_clean_bytes + SIZE_PTR, MOD_REG);
1028 DestroyParams(v_place_fbrr_base);
1031 SaveRetVal(v_orig_ret, v_place_for_memret);
1033 // Skip don't call variant
1034 tmppos3 = IA32_Jump_Imm32(&m_HookFunc, 0);
1035 m_HookFunc.start_count(counter3);
1039 m_HookFunc.end_count(counter);
1040 m_HookFunc.rewrite(tmppos, static_cast<jit_uint32_t>(counter));
1042 m_HookFunc.end_count(counter2);
1043 m_HookFunc.rewrite(tmppos2, static_cast<jit_uint32_t>(counter2));
1045 // *v_orig_ret = *v_override_ret
1046 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
1048 // mov ecx, [ebp + v_override_ret]
1049 // mov [ebp + v_orig_ret], ecx
1051 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1052 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_ECX, v_orig_ret);
1056 if (m_Proto.GetRet().pAssignOperator)
1058 // lea edx, [ebp + v_override_ret] <-- src addr
1059 // lea ecx, [ebp + v_orig_ret] <-- dest addr
1060 // push edx <-- src addr
1065 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_override_ret);
1066 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1067 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1068 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1070 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
1071 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1072 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
1077 BitwiseCopy_Setup();
1079 //lea edi, [ebp+v_orig_ret] <-- destination
1080 //lea esi, [ebp+v_override_ret] <-- src
1081 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_orig_ret);
1082 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_override_ret);
1084 BitwiseCopy_Do(m_Proto.GetRet().size);
1088 // skip don't call label target:
1089 m_HookFunc.end_count(counter3);
1090 m_HookFunc.rewrite(tmppos3, static_cast<jit_uint32_t>(counter3));
1093 // Sets *v_pContext to return value
1094 void GenContext::CallSetupHookLoop(int v_orig_ret, int v_override_ret,
1095 int v_cur_res, int v_prev_res, int v_status, int v_vfnptr_origentry,
1096 int v_this, int v_pContext)
1098 // call shptr->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this),
1099 // &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret);
1100 // The last two params are null for void funcs.
1102 if (m_Proto.GetRet().size == 0)
1105 IA32_Push_Imm8(&m_HookFunc, 0); // orig_ret
1106 IA32_Push_Imm8(&m_HookFunc, 0); // override_ret
1110 // orig_ret and override_ret
1111 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, v_override_ret);
1112 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_orig_ret);
1113 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1114 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1117 // cur_res and prev_res
1118 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
1119 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_prev_res);
1120 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1121 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1123 // status and vfnptr_origentry
1124 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_status);
1125 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_vfnptr_origentry);
1126 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1127 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1130 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_this);
1131 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1134 // *(this + vtbloffs) + SIZE_PTR*vtblidx
1135 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this); // get this into ecx (gcc!)
1136 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, m_VtblOffs);
1137 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_EAX, m_VtblIdx * SIZE_PTR, MOD_REG);
1138 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1141 IA32_Mov_Rm_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1142 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1143 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1146 #if SH_COMP == SH_COMP_GCC
1147 // on gcc/mingw, this is the first parameter
1148 GCC_ONLY(IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr)));
1149 #elif SH_COMP == SH_COMP_MSVC
1150 // on msvc, it's ecx
1151 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1154 // call the function. vtbloffs = 0, vtblidx = 19
1155 // get vtptr into edx -- we know shptr on jit time -> dereference it here!
1156 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX,
1157 (*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[19]);
1159 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1161 // on gcc/mingw, we have to clean up after the call
1162 // 9 params + hidden thisptr param
1163 GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 10*SIZE_PTR, MOD_REG));
1165 // store return value
1166 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_pContext);
1169 void GenContext::CallEndContext(int v_pContext)
1172 // shptr->EndContext(pContex)
1173 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_pContext);
1174 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1177 #if SH_COMP == SH_COMP_GCC
1178 // on gcc/mingw, this is the first parameter
1179 IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr));
1180 #elif SH_COMP == SH_COMP_MSVC
1181 // on msvc, it's ecx
1182 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1185 // get vtptr into edx -- we know shptr on jit time -> dereference it here!
1186 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX,
1187 (*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[20]);
1189 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1191 // on gcc/mingw, we have to clean up after the call
1192 // 1 param + hidden thisptr param
1193 GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
1196 void * GenContext::GenerateHookFunc()
1199 IA32_Push_Reg(&m_HookFunc, REG_EBP);
1200 IA32_Push_Reg(&m_HookFunc, REG_EBX);
1201 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EBP, REG_ESP, MOD_REG);
1203 // on msvc, save thisptr
1204 #if SH_COMP == SH_COMP_MSVC
1205 jit_int8_t v_this = -4;
1206 const int addstackoffset = -4;
1207 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1208 #elif SH_COMP == SH_COMP_GCC
1209 jit_int8_t v_this = 12; // first param
1210 const int addstackoffset = 0;
1214 // ********************** stack frame **********************
1216 // second param (gcc: first real param) ebp + 16
1217 // first param (gcc: thisptr) ebp + 12
1218 // ret address: ebp + 8
1219 // caller's ebp ebp + 4
1221 // MSVC ONLY: current this ebp - 4
1222 // void *vfnptr_origentry ebp - 4 -4
1223 // META_RES status = MRES_IGNORED ebp - 8 -4
1224 // META_RES prev_res ebp - 12 -4
1225 // META_RES cur_res ebp - 16 -4
1226 // IMyDelegate *iter ebp - 20 -4
1227 // IHookContext *pContext ebp - 24 -4
1228 // == 3 ptrs + 3 enums = 24 bytes
1231 // my_rettype *ret_ptr ebp - 28 -4
1232 // my_rettype orig_ret ebp - 28 - sizeof(my_rettype) -4
1233 // my_rettype override_ret ebp - 28 - sizeof(my_rettype)*2 -4
1234 // my_rettype plugin_ret ebp - 28 - sizeof(my_rettype)*3 -4
1235 // == + 3 * sizeof(my_rettype) bytes
1238 // my_rettype place_for_memret ebp - 28 - sizeof(my_rettype)*4 -4
1240 // gcc only: if required:
1241 // place forced byref params ebp - 28 - sizeof(my_rettype)*{4 or 5}
1244 const jit_int8_t v_vfnptr_origentry = -4 + addstackoffset;
1245 const jit_int8_t v_status = -8 + addstackoffset;
1246 const jit_int8_t v_prev_res = -12 + addstackoffset;
1247 const jit_int8_t v_cur_res = -16 + addstackoffset;
1248 const jit_int8_t v_iter = -20 + addstackoffset;
1249 const jit_int8_t v_pContext = -24 + addstackoffset;
1251 #if SH_COMP == SH_COMP_GCC
1252 jit_int32_t param_base_offs = 16;
1253 #elif SH_COMP == SH_COMP_MSVC
1254 jit_int32_t param_base_offs = 12;
1257 // Memory return: first param is the address
1258 jit_int32_t v_memret_addr = 0;
1259 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1261 #if SH_COMP == SH_COMP_GCC
1262 // gcc: now: first param = mem ret addr
1263 // second param = this pointer
1264 // third param = actual first param
1267 param_base_offs += SIZE_PTR;
1268 #elif SH_COMP == SH_COMP_MSVC
1269 v_memret_addr = param_base_offs;
1270 param_base_offs += SIZE_PTR;
1274 jit_int32_t v_ret_ptr = -28 + addstackoffset;
1275 jit_int32_t v_orig_ret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 1;
1276 jit_int32_t v_override_ret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 2;
1277 jit_int32_t v_plugin_ret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 3;
1279 jit_int32_t v_place_for_memret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 4;
1281 jit_int32_t v_place_fbrr_base = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * (MemRetWithTempObj() ? 5 : 4);
1283 // Hash for temporary storage for byval params with copy constructors
1284 // (param, offset into stack)
1285 short usedStackBytes = 3*SIZE_MWORD + 3*SIZE_PTR // vfnptr_origentry, status, prev_res, cur_res, iter, pContext
1286 + 3 * GetStackSize(m_Proto.GetRet()) + (m_Proto.GetRet().size == 0 ? 0 : SIZE_PTR) // ret_ptr, orig_ret, override_ret, plugin_ret
1287 + (MemRetWithTempObj() ? GetStackSize(m_Proto.GetRet()) : 0)
1288 + GetForcedByRefParamsSize()
1289 - addstackoffset; // msvc: current thisptr
1291 IA32_Sub_Rm_Imm32(&m_HookFunc, REG_ESP, usedStackBytes, MOD_REG);
1293 // init status localvar
1294 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_status);
1296 // Call constructors for ret vars if required
1297 if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1298 m_Proto.GetRet().pNormalCtor)
1300 // :TODO: Gcc version
1303 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1304 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1305 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1306 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1307 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1310 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1311 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1312 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1313 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1314 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1317 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1318 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1319 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1320 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1321 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1323 // _don't_ call a constructor for v_place_for_memret !
1326 // ********************** SetupHookLoop **********************
1327 CallSetupHookLoop(v_orig_ret, v_override_ret, v_cur_res, v_prev_res, v_status, v_vfnptr_origentry,
1328 v_this, v_pContext);
1330 // ********************** call pre hooks **********************
1331 GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1332 v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
1334 // ********************** call orig func **********************
1335 GenerateCallOrig(v_status, v_pContext, param_base_offs, v_this, v_vfnptr_origentry, v_orig_ret,
1336 v_override_ret, v_place_for_memret, v_place_fbrr_base);
1338 // ********************** call post hooks **********************
1339 GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1340 v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
1342 // ********************** end context and return **********************
1344 PrepareReturn(v_status, v_pContext, v_ret_ptr);
1346 CallEndContext(v_pContext);
1348 // Call destructors of byval object params which have a destructor
1349 jit_int32_t cur_param_pos = param_base_offs;
1350 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1352 const IntPassInfo &pi = m_Proto.GetParam(i);
1353 // GCC: NOT of forced byref params. the caller destructs those.
1354 if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
1355 (pi.flags & PassInfo::PassFlag_ByVal) && !(pi.flags & PassFlag_ForcedByRef))
1357 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, cur_param_pos);
1358 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
1359 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1361 cur_param_pos += GetStackSize(pi);
1364 DoReturn(v_ret_ptr, v_memret_addr);
1366 // Call destructors of orig_ret/ ...
1367 if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1368 m_Proto.GetRet().pDtor)
1370 // Preserve return value in EAX(:EDX)
1371 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1372 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1374 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1375 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1376 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1377 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1378 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1380 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1381 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1382 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1383 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1384 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1386 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1387 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1388 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1389 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1390 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1392 IA32_Pop_Reg(&m_HookFunc, REG_EDX);
1393 IA32_Pop_Reg(&m_HookFunc, REG_EAX);
1397 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESP, REG_EBP, MOD_REG);
1398 IA32_Pop_Reg(&m_HookFunc, REG_EBX);
1399 IA32_Pop_Reg(&m_HookFunc, REG_EBP);
1400 MSVC_ONLY(IA32_Return_Popstack(&m_HookFunc, GetParamsStackSize()));
1401 // gcc: Remove 4 bytes from stack on memory return
1402 #if SH_COMP == SH_COMP_GCC
1403 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1404 IA32_Return_Popstack(&m_HookFunc, SIZE_PTR);
1406 IA32_Return(&m_HookFunc);
1409 // Store pointer for later use
1410 // m_HookfuncVfnPtr is a pointer to a void* because SH expects a pointer
1411 // into the hookman's vtable
1412 *m_HookfuncVfnptr = reinterpret_cast<void*>(m_HookFunc.GetData());
1416 return m_HookFunc.GetData();
1419 // Pre-condition: GenerateHookFunc() has been called!
1420 void * GenContext::GeneratePubFunc()
1422 jitoffs_t counter, tmppos;
1424 // The pubfunc is a static cdecl function.
1426 // int HookManPubFunc(
1427 // bool store, ebp + 8
1428 // IHookManagerInfo *hi ebp + 12
1434 // hi->SetInfo(HOOKMAN_VERSION, m_VtblOffs, m_VtblIdx, m_Proto.GetProto(), m_HookfuncVfnptr)
1438 IA32_Push_Reg(&m_PubFunc, REG_EBP);
1439 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EBP, REG_ESP, MOD_REG);
1442 // save store in eax, hi in ecx
1443 IA32_Movzx_Reg32_Rm8_Disp8(&m_PubFunc, REG_EAX, REG_EBP, 8);
1444 IA32_Mov_Reg_Rm_DispAuto(&m_PubFunc, REG_ECX, REG_EBP, 12);
1446 // Check for store == 0
1447 IA32_Test_Rm_Reg8(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1448 tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1449 m_PubFunc.start_count(counter);
1451 // nonzero -> store hi
1452 IA32_Mov_Rm_Imm32(&m_PubFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1453 IA32_Mov_Rm_Reg(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1456 m_PubFunc.end_count(counter);
1457 m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1459 // check for hi == 0
1460 IA32_Test_Rm_Reg(&m_PubFunc, REG_ECX, REG_ECX, MOD_REG);
1461 tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1462 m_PubFunc.start_count(counter);
1464 // nonzero -> call vfunc
1465 // push params in reverse order
1466 IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_HookfuncVfnptr));
1467 IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_BuiltPI));
1468 IA32_Push_Imm32(&m_PubFunc, m_VtblIdx);
1469 IA32_Push_Imm32(&m_PubFunc, m_VtblOffs);
1470 IA32_Push_Imm32(&m_PubFunc, SH_HOOKMAN_VERSION);
1472 // hi == this is in ecx
1473 // on gcc/mingw, ecx is the first parameter
1474 #if SH_COMP == SH_COMP_GCC
1475 IA32_Push_Reg(&m_PubFunc, REG_ECX);
1478 // call the function. vtbloffs = 0, vtblidx = 0
1479 // get vtptr into edx
1480 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1481 // get funcptr into eax
1482 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1484 IA32_Call_Reg(&m_PubFunc, REG_EAX);
1486 // on gcc/mingw, we have to clean up after the call
1487 #if SH_COMP == SH_COMP_GCC
1488 // 5 params + hidden thisptr param
1489 IA32_Add_Rm_Imm8(&m_PubFunc, REG_ESP, 6*SIZE_MWORD, MOD_REG);
1493 m_PubFunc.end_count(counter);
1494 m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1497 IA32_Xor_Reg_Rm(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1500 IA32_Mov_Reg_Rm(&m_PubFunc, REG_ESP, REG_EBP, MOD_REG);
1501 IA32_Pop_Reg(&m_PubFunc, REG_EBP);
1502 IA32_Return(&m_PubFunc);
1509 bool GenContext::PassInfoSupported(const IntPassInfo &pi, bool is_ret)
1511 // :TODO: Error returns
1512 if (pi.type != PassInfo::PassType_Basic &&
1513 pi.type != PassInfo::PassType_Float &&
1514 pi.type != PassInfo::PassType_Object)
1519 if (pi.type == PassInfo::PassType_Object &&
1520 (pi.flags & PassInfo::PassFlag_ByVal))
1522 if ((pi.flags & PassInfo::PassFlag_CCtor) && !pi.pCopyCtor)
1527 if ((pi.flags & PassInfo::PassFlag_ODtor) && !pi.pDtor)
1532 if ((pi.flags & PassInfo::PassFlag_AssignOp) && !pi.pAssignOperator)
1537 if ((pi.flags & PassInfo::PassFlag_OCtor) && !pi.pNormalCtor)
1543 if ((pi.flags & (PassInfo::PassFlag_ByVal | PassInfo::PassFlag_ByRef)) == 0)
1545 return false; // Neither byval nor byref!
1550 void GenContext::AutoDetectRetType()
1552 IntPassInfo &pi = m_Proto.GetRet();
1554 // Only relevant for byval types
1555 if (pi.flags & PassInfo::PassFlag_ByVal)
1558 if (pi.type == PassInfo::PassType_Basic ||
1559 pi.type == PassInfo::PassType_Float)
1562 // _always_ in registers, no matter what the user says
1565 pi.flags &= ~PassInfo::PassFlag_RetMem;
1566 pi.flags |= PassInfo::PassFlag_RetReg;
1570 // Does this even exist? No idea, if it does: in memory!
1571 pi.flags &= ~PassInfo::PassFlag_RetReg;
1572 pi.flags |= PassInfo::PassFlag_RetMem;
1576 else if (pi.type == PassInfo::PassType_Object)
1578 // If the user says nothing, auto-detect
1579 if ((pi.flags & (PassInfo::PassFlag_RetMem | PassInfo::PassFlag_RetReg)) == 0)
1581 #if SH_COMP == SH_COMP_MSVC
1582 // MSVC seems to return _all_ structs, classes, unions in memory
1583 pi.flags |= PassInfo::PassFlag_RetMem;
1584 #elif SH_COMP == SH_COMP_GCC
1585 // Same goes for GCC :)
1586 pi.flags |= PassInfo::PassFlag_RetMem;
1593 // byref: make sure that the flag is _not_ set
1594 pi.flags &= ~PassInfo::PassFlag_RetMem;
1595 pi.flags |= PassInfo::PassFlag_RetReg;
1599 void GenContext::AutoDetectParamFlags()
1601 #if SH_COMP == SH_COMP_GCC
1602 // On GCC, all objects are passed by reference if they have a destructor
1603 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1605 IntPassInfo &pi = m_Proto.GetParam(i);
1606 if (pi.type == PassInfo::PassType_Object &&
1607 (pi.flags & PassInfo::PassFlag_ODtor))
1609 pi.flags |= PassFlag_ForcedByRef;
1615 HookManagerPubFunc GenContext::Generate()
1619 // Check conditions:
1620 // -1) good proto version
1621 // 0) we don't support unknown passtypes, convention, ...
1622 // 1) we don't support functions which return objects by value or take parameters by value
1623 // that have a constructor, a destructor or an overloaded assignment op
1624 // (we wouldn't know how to call it!)
1626 if (m_Proto.GetVersion() < 1)
1631 AutoDetectRetType();
1632 AutoDetectParamFlags();
1634 // Basically, we only support ThisCall/thiscall with varargs
1635 if ((m_Proto.GetConvention() & (~ProtoInfo::CallConv_HasVafmt)) != ProtoInfo::CallConv_ThisCall)
1641 if (m_Proto.GetRet().size != 0 && !PassInfoSupported(m_Proto.GetRet(), true))
1646 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1648 if (!PassInfoSupported(m_Proto.GetParam(i), false))
1654 return fastdelegate::detail::horrible_cast<HookManagerPubFunc>(GeneratePubFunc());
1657 HookManagerPubFunc GenContext::GetPubFunc()
1659 if (m_GeneratedPubFunc == 0)
1660 m_GeneratedPubFunc = Generate();
1662 return m_GeneratedPubFunc;
1665 bool GenContext::Equal(const CProto &proto, int vtbl_offs, int vtbl_idx)
1667 return (m_Proto.ExactlyEqual(proto) && m_VtblOffs == vtbl_offs && m_VtblIdx == vtbl_idx);
1670 bool GenContext::Equal(HookManagerPubFunc other)
1672 return m_GeneratedPubFunc == other;
1675 // *********************************** class GenContextContainer
1676 CHookManagerAutoGen::CHookManagerAutoGen(ISourceHook *pSHPtr) : m_pSHPtr(pSHPtr)
1680 CHookManagerAutoGen::~CHookManagerAutoGen()
1682 for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1684 delete iter->m_GenContext;
1688 int CHookManagerAutoGen::GetIfaceVersion()
1690 return SH_HOOKMANAUTOGEN_IFACE_VERSION;
1693 int CHookManagerAutoGen::GetImplVersion()
1695 return SH_HOOKMANAUTOGEN_IMPL_VERSION;
1698 HookManagerPubFunc CHookManagerAutoGen::MakeHookMan(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx)
1700 CProto mproto(proto);
1701 for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1703 if (iter->m_GenContext->Equal(mproto, vtbl_offs, vtbl_idx))
1706 return iter->m_GenContext->GetPubFunc();
1710 // Not found yet -> new one
1713 sctx.m_GenContext = new GenContext(proto, vtbl_offs, vtbl_idx, m_pSHPtr);
1715 if (sctx.m_GenContext->GetPubFunc() == NULL)
1721 m_Contexts.push_back(sctx);
1722 return sctx.m_GenContext->GetPubFunc();
1726 void CHookManagerAutoGen::ReleaseHookMan(HookManagerPubFunc pubFunc)
1728 for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1730 if (iter->m_GenContext->Equal(pubFunc))
1733 if (iter->m_RefCnt == 0)
1735 delete iter->m_GenContext;
1736 m_Contexts.erase(iter);