1 /* Implements exception handling. 2 Copyright (C) 1989-2013 Free Software Foundation, Inc. 3 Contributed by Mike Stump <mrs@cygnus.com>. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 22 /* An exception is an event that can be "thrown" from within a 23 function. This event can then be "caught" by the callers of 24 the function. 25 26 The representation of exceptions changes several times during 27 the compilation process: 28 29 In the beginning, in the front end, we have the GENERIC trees 30 TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR, 31 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR. 32 33 During initial gimplification (gimplify.c) these are lowered 34 to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes. 35 The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted 36 into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1 37 conversion. 38 39 During pass_lower_eh (tree-eh.c) we record the nested structure 40 of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE. 41 We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW 42 regions at this time. We can then flatten the statements within 43 the TRY nodes to straight-line code. Statements that had been within 44 TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE, 45 so that we may remember what action is supposed to be taken if 46 a given statement does throw. During this lowering process, 47 we create an EH_LANDING_PAD node for each EH_REGION that has 48 some code within the function that needs to be executed if a 49 throw does happen. We also create RESX statements that are 50 used to transfer control from an inner EH_REGION to an outer 51 EH_REGION. We also create EH_DISPATCH statements as placeholders 52 for a runtime type comparison that should be made in order to 53 select the action to perform among different CATCH and EH_FILTER 54 regions. 55 56 During pass_lower_eh_dispatch (tree-eh.c), which is run after 57 all inlining is complete, we are able to run assign_filter_values, 58 which allows us to map the set of types manipulated by all of the 59 CATCH and EH_FILTER regions to a set of integers. This set of integers 60 will be how the exception runtime communicates with the code generated 61 within the function. We then expand the GIMPLE_EH_DISPATCH statements 62 to a switch or conditional branches that use the argument provided by 63 the runtime (__builtin_eh_filter) and the set of integers we computed 64 in assign_filter_values. 65 66 During pass_lower_resx (tree-eh.c), which is run near the end 67 of optimization, we expand RESX statements. If the eh region 68 that is outer to the RESX statement is a MUST_NOT_THROW, then 69 the RESX expands to some form of abort statement. If the eh 70 region that is outer to the RESX statement is within the current 71 function, then the RESX expands to a bookkeeping call 72 (__builtin_eh_copy_values) and a goto. Otherwise, the next 73 handler for the exception must be within a function somewhere 74 up the call chain, so we call back into the exception runtime 75 (__builtin_unwind_resume). 76 77 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes 78 that create an rtl to eh_region mapping that corresponds to the 79 gimple to eh_region mapping that had been recorded in the 80 THROW_STMT_TABLE. 81 82 Then, via finish_eh_generation, we generate the real landing pads 83 to which the runtime will actually transfer control. These new 84 landing pads perform whatever bookkeeping is needed by the target 85 backend in order to resume execution within the current function. 86 Each of these new landing pads falls through into the post_landing_pad 87 label which had been used within the CFG up to this point. All 88 exception edges within the CFG are redirected to the new landing pads. 89 If the target uses setjmp to implement exceptions, the various extra 90 calls into the runtime to register and unregister the current stack 91 frame are emitted at this time. 92 93 During pass_convert_to_eh_region_ranges (except.c), we transform 94 the REG_EH_REGION notes attached to individual insns into 95 non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG 96 and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the 97 same associated action within the exception region tree, meaning 98 that (1) the exception is caught by the same landing pad within the 99 current function, (2) the exception is blocked by the runtime with 100 a MUST_NOT_THROW region, or (3) the exception is not handled at all 101 within the current function. 102 103 Finally, during assembly generation, we call 104 output_function_exception_table (except.c) to emit the tables with 105 which the exception runtime can determine if a given stack frame 106 handles a given exception, and if so what filter value to provide 107 to the function when the non-local control transfer is effected. 108 If the target uses dwarf2 unwinding to implement exceptions, then 109 output_call_frame_info (dwarf2out.c) emits the required unwind data. */ 110 111 112 #include "config.h" 113 #include "system.h" 114 #include "coretypes.h" 115 #include "tm.h" 116 #include "rtl.h" 117 #include "tree.h" 118 #include "flags.h" 119 #include "function.h" 120 #include "expr.h" 121 #include "libfuncs.h" 122 #include "insn-config.h" 123 #include "except.h" 124 #include "hard-reg-set.h" 125 #include "basic-block.h" 126 #include "output.h" 127 #include "dwarf2asm.h" 128 #include "dwarf2out.h" 129 #include "dwarf2.h" 130 #include "toplev.h" 131 #include "hashtab.h" 132 #include "intl.h" 133 #include "ggc.h" 134 #include "tm_p.h" 135 #include "target.h" 136 #include "common/common-target.h" 137 #include "langhooks.h" 138 #include "cgraph.h" 139 #include "diagnostic.h" 140 #include "tree-pretty-print.h" 141 #include "tree-pass.h" 142 #include "tree-flow.h" 143 #include "cfgloop.h" 144 145 /* Provide defaults for stuff that may not be defined when using 146 sjlj exceptions. */ 147 #ifndef EH_RETURN_DATA_REGNO 148 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM 149 #endif 150 151 static GTY(()) int call_site_base; 152 static GTY ((param_is (union tree_node))) 153 htab_t type_to_runtime_map; 154 155 /* Describe the SjLj_Function_Context structure. */ 156 static GTY(()) tree sjlj_fc_type_node; 157 static int sjlj_fc_call_site_ofs; 158 static int sjlj_fc_data_ofs; 159 static int sjlj_fc_personality_ofs; 160 static int sjlj_fc_lsda_ofs; 161 static int sjlj_fc_jbuf_ofs; 162 163 164 struct GTY(()) call_site_record_d 165 { 166 rtx landing_pad; 167 int action; 168 }; 169 170 static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *, 171 eh_landing_pad *); 172 173 static int t2r_eq (const void *, const void *); 174 static hashval_t t2r_hash (const void *); 175 176 static int ttypes_filter_eq (const void *, const void *); 177 static hashval_t ttypes_filter_hash (const void *); 178 static int ehspec_filter_eq (const void *, const void *); 179 static hashval_t ehspec_filter_hash (const void *); 180 static int add_ttypes_entry (htab_t, tree); 181 static int add_ehspec_entry (htab_t, htab_t, tree); 182 static void dw2_build_landing_pads (void); 183 184 static int action_record_eq (const void *, const void *); 185 static hashval_t action_record_hash (const void *); 186 static int add_action_record (htab_t, int, int); 187 static int collect_one_action_chain (htab_t, eh_region); 188 static int add_call_site (rtx, int, int); 189 190 static void push_uleb128 (vec<uchar, va_gc> **, unsigned int); 191 static void push_sleb128 (vec<uchar, va_gc> **, int); 192 #ifndef HAVE_AS_LEB128 193 static int dw2_size_of_call_site_table (int); 194 static int sjlj_size_of_call_site_table (void); 195 #endif 196 static void dw2_output_call_site_table (int, int); 197 static void sjlj_output_call_site_table (void); 198 199 200 void 201 init_eh (void) 202 { 203 if (! flag_exceptions) 204 return; 205 206 type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL); 207 208 /* Create the SjLj_Function_Context structure. This should match 209 the definition in unwind-sjlj.c. */ 210 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 211 { 212 tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp; 213 214 sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE); 215 216 f_prev = build_decl (BUILTINS_LOCATION, 217 FIELD_DECL, get_identifier ("__prev"), 218 build_pointer_type (sjlj_fc_type_node)); 219 DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node; 220 221 f_cs = build_decl (BUILTINS_LOCATION, 222 FIELD_DECL, get_identifier ("__call_site"), 223 integer_type_node); 224 DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node; 225 226 tmp = build_index_type (size_int (4 - 1)); 227 tmp = build_array_type (lang_hooks.types.type_for_mode 228 (targetm.unwind_word_mode (), 1), 229 tmp); 230 f_data = build_decl (BUILTINS_LOCATION, 231 FIELD_DECL, get_identifier ("__data"), tmp); 232 DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node; 233 234 f_per = build_decl (BUILTINS_LOCATION, 235 FIELD_DECL, get_identifier ("__personality"), 236 ptr_type_node); 237 DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node; 238 239 f_lsda = build_decl (BUILTINS_LOCATION, 240 FIELD_DECL, get_identifier ("__lsda"), 241 ptr_type_node); 242 DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node; 243 244 #ifdef DONT_USE_BUILTIN_SETJMP 245 #ifdef JMP_BUF_SIZE 246 tmp = size_int (JMP_BUF_SIZE - 1); 247 #else 248 /* Should be large enough for most systems, if it is not, 249 JMP_BUF_SIZE should be defined with the proper value. It will 250 also tend to be larger than necessary for most systems, a more 251 optimal port will define JMP_BUF_SIZE. */ 252 tmp = size_int (FIRST_PSEUDO_REGISTER + 2 - 1); 253 #endif 254 #else 255 /* builtin_setjmp takes a pointer to 5 words. */ 256 tmp = size_int (5 * BITS_PER_WORD / POINTER_SIZE - 1); 257 #endif 258 tmp = build_index_type (tmp); 259 tmp = build_array_type (ptr_type_node, tmp); 260 f_jbuf = build_decl (BUILTINS_LOCATION, 261 FIELD_DECL, get_identifier ("__jbuf"), tmp); 262 #ifdef DONT_USE_BUILTIN_SETJMP 263 /* We don't know what the alignment requirements of the 264 runtime's jmp_buf has. Overestimate. */ 265 DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT; 266 DECL_USER_ALIGN (f_jbuf) = 1; 267 #endif 268 DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node; 269 270 TYPE_FIELDS (sjlj_fc_type_node) = f_prev; 271 TREE_CHAIN (f_prev) = f_cs; 272 TREE_CHAIN (f_cs) = f_data; 273 TREE_CHAIN (f_data) = f_per; 274 TREE_CHAIN (f_per) = f_lsda; 275 TREE_CHAIN (f_lsda) = f_jbuf; 276 277 layout_type (sjlj_fc_type_node); 278 279 /* Cache the interesting field offsets so that we have 280 easy access from rtl. */ 281 sjlj_fc_call_site_ofs 282 = (tree_low_cst (DECL_FIELD_OFFSET (f_cs), 1) 283 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs), 1) / BITS_PER_UNIT); 284 sjlj_fc_data_ofs 285 = (tree_low_cst (DECL_FIELD_OFFSET (f_data), 1) 286 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data), 1) / BITS_PER_UNIT); 287 sjlj_fc_personality_ofs 288 = (tree_low_cst (DECL_FIELD_OFFSET (f_per), 1) 289 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per), 1) / BITS_PER_UNIT); 290 sjlj_fc_lsda_ofs 291 = (tree_low_cst (DECL_FIELD_OFFSET (f_lsda), 1) 292 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda), 1) / BITS_PER_UNIT); 293 sjlj_fc_jbuf_ofs 294 = (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf), 1) 295 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf), 1) / BITS_PER_UNIT); 296 } 297 } 298 299 void 300 init_eh_for_function (void) 301 { 302 cfun->eh = ggc_alloc_cleared_eh_status (); 303 304 /* Make sure zero'th entries are used. */ 305 vec_safe_push (cfun->eh->region_array, (eh_region)0); 306 vec_safe_push (cfun->eh->lp_array, (eh_landing_pad)0); 307 } 308 309 /* Routines to generate the exception tree somewhat directly. 310 These are used from tree-eh.c when processing exception related 311 nodes during tree optimization. */ 312 313 static eh_region 314 gen_eh_region (enum eh_region_type type, eh_region outer) 315 { 316 eh_region new_eh; 317 318 /* Insert a new blank region as a leaf in the tree. */ 319 new_eh = ggc_alloc_cleared_eh_region_d (); 320 new_eh->type = type; 321 new_eh->outer = outer; 322 if (outer) 323 { 324 new_eh->next_peer = outer->inner; 325 outer->inner = new_eh; 326 } 327 else 328 { 329 new_eh->next_peer = cfun->eh->region_tree; 330 cfun->eh->region_tree = new_eh; 331 } 332 333 new_eh->index = vec_safe_length (cfun->eh->region_array); 334 vec_safe_push (cfun->eh->region_array, new_eh); 335 336 /* Copy the language's notion of whether to use __cxa_end_cleanup. */ 337 if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup) 338 new_eh->use_cxa_end_cleanup = true; 339 340 return new_eh; 341 } 342 343 eh_region 344 gen_eh_region_cleanup (eh_region outer) 345 { 346 return gen_eh_region (ERT_CLEANUP, outer); 347 } 348 349 eh_region 350 gen_eh_region_try (eh_region outer) 351 { 352 return gen_eh_region (ERT_TRY, outer); 353 } 354 355 eh_catch 356 gen_eh_region_catch (eh_region t, tree type_or_list) 357 { 358 eh_catch c, l; 359 tree type_list, type_node; 360 361 gcc_assert (t->type == ERT_TRY); 362 363 /* Ensure to always end up with a type list to normalize further 364 processing, then register each type against the runtime types map. */ 365 type_list = type_or_list; 366 if (type_or_list) 367 { 368 if (TREE_CODE (type_or_list) != TREE_LIST) 369 type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE); 370 371 type_node = type_list; 372 for (; type_node; type_node = TREE_CHAIN (type_node)) 373 add_type_for_runtime (TREE_VALUE (type_node)); 374 } 375 376 c = ggc_alloc_cleared_eh_catch_d (); 377 c->type_list = type_list; 378 l = t->u.eh_try.last_catch; 379 c->prev_catch = l; 380 if (l) 381 l->next_catch = c; 382 else 383 t->u.eh_try.first_catch = c; 384 t->u.eh_try.last_catch = c; 385 386 return c; 387 } 388 389 eh_region 390 gen_eh_region_allowed (eh_region outer, tree allowed) 391 { 392 eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer); 393 region->u.allowed.type_list = allowed; 394 395 for (; allowed ; allowed = TREE_CHAIN (allowed)) 396 add_type_for_runtime (TREE_VALUE (allowed)); 397 398 return region; 399 } 400 401 eh_region 402 gen_eh_region_must_not_throw (eh_region outer) 403 { 404 return gen_eh_region (ERT_MUST_NOT_THROW, outer); 405 } 406 407 eh_landing_pad 408 gen_eh_landing_pad (eh_region region) 409 { 410 eh_landing_pad lp = ggc_alloc_cleared_eh_landing_pad_d (); 411 412 lp->next_lp = region->landing_pads; 413 lp->region = region; 414 lp->index = vec_safe_length (cfun->eh->lp_array); 415 region->landing_pads = lp; 416 417 vec_safe_push (cfun->eh->lp_array, lp); 418 419 return lp; 420 } 421 422 eh_region 423 get_eh_region_from_number_fn (struct function *ifun, int i) 424 { 425 return (*ifun->eh->region_array)[i]; 426 } 427 428 eh_region 429 get_eh_region_from_number (int i) 430 { 431 return get_eh_region_from_number_fn (cfun, i); 432 } 433 434 eh_landing_pad 435 get_eh_landing_pad_from_number_fn (struct function *ifun, int i) 436 { 437 return (*ifun->eh->lp_array)[i]; 438 } 439 440 eh_landing_pad 441 get_eh_landing_pad_from_number (int i) 442 { 443 return get_eh_landing_pad_from_number_fn (cfun, i); 444 } 445 446 eh_region 447 get_eh_region_from_lp_number_fn (struct function *ifun, int i) 448 { 449 if (i < 0) 450 return (*ifun->eh->region_array)[-i]; 451 else if (i == 0) 452 return NULL; 453 else 454 { 455 eh_landing_pad lp; 456 lp = (*ifun->eh->lp_array)[i]; 457 return lp->region; 458 } 459 } 460 461 eh_region 462 get_eh_region_from_lp_number (int i) 463 { 464 return get_eh_region_from_lp_number_fn (cfun, i); 465 } 466 467 /* Returns true if the current function has exception handling regions. */ 468 469 bool 470 current_function_has_exception_handlers (void) 471 { 472 return cfun->eh->region_tree != NULL; 473 } 474 475 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD. 476 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */ 477 478 struct duplicate_eh_regions_data 479 { 480 duplicate_eh_regions_map label_map; 481 void *label_map_data; 482 struct pointer_map_t *eh_map; 483 }; 484 485 static void 486 duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data, 487 eh_region old_r, eh_region outer) 488 { 489 eh_landing_pad old_lp, new_lp; 490 eh_region new_r; 491 void **slot; 492 493 new_r = gen_eh_region (old_r->type, outer); 494 slot = pointer_map_insert (data->eh_map, (void *)old_r); 495 gcc_assert (*slot == NULL); 496 *slot = (void *)new_r; 497 498 switch (old_r->type) 499 { 500 case ERT_CLEANUP: 501 break; 502 503 case ERT_TRY: 504 { 505 eh_catch oc, nc; 506 for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch) 507 { 508 /* We should be doing all our region duplication before and 509 during inlining, which is before filter lists are created. */ 510 gcc_assert (oc->filter_list == NULL); 511 nc = gen_eh_region_catch (new_r, oc->type_list); 512 nc->label = data->label_map (oc->label, data->label_map_data); 513 } 514 } 515 break; 516 517 case ERT_ALLOWED_EXCEPTIONS: 518 new_r->u.allowed.type_list = old_r->u.allowed.type_list; 519 if (old_r->u.allowed.label) 520 new_r->u.allowed.label 521 = data->label_map (old_r->u.allowed.label, data->label_map_data); 522 else 523 new_r->u.allowed.label = NULL_TREE; 524 break; 525 526 case ERT_MUST_NOT_THROW: 527 new_r->u.must_not_throw.failure_loc = 528 LOCATION_LOCUS (old_r->u.must_not_throw.failure_loc); 529 new_r->u.must_not_throw.failure_decl = 530 old_r->u.must_not_throw.failure_decl; 531 break; 532 } 533 534 for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp) 535 { 536 /* Don't bother copying unused landing pads. */ 537 if (old_lp->post_landing_pad == NULL) 538 continue; 539 540 new_lp = gen_eh_landing_pad (new_r); 541 slot = pointer_map_insert (data->eh_map, (void *)old_lp); 542 gcc_assert (*slot == NULL); 543 *slot = (void *)new_lp; 544 545 new_lp->post_landing_pad 546 = data->label_map (old_lp->post_landing_pad, data->label_map_data); 547 EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index; 548 } 549 550 /* Make sure to preserve the original use of __cxa_end_cleanup. */ 551 new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup; 552 553 for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer) 554 duplicate_eh_regions_1 (data, old_r, new_r); 555 } 556 557 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into 558 the current function and root the tree below OUTER_REGION. 559 The special case of COPY_REGION of NULL means all regions. 560 Remap labels using MAP/MAP_DATA callback. Return a pointer map 561 that allows the caller to remap uses of both EH regions and 562 EH landing pads. */ 563 564 struct pointer_map_t * 565 duplicate_eh_regions (struct function *ifun, 566 eh_region copy_region, int outer_lp, 567 duplicate_eh_regions_map map, void *map_data) 568 { 569 struct duplicate_eh_regions_data data; 570 eh_region outer_region; 571 572 #ifdef ENABLE_CHECKING 573 verify_eh_tree (ifun); 574 #endif 575 576 data.label_map = map; 577 data.label_map_data = map_data; 578 data.eh_map = pointer_map_create (); 579 580 outer_region = get_eh_region_from_lp_number (outer_lp); 581 582 /* Copy all the regions in the subtree. */ 583 if (copy_region) 584 duplicate_eh_regions_1 (&data, copy_region, outer_region); 585 else 586 { 587 eh_region r; 588 for (r = ifun->eh->region_tree; r ; r = r->next_peer) 589 duplicate_eh_regions_1 (&data, r, outer_region); 590 } 591 592 #ifdef ENABLE_CHECKING 593 verify_eh_tree (cfun); 594 #endif 595 596 return data.eh_map; 597 } 598 599 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */ 600 601 eh_region 602 eh_region_outermost (struct function *ifun, eh_region region_a, 603 eh_region region_b) 604 { 605 sbitmap b_outer; 606 607 gcc_assert (ifun->eh->region_array); 608 gcc_assert (ifun->eh->region_tree); 609 610 b_outer = sbitmap_alloc (ifun->eh->region_array->length()); 611 bitmap_clear (b_outer); 612 613 do 614 { 615 bitmap_set_bit (b_outer, region_b->index); 616 region_b = region_b->outer; 617 } 618 while (region_b); 619 620 do 621 { 622 if (bitmap_bit_p (b_outer, region_a->index)) 623 break; 624 region_a = region_a->outer; 625 } 626 while (region_a); 627 628 sbitmap_free (b_outer); 629 return region_a; 630 } 631 632 static int 633 t2r_eq (const void *pentry, const void *pdata) 634 { 635 const_tree const entry = (const_tree) pentry; 636 const_tree const data = (const_tree) pdata; 637 638 return TREE_PURPOSE (entry) == data; 639 } 640 641 static hashval_t 642 t2r_hash (const void *pentry) 643 { 644 const_tree const entry = (const_tree) pentry; 645 return TREE_HASH (TREE_PURPOSE (entry)); 646 } 647 648 void 649 add_type_for_runtime (tree type) 650 { 651 tree *slot; 652 653 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */ 654 if (TREE_CODE (type) == NOP_EXPR) 655 return; 656 657 slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type, 658 TREE_HASH (type), INSERT); 659 if (*slot == NULL) 660 { 661 tree runtime = lang_hooks.eh_runtime_type (type); 662 *slot = tree_cons (type, runtime, NULL_TREE); 663 } 664 } 665 666 tree 667 lookup_type_for_runtime (tree type) 668 { 669 tree *slot; 670 671 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */ 672 if (TREE_CODE (type) == NOP_EXPR) 673 return type; 674 675 slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type, 676 TREE_HASH (type), NO_INSERT); 677 678 /* We should have always inserted the data earlier. */ 679 return TREE_VALUE (*slot); 680 } 681 682 683 /* Represent an entry in @TTypes for either catch actions 684 or exception filter actions. */ 685 struct ttypes_filter { 686 tree t; 687 int filter; 688 }; 689 690 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA 691 (a tree) for a @TTypes type node we are thinking about adding. */ 692 693 static int 694 ttypes_filter_eq (const void *pentry, const void *pdata) 695 { 696 const struct ttypes_filter *const entry 697 = (const struct ttypes_filter *) pentry; 698 const_tree const data = (const_tree) pdata; 699 700 return entry->t == data; 701 } 702 703 static hashval_t 704 ttypes_filter_hash (const void *pentry) 705 { 706 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry; 707 return TREE_HASH (entry->t); 708 } 709 710 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes 711 exception specification list we are thinking about adding. */ 712 /* ??? Currently we use the type lists in the order given. Someone 713 should put these in some canonical order. */ 714 715 static int 716 ehspec_filter_eq (const void *pentry, const void *pdata) 717 { 718 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry; 719 const struct ttypes_filter *data = (const struct ttypes_filter *) pdata; 720 721 return type_list_equal (entry->t, data->t); 722 } 723 724 /* Hash function for exception specification lists. */ 725 726 static hashval_t 727 ehspec_filter_hash (const void *pentry) 728 { 729 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry; 730 hashval_t h = 0; 731 tree list; 732 733 for (list = entry->t; list ; list = TREE_CHAIN (list)) 734 h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list)); 735 return h; 736 } 737 738 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH 739 to speed up the search. Return the filter value to be used. */ 740 741 static int 742 add_ttypes_entry (htab_t ttypes_hash, tree type) 743 { 744 struct ttypes_filter **slot, *n; 745 746 slot = (struct ttypes_filter **) 747 htab_find_slot_with_hash (ttypes_hash, type, TREE_HASH (type), INSERT); 748 749 if ((n = *slot) == NULL) 750 { 751 /* Filter value is a 1 based table index. */ 752 753 n = XNEW (struct ttypes_filter); 754 n->t = type; 755 n->filter = vec_safe_length (cfun->eh->ttype_data) + 1; 756 *slot = n; 757 758 vec_safe_push (cfun->eh->ttype_data, type); 759 } 760 761 return n->filter; 762 } 763 764 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH 765 to speed up the search. Return the filter value to be used. */ 766 767 static int 768 add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list) 769 { 770 struct ttypes_filter **slot, *n; 771 struct ttypes_filter dummy; 772 773 dummy.t = list; 774 slot = (struct ttypes_filter **) 775 htab_find_slot (ehspec_hash, &dummy, INSERT); 776 777 if ((n = *slot) == NULL) 778 { 779 int len; 780 781 if (targetm.arm_eabi_unwinder) 782 len = vec_safe_length (cfun->eh->ehspec_data.arm_eabi); 783 else 784 len = vec_safe_length (cfun->eh->ehspec_data.other); 785 786 /* Filter value is a -1 based byte index into a uleb128 buffer. */ 787 788 n = XNEW (struct ttypes_filter); 789 n->t = list; 790 n->filter = -(len + 1); 791 *slot = n; 792 793 /* Generate a 0 terminated list of filter values. */ 794 for (; list ; list = TREE_CHAIN (list)) 795 { 796 if (targetm.arm_eabi_unwinder) 797 vec_safe_push (cfun->eh->ehspec_data.arm_eabi, TREE_VALUE (list)); 798 else 799 { 800 /* Look up each type in the list and encode its filter 801 value as a uleb128. */ 802 push_uleb128 (&cfun->eh->ehspec_data.other, 803 add_ttypes_entry (ttypes_hash, TREE_VALUE (list))); 804 } 805 } 806 if (targetm.arm_eabi_unwinder) 807 vec_safe_push (cfun->eh->ehspec_data.arm_eabi, NULL_TREE); 808 else 809 vec_safe_push (cfun->eh->ehspec_data.other, (uchar)0); 810 } 811 812 return n->filter; 813 } 814 815 /* Generate the action filter values to be used for CATCH and 816 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions, 817 we use lots of landing pads, and so every type or list can share 818 the same filter value, which saves table space. */ 819 820 void 821 assign_filter_values (void) 822 { 823 int i; 824 htab_t ttypes, ehspec; 825 eh_region r; 826 eh_catch c; 827 828 vec_alloc (cfun->eh->ttype_data, 16); 829 if (targetm.arm_eabi_unwinder) 830 vec_alloc (cfun->eh->ehspec_data.arm_eabi, 64); 831 else 832 vec_alloc (cfun->eh->ehspec_data.other, 64); 833 834 ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free); 835 ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free); 836 837 for (i = 1; vec_safe_iterate (cfun->eh->region_array, i, &r); ++i) 838 { 839 if (r == NULL) 840 continue; 841 842 switch (r->type) 843 { 844 case ERT_TRY: 845 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) 846 { 847 /* Whatever type_list is (NULL or true list), we build a list 848 of filters for the region. */ 849 c->filter_list = NULL_TREE; 850 851 if (c->type_list != NULL) 852 { 853 /* Get a filter value for each of the types caught and store 854 them in the region's dedicated list. */ 855 tree tp_node = c->type_list; 856 857 for ( ; tp_node; tp_node = TREE_CHAIN (tp_node)) 858 { 859 int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node)); 860 tree flt_node = build_int_cst (integer_type_node, flt); 861 862 c->filter_list 863 = tree_cons (NULL_TREE, flt_node, c->filter_list); 864 } 865 } 866 else 867 { 868 /* Get a filter value for the NULL list also since it 869 will need an action record anyway. */ 870 int flt = add_ttypes_entry (ttypes, NULL); 871 tree flt_node = build_int_cst (integer_type_node, flt); 872 873 c->filter_list 874 = tree_cons (NULL_TREE, flt_node, NULL); 875 } 876 } 877 break; 878 879 case ERT_ALLOWED_EXCEPTIONS: 880 r->u.allowed.filter 881 = add_ehspec_entry (ehspec, ttypes, r->u.allowed.type_list); 882 break; 883 884 default: 885 break; 886 } 887 } 888 889 htab_delete (ttypes); 890 htab_delete (ehspec); 891 } 892 893 /* Emit SEQ into basic block just before INSN (that is assumed to be 894 first instruction of some existing BB and return the newly 895 produced block. */ 896 static basic_block 897 emit_to_new_bb_before (rtx seq, rtx insn) 898 { 899 rtx last; 900 basic_block bb, prev_bb; 901 edge e; 902 edge_iterator ei; 903 904 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg 905 call), we don't want it to go into newly created landing pad or other EH 906 construct. */ 907 for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); ) 908 if (e->flags & EDGE_FALLTHRU) 909 force_nonfallthru (e); 910 else 911 ei_next (&ei); 912 last = emit_insn_before (seq, insn); 913 if (BARRIER_P (last)) 914 last = PREV_INSN (last); 915 prev_bb = BLOCK_FOR_INSN (insn)->prev_bb; 916 bb = create_basic_block (seq, last, prev_bb); 917 update_bb_for_insn (bb); 918 bb->flags |= BB_SUPERBLOCK; 919 return bb; 920 } 921 922 /* A subroutine of dw2_build_landing_pads, also used for edge splitting 923 at the rtl level. Emit the code required by the target at a landing 924 pad for the given region. */ 925 926 void 927 expand_dw2_landing_pad_for_region (eh_region region) 928 { 929 #ifdef HAVE_exception_receiver 930 if (HAVE_exception_receiver) 931 emit_insn (gen_exception_receiver ()); 932 else 933 #endif 934 #ifdef HAVE_nonlocal_goto_receiver 935 if (HAVE_nonlocal_goto_receiver) 936 emit_insn (gen_nonlocal_goto_receiver ()); 937 else 938 #endif 939 { /* Nothing */ } 940 941 if (region->exc_ptr_reg) 942 emit_move_insn (region->exc_ptr_reg, 943 gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0))); 944 if (region->filter_reg) 945 emit_move_insn (region->filter_reg, 946 gen_rtx_REG (targetm.eh_return_filter_mode (), 947 EH_RETURN_DATA_REGNO (1))); 948 } 949 950 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */ 951 952 static void 953 dw2_build_landing_pads (void) 954 { 955 int i; 956 eh_landing_pad lp; 957 int e_flags = EDGE_FALLTHRU; 958 959 /* If we're going to partition blocks, we need to be able to add 960 new landing pads later, which means that we need to hold on to 961 the post-landing-pad block. Prevent it from being merged away. 962 We'll remove this bit after partitioning. */ 963 if (flag_reorder_blocks_and_partition) 964 e_flags |= EDGE_PRESERVE; 965 966 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i) 967 { 968 basic_block bb; 969 rtx seq; 970 edge e; 971 972 if (lp == NULL || lp->post_landing_pad == NULL) 973 continue; 974 975 start_sequence (); 976 977 lp->landing_pad = gen_label_rtx (); 978 emit_label (lp->landing_pad); 979 LABEL_PRESERVE_P (lp->landing_pad) = 1; 980 981 expand_dw2_landing_pad_for_region (lp->region); 982 983 seq = get_insns (); 984 end_sequence (); 985 986 bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad)); 987 e = make_edge (bb, bb->next_bb, e_flags); 988 e->count = bb->count; 989 e->probability = REG_BR_PROB_BASE; 990 if (current_loops) 991 { 992 struct loop *loop = bb->next_bb->loop_father; 993 /* If we created a pre-header block, add the new block to the 994 outer loop, otherwise to the loop itself. */ 995 if (bb->next_bb == loop->header) 996 add_bb_to_loop (bb, loop_outer (loop)); 997 else 998 add_bb_to_loop (bb, loop); 999 } 1000 } 1001 } 1002 1003 1004 static vec<int> sjlj_lp_call_site_index; 1005 1006 /* Process all active landing pads. Assign each one a compact dispatch 1007 index, and a call-site index. */ 1008 1009 static int 1010 sjlj_assign_call_site_values (void) 1011 { 1012 htab_t ar_hash; 1013 int i, disp_index; 1014 eh_landing_pad lp; 1015 1016 vec_alloc (crtl->eh.action_record_data, 64); 1017 ar_hash = htab_create (31, action_record_hash, action_record_eq, free); 1018 1019 disp_index = 0; 1020 call_site_base = 1; 1021 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i) 1022 if (lp && lp->post_landing_pad) 1023 { 1024 int action, call_site; 1025 1026 /* First: build the action table. */ 1027 action = collect_one_action_chain (ar_hash, lp->region); 1028 1029 /* Next: assign call-site values. If dwarf2 terms, this would be 1030 the region number assigned by convert_to_eh_region_ranges, but 1031 handles no-action and must-not-throw differently. */ 1032 /* Map must-not-throw to otherwise unused call-site index 0. */ 1033 if (action == -2) 1034 call_site = 0; 1035 /* Map no-action to otherwise unused call-site index -1. */ 1036 else if (action == -1) 1037 call_site = -1; 1038 /* Otherwise, look it up in the table. */ 1039 else 1040 call_site = add_call_site (GEN_INT (disp_index), action, 0); 1041 sjlj_lp_call_site_index[i] = call_site; 1042 1043 disp_index++; 1044 } 1045 1046 htab_delete (ar_hash); 1047 1048 return disp_index; 1049 } 1050 1051 /* Emit code to record the current call-site index before every 1052 insn that can throw. */ 1053 1054 static void 1055 sjlj_mark_call_sites (void) 1056 { 1057 int last_call_site = -2; 1058 rtx insn, mem; 1059 1060 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn)) 1061 { 1062 eh_landing_pad lp; 1063 eh_region r; 1064 bool nothrow; 1065 int this_call_site; 1066 rtx before, p; 1067 1068 /* Reset value tracking at extended basic block boundaries. */ 1069 if (LABEL_P (insn)) 1070 last_call_site = -2; 1071 1072 if (! INSN_P (insn)) 1073 continue; 1074 1075 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp); 1076 if (nothrow) 1077 continue; 1078 if (lp) 1079 this_call_site = sjlj_lp_call_site_index[lp->index]; 1080 else if (r == NULL) 1081 { 1082 /* Calls (and trapping insns) without notes are outside any 1083 exception handling region in this function. Mark them as 1084 no action. */ 1085 this_call_site = -1; 1086 } 1087 else 1088 { 1089 gcc_assert (r->type == ERT_MUST_NOT_THROW); 1090 this_call_site = 0; 1091 } 1092 1093 if (this_call_site != -1) 1094 crtl->uses_eh_lsda = 1; 1095 1096 if (this_call_site == last_call_site) 1097 continue; 1098 1099 /* Don't separate a call from it's argument loads. */ 1100 before = insn; 1101 if (CALL_P (insn)) 1102 before = find_first_parameter_load (insn, NULL_RTX); 1103 1104 start_sequence (); 1105 mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node), 1106 sjlj_fc_call_site_ofs); 1107 emit_move_insn (mem, GEN_INT (this_call_site)); 1108 p = get_insns (); 1109 end_sequence (); 1110 1111 emit_insn_before (p, before); 1112 last_call_site = this_call_site; 1113 } 1114 } 1115 1116 /* Construct the SjLj_Function_Context. */ 1117 1118 static void 1119 sjlj_emit_function_enter (rtx dispatch_label) 1120 { 1121 rtx fn_begin, fc, mem, seq; 1122 bool fn_begin_outside_block; 1123 rtx personality = get_personality_function (current_function_decl); 1124 1125 fc = crtl->eh.sjlj_fc; 1126 1127 start_sequence (); 1128 1129 /* We're storing this libcall's address into memory instead of 1130 calling it directly. Thus, we must call assemble_external_libcall 1131 here, as we can not depend on emit_library_call to do it for us. */ 1132 assemble_external_libcall (personality); 1133 mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs); 1134 emit_move_insn (mem, personality); 1135 1136 mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs); 1137 if (crtl->uses_eh_lsda) 1138 { 1139 char buf[20]; 1140 rtx sym; 1141 1142 ASM_GENERATE_INTERNAL_LABEL (buf, "LLSDA", current_function_funcdef_no); 1143 sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf)); 1144 SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_LOCAL; 1145 emit_move_insn (mem, sym); 1146 } 1147 else 1148 emit_move_insn (mem, const0_rtx); 1149 1150 if (dispatch_label) 1151 { 1152 #ifdef DONT_USE_BUILTIN_SETJMP 1153 rtx x; 1154 x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE, 1155 TYPE_MODE (integer_type_node), 1, 1156 plus_constant (Pmode, XEXP (fc, 0), 1157 sjlj_fc_jbuf_ofs), Pmode); 1158 1159 emit_cmp_and_jump_insns (x, const0_rtx, NE, 0, 1160 TYPE_MODE (integer_type_node), 0, 1161 dispatch_label, REG_BR_PROB_BASE / 100); 1162 #else 1163 expand_builtin_setjmp_setup (plus_constant (Pmode, XEXP (fc, 0), 1164 sjlj_fc_jbuf_ofs), 1165 dispatch_label); 1166 #endif 1167 } 1168 1169 emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode, 1170 1, XEXP (fc, 0), Pmode); 1171 1172 seq = get_insns (); 1173 end_sequence (); 1174 1175 /* ??? Instead of doing this at the beginning of the function, 1176 do this in a block that is at loop level 0 and dominates all 1177 can_throw_internal instructions. */ 1178 1179 fn_begin_outside_block = true; 1180 for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin)) 1181 if (NOTE_P (fn_begin)) 1182 { 1183 if (NOTE_KIND (fn_begin) == NOTE_INSN_FUNCTION_BEG) 1184 break; 1185 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin)) 1186 fn_begin_outside_block = false; 1187 } 1188 1189 if (fn_begin_outside_block) 1190 insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR)); 1191 else 1192 emit_insn_after (seq, fn_begin); 1193 } 1194 1195 /* Call back from expand_function_end to know where we should put 1196 the call to unwind_sjlj_unregister_libfunc if needed. */ 1197 1198 void 1199 sjlj_emit_function_exit_after (rtx after) 1200 { 1201 crtl->eh.sjlj_exit_after = after; 1202 } 1203 1204 static void 1205 sjlj_emit_function_exit (void) 1206 { 1207 rtx seq, insn; 1208 1209 start_sequence (); 1210 1211 emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode, 1212 1, XEXP (crtl->eh.sjlj_fc, 0), Pmode); 1213 1214 seq = get_insns (); 1215 end_sequence (); 1216 1217 /* ??? Really this can be done in any block at loop level 0 that 1218 post-dominates all can_throw_internal instructions. This is 1219 the last possible moment. */ 1220 1221 insn = crtl->eh.sjlj_exit_after; 1222 if (LABEL_P (insn)) 1223 insn = NEXT_INSN (insn); 1224 1225 emit_insn_after (seq, insn); 1226 } 1227 1228 static void 1229 sjlj_emit_dispatch_table (rtx dispatch_label, int num_dispatch) 1230 { 1231 enum machine_mode unwind_word_mode = targetm.unwind_word_mode (); 1232 enum machine_mode filter_mode = targetm.eh_return_filter_mode (); 1233 eh_landing_pad lp; 1234 rtx mem, seq, fc, before, exc_ptr_reg, filter_reg; 1235 rtx first_reachable_label; 1236 basic_block bb; 1237 eh_region r; 1238 edge e; 1239 int i, disp_index; 1240 vec<tree> dispatch_labels = vNULL; 1241 1242 fc = crtl->eh.sjlj_fc; 1243 1244 start_sequence (); 1245 1246 emit_label (dispatch_label); 1247 1248 #ifndef DONT_USE_BUILTIN_SETJMP 1249 expand_builtin_setjmp_receiver (dispatch_label); 1250 1251 /* The caller of expand_builtin_setjmp_receiver is responsible for 1252 making sure that the label doesn't vanish. The only other caller 1253 is the expander for __builtin_setjmp_receiver, which places this 1254 label on the nonlocal_goto_label list. Since we're modeling these 1255 CFG edges more exactly, we can use the forced_labels list instead. */ 1256 LABEL_PRESERVE_P (dispatch_label) = 1; 1257 forced_labels 1258 = gen_rtx_EXPR_LIST (VOIDmode, dispatch_label, forced_labels); 1259 #endif 1260 1261 /* Load up exc_ptr and filter values from the function context. */ 1262 mem = adjust_address (fc, unwind_word_mode, sjlj_fc_data_ofs); 1263 if (unwind_word_mode != ptr_mode) 1264 { 1265 #ifdef POINTERS_EXTEND_UNSIGNED 1266 mem = convert_memory_address (ptr_mode, mem); 1267 #else 1268 mem = convert_to_mode (ptr_mode, mem, 0); 1269 #endif 1270 } 1271 exc_ptr_reg = force_reg (ptr_mode, mem); 1272 1273 mem = adjust_address (fc, unwind_word_mode, 1274 sjlj_fc_data_ofs + GET_MODE_SIZE (unwind_word_mode)); 1275 if (unwind_word_mode != filter_mode) 1276 mem = convert_to_mode (filter_mode, mem, 0); 1277 filter_reg = force_reg (filter_mode, mem); 1278 1279 /* Jump to one of the directly reachable regions. */ 1280 1281 disp_index = 0; 1282 first_reachable_label = NULL; 1283 1284 /* If there's exactly one call site in the function, don't bother 1285 generating a switch statement. */ 1286 if (num_dispatch > 1) 1287 dispatch_labels.create (num_dispatch); 1288 1289 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i) 1290 if (lp && lp->post_landing_pad) 1291 { 1292 rtx seq2, label; 1293 1294 start_sequence (); 1295 1296 lp->landing_pad = dispatch_label; 1297 1298 if (num_dispatch > 1) 1299 { 1300 tree t_label, case_elt, t; 1301 1302 t_label = create_artificial_label (UNKNOWN_LOCATION); 1303 t = build_int_cst (integer_type_node, disp_index); 1304 case_elt = build_case_label (t, NULL, t_label); 1305 dispatch_labels.quick_push (case_elt); 1306 label = label_rtx (t_label); 1307 } 1308 else 1309 label = gen_label_rtx (); 1310 1311 if (disp_index == 0) 1312 first_reachable_label = label; 1313 emit_label (label); 1314 1315 r = lp->region; 1316 if (r->exc_ptr_reg) 1317 emit_move_insn (r->exc_ptr_reg, exc_ptr_reg); 1318 if (r->filter_reg) 1319 emit_move_insn (r->filter_reg, filter_reg); 1320 1321 seq2 = get_insns (); 1322 end_sequence (); 1323 1324 before = label_rtx (lp->post_landing_pad); 1325 bb = emit_to_new_bb_before (seq2, before); 1326 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU); 1327 e->count = bb->count; 1328 e->probability = REG_BR_PROB_BASE; 1329 if (current_loops) 1330 { 1331 struct loop *loop = bb->next_bb->loop_father; 1332 /* If we created a pre-header block, add the new block to the 1333 outer loop, otherwise to the loop itself. */ 1334 if (bb->next_bb == loop->header) 1335 add_bb_to_loop (bb, loop_outer (loop)); 1336 else 1337 add_bb_to_loop (bb, loop); 1338 /* ??? For multiple dispatches we will end up with edges 1339 from the loop tree root into this loop, making it a 1340 multiple-entry loop. Discard all affected loops. */ 1341 if (num_dispatch > 1) 1342 { 1343 for (loop = bb->loop_father; 1344 loop_outer (loop); loop = loop_outer (loop)) 1345 { 1346 loop->header = NULL; 1347 loop->latch = NULL; 1348 } 1349 } 1350 } 1351 1352 disp_index++; 1353 } 1354 gcc_assert (disp_index == num_dispatch); 1355 1356 if (num_dispatch > 1) 1357 { 1358 rtx disp = adjust_address (fc, TYPE_MODE (integer_type_node), 1359 sjlj_fc_call_site_ofs); 1360 expand_sjlj_dispatch_table (disp, dispatch_labels); 1361 } 1362 1363 seq = get_insns (); 1364 end_sequence (); 1365 1366 bb = emit_to_new_bb_before (seq, first_reachable_label); 1367 if (num_dispatch == 1) 1368 { 1369 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU); 1370 e->count = bb->count; 1371 e->probability = REG_BR_PROB_BASE; 1372 if (current_loops) 1373 { 1374 struct loop *loop = bb->next_bb->loop_father; 1375 /* If we created a pre-header block, add the new block to the 1376 outer loop, otherwise to the loop itself. */ 1377 if (bb->next_bb == loop->header) 1378 add_bb_to_loop (bb, loop_outer (loop)); 1379 else 1380 add_bb_to_loop (bb, loop); 1381 } 1382 } 1383 else 1384 { 1385 /* We are not wiring up edges here, but as the dispatcher call 1386 is at function begin simply associate the block with the 1387 outermost (non-)loop. */ 1388 if (current_loops) 1389 add_bb_to_loop (bb, current_loops->tree_root); 1390 } 1391 } 1392 1393 static void 1394 sjlj_build_landing_pads (void) 1395 { 1396 int num_dispatch; 1397 1398 num_dispatch = vec_safe_length (cfun->eh->lp_array); 1399 if (num_dispatch == 0) 1400 return; 1401 sjlj_lp_call_site_index.safe_grow_cleared (num_dispatch); 1402 1403 num_dispatch = sjlj_assign_call_site_values (); 1404 if (num_dispatch > 0) 1405 { 1406 rtx dispatch_label = gen_label_rtx (); 1407 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node, 1408 TYPE_MODE (sjlj_fc_type_node), 1409 TYPE_ALIGN (sjlj_fc_type_node)); 1410 crtl->eh.sjlj_fc 1411 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node), 1412 int_size_in_bytes (sjlj_fc_type_node), 1413 align); 1414 1415 sjlj_mark_call_sites (); 1416 sjlj_emit_function_enter (dispatch_label); 1417 sjlj_emit_dispatch_table (dispatch_label, num_dispatch); 1418 sjlj_emit_function_exit (); 1419 } 1420 1421 /* If we do not have any landing pads, we may still need to register a 1422 personality routine and (empty) LSDA to handle must-not-throw regions. */ 1423 else if (function_needs_eh_personality (cfun) != eh_personality_none) 1424 { 1425 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node, 1426 TYPE_MODE (sjlj_fc_type_node), 1427 TYPE_ALIGN (sjlj_fc_type_node)); 1428 crtl->eh.sjlj_fc 1429 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node), 1430 int_size_in_bytes (sjlj_fc_type_node), 1431 align); 1432 1433 sjlj_mark_call_sites (); 1434 sjlj_emit_function_enter (NULL_RTX); 1435 sjlj_emit_function_exit (); 1436 } 1437 1438 sjlj_lp_call_site_index.release (); 1439 } 1440 1441 /* After initial rtl generation, call back to finish generating 1442 exception support code. */ 1443 1444 void 1445 finish_eh_generation (void) 1446 { 1447 basic_block bb; 1448 1449 /* Construct the landing pads. */ 1450 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 1451 sjlj_build_landing_pads (); 1452 else 1453 dw2_build_landing_pads (); 1454 break_superblocks (); 1455 1456 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ 1457 /* Kludge for Alpha (see alpha_gp_save_rtx). */ 1458 || single_succ_edge (ENTRY_BLOCK_PTR)->insns.r) 1459 commit_edge_insertions (); 1460 1461 /* Redirect all EH edges from the post_landing_pad to the landing pad. */ 1462 FOR_EACH_BB (bb) 1463 { 1464 eh_landing_pad lp; 1465 edge_iterator ei; 1466 edge e; 1467 1468 lp = get_eh_landing_pad_from_rtx (BB_END (bb)); 1469 1470 FOR_EACH_EDGE (e, ei, bb->succs) 1471 if (e->flags & EDGE_EH) 1472 break; 1473 1474 /* We should not have generated any new throwing insns during this 1475 pass, and we should not have lost any EH edges, so we only need 1476 to handle two cases here: 1477 (1) reachable handler and an existing edge to post-landing-pad, 1478 (2) no reachable handler and no edge. */ 1479 gcc_assert ((lp != NULL) == (e != NULL)); 1480 if (lp != NULL) 1481 { 1482 gcc_assert (BB_HEAD (e->dest) == label_rtx (lp->post_landing_pad)); 1483 1484 redirect_edge_succ (e, BLOCK_FOR_INSN (lp->landing_pad)); 1485 e->flags |= (CALL_P (BB_END (bb)) 1486 ? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL 1487 : EDGE_ABNORMAL); 1488 } 1489 } 1490 } 1491 1492 /* This section handles removing dead code for flow. */ 1493 1494 void 1495 remove_eh_landing_pad (eh_landing_pad lp) 1496 { 1497 eh_landing_pad *pp; 1498 1499 for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp) 1500 continue; 1501 *pp = lp->next_lp; 1502 1503 if (lp->post_landing_pad) 1504 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0; 1505 (*cfun->eh->lp_array)[lp->index] = NULL; 1506 } 1507 1508 /* Splice the EH region at PP from the region tree. */ 1509 1510 static void 1511 remove_eh_handler_splicer (eh_region *pp) 1512 { 1513 eh_region region = *pp; 1514 eh_landing_pad lp; 1515 1516 for (lp = region->landing_pads; lp ; lp = lp->next_lp) 1517 { 1518 if (lp->post_landing_pad) 1519 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0; 1520 (*cfun->eh->lp_array)[lp->index] = NULL; 1521 } 1522 1523 if (region->inner) 1524 { 1525 eh_region p, outer; 1526 outer = region->outer; 1527 1528 *pp = p = region->inner; 1529 do 1530 { 1531 p->outer = outer; 1532 pp = &p->next_peer; 1533 p = *pp; 1534 } 1535 while (p); 1536 } 1537 *pp = region->next_peer; 1538 1539 (*cfun->eh->region_array)[region->index] = NULL; 1540 } 1541 1542 /* Splice a single EH region REGION from the region tree. 1543 1544 To unlink REGION, we need to find the pointer to it with a relatively 1545 expensive search in REGION's outer region. If you are going to 1546 remove a number of handlers, using remove_unreachable_eh_regions may 1547 be a better option. */ 1548 1549 void 1550 remove_eh_handler (eh_region region) 1551 { 1552 eh_region *pp, *pp_start, p, outer; 1553 1554 outer = region->outer; 1555 if (outer) 1556 pp_start = &outer->inner; 1557 else 1558 pp_start = &cfun->eh->region_tree; 1559 for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp) 1560 continue; 1561 1562 remove_eh_handler_splicer (pp); 1563 } 1564 1565 /* Worker for remove_unreachable_eh_regions. 1566 PP is a pointer to the region to start a region tree depth-first 1567 search from. R_REACHABLE is the set of regions that have to be 1568 preserved. */ 1569 1570 static void 1571 remove_unreachable_eh_regions_worker (eh_region *pp, sbitmap r_reachable) 1572 { 1573 while (*pp) 1574 { 1575 eh_region region = *pp; 1576 remove_unreachable_eh_regions_worker (®ion->inner, r_reachable); 1577 if (!bitmap_bit_p (r_reachable, region->index)) 1578 remove_eh_handler_splicer (pp); 1579 else 1580 pp = ®ion->next_peer; 1581 } 1582 } 1583 1584 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree. 1585 Do this by traversing the EH tree top-down and splice out regions that 1586 are not marked. By removing regions from the leaves, we avoid costly 1587 searches in the region tree. */ 1588 1589 void 1590 remove_unreachable_eh_regions (sbitmap r_reachable) 1591 { 1592 remove_unreachable_eh_regions_worker (&cfun->eh->region_tree, r_reachable); 1593 } 1594 1595 /* Invokes CALLBACK for every exception handler landing pad label. 1596 Only used by reload hackery; should not be used by new code. */ 1597 1598 void 1599 for_each_eh_label (void (*callback) (rtx)) 1600 { 1601 eh_landing_pad lp; 1602 int i; 1603 1604 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i) 1605 { 1606 if (lp) 1607 { 1608 rtx lab = lp->landing_pad; 1609 if (lab && LABEL_P (lab)) 1610 (*callback) (lab); 1611 } 1612 } 1613 } 1614 1615 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a 1616 call insn. 1617 1618 At the gimple level, we use LP_NR 1619 > 0 : The statement transfers to landing pad LP_NR 1620 = 0 : The statement is outside any EH region 1621 < 0 : The statement is within MUST_NOT_THROW region -LP_NR. 1622 1623 At the rtl level, we use LP_NR 1624 > 0 : The insn transfers to landing pad LP_NR 1625 = 0 : The insn cannot throw 1626 < 0 : The insn is within MUST_NOT_THROW region -LP_NR 1627 = INT_MIN : The insn cannot throw or execute a nonlocal-goto. 1628 missing note: The insn is outside any EH region. 1629 1630 ??? This difference probably ought to be avoided. We could stand 1631 to record nothrow for arbitrary gimple statements, and so avoid 1632 some moderately complex lookups in stmt_could_throw_p. Perhaps 1633 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the 1634 no-nonlocal-goto property should be recorded elsewhere as a bit 1635 on the call_insn directly. Perhaps we should make more use of 1636 attaching the trees to call_insns (reachable via symbol_ref in 1637 direct call cases) and just pull the data out of the trees. */ 1638 1639 void 1640 make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr) 1641 { 1642 rtx value; 1643 if (ecf_flags & ECF_NOTHROW) 1644 value = const0_rtx; 1645 else if (lp_nr != 0) 1646 value = GEN_INT (lp_nr); 1647 else 1648 return; 1649 add_reg_note (insn, REG_EH_REGION, value); 1650 } 1651 1652 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw 1653 nor perform a non-local goto. Replace the region note if it 1654 already exists. */ 1655 1656 void 1657 make_reg_eh_region_note_nothrow_nononlocal (rtx insn) 1658 { 1659 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); 1660 rtx intmin = GEN_INT (INT_MIN); 1661 1662 if (note != 0) 1663 XEXP (note, 0) = intmin; 1664 else 1665 add_reg_note (insn, REG_EH_REGION, intmin); 1666 } 1667 1668 /* Return true if INSN could throw, assuming no REG_EH_REGION note 1669 to the contrary. */ 1670 1671 bool 1672 insn_could_throw_p (const_rtx insn) 1673 { 1674 if (!flag_exceptions) 1675 return false; 1676 if (CALL_P (insn)) 1677 return true; 1678 if (INSN_P (insn) && cfun->can_throw_non_call_exceptions) 1679 return may_trap_p (PATTERN (insn)); 1680 return false; 1681 } 1682 1683 /* Copy an REG_EH_REGION note to each insn that might throw beginning 1684 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn 1685 to look for a note, or the note itself. */ 1686 1687 void 1688 copy_reg_eh_region_note_forward (rtx note_or_insn, rtx first, rtx last) 1689 { 1690 rtx insn, note = note_or_insn; 1691 1692 if (INSN_P (note_or_insn)) 1693 { 1694 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX); 1695 if (note == NULL) 1696 return; 1697 } 1698 note = XEXP (note, 0); 1699 1700 for (insn = first; insn != last ; insn = NEXT_INSN (insn)) 1701 if (!find_reg_note (insn, REG_EH_REGION, NULL_RTX) 1702 && insn_could_throw_p (insn)) 1703 add_reg_note (insn, REG_EH_REGION, note); 1704 } 1705 1706 /* Likewise, but iterate backward. */ 1707 1708 void 1709 copy_reg_eh_region_note_backward (rtx note_or_insn, rtx last, rtx first) 1710 { 1711 rtx insn, note = note_or_insn; 1712 1713 if (INSN_P (note_or_insn)) 1714 { 1715 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX); 1716 if (note == NULL) 1717 return; 1718 } 1719 note = XEXP (note, 0); 1720 1721 for (insn = last; insn != first; insn = PREV_INSN (insn)) 1722 if (insn_could_throw_p (insn)) 1723 add_reg_note (insn, REG_EH_REGION, note); 1724 } 1725 1726 1727 /* Extract all EH information from INSN. Return true if the insn 1728 was marked NOTHROW. */ 1729 1730 static bool 1731 get_eh_region_and_lp_from_rtx (const_rtx insn, eh_region *pr, 1732 eh_landing_pad *plp) 1733 { 1734 eh_landing_pad lp = NULL; 1735 eh_region r = NULL; 1736 bool ret = false; 1737 rtx note; 1738 int lp_nr; 1739 1740 if (! INSN_P (insn)) 1741 goto egress; 1742 1743 if (NONJUMP_INSN_P (insn) 1744 && GET_CODE (PATTERN (insn)) == SEQUENCE) 1745 insn = XVECEXP (PATTERN (insn), 0, 0); 1746 1747 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); 1748 if (!note) 1749 { 1750 ret = !insn_could_throw_p (insn); 1751 goto egress; 1752 } 1753 1754 lp_nr = INTVAL (XEXP (note, 0)); 1755 if (lp_nr == 0 || lp_nr == INT_MIN) 1756 { 1757 ret = true; 1758 goto egress; 1759 } 1760 1761 if (lp_nr < 0) 1762 r = (*cfun->eh->region_array)[-lp_nr]; 1763 else 1764 { 1765 lp = (*cfun->eh->lp_array)[lp_nr]; 1766 r = lp->region; 1767 } 1768 1769 egress: 1770 *plp = lp; 1771 *pr = r; 1772 return ret; 1773 } 1774 1775 /* Return the landing pad to which INSN may go, or NULL if it does not 1776 have a reachable landing pad within this function. */ 1777 1778 eh_landing_pad 1779 get_eh_landing_pad_from_rtx (const_rtx insn) 1780 { 1781 eh_landing_pad lp; 1782 eh_region r; 1783 1784 get_eh_region_and_lp_from_rtx (insn, &r, &lp); 1785 return lp; 1786 } 1787 1788 /* Return the region to which INSN may go, or NULL if it does not 1789 have a reachable region within this function. */ 1790 1791 eh_region 1792 get_eh_region_from_rtx (const_rtx insn) 1793 { 1794 eh_landing_pad lp; 1795 eh_region r; 1796 1797 get_eh_region_and_lp_from_rtx (insn, &r, &lp); 1798 return r; 1799 } 1800 1801 /* Return true if INSN throws and is caught by something in this function. */ 1802 1803 bool 1804 can_throw_internal (const_rtx insn) 1805 { 1806 return get_eh_landing_pad_from_rtx (insn) != NULL; 1807 } 1808 1809 /* Return true if INSN throws and escapes from the current function. */ 1810 1811 bool 1812 can_throw_external (const_rtx insn) 1813 { 1814 eh_landing_pad lp; 1815 eh_region r; 1816 bool nothrow; 1817 1818 if (! INSN_P (insn)) 1819 return false; 1820 1821 if (NONJUMP_INSN_P (insn) 1822 && GET_CODE (PATTERN (insn)) == SEQUENCE) 1823 { 1824 rtx seq = PATTERN (insn); 1825 int i, n = XVECLEN (seq, 0); 1826 1827 for (i = 0; i < n; i++) 1828 if (can_throw_external (XVECEXP (seq, 0, i))) 1829 return true; 1830 1831 return false; 1832 } 1833 1834 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp); 1835 1836 /* If we can't throw, we obviously can't throw external. */ 1837 if (nothrow) 1838 return false; 1839 1840 /* If we have an internal landing pad, then we're not external. */ 1841 if (lp != NULL) 1842 return false; 1843 1844 /* If we're not within an EH region, then we are external. */ 1845 if (r == NULL) 1846 return true; 1847 1848 /* The only thing that ought to be left is MUST_NOT_THROW regions, 1849 which don't always have landing pads. */ 1850 gcc_assert (r->type == ERT_MUST_NOT_THROW); 1851 return false; 1852 } 1853 1854 /* Return true if INSN cannot throw at all. */ 1855 1856 bool 1857 insn_nothrow_p (const_rtx insn) 1858 { 1859 eh_landing_pad lp; 1860 eh_region r; 1861 1862 if (! INSN_P (insn)) 1863 return true; 1864 1865 if (NONJUMP_INSN_P (insn) 1866 && GET_CODE (PATTERN (insn)) == SEQUENCE) 1867 { 1868 rtx seq = PATTERN (insn); 1869 int i, n = XVECLEN (seq, 0); 1870 1871 for (i = 0; i < n; i++) 1872 if (!insn_nothrow_p (XVECEXP (seq, 0, i))) 1873 return false; 1874 1875 return true; 1876 } 1877 1878 return get_eh_region_and_lp_from_rtx (insn, &r, &lp); 1879 } 1880 1881 /* Return true if INSN can perform a non-local goto. */ 1882 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */ 1883 1884 bool 1885 can_nonlocal_goto (const_rtx insn) 1886 { 1887 if (nonlocal_goto_handler_labels && CALL_P (insn)) 1888 { 1889 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); 1890 if (!note || INTVAL (XEXP (note, 0)) != INT_MIN) 1891 return true; 1892 } 1893 return false; 1894 } 1895 1896 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */ 1897 1898 static unsigned int 1899 set_nothrow_function_flags (void) 1900 { 1901 rtx insn; 1902 1903 crtl->nothrow = 1; 1904 1905 /* Assume crtl->all_throwers_are_sibcalls until we encounter 1906 something that can throw an exception. We specifically exempt 1907 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps, 1908 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this 1909 is optimistic. */ 1910 1911 crtl->all_throwers_are_sibcalls = 1; 1912 1913 /* If we don't know that this implementation of the function will 1914 actually be used, then we must not set TREE_NOTHROW, since 1915 callers must not assume that this function does not throw. */ 1916 if (TREE_NOTHROW (current_function_decl)) 1917 return 0; 1918 1919 if (! flag_exceptions) 1920 return 0; 1921 1922 for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) 1923 if (can_throw_external (insn)) 1924 { 1925 crtl->nothrow = 0; 1926 1927 if (!CALL_P (insn) || !SIBLING_CALL_P (insn)) 1928 { 1929 crtl->all_throwers_are_sibcalls = 0; 1930 return 0; 1931 } 1932 } 1933 1934 if (crtl->nothrow 1935 && (cgraph_function_body_availability (cgraph_get_node 1936 (current_function_decl)) 1937 >= AVAIL_AVAILABLE)) 1938 { 1939 struct cgraph_node *node = cgraph_get_node (current_function_decl); 1940 struct cgraph_edge *e; 1941 for (e = node->callers; e; e = e->next_caller) 1942 e->can_throw_external = false; 1943 cgraph_set_nothrow_flag (node, true); 1944 1945 if (dump_file) 1946 fprintf (dump_file, "Marking function nothrow: %s\n\n", 1947 current_function_name ()); 1948 } 1949 return 0; 1950 } 1951 1952 struct rtl_opt_pass pass_set_nothrow_function_flags = 1953 { 1954 { 1955 RTL_PASS, 1956 "nothrow", /* name */ 1957 OPTGROUP_NONE, /* optinfo_flags */ 1958 NULL, /* gate */ 1959 set_nothrow_function_flags, /* execute */ 1960 NULL, /* sub */ 1961 NULL, /* next */ 1962 0, /* static_pass_number */ 1963 TV_NONE, /* tv_id */ 1964 0, /* properties_required */ 1965 0, /* properties_provided */ 1966 0, /* properties_destroyed */ 1967 0, /* todo_flags_start */ 1968 0 /* todo_flags_finish */ 1969 } 1970 }; 1971 1972 1973 /* Various hooks for unwind library. */ 1974 1975 /* Expand the EH support builtin functions: 1976 __builtin_eh_pointer and __builtin_eh_filter. */ 1977 1978 static eh_region 1979 expand_builtin_eh_common (tree region_nr_t) 1980 { 1981 HOST_WIDE_INT region_nr; 1982 eh_region region; 1983 1984 gcc_assert (host_integerp (region_nr_t, 0)); 1985 region_nr = tree_low_cst (region_nr_t, 0); 1986 1987 region = (*cfun->eh->region_array)[region_nr]; 1988 1989 /* ??? We shouldn't have been able to delete a eh region without 1990 deleting all the code that depended on it. */ 1991 gcc_assert (region != NULL); 1992 1993 return region; 1994 } 1995 1996 /* Expand to the exc_ptr value from the given eh region. */ 1997 1998 rtx 1999 expand_builtin_eh_pointer (tree exp) 2000 { 2001 eh_region region 2002 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0)); 2003 if (region->exc_ptr_reg == NULL) 2004 region->exc_ptr_reg = gen_reg_rtx (ptr_mode); 2005 return region->exc_ptr_reg; 2006 } 2007 2008 /* Expand to the filter value from the given eh region. */ 2009 2010 rtx 2011 expand_builtin_eh_filter (tree exp) 2012 { 2013 eh_region region 2014 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0)); 2015 if (region->filter_reg == NULL) 2016 region->filter_reg = gen_reg_rtx (targetm.eh_return_filter_mode ()); 2017 return region->filter_reg; 2018 } 2019 2020 /* Copy the exc_ptr and filter values from one landing pad's registers 2021 to another. This is used to inline the resx statement. */ 2022 2023 rtx 2024 expand_builtin_eh_copy_values (tree exp) 2025 { 2026 eh_region dst 2027 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0)); 2028 eh_region src 2029 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1)); 2030 enum machine_mode fmode = targetm.eh_return_filter_mode (); 2031 2032 if (dst->exc_ptr_reg == NULL) 2033 dst->exc_ptr_reg = gen_reg_rtx (ptr_mode); 2034 if (src->exc_ptr_reg == NULL) 2035 src->exc_ptr_reg = gen_reg_rtx (ptr_mode); 2036 2037 if (dst->filter_reg == NULL) 2038 dst->filter_reg = gen_reg_rtx (fmode); 2039 if (src->filter_reg == NULL) 2040 src->filter_reg = gen_reg_rtx (fmode); 2041 2042 emit_move_insn (dst->exc_ptr_reg, src->exc_ptr_reg); 2043 emit_move_insn (dst->filter_reg, src->filter_reg); 2044 2045 return const0_rtx; 2046 } 2047 2048 /* Do any necessary initialization to access arbitrary stack frames. 2049 On the SPARC, this means flushing the register windows. */ 2050 2051 void 2052 expand_builtin_unwind_init (void) 2053 { 2054 /* Set this so all the registers get saved in our frame; we need to be 2055 able to copy the saved values for any registers from frames we unwind. */ 2056 crtl->saves_all_registers = 1; 2057 2058 #ifdef SETUP_FRAME_ADDRESSES 2059 SETUP_FRAME_ADDRESSES (); 2060 #endif 2061 } 2062 2063 /* Map a non-negative number to an eh return data register number; expands 2064 to -1 if no return data register is associated with the input number. 2065 At least the inputs 0 and 1 must be mapped; the target may provide more. */ 2066 2067 rtx 2068 expand_builtin_eh_return_data_regno (tree exp) 2069 { 2070 tree which = CALL_EXPR_ARG (exp, 0); 2071 unsigned HOST_WIDE_INT iwhich; 2072 2073 if (TREE_CODE (which) != INTEGER_CST) 2074 { 2075 error ("argument of %<__builtin_eh_return_regno%> must be constant"); 2076 return constm1_rtx; 2077 } 2078 2079 iwhich = tree_low_cst (which, 1); 2080 iwhich = EH_RETURN_DATA_REGNO (iwhich); 2081 if (iwhich == INVALID_REGNUM) 2082 return constm1_rtx; 2083 2084 #ifdef DWARF_FRAME_REGNUM 2085 iwhich = DWARF_FRAME_REGNUM (iwhich); 2086 #else 2087 iwhich = DBX_REGISTER_NUMBER (iwhich); 2088 #endif 2089 2090 return GEN_INT (iwhich); 2091 } 2092 2093 /* Given a value extracted from the return address register or stack slot, 2094 return the actual address encoded in that value. */ 2095 2096 rtx 2097 expand_builtin_extract_return_addr (tree addr_tree) 2098 { 2099 rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL); 2100 2101 if (GET_MODE (addr) != Pmode 2102 && GET_MODE (addr) != VOIDmode) 2103 { 2104 #ifdef POINTERS_EXTEND_UNSIGNED 2105 addr = convert_memory_address (Pmode, addr); 2106 #else 2107 addr = convert_to_mode (Pmode, addr, 0); 2108 #endif 2109 } 2110 2111 /* First mask out any unwanted bits. */ 2112 #ifdef MASK_RETURN_ADDR 2113 expand_and (Pmode, addr, MASK_RETURN_ADDR, addr); 2114 #endif 2115 2116 /* Then adjust to find the real return address. */ 2117 #if defined (RETURN_ADDR_OFFSET) 2118 addr = plus_constant (Pmode, addr, RETURN_ADDR_OFFSET); 2119 #endif 2120 2121 return addr; 2122 } 2123 2124 /* Given an actual address in addr_tree, do any necessary encoding 2125 and return the value to be stored in the return address register or 2126 stack slot so the epilogue will return to that address. */ 2127 2128 rtx 2129 expand_builtin_frob_return_addr (tree addr_tree) 2130 { 2131 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL); 2132 2133 addr = convert_memory_address (Pmode, addr); 2134 2135 #ifdef RETURN_ADDR_OFFSET 2136 addr = force_reg (Pmode, addr); 2137 addr = plus_constant (Pmode, addr, -RETURN_ADDR_OFFSET); 2138 #endif 2139 2140 return addr; 2141 } 2142 2143 /* Set up the epilogue with the magic bits we'll need to return to the 2144 exception handler. */ 2145 2146 void 2147 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED, 2148 tree handler_tree) 2149 { 2150 rtx tmp; 2151 2152 #ifdef EH_RETURN_STACKADJ_RTX 2153 tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj, 2154 VOIDmode, EXPAND_NORMAL); 2155 tmp = convert_memory_address (Pmode, tmp); 2156 if (!crtl->eh.ehr_stackadj) 2157 crtl->eh.ehr_stackadj = copy_to_reg (tmp); 2158 else if (tmp != crtl->eh.ehr_stackadj) 2159 emit_move_insn (crtl->eh.ehr_stackadj, tmp); 2160 #endif 2161 2162 tmp = expand_expr (handler_tree, crtl->eh.ehr_handler, 2163 VOIDmode, EXPAND_NORMAL); 2164 tmp = convert_memory_address (Pmode, tmp); 2165 if (!crtl->eh.ehr_handler) 2166 crtl->eh.ehr_handler = copy_to_reg (tmp); 2167 else if (tmp != crtl->eh.ehr_handler) 2168 emit_move_insn (crtl->eh.ehr_handler, tmp); 2169 2170 if (!crtl->eh.ehr_label) 2171 crtl->eh.ehr_label = gen_label_rtx (); 2172 emit_jump (crtl->eh.ehr_label); 2173 } 2174 2175 /* Expand __builtin_eh_return. This exit path from the function loads up 2176 the eh return data registers, adjusts the stack, and branches to a 2177 given PC other than the normal return address. */ 2178 2179 void 2180 expand_eh_return (void) 2181 { 2182 rtx around_label; 2183 2184 if (! crtl->eh.ehr_label) 2185 return; 2186 2187 crtl->calls_eh_return = 1; 2188 2189 #ifdef EH_RETURN_STACKADJ_RTX 2190 emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx); 2191 #endif 2192 2193 around_label = gen_label_rtx (); 2194 emit_jump (around_label); 2195 2196 emit_label (crtl->eh.ehr_label); 2197 clobber_return_register (); 2198 2199 #ifdef EH_RETURN_STACKADJ_RTX 2200 emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj); 2201 #endif 2202 2203 #ifdef HAVE_eh_return 2204 if (HAVE_eh_return) 2205 emit_insn (gen_eh_return (crtl->eh.ehr_handler)); 2206 else 2207 #endif 2208 { 2209 #ifdef EH_RETURN_HANDLER_RTX 2210 emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler); 2211 #else 2212 error ("__builtin_eh_return not supported on this target"); 2213 #endif 2214 } 2215 2216 emit_label (around_label); 2217 } 2218 2219 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by 2220 POINTERS_EXTEND_UNSIGNED and return it. */ 2221 2222 rtx 2223 expand_builtin_extend_pointer (tree addr_tree) 2224 { 2225 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL); 2226 int extend; 2227 2228 #ifdef POINTERS_EXTEND_UNSIGNED 2229 extend = POINTERS_EXTEND_UNSIGNED; 2230 #else 2231 /* The previous EH code did an unsigned extend by default, so we do this also 2232 for consistency. */ 2233 extend = 1; 2234 #endif 2235 2236 return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend); 2237 } 2238 2239 /* In the following functions, we represent entries in the action table 2240 as 1-based indices. Special cases are: 2241 2242 0: null action record, non-null landing pad; implies cleanups 2243 -1: null action record, null landing pad; implies no action 2244 -2: no call-site entry; implies must_not_throw 2245 -3: we have yet to process outer regions 2246 2247 Further, no special cases apply to the "next" field of the record. 2248 For next, 0 means end of list. */ 2249 2250 struct action_record 2251 { 2252 int offset; 2253 int filter; 2254 int next; 2255 }; 2256 2257 static int 2258 action_record_eq (const void *pentry, const void *pdata) 2259 { 2260 const struct action_record *entry = (const struct action_record *) pentry; 2261 const struct action_record *data = (const struct action_record *) pdata; 2262 return entry->filter == data->filter && entry->next == data->next; 2263 } 2264 2265 static hashval_t 2266 action_record_hash (const void *pentry) 2267 { 2268 const struct action_record *entry = (const struct action_record *) pentry; 2269 return entry->next * 1009 + entry->filter; 2270 } 2271 2272 static int 2273 add_action_record (htab_t ar_hash, int filter, int next) 2274 { 2275 struct action_record **slot, *new_ar, tmp; 2276 2277 tmp.filter = filter; 2278 tmp.next = next; 2279 slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT); 2280 2281 if ((new_ar = *slot) == NULL) 2282 { 2283 new_ar = XNEW (struct action_record); 2284 new_ar->offset = crtl->eh.action_record_data->length () + 1; 2285 new_ar->filter = filter; 2286 new_ar->next = next; 2287 *slot = new_ar; 2288 2289 /* The filter value goes in untouched. The link to the next 2290 record is a "self-relative" byte offset, or zero to indicate 2291 that there is no next record. So convert the absolute 1 based 2292 indices we've been carrying around into a displacement. */ 2293 2294 push_sleb128 (&crtl->eh.action_record_data, filter); 2295 if (next) 2296 next -= crtl->eh.action_record_data->length () + 1; 2297 push_sleb128 (&crtl->eh.action_record_data, next); 2298 } 2299 2300 return new_ar->offset; 2301 } 2302 2303 static int 2304 collect_one_action_chain (htab_t ar_hash, eh_region region) 2305 { 2306 int next; 2307 2308 /* If we've reached the top of the region chain, then we have 2309 no actions, and require no landing pad. */ 2310 if (region == NULL) 2311 return -1; 2312 2313 switch (region->type) 2314 { 2315 case ERT_CLEANUP: 2316 { 2317 eh_region r; 2318 /* A cleanup adds a zero filter to the beginning of the chain, but 2319 there are special cases to look out for. If there are *only* 2320 cleanups along a path, then it compresses to a zero action. 2321 Further, if there are multiple cleanups along a path, we only 2322 need to represent one of them, as that is enough to trigger 2323 entry to the landing pad at runtime. */ 2324 next = collect_one_action_chain (ar_hash, region->outer); 2325 if (next <= 0) 2326 return 0; 2327 for (r = region->outer; r ; r = r->outer) 2328 if (r->type == ERT_CLEANUP) 2329 return next; 2330 return add_action_record (ar_hash, 0, next); 2331 } 2332 2333 case ERT_TRY: 2334 { 2335 eh_catch c; 2336 2337 /* Process the associated catch regions in reverse order. 2338 If there's a catch-all handler, then we don't need to 2339 search outer regions. Use a magic -3 value to record 2340 that we haven't done the outer search. */ 2341 next = -3; 2342 for (c = region->u.eh_try.last_catch; c ; c = c->prev_catch) 2343 { 2344 if (c->type_list == NULL) 2345 { 2346 /* Retrieve the filter from the head of the filter list 2347 where we have stored it (see assign_filter_values). */ 2348 int filter = TREE_INT_CST_LOW (TREE_VALUE (c->filter_list)); 2349 next = add_action_record (ar_hash, filter, 0); 2350 } 2351 else 2352 { 2353 /* Once the outer search is done, trigger an action record for 2354 each filter we have. */ 2355 tree flt_node; 2356 2357 if (next == -3) 2358 { 2359 next = collect_one_action_chain (ar_hash, region->outer); 2360 2361 /* If there is no next action, terminate the chain. */ 2362 if (next == -1) 2363 next = 0; 2364 /* If all outer actions are cleanups or must_not_throw, 2365 we'll have no action record for it, since we had wanted 2366 to encode these states in the call-site record directly. 2367 Add a cleanup action to the chain to catch these. */ 2368 else if (next <= 0) 2369 next = add_action_record (ar_hash, 0, 0); 2370 } 2371 2372 flt_node = c->filter_list; 2373 for (; flt_node; flt_node = TREE_CHAIN (flt_node)) 2374 { 2375 int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node)); 2376 next = add_action_record (ar_hash, filter, next); 2377 } 2378 } 2379 } 2380 return next; 2381 } 2382 2383 case ERT_ALLOWED_EXCEPTIONS: 2384 /* An exception specification adds its filter to the 2385 beginning of the chain. */ 2386 next = collect_one_action_chain (ar_hash, region->outer); 2387 2388 /* If there is no next action, terminate the chain. */ 2389 if (next == -1) 2390 next = 0; 2391 /* If all outer actions are cleanups or must_not_throw, 2392 we'll have no action record for it, since we had wanted 2393 to encode these states in the call-site record directly. 2394 Add a cleanup action to the chain to catch these. */ 2395 else if (next <= 0) 2396 next = add_action_record (ar_hash, 0, 0); 2397 2398 return add_action_record (ar_hash, region->u.allowed.filter, next); 2399 2400 case ERT_MUST_NOT_THROW: 2401 /* A must-not-throw region with no inner handlers or cleanups 2402 requires no call-site entry. Note that this differs from 2403 the no handler or cleanup case in that we do require an lsda 2404 to be generated. Return a magic -2 value to record this. */ 2405 return -2; 2406 } 2407 2408 gcc_unreachable (); 2409 } 2410 2411 static int 2412 add_call_site (rtx landing_pad, int action, int section) 2413 { 2414 call_site_record record; 2415 2416 record = ggc_alloc_call_site_record_d (); 2417 record->landing_pad = landing_pad; 2418 record->action = action; 2419 2420 vec_safe_push (crtl->eh.call_site_record_v[section], record); 2421 2422 return call_site_base + crtl->eh.call_site_record_v[section]->length () - 1; 2423 } 2424 2425 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes. 2426 The new note numbers will not refer to region numbers, but 2427 instead to call site entries. */ 2428 2429 static unsigned int 2430 convert_to_eh_region_ranges (void) 2431 { 2432 rtx insn, iter, note; 2433 htab_t ar_hash; 2434 int last_action = -3; 2435 rtx last_action_insn = NULL_RTX; 2436 rtx last_landing_pad = NULL_RTX; 2437 rtx first_no_action_insn = NULL_RTX; 2438 int call_site = 0; 2439 int cur_sec = 0; 2440 rtx section_switch_note = NULL_RTX; 2441 rtx first_no_action_insn_before_switch = NULL_RTX; 2442 rtx last_no_action_insn_before_switch = NULL_RTX; 2443 int saved_call_site_base = call_site_base; 2444 2445 vec_alloc (crtl->eh.action_record_data, 64); 2446 2447 ar_hash = htab_create (31, action_record_hash, action_record_eq, free); 2448 2449 for (iter = get_insns (); iter ; iter = NEXT_INSN (iter)) 2450 if (INSN_P (iter)) 2451 { 2452 eh_landing_pad lp; 2453 eh_region region; 2454 bool nothrow; 2455 int this_action; 2456 rtx this_landing_pad; 2457 2458 insn = iter; 2459 if (NONJUMP_INSN_P (insn) 2460 && GET_CODE (PATTERN (insn)) == SEQUENCE) 2461 insn = XVECEXP (PATTERN (insn), 0, 0); 2462 2463 nothrow = get_eh_region_and_lp_from_rtx (insn, ®ion, &lp); 2464 if (nothrow) 2465 continue; 2466 if (region) 2467 this_action = collect_one_action_chain (ar_hash, region); 2468 else 2469 this_action = -1; 2470 2471 /* Existence of catch handlers, or must-not-throw regions 2472 implies that an lsda is needed (even if empty). */ 2473 if (this_action != -1) 2474 crtl->uses_eh_lsda = 1; 2475 2476 /* Delay creation of region notes for no-action regions 2477 until we're sure that an lsda will be required. */ 2478 else if (last_action == -3) 2479 { 2480 first_no_action_insn = iter; 2481 last_action = -1; 2482 } 2483 2484 if (this_action >= 0) 2485 this_landing_pad = lp->landing_pad; 2486 else 2487 this_landing_pad = NULL_RTX; 2488 2489 /* Differing actions or landing pads implies a change in call-site 2490 info, which implies some EH_REGION note should be emitted. */ 2491 if (last_action != this_action 2492 || last_landing_pad != this_landing_pad) 2493 { 2494 /* If there is a queued no-action region in the other section 2495 with hot/cold partitioning, emit it now. */ 2496 if (first_no_action_insn_before_switch) 2497 { 2498 gcc_assert (this_action != -1 2499 && last_action == (first_no_action_insn 2500 ? -1 : -3)); 2501 call_site = add_call_site (NULL_RTX, 0, 0); 2502 note = emit_note_before (NOTE_INSN_EH_REGION_BEG, 2503 first_no_action_insn_before_switch); 2504 NOTE_EH_HANDLER (note) = call_site; 2505 note = emit_note_after (NOTE_INSN_EH_REGION_END, 2506 last_no_action_insn_before_switch); 2507 NOTE_EH_HANDLER (note) = call_site; 2508 gcc_assert (last_action != -3 2509 || (last_action_insn 2510 == last_no_action_insn_before_switch)); 2511 first_no_action_insn_before_switch = NULL_RTX; 2512 last_no_action_insn_before_switch = NULL_RTX; 2513 call_site_base++; 2514 } 2515 /* If we'd not seen a previous action (-3) or the previous 2516 action was must-not-throw (-2), then we do not need an 2517 end note. */ 2518 if (last_action >= -1) 2519 { 2520 /* If we delayed the creation of the begin, do it now. */ 2521 if (first_no_action_insn) 2522 { 2523 call_site = add_call_site (NULL_RTX, 0, cur_sec); 2524 note = emit_note_before (NOTE_INSN_EH_REGION_BEG, 2525 first_no_action_insn); 2526 NOTE_EH_HANDLER (note) = call_site; 2527 first_no_action_insn = NULL_RTX; 2528 } 2529 2530 note = emit_note_after (NOTE_INSN_EH_REGION_END, 2531 last_action_insn); 2532 NOTE_EH_HANDLER (note) = call_site; 2533 } 2534 2535 /* If the new action is must-not-throw, then no region notes 2536 are created. */ 2537 if (this_action >= -1) 2538 { 2539 call_site = add_call_site (this_landing_pad, 2540 this_action < 0 ? 0 : this_action, 2541 cur_sec); 2542 note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter); 2543 NOTE_EH_HANDLER (note) = call_site; 2544 } 2545 2546 last_action = this_action; 2547 last_landing_pad = this_landing_pad; 2548 } 2549 last_action_insn = iter; 2550 } 2551 else if (NOTE_P (iter) 2552 && NOTE_KIND (iter) == NOTE_INSN_SWITCH_TEXT_SECTIONS) 2553 { 2554 gcc_assert (section_switch_note == NULL_RTX); 2555 gcc_assert (flag_reorder_blocks_and_partition); 2556 section_switch_note = iter; 2557 if (first_no_action_insn) 2558 { 2559 first_no_action_insn_before_switch = first_no_action_insn; 2560 last_no_action_insn_before_switch = last_action_insn; 2561 first_no_action_insn = NULL_RTX; 2562 gcc_assert (last_action == -1); 2563 last_action = -3; 2564 } 2565 /* Force closing of current EH region before section switch and 2566 opening a new one afterwards. */ 2567 else if (last_action != -3) 2568 last_landing_pad = pc_rtx; 2569 if (crtl->eh.call_site_record_v[cur_sec]) 2570 call_site_base += crtl->eh.call_site_record_v[cur_sec]->length (); 2571 cur_sec++; 2572 gcc_assert (crtl->eh.call_site_record_v[cur_sec] == NULL); 2573 vec_alloc (crtl->eh.call_site_record_v[cur_sec], 10); 2574 } 2575 2576 if (last_action >= -1 && ! first_no_action_insn) 2577 { 2578 note = emit_note_after (NOTE_INSN_EH_REGION_END, last_action_insn); 2579 NOTE_EH_HANDLER (note) = call_site; 2580 } 2581 2582 call_site_base = saved_call_site_base; 2583 2584 htab_delete (ar_hash); 2585 return 0; 2586 } 2587 2588 static bool 2589 gate_convert_to_eh_region_ranges (void) 2590 { 2591 /* Nothing to do for SJLJ exceptions or if no regions created. */ 2592 if (cfun->eh->region_tree == NULL) 2593 return false; 2594 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 2595 return false; 2596 return true; 2597 } 2598 2599 struct rtl_opt_pass pass_convert_to_eh_region_ranges = 2600 { 2601 { 2602 RTL_PASS, 2603 "eh_ranges", /* name */ 2604 OPTGROUP_NONE, /* optinfo_flags */ 2605 gate_convert_to_eh_region_ranges, /* gate */ 2606 convert_to_eh_region_ranges, /* execute */ 2607 NULL, /* sub */ 2608 NULL, /* next */ 2609 0, /* static_pass_number */ 2610 TV_NONE, /* tv_id */ 2611 0, /* properties_required */ 2612 0, /* properties_provided */ 2613 0, /* properties_destroyed */ 2614 0, /* todo_flags_start */ 2615 0 /* todo_flags_finish */ 2616 } 2617 }; 2618 2619 static void 2620 push_uleb128 (vec<uchar, va_gc> **data_area, unsigned int value) 2621 { 2622 do 2623 { 2624 unsigned char byte = value & 0x7f; 2625 value >>= 7; 2626 if (value) 2627 byte |= 0x80; 2628 vec_safe_push (*data_area, byte); 2629 } 2630 while (value); 2631 } 2632 2633 static void 2634 push_sleb128 (vec<uchar, va_gc> **data_area, int value) 2635 { 2636 unsigned char byte; 2637 int more; 2638 2639 do 2640 { 2641 byte = value & 0x7f; 2642 value >>= 7; 2643 more = ! ((value == 0 && (byte & 0x40) == 0) 2644 || (value == -1 && (byte & 0x40) != 0)); 2645 if (more) 2646 byte |= 0x80; 2647 vec_safe_push (*data_area, byte); 2648 } 2649 while (more); 2650 } 2651 2652 2653 #ifndef HAVE_AS_LEB128 2654 static int 2655 dw2_size_of_call_site_table (int section) 2656 { 2657 int n = vec_safe_length (crtl->eh.call_site_record_v[section]); 2658 int size = n * (4 + 4 + 4); 2659 int i; 2660 2661 for (i = 0; i < n; ++i) 2662 { 2663 struct call_site_record_d *cs = 2664 (*crtl->eh.call_site_record_v[section])[i]; 2665 size += size_of_uleb128 (cs->action); 2666 } 2667 2668 return size; 2669 } 2670 2671 static int 2672 sjlj_size_of_call_site_table (void) 2673 { 2674 int n = vec_safe_length (crtl->eh.call_site_record_v[0]); 2675 int size = 0; 2676 int i; 2677 2678 for (i = 0; i < n; ++i) 2679 { 2680 struct call_site_record_d *cs = 2681 (*crtl->eh.call_site_record_v[0])[i]; 2682 size += size_of_uleb128 (INTVAL (cs->landing_pad)); 2683 size += size_of_uleb128 (cs->action); 2684 } 2685 2686 return size; 2687 } 2688 #endif 2689 2690 static void 2691 dw2_output_call_site_table (int cs_format, int section) 2692 { 2693 int n = vec_safe_length (crtl->eh.call_site_record_v[section]); 2694 int i; 2695 const char *begin; 2696 2697 if (section == 0) 2698 begin = current_function_func_begin_label; 2699 else if (first_function_block_is_cold) 2700 begin = crtl->subsections.hot_section_label; 2701 else 2702 begin = crtl->subsections.cold_section_label; 2703 2704 for (i = 0; i < n; ++i) 2705 { 2706 struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[section])[i]; 2707 char reg_start_lab[32]; 2708 char reg_end_lab[32]; 2709 char landing_pad_lab[32]; 2710 2711 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i); 2712 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab, "LEHE", call_site_base + i); 2713 2714 if (cs->landing_pad) 2715 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab, "L", 2716 CODE_LABEL_NUMBER (cs->landing_pad)); 2717 2718 /* ??? Perhaps use insn length scaling if the assembler supports 2719 generic arithmetic. */ 2720 /* ??? Perhaps use attr_length to choose data1 or data2 instead of 2721 data4 if the function is small enough. */ 2722 if (cs_format == DW_EH_PE_uleb128) 2723 { 2724 dw2_asm_output_delta_uleb128 (reg_start_lab, begin, 2725 "region %d start", i); 2726 dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab, 2727 "length"); 2728 if (cs->landing_pad) 2729 dw2_asm_output_delta_uleb128 (landing_pad_lab, begin, 2730 "landing pad"); 2731 else 2732 dw2_asm_output_data_uleb128 (0, "landing pad"); 2733 } 2734 else 2735 { 2736 dw2_asm_output_delta (4, reg_start_lab, begin, 2737 "region %d start", i); 2738 dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length"); 2739 if (cs->landing_pad) 2740 dw2_asm_output_delta (4, landing_pad_lab, begin, 2741 "landing pad"); 2742 else 2743 dw2_asm_output_data (4, 0, "landing pad"); 2744 } 2745 dw2_asm_output_data_uleb128 (cs->action, "action"); 2746 } 2747 2748 call_site_base += n; 2749 } 2750 2751 static void 2752 sjlj_output_call_site_table (void) 2753 { 2754 int n = vec_safe_length (crtl->eh.call_site_record_v[0]); 2755 int i; 2756 2757 for (i = 0; i < n; ++i) 2758 { 2759 struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[0])[i]; 2760 2761 dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad), 2762 "region %d landing pad", i); 2763 dw2_asm_output_data_uleb128 (cs->action, "action"); 2764 } 2765 2766 call_site_base += n; 2767 } 2768 2769 /* Switch to the section that should be used for exception tables. */ 2770 2771 static void 2772 switch_to_exception_section (const char * ARG_UNUSED (fnname)) 2773 { 2774 section *s; 2775 2776 if (exception_section) 2777 s = exception_section; 2778 else 2779 { 2780 /* Compute the section and cache it into exception_section, 2781 unless it depends on the function name. */ 2782 if (targetm_common.have_named_sections) 2783 { 2784 int flags; 2785 2786 if (EH_TABLES_CAN_BE_READ_ONLY) 2787 { 2788 int tt_format = 2789 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1); 2790 flags = ((! flag_pic 2791 || ((tt_format & 0x70) != DW_EH_PE_absptr 2792 && (tt_format & 0x70) != DW_EH_PE_aligned)) 2793 ? 0 : SECTION_WRITE); 2794 } 2795 else 2796 flags = SECTION_WRITE; 2797 2798 #ifdef HAVE_LD_EH_GC_SECTIONS 2799 if (flag_function_sections 2800 || (DECL_ONE_ONLY (current_function_decl) && HAVE_COMDAT_GROUP)) 2801 { 2802 char *section_name = XNEWVEC (char, strlen (fnname) + 32); 2803 /* The EH table must match the code section, so only mark 2804 it linkonce if we have COMDAT groups to tie them together. */ 2805 if (DECL_ONE_ONLY (current_function_decl) && HAVE_COMDAT_GROUP) 2806 flags |= SECTION_LINKONCE; 2807 sprintf (section_name, ".gcc_except_table.%s", fnname); 2808 s = get_section (section_name, flags, current_function_decl); 2809 free (section_name); 2810 } 2811 else 2812 #endif 2813 exception_section 2814 = s = get_section (".gcc_except_table", flags, NULL); 2815 } 2816 else 2817 exception_section 2818 = s = flag_pic ? data_section : readonly_data_section; 2819 } 2820 2821 switch_to_section (s); 2822 } 2823 2824 2825 /* Output a reference from an exception table to the type_info object TYPE. 2826 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for 2827 the value. */ 2828 2829 static void 2830 output_ttype (tree type, int tt_format, int tt_format_size) 2831 { 2832 rtx value; 2833 bool is_public = true; 2834 2835 if (type == NULL_TREE) 2836 value = const0_rtx; 2837 else 2838 { 2839 /* FIXME lto. pass_ipa_free_lang_data changes all types to 2840 runtime types so TYPE should already be a runtime type 2841 reference. When pass_ipa_free_lang data is made a default 2842 pass, we can then remove the call to lookup_type_for_runtime 2843 below. */ 2844 if (TYPE_P (type)) 2845 type = lookup_type_for_runtime (type); 2846 2847 value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 2848 2849 /* Let cgraph know that the rtti decl is used. Not all of the 2850 paths below go through assemble_integer, which would take 2851 care of this for us. */ 2852 STRIP_NOPS (type); 2853 if (TREE_CODE (type) == ADDR_EXPR) 2854 { 2855 type = TREE_OPERAND (type, 0); 2856 if (TREE_CODE (type) == VAR_DECL) 2857 is_public = TREE_PUBLIC (type); 2858 } 2859 else 2860 gcc_assert (TREE_CODE (type) == INTEGER_CST); 2861 } 2862 2863 /* Allow the target to override the type table entry format. */ 2864 if (targetm.asm_out.ttype (value)) 2865 return; 2866 2867 if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned) 2868 assemble_integer (value, tt_format_size, 2869 tt_format_size * BITS_PER_UNIT, 1); 2870 else 2871 dw2_asm_output_encoded_addr_rtx (tt_format, value, is_public, NULL); 2872 } 2873 2874 static void 2875 output_one_function_exception_table (int section) 2876 { 2877 int tt_format, cs_format, lp_format, i; 2878 #ifdef HAVE_AS_LEB128 2879 char ttype_label[32]; 2880 char cs_after_size_label[32]; 2881 char cs_end_label[32]; 2882 #else 2883 int call_site_len; 2884 #endif 2885 int have_tt_data; 2886 int tt_format_size = 0; 2887 2888 have_tt_data = (vec_safe_length (cfun->eh->ttype_data) 2889 || (targetm.arm_eabi_unwinder 2890 ? vec_safe_length (cfun->eh->ehspec_data.arm_eabi) 2891 : vec_safe_length (cfun->eh->ehspec_data.other))); 2892 2893 /* Indicate the format of the @TType entries. */ 2894 if (! have_tt_data) 2895 tt_format = DW_EH_PE_omit; 2896 else 2897 { 2898 tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1); 2899 #ifdef HAVE_AS_LEB128 2900 ASM_GENERATE_INTERNAL_LABEL (ttype_label, 2901 section ? "LLSDATTC" : "LLSDATT", 2902 current_function_funcdef_no); 2903 #endif 2904 tt_format_size = size_of_encoded_value (tt_format); 2905 2906 assemble_align (tt_format_size * BITS_PER_UNIT); 2907 } 2908 2909 targetm.asm_out.internal_label (asm_out_file, section ? "LLSDAC" : "LLSDA", 2910 current_function_funcdef_no); 2911 2912 /* The LSDA header. */ 2913 2914 /* Indicate the format of the landing pad start pointer. An omitted 2915 field implies @LPStart == @Start. */ 2916 /* Currently we always put @LPStart == @Start. This field would 2917 be most useful in moving the landing pads completely out of 2918 line to another section, but it could also be used to minimize 2919 the size of uleb128 landing pad offsets. */ 2920 lp_format = DW_EH_PE_omit; 2921 dw2_asm_output_data (1, lp_format, "@LPStart format (%s)", 2922 eh_data_format_name (lp_format)); 2923 2924 /* @LPStart pointer would go here. */ 2925 2926 dw2_asm_output_data (1, tt_format, "@TType format (%s)", 2927 eh_data_format_name (tt_format)); 2928 2929 #ifndef HAVE_AS_LEB128 2930 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 2931 call_site_len = sjlj_size_of_call_site_table (); 2932 else 2933 call_site_len = dw2_size_of_call_site_table (section); 2934 #endif 2935 2936 /* A pc-relative 4-byte displacement to the @TType data. */ 2937 if (have_tt_data) 2938 { 2939 #ifdef HAVE_AS_LEB128 2940 char ttype_after_disp_label[32]; 2941 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label, 2942 section ? "LLSDATTDC" : "LLSDATTD", 2943 current_function_funcdef_no); 2944 dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label, 2945 "@TType base offset"); 2946 ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label); 2947 #else 2948 /* Ug. Alignment queers things. */ 2949 unsigned int before_disp, after_disp, last_disp, disp; 2950 2951 before_disp = 1 + 1; 2952 after_disp = (1 + size_of_uleb128 (call_site_len) 2953 + call_site_len 2954 + vec_safe_length (crtl->eh.action_record_data) 2955 + (vec_safe_length (cfun->eh->ttype_data) 2956 * tt_format_size)); 2957 2958 disp = after_disp; 2959 do 2960 { 2961 unsigned int disp_size, pad; 2962 2963 last_disp = disp; 2964 disp_size = size_of_uleb128 (disp); 2965 pad = before_disp + disp_size + after_disp; 2966 if (pad % tt_format_size) 2967 pad = tt_format_size - (pad % tt_format_size); 2968 else 2969 pad = 0; 2970 disp = after_disp + pad; 2971 } 2972 while (disp != last_disp); 2973 2974 dw2_asm_output_data_uleb128 (disp, "@TType base offset"); 2975 #endif 2976 } 2977 2978 /* Indicate the format of the call-site offsets. */ 2979 #ifdef HAVE_AS_LEB128 2980 cs_format = DW_EH_PE_uleb128; 2981 #else 2982 cs_format = DW_EH_PE_udata4; 2983 #endif 2984 dw2_asm_output_data (1, cs_format, "call-site format (%s)", 2985 eh_data_format_name (cs_format)); 2986 2987 #ifdef HAVE_AS_LEB128 2988 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label, 2989 section ? "LLSDACSBC" : "LLSDACSB", 2990 current_function_funcdef_no); 2991 ASM_GENERATE_INTERNAL_LABEL (cs_end_label, 2992 section ? "LLSDACSEC" : "LLSDACSE", 2993 current_function_funcdef_no); 2994 dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label, 2995 "Call-site table length"); 2996 ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label); 2997 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 2998 sjlj_output_call_site_table (); 2999 else 3000 dw2_output_call_site_table (cs_format, section); 3001 ASM_OUTPUT_LABEL (asm_out_file, cs_end_label); 3002 #else 3003 dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length"); 3004 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 3005 sjlj_output_call_site_table (); 3006 else 3007 dw2_output_call_site_table (cs_format, section); 3008 #endif 3009 3010 /* ??? Decode and interpret the data for flag_debug_asm. */ 3011 { 3012 uchar uc; 3013 FOR_EACH_VEC_ELT (*crtl->eh.action_record_data, i, uc) 3014 dw2_asm_output_data (1, uc, i ? NULL : "Action record table"); 3015 } 3016 3017 if (have_tt_data) 3018 assemble_align (tt_format_size * BITS_PER_UNIT); 3019 3020 i = vec_safe_length (cfun->eh->ttype_data); 3021 while (i-- > 0) 3022 { 3023 tree type = (*cfun->eh->ttype_data)[i]; 3024 output_ttype (type, tt_format, tt_format_size); 3025 } 3026 3027 #ifdef HAVE_AS_LEB128 3028 if (have_tt_data) 3029 ASM_OUTPUT_LABEL (asm_out_file, ttype_label); 3030 #endif 3031 3032 /* ??? Decode and interpret the data for flag_debug_asm. */ 3033 if (targetm.arm_eabi_unwinder) 3034 { 3035 tree type; 3036 for (i = 0; 3037 vec_safe_iterate (cfun->eh->ehspec_data.arm_eabi, i, &type); ++i) 3038 output_ttype (type, tt_format, tt_format_size); 3039 } 3040 else 3041 { 3042 uchar uc; 3043 for (i = 0; 3044 vec_safe_iterate (cfun->eh->ehspec_data.other, i, &uc); ++i) 3045 dw2_asm_output_data (1, uc, 3046 i ? NULL : "Exception specification table"); 3047 } 3048 } 3049 3050 void 3051 output_function_exception_table (const char *fnname) 3052 { 3053 rtx personality = get_personality_function (current_function_decl); 3054 3055 /* Not all functions need anything. */ 3056 if (! crtl->uses_eh_lsda) 3057 return; 3058 3059 if (personality) 3060 { 3061 assemble_external_libcall (personality); 3062 3063 if (targetm.asm_out.emit_except_personality) 3064 targetm.asm_out.emit_except_personality (personality); 3065 } 3066 3067 switch_to_exception_section (fnname); 3068 3069 /* If the target wants a label to begin the table, emit it here. */ 3070 targetm.asm_out.emit_except_table_label (asm_out_file); 3071 3072 output_one_function_exception_table (0); 3073 if (crtl->eh.call_site_record_v[1]) 3074 output_one_function_exception_table (1); 3075 3076 switch_to_section (current_function_section ()); 3077 } 3078 3079 void 3080 set_eh_throw_stmt_table (struct function *fun, struct htab *table) 3081 { 3082 fun->eh->throw_stmt_table = table; 3083 } 3084 3085 htab_t 3086 get_eh_throw_stmt_table (struct function *fun) 3087 { 3088 return fun->eh->throw_stmt_table; 3089 } 3090 3091 /* Determine if the function needs an EH personality function. */ 3092 3093 enum eh_personality_kind 3094 function_needs_eh_personality (struct function *fn) 3095 { 3096 enum eh_personality_kind kind = eh_personality_none; 3097 eh_region i; 3098 3099 FOR_ALL_EH_REGION_FN (i, fn) 3100 { 3101 switch (i->type) 3102 { 3103 case ERT_CLEANUP: 3104 /* Can do with any personality including the generic C one. */ 3105 kind = eh_personality_any; 3106 break; 3107 3108 case ERT_TRY: 3109 case ERT_ALLOWED_EXCEPTIONS: 3110 /* Always needs a EH personality function. The generic C 3111 personality doesn't handle these even for empty type lists. */ 3112 return eh_personality_lang; 3113 3114 case ERT_MUST_NOT_THROW: 3115 /* Always needs a EH personality function. The language may specify 3116 what abort routine that must be used, e.g. std::terminate. */ 3117 return eh_personality_lang; 3118 } 3119 } 3120 3121 return kind; 3122 } 3123 3124 /* Dump EH information to OUT. */ 3125 3126 void 3127 dump_eh_tree (FILE * out, struct function *fun) 3128 { 3129 eh_region i; 3130 int depth = 0; 3131 static const char *const type_name[] = { 3132 "cleanup", "try", "allowed_exceptions", "must_not_throw" 3133 }; 3134 3135 i = fun->eh->region_tree; 3136 if (!i) 3137 return; 3138 3139 fprintf (out, "Eh tree:\n"); 3140 while (1) 3141 { 3142 fprintf (out, " %*s %i %s", depth * 2, "", 3143 i->index, type_name[(int) i->type]); 3144 3145 if (i->landing_pads) 3146 { 3147 eh_landing_pad lp; 3148 3149 fprintf (out, " land:"); 3150 if (current_ir_type () == IR_GIMPLE) 3151 { 3152 for (lp = i->landing_pads; lp ; lp = lp->next_lp) 3153 { 3154 fprintf (out, "{%i,", lp->index); 3155 print_generic_expr (out, lp->post_landing_pad, 0); 3156 fputc ('}', out); 3157 if (lp->next_lp) 3158 fputc (',', out); 3159 } 3160 } 3161 else 3162 { 3163 for (lp = i->landing_pads; lp ; lp = lp->next_lp) 3164 { 3165 fprintf (out, "{%i,", lp->index); 3166 if (lp->landing_pad) 3167 fprintf (out, "%i%s,", INSN_UID (lp->landing_pad), 3168 NOTE_P (lp->landing_pad) ? "(del)" : ""); 3169 else 3170 fprintf (out, "(nil),"); 3171 if (lp->post_landing_pad) 3172 { 3173 rtx lab = label_rtx (lp->post_landing_pad); 3174 fprintf (out, "%i%s}", INSN_UID (lab), 3175 NOTE_P (lab) ? "(del)" : ""); 3176 } 3177 else 3178 fprintf (out, "(nil)}"); 3179 if (lp->next_lp) 3180 fputc (',', out); 3181 } 3182 } 3183 } 3184 3185 switch (i->type) 3186 { 3187 case ERT_CLEANUP: 3188 case ERT_MUST_NOT_THROW: 3189 break; 3190 3191 case ERT_TRY: 3192 { 3193 eh_catch c; 3194 fprintf (out, " catch:"); 3195 for (c = i->u.eh_try.first_catch; c; c = c->next_catch) 3196 { 3197 fputc ('{', out); 3198 if (c->label) 3199 { 3200 fprintf (out, "lab:"); 3201 print_generic_expr (out, c->label, 0); 3202 fputc (';', out); 3203 } 3204 print_generic_expr (out, c->type_list, 0); 3205 fputc ('}', out); 3206 if (c->next_catch) 3207 fputc (',', out); 3208 } 3209 } 3210 break; 3211 3212 case ERT_ALLOWED_EXCEPTIONS: 3213 fprintf (out, " filter :%i types:", i->u.allowed.filter); 3214 print_generic_expr (out, i->u.allowed.type_list, 0); 3215 break; 3216 } 3217 fputc ('\n', out); 3218 3219 /* If there are sub-regions, process them. */ 3220 if (i->inner) 3221 i = i->inner, depth++; 3222 /* If there are peers, process them. */ 3223 else if (i->next_peer) 3224 i = i->next_peer; 3225 /* Otherwise, step back up the tree to the next peer. */ 3226 else 3227 { 3228 do 3229 { 3230 i = i->outer; 3231 depth--; 3232 if (i == NULL) 3233 return; 3234 } 3235 while (i->next_peer == NULL); 3236 i = i->next_peer; 3237 } 3238 } 3239 } 3240 3241 /* Dump the EH tree for FN on stderr. */ 3242 3243 DEBUG_FUNCTION void 3244 debug_eh_tree (struct function *fn) 3245 { 3246 dump_eh_tree (stderr, fn); 3247 } 3248 3249 /* Verify invariants on EH datastructures. */ 3250 3251 DEBUG_FUNCTION void 3252 verify_eh_tree (struct function *fun) 3253 { 3254 eh_region r, outer; 3255 int nvisited_lp, nvisited_r; 3256 int count_lp, count_r, depth, i; 3257 eh_landing_pad lp; 3258 bool err = false; 3259 3260 if (!fun->eh->region_tree) 3261 return; 3262 3263 count_r = 0; 3264 for (i = 1; vec_safe_iterate (fun->eh->region_array, i, &r); ++i) 3265 if (r) 3266 { 3267 if (r->index == i) 3268 count_r++; 3269 else 3270 { 3271 error ("region_array is corrupted for region %i", r->index); 3272 err = true; 3273 } 3274 } 3275 3276 count_lp = 0; 3277 for (i = 1; vec_safe_iterate (fun->eh->lp_array, i, &lp); ++i) 3278 if (lp) 3279 { 3280 if (lp->index == i) 3281 count_lp++; 3282 else 3283 { 3284 error ("lp_array is corrupted for lp %i", lp->index); 3285 err = true; 3286 } 3287 } 3288 3289 depth = nvisited_lp = nvisited_r = 0; 3290 outer = NULL; 3291 r = fun->eh->region_tree; 3292 while (1) 3293 { 3294 if ((*fun->eh->region_array)[r->index] != r) 3295 { 3296 error ("region_array is corrupted for region %i", r->index); 3297 err = true; 3298 } 3299 if (r->outer != outer) 3300 { 3301 error ("outer block of region %i is wrong", r->index); 3302 err = true; 3303 } 3304 if (depth < 0) 3305 { 3306 error ("negative nesting depth of region %i", r->index); 3307 err = true; 3308 } 3309 nvisited_r++; 3310 3311 for (lp = r->landing_pads; lp ; lp = lp->next_lp) 3312 { 3313 if ((*fun->eh->lp_array)[lp->index] != lp) 3314 { 3315 error ("lp_array is corrupted for lp %i", lp->index); 3316 err = true; 3317 } 3318 if (lp->region != r) 3319 { 3320 error ("region of lp %i is wrong", lp->index); 3321 err = true; 3322 } 3323 nvisited_lp++; 3324 } 3325 3326 if (r->inner) 3327 outer = r, r = r->inner, depth++; 3328 else if (r->next_peer) 3329 r = r->next_peer; 3330 else 3331 { 3332 do 3333 { 3334 r = r->outer; 3335 if (r == NULL) 3336 goto region_done; 3337 depth--; 3338 outer = r->outer; 3339 } 3340 while (r->next_peer == NULL); 3341 r = r->next_peer; 3342 } 3343 } 3344 region_done: 3345 if (depth != 0) 3346 { 3347 error ("tree list ends on depth %i", depth); 3348 err = true; 3349 } 3350 if (count_r != nvisited_r) 3351 { 3352 error ("region_array does not match region_tree"); 3353 err = true; 3354 } 3355 if (count_lp != nvisited_lp) 3356 { 3357 error ("lp_array does not match region_tree"); 3358 err = true; 3359 } 3360 3361 if (err) 3362 { 3363 dump_eh_tree (stderr, fun); 3364 internal_error ("verify_eh_tree failed"); 3365 } 3366 } 3367 3368 #include "gt-except.h" 3369