core/sourcehook/sourcehook_hookmangen.cpp
author Scott Ehlert <ds@alliedmods.net>
Thu Dec 10 00:59:50 2009 -0600 (2009-12-10)
changeset 689 4065ba5e9155
parent 685 522727461c0d
child 733 2365240861a2
permissions -rw-r--r--
Rewrote user message caching code to always use IServerGameDLL::GetUserMessageInfo (bug 4117, r=dvander).

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