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