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"
22 #include <stdarg.h> // we might need the address of vsnprintf
25 #if SH_COMP == SH_COMP_MSVC
27 # define MSVC_ONLY(x) x
28 #elif SH_COMP == SH_COMP_GCC
29 # define GCC_ONLY(x) x
33 // :TODO: test BIG vtable indices
39 CPageAlloc GenBuffer::ms_Allocator;
42 jit_int32_t DownCastPtr(T ptr)
44 return reinterpret_cast<jit_int32_t>(ptr);
47 jit_uint32_t DownCastSize(size_t size)
49 return static_cast<jit_uint32_t>(size);
52 GenContext::GenContext(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx, ISourceHook *pSHPtr)
53 : m_GeneratedPubFunc(NULL), m_OrigProto(proto), m_Proto(proto), m_VtblOffs(vtbl_offs),
54 m_VtblIdx(vtbl_idx), m_SHPtr(pSHPtr), m_pHI(NULL), m_HookfuncVfnptr(NULL), m_RegCounter(0)
57 m_HookfuncVfnptr = new void*;
58 m_BuiltPI = new ProtoInfo;
59 m_BuiltPI_Params = NULL;
60 m_BuiltPI_Params2 = NULL;
63 GenContext::~GenContext()
67 delete m_HookfuncVfnptr;
71 void GenContext::Clear()
77 delete m_BuiltPI_Params;
78 m_BuiltPI_Params = NULL;
80 if (m_BuiltPI_Params2)
82 delete m_BuiltPI_Params2;
83 m_BuiltPI_Params2 = NULL;
87 void GenContext::BuildProtoInfo()
89 m_BuiltPI->convention = m_Proto.GetConvention();
90 m_BuiltPI->numOfParams = m_Proto.GetNumOfParams();
92 m_BuiltPI->retPassInfo.size = m_Proto.GetRet().size;
93 m_BuiltPI->retPassInfo.type = m_Proto.GetRet().type;
94 m_BuiltPI->retPassInfo.flags = m_Proto.GetRet().flags;
95 m_BuiltPI->retPassInfo2.pNormalCtor = m_Proto.GetRet().pNormalCtor;
96 m_BuiltPI->retPassInfo2.pCopyCtor = m_Proto.GetRet().pCopyCtor;
97 m_BuiltPI->retPassInfo2.pDtor = m_Proto.GetRet().pDtor;
98 m_BuiltPI->retPassInfo2.pAssignOperator = m_Proto.GetRet().pAssignOperator;
100 if (m_BuiltPI_Params)
101 delete m_BuiltPI_Params;
102 m_BuiltPI_Params = new PassInfo[m_BuiltPI->numOfParams + 1];
103 if (m_BuiltPI_Params2)
104 delete m_BuiltPI_Params2;
105 m_BuiltPI_Params2 = new PassInfo::V2Info[m_BuiltPI->numOfParams + 1];
107 m_BuiltPI_Params[0].size = 1; // Version 1
108 m_BuiltPI_Params[0].type = 0;
109 m_BuiltPI_Params[0].flags = 0;
111 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
113 m_BuiltPI_Params[i+1].size = m_Proto.GetParam(i).size;
114 m_BuiltPI_Params[i+1].type = m_Proto.GetParam(i).type;
115 m_BuiltPI_Params[i+1].flags = m_Proto.GetParam(i).flags;
117 m_BuiltPI_Params2[i+1].pNormalCtor = m_Proto.GetParam(i).pNormalCtor;
118 m_BuiltPI_Params2[i+1].pCopyCtor = m_Proto.GetParam(i).pCopyCtor;
119 m_BuiltPI_Params2[i+1].pDtor = m_Proto.GetParam(i).pDtor;
120 m_BuiltPI_Params2[i+1].pAssignOperator = m_Proto.GetParam(i).pAssignOperator;
123 m_BuiltPI->paramsPassInfo = m_BuiltPI_Params;
124 m_BuiltPI->paramsPassInfo2 = m_BuiltPI_Params2;
127 jit_int32_t GenContext::GetRealSize(const IntPassInfo &info)
129 if (info.flags & PassInfo::PassFlag_ByRef)
133 return static_cast<jit_int32_t>(info.size);
136 // Computes size on the stack
137 jit_int32_t GenContext::GetStackSize(const IntPassInfo &info)
139 // Align up to 4 byte boundaries
140 jit_int32_t rs = GetRealSize(info);
142 rs = (rs & ~(3)) + 4;
146 jit_int8_t GenContext::NextRegEBX_ECX_EDX()
148 switch ((m_RegCounter++) % 3)
161 void GenContext::BitwiseCopy_Setup()
167 IA32_Cld(&m_HookFunc);
168 IA32_Push_Reg(&m_HookFunc, REG_EDI);
169 IA32_Push_Reg(&m_HookFunc, REG_ESI);
172 void GenContext::BitwiseCopy_Do(size_t size)
174 jit_uint32_t dwords = DownCastSize(size) / 4;
175 jit_uint32_t bytes = DownCastSize(size) % 4;
188 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, dwords);
189 IA32_Rep(&m_HookFunc);
190 IA32_Movsd(&m_HookFunc);
194 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, bytes);
195 IA32_Rep(&m_HookFunc);
196 IA32_Movsb(&m_HookFunc);
198 IA32_Pop_Reg(&m_HookFunc, REG_ESI);
199 IA32_Pop_Reg(&m_HookFunc, REG_EDI);
202 short GenContext::GetParamsStackSize()
205 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
207 acc += GetStackSize(m_Proto.GetParam(i));
213 short GenContext::GetForcedByRefParamOffset(int p)
216 for (int i = 0; i < p; ++i)
218 if (m_Proto.GetParam(i).flags & PassFlag_ForcedByRef)
219 off += GetStackSize(m_Proto.GetParam(i));
224 short GenContext::GetForcedByRefParamsSize()
226 return GetForcedByRefParamOffset(m_Proto.GetNumOfParams());
229 jit_int32_t GenContext::PushRef(jit_int32_t param_offset, const IntPassInfo &pi)
231 // push [ebp+<offset>]
232 IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_offset);
237 jit_int32_t GenContext::PushBasic(jit_int32_t param_offset, const IntPassInfo &pi)
245 SH_ASSERT(0, ("Unsupported!"));
248 reg = NextRegEBX_ECX_EDX();
249 //movzx reg, BYTE PTR [ebp+<offset>]
251 IA32_Movzx_Reg32_Rm8_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
252 IA32_Push_Reg(&m_HookFunc, reg);
256 reg = NextRegEBX_ECX_EDX();
257 //movzx reg, WORD PTR [ebp+<offset>]
259 m_HookFunc.write_ubyte(IA32_16BIT_PREFIX);
260 IA32_Movzx_Reg32_Rm16_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
261 IA32_Push_Reg(&m_HookFunc, reg);
265 reg = NextRegEBX_ECX_EDX();
266 //mov reg, DWORD PTR [ebp+<offset>]
268 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
269 IA32_Push_Reg(&m_HookFunc, reg);
273 reg = NextRegEBX_ECX_EDX();
274 reg2 = NextRegEBX_ECX_EDX();
275 //mov reg, DWORD PTR [ebp+<offset>+4]
276 //mov reg2, DWORD PTR [ebp+<offset>]
280 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset+4);
281 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg2, REG_EBP, param_offset);
282 IA32_Push_Reg(&m_HookFunc, reg);
283 IA32_Push_Reg(&m_HookFunc, reg2);
289 jit_int32_t GenContext::PushFloat(jit_int32_t param_offset, const IntPassInfo &pi)
294 SH_ASSERT(0, ("Unsupported!"));
297 //fld DWORD PTR [ebp+<offset>]
299 //fstp DWORD PTR [esp]
300 IA32_Fld_Mem32_DispAuto(&m_HookFunc, REG_EBP, param_offset);
301 IA32_Push_Reg(&m_HookFunc, NextRegEBX_ECX_EDX());
302 IA32_Fstp_Mem32_ESP(&m_HookFunc);
305 //fld QWORD PTR [ebp+<offset>]
307 //fstp QWORD PTR [esp]
308 IA32_Fld_Mem64_DispAuto(&m_HookFunc, REG_EBP, param_offset);
309 IA32_Sub_Rm_Imm8(&m_HookFunc, REG_ESP, 8, MOD_REG);
310 IA32_Fstp_Mem64_ESP(&m_HookFunc);
315 jit_int32_t GenContext::PushObject(jit_int32_t param_offset, const IntPassInfo &pi, jit_int32_t place_fbrr)
317 if ((pi.flags & PassFlag_ForcedByRef) == 0)
319 // make room on the stack
321 IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, GetStackSize(pi), MOD_REG);
324 // if there is a copy constructor..
329 // this= target addr = forcedbyref ? ebp+place_fbrr : esp+12
330 // call copy constructor
333 IA32_Push_Reg(&m_HookFunc, REG_EAX);
335 if (pi.flags & PassFlag_ForcedByRef)
336 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
338 IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_ECX, REG_NOIDX, REG_ESP, NOSCALE, 4);
340 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_offset);
341 IA32_Push_Reg(&m_HookFunc, REG_EAX);
342 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
343 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(pi.pCopyCtor));
344 IA32_Call_Reg(&m_HookFunc, REG_EDX);
345 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
346 IA32_Pop_Reg(&m_HookFunc, REG_EAX);
356 // lea edi, [ebp_place_fbrr]
358 // lea edi, [esp+8] - bc_setup pushed two regs onto the stack!
359 //lea esi, [ebp+<offs>]
360 if (pi.flags & PassFlag_ForcedByRef)
361 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, place_fbrr);
363 IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_EDI, REG_NOIDX, REG_ESP, NOSCALE, 8);
365 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, param_offset);
367 BitwiseCopy_Do(pi.size);
370 // forcedref: push reference to ebp+place_fbrr
371 if (pi.flags & PassFlag_ForcedByRef)
373 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
374 IA32_Push_Reg(&m_HookFunc, REG_ECX);
378 return DownCastSize(pi.size);
381 void GenContext::DestroyParams(jit_int32_t fbrr_base)
383 for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
385 const IntPassInfo &pi = m_Proto.GetParam(i);
386 if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
387 (pi.flags & PassInfo::PassFlag_ByVal) && (pi.flags & PassFlag_ForcedByRef))
389 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, fbrr_base + GetForcedByRefParamOffset(i));
390 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
391 IA32_Call_Reg(&m_HookFunc, REG_EAX);
396 // May not touch eax!
397 jit_int32_t GenContext::PushParams(jit_int32_t param_base_offset, jit_int32_t save_ret_to, int v_place_for_memret,
398 jit_int32_t v_place_fbrr_base)
400 jit_int32_t added_to_stack = 0;
403 // compute the offset _after_ the last parameter
404 jit_int32_t cur_offset = param_base_offset;
405 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
407 cur_offset += GetStackSize(m_Proto.GetParam(i));
410 // push parameters in reverse order
411 for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
413 const IntPassInfo &pi = m_Proto.GetParam(i);
414 cur_offset -= GetStackSize(pi);
415 if (pi.flags & PassInfo::PassFlag_ByVal)
419 case PassInfo::PassType_Basic:
420 ret = PushBasic(cur_offset, pi);
422 case PassInfo::PassType_Float:
423 ret = PushFloat(cur_offset, pi);
425 case PassInfo::PassType_Object:
426 ret = PushObject(cur_offset, pi, v_place_fbrr_base + GetForcedByRefParamOffset(i));
430 else if (pi.flags & PassInfo::PassFlag_ByRef)
432 PushRef(cur_offset, pi);
436 SH_ASSERT(0, ("Unsupported!"));
438 added_to_stack += ret;
441 return added_to_stack;
444 // It is IMPORTANT that PushMemRetPtr doesn't touch ecx and eax
445 jit_int32_t GenContext::PushMemRetPtr(jit_int32_t save_ret_to, jit_int32_t v_place_for_memret)
447 // Memory return support
448 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
450 // push address where to save it!
452 IA32_Lea_DispRegImmAuto(&m_HookFunc, reg, REG_EBP,
453 MemRetWithTempObj() ? v_place_for_memret : save_ret_to);
454 IA32_Push_Reg(&m_HookFunc, reg);
456 return (SH_COMP==SH_COMP_MSVC) ? 4 : 0; // varargs funcs on msvc might need this.
457 // gcc doesn't: callee cleans the memret ptr, caller the other params :s
462 void GenContext::SaveRetVal(int v_where, int v_place_for_memret)
464 size_t size = GetRealSize(m_Proto.GetRet());
467 // No return value -> nothing
471 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
473 // mov [ebp + v_plugin_ret], eax
474 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
481 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
483 if (MemRetWithTempObj())
485 // *v_where = *v_place_for_memret
487 // if we have an assign operator, use that
488 if (m_Proto.GetRet().pAssignOperator)
490 // lea edx, [ebp + v_place_for_memret] <-- src addr
491 // lea ecx, [ebp + v_where] <-- dest addr
497 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_place_for_memret);
498 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_where);
499 IA32_Push_Reg(&m_HookFunc, REG_EDX);
500 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
502 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
503 IA32_Call_Reg(&m_HookFunc, REG_EAX);
504 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
511 //lea edi, [evp+v_where] <-- destination
512 //lea esi, [ebp+v_place_for_memret] <-- src
513 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_where);
514 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_place_for_memret);
516 BitwiseCopy_Do(m_Proto.GetRet().size);
519 // Then: destruct *v_place_for_memret if required
520 if (m_Proto.GetRet().pDtor)
522 //lea ecx, [ebp+v_place_for_memret]
527 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_place_for_memret);
528 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
529 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
530 IA32_Call_Reg(&m_HookFunc, REG_EAX);
531 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
536 // Already copied to correct address -> we're done
541 if (m_Proto.GetRet().type == PassInfo::PassType_Float)
544 IA32_Fstp_Mem32_DispAuto(&m_HookFunc, REG_EBP, v_where);
546 IA32_Fstp_Mem64_DispAuto(&m_HookFunc, REG_EBP, v_where);
548 else if (m_Proto.GetRet().type == PassInfo::PassType_Basic)
552 // size <= 4: return in EAX
553 // We align <4 sizes up to 4
556 // mov [ebp + v_plugin_ret], eax
557 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
561 // size <= 4: return in EAX:EDX
562 // We align 4<x<8 sizes up to 8
564 // mov [ebp + v_plugin_ret], eax
565 // mov [ebp + v_plugin_ret + 4], edx
566 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
567 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
570 else if (m_Proto.GetRet().type == PassInfo::PassType_Object)
572 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)
576 // size <= 4: return in EAX
577 // We align <4 sizes up to 4
579 // mov [ebp + v_plugin_ret], eax
580 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
584 // size <= 4: return in EAX:EDX
585 // We align 4<x<8 sizes up to 8
587 // mov [ebp + v_plugin_ret], eax
588 // mov [ebp + v_plugin_ret + 4], edx
589 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
590 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
594 SH_ASSERT(0, ("RetReg and size > 8 !"));
600 bool GenContext::MemRetWithTempObj()
602 // Memory return AND (has destructor OR has assign operator)
603 return ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
604 && (m_Proto.GetRet().flags & (PassInfo::PassFlag_ODtor | PassInfo::PassFlag_AssignOp)));
607 void GenContext::ProcessPluginRetVal(int v_cur_res, int v_pContext, int v_plugin_ret)
609 // only for non-void functions!
610 if (m_Proto.GetRet().size == 0)
613 // if (cur_res >= MRES_OVERRIDE)
614 // *reinterpret_cast<my_rettype*>(pContext->GetOverrideRetPtr()) = plugin_ret;
617 // cmp eax,MRES_OVERRIDE
619 // pContext->GetOverrideRetPtr() --> overrideretptr in eax
624 jitoffs_t tmppos, counter;
626 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
628 IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_OVERRIDE);
629 tmppos = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NGE, 0);
630 m_HookFunc.start_count(counter);
632 // eax = pContext->GetOverrideRetPtr()
639 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
640 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
642 // vtbloffs=0, vtblidx=1
643 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
644 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 4);
645 IA32_Call_Reg(&m_HookFunc, REG_EAX);
646 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
650 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
652 // mov ecx, [ebp+v_plugin_ret]
654 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
655 IA32_Mov_Rm_Reg(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
659 if (m_Proto.GetRet().pAssignOperator)
661 // lea edx, [ebp + v_plugin_ret]
662 // push edx <-- src addr
663 // msvc: ecx = eax <-- dest addr
664 // gcc: push eax <-- dest addr
668 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_plugin_ret);
669 IA32_Push_Reg(&m_HookFunc, REG_EDX);
670 #if SH_COMP == SH_COMP_MSVC
671 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
672 #elif SH_COMP == SH_COMP_GCC
673 IA32_Push_Reg(&m_HookFunc, REG_EAX);
676 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
677 IA32_Call_Reg(&m_HookFunc, REG_EAX);
678 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
685 //mov edi, eax <-- destination
686 //lea esi, [ebp+v_plugin_ret] <-- src
687 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDI, REG_EAX, MOD_REG);
688 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_plugin_ret);
690 BitwiseCopy_Do(m_Proto.GetRet().size);
694 m_HookFunc.end_count(counter);
695 m_HookFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
698 void GenContext::PrepareReturn(int v_status, int v_pContext, int v_retptr)
700 // only for non-void functions!
701 if (m_Proto.GetRet().size == 0)
704 // retptr = status >= MRES_OVERRIDE ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()
706 // OverrideRetPtr: vtblidx = 1
707 // OrigRetPtr: vtbldix = 2
708 // vtblidx = (status >= MRES_OVERRIDE) ? 1 : 2
711 // eax = pContext->GetOverrideRetPtr()
715 // eax = (status < MRES_OVERRIDE) ? 1 : 0
717 // cmp [ebp + v_status], MRES_OVERRIDE
718 // setl al <-- setcc optimization for ternary operators,
721 // lea eax, [4*eax + 0x4]
730 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
731 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
732 IA32_Xor_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
733 IA32_Cmp_Rm_Disp8_Imm8(&m_HookFunc, REG_EBP, v_status, MRES_OVERRIDE);
734 IA32_SetCC_Rm8(&m_HookFunc, REG_EAX, CC_L);
736 IA32_Lea_Reg_RegMultImm32(&m_HookFunc, REG_EAX, REG_EAX, SCALE4, 4);
738 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
739 IA32_Add_Reg_Rm(&m_HookFunc, REG_EDX, REG_EAX, MOD_REG);
741 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_MEM_REG);
742 IA32_Call_Reg(&m_HookFunc, REG_EDX);
743 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
745 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_retptr);
748 void GenContext::DoReturn(int v_retptr, int v_memret_outaddr)
750 size_t size = m_Proto.GetRet().size;
754 // Get real ret pointer into ecx
755 // mov ecx, [ebp + v_ret_ptr]
756 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_retptr);
758 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
761 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
766 if (m_Proto.GetRet().type == PassInfo::PassType_Float)
769 IA32_Fld_Mem32(&m_HookFunc, REG_ECX);
771 IA32_Fld_Mem64(&m_HookFunc, REG_ECX);
773 else if (m_Proto.GetRet().type == PassInfo::PassType_Basic ||
774 ((m_Proto.GetRet().type == PassInfo::PassType_Object) && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)) )
778 // size <= 4: return in EAX
779 // We align <4 sizes up to 4
782 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
786 // size <= 4: return in EAX:EDX
787 // We align 4<x<8 sizes up to 8
791 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
792 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, 4);
796 // size >8: return in memory
801 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
803 // *memret_outaddr = plugin_ret
804 if (m_Proto.GetRet().pCopyCtor)
806 // mov edx, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
807 // push edx <-- src addr
808 // msvc: ecx = [ebp + v_memret_outaddr] <-- dest addr
809 // gcc: push [ebp + v_memret_outaddr] <-- dest addr
813 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_REG);
814 IA32_Push_Reg(&m_HookFunc, REG_EDX);
816 #if SH_COMP == SH_COMP_MSVC
817 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_memret_outaddr);
818 #elif SH_COMP == SH_COMP_GCC
819 IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, v_memret_outaddr);
822 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pCopyCtor));
823 IA32_Call_Reg(&m_HookFunc, REG_EAX);
824 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
831 //mov edi, [ebp+v_memret_outaddr] <-- destination
832 //mov esi, ecx <-- src ( we set ecx to [ebp+v_retptr] before )
833 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDI, REG_EBP, v_memret_outaddr);
834 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESI, REG_ECX, MOD_REG);
836 BitwiseCopy_Do(m_Proto.GetRet().size);
839 // In both cases: return the pointer in EAX
840 // mov eax, [ebp + v_memret_outaddr]
841 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_memret_outaddr);
845 void GenContext::GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter,
846 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)
848 jitoffs_t counter, tmppos;
849 jitoffs_t counter2, tmppos2;
851 jitoffs_t loop_begin_counter;
853 // prev_res = MRES_IGNORED
854 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_prev_res);
856 m_HookFunc.start_count(loop_begin_counter);
858 // eax = pContext->GetNext()
865 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
866 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
868 // vtbloffs=0, vtblidx=0
869 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
870 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_MEM_REG);
871 IA32_Call_Reg(&m_HookFunc, REG_EAX);
872 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
877 IA32_Test_Rm_Reg(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
878 tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
879 m_HookFunc.start_count(counter);
881 // prev_res = MRES_IGNORED
882 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_cur_res);
889 // eax = [eax+2*SIZE_PTR]
893 jit_int32_t caller_clean_bytes = 0; // gcc always, msvc never (hooks never have varargs!)
894 // vafmt: push va_buf
895 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
897 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf);
898 IA32_Push_Reg(&m_HookFunc, REG_ECX);
899 caller_clean_bytes += SIZE_PTR;
902 caller_clean_bytes += PushParams(base_param_offset, v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
904 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
905 if (SH_COMP == SH_COMP_GCC)
906 IA32_Push_Reg(&m_HookFunc, REG_ECX);
907 caller_clean_bytes += PushMemRetPtr(v_plugin_ret, v_place_for_memret);
908 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
909 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 2*SIZE_PTR);
910 IA32_Call_Reg(&m_HookFunc, REG_EAX);
912 DestroyParams(v_place_fbrr_base);
914 SaveRetVal(v_plugin_ret, v_place_for_memret);
916 // cleanup (gcc only)
918 if (SH_COMP == SH_COMP_GCC)
919 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, caller_clean_bytes + SIZE_PTR, MOD_REG);
921 // process meta return:
922 // prev_res = cur_res
923 // if (cur_res > status) status = cur_res;
933 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
934 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDX, REG_EBP, v_status);
935 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_prev_res);
937 IA32_Cmp_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_REG);
938 tmppos2 = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NG, 0);
939 m_HookFunc.start_count(counter2);
941 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_status);
943 m_HookFunc.end_count(counter2);
944 m_HookFunc.rewrite(tmppos2, static_cast<jit_uint8_t>(counter2));
946 // process retval for non-void functions
947 ProcessPluginRetVal(v_cur_res, v_pContext, v_plugin_ret);
949 // jump back to loop begin
950 tmppos2 = IA32_Jump_Imm32(&m_HookFunc, 0);
951 m_HookFunc.end_count(loop_begin_counter);
952 m_HookFunc.rewrite(tmppos2, -static_cast<jit_int32_t>(loop_begin_counter));
954 m_HookFunc.end_count(counter);
955 m_HookFunc.rewrite(tmppos, static_cast<jit_int32_t>(counter));
958 void GenContext::GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this,
959 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)
961 jitoffs_t counter, tmppos;
962 jitoffs_t counter2, tmppos2;
963 jitoffs_t counter3, tmppos3;
965 // if (status != MRES_SUPERCEDE && pConteext->ShouldCallOrig())
966 // *v_orig_ret = orig_call()
968 // *v_orig_ret = *v_override_ret
971 // cmp eax, MRES_SUPERCEDE
973 // call pContext->ShouldCallOrig()
974 // test al, al !! important: al, not eax! bool is only stored in the LSbyte
978 // SaveRet(v_orig_ret)
979 // jmp skip_dont_call:
982 // *v_orig_ret = *v_override_ret
985 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_status);
986 IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_SUPERCEDE);
988 tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_E, 0);
989 m_HookFunc.start_count(counter);
991 // eax = pContext->ShouldCallOrig()
995 // eax = [eax + 3*SIZE_PTR]
998 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
999 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1001 // vtbloffs=0, vtblidx=3
1002 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
1003 IA32_Mov_Reg_Rm_Disp8(&m_HookFunc, REG_EAX, REG_EAX, 3*SIZE_PTR);
1004 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1005 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1007 IA32_Test_Rm_Reg8(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
1008 tmppos2 = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
1009 m_HookFunc.start_count(counter2);
1011 jit_int32_t caller_clean_bytes = 0; // gcc always, msvc when cdecl-like (varargs)
1013 // vafmt: push va_buf, then "%s"
1014 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
1016 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf);
1017 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1018 IA32_Push_Imm32(&m_HookFunc, DownCastPtr("%s"));
1019 caller_clean_bytes += 2*SIZE_PTR;
1023 caller_clean_bytes += PushParams(param_base_offs, v_orig_ret, v_place_for_memret, v_place_fbrr_base);
1026 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this);
1027 if (SH_COMP == SH_COMP_GCC)
1029 // on gcc/mingw, this is the first parameter
1030 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1031 // on msvc without varargs, simply leave it in ecx
1033 // actually, if we're returning in memory, this pointer is the second param
1034 // and the memret pointer is the real first parameter
1035 caller_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret);
1039 // On msvc, if we're returning in memory, the memret pointer is the first parameter
1040 caller_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret);
1042 // actually, with varargs, the this pointer is the first param and the memret ptr
1043 // is the second one
1044 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1046 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1051 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_vfnptr_origentry);
1052 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1055 if (SH_COMP == SH_COMP_GCC || (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs))
1056 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, caller_clean_bytes + SIZE_PTR, MOD_REG);
1058 DestroyParams(v_place_fbrr_base);
1061 SaveRetVal(v_orig_ret, v_place_for_memret);
1063 // Skip don't call variant
1064 tmppos3 = IA32_Jump_Imm32(&m_HookFunc, 0);
1065 m_HookFunc.start_count(counter3);
1069 m_HookFunc.end_count(counter);
1070 m_HookFunc.rewrite(tmppos, static_cast<jit_uint32_t>(counter));
1072 m_HookFunc.end_count(counter2);
1073 m_HookFunc.rewrite(tmppos2, static_cast<jit_uint32_t>(counter2));
1075 // *v_orig_ret = *v_override_ret
1076 if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
1078 // mov ecx, [ebp + v_override_ret]
1079 // mov [ebp + v_orig_ret], ecx
1081 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1082 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_ECX, v_orig_ret);
1086 if (m_Proto.GetRet().pAssignOperator)
1088 // lea edx, [ebp + v_override_ret] <-- src addr
1089 // lea ecx, [ebp + v_orig_ret] <-- dest addr
1090 // push edx <-- src addr
1095 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_override_ret);
1096 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1097 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1098 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1100 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
1101 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1102 GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
1107 BitwiseCopy_Setup();
1109 //lea edi, [ebp+v_orig_ret] <-- destination
1110 //lea esi, [ebp+v_override_ret] <-- src
1111 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_orig_ret);
1112 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_override_ret);
1114 BitwiseCopy_Do(m_Proto.GetRet().size);
1118 // skip don't call label target:
1119 m_HookFunc.end_count(counter3);
1120 m_HookFunc.rewrite(tmppos3, static_cast<jit_uint32_t>(counter3));
1123 // Sets *v_pContext to return value
1124 void GenContext::CallSetupHookLoop(int v_orig_ret, int v_override_ret,
1125 int v_cur_res, int v_prev_res, int v_status, int v_vfnptr_origentry,
1126 int v_this, int v_pContext)
1128 // call shptr->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this),
1129 // &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret);
1130 // The last two params are null for void funcs.
1132 if (m_Proto.GetRet().size == 0)
1135 IA32_Push_Imm8(&m_HookFunc, 0); // orig_ret
1136 IA32_Push_Imm8(&m_HookFunc, 0); // override_ret
1140 // orig_ret and override_ret
1141 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, v_override_ret);
1142 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_orig_ret);
1143 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1144 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1147 // cur_res and prev_res
1148 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
1149 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_prev_res);
1150 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1151 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1153 // status and vfnptr_origentry
1154 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_status);
1155 IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_vfnptr_origentry);
1156 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1157 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1160 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_this);
1161 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1164 // *(this + vtbloffs) + SIZE_PTR*vtblidx
1165 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this); // get this into ecx (gcc!)
1166 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, m_VtblOffs);
1167 IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_EAX, m_VtblIdx * SIZE_PTR, MOD_REG);
1168 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1171 IA32_Mov_Rm_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1172 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1173 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1176 #if SH_COMP == SH_COMP_GCC
1177 // on gcc/mingw, this is the first parameter
1178 GCC_ONLY(IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr)));
1179 #elif SH_COMP == SH_COMP_MSVC
1180 // on msvc, it's ecx
1181 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1184 // call the function. vtbloffs = 0, vtblidx = 19
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))[19]);
1189 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1191 // on gcc/mingw, we have to clean up after the call
1192 // 9 params + hidden thisptr param
1193 GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 10*SIZE_PTR, MOD_REG));
1195 // store return value
1196 IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_pContext);
1199 void GenContext::CallEndContext(int v_pContext)
1202 // shptr->EndContext(pContex)
1203 IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_pContext);
1204 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1207 #if SH_COMP == SH_COMP_GCC
1208 // on gcc/mingw, this is the first parameter
1209 IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr));
1210 #elif SH_COMP == SH_COMP_MSVC
1211 // on msvc, it's ecx
1212 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
1215 // get vtptr into edx -- we know shptr on jit time -> dereference it here!
1216 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX,
1217 (*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[20]);
1219 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1221 // on gcc/mingw, we have to clean up after the call
1222 // 1 param + hidden thisptr param
1223 GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
1226 void GenContext::ResetFrame(jit_int32_t startOffset)
1228 m_HookFunc_FrameOffset = startOffset;
1229 m_HookFunc_FrameVarsSize = 0;
1232 jit_int32_t GenContext::AddVarToFrame(jit_int32_t size)
1234 m_HookFunc_FrameOffset -= size;
1235 m_HookFunc_FrameVarsSize += size;
1236 return m_HookFunc_FrameOffset;
1239 jit_int32_t GenContext::ComputeVarsSize()
1241 return m_HookFunc_FrameVarsSize;
1244 void * GenContext::GenerateHookFunc()
1247 IA32_Push_Reg(&m_HookFunc, REG_EBP);
1248 IA32_Push_Reg(&m_HookFunc, REG_EBX);
1249 IA32_Mov_Reg_Rm(&m_HookFunc, REG_EBP, REG_ESP, MOD_REG);
1251 if ((m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs) && (m_Proto.GetRet().type == PassInfo::PassType_Object))
1252 IA32_Int3(&m_HookFunc);
1254 jit_int32_t v_this = 0;
1255 jit_int32_t param_base_offs = 0;
1256 if (SH_COMP == SH_COMP_GCC || (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs))
1258 // gcc or msvc with varargs:
1259 v_this = 12; // first param
1260 param_base_offs = 16;
1265 // on msvc without varargs, save thisptr
1267 param_base_offs = 12;
1268 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1269 ResetFrame(-4); // start placing local vars on offset -4
1270 // because there already is the thisptr variable
1273 // ********************** stack frame **********************
1274 // MSVC without varargs
1275 // second param (gcc: first real param) ebp + 16
1276 // first param (gcc: thisptr) ebp + 12
1277 // ret address: ebp + 8
1278 // caller's ebp ebp + 4
1280 // MSVC ONLY: current this ebp - 4
1281 // void *vfnptr_origentry ebp - 4 -4
1282 // META_RES status = MRES_IGNORED ebp - 8 -4
1283 // META_RES prev_res ebp - 12 -4
1284 // META_RES cur_res ebp - 16 -4
1285 // IMyDelegate *iter ebp - 20 -4
1286 // IHookContext *pContext ebp - 24 -4
1287 // == 3 ptrs + 3 enums = 24 bytes
1290 // my_rettype *ret_ptr ebp - 28 -4
1291 // my_rettype orig_ret ebp - 28 - sizeof(my_rettype) -4
1292 // my_rettype override_ret ebp - 28 - sizeof(my_rettype)*2 -4
1293 // my_rettype plugin_ret ebp - 28 - sizeof(my_rettype)*3 -4
1294 // == + 3 * sizeof(my_rettype) bytes
1297 // my_rettype place_for_memret ebp - 28 - sizeof(my_rettype)*4 -4
1299 // gcc only: if required:
1300 // place forced byref params ebp - 28 - sizeof(my_rettype)*{4 or 5}
1304 // char va_buf[something];
1307 const jit_int8_t v_vfnptr_origentry = AddVarToFrame(SIZE_PTR);
1308 const jit_int8_t v_status = AddVarToFrame(sizeof(META_RES));
1309 const jit_int8_t v_prev_res = AddVarToFrame(sizeof(META_RES));
1310 const jit_int8_t v_cur_res = AddVarToFrame(sizeof(META_RES));
1311 const jit_int8_t v_iter = AddVarToFrame(SIZE_PTR);
1312 const jit_int8_t v_pContext = AddVarToFrame(SIZE_PTR);
1314 // Memory return: first param is the address
1315 jit_int32_t v_memret_addr = 0;
1316 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1318 if (SH_COMP == SH_COMP_GCC)
1320 // gcc: now: first param = mem ret addr
1321 // second param = this pointer
1322 // third param = actual first param
1325 param_base_offs += SIZE_PTR;
1329 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1333 // first param = this pointer
1334 // second param = mem ret addr
1335 // third param = actual first param
1337 // params_base_offs is already updated to point to after the this pointer
1338 v_memret_addr = param_base_offs;
1339 param_base_offs += SIZE_PTR;
1343 v_memret_addr = param_base_offs;
1344 param_base_offs += SIZE_PTR;
1349 jit_int32_t v_ret_ptr = 0;
1350 jit_int32_t v_orig_ret = 0;
1351 jit_int32_t v_override_ret = 0;
1352 jit_int32_t v_plugin_ret = 0;
1354 if (m_Proto.GetRet().size != 0)
1356 v_ret_ptr = AddVarToFrame(SIZE_PTR);
1357 v_orig_ret = AddVarToFrame(GetStackSize(m_Proto.GetRet()));
1358 v_override_ret = AddVarToFrame(GetStackSize(m_Proto.GetRet()));
1359 v_plugin_ret = AddVarToFrame(GetStackSize(m_Proto.GetRet()));
1362 jit_int32_t v_place_for_memret = 0;
1363 if (MemRetWithTempObj())
1365 v_place_for_memret = AddVarToFrame(GetStackSize(m_Proto.GetRet()));
1368 jit_int32_t v_place_fbrr_base = 0;
1369 if (SH_COMP == SH_COMP_GCC && GetForcedByRefParamsSize())
1371 v_place_fbrr_base = AddVarToFrame(GetForcedByRefParamsSize());
1374 // Only exists for varargs functions
1375 jit_int32_t v_va_argptr = 0;
1376 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1378 v_va_argptr = AddVarToFrame(SIZE_PTR);
1381 jit_int32_t v_va_buf = 0;
1382 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
1384 v_va_buf = AddVarToFrame(SourceHook::STRBUF_LEN);
1387 IA32_Sub_Rm_Imm32(&m_HookFunc, REG_ESP, ComputeVarsSize(), MOD_REG);
1389 // init status localvar
1390 IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_status);
1392 // VarArgs: init argptr & format
1393 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs)
1395 // argptr = first vararg param
1396 // lea eax, [ebp + param_base_offs + paramssize]
1399 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_base_offs + GetParamsStackSize() + SIZE_PTR); // +SIZE_PTR: last const char * is not in protoinfo
1400 IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_va_argptr);
1402 if (m_Proto.GetConvention() & ProtoInfo::CallConv_HasVafmt)
1406 // push valist, fmt param, maxsize, buffer
1407 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1408 IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_base_offs + GetParamsStackSize()); // last given param (+4-4, see above)
1409 IA32_Push_Imm32(&m_HookFunc, SourceHook::STRBUF_LEN - 1);
1410 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_va_buf);
1411 IA32_Push_Reg(&m_HookFunc, REG_ECX);
1414 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(&vsnprintf));
1415 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1418 IA32_Add_Rm_Imm32(&m_HookFunc, REG_ESP, 0x10, MOD_REG);
1420 // Set trailing zero
1421 IA32_Xor_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_REG);
1422 IA32_Mov_Rm8_Reg8_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_va_buf + SourceHook::STRBUF_LEN - 1);
1425 // Call constructors for ret vars if required
1426 if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1427 m_Proto.GetRet().pNormalCtor)
1430 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1431 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1432 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1433 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1434 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1437 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1438 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1439 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1440 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1441 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1444 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1445 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1446 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
1447 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1448 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1450 // _don't_ call a constructor for v_place_for_memret !
1453 // ********************** SetupHookLoop **********************
1454 CallSetupHookLoop(v_orig_ret, v_override_ret, v_cur_res, v_prev_res, v_status, v_vfnptr_origentry,
1455 v_this, v_pContext);
1457 // ********************** call pre hooks **********************
1458 GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1459 v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf);
1461 // ********************** call orig func **********************
1462 GenerateCallOrig(v_status, v_pContext, param_base_offs, v_this, v_vfnptr_origentry, v_orig_ret,
1463 v_override_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf);
1465 // ********************** call post hooks **********************
1466 GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
1467 v_plugin_ret, v_place_for_memret, v_place_fbrr_base, v_va_buf);
1469 // ********************** end context and return **********************
1471 PrepareReturn(v_status, v_pContext, v_ret_ptr);
1473 CallEndContext(v_pContext);
1475 // Call destructors of byval object params which have a destructor
1476 jit_int32_t cur_param_pos = param_base_offs;
1477 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1479 const IntPassInfo &pi = m_Proto.GetParam(i);
1480 // GCC: NOT of forced byref params. the caller destructs those.
1481 if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
1482 (pi.flags & PassInfo::PassFlag_ByVal) && !(pi.flags & PassFlag_ForcedByRef))
1484 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, cur_param_pos);
1485 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
1486 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1488 cur_param_pos += GetStackSize(pi);
1491 DoReturn(v_ret_ptr, v_memret_addr);
1493 // Call destructors of orig_ret/ ...
1494 if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
1495 m_Proto.GetRet().pDtor)
1497 // Preserve return value in EAX(:EDX)
1498 IA32_Push_Reg(&m_HookFunc, REG_EAX);
1499 IA32_Push_Reg(&m_HookFunc, REG_EDX);
1501 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
1502 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1503 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1504 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1505 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1507 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
1508 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1509 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1510 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1511 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1513 IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
1514 GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
1515 IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
1516 IA32_Call_Reg(&m_HookFunc, REG_EAX);
1517 GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
1519 IA32_Pop_Reg(&m_HookFunc, REG_EDX);
1520 IA32_Pop_Reg(&m_HookFunc, REG_EAX);
1524 IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESP, REG_EBP, MOD_REG);
1525 IA32_Pop_Reg(&m_HookFunc, REG_EBX);
1526 IA32_Pop_Reg(&m_HookFunc, REG_EBP);
1528 if (SH_COMP == SH_COMP_MSVC && !(m_Proto.GetConvention() & ProtoInfo::CallConv_HasVarArgs))
1530 // msvc without varargs:
1531 // callee cleans the stack
1533 short cleansize = GetParamsStackSize();
1534 // Memory return: address is first param
1535 if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
1536 cleansize += SIZE_PTR;
1538 IA32_Return_Popstack(&m_HookFunc, cleansize);
1542 // gcc or msvc with varargs: caller cleans the stack
1543 // exception: gcc removes the memret addr on memret:
1544 if (SH_COMP == SH_COMP_GCC && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem))
1545 IA32_Return_Popstack(&m_HookFunc, SIZE_PTR);
1547 IA32_Return(&m_HookFunc);
1551 // Store pointer for later use
1552 // m_HookfuncVfnPtr is a pointer to a void* because SH expects a pointer
1553 // into the hookman's vtable
1554 *m_HookfuncVfnptr = reinterpret_cast<void*>(m_HookFunc.GetData());
1558 return m_HookFunc.GetData();
1561 // Pre-condition: GenerateHookFunc() has been called!
1562 void * GenContext::GeneratePubFunc()
1564 jitoffs_t counter, tmppos;
1566 // The pubfunc is a static cdecl function.
1568 // int HookManPubFunc(
1569 // bool store, ebp + 8
1570 // IHookManagerInfo *hi ebp + 12
1576 // hi->SetInfo(HOOKMAN_VERSION, m_VtblOffs, m_VtblIdx, m_Proto.GetProto(), m_HookfuncVfnptr)
1580 IA32_Push_Reg(&m_PubFunc, REG_EBP);
1581 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EBP, REG_ESP, MOD_REG);
1584 // save store in eax, hi in ecx
1585 IA32_Movzx_Reg32_Rm8_Disp8(&m_PubFunc, REG_EAX, REG_EBP, 8);
1586 IA32_Mov_Reg_Rm_DispAuto(&m_PubFunc, REG_ECX, REG_EBP, 12);
1588 // Check for store == 0
1589 IA32_Test_Rm_Reg8(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1590 tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1591 m_PubFunc.start_count(counter);
1593 // nonzero -> store hi
1594 IA32_Mov_Rm_Imm32(&m_PubFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
1595 IA32_Mov_Rm_Reg(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1598 m_PubFunc.end_count(counter);
1599 m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1601 // check for hi == 0
1602 IA32_Test_Rm_Reg(&m_PubFunc, REG_ECX, REG_ECX, MOD_REG);
1603 tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
1604 m_PubFunc.start_count(counter);
1606 // nonzero -> call vfunc
1607 // push params in reverse order
1608 IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_HookfuncVfnptr));
1609 IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_BuiltPI));
1610 IA32_Push_Imm32(&m_PubFunc, m_VtblIdx);
1611 IA32_Push_Imm32(&m_PubFunc, m_VtblOffs);
1612 IA32_Push_Imm32(&m_PubFunc, SH_HOOKMAN_VERSION);
1614 // hi == this is in ecx
1615 // on gcc/mingw, ecx is the first parameter
1616 #if SH_COMP == SH_COMP_GCC
1617 IA32_Push_Reg(&m_PubFunc, REG_ECX);
1620 // call the function. vtbloffs = 0, vtblidx = 0
1621 // get vtptr into edx
1622 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
1623 // get funcptr into eax
1624 IA32_Mov_Reg_Rm(&m_PubFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
1626 IA32_Call_Reg(&m_PubFunc, REG_EAX);
1628 // on gcc/mingw, we have to clean up after the call
1629 #if SH_COMP == SH_COMP_GCC
1630 // 5 params + hidden thisptr param
1631 IA32_Add_Rm_Imm8(&m_PubFunc, REG_ESP, 6*SIZE_MWORD, MOD_REG);
1635 m_PubFunc.end_count(counter);
1636 m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
1639 IA32_Xor_Reg_Rm(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
1642 IA32_Mov_Reg_Rm(&m_PubFunc, REG_ESP, REG_EBP, MOD_REG);
1643 IA32_Pop_Reg(&m_PubFunc, REG_EBP);
1644 IA32_Return(&m_PubFunc);
1651 bool GenContext::PassInfoSupported(const IntPassInfo &pi, bool is_ret)
1653 // :TODO: Error returns
1654 if (pi.type != PassInfo::PassType_Basic &&
1655 pi.type != PassInfo::PassType_Float &&
1656 pi.type != PassInfo::PassType_Object)
1661 if (pi.type == PassInfo::PassType_Object &&
1662 (pi.flags & PassInfo::PassFlag_ByVal))
1664 if ((pi.flags & PassInfo::PassFlag_CCtor) && !pi.pCopyCtor)
1669 if ((pi.flags & PassInfo::PassFlag_ODtor) && !pi.pDtor)
1674 if ((pi.flags & PassInfo::PassFlag_AssignOp) && !pi.pAssignOperator)
1679 if ((pi.flags & PassInfo::PassFlag_OCtor) && !pi.pNormalCtor)
1685 if ((pi.flags & (PassInfo::PassFlag_ByVal | PassInfo::PassFlag_ByRef)) == 0)
1687 return false; // Neither byval nor byref!
1692 void GenContext::AutoDetectRetType()
1694 IntPassInfo &pi = m_Proto.GetRet();
1696 // Only relevant for byval types
1697 if (pi.flags & PassInfo::PassFlag_ByVal)
1700 if (pi.type == PassInfo::PassType_Basic ||
1701 pi.type == PassInfo::PassType_Float)
1704 // _always_ in registers, no matter what the user says
1707 pi.flags &= ~PassInfo::PassFlag_RetMem;
1708 pi.flags |= PassInfo::PassFlag_RetReg;
1712 // Does this even exist? No idea, if it does: in memory!
1713 pi.flags &= ~PassInfo::PassFlag_RetReg;
1714 pi.flags |= PassInfo::PassFlag_RetMem;
1718 else if (pi.type == PassInfo::PassType_Object)
1720 // If the user says nothing, auto-detect
1721 if ((pi.flags & (PassInfo::PassFlag_RetMem | PassInfo::PassFlag_RetReg)) == 0)
1723 #if SH_COMP == SH_COMP_MSVC
1724 // MSVC seems to return _all_ structs, classes, unions in memory
1725 pi.flags |= PassInfo::PassFlag_RetMem;
1726 #elif SH_COMP == SH_COMP_GCC
1727 // Same goes for GCC :)
1728 pi.flags |= PassInfo::PassFlag_RetMem;
1735 // byref: make sure that the flag is _not_ set
1736 pi.flags &= ~PassInfo::PassFlag_RetMem;
1737 pi.flags |= PassInfo::PassFlag_RetReg;
1741 void GenContext::AutoDetectParamFlags()
1743 #if SH_COMP == SH_COMP_GCC
1744 // On GCC, all objects are passed by reference if they have a destructor
1745 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1747 IntPassInfo &pi = m_Proto.GetParam(i);
1748 if (pi.type == PassInfo::PassType_Object &&
1749 (pi.flags & PassInfo::PassFlag_ODtor))
1751 pi.flags |= PassFlag_ForcedByRef;
1757 HookManagerPubFunc GenContext::Generate()
1761 // Check conditions:
1762 // -1) good proto version
1763 // 0) we don't support unknown passtypes, convention, ...
1764 // 1) we don't support functions which return objects by value or take parameters by value
1765 // that have a constructor, a destructor or an overloaded assignment op
1766 // (we wouldn't know how to call it!)
1768 if (m_Proto.GetVersion() < 1)
1773 AutoDetectRetType();
1774 AutoDetectParamFlags();
1776 // Basically, we only support ThisCall/thiscall with varargs
1777 if ((m_Proto.GetConvention() & (~ProtoInfo::CallConv_HasVafmt)) != ProtoInfo::CallConv_ThisCall)
1783 if (m_Proto.GetRet().size != 0 && !PassInfoSupported(m_Proto.GetRet(), true))
1788 for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
1790 if (!PassInfoSupported(m_Proto.GetParam(i), false))
1796 return fastdelegate::detail::horrible_cast<HookManagerPubFunc>(GeneratePubFunc());
1799 HookManagerPubFunc GenContext::GetPubFunc()
1801 if (m_GeneratedPubFunc == 0)
1802 m_GeneratedPubFunc = Generate();
1804 return m_GeneratedPubFunc;
1807 bool GenContext::Equal(const CProto &proto, int vtbl_offs, int vtbl_idx)
1809 return (m_OrigProto.ExactlyEqual(proto) && m_VtblOffs == vtbl_offs && m_VtblIdx == vtbl_idx);
1812 bool GenContext::Equal(HookManagerPubFunc other)
1814 return m_GeneratedPubFunc == other;
1817 // *********************************** class GenContextContainer
1818 CHookManagerAutoGen::CHookManagerAutoGen(ISourceHook *pSHPtr) : m_pSHPtr(pSHPtr)
1822 CHookManagerAutoGen::~CHookManagerAutoGen()
1824 for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1826 delete iter->m_GenContext;
1830 int CHookManagerAutoGen::GetIfaceVersion()
1832 return SH_HOOKMANAUTOGEN_IFACE_VERSION;
1835 int CHookManagerAutoGen::GetImplVersion()
1837 return SH_HOOKMANAUTOGEN_IMPL_VERSION;
1840 HookManagerPubFunc CHookManagerAutoGen::MakeHookMan(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx)
1842 CProto mproto(proto);
1843 for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1845 if (iter->m_GenContext->Equal(mproto, vtbl_offs, vtbl_idx))
1848 return iter->m_GenContext->GetPubFunc();
1852 // Not found yet -> new one
1855 sctx.m_GenContext = new GenContext(proto, vtbl_offs, vtbl_idx, m_pSHPtr);
1857 if (sctx.m_GenContext->GetPubFunc() == NULL)
1863 m_Contexts.push_back(sctx);
1864 return sctx.m_GenContext->GetPubFunc();
1868 void CHookManagerAutoGen::ReleaseHookMan(HookManagerPubFunc pubFunc)
1870 for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
1872 if (iter->m_GenContext->Equal(pubFunc))
1875 if (iter->m_RefCnt == 0)
1877 delete iter->m_GenContext;
1878 m_Contexts.erase(iter);