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