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 Ximian, Inc.
  10  */
  11
  12 #include <config.h>
  13 #include <glib.h>
  14 #include <signal.h>
  15 #include <string.h>
  16
  17 #ifdef HAVE_EXECINFO_H
  18 #include <execinfo.h>
  19 #endif
  20
  21 #ifdef HAVE_SYS_TYPES_H
  22 #include <sys/types.h>
  23 #endif
  24
  25 #ifdef HAVE_SYS_WAIT_H
  26 #include <sys/wait.h>
  27 #endif
  28
  29 #ifdef HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32
  33 #ifdef HAVE_SYS_SYSCALL_H
  34 #include <sys/syscall.h>
  35 #endif
  36
  37 #include <mono/metadata/appdomain.h>
  38 #include <mono/metadata/tabledefs.h>
  39 #include <mono/metadata/threads.h>
  40 #include <mono/metadata/threads-types.h>
  41 #include <mono/metadata/debug-helpers.h>
  42 #include <mono/metadata/exception.h>
  43 #include <mono/metadata/gc-internal.h>
  44 #include <mono/metadata/mono-debug.h>
  45 #include <mono/metadata/profiler.h>
  46 #include <mono/utils/mono-mmap.h>
  47
  48 #include "mini.h"
  49 #include "debug-mini.h"
  50 #include "trace.h"
  51 #include "debugger-agent.h"
  52
  53 #ifndef MONO_ARCH_CONTEXT_DEF
  54 #define MONO_ARCH_CONTEXT_DEF
  55 #endif
  56
  57 static gpointer restore_context_func, call_filter_func;
  58 static gpointer throw_exception_func, rethrow_exception_func;
  59 static gpointer throw_exception_by_name_func, throw_corlib_exception_func;
  60
  61 static gpointer try_more_restore_tramp = NULL;
  62 static gpointer restore_stack_protection_tramp = NULL;
  63
  64 static void try_more_restore (void);
  65 static void restore_stack_protection (void);
  66 static void mono_walk_stack_full (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoContext *start_ctx, MonoStackFrameWalk func, gboolean use_new_ctx, gpointer user_data);
  67
  68 void
  69 mono_exceptions_init (void)
  70 {
  71 #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
  72         guint32 code_size;
  73         MonoJumpInfo *ji;
  74
  75         if (mono_aot_only) {
  76                 restore_context_func = mono_aot_get_named_code ("restore_context");
  77                 call_filter_func = mono_aot_get_named_code ("call_filter");
  78                 throw_exception_func = mono_aot_get_named_code ("throw_exception");
  79                 rethrow_exception_func = mono_aot_get_named_code ("rethrow_exception");
  80         } else {
  81                 restore_context_func = mono_arch_get_restore_context_full (&code_size, &ji, FALSE);
  82                 call_filter_func = mono_arch_get_call_filter_full (&code_size, &ji, FALSE);
  83                 throw_exception_func = mono_arch_get_throw_exception_full (&code_size, &ji, FALSE);
  84                 rethrow_exception_func = mono_arch_get_rethrow_exception_full (&code_size, &ji, FALSE);
  85         }
  86 #else
  87         restore_context_func = mono_arch_get_restore_context ();
  88         call_filter_func = mono_arch_get_call_filter ();
  89         throw_exception_func = mono_arch_get_throw_exception ();
  90         rethrow_exception_func = mono_arch_get_rethrow_exception ();
  91 #endif
  92 #ifdef MONO_ARCH_HAVE_RESTORE_STACK_SUPPORT
  93         try_more_restore_tramp = mono_create_specific_trampoline (try_more_restore, MONO_TRAMPOLINE_RESTORE_STACK_PROT, mono_domain_get (), NULL);
  94         restore_stack_protection_tramp = mono_create_specific_trampoline (restore_stack_protection, MONO_TRAMPOLINE_RESTORE_STACK_PROT, mono_domain_get (), NULL);
  95 #endif
  96
  97 #ifdef MONO_ARCH_HAVE_EXCEPTIONS_INIT
  98         mono_arch_exceptions_init ();
  99 #endif
 100 }
 101
 102 gpointer
 103 mono_get_throw_exception (void)
 104 {
 105         g_assert (throw_exception_func);
 106         return throw_exception_func;
 107 }
 108
 109 gpointer
 110 mono_get_rethrow_exception (void)
 111 {
 112         g_assert (rethrow_exception_func);
 113         return rethrow_exception_func;
 114 }
 115
 116 gpointer
 117 mono_get_call_filter (void)
 118 {
 119         g_assert (call_filter_func);
 120         return call_filter_func;
 121 }
 122
 123 gpointer
 124 mono_get_restore_context (void)
 125 {
 126         g_assert (restore_context_func);
 127         return restore_context_func;
 128 }
 129
 130 gpointer
 131 mono_get_throw_exception_by_name (void)
 132 {
 133 #ifdef MONO_ARCH_HAVE_THROW_EXCEPTION_BY_NAME
 134
 135         gpointer code = NULL;
 136 #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
 137         guint32 code_size;
 138         MonoJumpInfo *ji;
 139 #endif
 140
 141         /* This depends on corlib classes so cannot be inited in mono_exceptions_init () */
 142         if (throw_exception_by_name_func)
 143                 return throw_exception_by_name_func;
 144
 145 #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
 146         if (mono_aot_only)
 147                 code = mono_aot_get_named_code ("throw_exception_by_name");
 148         else
 149                 code = mono_arch_get_throw_exception_by_name_full (&code_size, &ji, FALSE);
 150 #else
 151                 code = mono_arch_get_throw_exception_by_name ();
 152 #endif
 153
 154         mono_memory_barrier ();
 155
 156         throw_exception_by_name_func = code;
 157
 158 #else
 159
 160         throw_exception_by_name_func = NULL;
 161
 162         g_assert_not_reached ();
 163 #endif
 164
 165         return throw_exception_by_name_func;
 166 }
 167
 168 gpointer
 169 mono_get_throw_corlib_exception (void)
 170 {
 171         gpointer code = NULL;
 172 #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
 173         guint32 code_size;
 174         MonoJumpInfo *ji;
 175 #endif
 176
 177         /* This depends on corlib classes so cannot be inited in mono_exceptions_init () */
 178         if (throw_corlib_exception_func)
 179                 return throw_corlib_exception_func;
 180
 181 #if MONO_ARCH_HAVE_THROW_CORLIB_EXCEPTION
 182 #ifdef MONO_ARCH_HAVE_FULL_AOT_TRAMPOLINES
 183         if (mono_aot_only)
 184                 code = mono_aot_get_named_code ("throw_corlib_exception");
 185         else
 186                 code = mono_arch_get_throw_corlib_exception_full (&code_size, &ji, FALSE);
 187 #else
 188                 code = mono_arch_get_throw_corlib_exception ();
 189 #endif
 190 #else
 191         g_assert_not_reached ();
 192 #endif
 193
 194         mono_memory_barrier ();
 195
 196         throw_corlib_exception_func = code;
 197
 198         return throw_corlib_exception_func;
 199 }
 200
 201 static gboolean
 202 is_address_protected (MonoJitInfo *ji, MonoJitExceptionInfo *ei, gpointer ip)
 203 {
 204         MonoTryBlockHoleTableJitInfo *table;
 205         int i;
 206         guint32 offset;
 207         guint16 clause;
 208
 209         /*FIXME check if under s390 it should be ei->try_start >= ip*/
 210         if (ei->try_start > ip || ip >= ei->try_end)
 211                 return FALSE;
 212
 213         if (!ji->has_try_block_holes)
 214                 return TRUE;
 215
 216         table = mono_jit_info_get_try_block_hole_table_info (ji);
 217         offset = (guint32)((char*)ip - (char*)ji->code_start);
 218         clause = (guint16)(ei - ji->clauses);
 219         g_assert (clause < ji->num_clauses);
 220
 221         for (i = 0; i < table->num_holes; ++i) {
 222                 MonoTryBlockHoleJitInfo *hole = &table->holes [i];
 223                 if (hole->clause == clause && hole->offset <= offset && hole->offset + hole->length > offset)
 224                         return FALSE;
 225         }
 226         return TRUE;
 227 }
 228
 229 #ifdef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
 230
 231 /*
 232  * find_jit_info_no_ext:
 233  *
 234  * If the target has the find_jit_info_ext version of this function, define the old
 235  * version here which translates between the old and new APIs.
 236  */
 237 static MonoJitInfo *
 238 find_jit_info_no_ext (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
 239                            MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
 240 {
 241         StackFrameInfo frame;
 242         MonoJitInfo *ji;
 243         gboolean err;
 244         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 245
 246         /* Avoid costly table lookup during stack overflow */
 247         if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
 248                 ji = prev_ji;
 249         else
 250                 ji = mini_jit_info_table_find (domain, ip, NULL);
 251
 252         if (managed)
 253                 *managed = FALSE;
 254
 255         err = mono_arch_find_jit_info_ext (domain, jit_tls, ji, ctx, new_ctx, lmf, &frame);
 256         if (!err)
 257                 return (gpointer)-1;
 258
 259         /* Convert between the new and the old APIs */
 260         switch (frame.type) {
 261         case FRAME_TYPE_MANAGED:
 262                 if (managed)
 263                         *managed = TRUE;
 264                 return ji;
 265         case FRAME_TYPE_MANAGED_TO_NATIVE:
 266                 if (frame.ji)
 267                         return frame.ji;
 268                 else {
 269                         memset (res, 0, sizeof (MonoJitInfo));
 270                         res->method = frame.method;
 271                         return res;
 272                 }
 273         case FRAME_TYPE_DEBUGGER_INVOKE: {
 274                 MonoContext tmp_ctx;
 275
 276                 /*
 277                  * The normal exception handling code can't handle this frame, so just
 278                  * skip it.
 279                  */
 280                 ji = find_jit_info_no_ext (domain, jit_tls, res, NULL, new_ctx, &tmp_ctx, lmf, managed);
 281                 memcpy (new_ctx, &tmp_ctx, sizeof (MonoContext));
 282                 return ji;
 283         }
 284         default:
 285                 g_assert_not_reached ();
 286                 return NULL;
 287         }
 288 }
 289
 290 #endif
 291
 292 /* mono_find_jit_info:
 293  *
 294  * This function is used to gather information from @ctx. It return the
 295  * MonoJitInfo of the corresponding function, unwinds one stack frame and
 296  * stores the resulting context into @new_ctx. It also stores a string
 297  * describing the stack location into @trace (if not NULL), and modifies
 298  * the @lmf if necessary. @native_offset return the IP offset from the
 299  * start of the function or -1 if that info is not available.
 300  */
 301 MonoJitInfo *
 302 mono_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
 303                     MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset,
 304                     gboolean *managed)
 305 {
 306         gboolean managed2;
 307         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 308         MonoJitInfo *ji;
 309
 310         if (trace)
 311                 *trace = NULL;
 312
 313         if (native_offset)
 314                 *native_offset = -1;
 315
 316         if (managed)
 317                 *managed = FALSE;
 318
 319 #ifdef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
 320         ji = find_jit_info_no_ext (domain, jit_tls, res, prev_ji, ctx, new_ctx, lmf, &managed2);
 321 #else
 322         ji = mono_arch_find_jit_info (domain, jit_tls, res, prev_ji, ctx, new_ctx, lmf, &managed2);
 323 #endif
 324
 325         if (ji == (gpointer)-1)
 326                 return ji;
 327
 328         if (managed2 || (ji && ji->method->wrapper_type)) {
 329                 const char *real_ip, *start;
 330                 gint32 offset;
 331
 332                 start = (const char *)ji->code_start;
 333                 if (!managed2)
 334                         /* ctx->ip points into native code */
 335                         real_ip = (const char*)MONO_CONTEXT_GET_IP (new_ctx);
 336                 else
 337                         real_ip = (const char*)ip;
 338
 339                 if ((real_ip >= start) && (real_ip <= start + ji->code_size))
 340                         offset = real_ip - start;
 341                 else
 342                         offset = -1;
 343
 344                 if (native_offset)
 345                         *native_offset = offset;
 346
 347                 if (managed)
 348                         if (!ji->method->wrapper_type)
 349                                 *managed = TRUE;
 350
 351                 if (trace)
 352                         *trace = mono_debug_print_stack_frame (ji->method, offset, domain);
 353         } else {
 354                 if (trace) {
 355                         char *fname = mono_method_full_name (res->method, TRUE);
 356                         *trace = g_strdup_printf ("in (unmanaged) %s", fname);
 357                         g_free (fname);
 358                 }
 359         }
 360
 361         return ji;
 362 }
 363
 364 #ifdef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
 365
 366 /*
 367  * mono_find_jit_info_ext:
 368  *
 369  *   A version of mono_find_jit_info which returns all data in the StackFrameInfo
 370  * structure.
 371  */
 372 gboolean
 373 mono_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls,
 374                                                 MonoJitInfo *prev_ji, MonoContext *ctx,
 375                                                 MonoContext *new_ctx, char **trace, MonoLMF **lmf,
 376                                                 StackFrameInfo *frame)
 377 {
 378         gboolean err;
 379         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 380         MonoJitInfo *ji;
 381         MonoDomain *target_domain;
 382
 383         if (trace)
 384                 *trace = NULL;
 385
 386         /* Avoid costly table lookup during stack overflow */
 387         if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
 388                 ji = prev_ji;
 389         else
 390                 ji = mini_jit_info_table_find (domain, ip, &target_domain);
 391
 392         if (!target_domain)
 393                 target_domain = domain;
 394
 395         err = mono_arch_find_jit_info_ext (target_domain, jit_tls, ji, ctx, new_ctx, lmf, frame);
 396         if (!err)
 397                 return FALSE;
 398
 399         frame->native_offset = -1;
 400         frame->domain = target_domain;
 401
 402         ji = frame->ji;
 403
 404         if (ji && (frame->managed || ji->method->wrapper_type)) {
 405                 const char *real_ip, *start;
 406
 407                 start = (const char *)ji->code_start;
 408                 if (!frame->managed)
 409                         /* ctx->ip points into native code */
 410                         real_ip = (const char*)MONO_CONTEXT_GET_IP (new_ctx);
 411                 else
 412                         real_ip = (const char*)ip;
 413
 414                 if ((real_ip >= start) && (real_ip <= start + ji->code_size))
 415                         frame->native_offset = real_ip - start;
 416                 else
 417                         frame->native_offset = -1;
 418
 419                 if (trace)
 420                         *trace = mono_debug_print_stack_frame (ji->method, frame->native_offset, domain);
 421         } else {
 422                 if (trace && frame->method) {
 423                         char *fname = mono_method_full_name (frame->method, TRUE);
 424                         *trace = g_strdup_printf ("in (unmanaged) %s", fname);
 425                         g_free (fname);
 426                 }
 427         }
 428
 429         return TRUE;
 430 }
 431
 432 #endif /* MONO_ARCH_HAVE_FIND_JIT_INFO_EXT */
 433
 434 static gpointer
 435 get_generic_info_from_stack_frame (MonoJitInfo *ji, MonoContext *ctx)
 436 {
 437         MonoGenericJitInfo *gi;
 438         gpointer info;
 439
 440         if (!ji->has_generic_jit_info)
 441                 return NULL;
 442         gi = mono_jit_info_get_generic_jit_info (ji);
 443         if (!gi->has_this)
 444                 return NULL;
 445
 446         if (gi->this_in_reg)
 447                 info = mono_arch_context_get_int_reg (ctx, gi->this_reg);
 448         else
 449                 info = *(gpointer*)(gpointer)((char*)mono_arch_context_get_int_reg (ctx, gi->this_reg) +
 450                                                                           gi->this_offset);
 451         if (mono_method_get_context (ji->method)->method_inst) {
 452                 return info;
 453         } else if ((ji->method->flags & METHOD_ATTRIBUTE_STATIC) || ji->method->klass->valuetype) {
 454                 return info;
 455         } else {
 456                 /* Avoid returning a managed object */
 457                 MonoObject *this_obj = info;
 458
 459                 return this_obj->vtable->klass;
 460         }
 461 }
 462
 463 static MonoGenericContext
 464 get_generic_context_from_stack_frame (MonoJitInfo *ji, gpointer generic_info)
 465 {
 466         MonoGenericContext context = { NULL, NULL };
 467         MonoClass *class, *method_container_class;
 468
 469         g_assert (generic_info);
 470
 471         g_assert (ji->method->is_inflated);
 472         if (mono_method_get_context (ji->method)->method_inst) {
 473                 MonoMethodRuntimeGenericContext *mrgctx = generic_info;
 474
 475                 class = mrgctx->class_vtable->klass;
 476                 context.method_inst = mrgctx->method_inst;
 477                 g_assert (context.method_inst);
 478         } else if ((ji->method->flags & METHOD_ATTRIBUTE_STATIC) || ji->method->klass->valuetype) {
 479                 MonoVTable *vtable = generic_info;
 480
 481                 class = vtable->klass;
 482         } else {
 483                 class = generic_info;
 484         }
 485
 486         //g_assert (!ji->method->klass->generic_container);
 487         if (ji->method->klass->generic_class)
 488                 method_container_class = ji->method->klass->generic_class->container_class;
 489         else
 490                 method_container_class = ji->method->klass;
 491
 492         /* class might refer to a subclass of ji->method's class */
 493         while (class->generic_class && class->generic_class->container_class != method_container_class) {
 494                 class = class->parent;
 495                 g_assert (class);
 496         }
 497
 498         if (class->generic_class || class->generic_container)
 499                 context.class_inst = mini_class_get_context (class)->class_inst;
 500
 501         if (class->generic_class)
 502                 g_assert (mono_class_has_parent_and_ignore_generics (class->generic_class->container_class, method_container_class));
 503         else
 504                 g_assert (mono_class_has_parent_and_ignore_generics (class, method_container_class));
 505
 506         return context;
 507 }
 508
 509 static MonoMethod*
 510 get_method_from_stack_frame (MonoJitInfo *ji, gpointer generic_info)
 511 {
 512         MonoGenericContext context;
 513         MonoMethod *method;
 514
 515         if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
 516                 return ji->method;
 517         context = get_generic_context_from_stack_frame (ji, generic_info);
 518
 519         method = mono_method_get_declaring_generic_method (ji->method);
 520         method = mono_class_inflate_generic_method (method, &context);
 521
 522         return method;
 523 }
 524
 525 MonoString *
 526 ves_icall_System_Exception_get_trace (MonoException *ex)
 527 {
 528         MonoDomain *domain = mono_domain_get ();
 529         MonoString *res;
 530         MonoArray *ta = ex->trace_ips;
 531         int i, len;
 532         GString *trace_str;
 533
 534         if (ta == NULL)
 535                 /* Exception is not thrown yet */
 536                 return NULL;
 537
 538         len = mono_array_length (ta) >> 1;
 539         trace_str = g_string_new ("");
 540         for (i = 0; i < len; i++) {
 541                 MonoJitInfo *ji;
 542                 gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
 543                 gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
 544
 545                 ji = mono_jit_info_table_find (domain, ip);
 546                 if (ji == NULL) {
 547                         /* Unmanaged frame */
 548                         g_string_append_printf (trace_str, "in (unmanaged) %p\n", ip);
 549                 } else {
 550                         gchar *location;
 551                         gint32 address;
 552                         MonoMethod *method = get_method_from_stack_frame (ji, generic_info);
 553
 554                         address = (char *)ip - (char *)ji->code_start;
 555                         location = mono_debug_print_stack_frame (
 556                                 method, address, ex->object.vtable->domain);
 557
 558                         g_string_append_printf (trace_str, "%s\n", location);
 559                         g_free (location);
 560                 }
 561         }
 562
 563         res = mono_string_new (ex->object.vtable->domain, trace_str->str);
 564         g_string_free (trace_str, TRUE);
 565
 566         return res;
 567 }
 568
 569 MonoArray *
 570 ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
 571 {
 572         MonoDomain *domain = mono_domain_get ();
 573         MonoArray *res;
 574         MonoArray *ta = exc->trace_ips;
 575         MonoDebugSourceLocation *location;
 576         int i, len;
 577
 578         if (ta == NULL) {
 579                 /* Exception is not thrown yet */
 580                 return mono_array_new (domain, mono_defaults.stack_frame_class, 0);
 581         }
 582
 583         len = mono_array_length (ta) >> 1;
 584
 585         res = mono_array_new (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0);
 586
 587         for (i = skip; i < len; i++) {
 588                 MonoJitInfo *ji;
 589                 MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
 590                 gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
 591                 gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
 592                 MonoMethod *method;
 593
 594                 ji = mono_jit_info_table_find (domain, ip);
 595                 if (ji == NULL) {
 596                         /* Unmanaged frame */
 597                         mono_array_setref (res, i, sf);
 598                         continue;
 599                 }
 600
 601                 g_assert (ji != NULL);
 602
 603                 method = get_method_from_stack_frame (ji, generic_info);
 604                 if (ji->method->wrapper_type) {
 605                         char *s;
 606
 607                         sf->method = NULL;
 608                         s = mono_method_full_name (method, TRUE);
 609                         MONO_OBJECT_SETREF (sf, internal_method_name, mono_string_new (domain, s));
 610                         g_free (s);
 611                 }
 612                 else
 613                         MONO_OBJECT_SETREF (sf, method, mono_method_get_object (domain, method, NULL));
 614                 sf->native_offset = (char *)ip - (char *)ji->code_start;
 615
 616                 /*
 617                  * mono_debug_lookup_source_location() returns both the file / line number information
 618                  * and the IL offset.  Note that computing the IL offset is already an expensive
 619                  * operation, so we shouldn't call this method twice.
 620                  */
 621                 location = mono_debug_lookup_source_location (ji->method, sf->native_offset, domain);
 622                 if (location)
 623                         sf->il_offset = location->il_offset;
 624                 else
 625                         sf->il_offset = 0;
 626
 627                 if (need_file_info) {
 628                         if (location && location->source_file) {
 629                                 MONO_OBJECT_SETREF (sf, filename, mono_string_new (domain, location->source_file));
 630                                 sf->line = location->row;
 631                                 sf->column = location->column;
 632                         } else {
 633                                 sf->line = sf->column = 0;
 634                                 sf->filename = NULL;
 635                         }
 636                 }
 637
 638                 mono_debug_free_source_location (location);
 639                 mono_array_setref (res, i, sf);
 640         }
 641
 642         return res;
 643 }
 644
 645 /**
 646  * mono_walk_stack:
 647  * @domain: starting appdomain
 648  * @jit_tls: JIT data for the thread
 649  * @start_ctx: starting state of the stack frame
 650  * @func: callback to call for each stack frame
 651  * @user_data: data passed to the callback
 652  *
 653  * This function walks the stack of a thread, starting from the state
 654  * represented by jit_tls and start_ctx. For each frame the callback
 655  * function is called with the relevant info. The walk ends when no more
 656  * managed stack frames are found or when the callback returns a TRUE value.
 657  * Note that the function can be used to walk the stack of a thread
 658  * different from the current.
 659  */
 660 void
 661 mono_walk_stack (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoContext *start_ctx, MonoStackFrameWalk func, gpointer user_data)
 662 {
 663         mono_walk_stack_full (domain, jit_tls, start_ctx, func, TRUE, user_data);
 664 }
 665
 666 static void
 667 mono_walk_stack_full (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoContext *start_ctx, MonoStackFrameWalk func, gboolean use_new_ctx, gpointer user_data)
 668 {
 669         MonoLMF *lmf = mono_get_lmf ();
 670         MonoJitInfo *ji, rji;
 671         gint native_offset;
 672         gboolean managed;
 673         MonoContext ctx, new_ctx;
 674
 675         ctx = *start_ctx;
 676
 677         while (MONO_CONTEXT_GET_SP (&ctx) < jit_tls->end_of_stack) {
 678                 /*
 679                  * FIXME: mono_find_jit_info () will need to be able to return a different
 680                  * MonoDomain when apddomain transitions are found on the stack.
 681                  */
 682                 ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, &native_offset, &managed);
 683                 if (!ji || ji == (gpointer)-1)
 684                         return;
 685
 686                 if (func (domain, use_new_ctx ? &new_ctx : &ctx, ji, user_data))
 687                         return;
 688
 689                 ctx = new_ctx;
 690         }
 691 }
 692
 693 void
 694 mono_jit_walk_stack_from_ctx (MonoStackWalk func, MonoContext *start_ctx, gboolean do_il_offset, gpointer user_data)
 695 {
 696         MonoDomain *domain = mono_domain_get ();
 697         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
 698         MonoLMF *lmf = mono_get_lmf ();
 699         MonoJitInfo *ji, rji;
 700         gint native_offset, il_offset;
 701         gboolean managed;
 702         MonoContext ctx, new_ctx;
 703
 704         MONO_ARCH_CONTEXT_DEF
 705
 706         mono_arch_flush_register_windows ();
 707
 708         if (start_ctx) {
 709                 memcpy (&ctx, start_ctx, sizeof (MonoContext));
 710         } else {
 711 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
 712         MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
 713 #else
 714     MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_jit_walk_stack_from_ctx);
 715 #endif
 716         }
 717
 718         while (MONO_CONTEXT_GET_SP (&ctx) < jit_tls->end_of_stack) {
 719                 ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, &native_offset, &managed);
 720                 g_assert (ji);
 721
 722                 if (ji == (gpointer)-1)
 723                         return;
 724
 725                 if (do_il_offset) {
 726                         MonoDebugSourceLocation *source;
 727
 728                         source = mono_debug_lookup_source_location (ji->method, native_offset, domain);
 729                         il_offset = source ? source->il_offset : -1;
 730                         mono_debug_free_source_location (source);
 731                 } else
 732                         il_offset = -1;
 733
 734                 if (func (ji->method, native_offset, il_offset, managed, user_data))
 735                         return;
 736
 737                 ctx = new_ctx;
 738         }
 739 }
 740
 741 void
 742 mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data)
 743 {
 744         mono_jit_walk_stack_from_ctx (func, NULL, do_il_offset, user_data);
 745 }
 746
 747 void
 748 mono_jit_walk_stack_from_ctx_in_thread (MonoJitStackWalk func, MonoDomain *domain, MonoContext *start_ctx, gboolean do_il_offset, MonoInternalThread *thread, MonoLMF *lmf, gpointer user_data)
 749 {
 750         MonoJitTlsData *jit_tls = thread->jit_data;
 751         gint il_offset;
 752         MonoContext ctx, new_ctx;
 753         StackFrameInfo frame;
 754 #ifndef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
 755         gint native_offset;
 756         gboolean managed;
 757         MonoJitInfo *ji, rji;
 758 #else
 759         gboolean res;
 760 #endif
 761
 762         MONO_ARCH_CONTEXT_DEF
 763
 764         mono_arch_flush_register_windows ();
 765
 766         if (start_ctx) {
 767                 memcpy (&ctx, start_ctx, sizeof (MonoContext));
 768         } else {
 769 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
 770                 MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
 771 #else
 772                 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_jit_walk_stack_from_ctx);
 773 #endif
 774                 g_assert (thread == mono_thread_internal_current ());
 775         }
 776
 777         while (MONO_CONTEXT_GET_SP (&ctx) < jit_tls->end_of_stack) {
 778                 frame.lmf = lmf;
 779 #ifdef MONO_ARCH_HAVE_FIND_JIT_INFO_EXT
 780                 res = mono_find_jit_info_ext (domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, &frame);
 781                 if (!res)
 782                         return;
 783 #else
 784                 ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, &native_offset, &managed);
 785                 g_assert (ji);
 786                 frame.type = FRAME_TYPE_MANAGED;
 787                 frame.ji = ji;
 788                 frame.managed = managed;
 789                 frame.native_offset = native_offset;
 790
 791                 if (ji == (gpointer)-1)
 792                         return;
 793 #endif
 794
 795                 if (do_il_offset && frame.ji) {
 796                         MonoDebugSourceLocation *source;
 797
 798                         source = mono_debug_lookup_source_location (frame.ji->method, frame.native_offset, domain);
 799                         il_offset = source ? source->il_offset : -1;
 800                         mono_debug_free_source_location (source);
 801                 } else
 802                         il_offset = -1;
 803
 804                 frame.il_offset = il_offset;
 805
 806                 if (func (&frame, &ctx, user_data))
 807                         return;
 808
 809                 ctx = new_ctx;
 810         }
 811 }
 812
 813
 814 MonoBoolean
 815 ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
 816                           MonoReflectionMethod **method,
 817                           gint32 *iloffset, gint32 *native_offset,
 818                           MonoString **file, gint32 *line, gint32 *column)
 819 {
 820         MonoDomain *domain = mono_domain_get ();
 821         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
 822         MonoLMF *lmf = mono_get_lmf ();
 823         MonoJitInfo *ji, rji;
 824         MonoContext ctx, new_ctx, ji_ctx;
 825         MonoDebugSourceLocation *location;
 826         MonoMethod *last_method = NULL, *actual_method;
 827
 828         MONO_ARCH_CONTEXT_DEF;
 829
 830         mono_arch_flush_register_windows ();
 831
 832 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
 833         MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
 834 #else
 835         MONO_INIT_CONTEXT_FROM_FUNC (&ctx, ves_icall_get_frame_info);
 836 #endif
 837
 838         do {
 839                 ji_ctx = ctx;
 840                 ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, (int*) native_offset, NULL);
 841                 ctx = new_ctx;
 842
 843                 if (ji && ji != (gpointer)-1 &&
 844                                 MONO_CONTEXT_GET_IP (&ctx) >= ji->code_start &&
 845                                 (guint8*)MONO_CONTEXT_GET_IP (&ctx) < (guint8*)ji->code_start + ji->code_size) {
 846                         ji_ctx = ctx;
 847                 }
 848
 849                 if (!ji || ji == (gpointer)-1 || MONO_CONTEXT_GET_SP (&ctx) >= jit_tls->end_of_stack)
 850                         return FALSE;
 851
 852                 /* skip all wrappers ??*/
 853                 if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
 854                     ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
 855                     ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
 856                     ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
 857                     ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE ||
 858                         ji->method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)
 859                         continue;
 860
 861                 if (ji->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE && ji->method == last_method) {
 862                         /*
 863                          * FIXME: Native-to-managed wrappers sometimes show up twice.
 864                          * Probably the whole mono_find_jit_info () stuff needs to be fixed so this
 865                          * isn't needed.
 866                          */
 867                         continue;
 868                 }
 869
 870                 last_method = ji->method;
 871
 872                 skip--;
 873
 874         } while (skip >= 0);
 875
 876         actual_method = get_method_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, &ji_ctx));
 877
 878         mono_gc_wbarrier_generic_store (method, (MonoObject*) mono_method_get_object (domain, actual_method, NULL));
 879
 880         location = mono_debug_lookup_source_location (ji->method, *native_offset, domain);
 881         if (location)
 882                 *iloffset = location->il_offset;
 883         else
 884                 *iloffset = 0;
 885
 886         if (need_file_info) {
 887                 if (location) {
 888                         mono_gc_wbarrier_generic_store (file, (MonoObject*) mono_string_new (domain, location->source_file));
 889                         *line = location->row;
 890                         *column = location->column;
 891                 } else {
 892                         *file = NULL;
 893                         *line = *column = 0;
 894                 }
 895         }
 896
 897         mono_debug_free_source_location (location);
 898
 899         return TRUE;
 900 }
 901
 902 typedef struct {
 903         guint32 skips;
 904         MonoSecurityFrame *frame;
 905 } MonoFrameSecurityInfo;
 906
 907 static gboolean
 908 callback_get_first_frame_security_info (MonoDomain *domain, MonoContext *ctx, MonoJitInfo *ji, gpointer data)
 909 {
 910         MonoFrameSecurityInfo *si = (MonoFrameSecurityInfo*) data;
 911
 912         /* FIXME: skip all wrappers ?? probably not - case by case testing is required */
 913         if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
 914             ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
 915             ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
 916             ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
 917             ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE) {
 918                 return FALSE;
 919         }
 920
 921         if (si->skips > 0) {
 922                 si->skips--;
 923                 return FALSE;
 924         }
 925
 926         si->frame = mono_declsec_create_frame (domain, ji);
 927
 928         /* Stop - we only want the first frame (e.g. LinkDemand and InheritanceDemand) */
 929         return TRUE;
 930 }
 931
 932 /**
 933  * ves_icall_System_Security_SecurityFrame_GetSecurityFrame:
 934  * @skip: the number of stack frames to skip
 935  *
 936  * This function returns a the security informations of a single stack frame
 937  * (after the skipped ones). This is required for [NonCas]LinkDemand[Choice]
 938  * and [NonCas]InheritanceDemand[Choice] as only the caller security is
 939  * evaluated.
 940  */
 941 MonoSecurityFrame*
 942 ves_icall_System_Security_SecurityFrame_GetSecurityFrame (gint32 skip)
 943 {
 944         MonoDomain *domain = mono_domain_get ();
 945         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
 946         MonoFrameSecurityInfo si;
 947         MonoContext ctx;
 948
 949         MONO_ARCH_CONTEXT_DEF
 950
 951 #ifdef MONO_INIT_CONTEXT_FROM_CURRENT
 952         MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
 953 #else
 954         MONO_INIT_CONTEXT_FROM_FUNC (&ctx, ves_icall_System_Security_SecurityFrame_GetSecurityFrame);
 955 #endif
 956
 957 #if     defined(__ia64__) || defined(__s390__) || defined(__s390x__)
 958         skip--;
 959 #endif
 960
 961         si.skips = skip;
 962         si.frame = NULL;
 963         mono_walk_stack (domain, jit_tls, &ctx, callback_get_first_frame_security_info, (gpointer)&si);
 964
 965         return (si.skips == 0) ? si.frame : NULL;
 966 }
 967
 968
 969 typedef struct {
 970         guint32 skips;
 971         MonoArray *stack;
 972         guint32 count;
 973         guint32 maximum;
 974 } MonoSecurityStack;
 975
 976 static void
 977 grow_array (MonoSecurityStack *stack)
 978 {
 979         MonoDomain *domain = mono_domain_get ();
 980         guint32 newsize = (stack->maximum << 1);
 981         MonoArray *newstack = mono_array_new (domain, mono_defaults.runtimesecurityframe_class, newsize);
 982         int i;
 983         for (i=0; i < stack->maximum; i++) {
 984                 gpointer frame = mono_array_get (stack->stack, gpointer, i);
 985                 mono_array_setref (newstack, i, frame);
 986         }
 987         stack->maximum = newsize;
 988         stack->stack = newstack;
 989 }
 990
 991 static gboolean
 992 callback_get_stack_frames_security_info (MonoDomain *domain, MonoContext *ctx, MonoJitInfo *ji, gpointer data)
 993 {
 994         MonoSecurityStack *ss = (MonoSecurityStack*) data;
 995
 996         /* FIXME: skip all wrappers ?? probably not - case by case testing is required */
 997         if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
 998             ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
 999             ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
1000             ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
1001             ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE) {
1002                 return FALSE;
1003         }
1004
1005         if (ss->skips > 0) {
1006                 ss->skips--;
1007                 return FALSE;
1008         }
1009
1010         if (ss->count == ss->maximum)
1011                 grow_array (ss);
1012
1013         mono_array_setref (ss->stack, ss->count++, mono_declsec_create_frame (domain, ji));
1014
1015         /* continue down the stack */
1016         return FALSE;
1017 }
1018
1019 static MonoArray *
1020 glist_to_array (GList *list, MonoClass *eclass)
1021 {
1022         MonoDomain *domain = mono_domain_get ();
1023         MonoArray *res;
1024         int len, i;
1025
1026         if (!list)
1027                 return NULL;
1028
1029         len = g_list_length (list);
1030         res = mono_array_new (domain, eclass, len);
1031
1032         for (i = 0; list; list = list->next, i++)
1033                 mono_array_set (res, gpointer, i, list->data);
1034
1035         return res;
1036 }
1037
1038 /**
1039  * ves_icall_System_Security_SecurityFrame_GetSecurityStack:
1040  * @skip: the number of stack frames to skip
1041  *
1042  * This function returns an managed array of containing the security
1043  * informations for each frame (after the skipped ones). This is used for
1044  * [NonCas]Demand[Choice] where the complete evaluation of the stack is
1045  * required.
1046  */
1047 MonoArray*
1048 ves_icall_System_Security_SecurityFrame_GetSecurityStack (gint32 skip)
1049 {
1050         MonoDomain *domain = mono_domain_get ();
1051         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1052         MonoSecurityStack ss;
1053         MonoContext ctx;
1054
1055         MONO_ARCH_CONTEXT_DEF
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_System_Security_SecurityFrame_GetSecurityStack);
1061 #endif
1062
1063 #if     defined(__ia64__) || defined(__s390__) || defined(__s390x__)
1064         skip--;
1065 #endif
1066
1067         ss.skips = skip;
1068         ss.count = 0;
1069         ss.maximum = MONO_CAS_INITIAL_STACK_SIZE;
1070         ss.stack = mono_array_new (domain, mono_defaults.runtimesecurityframe_class, ss.maximum);
1071         mono_walk_stack (domain, jit_tls, &ctx, callback_get_stack_frames_security_info, (gpointer)&ss);
1072         /* g_warning ("STACK RESULT: %d out of %d", ss.count, ss.maximum); */
1073         return ss.stack;
1074 }
1075
1076 static MonoClass*
1077 get_exception_catch_class (MonoJitExceptionInfo *ei, MonoJitInfo *ji, MonoContext *ctx)
1078 {
1079         MonoClass *catch_class = ei->data.catch_class;
1080         MonoType *inflated_type;
1081         MonoGenericContext context;
1082
1083         /*MonoJitExceptionInfo::data is an union used by filter and finally clauses too.*/
1084         if (!catch_class || ei->flags != MONO_EXCEPTION_CLAUSE_NONE)
1085                 return NULL;
1086
1087         if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
1088                 return catch_class;
1089         context = get_generic_context_from_stack_frame (ji, get_generic_info_from_stack_frame (ji, ctx));
1090
1091         /* FIXME: we shouldn't inflate but instead put the
1092            type in the rgctx and fetch it from there.  It
1093            might be a good idea to do this lazily, i.e. only
1094            when the exception is actually thrown, so as not to
1095            waste space for exception clauses which might never
1096            be encountered. */
1097         inflated_type = mono_class_inflate_generic_type (&catch_class->byval_arg, &context);
1098         catch_class = mono_class_from_mono_type (inflated_type);
1099         mono_metadata_free_type (inflated_type);
1100
1101         return catch_class;
1102 }
1103
1104 /*
1105  * mini_jit_info_table_find:
1106  *
1107  *   Same as mono_jit_info_table_find, but search all the domains of the current thread
1108  * if ADDR is not found in DOMAIN. The domain where the method was found is stored into
1109  * OUT_DOMAIN if it is not NULL.
1110  */
1111 MonoJitInfo*
1112 mini_jit_info_table_find (MonoDomain *domain, char *addr, MonoDomain **out_domain)
1113 {
1114         MonoJitInfo *ji;
1115         MonoInternalThread *t = mono_thread_internal_current ();
1116         GSList *l;
1117
1118         if (out_domain)
1119                 *out_domain = NULL;
1120
1121         ji = mono_jit_info_table_find (domain, addr);
1122         if (ji) {
1123                 if (out_domain)
1124                         *out_domain = domain;
1125                 return ji;
1126         }
1127
1128         /* maybe it is shared code, so we also search in the root domain */
1129         if (domain != mono_get_root_domain ()) {
1130                 ji = mono_jit_info_table_find (mono_get_root_domain (), addr);
1131                 if (ji) {
1132                         if (out_domain)
1133                                 *out_domain = mono_get_root_domain ();
1134                         return ji;
1135                 }
1136         }
1137
1138         for (l = t->appdomain_refs; l; l = l->next) {
1139                 if (l->data != domain) {
1140                         ji = mono_jit_info_table_find ((MonoDomain*)l->data, addr);
1141                         if (ji) {
1142                                 if (out_domain)
1143                                         *out_domain = (MonoDomain*)l->data;
1144                                 return ji;
1145                         }
1146                 }
1147         }
1148
1149         return NULL;
1150 }
1151
1152 /**
1153  * mono_handle_exception_internal:
1154  * @ctx: saved processor state
1155  * @obj: the exception object
1156  * @test_only: only test if the exception is caught, but dont call handlers
1157  * @out_filter_idx: out parameter. if test_only is true, set to the index of
1158  * the first filter clause which caught the exception.
1159  * @resume: whenever to resume unwinding based on the state in MonoJitTlsData.
1160  */
1161 static gboolean
1162 mono_handle_exception_internal (MonoContext *ctx, gpointer obj, gpointer original_ip, gboolean test_only, gboolean resume, gint32 *out_filter_idx, MonoJitInfo **out_ji)
1163 {
1164         MonoDomain *domain = mono_domain_get ();
1165         MonoJitInfo *ji, rji;
1166         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1167         static void (*restore_context) (void *);
1168         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1169         MonoLMF *lmf = mono_get_lmf ();
1170         MonoArray *initial_trace_ips = NULL;
1171         GList *trace_ips = NULL;
1172         MonoException *mono_ex;
1173         gboolean stack_overflow = FALSE;
1174         MonoContext initial_ctx;
1175         int frame_count = 0;
1176         gboolean has_dynamic_methods = FALSE;
1177         gint32 filter_idx, first_filter_idx;
1178
1179
1180         g_assert (ctx != NULL);
1181         if (!obj) {
1182                 MonoException *ex = mono_get_exception_null_reference ();
1183                 MONO_OBJECT_SETREF (ex, message, mono_string_new (domain, "Object reference not set to an instance of an object"));
1184                 obj = (MonoObject *)ex;
1185         }
1186
1187         /*
1188          * Allocate a new exception object instead of the preconstructed ones.
1189          */
1190         if (obj == domain->stack_overflow_ex) {
1191                 /*
1192                  * It is not a good idea to try and put even more pressure on the little stack available.
1193                  * obj = mono_get_exception_stack_overflow ();
1194                  */
1195                 stack_overflow = TRUE;
1196         }
1197         else if (obj == domain->null_reference_ex) {
1198                 obj = mono_get_exception_null_reference ();
1199         }
1200
1201         if (mono_object_isinst (obj, mono_defaults.exception_class)) {
1202                 mono_ex = (MonoException*)obj;
1203                 initial_trace_ips = mono_ex->trace_ips;
1204         } else {
1205                 mono_ex = NULL;
1206         }
1207
1208         if (mono_ex && jit_tls->class_cast_from && !strcmp (mono_ex->object.vtable->klass->name, "InvalidCastException")) {
1209                 char *from_name = mono_type_get_full_name (jit_tls->class_cast_from);
1210                 char *to_name = mono_type_get_full_name (jit_tls->class_cast_to);
1211                 char *msg = g_strdup_printf ("Unable to cast object of type '%s' to type '%s'.", from_name, to_name);
1212                 mono_ex->message = mono_string_new (domain, msg);
1213                 g_free (from_name);
1214                 g_free (to_name);
1215                 g_free (msg);
1216         }
1217
1218         if (!call_filter)
1219                 call_filter = mono_get_call_filter ();
1220
1221         if (!restore_context)
1222                 restore_context = mono_get_restore_context ();
1223
1224         g_assert (jit_tls->end_of_stack);
1225         g_assert (jit_tls->abort_func);
1226
1227         if (!test_only) {
1228                 MonoContext ctx_cp = *ctx;
1229                 if (mono_trace_is_enabled ()) {
1230                         MonoMethod *system_exception_get_message = mono_class_get_method_from_name (mono_defaults.exception_class, "get_Message", 0);
1231                         MonoMethod *get_message = system_exception_get_message == NULL ? NULL : mono_object_get_virtual_method (obj, system_exception_get_message);
1232                         MonoObject *message;
1233                         const char *type_name = mono_class_get_name (mono_object_class (mono_ex));
1234                         char *msg = NULL;
1235                         MonoObject *exc = NULL;
1236                         if (get_message == NULL) {
1237                                 message = NULL;
1238                         } else if (!strcmp (type_name, "OutOfMemoryException") || !strcmp (type_name, "StackOverflowException")) {
1239                                 message = NULL;
1240                                 msg = g_strdup_printf ("(No exception message for: %s)\n", type_name);
1241                         } else {
1242                                 message = mono_runtime_invoke (get_message, obj, NULL, &exc);
1243
1244                         }
1245                         if (msg == NULL) {
1246                                 msg = message ? mono_string_to_utf8 ((MonoString *) message) : g_strdup ("(System.Exception.Message property not available)");
1247                         }
1248                         g_print ("[%p:] EXCEPTION handling: %s.%s: %s\n", (void*)GetCurrentThreadId (), mono_object_class (obj)->name_space, mono_object_class (obj)->name, msg);
1249                         g_free (msg);
1250                         if (mono_ex && mono_trace_eval_exception (mono_object_class (mono_ex)))
1251                                 mono_print_thread_dump_from_ctx (ctx);
1252                 }
1253                 mono_profiler_exception_thrown (obj);
1254                 if (!mono_handle_exception_internal (&ctx_cp, obj, original_ip, TRUE, FALSE, &first_filter_idx, out_ji)) {
1255                         if (mono_break_on_exc)
1256                                 G_BREAKPOINT ();
1257                         mono_debugger_agent_handle_exception (obj, ctx, NULL);
1258                         // FIXME: This runs managed code so it might cause another stack overflow when
1259                         // we are handling a stack overflow
1260                         mono_unhandled_exception (obj);
1261                 } else {
1262                         mono_debugger_agent_handle_exception (obj, ctx, &ctx_cp);
1263                 }
1264         }
1265
1266         if (out_filter_idx)
1267                 *out_filter_idx = -1;
1268         if (out_ji)
1269                 *out_ji = NULL;
1270         filter_idx = 0;
1271         initial_ctx = *ctx;
1272         memset (&rji, 0, sizeof (rji));
1273
1274         while (1) {
1275                 MonoContext new_ctx;
1276                 guint32 free_stack;
1277
1278                 ji = mono_find_jit_info (domain, jit_tls, &rji, &rji, ctx, &new_ctx,
1279                                                                  NULL, &lmf, NULL, NULL);
1280                 if (!ji) {
1281                         g_warning ("Exception inside function without unwind info");
1282                         g_assert_not_reached ();
1283                 }
1284
1285                 if (ji != (gpointer)-1 && !(ji->code_start <= MONO_CONTEXT_GET_IP (ctx) && (((guint8*)ji->code_start + ji->code_size >= (guint8*)MONO_CONTEXT_GET_IP (ctx))))) {
1286                         /*
1287                          * The exception was raised in native code and we got back to managed code
1288                          * using the LMF.
1289                          */
1290                         *ctx = new_ctx;
1291                         continue;
1292                 }
1293
1294                 if (ji != (gpointer)-1) {
1295                         frame_count ++;
1296                         //printf ("M: %s %d %d.\n", mono_method_full_name (ji->method, TRUE), frame_count, test_only);
1297
1298                         if (test_only && ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
1299                                 /*
1300                                  * Avoid overwriting the stack trace if the exception is
1301                                  * rethrown. Also avoid giant stack traces during a stack
1302                                  * overflow.
1303                                  */
1304                                 if (!initial_trace_ips && (frame_count < 1000)) {
1305                                         trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
1306                                         trace_ips = g_list_prepend (trace_ips,
1307                                                 get_generic_info_from_stack_frame (ji, ctx));
1308                                 }
1309                         }
1310
1311                         if (ji->method->dynamic)
1312                                 has_dynamic_methods = TRUE;
1313
1314                         if (stack_overflow)
1315 #ifndef MONO_ARCH_STACK_GROWS_UP
1316                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx));
1317 #else
1318                                 free_stack = (guint8*)(MONO_CONTEXT_GET_SP (&initial_ctx)) - (guint8*)(MONO_CONTEXT_GET_SP (ctx));
1319 #endif
1320                         else
1321                                 free_stack = 0xffffff;
1322
1323                         /*
1324                          * During stack overflow, wait till the unwinding frees some stack
1325                          * space before running handlers/finalizers.
1326                          */
1327                         if ((free_stack > (64 * 1024)) && ji->num_clauses) {
1328                                 int i;
1329
1330                                 for (i = 0; i < ji->num_clauses; i++) {
1331                                         MonoJitExceptionInfo *ei = &ji->clauses [i];
1332                                         gboolean filtered = FALSE;
1333
1334 #if defined(__s390__)
1335                                         /*
1336                                          * This is required in cases where a try block starts immediately after
1337                                          * a call which causes an exception. Testcase: tests/exception8.cs.
1338                                          * FIXME: Clean this up.
1339                                          */
1340                                         if (ei->try_start < MONO_CONTEXT_GET_IP (ctx) && MONO_CONTEXT_GET_IP (ctx) <= ei->try_end) {
1341 #else
1342                                         if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx))) {
1343 #endif
1344                                                 /* catch block */
1345                                                 MonoClass *catch_class = get_exception_catch_class (ei, ji, ctx);
1346
1347                                                 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) || (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER)) {
1348                                                         if (ji->from_llvm) {
1349 #ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
1350                                                                 MONO_CONTEXT_SET_LLVM_EXC_REG (ctx, obj);
1351 #else
1352                                                                 g_assert_not_reached ();
1353 #endif
1354                                                         } else {
1355                                                                 /* store the exception object in bp + ei->exvar_offset */
1356                                                                 *((gpointer *)(gpointer)((char *)MONO_CONTEXT_GET_BP (ctx) + ei->exvar_offset)) = obj;
1357                                                         }
1358                                                 }
1359
1360                                                 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
1361                                                         if (test_only) {
1362                                                                 mono_perfcounters->exceptions_filters++;
1363                                                                 mono_debugger_call_exception_handler (ei->data.filter, MONO_CONTEXT_GET_SP (ctx), obj);
1364                                                                 filtered = call_filter (ctx, ei->data.filter);
1365                                                                 if (filtered && out_filter_idx)
1366                                                                         *out_filter_idx = filter_idx;
1367                                                                 if (out_ji)
1368                                                                         *out_ji = ji;
1369                                                         }
1370                                                         else {
1371                                                                 /*
1372                                                                  * Filter clauses should only be run in the
1373                                                                  * first pass of exception handling.
1374                                                                  */
1375                                                                 filtered = (filter_idx == first_filter_idx);
1376                                                         }
1377                                                         filter_idx ++;
1378                                                 }
1379
1380                                                 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
1381                                                      mono_object_isinst (obj, catch_class)) || filtered) {
1382                                                         if (test_only) {
1383                                                                 if (mono_ex && !initial_trace_ips) {
1384                                                                         trace_ips = g_list_reverse (trace_ips);
1385                                                                         MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
1386                                                                         if (has_dynamic_methods)
1387                                                                                 /* These methods could go away anytime, so compute the stack trace now */
1388                                                                                 MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
1389                                                                 }
1390                                                                 g_list_free (trace_ips);
1391
1392                                                                 return TRUE;
1393                                                         }
1394                                                         /*
1395                                                          * This guards against the situation that we abort a thread that is executing a finally clause
1396                                                          * that was called by the EH machinery. It won't have a guard trampoline installed, so we must
1397                                                          * check for this situation here and resume interruption if we are below the guarded block.
1398                                                          */
1399                                                         if (G_UNLIKELY (jit_tls->handler_block_return_address)) {
1400                                                                 gboolean is_outside = FALSE;
1401                                                                 gpointer prot_bp = MONO_CONTEXT_GET_BP (&jit_tls->ex_ctx);
1402                                                                 gpointer catch_bp = MONO_CONTEXT_GET_BP (ctx);
1403                                                                 //FIXME make this stack direction aware
1404                                                                 if (catch_bp > prot_bp) {
1405                                                                         is_outside = TRUE;
1406                                                                 } else if (catch_bp == prot_bp) {
1407                                                                         /* Can be either try { try { } catch {} } finally {} or try { try { } finally {} } catch {}
1408                                                                          * So we check if the catch handler_start is protected by the guarded handler protected region
1409                                                                          *
1410                                                                          * Assumptions:
1411                                                                          *      If there is an outstanding guarded_block return address, it means the current thread must be aborted.
1412                                                                          *      This is the only way to reach out the guarded block as other cases are handled by the trampoline.
1413                                                                          *      There aren't any further finally/fault handler blocks down the stack over this exception.
1414                                                                          *   This must be ensured by the code that installs the guard trampoline.
1415                                                                          */
1416                                                                         g_assert (ji == mini_jit_info_table_find (domain, MONO_CONTEXT_GET_IP (&jit_tls->ex_ctx), NULL));
1417
1418                                                                         if (!is_address_protected (ji, jit_tls->handler_block, ei->handler_start)) {
1419                                                                                 is_outside = TRUE;
1420                                                                         }
1421                                                                 }
1422                                                                 if (is_outside) {
1423                                                                         jit_tls->handler_block_return_address = NULL;
1424                                                                         jit_tls->handler_block = NULL;
1425                                                                         mono_thread_resume_interruption (); /*We ignore the exception here, it will be raised later*/
1426                                                                 }
1427                                                         }
1428
1429                                                         if (mono_trace_is_enabled () && mono_trace_eval (ji->method))
1430                                                                 g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
1431                                                         mono_profiler_exception_clause_handler (ji->method, ei->flags, i);
1432                                                         mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), obj);
1433                                                         MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1434                                                         *(mono_get_lmf_addr ()) = lmf;
1435                                                         mono_perfcounters->exceptions_depth += frame_count;
1436                                                         if (obj == domain->stack_overflow_ex)
1437                                                                 jit_tls->handling_stack_ovf = FALSE;
1438
1439                                                         return 0;
1440                                                 }
1441                                                 if (!test_only && is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx)) &&
1442                                                     (ei->flags == MONO_EXCEPTION_CLAUSE_FAULT)) {
1443                                                         if (mono_trace_is_enabled () && mono_trace_eval (ji->method))
1444                                                                 g_print ("EXCEPTION: fault clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
1445                                                         mono_profiler_exception_clause_handler (ji->method, ei->flags, i);
1446                                                         mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), obj);
1447                                                         call_filter (ctx, ei->handler_start);
1448                                                 }
1449                                                 if (!test_only && is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (ctx)) &&
1450                                                     (ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY)) {
1451                                                         if (mono_trace_is_enabled () && mono_trace_eval (ji->method))
1452                                                                 g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
1453                                                         mono_profiler_exception_clause_handler (ji->method, ei->flags, i);
1454                                                         mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), obj);
1455                                                         mono_perfcounters->exceptions_finallys++;
1456                                                         *(mono_get_lmf_addr ()) = lmf;
1457                                                         if (ji->from_llvm) {
1458                                                                 /*
1459                                                                  * LLVM compiled finally handlers follow the design
1460                                                                  * of the c++ ehabi, i.e. they call a resume function
1461                                                                  * at the end instead of returning to the caller.
1462                                                                  * So save the exception handling state,
1463                                                                  * mono_resume_unwind () will call us again to continue
1464                                                                  * the unwinding.
1465                                                                  */
1466                                                                 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1467                                                                 *(mono_get_lmf_addr ()) = lmf;
1468                                                                 jit_tls->ex_ctx = new_ctx;
1469                                                                 jit_tls->ex_obj = obj;
1470                                                                 return 0;
1471                                                         } else {
1472                                                                 call_filter (ctx, ei->handler_start);
1473                                                         }
1474                                                 }
1475
1476                                         }
1477                                 }
1478                         }
1479                         if (!test_only)
1480                                 mono_profiler_exception_method_leave (ji->method);
1481                 }
1482
1483                 *ctx = new_ctx;
1484
1485                 if (ji == (gpointer)-1) {
1486
1487                         if (!test_only) {
1488                                 *(mono_get_lmf_addr ()) = lmf;
1489
1490                                 jit_tls->abort_func (obj);
1491                                 g_assert_not_reached ();
1492                         } else {
1493                                 if (mono_ex && !initial_trace_ips) {
1494                                         trace_ips = g_list_reverse (trace_ips);
1495                                         MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
1496                                         if (has_dynamic_methods)
1497                                                 /* These methods could go away anytime, so compute the stack trace now */
1498                                                 MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
1499                                 }
1500                                 g_list_free (trace_ips);
1501                                 return FALSE;
1502                         }
1503                 }
1504         }
1505
1506         g_assert_not_reached ();
1507 }
1508
1509 /*
1510  * mono_debugger_handle_exception:
1511  *
1512  *  Notify the debugger about exceptions.  Returns TRUE if the debugger wants us to stop
1513  *  at the exception and FALSE to resume with the normal exception handling.
1514  *
1515  *  The arch code is responsible to setup @ctx in a way that MONO_CONTEXT_GET_IP () and
1516  *  MONO_CONTEXT_GET_SP () point to the throw instruction; ie. before executing the
1517  *  `callq throw' instruction.
1518  */
1519 gboolean
1520 mono_debugger_handle_exception (MonoContext *ctx, MonoObject *obj)
1521 {
1522         MonoDebuggerExceptionAction action;
1523
1524         if (!mono_debug_using_mono_debugger ())
1525                 return FALSE;
1526
1527         if (!obj) {
1528                 MonoException *ex = mono_get_exception_null_reference ();
1529                 MONO_OBJECT_SETREF (ex, message, mono_string_new (mono_domain_get (), "Object reference not set to an instance of an object"));
1530                 obj = (MonoObject *)ex;
1531         }
1532
1533         action = _mono_debugger_throw_exception (MONO_CONTEXT_GET_IP (ctx), MONO_CONTEXT_GET_SP (ctx), obj);
1534
1535         if (action == MONO_DEBUGGER_EXCEPTION_ACTION_STOP) {
1536                 /*
1537                  * The debugger wants us to stop on the `throw' instruction.
1538                  * By the time we get here, it already inserted a breakpoint there.
1539                  */
1540                 return TRUE;
1541         } else if (action == MONO_DEBUGGER_EXCEPTION_ACTION_STOP_UNHANDLED) {
1542                 MonoContext ctx_cp = *ctx;
1543                 MonoJitInfo *ji = NULL;
1544                 gboolean ret;
1545
1546                 /*
1547                  * The debugger wants us to stop only if this exception is user-unhandled.
1548                  */
1549
1550                 ret = mono_handle_exception_internal (&ctx_cp, obj, MONO_CONTEXT_GET_IP (ctx), TRUE, FALSE, NULL, &ji);
1551                 if (ret && (ji != NULL) && (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE)) {
1552                         /*
1553                          * The exception is handled in a runtime-invoke wrapper, that means that it's unhandled
1554                          * inside the method being invoked, so we handle it like a user-unhandled exception.
1555                          */
1556                         ret = FALSE;
1557                 }
1558
1559                 if (!ret) {
1560                         /*
1561                          * The exception is user-unhandled - tell the debugger to stop.
1562                          */
1563                         return _mono_debugger_unhandled_exception (MONO_CONTEXT_GET_IP (ctx), MONO_CONTEXT_GET_SP (ctx), obj);
1564                 }
1565
1566                 /*
1567                  * The exception is catched somewhere - resume with the normal exception handling and don't
1568                  * stop in the debugger.
1569                  */
1570         }
1571
1572         return FALSE;
1573 }
1574
1575 /**
1576  * mono_debugger_run_finally:
1577  * @start_ctx: saved processor state
1578  *
1579  * This method is called by the Mono Debugger to call all `finally' clauses of the
1580  * current stack frame.  It's used when the user issues a `return' command to make
1581  * the current stack frame return.  After returning from this method, the debugger
1582  * unwinds the stack one frame and gives control back to the user.
1583  *
1584  * NOTE: This method is only used when running inside the Mono Debugger.
1585  */
1586 void
1587 mono_debugger_run_finally (MonoContext *start_ctx)
1588 {
1589         static int (*call_filter) (MonoContext *, gpointer) = NULL;
1590         MonoDomain *domain = mono_domain_get ();
1591         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1592         MonoLMF *lmf = mono_get_lmf ();
1593         MonoContext ctx, new_ctx;
1594         MonoJitInfo *ji, rji;
1595         int i;
1596
1597         ctx = *start_ctx;
1598
1599         ji = mono_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, NULL);
1600         if (!ji || ji == (gpointer)-1)
1601                 return;
1602
1603         if (!call_filter)
1604                 call_filter = mono_get_call_filter ();
1605
1606         for (i = 0; i < ji->num_clauses; i++) {
1607                 MonoJitExceptionInfo *ei = &ji->clauses [i];
1608
1609                 if (is_address_protected (ji, ei, MONO_CONTEXT_GET_IP (&ctx)) &&
1610                     (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
1611                         call_filter (&ctx, ei->handler_start);
1612                 }
1613         }
1614 }
1615
1616 /**
1617  * mono_handle_exception:
1618  * @ctx: saved processor state
1619  * @obj: the exception object
1620  * @test_only: only test if the exception is caught, but dont call handlers
1621  */
1622 gboolean
1623 mono_handle_exception (MonoContext *ctx, gpointer obj, gpointer original_ip, gboolean test_only)
1624 {
1625         if (!test_only)
1626                 mono_perfcounters->exceptions_thrown++;
1627
1628         return mono_handle_exception_internal (ctx, obj, original_ip, test_only, FALSE, NULL, NULL);
1629 }
1630
1631 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
1632
1633 #ifndef MONO_ARCH_USE_SIGACTION
1634 #error "Can't use sigaltstack without sigaction"
1635 #endif
1636
1637 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
1638
1639 void
1640 mono_setup_altstack (MonoJitTlsData *tls)
1641 {
1642         size_t stsize = 0;
1643         struct sigaltstack sa;
1644         guint8 *staddr = NULL;
1645
1646         if (mono_running_on_valgrind ())
1647                 return;
1648
1649         mono_thread_get_stack_bounds (&staddr, &stsize);
1650
1651         g_assert (staddr);
1652
1653         tls->end_of_stack = staddr + stsize;
1654
1655         /*g_print ("thread %p, stack_base: %p, stack_size: %d\n", (gpointer)pthread_self (), staddr, stsize);*/
1656
1657         tls->stack_ovf_guard_base = staddr + mono_pagesize ();
1658         tls->stack_ovf_guard_size = ALIGN_TO (8 * 4096, mono_pagesize ());
1659
1660         if (mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_NONE)) {
1661                 /* mprotect can fail for the main thread stack */
1662                 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);
1663                 g_assert (gaddr == tls->stack_ovf_guard_base);
1664                 tls->stack_ovf_valloced = TRUE;
1665         }
1666
1667         /*
1668          * threads created by nptl does not seem to have a guard page, and
1669          * since the main thread is not created by us, we can't even set one.
1670          * Increasing stsize fools the SIGSEGV signal handler into thinking this
1671          * is a stack overflow exception.
1672          */
1673         tls->stack_size = stsize + mono_pagesize ();
1674
1675         /* Setup an alternate signal stack */
1676         tls->signal_stack = mono_valloc (0, MONO_ARCH_SIGNAL_STACK_SIZE, MONO_MMAP_READ|MONO_MMAP_WRITE|MONO_MMAP_PRIVATE|MONO_MMAP_ANON);
1677         tls->signal_stack_size = MONO_ARCH_SIGNAL_STACK_SIZE;
1678
1679         g_assert (tls->signal_stack);
1680
1681         sa.ss_sp = tls->signal_stack;
1682         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
1683         sa.ss_flags = SS_ONSTACK;
1684         sigaltstack (&sa, NULL);
1685 }
1686
1687 void
1688 mono_free_altstack (MonoJitTlsData *tls)
1689 {
1690         struct sigaltstack sa;
1691         int err;
1692
1693         sa.ss_sp = tls->signal_stack;
1694         sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
1695         sa.ss_flags = SS_DISABLE;
1696         err = sigaltstack  (&sa, NULL);
1697         g_assert (err == 0);
1698
1699         if (tls->signal_stack)
1700                 mono_vfree (tls->signal_stack, MONO_ARCH_SIGNAL_STACK_SIZE);
1701         if (tls->stack_ovf_valloced)
1702                 mono_vfree (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size);
1703         else
1704                 mono_mprotect (tls->stack_ovf_guard_base, tls->stack_ovf_guard_size, MONO_MMAP_READ|MONO_MMAP_WRITE);
1705 }
1706
1707 #else /* !MONO_ARCH_SIGSEGV_ON_ALTSTACK */
1708
1709 void
1710 mono_setup_altstack (MonoJitTlsData *tls)
1711 {
1712 }
1713
1714 void
1715 mono_free_altstack (MonoJitTlsData *tls)
1716 {
1717 }
1718
1719 #endif /* MONO_ARCH_SIGSEGV_ON_ALTSTACK */
1720
1721 static gboolean
1722 try_restore_stack_protection (MonoJitTlsData *jit_tls, int extra_bytes)
1723 {
1724         gint32 unprotect_size = jit_tls->stack_ovf_guard_size;
1725         /* we need to leave some room for throwing the exception */
1726         while (unprotect_size >= 0 && (char*)jit_tls->stack_ovf_guard_base + unprotect_size > ((char*)&unprotect_size - extra_bytes))
1727                 unprotect_size -= mono_pagesize ();
1728         /* at this point we could try and build a new domain->stack_overflow_ex, but only if there
1729          * is sufficient stack
1730          */
1731         //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);
1732         if (unprotect_size)
1733                 mono_mprotect (jit_tls->stack_ovf_guard_base, unprotect_size, MONO_MMAP_NONE);
1734         return unprotect_size == jit_tls->stack_ovf_guard_size;
1735 }
1736
1737 static void
1738 try_more_restore (void)
1739 {
1740         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1741         if (try_restore_stack_protection (jit_tls, 500))
1742                 jit_tls->restore_stack_prot = NULL;
1743 }
1744
1745 static void
1746 restore_stack_protection (void)
1747 {
1748         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1749         MonoException *ex = mono_domain_get ()->stack_overflow_ex;
1750         /* if we can't restore the stack protection, keep a callback installed so
1751          * we'll try to restore as much stack as we can at each return from unmanaged
1752          * code.
1753          */
1754         if (try_restore_stack_protection (jit_tls, 4096))
1755                 jit_tls->restore_stack_prot = NULL;
1756         else
1757                 jit_tls->restore_stack_prot = try_more_restore_tramp;
1758         /* here we also throw a stack overflow exception */
1759         ex->trace_ips = NULL;
1760         ex->stack_trace = NULL;
1761         mono_raise_exception (ex);
1762 }
1763
1764 gpointer
1765 mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
1766 {
1767         void (*func)(void) = (gpointer)tramp_data;
1768         func ();
1769         return NULL;
1770 }
1771
1772 gboolean
1773 mono_handle_soft_stack_ovf (MonoJitTlsData *jit_tls, MonoJitInfo *ji, void *ctx, guint8* fault_addr)
1774 {
1775         /* we got a stack overflow in the soft-guard pages
1776          * There are two cases:
1777          * 1) managed code caused the overflow: we unprotect the soft-guard page
1778          * and let the arch-specific code trigger the exception handling mechanism
1779          * in the thread stack. The soft-guard pages will be protected again as the stack is unwound.
1780          * 2) unmanaged code caused the overflow: we unprotect the soft-guard page
1781          * and hope we can continue with those enabled, at least until the hard-guard page
1782          * is hit. The alternative to continuing here is to just print a message and abort.
1783          * We may add in the future the code to protect the pages again in the codepath
1784          * when we return from unmanaged to managed code.
1785          */
1786         if (jit_tls->stack_ovf_guard_size && fault_addr >= (guint8*)jit_tls->stack_ovf_guard_base &&
1787                         fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + jit_tls->stack_ovf_guard_size) {
1788                 /* we unprotect the minimum amount we can */
1789                 guint32 guard_size;
1790                 gboolean handled = FALSE;
1791
1792                 guard_size = jit_tls->stack_ovf_guard_size - (mono_pagesize () * SIZEOF_VOID_P / 4);
1793                 while (guard_size && fault_addr < (guint8*)jit_tls->stack_ovf_guard_base + guard_size) {
1794                         guard_size -= mono_pagesize ();
1795                 }
1796                 guard_size = jit_tls->stack_ovf_guard_size - guard_size;
1797                 /*fprintf (stderr, "unprotecting: %d\n", guard_size);*/
1798                 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);
1799 #ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
1800                 if (ji) {
1801                         mono_arch_handle_altstack_exception (ctx, fault_addr, TRUE);
1802                         handled = TRUE;
1803                 }
1804 #endif
1805                 if (!handled) {
1806                         /* We print a message: after this even managed stack overflows
1807                          * may crash the runtime
1808                          */
1809                         fprintf (stderr, "Stack overflow in unmanaged: IP: %p, fault addr: %p\n", mono_arch_ip_from_context (ctx), fault_addr);
1810                         if (!jit_tls->handling_stack_ovf) {
1811                                 jit_tls->restore_stack_prot = restore_stack_protection_tramp;
1812                                 jit_tls->handling_stack_ovf = 1;
1813                         } else {
1814                                 /*fprintf (stderr, "Already handling stack overflow\n");*/
1815                         }
1816                 }
1817                 return TRUE;
1818         }
1819         return FALSE;
1820 }
1821
1822 static gboolean
1823 print_stack_frame (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed, gpointer data)
1824 {
1825         FILE *stream = (FILE*)data;
1826
1827         if (method) {
1828                 gchar *location = mono_debug_print_stack_frame (method, native_offset, mono_domain_get ());
1829                 fprintf (stream, "  %s\n", location);
1830                 g_free (location);
1831         } else
1832                 fprintf (stream, "  at <unknown> <0x%05x>\n", native_offset);
1833
1834         return FALSE;
1835 }
1836
1837 static G_GNUC_UNUSED gboolean
1838 print_stack_frame_to_string (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed,
1839                              gpointer data)
1840 {
1841         GString *p = (GString*)data;
1842
1843         if (method) {
1844                 gchar *location = mono_debug_print_stack_frame (method, native_offset, mono_domain_get ());
1845                 g_string_append_printf (p, "  %s\n", location);
1846                 g_free (location);
1847         } else
1848                 g_string_append_printf (p, "  at <unknown> <0x%05x>\n", native_offset);
1849
1850         return FALSE;
1851 }
1852
1853 static gboolean handling_sigsegv = FALSE;
1854
1855 /*
1856  * mono_handle_native_sigsegv:
1857  *
1858  *   Handle a SIGSEGV received while in native code by printing diagnostic
1859  * information and aborting.
1860  */
1861 void
1862 mono_handle_native_sigsegv (int signal, void *ctx)
1863 {
1864 #ifdef MONO_ARCH_USE_SIGACTION
1865         struct sigaction sa;
1866 #endif
1867         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
1868
1869         if (handling_sigsegv)
1870                 return;
1871
1872         if (mini_get_debug_options ()->suspend_on_sigsegv) {
1873                 fprintf (stderr, "Received SIGSEGV, suspending...");
1874                 while (1)
1875                         ;
1876         }
1877
1878         /* To prevent infinite loops when the stack walk causes a crash */
1879         handling_sigsegv = TRUE;
1880
1881         /* !jit_tls means the thread was not registered with the runtime */
1882         if (jit_tls && mono_thread_internal_current ()) {
1883                 fprintf (stderr, "Stacktrace:\n\n");
1884
1885                 mono_jit_walk_stack (print_stack_frame, TRUE, stderr);
1886
1887                 fflush (stderr);
1888         }
1889
1890 #ifdef HAVE_BACKTRACE_SYMBOLS
1891  {
1892         void *array [256];
1893         char **names;
1894         int i, size;
1895         const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
1896
1897         fprintf (stderr, "\nNative stacktrace:\n\n");
1898
1899         size = backtrace (array, 256);
1900         names = backtrace_symbols (array, size);
1901         for (i =0; i < size; ++i) {
1902                 fprintf (stderr, "\t%s\n", names [i]);
1903         }
1904         free (names);
1905
1906         fflush (stderr);
1907
1908         /* Try to get more meaningful information using gdb */
1909
1910 #if !defined(HOST_WIN32) && defined(HAVE_SYS_SYSCALL_H) && defined(SYS_fork)
1911         if (!mini_get_debug_options ()->no_gdb_backtrace && !mono_debug_using_mono_debugger ()) {
1912                 /* From g_spawn_command_line_sync () in eglib */
1913                 int res;
1914                 int stdout_pipe [2] = { -1, -1 };
1915                 pid_t pid;
1916                 int status;
1917                 char buffer [1024];
1918
1919                 res = pipe (stdout_pipe);
1920                 g_assert (res != -1);
1921
1922                 //pid = fork ();
1923                 /*
1924                  * glibc fork acquires some locks, so if the crash happened inside malloc/free,
1925                  * it will deadlock. Call the syscall directly instead.
1926                  */
1927                 pid = mono_runtime_syscall_fork ();
1928
1929                 if (pid == 0) {
1930                         close (stdout_pipe [0]);
1931                         dup2 (stdout_pipe [1], STDOUT_FILENO);
1932
1933                         for (i = getdtablesize () - 1; i >= 3; i--)
1934                                 close (i);
1935
1936                         if (!mono_gdb_render_native_backtraces ())
1937                                 close (STDOUT_FILENO);
1938
1939                         exit (1);
1940                 }
1941
1942                 close (stdout_pipe [1]);
1943
1944                 fprintf (stderr, "\nDebug info from gdb:\n\n");
1945
1946                 while (1) {
1947                         int nread = read (stdout_pipe [0], buffer, 1024);
1948
1949                         if (nread <= 0)
1950                                 break;
1951                         write (STDERR_FILENO, buffer, nread);
1952                 }
1953
1954                 waitpid (pid, &status, WNOHANG);
1955         }
1956 #endif
1957         /*
1958          * A SIGSEGV indicates something went very wrong so we can no longer depend
1959          * on anything working. So try to print out lots of diagnostics, starting
1960          * with ones which have a greater chance of working.
1961          */
1962         fprintf (stderr,
1963                          "\n"
1964                          "=================================================================\n"
1965                          "Got a %s while executing native code. This usually indicates\n"
1966                          "a fatal error in the mono runtime or one of the native libraries \n"
1967                          "used by your application.\n"
1968                          "=================================================================\n"
1969                          "\n", signal_str);
1970
1971  }
1972 #endif
1973
1974 #ifdef MONO_ARCH_USE_SIGACTION
1975
1976         /* Remove our SIGABRT handler */
1977         sa.sa_handler = SIG_DFL;
1978         sigemptyset (&sa.sa_mask);
1979         sa.sa_flags = 0;
1980
1981         g_assert (sigaction (SIGABRT, &sa, NULL) != -1);
1982
1983 #endif
1984
1985         abort ();
1986 }
1987
1988 static void
1989 mono_print_thread_dump_internal (void *sigctx, MonoContext *start_ctx)
1990 {
1991         MonoInternalThread *thread = mono_thread_internal_current ();
1992 #if defined(__i386__) || defined(__x86_64__)
1993         MonoContext ctx;
1994 #endif
1995         GString* text = g_string_new (0);
1996         char *name, *wapi_desc;
1997         GError *error = NULL;
1998
1999         if (thread->name) {
2000                 name = g_utf16_to_utf8 (thread->name, thread->name_len, NULL, NULL, &error);
2001                 g_assert (!error);
2002                 g_string_append_printf (text, "\n\"%s\"", name);
2003                 g_free (name);
2004         }
2005         else if (thread->threadpool_thread)
2006                 g_string_append (text, "\n\"<threadpool thread>\"");
2007         else
2008                 g_string_append (text, "\n\"<unnamed thread>\"");
2009
2010 #ifndef HOST_WIN32
2011         wapi_desc = wapi_current_thread_desc ();
2012         g_string_append_printf (text, " tid=0x%p this=0x%p %s\n", (gpointer)(gsize)thread->tid, thread,  wapi_desc);
2013         free (wapi_desc);
2014 #endif
2015
2016 #ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
2017         if (start_ctx) {
2018                 memcpy (&ctx, start_ctx, sizeof (MonoContext));
2019         } else if (!sigctx)
2020                 MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_print_thread_dump);
2021         else
2022                 mono_arch_sigctx_to_monoctx (sigctx, &ctx);
2023
2024         mono_jit_walk_stack_from_ctx (print_stack_frame_to_string, &ctx, TRUE, text);
2025 #else
2026         printf ("\t<Stack traces in thread dumps not supported on this platform>\n");
2027 #endif
2028
2029         fprintf (stdout, "%s", text->str);
2030         g_string_free (text, TRUE);
2031         fflush (stdout);
2032 }
2033
2034 /*
2035  * mono_print_thread_dump:
2036  *
2037  *   Print information about the current thread to stdout.
2038  * SIGCTX can be NULL, allowing this to be called from gdb.
2039  */
2040 void
2041 mono_print_thread_dump (void *sigctx)
2042 {
2043         mono_print_thread_dump_internal (sigctx, NULL);
2044 }
2045
2046 void
2047 mono_print_thread_dump_from_ctx (MonoContext *ctx)
2048 {
2049         mono_print_thread_dump_internal (NULL, ctx);
2050 }
2051
2052 /*
2053  * mono_resume_unwind:
2054  *
2055  *   This is called by code at the end of LLVM compiled finally clauses to continue
2056  * unwinding.
2057  */
2058 void
2059 mono_resume_unwind (void)
2060 {
2061         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
2062         static void (*restore_context) (MonoContext *);
2063         MonoContext ctx;
2064
2065         memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
2066
2067         mono_handle_exception_internal (&ctx, jit_tls->ex_obj, NULL, FALSE, TRUE, NULL, NULL);
2068
2069         if (!restore_context)
2070                 restore_context = mono_get_restore_context ();
2071
2072         restore_context (&ctx);
2073 }
2074
2075 #ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
2076
2077 typedef struct {
2078         MonoJitInfo *ji;
2079         MonoContext ctx;
2080         MonoJitExceptionInfo *ei;
2081 } FindHandlerBlockData;
2082
2083 static gboolean
2084 find_last_handler_block (MonoDomain *domain, MonoContext *ctx, MonoJitInfo *ji, gpointer data)
2085 {
2086         int i;
2087         gpointer ip;
2088         FindHandlerBlockData *pdata = data;
2089
2090         if (ji->method->wrapper_type)
2091                 return FALSE;
2092
2093         ip = MONO_CONTEXT_GET_IP (ctx);
2094
2095         for (i = 0; i < ji->num_clauses; ++i) {
2096                 MonoJitExceptionInfo *ei = ji->clauses + i;
2097                 if (ei->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2098                         continue;
2099                 /*If ip points to the first instruction it means the handler block didn't start
2100                  so we can leave its execution to the EH machinery*/
2101                 if (ei->handler_start < ip && ip < ei->data.handler_end) {
2102                         pdata->ji = ji;
2103                         pdata->ei = ei;
2104                         pdata->ctx = *ctx;
2105                         break;
2106                 }
2107         }
2108         return FALSE;
2109 }
2110
2111
2112 static gpointer
2113 install_handler_block_guard (MonoJitInfo *ji, MonoContext *ctx)
2114 {
2115         int i;
2116         MonoJitExceptionInfo *clause = NULL;
2117         gpointer ip;
2118
2119         ip = MONO_CONTEXT_GET_IP (ctx);
2120
2121         for (i = 0; i < ji->num_clauses; ++i) {
2122                 clause = &ji->clauses [i];
2123                 if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
2124                         continue;
2125                 if (clause->handler_start < ip && clause->data.handler_end > ip)
2126                         break;
2127         }
2128
2129         /*no matching finally */
2130         if (i == ji->num_clauses)
2131                 return NULL;
2132
2133         /*If we stopped on the instruction right before the try, we haven't actually started executing it*/
2134         if (ip == clause->handler_start)
2135                 return NULL;
2136
2137         return mono_arch_install_handler_block_guard (ji, clause, ctx, mono_create_handler_block_trampoline ());
2138 }
2139
2140 /*
2141  * Finds the bottom handler block running and install a block guard if needed.
2142  */
2143 gboolean
2144 mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx)
2145 {
2146         FindHandlerBlockData data = { 0 };
2147         MonoDomain *domain = mono_domain_get ();
2148         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
2149         gpointer resume_ip;
2150
2151         if (jit_tls->handler_block_return_address)
2152                 return FALSE;
2153
2154         mono_walk_stack_full (domain, jit_tls, ctx, find_last_handler_block, FALSE, &data);
2155
2156         if (!data.ji)
2157                 return FALSE;
2158
2159         memcpy (&jit_tls->ex_ctx, &data.ctx, sizeof (MonoContext));
2160
2161         resume_ip = install_handler_block_guard (data.ji, &data.ctx);
2162         if (resume_ip == NULL)
2163                 return FALSE;
2164
2165         jit_tls->handler_block_return_address = resume_ip;
2166         jit_tls->handler_block = data.ei;
2167
2168 #ifndef HOST_WIN32
2169         /*Clear current thread from been wapi interrupted otherwise things can go south*/
2170         wapi_clear_interruption ();
2171 #endif
2172         return TRUE;
2173 }
2174
2175 #else
2176 gboolean
2177 mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx)
2178 {
2179         return FALSE;
2180 }
2181
2182 #endif
2183