sourcehook/sourcehook_hookmangen.cpp
author Pavol Marko <pavolmarko@gmail.com>
Sat Nov 10 16:32:16 2007 +0000 (2007-11-10)
branchhookman_autogen
changeset 456 9f19985c76aa
parent 455 deec66cea8cc
child 461 2fa049f36721
permissions -rw-r--r--
Removed old g_Genc stuff and fixed GenContext::Equal
pavolmarko@432
     1
/* ======== SourceHook ========
pavolmarko@432
     2
* Copyright (C) 2004-2007 Metamod:Source Development Team
pavolmarko@432
     3
* No warranties of any kind
pavolmarko@432
     4
*
pavolmarko@432
     5
* License: zlib/libpng
pavolmarko@432
     6
*
pavolmarko@432
     7
* Author(s): Pavol "PM OnoTo" Marko
pavolmarko@432
     8
* Contributor(s): Borja "faluco" Ferav  (many thanks for assitance!)
pavolmarko@432
     9
*				  David "BAILOPAN" Anderson
pavolmarko@432
    10
* ============================
pavolmarko@432
    11
*/
pavolmarko@432
    12
pavolmarko@432
    13
// recommended literature:
pavolmarko@432
    14
// http://www.cs.umbc.edu/~chang/cs313.s02/stack.shtml
pavolmarko@432
    15
// http://www.angelcode.com/dev/callconv/callconv.html
pavolmarko@432
    16
// http://www.arl.wustl.edu/~lockwood/class/cs306/books/artofasm/Chapter_6/CH06-1.html
pavolmarko@432
    17
pavolmarko@455
    18
#include "sourcehook_impl.h"
pavolmarko@432
    19
#include "sourcehook_hookmangen.h"
pavolmarko@432
    20
#include "sourcehook_hookmangen_x86.h"
pavolmarko@432
    21
#include "sh_memory.h"
pavolmarko@432
    22
pavolmarko@447
    23
#if SH_COMP == SH_COMP_MSVC
pavolmarko@447
    24
# define GCC_ONLY(x)
pavolmarko@447
    25
# define MSVC_ONLY(x) x
pavolmarko@447
    26
#elif SH_COMP == SH_COMP_GCC
pavolmarko@447
    27
# define GCC_ONLY(x) x
pavolmarko@447
    28
# define MSVC_ONLY(x)
pavolmarko@447
    29
#endif
pavolmarko@447
    30
pavolmarko@432
    31
// :TODO: test BIG vtable indices
pavolmarko@432
    32
pavolmarko@432
    33
namespace SourceHook
pavolmarko@432
    34
{
pavolmarko@432
    35
	namespace Impl
pavolmarko@432
    36
	{
pavolmarko@435
    37
		CPageAlloc GenBuffer::ms_Allocator;
pavolmarko@435
    38
pavolmarko@432
    39
		template <class T>
pavolmarko@432
    40
		jit_int32_t DownCastPtr(T ptr)
pavolmarko@432
    41
		{
pavolmarko@432
    42
			return reinterpret_cast<jit_int32_t>(ptr);
pavolmarko@432
    43
		}
pavolmarko@432
    44
pavolmarko@432
    45
		jit_uint32_t DownCastSize(size_t size)
pavolmarko@432
    46
		{
pavolmarko@432
    47
			return static_cast<jit_uint32_t>(size);
pavolmarko@432
    48
		}
pavolmarko@432
    49
pavolmarko@432
    50
		GenContext::GenContext(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx, ISourceHook *pSHPtr)
pavolmarko@456
    51
			: m_GeneratedPubFunc(NULL), m_OrigProto(proto), m_Proto(proto), m_VtblOffs(vtbl_offs),
pavolmarko@456
    52
			  m_VtblIdx(vtbl_idx), m_SHPtr(pSHPtr), m_pHI(NULL), m_HookfuncVfnptr(NULL), m_RegCounter(0)
pavolmarko@432
    53
		{
pavolmarko@432
    54
			m_pHI = new void*;
pavolmarko@432
    55
			m_HookfuncVfnptr = new void*;
pavolmarko@432
    56
			m_BuiltPI = new ProtoInfo;
pavolmarko@432
    57
			m_BuiltPI_Params = NULL;
pavolmarko@432
    58
			m_BuiltPI_Params2 = NULL;
pavolmarko@432
    59
		}
pavolmarko@432
    60
pavolmarko@432
    61
		GenContext::~GenContext()
pavolmarko@432
    62
		{
pavolmarko@432
    63
			Clear();
pavolmarko@432
    64
			delete m_pHI;
pavolmarko@432
    65
			delete m_HookfuncVfnptr;
pavolmarko@432
    66
			delete m_BuiltPI;
pavolmarko@432
    67
		}
pavolmarko@432
    68
pavolmarko@432
    69
		void GenContext::Clear()
pavolmarko@432
    70
		{
pavolmarko@432
    71
			m_HookFunc.clear();
pavolmarko@432
    72
			m_PubFunc.clear();
pavolmarko@432
    73
			if (m_BuiltPI_Params)
pavolmarko@432
    74
			{
pavolmarko@432
    75
				delete m_BuiltPI_Params;
pavolmarko@432
    76
				m_BuiltPI_Params = NULL;
pavolmarko@432
    77
			}
pavolmarko@432
    78
			if (m_BuiltPI_Params2)
pavolmarko@432
    79
			{
pavolmarko@432
    80
				delete m_BuiltPI_Params2;
pavolmarko@432
    81
				m_BuiltPI_Params2 = NULL;
pavolmarko@432
    82
			}
pavolmarko@432
    83
		}
pavolmarko@432
    84
pavolmarko@432
    85
		void GenContext::BuildProtoInfo()
pavolmarko@432
    86
		{
pavolmarko@432
    87
			m_BuiltPI->convention = m_Proto.GetConvention();
pavolmarko@432
    88
			m_BuiltPI->numOfParams = m_Proto.GetNumOfParams();
pavolmarko@432
    89
pavolmarko@432
    90
			m_BuiltPI->retPassInfo.size = m_Proto.GetRet().size;
pavolmarko@432
    91
			m_BuiltPI->retPassInfo.type = m_Proto.GetRet().type;
pavolmarko@432
    92
			m_BuiltPI->retPassInfo.flags = m_Proto.GetRet().flags;
pavolmarko@432
    93
			m_BuiltPI->retPassInfo2.pNormalCtor = m_Proto.GetRet().pNormalCtor;
pavolmarko@432
    94
			m_BuiltPI->retPassInfo2.pCopyCtor = m_Proto.GetRet().pCopyCtor;
pavolmarko@432
    95
			m_BuiltPI->retPassInfo2.pDtor = m_Proto.GetRet().pDtor;
pavolmarko@432
    96
			m_BuiltPI->retPassInfo2.pAssignOperator = m_Proto.GetRet().pAssignOperator;
pavolmarko@432
    97
pavolmarko@432
    98
			if (m_BuiltPI_Params)
pavolmarko@432
    99
				delete m_BuiltPI_Params;
pavolmarko@432
   100
			m_BuiltPI_Params = new PassInfo[m_BuiltPI->numOfParams + 1];
pavolmarko@432
   101
			if (m_BuiltPI_Params2)
pavolmarko@432
   102
				delete m_BuiltPI_Params2;
pavolmarko@432
   103
			m_BuiltPI_Params2 = new PassInfo::V2Info[m_BuiltPI->numOfParams + 1];
pavolmarko@432
   104
pavolmarko@432
   105
			m_BuiltPI_Params[0].size = 1;			// Version 1
pavolmarko@432
   106
			m_BuiltPI_Params[0].type = 0;
pavolmarko@432
   107
			m_BuiltPI_Params[0].flags = 0;
pavolmarko@432
   108
			
pavolmarko@432
   109
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@432
   110
			{
pavolmarko@432
   111
				m_BuiltPI_Params[i+1].size = m_Proto.GetParam(i).size;
pavolmarko@432
   112
				m_BuiltPI_Params[i+1].type = m_Proto.GetParam(i).type;
pavolmarko@432
   113
				m_BuiltPI_Params[i+1].flags = m_Proto.GetParam(i).flags;
pavolmarko@432
   114
pavolmarko@432
   115
				m_BuiltPI_Params2[i+1].pNormalCtor = m_Proto.GetParam(i).pNormalCtor;
pavolmarko@432
   116
				m_BuiltPI_Params2[i+1].pCopyCtor = m_Proto.GetParam(i).pCopyCtor;
pavolmarko@432
   117
				m_BuiltPI_Params2[i+1].pDtor = m_Proto.GetParam(i).pDtor;
pavolmarko@432
   118
				m_BuiltPI_Params2[i+1].pAssignOperator = m_Proto.GetParam(i).pAssignOperator;
pavolmarko@432
   119
			}
pavolmarko@432
   120
pavolmarko@432
   121
			m_BuiltPI->paramsPassInfo = m_BuiltPI_Params;
pavolmarko@432
   122
			m_BuiltPI->paramsPassInfo2 = m_BuiltPI_Params2;
pavolmarko@432
   123
		}
pavolmarko@432
   124
pavolmarko@432
   125
		jit_int32_t GenContext::GetRealSize(const IntPassInfo &info)
pavolmarko@432
   126
		{
pavolmarko@432
   127
			if (info.flags & PassInfo::PassFlag_ByRef)
pavolmarko@432
   128
			{
pavolmarko@432
   129
				return SIZE_PTR;
pavolmarko@432
   130
			}
pavolmarko@432
   131
			return static_cast<jit_int32_t>(info.size);
pavolmarko@432
   132
		}
pavolmarko@432
   133
pavolmarko@432
   134
		// Computes size on the stack
pavolmarko@432
   135
		jit_int32_t GenContext::GetStackSize(const IntPassInfo &info)
pavolmarko@432
   136
		{
pavolmarko@432
   137
			// Align up to 4 byte boundaries
pavolmarko@432
   138
			jit_int32_t rs = GetRealSize(info);
pavolmarko@432
   139
			if (rs % 4 != 0)
pavolmarko@432
   140
				rs = (rs & ~(3)) + 4;
pavolmarko@432
   141
			return rs;
pavolmarko@432
   142
		}
pavolmarko@432
   143
pavolmarko@432
   144
		jit_int8_t GenContext::NextRegEBX_ECX_EDX()
pavolmarko@432
   145
		{
pavolmarko@432
   146
			switch ((m_RegCounter++) % 3)
pavolmarko@432
   147
			{
pavolmarko@432
   148
			case 0:
pavolmarko@432
   149
				return REG_EBX;
pavolmarko@432
   150
			case 1:
pavolmarko@432
   151
				return REG_ECX;
pavolmarko@432
   152
			case 2:
pavolmarko@432
   153
			default:
pavolmarko@432
   154
				m_RegCounter = 0;
pavolmarko@432
   155
				return REG_EDX;
pavolmarko@432
   156
			}
pavolmarko@432
   157
		}
pavolmarko@432
   158
pavolmarko@437
   159
		void GenContext::BitwiseCopy_Setup()
pavolmarko@437
   160
		{
pavolmarko@437
   161
			//cld
pavolmarko@437
   162
			//push edi
pavolmarko@437
   163
			//push esi
pavolmarko@437
   164
pavolmarko@437
   165
			IA32_Cld(&m_HookFunc);
pavolmarko@437
   166
			IA32_Push_Reg(&m_HookFunc, REG_EDI);
pavolmarko@437
   167
			IA32_Push_Reg(&m_HookFunc, REG_ESI);
pavolmarko@437
   168
		}
pavolmarko@437
   169
pavolmarko@437
   170
		void GenContext::BitwiseCopy_Do(size_t size)
pavolmarko@437
   171
		{
pavolmarko@437
   172
			jit_uint32_t dwords = DownCastSize(size) / 4;
pavolmarko@437
   173
			jit_uint32_t bytes = DownCastSize(size) % 4;
pavolmarko@437
   174
pavolmarko@437
   175
			//if dwords
pavolmarko@437
   176
			// mov ecx, <dwords>
pavolmarko@437
   177
			// rep movsd
pavolmarko@437
   178
			//if bytes
pavolmarko@437
   179
			// mov ecx, <bytes>
pavolmarko@437
   180
			// rep movsb
pavolmarko@437
   181
			//pop esi
pavolmarko@437
   182
			//pop edi
pavolmarko@437
   183
pavolmarko@437
   184
			if (dwords)
pavolmarko@437
   185
			{
pavolmarko@437
   186
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, dwords);
pavolmarko@437
   187
				IA32_Rep(&m_HookFunc);
pavolmarko@437
   188
				IA32_Movsd(&m_HookFunc);
pavolmarko@437
   189
			}
pavolmarko@437
   190
			if (bytes)
pavolmarko@437
   191
			{
pavolmarko@437
   192
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, bytes);
pavolmarko@437
   193
				IA32_Rep(&m_HookFunc);
pavolmarko@437
   194
				IA32_Movsb(&m_HookFunc);
pavolmarko@437
   195
			}
pavolmarko@437
   196
			IA32_Pop_Reg(&m_HookFunc, REG_ESI);
pavolmarko@437
   197
			IA32_Pop_Reg(&m_HookFunc, REG_EDI);
pavolmarko@437
   198
		}
pavolmarko@437
   199
pavolmarko@448
   200
		short GenContext::GetParamsStackSize()
pavolmarko@448
   201
		{
pavolmarko@448
   202
			short acc = 0;
pavolmarko@448
   203
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@448
   204
			{
pavolmarko@448
   205
				acc += GetStackSize(m_Proto.GetParam(i));
pavolmarko@448
   206
			}
pavolmarko@448
   207
pavolmarko@448
   208
			// Memory return: address is first param
pavolmarko@448
   209
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
pavolmarko@448
   210
				acc += SIZE_PTR;
pavolmarko@448
   211
pavolmarko@448
   212
			// :TODO: cdecl: THIS POINTER AS FIRST PARAM!!!
pavolmarko@448
   213
pavolmarko@448
   214
			return acc;
pavolmarko@448
   215
		}
pavolmarko@448
   216
pavolmarko@448
   217
		short GenContext::GetForcedByRefParamOffset(int p)
pavolmarko@448
   218
		{
pavolmarko@448
   219
			short off = 0;
pavolmarko@448
   220
			for (int i = 0; i < p; ++i)
pavolmarko@448
   221
			{
pavolmarko@448
   222
				if (m_Proto.GetParam(i).flags & PassFlag_ForcedByRef)
pavolmarko@448
   223
					off += GetStackSize(m_Proto.GetParam(i));
pavolmarko@448
   224
			}
pavolmarko@448
   225
			return off;
pavolmarko@448
   226
		}
pavolmarko@448
   227
pavolmarko@448
   228
		short GenContext::GetForcedByRefParamsSize()
pavolmarko@448
   229
		{
pavolmarko@448
   230
			return GetForcedByRefParamOffset(m_Proto.GetNumOfParams());
pavolmarko@448
   231
		}
pavolmarko@448
   232
pavolmarko@432
   233
		jit_int32_t GenContext::PushRef(jit_int32_t param_offset, const IntPassInfo &pi)
pavolmarko@432
   234
		{
pavolmarko@432
   235
			// push [ebp+<offset>]
pavolmarko@432
   236
			IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, param_offset);
pavolmarko@432
   237
pavolmarko@432
   238
			return SIZE_PTR;
pavolmarko@432
   239
		}
pavolmarko@432
   240
pavolmarko@432
   241
		jit_int32_t GenContext::PushBasic(jit_int32_t param_offset, const IntPassInfo &pi)
pavolmarko@432
   242
		{
pavolmarko@432
   243
			int reg;
pavolmarko@432
   244
			int reg2;
pavolmarko@432
   245
pavolmarko@432
   246
			switch (pi.size)
pavolmarko@432
   247
			{
pavolmarko@432
   248
			default:
pavolmarko@432
   249
				SH_ASSERT(0, ("Unsupported!"));
pavolmarko@432
   250
				return 0;
pavolmarko@432
   251
			case 1:
pavolmarko@432
   252
				reg = NextRegEBX_ECX_EDX();
pavolmarko@432
   253
				//movzx reg, BYTE PTR [ebp+<offset>]
pavolmarko@432
   254
				//push reg
pavolmarko@432
   255
				IA32_Movzx_Reg32_Rm8_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
pavolmarko@432
   256
				IA32_Push_Reg(&m_HookFunc, reg);
pavolmarko@432
   257
pavolmarko@432
   258
				return 4;
pavolmarko@432
   259
			case 2:
pavolmarko@432
   260
				reg = NextRegEBX_ECX_EDX();
pavolmarko@432
   261
				//movzx reg, WORD PTR [ebp+<offset>]
pavolmarko@432
   262
				//push reg
pavolmarko@432
   263
				m_HookFunc.write_ubyte(IA32_16BIT_PREFIX);
pavolmarko@432
   264
				IA32_Movzx_Reg32_Rm16_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
pavolmarko@432
   265
				IA32_Push_Reg(&m_HookFunc, reg);
pavolmarko@432
   266
pavolmarko@432
   267
				return 4;
pavolmarko@432
   268
			case 4:
pavolmarko@432
   269
				reg = NextRegEBX_ECX_EDX();
pavolmarko@432
   270
				//mov reg, DWORD PTR [ebp+<offset>]
pavolmarko@432
   271
				//push reg
pavolmarko@432
   272
				IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset);
pavolmarko@432
   273
				IA32_Push_Reg(&m_HookFunc, reg);
pavolmarko@432
   274
pavolmarko@432
   275
				return 4;
pavolmarko@432
   276
			case 8:
pavolmarko@432
   277
				reg = NextRegEBX_ECX_EDX();
pavolmarko@432
   278
				reg2 = NextRegEBX_ECX_EDX();
pavolmarko@432
   279
				//mov reg, DWORD PTR [ebp+<offset>+4]
pavolmarko@432
   280
				//mov reg2, DWORD PTR [ebp+<offset>]
pavolmarko@432
   281
				//push reg
pavolmarko@432
   282
				//push reg2
pavolmarko@432
   283
pavolmarko@432
   284
				IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg, REG_EBP, param_offset+4);
pavolmarko@432
   285
				IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, reg2, REG_EBP, param_offset);
pavolmarko@432
   286
				IA32_Push_Reg(&m_HookFunc, reg);
pavolmarko@432
   287
				IA32_Push_Reg(&m_HookFunc, reg2);
pavolmarko@432
   288
pavolmarko@432
   289
				return 8;
pavolmarko@432
   290
			}
pavolmarko@432
   291
		}
pavolmarko@432
   292
pavolmarko@432
   293
		jit_int32_t GenContext::PushFloat(jit_int32_t param_offset, const IntPassInfo &pi)
pavolmarko@432
   294
		{
pavolmarko@432
   295
			switch (pi.size)
pavolmarko@432
   296
			{
pavolmarko@432
   297
			default:
pavolmarko@432
   298
				SH_ASSERT(0, ("Unsupported!"));
pavolmarko@432
   299
				return 0;
pavolmarko@432
   300
			case 4:
pavolmarko@432
   301
				//fld DWORD PTR [ebp+<offset>]
pavolmarko@432
   302
				//push reg
pavolmarko@432
   303
				//fstp DWORD PTR [esp]
pavolmarko@432
   304
				IA32_Fld_Mem32_DispAuto(&m_HookFunc, REG_EBP, param_offset);
pavolmarko@432
   305
				IA32_Push_Reg(&m_HookFunc, NextRegEBX_ECX_EDX());
pavolmarko@432
   306
				IA32_Fstp_Mem32_ESP(&m_HookFunc);
pavolmarko@432
   307
				return 4;
pavolmarko@432
   308
			case 8:
pavolmarko@432
   309
				//fld QWORD PTR [ebp+<offset>]
pavolmarko@432
   310
				//sub esp, 8
pavolmarko@432
   311
				//fstp QWORD PTR [esp]
pavolmarko@432
   312
				IA32_Fld_Mem64_DispAuto(&m_HookFunc, REG_EBP, param_offset);
pavolmarko@432
   313
				IA32_Sub_Rm_Imm8(&m_HookFunc, REG_ESP, 8, MOD_REG);
pavolmarko@432
   314
				IA32_Fstp_Mem64_ESP(&m_HookFunc);
pavolmarko@432
   315
				return 8;
pavolmarko@432
   316
			}
pavolmarko@432
   317
		}
pavolmarko@432
   318
pavolmarko@448
   319
		jit_int32_t GenContext::PushObject(jit_int32_t param_offset, const IntPassInfo &pi, jit_int32_t place_fbrr)
pavolmarko@432
   320
		{
pavolmarko@448
   321
			if ((pi.flags & PassFlag_ForcedByRef) == 0)
pavolmarko@448
   322
			{
pavolmarko@448
   323
				// make room on the stack
pavolmarko@448
   324
				// sub esp, <size>
pavolmarko@448
   325
				IA32_Sub_Rm_ImmAuto(&m_HookFunc, REG_ESP, GetStackSize(pi), MOD_REG);
pavolmarko@448
   326
			}
pavolmarko@432
   327
pavolmarko@432
   328
			// if there is a copy constructor..
pavolmarko@432
   329
			if (pi.pCopyCtor)
pavolmarko@432
   330
			{
pavolmarko@432
   331
				// save eax
pavolmarko@432
   332
				// push src addr
pavolmarko@448
   333
				// this= target addr = forcedbyref ? ebp+place_fbrr : esp+12
pavolmarko@432
   334
				// call copy constructor
pavolmarko@432
   335
				// restore eax
pavolmarko@432
   336
			
pavolmarko@432
   337
				IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@448
   338
				
pavolmarko@448
   339
				if (pi.flags & PassFlag_ForcedByRef)
pavolmarko@448
   340
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
pavolmarko@448
   341
				else
pavolmarko@448
   342
					IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_ECX, REG_NOIDX, REG_ESP, NOSCALE, 4);
pavolmarko@448
   343
				
pavolmarko@432
   344
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, param_offset);
pavolmarko@432
   345
				IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
   346
				GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   347
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(pi.pCopyCtor));
pavolmarko@432
   348
				IA32_Call_Reg(&m_HookFunc, REG_EDX);
pavolmarko@447
   349
				GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
pavolmarko@432
   350
				IA32_Pop_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
   351
			}
pavolmarko@432
   352
			else
pavolmarko@432
   353
			{
pavolmarko@432
   354
				// bitwise copy
pavolmarko@432
   355
pavolmarko@437
   356
				
pavolmarko@437
   357
				BitwiseCopy_Setup();
pavolmarko@437
   358
pavolmarko@448
   359
				//if forcedbyref:
pavolmarko@448
   360
				//  lea edi, [ebp_place_fbrr]
pavolmarko@448
   361
				//else
pavolmarko@448
   362
				//  lea edi, [esp+8]			-  bc_setup pushed two regs onto the stack!
pavolmarko@432
   363
				//lea esi, [ebp+<offs>]
pavolmarko@448
   364
				if (pi.flags & PassFlag_ForcedByRef)
pavolmarko@448
   365
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, place_fbrr);
pavolmarko@448
   366
				else
pavolmarko@448
   367
					IA32_Lea_Reg_DispRegMultImm8(&m_HookFunc, REG_EDI, REG_NOIDX, REG_ESP, NOSCALE, 8);
pavolmarko@448
   368
pavolmarko@432
   369
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, param_offset);
pavolmarko@437
   370
pavolmarko@437
   371
				BitwiseCopy_Do(pi.size);
pavolmarko@432
   372
			}
pavolmarko@432
   373
pavolmarko@448
   374
			// forcedref: push reference to ebp+place_fbrr
pavolmarko@448
   375
			if (pi.flags & PassFlag_ForcedByRef)
pavolmarko@448
   376
			{
pavolmarko@448
   377
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, place_fbrr);
pavolmarko@448
   378
				IA32_Push_Reg(&m_HookFunc, REG_ECX);
pavolmarko@448
   379
				return SIZE_PTR;
pavolmarko@448
   380
			}
pavolmarko@448
   381
			
pavolmarko@432
   382
			return DownCastSize(pi.size);
pavolmarko@432
   383
		}
pavolmarko@432
   384
pavolmarko@448
   385
		void GenContext::DestroyParams(jit_int32_t fbrr_base)
pavolmarko@448
   386
		{
pavolmarko@448
   387
			for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
pavolmarko@448
   388
			{
pavolmarko@448
   389
				const IntPassInfo &pi = m_Proto.GetParam(i);
pavolmarko@448
   390
				if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
pavolmarko@448
   391
					(pi.flags & PassInfo::PassFlag_ByVal) && (pi.flags & PassFlag_ForcedByRef))
pavolmarko@448
   392
				{
pavolmarko@448
   393
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, fbrr_base + GetForcedByRefParamOffset(i));
pavolmarko@448
   394
					IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
pavolmarko@448
   395
					IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@448
   396
				}
pavolmarko@448
   397
			}
pavolmarko@448
   398
		}
pavolmarko@448
   399
		
pavolmarko@432
   400
		// May not touch eax!
pavolmarko@448
   401
		jit_int32_t GenContext::PushParams(jit_int32_t param_base_offset, jit_int32_t save_ret_to, int v_place_for_memret,
pavolmarko@448
   402
				jit_int32_t v_place_fbrr_base)
pavolmarko@432
   403
		{
pavolmarko@432
   404
			jit_int32_t added_to_stack = 0;
pavolmarko@432
   405
			jit_int32_t ret = 0;
pavolmarko@432
   406
pavolmarko@432
   407
			// compute the offset _after_ the last parameter
pavolmarko@432
   408
			jit_int32_t cur_offset = param_base_offset;
pavolmarko@432
   409
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@432
   410
			{
pavolmarko@432
   411
				cur_offset += GetStackSize(m_Proto.GetParam(i));
pavolmarko@432
   412
			}
pavolmarko@432
   413
pavolmarko@432
   414
			// push parameters in reverse order
pavolmarko@432
   415
			for (int i = m_Proto.GetNumOfParams() - 1; i >= 0; --i)
pavolmarko@432
   416
			{
pavolmarko@432
   417
				const IntPassInfo &pi = m_Proto.GetParam(i);
pavolmarko@432
   418
				cur_offset -= GetStackSize(pi);
pavolmarko@432
   419
				if (pi.flags & PassInfo::PassFlag_ByVal)
pavolmarko@432
   420
				{
pavolmarko@432
   421
					switch (pi.type)
pavolmarko@432
   422
					{
pavolmarko@432
   423
					case PassInfo::PassType_Basic:
pavolmarko@432
   424
						ret = PushBasic(cur_offset, pi);
pavolmarko@432
   425
						break;
pavolmarko@432
   426
					case PassInfo::PassType_Float:
pavolmarko@432
   427
						ret = PushFloat(cur_offset, pi);
pavolmarko@432
   428
						break;
pavolmarko@432
   429
					case PassInfo::PassType_Object:
pavolmarko@448
   430
						ret = PushObject(cur_offset, pi, v_place_fbrr_base + GetForcedByRefParamOffset(i));
pavolmarko@432
   431
						break;
pavolmarko@432
   432
					}
pavolmarko@432
   433
				}
pavolmarko@432
   434
				else if (pi.flags & PassInfo::PassFlag_ByRef)
pavolmarko@432
   435
				{
pavolmarko@432
   436
					PushRef(cur_offset, pi);
pavolmarko@432
   437
				}
pavolmarko@432
   438
				else
pavolmarko@432
   439
				{
pavolmarko@432
   440
					SH_ASSERT(0, ("Unsupported!"));
pavolmarko@432
   441
				}
pavolmarko@432
   442
				added_to_stack += ret;
pavolmarko@432
   443
			}
pavolmarko@436
   444
pavolmarko@449
   445
			return added_to_stack;
pavolmarko@449
   446
		}
pavolmarko@449
   447
pavolmarko@449
   448
		// It is IMPORTANT that PushMemRetPtr doesn't touch ecx and eax
pavolmarko@449
   449
		jit_int32_t GenContext::PushMemRetPtr(jit_int32_t save_ret_to, jit_int32_t v_place_for_memret)
pavolmarko@449
   450
		{
pavolmarko@436
   451
			// Memory return support
pavolmarko@436
   452
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
pavolmarko@436
   453
			{
pavolmarko@436
   454
				// push address where to save it!
pavolmarko@449
   455
				int reg = REG_EDX;
pavolmarko@437
   456
				IA32_Lea_DispRegImmAuto(&m_HookFunc, reg, REG_EBP,
pavolmarko@437
   457
					MemRetWithTempObj() ? v_place_for_memret : save_ret_to);
pavolmarko@436
   458
				IA32_Push_Reg(&m_HookFunc, reg);
pavolmarko@436
   459
pavolmarko@449
   460
				return (SH_COMP==SH_COMP_MSVC) ? 4 : 0;			// varargs funcs on msvc might need this.
pavolmarko@449
   461
																// gcc doesn't: callee cleans the memret ptr, caller the other params :s
pavolmarko@436
   462
			}
pavolmarko@449
   463
			return 0;
pavolmarko@432
   464
		}
pavolmarko@432
   465
pavolmarko@437
   466
		void GenContext::SaveRetVal(int v_where, int v_place_for_memret)
pavolmarko@432
   467
		{
pavolmarko@438
   468
			size_t size = GetRealSize(m_Proto.GetRet());
pavolmarko@432
   469
			if (size == 0)
pavolmarko@432
   470
			{
pavolmarko@432
   471
				// No return value -> nothing
pavolmarko@432
   472
				return;
pavolmarko@432
   473
			}
pavolmarko@432
   474
pavolmarko@438
   475
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
pavolmarko@438
   476
			{
pavolmarko@438
   477
				// mov [ebp + v_plugin_ret], eax
pavolmarko@438
   478
				IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
pavolmarko@438
   479
				return;
pavolmarko@438
   480
			}
pavolmarko@438
   481
			// else: ByVal
pavolmarko@438
   482
pavolmarko@438
   483
pavolmarko@436
   484
			// Memory return:
pavolmarko@436
   485
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
pavolmarko@437
   486
			{
pavolmarko@437
   487
				if (MemRetWithTempObj())
pavolmarko@437
   488
				{
pavolmarko@437
   489
					// *v_where = *v_place_for_memret
pavolmarko@437
   490
pavolmarko@437
   491
					// if we have an assign operator, use that
pavolmarko@437
   492
					if (m_Proto.GetRet().pAssignOperator)
pavolmarko@437
   493
					{
pavolmarko@437
   494
						// lea edx, [ebp + v_place_for_memret]  <-- src addr
pavolmarko@437
   495
						// lea ecx, [ebp + v_where]				<-- dest addr
pavolmarko@447
   496
						// push edx
pavolmarko@437
   497
						// gcc: push ecx
pavolmarko@437
   498
						// call it
pavolmarko@447
   499
						// gcc: clean up
pavolmarko@437
   500
pavolmarko@437
   501
						IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_place_for_memret);
pavolmarko@437
   502
						IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_where);
pavolmarko@437
   503
						IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@447
   504
						GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
   505
pavolmarko@437
   506
						IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
pavolmarko@437
   507
						IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
   508
						GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
   509
					}
pavolmarko@437
   510
					else
pavolmarko@437
   511
					{
pavolmarko@437
   512
						// bitwise copy
pavolmarko@437
   513
						BitwiseCopy_Setup();
pavolmarko@437
   514
pavolmarko@437
   515
						//lea edi, [evp+v_where]		<-- destination
pavolmarko@437
   516
						//lea esi, [ebp+v_place_for_memret]	<-- src
pavolmarko@437
   517
						IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_where);
pavolmarko@437
   518
						IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_place_for_memret);
pavolmarko@437
   519
pavolmarko@437
   520
						BitwiseCopy_Do(m_Proto.GetRet().size);
pavolmarko@437
   521
					}
pavolmarko@437
   522
pavolmarko@437
   523
					// Then: destruct *v_place_for_memret if required
pavolmarko@437
   524
					if (m_Proto.GetRet().pDtor)
pavolmarko@437
   525
					{
pavolmarko@437
   526
						//lea ecx, [ebp+v_place_for_memret]
pavolmarko@437
   527
						//gcc: push ecx
pavolmarko@437
   528
						//call it
pavolmarko@447
   529
						//gcc: clean up
pavolmarko@437
   530
pavolmarko@437
   531
						IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_place_for_memret);
pavolmarko@447
   532
						GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
   533
						IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
pavolmarko@437
   534
						IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
   535
						GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
   536
					}
pavolmarko@437
   537
				}
pavolmarko@437
   538
				else
pavolmarko@437
   539
				{
pavolmarko@437
   540
					// Already copied to correct address -> we're done
pavolmarko@437
   541
					return;
pavolmarko@437
   542
				}
pavolmarko@437
   543
			}
pavolmarko@436
   544
pavolmarko@432
   545
			if (m_Proto.GetRet().type == PassInfo::PassType_Float)
pavolmarko@432
   546
			{
pavolmarko@432
   547
				if (size == 4)
pavolmarko@432
   548
					IA32_Fstp_Mem32_DispAuto(&m_HookFunc, REG_EBP, v_where);
pavolmarko@432
   549
				else if (size == 8)
pavolmarko@432
   550
					IA32_Fstp_Mem64_DispAuto(&m_HookFunc, REG_EBP, v_where);
pavolmarko@432
   551
			}
pavolmarko@432
   552
			else if (m_Proto.GetRet().type == PassInfo::PassType_Basic)
pavolmarko@432
   553
			{
pavolmarko@432
   554
				if (size <= 4)
pavolmarko@432
   555
				{
pavolmarko@432
   556
					// size <= 4: return in EAX
pavolmarko@432
   557
					//  We align <4 sizes up to 4
pavolmarko@432
   558
pavolmarko@432
   559
pavolmarko@432
   560
					// mov [ebp + v_plugin_ret], eax
pavolmarko@432
   561
					IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
pavolmarko@432
   562
				}
pavolmarko@432
   563
				else if (size <= 8)
pavolmarko@432
   564
				{
pavolmarko@432
   565
					// size <= 4: return in EAX:EDX
pavolmarko@432
   566
					//  We align 4<x<8 sizes up to 8
pavolmarko@432
   567
pavolmarko@432
   568
					// mov [ebp + v_plugin_ret], eax
pavolmarko@432
   569
					// mov [ebp + v_plugin_ret + 4], edx
pavolmarko@432
   570
					IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
pavolmarko@432
   571
					IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
pavolmarko@432
   572
				}
pavolmarko@436
   573
			}
pavolmarko@436
   574
			else if (m_Proto.GetRet().type == PassInfo::PassType_Object)
pavolmarko@436
   575
			{
pavolmarko@436
   576
				if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)
pavolmarko@432
   577
				{
pavolmarko@436
   578
					if (size <= 4)
pavolmarko@436
   579
					{
pavolmarko@436
   580
						// size <= 4: return in EAX
pavolmarko@436
   581
						//  We align <4 sizes up to 4
pavolmarko@436
   582
pavolmarko@436
   583
						// mov [ebp + v_plugin_ret], eax
pavolmarko@436
   584
						IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
pavolmarko@436
   585
					}
pavolmarko@436
   586
					else if (size <= 8)
pavolmarko@436
   587
					{
pavolmarko@436
   588
						// size <= 4: return in EAX:EDX
pavolmarko@436
   589
						//  We align 4<x<8 sizes up to 8
pavolmarko@436
   590
pavolmarko@436
   591
						// mov [ebp + v_plugin_ret], eax
pavolmarko@436
   592
						// mov [ebp + v_plugin_ret + 4], edx
pavolmarko@436
   593
						IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_where);
pavolmarko@436
   594
						IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EDX, v_where + 4);
pavolmarko@436
   595
					}
pavolmarko@436
   596
					else
pavolmarko@436
   597
					{
pavolmarko@436
   598
						SH_ASSERT(0, ("RetReg and size > 8 !"));
pavolmarko@436
   599
					}
pavolmarko@432
   600
				}
pavolmarko@432
   601
			}
pavolmarko@432
   602
		}
pavolmarko@432
   603
pavolmarko@437
   604
		bool GenContext::MemRetWithTempObj()
pavolmarko@437
   605
		{
pavolmarko@437
   606
			// Memory return AND (has destructor OR has assign operator)
pavolmarko@437
   607
			return ((m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
pavolmarko@437
   608
				&& (m_Proto.GetRet().flags & (PassInfo::PassFlag_ODtor | PassInfo::PassFlag_AssignOp)));
pavolmarko@437
   609
		}
pavolmarko@437
   610
pavolmarko@432
   611
		void GenContext::ProcessPluginRetVal(int v_cur_res, int v_pContext, int v_plugin_ret)
pavolmarko@432
   612
		{
pavolmarko@432
   613
			// only for non-void functions!
pavolmarko@432
   614
			if (m_Proto.GetRet().size == 0)
pavolmarko@432
   615
				return;
pavolmarko@432
   616
pavolmarko@432
   617
			// if (cur_res >= MRES_OVERRIDE)
pavolmarko@432
   618
			//   *reinterpret_cast<my_rettype*>(pContext->GetOverrideRetPtr()) = plugin_ret;
pavolmarko@432
   619
pavolmarko@432
   620
			//  eax = cur_res
pavolmarko@432
   621
			//  cmp eax,MRES_OVERRIDE
pavolmarko@432
   622
			//  jnge thelabel
pavolmarko@432
   623
			//    pContext->GetOverrideRetPtr()   -->  overrideretptr in eax
pavolmarko@432
   624
			//    *eax = plugin_ret
pavolmarko@432
   625
			//  thelabel:
pavolmarko@432
   626
			//
pavolmarko@432
   627
pavolmarko@432
   628
			jitoffs_t tmppos, counter;
pavolmarko@432
   629
pavolmarko@432
   630
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
pavolmarko@432
   631
pavolmarko@432
   632
			IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_OVERRIDE);
pavolmarko@432
   633
			tmppos = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NGE, 0);
pavolmarko@432
   634
			m_HookFunc.start_count(counter);
pavolmarko@432
   635
pavolmarko@432
   636
			// eax = pContext->GetOverrideRetPtr()
pavolmarko@432
   637
			//   ECX = pContext
pavolmarko@432
   638
			//   gcc: push ecx
pavolmarko@432
   639
			//   eax = [ecx]
pavolmarko@432
   640
			//   eax = [eax + 4]
pavolmarko@432
   641
			//   call eax
pavolmarko@447
   642
			//   gcc: clean up
pavolmarko@432
   643
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
pavolmarko@447
   644
			GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   645
pavolmarko@432
   646
			// vtbloffs=0, vtblidx=1
pavolmarko@432
   647
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   648
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 4);
pavolmarko@432
   649
			IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
   650
			GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   651
pavolmarko@432
   652
pavolmarko@432
   653
			// *eax = plugin_ret
pavolmarko@438
   654
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
pavolmarko@432
   655
			{
pavolmarko@438
   656
				// mov ecx, [ebp+v_plugin_ret]
pavolmarko@438
   657
				// mov [eax], ecx
pavolmarko@438
   658
				IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
pavolmarko@438
   659
				IA32_Mov_Rm_Reg(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   660
			}
pavolmarko@432
   661
			else
pavolmarko@432
   662
			{
pavolmarko@438
   663
				if (m_Proto.GetRet().pAssignOperator)
pavolmarko@438
   664
				{
pavolmarko@438
   665
					// lea edx, [ebp + v_plugin_ret]
pavolmarko@447
   666
					// push edx					<-- src addr
pavolmarko@438
   667
					// msvc: ecx = eax				<-- dest addr
pavolmarko@438
   668
					// gcc: push eax				<-- dest addr
pavolmarko@438
   669
					// call it
pavolmarko@447
   670
					// gcc: clean up
pavolmarko@438
   671
pavolmarko@438
   672
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_plugin_ret);
pavolmarko@447
   673
					IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@438
   674
#if SH_COMP == SH_COMP_MSVC
pavolmarko@438
   675
					IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
pavolmarko@438
   676
#elif SH_COMP == SH_COMP_GCC
pavolmarko@438
   677
					IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@438
   678
#endif
pavolmarko@432
   679
pavolmarko@438
   680
					IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
pavolmarko@438
   681
					IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
   682
					GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
pavolmarko@438
   683
				}
pavolmarko@438
   684
				else
pavolmarko@438
   685
				{
pavolmarko@438
   686
					// bitwise copy
pavolmarko@438
   687
					BitwiseCopy_Setup();
pavolmarko@437
   688
pavolmarko@438
   689
					//mov edi, eax					<-- destination
pavolmarko@438
   690
					//lea esi, [ebp+v_plugin_ret]	<-- src
pavolmarko@438
   691
					IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDI, REG_EAX, MOD_REG);
pavolmarko@438
   692
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_plugin_ret);
pavolmarko@438
   693
pavolmarko@438
   694
					BitwiseCopy_Do(m_Proto.GetRet().size);
pavolmarko@438
   695
				}
pavolmarko@432
   696
			}
pavolmarko@432
   697
pavolmarko@432
   698
			m_HookFunc.end_count(counter);
pavolmarko@432
   699
			m_HookFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
pavolmarko@432
   700
		}
pavolmarko@432
   701
pavolmarko@432
   702
		void GenContext::PrepareReturn(int v_status, int v_pContext, int v_retptr)
pavolmarko@432
   703
		{
pavolmarko@432
   704
			// only for non-void functions!
pavolmarko@432
   705
			if (m_Proto.GetRet().size == 0)
pavolmarko@432
   706
				return;
pavolmarko@432
   707
pavolmarko@432
   708
			// retptr = status >= MRES_OVERRIDE ? pContext->GetOverrideRetPtr() : pContext->GetOrigRetPtr()
pavolmarko@432
   709
pavolmarko@432
   710
			// OverrideRetPtr: vtblidx = 1
pavolmarko@432
   711
			// OrigRetPtr: vtbldix = 2
pavolmarko@432
   712
			//  vtblidx = (status >= MRES_OVERRIDE) ? 1 : 2
pavolmarko@432
   713
pavolmarko@432
   714
			// 
pavolmarko@432
   715
			// eax = pContext->GetOverrideRetPtr()
pavolmarko@432
   716
			//   ECX = pContext
pavolmarko@432
   717
			//   gcc: push ecx
pavolmarko@432
   718
pavolmarko@432
   719
			// eax = (status < MRES_OVERRIDE) ? 1 : 0
pavolmarko@432
   720
			//   xor eax, eax
pavolmarko@432
   721
			//   cmp [ebp + v_status], MRES_OVERRIDE
pavolmarko@432
   722
			//   setl al								<-- setcc optimization for ternary operators, 
pavolmarko@432
   723
			
pavolmarko@432
   724
pavolmarko@432
   725
			//   lea eax, [4*eax + 0x4]
pavolmarko@432
   726
pavolmarko@432
   727
			//   edx = [ecx]
pavolmarko@432
   728
			//   add edx, eax
pavolmarko@432
   729
			//   mov edx, [edx]
pavolmarko@432
   730
pavolmarko@432
   731
			//   call edx
pavolmarko@447
   732
			// gcc: clean up
pavolmarko@432
   733
pavolmarko@432
   734
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
pavolmarko@447
   735
			GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   736
			IA32_Xor_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
pavolmarko@432
   737
			IA32_Cmp_Rm_Disp8_Imm8(&m_HookFunc, REG_EBP, v_status, MRES_OVERRIDE);
pavolmarko@432
   738
			IA32_SetCC_Rm8(&m_HookFunc, REG_EAX, CC_L);
pavolmarko@432
   739
pavolmarko@432
   740
			IA32_Lea_Reg_RegMultImm32(&m_HookFunc, REG_EAX, REG_EAX, SCALE4, 4);
pavolmarko@432
   741
pavolmarko@432
   742
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   743
			IA32_Add_Reg_Rm(&m_HookFunc, REG_EDX, REG_EAX, MOD_REG);
pavolmarko@432
   744
pavolmarko@432
   745
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_EDX, MOD_MEM_REG);
pavolmarko@432
   746
			IA32_Call_Reg(&m_HookFunc, REG_EDX);
pavolmarko@447
   747
			GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   748
pavolmarko@432
   749
			IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_EAX, v_retptr);
pavolmarko@432
   750
		}
pavolmarko@432
   751
pavolmarko@436
   752
		void GenContext::DoReturn(int v_retptr, int v_memret_outaddr)
pavolmarko@432
   753
		{
pavolmarko@432
   754
			size_t size = m_Proto.GetRet().size;
pavolmarko@432
   755
			if (!size)
pavolmarko@432
   756
				return;
pavolmarko@432
   757
pavolmarko@432
   758
			// Get real ret pointer into ecx
pavolmarko@432
   759
			// mov ecx, [ebp + v_ret_ptr]
pavolmarko@432
   760
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_retptr);
pavolmarko@432
   761
pavolmarko@438
   762
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
pavolmarko@438
   763
			{
pavolmarko@438
   764
				// mov eax, [ecx]
pavolmarko@438
   765
				IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@438
   766
				return;
pavolmarko@438
   767
			}
pavolmarko@438
   768
			// else: byval
pavolmarko@438
   769
pavolmarko@432
   770
			if (m_Proto.GetRet().type == PassInfo::PassType_Float)
pavolmarko@432
   771
			{
pavolmarko@432
   772
				if (size == 4)
pavolmarko@432
   773
					IA32_Fld_Mem32(&m_HookFunc, REG_ECX);
pavolmarko@432
   774
				else if (size == 8)
pavolmarko@432
   775
					IA32_Fld_Mem64(&m_HookFunc, REG_ECX);
pavolmarko@432
   776
			}
pavolmarko@436
   777
			else if (m_Proto.GetRet().type == PassInfo::PassType_Basic || 
pavolmarko@436
   778
				((m_Proto.GetRet().type == PassInfo::PassType_Object) && (m_Proto.GetRet().flags & PassInfo::PassFlag_RetReg)) )
pavolmarko@432
   779
			{
pavolmarko@432
   780
				if (size <= 4)
pavolmarko@432
   781
				{
pavolmarko@432
   782
					// size <= 4: return in EAX
pavolmarko@432
   783
					//  We align <4 sizes up to 4
pavolmarko@432
   784
pavolmarko@432
   785
					// mov eax, [ecx]
pavolmarko@432
   786
					IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   787
				}
pavolmarko@432
   788
				else if (size <= 8)
pavolmarko@432
   789
				{
pavolmarko@432
   790
					// size <= 4: return in EAX:EDX
pavolmarko@432
   791
					//  We align 4<x<8 sizes up to 8
pavolmarko@432
   792
pavolmarko@432
   793
					// mov eax, [ecx]
pavolmarko@432
   794
					// mov edx, [ecx+4]
pavolmarko@432
   795
					IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   796
					IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, 4);
pavolmarko@432
   797
				}
pavolmarko@432
   798
				else
pavolmarko@432
   799
				{
pavolmarko@432
   800
					// size >8: return in memory
pavolmarko@436
   801
					//  handled later
pavolmarko@432
   802
				}
pavolmarko@432
   803
			}
pavolmarko@436
   804
pavolmarko@436
   805
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
pavolmarko@436
   806
			{
pavolmarko@436
   807
				// *memret_outaddr = plugin_ret
pavolmarko@437
   808
				if (m_Proto.GetRet().pCopyCtor)
pavolmarko@436
   809
				{
pavolmarko@436
   810
					// mov edx, ecx				<-- src	( we set ecx to [ebp+v_retptr] before )
pavolmarko@447
   811
					// push edx					<-- src addr
pavolmarko@436
   812
					// msvc: ecx = [ebp + v_memret_outaddr]				<-- dest addr
pavolmarko@436
   813
					// gcc: push [ebp + v_memret_outaddr]				<-- dest addr
pavolmarko@436
   814
					// call it
pavolmarko@447
   815
					// gcc: clean up
pavolmarko@436
   816
pavolmarko@436
   817
					IA32_Mov_Reg_Rm(&m_HookFunc, REG_EDX, REG_ECX, MOD_REG);
pavolmarko@447
   818
					IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@436
   819
pavolmarko@436
   820
#if SH_COMP == SH_COMP_MSVC
pavolmarko@436
   821
					IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_memret_outaddr);
pavolmarko@436
   822
#elif SH_COMP == SH_COMP_GCC
pavolmarko@436
   823
					IA32_Push_Rm_DispAuto(&m_HookFunc, REG_EBP, v_memret_outaddr);
pavolmarko@436
   824
#endif
pavolmarko@436
   825
pavolmarko@437
   826
					IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pCopyCtor));
pavolmarko@436
   827
					IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
   828
					GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2 * SIZE_PTR, MOD_REG));
pavolmarko@436
   829
				}
pavolmarko@436
   830
				else
pavolmarko@436
   831
				{
pavolmarko@436
   832
					// bitwise copy
pavolmarko@437
   833
					BitwiseCopy_Setup();
pavolmarko@436
   834
					
pavolmarko@436
   835
					//mov edi, [ebp+v_memret_outaddr]		<-- destination
pavolmarko@436
   836
					//mov esi, ecx						<-- src	( we set ecx to [ebp+v_retptr] before )
pavolmarko@436
   837
					IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDI, REG_EBP, v_memret_outaddr);
pavolmarko@436
   838
					IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESI, REG_ECX, MOD_REG);
pavolmarko@437
   839
pavolmarko@437
   840
					BitwiseCopy_Do(m_Proto.GetRet().size);
pavolmarko@436
   841
				}
pavolmarko@436
   842
pavolmarko@436
   843
				// In both cases: return the pointer in EAX
pavolmarko@436
   844
				// mov eax, [ebp + v_memret_outaddr]
pavolmarko@436
   845
				IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_memret_outaddr);
pavolmarko@436
   846
			}
pavolmarko@432
   847
		}
pavolmarko@432
   848
pavolmarko@432
   849
		void GenContext::GenerateCallHooks(int v_status, int v_prev_res, int v_cur_res, int v_iter,
pavolmarko@448
   850
			int v_pContext, int base_param_offset, int v_plugin_ret, int v_place_for_memret, jit_int32_t v_place_fbrr_base)
pavolmarko@432
   851
		{
pavolmarko@432
   852
			jitoffs_t counter, tmppos;
pavolmarko@432
   853
			jitoffs_t counter2, tmppos2;
pavolmarko@432
   854
pavolmarko@432
   855
			jitoffs_t loop_begin_counter;
pavolmarko@432
   856
pavolmarko@432
   857
			// prev_res = MRES_IGNORED
pavolmarko@432
   858
			IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_prev_res);
pavolmarko@432
   859
pavolmarko@432
   860
			m_HookFunc.start_count(loop_begin_counter);
pavolmarko@432
   861
pavolmarko@432
   862
			// eax = pContext->GetNext()
pavolmarko@432
   863
			//   ECX = pContext
pavolmarko@432
   864
			//   gcc: push ecx
pavolmarko@432
   865
			//   eax = [ecx]
pavolmarko@432
   866
			//   eax = [eax]
pavolmarko@432
   867
			//   call eax
pavolmarko@447
   868
			// gcc: clean up
pavolmarko@432
   869
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
pavolmarko@447
   870
			GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   871
pavolmarko@432
   872
			// vtbloffs=0, vtblidx=0
pavolmarko@432
   873
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   874
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EAX, MOD_MEM_REG);
pavolmarko@432
   875
			IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
   876
			GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   877
pavolmarko@432
   878
			// quit on zero
pavolmarko@432
   879
			//  test eax, eax
pavolmarko@432
   880
			//  jz exit
pavolmarko@432
   881
			IA32_Test_Rm_Reg(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
pavolmarko@432
   882
			tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
pavolmarko@432
   883
			m_HookFunc.start_count(counter);
pavolmarko@432
   884
pavolmarko@432
   885
			// prev_res = MRES_IGNORED
pavolmarko@432
   886
			IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_cur_res); 
pavolmarko@432
   887
pavolmarko@432
   888
			// iter->call()
pavolmarko@432
   889
			//  push params
pavolmarko@432
   890
			//   ecx = eax
pavolmarko@432
   891
			//   gcc: push ecx
pavolmarko@432
   892
			//   eax = [ecx]
pavolmarko@432
   893
			//   eax = [eax+2*SIZE_PTR]
pavolmarko@432
   894
			//   call eax
pavolmarko@447
   895
			//   gcc: clean up 
pavolmarko@447
   896
pavolmarko@448
   897
			jit_int32_t gcc_clean_bytes = PushParams(base_param_offset, v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
pavolmarko@432
   898
pavolmarko@432
   899
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_ECX, REG_EAX, MOD_REG);
pavolmarko@447
   900
			GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@449
   901
			gcc_clean_bytes += PushMemRetPtr(v_plugin_ret, v_place_for_memret);
pavolmarko@432
   902
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   903
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EAX, 2*SIZE_PTR);
pavolmarko@432
   904
			IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
   905
pavolmarko@448
   906
			DestroyParams(v_place_fbrr_base);
pavolmarko@448
   907
pavolmarko@437
   908
			SaveRetVal(v_plugin_ret, v_place_for_memret);
pavolmarko@432
   909
pavolmarko@432
   910
			// cleanup
pavolmarko@448
   911
#if SH_COMP == SH_COMP_GCC
pavolmarko@448
   912
			IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, gcc_clean_bytes + SIZE_PTR, MOD_REG);
pavolmarko@448
   913
#endif
pavolmarko@448
   914
pavolmarko@432
   915
			// params + thisptr
pavolmarko@432
   916
pavolmarko@432
   917
			// process meta return:
pavolmarko@432
   918
			//  prev_res = cur_res
pavolmarko@432
   919
			//  if (cur_res > status) status = cur_res;
pavolmarko@432
   920
			//
pavolmarko@432
   921
			//  eax = cur_res
pavolmarko@432
   922
			//  edx = status
pavolmarko@432
   923
			//  prev_res = eax
pavolmarko@432
   924
			//  cmp eax,edx
pavolmarko@432
   925
			//  jng thelabel
pavolmarko@432
   926
			//  status = eax
pavolmarko@432
   927
			//  thelabel:
pavolmarko@432
   928
			//
pavolmarko@432
   929
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
pavolmarko@432
   930
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EDX, REG_EBP, v_status);
pavolmarko@432
   931
			IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_prev_res);
pavolmarko@432
   932
pavolmarko@432
   933
			IA32_Cmp_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_REG);
pavolmarko@432
   934
			tmppos2 = IA32_Jump_Cond_Imm8(&m_HookFunc, CC_NG, 0);
pavolmarko@432
   935
			m_HookFunc.start_count(counter2);
pavolmarko@432
   936
pavolmarko@432
   937
			IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_status);
pavolmarko@432
   938
pavolmarko@432
   939
			m_HookFunc.end_count(counter2);
pavolmarko@432
   940
			m_HookFunc.rewrite(tmppos2, static_cast<jit_uint8_t>(counter2));
pavolmarko@432
   941
pavolmarko@432
   942
			// process retval for non-void functions
pavolmarko@432
   943
			ProcessPluginRetVal(v_cur_res, v_pContext, v_plugin_ret);
pavolmarko@432
   944
pavolmarko@432
   945
			// jump back to loop begin
pavolmarko@432
   946
			tmppos2 = IA32_Jump_Imm32(&m_HookFunc, 0);
pavolmarko@432
   947
			m_HookFunc.end_count(loop_begin_counter);
pavolmarko@432
   948
			m_HookFunc.rewrite(tmppos2, -static_cast<jit_int32_t>(loop_begin_counter));
pavolmarko@432
   949
pavolmarko@432
   950
			m_HookFunc.end_count(counter);
pavolmarko@432
   951
			m_HookFunc.rewrite(tmppos, static_cast<jit_int32_t>(counter));
pavolmarko@432
   952
		}
pavolmarko@432
   953
pavolmarko@437
   954
		void GenContext::GenerateCallOrig(int v_status, int v_pContext, int param_base_offs, int v_this,
pavolmarko@448
   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)
pavolmarko@432
   956
		{
pavolmarko@432
   957
			jitoffs_t counter, tmppos;
pavolmarko@432
   958
			jitoffs_t counter2, tmppos2;
pavolmarko@432
   959
			jitoffs_t counter3, tmppos3;
pavolmarko@432
   960
pavolmarko@432
   961
			// if (status != MRES_SUPERCEDE && pConteext->ShouldCallOrig())
pavolmarko@432
   962
			//   *v_orig_ret = orig_call()
pavolmarko@432
   963
			// else
pavolmarko@432
   964
			//   *v_orig_ret = *v_override_ret
pavolmarko@432
   965
pavolmarko@432
   966
			// mov eax, status
pavolmarko@432
   967
			// cmp eax, MRES_SUPERCEDE
pavolmarko@432
   968
			// je dont_call
pavolmarko@432
   969
			// call pContext->ShouldCallOrig()
pavolmarko@432
   970
			// test al, al						!! important: al, not eax! bool is only stored in the LSbyte
pavolmarko@432
   971
			// jz dont_call
pavolmarko@432
   972
			//
pavolmarko@432
   973
			//  orig_call()
pavolmarko@432
   974
			//  SaveRet(v_orig_ret)
pavolmarko@432
   975
			//  jmp skip_dont_call:
pavolmarko@432
   976
			//
pavolmarko@432
   977
			// dont_call:
pavolmarko@432
   978
			//  *v_orig_ret = *v_override_ret
pavolmarko@432
   979
			// skip_dont_call:
pavolmarko@432
   980
pavolmarko@432
   981
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_status);
pavolmarko@432
   982
			IA32_Cmp_Rm_Imm32(&m_HookFunc, MOD_REG, REG_EAX, MRES_SUPERCEDE);
pavolmarko@432
   983
pavolmarko@432
   984
			tmppos = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_E, 0);
pavolmarko@432
   985
			m_HookFunc.start_count(counter);
pavolmarko@432
   986
pavolmarko@432
   987
			// eax = pContext->ShouldCallOrig()
pavolmarko@432
   988
			//   ECX = pContext
pavolmarko@432
   989
			//   gcc: push ecx
pavolmarko@432
   990
			//   eax = [ecx]
pavolmarko@432
   991
			//   eax = [eax + 3*PTR_SIZE]
pavolmarko@432
   992
			//   call eax
pavolmarko@447
   993
			// gcc: clean up
pavolmarko@432
   994
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_pContext);
pavolmarko@447
   995
			GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
   996
pavolmarko@432
   997
			// vtbloffs=0, vtblidx=3
pavolmarko@432
   998
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
   999
			IA32_Mov_Reg_Rm_Disp8(&m_HookFunc, REG_EAX, REG_EAX, 3*SIZE_PTR);
pavolmarko@432
  1000
			IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1001
			GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
  1002
pavolmarko@432
  1003
			IA32_Test_Rm_Reg8(&m_HookFunc, REG_EAX, REG_EAX, MOD_REG);
pavolmarko@432
  1004
			tmppos2 = IA32_Jump_Cond_Imm32(&m_HookFunc, CC_Z, 0);
pavolmarko@432
  1005
			m_HookFunc.start_count(counter2);
pavolmarko@432
  1006
pavolmarko@432
  1007
			// push params
pavolmarko@448
  1008
			jit_int32_t gcc_clean_bytes = PushParams(param_base_offs, v_orig_ret, v_place_for_memret, v_place_fbrr_base);
pavolmarko@432
  1009
pavolmarko@432
  1010
			// thisptr
pavolmarko@432
  1011
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this);
pavolmarko@432
  1012
#if SH_COMP == SH_COMP_GCC
pavolmarko@432
  1013
			//  on gcc/mingw, this is the first parameter
pavolmarko@432
  1014
			IA32_Push_Reg(&m_HookFunc, REG_ECX);
pavolmarko@432
  1015
			//  on msvc, simply leave it in ecx
pavolmarko@432
  1016
#endif
pavolmarko@449
  1017
			gcc_clean_bytes += PushMemRetPtr(v_orig_ret, v_place_for_memret);
pavolmarko@432
  1018
pavolmarko@432
  1019
			// call
pavolmarko@432
  1020
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_vfnptr_origentry);
pavolmarko@432
  1021
			IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1022
pavolmarko@432
  1023
			// cleanup
pavolmarko@432
  1024
#if SH_COMP == SH_COMP_GCC
pavolmarko@432
  1025
			IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, gcc_clean_bytes + SIZE_PTR, MOD_REG);
pavolmarko@432
  1026
#endif
pavolmarko@432
  1027
pavolmarko@448
  1028
			DestroyParams(v_place_fbrr_base);
pavolmarko@448
  1029
pavolmarko@432
  1030
			// save retval
pavolmarko@437
  1031
			SaveRetVal(v_orig_ret, v_place_for_memret);
pavolmarko@432
  1032
pavolmarko@432
  1033
			// Skip don't call variant
pavolmarko@432
  1034
			tmppos3 = IA32_Jump_Imm32(&m_HookFunc, 0);
pavolmarko@432
  1035
			m_HookFunc.start_count(counter3);
pavolmarko@432
  1036
pavolmarko@432
  1037
pavolmarko@432
  1038
			// don't call:
pavolmarko@432
  1039
			m_HookFunc.end_count(counter);
pavolmarko@432
  1040
			m_HookFunc.rewrite(tmppos, static_cast<jit_uint32_t>(counter));
pavolmarko@432
  1041
pavolmarko@432
  1042
			m_HookFunc.end_count(counter2);
pavolmarko@432
  1043
			m_HookFunc.rewrite(tmppos2, static_cast<jit_uint32_t>(counter2));
pavolmarko@432
  1044
pavolmarko@432
  1045
			// *v_orig_ret = *v_override_ret
pavolmarko@439
  1046
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_ByRef)
pavolmarko@432
  1047
			{
pavolmarko@439
  1048
				// mov ecx, [ebp + v_override_ret]
pavolmarko@439
  1049
				// mov [ebp + v_orig_ret], ecx
pavolmarko@432
  1050
pavolmarko@439
  1051
				IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
pavolmarko@439
  1052
				IA32_Mov_Rm_Reg_DispAuto(&m_HookFunc, REG_EBP, REG_ECX, v_orig_ret);
pavolmarko@432
  1053
			}
pavolmarko@432
  1054
			else
pavolmarko@432
  1055
			{
pavolmarko@439
  1056
				if (m_Proto.GetRet().pAssignOperator)
pavolmarko@439
  1057
				{
pavolmarko@439
  1058
					// lea edx, [ebp + v_override_ret]			<-- src addr
pavolmarko@439
  1059
					// lea ecx, [ebp + v_orig_ret]				<-- dest addr
pavolmarko@447
  1060
					// push edx					<-- src addr
pavolmarko@439
  1061
					// gcc: push ecx
pavolmarko@439
  1062
					// call it
pavolmarko@447
  1063
					// gcc: clean up
pavolmarko@439
  1064
pavolmarko@439
  1065
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_override_ret);
pavolmarko@439
  1066
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
pavolmarko@439
  1067
					IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@447
  1068
					GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
  1069
pavolmarko@439
  1070
					IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pAssignOperator));
pavolmarko@439
  1071
					IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1072
					GCC_ONLY(IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
pavolmarko@439
  1073
				}
pavolmarko@439
  1074
				else
pavolmarko@439
  1075
				{
pavolmarko@439
  1076
					// bitwise copy
pavolmarko@439
  1077
					BitwiseCopy_Setup();
pavolmarko@437
  1078
pavolmarko@439
  1079
					//lea edi, [ebp+v_orig_ret]			<-- destination
pavolmarko@439
  1080
					//lea esi, [ebp+v_override_ret]		<-- src
pavolmarko@439
  1081
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDI, REG_EBP, v_orig_ret);
pavolmarko@439
  1082
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ESI, REG_EBP, v_override_ret);
pavolmarko@439
  1083
pavolmarko@439
  1084
					BitwiseCopy_Do(m_Proto.GetRet().size);
pavolmarko@439
  1085
				}
pavolmarko@432
  1086
			}
pavolmarko@432
  1087
pavolmarko@432
  1088
			// skip don't call label target:
pavolmarko@432
  1089
			m_HookFunc.end_count(counter3);
pavolmarko@432
  1090
			m_HookFunc.rewrite(tmppos3, static_cast<jit_uint32_t>(counter3));
pavolmarko@432
  1091
		}
pavolmarko@432
  1092
pavolmarko@432
  1093
		// Sets *v_pContext to return value
pavolmarko@432
  1094
		void GenContext::CallSetupHookLoop(int v_orig_ret, int v_override_ret, 
pavolmarko@432
  1095
			int v_cur_res, int v_prev_res, int v_status, int v_vfnptr_origentry,
pavolmarko@432
  1096
			int v_this, int v_pContext)
pavolmarko@432
  1097
		{
pavolmarko@432
  1098
			// call shptr->SetupHookLoop(ms_HI, ourvfnptr, reinterpret_cast<void*>(this),
pavolmarko@432
  1099
			//  &vfnptr_origentry, &status, &prev_res, &cur_res, &orig_ret, &override_ret);
pavolmarko@432
  1100
			// The last two params are null for void funcs.
pavolmarko@432
  1101
pavolmarko@432
  1102
			if (m_Proto.GetRet().size == 0)
pavolmarko@432
  1103
			{
pavolmarko@432
  1104
				// void
pavolmarko@432
  1105
				IA32_Push_Imm8(&m_HookFunc, 0);		// orig_ret
pavolmarko@432
  1106
				IA32_Push_Imm8(&m_HookFunc, 0);		// override_ret
pavolmarko@432
  1107
			}
pavolmarko@432
  1108
			else
pavolmarko@432
  1109
			{
pavolmarko@432
  1110
				// orig_ret and override_ret
pavolmarko@432
  1111
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EAX, REG_EBP, v_override_ret);
pavolmarko@432
  1112
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_EDX, REG_EBP, v_orig_ret);
pavolmarko@432
  1113
				IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1114
				IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@432
  1115
			}
pavolmarko@432
  1116
pavolmarko@432
  1117
			// cur_res and prev_res
pavolmarko@432
  1118
			IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_cur_res);
pavolmarko@432
  1119
			IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_prev_res);
pavolmarko@432
  1120
			IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1121
			IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@432
  1122
pavolmarko@432
  1123
			// status and vfnptr_origentry
pavolmarko@432
  1124
			IA32_Lea_DispRegImm8(&m_HookFunc, REG_EAX, REG_EBP, v_status);
pavolmarko@432
  1125
			IA32_Lea_DispRegImm8(&m_HookFunc, REG_EDX, REG_EBP, v_vfnptr_origentry);
pavolmarko@432
  1126
			IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1127
			IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@432
  1128
pavolmarko@432
  1129
			// this
pavolmarko@432
  1130
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_this);
pavolmarko@432
  1131
			IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1132
pavolmarko@432
  1133
			// our vfn ptr
pavolmarko@432
  1134
			//  *(this + vtbloffs) + SIZE_PTR*vtblidx
pavolmarko@432
  1135
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_ECX, REG_EBP, v_this);			// get this into ecx (gcc!)
pavolmarko@432
  1136
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_ECX, m_VtblOffs);
pavolmarko@432
  1137
			IA32_Add_Rm_ImmAuto(&m_HookFunc, REG_EAX, m_VtblIdx * SIZE_PTR, MOD_REG);
pavolmarko@432
  1138
			IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1139
pavolmarko@432
  1140
			// *m_pHI
pavolmarko@432
  1141
			IA32_Mov_Rm_Imm32(&m_HookFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
pavolmarko@432
  1142
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
pavolmarko@432
  1143
			IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1144
pavolmarko@432
  1145
			// set up thisptr
pavolmarko@432
  1146
#if SH_COMP == SH_COMP_GCC
pavolmarko@432
  1147
			//  on gcc/mingw, this is the first parameter
pavolmarko@447
  1148
			GCC_ONLY(IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr)));
pavolmarko@432
  1149
#elif SH_COMP == SH_COMP_MSVC
pavolmarko@432
  1150
			//  on msvc, it's ecx
pavolmarko@432
  1151
			IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
pavolmarko@432
  1152
#endif
pavolmarko@432
  1153
pavolmarko@432
  1154
			// call the function. vtbloffs = 0, vtblidx = 19
pavolmarko@432
  1155
			// get vtptr into edx  --  we know shptr on jit time -> dereference it here!
pavolmarko@432
  1156
			IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, 
pavolmarko@432
  1157
				(*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[19]);
pavolmarko@432
  1158
pavolmarko@432
  1159
			IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1160
pavolmarko@432
  1161
			// on gcc/mingw, we have to clean up after the call
pavolmarko@432
  1162
			// 9 params + hidden thisptr param
pavolmarko@447
  1163
			GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 10*SIZE_PTR, MOD_REG));
pavolmarko@432
  1164
pavolmarko@432
  1165
			// store return value
pavolmarko@432
  1166
			IA32_Mov_Rm_Reg_Disp8(&m_HookFunc, REG_EBP, REG_EAX, v_pContext);
pavolmarko@432
  1167
		}
pavolmarko@432
  1168
pavolmarko@432
  1169
		void GenContext::CallEndContext(int v_pContext)
pavolmarko@432
  1170
		{
pavolmarko@432
  1171
			// call endcontext:
pavolmarko@432
  1172
			// shptr->EndContext(pContex)
pavolmarko@432
  1173
			IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, REG_EBP, v_pContext);
pavolmarko@432
  1174
			IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1175
pavolmarko@432
  1176
			// thisptr
pavolmarko@432
  1177
#if SH_COMP == SH_COMP_GCC
pavolmarko@432
  1178
			//  on gcc/mingw, this is the first parameter
pavolmarko@432
  1179
			IA32_Push_Imm32(&m_HookFunc, DownCastPtr(m_SHPtr));
pavolmarko@432
  1180
#elif SH_COMP == SH_COMP_MSVC
pavolmarko@432
  1181
			//  on msvc, it's ecx
pavolmarko@432
  1182
			IA32_Mov_Reg_Imm32(&m_HookFunc, REG_ECX, DownCastPtr(m_SHPtr));
pavolmarko@432
  1183
#endif
pavolmarko@432
  1184
pavolmarko@432
  1185
			// get vtptr into edx  --  we know shptr on jit time -> dereference it here!
pavolmarko@432
  1186
			IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, 
pavolmarko@432
  1187
				(*reinterpret_cast<jit_uint32_t**>(m_SHPtr))[20]);
pavolmarko@432
  1188
pavolmarko@432
  1189
			IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1190
pavolmarko@432
  1191
			// on gcc/mingw, we have to clean up after the call
pavolmarko@432
  1192
			// 1 param + hidden thisptr param
pavolmarko@447
  1193
			GCC_ONLY(IA32_Add_Rm_Imm8(&m_HookFunc, REG_ESP, 2*SIZE_PTR, MOD_REG));
pavolmarko@432
  1194
		}
pavolmarko@432
  1195
pavolmarko@442
  1196
		void * GenContext::GenerateHookFunc()
pavolmarko@432
  1197
		{
pavolmarko@432
  1198
			// prologue
pavolmarko@432
  1199
			IA32_Push_Reg(&m_HookFunc, REG_EBP);
pavolmarko@432
  1200
			IA32_Push_Reg(&m_HookFunc, REG_EBX);
pavolmarko@432
  1201
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_EBP, REG_ESP, MOD_REG);
pavolmarko@432
  1202
pavolmarko@432
  1203
			// on msvc, save thisptr
pavolmarko@432
  1204
#if SH_COMP == SH_COMP_MSVC
pavolmarko@449
  1205
			jit_int8_t v_this = -4;
pavolmarko@432
  1206
			const int addstackoffset = -4;
pavolmarko@432
  1207
			IA32_Push_Reg(&m_HookFunc, REG_ECX);
pavolmarko@432
  1208
#elif SH_COMP == SH_COMP_GCC
pavolmarko@449
  1209
			jit_int8_t v_this = 12;		// first param
pavolmarko@432
  1210
			const int addstackoffset = 0;
pavolmarko@432
  1211
#endif
pavolmarko@432
  1212
pavolmarko@432
  1213
pavolmarko@432
  1214
			// ********************** stack frame **********************
pavolmarko@432
  1215
			//														MSVC
pavolmarko@432
  1216
			//   second param (gcc: first real param)	ebp + 16
pavolmarko@432
  1217
			//   first param (gcc: thisptr)				ebp + 12
pavolmarko@432
  1218
			//   ret address:							ebp + 8
pavolmarko@432
  1219
			//   caller's ebp							ebp + 4
pavolmarko@432
  1220
			//   saved ebx								ebp
pavolmarko@432
  1221
			//   MSVC ONLY:	current this				ebp - 4
pavolmarko@432
  1222
			//   void *vfnptr_origentry					ebp - 4			-4
pavolmarko@432
  1223
			//   META_RES status = MRES_IGNORED			ebp - 8			-4
pavolmarko@432
  1224
			//   META_RES prev_res						ebp - 12		-4
pavolmarko@432
  1225
			//   META_RES cur_res						ebp - 16		-4
pavolmarko@432
  1226
			//   IMyDelegate *iter						ebp - 20		-4
pavolmarko@432
  1227
			//   IHookContext *pContext					ebp - 24		-4
pavolmarko@432
  1228
			//  == 3 ptrs + 3 enums = 24 bytes
pavolmarko@432
  1229
			//
pavolmarko@432
  1230
			// non-void: add:
pavolmarko@432
  1231
			//   my_rettype *ret_ptr					ebp - 28		-4
pavolmarko@432
  1232
			//   my_rettype orig_ret					ebp - 28 - sizeof(my_rettype)			-4
pavolmarko@432
  1233
			//   my_rettype override_ret				ebp - 28 - sizeof(my_rettype)*2			-4
pavolmarko@432
  1234
			//   my_rettype plugin_ret					ebp - 28 - sizeof(my_rettype)*3			-4
pavolmarko@432
  1235
			//  == + 3 * sizeof(my_rettype) bytes
pavolmarko@432
  1236
pavolmarko@437
  1237
			// if required:
pavolmarko@437
  1238
			//   my_rettype place_for_memret			ebp - 28 - sizeof(my_rettype)*4			-4
pavolmarko@448
  1239
pavolmarko@448
  1240
			// gcc only: if required:
pavolmarko@448
  1241
			//   place forced byref params              ebp - 28 - sizeof(my_rettype)*{4 or 5}
pavolmarko@437
  1242
			
pavolmarko@437
  1243
pavolmarko@432
  1244
			const jit_int8_t v_vfnptr_origentry =	-4	+ addstackoffset;
pavolmarko@432
  1245
			const jit_int8_t v_status =				-8	+ addstackoffset;
pavolmarko@432
  1246
			const jit_int8_t v_prev_res =			-12	+ addstackoffset;
pavolmarko@432
  1247
			const jit_int8_t v_cur_res =			-16	+ addstackoffset;
pavolmarko@432
  1248
			const jit_int8_t v_iter =				-20	+ addstackoffset;
pavolmarko@432
  1249
			const jit_int8_t v_pContext =			-24 + addstackoffset;
pavolmarko@432
  1250
			
pavolmarko@432
  1251
#if SH_COMP == SH_COMP_GCC
pavolmarko@436
  1252
			jit_int32_t param_base_offs =		16;
pavolmarko@432
  1253
#elif SH_COMP == SH_COMP_MSVC
pavolmarko@436
  1254
			jit_int32_t param_base_offs =		12;
pavolmarko@432
  1255
#endif
pavolmarko@432
  1256
pavolmarko@436
  1257
			// Memory return: first param is the address
pavolmarko@436
  1258
			jit_int32_t v_memret_addr = 0;
pavolmarko@436
  1259
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
pavolmarko@436
  1260
			{
pavolmarko@449
  1261
#if SH_COMP == SH_COMP_GCC
pavolmarko@449
  1262
				// gcc: now:	first param = mem ret addr
pavolmarko@449
  1263
				//				second param = this pointer
pavolmarko@449
  1264
				//				third param = actual first param
pavolmarko@449
  1265
				v_memret_addr = 12;
pavolmarko@449
  1266
				v_this += 4;
pavolmarko@449
  1267
				param_base_offs += SIZE_PTR;
pavolmarko@449
  1268
#elif SH_COMP == SH_COMP_MSVC
pavolmarko@436
  1269
				v_memret_addr = param_base_offs;
pavolmarko@436
  1270
				param_base_offs += SIZE_PTR;
pavolmarko@449
  1271
#endif
pavolmarko@436
  1272
			}
pavolmarko@436
  1273
pavolmarko@432
  1274
			jit_int32_t v_ret_ptr =					-28 + addstackoffset;
pavolmarko@432
  1275
			jit_int32_t v_orig_ret =				-28	+ addstackoffset - GetStackSize(m_Proto.GetRet()) * 1;
pavolmarko@432
  1276
			jit_int32_t v_override_ret =			-28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 2;
pavolmarko@432
  1277
			jit_int32_t v_plugin_ret =				-28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 3;
pavolmarko@432
  1278
pavolmarko@437
  1279
			jit_int32_t v_place_for_memret =		-28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * 4;
pavolmarko@437
  1280
pavolmarko@448
  1281
			jit_int32_t v_place_fbrr_base  =		-28 + addstackoffset - GetStackSize(m_Proto.GetRet()) * (MemRetWithTempObj() ? 5 : 4);
pavolmarko@448
  1282
pavolmarko@432
  1283
			// Hash for temporary storage for byval params with copy constructors
pavolmarko@432
  1284
			// (param, offset into stack)
pavolmarko@437
  1285
			short usedStackBytes = 3*SIZE_MWORD + 3*SIZE_PTR		// vfnptr_origentry, status, prev_res, cur_res, iter, pContext
pavolmarko@437
  1286
				+ 3 * GetStackSize(m_Proto.GetRet()) + (m_Proto.GetRet().size == 0 ? 0 : SIZE_PTR)	// ret_ptr, orig_ret, override_ret, plugin_ret
pavolmarko@437
  1287
				+ (MemRetWithTempObj() ? GetStackSize(m_Proto.GetRet()) : 0)
pavolmarko@448
  1288
				+ GetForcedByRefParamsSize()
pavolmarko@432
  1289
				- addstackoffset;									// msvc: current thisptr	
pavolmarko@432
  1290
pavolmarko@432
  1291
			IA32_Sub_Rm_Imm32(&m_HookFunc, REG_ESP, usedStackBytes, MOD_REG);
pavolmarko@432
  1292
pavolmarko@432
  1293
			// init status localvar
pavolmarko@432
  1294
			IA32_Mov_Rm_Imm32_Disp8(&m_HookFunc, REG_EBP, MRES_IGNORED, v_status);
pavolmarko@432
  1295
pavolmarko@432
  1296
			// Call constructors for ret vars if required
pavolmarko@439
  1297
			if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
pavolmarko@439
  1298
				m_Proto.GetRet().pNormalCtor)
pavolmarko@432
  1299
			{
pavolmarko@432
  1300
				// :TODO: Gcc version
pavolmarko@432
  1301
pavolmarko@432
  1302
				// orig_reg
pavolmarko@432
  1303
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
pavolmarko@447
  1304
				GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
  1305
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
pavolmarko@432
  1306
				IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1307
				GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
  1308
pavolmarko@432
  1309
				// override_reg
pavolmarko@432
  1310
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
pavolmarko@447
  1311
				GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
  1312
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
pavolmarko@432
  1313
				IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1314
				GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
  1315
pavolmarko@432
  1316
				// plugin_ret
pavolmarko@432
  1317
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
pavolmarko@447
  1318
				GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@432
  1319
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pNormalCtor));
pavolmarko@432
  1320
				IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1321
				GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
  1322
pavolmarko@437
  1323
				// _don't_ call a constructor for v_place_for_memret !
pavolmarko@432
  1324
			}
pavolmarko@432
  1325
pavolmarko@432
  1326
			// ********************** SetupHookLoop **********************
pavolmarko@432
  1327
			CallSetupHookLoop(v_orig_ret, v_override_ret, v_cur_res, v_prev_res, v_status, v_vfnptr_origentry,
pavolmarko@432
  1328
				v_this, v_pContext);
pavolmarko@432
  1329
pavolmarko@432
  1330
			// ********************** call pre hooks **********************
pavolmarko@432
  1331
			GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
pavolmarko@448
  1332
				v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
pavolmarko@432
  1333
pavolmarko@432
  1334
			// ********************** call orig func **********************
pavolmarko@432
  1335
			GenerateCallOrig(v_status, v_pContext, param_base_offs, v_this, v_vfnptr_origentry, v_orig_ret,
pavolmarko@448
  1336
				v_override_ret, v_place_for_memret, v_place_fbrr_base);
pavolmarko@432
  1337
pavolmarko@432
  1338
			// ********************** call post hooks **********************
pavolmarko@432
  1339
			GenerateCallHooks(v_status, v_prev_res, v_cur_res, v_iter, v_pContext, param_base_offs,
pavolmarko@448
  1340
				v_plugin_ret, v_place_for_memret, v_place_fbrr_base);
pavolmarko@432
  1341
pavolmarko@432
  1342
			// ********************** end context and return **********************
pavolmarko@432
  1343
pavolmarko@432
  1344
			PrepareReturn(v_status, v_pContext, v_ret_ptr);
pavolmarko@432
  1345
pavolmarko@432
  1346
			CallEndContext(v_pContext);
pavolmarko@432
  1347
pavolmarko@432
  1348
			// Call destructors of byval object params which have a destructor
pavolmarko@432
  1349
			jit_int32_t cur_param_pos = param_base_offs;
pavolmarko@432
  1350
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@432
  1351
			{
pavolmarko@432
  1352
				const IntPassInfo &pi = m_Proto.GetParam(i);
pavolmarko@448
  1353
				// GCC: NOT of forced byref params. the caller destructs those.
pavolmarko@432
  1354
				if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ODtor) &&
pavolmarko@448
  1355
					(pi.flags & PassInfo::PassFlag_ByVal) && !(pi.flags & PassFlag_ForcedByRef))
pavolmarko@432
  1356
				{
pavolmarko@432
  1357
					IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, cur_param_pos);
pavolmarko@432
  1358
					IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(pi.pDtor));
pavolmarko@432
  1359
					IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@432
  1360
				}
pavolmarko@432
  1361
				cur_param_pos += GetStackSize(pi);
pavolmarko@432
  1362
			}
pavolmarko@432
  1363
pavolmarko@436
  1364
			DoReturn(v_ret_ptr, v_memret_addr);
pavolmarko@432
  1365
pavolmarko@437
  1366
			// Call destructors of orig_ret/ ...
pavolmarko@439
  1367
			if((m_Proto.GetRet().flags & PassInfo::PassFlag_ByVal) &&
pavolmarko@439
  1368
				m_Proto.GetRet().pDtor)
pavolmarko@437
  1369
			{
pavolmarko@437
  1370
				// Preserve return value in EAX(:EDX)
pavolmarko@437
  1371
				IA32_Push_Reg(&m_HookFunc, REG_EAX);
pavolmarko@437
  1372
				IA32_Push_Reg(&m_HookFunc, REG_EDX);
pavolmarko@437
  1373
pavolmarko@437
  1374
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_plugin_ret);
pavolmarko@447
  1375
				GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
  1376
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
pavolmarko@437
  1377
				IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1378
				GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
  1379
pavolmarko@437
  1380
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_override_ret);
pavolmarko@447
  1381
				GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
  1382
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
pavolmarko@437
  1383
				IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1384
				GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
  1385
pavolmarko@437
  1386
				IA32_Lea_DispRegImmAuto(&m_HookFunc, REG_ECX, REG_EBP, v_orig_ret);
pavolmarko@447
  1387
				GCC_ONLY(IA32_Push_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
  1388
				IA32_Mov_Reg_Imm32(&m_HookFunc, REG_EAX, DownCastPtr(m_Proto.GetRet().pDtor));
pavolmarko@437
  1389
				IA32_Call_Reg(&m_HookFunc, REG_EAX);
pavolmarko@447
  1390
				GCC_ONLY(IA32_Pop_Reg(&m_HookFunc, REG_ECX));
pavolmarko@437
  1391
pavolmarko@437
  1392
				IA32_Pop_Reg(&m_HookFunc, REG_EDX);
pavolmarko@437
  1393
				IA32_Pop_Reg(&m_HookFunc, REG_EAX);
pavolmarko@437
  1394
			}
pavolmarko@432
  1395
pavolmarko@432
  1396
			// epilogue
pavolmarko@432
  1397
			IA32_Mov_Reg_Rm(&m_HookFunc, REG_ESP, REG_EBP, MOD_REG);
pavolmarko@432
  1398
			IA32_Pop_Reg(&m_HookFunc, REG_EBX);
pavolmarko@432
  1399
			IA32_Pop_Reg(&m_HookFunc, REG_EBP);
pavolmarko@447
  1400
			MSVC_ONLY(IA32_Return_Popstack(&m_HookFunc, GetParamsStackSize()));
pavolmarko@449
  1401
			// gcc: Remove 4 bytes from stack on memory return
pavolmarko@449
  1402
#if SH_COMP == SH_COMP_GCC
pavolmarko@449
  1403
			if (m_Proto.GetRet().flags & PassInfo::PassFlag_RetMem)
pavolmarko@449
  1404
				IA32_Return_Popstack(&m_HookFunc, SIZE_PTR);
pavolmarko@449
  1405
			else
pavolmarko@449
  1406
				IA32_Return(&m_HookFunc);
pavolmarko@449
  1407
#endif
pavolmarko@449
  1408
			
pavolmarko@432
  1409
			// Store pointer for later use
pavolmarko@432
  1410
			// m_HookfuncVfnPtr is a pointer to a void* because SH expects a pointer
pavolmarko@432
  1411
			// into the hookman's vtable
pavolmarko@432
  1412
			*m_HookfuncVfnptr = reinterpret_cast<void*>(m_HookFunc.GetData());
pavolmarko@435
  1413
pavolmarko@435
  1414
			m_HookFunc.SetRE();
pavolmarko@435
  1415
pavolmarko@432
  1416
			return m_HookFunc.GetData();
pavolmarko@432
  1417
		}
pavolmarko@432
  1418
pavolmarko@432
  1419
		// Pre-condition: GenerateHookFunc() has been called!
pavolmarko@442
  1420
		void * GenContext::GeneratePubFunc()
pavolmarko@432
  1421
		{
pavolmarko@432
  1422
			jitoffs_t counter, tmppos;
pavolmarko@432
  1423
pavolmarko@432
  1424
			// The pubfunc is a static cdecl function.
pavolmarko@432
  1425
			// C Code:
pavolmarko@432
  1426
			//  int HookManPubFunc(
pavolmarko@432
  1427
			//     bool store,				ebp + 8
pavolmarko@432
  1428
			//     IHookManagerInfo *hi		ebp + 12
pavolmarko@432
  1429
			//     )
pavolmarko@432
  1430
			//  {
pavolmarko@432
  1431
			//    if (store)
pavolmarko@432
  1432
			//      *m_pHI = hi;
pavolmarko@432
  1433
			//    if (hi)
pavolmarko@432
  1434
			//      hi->SetInfo(HOOKMAN_VERSION, m_VtblOffs, m_VtblIdx, m_Proto.GetProto(), m_HookfuncVfnptr)
pavolmarko@432
  1435
			//  }
pavolmarko@432
  1436
pavolmarko@432
  1437
			// prologue
pavolmarko@432
  1438
			IA32_Push_Reg(&m_PubFunc, REG_EBP);
pavolmarko@432
  1439
			IA32_Mov_Reg_Rm(&m_PubFunc, REG_EBP, REG_ESP, MOD_REG);
pavolmarko@432
  1440
pavolmarko@432
  1441
			
pavolmarko@432
  1442
			// save store in eax, hi in ecx
pavolmarko@432
  1443
			IA32_Movzx_Reg32_Rm8_Disp8(&m_PubFunc, REG_EAX, REG_EBP, 8);
pavolmarko@432
  1444
			IA32_Mov_Reg_Rm_DispAuto(&m_PubFunc, REG_ECX, REG_EBP, 12);
pavolmarko@432
  1445
pavolmarko@432
  1446
			// Check for store == 0
pavolmarko@432
  1447
			IA32_Test_Rm_Reg8(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
pavolmarko@432
  1448
			tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
pavolmarko@432
  1449
			m_PubFunc.start_count(counter);
pavolmarko@432
  1450
pavolmarko@432
  1451
			// nonzero -> store hi
pavolmarko@432
  1452
			IA32_Mov_Rm_Imm32(&m_PubFunc, REG_EDX, DownCastPtr(m_pHI), MOD_REG);
pavolmarko@432
  1453
			IA32_Mov_Rm_Reg(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
  1454
pavolmarko@432
  1455
			// zero
pavolmarko@432
  1456
			m_PubFunc.end_count(counter);
pavolmarko@432
  1457
			m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
pavolmarko@432
  1458
pavolmarko@432
  1459
			// check for hi == 0
pavolmarko@432
  1460
			IA32_Test_Rm_Reg(&m_PubFunc, REG_ECX, REG_ECX, MOD_REG);
pavolmarko@432
  1461
			tmppos = IA32_Jump_Cond_Imm8(&m_PubFunc, CC_Z, 0);
pavolmarko@432
  1462
			m_PubFunc.start_count(counter);
pavolmarko@432
  1463
pavolmarko@432
  1464
			// nonzero -> call vfunc
pavolmarko@432
  1465
			//  push params in reverse order
pavolmarko@432
  1466
			IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_HookfuncVfnptr));
pavolmarko@432
  1467
			IA32_Push_Imm32(&m_PubFunc, DownCastPtr(m_BuiltPI));
pavolmarko@432
  1468
			IA32_Push_Imm32(&m_PubFunc, m_VtblIdx);
pavolmarko@432
  1469
			IA32_Push_Imm32(&m_PubFunc, m_VtblOffs);
pavolmarko@432
  1470
			IA32_Push_Imm32(&m_PubFunc, SH_HOOKMAN_VERSION);
pavolmarko@432
  1471
pavolmarko@432
  1472
			//  hi == this is in ecx
pavolmarko@432
  1473
			//  on gcc/mingw, ecx is the first parameter
pavolmarko@432
  1474
#if SH_COMP == SH_COMP_GCC
pavolmarko@432
  1475
			IA32_Push_Reg(&m_PubFunc, REG_ECX);
pavolmarko@432
  1476
#endif
pavolmarko@432
  1477
			
pavolmarko@432
  1478
			// call the function. vtbloffs = 0, vtblidx = 0
pavolmarko@432
  1479
			// get vtptr into edx
pavolmarko@432
  1480
			IA32_Mov_Reg_Rm(&m_PubFunc, REG_EDX, REG_ECX, MOD_MEM_REG);
pavolmarko@432
  1481
			// get funcptr into eax
pavolmarko@432
  1482
			IA32_Mov_Reg_Rm(&m_PubFunc, REG_EAX, REG_EDX, MOD_MEM_REG);
pavolmarko@432
  1483
pavolmarko@432
  1484
			IA32_Call_Reg(&m_PubFunc, REG_EAX);
pavolmarko@432
  1485
pavolmarko@432
  1486
			// on gcc/mingw, we have to clean up after the call
pavolmarko@432
  1487
#if SH_COMP == SH_COMP_GCC
pavolmarko@432
  1488
			// 5 params + hidden thisptr param
pavolmarko@432
  1489
			IA32_Add_Rm_Imm8(&m_PubFunc, REG_ESP, 6*SIZE_MWORD, MOD_REG);
pavolmarko@432
  1490
#endif
pavolmarko@432
  1491
pavolmarko@432
  1492
			// zero
pavolmarko@432
  1493
			m_PubFunc.end_count(counter);
pavolmarko@432
  1494
			m_PubFunc.rewrite(tmppos, static_cast<jit_uint8_t>(counter));
pavolmarko@432
  1495
pavolmarko@432
  1496
			// return value
pavolmarko@432
  1497
			IA32_Xor_Reg_Rm(&m_PubFunc, REG_EAX, REG_EAX, MOD_REG);
pavolmarko@432
  1498
pavolmarko@432
  1499
			// epilogue
pavolmarko@432
  1500
			IA32_Mov_Reg_Rm(&m_PubFunc, REG_ESP, REG_EBP, MOD_REG);
pavolmarko@432
  1501
			IA32_Pop_Reg(&m_PubFunc, REG_EBP);
pavolmarko@432
  1502
			IA32_Return(&m_PubFunc);
pavolmarko@432
  1503
pavolmarko@435
  1504
			m_PubFunc.SetRE();
pavolmarko@432
  1505
pavolmarko@432
  1506
			return m_PubFunc;
pavolmarko@432
  1507
		}
pavolmarko@432
  1508
pavolmarko@432
  1509
		bool GenContext::PassInfoSupported(const IntPassInfo &pi, bool is_ret)
pavolmarko@432
  1510
		{
pavolmarko@451
  1511
			// :TODO: Error returns
pavolmarko@432
  1512
			if (pi.type != PassInfo::PassType_Basic &&
pavolmarko@432
  1513
				pi.type != PassInfo::PassType_Float &&
pavolmarko@432
  1514
				pi.type != PassInfo::PassType_Object)
pavolmarko@432
  1515
			{
pavolmarko@432
  1516
				return false;
pavolmarko@432
  1517
			}
pavolmarko@432
  1518
pavolmarko@432
  1519
			if (pi.type == PassInfo::PassType_Object &&
pavolmarko@432
  1520
				(pi.flags & PassInfo::PassFlag_ByVal))
pavolmarko@432
  1521
			{
pavolmarko@437
  1522
				if ((pi.flags & PassInfo::PassFlag_CCtor) && !pi.pCopyCtor)
pavolmarko@448
  1523
				{
pavolmarko@432
  1524
					return false;
pavolmarko@448
  1525
				}
pavolmarko@432
  1526
pavolmarko@432
  1527
				if ((pi.flags & PassInfo::PassFlag_ODtor) && !pi.pDtor)
pavolmarko@448
  1528
				{
pavolmarko@432
  1529
					return false;
pavolmarko@448
  1530
				}
pavolmarko@448
  1531
				
pavolmarko@437
  1532
				if ((pi.flags & PassInfo::PassFlag_AssignOp) && !pi.pAssignOperator)
pavolmarko@448
  1533
				{
pavolmarko@432
  1534
					return false;
pavolmarko@448
  1535
				}
pavolmarko@432
  1536
pavolmarko@437
  1537
				if ((pi.flags & PassInfo::PassFlag_OCtor) && !pi.pNormalCtor)
pavolmarko@448
  1538
				{
pavolmarko@432
  1539
					return false;
pavolmarko@448
  1540
				}
pavolmarko@432
  1541
			}
pavolmarko@432
  1542
pavolmarko@432
  1543
			if ((pi.flags & (PassInfo::PassFlag_ByVal | PassInfo::PassFlag_ByRef)) == 0)
pavolmarko@432
  1544
			{
pavolmarko@432
  1545
				return false;			 // Neither byval nor byref!
pavolmarko@432
  1546
			}
pavolmarko@432
  1547
			return true;
pavolmarko@432
  1548
		}
pavolmarko@432
  1549
pavolmarko@436
  1550
		void GenContext::AutoDetectRetType()
pavolmarko@436
  1551
		{
pavolmarko@436
  1552
			IntPassInfo &pi = m_Proto.GetRet();
pavolmarko@436
  1553
pavolmarko@436
  1554
			// Only relevant for byval types
pavolmarko@436
  1555
			if (pi.flags & PassInfo::PassFlag_ByVal)
pavolmarko@436
  1556
			{
pavolmarko@436
  1557
				// Basic + float: 
pavolmarko@436
  1558
				if (pi.type == PassInfo::PassType_Basic ||
pavolmarko@436
  1559
					pi.type == PassInfo::PassType_Float)
pavolmarko@436
  1560
				{
pavolmarko@436
  1561
					// <= 8 bytes:
pavolmarko@436
  1562
					//    _always_ in registers, no matter what the user says
pavolmarko@436
  1563
					if (pi.size <= 8)
pavolmarko@436
  1564
					{
pavolmarko@436
  1565
						pi.flags &= ~PassInfo::PassFlag_RetMem;
pavolmarko@436
  1566
						pi.flags |= PassInfo::PassFlag_RetReg;
pavolmarko@436
  1567
					}
pavolmarko@436
  1568
					else
pavolmarko@436
  1569
					{
pavolmarko@436
  1570
						// Does this even exist? No idea, if it does: in memory!
pavolmarko@436
  1571
						pi.flags &= ~PassInfo::PassFlag_RetReg;
pavolmarko@436
  1572
						pi.flags |= PassInfo::PassFlag_RetMem;
pavolmarko@436
  1573
					}
pavolmarko@436
  1574
				}
pavolmarko@436
  1575
				// Object: 
pavolmarko@436
  1576
				else if (pi.type == PassInfo::PassType_Object)
pavolmarko@436
  1577
				{
pavolmarko@436
  1578
					// If the user says nothing, auto-detect
pavolmarko@436
  1579
					if ((pi.flags & (PassInfo::PassFlag_RetMem | PassInfo::PassFlag_RetReg)) == 0)
pavolmarko@436
  1580
					{
pavolmarko@436
  1581
#if SH_COMP == SH_COMP_MSVC
pavolmarko@436
  1582
						// MSVC seems to return _all_ structs, classes, unions in memory
pavolmarko@436
  1583
						pi.flags |= PassInfo::PassFlag_RetMem;
pavolmarko@436
  1584
#elif SH_COMP == SH_COMP_GCC
pavolmarko@436
  1585
						// Same goes for GCC :)
pavolmarko@436
  1586
						pi.flags |= PassInfo::PassFlag_RetMem;
pavolmarko@436
  1587
#endif
pavolmarko@436
  1588
					}
pavolmarko@436
  1589
				}
pavolmarko@436
  1590
			}
pavolmarko@438
  1591
			else
pavolmarko@438
  1592
			{
pavolmarko@438
  1593
				// byref: make sure that the flag is _not_ set
pavolmarko@438
  1594
				pi.flags &= ~PassInfo::PassFlag_RetMem;
pavolmarko@438
  1595
				pi.flags |= PassInfo::PassFlag_RetReg;
pavolmarko@438
  1596
			}
pavolmarko@436
  1597
		}
pavolmarko@436
  1598
pavolmarko@447
  1599
		void GenContext::AutoDetectParamFlags()
pavolmarko@447
  1600
		{
pavolmarko@447
  1601
#if SH_COMP == SH_COMP_GCC
pavolmarko@447
  1602
			// On GCC, all objects are passed by reference if they have a destructor
pavolmarko@447
  1603
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@447
  1604
			{
pavolmarko@447
  1605
				IntPassInfo &pi = m_Proto.GetParam(i);
pavolmarko@447
  1606
				if (pi.type == PassInfo::PassType_Object &&
pavolmarko@447
  1607
					(pi.flags & PassInfo::PassFlag_ODtor))
pavolmarko@447
  1608
				{
pavolmarko@448
  1609
					pi.flags |= PassFlag_ForcedByRef;
pavolmarko@447
  1610
				}
pavolmarko@447
  1611
			}
pavolmarko@447
  1612
#endif
pavolmarko@447
  1613
		}
pavolmarko@447
  1614
pavolmarko@432
  1615
		HookManagerPubFunc GenContext::Generate()
pavolmarko@432
  1616
		{
pavolmarko@432
  1617
			Clear();
pavolmarko@432
  1618
pavolmarko@432
  1619
			// Check conditions:
pavolmarko@432
  1620
			// -1) good proto version
pavolmarko@432
  1621
			//  0) we don't support unknown passtypes, convention, ...
pavolmarko@432
  1622
			//  1) we don't support functions which return objects by value or take parameters by value
pavolmarko@432
  1623
			//     that have a constructor, a destructor or an overloaded assignment op
pavolmarko@432
  1624
			//     (we wouldn't know how to call it!)
pavolmarko@432
  1625
pavolmarko@432
  1626
			if (m_Proto.GetVersion() < 1)
pavolmarko@432
  1627
			{
pavolmarko@432
  1628
				return NULL;
pavolmarko@432
  1629
			}
pavolmarko@432
  1630
pavolmarko@436
  1631
			AutoDetectRetType();
pavolmarko@447
  1632
			AutoDetectParamFlags();
pavolmarko@436
  1633
pavolmarko@452
  1634
			// Basically, we only support ThisCall/thiscall with varargs
pavolmarko@452
  1635
			if ((m_Proto.GetConvention() & (~ProtoInfo::CallConv_HasVafmt)) != ProtoInfo::CallConv_ThisCall)
pavolmarko@432
  1636
			{
pavolmarko@432
  1637
				return NULL;
pavolmarko@432
  1638
			}
pavolmarko@432
  1639
pavolmarko@432
  1640
pavolmarko@432
  1641
			if (m_Proto.GetRet().size != 0 && !PassInfoSupported(m_Proto.GetRet(), true))
pavolmarko@432
  1642
			{
pavolmarko@432
  1643
				return NULL;
pavolmarko@432
  1644
			}
pavolmarko@432
  1645
pavolmarko@432
  1646
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@432
  1647
			{
pavolmarko@432
  1648
				if (!PassInfoSupported(m_Proto.GetParam(i), false))
pavolmarko@432
  1649
					return NULL;
pavolmarko@432
  1650
			}
pavolmarko@432
  1651
pavolmarko@432
  1652
			BuildProtoInfo();
pavolmarko@432
  1653
			GenerateHookFunc();
pavolmarko@442
  1654
			return fastdelegate::detail::horrible_cast<HookManagerPubFunc>(GeneratePubFunc());
pavolmarko@432
  1655
		}
pavolmarko@455
  1656
pavolmarko@455
  1657
		HookManagerPubFunc GenContext::GetPubFunc()
pavolmarko@455
  1658
		{
pavolmarko@455
  1659
			if (m_GeneratedPubFunc == 0)
pavolmarko@455
  1660
				m_GeneratedPubFunc = Generate();
pavolmarko@455
  1661
pavolmarko@455
  1662
			return m_GeneratedPubFunc;
pavolmarko@455
  1663
		}
pavolmarko@455
  1664
pavolmarko@455
  1665
		bool GenContext::Equal(const CProto &proto, int vtbl_offs, int vtbl_idx)
pavolmarko@455
  1666
		{
pavolmarko@456
  1667
			return (m_OrigProto.ExactlyEqual(proto) && m_VtblOffs == vtbl_offs && m_VtblIdx == vtbl_idx);
pavolmarko@455
  1668
		}
pavolmarko@455
  1669
pavolmarko@455
  1670
		bool GenContext::Equal(HookManagerPubFunc other)
pavolmarko@455
  1671
		{
pavolmarko@455
  1672
			return m_GeneratedPubFunc == other;
pavolmarko@455
  1673
		}
pavolmarko@455
  1674
pavolmarko@455
  1675
		// *********************************** class GenContextContainer
pavolmarko@455
  1676
		CHookManagerAutoGen::CHookManagerAutoGen(ISourceHook *pSHPtr) : m_pSHPtr(pSHPtr)
pavolmarko@455
  1677
		{
pavolmarko@455
  1678
		}
pavolmarko@455
  1679
pavolmarko@455
  1680
		CHookManagerAutoGen::~CHookManagerAutoGen()
pavolmarko@455
  1681
		{
pavolmarko@455
  1682
			for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
pavolmarko@455
  1683
			{
pavolmarko@455
  1684
				delete iter->m_GenContext;
pavolmarko@455
  1685
			}
pavolmarko@455
  1686
		}
pavolmarko@455
  1687
pavolmarko@455
  1688
		int CHookManagerAutoGen::GetIfaceVersion()
pavolmarko@455
  1689
		{
pavolmarko@455
  1690
			return SH_HOOKMANAUTOGEN_IFACE_VERSION;
pavolmarko@455
  1691
		}
pavolmarko@455
  1692
pavolmarko@455
  1693
		int CHookManagerAutoGen::GetImplVersion()
pavolmarko@455
  1694
		{
pavolmarko@455
  1695
			return SH_HOOKMANAUTOGEN_IMPL_VERSION;
pavolmarko@455
  1696
		}
pavolmarko@455
  1697
pavolmarko@455
  1698
		HookManagerPubFunc CHookManagerAutoGen::MakeHookMan(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx)
pavolmarko@455
  1699
		{
pavolmarko@455
  1700
			CProto mproto(proto);
pavolmarko@455
  1701
			for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
pavolmarko@455
  1702
			{
pavolmarko@455
  1703
				if (iter->m_GenContext->Equal(mproto, vtbl_offs, vtbl_idx))
pavolmarko@455
  1704
				{
pavolmarko@455
  1705
					iter->m_RefCnt++;
pavolmarko@455
  1706
					return iter->m_GenContext->GetPubFunc();
pavolmarko@455
  1707
				}
pavolmarko@455
  1708
			}
pavolmarko@455
  1709
pavolmarko@455
  1710
			// Not found yet -> new one
pavolmarko@455
  1711
			StoredContext sctx;
pavolmarko@455
  1712
			sctx.m_RefCnt = 1;
pavolmarko@455
  1713
			sctx.m_GenContext = new GenContext(proto, vtbl_offs, vtbl_idx, m_pSHPtr);
pavolmarko@455
  1714
pavolmarko@455
  1715
			if (sctx.m_GenContext->GetPubFunc() == NULL)
pavolmarko@455
  1716
			{
pavolmarko@455
  1717
				return NULL;
pavolmarko@455
  1718
			}
pavolmarko@455
  1719
			else
pavolmarko@455
  1720
			{
pavolmarko@455
  1721
				m_Contexts.push_back(sctx);
pavolmarko@455
  1722
				return sctx.m_GenContext->GetPubFunc();
pavolmarko@455
  1723
			}
pavolmarko@455
  1724
		}
pavolmarko@455
  1725
pavolmarko@455
  1726
		void CHookManagerAutoGen::ReleaseHookMan(HookManagerPubFunc pubFunc)
pavolmarko@455
  1727
		{
pavolmarko@455
  1728
			for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
pavolmarko@455
  1729
			{
pavolmarko@455
  1730
				if (iter->m_GenContext->Equal(pubFunc))
pavolmarko@455
  1731
				{
pavolmarko@455
  1732
					iter->m_RefCnt--;
pavolmarko@455
  1733
					if (iter->m_RefCnt == 0)
pavolmarko@455
  1734
					{
pavolmarko@455
  1735
						delete iter->m_GenContext;
pavolmarko@455
  1736
						m_Contexts.erase(iter);
pavolmarko@455
  1737
					}
pavolmarko@455
  1738
					break;
pavolmarko@455
  1739
				}
pavolmarko@455
  1740
			}
pavolmarko@455
  1741
		}
pavolmarko@432
  1742
	}
pavolmarko@442
  1743
}