sourcehook/sourcehook_hookmangen.cpp
author David Anderson <dvander@alliedmods.net>
Tue Oct 14 23:31:05 2008 -0700 (2008-10-14)
changeset 534 eb2d7d18441c
parent 523 6f1630519b81
permissions -rw-r--r--
Added MSVC9 support (bug 3258).
pavolmarko@480
     1
/* ======== SourceHook ========
ds@523
     2
* Copyright (C) 2004-2008 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);
pavolmarko@480
   876
					IA32_Mov_Reg_Rm_DispAuto(&m_HookFunc, REG_EAX, 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
pavolmarko@480
  1872
						// Same goes for GCC :)
pavolmarko@480
  1873
						pi.flags |= PassInfo::PassFlag_RetMem;
pavolmarko@480
  1874
#endif
pavolmarko@480
  1875
					}
pavolmarko@480
  1876
				}
pavolmarko@480
  1877
			}
pavolmarko@480
  1878
			else
pavolmarko@480
  1879
			{
pavolmarko@480
  1880
				// byref: make sure that the flag is _not_ set
pavolmarko@480
  1881
				pi.flags &= ~PassInfo::PassFlag_RetMem;
pavolmarko@480
  1882
				pi.flags |= PassInfo::PassFlag_RetReg;
pavolmarko@480
  1883
			}
pavolmarko@480
  1884
		}
pavolmarko@480
  1885
pavolmarko@480
  1886
		void GenContext::AutoDetectParamFlags()
pavolmarko@480
  1887
		{
pavolmarko@480
  1888
#if SH_COMP == SH_COMP_GCC
pavolmarko@480
  1889
			// On GCC, all objects are passed by reference if they have a destructor
pavolmarko@480
  1890
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@480
  1891
			{
pavolmarko@480
  1892
				IntPassInfo &pi = m_Proto.GetParam(i);
pavolmarko@480
  1893
				if (pi.type == PassInfo::PassType_Object && (pi.flags & PassInfo::PassFlag_ByVal) && 
pavolmarko@480
  1894
					(pi.flags & PassInfo::PassFlag_ODtor))
pavolmarko@480
  1895
				{
pavolmarko@480
  1896
					pi.flags |= PassFlag_ForcedByRef;
pavolmarko@480
  1897
				}
pavolmarko@480
  1898
			}
pavolmarko@480
  1899
#endif
pavolmarko@480
  1900
		}
pavolmarko@480
  1901
pavolmarko@480
  1902
		HookManagerPubFunc GenContext::Generate()
pavolmarko@480
  1903
		{
pavolmarko@480
  1904
			Clear();
pavolmarko@480
  1905
pavolmarko@480
  1906
			// Check conditions:
pavolmarko@480
  1907
			// -1) good proto version
pavolmarko@480
  1908
			//  0) we don't support unknown passtypes, convention, ...
pavolmarko@480
  1909
			//  1) we don't support functions which return objects by value or take parameters by value
pavolmarko@480
  1910
			//     that have a constructor, a destructor or an overloaded assignment op
pavolmarko@480
  1911
			//     (we wouldn't know how to call it!)
pavolmarko@480
  1912
pavolmarko@480
  1913
			if (m_Proto.GetVersion() < 1)
pavolmarko@480
  1914
			{
pavolmarko@480
  1915
				return NULL;
pavolmarko@480
  1916
			}
pavolmarko@480
  1917
pavolmarko@480
  1918
			AutoDetectRetType();
pavolmarko@480
  1919
			AutoDetectParamFlags();
pavolmarko@480
  1920
pavolmarko@480
  1921
			// Basically, we only support ThisCall/thiscall with varargs
pavolmarko@480
  1922
			if ((m_Proto.GetConvention() & (~ProtoInfo::CallConv_HasVafmt)) != ProtoInfo::CallConv_ThisCall)
pavolmarko@480
  1923
			{
pavolmarko@480
  1924
				return NULL;
pavolmarko@480
  1925
			}
pavolmarko@480
  1926
pavolmarko@480
  1927
pavolmarko@480
  1928
			if (m_Proto.GetRet().size != 0 && !PassInfoSupported(m_Proto.GetRet(), true))
pavolmarko@480
  1929
			{
pavolmarko@480
  1930
				return NULL;
pavolmarko@480
  1931
			}
pavolmarko@480
  1932
pavolmarko@480
  1933
			for (int i = 0; i < m_Proto.GetNumOfParams(); ++i)
pavolmarko@480
  1934
			{
pavolmarko@480
  1935
				if (!PassInfoSupported(m_Proto.GetParam(i), false))
pavolmarko@480
  1936
					return NULL;
pavolmarko@480
  1937
			}
pavolmarko@480
  1938
pavolmarko@480
  1939
			BuildProtoInfo();
pavolmarko@480
  1940
			GenerateHookFunc();
pavolmarko@480
  1941
			return fastdelegate::detail::horrible_cast<HookManagerPubFunc>(GeneratePubFunc());
pavolmarko@480
  1942
		}
pavolmarko@480
  1943
pavolmarko@480
  1944
		HookManagerPubFunc GenContext::GetPubFunc()
pavolmarko@480
  1945
		{
pavolmarko@480
  1946
			if (m_GeneratedPubFunc == 0)
pavolmarko@480
  1947
				m_GeneratedPubFunc = Generate();
pavolmarko@480
  1948
pavolmarko@480
  1949
			return m_GeneratedPubFunc;
pavolmarko@480
  1950
		}
pavolmarko@480
  1951
pavolmarko@480
  1952
		bool GenContext::Equal(const CProto &proto, int vtbl_offs, int vtbl_idx)
pavolmarko@480
  1953
		{
pavolmarko@480
  1954
			return (m_OrigProto.ExactlyEqual(proto) && m_VtblOffs == vtbl_offs && m_VtblIdx == vtbl_idx);
pavolmarko@480
  1955
		}
pavolmarko@480
  1956
pavolmarko@480
  1957
		bool GenContext::Equal(HookManagerPubFunc other)
pavolmarko@480
  1958
		{
pavolmarko@480
  1959
			return m_GeneratedPubFunc == other;
pavolmarko@480
  1960
		}
pavolmarko@480
  1961
pavolmarko@480
  1962
		// *********************************** class GenContextContainer
pavolmarko@480
  1963
		CHookManagerAutoGen::CHookManagerAutoGen(ISourceHook *pSHPtr) : m_pSHPtr(pSHPtr)
pavolmarko@480
  1964
		{
pavolmarko@480
  1965
		}
pavolmarko@480
  1966
pavolmarko@480
  1967
		CHookManagerAutoGen::~CHookManagerAutoGen()
pavolmarko@480
  1968
		{
pavolmarko@480
  1969
			for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
pavolmarko@480
  1970
			{
pavolmarko@480
  1971
				delete iter->m_GenContext;
pavolmarko@480
  1972
			}
pavolmarko@480
  1973
		}
pavolmarko@480
  1974
pavolmarko@480
  1975
		int CHookManagerAutoGen::GetIfaceVersion()
pavolmarko@480
  1976
		{
pavolmarko@480
  1977
			return SH_HOOKMANAUTOGEN_IFACE_VERSION;
pavolmarko@480
  1978
		}
pavolmarko@480
  1979
pavolmarko@480
  1980
		int CHookManagerAutoGen::GetImplVersion()
pavolmarko@480
  1981
		{
pavolmarko@480
  1982
			return SH_HOOKMANAUTOGEN_IMPL_VERSION;
pavolmarko@480
  1983
		}
pavolmarko@480
  1984
pavolmarko@480
  1985
		HookManagerPubFunc CHookManagerAutoGen::MakeHookMan(const ProtoInfo *proto, int vtbl_offs, int vtbl_idx)
pavolmarko@480
  1986
		{
pavolmarko@480
  1987
			CProto mproto(proto);
pavolmarko@480
  1988
			for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
pavolmarko@480
  1989
			{
pavolmarko@480
  1990
				if (iter->m_GenContext->Equal(mproto, vtbl_offs, vtbl_idx))
pavolmarko@480
  1991
				{
pavolmarko@480
  1992
					iter->m_RefCnt++;
pavolmarko@480
  1993
					return iter->m_GenContext->GetPubFunc();
pavolmarko@480
  1994
				}
pavolmarko@480
  1995
			}
pavolmarko@480
  1996
pavolmarko@480
  1997
			// Not found yet -> new one
pavolmarko@480
  1998
			StoredContext sctx;
pavolmarko@480
  1999
			sctx.m_RefCnt = 1;
pavolmarko@480
  2000
			sctx.m_GenContext = new GenContext(proto, vtbl_offs, vtbl_idx, m_pSHPtr);
pavolmarko@480
  2001
pavolmarko@480
  2002
			if (sctx.m_GenContext->GetPubFunc() == NULL)
pavolmarko@480
  2003
			{
pavolmarko@480
  2004
				return NULL;
pavolmarko@480
  2005
			}
pavolmarko@480
  2006
			else
pavolmarko@480
  2007
			{
pavolmarko@480
  2008
				m_Contexts.push_back(sctx);
pavolmarko@480
  2009
				return sctx.m_GenContext->GetPubFunc();
pavolmarko@480
  2010
			}
pavolmarko@480
  2011
		}
pavolmarko@480
  2012
pavolmarko@480
  2013
		void CHookManagerAutoGen::ReleaseHookMan(HookManagerPubFunc pubFunc)
pavolmarko@480
  2014
		{
pavolmarko@480
  2015
			for (List<StoredContext>::iterator iter = m_Contexts.begin(); iter != m_Contexts.end(); ++iter)
pavolmarko@480
  2016
			{
pavolmarko@480
  2017
				if (iter->m_GenContext->Equal(pubFunc))
pavolmarko@480
  2018
				{
pavolmarko@480
  2019
					iter->m_RefCnt--;
pavolmarko@480
  2020
					if (iter->m_RefCnt == 0)
pavolmarko@480
  2021
					{
pavolmarko@480
  2022
						delete iter->m_GenContext;
pavolmarko@480
  2023
						m_Contexts.erase(iter);
pavolmarko@480
  2024
					}
pavolmarko@480
  2025
					break;
pavolmarko@480
  2026
				}
pavolmarko@480
  2027
			}
pavolmarko@480
  2028
		}
pavolmarko@480
  2029
	}
pavolmarko@480
  2030
}