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 (list, o);
1336                                                 }
1337                                         }
1338                                 }
1339                         }
1340
1341                         MONO_OBJECT_SETREF (mono_ex, dynamic_methods, list);
1342                 }
1343         }
1344         g_list_free (*trace_ips);
1345         *trace_ips = NULL;
1346 }
1347
1348 /*
1349  * mono_handle_exception_internal_first_pass:
1350  *
1351  *   The first pass of exception handling. Unwind the stack until a catch clause which can catch
1352  * OBJ is found. Run the index of the filter clause which caught the exception into
1353  * OUT_FILTER_IDX. Return TRUE if the exception is caught, FALSE otherwise.
1354  */
1355 static gboolean
1356 mono_handle_exception_internal_first_pass (MonoContext *ctx, MonoObject *obj, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoJitInfo **out_prev_ji, MonoObject *non_exception)
1357 {
1358         MonoError error;
1359         MonoDomain *domain = mono_domain_get ();
1360         MonoJitInfo *ji = NULL;
1361         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1362         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
1363         MonoLMF *lmf = mono_get_lmf ();
1364         MonoArray *initial_trace_ips = NULL;
1365         GList *trace_ips = NULL;
1366         GSList *dynamic_methods = NULL;
1367         MonoException *mono_ex;
1368         gboolean stack_overflow = FALSE;
1369         MonoContext initial_ctx;
1370         MonoMethod *method;
1371         int frame_count = 0;
1372         gint32 filter_idx;
1373         int i;
1374         MonoObject *ex_obj;
1375
1376         g_assert (ctx != NULL);
1377
1378         if (obj == (MonoObject *)domain->stack_overflow_ex)
1379                 stack_overflow = TRUE;
1380
1381         mono_ex = (MonoException*)obj;
1382         initial_trace_ips = mono_ex->trace_ips;
1383
1384         if (mono_object_isinst_checked (obj, mono_defaults.exception_class, &error)) {
1385                 mono_ex = (MonoException*)obj;
1386                 initial_trace_ips = mono_ex->trace_ips;
1387         } else {
1388                 mono_error_assert_ok (&error);
1389                 mono_ex = NULL;
1390         }
1391
1392         if (!call_filter)
1393                 call_filter = (int (*) (MonoContext *, void *))mono_get_call_filter ();
1394
1395         g_assert (jit_tls->end_of_stack);
1396         g_assert (jit_tls->abort_func);
1397
1398         if (out_filter_idx)
1399                 *out_filter_idx = -1;
1400         if (out_ji)
1401                 *out_ji = NULL;
1402         if (out_prev_ji)
1403                 *out_prev_ji = NULL;
1404         filter_idx = 0;
1405         initial_ctx = *ctx;
1406
1407         while (1) {
1408                 MonoContext new_ctx;
1409                 guint32 free_stack;
1410                 int clause_index_start = 0;
1411                 gboolean unwind_res = TRUE;
1412
1413                 StackFrameInfo frame;
1414
1415                 if (out_prev_ji)
1416                         *out_prev_ji = ji;
1417
1418                 unwind_res = mono_find_jit_info_ext (domain, jit_tls, NULL, ctx, &new_ctx, NULL, &lmf, NULL, &frame);
1419                 if (unwind_res) {
1420                         if (frame.type == FRAME_TYPE_DEBUGGER_INVOKE ||
1421                                         frame.type == FRAME_TYPE_MANAGED_TO_NATIVE ||
1422                                         frame.type == FRAME_TYPE_TRAMPOLINE) {
1423                                 *ctx = new_ctx;
1424                                 continue;
1425                         }
1426                         g_assert (frame.type == FRAME_TYPE_MANAGED);
1427                         ji = frame.ji;
1428                 }
1429
1430                 if (!unwind_res) {
1431                         setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1432                         g_slist_free (dynamic_methods);
1433                         return FALSE;
1434                 }
1435
1436                 frame_count ++;
1437                 method = jinfo_get_method (ji);
1438                 //printf ("M: %s %d.\n", mono_method_full_name (method, TRUE), frame_count);
1439
1440                 if (mini_get_debug_options ()->reverse_pinvoke_exceptions && method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
1441                         g_error ("A native frame was found while unwinding the stack after an exception.\n"
1442                                          "The native frame called the managed method:\n%s\n",
1443                                          mono_method_full_name (method, TRUE));
1444                 }
1445
1446                 if (method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
1447                         /*
1448                          * Avoid overwriting the stack trace if the exception is
1449                          * rethrown. Also avoid giant stack traces during a stack
1450                          * overflow.
1451                          */
1452                         if (!initial_trace_ips && (frame_count < 1000)) {
1453                                 trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
1454                                 trace_ips = g_list_prepend (trace_ips,
1455                                                                                         get_generic_info_from_stack_frame (ji, ctx));
1456                         }
1457                 }
1458
1459                 if (method->dynamic)
1460                         dynamic_methods = g_slist_prepend (dynamic_methods, method);
1461
1462                 if (stack_overflow) {
1463                         if (DOES_STACK_GROWS_UP)
1464                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx));
1465                         else
1466                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (ctx));
1467                 } else {
1468                         free_stack = 0xffffff;
1469                 }
1470
1471                 for (i = clause_index_start; i < ji->num_clauses; i++) {
1472                         MonoJitExceptionInfo *ei = &ji->clauses [i];
1473                         gboolean filtered = FALSE;
1474
1475                         /*
1476                          * During stack overflow, wait till the unwinding frees some stack
1477                          * space before running handlers/finalizers.
1478                          */
1479                         if (free_stack <= (64 * 1024))
1480                                 continue;
1481
1482                         if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx))) {
1483                                 /* catch block */
1484                                 MonoClass *catch_class = get_exception_catch_class (ei, ji, ctx);
1485
1486                                 /*
1487                                  * Have to unwrap RuntimeWrappedExceptions if the
1488                                  * method's assembly doesn't have a RuntimeCompatibilityAttribute.
1489                                  */
1490                                 if (non_exception && !wrap_non_exception_throws (method))
1491                                         ex_obj = non_exception;
1492                                 else
1493                                         ex_obj = obj;
1494
1495                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
1496                                         gboolean is_user_frame = method->wrapper_type == MONO_WRAPPER_NONE || method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD;
1497 #ifndef DISABLE_PERFCOUNTERS
1498                                         mono_perfcounters->exceptions_filters++;
1499 #endif
1500                                         /*
1501                                         Here's the thing, if this is a filter clause done by a wrapper like runtime invoke, we don't want to
1502                                         trim the stackframe since if it returns FALSE we lose information.
1503
1504                                         FIXME Not 100% sure if it's a good idea even with user clauses.
1505                                         */
1506                                         if (is_user_frame)
1507                                                 setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1508
1509 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
1510                                         if (ji->from_llvm)
1511                                                 MONO_CONTEXT_SET_LLVM_EXC_REG (ctx, ex_obj);
1512                                         else
1513                                                 /* Can't pass the ex object in a register yet to filter clauses, because call_filter () might not support it */
1514                                                 *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1515 #else
1516                                         g_assert (!ji->from_llvm);
1517                                         /* store the exception object in bp + ei->exvar_offset */
1518                                         *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1519 #endif
1520
1521 #ifdef MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG
1522                                         /*
1523                                          * Pass the original il clause index to the landing pad so it can
1524                                          * branch to the landing pad associated with the il clause.
1525                                          * This is needed because llvm compiled code assumes that the EH
1526                                          * code always branches to the innermost landing pad.
1527                                          */
1528                                         if (ji->from_llvm)
1529                                                 MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG (ctx, ei->clause_index);
1530 #endif
1531
1532                                         mono_debugger_agent_begin_exception_filter (mono_ex, ctx, &initial_ctx);
1533                                         filtered = call_filter (ctx, ei->data.filter);
1534                                         mono_debugger_agent_end_exception_filter (mono_ex, ctx, &initial_ctx);
1535                                         if (filtered && out_filter_idx)
1536                                                 *out_filter_idx = filter_idx;
1537                                         if (out_ji)
1538                                                 *out_ji = ji;
1539                                         filter_idx ++;
1540
1541                                         if (filtered) {
1542                                                 if (!is_user_frame)
1543                                                         setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1544                                                 g_slist_free (dynamic_methods);
1545                                                 /* mono_debugger_agent_handle_exception () needs this */
1546                                                 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1547                                                 return TRUE;
1548                                         }
1549                                 }
1550
1551                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_NONE && mono_object_isinst_checked (ex_obj, catch_class, &error)) {
1552                                         setup_stack_trace (mono_ex, dynamic_methods, initial_trace_ips, &trace_ips);
1553                                         g_slist_free (dynamic_methods);
1554
1555                                         if (out_ji)
1556                                                 *out_ji = ji;
1557
1558                                         /* mono_debugger_agent_handle_exception () needs this */
1559                                         MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1560                                         return TRUE;
1561                                 }
1562                                 mono_error_cleanup (&error);
1563                         }
1564                 }
1565
1566                 *ctx = new_ctx;
1567         }
1568
1569         g_assert_not_reached ();
1570 }
1571
1572 /**
1573  * mono_handle_exception_internal:
1574  * @ctx: saved processor state
1575  * @obj: the exception object
1576  * @resume: whenever to resume unwinding based on the state in MonoJitTlsData.
1577  */
1578 static gboolean
1579 mono_handle_exception_internal (MonoContext *ctx, MonoObject *obj, gboolean resume, MonoJitInfo **out_ji)
1580 {
1581         MonoError error;
1582         MonoDomain *domain = mono_domain_get ();
1583         MonoJitInfo *ji, *prev_ji;
1584         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1585         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
1586         MonoLMF *lmf = mono_get_lmf ();
1587         MonoException *mono_ex;
1588         gboolean stack_overflow = FALSE;
1589         MonoContext initial_ctx;
1590         MonoMethod *method;
1591         int frame_count = 0;
1592         gint32 filter_idx, first_filter_idx = 0;
1593         int i;
1594         MonoObject *ex_obj;
1595         MonoObject *non_exception = NULL;
1596
1597         g_assert (ctx != NULL);
1598         if (!obj) {
1599                 MonoException *ex = mono_get_exception_null_reference ();
1600                 MONO_OBJECT_SETREF (ex, message, mono_string_new (domain, "Object reference not set to an instance of an object"));
1601                 obj = (MonoObject *)ex;
1602         }
1603
1604         /*
1605          * Allocate a new exception object instead of the preconstructed ones.
1606          */
1607         if (obj == (MonoObject *)domain->stack_overflow_ex) {
1608                 /*
1609                  * It is not a good idea to try and put even more pressure on the little stack available.
1610                  * obj = mono_get_exception_stack_overflow ();
1611                  */
1612                 stack_overflow = TRUE;
1613         }
1614         else if (obj == (MonoObject *)domain->null_reference_ex) {
1615                 obj = (MonoObject *)mono_get_exception_null_reference ();
1616         }
1617
1618         if (!mono_object_isinst_checked (obj, mono_defaults.exception_class, &error)) {
1619                 mono_error_assert_ok (&error);
1620                 non_exception = obj;
1621                 obj = (MonoObject *)mono_get_exception_runtime_wrapped_checked (obj, &error);
1622                 mono_error_assert_ok (&error);
1623         }
1624
1625         mono_ex = (MonoException*)obj;
1626
1627         if (mini_get_debug_options ()->suspend_on_exception) {
1628                 mono_runtime_printf_err ("Exception thrown, suspending...");
1629                 while (1)
1630                         ;
1631         }
1632
1633         if (mono_object_isinst_checked (obj, mono_defaults.exception_class, &error)) {
1634                 mono_ex = (MonoException*)obj;
1635         } else {
1636                 mono_error_assert_ok (&error);
1637                 mono_ex = NULL;
1638         }
1639
1640         if (mono_ex && jit_tls->class_cast_from) {
1641                 if (!strcmp (mono_ex->object.vtable->klass->name, "InvalidCastException")) {
1642                         char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
1643                         char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
1644                         char *msg = g_strdup_printf ("Unable to cast object of type '%s' to type '%s'.", from_name, to_name);
1645                         mono_ex->message = mono_string_new (domain, msg);
1646                         g_free (from_name);
1647                         g_free (to_name);
1648                         g_free (msg);
1649                 }
1650                 if (!strcmp (mono_ex->object.vtable->klass->name, "ArrayTypeMismatchException")) {
1651                         char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
1652                         char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
1653                         char *msg = g_strdup_printf ("Source array of type '%s' cannot be cast to destination array type '%s'.", from_name, to_name);
1654                         mono_ex->message = mono_string_new (domain, msg);
1655                         g_free (from_name);
1656                         g_free (to_name);
1657                         g_free (msg);
1658                 }
1659         }
1660
1661         if (!call_filter)
1662                 call_filter = (int (*)(MonoContext *, void*))mono_get_call_filter ();
1663
1664         g_assert (jit_tls->end_of_stack);
1665         g_assert (jit_tls->abort_func);
1666
1667         /*
1668          * We set orig_ex_ctx_set to TRUE/FALSE around profiler calls to make sure it doesn't
1669          * end up being TRUE on any code path.
1670          */
1671         memcpy (&jit_tls->orig_ex_ctx, ctx, sizeof (MonoContext));
1672
1673         if (!resume) {
1674                 gboolean res;
1675
1676                 MonoContext ctx_cp = *ctx;
1677                 if (mono_trace_is_enabled ()) {
1678                         MonoMethod *system_exception_get_message = mono_class_get_method_from_name (mono_defaults.exception_class, "get_Message", 0);
1679                         MonoMethod *get_message = system_exception_get_message == NULL ? NULL : mono_object_get_virtual_method (obj, system_exception_get_message);
1680                         MonoObject *message;
1681                         const char *type_name = mono_class_get_name (mono_object_class (mono_ex));
1682                         char *msg = NULL;
1683                         if (get_message == NULL) {
1684                                 message = NULL;
1685                         } else if (!strcmp (type_name, "OutOfMemoryException") || !strcmp (type_name, "StackOverflowException")) {
1686                                 message = NULL;
1687                                 msg = g_strdup_printf ("(No exception message for: %s)\n", type_name);
1688                         } else {
1689                                 MonoObject *exc = NULL;
1690                                 message = mono_runtime_try_invoke (get_message, obj, NULL, &exc, &error);
1691                                 g_assert (exc == NULL);
1692                                 mono_error_assert_ok (&error);
1693                         }
1694                         if (msg == NULL) {
1695                                 msg = message ? mono_string_to_utf8 ((MonoString *) message) : g_strdup ("(System.Exception.Message property not available)");
1696                         }
1697                         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);
1698                         g_free (msg);
1699                         if (mono_ex && mono_trace_eval_exception (mono_object_class (mono_ex)))
1700                                 mono_print_thread_dump_from_ctx (ctx);
1701                 }
1702                 jit_tls->orig_ex_ctx_set = TRUE;
1703                 mono_profiler_exception_thrown (obj);
1704                 jit_tls->orig_ex_ctx_set = FALSE;
1705
1706                 res = mono_handle_exception_internal_first_pass (&ctx_cp, obj, &first_filter_idx, &ji, &prev_ji, non_exception);
1707
1708                 if (!res) {
1709                         if (mini_get_debug_options ()->break_on_exc)
1710                                 G_BREAKPOINT ();
1711                         mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, NULL);
1712
1713                         if (mini_get_debug_options ()->suspend_on_unhandled) {
1714                                 mono_runtime_printf_err ("Unhandled exception, suspending...");
1715                                 while (1)
1716                                         ;
1717                         }
1718
1719                         // FIXME: This runs managed code so it might cause another stack overflow when
1720                         // we are handling a stack overflow
1721                         mono_unhandled_exception (obj);
1722                 } else {
1723                         gboolean unhandled = FALSE;
1724
1725                         /*
1726                          * The exceptions caught by the mono_runtime_invoke_checked () calls
1727                          * in the threadpool needs to be treated as unhandled (#669836).
1728                          *
1729                          * FIXME: The check below is hackish, but its hard to distinguish
1730                          * these runtime invoke calls from others in the runtime.
1731                          */
1732                         if (ji && jinfo_get_method (ji)->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE) {
1733                                 if (prev_ji && jinfo_get_method (prev_ji) == mono_defaults.threadpool_perform_wait_callback_method)
1734                                         unhandled = TRUE;
1735                         }
1736
1737                         if (unhandled)
1738                                 mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, NULL);
1739                         else
1740                                 mono_debugger_agent_handle_exception ((MonoException *)obj, ctx, &ctx_cp);
1741                 }
1742         }
1743
1744         if (out_ji)
1745                 *out_ji = NULL;
1746         filter_idx = 0;
1747         initial_ctx = *ctx;
1748
1749         while (1) {
1750                 MonoContext new_ctx;
1751                 guint32 free_stack;
1752                 int clause_index_start = 0;
1753                 gboolean unwind_res = TRUE;
1754
1755                 if (resume) {
1756                         resume = FALSE;
1757                         ji = jit_tls->resume_state.ji;
1758                         new_ctx = jit_tls->resume_state.new_ctx;
1759                         clause_index_start = jit_tls->resume_state.clause_index;
1760                         lmf = jit_tls->resume_state.lmf;
1761                         first_filter_idx = jit_tls->resume_state.first_filter_idx;
1762                         filter_idx = jit_tls->resume_state.filter_idx;
1763                 } else {
1764                         StackFrameInfo frame;
1765
1766                         unwind_res = mono_find_jit_info_ext (domain, jit_tls, NULL, ctx, &new_ctx, NULL, &lmf, NULL, &frame);
1767                         if (unwind_res) {
1768                                 if (frame.type == FRAME_TYPE_DEBUGGER_INVOKE ||
1769                                                 frame.type == FRAME_TYPE_MANAGED_TO_NATIVE ||
1770                                                 frame.type == FRAME_TYPE_TRAMPOLINE) {
1771                                         *ctx = new_ctx;
1772                                         continue;
1773                                 }
1774                                 g_assert (frame.type == FRAME_TYPE_MANAGED);
1775                                 ji = frame.ji;
1776                         }
1777                 }
1778
1779                 if (!unwind_res) {
1780                         *(mono_get_lmf_addr ()) = lmf;
1781
1782                         jit_tls->abort_func (obj);
1783                         g_assert_not_reached ();
1784                 }
1785
1786                 method = jinfo_get_method (ji);
1787                 frame_count ++;
1788                 //printf ("M: %s %d.\n", mono_method_full_name (method, TRUE), frame_count);
1789
1790                 if (stack_overflow) {
1791                         if (DOES_STACK_GROWS_UP)
1792                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx));
1793                         else
1794                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (ctx));
1795                 } else {
1796                         free_stack = 0xffffff;
1797                 }
1798
1799                 for (i = clause_index_start; i < ji->num_clauses; i++) {
1800                         MonoJitExceptionInfo *ei = &ji->clauses [i];
1801                         gboolean filtered = FALSE;
1802
1803                         /*
1804                          * During stack overflow, wait till the unwinding frees some stack
1805                          * space before running handlers/finalizers.
1806                          */
1807                         if (free_stack <= (64 * 1024))
1808                                 continue;
1809
1810                         if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx))) {
1811                                 /* catch block */
1812                                 MonoClass *catch_class = get_exception_catch_class (ei, ji, ctx);
1813
1814                                 /*
1815                                  * Have to unwrap RuntimeWrappedExceptions if the
1816                                  * method's assembly doesn't have a RuntimeCompatibilityAttribute.
1817                                  */
1818                                 if (non_exception && !wrap_non_exception_throws (method))
1819                                         ex_obj = non_exception;
1820                                 else
1821                                         ex_obj = obj;
1822
1823                                 if (((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) || (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER))) {
1824 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
1825                                         MONO_CONTEXT_SET_LLVM_EXC_REG (ctx, ex_obj);
1826 #else
1827                                         g_assert (!ji->from_llvm);
1828                                         /* store the exception object in bp + ei->exvar_offset */
1829                                         *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = ex_obj;
1830 #endif
1831                                 }
1832
1833 #ifdef MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG
1834                                 if (ji->from_llvm)
1835                                         MONO_CONTEXT_SET_LLVM_EH_SELECTOR_REG (ctx, ei->clause_index);
1836 #endif
1837
1838                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
1839                                         /*
1840                                          * Filter clauses should only be run in the
1841                                          * first pass of exception handling.
1842                                          */
1843                                         filtered = (filter_idx == first_filter_idx);
1844                                         filter_idx ++;
1845                                 }
1846
1847                                 mono_error_init (&error);
1848                                 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
1849                                      mono_object_isinst_checked (ex_obj, catch_class, &error)) || filtered) {
1850                                         /*
1851                                          * This guards against the situation that we abort a thread that is executing a finally clause
1852                                          * that was called by the EH machinery. It won't have a guard trampoline installed, so we must
1853                                          * check for this situation here and resume interruption if we are below the guarded block.
1854                                          */
1855                                         if (G_UNLIKELY (jit_tls->handler_block_return_address)) {
1856                                                 gboolean is_outside = FALSE;
1857                                                 gpointer prot_bp = MONO_CONTEXT_GET_BP (&jit_tls->handler_block_context);
1858                                                 gpointer catch_bp = MONO_CONTEXT_GET_BP (ctx);
1859                                                 //FIXME make this stack direction aware
1860                                                 if (catch_bp > prot_bp) {
1861                                                         is_outside = TRUE;
1862                                                 } else if (catch_bp == prot_bp) {
1863                                                         /* Can be either try { try { } catch {} } finally {} or try { try { } finally {} } catch {}
1864                                                          * So we check if the catch handler_start is protected by the guarded handler protected region
1865                                                          *
1866                                                          * Assumptions:
1867                                                          *      If there is an outstanding guarded_block return address, it means the current thread must be aborted.
1868                                                          *      This is the only way to reach out the guarded block as other cases are handled by the trampoline.
1869                                                          *      There aren't any further finally/fault handler blocks down the stack over this exception.
1870                                                          *   This must be ensured by the code that installs the guard trampoline.
1871                                                          */
1872                                                         g_assert (ji == mini_jit_info_table_find (domain, (char *)MONO_CONTEXT_GET_IP (&jit_tls->handler_block_context), NULL));
1873
1874                                                         if (!is_address_protected (ji, jit_tls->handler_block, ei->handler_start)) {
1875                                                                 is_outside = TRUE;
1876                                                         }
1877                                                 }
1878                                                 if (is_outside) {
1879                                                         jit_tls->handler_block_return_address = NULL;
1880                                                         jit_tls->handler_block = NULL;
1881                                                         mono_thread_resume_interruption (); /*We ignore the exception here, it will be raised later*/
1882                                                 }
1883                                         }
1884
1885                                         if (mono_trace_is_enabled () && mono_trace_eval (method))
1886                                                 g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (method, TRUE));
1887                                         jit_tls->orig_ex_ctx_set = TRUE;
1888                                         mono_profiler_exception_clause_handler (method, ei->flags, i);
1889                                         jit_tls->orig_ex_ctx_set = FALSE;
1890                                         MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1891                                         mono_set_lmf (lmf);
1892 #ifndef DISABLE_PERFCOUNTERS
1893                                         mono_perfcounters->exceptions_depth += frame_count;
1894 #endif
1895                                         if (obj == (MonoObject *)domain->stack_overflow_ex)
1896                                                 jit_tls->handling_stack_ovf = FALSE;
1897
1898                                         return 0;
1899                                 }
1900                                 mono_error_cleanup (&error);
1901                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FAULT) {
1902                                         if (mono_trace_is_enabled () && mono_trace_eval (method))
1903                                                 g_print ("EXCEPTION: fault clause %d of %s\n", i, mono_method_full_name (method, TRUE));
1904                                         jit_tls->orig_ex_ctx_set = TRUE;
1905                                         mono_profiler_exception_clause_handler (method, ei->flags, i);
1906                                         jit_tls->orig_ex_ctx_set = FALSE;
1907                                         call_filter (ctx, ei->handler_start);
1908                                 }
1909                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY) {
1910                                         if (mono_trace_is_enabled () && mono_trace_eval (method))
1911                                                 g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (method, TRUE));
1912                                         jit_tls->orig_ex_ctx_set = TRUE;
1913                                         mono_profiler_exception_clause_handler (method, ei->flags, i);
1914                                         jit_tls->orig_ex_ctx_set = FALSE;
1915 #ifndef DISABLE_PERFCOUNTERS
1916                                         mono_perfcounters->exceptions_finallys++;
1917 #endif
1918                                         mono_set_lmf (lmf);
1919                                         if (ji->from_llvm) {
1920                                                 /*
1921                                                  * LLVM compiled finally handlers follow the design
1922                                                  * of the c++ ehabi, i.e. they call a resume function
1923                                                  * at the end instead of returning to the caller.
1924                                                  * So save the exception handling state,
1925                                                  * mono_resume_unwind () will call us again to continue
1926                                                  * the unwinding.
1927                                                  */
1928                                                 jit_tls->resume_state.ex_obj = obj;
1929                                                 jit_tls->resume_state.ji = ji;
1930                                                 jit_tls->resume_state.clause_index = i + 1;
1931                                                 jit_tls->resume_state.ctx = *ctx;
1932                                                 jit_tls->resume_state.new_ctx = new_ctx;
1933                                                 jit_tls->resume_state.lmf = lmf;
1934                                                 jit_tls->resume_state.first_filter_idx = first_filter_idx;
1935                                                 jit_tls->resume_state.filter_idx = filter_idx;
1936                                                 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1937                                                 return 0;
1938                                         } else {
1939                                                 call_filter (ctx, ei->handler_start);
1940                                         }
1941                                 }
1942                         }
1943                 }
1944
1945                 jit_tls->orig_ex_ctx_set = TRUE;
1946                 mono_profiler_exception_method_leave (method);
1947                 jit_tls->orig_ex_ctx_set = FALSE;
1948
1949                 *ctx = new_ctx;
1950         }
1951
1952         g_assert_not_reached ();
1953 }
1954
1955 /**
1956  * mono_debugger_run_finally:
1957  * @start_ctx: saved processor state
1958  *
1959  * This method is called by the Mono Debugger to call all `finally' clauses of the
1960  * current stack frame.  It's used when the user issues a `return' command to make
1961  * the current stack frame return.  After returning from this method, the debugger
1962  * unwinds the stack one frame and gives control back to the user.
1963  *
1964  * NOTE: This method is only used when running inside the Mono Debugger.
1965  */
1966 void
1967 mono_debugger_run_finally (MonoContext *start_ctx)
1968 {
1969         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1970         MonoDomain *domain = mono_domain_get ();
1971         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
1972         MonoLMF *lmf = mono_get_lmf ();
1973         MonoContext ctx, new_ctx;
1974         MonoJitInfo *ji, rji;
1975         int i;
1976
1977         ctx = *start_ctx;
1978
1979         ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, NULL);
1980         if (!ji || ji == (gpointer)-1)
1981                 return;
1982
1983         if (!call_filter)
1984                 call_filter = (int (*)(MonoContext *, void *))mono_get_call_filter ();
1985
1986         for (i = 0; i < ji->num_clauses; i++) {
1987                 MonoJitExceptionInfo *ei = &ji->clauses [i];
1988
1989                 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (&ctx)) &&
1990                     (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
1991                         call_filter (&ctx, ei->handler_start);
1992                 }
1993         }
1994 }
1995
1996 /**
1997  * mono_handle_exception:
1998  * @ctx: saved processor state
1999  * @obj: the exception object
2000  */
2001 gboolean
2002 mono_handle_exception (MonoContext *ctx, MonoObject *obj)
2003 {
2004 #ifndef DISABLE_PERFCOUNTERS
2005         mono_perfcounters->exceptions_thrown++;
2006 #endif
2007
2008         return mono_handle_exception_internal (ctx, obj, FALSE, NULL);
2009 }
2010
2011 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2012
2013 #ifndef MONO_ARCH_USE_SIGACTION
2014 #error "Can't use sigaltstack without sigaction"
2015 #endif
2016
2017 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
2018
2019 void
2020 mono_setup_altstack (MonoJitTlsData *tls)
2021 {
2022         size_t stsize = 0;
2023         stack_t sa;
2024         guint8 *staddr = NULL;
2025
2026         if (mono_running_on_valgrind ())
2027                 return;
2028
2029         mono_thread_info_get_stack_bounds (&staddr, &stsize);
2030
2031         g_assert (staddr);
2032
2033         tls->end_of_stack = staddr + stsize;
2034         tls->stack_size = stsize;
2035
2036         /*g_print ("thread %p, stack_base: %p, stack_size: %d\n", (gpointer)pthread_self (), staddr, stsize);*/
2037
2038         tls->stack_ovf_guard_base = staddr + mono_pagesize ();
2039         tls->stack_ovf_guard_size = ALIGN_TO (8 * 4096, mono_pagesize ());
2040
2041         g_assert ((guint8*)&sa >= (guint8*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size);
2042
2043         if (mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_NONE)) {
2044                 /* mprotect can fail for the main thread stack */
2045                 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);
2046                 g_assert (gaddr == tls->stack_ovf_guard_base);
2047                 tls->stack_ovf_valloced = TRUE;
2048         }
2049
2050         /* Setup an alternate signal stack */
2051         tls->signal_stack = mono_valloc (0, MONO_ARCH_SIGNAL_STACK_SIZE, MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_PRIVATE|MONO_MMAP_ANON);
2052         tls->signal_stack_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2053
2054         g_assert (tls->signal_stack);
2055
2056         sa.ss_sp = tls->signal_stack;
2057         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2058         sa.ss_flags = 0;
2059         g_assert (sigaltstack (&sa, NULL) == 0);
2060
2061         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);
2062 }
2063
2064 void
2065 mono_free_altstack (MonoJitTlsData *tls)
2066 {
2067         stack_t sa;
2068         int err;
2069
2070         sa.ss_sp = tls->signal_stack;
2071         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2072         sa.ss_flags = SS_DISABLE;
2073         err = sigaltstack  (&sa, NULL);
2074         g_assert (err == 0);
2075
2076         if (tls->signal_stack)
2077                 mono_vfree (tls->signal_stack, MONO_ARCH_SIGNAL_STACK_SIZE);
2078         if (tls->stack_ovf_valloced)
2079                 mono_vfree (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size);
2080         else
2081                 mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_READ|MONO_MMAP_WRITE);
2082 }
2083
2084 #else /* !MONO_ARCH_SIGSEGV_ON_ALTSTACK */
2085
2086 void
2087 mono_setup_altstack (MonoJitTlsData *tls)
2088 {
2089 }
2090
2091 void
2092 mono_free_altstack (MonoJitTlsData *tls)
2093 {
2094 }
2095
2096 #endif /* MONO_ARCH_SIGSEGV_ON_ALTSTACK */
2097
2098 static gboolean
2099 try_restore_stack_protection (MonoJitTlsData *jit_tls, int extra_bytes)
2100 {
2101         gint32 unprotect_size = jit_tls->stack_ovf_guard_size;
2102         /* we need to leave some room for throwing the exception */
2103         while (unprotect_size >= 0 && (char*)jit_tls->stack_ovf_guard_base + unprotect_size > ((char*)&unprotect_size - extra_bytes))
2104                 unprotect_size -= mono_pagesize ();
2105         /* at this point we could try and build a new domain->stack_overflow_ex, but only if there
2106          * is sufficient stack
2107          */
2108         //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);
2109         if (unprotect_size)
2110                 mono_mprotect (jit_tls->stack_ovf_guard_base, unprotect_size, MONO_MMAP_NONE);
2111         return unprotect_size == jit_tls->stack_ovf_guard_size;
2112 }
2113
2114 static G_GNUC_UNUSED void
2115 try_more_restore (void)
2116 {
2117         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2118         if (try_restore_stack_protection (jit_tls, 500))
2119                 jit_tls->restore_stack_prot = NULL;
2120 }
2121
2122 static G_GNUC_UNUSED void
2123 restore_stack_protection (void)
2124 {
2125         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2126         MonoException *ex = mono_domain_get ()->stack_overflow_ex;
2127         /* if we can't restore the stack protection, keep a callback installed so
2128          * we'll try to restore as much stack as we can at each return from unmanaged
2129          * code.
2130          */
2131         if (try_restore_stack_protection (jit_tls, 4096))
2132                 jit_tls->restore_stack_prot = NULL;
2133         else
2134                 jit_tls->restore_stack_prot = try_more_restore_tramp;
2135         /* here we also throw a stack overflow exception */
2136         ex->trace_ips = NULL;
2137         ex->stack_trace = NULL;
2138         mono_raise_exception (ex);
2139 }
2140
2141 gpointer
2142 mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
2143 {
2144         void (*func)(void) = (void (*)(void))tramp_data;
2145         func ();
2146         return NULL;
2147 }
2148
2149 gboolean
2150 mono_handle_soft_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, guint8* fault_addr)
2151 {
2152         if (mono_llvm_only)
2153                 return FALSE;
2154
2155         /* we got a stack overflow in the soft-guard pages
2156          * There are two cases:
2157          * 1) managed code caused the overflow: we unprotect the soft-guard page
2158          * and let the arch-specific code trigger the exception handling mechanism
2159          * in the thread stack. The soft-guard pages will be protected again as the stack is unwound.
2160          * 2) unmanaged code caused the overflow: we unprotect the soft-guard page
2161          * and hope we can continue with those enabled, at least until the hard-guard page
2162          * is hit. The alternative to continuing here is to just print a message and abort.
2163          * We may add in the future the code to protect the pages again in the codepath
2164          * when we return from unmanaged to managed code.
2165          */
2166         if (jit_tls->stack_ovf_guard_size && fault_addr >= (guint8*)jit_tls->stack_ovf_guard_base &&
2167                         fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + jit_tls->stack_ovf_guard_size) {
2168                 /* we unprotect the minimum amount we can */
2169                 guint32 guard_size;
2170                 gboolean handled = FALSE;
2171
2172                 guard_size = jit_tls->stack_ovf_guard_size - (mono_pagesize () * SIZEOF_VOID_P / 4);
2173                 while (guard_size && fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + guard_size) {
2174                         guard_size -= mono_pagesize ();
2175                 }
2176                 guard_size = jit_tls->stack_ovf_guard_size - guard_size;
2177                 /*fprintf (stderr, "unprotecting: %d\n", guard_size);*/
2178                 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);
2179 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2180                 if (ji) {
2181                         mono_arch_handle_altstack_exception (ctx, siginfo, fault_addr, TRUE);
2182                         handled = TRUE;
2183                 }
2184 #endif
2185                 if (!handled) {
2186                         /* We print a message: after this even managed stack overflows
2187                          * may crash the runtime
2188                          */
2189                         mono_runtime_printf_err ("Stack overflow in unmanaged: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
2190                         if (!jit_tls->handling_stack_ovf) {
2191                                 jit_tls->restore_stack_prot = restore_stack_protection_tramp;
2192                                 jit_tls->handling_stack_ovf = 1;
2193                         } else {
2194                                 /*fprintf (stderr, "Already handling stack overflow\n");*/
2195                         }
2196                 }
2197                 return TRUE;
2198         }
2199         return FALSE;
2200 }
2201
2202 typedef struct {
2203         MonoMethod *omethod;
2204         int count;
2205 } PrintOverflowUserData;
2206
2207 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2208 static gboolean
2209 print_overflow_stack_frame (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2210 {
2211         MonoMethod *method = NULL;
2212         PrintOverflowUserData *user_data = (PrintOverflowUserData *)data;
2213         gchar *location;
2214
2215         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2216                 method = jinfo_get_method (frame->ji);
2217
2218         if (method) {
2219                 if (user_data->count == 0) {
2220                         /* The first frame is in its prolog, so a line number cannot be computed */
2221                         user_data->count ++;
2222                         return FALSE;
2223                 }
2224
2225                 /* If this is a one method overflow, skip the other instances */
2226                 if (method == user_data->omethod)
2227                         return FALSE;
2228
2229                 location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
2230                 mono_runtime_printf_err ("  %s", location);
2231                 g_free (location);
2232
2233                 if (user_data->count == 1) {
2234                         mono_runtime_printf_err ("  <...>");
2235                         user_data->omethod = method;
2236                 } else {
2237                         user_data->omethod = NULL;
2238                 }
2239
2240                 user_data->count ++;
2241         } else
2242                 mono_runtime_printf_err ("  at <unknown> <0x%05x>", frame->native_offset);
2243
2244         return FALSE;
2245 }
2246 #endif
2247
2248 void
2249 mono_handle_hard_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr)
2250 {
2251 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2252         PrintOverflowUserData ud;
2253         MonoContext mctx;
2254 #endif
2255
2256         /* we don't do much now, but we can warn the user with a useful message */
2257         mono_runtime_printf_err ("Stack overflow: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
2258
2259 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2260         mono_sigctx_to_monoctx (ctx, &mctx);
2261
2262         mono_runtime_printf_err ("Stacktrace:");
2263
2264         memset (&ud, 0, sizeof (ud));
2265
2266         mono_walk_stack_with_ctx (print_overflow_stack_frame, &mctx, MONO_UNWIND_LOOKUP_ACTUAL_METHOD, &ud);
2267 #else
2268         if (ji && !ji->is_trampoline && jinfo_get_method (ji))
2269                 mono_runtime_printf_err ("At %s", mono_method_full_name (jinfo_get_method (ji), TRUE));
2270         else
2271                 mono_runtime_printf_err ("At <unmanaged>.");
2272 #endif
2273
2274         _exit (1);
2275 }
2276
2277 static gboolean
2278 print_stack_frame_to_stderr (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2279 {
2280         MonoMethod *method = NULL;
2281
2282         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2283                 method = jinfo_get_method (frame->ji);
2284
2285         if (method) {
2286                 gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
2287                 mono_runtime_printf_err ("  %s", location);
2288                 g_free (location);
2289         } else
2290                 mono_runtime_printf_err ("  at <unknown> <0x%05x>", frame->native_offset);
2291
2292         return FALSE;
2293 }
2294
2295 static G_GNUC_UNUSED gboolean
2296 print_stack_frame_to_string (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2297 {
2298         GString *p = (GString*)data;
2299         MonoMethod *method = NULL;
2300
2301         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2302                 method = jinfo_get_method (frame->ji);
2303
2304         if (method && frame->domain) {
2305                 gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, frame->domain);
2306                 g_string_append_printf (p, "  %s\n", location);
2307                 g_free (location);
2308         } else
2309                 g_string_append_printf (p, "  at <unknown> <0x%05x>\n", frame->native_offset);
2310
2311         return FALSE;
2312 }
2313
2314 #ifndef MONO_CROSS_COMPILE
2315
2316 static gboolean handling_sigsegv = FALSE;
2317
2318 /*
2319  * mono_handle_native_sigsegv:
2320  *
2321  *   Handle a SIGSEGV received while in native code by printing diagnostic
2322  * information and aborting.
2323  */
2324 void
2325 mono_handle_native_sigsegv (int signal, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *info)
2326 {
2327 #ifdef MONO_ARCH_USE_SIGACTION
2328         struct sigaction sa;
2329 #endif
2330         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2331         const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
2332
2333         if (handling_sigsegv)
2334                 return;
2335
2336         if (mini_get_debug_options ()->suspend_on_sigsegv) {
2337                 mono_runtime_printf_err ("Received SIGSEGV, suspending...");
2338 #ifdef HOST_WIN32
2339                 while (1)
2340                         ;
2341 #else
2342                 while (1) {
2343                         sleep (1);
2344                 }
2345 #endif
2346         }
2347
2348         /* To prevent infinite loops when the stack walk causes a crash */
2349         handling_sigsegv = TRUE;
2350
2351         /* !jit_tls means the thread was not registered with the runtime */
2352         if (jit_tls && mono_thread_internal_current ()) {
2353                 mono_runtime_printf_err ("Stacktrace:\n");
2354
2355                 /* FIXME: Is MONO_UNWIND_LOOKUP_IL_OFFSET correct here? */
2356                 mono_walk_stack (print_stack_frame_to_stderr, MONO_UNWIND_LOOKUP_IL_OFFSET, NULL);
2357         }
2358
2359 #ifdef HAVE_BACKTRACE_SYMBOLS
2360  {
2361         void *array [256];
2362         char **names;
2363         int i, size;
2364
2365         mono_runtime_printf_err ("\nNative stacktrace:\n");
2366
2367         size = backtrace (array, 256);
2368         names = backtrace_symbols (array, size);
2369         for (i =0; i < size; ++i) {
2370                 mono_runtime_printf_err ("\t%s", names [i]);
2371         }
2372         free (names);
2373
2374         /* Try to get more meaningful information using gdb */
2375
2376 #if !defined(HOST_WIN32) && defined(HAVE_SYS_SYSCALL_H) && defined(SYS_fork)
2377         if (!mini_get_debug_options ()->no_gdb_backtrace) {
2378                 /* From g_spawn_command_line_sync () in eglib */
2379                 pid_t pid;
2380                 int status;
2381                 pid_t crashed_pid = getpid ();
2382
2383                 //pid = fork ();
2384                 /*
2385                  * glibc fork acquires some locks, so if the crash happened inside malloc/free,
2386                  * it will deadlock. Call the syscall directly instead.
2387                  */
2388                 pid = mono_runtime_syscall_fork ();
2389 #if defined (HAVE_PRCTL) && defined(PR_SET_PTRACER)
2390                 if (pid > 0) {
2391                         // Allow gdb to attach to the process even if ptrace_scope sysctl variable is set to
2392                         // a value other than 0 (the most permissive ptrace scope). Most modern Linux
2393                         // distributions set the scope to 1 which allows attaching only to direct children of
2394                         // the current process
2395                         prctl (PR_SET_PTRACER, pid, 0, 0, 0);
2396                 }
2397 #endif
2398                 if (pid == 0) {
2399                         dup2 (STDERR_FILENO, STDOUT_FILENO);
2400
2401                         mono_gdb_render_native_backtraces (crashed_pid);
2402                         exit (1);
2403                 }
2404
2405                 mono_runtime_printf_err ("\nDebug info from gdb:\n");
2406                 waitpid (pid, &status, 0);
2407         }
2408 #endif
2409  }
2410 #else
2411         mono_exception_native_unwind (ctx, info);
2412 #endif
2413
2414         /*
2415          * A SIGSEGV indicates something went very wrong so we can no longer depend
2416          * on anything working. So try to print out lots of diagnostics, starting
2417          * with ones which have a greater chance of working.
2418          */
2419         mono_runtime_printf_err (
2420                          "\n"
2421                          "=================================================================\n"
2422                          "Got a %s while executing native code. This usually indicates\n"
2423                          "a fatal error in the mono runtime or one of the native libraries \n"
2424                          "used by your application.\n"
2425                          "=================================================================\n",
2426                         signal_str);
2427
2428
2429 #ifdef MONO_ARCH_USE_SIGACTION
2430
2431         /* Remove our SIGABRT handler */
2432         sa.sa_handler = SIG_DFL;
2433         sigemptyset (&sa.sa_mask);
2434         sa.sa_flags = 0;
2435
2436         g_assert (sigaction (SIGABRT, &sa, NULL) != -1);
2437
2438 #endif
2439
2440         if (!mono_do_crash_chaining) {
2441                 /*Android abort is a fluke, it doesn't abort, it triggers another segv. */
2442 #if defined (PLATFORM_ANDROID)
2443                 exit (-1);
2444 #else
2445                 abort ();
2446 #endif
2447         }
2448 }
2449
2450 #else
2451
2452 void
2453 mono_handle_native_sigsegv (int signal, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *info)
2454 {
2455         g_assert_not_reached ();
2456 }
2457
2458 #endif /* !MONO_CROSS_COMPILE */
2459
2460 static void
2461 mono_print_thread_dump_internal (void *sigctx, MonoContext *start_ctx)
2462 {
2463         MonoInternalThread *thread = mono_thread_internal_current ();
2464 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2465         MonoContext ctx;
2466 #endif
2467         GString* text;
2468         char *name;
2469 #ifndef HOST_WIN32
2470         char *wapi_desc;
2471 #endif
2472         GError *error = NULL;
2473
2474         if (!thread)
2475                 return;
2476
2477         text = g_string_new (0);
2478         if (thread->name) {
2479                 name = g_utf16_to_utf8 (thread->name, thread->name_len, NULL, NULL, &error);
2480                 g_assert (!error);
2481                 g_string_append_printf (text, "\n\"%s\"", name);
2482                 g_free (name);
2483         }
2484         else if (thread->threadpool_thread)
2485                 g_string_append (text, "\n\"<threadpool thread>\"");
2486         else
2487                 g_string_append (text, "\n\"<unnamed thread>\"");
2488
2489 #ifndef HOST_WIN32
2490         wapi_desc = wapi_current_thread_desc ();
2491         g_string_append_printf (text, " tid=0x%p this=0x%p %s\n", (gpointer)(gsize)thread->tid, thread,  wapi_desc);
2492         free (wapi_desc);
2493 #endif
2494
2495 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2496         if (start_ctx) {
2497                 memcpy (&ctx, start_ctx, sizeof (MonoContext));
2498         } else if (!sigctx)
2499                 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_print_thread_dump);
2500         else
2501                 mono_sigctx_to_monoctx (sigctx, &ctx);
2502
2503         mono_walk_stack_with_ctx (print_stack_frame_to_string, &ctx, MONO_UNWIND_LOOKUP_ALL, text);
2504 #else
2505         mono_runtime_printf ("\t<Stack traces in thread dumps not supported on this platform>");
2506 #endif
2507
2508         mono_runtime_printf ("%s", text->str);
2509
2510 #if PLATFORM_WIN32 && TARGET_WIN32 && _DEBUG
2511         OutputDebugStringA(text->str);
2512 #endif
2513
2514         g_string_free (text, TRUE);
2515         mono_runtime_stdout_fflush ();
2516 }
2517
2518 /*
2519  * mono_print_thread_dump:
2520  *
2521  *   Print information about the current thread to stdout.
2522  * SIGCTX can be NULL, allowing this to be called from gdb.
2523  */
2524 void
2525 mono_print_thread_dump (void *sigctx)
2526 {
2527         mono_print_thread_dump_internal (sigctx, NULL);
2528 }
2529
2530 void
2531 mono_print_thread_dump_from_ctx (MonoContext *ctx)
2532 {
2533         mono_print_thread_dump_internal (NULL, ctx);
2534 }
2535
2536 /*
2537  * mono_resume_unwind:
2538  *
2539  *   This is called by a trampoline from LLVM compiled finally clauses to continue
2540  * unwinding.
2541  */
2542 void
2543 mono_resume_unwind (MonoContext *ctx)
2544 {
2545         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2546         MonoContext new_ctx;
2547
2548         MONO_CONTEXT_SET_IP (ctx, MONO_CONTEXT_GET_IP (&jit_tls->resume_state.ctx));
2549         MONO_CONTEXT_SET_SP (ctx, MONO_CONTEXT_GET_SP (&jit_tls->resume_state.ctx));
2550         new_ctx = *ctx;
2551
2552         mono_handle_exception_internal (&new_ctx, (MonoObject *)jit_tls->resume_state.ex_obj, TRUE, NULL);
2553
2554         mono_restore_context (&new_ctx);
2555 }
2556
2557 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
2558
2559 typedef struct {
2560         MonoJitInfo *ji;
2561         MonoContext ctx;
2562         MonoJitExceptionInfo *ei;
2563 } FindHandlerBlockData;
2564
2565 static gboolean
2566 find_last_handler_block (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2567 {
2568         int i;
2569         gpointer ip;
2570         FindHandlerBlockData *pdata = (FindHandlerBlockData *)data;
2571         MonoJitInfo *ji = frame->ji;
2572
2573         if (!ji)
2574                 return FALSE;
2575
2576         ip = MONO_CONTEXT_GET_IP (ctx);
2577
2578         for (i = 0; i < ji->num_clauses; ++i) {
2579                 MonoJitExceptionInfo *ei = ji->clauses + i;
2580                 if (ei->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2581                         continue;
2582                 /*If ip points to the first instruction it means the handler block didn't start
2583                  so we can leave its execution to the EH machinery*/
2584                 if (ei->handler_start < ip && ip < ei->data.handler_end) {
2585                         pdata->ji = ji;
2586                         pdata->ei = ei;
2587                         pdata->ctx = *ctx;
2588                         break;
2589                 }
2590         }
2591         return FALSE;
2592 }
2593
2594
2595 static gpointer
2596 install_handler_block_guard (MonoJitInfo *ji, MonoContext *ctx)
2597 {
2598         int i;
2599         MonoJitExceptionInfo *clause = NULL;
2600         gpointer ip;
2601
2602         ip = MONO_CONTEXT_GET_IP (ctx);
2603
2604         for (i = 0; i < ji->num_clauses; ++i) {
2605                 clause = &ji->clauses [i];
2606                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2607                         continue;
2608                 if (clause->handler_start < ip && clause->data.handler_end > ip)
2609                         break;
2610         }
2611
2612         /*no matching finally */
2613         if (i == ji->num_clauses)
2614                 return NULL;
2615
2616         /*If we stopped on the instruction right before the try, we haven't actually started executing it*/
2617         if (ip == clause->handler_start)
2618                 return NULL;
2619
2620         return mono_arch_install_handler_block_guard (ji, clause, ctx, mono_create_handler_block_trampoline ());
2621 }
2622
2623 /*
2624  * Finds the bottom handler block running and install a block guard if needed.
2625  * FIXME add full-aot support.
2626  */
2627 gboolean
2628 mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
2629 {
2630         FindHandlerBlockData data = { 0 };
2631         MonoJitTlsData *jit_tls = (MonoJitTlsData *)ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS];
2632         gpointer resume_ip;
2633
2634         /* FIXME */
2635         if (mono_aot_only)
2636                 return FALSE;
2637
2638         /* Guard against a null MonoJitTlsData. This can happens if the thread receives the
2639          * interrupt signal before the JIT has time to initialize its TLS data for the given thread.
2640          */
2641         if (!jit_tls || jit_tls->handler_block_return_address)
2642                 return FALSE;
2643
2644         /* Do an async safe stack walk */
2645         mono_thread_info_set_is_async_context (TRUE);
2646         mono_walk_stack_with_state (find_last_handler_block, ctx, MONO_UNWIND_NONE, &data);
2647         mono_thread_info_set_is_async_context (FALSE);
2648
2649         if (!data.ji)
2650                 return FALSE;
2651
2652         memcpy (&jit_tls->handler_block_context, &data.ctx, sizeof (MonoContext));
2653
2654         resume_ip = install_handler_block_guard (data.ji, &data.ctx);
2655         if (resume_ip == NULL)
2656                 return FALSE;
2657
2658         jit_tls->handler_block_return_address = resume_ip;
2659         jit_tls->handler_block = data.ei;
2660
2661         return TRUE;
2662 }
2663
2664 #else
2665 gboolean
2666 mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
2667 {
2668         return FALSE;
2669 }
2670
2671 #endif
2672
2673 void
2674 mono_set_cast_details (MonoClass *from, MonoClass *to)
2675 {
2676         MonoJitTlsData *jit_tls = NULL;
2677
2678         if (mini_get_debug_options ()->better_cast_details) {
2679                 jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2680                 jit_tls->class_cast_from = from;
2681                 jit_tls->class_cast_to = to;
2682         }
2683 }
2684
2685
2686 /*returns false if the thread is not attached*/
2687 gboolean
2688 mono_thread_state_init_from_sigctx (MonoThreadUnwindState *ctx, void *sigctx)
2689 {
2690 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2691         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2692         if (!thread) {
2693                 ctx->valid = FALSE;
2694                 G_BREAKPOINT ();
2695                 return FALSE;
2696         }
2697
2698         if (sigctx) {
2699                 mono_sigctx_to_monoctx (sigctx, &ctx->ctx);
2700
2701                 ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2702                 ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2703                 ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2704         }
2705         else {
2706                 mono_thread_state_init (ctx);
2707         }
2708
2709         if (!ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] || !ctx->unwind_data [MONO_UNWIND_DATA_LMF])
2710                 return FALSE;
2711
2712         ctx->valid = TRUE;
2713         return TRUE;
2714 #else
2715         g_error ("Implement mono_arch_sigctx_to_monoctx for the current target");
2716         return FALSE;
2717 #endif
2718 }
2719
2720 void
2721 mono_thread_state_init (MonoThreadUnwindState *ctx)
2722 {
2723         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2724
2725 #if defined(MONO_CROSS_COMPILE)
2726         ctx->valid = FALSE; //A cross compiler doesn't need to suspend.
2727 #elif MONO_ARCH_HAS_MONO_CONTEXT
2728         MONO_CONTEXT_GET_CURRENT (ctx->ctx);
2729 #else
2730         g_error ("Use a null sigctx requires a working mono-context");
2731 #endif
2732
2733         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2734         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2735         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread ? thread->jit_data : NULL;
2736         ctx->valid = TRUE;
2737 }
2738
2739
2740 gboolean
2741 mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx)
2742 {
2743         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2744         if (!thread) {
2745                 ctx->valid = FALSE;
2746                 return FALSE;
2747         }
2748
2749         ctx->ctx = *mctx;
2750         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2751         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2752         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2753         ctx->valid = TRUE;
2754         return TRUE;
2755 }
2756
2757 /*returns false if the thread is not attached*/
2758 gboolean
2759 mono_thread_state_init_from_current (MonoThreadUnwindState *ctx)
2760 {
2761         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2762         MONO_ARCH_CONTEXT_DEF
2763
2764         mono_arch_flush_register_windows ();
2765
2766         if (!thread || !thread->jit_data) {
2767                 ctx->valid = FALSE;
2768                 return FALSE;
2769         }
2770 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
2771         MONO_INIT_CONTEXT_FROM_CURRENT (&ctx->ctx);
2772 #else
2773         MONO_INIT_CONTEXT_FROM_FUNC (&ctx->ctx, mono_thread_state_init_from_current);
2774 #endif
2775
2776         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2777         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2778         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2779         ctx->valid = TRUE;
2780         return TRUE;
2781 }
2782
2783 static void
2784 mono_raise_exception_with_ctx (MonoException *exc, MonoContext *ctx)
2785 {
2786         mono_handle_exception (ctx, (MonoObject *)exc);
2787         mono_restore_context (ctx);
2788 }
2789
2790 /*FIXME Move all monoctx -> sigctx conversion to signal handlers once all archs support utils/mono-context */
2791 void
2792 mono_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
2793 {
2794 #ifdef MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK
2795         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2796         jit_tls->ex_ctx = *ctx;
2797
2798         mono_arch_setup_async_callback (ctx, async_cb, user_data);
2799 #else
2800         g_error ("This target doesn't support mono_arch_setup_async_callback");
2801 #endif
2802 }
2803
2804 void
2805 mono_install_unhandled_exception_hook (MonoUnhandledExceptionFunc func, gpointer user_data)
2806 {
2807         unhandled_exception_hook = func;
2808         unhandled_exception_hook_data = user_data;
2809 }
2810
2811 void
2812 mono_invoke_unhandled_exception_hook (MonoObject *exc)
2813 {
2814         if (unhandled_exception_hook) {
2815                 unhandled_exception_hook (exc, unhandled_exception_hook_data);
2816         } else {
2817                 MonoObject *other = NULL;
2818                 MonoString *str = mono_object_to_string (exc, &other);
2819                 char *msg = NULL;
2820
2821                 if (str)
2822                         msg = mono_string_to_utf8 (str);
2823                 else if (other) {
2824                         char *original_backtrace = mono_exception_get_managed_backtrace ((MonoException*)exc);
2825                         char *nested_backtrace = mono_exception_get_managed_backtrace ((MonoException*)other);
2826
2827                         msg = g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n",
2828                                 original_backtrace, nested_backtrace);
2829
2830                         g_free (original_backtrace);
2831                         g_free (nested_backtrace);
2832                 } else {
2833                         msg = g_strdup ("Nested exception trying to figure out what went wrong");
2834                 }
2835                 mono_runtime_printf_err ("[ERROR] FATAL UNHANDLED EXCEPTION: %s", msg);
2836                 g_free (msg);
2837 #if defined(HOST_IOS)
2838                 g_assertion_message ("Terminating runtime due to unhandled exception");
2839 #else
2840                 exit (mono_environment_exitcode_get ());
2841 #endif
2842         }
2843
2844         g_assert_not_reached ();
2845 }
2846
2847 /*
2848  * mono_restore_context:
2849  *
2850  *   Call the architecture specific restore context function.
2851  */
2852 void
2853 mono_restore_context (MonoContext *ctx)
2854 {
2855         static void (*restore_context) (MonoContext *);
2856
2857         if (!restore_context)
2858                 restore_context = (void (*)(MonoContext *))mono_get_restore_context ();
2859         restore_context (ctx);
2860         g_assert_not_reached ();
2861 }
2862
2863 /*
2864  * mono_jinfo_get_unwind_info:
2865  *
2866  *   Return the unwind info for JI.
2867  */
2868 guint8*
2869 mono_jinfo_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len)
2870 {
2871         if (ji->from_aot)
2872                 return mono_aot_get_unwind_info (ji, unwind_info_len);
2873         else
2874                 return mono_get_cached_unwind_info (ji->unwind_info, unwind_info_len);
2875 }
2876
2877 int
2878 mono_jinfo_get_epilog_size (MonoJitInfo *ji)
2879 {
2880         MonoArchEHJitInfo *info;
2881
2882         info = mono_jit_info_get_arch_eh_info (ji);
2883         g_assert (info);
2884
2885         return info->epilog_size;
2886 }
2887
2888 /*
2889  * LLVM/Bitcode exception handling.
2890  */
2891
2892 static void
2893 throw_exception (MonoObject *ex, gboolean rethrow)
2894 {
2895         MonoError error;
2896         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
2897         MonoException *mono_ex;
2898
2899         if (!mono_object_isinst_checked (ex, mono_defaults.exception_class, &error)) {
2900                 mono_error_assert_ok (&error);
2901                 mono_ex = mono_get_exception_runtime_wrapped_checked (ex, &error);
2902                 mono_error_assert_ok (&error);
2903         }
2904         else
2905                 mono_ex = (MonoException*)ex;
2906
2907         // Note: Not pinned
2908         jit_tls->thrown_exc = mono_gchandle_new ((MonoObject*)mono_ex, FALSE);
2909
2910         if (!rethrow) {
2911 #ifdef MONO_ARCH_HAVE_UNWIND_BACKTRACE
2912                 GList *l, *ips = NULL;
2913                 GList *trace;
2914
2915                 _Unwind_Backtrace (build_stack_trace, &ips);
2916                 /* The list contains ip-gshared info pairs */
2917                 trace = NULL;
2918                 ips = g_list_reverse (ips);
2919                 for (l = ips; l; l = l->next) {
2920                         trace = g_list_append (trace, l->data);
2921                         trace = g_list_append (trace, NULL);
2922                 }
2923                 MonoArray *ips_arr = mono_glist_to_array (trace, mono_defaults.int_class, &error);
2924                 mono_error_assert_ok (&error);
2925                 MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
2926                 g_list_free (l);
2927                 g_list_free (trace);
2928 #endif
2929         }
2930
2931         mono_llvm_cpp_throw_exception ();
2932 }
2933
2934 void
2935 mono_llvm_throw_exception (MonoObject *ex)
2936 {
2937         throw_exception (ex, FALSE);
2938 }
2939
2940 void
2941 mono_llvm_rethrow_exception (MonoObject *ex)
2942 {
2943         throw_exception (ex, TRUE);
2944 }
2945
2946 void
2947 mono_llvm_raise_exception (MonoException *e)
2948 {
2949         mono_llvm_throw_exception ((MonoObject*)e);
2950 }
2951
2952 void
2953 mono_llvm_throw_corlib_exception (guint32 ex_token_index)
2954 {
2955         guint32 ex_token = MONO_TOKEN_TYPE_DEF | ex_token_index;
2956         MonoException *ex;
2957
2958         ex = mono_exception_from_token (mono_defaults.exception_class->image, ex_token);
2959
2960         mono_llvm_throw_exception ((MonoObject*)ex);
2961 }
2962
2963 /*
2964  * mono_llvm_resume_exception:
2965  *
2966  *   Resume exception propagation.
2967  */
2968 void
2969 mono_llvm_resume_exception (void)
2970 {
2971         mono_llvm_cpp_throw_exception ();
2972 }
2973
2974 /*
2975  * mono_llvm_load_exception:
2976  *
2977  *   Return the currently thrown exception.
2978  */
2979 MonoObject *
2980 mono_llvm_load_exception (void)
2981 {
2982                 MonoError error;
2983         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
2984
2985         MonoException *mono_ex = (MonoException*)mono_gchandle_get_target (jit_tls->thrown_exc);
2986
2987         if (mono_ex->trace_ips) {
2988                 GList *trace_ips = NULL;
2989                 gpointer ip = __builtin_return_address (0);
2990
2991                 size_t upper = mono_array_length (mono_ex->trace_ips);
2992
2993                 for (int i = 0; i < upper; i+= 2) {
2994                         gpointer curr_ip = mono_array_get (mono_ex->trace_ips, gpointer, i);
2995                         gpointer curr_info = mono_array_get (mono_ex->trace_ips, gpointer, i + 1);
2996                         trace_ips = g_list_append (trace_ips, curr_ip);
2997                         trace_ips = g_list_append (trace_ips, curr_info);
2998
2999                         if (ip == curr_ip)
3000                                 break;
3001                 }
3002
3003                 // FIXME: Does this work correctly for rethrows?
3004                 // We may be discarding useful information
3005                 // when this gets GC'ed
3006                 MonoArray *ips_arr = mono_glist_to_array (trace_ips, mono_defaults.int_class, &error);
3007                 mono_error_assert_ok (&error);
3008                 MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
3009                 g_list_free (trace_ips);
3010
3011                 // FIXME:
3012                 //MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
3013         } else {
3014                 MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_array_new_checked (mono_domain_get (), mono_defaults.int_class, 0, &error));
3015                 mono_error_assert_ok (&error);
3016                 MONO_OBJECT_SETREF (mono_ex, stack_trace, mono_array_new_checked (mono_domain_get (), mono_defaults.stack_frame_class, 0, &error));
3017                 mono_error_assert_ok (&error);
3018         }
3019
3020         return &mono_ex->object;
3021 }
3022
3023 /*
3024  * mono_llvm_clear_exception:
3025  *
3026  *   Mark the currently thrown exception as handled.
3027  */
3028 void
3029 mono_llvm_clear_exception (void)
3030 {
3031         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
3032         mono_gchandle_free (jit_tls->thrown_exc);
3033         jit_tls->thrown_exc = 0;
3034
3035         mono_memory_barrier ();
3036 }
3037
3038 /*
3039  * mono_llvm_match_exception:
3040  *
3041  *   Return the innermost clause containing REGION_START-REGION_END which can handle
3042  * the current exception.
3043  */
3044 gint32
3045 mono_llvm_match_exception (MonoJitInfo *jinfo, guint32 region_start, guint32 region_end, gpointer rgctx, MonoObject *this_obj)
3046 {
3047                         MonoError error;
3048         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
3049         MonoObject *exc;
3050         gint32 index = -1;
3051
3052         g_assert (jit_tls->thrown_exc);
3053         exc = mono_gchandle_get_target (jit_tls->thrown_exc);
3054         for (int i = 0; i < jinfo->num_clauses; i++) {
3055                 MonoJitExceptionInfo *ei = &jinfo->clauses [i];
3056                 MonoClass *catch_class;
3057
3058                 if (! (ei->try_offset == region_start && ei->try_offset + ei->try_len == region_end) )
3059                         continue;
3060
3061                 catch_class = ei->data.catch_class;
3062                 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) {
3063                         MonoGenericContext context;
3064                         MonoType *inflated_type;
3065
3066                         g_assert (rgctx || this_obj);
3067                         context = get_generic_context_from_stack_frame (jinfo, rgctx ? rgctx : this_obj->vtable);
3068                         inflated_type = mono_class_inflate_generic_type_checked (&catch_class->byval_arg, &context, &error);
3069                         mono_error_assert_ok (&error); /* FIXME don't swallow the error */
3070
3071                         catch_class = mono_class_from_mono_type (inflated_type);
3072                         mono_metadata_free_type (inflated_type);
3073                 }
3074
3075                 // FIXME: Handle edge cases handled in get_exception_catch_class
3076                 if (ei->flags == MONO_EXCEPTION_CLAUSE_NONE && mono_object_isinst_checked (exc, catch_class, &error)) {
3077                         index = ei->clause_index;
3078                         break;
3079                 } else
3080                         mono_error_assert_ok (&error);
3081
3082                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
3083                         g_assert_not_reached ();
3084                 }
3085         }
3086
3087         return index;
3088 }
3089
3090 #ifdef ENABLE_LLVM
3091 _Unwind_Reason_Code
3092 mono_debug_personality (int a, _Unwind_Action b,
3093 uint64_t c, struct _Unwind_Exception *d, struct _Unwind_Context *e)
3094 {
3095         g_assert_not_reached ();
3096 }
3097 #else
3098 void
3099 mono_debug_personality (void);
3100
3101 void
3102 mono_debug_personality (void)
3103 {
3104         g_assert_not_reached ();
3105 }
3106 #endif