mono/arch/x86/tramp.c

   1 /*
   2  * Create trampolines to invoke arbitrary functions.
   3  *
   4  * Copyright (C) Ximian Inc.
   5  *
   6  * Author: Paolo Molaro (lupus@ximian.com)
   7  *
   8  */
   9
  10 #include "config.h"
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include "x86-codegen.h"
  14 #include "mono/metadata/class.h"
  15 #include "mono/metadata/tabledefs.h"
  16 #include "mono/interpreter/interp.h"
  17 #include "mono/metadata/appdomain.h"
  18 #include "mono/metadata/marshal.h"
  19
  20 /*
  21  * The resulting function takes the form:
  22  * void func (void (*callme)(), void *retval, void *this_obj, stackval *arguments);
  23  */
  24 #define FUNC_ADDR_POS   8
  25 #define RETVAL_POS      12
  26 #define THIS_POS        16
  27 #define ARGP_POS        20
  28 #define LOC_POS -4
  29
  30 #define ARG_SIZE        sizeof (stackval)
  31
  32 MonoPIFunc
  33 mono_create_trampoline (MonoMethod *method, int runtime)
  34 {
  35         MonoMethodSignature *sig;
  36         unsigned char *p, *code_buffer;
  37         guint32 local_size = 0, stack_size = 0, code_size = 50;
  38         guint32 arg_pos, simpletype;
  39         int i, stringp;
  40         int need_marshal;
  41         GList *free_locs = NULL;
  42
  43         if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) || runtime)
  44                 need_marshal = 0;
  45         else
  46                 need_marshal = 1;
  47
  48         sig = method->signature;
  49
  50         if (sig->hasthis) {
  51                 stack_size += sizeof (gpointer);
  52                 code_size += 5;
  53         }
  54
  55         for (i = 0; i < sig->param_count; ++i) {
  56                 if (sig->params [i]->byref) {
  57                         stack_size += sizeof (gpointer);
  58                         code_size += 20;
  59                         local_size++;
  60                         continue;
  61                 }
  62                 simpletype = sig->params [i]->type;
  63 enum_calc_size:
  64                 switch (simpletype) {
  65                 case MONO_TYPE_BOOLEAN:
  66                 case MONO_TYPE_CHAR:
  67                 case MONO_TYPE_I1:
  68                 case MONO_TYPE_U1:
  69                 case MONO_TYPE_I2:
  70                 case MONO_TYPE_U2:
  71                 case MONO_TYPE_I4:
  72                 case MONO_TYPE_U4:
  73                 case MONO_TYPE_I:
  74                 case MONO_TYPE_U:
  75                 case MONO_TYPE_PTR:
  76                 case MONO_TYPE_R4:
  77                 case MONO_TYPE_SZARRAY:
  78                 case MONO_TYPE_CLASS:
  79                 case MONO_TYPE_OBJECT:
  80                         stack_size += 4;
  81                         code_size += i < 10 ? 5 : 8;
  82                         break;
  83                 case MONO_TYPE_VALUETYPE:
  84                         if (sig->params [i]->data.klass->enumtype) {
  85                                 simpletype = sig->params [i]->data.klass->enum_basetype->type;
  86                                 goto enum_calc_size;
  87                         }
  88                         if (mono_class_value_size (sig->params [i]->data.klass, NULL) != 4)
  89                                 g_error ("can only marshal enums, not generic structures (size: %d)", mono_class_value_size (sig->params [i]->data.klass, NULL));
  90                         stack_size += 4;
  91                         code_size += i < 10 ? 5 : 8;
  92                         break;
  93                 case MONO_TYPE_STRING:
  94                         stack_size += 4;
  95                         code_size += 20;
  96                         local_size++;
  97                         break;
  98                 case MONO_TYPE_I8:
  99                         stack_size += 8;
 100                         code_size += i < 10 ? 5 : 8;
 101                         break;
 102                 case MONO_TYPE_R8:
 103                         stack_size += 8;
 104                         code_size += i < 10 ? 7 : 10;
 105                         break;
 106                 default:
 107                         g_error ("Can't trampoline 0x%x", sig->params [i]->type);
 108                 }
 109         }
 110         /*
 111          * FIXME: take into account large return values.
 112          */
 113
 114         code_buffer = p = alloca (code_size);
 115
 116         /*
 117          * Standard function prolog.
 118          */
 119         x86_push_reg (p, X86_EBP);
 120         x86_mov_reg_reg (p, X86_EBP, X86_ESP, 4);
 121         /*
 122          * We store some local vars here to handle string pointers.
 123          * and align to 16 byte boundary...
 124          */
 125         if (local_size) {
 126                 x86_alu_reg_imm (p, X86_SUB, X86_ESP, local_size * 4);
 127                 stack_size = (stack_size * local_size * 4) % 16;
 128         } else {
 129                 stack_size = stack_size % 16;
 130         }
 131         if (stack_size)
 132                 x86_alu_reg_imm (p, X86_SUB, X86_ESP, stack_size);
 133
 134         /*
 135          * EDX has the pointer to the args.
 136          */
 137         x86_mov_reg_membase (p, X86_EDX, X86_EBP, ARGP_POS, 4);
 138
 139         /*
 140          * Push arguments in reverse order.
 141          */
 142         stringp = 0;
 143         for (i = sig->param_count; i; --i) {
 144                 arg_pos = ARG_SIZE * (i - 1);
 145                 if (sig->params [i - 1]->byref) {
 146                         if (!need_marshal) {
 147                                 x86_push_membase (p, X86_EDX, arg_pos);
 148                                 continue;
 149                         }
 150                         if (sig->params [i - 1]->type == MONO_TYPE_SZARRAY &&
 151                             sig->params [i - 1]->data.type->type == MONO_TYPE_STRING) {
 152                                 x86_mov_reg_membase (p, X86_EAX, X86_EDX, arg_pos, 4);
 153                                 x86_push_regp (p, X86_EAX);
 154                                 x86_mov_reg_imm (p, X86_EDX, mono_marshal_string_array);
 155                                 x86_call_reg (p, X86_EDX);
 156                                 x86_alu_reg_imm (p, X86_ADD, X86_ESP, 4);
 157                                 /*
 158                                  * Store the pointer in a local we'll free later.
 159                                  */
 160                                 stringp++;
 161                                 x86_mov_membase_reg (p, X86_EBP, LOC_POS * stringp, X86_EAX, 4);
 162                                 free_locs = g_list_prepend (free_locs, GUINT_TO_POINTER (LOC_POS * stringp));
 163                                 /* load the pointer and push it */
 164                                 x86_lea_membase (p, X86_EAX, X86_EBP, LOC_POS * stringp);
 165                                 x86_push_reg (p, X86_EAX);
 166                                 /* restore pointer to args in EDX */
 167                                 x86_mov_reg_membase (p, X86_EDX, X86_EBP, ARGP_POS, 4);
 168                         } else {
 169                                 x86_push_membase (p, X86_EDX, arg_pos);
 170                         }
 171                         continue;
 172                 }
 173                 simpletype = sig->params [i - 1]->type;
 174 enum_marshal:
 175                 switch (simpletype) {
 176                 case MONO_TYPE_BOOLEAN:
 177                 case MONO_TYPE_I1:
 178                 case MONO_TYPE_U1:
 179                 case MONO_TYPE_I2:
 180                 case MONO_TYPE_U2:
 181                 case MONO_TYPE_CHAR:
 182                 case MONO_TYPE_I4:
 183                 case MONO_TYPE_U4:
 184                 case MONO_TYPE_I:
 185                 case MONO_TYPE_U:
 186                 case MONO_TYPE_PTR:
 187                 case MONO_TYPE_SZARRAY:
 188                 case MONO_TYPE_CLASS:
 189                 case MONO_TYPE_OBJECT:
 190                 case MONO_TYPE_R4:
 191                         x86_push_membase (p, X86_EDX, arg_pos);
 192                         break;
 193                 case MONO_TYPE_VALUETYPE:
 194                         if (!sig->params [i - 1]->data.klass->enumtype) {
 195                                 /* it's a structure that fits in 4 bytes, need to push the value pointed to */
 196                                 x86_mov_reg_membase (p, X86_EAX, X86_EDX, arg_pos, 4);
 197                                 x86_push_regp (p, X86_EAX);
 198                         } else {
 199                                 /* it's an enum value */
 200                                 simpletype = sig->params [i - 1]->data.klass->enum_basetype->type;
 201                                 goto enum_marshal;
 202                         }
 203                         break;
 204                 case MONO_TYPE_STRING:
 205                         /*
 206                          * If it is an internalcall we assume it's the object we want.
 207                          * Yet another reason why MONO_TYPE_STRING should not be used to indicate char*.
 208                          */
 209                         if (!need_marshal) {
 210                                 x86_push_membase (p, X86_EDX, arg_pos);
 211                                 break;
 212                         }
 213                         /*if (frame->method->flags & PINVOKE_ATTRIBUTE_CHAR_SET_ANSI*/
 214                         x86_push_membase (p, X86_EDX, arg_pos);
 215                         x86_mov_reg_imm (p, X86_EDX, mono_string_to_utf8);
 216                         x86_call_reg (p, X86_EDX);
 217                         x86_alu_reg_imm (p, X86_ADD, X86_ESP, 4);
 218                         x86_push_reg (p, X86_EAX);
 219                         /*
 220                          * Store the pointer in a local we'll free later.
 221                          */
 222                         stringp++;
 223                         x86_mov_membase_reg (p, X86_EBP, LOC_POS * stringp, X86_EAX, 4);
 224                         free_locs = g_list_prepend (free_locs, GUINT_TO_POINTER (LOC_POS * stringp));
 225                         /*
 226                          * we didn't save the reg: restore it here.
 227                          */
 228                         if (i > 1)
 229                                 x86_mov_reg_membase (p, X86_EDX, X86_EBP, ARGP_POS, 4);
 230                         break;
 231                 case MONO_TYPE_I8:
 232                 case MONO_TYPE_U8:
 233                 case MONO_TYPE_R8:
 234                         x86_push_membase (p, X86_EDX, arg_pos + 4);
 235                         x86_push_membase (p, X86_EDX, arg_pos);
 236                         break;
 237                 default:
 238                         g_error ("Can't trampoline 0x%x", sig->params [i - 1]->type);
 239                 }
 240         }
 241
 242         if (sig->hasthis) {
 243                 if (sig->call_convention != MONO_CALL_THISCALL) {
 244                         x86_mov_reg_membase (p, X86_EDX, X86_EBP, THIS_POS, 4);
 245                         x86_push_reg (p, X86_EDX);
 246                 } else {
 247                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, THIS_POS, 4);
 248                 }
 249         }
 250
 251         /*
 252          * Insert call to function
 253          */
 254         x86_mov_reg_membase (p, X86_EDX, X86_EBP, FUNC_ADDR_POS, 4);
 255         x86_call_reg (p, X86_EDX);
 256
 257         /*
 258          * Handle retval.
 259          * Small integer and pointer values are in EAX.
 260          * Long integers are in EAX:EDX.
 261          * FP values are on the FP stack.
 262          */
 263
 264         if (sig->ret->byref ||
 265             (method->klass == mono_defaults.string_class &&
 266              *method->name == '.' && !strcmp (method->name, ".ctor"))) {
 267                 x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 268                 x86_mov_regp_reg (p, X86_ECX, X86_EAX, 4);
 269         } else {
 270                 simpletype = sig->ret->type;
 271 enum_retvalue:
 272                 switch (simpletype) {
 273                 case MONO_TYPE_BOOLEAN:
 274                 case MONO_TYPE_I1:
 275                 case MONO_TYPE_U1:
 276                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 277                         x86_mov_regp_reg (p, X86_ECX, X86_EAX, 1);
 278                         break;
 279                 case MONO_TYPE_CHAR:
 280                 case MONO_TYPE_I2:
 281                 case MONO_TYPE_U2:
 282                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 283                         x86_mov_regp_reg (p, X86_ECX, X86_EAX, 2);
 284                         break;
 285                 case MONO_TYPE_I4:
 286                 case MONO_TYPE_U4:
 287                 case MONO_TYPE_I:
 288                 case MONO_TYPE_U:
 289                 case MONO_TYPE_CLASS:
 290                 case MONO_TYPE_OBJECT:
 291                 case MONO_TYPE_SZARRAY:
 292                 case MONO_TYPE_ARRAY:
 293                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 294                         x86_mov_regp_reg (p, X86_ECX, X86_EAX, 4);
 295                         break;
 296                 case MONO_TYPE_STRING:
 297                         if (!need_marshal) {
 298                                 x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 299                                 x86_mov_regp_reg (p, X86_ECX, X86_EAX, 4);
 300                                 break;
 301                         }
 302
 303                         /* If the argument is non-null, then convert the value back */
 304                         x86_alu_reg_reg (p, X86_OR, X86_EAX, X86_EAX);
 305                         x86_branch8 (p, X86_CC_EQ, 11, FALSE);
 306                         x86_push_reg (p, X86_EAX);
 307                         x86_mov_reg_imm (p, X86_EDX, mono_string_new_wrapper);
 308                         x86_call_reg (p, X86_EDX);
 309                         x86_alu_reg_imm (p, X86_ADD, X86_ESP, 4);
 310
 311                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 312                         x86_mov_regp_reg (p, X86_ECX, X86_EAX, 4);
 313                         break;
 314                 case MONO_TYPE_R4:
 315                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 316                         x86_fst_membase (p, X86_ECX, 0, FALSE, TRUE);
 317                         break;
 318                 case MONO_TYPE_R8:
 319                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 320                         x86_fst_membase (p, X86_ECX, 0, TRUE, TRUE);
 321                         break;
 322                 case MONO_TYPE_I8:
 323                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, RETVAL_POS, 4);
 324                         x86_mov_regp_reg (p, X86_ECX, X86_EAX, 4);
 325                         x86_mov_membase_reg (p, X86_ECX, 4, X86_EDX, 4);
 326                         break;
 327                 case MONO_TYPE_VALUETYPE:
 328                         if (sig->ret->data.klass->enumtype) {
 329                                 simpletype = sig->ret->data.klass->enum_basetype->type;
 330                                 goto enum_retvalue;
 331                         }
 332                 case MONO_TYPE_VOID:
 333                         break;
 334                 default:
 335                         g_error ("Can't handle as return value 0x%x", sig->ret->type);
 336                 }
 337         }
 338
 339         /*
 340          * free the allocated strings.
 341          */
 342         if (need_marshal) {
 343                 GList* tmp;
 344                 for (tmp = free_locs; tmp; tmp = tmp->next) {
 345                         x86_mov_reg_imm (p, X86_EDX, g_free);
 346                         x86_push_membase (p, X86_EBP, GPOINTER_TO_UINT (tmp->data));
 347                         x86_call_reg (p, X86_EDX);
 348                 }
 349                 g_list_free (free_locs);
 350         }
 351         /*
 352          * Standard epilog.
 353          */
 354         x86_leave (p);
 355         x86_ret (p);
 356
 357         g_assert (p - code_buffer < code_size);
 358         return g_memdup (code_buffer, p - code_buffer);
 359 }
 360
 361 #define MINV_POS  (- sizeof (MonoInvocation))
 362 #define STACK_POS (MINV_POS - sizeof (stackval) * sig->param_count)
 363 #define OBJ_POS   8
 364 #define TYPE_OFFSET (G_STRUCT_OFFSET (stackval, type))
 365
 366 /*
 367  * Returns a pointer to a native function that can be used to
 368  * call the specified method.
 369  * The function created will receive the arguments according
 370  * to the call convention specified in the method.
 371  * This function works by creating a MonoInvocation structure,
 372  * filling the fields in and calling ves_exec_method on it.
 373  * Still need to figure out how to handle the exception stuff
 374  * across the managed/unmanaged boundary.
 375  */
 376 void *
 377 mono_create_method_pointer (MonoMethod *method)
 378 {
 379         MonoMethodSignature *sig;
 380         MonoJitInfo *ji;
 381         unsigned char *p, *code_buffer;
 382         gint32 local_size;
 383         gint32 stackval_pos, arg_pos = 8;
 384         int i, align;
 385
 386         /*
 387          * If it is a static P/Invoke method, we can just return the pointer
 388          * to the method implementation.
 389          */
 390         sig = method->signature;
 391
 392         code_buffer = p = alloca (512); /* FIXME: check for overflows... */
 393
 394         local_size = sizeof (MonoInvocation) + sizeof (stackval) * (sig->param_count + 1);
 395         stackval_pos = -local_size;
 396
 397         /*
 398          * Standard function prolog.
 399          */
 400         x86_push_reg (p, X86_EBP);
 401         x86_mov_reg_reg (p, X86_EBP, X86_ESP, 4);
 402         x86_alu_reg_imm (p, X86_SUB, X86_ESP, local_size);
 403
 404         /*
 405          * Initialize MonoInvocation fields, first the ones known now.
 406          */
 407         x86_mov_reg_imm (p, X86_EAX, 0);
 408         x86_mov_membase_reg (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex)), X86_EAX, 4);
 409         x86_mov_membase_reg (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex_handler)), X86_EAX, 4);
 410         x86_mov_membase_reg (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, child)), X86_EAX, 4);
 411         x86_mov_membase_reg (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, parent)), X86_EAX, 4);
 412         /*
 413          * Set the method pointer.
 414          */
 415         x86_mov_membase_imm (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, method)), (int)method, 4);
 416
 417         /*
 418          * Handle this.
 419          */
 420         if (sig->hasthis) {
 421                 if (sig->call_convention != MONO_CALL_THISCALL) {
 422                         /*
 423                          * Grab it from the stack, otherwise it's already in ECX.
 424                          */
 425                         x86_mov_reg_membase (p, X86_ECX, X86_EBP, OBJ_POS, 4);
 426                         arg_pos += 4;
 427                 }
 428                 x86_mov_membase_reg (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj)), X86_ECX, 4);
 429         }
 430         /*
 431          * Handle the arguments. stackval_pos is the posset of the stackval array from EBP.
 432          * arg_pos is the offset from EBP to the incoming arg on the stack.
 433          * We just call stackval_from_data to handle all the (nasty) issues....
 434          */
 435         x86_lea_membase (p, X86_EAX, X86_EBP, stackval_pos);
 436         x86_mov_membase_reg (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, stack_args)), X86_EAX, 4);
 437         for (i = 0; i < sig->param_count; ++i) {
 438                 x86_mov_reg_imm (p, X86_ECX, stackval_from_data);
 439                 x86_lea_membase (p, X86_EDX, X86_EBP, arg_pos);
 440                 x86_lea_membase (p, X86_EAX, X86_EBP, stackval_pos);
 441                 x86_push_reg (p, X86_EDX);
 442                 x86_push_reg (p, X86_EAX);
 443                 x86_push_imm (p, sig->params [i]);
 444                 x86_call_reg (p, X86_ECX);
 445                 x86_alu_reg_imm (p, X86_SUB, X86_ESP, 12);
 446                 stackval_pos += sizeof (stackval);
 447                 arg_pos += mono_type_stack_size (sig->params [i], &align);
 448         }
 449
 450         /*
 451          * Handle the return value storage area.
 452          */
 453         x86_lea_membase (p, X86_EAX, X86_EBP, stackval_pos);
 454         x86_mov_membase_reg (p, X86_EBP, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval)), X86_EAX, 4);
 455
 456         /*
 457          * Call the method.
 458          */
 459         x86_lea_membase (p, X86_EAX, X86_EBP, MINV_POS);
 460         x86_push_reg (p, X86_EAX);
 461         x86_mov_reg_imm (p, X86_EDX, ves_exec_method);
 462         x86_call_reg (p, X86_EDX);
 463
 464         /*
 465          * Move the return value to the proper place.
 466          */
 467         x86_lea_membase (p, X86_EAX, X86_EBP, stackval_pos);
 468         if (sig->ret->byref) {
 469                 x86_mov_reg_membase (p, X86_EAX, X86_EAX, 0, 4);
 470         } else {
 471                 switch (sig->ret->type) {
 472                 case MONO_TYPE_VOID:
 473                         break;
 474                 case MONO_TYPE_BOOLEAN:
 475                         x86_mov_reg_membase (p, X86_EAX, X86_EAX, 0, 1);
 476                         break;
 477                 case MONO_TYPE_I4:
 478                 case MONO_TYPE_U4:
 479                 case MONO_TYPE_I:
 480                 case MONO_TYPE_U:
 481                 case MONO_TYPE_OBJECT:
 482                 case MONO_TYPE_STRING:
 483                 case MONO_TYPE_CLASS:
 484                         x86_mov_reg_membase (p, X86_EAX, X86_EAX, 0, 4);
 485                         break;
 486                 case MONO_TYPE_I8:
 487                         x86_mov_reg_membase (p, X86_EDX, X86_EAX, 4, 4);
 488                         x86_mov_reg_membase (p, X86_EAX, X86_EAX, 0, 4);
 489                         break;
 490                 case MONO_TYPE_R8:
 491                         x86_fld_membase (p, X86_EAX, 0, TRUE);
 492                         break;
 493                 default:
 494                         g_error ("Type 0x%x not handled yet in thunk creation", sig->ret->type);
 495                         break;
 496                 }
 497         }
 498
 499         /*
 500          * Standard epilog.
 501          */
 502         x86_leave (p);
 503         x86_ret (p);
 504
 505         g_assert (p - code_buffer < 512);
 506
 507         ji = g_new0 (MonoJitInfo, 1);
 508         ji->method = method;
 509         ji->code_size = p - code_buffer;
 510         ji->code_start = g_memdup (code_buffer, p - code_buffer);
 511
 512         mono_jit_info_table_add (mono_root_domain, ji);
 513
 514         return ji->code_start;
 515 }