1169689Skan/* Handle exceptional things in C++. 2169689Skan Copyright (C) 1989-2015 Free Software Foundation, Inc. 3169689Skan Contributed by Michael Tiemann <tiemann@cygnus.com> 4169689Skan Rewritten by Mike Stump <mrs@cygnus.com>, based upon an 5169689Skan initial re-implementation courtesy Tad Hunt. 6169689Skan 7169689SkanThis file is part of GCC. 8169689Skan 9169689SkanGCC is free software; you can redistribute it and/or modify 10169689Skanit under the terms of the GNU General Public License as published by 11169689Skanthe Free Software Foundation; either version 3, or (at your option) 12169689Skanany later version. 13169689Skan 14169689SkanGCC is distributed in the hope that it will be useful, 15169689Skanbut WITHOUT ANY WARRANTY; without even the implied warranty of 16169689SkanMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17169689SkanGNU General Public License for more details. 18169689Skan 19169689SkanYou should have received a copy of the GNU General Public License 20169689Skanalong with GCC; see the file COPYING3. If not see 21169689Skan<http://www.gnu.org/licenses/>. */ 22169689Skan 23169689Skan 24169689Skan#include "config.h" 25169689Skan#include "system.h" 26169689Skan#include "coretypes.h" 27169689Skan#include "tm.h" 28169689Skan#include "hash-set.h" 29169689Skan#include "machmode.h" 30169689Skan#include "vec.h" 31169689Skan#include "double-int.h" 32169689Skan#include "input.h" 33169689Skan#include "alias.h" 34169689Skan#include "symtab.h" 35169689Skan#include "wide-int.h" 36169689Skan#include "inchash.h" 37169689Skan#include "tree.h" 38169689Skan#include "stringpool.h" 39169689Skan#include "trans-mem.h" 40169689Skan#include "attribs.h" 41169689Skan#include "cp-tree.h" 42169689Skan#include "flags.h" 43169689Skan#include "tree-inline.h" 44169689Skan#include "tree-iterator.h" 45169689Skan#include "target.h" 46169689Skan 47169689Skanstatic void push_eh_cleanup (tree); 48169689Skanstatic tree prepare_eh_type (tree); 49169689Skanstatic tree do_begin_catch (void); 50169689Skanstatic int dtor_nothrow (tree); 51169689Skanstatic tree do_end_catch (tree); 52169689Skanstatic bool decl_is_java_type (tree decl, int err); 53169689Skanstatic void initialize_handler_parm (tree, tree); 54169689Skanstatic tree do_allocate_exception (tree); 55169689Skanstatic tree wrap_cleanups_r (tree *, int *, void *); 56169689Skanstatic int complete_ptr_ref_or_void_ptr_p (tree, tree); 57169689Skanstatic bool is_admissible_throw_operand_or_catch_parameter (tree, bool); 58169689Skanstatic int can_convert_eh (tree, tree); 59169689Skan 60169689Skan/* Sets up all the global eh stuff that needs to be initialized at the 61169689Skan start of compilation. */ 62169689Skan 63169689Skanvoid 64169689Skaninit_exception_processing (void) 65169689Skan{ 66169689Skan tree tmp; 67169689Skan 68169689Skan /* void std::terminate (); */ 69169689Skan push_namespace (std_identifier); 70169689Skan tmp = build_function_type_list (void_type_node, NULL_TREE); 71169689Skan terminate_node = build_cp_library_fn_ptr ("terminate", tmp, 72169689Skan ECF_NOTHROW | ECF_NORETURN); 73169689Skan TREE_THIS_VOLATILE (terminate_node) = 1; 74169689Skan TREE_NOTHROW (terminate_node) = 1; 75169689Skan pop_namespace (); 76169689Skan 77169689Skan /* void __cxa_call_unexpected(void *); */ 78169689Skan tmp = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE); 79169689Skan call_unexpected_node 80169689Skan = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp); 81169689Skan} 82169689Skan 83169689Skan/* Returns an expression to be executed if an unhandled exception is 84169689Skan propagated out of a cleanup region. */ 85169689Skan 86169689Skantree 87169689Skancp_protect_cleanup_actions (void) 88169689Skan{ 89169689Skan /* [except.terminate] 90169689Skan 91169689Skan When the destruction of an object during stack unwinding exits 92169689Skan using an exception ... void terminate(); is called. */ 93169689Skan return terminate_node; 94169689Skan} 95169689Skan 96169689Skanstatic tree 97169689Skanprepare_eh_type (tree type) 98169689Skan{ 99169689Skan if (type == NULL_TREE) 100169689Skan return type; 101169689Skan if (type == error_mark_node) 102169689Skan return error_mark_node; 103169689Skan 104169689Skan /* peel back references, so they match. */ 105169689Skan type = non_reference (type); 106169689Skan 107169689Skan /* Peel off cv qualifiers. */ 108169689Skan type = TYPE_MAIN_VARIANT (type); 109169689Skan 110169689Skan /* Functions and arrays decay to pointers. */ 111169689Skan type = type_decays_to (type); 112169689Skan 113169689Skan return type; 114169689Skan} 115169689Skan 116169689Skan/* Return the type info for TYPE as used by EH machinery. */ 117169689Skantree 118169689Skaneh_type_info (tree type) 119169689Skan{ 120169689Skan tree exp; 121169689Skan 122169689Skan if (type == NULL_TREE || type == error_mark_node) 123169689Skan return type; 124169689Skan 125169689Skan if (decl_is_java_type (type, 0)) 126169689Skan exp = build_java_class_ref (TREE_TYPE (type)); 127169689Skan else 128169689Skan exp = get_tinfo_decl (type); 129169689Skan 130169689Skan return exp; 131169689Skan} 132169689Skan 133169689Skan/* Build the address of a typeinfo decl for use in the runtime 134169689Skan matching field of the exception model. */ 135169689Skan 136169689Skantree 137169689Skanbuild_eh_type_type (tree type) 138169689Skan{ 139169689Skan tree exp = eh_type_info (type); 140169689Skan 141169689Skan if (!exp) 142169689Skan return NULL; 143169689Skan 144169689Skan mark_used (exp); 145169689Skan 146169689Skan return convert (ptr_type_node, build_address (exp)); 147169689Skan} 148169689Skan 149169689Skantree 150169689Skanbuild_exc_ptr (void) 151169689Skan{ 152169689Skan return build_call_n (builtin_decl_explicit (BUILT_IN_EH_POINTER), 153169689Skan 1, integer_zero_node); 154169689Skan} 155169689Skan 156169689Skan/* Declare a function NAME, returning RETURN_TYPE, taking a single 157169689Skan parameter PARM_TYPE, with an empty exception specification. 158169689Skan 159169689Skan Note that the C++ ABI document does not have a throw-specifier on 160169689Skan the routines declared below via this function. The declarations 161169689Skan are consistent with the actual implementations in libsupc++. */ 162169689Skan 163169689Skanstatic tree 164169689Skandeclare_library_fn (tree name, tree return_type, tree parm_type, int ecf_flags) 165169689Skan{ 166169689Skan return push_library_fn (name, build_function_type_list (return_type, 167169689Skan parm_type, 168169689Skan NULL_TREE), 169169689Skan empty_except_spec, 170169689Skan ecf_flags); 171169689Skan} 172169689Skan 173169689Skan/* Build up a call to __cxa_get_exception_ptr so that we can build a 174169689Skan copy constructor for the thrown object. */ 175169689Skan 176static tree 177do_get_exception_ptr (void) 178{ 179 tree fn; 180 181 fn = get_identifier ("__cxa_get_exception_ptr"); 182 if (!get_global_value_if_present (fn, &fn)) 183 { 184 /* Declare void* __cxa_get_exception_ptr (void *) throw(). */ 185 fn = declare_library_fn (fn, ptr_type_node, ptr_type_node, 186 ECF_NOTHROW | ECF_PURE | ECF_LEAF | ECF_TM_PURE); 187 } 188 189 return cp_build_function_call_nary (fn, tf_warning_or_error, 190 build_exc_ptr (), NULL_TREE); 191} 192 193/* Build up a call to __cxa_begin_catch, to tell the runtime that the 194 exception has been handled. */ 195 196static tree 197do_begin_catch (void) 198{ 199 tree fn; 200 201 fn = get_identifier ("__cxa_begin_catch"); 202 if (!get_global_value_if_present (fn, &fn)) 203 { 204 /* Declare void* __cxa_begin_catch (void *) throw(). */ 205 fn = declare_library_fn (fn, ptr_type_node, ptr_type_node, ECF_NOTHROW); 206 207 /* Create its transactional-memory equivalent. */ 208 if (flag_tm) 209 { 210 tree fn2 = get_identifier ("_ITM_cxa_begin_catch"); 211 if (!get_global_value_if_present (fn2, &fn2)) 212 fn2 = declare_library_fn (fn2, ptr_type_node, 213 ptr_type_node, ECF_NOTHROW | ECF_TM_PURE); 214 record_tm_replacement (fn, fn2); 215 } 216 } 217 218 return cp_build_function_call_nary (fn, tf_warning_or_error, 219 build_exc_ptr (), NULL_TREE); 220} 221 222/* Returns nonzero if cleaning up an exception of type TYPE (which can be 223 NULL_TREE for a ... handler) will not throw an exception. */ 224 225static int 226dtor_nothrow (tree type) 227{ 228 if (type == NULL_TREE || type == error_mark_node) 229 return 0; 230 231 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type)) 232 return 1; 233 234 if (CLASSTYPE_LAZY_DESTRUCTOR (type)) 235 lazily_declare_fn (sfk_destructor, type); 236 237 return TREE_NOTHROW (CLASSTYPE_DESTRUCTORS (type)); 238} 239 240/* Build up a call to __cxa_end_catch, to destroy the exception object 241 for the current catch block if no others are currently using it. */ 242 243static tree 244do_end_catch (tree type) 245{ 246 tree fn, cleanup; 247 248 fn = get_identifier ("__cxa_end_catch"); 249 if (!get_global_value_if_present (fn, &fn)) 250 { 251 /* Declare void __cxa_end_catch (). 252 This can throw if the destructor for the exception throws. */ 253 fn = push_void_library_fn (fn, void_list_node, 0); 254 255 /* Create its transactional-memory equivalent. */ 256 if (flag_tm) 257 { 258 tree fn2 = get_identifier ("_ITM_cxa_end_catch"); 259 if (!get_global_value_if_present (fn2, &fn2)) 260 fn2 = push_void_library_fn (fn2, void_list_node, ECF_TM_PURE); 261 record_tm_replacement (fn, fn2); 262 } 263 } 264 265 cleanup = cp_build_function_call_vec (fn, NULL, tf_warning_or_error); 266 TREE_NOTHROW (cleanup) = dtor_nothrow (type); 267 268 return cleanup; 269} 270 271/* This routine creates the cleanup for the current exception. */ 272 273static void 274push_eh_cleanup (tree type) 275{ 276 finish_decl_cleanup (NULL_TREE, do_end_catch (type)); 277} 278 279/* Return nonzero value if DECL is a Java type suitable for catch or 280 throw. */ 281 282static bool 283decl_is_java_type (tree decl, int err) 284{ 285 bool r = (TYPE_PTR_P (decl) 286 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 287 && TYPE_FOR_JAVA (TREE_TYPE (decl))); 288 289 if (err) 290 { 291 if (TREE_CODE (decl) == REFERENCE_TYPE 292 && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 293 && TYPE_FOR_JAVA (TREE_TYPE (decl))) 294 { 295 /* Can't throw a reference. */ 296 error ("type %qT is disallowed in Java %<throw%> or %<catch%>", 297 decl); 298 } 299 300 if (r) 301 { 302 tree jthrow_node 303 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable")); 304 305 if (jthrow_node == NULL_TREE) 306 fatal_error 307 (input_location, 308 "call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined"); 309 310 jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node)); 311 312 if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl))) 313 { 314 /* Thrown object must be a Throwable. */ 315 error ("type %qT is not derived from %<java::lang::Throwable%>", 316 TREE_TYPE (decl)); 317 } 318 } 319 } 320 321 return r; 322} 323 324/* Select the personality routine to be used for exception handling, 325 or issue an error if we need two different ones in the same 326 translation unit. 327 ??? At present DECL_FUNCTION_PERSONALITY is set via 328 LANG_HOOKS_EH_PERSONALITY. Should it be done here instead? */ 329void 330choose_personality_routine (enum languages lang) 331{ 332 static enum { 333 chose_none, 334 chose_cpp, 335 chose_java, 336 gave_error 337 } state; 338 339 switch (state) 340 { 341 case gave_error: 342 return; 343 344 case chose_cpp: 345 if (lang != lang_cplusplus) 346 goto give_error; 347 return; 348 349 case chose_java: 350 if (lang != lang_java) 351 goto give_error; 352 return; 353 354 case chose_none: 355 ; /* Proceed to language selection. */ 356 } 357 358 switch (lang) 359 { 360 case lang_cplusplus: 361 state = chose_cpp; 362 break; 363 364 case lang_java: 365 state = chose_java; 366 terminate_node = builtin_decl_explicit (BUILT_IN_ABORT); 367 pragma_java_exceptions = true; 368 break; 369 370 default: 371 gcc_unreachable (); 372 } 373 return; 374 375 give_error: 376 error ("mixing C++ and Java catches in a single translation unit"); 377 state = gave_error; 378} 379 380/* Wrap EXPR in a MUST_NOT_THROW_EXPR expressing that EXPR must 381 not throw any exceptions if COND is true. A condition of 382 NULL_TREE is treated as 'true'. */ 383 384tree 385build_must_not_throw_expr (tree body, tree cond) 386{ 387 tree type = body ? TREE_TYPE (body) : void_type_node; 388 389 if (!flag_exceptions) 390 return body; 391 392 if (cond && !value_dependent_expression_p (cond)) 393 { 394 cond = cxx_constant_value (cond); 395 if (integer_zerop (cond)) 396 return body; 397 else if (integer_onep (cond)) 398 cond = NULL_TREE; 399 } 400 401 return build2 (MUST_NOT_THROW_EXPR, type, body, cond); 402} 403 404 405/* Initialize the catch parameter DECL. */ 406 407static void 408initialize_handler_parm (tree decl, tree exp) 409{ 410 tree init; 411 tree init_type; 412 413 /* Make sure we mark the catch param as used, otherwise we'll get a 414 warning about an unused ((anonymous)). */ 415 TREE_USED (decl) = 1; 416 DECL_READ_P (decl) = 1; 417 418 /* Figure out the type that the initializer is. Pointers are returned 419 adjusted by value from __cxa_begin_catch. Others are returned by 420 reference. */ 421 init_type = TREE_TYPE (decl); 422 if (!POINTER_TYPE_P (init_type)) 423 init_type = build_reference_type (init_type); 424 425 choose_personality_routine (decl_is_java_type (init_type, 0) 426 ? lang_java : lang_cplusplus); 427 428 /* Since pointers are passed by value, initialize a reference to 429 pointer catch parm with the address of the temporary. */ 430 if (TREE_CODE (init_type) == REFERENCE_TYPE 431 && TYPE_PTR_P (TREE_TYPE (init_type))) 432 exp = cp_build_addr_expr (exp, tf_warning_or_error); 433 434 exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0, 435 tf_warning_or_error); 436 437 init = convert_from_reference (exp); 438 439 /* If the constructor for the catch parm exits via an exception, we 440 must call terminate. See eh23.C. */ 441 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))) 442 { 443 /* Generate the copy constructor call directly so we can wrap it. 444 See also expand_default_init. */ 445 init = ocp_convert (TREE_TYPE (decl), init, 446 CONV_IMPLICIT|CONV_FORCE_TEMP, 0, 447 tf_warning_or_error); 448 /* Force cleanups now to avoid nesting problems with the 449 MUST_NOT_THROW_EXPR. */ 450 init = fold_build_cleanup_point_expr (TREE_TYPE (init), init); 451 init = build_must_not_throw_expr (init, NULL_TREE); 452 } 453 454 decl = pushdecl (decl); 455 456 start_decl_1 (decl, true); 457 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE, 458 LOOKUP_ONLYCONVERTING|DIRECT_BIND); 459} 460 461 462/* Routine to see if exception handling is turned on. 463 DO_WARN is nonzero if we want to inform the user that exception 464 handling is turned off. 465 466 This is used to ensure that -fexceptions has been specified if the 467 compiler tries to use any exception-specific functions. */ 468 469static inline int 470doing_eh (void) 471{ 472 if (! flag_exceptions) 473 { 474 static int warned = 0; 475 if (! warned) 476 { 477 error ("exception handling disabled, use -fexceptions to enable"); 478 warned = 1; 479 } 480 return 0; 481 } 482 return 1; 483} 484 485/* Call this to start a catch block. DECL is the catch parameter. */ 486 487tree 488expand_start_catch_block (tree decl) 489{ 490 tree exp; 491 tree type, init; 492 493 if (! doing_eh ()) 494 return NULL_TREE; 495 496 if (decl) 497 { 498 if (!is_admissible_throw_operand_or_catch_parameter (decl, false)) 499 decl = error_mark_node; 500 501 type = prepare_eh_type (TREE_TYPE (decl)); 502 mark_used (eh_type_info (type)); 503 } 504 else 505 type = NULL_TREE; 506 507 if (decl && decl_is_java_type (type, 1)) 508 { 509 /* Java only passes object via pointer and doesn't require 510 adjusting. The java object is immediately before the 511 generic exception header. */ 512 exp = build_exc_ptr (); 513 exp = build1 (NOP_EXPR, build_pointer_type (type), exp); 514 exp = fold_build_pointer_plus (exp, 515 fold_build1_loc (input_location, 516 NEGATE_EXPR, sizetype, 517 TYPE_SIZE_UNIT (TREE_TYPE (exp)))); 518 exp = cp_build_indirect_ref (exp, RO_NULL, tf_warning_or_error); 519 initialize_handler_parm (decl, exp); 520 return type; 521 } 522 523 /* Call __cxa_end_catch at the end of processing the exception. */ 524 push_eh_cleanup (type); 525 526 init = do_begin_catch (); 527 528 /* If there's no decl at all, then all we need to do is make sure 529 to tell the runtime that we've begun handling the exception. */ 530 if (decl == NULL || decl == error_mark_node || init == error_mark_node) 531 finish_expr_stmt (init); 532 533 /* If the C++ object needs constructing, we need to do that before 534 calling __cxa_begin_catch, so that std::uncaught_exception gets 535 the right value during the copy constructor. */ 536 else if (flag_use_cxa_get_exception_ptr 537 && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))) 538 { 539 exp = do_get_exception_ptr (); 540 initialize_handler_parm (decl, exp); 541 finish_expr_stmt (init); 542 } 543 544 /* Otherwise the type uses a bitwise copy, and we don't have to worry 545 about the value of std::uncaught_exception and therefore can do the 546 copy with the return value of __cxa_end_catch instead. */ 547 else 548 { 549 tree init_type = type; 550 551 /* Pointers are passed by values, everything else by reference. */ 552 if (!TYPE_PTR_P (type)) 553 init_type = build_pointer_type (type); 554 if (init_type != TREE_TYPE (init)) 555 init = build1 (NOP_EXPR, init_type, init); 556 exp = create_temporary_var (init_type); 557 DECL_REGISTER (exp) = 1; 558 cp_finish_decl (exp, init, /*init_const_expr=*/false, 559 NULL_TREE, LOOKUP_ONLYCONVERTING); 560 initialize_handler_parm (decl, exp); 561 } 562 563 return type; 564} 565 566 567/* Call this to end a catch block. Its responsible for emitting the 568 code to handle jumping back to the correct place, and for emitting 569 the label to jump to if this catch block didn't match. */ 570 571void 572expand_end_catch_block (void) 573{ 574 if (! doing_eh ()) 575 return; 576 577 /* The exception being handled is rethrown if control reaches the end of 578 a handler of the function-try-block of a constructor or destructor. */ 579 if (in_function_try_handler 580 && (DECL_CONSTRUCTOR_P (current_function_decl) 581 || DECL_DESTRUCTOR_P (current_function_decl))) 582 finish_expr_stmt (build_throw (NULL_TREE)); 583} 584 585tree 586begin_eh_spec_block (void) 587{ 588 tree r; 589 location_t spec_location = DECL_SOURCE_LOCATION (current_function_decl); 590 591 /* A noexcept specification (or throw() with -fnothrow-opt) is a 592 MUST_NOT_THROW_EXPR. */ 593 if (TYPE_NOEXCEPT_P (TREE_TYPE (current_function_decl))) 594 { 595 r = build_stmt (spec_location, MUST_NOT_THROW_EXPR, 596 NULL_TREE, NULL_TREE); 597 TREE_SIDE_EFFECTS (r) = 1; 598 } 599 else 600 r = build_stmt (spec_location, EH_SPEC_BLOCK, NULL_TREE, NULL_TREE); 601 add_stmt (r); 602 TREE_OPERAND (r, 0) = push_stmt_list (); 603 return r; 604} 605 606void 607finish_eh_spec_block (tree raw_raises, tree eh_spec_block) 608{ 609 tree raises; 610 611 TREE_OPERAND (eh_spec_block, 0) 612 = pop_stmt_list (TREE_OPERAND (eh_spec_block, 0)); 613 614 if (TREE_CODE (eh_spec_block) == MUST_NOT_THROW_EXPR) 615 return; 616 617 /* Strip cv quals, etc, from the specification types. */ 618 for (raises = NULL_TREE; 619 raw_raises && TREE_VALUE (raw_raises); 620 raw_raises = TREE_CHAIN (raw_raises)) 621 { 622 tree type = prepare_eh_type (TREE_VALUE (raw_raises)); 623 tree tinfo = eh_type_info (type); 624 625 mark_used (tinfo); 626 raises = tree_cons (NULL_TREE, type, raises); 627 } 628 629 EH_SPEC_RAISES (eh_spec_block) = raises; 630} 631 632/* Return a pointer to a buffer for an exception object of type TYPE. */ 633 634static tree 635do_allocate_exception (tree type) 636{ 637 tree fn; 638 639 fn = get_identifier ("__cxa_allocate_exception"); 640 if (!get_global_value_if_present (fn, &fn)) 641 { 642 /* Declare void *__cxa_allocate_exception(size_t) throw(). */ 643 fn = declare_library_fn (fn, ptr_type_node, size_type_node, 644 ECF_NOTHROW | ECF_MALLOC); 645 646 if (flag_tm) 647 { 648 tree fn2 = get_identifier ("_ITM_cxa_allocate_exception"); 649 if (!get_global_value_if_present (fn2, &fn2)) 650 fn2 = declare_library_fn (fn2, ptr_type_node, 651 size_type_node, 652 ECF_NOTHROW | ECF_MALLOC | ECF_TM_PURE); 653 record_tm_replacement (fn, fn2); 654 } 655 } 656 657 return cp_build_function_call_nary (fn, tf_warning_or_error, 658 size_in_bytes (type), NULL_TREE); 659} 660 661/* Call __cxa_free_exception from a cleanup. This is never invoked 662 directly, but see the comment for stabilize_throw_expr. */ 663 664static tree 665do_free_exception (tree ptr) 666{ 667 tree fn; 668 669 fn = get_identifier ("__cxa_free_exception"); 670 if (!get_global_value_if_present (fn, &fn)) 671 { 672 /* Declare void __cxa_free_exception (void *) throw(). */ 673 fn = declare_library_fn (fn, void_type_node, ptr_type_node, 674 ECF_NOTHROW | ECF_LEAF); 675 } 676 677 return cp_build_function_call_nary (fn, tf_warning_or_error, ptr, NULL_TREE); 678} 679 680/* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR. 681 Called from build_throw via walk_tree_without_duplicates. */ 682 683static tree 684wrap_cleanups_r (tree *tp, int *walk_subtrees, void * /*data*/) 685{ 686 tree exp = *tp; 687 tree cleanup; 688 689 /* Don't walk into types. */ 690 if (TYPE_P (exp)) 691 { 692 *walk_subtrees = 0; 693 return NULL_TREE; 694 } 695 if (TREE_CODE (exp) != TARGET_EXPR) 696 return NULL_TREE; 697 698 cleanup = TARGET_EXPR_CLEANUP (exp); 699 if (cleanup) 700 { 701 cleanup = build2 (MUST_NOT_THROW_EXPR, void_type_node, cleanup, 702 NULL_TREE); 703 TARGET_EXPR_CLEANUP (exp) = cleanup; 704 } 705 706 /* Keep iterating. */ 707 return NULL_TREE; 708} 709 710/* Build a throw expression. */ 711 712tree 713build_throw (tree exp) 714{ 715 tree fn; 716 717 if (exp == error_mark_node) 718 return exp; 719 720 if (processing_template_decl) 721 { 722 if (cfun) 723 current_function_returns_abnormally = 1; 724 exp = build_min (THROW_EXPR, void_type_node, exp); 725 SET_EXPR_LOCATION (exp, input_location); 726 return exp; 727 } 728 729 if (exp == null_node) 730 warning (0, "throwing NULL, which has integral, not pointer type"); 731 732 if (exp != NULL_TREE) 733 { 734 if (!is_admissible_throw_operand_or_catch_parameter (exp, true)) 735 return error_mark_node; 736 } 737 738 if (! doing_eh ()) 739 return error_mark_node; 740 741 if (exp && decl_is_java_type (TREE_TYPE (exp), 1)) 742 { 743 tree fn = get_identifier ("_Jv_Throw"); 744 if (!get_global_value_if_present (fn, &fn)) 745 { 746 /* Declare void _Jv_Throw (void *). */ 747 tree tmp; 748 tmp = build_function_type_list (ptr_type_node, 749 ptr_type_node, NULL_TREE); 750 fn = push_throw_library_fn (fn, tmp); 751 } 752 else if (really_overloaded_fn (fn)) 753 { 754 error ("%qD should never be overloaded", fn); 755 return error_mark_node; 756 } 757 fn = OVL_CURRENT (fn); 758 exp = cp_build_function_call_nary (fn, tf_warning_or_error, 759 exp, NULL_TREE); 760 } 761 else if (exp) 762 { 763 tree throw_type; 764 tree temp_type; 765 tree cleanup; 766 tree object, ptr; 767 tree tmp; 768 tree allocate_expr; 769 770 /* The CLEANUP_TYPE is the internal type of a destructor. */ 771 if (!cleanup_type) 772 { 773 tmp = build_function_type_list (void_type_node, 774 ptr_type_node, NULL_TREE); 775 cleanup_type = build_pointer_type (tmp); 776 } 777 778 fn = get_identifier ("__cxa_throw"); 779 if (!get_global_value_if_present (fn, &fn)) 780 { 781 /* Declare void __cxa_throw (void*, void*, void (*)(void*)). */ 782 /* ??? Second argument is supposed to be "std::type_info*". */ 783 tmp = build_function_type_list (void_type_node, 784 ptr_type_node, ptr_type_node, 785 cleanup_type, NULL_TREE); 786 fn = push_throw_library_fn (fn, tmp); 787 788 if (flag_tm) 789 { 790 tree fn2 = get_identifier ("_ITM_cxa_throw"); 791 if (!get_global_value_if_present (fn2, &fn2)) 792 fn2 = push_throw_library_fn (fn2, tmp); 793 apply_tm_attr (fn2, get_identifier ("transaction_pure")); 794 record_tm_replacement (fn, fn2); 795 } 796 } 797 798 /* [except.throw] 799 800 A throw-expression initializes a temporary object, the type 801 of which is determined by removing any top-level 802 cv-qualifiers from the static type of the operand of throw 803 and adjusting the type from "array of T" or "function return 804 T" to "pointer to T" or "pointer to function returning T" 805 respectively. */ 806 temp_type = is_bitfield_expr_with_lowered_type (exp); 807 if (!temp_type) 808 temp_type = cv_unqualified (type_decays_to (TREE_TYPE (exp))); 809 810 /* OK, this is kind of wacky. The standard says that we call 811 terminate when the exception handling mechanism, after 812 completing evaluation of the expression to be thrown but 813 before the exception is caught (_except.throw_), calls a 814 user function that exits via an uncaught exception. 815 816 So we have to protect the actual initialization of the 817 exception object with terminate(), but evaluate the 818 expression first. Since there could be temps in the 819 expression, we need to handle that, too. We also expand 820 the call to __cxa_allocate_exception first (which doesn't 821 matter, since it can't throw). */ 822 823 /* Allocate the space for the exception. */ 824 allocate_expr = do_allocate_exception (temp_type); 825 allocate_expr = get_target_expr (allocate_expr); 826 ptr = TARGET_EXPR_SLOT (allocate_expr); 827 TARGET_EXPR_CLEANUP (allocate_expr) = do_free_exception (ptr); 828 CLEANUP_EH_ONLY (allocate_expr) = 1; 829 830 object = build_nop (build_pointer_type (temp_type), ptr); 831 object = cp_build_indirect_ref (object, RO_NULL, tf_warning_or_error); 832 833 /* And initialize the exception object. */ 834 if (CLASS_TYPE_P (temp_type)) 835 { 836 int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING; 837 vec<tree, va_gc> *exp_vec; 838 839 /* Under C++0x [12.8/16 class.copy], a thrown lvalue is sometimes 840 treated as an rvalue for the purposes of overload resolution 841 to favor move constructors over copy constructors. */ 842 if (/* Must be a local, automatic variable. */ 843 VAR_P (exp) 844 && DECL_CONTEXT (exp) == current_function_decl 845 && ! TREE_STATIC (exp) 846 /* The variable must not have the `volatile' qualifier. */ 847 && !(cp_type_quals (TREE_TYPE (exp)) & TYPE_QUAL_VOLATILE)) 848 flags = flags | LOOKUP_PREFER_RVALUE; 849 850 /* Call the copy constructor. */ 851 exp_vec = make_tree_vector_single (exp); 852 exp = (build_special_member_call 853 (object, complete_ctor_identifier, &exp_vec, 854 TREE_TYPE (object), flags, tf_warning_or_error)); 855 release_tree_vector (exp_vec); 856 if (exp == error_mark_node) 857 { 858 error (" in thrown expression"); 859 return error_mark_node; 860 } 861 } 862 else 863 { 864 tmp = decay_conversion (exp, tf_warning_or_error); 865 if (tmp == error_mark_node) 866 return error_mark_node; 867 exp = build2 (INIT_EXPR, temp_type, object, tmp); 868 } 869 870 /* Mark any cleanups from the initialization as MUST_NOT_THROW, since 871 they are run after the exception object is initialized. */ 872 cp_walk_tree_without_duplicates (&exp, wrap_cleanups_r, 0); 873 874 /* Prepend the allocation. */ 875 exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), allocate_expr, exp); 876 877 /* Force all the cleanups to be evaluated here so that we don't have 878 to do them during unwinding. */ 879 exp = build1 (CLEANUP_POINT_EXPR, void_type_node, exp); 880 881 throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object))); 882 883 cleanup = NULL_TREE; 884 if (type_build_dtor_call (TREE_TYPE (object))) 885 { 886 tree fn = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)), 887 complete_dtor_identifier, 0); 888 fn = BASELINK_FUNCTIONS (fn); 889 mark_used (fn); 890 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (object))) 891 { 892 cxx_mark_addressable (fn); 893 /* Pretend it's a normal function. */ 894 cleanup = build1 (ADDR_EXPR, cleanup_type, fn); 895 } 896 } 897 if (cleanup == NULL_TREE) 898 cleanup = build_int_cst (cleanup_type, 0); 899 900 /* ??? Indicate that this function call throws throw_type. */ 901 tmp = cp_build_function_call_nary (fn, tf_warning_or_error, 902 ptr, throw_type, cleanup, NULL_TREE); 903 904 /* Tack on the initialization stuff. */ 905 exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp); 906 } 907 else 908 { 909 /* Rethrow current exception. */ 910 911 tree fn = get_identifier ("__cxa_rethrow"); 912 if (!get_global_value_if_present (fn, &fn)) 913 { 914 /* Declare void __cxa_rethrow (void). */ 915 fn = push_throw_library_fn 916 (fn, build_function_type_list (void_type_node, NULL_TREE)); 917 } 918 919 if (flag_tm) 920 apply_tm_attr (fn, get_identifier ("transaction_pure")); 921 922 /* ??? Indicate that this function call allows exceptions of the type 923 of the enclosing catch block (if known). */ 924 exp = cp_build_function_call_vec (fn, NULL, tf_warning_or_error); 925 } 926 927 exp = build1 (THROW_EXPR, void_type_node, exp); 928 SET_EXPR_LOCATION (exp, input_location); 929 930 return exp; 931} 932 933/* Make sure TYPE is complete, pointer to complete, reference to 934 complete, or pointer to cv void. Issue diagnostic on failure. 935 Return the zero on failure and nonzero on success. FROM can be 936 the expr or decl from whence TYPE came, if available. */ 937 938static int 939complete_ptr_ref_or_void_ptr_p (tree type, tree from) 940{ 941 int is_ptr; 942 943 /* Check complete. */ 944 type = complete_type_or_else (type, from); 945 if (!type) 946 return 0; 947 948 /* Or a pointer or ref to one, or cv void *. */ 949 is_ptr = TYPE_PTR_P (type); 950 if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE) 951 { 952 tree core = TREE_TYPE (type); 953 954 if (is_ptr && VOID_TYPE_P (core)) 955 /* OK */; 956 else if (!complete_type_or_else (core, from)) 957 return 0; 958 } 959 return 1; 960} 961 962/* If IS_THROW is true return truth-value if T is an expression admissible 963 in throw-expression, i.e. if it is not of incomplete type or a pointer/ 964 reference to such a type or of an abstract class type. 965 If IS_THROW is false, likewise for a catch parameter, same requirements 966 for its type plus rvalue reference type is also not admissible. */ 967 968static bool 969is_admissible_throw_operand_or_catch_parameter (tree t, bool is_throw) 970{ 971 tree expr = is_throw ? t : NULL_TREE; 972 tree type = TREE_TYPE (t); 973 974 /* C++11 [except.handle] The exception-declaration shall not denote 975 an incomplete type, an abstract class type, or an rvalue reference 976 type. */ 977 978 /* 15.1/4 [...] The type of the throw-expression shall not be an 979 incomplete type, or a pointer or a reference to an incomplete 980 type, other than void*, const void*, volatile void*, or 981 const volatile void*. Except for these restriction and the 982 restrictions on type matching mentioned in 15.3, the operand 983 of throw is treated exactly as a function argument in a call 984 (5.2.2) or the operand of a return statement. */ 985 if (!complete_ptr_ref_or_void_ptr_p (type, expr)) 986 return false; 987 988 /* 10.4/3 An abstract class shall not be used as a parameter type, 989 as a function return type or as type of an explicit 990 conversion. */ 991 else if (abstract_virtuals_error (is_throw ? ACU_THROW : ACU_CATCH, type)) 992 return false; 993 else if (!is_throw 994 && TREE_CODE (type) == REFERENCE_TYPE 995 && TYPE_REF_IS_RVALUE (type)) 996 { 997 error ("cannot declare catch parameter to be of rvalue " 998 "reference type %qT", type); 999 return false; 1000 } 1001 else if (variably_modified_type_p (type, NULL_TREE)) 1002 { 1003 if (is_throw) 1004 error ("cannot throw expression of type %qT because it involves " 1005 "types of variable size", type); 1006 else 1007 error ("cannot catch type %qT because it involves types of " 1008 "variable size", type); 1009 return false; 1010 } 1011 1012 return true; 1013} 1014 1015/* Returns nonzero if FN is a declaration of a standard C library 1016 function which is known not to throw. 1017 1018 [lib.res.on.exception.handling]: None of the functions from the 1019 Standard C library shall report an error by throwing an 1020 exception, unless it calls a program-supplied function that 1021 throws an exception. */ 1022 1023#include "cfns.h" 1024 1025int 1026nothrow_libfn_p (const_tree fn) 1027{ 1028 tree id; 1029 1030 if (TREE_PUBLIC (fn) 1031 && DECL_EXTERNAL (fn) 1032 && DECL_NAMESPACE_SCOPE_P (fn) 1033 && DECL_EXTERN_C_P (fn)) 1034 /* OK */; 1035 else 1036 /* Can't be a C library function. */ 1037 return 0; 1038 1039 /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME 1040 unless the system headers are playing rename tricks, and if 1041 they are, we don't want to be confused by them. */ 1042 id = DECL_NAME (fn); 1043 return !!libc_name::libc_name_p (IDENTIFIER_POINTER (id), 1044 IDENTIFIER_LENGTH (id)); 1045} 1046 1047/* Returns nonzero if an exception of type FROM will be caught by a 1048 handler for type TO, as per [except.handle]. */ 1049 1050static int 1051can_convert_eh (tree to, tree from) 1052{ 1053 to = non_reference (to); 1054 from = non_reference (from); 1055 1056 if (TYPE_PTR_P (to) && TYPE_PTR_P (from)) 1057 { 1058 to = TREE_TYPE (to); 1059 from = TREE_TYPE (from); 1060 1061 if (! at_least_as_qualified_p (to, from)) 1062 return 0; 1063 1064 if (VOID_TYPE_P (to)) 1065 return 1; 1066 1067 /* Else fall through. */ 1068 } 1069 1070 if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from) 1071 && publicly_uniquely_derived_p (to, from)) 1072 return 1; 1073 1074 return 0; 1075} 1076 1077/* Check whether any of the handlers in I are shadowed by another handler 1078 accepting TYPE. Note that the shadowing may not be complete; even if 1079 an exception of type B would be caught by a handler for A, there could 1080 be a derived class C for which A is an ambiguous base but B is not, so 1081 the handler for B would catch an exception of type C. */ 1082 1083static void 1084check_handlers_1 (tree master, tree_stmt_iterator i) 1085{ 1086 tree type = TREE_TYPE (master); 1087 1088 for (; !tsi_end_p (i); tsi_next (&i)) 1089 { 1090 tree handler = tsi_stmt (i); 1091 if (TREE_TYPE (handler) && can_convert_eh (type, TREE_TYPE (handler))) 1092 { 1093 warning_at (EXPR_LOCATION (handler), 0, 1094 "exception of type %qT will be caught", 1095 TREE_TYPE (handler)); 1096 warning_at (EXPR_LOCATION (master), 0, 1097 " by earlier handler for %qT", type); 1098 break; 1099 } 1100 } 1101} 1102 1103/* Given a STATEMENT_LIST of HANDLERs, make sure that they're OK. */ 1104 1105void 1106check_handlers (tree handlers) 1107{ 1108 tree_stmt_iterator i; 1109 1110 /* If we don't have a STATEMENT_LIST, then we've just got one 1111 handler, and thus nothing to warn about. */ 1112 if (TREE_CODE (handlers) != STATEMENT_LIST) 1113 return; 1114 1115 i = tsi_start (handlers); 1116 if (!tsi_end_p (i)) 1117 while (1) 1118 { 1119 tree handler = tsi_stmt (i); 1120 tsi_next (&i); 1121 1122 /* No more handlers; nothing to shadow. */ 1123 if (tsi_end_p (i)) 1124 break; 1125 if (TREE_TYPE (handler) == NULL_TREE) 1126 permerror (EXPR_LOCATION (handler), "%<...%>" 1127 " handler must be the last handler for its try block"); 1128 else 1129 check_handlers_1 (handler, i); 1130 } 1131} 1132 1133/* walk_tree helper for finish_noexcept_expr. Returns non-null if the 1134 expression *TP causes the noexcept operator to evaluate to false. 1135 1136 5.3.7 [expr.noexcept]: The result of the noexcept operator is false if 1137 in a potentially-evaluated context the expression would contain 1138 * a potentially evaluated call to a function, member function, 1139 function pointer, or member function pointer that does not have a 1140 non-throwing exception-specification (15.4), 1141 * a potentially evaluated throw-expression (15.1), 1142 * a potentially evaluated dynamic_cast expression dynamic_cast<T>(v), 1143 where T is a reference type, that requires a run-time check (5.2.7), or 1144 * a potentially evaluated typeid expression (5.2.8) applied to a glvalue 1145 expression whose type is a polymorphic class type (10.3). */ 1146 1147static tree 1148check_noexcept_r (tree *tp, int * /*walk_subtrees*/, void * /*data*/) 1149{ 1150 tree t = *tp; 1151 enum tree_code code = TREE_CODE (t); 1152 if ((code == CALL_EXPR && CALL_EXPR_FN (t)) 1153 || code == AGGR_INIT_EXPR) 1154 { 1155 /* We can only use the exception specification of the called function 1156 for determining the value of a noexcept expression; we can't use 1157 TREE_NOTHROW, as it might have a different value in another 1158 translation unit, creating ODR problems. 1159 1160 We could use TREE_NOTHROW (t) for !TREE_PUBLIC fns, though... */ 1161 tree fn = (code == AGGR_INIT_EXPR 1162 ? AGGR_INIT_EXPR_FN (t) : CALL_EXPR_FN (t)); 1163 tree type = TREE_TYPE (TREE_TYPE (fn)); 1164 1165 STRIP_NOPS (fn); 1166 if (TREE_CODE (fn) == ADDR_EXPR) 1167 fn = TREE_OPERAND (fn, 0); 1168 if (TREE_CODE (fn) == FUNCTION_DECL) 1169 { 1170 /* We do use TREE_NOTHROW for ABI internals like __dynamic_cast, 1171 and for C library functions known not to throw. */ 1172 if (DECL_EXTERN_C_P (fn) 1173 && (DECL_ARTIFICIAL (fn) 1174 || nothrow_libfn_p (fn))) 1175 return TREE_NOTHROW (fn) ? NULL_TREE : fn; 1176 /* A call to a constexpr function is noexcept if the call 1177 is a constant expression. */ 1178 if (DECL_DECLARED_CONSTEXPR_P (fn) 1179 && is_sub_constant_expr (t)) 1180 return NULL_TREE; 1181 } 1182 if (!TYPE_NOTHROW_P (type)) 1183 return fn; 1184 } 1185 1186 return NULL_TREE; 1187} 1188 1189/* If a function that causes a noexcept-expression to be false isn't 1190 defined yet, remember it and check it for TREE_NOTHROW again at EOF. */ 1191 1192typedef struct GTY(()) pending_noexcept { 1193 tree fn; 1194 location_t loc; 1195} pending_noexcept; 1196static GTY(()) vec<pending_noexcept, va_gc> *pending_noexcept_checks; 1197 1198/* FN is a FUNCTION_DECL that caused a noexcept-expr to be false. Warn if 1199 it can't throw. */ 1200 1201static void 1202maybe_noexcept_warning (tree fn) 1203{ 1204 if (TREE_NOTHROW (fn)) 1205 { 1206 warning (OPT_Wnoexcept, "noexcept-expression evaluates to %<false%> " 1207 "because of a call to %qD", fn); 1208 warning (OPT_Wnoexcept, "but %q+D does not throw; perhaps " 1209 "it should be declared %<noexcept%>", fn); 1210 } 1211} 1212 1213/* Check any functions that weren't defined earlier when they caused a 1214 noexcept expression to evaluate to false. */ 1215 1216void 1217perform_deferred_noexcept_checks (void) 1218{ 1219 int i; 1220 pending_noexcept *p; 1221 location_t saved_loc = input_location; 1222 FOR_EACH_VEC_SAFE_ELT (pending_noexcept_checks, i, p) 1223 { 1224 input_location = p->loc; 1225 maybe_noexcept_warning (p->fn); 1226 } 1227 input_location = saved_loc; 1228} 1229 1230/* Evaluate noexcept ( EXPR ). */ 1231 1232tree 1233finish_noexcept_expr (tree expr, tsubst_flags_t complain) 1234{ 1235 if (expr == error_mark_node) 1236 return error_mark_node; 1237 1238 if (processing_template_decl) 1239 return build_min (NOEXCEPT_EXPR, boolean_type_node, expr); 1240 1241 return (expr_noexcept_p (expr, complain) 1242 ? boolean_true_node : boolean_false_node); 1243} 1244 1245/* Returns whether EXPR is noexcept, possibly warning if allowed by 1246 COMPLAIN. */ 1247 1248bool 1249expr_noexcept_p (tree expr, tsubst_flags_t complain) 1250{ 1251 tree fn; 1252 1253 if (expr == error_mark_node) 1254 return false; 1255 1256 fn = cp_walk_tree_without_duplicates (&expr, check_noexcept_r, 0); 1257 if (fn) 1258 { 1259 if ((complain & tf_warning) && warn_noexcept 1260 && TREE_CODE (fn) == FUNCTION_DECL) 1261 { 1262 if (!DECL_INITIAL (fn)) 1263 { 1264 /* Not defined yet; check again at EOF. */ 1265 pending_noexcept p = {fn, input_location}; 1266 vec_safe_push (pending_noexcept_checks, p); 1267 } 1268 else 1269 maybe_noexcept_warning (fn); 1270 } 1271 return false; 1272 } 1273 else 1274 return true; 1275} 1276 1277/* Return true iff SPEC is throw() or noexcept(true). */ 1278 1279bool 1280nothrow_spec_p (const_tree spec) 1281{ 1282 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec)); 1283 if (spec == NULL_TREE 1284 || TREE_VALUE (spec) != NULL_TREE 1285 || spec == noexcept_false_spec) 1286 return false; 1287 if (TREE_PURPOSE (spec) == NULL_TREE 1288 || spec == noexcept_true_spec) 1289 return true; 1290 gcc_assert (processing_template_decl 1291 || TREE_PURPOSE (spec) == error_mark_node); 1292 return false; 1293} 1294 1295/* For FUNCTION_TYPE or METHOD_TYPE, true if NODE is noexcept. This is the 1296 case for things declared noexcept(true) and, with -fnothrow-opt, for 1297 throw() functions. */ 1298 1299bool 1300type_noexcept_p (const_tree type) 1301{ 1302 tree spec = TYPE_RAISES_EXCEPTIONS (type); 1303 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec)); 1304 if (flag_nothrow_opt) 1305 return nothrow_spec_p (spec); 1306 else 1307 return spec == noexcept_true_spec; 1308} 1309 1310/* For FUNCTION_TYPE or METHOD_TYPE, true if NODE can throw any type, 1311 i.e. no exception-specification or noexcept(false). */ 1312 1313bool 1314type_throw_all_p (const_tree type) 1315{ 1316 tree spec = TYPE_RAISES_EXCEPTIONS (type); 1317 gcc_assert (!DEFERRED_NOEXCEPT_SPEC_P (spec)); 1318 return spec == NULL_TREE || spec == noexcept_false_spec; 1319} 1320 1321/* Create a representation of the noexcept-specification with 1322 constant-expression of EXPR. COMPLAIN is as for tsubst. */ 1323 1324tree 1325build_noexcept_spec (tree expr, int complain) 1326{ 1327 /* This isn't part of the signature, so don't bother trying to evaluate 1328 it until instantiation. */ 1329 if (!processing_template_decl && TREE_CODE (expr) != DEFERRED_NOEXCEPT) 1330 { 1331 expr = perform_implicit_conversion_flags (boolean_type_node, expr, 1332 complain, 1333 LOOKUP_NORMAL); 1334 expr = cxx_constant_value (expr); 1335 } 1336 if (TREE_CODE (expr) == INTEGER_CST) 1337 { 1338 if (operand_equal_p (expr, boolean_true_node, 0)) 1339 return noexcept_true_spec; 1340 else 1341 { 1342 gcc_checking_assert (operand_equal_p (expr, boolean_false_node, 0)); 1343 return noexcept_false_spec; 1344 } 1345 } 1346 else if (expr == error_mark_node) 1347 return error_mark_node; 1348 else 1349 { 1350 gcc_assert (processing_template_decl 1351 || TREE_CODE (expr) == DEFERRED_NOEXCEPT); 1352 return build_tree_list (expr, NULL_TREE); 1353 } 1354} 1355 1356/* Returns a noexcept-specifier to be evaluated later, for an 1357 implicitly-declared or explicitly defaulted special member function. */ 1358 1359tree 1360unevaluated_noexcept_spec (void) 1361{ 1362 static tree spec; 1363 if (spec == NULL_TREE) 1364 spec = build_noexcept_spec (make_node (DEFERRED_NOEXCEPT), tf_none); 1365 return spec; 1366} 1367 1368/* Returns a TRY_CATCH_EXPR that will put TRY_LIST and CATCH_LIST in the 1369 TRY and CATCH locations. CATCH_LIST must be a STATEMENT_LIST */ 1370 1371tree 1372create_try_catch_expr (tree try_expr, tree catch_list) 1373{ 1374 location_t loc = EXPR_LOCATION (try_expr); 1375 1376 append_to_statement_list (do_begin_catch (), &catch_list); 1377 append_to_statement_list (build_throw (NULL_TREE), &catch_list); 1378 tree catch_tf_expr = build_stmt (loc, TRY_FINALLY_EXPR, catch_list, 1379 do_end_catch (NULL_TREE)); 1380 catch_list = build2 (CATCH_EXPR, void_type_node, NULL_TREE, 1381 catch_tf_expr); 1382 tree try_catch_expr = build_stmt (loc, TRY_CATCH_EXPR, try_expr, catch_list); 1383 return try_catch_expr; 1384} 1385 1386#include "gt-cp-except.h" 1387