Merge remote branch 'upstream/master'

diff --cc configure.in
Simple merge

diff --cc mono/io-layer/sockets.c
Simple merge

diff --cc mono/metadata/assembly.c
Simple merge

diff --cc mono/metadata/object.c
Simple merge

diff --cc mono/mini/Makefile.am
Simple merge

diff --cc mono/mini/aot-compiler.c
index 5e8bc916b840882895ae888086dda7836db93080,35d9c911840b8a231abdb36f6ad57e15bddffd80..6f13e974c20ccf7feab18eea589ede91e123fbf4
--- 1/mono/mini/aot-compiler.c
--- 2/mono/mini/aot-compiler.c
+++ b/mono/mini/aot-compiler.c
@@@ -3950,8 -3916,7 +4048,7 @@@ emit_plt (MonoAotCompile *acfg
        sprintf (symbol, "plt");
  
        emit_section_change (acfg, ".text", 0);
-       emit_global (acfg, symbol, TRUE);
 -      emit_alignment (acfg, 16);
 +      emit_alignment (acfg, NACL_SIZE(16, kNaClAlignment));
        emit_label (acfg, symbol);
        emit_label (acfg, acfg->plt_symbol);
  

diff --cc mono/mini/aot-runtime.c
index bcd3b1c3e0a0ea129d02174855cb3c93d200594f,9610c7859b29d13a8001d15047d6832016356c99..115384028f003b2d2bca9677e26e655fb197ce92
--- 1/mono/mini/aot-runtime.c
--- 2/mono/mini/aot-runtime.c
+++ b/mono/mini/aot-runtime.c
@@@ -934,17 -1030,12 +1030,13 @@@ load_aot_module (MonoAssembly *assembly
        MonoAotModule *amodule;
        MonoDl *sofile;
        gboolean usable = TRUE;
-       char *saved_guid = NULL;
-       char *aot_version = NULL;
-       char *runtime_version, *build_info;
-       char *opt_flags = NULL;
+       char *version_symbol = NULL;
+       char *msg = NULL;
        gpointer *globals;
-       gboolean full_aot = FALSE;
-       MonoAotFileInfo *file_info = NULL;
-       int i;
-       gpointer *got_addr;
+       MonoAotFileInfo *info = NULL;
+       int i, version;
        guint8 *blob;
 +      gboolean do_load_image = TRUE;
  
        if (mono_compile_aot)
                return;

diff --cc mono/mini/cpu-amd64.md
Simple merge

diff --cc mono/mini/cpu-x86.md
Simple merge

diff --cc mono/mini/exceptions-amd64.c
Simple merge

diff --cc mono/mini/exceptions-x86.c
Simple merge

diff --cc mono/mini/method-to-ir.c
Simple merge

diff --cc mono/mini/mini-amd64.c
index b224680855b002c8fe4674268b2f98cc9e6a1c1d,cb1edb8cdc0c53697b6c3021851f401c69fac76f..49c3a53c715324b74493490b6898225eaf745142
--- 1/mono/mini/mini-amd64.c
--- 2/mono/mini/mini-amd64.c
+++ b/mono/mini/mini-amd64.c
@@@ -1907,12 -1560,12 +1912,12 @@@ mono_arch_allocate_vars (MonoCompile *c
                                        ins->opcode = OP_REGOFFSET;
                                        ins->inst_basereg = cfg->frame_reg;
                                        /* These arguments are saved to the stack in the prolog */
 -                                      offset = ALIGN_TO (offset, sizeof (gpointer));
 +                                      offset = ALIGN_TO (offset, sizeof(mgreg_t));
                                        if (cfg->arch.omit_fp) {
                                                ins->inst_offset = offset;
-                                               offset += (ainfo->storage == ArgValuetypeInReg) ? 2 * sizeof(mgreg_t) : sizeof(mgreg_t);
 -                                              offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (gpointer) : sizeof (gpointer);
++                                              offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (mgreg_t) : sizeof (mgreg_t);
                                        } else {
-                                               offset += (ainfo->storage == ArgValuetypeInReg) ? 2 * sizeof(mgreg_t) : sizeof(mgreg_t);
 -                                              offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (gpointer) : sizeof (gpointer);
++                                              offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (mgreg_t) : sizeof (mgreg_t);
                                                ins->inst_offset = - offset;
                                        }
                                        break;
@@@ -1984,14 -1637,14 +1989,14 @@@
                                ins->opcode = OP_REGOFFSET;
                                ins->inst_basereg = cfg->frame_reg;
                                /* These arguments are saved to the stack in the prolog */
 -                              offset = ALIGN_TO (offset, sizeof (gpointer));
 +                              offset = ALIGN_TO (offset, sizeof(mgreg_t));
                                if (cfg->arch.omit_fp) {
                                        ins->inst_offset = offset;
-                                       offset += (ainfo->storage == ArgValuetypeInReg) ? 2 * sizeof(mgreg_t) : sizeof(mgreg_t);
 -                                      offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (gpointer) : sizeof (gpointer);
++                                      offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (mgreg_t) : sizeof (mgreg_t);
                                        // Arguments are yet supported by the stack map creation code
                                        //cfg->locals_max_stack_offset = MAX (cfg->locals_max_stack_offset, offset);
                                } else {
-                                       offset += (ainfo->storage == ArgValuetypeInReg) ? 2 * sizeof(mgreg_t) : sizeof(mgreg_t);
 -                                      offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (gpointer) : sizeof (gpointer);
++                                      offset += (ainfo->storage == ArgValuetypeInReg) ? ainfo->nregs * sizeof (mgreg_t) : sizeof (mgreg_t);
                                        ins->inst_offset = - offset;
                                        //cfg->locals_min_stack_offset = MIN (cfg->locals_min_stack_offset, offset);
                                }
@@@ -6100,12 -5677,15 +6130,21 @@@ mono_arch_output_basic_block (MonoCompi
                        MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = code - cfg->native_code;
                        break;
                }
 +              case OP_NACL_GC_SAFE_POINT: {
 +#if defined(__native_client_codegen__)
 +                      code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, (gpointer)mono_nacl_gc, TRUE);
 +#endif
 +                      break;
 +              }
+               case OP_GC_LIVENESS_DEF:
+               case OP_GC_LIVENESS_USE:
+               case OP_GC_PARAM_SLOT_LIVENESS_DEF:
+                       ins->backend.pc_offset = code - cfg->native_code;
+                       break;
+               case OP_GC_SPILL_SLOT_LIVENESS_DEF:
+                       ins->backend.pc_offset = code - cfg->native_code;
+                       bb->spill_slot_defs = g_slist_prepend_mempool (cfg->mempool, bb->spill_slot_defs, ins);
+                       break;
                default:
                        g_warning ("unknown opcode %s in %s()\n", mono_inst_name (ins->opcode), __FUNCTION__);
                        g_assert_not_reached ();
@@@ -6308,8 -5870,10 +6348,10 @@@ mono_arch_emit_prolog (MonoCompile *cfg
  #ifdef HOST_WIN32
                mono_arch_unwindinfo_add_push_nonvol (&cfg->arch.unwindinfo, cfg->native_code, code, AMD64_RBP);
  #endif
+               /* These are handled automatically by the stack marking code */
+               mini_gc_set_slot_type_from_cfa (cfg, -cfa_offset, SLOT_NOREF);
                
 -              amd64_mov_reg_reg (code, AMD64_RBP, AMD64_RSP, sizeof (gpointer));
 +              amd64_mov_reg_reg (code, AMD64_RBP, AMD64_RSP, sizeof(mgreg_t));
                mono_emit_unwind_op_def_cfa_reg (cfg, code, AMD64_RBP);
                async_exc_point (code);
  #ifdef HOST_WIN32

diff --cc mono/mini/mini-amd64.h
Simple merge

diff --cc mono/mini/mini-ops.h
index be987c0abab8be789bd0b21ce186af098148b858,b79690642cbac3a6b0091bf26d846191c6d21e2e..687abadec168f4c8cace239a5999c9e18fb2bf1c
--- 1/mono/mini/mini-ops.h
--- 2/mono/mini/mini-ops.h
+++ b/mono/mini/mini-ops.h
@@@ -870,14 -870,27 +870,34 @@@ MINI_OP(OP_LIVERANGE_START, "liverange_
   */
  MINI_OP(OP_LIVERANGE_END, "liverange_end", NONE, NONE, NONE)
  
+ /* GC support */
+ /*
+  * mono_arch_output_basic_block () will set the backend.pc_offset field to the current pc
+  * offset.
+  */
+ MINI_OP(OP_GC_LIVENESS_DEF, "gc_liveness_def", NONE, NONE, NONE)
+ MINI_OP(OP_GC_LIVENESS_USE, "gc_liveness_use", NONE, NONE, NONE)
+ 
+ /*
+  * This marks the location inside a basic block where a GC tracked spill slot has been
+  * defined. The spill slot is assumed to be alive until the end of the bblock.
+  */
+ MINI_OP(OP_GC_SPILL_SLOT_LIVENESS_DEF, "gc_spill_slot_liveness_def", NONE, NONE, NONE)
+ 
+ /*
+  * This marks the location inside a basic block where a GC tracked param area slot has
+  * been defined. The slot is assumed to be alive until the next call.
+  */
+ MINI_OP(OP_GC_PARAM_SLOT_LIVENESS_DEF, "gc_param_slot_liveness_def", NONE, NONE, NONE)
+ 
  /* Arch specific opcodes */
 +/* #if defined(__native_client_codegen__) || defined(__native_client__) */
 +/* We have to define these in terms of the TARGET defines, not NaCl defines */
 +/* because genmdesc.pl doesn't have multiple defines per platform.          */
 +#if defined(TARGET_AMD64) || defined(TARGET_X86)
 +MINI_OP(OP_NACL_GC_SAFE_POINT,     "nacl_gc_safe_point", IREG, NONE, NONE)
 +#endif
 +
  #if defined(TARGET_X86) || defined(TARGET_AMD64)
  MINI_OP(OP_X86_TEST_NULL,          "x86_test_null", NONE, IREG, NONE)
  MINI_OP(OP_X86_COMPARE_MEMBASE_REG,"x86_compare_membase_reg", NONE, IREG, IREG)

diff --cc mono/mini/mini-x86.c
index 1139677d97be0455f49ff857acaa4cf198ac766c,26078a9dc99a5a54c762b09d7bcd2283a5d819fd..66a39e08eb20ab10417a274c2c010ac8109ec556
--- 1/mono/mini/mini-x86.c
--- 2/mono/mini/mini-x86.c
+++ b/mono/mini/mini-x86.c
@@@ -4669,12 -4694,15 +4681,21 @@@ mono_arch_output_basic_block (MonoCompi
                        MONO_VARINFO (cfg, ins->inst_c0)->live_range_end = code - cfg->native_code;
                        break;
                }
 +              case OP_NACL_GC_SAFE_POINT: {
 +#if defined(__native_client_codegen__)
 +                      code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, (gpointer)mono_nacl_gc);
 +#endif
 +                      break;
 +              }
+               case OP_GC_LIVENESS_DEF:
+               case OP_GC_LIVENESS_USE:
+               case OP_GC_PARAM_SLOT_LIVENESS_DEF:
+                       ins->backend.pc_offset = code - cfg->native_code;
+                       break;
+               case OP_GC_SPILL_SLOT_LIVENESS_DEF:
+                       ins->backend.pc_offset = code - cfg->native_code;
+                       bb->spill_slot_defs = g_slist_prepend_mempool (cfg->mempool, bb->spill_slot_defs, ins);
+                       break;
                default:
                        g_warning ("unknown opcode %s\n", mono_inst_name (ins->opcode));
                        g_assert_not_reached ();

diff --cc mono/mini/mini-x86.h
Simple merge

diff --cc mono/mini/mini.c
Simple merge

diff --cc mono/mini/mini.h
Simple merge

diff --cc mono/mini/tramp-x86.c
Simple merge