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_hookmangen.h"
19 #include "sourcehook_hookmangen_x86.h"
20 #include "sh_memory.h"
22 // :TODO: test BIG vtable indices
28 CPageAlloc GenBuffer::ms_Allocator;
31 jit_int32_t DownCastPtr(T ptr)
33 return reinterpret_cast<jit_int32_t>(ptr);
36 jit_uint32_t DownCastSize(size_t size)
38 return static_cast<jit_uint32_t>(size);
41 GenContext::GenContext(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx, ISourceHook *pSHPtr)
42 : m_Proto(proto), m_VtblOffs(vtbl_offs), m_VtblIdx(vtbl_idx), m_SHPtr(pSHPtr),
43 m_pHI(NULL), m_HookfuncVfnptr(NULL), m_RegCounter(0)
46 m_HookfuncVfnptr = new void*;
47 m_BuiltPI = new ProtoInfo;
48 m_BuiltPI_Params = NULL;
49 m_BuiltPI_Params2 = NULL;
52 GenContext::~GenContext()
56 delete m_HookfuncVfnptr;
60 void GenContext::Clear()
66 delete m_BuiltPI_Params;
67 m_BuiltPI_Params = NULL;
69 if (m_BuiltPI_Params2)
71 delete m_BuiltPI_Params2;
72 m_BuiltPI_Params2 = NULL;
76 void GenContext::BuildProtoInfo()
78 m_BuiltPI->convention = m_Proto.GetConvention();
79 m_BuiltPI->numOfParams = m_Proto.GetNumOfParams();
81 m_BuiltPI->retPassInfo.size = m_Proto.GetRet().size;
82 m_BuiltPI->retPassInfo.type = m_Proto.GetRet().type;
83 m_BuiltPI->retPassInfo.flags = m_Proto.GetRet().flags;
84 m_BuiltPI->retPassInfo2.pNormalCtor = m_Proto.GetRet().pNormalCtor;
85 m_BuiltPI->retPassInfo2.pCopyCtor = m_Proto.GetRet().pCopyCtor;
86 m_BuiltPI->retPassInfo2.pDtor = m_Proto.GetRet().pDtor;
87 m_BuiltPI->retPassInfo2.pAssignOperator = m_Proto.GetRet().pAssignOperator;
90 delete m_BuiltPI_Params;
91 m_BuiltPI_Params = new PassInfo[m_BuiltPI->numOfParams + 1];
92 if (m_BuiltPI_Params2)
93 delete m_BuiltPI_Params2;
94 m_BuiltPI_Params2 = new PassInfo::V2Info[m_BuiltPI->numOfParams + 1];
96 m_BuiltPI_Params[0].size = 1; // Version 1
97 m_BuiltPI_Params[0].type = 0;
98 m_BuiltPI_Params[0].flags = 0;
100 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
102 m_BuiltPI_Params[i+1].size = m_Proto.GetParam(i).size;
103 m_BuiltPI_Params[i+1].type = m_Proto.GetParam(i).type;
104 m_BuiltPI_Params[i+1].flags = m_Proto.GetParam(i).flags;
106 m_BuiltPI_Params2[i+1].pNormalCtor = m_Proto.GetParam(i).pNormalCtor;
107 m_BuiltPI_Params2[i+1].pCopyCtor = m_Proto.GetParam(i).pCopyCtor;
108 m_BuiltPI_Params2[i+1].pDtor = m_Proto.GetParam(i).pDtor;
109 m_BuiltPI_Params2[i+1].pAssignOperator = m_Proto.GetParam(i).pAssignOperator;
112 m_BuiltPI->paramsPassInfo = m_BuiltPI_Params;
113 m_BuiltPI->paramsPassInfo2 = m_BuiltPI_Params2;
116 jit_int32_t GenContext::GetRealSize(const IntPassInfo &info)
118 if (info.flags & PassInfo::PassFlag_ByRef)
122 return static_cast<jit_int32_t>(info.size);
125 // Computes size on the stack
126 jit_int32_t GenContext::GetStackSize(const IntPassInfo &info)
128 // Align up to 4 byte boundaries
129 jit_int32_t rs = GetRealSize(info);
131 rs = (rs & ~(3)) + 4;
135 jit_int8_t GenContext::NextRegEBX_ECX_EDX()
137 switch ((m_RegCounter++) % 3)
150 void GenContext::BitwiseCopy_Setup()
156 IA32_Cld(&m_HookFunc);
157 IA32_Push_Reg(&m_HookFunc, REG_EDI);
158 IA32_Push_Reg(&m_HookFunc, REG_ESI);
161 void GenContext::BitwiseCopy_Do(size_t size)
163 jit_uint32_t dwords = DownCastSize(size) / 4;
164 jit_uint32_t bytes = DownCastSize(size) % 4;
177 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, dwords);
178 IA32_Rep(&m_HookFunc);
179 IA32_Movsd(&m_HookFunc);
183 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, bytes);
184 IA32_Rep(&m_HookFunc);
185 IA32_Movsb(&m_HookFunc);
187 IA32_Pop_Reg(&m_HookFunc, REG_ESI);
188 IA32_Pop_Reg(&m_HookFunc, REG_EDI);
191 jit_int32_t GenContext::PushRef(jit_int32_t param_offset, const IntPassInfo &pi)
193 // push [ebp+<offset>]
194 IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_offset);
199 jit_int32_t GenContext::PushBasic(jit_int32_t param_offset, const IntPassInfo &pi)
207 SH_ASSERT(0, ("Unsupported!"));
210 reg = NextRegEBX_ECX_EDX();
211 //movzx reg, BYTE PTR [ebp+<offset>]
213 IA32_Movzx_Reg32_Rm8_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
214 IA32_Push_Reg(&m_HookFunc, reg);
218 reg = NextRegEBX_ECX_EDX();
219 //movzx reg, WORD PTR [ebp+<offset>]
221 m_HookFunc.write_ubyte(IA32_16BIT_PREFIX);
222 IA32_Movzx_Reg32_Rm16_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
223 IA32_Push_Reg(&m_HookFunc, reg);
227 reg = NextRegEBX_ECX_EDX();
228 //mov reg, DWORD PTR [ebp+<offset>]
230 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
231 IA32_Push_Reg(&m_HookFunc, reg);
235 reg = NextRegEBX_ECX_EDX();
236 reg2 = NextRegEBX_ECX_EDX();
237 //mov reg, DWORD PTR [ebp+<offset>+4]
238 //mov reg2, DWORD PTR [ebp+<offset>]
242 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset+4);
243 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg2, REG_EBP, param_offset);
244 IA32_Push_Reg(&m_HookFunc, reg);
245 IA32_Push_Reg(&m_HookFunc, reg2);
251 jit_int32_t GenContext::PushFloat(jit_int32_t param_offset, const IntPassInfo &pi)
256 SH_ASSERT(0, ("Unsupported!"));
259 //fld DWORD PTR [ebp+<offset>]
261 //fstp DWORD PTR [esp]
262 IA32_Fld_Mem32_DispAuto(&m_HookFunc, REG_EBP, param_offset);
263 IA32_Push_Reg(&m_HookFunc, NextRegEBX_ECX_EDX());
264 IA32_Fstp_Mem32_ESP(&m_HookFunc);
267 //fld QWORD PTR [ebp+<offset>]
269 //fstp QWORD PTR [esp]
270 IA32_Fld_Mem64_DispAuto(&m_HookFunc, REG_EBP, param_offset);
271 IA32_Sub_Rm_Imm8(&m_HookFunc, REG_ESP, 8, MOD_REG);
272 IA32_Fstp_Mem64_ESP(&m_HookFunc);
277 jit_int32_t GenContext::PushObject(jit_int32_t param_offset, const IntPassInfo &pi)
279 // make room on the stack
281 IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, GetStackSize(pi), MOD_REG);
283 // if there is a copy constructor..
288 // this= target addr = esp+12
289 // call copy constructor
292 IA32_Push_Reg(&m_HookFunc, REG_EAX);
293 IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_ECX, REG_NOIDX, REG_ESP, NOSCALE, 4);
294 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_offset);
295 IA32_Push_Reg(&m_HookFunc, REG_EAX);
296 #if SH_COMP == SH_COMP_GCC
297 IA32_Push_Reg(&m_HookFunc, REG_ECX);
299 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(pi.pCopyCtor));
300 IA32_Call_Reg(&m_HookFunc, REG_EDX);
302 IA32_Pop_Reg(&m_HookFunc, REG_EAX);
312 //lea esi, [ebp+<offs>]
313 IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_EDI, REG_NOIDX, REG_ESP, NOSCALE, 8);
314 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, param_offset);
316 BitwiseCopy_Do(pi.size);
319 return DownCastSize(pi.size);
322 // May not touch eax!
323 jit_int32_t GenContext::PushParams(jit_int32_t param_base_offset, jit_int32_t save_ret_to, int v_place_for_memret)
325 jit_int32_t added_to_stack = 0;
328 // compute the offset _after_ the last parameter
329 jit_int32_t cur_offset = param_base_offset;
330 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
332 cur_offset += GetStackSize(m_Proto.GetParam(i));
335 // push parameters in reverse order
336 for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
338 const IntPassInfo &pi = m_Proto.GetParam(i);
339 cur_offset -= GetStackSize(pi);
340 if (pi.flags & PassInfo::PassFlag_ByVal)
344 case PassInfo::PassType_Basic:
345 ret = PushBasic(cur_offset, pi);
347 case PassInfo::PassType_Float:
348 ret = PushFloat(cur_offset, pi);
350 case PassInfo::PassType_Object:
351 ret = PushObject(cur_offset, pi);
355 else if (pi.flags & PassInfo::PassFlag_ByRef)
357 PushRef(cur_offset, pi);
361 SH_ASSERT(0, ("Unsupported!"));
363 added_to_stack += ret;
366 // Memory return support
367 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
369 // push address where to save it!
370 int reg = NextRegEBX_ECX_EDX();
371 IA32_Lea_DispRegImmAuto(&m_HookFunc, reg, REG_EBP,
372 MemRetWithTempObj() ? v_place_for_memret : save_ret_to);
373 IA32_Push_Reg(&m_HookFunc, reg);
375 added_to_stack += SIZE_PTR;
378 return added_to_stack;
381 void GenContext::SaveRetVal(int v_where, int v_place_for_memret)
383 size_t size = GetRealSize(m_Proto.GetRet());
386 // No return value -> nothing
390 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
392 // mov [ebp + v_plugin_ret], eax
393 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
400 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
402 if (MemRetWithTempObj())
404 // *v_where = *v_place_for_memret
406 // if we have an assign operator, use that
407 if (m_Proto.GetRet().pAssignOperator)
409 // lea edx, [ebp + v_place_for_memret] <-- src addr
410 // lea ecx, [ebp + v_where] <-- dest addr
415 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_place_for_memret);
416 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_where);
417 #if SH_COMP == SH_COMP_GCC
418 IA32_Push_Reg(&m_HookFunc, REG_ECX);
420 IA32_Push_Reg(&m_HookFunc, REG_EDX);
422 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
423 IA32_Call_Reg(&m_HookFunc, REG_EAX);
430 //lea edi, [evp+v_where] <-- destination
431 //lea esi, [ebp+v_place_for_memret] <-- src
432 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_where);
433 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_place_for_memret);
435 BitwiseCopy_Do(m_Proto.GetRet().size);
438 // Then: destruct *v_place_for_memret if required
439 if (m_Proto.GetRet().pDtor)
441 //lea ecx, [ebp+v_place_for_memret]
445 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_place_for_memret);
446 #if SH_COMP == SH_COMP_GCC
447 IA32_Push_Reg(&m_HookFunc, REG_ECX);
449 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
450 IA32_Call_Reg(&m_HookFunc, REG_EAX);
455 // Already copied to correct address -> we're done
460 if (m_Proto.GetRet().type == PassInfo::PassType_Float)
463 IA32_Fstp_Mem32_DispAuto(&m_HookFunc, REG_EBP, v_where);
465 IA32_Fstp_Mem64_DispAuto(&m_HookFunc, REG_EBP, v_where);
467 else if (m_Proto.GetRet().type == PassInfo::PassType_Basic)
471 // size <= 4: return in EAX
472 // We align <4 sizes up to 4
475 // mov [ebp + v_plugin_ret], eax
476 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
480 // size <= 4: return in EAX:EDX
481 // We align 4<x<8 sizes up to 8
483 // mov [ebp + v_plugin_ret], eax
484 // mov [ebp + v_plugin_ret + 4], edx
485 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
486 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
489 else if (m_Proto.GetRet().type == PassInfo::PassType_Object)
491 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)
495 // size <= 4: return in EAX
496 // We align <4 sizes up to 4
498 // mov [ebp + v_plugin_ret], eax
499 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
503 // size <= 4: return in EAX:EDX
504 // We align 4<x<8 sizes up to 8
506 // mov [ebp + v_plugin_ret], eax
507 // mov [ebp + v_plugin_ret + 4], edx
508 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
509 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
513 SH_ASSERT(0, ("RetReg and size > 8 !"));
519 bool GenContext::MemRetWithTempObj()
521 // Memory return AND (has destructor OR has assign operator)
522 return ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
523 && (m_Proto.GetRet().flags & (PassInfo::PassFlag_ODtor | PassInfo::PassFlag_AssignOp)));
526 void GenContext::ProcessPluginRetVal(int v_cur_res, int v_pContext, int v_plugin_ret)
528 // only for non-void functions!
529 if (m_Proto.GetRet().size == 0)
532 // if (cur_res >= MRES_OVERRIDE)
533 // *reinterpret_cast<my_rettype*>(pContext->GetOverrideRetPtr()) = plugin_ret;
536 // cmp eax,MRES_OVERRIDE
538 // pContext->GetOverrideRetPtr() --> overrideretptr in eax
543 jitoffs_t tmppos, counter;
545 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
547 IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_OVERRIDE);
548 tmppos = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NGE, 0);
549 m_HookFunc.start_count(counter);
551 // eax = pContext->GetOverrideRetPtr()
557 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
558 #if SH_COMP == SH_COMP_GCC
559 IA32_Push_Reg(&m_HookFunc, REG_ECX);
562 // vtbloffs=0, vtblidx=1
563 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
564 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 4);
565 IA32_Call_Reg(&m_HookFunc, REG_EAX);
569 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
571 // mov ecx, [ebp+v_plugin_ret]
573 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
574 IA32_Mov_Rm_Reg(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
578 if (m_Proto.GetRet().pAssignOperator)
580 // lea edx, [ebp + v_plugin_ret]
581 // msvc: ecx = eax <-- dest addr
582 // gcc: push eax <-- dest addr
583 // push edx <-- src addr
586 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_plugin_ret);
587 #if SH_COMP == SH_COMP_MSVC
588 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
589 #elif SH_COMP == SH_COMP_GCC
590 IA32_Push_Reg(&m_HookFunc, REG_EAX);
592 IA32_Push_Reg(&m_HookFunc, REG_EDX);
594 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
595 IA32_Call_Reg(&m_HookFunc, REG_EAX);
602 //mov edi, eax <-- destination
603 //lea esi, [ebp+v_plugin_ret] <-- src
604 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDI, REG_EAX, MOD_REG);
605 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_plugin_ret);
607 BitwiseCopy_Do(m_Proto.GetRet().size);
611 m_HookFunc.end_count(counter);
612 m_HookFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
615 void GenContext::PrepareReturn(int v_status, int v_pContext, int v_retptr)
617 // only for non-void functions!
618 if (m_Proto.GetRet().size == 0)
621 // retptr = status >= MRES_OVERRIDE ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()
623 // OverrideRetPtr: vtblidx = 1
624 // OrigRetPtr: vtbldix = 2
625 // vtblidx = (status >= MRES_OVERRIDE) ? 1 : 2
628 // eax = pContext->GetOverrideRetPtr()
632 // eax = (status < MRES_OVERRIDE) ? 1 : 0
634 // cmp [ebp + v_status], MRES_OVERRIDE
635 // setl al <-- setcc optimization for ternary operators,
638 // lea eax, [4*eax + 0x4]
646 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
647 #if SH_COMP == SH_COMP_GCC
648 IA32_Push_Reg(&m_HookFunc, REG_ECX);
650 IA32_Xor_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
651 IA32_Cmp_Rm_Disp8_Imm8(&m_HookFunc, REG_EBP, v_status, MRES_OVERRIDE);
652 IA32_SetCC_Rm8(&m_HookFunc, REG_EAX, CC_L);
654 IA32_Lea_Reg_RegMultImm32(&m_HookFunc, REG_EAX, REG_EAX, SCALE4, 4);
656 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
657 IA32_Add_Reg_Rm(&m_HookFunc, REG_EDX, REG_EAX, MOD_REG);
659 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_MEM_REG);
660 IA32_Call_Reg(&m_HookFunc, REG_EDX);
662 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_retptr);
665 void GenContext::DoReturn(int v_retptr, int v_memret_outaddr)
667 size_t size = m_Proto.GetRet().size;
671 // Get real ret pointer into ecx
672 // mov ecx, [ebp + v_ret_ptr]
673 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_retptr);
675 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
678 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
683 if (m_Proto.GetRet().type == PassInfo::PassType_Float)
686 IA32_Fld_Mem32(&m_HookFunc, REG_ECX);
688 IA32_Fld_Mem64(&m_HookFunc, REG_ECX);
690 else if (m_Proto.GetRet().type == PassInfo::PassType_Basic ||
691 ((m_Proto.GetRet().type == PassInfo::PassType_Object) && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)) )
695 // size <= 4: return in EAX
696 // We align <4 sizes up to 4
699 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
703 // size <= 4: return in EAX:EDX
704 // We align 4<x<8 sizes up to 8
708 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
709 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, 4);
713 // size >8: return in memory
718 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
720 // *memret_outaddr = plugin_ret
721 if (m_Proto.GetRet().pCopyCtor)
723 // mov edx, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
724 // msvc: ecx = [ebp + v_memret_outaddr] <-- dest addr
725 // gcc: push [ebp + v_memret_outaddr] <-- dest addr
726 // push edx <-- src addr
729 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_REG);
731 #if SH_COMP == SH_COMP_MSVC
732 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_memret_outaddr);
733 #elif SH_COMP == SH_COMP_GCC
734 IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, v_memret_outaddr);
736 IA32_Push_Reg(&m_HookFunc, REG_EDX);
738 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pCopyCtor));
739 IA32_Call_Reg(&m_HookFunc, REG_EAX);
746 //mov edi, [ebp+v_memret_outaddr] <-- destination
747 //mov esi, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
748 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDI, REG_EBP, v_memret_outaddr);
749 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESI, REG_ECX, MOD_REG);
751 BitwiseCopy_Do(m_Proto.GetRet().size);
754 // In both cases: return the pointer in EAX
755 // mov eax, [ebp + v_memret_outaddr]
756 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_memret_outaddr);
760 void GenContext::GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter,
761 int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret)
763 jitoffs_t counter, tmppos;
764 jitoffs_t counter2, tmppos2;
766 jitoffs_t loop_begin_counter;
768 // prev_res = MRES_IGNORED
769 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_prev_res);
771 m_HookFunc.start_count(loop_begin_counter);
773 // eax = pContext->GetNext()
779 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
780 #if SH_COMP == SH_COMP_GCC
781 IA32_Push_Reg(&m_HookFunc, REG_ECX);
784 // vtbloffs=0, vtblidx=0
785 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
786 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_MEM_REG);
787 IA32_Call_Reg(&m_HookFunc, REG_EAX);
792 IA32_Test_Rm_Reg(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
793 tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
794 m_HookFunc.start_count(counter);
796 // prev_res = MRES_IGNORED
797 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_cur_res);
804 // eax = [eax+2*SIZE_PTR]
806 jit_int32_t gcc_clean_bytes = PushParams(base_param_offset, v_plugin_ret, v_place_for_memret);
808 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
809 #if SH_COMP == SH_COMP_GCC
810 IA32_Push_Reg(&m_HookFunc, REG_ECX);
812 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
813 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 2*SIZE_PTR);
814 IA32_Call_Reg(&m_HookFunc, REG_EAX);
816 SaveRetVal(v_plugin_ret, v_place_for_memret);
819 #if SH_COMP == SH_COMP_GCC
821 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, gcc_clean_bytes + SIZE_PTR, MOD_REG);
824 // process meta return:
825 // prev_res = cur_res
826 // if (cur_res > status) status = cur_res;
836 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
837 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDX, REG_EBP, v_status);
838 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_prev_res);
840 IA32_Cmp_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_REG);
841 tmppos2 = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NG, 0);
842 m_HookFunc.start_count(counter2);
844 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_status);
846 m_HookFunc.end_count(counter2);
847 m_HookFunc.rewrite(tmppos2, static_cast<jit_uint8_t>(counter2));
849 // process retval for non-void functions
850 ProcessPluginRetVal(v_cur_res, v_pContext, v_plugin_ret);
852 // jump back to loop begin
853 tmppos2 = IA32_Jump_Imm32(&m_HookFunc, 0);
854 m_HookFunc.end_count(loop_begin_counter);
855 m_HookFunc.rewrite(tmppos2, -static_cast<jit_int32_t>(loop_begin_counter));
857 m_HookFunc.end_count(counter);
858 m_HookFunc.rewrite(tmppos, static_cast<jit_int32_t>(counter));
861 short GenContext::GetParamsStackSize()
864 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
866 acc += GetStackSize(m_Proto.GetParam(i));
869 // Memory return: address is first param
870 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
873 // :TODO: cdecl: THIS POINTER AS FIRST PARAM!!!
878 void GenContext::GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this,
879 int v_vfnptr_origentry, int v_orig_ret, int v_override_ret, int v_place_for_memret)
881 jitoffs_t counter, tmppos;
882 jitoffs_t counter2, tmppos2;
883 jitoffs_t counter3, tmppos3;
885 // if (status != MRES_SUPERCEDE && pConteext->ShouldCallOrig())
886 // *v_orig_ret = orig_call()
888 // *v_orig_ret = *v_override_ret
891 // cmp eax, MRES_SUPERCEDE
893 // call pContext->ShouldCallOrig()
894 // test al, al !! important: al, not eax! bool is only stored in the LSbyte
898 // SaveRet(v_orig_ret)
899 // jmp skip_dont_call:
902 // *v_orig_ret = *v_override_ret
905 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_status);
906 IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_SUPERCEDE);
908 tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_E, 0);
909 m_HookFunc.start_count(counter);
911 // eax = pContext->ShouldCallOrig()
915 // eax = [eax + 3*PTR_SIZE]
917 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
918 #if SH_COMP == SH_COMP_GCC
919 IA32_Push_Reg(&m_HookFunc, REG_ECX);
922 // vtbloffs=0, vtblidx=3
923 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
924 IA32_Mov_Reg_Rm_Disp8(&m_HookFunc, REG_EAX, REG_EAX, 3*SIZE_PTR);
925 IA32_Call_Reg(&m_HookFunc, REG_EAX);
927 IA32_Test_Rm_Reg8(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
928 tmppos2 = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
929 m_HookFunc.start_count(counter2);
932 jit_int32_t gcc_clean_bytes = PushParams(param_base_offs, v_orig_ret, v_place_for_memret);
935 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this);
936 #if SH_COMP == SH_COMP_GCC
937 // on gcc/mingw, this is the first parameter
938 IA32_Push_Reg(&m_HookFunc, REG_ECX);
939 // on msvc, simply leave it in ecx
943 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_vfnptr_origentry);
944 IA32_Call_Reg(&m_HookFunc, REG_EAX);
947 #if SH_COMP == SH_COMP_GCC
949 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, gcc_clean_bytes + SIZE_PTR, MOD_REG);
953 SaveRetVal(v_orig_ret, v_place_for_memret);
955 // Skip don't call variant
956 tmppos3 = IA32_Jump_Imm32(&m_HookFunc, 0);
957 m_HookFunc.start_count(counter3);
961 m_HookFunc.end_count(counter);
962 m_HookFunc.rewrite(tmppos, static_cast<jit_uint32_t>(counter));
964 m_HookFunc.end_count(counter2);
965 m_HookFunc.rewrite(tmppos2, static_cast<jit_uint32_t>(counter2));
967 // *v_orig_ret = *v_override_ret
968 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
970 // mov ecx, [ebp + v_override_ret]
971 // mov [ebp + v_orig_ret], ecx
973 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
974 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_ECX, v_orig_ret);
978 if (m_Proto.GetRet().pAssignOperator)
980 // lea edx, [ebp + v_override_ret] <-- src addr
981 // lea ecx, [ebp + v_orig_ret] <-- dest addr
983 // push edx <-- src addr
986 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_override_ret);
987 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
988 #if SH_COMP == SH_COMP_GCC
989 IA32_Push_Reg(&m_HookFunc, REG_ECX);
991 IA32_Push_Reg(&m_HookFunc, REG_EDX);
993 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
994 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1001 //lea edi, [ebp+v_orig_ret] <-- destination
1002 //lea esi, [ebp+v_override_ret] <-- src
1003 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_orig_ret);
1004 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_override_ret);
1006 BitwiseCopy_Do(m_Proto.GetRet().size);
1010 // skip don't call label target:
1011 m_HookFunc.end_count(counter3);
1012 m_HookFunc.rewrite(tmppos3, static_cast<jit_uint32_t>(counter3));
1015 // Sets *v_pContext to return value
1016 void GenContext::CallSetupHookLoop(int v_orig_ret, int v_override_ret,
1017 int v_cur_res, int v_prev_res, int v_status, int v_vfnptr_origentry,
1018 int v_this, int v_pContext)
1020 // call shptr->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this),
1021 // &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret);
1022 // The last two params are null for void funcs.
1024 if (m_Proto.GetRet().size == 0)
1027 IA32_Push_Imm8(&m_HookFunc, 0); // orig_ret
1028 IA32_Push_Imm8(&m_HookFunc, 0); // override_ret
1032 // orig_ret and override_ret
1033 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, v_override_ret);
1034 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_orig_ret);
1035 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1036 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1039 // cur_res and prev_res
1040 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
1041 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_prev_res);
1042 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1043 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1045 // status and vfnptr_origentry
1046 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_status);
1047 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_vfnptr_origentry);
1048 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1049 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1052 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_this);
1053 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1056 // *(this + vtbloffs) + SIZE_PTR*vtblidx
1057 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this); // get this into ecx (gcc!)
1058 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, m_VtblOffs);
1059 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_EAX, m_VtblIdx * SIZE_PTR, MOD_REG);
1060 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1063 IA32_Mov_Rm_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1064 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1065 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1068 #if SH_COMP == SH_COMP_GCC
1069 // on gcc/mingw, this is the first parameter
1070 IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr));
1071 #elif SH_COMP == SH_COMP_MSVC
1072 // on msvc, it's ecx
1073 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1076 // call the function. vtbloffs = 0, vtblidx = 19
1077 // get vtptr into edx -- we know shptr on jit time -> dereference it here!
1078 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX,
1079 (*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[19]);
1081 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1083 // on gcc/mingw, we have to clean up after the call
1084 #if SH_COMP == SH_COMP_GCC
1085 // 9 params + hidden thisptr param
1086 IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 10*SIZE_PTR, MOD_REG);
1089 // store return value
1090 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_pContext);
1093 void GenContext::CallEndContext(int v_pContext)
1096 // shptr->EndContext(pContex)
1097 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_pContext);
1098 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1101 #if SH_COMP == SH_COMP_GCC
1102 // on gcc/mingw, this is the first parameter
1103 IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr));
1104 #elif SH_COMP == SH_COMP_MSVC
1105 // on msvc, it's ecx
1106 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1109 // get vtptr into edx -- we know shptr on jit time -> dereference it here!
1110 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX,
1111 (*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[20]);
1113 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1115 // on gcc/mingw, we have to clean up after the call
1116 #if SH_COMP == SH_COMP_GCC
1117 // 1 param + hidden thisptr param
1118 IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG);
1122 void * GenContext::GenerateHookFunc()
1125 IA32_Push_Reg(&m_HookFunc, REG_EBP);
1126 IA32_Push_Reg(&m_HookFunc, REG_EBX);
1127 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EBP, REG_ESP, MOD_REG);
1129 // on msvc, save thisptr
1130 #if SH_COMP == SH_COMP_MSVC
1131 const jit_int8_t v_this = -4;
1132 const int addstackoffset = -4;
1133 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1134 #elif SH_COMP == SH_COMP_GCC
1135 const jit_int8_t v_this = 8; // first param
1136 const int addstackoffset = 0;
1140 // ********************** stack frame **********************
1142 // second param (gcc: first real param) ebp + 16
1143 // first param (gcc: thisptr) ebp + 12
1144 // ret address: ebp + 8
1145 // caller's ebp ebp + 4
1147 // MSVC ONLY: current this ebp - 4
1148 // void *vfnptr_origentry ebp - 4 -4
1149 // META_RES status = MRES_IGNORED ebp - 8 -4
1150 // META_RES prev_res ebp - 12 -4
1151 // META_RES cur_res ebp - 16 -4
1152 // IMyDelegate *iter ebp - 20 -4
1153 // IHookContext *pContext ebp - 24 -4
1154 // == 3 ptrs + 3 enums = 24 bytes
1157 // my_rettype *ret_ptr ebp - 28 -4
1158 // my_rettype orig_ret ebp - 28 - sizeof(my_rettype) -4
1159 // my_rettype override_ret ebp - 28 - sizeof(my_rettype)*2 -4
1160 // my_rettype plugin_ret ebp - 28 - sizeof(my_rettype)*3 -4
1161 // == + 3 * sizeof(my_rettype) bytes
1164 // my_rettype place_for_memret ebp - 28 - sizeof(my_rettype)*4 -4
1167 const jit_int8_t v_vfnptr_origentry = -4 + addstackoffset;
1168 const jit_int8_t v_status = -8 + addstackoffset;
1169 const jit_int8_t v_prev_res = -12 + addstackoffset;
1170 const jit_int8_t v_cur_res = -16 + addstackoffset;
1171 const jit_int8_t v_iter = -20 + addstackoffset;
1172 const jit_int8_t v_pContext = -24 + addstackoffset;
1174 #if SH_COMP == SH_COMP_GCC
1175 jit_int32_t param_base_offs = 16;
1176 #elif SH_COMP == SH_COMP_MSVC
1177 jit_int32_t param_base_offs = 12;
1180 // Memory return: first param is the address
1181 jit_int32_t v_memret_addr = 0;
1182 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1184 v_memret_addr = param_base_offs;
1185 param_base_offs += SIZE_PTR;
1188 jit_int32_t v_ret_ptr = -28 + addstackoffset;
1189 jit_int32_t v_orig_ret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 1;
1190 jit_int32_t v_override_ret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 2;
1191 jit_int32_t v_plugin_ret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 3;
1193 jit_int32_t v_place_for_memret = -28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 4;
1195 // Hash for temporary storage for byval params with copy constructors
1196 // (param, offset into stack)
1197 short usedStackBytes = 3*SIZE_MWORD + 3*SIZE_PTR // vfnptr_origentry, status, prev_res, cur_res, iter, pContext
1198 + 3 * GetStackSize(m_Proto.GetRet()) + (m_Proto.GetRet().size == 0 ? 0 : SIZE_PTR) // ret_ptr, orig_ret, override_ret, plugin_ret
1199 + (MemRetWithTempObj() ? GetStackSize(m_Proto.GetRet()) : 0)
1200 - addstackoffset; // msvc: current thisptr
1202 IA32_Sub_Rm_Imm32(&m_HookFunc, REG_ESP, usedStackBytes, MOD_REG);
1204 // init status localvar
1205 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_status);
1207 // Call constructors for ret vars if required
1208 if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1209 m_Proto.GetRet().pNormalCtor)
1211 // :TODO: Gcc version
1214 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1215 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1216 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1219 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1220 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1221 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1224 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1225 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1226 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1228 // _don't_ call a constructor for v_place_for_memret !
1231 // ********************** SetupHookLoop **********************
1232 CallSetupHookLoop(v_orig_ret, v_override_ret, v_cur_res, v_prev_res, v_status, v_vfnptr_origentry,
1233 v_this, v_pContext);
1235 // ********************** call pre hooks **********************
1236 GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1237 v_plugin_ret, v_place_for_memret);
1239 // ********************** call orig func **********************
1240 GenerateCallOrig(v_status, v_pContext, param_base_offs, v_this, v_vfnptr_origentry, v_orig_ret,
1241 v_override_ret, v_place_for_memret);
1243 // ********************** call post hooks **********************
1244 GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1245 v_plugin_ret, v_place_for_memret);
1247 // ********************** end context and return **********************
1249 PrepareReturn(v_status, v_pContext, v_ret_ptr);
1251 CallEndContext(v_pContext);
1253 // Call destructors of byval object params which have a destructor
1254 jit_int32_t cur_param_pos = param_base_offs;
1255 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1257 const IntPassInfo &pi = m_Proto.GetParam(i);
1258 if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
1259 (pi.flags & PassInfo::PassFlag_ByVal))
1261 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, cur_param_pos);
1262 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
1263 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1265 cur_param_pos += GetStackSize(pi);
1268 DoReturn(v_ret_ptr, v_memret_addr);
1270 // Call destructors of orig_ret/ ...
1271 if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1272 m_Proto.GetRet().pDtor)
1274 // Preserve return value in EAX(:EDX)
1275 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1276 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1278 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1279 #if SH_COMP == SH_COMP_GCC
1280 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1282 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1283 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1285 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1286 #if SH_COMP == SH_COMP_GCC
1287 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1289 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1290 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1292 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1293 #if SH_COMP == SH_COMP_GCC
1294 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1296 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1297 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1299 IA32_Pop_Reg(&m_HookFunc, REG_EDX);
1300 IA32_Pop_Reg(&m_HookFunc, REG_EAX);
1304 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESP, REG_EBP, MOD_REG);
1305 IA32_Pop_Reg(&m_HookFunc, REG_EBX);
1306 IA32_Pop_Reg(&m_HookFunc, REG_EBP);
1307 IA32_Return_Popstack(&m_HookFunc, GetParamsStackSize());
1309 // Store pointer for later use
1310 // m_HookfuncVfnPtr is a pointer to a void* because SH expects a pointer
1311 // into the hookman's vtable
1312 *m_HookfuncVfnptr = reinterpret_cast<void*>(m_HookFunc.GetData());
1316 return m_HookFunc.GetData();
1319 // Pre-condition: GenerateHookFunc() has been called!
1320 void * GenContext::GeneratePubFunc()
1322 jitoffs_t counter, tmppos;
1324 // The pubfunc is a static cdecl function.
1326 // int HookManPubFunc(
1327 // bool store, ebp + 8
1328 // IHookManagerInfo *hi ebp + 12
1334 // hi->SetInfo(HOOKMAN_VERSION, m_VtblOffs, m_VtblIdx, m_Proto.GetProto(), m_HookfuncVfnptr)
1338 IA32_Push_Reg(&m_PubFunc, REG_EBP);
1339 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EBP, REG_ESP, MOD_REG);
1342 // save store in eax, hi in ecx
1343 IA32_Movzx_Reg32_Rm8_Disp8(&m_PubFunc, REG_EAX, REG_EBP, 8);
1344 IA32_Mov_Reg_Rm_DispAuto(&m_PubFunc, REG_ECX, REG_EBP, 12);
1346 // Check for store == 0
1347 IA32_Test_Rm_Reg8(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1348 tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1349 m_PubFunc.start_count(counter);
1351 // nonzero -> store hi
1352 IA32_Mov_Rm_Imm32(&m_PubFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1353 IA32_Mov_Rm_Reg(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1356 m_PubFunc.end_count(counter);
1357 m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1359 // check for hi == 0
1360 IA32_Test_Rm_Reg(&m_PubFunc, REG_ECX, REG_ECX, MOD_REG);
1361 tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1362 m_PubFunc.start_count(counter);
1364 // nonzero -> call vfunc
1365 // push params in reverse order
1366 IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_HookfuncVfnptr));
1367 IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_BuiltPI));
1368 IA32_Push_Imm32(&m_PubFunc, m_VtblIdx);
1369 IA32_Push_Imm32(&m_PubFunc, m_VtblOffs);
1370 IA32_Push_Imm32(&m_PubFunc, SH_HOOKMAN_VERSION);
1372 // hi == this is in ecx
1373 // on gcc/mingw, ecx is the first parameter
1374 #if SH_COMP == SH_COMP_GCC
1375 IA32_Push_Reg(&m_PubFunc, REG_ECX);
1378 // call the function. vtbloffs = 0, vtblidx = 0
1379 // get vtptr into edx
1380 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1381 // get funcptr into eax
1382 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1384 IA32_Call_Reg(&m_PubFunc, REG_EAX);
1386 // on gcc/mingw, we have to clean up after the call
1387 #if SH_COMP == SH_COMP_GCC
1388 // 5 params + hidden thisptr param
1389 IA32_Add_Rm_Imm8(&m_PubFunc, REG_ESP, 6*SIZE_MWORD, MOD_REG);
1393 m_PubFunc.end_count(counter);
1394 m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1397 IA32_Xor_Reg_Rm(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1400 IA32_Mov_Reg_Rm(&m_PubFunc, REG_ESP, REG_EBP, MOD_REG);
1401 IA32_Pop_Reg(&m_PubFunc, REG_EBP);
1402 IA32_Return(&m_PubFunc);
1409 bool GenContext::PassInfoSupported(const IntPassInfo &pi, bool is_ret)
1411 if (pi.type != PassInfo::PassType_Basic &&
1412 pi.type != PassInfo::PassType_Float &&
1413 pi.type != PassInfo::PassType_Object)
1418 if (pi.type == PassInfo::PassType_Object &&
1419 (pi.flags & PassInfo::PassFlag_ByVal))
1421 if ((pi.flags & PassInfo::PassFlag_CCtor) && !pi.pCopyCtor)
1424 if ((pi.flags & PassInfo::PassFlag_ODtor) && !pi.pDtor)
1427 if ((pi.flags & PassInfo::PassFlag_AssignOp) && !pi.pAssignOperator)
1430 if ((pi.flags & PassInfo::PassFlag_OCtor) && !pi.pNormalCtor)
1434 if ((pi.flags & (PassInfo::PassFlag_ByVal | PassInfo::PassFlag_ByRef)) == 0)
1436 return false; // Neither byval nor byref!
1441 void GenContext::AutoDetectRetType()
1443 IntPassInfo &pi = m_Proto.GetRet();
1445 // Only relevant for byval types
1446 if (pi.flags & PassInfo::PassFlag_ByVal)
1449 if (pi.type == PassInfo::PassType_Basic ||
1450 pi.type == PassInfo::PassType_Float)
1453 // _always_ in registers, no matter what the user says
1456 pi.flags &= ~PassInfo::PassFlag_RetMem;
1457 pi.flags |= PassInfo::PassFlag_RetReg;
1461 // Does this even exist? No idea, if it does: in memory!
1462 pi.flags &= ~PassInfo::PassFlag_RetReg;
1463 pi.flags |= PassInfo::PassFlag_RetMem;
1467 else if (pi.type == PassInfo::PassType_Object)
1469 // If the user says nothing, auto-detect
1470 if ((pi.flags & (PassInfo::PassFlag_RetMem | PassInfo::PassFlag_RetReg)) == 0)
1472 #if SH_COMP == SH_COMP_MSVC
1473 // MSVC seems to return _all_ structs, classes, unions in memory
1474 pi.flags |= PassInfo::PassFlag_RetMem;
1475 #elif SH_COMP == SH_COMP_GCC
1476 // Same goes for GCC :)
1477 pi.flags |= PassInfo::PassFlag_RetMem;
1484 // byref: make sure that the flag is _not_ set
1485 pi.flags &= ~PassInfo::PassFlag_RetMem;
1486 pi.flags |= PassInfo::PassFlag_RetReg;
1490 HookManagerPubFunc GenContext::Generate()
1494 // Check conditions:
1495 // -1) good proto version
1496 // 0) we don't support unknown passtypes, convention, ...
1497 // 1) we don't support functions which return objects by value or take parameters by value
1498 // that have a constructor, a destructor or an overloaded assignment op
1499 // (we wouldn't know how to call it!)
1501 if (m_Proto.GetVersion() < 1)
1506 AutoDetectRetType();
1508 if (m_Proto.GetConvention() != ProtoInfo::CallConv_Cdecl &&
1509 m_Proto.GetConvention() != ProtoInfo::CallConv_ThisCall)
1515 if (m_Proto.GetRet().size != 0 && !PassInfoSupported(m_Proto.GetRet(), true))
1520 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1522 if (!PassInfoSupported(m_Proto.GetParam(i), false))
1528 return fastdelegate::detail::horrible_cast<HookManagerPubFunc>(GeneratePubFunc());