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 #ifndef DISABLE_PERFCOUNTERS
2010         mono_perfcounters->exceptions_thrown++;
2011 #endif
2012
2013         return mono_handle_exception_internal (ctx, obj, FALSE, NULL);
2014 }
2015
2016 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2017
2018 #ifndef MONO_ARCH_USE_SIGACTION
2019 #error "Can't use sigaltstack without sigaction"
2020 #endif
2021
2022 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
2023
2024 void
2025 mono_setup_altstack (MonoJitTlsData *tls)
2026 {
2027         size_t stsize = 0;
2028         stack_t sa;
2029         guint8 *staddr = NULL;
2030
2031         if (mono_running_on_valgrind ())
2032                 return;
2033
2034         mono_thread_info_get_stack_bounds (&staddr, &stsize);
2035
2036         g_assert (staddr);
2037
2038         tls->end_of_stack = staddr + stsize;
2039         tls->stack_size = stsize;
2040
2041         /*g_print ("thread %p, stack_base: %p, stack_size: %d\n", (gpointer)pthread_self (), staddr, stsize);*/
2042
2043         tls->stack_ovf_guard_base = staddr + mono_pagesize ();
2044         tls->stack_ovf_guard_size = ALIGN_TO (8 * 4096, mono_pagesize ());
2045
2046         g_assert ((guint8*)&sa >= (guint8*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size);
2047
2048         if (mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_NONE)) {
2049                 /* mprotect can fail for the main thread stack */
2050                 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);
2051                 g_assert (gaddr == tls->stack_ovf_guard_base);
2052                 tls->stack_ovf_valloced = TRUE;
2053         }
2054
2055         /* Setup an alternate signal stack */
2056         tls->signal_stack = mono_valloc (0, MONO_ARCH_SIGNAL_STACK_SIZE, MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_PRIVATE|MONO_MMAP_ANON);
2057         tls->signal_stack_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2058
2059         g_assert (tls->signal_stack);
2060
2061         sa.ss_sp = tls->signal_stack;
2062         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2063         sa.ss_flags = 0;
2064         g_assert (sigaltstack (&sa, NULL) == 0);
2065
2066         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);
2067 }
2068
2069 void
2070 mono_free_altstack (MonoJitTlsData *tls)
2071 {
2072         stack_t sa;
2073         int err;
2074
2075         sa.ss_sp = tls->signal_stack;
2076         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
2077         sa.ss_flags = SS_DISABLE;
2078         err = sigaltstack  (&sa, NULL);
2079         g_assert (err == 0);
2080
2081         if (tls->signal_stack)
2082                 mono_vfree (tls->signal_stack, MONO_ARCH_SIGNAL_STACK_SIZE);
2083         if (tls->stack_ovf_valloced)
2084                 mono_vfree (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size);
2085         else
2086                 mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_READ|MONO_MMAP_WRITE);
2087 }
2088
2089 #else /* !MONO_ARCH_SIGSEGV_ON_ALTSTACK */
2090
2091 void
2092 mono_setup_altstack (MonoJitTlsData *tls)
2093 {
2094 }
2095
2096 void
2097 mono_free_altstack (MonoJitTlsData *tls)
2098 {
2099 }
2100
2101 #endif /* MONO_ARCH_SIGSEGV_ON_ALTSTACK */
2102
2103 static gboolean
2104 try_restore_stack_protection (MonoJitTlsData *jit_tls, int extra_bytes)
2105 {
2106         gint32 unprotect_size = jit_tls->stack_ovf_guard_size;
2107         /* we need to leave some room for throwing the exception */
2108         while (unprotect_size >= 0 && (char*)jit_tls->stack_ovf_guard_base + unprotect_size > ((char*)&unprotect_size - extra_bytes))
2109                 unprotect_size -= mono_pagesize ();
2110         /* at this point we could try and build a new domain->stack_overflow_ex, but only if there
2111          * is sufficient stack
2112          */
2113         //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);
2114         if (unprotect_size)
2115                 mono_mprotect (jit_tls->stack_ovf_guard_base, unprotect_size, MONO_MMAP_NONE);
2116         return unprotect_size == jit_tls->stack_ovf_guard_size;
2117 }
2118
2119 static G_GNUC_UNUSED void
2120 try_more_restore (void)
2121 {
2122         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2123         if (try_restore_stack_protection (jit_tls, 500))
2124                 jit_tls->restore_stack_prot = NULL;
2125 }
2126
2127 static G_GNUC_UNUSED void
2128 restore_stack_protection (void)
2129 {
2130         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2131         MonoException *ex = mono_domain_get ()->stack_overflow_ex;
2132         /* if we can't restore the stack protection, keep a callback installed so
2133          * we'll try to restore as much stack as we can at each return from unmanaged
2134          * code.
2135          */
2136         if (try_restore_stack_protection (jit_tls, 4096))
2137                 jit_tls->restore_stack_prot = NULL;
2138         else
2139                 jit_tls->restore_stack_prot = try_more_restore_tramp;
2140         /* here we also throw a stack overflow exception */
2141         ex->trace_ips = NULL;
2142         ex->stack_trace = NULL;
2143         mono_raise_exception (ex);
2144 }
2145
2146 gpointer
2147 mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
2148 {
2149         void (*func)(void) = (void (*)(void))tramp_data;
2150         func ();
2151         return NULL;
2152 }
2153
2154 gboolean
2155 mono_handle_soft_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, guint8* fault_addr)
2156 {
2157         if (mono_llvm_only)
2158                 return FALSE;
2159
2160         /* we got a stack overflow in the soft-guard pages
2161          * There are two cases:
2162          * 1) managed code caused the overflow: we unprotect the soft-guard page
2163          * and let the arch-specific code trigger the exception handling mechanism
2164          * in the thread stack. The soft-guard pages will be protected again as the stack is unwound.
2165          * 2) unmanaged code caused the overflow: we unprotect the soft-guard page
2166          * and hope we can continue with those enabled, at least until the hard-guard page
2167          * is hit. The alternative to continuing here is to just print a message and abort.
2168          * We may add in the future the code to protect the pages again in the codepath
2169          * when we return from unmanaged to managed code.
2170          */
2171         if (jit_tls->stack_ovf_guard_size && fault_addr >= (guint8*)jit_tls->stack_ovf_guard_base &&
2172                         fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + jit_tls->stack_ovf_guard_size) {
2173                 /* we unprotect the minimum amount we can */
2174                 guint32 guard_size;
2175                 gboolean handled = FALSE;
2176
2177                 guard_size = jit_tls->stack_ovf_guard_size - (mono_pagesize () * SIZEOF_VOID_P / 4);
2178                 while (guard_size && fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + guard_size) {
2179                         guard_size -= mono_pagesize ();
2180                 }
2181                 guard_size = jit_tls->stack_ovf_guard_size - guard_size;
2182                 /*fprintf (stderr, "unprotecting: %d\n", guard_size);*/
2183                 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);
2184 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
2185                 if (ji) {
2186                         mono_arch_handle_altstack_exception (ctx, siginfo, fault_addr, TRUE);
2187                         handled = TRUE;
2188                 }
2189 #endif
2190                 if (!handled) {
2191                         /* We print a message: after this even managed stack overflows
2192                          * may crash the runtime
2193                          */
2194                         mono_runtime_printf_err ("Stack overflow in unmanaged: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
2195                         if (!jit_tls->handling_stack_ovf) {
2196                                 jit_tls->restore_stack_prot = restore_stack_protection_tramp;
2197                                 jit_tls->handling_stack_ovf = 1;
2198                         } else {
2199                                 /*fprintf (stderr, "Already handling stack overflow\n");*/
2200                         }
2201                 }
2202                 return TRUE;
2203         }
2204         return FALSE;
2205 }
2206
2207 typedef struct {
2208         MonoMethod *omethod;
2209         int count;
2210 } PrintOverflowUserData;
2211
2212 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2213 static gboolean
2214 print_overflow_stack_frame (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2215 {
2216         MonoMethod *method = NULL;
2217         PrintOverflowUserData *user_data = (PrintOverflowUserData *)data;
2218         gchar *location;
2219
2220         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2221                 method = jinfo_get_method (frame->ji);
2222
2223         if (method) {
2224                 if (user_data->count == 0) {
2225                         /* The first frame is in its prolog, so a line number cannot be computed */
2226                         user_data->count ++;
2227                         return FALSE;
2228                 }
2229
2230                 /* If this is a one method overflow, skip the other instances */
2231                 if (method == user_data->omethod)
2232                         return FALSE;
2233
2234                 location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
2235                 mono_runtime_printf_err ("  %s", location);
2236                 g_free (location);
2237
2238                 if (user_data->count == 1) {
2239                         mono_runtime_printf_err ("  <...>");
2240                         user_data->omethod = method;
2241                 } else {
2242                         user_data->omethod = NULL;
2243                 }
2244
2245                 user_data->count ++;
2246         } else
2247                 mono_runtime_printf_err ("  at <unknown> <0x%05x>", frame->native_offset);
2248
2249         return FALSE;
2250 }
2251 #endif
2252
2253 void
2254 mono_handle_hard_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr)
2255 {
2256 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2257         PrintOverflowUserData ud;
2258         MonoContext mctx;
2259 #endif
2260
2261         /* we don't do much now, but we can warn the user with a useful message */
2262         mono_runtime_printf_err ("Stack overflow: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
2263
2264 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2265         mono_sigctx_to_monoctx (ctx, &mctx);
2266
2267         mono_runtime_printf_err ("Stacktrace:");
2268
2269         memset (&ud, 0, sizeof (ud));
2270
2271         mono_walk_stack_with_ctx (print_overflow_stack_frame, &mctx, MONO_UNWIND_LOOKUP_ACTUAL_METHOD, &ud);
2272 #else
2273         if (ji && !ji->is_trampoline && jinfo_get_method (ji))
2274                 mono_runtime_printf_err ("At %s", mono_method_full_name (jinfo_get_method (ji), TRUE));
2275         else
2276                 mono_runtime_printf_err ("At <unmanaged>.");
2277 #endif
2278
2279         _exit (1);
2280 }
2281
2282 static gboolean
2283 print_stack_frame_to_stderr (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2284 {
2285         MonoMethod *method = NULL;
2286
2287         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2288                 method = jinfo_get_method (frame->ji);
2289
2290         if (method) {
2291                 gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
2292                 mono_runtime_printf_err ("  %s", location);
2293                 g_free (location);
2294         } else
2295                 mono_runtime_printf_err ("  at <unknown> <0x%05x>", frame->native_offset);
2296
2297         return FALSE;
2298 }
2299
2300 static G_GNUC_UNUSED gboolean
2301 print_stack_frame_to_string (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2302 {
2303         GString *p = (GString*)data;
2304         MonoMethod *method = NULL;
2305
2306         if (frame->ji && frame->type != FRAME_TYPE_TRAMPOLINE)
2307                 method = jinfo_get_method (frame->ji);
2308
2309         if (method && frame->domain) {
2310                 gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, frame->domain);
2311                 g_string_append_printf (p, "  %s\n", location);
2312                 g_free (location);
2313         } else
2314                 g_string_append_printf (p, "  at <unknown> <0x%05x>\n", frame->native_offset);
2315
2316         return FALSE;
2317 }
2318
2319 #ifndef MONO_CROSS_COMPILE
2320
2321 static gboolean handling_sigsegv = FALSE;
2322
2323 /*
2324  * mono_handle_native_sigsegv:
2325  *
2326  *   Handle a SIGSEGV received while in native code by printing diagnostic
2327  * information and aborting.
2328  */
2329 void
2330 mono_handle_native_sigsegv (int signal, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *info)
2331 {
2332 #ifdef MONO_ARCH_USE_SIGACTION
2333         struct sigaction sa;
2334 #endif
2335         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2336         const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
2337
2338         if (handling_sigsegv)
2339                 return;
2340
2341         if (mini_get_debug_options ()->suspend_on_sigsegv) {
2342                 mono_runtime_printf_err ("Received SIGSEGV, suspending...");
2343 #ifdef HOST_WIN32
2344                 while (1)
2345                         ;
2346 #else
2347                 while (1) {
2348                         sleep (1);
2349                 }
2350 #endif
2351         }
2352
2353         /* To prevent infinite loops when the stack walk causes a crash */
2354         handling_sigsegv = TRUE;
2355
2356         /* !jit_tls means the thread was not registered with the runtime */
2357         if (jit_tls && mono_thread_internal_current ()) {
2358                 mono_runtime_printf_err ("Stacktrace:\n");
2359
2360                 /* FIXME: Is MONO_UNWIND_LOOKUP_IL_OFFSET correct here? */
2361                 mono_walk_stack (print_stack_frame_to_stderr, MONO_UNWIND_LOOKUP_IL_OFFSET, NULL);
2362         }
2363
2364 #ifdef HAVE_BACKTRACE_SYMBOLS
2365  {
2366         void *array [256];
2367         char **names;
2368         int i, size;
2369
2370         mono_runtime_printf_err ("\nNative stacktrace:\n");
2371
2372         size = backtrace (array, 256);
2373         names = backtrace_symbols (array, size);
2374         for (i =0; i < size; ++i) {
2375                 mono_runtime_printf_err ("\t%s", names [i]);
2376         }
2377         free (names);
2378
2379         /* Try to get more meaningful information using gdb */
2380
2381 #if !defined(HOST_WIN32) && defined(HAVE_SYS_SYSCALL_H) && defined(SYS_fork)
2382         if (!mini_get_debug_options ()->no_gdb_backtrace) {
2383                 /* From g_spawn_command_line_sync () in eglib */
2384                 pid_t pid;
2385                 int status;
2386                 pid_t crashed_pid = getpid ();
2387
2388                 //pid = fork ();
2389                 /*
2390                  * glibc fork acquires some locks, so if the crash happened inside malloc/free,
2391                  * it will deadlock. Call the syscall directly instead.
2392                  */
2393                 pid = mono_runtime_syscall_fork ();
2394 #if defined (HAVE_PRCTL) && defined(PR_SET_PTRACER)
2395                 if (pid > 0) {
2396                         // Allow gdb to attach to the process even if ptrace_scope sysctl variable is set to
2397                         // a value other than 0 (the most permissive ptrace scope). Most modern Linux
2398                         // distributions set the scope to 1 which allows attaching only to direct children of
2399                         // the current process
2400                         prctl (PR_SET_PTRACER, pid, 0, 0, 0);
2401                 }
2402 #endif
2403                 if (pid == 0) {
2404                         dup2 (STDERR_FILENO, STDOUT_FILENO);
2405
2406                         mono_gdb_render_native_backtraces (crashed_pid);
2407                         exit (1);
2408                 }
2409
2410                 mono_runtime_printf_err ("\nDebug info from gdb:\n");
2411                 waitpid (pid, &status, 0);
2412         }
2413 #endif
2414  }
2415 #else
2416         mono_exception_native_unwind (ctx, info);
2417 #endif
2418
2419         /*
2420          * A SIGSEGV indicates something went very wrong so we can no longer depend
2421          * on anything working. So try to print out lots of diagnostics, starting
2422          * with ones which have a greater chance of working.
2423          */
2424         mono_runtime_printf_err (
2425                          "\n"
2426                          "=================================================================\n"
2427                          "Got a %s while executing native code. This usually indicates\n"
2428                          "a fatal error in the mono runtime or one of the native libraries \n"
2429                          "used by your application.\n"
2430                          "=================================================================\n",
2431                         signal_str);
2432
2433
2434 #ifdef MONO_ARCH_USE_SIGACTION
2435
2436         /* Remove our SIGABRT handler */
2437         sa.sa_handler = SIG_DFL;
2438         sigemptyset (&sa.sa_mask);
2439         sa.sa_flags = 0;
2440
2441         g_assert (sigaction (SIGABRT, &sa, NULL) != -1);
2442
2443 #endif
2444
2445         if (!mono_do_crash_chaining) {
2446                 /*Android abort is a fluke, it doesn't abort, it triggers another segv. */
2447 #if defined (PLATFORM_ANDROID)
2448                 exit (-1);
2449 #else
2450                 abort ();
2451 #endif
2452         }
2453 }
2454
2455 #else
2456
2457 void
2458 mono_handle_native_sigsegv (int signal, void *ctx, MONO_SIG_HANDLER_INFO_TYPE *info)
2459 {
2460         g_assert_not_reached ();
2461 }
2462
2463 #endif /* !MONO_CROSS_COMPILE */
2464
2465 static void
2466 mono_print_thread_dump_internal (void *sigctx, MonoContext *start_ctx)
2467 {
2468         MonoInternalThread *thread = mono_thread_internal_current ();
2469 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2470         MonoContext ctx;
2471 #endif
2472         GString* text;
2473         char *name;
2474 #ifndef HOST_WIN32
2475         char *wapi_desc;
2476 #endif
2477         GError *error = NULL;
2478
2479         if (!thread)
2480                 return;
2481
2482         text = g_string_new (0);
2483         if (thread->name) {
2484                 name = g_utf16_to_utf8 (thread->name, thread->name_len, NULL, NULL, &error);
2485                 g_assert (!error);
2486                 g_string_append_printf (text, "\n\"%s\"", name);
2487                 g_free (name);
2488         }
2489         else if (thread->threadpool_thread)
2490                 g_string_append (text, "\n\"<threadpool thread>\"");
2491         else
2492                 g_string_append (text, "\n\"<unnamed thread>\"");
2493
2494 #ifndef HOST_WIN32
2495         wapi_desc = wapi_current_thread_desc ();
2496         g_string_append_printf (text, " tid=0x%p this=0x%p %s\n", (gpointer)(gsize)thread->tid, thread,  wapi_desc);
2497         free (wapi_desc);
2498 #endif
2499
2500 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2501         if (start_ctx) {
2502                 memcpy (&ctx, start_ctx, sizeof (MonoContext));
2503         } else if (!sigctx)
2504                 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_print_thread_dump);
2505         else
2506                 mono_sigctx_to_monoctx (sigctx, &ctx);
2507
2508         mono_walk_stack_with_ctx (print_stack_frame_to_string, &ctx, MONO_UNWIND_LOOKUP_ALL, text);
2509 #else
2510         mono_runtime_printf ("\t<Stack traces in thread dumps not supported on this platform>");
2511 #endif
2512
2513         mono_runtime_printf ("%s", text->str);
2514
2515 #if PLATFORM_WIN32 && TARGET_WIN32 && _DEBUG
2516         OutputDebugStringA(text->str);
2517 #endif
2518
2519         g_string_free (text, TRUE);
2520         mono_runtime_stdout_fflush ();
2521 }
2522
2523 /*
2524  * mono_print_thread_dump:
2525  *
2526  *   Print information about the current thread to stdout.
2527  * SIGCTX can be NULL, allowing this to be called from gdb.
2528  */
2529 void
2530 mono_print_thread_dump (void *sigctx)
2531 {
2532         mono_print_thread_dump_internal (sigctx, NULL);
2533 }
2534
2535 void
2536 mono_print_thread_dump_from_ctx (MonoContext *ctx)
2537 {
2538         mono_print_thread_dump_internal (NULL, ctx);
2539 }
2540
2541 /*
2542  * mono_resume_unwind:
2543  *
2544  *   This is called by a trampoline from LLVM compiled finally clauses to continue
2545  * unwinding.
2546  */
2547 void
2548 mono_resume_unwind (MonoContext *ctx)
2549 {
2550         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2551         MonoContext new_ctx;
2552
2553         MONO_CONTEXT_SET_IP (ctx, MONO_CONTEXT_GET_IP (&jit_tls->resume_state.ctx));
2554         MONO_CONTEXT_SET_SP (ctx, MONO_CONTEXT_GET_SP (&jit_tls->resume_state.ctx));
2555         new_ctx = *ctx;
2556
2557         mono_handle_exception_internal (&new_ctx, (MonoObject *)jit_tls->resume_state.ex_obj, TRUE, NULL);
2558
2559         mono_restore_context (&new_ctx);
2560 }
2561
2562 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
2563
2564 typedef struct {
2565         MonoJitInfo *ji;
2566         MonoContext ctx;
2567         MonoJitExceptionInfo *ei;
2568 } FindHandlerBlockData;
2569
2570 static gboolean
2571 find_last_handler_block (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
2572 {
2573         int i;
2574         gpointer ip;
2575         FindHandlerBlockData *pdata = (FindHandlerBlockData *)data;
2576         MonoJitInfo *ji = frame->ji;
2577
2578         if (!ji)
2579                 return FALSE;
2580
2581         ip = MONO_CONTEXT_GET_IP (ctx);
2582
2583         for (i = 0; i < ji->num_clauses; ++i) {
2584                 MonoJitExceptionInfo *ei = ji->clauses + i;
2585                 if (ei->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2586                         continue;
2587                 /*If ip points to the first instruction it means the handler block didn't start
2588                  so we can leave its execution to the EH machinery*/
2589                 if (ei->handler_start < ip && ip < ei->data.handler_end) {
2590                         pdata->ji = ji;
2591                         pdata->ei = ei;
2592                         pdata->ctx = *ctx;
2593                         break;
2594                 }
2595         }
2596         return FALSE;
2597 }
2598
2599
2600 static gpointer
2601 install_handler_block_guard (MonoJitInfo *ji, MonoContext *ctx)
2602 {
2603         int i;
2604         MonoJitExceptionInfo *clause = NULL;
2605         gpointer ip;
2606
2607         ip = MONO_CONTEXT_GET_IP (ctx);
2608
2609         for (i = 0; i < ji->num_clauses; ++i) {
2610                 clause = &ji->clauses [i];
2611                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2612                         continue;
2613                 if (clause->handler_start < ip && clause->data.handler_end > ip)
2614                         break;
2615         }
2616
2617         /*no matching finally */
2618         if (i == ji->num_clauses)
2619                 return NULL;
2620
2621         /*If we stopped on the instruction right before the try, we haven't actually started executing it*/
2622         if (ip == clause->handler_start)
2623                 return NULL;
2624
2625         return mono_arch_install_handler_block_guard (ji, clause, ctx, mono_create_handler_block_trampoline ());
2626 }
2627
2628 /*
2629  * Finds the bottom handler block running and install a block guard if needed.
2630  * FIXME add full-aot support.
2631  */
2632 gboolean
2633 mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
2634 {
2635         FindHandlerBlockData data = { 0 };
2636         MonoJitTlsData *jit_tls = (MonoJitTlsData *)ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS];
2637         gpointer resume_ip;
2638
2639         /* FIXME */
2640         if (mono_aot_only)
2641                 return FALSE;
2642
2643         /* Guard against a null MonoJitTlsData. This can happens if the thread receives the
2644          * interrupt signal before the JIT has time to initialize its TLS data for the given thread.
2645          */
2646         if (!jit_tls || jit_tls->handler_block_return_address)
2647                 return FALSE;
2648
2649         /* Do an async safe stack walk */
2650         mono_thread_info_set_is_async_context (TRUE);
2651         mono_walk_stack_with_state (find_last_handler_block, ctx, MONO_UNWIND_NONE, &data);
2652         mono_thread_info_set_is_async_context (FALSE);
2653
2654         if (!data.ji)
2655                 return FALSE;
2656
2657         memcpy (&jit_tls->handler_block_context, &data.ctx, sizeof (MonoContext));
2658
2659         resume_ip = install_handler_block_guard (data.ji, &data.ctx);
2660         if (resume_ip == NULL)
2661                 return FALSE;
2662
2663         jit_tls->handler_block_return_address = resume_ip;
2664         jit_tls->handler_block = data.ei;
2665
2666         return TRUE;
2667 }
2668
2669 #else
2670 gboolean
2671 mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
2672 {
2673         return FALSE;
2674 }
2675
2676 #endif
2677
2678 void
2679 mono_set_cast_details (MonoClass *from, MonoClass *to)
2680 {
2681         MonoJitTlsData *jit_tls = NULL;
2682
2683         if (mini_get_debug_options ()->better_cast_details) {
2684                 jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2685                 jit_tls->class_cast_from = from;
2686                 jit_tls->class_cast_to = to;
2687         }
2688 }
2689
2690
2691 /*returns false if the thread is not attached*/
2692 gboolean
2693 mono_thread_state_init_from_sigctx (MonoThreadUnwindState *ctx, void *sigctx)
2694 {
2695 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2696         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2697         if (!thread) {
2698                 ctx->valid = FALSE;
2699                 G_BREAKPOINT ();
2700                 return FALSE;
2701         }
2702
2703         if (sigctx) {
2704                 mono_sigctx_to_monoctx (sigctx, &ctx->ctx);
2705
2706                 ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2707                 ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2708                 ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2709         }
2710         else {
2711                 mono_thread_state_init (ctx);
2712         }
2713
2714         if (!ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] || !ctx->unwind_data [MONO_UNWIND_DATA_LMF])
2715                 return FALSE;
2716
2717         ctx->valid = TRUE;
2718         return TRUE;
2719 #else
2720         g_error ("Implement mono_arch_sigctx_to_monoctx for the current target");
2721         return FALSE;
2722 #endif
2723 }
2724
2725 void
2726 mono_thread_state_init (MonoThreadUnwindState *ctx)
2727 {
2728         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2729
2730 #if defined(MONO_CROSS_COMPILE)
2731         ctx->valid = FALSE; //A cross compiler doesn't need to suspend.
2732 #elif MONO_ARCH_HAS_MONO_CONTEXT
2733         MONO_CONTEXT_GET_CURRENT (ctx->ctx);
2734 #else
2735         g_error ("Use a null sigctx requires a working mono-context");
2736 #endif
2737
2738         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2739         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2740         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread ? thread->jit_data : NULL;
2741         ctx->valid = TRUE;
2742 }
2743
2744
2745 gboolean
2746 mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx)
2747 {
2748         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2749         if (!thread) {
2750                 ctx->valid = FALSE;
2751                 return FALSE;
2752         }
2753
2754         ctx->ctx = *mctx;
2755         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2756         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2757         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2758         ctx->valid = TRUE;
2759         return TRUE;
2760 }
2761
2762 /*returns false if the thread is not attached*/
2763 gboolean
2764 mono_thread_state_init_from_current (MonoThreadUnwindState *ctx)
2765 {
2766         MonoThreadInfo *thread = mono_thread_info_current_unchecked ();
2767         MONO_ARCH_CONTEXT_DEF
2768
2769         mono_arch_flush_register_windows ();
2770
2771         if (!thread || !thread->jit_data) {
2772                 ctx->valid = FALSE;
2773                 return FALSE;
2774         }
2775 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
2776         MONO_INIT_CONTEXT_FROM_CURRENT (&ctx->ctx);
2777 #else
2778         MONO_INIT_CONTEXT_FROM_FUNC (&ctx->ctx, mono_thread_state_init_from_current);
2779 #endif
2780
2781         ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
2782         ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
2783         ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
2784         ctx->valid = TRUE;
2785         return TRUE;
2786 }
2787
2788 static void
2789 mono_raise_exception_with_ctx (MonoException *exc, MonoContext *ctx)
2790 {
2791         mono_handle_exception (ctx, (MonoObject *)exc);
2792         mono_restore_context (ctx);
2793 }
2794
2795 /*FIXME Move all monoctx -> sigctx conversion to signal handlers once all archs support utils/mono-context */
2796 void
2797 mono_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
2798 {
2799 #ifdef MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK
2800         MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
2801         jit_tls->ex_ctx = *ctx;
2802
2803         mono_arch_setup_async_callback (ctx, async_cb, user_data);
2804 #else
2805         g_error ("This target doesn't support mono_arch_setup_async_callback");
2806 #endif
2807 }
2808
2809 void
2810 mono_install_unhandled_exception_hook (MonoUnhandledExceptionFunc func, gpointer user_data)
2811 {
2812         unhandled_exception_hook = func;
2813         unhandled_exception_hook_data = user_data;
2814 }
2815
2816 void
2817 mono_invoke_unhandled_exception_hook (MonoObject *exc)
2818 {
2819         if (unhandled_exception_hook) {
2820                 unhandled_exception_hook (exc, unhandled_exception_hook_data);
2821         } else {
2822                 MonoObject *other = NULL;
2823                 MonoString *str = mono_object_to_string (exc, &other);
2824                 char *msg = NULL;
2825
2826                 if (str)
2827                         msg = mono_string_to_utf8 (str);
2828                 else if (other) {
2829                         char *original_backtrace = mono_exception_get_managed_backtrace ((MonoException*)exc);
2830                         char *nested_backtrace = mono_exception_get_managed_backtrace ((MonoException*)other);
2831
2832                         msg = g_strdup_printf ("Nested exception detected.\nOriginal Exception: %s\nNested exception:%s\n",
2833                                 original_backtrace, nested_backtrace);
2834
2835                         g_free (original_backtrace);
2836                         g_free (nested_backtrace);
2837                 } else {
2838                         msg = g_strdup ("Nested exception trying to figure out what went wrong");
2839                 }
2840                 mono_runtime_printf_err ("[ERROR] FATAL UNHANDLED EXCEPTION: %s", msg);
2841                 g_free (msg);
2842 #if defined(HOST_IOS)
2843                 g_assertion_message ("Terminating runtime due to unhandled exception");
2844 #else
2845                 exit (mono_environment_exitcode_get ());
2846 #endif
2847         }
2848
2849         g_assert_not_reached ();
2850 }
2851
2852 /*
2853  * mono_restore_context:
2854  *
2855  *   Call the architecture specific restore context function.
2856  */
2857 void
2858 mono_restore_context (MonoContext *ctx)
2859 {
2860         static void (*restore_context) (MonoContext *);
2861
2862         if (!restore_context)
2863                 restore_context = (void (*)(MonoContext *))mono_get_restore_context ();
2864         restore_context (ctx);
2865         g_assert_not_reached ();
2866 }
2867
2868 /*
2869  * mono_jinfo_get_unwind_info:
2870  *
2871  *   Return the unwind info for JI.
2872  */
2873 guint8*
2874 mono_jinfo_get_unwind_info (MonoJitInfo *ji, guint32 *unwind_info_len)
2875 {
2876         if (ji->from_aot)
2877                 return mono_aot_get_unwind_info (ji, unwind_info_len);
2878         else
2879                 return mono_get_cached_unwind_info (ji->unwind_info, unwind_info_len);
2880 }
2881
2882 int
2883 mono_jinfo_get_epilog_size (MonoJitInfo *ji)
2884 {
2885         MonoArchEHJitInfo *info;
2886
2887         info = mono_jit_info_get_arch_eh_info (ji);
2888         g_assert (info);
2889
2890         return info->epilog_size;
2891 }
2892
2893 /*
2894  * LLVM/Bitcode exception handling.
2895  */
2896
2897 static void
2898 throw_exception (MonoObject *ex, gboolean rethrow)
2899 {
2900         MonoError error;
2901         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
2902         MonoException *mono_ex;
2903
2904         if (!mono_object_isinst_checked (ex, mono_defaults.exception_class, &error)) {
2905                 mono_error_assert_ok (&error);
2906                 mono_ex = mono_get_exception_runtime_wrapped_checked (ex, &error);
2907                 mono_error_assert_ok (&error);
2908         }
2909         else
2910                 mono_ex = (MonoException*)ex;
2911
2912         // Note: Not pinned
2913         jit_tls->thrown_exc = mono_gchandle_new ((MonoObject*)mono_ex, FALSE);
2914
2915         if (!rethrow) {
2916 #ifdef MONO_ARCH_HAVE_UNWIND_BACKTRACE
2917                 GList *l, *ips = NULL;
2918                 GList *trace;
2919
2920                 _Unwind_Backtrace (build_stack_trace, &ips);
2921                 /* The list contains ip-gshared info pairs */
2922                 trace = NULL;
2923                 ips = g_list_reverse (ips);
2924                 for (l = ips; l; l = l->next) {
2925                         trace = g_list_append (trace, l->data);
2926                         trace = g_list_append (trace, NULL);
2927                 }
2928                 MonoArray *ips_arr = mono_glist_to_array (trace, mono_defaults.int_class, &error);
2929                 mono_error_assert_ok (&error);
2930                 MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
2931                 g_list_free (l);
2932                 g_list_free (trace);
2933 #endif
2934         }
2935
2936         mono_llvm_cpp_throw_exception ();
2937 }
2938
2939 void
2940 mono_llvm_throw_exception (MonoObject *ex)
2941 {
2942         throw_exception (ex, FALSE);
2943 }
2944
2945 void
2946 mono_llvm_rethrow_exception (MonoObject *ex)
2947 {
2948         throw_exception (ex, TRUE);
2949 }
2950
2951 void
2952 mono_llvm_raise_exception (MonoException *e)
2953 {
2954         mono_llvm_throw_exception ((MonoObject*)e);
2955 }
2956
2957 void
2958 mono_llvm_throw_corlib_exception (guint32 ex_token_index)
2959 {
2960         guint32 ex_token = MONO_TOKEN_TYPE_DEF | ex_token_index;
2961         MonoException *ex;
2962
2963         ex = mono_exception_from_token (mono_defaults.exception_class->image, ex_token);
2964
2965         mono_llvm_throw_exception ((MonoObject*)ex);
2966 }
2967
2968 /*
2969  * mono_llvm_resume_exception:
2970  *
2971  *   Resume exception propagation.
2972  */
2973 void
2974 mono_llvm_resume_exception (void)
2975 {
2976         mono_llvm_cpp_throw_exception ();
2977 }
2978
2979 /*
2980  * mono_llvm_load_exception:
2981  *
2982  *   Return the currently thrown exception.
2983  */
2984 MonoObject *
2985 mono_llvm_load_exception (void)
2986 {
2987                 MonoError error;
2988         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
2989
2990         MonoException *mono_ex = (MonoException*)mono_gchandle_get_target (jit_tls->thrown_exc);
2991
2992         if (mono_ex->trace_ips) {
2993                 GList *trace_ips = NULL;
2994                 gpointer ip = __builtin_return_address (0);
2995
2996                 size_t upper = mono_array_length (mono_ex->trace_ips);
2997
2998                 for (int i = 0; i < upper; i+= 2) {
2999                         gpointer curr_ip = mono_array_get (mono_ex->trace_ips, gpointer, i);
3000                         gpointer curr_info = mono_array_get (mono_ex->trace_ips, gpointer, i + 1);
3001                         trace_ips = g_list_append (trace_ips, curr_ip);
3002                         trace_ips = g_list_append (trace_ips, curr_info);
3003
3004                         if (ip == curr_ip)
3005                                 break;
3006                 }
3007
3008                 // FIXME: Does this work correctly for rethrows?
3009                 // We may be discarding useful information
3010                 // when this gets GC'ed
3011                 MonoArray *ips_arr = mono_glist_to_array (trace_ips, mono_defaults.int_class, &error);
3012                 mono_error_assert_ok (&error);
3013                 MONO_OBJECT_SETREF (mono_ex, trace_ips, ips_arr);
3014                 g_list_free (trace_ips);
3015
3016                 // FIXME:
3017                 //MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
3018         } else {
3019                 MONO_OBJECT_SETREF (mono_ex, trace_ips, mono_array_new_checked (mono_domain_get (), mono_defaults.int_class, 0, &error));
3020                 mono_error_assert_ok (&error);
3021                 MONO_OBJECT_SETREF (mono_ex, stack_trace, mono_array_new_checked (mono_domain_get (), mono_defaults.stack_frame_class, 0, &error));
3022                 mono_error_assert_ok (&error);
3023         }
3024
3025         return &mono_ex->object;
3026 }
3027
3028 /*
3029  * mono_llvm_clear_exception:
3030  *
3031  *   Mark the currently thrown exception as handled.
3032  */
3033 void
3034 mono_llvm_clear_exception (void)
3035 {
3036         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
3037         mono_gchandle_free (jit_tls->thrown_exc);
3038         jit_tls->thrown_exc = 0;
3039
3040         mono_memory_barrier ();
3041 }
3042
3043 /*
3044  * mono_llvm_match_exception:
3045  *
3046  *   Return the innermost clause containing REGION_START-REGION_END which can handle
3047  * the current exception.
3048  */
3049 gint32
3050 mono_llvm_match_exception (MonoJitInfo *jinfo, guint32 region_start, guint32 region_end, gpointer rgctx, MonoObject *this_obj)
3051 {
3052                         MonoError error;
3053         MonoJitTlsData *jit_tls = mono_get_jit_tls ();
3054         MonoObject *exc;
3055         gint32 index = -1;
3056
3057         g_assert (jit_tls->thrown_exc);
3058         exc = mono_gchandle_get_target (jit_tls->thrown_exc);
3059         for (int i = 0; i < jinfo->num_clauses; i++) {
3060                 MonoJitExceptionInfo *ei = &jinfo->clauses [i];
3061                 MonoClass *catch_class;
3062
3063                 if (! (ei->try_offset == region_start && ei->try_offset + ei->try_len == region_end) )
3064                         continue;
3065
3066                 catch_class = ei->data.catch_class;
3067                 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) {
3068                         MonoGenericContext context;
3069                         MonoType *inflated_type;
3070
3071                         g_assert (rgctx || this_obj);
3072                         context = get_generic_context_from_stack_frame (jinfo, rgctx ? rgctx : this_obj->vtable);
3073                         inflated_type = mono_class_inflate_generic_type_checked (&catch_class->byval_arg, &context, &error);
3074                         mono_error_assert_ok (&error); /* FIXME don't swallow the error */
3075
3076                         catch_class = mono_class_from_mono_type (inflated_type);
3077                         mono_metadata_free_type (inflated_type);
3078                 }
3079
3080                 // FIXME: Handle edge cases handled in get_exception_catch_class
3081                 if (ei->flags == MONO_EXCEPTION_CLAUSE_NONE && mono_object_isinst_checked (exc, catch_class, &error)) {
3082                         index = ei->clause_index;
3083                         break;
3084                 } else
3085                         mono_error_assert_ok (&error);
3086
3087                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
3088                         g_assert_not_reached ();
3089                 }
3090         }
3091
3092         return index;
3093 }
3094
3095 #ifdef ENABLE_LLVM
3096 _Unwind_Reason_Code
3097 mono_debug_personality (int a, _Unwind_Action b,
3098 uint64_t c, struct _Unwind_Exception *d, struct _Unwind_Context *e)
3099 {
3100         g_assert_not_reached ();
3101 }
3102 #else
3103 void
3104 mono_debug_personality (void);
3105
3106 void
3107 mono_debug_personality (void)
3108 {
3109         g_assert_not_reached ();
3110 }
3111 #endif