mono/mini/mini-exceptions.c

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