mono/mini/mini-exceptions.c

   1 /*
   2  * mini-exceptions.c: generic exception support
   3  *
   4  * Authors:
   5  *   Dietmar Maurer (dietmar@ximian.com)
   6  *   Mono Team (mono-list@lists.ximian.com)
   7  *
   8  * Copyright 2001-2003 Ximian, Inc.
   9  * Copyright 2003-2008 Novell, Inc.
  10  * Copyright 2011 Xamarin Inc (http://www.xamarin.com).
  11  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  12  */
  13
  14 #include <config.h>
  15 #include <glib.h>
  16 #include <string.h>
  17
  18 #ifdef HAVE_SIGNAL_H
  19 #include <signal.h>
  20 #endif
  21
  22 #ifdef HAVE_EXECINFO_H
  23 #include <execinfo.h>
  24 #endif
  25
  26 #ifdef HAVE_SYS_TYPES_H
  27 #include <sys/types.h>
  28 #endif
  29
  30 #ifdef HAVE_SYS_WAIT_H
  31 #include <sys/wait.h>
  32 #endif
  33
  34 #ifdef HAVE_UNISTD_H
  35 #include <unistd.h>
  36 #endif
  37
  38 #ifdef HAVE_SYS_SYSCALL_H
  39 #include <sys/syscall.h>
  40 #endif
  41
  42 #ifdef HAVE_SYS_PRCTL_H
  43 #include <sys/prctl.h>
  44 #endif
  45
  46 #ifdef HAVE_UNWIND_H
  47 #include <unwind.h>
  48 #endif
  49
  50 #include <mono/metadata/appdomain.h>
  51 #include <mono/metadata/tabledefs.h>
  52 #include <mono/metadata/threads.h>
  53 #include <mono/metadata/threads-types.h>
  54 #include <mono/metadata/debug-helpers.h>
  55 #include <mono/metadata/exception.h>
  56 #include <mono/metadata/exception-internals.h>
  57 #include <mono/metadata/object-internals.h>
  58 #include <mono/metadata/reflection-internals.h>
  59 #include <mono/metadata/gc-internals.h>
  60 #include <mono/metadata/mono-debug.h>
  61 #include <mono/metadata/profiler.h>
  62 #include <mono/metadata/mono-endian.h>
  63 #include <mono/metadata/environment.h>
  64 #include <mono/metadata/mono-mlist.h>
  65 #include <mono/utils/mono-mmap.h>
  66 #include <mono/utils/mono-logger-internals.h>
  67 #include <mono/utils/mono-error.h>
  68 #include <mono/utils/mono-error-internals.h>
  69
  70 #include "mini.h"
  71 #include "trace.h"
  72 #include "debugger-agent.h"
  73 #include "seq-points.h"
  74 #include "llvm-runtime.h"
  75 #include "mini-llvm.h"
  76
  77 #ifdef ENABLE_LLVM
  78 #include "mini-llvm-cpp.h"
  79 #endif
  80
  81 #ifndef MONO_ARCH_CONTEXT_DEF
  82 #define MONO_ARCH_CONTEXT_DEF
  83 #endif
  84
  85 static gpointer restore_context_func, call_filter_func;
  86 static gpointer throw_exception_func, rethrow_exception_func;
  87 static gpointer throw_corlib_exception_func;
  88
  89 static gpointer try_more_restore_tramp = NULL;
  90 static gpointer restore_stack_protection_tramp = NULL;
  91
  92 static MonoUnhandledExceptionFunc unhandled_exception_hook = NULL;
  93 static gpointer unhandled_exception_hook_data = NULL;
  94
  95 static void try_more_restore (void);
  96 static void restore_stack_protection (void);
  97 static void mono_walk_stack_full (MonoJitStackWalk func, MonoContext *start_ctx, MonoDomain *domain, MonoJitTlsData *jit_tls, MonoLMF *lmf, MonoUnwindOptions unwind_options, gpointer user_data);
  98 static void mono_raise_exception_with_ctx (MonoException *exc, MonoContext *ctx);
  99 static void mono_runtime_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data);
 100
 101 void
 102 mono_exceptions_init (void)
 103 {
 104         MonoRuntimeExceptionHandlingCallbacks cbs;
 105         if (mono_aot_only) {
 106                 restore_context_func = mono_aot_get_trampoline ("restore_context");
 107                 call_filter_func = mono_aot_get_trampoline ("call_filter");
 108                 throw_exception_func = mono_aot_get_trampoline ("throw_exception");
 109                 rethrow_exception_func = mono_aot_get_trampoline ("rethrow_exception");
 110         } else {
 111                 MonoTrampInfo *info;
 112
 113                 restore_context_func = mono_arch_get_restore_context (&info, FALSE);
 114                 mono_tramp_info_register (info, NULL);
 115                 call_filter_func = mono_arch_get_call_filter (&info, FALSE);
 116                 mono_tramp_info_register (info, NULL);
 117                 throw_exception_func = mono_arch_get_throw_exception (&info, FALSE);
 118                 mono_tramp_info_register (info, NULL);
 119                 rethrow_exception_func = mono_arch_get_rethrow_exception (&info, FALSE);
 120                 mono_tramp_info_register (info, NULL);
 121         }
 122 #ifdef MONO_ARCH_HAVE_RESTORE_STACK_SUPPORT
 123         if (!mono_llvm_only) {
 124                 try_more_restore_tramp = mono_create_specific_trampoline (try_more_restore, MONO_TRAMPOLINE_RESTORE_STACK_PROT, mono_domain_get (), NULL);
 125                 restore_stack_protection_tramp = mono_create_specific_trampoline (restore_stack_protection, MONO_TRAMPOLINE_RESTORE_STACK_PROT, mono_domain_get (), NULL);
 126         }
 127 #endif
 128
 129 #ifdef MONO_ARCH_HAVE_EXCEPTIONS_INIT
 130         mono_arch_exceptions_init ();
 131 #endif
 132         cbs.mono_walk_stack_with_ctx = mono_runtime_walk_stack_with_ctx;
 133         cbs.mono_walk_stack_with_state = mono_walk_stack_with_state;
 134
 135         if (mono_llvm_only)
 136                 cbs.mono_raise_exception = mono_llvm_raise_exception;
 137         else
 138                 cbs.mono_raise_exception = (void (*)(MonoException *))mono_get_throw_exception ();
 139         cbs.mono_raise_exception_with_ctx = mono_raise_exception_with_ctx;
 140         cbs.mono_exception_walk_trace = mono_exception_walk_trace;
 141         cbs.mono_install_handler_block_guard = mono_install_handler_block_guard;
 142         mono_install_eh_callbacks (&cbs);
 143 }
 144
 145 gpointer
 146 mono_get_throw_exception (void)
 147 {
 148         g_assert (throw_exception_func);
 149         return throw_exception_func;
 150 }
 151
 152 gpointer
 153 mono_get_rethrow_exception (void)
 154 {
 155         g_assert (rethrow_exception_func);
 156         return rethrow_exception_func;
 157 }
 158
 159 gpointer
 160 mono_get_call_filter (void)
 161 {
 162         g_assert (call_filter_func);
 163         return call_filter_func;
 164 }
 165
 166 gpointer
 167 mono_get_restore_context (void)
 168 {
 169         g_assert (restore_context_func);
 170         return restore_context_func;
 171 }
 172
 173 gpointer
 174 mono_get_throw_corlib_exception (void)
 175 {
 176         gpointer code = NULL;
 177         MonoTrampInfo *info;
 178
 179         /* This depends on corlib classes so cannot be inited in mono_exceptions_init () */
 180         if (throw_corlib_exception_func)
 181                 return throw_corlib_exception_func;
 182
 183         if (mono_aot_only)
 184                 code = mono_aot_get_trampoline ("throw_corlib_exception");
 185         else {
 186                 code = mono_arch_get_throw_corlib_exception (&info, FALSE);
 187                 mono_tramp_info_register (info, NULL);
 188         }
 189
 190         mono_memory_barrier ();
 191
 192         throw_corlib_exception_func = code;
 193
 194         return throw_corlib_exception_func;
 195 }
 196
 197 /*
 198  * mono_get_throw_exception_addr:
 199  *
 200  *   Return an address which stores the result of
 201  * mono_get_throw_exception.
 202  */
 203 gpointer
 204 mono_get_throw_exception_addr (void)
 205 {
 206         return &throw_exception_func;
 207 }
 208
 209 static gboolean
 210 is_address_protected (MonoJitInfo *ji, MonoJitExceptionInfo *ei, gpointer ip)
 211 {
 212         MonoTryBlockHoleTableJitInfo *table;
 213         int i;
 214         guint32 offset;
 215         guint16 clause;
 216
 217         if (ei->try_start > ip || ip >= ei->try_end)
 218                 return FALSE;
 219
 220         if (!ji->has_try_block_holes)
 221                 return TRUE;
 222
 223         table = mono_jit_info_get_try_block_hole_table_info (ji);
 224         offset = (guint32)((char*)ip - (char*)ji->code_start);
 225         clause = (guint16)(ei - ji->clauses);
 226         g_assert (clause < ji->num_clauses);
 227
 228         for (i = 0; i < table->num_holes; ++i) {
 229                 MonoTryBlockHoleJitInfo *hole = &table->holes [i];
 230                 if (hole->clause == clause && hole->offset <= offset && hole->offset + hole->length > offset)
 231                         return FALSE;
 232         }
 233         return TRUE;
 234 }
 235
 236 #ifdef MONO_ARCH_HAVE_UNWIND_BACKTRACE
 237
 238 #if 0
 239 static gboolean show_native_addresses = TRUE;
 240 #else
 241 static gboolean show_native_addresses = FALSE;
 242 #endif
 243
 244 static _Unwind_Reason_Code
 245 build_stack_trace (struct _Unwind_Context *frame_ctx, void *state)
 246 {
 247         MonoDomain *domain = mono_domain_get ();
 248         uintptr_t ip = _Unwind_GetIP (frame_ctx);
 249
 250         if (show_native_addresses || mono_jit_info_table_find (domain, (char*)ip)) {
 251                 GList **trace_ips = (GList **)state;
 252                 *trace_ips = g_list_prepend (*trace_ips, (gpointer)ip);
 253         }
 254
 255         return _URC_NO_REASON;
 256 }
 257
 258 static GSList*
 259 get_unwind_backtrace (void)
 260 {
 261         GSList *ips = NULL;
 262
 263         _Unwind_Backtrace (build_stack_trace, &ips);
 264
 265         return g_slist_reverse (ips);
 266 }
 267
 268 #else
 269
 270 static GSList*
 271 get_unwind_backtrace (void)
 272 {
 273         return NULL;
 274 }
 275
 276 #endif
 277
 278 /*
 279  * find_jit_info:
 280  *
 281  * Translate between the mono_arch_unwind_frame function and the old API.
 282  */
 283 static MonoJitInfo *
 284 find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
 285                            MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
 286 {
 287         StackFrameInfo frame;
 288         MonoJitInfo *ji;
 289         gboolean err;
 290         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 291
 292         /* Avoid costly table lookup during stack overflow */
 293         if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
 294                 ji = prev_ji;
 295         else
 296                 ji = mini_jit_info_table_find (domain, (char *)ip, NULL);
 297
 298         if (managed)
 299                 *managed = FALSE;
 300
 301         err = mono_arch_unwind_frame (domain, jit_tls, ji, ctx, new_ctx, lmf, NULL, &frame);
 302         if (!err)
 303                 return (MonoJitInfo *)-1;
 304
 305         if (*lmf && ((*lmf) != jit_tls->first_lmf) && ((gpointer)MONO_CONTEXT_GET_SP (new_ctx) >= (gpointer)(*lmf))) {
 306                 /*
 307                  * Remove any unused lmf.
 308                  * Mask out the lower bits which might be used to hold additional information.
 309                  */
 310                 *lmf = (MonoLMF *)(((gsize)(*lmf)->previous_lmf) & ~(SIZEOF_VOID_P -1));
 311         }
 312
 313         /* Convert between the new and the old APIs */
 314         switch (frame.type) {
 315         case FRAME_TYPE_MANAGED:
 316                 if (managed)
 317                         *managed = TRUE;
 318                 return frame.ji;
 319         case FRAME_TYPE_TRAMPOLINE:
 320                 return frame.ji;
 321         case FRAME_TYPE_MANAGED_TO_NATIVE:
 322                 if (frame.ji)
 323                         return frame.ji;
 324                 else {
 325                         memset (res, 0, sizeof (MonoJitInfo));
 326                         res->d.method = frame.method;
 327                         return res;
 328                 }
 329         case FRAME_TYPE_DEBUGGER_INVOKE: {
 330                 MonoContext tmp_ctx;
 331
 332                 /*
 333                  * The normal exception handling code can't handle this frame, so just
 334                  * skip it.
 335                  */
 336                 ji = find_jit_info (domain, jit_tls, res, NULL, new_ctx, &tmp_ctx, lmf, managed);
 337                 memcpy (new_ctx, &tmp_ctx, sizeof (MonoContext));
 338                 return ji;
 339         }
 340         default:
 341                 g_assert_not_reached ();
 342                 return NULL;
 343         }
 344 }
 345
 346 /* mono_find_jit_info:
 347  *
 348  * This function is used to gather information from @ctx. It return the
 349  * MonoJitInfo of the corresponding function, unwinds one stack frame and
 350  * stores the resulting context into @new_ctx. It also stores a string
 351  * describing the stack location into @trace (if not NULL), and modifies
 352  * the @lmf if necessary. @native_offset return the IP offset from the
 353  * start of the function or -1 if that info is not available.
 354  */
 355 MonoJitInfo *
 356 mono_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
 357                     MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset,
 358                     gboolean *managed)
 359 {
 360         gboolean managed2;
 361         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 362         MonoJitInfo *ji;
 363         MonoMethod *method = NULL;
 364
 365         if (trace)
 366                 *trace = NULL;
 367
 368         if (native_offset)
 369                 *native_offset = -1;
 370
 371         if (managed)
 372                 *managed = FALSE;
 373
 374         ji = find_jit_info (domain, jit_tls, res, prev_ji, ctx, new_ctx, lmf, &managed2);
 375
 376         if (ji == (gpointer)-1)
 377                 return ji;
 378
 379         if (ji && !ji->is_trampoline)
 380                 method = jinfo_get_method (ji);
 381
 382         if (managed2 || (method && method->wrapper_type)) {
 383                 const char *real_ip, *start;
 384                 gint32 offset;
 385
 386                 start = (const char *)ji->code_start;
 387                 if (!managed2)
 388                         /* ctx->ip points into native code */
 389                         real_ip = (const char*)MONO_CONTEXT_GET_IP (new_ctx);
 390                 else
 391                         real_ip = (const char*)ip;
 392
 393                 if ((real_ip >= start) && (real_ip <= start + ji->code_size))
 394                         offset = real_ip - start;
 395                 else
 396                         offset = -1;
 397
 398                 if (native_offset)
 399                         *native_offset = offset;
 400
 401                 if (managed)
 402                         if (!method->wrapper_type || method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
 403                                 *managed = TRUE;
 404
 405                 if (trace)
 406                         *trace = mono_debug_print_stack_frame (method, offset, domain);
 407         } else {
 408                 if (trace) {
 409                         char *fname = mono_method_full_name (jinfo_get_method (res), TRUE);
 410                         *trace = g_strdup_printf ("in (unmanaged) %s", fname);
 411                         g_free (fname);
 412                 }
 413         }
 414
 415         return ji;
 416 }
 417
 418 /*
 419  * mono_find_jit_info_ext:
 420  *
 421  *   A version of mono_find_jit_info which returns all data in the StackFrameInfo
 422  * structure.
 423  * A note about frames of type FRAME_TYPE_MANAGED_TO_NATIVE:
 424  * - These frames are used to mark managed-to-native transitions, so CTX will refer to native
 425  * code, and new_ctx will refer to the last managed frame. The caller should unwind once more
 426  * to obtain the last managed frame.
 427  * If SAVE_LOCATIONS is not NULL, it should point to an array of size MONO_MAX_IREGS.
 428  * On return, it will be filled with the locations where callee saved registers are saved
 429  * by the current frame. This is returned outside of StackFrameInfo because it can be
 430  * quite large on some platforms.
 431  * If ASYNC true, this function will be async safe, but some fields of frame and frame->ji will
 432  * not be set.
 433  */
 434 gboolean
 435 mono_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls,
 436                                                 MonoJitInfo *prev_ji, MonoContext *ctx,
 437                                                 MonoContext *new_ctx, char **trace, MonoLMF **lmf,
 438                                                 mgreg_t **save_locations,
 439                                                 StackFrameInfo *frame)
 440 {
 441         gboolean err;
 442         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 443         MonoJitInfo *ji;
 444         MonoDomain *target_domain = domain;
 445         MonoMethod *method = NULL;
 446         gboolean async = mono_thread_info_is_async_context ();
 447
 448         if (trace)
 449                 *trace = NULL;
 450
 451         /* Avoid costly table lookup during stack overflow */
 452         if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
 453                 ji = prev_ji;
 454         else
 455                 ji = mini_jit_info_table_find (domain, (char *)ip, &target_domain);
 456
 457         if (!target_domain)
 458                 target_domain = domain;
 459
 460         if (save_locations)
 461                 memset (save_locations, 0, MONO_MAX_IREGS * sizeof (mgreg_t*));
 462
 463         err = mono_arch_unwind_frame (target_domain, jit_tls, ji, ctx, new_ctx, lmf, save_locations, frame);
 464         if (!err)
 465                 return FALSE;
 466
 467         if (*lmf && ((*lmf) != jit_tls->first_lmf) && ((gpointer)MONO_CONTEXT_GET_SP (new_ctx) >= (gpointer)(*lmf))) {
 468                 /*
 469                  * Remove any unused lmf.
 470                  * Mask out the lower bits which might be used to hold additional information.
 471                  */
 472                 *lmf = (MonoLMF *)(((gsize)(*lmf)->previous_lmf) & ~(SIZEOF_VOID_P -1));
 473         }
 474
 475         if (frame->ji && !frame->ji->is_trampoline && !frame->ji->async)
 476                 method = jinfo_get_method (frame->ji);
 477
 478         if (frame->type == FRAME_TYPE_MANAGED && method) {
 479                 if (!method->wrapper_type || method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
 480                         frame->managed = TRUE;
 481         }
 482
 483         if (frame->type == FRAME_TYPE_MANAGED_TO_NATIVE) {
 484                 /*
 485                  * This type of frame is just a marker, the caller should unwind once more to get the
 486                  * last managed frame.
 487                  */
 488                 frame->ji = NULL;
 489                 frame->method = NULL;
 490         }
 491
 492         frame->native_offset = -1;
 493         frame->domain = target_domain;
 494         frame->async_context = async;
 495
 496         ji = frame->ji;
 497
 498         if (frame->type == FRAME_TYPE_MANAGED)
 499                 frame->method = method;
 500
 501         if (ji && (frame->managed || (method && method->wrapper_type))) {
 502                 const char *real_ip, *start;
 503
 504                 start = (const char *)ji->code_start;
 505                 if (frame->type == FRAME_TYPE_MANAGED)
 506                         real_ip = (const char*)ip;
 507                 else
 508                         /* ctx->ip points into native code */
 509                         real_ip = (const char*)MONO_CONTEXT_GET_IP (new_ctx);
 510
 511                 if ((real_ip >= start) && (real_ip <= start + ji->code_size))
 512                         frame->native_offset = real_ip - start;
 513                 else {
 514                         frame->native_offset = -1;
 515                 }
 516
 517                 if (trace)
 518                         *trace = mono_debug_print_stack_frame (method, frame->native_offset, domain);
 519         } else {
 520                 if (trace && frame->method) {
 521                         char *fname = mono_method_full_name (frame->method, TRUE);
 522                         *trace = g_strdup_printf ("in (unmanaged) %s", fname);
 523                         g_free (fname);
 524                 }
 525         }
 526
 527         return TRUE;
 528 }
 529
 530 /*
 531  * This function is async-safe.
 532  */
 533 static gpointer
 534 get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx)
 535 {
 536         MonoGenericJitInfo *gi;
 537         MonoMethod *method;
 538         gpointer info;
 539
 540         if (!ji->has_generic_jit_info)
 541                 return NULL;
 542         gi = mono_jit_info_get_generic_jit_info (ji);
 543         if (!gi->has_this)
 544                 return NULL;
 545
 546         info = NULL;
 547         /*
 548          * Search location list if available, it contains the precise location of the
 549          * argument for every pc offset, even if the method was interrupted while it was in
 550          * its prolog.
 551          */
 552         if (gi->nlocs) {
 553                 int offset = (mgreg_t)MONO_CONTEXT_GET_IP (ctx) - (mgreg_t)ji->code_start;
 554                 int i;
 555
 556                 for (i = 0; i < gi->nlocs; ++i) {
 557                         MonoDwarfLocListEntry *entry = &gi->locations [i];
 558
 559                         if (offset >= entry->from && (offset < entry->to || entry->to == 0)) {
 560                                 if (entry->is_reg)
 561                                         info = (gpointer)mono_arch_context_get_int_reg (ctx, entry->reg);
 562                                 else
 563                                         info = *(gpointer*)(gpointer)((char*)mono_arch_context_get_int_reg (ctx, entry->reg) + entry->offset);
 564                                 break;
 565                         }
 566                 }
 567                 g_assert (i < gi->nlocs);
 568         } else {
 569                 if (gi->this_in_reg)
 570                         info = (gpointer)mono_arch_context_get_int_reg (ctx, gi->this_reg);
 571                 else
 572                         info = *(gpointer*)(gpointer)((char*)mono_arch_context_get_int_reg (ctx, gi->this_reg) +
 573                                                                                   gi->this_offset);
 574         }
 575
 576         method = jinfo_get_method (ji);
 577         if (mono_method_get_context (method)->method_inst) {
 578                 /* A MonoMethodRuntimeGenericContext* */
 579                 return info;
 580         } else if ((method->flags & METHOD_ATTRIBUTE_STATIC) || method->klass->valuetype) {
 581                 /* A MonoVTable* */
 582                 return info;
 583         } else {
 584                 /* Avoid returning a managed object */
 585                 MonoObject *this_obj = (MonoObject *)info;
 586
 587                 return this_obj->vtable;
 588         }
 589 }
 590
 591 /*
 592  * generic_info is either a MonoMethodRuntimeGenericContext or a MonoVTable.
 593  */
 594 static MonoGenericContext
 595 get_generic_context_from_stack_frame (MonoJitInfo *ji, gpointer generic_info)
 596 {
 597         MonoGenericContext context = { NULL, NULL };
 598         MonoClass *klass, *method_container_class;
 599         MonoMethod *method;
 600
 601         g_assert (generic_info);
 602
 603         method = jinfo_get_method (ji);
 604         g_assert (method->is_inflated);
 605         if (mono_method_get_context (method)->method_inst) {
 606                 MonoMethodRuntimeGenericContext *mrgctx = (MonoMethodRuntimeGenericContext *)generic_info;
 607
 608                 klass = mrgctx->class_vtable->klass;
 609                 context.method_inst = mrgctx->method_inst;
 610                 g_assert (context.method_inst);
 611         } else {
 612                 MonoVTable *vtable = (MonoVTable *)generic_info;
 613
 614                 klass = vtable->klass;
 615         }
 616
 617         //g_assert (!method->klass->generic_container);
 618         if (method->klass->generic_class)
 619                 method_container_class = method->klass->generic_class->container_class;
 620         else
 621                 method_container_class = method->klass;
 622
 623         /* class might refer to a subclass of method's class */
 624         while (!(klass == method->klass || (klass->generic_class && klass->generic_class->container_class == method_container_class))) {
 625                 klass = klass->parent;
 626                 g_assert (klass);
 627         }
 628
 629         if (klass->generic_class || klass->generic_container)
 630                 context.class_inst = mini_class_get_context (klass)->class_inst;
 631
 632         if (klass->generic_class)
 633                 g_assert (mono_class_has_parent_and_ignore_generics (klass->generic_class->container_class, method_container_class));
 634         else
 635                 g_assert (mono_class_has_parent_and_ignore_generics (klass, method_container_class));
 636
 637         return context;
 638 }
 639
 640 static MonoMethod*
 641 get_method_from_stack_frame (MonoJitInfo *ji, gpointer generic_info)
 642 {
 643         MonoError error;
 644         MonoGenericContext context;
 645         MonoMethod *method;
 646
 647         if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
 648                 return jinfo_get_method (ji);
 649         context = get_generic_context_from_stack_frame (ji, generic_info);
 650
 651         method = jinfo_get_method (ji);
 652         method = mono_method_get_declaring_generic_method (method);
 653         method = mono_class_inflate_generic_method_checked (method, &context, &error);
 654         g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
 655
 656         return method;
 657 }
 658
 659 /**
 660  * mono_exception_walk_native_trace:
 661  * @ex: The exception object whose frames should be walked
 662  * @func: callback to call for each stack frame
 663  * @user_data: data passed to the callback
 664  *
 665  * This function walks the stacktrace of an exception. For
 666  * each frame the callback function is called with the relevant info.
 667  * The walk ends when no more stack frames are found or when the callback
 668  * returns a TRUE value.
 669  */
 670
 671 gboolean
 672 mono_exception_walk_trace (MonoException *ex, MonoExceptionFrameWalk func, gpointer user_data)
 673 {
 674         MonoDomain *domain = mono_domain_get ();
 675         MonoArray *ta = ex->trace_ips;
 676         int len, i;
 677
 678         if (ta == NULL)
 679                 return FALSE;
 680
 681         len = mono_array_length (ta) >> 1;
 682         for (i = 0; i < len; i++) {
 683                 gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
 684                 gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
 685                 MonoJitInfo *ji = mono_jit_info_table_find (domain, (char *)ip);
 686
 687                 if (ji == NULL) {
 688                         if (func (NULL, ip, 0, FALSE, user_data))
 689                                 return TRUE;
 690                 } else {
 691                         MonoMethod *method = get_method_from_stack_frame (ji, generic_info);
 692                         if (func (method, ji->code_start, (char *) ip - (char *) ji->code_start, TRUE, user_data))
 693                                 return TRUE;
 694                 }
 695         }
 696
 697         return len > 0;
 698 }
 699
 700 MonoArray *
 701 ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
 702 {
 703         MonoError error;
 704         MonoDomain *domain = mono_domain_get ();
 705         MonoArray *res;
 706         MonoArray *ta = exc->trace_ips;
 707         MonoDebugSourceLocation *location;
 708         int i, len;
 709
 710         if (ta == NULL) {
 711                 /* Exception is not thrown yet */
 712                 res = mono_array_new_checked (domain, mono_defaults.stack_frame_class, 0, &error);
 713                 mono_error_set_pending_exception (&error);
 714                 return res;
 715         }
 716
 717         len = mono_array_length (ta) >> 1;
 718
 719         res = mono_array_new_checked (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0, &error);
 720         if (mono_error_set_pending_exception (&error))
 721                 return NULL;
 722
 723         for (i = skip; i < len; i++) {
 724                 MonoJitInfo *ji;
 725                 MonoStackFrame *sf = (MonoStackFrame *)mono_object_new_checked (domain, mono_defaults.stack_frame_class, &error);
 726                 if (!mono_error_ok (&error)) {
 727                         mono_error_set_pending_exception (&error);
 728                         return NULL;
 729                 }
 730                 gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
 731                 gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
 732                 MonoMethod *method;
 733
 734                 ji = mono_jit_info_table_find (domain, (char *)ip);
 735                 if (ji == NULL) {
 736                         /* Unmanaged frame */
 737                         mono_array_setref (res, i, sf);
 738                         continue;
 739                 }
 740
 741                 g_assert (ji != NULL);
 742
 743                 if (mono_llvm_only)
 744                         /* Can't resolve actual method */
 745                         method = jinfo_get_method (ji);
 746                 else
 747                         method = get_method_from_stack_frame (ji, generic_info);
 748                 if (jinfo_get_method (ji)->wrapper_type) {
 749                         char *s;
 750
 751                         sf->method = NULL;
 752                         s = mono_method_get_name_full (method, TRUE, FALSE, MONO_TYPE_NAME_FORMAT_REFLECTION);
 753                         MONO_OBJECT_SETREF (sf, internal_method_name, mono_string_new (domain, s));
 754                         g_free (s);
 755                 }
 756                 else {
 757                         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, NULL, &error);
 758                         if (!mono_error_ok (&error)) {
 759                                 mono_error_set_pending_exception (&error);
 760                                 return NULL;
 761                         }
 762                         MONO_OBJECT_SETREF (sf, method, rm);
 763                 }
 764
 765                 sf->method_index = ji->from_aot ? mono_aot_find_method_index (method) : 0xffffff;
 766                 sf->method_address = (gsize) ji->code_start;
 767                 sf->native_offset = (char *)ip - (char *)ji->code_start;
 768
 769                 /*
 770                  * mono_debug_lookup_source_location() returns both the file / line number information
 771                  * and the IL offset.  Note that computing the IL offset is already an expensive
 772                  * operation, so we shouldn't call this method twice.
 773                  */
 774                 location = mono_debug_lookup_source_location (jinfo_get_method (ji), sf->native_offset, domain);
 775                 if (location) {
 776                         sf->il_offset = location->il_offset;
 777                 } else {
 778                         SeqPoint sp;
 779                         if (mono_find_prev_seq_point_for_native_offset (domain, jinfo_get_method (ji), sf->native_offset, NULL, &sp))
 780                                 sf->il_offset = sp.il_offset;
 781                         else
 782                                 sf->il_offset = -1;
 783                 }
 784
 785                 if (need_file_info) {
 786                         if (location && location->source_file) {
 787                                 MONO_OBJECT_SETREF (sf, filename, mono_string_new (domain, location->source_file));
 788                                 sf->line = location->row;
 789                                 sf->column = location->column;
 790                         } else {
 791                                 sf->line = sf->column = 0;
 792                                 sf->filename = NULL;
 793                         }
 794                 }
 795
 796                 mono_debug_free_source_location (location);
 797                 mono_array_setref (res, i, sf);
 798         }
 799
 800         return res;
 801 }
 802
 803 static void
 804 mono_runtime_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data)
 805 {
 806         if (!start_ctx) {
 807                 MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
 808                 if (jit_tls && jit_tls->orig_ex_ctx_set)
 809                         start_ctx = &jit_tls->orig_ex_ctx;
 810         }
 811         mono_walk_stack_with_ctx (func, start_ctx, unwind_options, user_data);
 812 }
 813 /**
 814  * mono_walk_stack_with_ctx:
 815  *
 816  * Unwind the current thread starting at @start_ctx.
 817  *
 818  * If @start_ctx is null, we capture the current context.
 819  */
 820 void
 821 mono_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data)
 822 {
 823         MonoContext extra_ctx;
 824         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
 825         MONO_ARCH_CONTEXT_DEF
 826
 827         if (!thread || !thread->jit_data)
 828                 return;
 829
 830         if (!start_ctx) {
 831                 mono_arch_flush_register_windows ();
 832
 833 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
 834                 MONO_INIT_CONTEXT_FROM_CURRENT (&extra_ctx);
 835 #else
 836                 MONO_INIT_CONTEXT_FROM_FUNC (&extra_ctx, mono_walk_stack_with_ctx);
 837 #endif
 838                 start_ctx = &extra_ctx;
 839         }
 840
 841         mono_walk_stack_full (func, start_ctx, mono_domain_get (), (MonoJitTlsData *)thread->jit_data, mono_get_lmf (), unwind_options, user_data);
 842 }
 843
 844 /**
 845  * mono_walk_stack_with_state:
 846  *
 847  * Unwind a thread described by @state.
 848  *
 849  * State must be valid (state->valid == TRUE).
 850  *
 851  * If you are using this function to unwind another thread, make sure it is suspended.
 852  *
 853  * If @state is null, we capture the current context.
 854  */
 855 void
 856 mono_walk_stack_with_state (MonoJitStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions unwind_options, void *user_data)
 857 {
 858         MonoThreadUnwindState extra_state;
 859         if (!state) {
 860                 g_assert (!mono_thread_info_is_async_context ());
 861                 if (!mono_thread_state_init_from_current (&extra_state))
 862                         return;
 863                 state = &extra_state;
 864         }
 865
 866         g_assert (state->valid);
 867
 868         if (!state->unwind_data [MONO_UNWIND_DATA_DOMAIN])
 869                 /* Not attached */
 870                 return;
 871
 872         mono_walk_stack_full (func,
 873                 &state->ctx,
 874                 (MonoDomain *)state->unwind_data [MONO_UNWIND_DATA_DOMAIN],
 875                 (MonoJitTlsData *)state->unwind_data [MONO_UNWIND_DATA_JIT_TLS],
 876                 (MonoLMF *)state->unwind_data [MONO_UNWIND_DATA_LMF],
 877                 unwind_options, user_data);
 878 }
 879
 880 void
 881 mono_walk_stack (MonoJitStackWalk func, MonoUnwindOptions options, void *user_data)
 882 {
 883         MonoThreadUnwindState state;
 884         if (!mono_thread_state_init_from_current (&state))
 885                 return;
 886         mono_walk_stack_with_state (func, &state, options, user_data);
 887 }
 888
 889 /**
 890  * mono_walk_stack_full:
 891  * @func: callback to call for each stack frame
 892  * @domain: starting appdomain, can be NULL to use the current domain
 893  * @unwind_options: what extra information the unwinder should gather
 894  * @start_ctx: starting state of the stack walk, can be NULL.
 895  * @thread: the thread whose stack to walk, can be NULL to use the current thread
 896  * @lmf: the LMF of @thread, can be NULL to use the LMF of the current thread
 897  * @user_data: data passed to the callback
 898  *
 899  * This function walks the stack of a thread, starting from the state
 900  * represented by start_ctx. For each frame the callback
 901  * function is called with the relevant info. The walk ends when no more
 902  * managed stack frames are found or when the callback returns a TRUE value.
 903  */
 904 static void
 905 mono_walk_stack_full (MonoJitStackWalk func, MonoContext *start_ctx, MonoDomain *domain, MonoJitTlsData *jit_tls, MonoLMF *lmf, MonoUnwindOptions unwind_options, gpointer user_data)
 906 {
 907         gint il_offset, i;
 908         MonoContext ctx, new_ctx;
 909         StackFrameInfo frame;
 910         gboolean res;
 911         mgreg_t *reg_locations [MONO_MAX_IREGS];
 912         mgreg_t *new_reg_locations [MONO_MAX_IREGS];
 913         gboolean get_reg_locations = unwind_options & MONO_UNWIND_REG_LOCATIONS;
 914         gboolean async = mono_thread_info_is_async_context ();
 915
 916         if (mono_llvm_only) {
 917                 GSList *l, *ips;
 918
 919                 if (async)
 920                         return;
 921
 922                 ips = get_unwind_backtrace ();
 923                 for (l = ips; l; l = l->next) {
 924                         guint8 *ip = (guint8*)l->data;
 925                         memset (&frame, 0, sizeof (StackFrameInfo));
 926                         frame.ji = mini_jit_info_table_find (domain, (char*)ip, &frame.domain);
 927                         if (!frame.ji || frame.ji->is_trampoline)
 928                                 continue;
 929                         frame.type = FRAME_TYPE_MANAGED;
 930                         frame.method = jinfo_get_method (frame.ji);
 931                         // FIXME: Cannot lookup the actual method
 932                         frame.actual_method = frame.method;
 933                         if (frame.type == FRAME_TYPE_MANAGED) {
 934                                 if (!frame.method->wrapper_type || frame.method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
 935                                         frame.managed = TRUE;
 936                         }
 937                         frame.native_offset = ip - (guint8*)frame.ji->code_start;
 938                         frame.il_offset = -1;
 939
 940                         if (func (&frame, NULL, user_data))
 941                                 break;
 942                 }
 943                 g_free (ips);
 944                 return;
 945         }
 946
 947         g_assert (start_ctx);
 948         g_assert (domain);
 949         g_assert (jit_tls);
 950         /*The LMF will be null if the target have no managed frames.*/
 951         /* g_assert (lmf); */
 952
 953         if (async)
 954                 g_assert (unwind_options == MONO_UNWIND_NONE);
 955
 956         memcpy (&ctx, start_ctx, sizeof (MonoContext));
 957         memset (reg_locations, 0, sizeof (reg_locations));
 958
 959         while (MONO_CONTEXT_GET_SP (&ctx) < jit_tls->end_of_stack) {
 960                 frame.lmf = lmf;
 961                 res = mono_find_jit_info_ext (domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, get_reg_locations ? new_reg_locations : NULL, &frame);
 962                 if (!res)
 963                         return;
 964
 965                 if ((unwind_options & MONO_UNWIND_LOOKUP_IL_OFFSET) && frame.ji && !frame.ji->is_trampoline) {
 966                         MonoDebugSourceLocation *source;
 967
 968                         source = mono_debug_lookup_source_location (jinfo_get_method (frame.ji), frame.native_offset, domain);
 969                         if (source) {
 970                                 il_offset = source->il_offset;
 971                         } else {
 972                                 SeqPoint sp;
 973                                 if (mono_find_prev_seq_point_for_native_offset (domain, jinfo_get_method (frame.ji), frame.native_offset, NULL, &sp))
 974                                         il_offset = sp.il_offset;
 975                                 else
 976                                         il_offset = -1;
 977                         }
 978                         mono_debug_free_source_location (source);
 979                 } else
 980                         il_offset = -1;
 981
 982                 frame.il_offset = il_offset;
 983
 984                 if ((unwind_options & MONO_UNWIND_LOOKUP_ACTUAL_METHOD) && frame.ji && !frame.ji->is_trampoline) {
 985                         frame.actual_method = get_method_from_stack_frame (frame.ji, get_generic_info_from_stack_frame (frame.ji, &ctx));
 986                 } else {
 987                         frame.actual_method = frame.method;
 988                 }
 989
 990                 if (get_reg_locations)
 991                         frame.reg_locations = reg_locations;
 992
 993                 if (func (&frame, &ctx, user_data))
 994                         return;
 995
 996                 if (get_reg_locations) {
 997                         for (i = 0; i < MONO_MAX_IREGS; ++i)
 998                                 if (new_reg_locations [i])
 999                                         reg_locations [i] = new_reg_locations [i];
1000                 }
1001
1002                 ctx = new_ctx;
1003         }
1004 }
1005
1006 MonoBoolean
1007 ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
1008                           MonoReflectionMethod **method,
1009                           gint32 *iloffset, gint32 *native_offset,
1010                           MonoString **file, gint32 *line, gint32 *column)
1011 {
1012         MonoError error;
1013         MonoDomain *domain = mono_domain_get ();
1014         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
1015         MonoLMF *lmf = mono_get_lmf ();
1016         MonoJitInfo *ji = NULL;
1017         MonoContext ctx, new_ctx;
1018         MonoDebugSourceLocation *location;
1019         MonoMethod *jmethod = NULL, *actual_method;
1020         StackFrameInfo frame;
1021         gboolean res;
1022
1023         MONO_ARCH_CONTEXT_DEF;
1024
1025         if (mono_llvm_only) {
1026                 GSList *l, *ips;
1027                 MonoDomain *frame_domain;
1028                 guint8 *frame_ip = NULL;
1029
1030                 /* FIXME: Generalize this code with an interface which returns an array of StackFrame structures */
1031                 jmethod = NULL;
1032                 ips = get_unwind_backtrace ();
1033                 for (l = ips; l && skip >= 0; l = l->next) {
1034                         guint8 *ip = (guint8*)l->data;
1035
1036                         frame_ip = ip;
1037
1038                         ji = mini_jit_info_table_find (mono_domain_get (), (char*)ip, &frame_domain);
1039                         if (!ji || ji->is_trampoline)
1040                                 continue;
1041
1042                         /* The skip count passed by the caller depends on us not filtering out MANAGED_TO_NATIVE */
1043                         jmethod = jinfo_get_method (ji);
1044                         if (jmethod->wrapper_type != MONO_WRAPPER_NONE && jmethod->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD && jmethod->wrapper_type != MONO_WRAPPER_MANAGED_TO_NATIVE)
1045                                 continue;
1046                         skip--;
1047                 }
1048                 g_slist_free (ips);
1049                 if (!jmethod || !l)
1050                         return FALSE;
1051                 /* No way to resolve generic instances */
1052                 actual_method = jmethod;
1053                 *native_offset = frame_ip - (guint8*)ji->code_start;
1054         } else {
1055                 mono_arch_flush_register_windows ();
1056
1057 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
1058                 MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
1059 #else
1060                 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, ves_icall_get_frame_info);
1061 #endif
1062
1063                 new_ctx = ctx;
1064                 do {
1065                         ctx = new_ctx;
1066                         res = mono_find_jit_info_ext (domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, &frame);
1067                         if (!res)
1068                                 return FALSE;
1069
1070                         if (frame.type == FRAME_TYPE_MANAGED_TO_NATIVE ||
1071                                 frame.type == FRAME_TYPE_DEBUGGER_INVOKE ||
1072                                 frame.type == FRAME_TYPE_TRAMPOLINE)
1073                                 continue;
1074
1075                         ji = frame.ji;
1076                         *native_offset = frame.native_offset;
1077
1078                         /* The skip count passed by the caller depends on us not filtering out MANAGED_TO_NATIVE */
1079                         jmethod = jinfo_get_method (ji);
1080                         if (jmethod->wrapper_type != MONO_WRAPPER_NONE && jmethod->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD && jmethod->wrapper_type != MONO_WRAPPER_MANAGED_TO_NATIVE)
1081                                 continue;
1082                         skip--;
1083                 } while (skip >= 0);
1084
1085                 actual_method = get_method_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, &ctx));
1086         }
1087
1088         MonoReflectionMethod *rm = mono_method_get_object_checked (domain, actual_method, NULL, &error);
1089         if (!mono_error_ok (&error)) {
1090                 mono_error_set_pending_exception (&error);
1091                 return FALSE;
1092         }
1093         mono_gc_wbarrier_generic_store (method, (MonoObject*) rm);
1094
1095         location = mono_debug_lookup_source_location (jmethod, *native_offset, domain);
1096         if (location)
1097                 *iloffset = location->il_offset;
1098         else
1099                 *iloffset = 0;
1100
1101         if (need_file_info) {
1102                 if (location) {
1103                         mono_gc_wbarrier_generic_store (file, (MonoObject*) mono_string_new (domain, location->source_file));
1104                         *line = location->row;
1105                         *column = location->column;
1106                 } else {
1107                         *file = NULL;
1108                         *line = *column = 0;
1109                 }
1110         }
1111
1112         mono_debug_free_source_location (location);
1113
1114         return TRUE;
1115 }
1116
1117 static MonoClass*
1118 get_exception_catch_class (MonoJitExceptionInfo *ei, MonoJitInfo *ji, MonoContext *ctx)
1119 {
1120         MonoError error;
1121         MonoClass *catch_class = ei->data.catch_class;
1122         MonoType *inflated_type;
1123         MonoGenericContext context;
1124
1125         /*MonoJitExceptionInfo::data is an union used by filter and finally clauses too.*/
1126         if (!catch_class || ei->flags != MONO_EXCEPTION_CLAUSE_NONE)
1127                 return NULL;
1128
1129         if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
1130                 return catch_class;
1131         context = get_generic_context_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, ctx));
1132
1133         /* FIXME: we shouldn't inflate but instead put the
1134            type in the rgctx and fetch it from there.  It
1135            might be a good idea to do this lazily, i.e. only
1136            when the exception is actually thrown, so as not to
1137            waste space for exception clauses which might never
1138            be encountered. */
1139         inflated_type = mono_class_inflate_generic_type_checked (&catch_class->byval_arg, &context, &error);
1140         mono_error_assert_ok (&error); /* FIXME don't swallow the error */
1141
1142         catch_class = mono_class_from_mono_type (inflated_type);
1143         mono_metadata_free_type (inflated_type);
1144
1145         return catch_class;
1146 }
1147
1148 /*
1149  * mini_jit_info_table_find_ext:
1150  *
1151  *   Same as mono_jit_info_table_find, but search all the domains of the current thread
1152  * if ADDR is not found in DOMAIN. The domain where the method was found is stored into
1153  * OUT_DOMAIN if it is not NULL.
1154  */
1155 MonoJitInfo*
1156 mini_jit_info_table_find_ext (MonoDomain *domain, char *addr, gboolean allow_trampolines, MonoDomain **out_domain)
1157 {
1158         MonoJitInfo *ji;
1159         MonoInternalThread *t = mono_thread_internal_current ();
1160         gpointer *refs;
1161
1162         if (out_domain)
1163                 *out_domain = NULL;
1164
1165         ji = mono_jit_info_table_find_internal (domain, addr, TRUE, allow_trampolines);
1166         if (ji) {
1167                 if (out_domain)
1168                         *out_domain = domain;
1169                 return ji;
1170         }
1171
1172         /* maybe it is shared code, so we also search in the root domain */
1173         if (domain != mono_get_root_domain ()) {
1174                 ji = mono_jit_info_table_find_internal (mono_get_root_domain (), addr, TRUE, allow_trampolines);
1175                 if (ji) {
1176                         if (out_domain)
1177                                 *out_domain = mono_get_root_domain ();
1178                         return ji;
1179                 }
1180         }
1181
1182         if (!t)
1183                 return NULL;
1184
1185         refs = (gpointer *)((t->appdomain_refs) ? *(gpointer *) t->appdomain_refs : NULL);
1186         for (; refs && *refs; refs++) {
1187                 if (*refs != domain && *refs != mono_get_root_domain ()) {
1188                         ji = mono_jit_info_table_find_internal ((MonoDomain*) *refs, addr, TRUE, allow_trampolines);
1189                         if (ji) {
1190                                 if (out_domain)
1191                                         *out_domain = (MonoDomain*) *refs;
1192                                 return ji;
1193                         }
1194                 }
1195         }
1196
1197         return NULL;
1198 }
1199
1200 MonoJitInfo*
1201 mini_jit_info_table_find (MonoDomain *domain, char *addr, MonoDomain **out_domain)
1202 {
1203         return mini_jit_info_table_find_ext (domain, addr, FALSE, out_domain);
1204 }
1205
1206 /* Class lazy loading functions */
1207 static GENERATE_GET_CLASS_WITH_CACHE (runtime_compat_attr, System.Runtime.CompilerServices, RuntimeCompatibilityAttribute)
1208
1209 /*
1210  * wrap_non_exception_throws:
1211  *
1212  *   Determine whenever M's assembly has a RuntimeCompatibilityAttribute with the
1213  * WrapNonExceptionThrows flag set.
1214  */
1215 static gboolean
1216 wrap_non_exception_throws (MonoMethod *m)
1217 {
1218         MonoError error;
1219         MonoAssembly *ass = m->klass->image->assembly;
1220         MonoCustomAttrInfo* attrs;
1221         MonoClass *klass;
1222         int i;
1223         gboolean val = FALSE;
1224
1225         g_assert (ass);
1226         if (ass->wrap_non_exception_throws_inited)
1227                 return ass->wrap_non_exception_throws;
1228
1229         klass = mono_class_get_runtime_compat_attr_class ();
1230
1231         attrs = mono_custom_attrs_from_assembly_checked (ass, &error);
1232         mono_error_cleanup (&error); /* FIXME don't swallow the error */
1233         if (attrs) {
1234                 for (i = 0; i < attrs->num_attrs; ++i) {
1235                         MonoCustomAttrEntry *attr = &attrs->attrs [i];
1236                         const gchar *p;
1237                         int num_named, named_type, name_len;
1238                         char *name;
1239
1240                         if (!attr->ctor || attr->ctor->klass != klass)
1241                                 continue;
1242                         /* Decode the RuntimeCompatibilityAttribute. See reflection.c */
1243                         p = (const char*)attr->data;
1244                         g_assert (read16 (p) == 0x0001);
1245                         p += 2;
1246                         num_named = read16 (p);
1247                         if (num_named != 1)
1248                                 continue;
1249                         p += 2;
1250                         named_type = *p;
1251                         p ++;
1252                         /* data_type = *p; */
1253                         p ++;
1254                         /* Property */
1255                         if (named_type != 0x54)
1256                                 continue;
1257                         name_len = mono_metadata_decode_blob_size (p, &p);
1258                         name = (char *)g_malloc (name_len + 1);
1259                         memcpy (name, p, name_len);
1260                         name [name_len] = 0;
1261                         p += name_len;
1262                         g_assert (!strcmp (name, "WrapNonExceptionThrows"));
1263                         g_free (name);
1264                         /* The value is a BOOLEAN */
1265                         val = *p;
1266                 }
1267                 mono_custom_attrs_free (attrs);
1268         }
1269
1270         ass->wrap_non_exception_throws = val;
1271         mono_memory_barrier ();
1272         ass->wrap_non_exception_throws_inited = TRUE;
1273
1274         return val;
1275 }
1276
1277 #ifndef MONO_ARCH_STACK_GROWS_UP
1278 #define DOES_STACK_GROWS_UP 1
1279 #else
1280 #define DOES_STACK_GROWS_UP 0
1281 #endif
1282
1283 #define MAX_UNMANAGED_BACKTRACE 128
1284 static MonoArray*
1285 build_native_trace (MonoError *error)
1286 {
1287         mono_error_init (error);
1288 /* This puppy only makes sense on mobile, IOW, ARM. */
1289 #if defined (HAVE_BACKTRACE_SYMBOLS) && defined (TARGET_ARM)
1290         MonoArray *res;
1291         void *native_trace [MAX_UNMANAGED_BACKTRACE];
1292         int size = backtrace (native_trace, MAX_UNMANAGED_BACKTRACE);
1293         int i;
1294
1295         if (!size)
1296                 return NULL;
1297         res = mono_array_new_checked (mono_domain_get (), mono_defaults.int_class, size, error);
1298         return_val_if_nok (error, NULL);
1299
1300         for (i = 0; i < size; i++)
1301                 mono_array_set (res, gpointer, i, native_trace [i]);
1302         return res;
1303 #else
1304         return NULL;
1305 #endif
1306 }
1307
1308 static void
1309 setup_stack_trace (MonoException *mono_ex, GSList *dynamic_methods, MonoArray *initial_trace_ips, GList **trace_ips)
1310 {
1311         if (mono_ex && !initial_trace_ips) {
1312                 *trace_ips = g_list_reverse (*trace_ips);
1313                 MonoError error;
1314                 MonoArray *ips_arr = mono_glist_to_array (*trace_ips, mono_defaults.int_class, &error);
1315                 mono_error_assert_ok (&error);
1316                 MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
1317                 MONO_OBJECT_SETREF (mono_ex, native_trace_ips, build_native_trace (&error));
1318                 mono_error_assert_ok (&error);
1319                 if (dynamic_methods) {
1320                         /* These methods could go away anytime, so save a reference to them in the exception object */
1321                         GSList *l;
1322                         MonoMList *list = NULL;
1323
1324                         for (l = dynamic_methods; l; l = l->next) {
1325                                 guint32 dis_link;
1326                                 MonoDomain *domain = mono_domain_get ();
1327
1328                                 if (domain->method_to_dyn_method) {
1329                                         mono_domain_lock (domain);
1330                                         dis_link = (guint32)(size_t)g_hash_table_lookup (domain->method_to_dyn_method, l->data);
1331                                         mono_domain_unlock (domain);
1332                                         if (dis_link) {
1333                                                 MonoObject *o = mono_gchandle_get_target (dis_link);
1334                                                 if (o) {
1335                                                         list = mono_mlist_prepend_checked (list, o, &error);
1336                                                         mono_error_assert_ok (&error);
1337                                                 }
1338                                         }
1339                                 }
1340                         }
1341
1342                         MONO_OBJECT_SETREF (mono_ex, dynamic_methods, list);
1343                 }
1344         }
1345         g_list_free (*trace_ips);
1346         *trace_ips = NULL;
1347 }
1348
1349 /*
1350  * mono_handle_exception_internal_first_pass:
1351  *
1352  *   The first pass of exception handling. Unwind the stack until a catch clause which can catch
1353  * OBJ is found. Run the index of the filter clause which caught the exception into
1354  * OUT_FILTER_IDX. Return TRUE if the exception is caught, FALSE otherwise.
1355  */
1356 static gboolean
1357 mono_handle_exception_internal_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoJitInfo **out_prev_ji, MonoObject *non_exception)
1358 {
1359         MonoError error;
1360         MonoDomain *domain = mono_domain_get ();
1361         MonoJitInfo *ji = NULL;
1362         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1363         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
1364         MonoLMF *lmf = mono_get_lmf ();
1365         MonoArray *initial_trace_ips = NULL;
1366         GList *trace_ips = NULL;
1367         GSList *dynamic_methods = NULL;
1368         MonoException *mono_ex;
1369         gboolean stack_overflow = FALSE;
1370         MonoContext initial_ctx;
1371         MonoMethod *method;
1372         int frame_count = 0;
1373         gint32 filter_idx;
1374         int i;
1375         MonoObject *ex_obj;
1376
1377         g_assert (ctx != NULL);
1378
1379         if (obj == (MonoObject *)domain->stack_overflow_ex)
1380                 stack_overflow = TRUE;
1381
1382         mono_ex = (MonoException*)obj;
1383         initial_trace_ips = mono_ex->trace_ips;
1384
1385         if (mono_object_isinst_checked (obj, mono_defaults.exception_class, &error)) {
1386                 mono_ex = (MonoException*)obj;
1387                 initial_trace_ips = mono_ex->trace_ips;
1388         } else {
1389                 mono_error_assert_ok (&error);
1390                 mono_ex = NULL;
1391         }
1392
1393         if (!call_filter)
1394                 call_filter = (int (*) (MonoContext *, void *))mono_get_call_filter ();
1395
1396         g_assert (jit_tls->end_of_stack);
1397         g_assert (jit_tls->abort_func);
1398
1399         if (out_filter_idx)
1400                 *out_filter_idx = -1;
1401         if (out_ji)
1402                 *out_ji = NULL;
1403         if (out_prev_ji)
1404                 *out_prev_ji = NULL;
1405         filter_idx = 0;
1406         initial_ctx = *ctx;
1407
1408         while (1) {
1409                 MonoContext new_ctx;
1410                 guint32 free_stack;
1411                 int clause_index_start = 0;
1412                 gboolean unwind_res = TRUE;
1413
1414                 StackFrameInfo frame;
1415
1416                 if (out_prev_ji)
1417                         *out_prev_ji = ji;
1418
1419                 unwind_res = mono_find_jit_info_ext (domain, jit_tls, NULL, ctx, &new_ctx, NULL, &lmf, NULL, &frame);
1420                 if (unwind_res) {
1421                         if (frame.type == FRAME_TYPE_DEBUGGER_INVOKE ||
1422                                         frame.type == FRAME_TYPE_MANAGED_TO_NATIVE ||
1423                                         frame.type == FRAME_TYPE_TRAMPOLINE) {
1424                                 *ctx = new_ctx;
1425                                 continue;
1426                         }
1427                         g_assert (frame.type == FRAME_TYPE_MANAGED);
1428                         ji = frame.ji;
1429                 }
1430
1431                 if (!unwind_res) {
1432                         setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1433                         g_slist_free (dynamic_methods);
1434                         return FALSE;
1435                 }
1436
1437                 frame_count ++;
1438                 method = jinfo_get_method (ji);
1439                 //printf ("M: %s %d.\n", mono_method_full_name (method, TRUE), frame_count);
1440
1441                 if (mini_get_debug_options ()->reverse_pinvoke_exceptions && method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
1442                         g_error ("A native frame was found while unwinding the stack after an exception.\n"
1443                                          "The native frame called the managed method:\n%s\n",
1444                                          mono_method_full_name (method, TRUE));
1445                 }
1446
1447                 if (method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
1448                         /*
1449                          * Avoid overwriting the stack trace if the exception is
1450                          * rethrown. Also avoid giant stack traces during a stack
1451                          * overflow.
1452                          */
1453                         if (!initial_trace_ips && (frame_count < 1000)) {
1454                                 trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
1455                                 trace_ips = g_list_prepend (trace_ips,
1456                                                                                         get_generic_info_from_stack_frame (ji, ctx));
1457                         }
1458                 }
1459
1460                 if (method->dynamic)
1461                         dynamic_methods = g_slist_prepend (dynamic_methods, method);
1462
1463                 if (stack_overflow) {
1464                         if (DOES_STACK_GROWS_UP)
1465                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx));
1466                         else
1467                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (ctx));
1468                 } else {
1469                         free_stack = 0xffffff;
1470                 }
1471
1472                 for (i = clause_index_start; i < ji->num_clauses; i++) {
1473                         MonoJitExceptionInfo *ei = &ji->clauses [i];
1474                         gboolean filtered = FALSE;
1475
1476                         /*
1477                          * During stack overflow, wait till the unwinding frees some stack
1478                          * space before running handlers/finalizers.
1479                          */
1480                         if (free_stack <= (64 * 1024))
1481                                 continue;
1482
1483                         if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx))) {
1484                                 /* catch block */
1485                                 MonoClass *catch_class = get_exception_catch_class (ei, ji, ctx);
1486
1487                                 /*
1488                                  * Have to unwrap RuntimeWrappedExceptions if the
1489                                  * method's assembly doesn't have a RuntimeCompatibilityAttribute.
1490                                  */
1491                                 if (non_exception && !wrap_non_exception_throws (method))
1492                                         ex_obj = non_exception;
1493                                 else
1494                                         ex_obj = obj;
1495
1496                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
1497                                         gboolean is_user_frame = method->wrapper_type == MONO_WRAPPER_NONE || method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD;
1498 #ifndef DISABLE_PERFCOUNTERS
1499                                         mono_perfcounters->exceptions_filters++;
1500 #endif
1501                                         /*
1502                                         Here's the thing, if this is a filter clause done by a wrapper like runtime invoke, we don't want to
1503                                         trim the stackframe since if it returns FALSE we lose information.
1504
1505                                         FIXME Not 100% sure if it's a good idea even with user clauses.
1506                                         */
1507                                         if (is_user_frame)
1508                                                 setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1509
1510 #ifndef MONO_CROSS_COMPILE
1511 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
1512                                         if (ji->from_llvm)
1513                                                 MONO_CONTEXT_SET_LLVM_EXC_REG (ctx, ex_obj);
1514                                         else
1515                                                 /* Can't pass the ex object in a register yet to filter clauses, because call_filter () might not support it */
1516                                                 *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1517 #else
1518                                         g_assert (!ji->from_llvm);
1519                                         /* store the exception object in bp + ei->exvar_offset */
1520                                         *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1521 #endif
1522 #endif
1523
1524 #ifdef MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG
1525                                         /*
1526                                          * Pass the original il clause index to the landing pad so it can
1527                                          * branch to the landing pad associated with the il clause.
1528                                          * This is needed because llvm compiled code assumes that the EH
1529                                          * code always branches to the innermost landing pad.
1530                                          */
1531                                         if (ji->from_llvm)
1532                                                 MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG (ctx, ei->clause_index);
1533 #endif
1534
1535                                         mono_debugger_agent_begin_exception_filter (mono_ex, ctx, &initial_ctx);
1536                                         filtered = call_filter (ctx, ei->data.filter);
1537                                         mono_debugger_agent_end_exception_filter (mono_ex, ctx, &initial_ctx);
1538                                         if (filtered && out_filter_idx)
1539                                                 *out_filter_idx = filter_idx;
1540                                         if (out_ji)
1541                                                 *out_ji = ji;
1542                                         filter_idx ++;
1543
1544                                         if (filtered) {
1545                                                 if (!is_user_frame)
1546                                                         setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1547                                                 g_slist_free (dynamic_methods);
1548                                                 /* mono_debugger_agent_handle_exception () needs this */
1549                                                 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1550                                                 return TRUE;
1551                                         }
1552                                 }
1553
1554                                 MonoError isinst_error;
1555                                 mono_error_init (&isinst_error);
1556                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_NONE && mono_object_isinst_checked (ex_obj, catch_class, &error)) {
1557                                         setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1558                                         g_slist_free (dynamic_methods);
1559
1560                                         if (out_ji)
1561                                                 *out_ji = ji;
1562
1563                                         /* mono_debugger_agent_handle_exception () needs this */
1564                                         MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1565                                         return TRUE;
1566                                 }
1567                                 mono_error_cleanup (&isinst_error);
1568                         }
1569                 }
1570
1571                 *ctx = new_ctx;
1572         }
1573
1574         g_assert_not_reached ();
1575 }
1576
1577 /**
1578  * mono_handle_exception_internal:
1579  * @ctx: saved processor state
1580  * @obj: the exception object
1581  * @resume: whenever to resume unwinding based on the state in MonoJitTlsData.
1582  */
1583 static gboolean
1584 mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resume, MonoJitInfo **out_ji)
1585 {
1586         MonoError error;
1587         MonoDomain *domain = mono_domain_get ();
1588         MonoJitInfo *ji, *prev_ji;
1589         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1590         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
1591         MonoLMF *lmf = mono_get_lmf ();
1592         MonoException *mono_ex;
1593         gboolean stack_overflow = FALSE;
1594         MonoContext initial_ctx;
1595         MonoMethod *method;
1596         int frame_count = 0;
1597         gint32 filter_idx, first_filter_idx = 0;
1598         int i;
1599         MonoObject *ex_obj;
1600         MonoObject *non_exception = NULL;
1601
1602         g_assert (ctx != NULL);
1603         if (!obj) {
1604                 MonoException *ex = mono_get_exception_null_reference ();
1605                 MONO_OBJECT_SETREF (ex, message, mono_string_new (domain, "Object reference not set to an instance of an object"));
1606                 obj = (MonoObject *)ex;
1607         }
1608
1609         /*
1610          * Allocate a new exception object instead of the preconstructed ones.
1611          */
1612         if (obj == (MonoObject *)domain->stack_overflow_ex) {
1613                 /*
1614                  * It is not a good idea to try and put even more pressure on the little stack available.
1615                  * obj = mono_get_exception_stack_overflow ();
1616                  */
1617                 stack_overflow = TRUE;
1618         }
1619         else if (obj == (MonoObject *)domain->null_reference_ex) {
1620                 obj = (MonoObject *)mono_get_exception_null_reference ();
1621         }
1622
1623         if (!mono_object_isinst_checked (obj, mono_defaults.exception_class, &error)) {
1624                 mono_error_assert_ok (&error);
1625                 non_exception = obj;
1626                 obj = (MonoObject *)mono_get_exception_runtime_wrapped_checked (obj, &error);
1627                 mono_error_assert_ok (&error);
1628         }
1629
1630         mono_ex = (MonoException*)obj;
1631
1632         if (mini_get_debug_options ()->suspend_on_exception) {
1633                 mono_runtime_printf_err ("Exception thrown, suspending...");
1634                 while (1)
1635                         ;
1636         }
1637
1638         if (mono_object_isinst_checked (obj, mono_defaults.exception_class, &error)) {
1639                 mono_ex = (MonoException*)obj;
1640         } else {
1641                 mono_error_assert_ok (&error);
1642                 mono_ex = NULL;
1643         }
1644
1645         if (mono_ex && jit_tls->class_cast_from) {
1646                 if (!strcmp (mono_ex->object.vtable->klass->name, "InvalidCastException")) {
1647                         char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
1648                         char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
1649                         char *msg = g_strdup_printf ("Unable to cast object of type '%s' to type '%s'.", from_name, to_name);
1650                         mono_ex->message = mono_string_new (domain, msg);
1651                         g_free (from_name);
1652                         g_free (to_name);
1653                         g_free (msg);
1654                 }
1655                 if (!strcmp (mono_ex->object.vtable->klass->name, "ArrayTypeMismatchException")) {
1656                         char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
1657                         char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
1658                         char *msg = g_strdup_printf ("Source array of type '%s' cannot be cast to destination array type '%s'.", from_name, to_name);
1659                         mono_ex->message = mono_string_new (domain, msg);
1660                         g_free (from_name);
1661                         g_free (to_name);
1662                         g_free (msg);
1663                 }
1664         }
1665
1666         if (!call_filter)
1667                 call_filter = (int (*)(MonoContext *, void*))mono_get_call_filter ();
1668
1669         g_assert (jit_tls->end_of_stack);
1670         g_assert (jit_tls->abort_func);
1671
1672         /*
1673          * We set orig_ex_ctx_set to TRUE/FALSE around profiler calls to make sure it doesn't
1674          * end up being TRUE on any code path.
1675          */
1676         memcpy (&jit_tls->orig_ex_ctx, ctx, sizeof (MonoContext));
1677
1678         if (!resume) {
1679                 gboolean res;
1680
1681                 MonoContext ctx_cp = *ctx;
1682                 if (mono_trace_is_enabled ()) {
1683                         MonoMethod *system_exception_get_message = mono_class_get_method_from_name (mono_defaults.exception_class, "get_Message", 0);
1684                         MonoMethod *get_message = system_exception_get_message == NULL ? NULL : mono_object_get_virtual_method (obj, system_exception_get_message);
1685                         MonoObject *message;
1686                         const char *type_name = mono_class_get_name (mono_object_class (mono_ex));
1687                         char *msg = NULL;
1688                         if (get_message == NULL) {
1689                                 message = NULL;
1690                         } else if (!strcmp (type_name, "OutOfMemoryException") || !strcmp (type_name, "StackOverflowException")) {
1691                                 message = NULL;
1692                                 msg = g_strdup_printf ("(No exception message for: %s)\n", type_name);
1693                         } else {
1694                                 MonoObject *exc = NULL;
1695                                 message = mono_runtime_try_invoke (get_message, obj, NULL, &exc, &error);
1696                                 g_assert (exc == NULL);
1697                                 mono_error_assert_ok (&error);
1698                         }
1699                         if (msg == NULL) {
1700                                 msg = message ? mono_string_to_utf8 ((MonoString *) message) : g_strdup ("(System.Exception.Message property not available)");
1701                         }
1702                         g_print ("[%p:] EXCEPTION handling: %s.%s: %s\n", (void*)mono_native_thread_id_get (), mono_object_class (obj)->name_space, mono_object_class (obj)->name, msg);
1703                         g_free (msg);
1704                         if (mono_ex && mono_trace_eval_exception (mono_object_class (mono_ex)))
1705                                 mono_print_thread_dump_from_ctx (ctx);
1706                 }
1707                 jit_tls->orig_ex_ctx_set = TRUE;
1708                 mono_profiler_exception_thrown (obj);
1709                 jit_tls->orig_ex_ctx_set = FALSE;
1710
1711                 res = mono_handle_exception_internal_first_pass (&ctx_cp, obj, &first_filter_idx, &ji, &prev_ji, non_exception);
1712
1713                 if (!res) {
1714                         if (mini_get_debug_options ()->break_on_exc)
1715                                 G_BREAKPOINT ();
1716                         mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, NULL);
1717
1718                         if (mini_get_debug_options ()->suspend_on_unhandled) {
1719                                 mono_runtime_printf_err ("Unhandled exception, suspending...");
1720                                 while (1)
1721                                         ;
1722                         }
1723
1724                         // FIXME: This runs managed code so it might cause another stack overflow when
1725                         // we are handling a stack overflow
1726                         mono_unhandled_exception (obj);
1727                 } else {
1728                         gboolean unhandled = FALSE;
1729
1730                         /*
1731                          * The exceptions caught by the mono_runtime_invoke_checked () calls
1732                          * in the threadpool needs to be treated as unhandled (#669836).
1733                          *
1734                          * FIXME: The check below is hackish, but its hard to distinguish
1735                          * these runtime invoke calls from others in the runtime.
1736                          */
1737                         if (ji && jinfo_get_method (ji)->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE) {
1738                                 if (prev_ji && jinfo_get_method (prev_ji) == mono_defaults.threadpool_perform_wait_callback_method)
1739                                         unhandled = TRUE;
1740                         }
1741
1742                         if (unhandled)
1743                                 mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, NULL);
1744                         else
1745                                 mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, &ctx_cp);
1746                 }
1747         }
1748
1749         if (out_ji)
1750                 *out_ji = NULL;
1751         filter_idx = 0;
1752         initial_ctx = *ctx;
1753
1754         while (1) {
1755                 MonoContext new_ctx;
1756                 guint32 free_stack;
1757                 int clause_index_start = 0;
1758                 gboolean unwind_res = TRUE;
1759
1760                 if (resume) {
1761                         resume = FALSE;
1762                         ji = jit_tls->resume_state.ji;
1763                         new_ctx = jit_tls->resume_state.new_ctx;
1764                         clause_index_start = jit_tls->resume_state.clause_index;
1765                         lmf = jit_tls->resume_state.lmf;
1766                         first_filter_idx = jit_tls->resume_state.first_filter_idx;
1767                         filter_idx = jit_tls->resume_state.filter_idx;
1768                 } else {
1769                         StackFrameInfo frame;
1770
1771                         unwind_res = mono_find_jit_info_ext (domain, jit_tls, NULL, ctx, &new_ctx, NULL, &lmf, NULL, &frame);
1772                         if (unwind_res) {
1773                                 if (frame.type == FRAME_TYPE_DEBUGGER_INVOKE ||
1774                                                 frame.type == FRAME_TYPE_MANAGED_TO_NATIVE ||
1775                                                 frame.type == FRAME_TYPE_TRAMPOLINE) {
1776                                         *ctx = new_ctx;
1777                                         continue;
1778                                 }
1779                                 g_assert (frame.type == FRAME_TYPE_MANAGED);
1780                                 ji = frame.ji;
1781                         }
1782                 }
1783
1784                 if (!unwind_res) {
1785                         *(mono_get_lmf_addr ()) = lmf;
1786
1787                         jit_tls->abort_func (obj);
1788                         g_assert_not_reached ();
1789                 }
1790
1791                 method = jinfo_get_method (ji);
1792                 frame_count ++;
1793                 //printf ("M: %s %d.\n", mono_method_full_name (method, TRUE), frame_count);
1794
1795                 if (stack_overflow) {
1796                         if (DOES_STACK_GROWS_UP)
1797                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx));
1798                         else
1799                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (ctx));
1800                 } else {
1801                         free_stack = 0xffffff;
1802                 }
1803
1804                 for (i = clause_index_start; i < ji->num_clauses; i++) {
1805                         MonoJitExceptionInfo *ei = &ji->clauses [i];
1806                         gboolean filtered = FALSE;
1807
1808                         /*
1809                          * During stack overflow, wait till the unwinding frees some stack
1810                          * space before running handlers/finalizers.
1811                          */
1812                         if (free_stack <= (64 * 1024))
1813                                 continue;
1814
1815                         if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx))) {
1816                                 /* catch block */
1817                                 MonoClass *catch_class = get_exception_catch_class (ei, ji, ctx);
1818
1819                                 /*
1820                                  * Have to unwrap RuntimeWrappedExceptions if the
1821                                  * method's assembly doesn't have a RuntimeCompatibilityAttribute.
1822                                  */
1823                                 if (non_exception && !wrap_non_exception_throws (method))
1824                                         ex_obj = non_exception;
1825                                 else
1826                                         ex_obj = obj;
1827
1828                                 if (((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) || (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER))) {
1829 #ifndef MONO_CROSS_COMPILE
1830 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
1831                                         MONO_CONTEXT_SET_LLVM_EXC_REG (ctx, ex_obj);
1832 #else
1833                                         g_assert (!ji->from_llvm);
1834                                         /* store the exception object in bp + ei->exvar_offset */
1835                                         *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1836 #endif
1837 #endif
1838                                 }
1839
1840 #ifdef MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG
1841                                 if (ji->from_llvm)
1842                                         MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG (ctx, ei->clause_index);
1843 #endif
1844
1845                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
1846                                         /*
1847                                          * Filter clauses should only be run in the
1848                                          * first pass of exception handling.
1849                                          */
1850                                         filtered = (filter_idx == first_filter_idx);
1851                                         filter_idx ++;
1852                                 }
1853
1854                                 mono_error_init (&error);
1855                                 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
1856                                      mono_object_isinst_checked (ex_obj, catch_class, &error)) || filtered) {
1857                                         /*
1858                                          * This guards against the situation that we abort a thread that is executing a finally clause
1859                                          * that was called by the EH machinery. It won't have a guard trampoline installed, so we must
1860                                          * check for this situation here and resume interruption if we are below the guarded block.
1861                                          */
1862                                         if (G_UNLIKELY (jit_tls->handler_block_return_address)) {
1863                                                 gboolean is_outside = FALSE;
1864                                                 gpointer prot_bp = MONO_CONTEXT_GET_BP (&jit_tls->handler_block_context);
1865                                                 gpointer catch_bp = MONO_CONTEXT_GET_BP (ctx);
1866                                                 //FIXME make this stack direction aware
1867                                                 if (catch_bp > prot_bp) {
1868                                                         is_outside = TRUE;
1869                                                 } else if (catch_bp == prot_bp) {
1870                                                         /* Can be either try { try { } catch {} } finally {} or try { try { } finally {} } catch {}
1871                                                          * So we check if the catch handler_start is protected by the guarded handler protected region
1872                                                          *
1873                                                          * Assumptions:
1874                                                          *      If there is an outstanding guarded_block return address, it means the current thread must be aborted.
1875                                                          *      This is the only way to reach out the guarded block as other cases are handled by the trampoline.
1876                                                          *      There aren't any further finally/fault handler blocks down the stack over this exception.
1877                                                          *   This must be ensured by the code that installs the guard trampoline.
1878                                                          */
1879                                                         g_assert (ji == mini_jit_info_table_find (domain, (char *)MONO_CONTEXT_GET_IP (&jit_tls->handler_block_context), NULL));
1880
1881                                                         if (!is_address_protected (ji, jit_tls->handler_block, ei->handler_start)) {
1882                                                                 is_outside = TRUE;
1883                                                         }
1884                                                 }
1885                                                 if (is_outside) {
1886                                                         jit_tls->handler_block_return_address = NULL;
1887                                                         jit_tls->handler_block = NULL;
1888                                                         mono_thread_resume_interruption (); /*We ignore the exception here, it will be raised later*/
1889                                                 }
1890                                         }
1891
1892                                         if (mono_trace_is_enabled () && mono_trace_eval (method))
1893                                                 g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (method, TRUE));
1894                                         jit_tls->orig_ex_ctx_set = TRUE;
1895                                         mono_profiler_exception_clause_handler (method, ei->flags, i);
1896                                         jit_tls->orig_ex_ctx_set = FALSE;
1897                                         MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1898                                         mono_set_lmf (lmf);
1899 #ifndef DISABLE_PERFCOUNTERS
1900                                         mono_perfcounters->exceptions_depth += frame_count;
1901 #endif
1902                                         if (obj == (MonoObject *)domain->stack_overflow_ex)
1903                                                 jit_tls->handling_stack_ovf = FALSE;
1904
1905                                         return 0;
1906                                 }
1907                                 mono_error_cleanup (&error);
1908                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FAULT) {
1909                                         if (mono_trace_is_enabled () && mono_trace_eval (method))
1910                                                 g_print ("EXCEPTION: fault clause %d of %s\n", i, mono_method_full_name (method, TRUE));
1911                                         jit_tls->orig_ex_ctx_set = TRUE;
1912                                         mono_profiler_exception_clause_handler (method, ei->flags, i);
1913                                         jit_tls->orig_ex_ctx_set = FALSE;
1914                                         call_filter (ctx, ei->handler_start);
1915                                 }
1916                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY) {
1917                                         if (mono_trace_is_enabled () && mono_trace_eval (method))
1918                                                 g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (method, TRUE));
1919                                         jit_tls->orig_ex_ctx_set = TRUE;
1920                                         mono_profiler_exception_clause_handler (method, ei->flags, i);
1921                                         jit_tls->orig_ex_ctx_set = FALSE;
1922 #ifndef DISABLE_PERFCOUNTERS
1923                                         mono_perfcounters->exceptions_finallys++;
1924 #endif
1925                                         mono_set_lmf (lmf);
1926                                         if (ji->from_llvm) {
1927                                                 /*
1928                                                  * LLVM compiled finally handlers follow the design
1929                                                  * of the c++ ehabi, i.e. they call a resume function
1930                                                  * at the end instead of returning to the caller.
1931                                                  * So save the exception handling state,
1932                                                  * mono_resume_unwind () will call us again to continue
1933                                                  * the unwinding.
1934                                                  */
1935                                                 jit_tls->resume_state.ex_obj = obj;
1936                                                 jit_tls->resume_state.ji = ji;
1937                                                 jit_tls->resume_state.clause_index = i + 1;
1938                                                 jit_tls->resume_state.ctx = *ctx;
1939                                                 jit_tls->resume_state.new_ctx = new_ctx;
1940                                                 jit_tls->resume_state.lmf = lmf;
1941                                                 jit_tls->resume_state.first_filter_idx = first_filter_idx;
1942                                                 jit_tls->resume_state.filter_idx = filter_idx;
1943                                                 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1944                                                 return 0;
1945                                         } else {
1946                                                 call_filter (ctx, ei->handler_start);
1947                                         }
1948                                 }
1949                         }
1950                 }
1951
1952                 jit_tls->orig_ex_ctx_set = TRUE;
1953                 mono_profiler_exception_method_leave (method);
1954                 jit_tls->orig_ex_ctx_set = FALSE;
1955
1956                 *ctx = new_ctx;
1957         }
1958
1959         g_assert_not_reached ();
1960 }
1961
1962 /**
1963  * mono_debugger_run_finally:
1964  * @start_ctx: saved processor state
1965  *
1966  * This method is called by the Mono Debugger to call all `finally' clauses of the
1967  * current stack frame.  It's used when the user issues a `return' command to make
1968  * the current stack frame return.  After returning from this method, the debugger
1969  * unwinds the stack one frame and gives control back to the user.
1970  *
1971  * NOTE: This method is only used when running inside the Mono Debugger.
1972  */
1973 void
1974 mono_debugger_run_finally (MonoContext *start_ctx)
1975 {
1976         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1977         MonoDomain *domain = mono_domain_get ();
1978         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
1979         MonoLMF *lmf = mono_get_lmf ();
1980         MonoContext ctx, new_ctx;
1981         MonoJitInfo *ji, rji;
1982         int i;
1983
1984         ctx = *start_ctx;
1985
1986         ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, NULL);
1987         if (!ji || ji == (gpointer)-1)
1988                 return;
1989
1990         if (!call_filter)
1991                 call_filter = (int (*)(MonoContext *, void *))mono_get_call_filter ();
1992
1993         for (i = 0; i < ji->num_clauses; i++) {
1994                 MonoJitExceptionInfo *ei = &ji->clauses [i];
1995
1996                 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (&ctx)) &&
1997                     (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
1998                         call_filter (&ctx, ei->handler_start);
1999                 }
2000         }
2001 }
2002
2003 /**
2004  * mono_handle_exception:
2005  * @ctx: saved processor state
2006  * @obj: the exception object
2007  */
2008 gboolean
2009 mono_handle_exception (MonoContext *ctx, MonoObject *obj)
2010 {
2011         MONO_REQ_GC_UNSAFE_MODE;
2012
2013 #ifndef DISABLE_PERFCOUNTERS
2014         mono_perfcounters->exceptions_thrown++;
2015 #endif
2016
2017         return mono_handle_exception_internal (ctx, obj, FALSE, NULL);
2018 }
2019
2020 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2021
2022 #ifndef MONO_ARCH_USE_SIGACTION
2023 #error "Can't use sigaltstack without sigaction"
2024 #endif
2025
2026 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
2027
2028 void
2029 mono_setup_altstack (MonoJitTlsData *tls)
2030 {
2031         size_t stsize = 0;
2032         stack_t sa;
2033         guint8 *staddr = NULL;
2034
2035         if (mono_running_on_valgrind ())
2036                 return;
2037
2038         mono_thread_info_get_stack_bounds (&staddr, &stsize);
2039
2040         g_assert (staddr);
2041
2042         tls->end_of_stack = staddr + stsize;
2043         tls->stack_size = stsize;
2044
2045         /*g_print ("thread %p, stack_base: %p, stack_size: %d\n", (gpointer)pthread_self (), staddr, stsize);*/
2046
2047         tls->stack_ovf_guard_base = staddr + mono_pagesize ();
2048         tls->stack_ovf_guard_size = ALIGN_TO (8 * 4096, mono_pagesize ());
2049
2050         g_assert ((guint8*)&sa >= (guint8*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size);
2051
2052         if (mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_NONE)) {
2053                 /* mprotect can fail for the main thread stack */
2054                 gpointer gaddr = mono_valloc (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_NONE|MONO_MMAP_PRIVATE|MONO_MMAP_ANON|MONO_MMAP_FIXED);
2055                 g_assert (gaddr == tls->stack_ovf_guard_base);
2056                 tls->stack_ovf_valloced = TRUE;
2057         }
2058
2059         /* Setup an alternate signal stack */
2060         tls->signal_stack = mono_valloc (0, MONO_ARCH_SIGNAL_STACK_SIZE, MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_PRIVATE|MONO_MMAP_ANON);
2061         tls->signal_stack_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2062
2063         g_assert (tls->signal_stack);
2064
2065         sa.ss_sp = tls->signal_stack;
2066         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2067         sa.ss_flags = 0;
2068         g_assert (sigaltstack (&sa, NULL) == 0);
2069
2070         mono_gc_register_altstack ((char*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size, (char*)staddr + stsize - ((char*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size), tls->signal_stack, tls->signal_stack_size);
2071 }
2072
2073 void
2074 mono_free_altstack (MonoJitTlsData *tls)
2075 {
2076         stack_t sa;
2077         int err;
2078
2079         sa.ss_sp = tls->signal_stack;
2080         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2081         sa.ss_flags = SS_DISABLE;
2082         err = sigaltstack  (&sa, NULL);
2083         g_assert (err == 0);
2084
2085         if (tls->signal_stack)
2086                 mono_vfree (tls->signal_stack, MONO_ARCH_SIGNAL_STACK_SIZE);
2087         if (tls->stack_ovf_valloced)
2088                 mono_vfree (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size);
2089         else
2090                 mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_READ|MONO_MMAP_WRITE);
2091 }
2092
2093 #else /* !MONO_ARCH_SIGSEGV_ON_ALTSTACK */
2094
2095 void
2096 mono_setup_altstack (MonoJitTlsData *tls)
2097 {
2098 }
2099
2100 void
2101 mono_free_altstack (MonoJitTlsData *tls)
2102 {
2103 }
2104
2105 #endif /* MONO_ARCH_SIGSEGV_ON_ALTSTACK */
2106
2107 static gboolean
2108 try_restore_stack_protection (MonoJitTlsData *jit_tls, int extra_bytes)
2109 {
2110         gint32 unprotect_size = jit_tls->stack_ovf_guard_size;
2111         /* we need to leave some room for throwing the exception */
2112         while (unprotect_size >= 0 && (char*)jit_tls->stack_ovf_guard_base + unprotect_size > ((char*)&unprotect_size - extra_bytes))
2113                 unprotect_size -= mono_pagesize ();
2114         /* at this point we could try and build a new domain->stack_overflow_ex, but only if there
2115          * is sufficient stack
2116          */
2117         //fprintf (stderr, "restoring stack protection: %p-%p (%d)\n", jit_tls->stack_ovf_guard_base, (char*)jit_tls->stack_ovf_guard_base + unprotect_size, unprotect_size);
2118         if (unprotect_size)
2119                 mono_mprotect (jit_tls->stack_ovf_guard_base, unprotect_size, MONO_MMAP_NONE);
2120         return unprotect_size == jit_tls->stack_ovf_guard_size;
2121 }
2122
2123 static G_GNUC_UNUSED void
2124 try_more_restore (void)
2125 {
2126         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2127         if (try_restore_stack_protection (jit_tls, 500))
2128                 jit_tls->restore_stack_prot = NULL;
2129 }
2130
2131 static G_GNUC_UNUSED void
2132 restore_stack_protection (void)
2133 {
2134         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2135         MonoException *ex = mono_domain_get ()->stack_overflow_ex;
2136         /* if we can't restore the stack protection, keep a callback installed so
2137          * we'll try to restore as much stack as we can at each return from unmanaged
2138          * code.
2139          */
2140         if (try_restore_stack_protection (jit_tls, 4096))
2141                 jit_tls->restore_stack_prot = NULL;
2142         else
2143                 jit_tls->restore_stack_prot = try_more_restore_tramp;
2144         /* here we also throw a stack overflow exception */
2145         ex->trace_ips = NULL;
2146         ex->stack_trace = NULL;
2147         mono_raise_exception (ex);
2148 }
2149
2150 gpointer
2151 mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
2152 {
2153         MONO_REQ_GC_UNSAFE_MODE;
2154
2155         void (*func)(void) = (void (*)(void))tramp_data;
2156         func ();
2157         return NULL;
2158 }
2159
2160 gboolean
2161 mono_handle_soft_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, guint8* fault_addr)
2162 {
2163         if (mono_llvm_only)
2164                 return FALSE;
2165
2166         /* we got a stack overflow in the soft-guard pages
2167          * There are two cases:
2168          * 1) managed code caused the overflow: we unprotect the soft-guard page
2169          * and let the arch-specific code trigger the exception handling mechanism
2170          * in the thread stack. The soft-guard pages will be protected again as the stack is unwound.
2171          * 2) unmanaged code caused the overflow: we unprotect the soft-guard page
2172          * and hope we can continue with those enabled, at least until the hard-guard page
2173          * is hit. The alternative to continuing here is to just print a message and abort.
2174          * We may add in the future the code to protect the pages again in the codepath
2175          * when we return from unmanaged to managed code.
2176          */
2177         if (jit_tls->stack_ovf_guard_size && fault_addr >= (guint8*)jit_tls->stack_ovf_guard_base &&
2178                         fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + jit_tls->stack_ovf_guard_size) {
2179                 /* we unprotect the minimum amount we can */
2180                 guint32 guard_size;
2181                 gboolean handled = FALSE;
2182
2183                 guard_size = jit_tls->stack_ovf_guard_size - (mono_pagesize () * SIZEOF_VOID_P / 4);
2184                 while (guard_size && fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + guard_size) {
2185                         guard_size -= mono_pagesize ();
2186                 }
2187                 guard_size = jit_tls->stack_ovf_guard_size - guard_size;
2188                 /*fprintf (stderr, "unprotecting: %d\n", guard_size);*/
2189                 mono_mprotect ((char*)jit_tls->stack_ovf_guard_base + jit_tls->stack_ovf_guard_size - guard_size, guard_size, MONO_MMAP_READ|MONO_MMAP_WRITE);
2190 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2191                 if (ji) {
2192                         mono_arch_handle_altstack_exception (ctx, siginfo, fault_addr, TRUE);
2193                         handled = TRUE;
2194                 }
2195 #endif
2196                 if (!handled) {
2197                         /* We print a message: after this even managed stack overflows
2198                          * may crash the runtime
2199                          */
2200                         mono_runtime_printf_err ("Stack overflow in unmanaged: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
2201                         if (!jit_tls->handling_stack_ovf) {
2202                                 jit_tls->restore_stack_prot = restore_stack_protection_tramp;
2203                                 jit_tls->handling_stack_ovf = 1;
2204                         } else {
2205                                 /*fprintf (stderr, "Already handling stack overflow\n");*/
2206                         }
2207                 }
2208                 return TRUE;
2209         }
2210         return FALSE;
2211 }
2212
2213 typedef struct {
2214         MonoMethod *omethod;
2215         int count;
2216 } PrintOverflowUserData;
2217
2218 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2219 static gboolean
2220 print_overflow_stack_frame (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2221 {
2222         MonoMethod *method = NULL;
2223         PrintOverflowUserData *user_data = (PrintOverflowUserData *)data;
2224         gchar *location;
2225
2226         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2227                 method = jinfo_get_method (frame->ji);
2228
2229         if (method) {
2230                 if (user_data->count == 0) {
2231                         /* The first frame is in its prolog, so a line number cannot be computed */
2232                         user_data->count ++;
2233                         return FALSE;
2234                 }
2235
2236                 /* If this is a one method overflow, skip the other instances */
2237                 if (method == user_data->omethod)
2238                         return FALSE;
2239
2240                 location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
2241                 mono_runtime_printf_err ("  %s", location);
2242                 g_free (location);
2243
2244                 if (user_data->count == 1) {
2245                         mono_runtime_printf_err ("  <...>");
2246                         user_data->omethod = method;
2247                 } else {
2248                         user_data->omethod = NULL;
2249                 }
2250
2251                 user_data->count ++;
2252         } else
2253                 mono_runtime_printf_err ("  at <unknown> <0x%05x>", frame->native_offset);
2254
2255         return FALSE;
2256 }
2257 #endif
2258
2259 void
2260 mono_handle_hard_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr)
2261 {
2262 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2263         PrintOverflowUserData ud;
2264         MonoContext mctx;
2265 #endif
2266
2267         /* we don't do much now, but we can warn the user with a useful message */
2268         mono_runtime_printf_err ("Stack overflow: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
2269
2270 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2271         mono_sigctx_to_monoctx (ctx, &mctx);
2272
2273         mono_runtime_printf_err ("Stacktrace:");
2274
2275         memset (&ud, 0, sizeof (ud));
2276
2277         mono_walk_stack_with_ctx (print_overflow_stack_frame, &mctx, MONO_UNWIND_LOOKUP_ACTUAL_METHOD, &ud);
2278 #else
2279         if (ji && !ji->is_trampoline && jinfo_get_method (ji))
2280                 mono_runtime_printf_err ("At %s", mono_method_full_name (jinfo_get_method (ji), TRUE));
2281         else
2282                 mono_runtime_printf_err ("At <unmanaged>.");
2283 #endif
2284
2285         _exit (1);
2286 }
2287
2288 static gboolean
2289 print_stack_frame_to_stderr (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2290 {
2291         MonoMethod *method = NULL;
2292
2293         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2294                 method = jinfo_get_method (frame->ji);
2295
2296         if (method) {
2297                 gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
2298                 mono_runtime_printf_err ("  %s", location);
2299                 g_free (location);
2300         } else
2301                 mono_runtime_printf_err ("  at <unknown> <0x%05x>", frame->native_offset);
2302
2303         return FALSE;
2304 }
2305
2306 static G_GNUC_UNUSED gboolean
2307 print_stack_frame_to_string (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2308 {
2309         GString *p = (GString*)data;
2310         MonoMethod *method = NULL;
2311
2312         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2313                 method = jinfo_get_method (frame->ji);
2314
2315         if (method && frame->domain) {
2316                 gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, frame->domain);
2317                 g_string_append_printf (p, "  %s\n", location);
2318                 g_free (location);
2319         } else
2320                 g_string_append_printf (p, "  at <unknown> <0x%05x>\n", frame->native_offset);
2321
2322         return FALSE;
2323 }
2324
2325 #ifndef MONO_CROSS_COMPILE
2326
2327 static gboolean handling_sigsegv = FALSE;
2328
2329 /*
2330  * mono_handle_native_sigsegv:
2331  *
2332  *   Handle a SIGSEGV received while in native code by printing diagnostic
2333  * information and aborting.
2334  */
2335 void
2336 mono_handle_native_sigsegv (int signal, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *info)
2337 {
2338 #ifdef MONO_ARCH_USE_SIGACTION
2339         struct sigaction sa;
2340 #endif
2341         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2342         const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
2343
2344         if (handling_sigsegv)
2345                 return;
2346
2347         if (mini_get_debug_options ()->suspend_on_sigsegv) {
2348                 mono_runtime_printf_err ("Received SIGSEGV, suspending...");
2349 #ifdef HOST_WIN32
2350                 while (1)
2351                         ;
2352 #else
2353                 while (1) {
2354                         sleep (1);
2355                 }
2356 #endif
2357         }
2358
2359         /* To prevent infinite loops when the stack walk causes a crash */
2360         handling_sigsegv = TRUE;
2361
2362         /* !jit_tls means the thread was not registered with the runtime */
2363         if (jit_tls && mono_thread_internal_current ()) {
2364                 mono_runtime_printf_err ("Stacktrace:\n");
2365
2366                 /* FIXME: Is MONO_UNWIND_LOOKUP_IL_OFFSET correct here? */
2367                 mono_walk_stack (print_stack_frame_to_stderr, MONO_UNWIND_LOOKUP_IL_OFFSET, NULL);
2368         }
2369
2370 #ifdef HAVE_BACKTRACE_SYMBOLS
2371  {
2372         void *array [256];
2373         char **names;
2374         int i, size;
2375
2376         mono_runtime_printf_err ("\nNative stacktrace:\n");
2377
2378         size = backtrace (array, 256);
2379         names = backtrace_symbols (array, size);
2380         for (i =0; i < size; ++i) {
2381                 mono_runtime_printf_err ("\t%s", names [i]);
2382         }
2383         free (names);
2384
2385         /* Try to get more meaningful information using gdb */
2386
2387 #if !defined(HOST_WIN32) && defined(HAVE_SYS_SYSCALL_H) && defined(SYS_fork)
2388         if (!mini_get_debug_options ()->no_gdb_backtrace) {
2389                 /* From g_spawn_command_line_sync () in eglib */
2390                 pid_t pid;
2391                 int status;
2392                 pid_t crashed_pid = getpid ();
2393
2394                 //pid = fork ();
2395                 /*
2396                  * glibc fork acquires some locks, so if the crash happened inside malloc/free,
2397                  * it will deadlock. Call the syscall directly instead.
2398                  */
2399                 pid = mono_runtime_syscall_fork ();
2400 #if defined (HAVE_PRCTL) && defined(PR_SET_PTRACER)
2401                 if (pid > 0) {
2402                         // Allow gdb to attach to the process even if ptrace_scope sysctl variable is set to
2403                         // a value other than 0 (the most permissive ptrace scope). Most modern Linux
2404                         // distributions set the scope to 1 which allows attaching only to direct children of
2405                         // the current process
2406                         prctl (PR_SET_PTRACER, pid, 0, 0, 0);
2407                 }
2408 #endif
2409                 if (pid == 0) {
2410                         dup2 (STDERR_FILENO, STDOUT_FILENO);
2411
2412                         mono_gdb_render_native_backtraces (crashed_pid);
2413                         exit (1);
2414                 }
2415
2416                 mono_runtime_printf_err ("\nDebug info from gdb:\n");
2417                 waitpid (pid, &status, 0);
2418         }
2419 #endif
2420  }
2421 #else
2422         mono_exception_native_unwind (ctx, info);
2423 #endif
2424
2425         /*
2426          * A SIGSEGV indicates something went very wrong so we can no longer depend
2427          * on anything working. So try to print out lots of diagnostics, starting
2428          * with ones which have a greater chance of working.
2429          */
2430         mono_runtime_printf_err (
2431                          "\n"
2432                          "=================================================================\n"
2433                          "Got a %s while executing native code. This usually indicates\n"
2434                          "a fatal error in the mono runtime or one of the native libraries \n"
2435                          "used by your application.\n"
2436                          "=================================================================\n",
2437                         signal_str);
2438
2439
2440 #ifdef MONO_ARCH_USE_SIGACTION
2441
2442         /* Remove our SIGABRT handler */
2443         sa.sa_handler = SIG_DFL;
2444         sigemptyset (&sa.sa_mask);
2445         sa.sa_flags = 0;
2446
2447         g_assert (sigaction (SIGABRT, &sa, NULL) != -1);
2448
2449 #endif
2450
2451         if (!mono_do_crash_chaining) {
2452                 /*Android abort is a fluke, it doesn't abort, it triggers another segv. */
2453 #if defined (PLATFORM_ANDROID)
2454                 exit (-1);
2455 #else
2456                 abort ();
2457 #endif
2458         }
2459 }
2460
2461 #else
2462
2463 void
2464 mono_handle_native_sigsegv (int signal, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *info)
2465 {
2466         g_assert_not_reached ();
2467 }
2468
2469 #endif /* !MONO_CROSS_COMPILE */
2470
2471 static void
2472 mono_print_thread_dump_internal (void *sigctx, MonoContext *start_ctx)
2473 {
2474         MonoInternalThread *thread = mono_thread_internal_current ();
2475 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2476         MonoContext ctx;
2477 #endif
2478         GString* text;
2479         char *name;
2480 #ifndef HOST_WIN32
2481         char *wapi_desc;
2482 #endif
2483         GError *error = NULL;
2484
2485         if (!thread)
2486                 return;
2487
2488         text = g_string_new (0);
2489         if (thread->name) {
2490                 name = g_utf16_to_utf8 (thread->name, thread->name_len, NULL, NULL, &error);
2491                 g_assert (!error);
2492                 g_string_append_printf (text, "\n\"%s\"", name);
2493                 g_free (name);
2494         }
2495         else if (thread->threadpool_thread)
2496                 g_string_append (text, "\n\"<threadpool thread>\"");
2497         else
2498                 g_string_append (text, "\n\"<unnamed thread>\"");
2499
2500 #ifndef HOST_WIN32
2501         wapi_desc = wapi_current_thread_desc ();
2502         g_string_append_printf (text, " tid=0x%p this=0x%p %s\n", (gpointer)(gsize)thread->tid, thread,  wapi_desc);
2503         free (wapi_desc);
2504 #endif
2505
2506 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2507         if (start_ctx) {
2508                 memcpy (&ctx, start_ctx, sizeof (MonoContext));
2509         } else if (!sigctx)
2510                 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_print_thread_dump);
2511         else
2512                 mono_sigctx_to_monoctx (sigctx, &ctx);
2513
2514         mono_walk_stack_with_ctx (print_stack_frame_to_string, &ctx, MONO_UNWIND_LOOKUP_ALL, text);
2515 #else
2516         mono_runtime_printf ("\t<Stack traces in thread dumps not supported on this platform>");
2517 #endif
2518
2519         mono_runtime_printf ("%s", text->str);
2520
2521 #if PLATFORM_WIN32 && TARGET_WIN32 && _DEBUG
2522         OutputDebugStringA(text->str);
2523 #endif
2524
2525         g_string_free (text, TRUE);
2526         mono_runtime_stdout_fflush ();
2527 }
2528
2529 /*
2530  * mono_print_thread_dump:
2531  *
2532  *   Print information about the current thread to stdout.
2533  * SIGCTX can be NULL, allowing this to be called from gdb.
2534  */
2535 void
2536 mono_print_thread_dump (void *sigctx)
2537 {
2538         mono_print_thread_dump_internal (sigctx, NULL);
2539 }
2540
2541 void
2542 mono_print_thread_dump_from_ctx (MonoContext *ctx)
2543 {
2544         mono_print_thread_dump_internal (NULL, ctx);
2545 }
2546
2547 /*
2548  * mono_resume_unwind:
2549  *
2550  *   This is called by a trampoline from LLVM compiled finally clauses to continue
2551  * unwinding.
2552  */
2553 void
2554 mono_resume_unwind (MonoContext *ctx)
2555 {
2556         MONO_REQ_GC_UNSAFE_MODE;
2557
2558         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2559         MonoContext new_ctx;
2560
2561         MONO_CONTEXT_SET_IP (ctx, MONO_CONTEXT_GET_IP (&jit_tls->resume_state.ctx));
2562         MONO_CONTEXT_SET_SP (ctx, MONO_CONTEXT_GET_SP (&jit_tls->resume_state.ctx));
2563         new_ctx = *ctx;
2564
2565         mono_handle_exception_internal (&new_ctx, (MonoObject *)jit_tls->resume_state.ex_obj, TRUE, NULL);
2566
2567         mono_restore_context (&new_ctx);
2568 }
2569
2570 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
2571
2572 typedef struct {
2573         MonoJitInfo *ji;
2574         MonoContext ctx;
2575         MonoJitExceptionInfo *ei;
2576 } FindHandlerBlockData;
2577
2578 static gboolean
2579 find_last_handler_block (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2580 {
2581         int i;
2582         gpointer ip;
2583         FindHandlerBlockData *pdata = (FindHandlerBlockData *)data;
2584         MonoJitInfo *ji = frame->ji;
2585
2586         if (!ji)
2587                 return FALSE;
2588
2589         ip = MONO_CONTEXT_GET_IP (ctx);
2590
2591         for (i = 0; i < ji->num_clauses; ++i) {
2592                 MonoJitExceptionInfo *ei = ji->clauses + i;
2593                 if (ei->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2594                         continue;
2595                 /*If ip points to the first instruction it means the handler block didn't start
2596                  so we can leave its execution to the EH machinery*/
2597                 if (ei->handler_start < ip && ip < ei->data.handler_end) {
2598                         pdata->ji = ji;
2599                         pdata->ei = ei;
2600                         pdata->ctx = *ctx;
2601                         break;
2602                 }
2603         }
2604         return FALSE;
2605 }
2606
2607
2608 static gpointer
2609 install_handler_block_guard (MonoJitInfo *ji, MonoContext *ctx)
2610 {
2611         int i;
2612         MonoJitExceptionInfo *clause = NULL;
2613         gpointer ip;
2614
2615         ip = MONO_CONTEXT_GET_IP (ctx);
2616
2617         for (i = 0; i < ji->num_clauses; ++i) {
2618                 clause = &ji->clauses [i];
2619                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2620                         continue;
2621                 if (clause->handler_start < ip && clause->data.handler_end > ip)
2622                         break;
2623         }
2624
2625         /*no matching finally */
2626         if (i == ji->num_clauses)
2627                 return NULL;
2628
2629         /*If we stopped on the instruction right before the try, we haven't actually started executing it*/
2630         if (ip == clause->handler_start)
2631                 return NULL;
2632
2633         return mono_arch_install_handler_block_guard (ji, clause, ctx, mono_create_handler_block_trampoline ());
2634 }
2635
2636 /*
2637  * Finds the bottom handler block running and install a block guard if needed.
2638  * FIXME add full-aot support.
2639  */
2640 gboolean
2641 mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
2642 {
2643         FindHandlerBlockData data = { 0 };
2644         MonoJitTlsData *jit_tls = (MonoJitTlsData *)ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS];
2645         gpointer resume_ip;
2646
2647         /* FIXME */
2648         if (mono_aot_only)
2649                 return FALSE;
2650
2651         /* Guard against a null MonoJitTlsData. This can happens if the thread receives the
2652          * interrupt signal before the JIT has time to initialize its TLS data for the given thread.
2653          */
2654         if (!jit_tls || jit_tls->handler_block_return_address)
2655                 return FALSE;
2656
2657         /* Do an async safe stack walk */
2658         mono_thread_info_set_is_async_context (TRUE);
2659         mono_walk_stack_with_state (find_last_handler_block, ctx, MONO_UNWIND_NONE, &data);
2660         mono_thread_info_set_is_async_context (FALSE);
2661
2662         if (!data.ji)
2663                 return FALSE;
2664
2665         memcpy (&jit_tls->handler_block_context, &data.ctx, sizeof (MonoContext));
2666
2667         resume_ip = install_handler_block_guard (data.ji, &data.ctx);
2668         if (resume_ip == NULL)
2669                 return FALSE;
2670
2671         jit_tls->handler_block_return_address = resume_ip;
2672         jit_tls->handler_block = data.ei;
2673
2674         return TRUE;
2675 }
2676
2677 #else
2678 gboolean
2679 mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
2680 {
2681         return FALSE;
2682 }
2683
2684 #endif
2685
2686 void
2687 mono_set_cast_details (MonoClass *from, MonoClass *to)
2688 {
2689         MonoJitTlsData *jit_tls = NULL;
2690
2691         if (mini_get_debug_options ()->better_cast_details) {
2692                 jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2693                 jit_tls->class_cast_from = from;
2694                 jit_tls->class_cast_to = to;
2695         }
2696 }
2697
2698
2699 /*returns false if the thread is not attached*/
2700 gboolean
2701 mono_thread_state_init_from_sigctx (MonoThreadUnwindState *ctx, void *sigctx)
2702 {
2703 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2704         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2705         if (!thread) {
2706                 ctx->valid = FALSE;
2707                 G_BREAKPOINT ();
2708                 return FALSE;
2709         }
2710
2711         if (sigctx) {
2712                 mono_sigctx_to_monoctx (sigctx, &ctx->ctx);
2713
2714                 ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2715                 ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2716                 ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2717         }
2718         else {
2719                 mono_thread_state_init (ctx);
2720         }
2721
2722         if (!ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] || !ctx->unwind_data [MONO_UNWIND_DATA_LMF])
2723                 return FALSE;
2724
2725         ctx->valid = TRUE;
2726         return TRUE;
2727 #else
2728         g_error ("Implement mono_arch_sigctx_to_monoctx for the current target");
2729         return FALSE;
2730 #endif
2731 }
2732
2733 void
2734 mono_thread_state_init (MonoThreadUnwindState *ctx)
2735 {
2736         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2737
2738 #if defined(MONO_CROSS_COMPILE)
2739         ctx->valid = FALSE; //A cross compiler doesn't need to suspend.
2740 #elif MONO_ARCH_HAS_MONO_CONTEXT
2741         MONO_CONTEXT_GET_CURRENT (ctx->ctx);
2742 #else
2743         g_error ("Use a null sigctx requires a working mono-context");
2744 #endif
2745
2746         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2747         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2748         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread ? thread->jit_data : NULL;
2749         ctx->valid = TRUE;
2750 }
2751
2752
2753 gboolean
2754 mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx)
2755 {
2756         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2757         if (!thread) {
2758                 ctx->valid = FALSE;
2759                 return FALSE;
2760         }
2761
2762         ctx->ctx = *mctx;
2763         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2764         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2765         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2766         ctx->valid = TRUE;
2767         return TRUE;
2768 }
2769
2770 /*returns false if the thread is not attached*/
2771 gboolean
2772 mono_thread_state_init_from_current (MonoThreadUnwindState *ctx)
2773 {
2774         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2775         MONO_ARCH_CONTEXT_DEF
2776
2777         mono_arch_flush_register_windows ();
2778
2779         if (!thread || !thread->jit_data) {
2780                 ctx->valid = FALSE;
2781                 return FALSE;
2782         }
2783 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
2784         MONO_INIT_CONTEXT_FROM_CURRENT (&ctx->ctx);
2785 #else
2786         MONO_INIT_CONTEXT_FROM_FUNC (&ctx->ctx, mono_thread_state_init_from_current);
2787 #endif
2788
2789         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2790         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2791         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2792         ctx->valid = TRUE;
2793         return TRUE;
2794 }
2795
2796 static void
2797 mono_raise_exception_with_ctx (MonoException *exc, MonoContext *ctx)
2798 {
2799         mono_handle_exception (ctx, (MonoObject *)exc);
2800         mono_restore_context (ctx);
2801 }
2802
2803 /*FIXME Move all monoctx -> sigctx conversion to signal handlers once all archs support utils/mono-context */
2804 void
2805 mono_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
2806 {
2807 #ifdef MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK
2808         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2809         jit_tls->ex_ctx = *ctx;
2810
2811         mono_arch_setup_async_callback (ctx, async_cb, user_data);
2812 #else
2813         g_error ("This target doesn't support mono_arch_setup_async_callback");
2814 #endif
2815 }
2816
2817 void
2818 mono_install_unhandled_exception_hook (MonoUnhandledExceptionFunc func, gpointer user_data)
2819 {
2820         unhandled_exception_hook = func;
2821         unhandled_exception_hook_data = user_data;
2822 }
2823
2824 void
2825 mono_invoke_unhandled_exception_hook (MonoObject *exc)
2826 {
2827         if (unhandled_exception_hook) {
2828                 unhandled_exception_hook (exc, unhandled_exception_hook_data);
2829         } else {
2830                 MonoObject *other = NULL;
2831                 MonoString *str = mono_object_to_string (exc, &other);
2832                 char *msg = NULL;
2833
2834                 if (str)
2835                         msg = mono_string_to_utf8 (str);
2836                 else if (other) {
2837                         char *original_backtrace = mono_exception_get_managed_backtrace ((MonoException*)exc);
2838                         char *nested_backtrace = mono_exception_get_managed_backtrace ((MonoException*)other);
2839
2840                         msg = g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n",
2841                                 original_backtrace, nested_backtrace);
2842
2843                         g_free (original_backtrace);
2844                         g_free (nested_backtrace);
2845                 } else {
2846                         msg = g_strdup ("Nested exception trying to figure out what went wrong");
2847                 }
2848                 mono_runtime_printf_err ("[ERROR] FATAL UNHANDLED EXCEPTION: %s", msg);
2849                 g_free (msg);
2850 #if defined(HOST_IOS)
2851                 g_assertion_message ("Terminating runtime due to unhandled exception");
2852 #else
2853                 exit (mono_environment_exitcode_get ());
2854 #endif
2855         }
2856
2857         g_assert_not_reached ();
2858 }
2859
2860 /*
2861  * mono_restore_context:
2862  *
2863  *   Call the architecture specific restore context function.
2864  */
2865 void
2866 mono_restore_context (MonoContext *ctx)
2867 {
2868         static void (*restore_context) (MonoContext *);
2869
2870         if (!restore_context)
2871                 restore_context = (void (*)(MonoContext *))mono_get_restore_context ();
2872         restore_context (ctx);
2873         g_assert_not_reached ();
2874 }
2875
2876 /*
2877  * mono_jinfo_get_unwind_info:
2878  *
2879  *   Return the unwind info for JI.
2880  */
2881 guint8*
2882 mono_jinfo_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len)
2883 {
2884         if (ji->from_aot)
2885                 return mono_aot_get_unwind_info (ji, unwind_info_len);
2886         else
2887                 return mono_get_cached_unwind_info (ji->unwind_info, unwind_info_len);
2888 }
2889
2890 int
2891 mono_jinfo_get_epilog_size (MonoJitInfo *ji)
2892 {
2893         MonoArchEHJitInfo *info;
2894
2895         info = mono_jit_info_get_arch_eh_info (ji);
2896         g_assert (info);
2897
2898         return info->epilog_size;
2899 }
2900
2901 /*
2902  * LLVM/Bitcode exception handling.
2903  */
2904
2905 static void
2906 throw_exception (MonoObject *ex, gboolean rethrow)
2907 {
2908         MonoError error;
2909         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
2910         MonoException *mono_ex;
2911
2912         if (!mono_object_isinst_checked (ex, mono_defaults.exception_class, &error)) {
2913                 mono_error_assert_ok (&error);
2914                 mono_ex = mono_get_exception_runtime_wrapped_checked (ex, &error);
2915                 mono_error_assert_ok (&error);
2916         }
2917         else
2918                 mono_ex = (MonoException*)ex;
2919
2920         // Note: Not pinned
2921         jit_tls->thrown_exc = mono_gchandle_new ((MonoObject*)mono_ex, FALSE);
2922
2923         if (!rethrow) {
2924 #ifdef MONO_ARCH_HAVE_UNWIND_BACKTRACE
2925                 GList *l, *ips = NULL;
2926                 GList *trace;
2927
2928                 _Unwind_Backtrace (build_stack_trace, &ips);
2929                 /* The list contains ip-gshared info pairs */
2930                 trace = NULL;
2931                 ips = g_list_reverse (ips);
2932                 for (l = ips; l; l = l->next) {
2933                         trace = g_list_append (trace, l->data);
2934                         trace = g_list_append (trace, NULL);
2935                 }
2936                 MonoArray *ips_arr = mono_glist_to_array (trace, mono_defaults.int_class, &error);
2937                 mono_error_assert_ok (&error);
2938                 MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
2939                 g_list_free (l);
2940                 g_list_free (trace);
2941 #endif
2942         }
2943
2944         mono_llvm_cpp_throw_exception ();
2945 }
2946
2947 void
2948 mono_llvm_throw_exception (MonoObject *ex)
2949 {
2950         throw_exception (ex, FALSE);
2951 }
2952
2953 void
2954 mono_llvm_rethrow_exception (MonoObject *ex)
2955 {
2956         throw_exception (ex, TRUE);
2957 }
2958
2959 void
2960 mono_llvm_raise_exception (MonoException *e)
2961 {
2962         mono_llvm_throw_exception ((MonoObject*)e);
2963 }
2964
2965 void
2966 mono_llvm_throw_corlib_exception (guint32 ex_token_index)
2967 {
2968         guint32 ex_token = MONO_TOKEN_TYPE_DEF | ex_token_index;
2969         MonoException *ex;
2970
2971         ex = mono_exception_from_token (mono_defaults.exception_class->image, ex_token);
2972
2973         mono_llvm_throw_exception ((MonoObject*)ex);
2974 }
2975
2976 /*
2977  * mono_llvm_resume_exception:
2978  *
2979  *   Resume exception propagation.
2980  */
2981 void
2982 mono_llvm_resume_exception (void)
2983 {
2984         mono_llvm_cpp_throw_exception ();
2985 }
2986
2987 /*
2988  * mono_llvm_load_exception:
2989  *
2990  *   Return the currently thrown exception.
2991  */
2992 MonoObject *
2993 mono_llvm_load_exception (void)
2994 {
2995                 MonoError error;
2996         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
2997
2998         MonoException *mono_ex = (MonoException*)mono_gchandle_get_target (jit_tls->thrown_exc);
2999
3000         if (mono_ex->trace_ips) {
3001                 GList *trace_ips = NULL;
3002                 gpointer ip = __builtin_return_address (0);
3003
3004                 size_t upper = mono_array_length (mono_ex->trace_ips);
3005
3006                 for (int i = 0; i < upper; i+= 2) {
3007                         gpointer curr_ip = mono_array_get (mono_ex->trace_ips, gpointer, i);
3008                         gpointer curr_info = mono_array_get (mono_ex->trace_ips, gpointer, i + 1);
3009                         trace_ips = g_list_append (trace_ips, curr_ip);
3010                         trace_ips = g_list_append (trace_ips, curr_info);
3011
3012                         if (ip == curr_ip)
3013                                 break;
3014                 }
3015
3016                 // FIXME: Does this work correctly for rethrows?
3017                 // We may be discarding useful information
3018                 // when this gets GC'ed
3019                 MonoArray *ips_arr = mono_glist_to_array (trace_ips, mono_defaults.int_class, &error);
3020                 mono_error_assert_ok (&error);
3021                 MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
3022                 g_list_free (trace_ips);
3023
3024                 // FIXME:
3025                 //MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
3026         } else {
3027                 MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_array_new_checked (mono_domain_get (), mono_defaults.int_class, 0, &error));
3028                 mono_error_assert_ok (&error);
3029                 MONO_OBJECT_SETREF (mono_ex, stack_trace, mono_array_new_checked (mono_domain_get (), mono_defaults.stack_frame_class, 0, &error));
3030                 mono_error_assert_ok (&error);
3031         }
3032
3033         return &mono_ex->object;
3034 }
3035
3036 /*
3037  * mono_llvm_clear_exception:
3038  *
3039  *   Mark the currently thrown exception as handled.
3040  */
3041 void
3042 mono_llvm_clear_exception (void)
3043 {
3044         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
3045         mono_gchandle_free (jit_tls->thrown_exc);
3046         jit_tls->thrown_exc = 0;
3047
3048         mono_memory_barrier ();
3049 }
3050
3051 /*
3052  * mono_llvm_match_exception:
3053  *
3054  *   Return the innermost clause containing REGION_START-REGION_END which can handle
3055  * the current exception.
3056  */
3057 gint32
3058 mono_llvm_match_exception (MonoJitInfo *jinfo, guint32 region_start, guint32 region_end, gpointer rgctx, MonoObject *this_obj)
3059 {
3060                         MonoError error;
3061         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
3062         MonoObject *exc;
3063         gint32 index = -1;
3064
3065         g_assert (jit_tls->thrown_exc);
3066         exc = mono_gchandle_get_target (jit_tls->thrown_exc);
3067         for (int i = 0; i < jinfo->num_clauses; i++) {
3068                 MonoJitExceptionInfo *ei = &jinfo->clauses [i];
3069                 MonoClass *catch_class;
3070
3071                 if (! (ei->try_offset == region_start && ei->try_offset + ei->try_len == region_end) )
3072                         continue;
3073
3074                 catch_class = ei->data.catch_class;
3075                 if (catch_class->byval_arg.type == MONO_TYPE_VAR || catch_class->byval_arg.type == MONO_TYPE_MVAR || catch_class->byval_arg.type == MONO_TYPE_GENERICINST) {
3076                         MonoGenericContext context;
3077                         MonoType *inflated_type;
3078
3079                         g_assert (rgctx || this_obj);
3080                         context = get_generic_context_from_stack_frame (jinfo, rgctx ? rgctx : this_obj->vtable);
3081                         inflated_type = mono_class_inflate_generic_type_checked (&catch_class->byval_arg, &context, &error);
3082                         mono_error_assert_ok (&error); /* FIXME don't swallow the error */
3083
3084                         catch_class = mono_class_from_mono_type (inflated_type);
3085                         mono_metadata_free_type (inflated_type);
3086                 }
3087
3088                 // FIXME: Handle edge cases handled in get_exception_catch_class
3089                 if (ei->flags == MONO_EXCEPTION_CLAUSE_NONE && mono_object_isinst_checked (exc, catch_class, &error)) {
3090                         index = ei->clause_index;
3091                         break;
3092                 } else
3093                         mono_error_assert_ok (&error);
3094
3095                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
3096                         g_assert_not_reached ();
3097                 }
3098         }
3099
3100         return index;
3101 }
3102
3103 #ifdef ENABLE_LLVM
3104 _Unwind_Reason_Code
3105 mono_debug_personality (int a, _Unwind_Action b,
3106 uint64_t c, struct _Unwind_Exception *d, struct _Unwind_Context *e)
3107 {
3108         g_assert_not_reached ();
3109 }
3110 #else
3111 void
3112 mono_debug_personality (void);
3113
3114 void
3115 mono_debug_personality (void)
3116 {
3117         g_assert_not_reached ();
3118 }
3119 #endif