![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to except.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to except.c CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 ! root 1: /* Handle exceptional things in C++. ! 2: Copyright (C) 1989, 1992, 1993, 1994 Free Software Foundation, Inc. ! 3: Contributed by Michael Tiemann <[email protected]> ! 4: Rewritten by Mike Stump <[email protected]>, based upon an ! 5: initial re-implementation courtesy Tad Hunt. ! 6: ! 7: This file is part of GNU CC. ! 8: ! 9: GNU CC is free software; you can redistribute it and/or modify ! 10: it under the terms of the GNU General Public License as published by ! 11: the Free Software Foundation; either version 2, or (at your option) ! 12: any later version. ! 13: ! 14: GNU CC is distributed in the hope that it will be useful, ! 15: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 17: GNU General Public License for more details. ! 18: ! 19: You should have received a copy of the GNU General Public License ! 20: along with GNU CC; see the file COPYING. If not, write to ! 21: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 22: ! 23: ! 24: /* High-level class interface. */ ! 25: ! 26: #include "config.h" ! 27: #include "tree.h" ! 28: #include "rtl.h" ! 29: #include "cp-tree.h" ! 30: #include "flags.h" ! 31: #include "obstack.h" ! 32: #include "expr.h" ! 33: ! 34: extern void (*interim_eh_hook) PROTO((tree)); ! 35: ! 36: /* holds the fndecl for __builtin_return_address () */ ! 37: tree builtin_return_address_fndecl; ! 38: ! 39: /* Define at your own risk! */ ! 40: #ifndef CROSS_COMPILE ! 41: #ifdef sun ! 42: #ifdef sparc ! 43: #define TRY_NEW_EH ! 44: #endif ! 45: #endif ! 46: #endif ! 47: ! 48: #ifndef TRY_NEW_EH ! 49: ! 50: static void ! 51: sorry_no_eh () ! 52: { ! 53: static int warned = 0; ! 54: if (! warned) ! 55: { ! 56: sorry ("exception handling not supported"); ! 57: warned = 1; ! 58: } ! 59: } ! 60: ! 61: void ! 62: expand_exception_blocks () ! 63: { ! 64: } ! 65: ! 66: void ! 67: start_protect () ! 68: { ! 69: } ! 70: ! 71: void ! 72: end_protect (finalization) ! 73: tree finalization; ! 74: { ! 75: } ! 76: ! 77: void ! 78: expand_start_try_stmts () ! 79: { ! 80: sorry_no_eh (); ! 81: } ! 82: ! 83: void ! 84: expand_end_try_stmts () ! 85: { ! 86: } ! 87: ! 88: void ! 89: expand_start_all_catch () ! 90: { ! 91: } ! 92: ! 93: void ! 94: expand_end_all_catch () ! 95: { ! 96: } ! 97: ! 98: void ! 99: expand_start_catch_block (declspecs, declarator) ! 100: tree declspecs, declarator; ! 101: { ! 102: } ! 103: ! 104: void ! 105: expand_end_catch_block () ! 106: { ! 107: } ! 108: ! 109: void ! 110: init_exception_processing () ! 111: { ! 112: } ! 113: ! 114: void ! 115: expand_throw (exp) ! 116: tree exp; ! 117: { ! 118: sorry_no_eh (); ! 119: } ! 120: ! 121: #else ! 122: ! 123: static int ! 124: doing_eh (do_warn) ! 125: int do_warn; ! 126: { ! 127: if (! flag_handle_exceptions) ! 128: { ! 129: static int warned = 0; ! 130: if (! warned && do_warn) ! 131: { ! 132: error ("exception handling disabled, use -fhandle-exceptions to enable."); ! 133: warned = 1; ! 134: } ! 135: return 0; ! 136: } ! 137: return 1; ! 138: } ! 139: ! 140: ! 141: /* ! 142: NO GNEWS IS GOOD GNEWS WITH GARRY GNUS: This version is much closer ! 143: to supporting exception handling as per Stroustrup's 2nd edition. ! 144: It is a complete rewrite of all the EH stuff that was here before ! 145: Shortcomings: ! 146: 1. The type of the throw and catch must still match ! 147: exactly (no support yet for matching base classes) ! 148: 2. Throw specifications of functions still doesnt't work. ! 149: Cool Things: ! 150: 1. Destructors are called properly :-) ! 151: 2. No overhead for the non-exception thrown case. ! 152: 3. Fixing shortcomings 1 and 2 is simple. ! 153: -Tad Hunt ([email protected]) ! 154: ! 155: */ ! 156: ! 157: /* A couple of backend routines from m88k.c */ ! 158: ! 159: /* used to cache a call to __builtin_return_address () */ ! 160: static tree BuiltinReturnAddress; ! 161: ! 162: ! 163: ! 164: ! 165: ! 166: #include <stdio.h> ! 167: ! 168: /* XXX - Tad: for EH */ ! 169: /* output an exception table entry */ ! 170: ! 171: static void ! 172: output_exception_table_entry (file, start_label, end_label, eh_label) ! 173: FILE *file; ! 174: rtx start_label, end_label, eh_label; ! 175: { ! 176: char label[100]; ! 177: ! 178: assemble_integer (start_label, BITS_PER_WORD/BITS_PER_UNIT, 1); ! 179: assemble_integer (end_label, BITS_PER_WORD/BITS_PER_UNIT, 1); ! 180: assemble_integer (eh_label, BITS_PER_WORD/BITS_PER_UNIT, 1); ! 181: putc ('\n', file); /* blank line */ ! 182: } ! 183: ! 184: static void ! 185: easy_expand_asm (str) ! 186: char *str; ! 187: { ! 188: expand_asm (build_string (strlen (str)+1, str)); ! 189: } ! 190: ! 191: /* unwind the stack. */ ! 192: static void ! 193: do_unwind (throw_label) ! 194: rtx throw_label; ! 195: { ! 196: #ifdef sparc ! 197: extern FILE *asm_out_file; ! 198: tree fcall; ! 199: tree params; ! 200: rtx return_val_rtx; ! 201: ! 202: /* call to __builtin_return_address () */ ! 203: params=tree_cons (NULL_TREE, integer_zero_node, NULL_TREE); ! 204: fcall = build_function_call (BuiltinReturnAddress, params); ! 205: return_val_rtx = expand_expr (fcall, NULL_RTX, SImode, 0); ! 206: /* In the return, the new pc is pc+8, as the value comming in is ! 207: really the address of the call insn, not the next insn. */ ! 208: emit_move_insn (return_val_rtx, plus_constant(gen_rtx (LABEL_REF, ! 209: Pmode, ! 210: throw_label), -8)); ! 211: /* We use three values, PC, type, and value */ ! 212: easy_expand_asm ("st %l0,[%fp]"); ! 213: easy_expand_asm ("st %l1,[%fp+4]"); ! 214: easy_expand_asm ("st %l2,[%fp+8]"); ! 215: easy_expand_asm ("ret"); ! 216: easy_expand_asm ("restore"); ! 217: emit_barrier (); ! 218: #endif ! 219: #if m88k ! 220: rtx temp_frame = frame_pointer_rtx; ! 221: ! 222: temp_frame = memory_address (Pmode, temp_frame); ! 223: temp_frame = copy_to_reg (gen_rtx (MEM, Pmode, temp_frame)); ! 224: ! 225: /* hopefully this will successfully pop the frame! */ ! 226: emit_move_insn (frame_pointer_rtx, temp_frame); ! 227: emit_move_insn (stack_pointer_rtx, frame_pointer_rtx); ! 228: emit_move_insn (arg_pointer_rtx, frame_pointer_rtx); ! 229: emit_insn (gen_add2_insn (stack_pointer_rtx, gen_rtx (CONST_INT, VOIDmode, ! 230: (HOST_WIDE_INT)m88k_debugger_offset (stack_pointer_rtx, 0)))); ! 231: ! 232: #if 0 ! 233: emit_insn (gen_add2_insn (arg_pointer_rtx, gen_rtx (CONST_INT, VOIDmode, ! 234: -(HOST_WIDE_INT)m88k_debugger_offset (arg_pointer_rtx, 0)))); ! 235: ! 236: emit_move_insn (stack_pointer_rtx, arg_pointer_rtx); ! 237: ! 238: emit_insn (gen_add2_insn (stack_pointer_rtx, gen_rtx (CONST_INT, VOIDmode, ! 239: (HOST_WIDE_INT)m88k_debugger_offset (arg_pointer_rtx, 0)))); ! 240: #endif ! 241: #endif ! 242: } ! 243: ! 244: ! 245: ! 246: #if 0 ! 247: /* This is the startup, and finish stuff per exception table. */ ! 248: ! 249: /* XXX - Tad: exception handling section */ ! 250: #ifndef EXCEPT_SECTION_ASM_OP ! 251: #define EXCEPT_SECTION_ASM_OP "section\t.gcc_except_table,\"a\",@progbits" ! 252: #endif ! 253: ! 254: #ifdef EXCEPT_SECTION_ASM_OP ! 255: typedef struct { ! 256: void *start_protect; ! 257: void *end_protect; ! 258: void *exception_handler; ! 259: } exception_table; ! 260: #endif /* EXCEPT_SECTION_ASM_OP */ ! 261: ! 262: #ifdef EXCEPT_SECTION_ASM_OP ! 263: ! 264: /* on machines which support it, the exception table lives in another section, ! 265: but it needs a label so we can reference it... This sets up that ! 266: label! */ ! 267: asm (EXCEPT_SECTION_ASM_OP); ! 268: exception_table __EXCEPTION_TABLE__[1] = { (void*)0, (void*)0, (void*)0 }; ! 269: asm (TEXT_SECTION_ASM_OP); ! 270: ! 271: #endif /* EXCEPT_SECTION_ASM_OP */ ! 272: ! 273: #ifdef EXCEPT_SECTION_ASM_OP ! 274: ! 275: /* we need to know where the end of the exception table is... so this ! 276: is how we do it! */ ! 277: ! 278: asm (EXCEPT_SECTION_ASM_OP); ! 279: exception_table __EXCEPTION_END__[1] = { (void*)-1, (void*)-1, (void*)-1 }; ! 280: asm (TEXT_SECTION_ASM_OP); ! 281: ! 282: #endif /* EXCEPT_SECTION_ASM_OP */ ! 283: ! 284: #endif ! 285: ! 286: void ! 287: exception_section () ! 288: { ! 289: #ifdef ASM_OUTPUT_SECTION_NAME ! 290: named_section (".gcc_except_table"); ! 291: #else ! 292: text_section (); ! 293: #endif ! 294: } ! 295: ! 296: ! 297: ! 298: ! 299: /* from: my-cp-except.c */ ! 300: ! 301: /* VI: ":set ts=4" */ ! 302: #if 0 ! 303: #include <stdio.h> */ ! 304: #include "config.h" ! 305: #include "tree.h" ! 306: #include "rtl.h" ! 307: #include "cp-tree.h" ! 308: #endif ! 309: #include "decl.h" ! 310: #if 0 ! 311: #include "flags.h" ! 312: #endif ! 313: #include "insn-flags.h" ! 314: #include "obstack.h" ! 315: #if 0 ! 316: #include "expr.h" ! 317: #endif ! 318: ! 319: /* ====================================================================== ! 320: Briefly the algorithm works like this: ! 321: ! 322: When a constructor or start of a try block is encountered, ! 323: push_eh_entry (&eh_stack) is called. Push_eh_entry () creates a ! 324: new entry in the unwind protection stack and returns a label to ! 325: output to start the protection for that block. ! 326: ! 327: When a destructor or end try block is encountered, pop_eh_entry ! 328: (&eh_stack) is called. Pop_eh_entry () returns the ehEntry it ! 329: created when push_eh_entry () was called. The ehEntry structure ! 330: contains three things at this point. The start protect label, ! 331: the end protect label, and the exception handler label. The end ! 332: protect label should be output before the call to the destructor ! 333: (if any). If it was a destructor, then its parse tree is stored ! 334: in the finalization variable in the ehEntry structure. Otherwise ! 335: the finalization variable is set to NULL to reflect the fact that ! 336: is the the end of a try block. Next, this modified ehEntry node ! 337: is enqueued in the finalizations queue by calling ! 338: enqueue_eh_entry (&queue,entry). ! 339: ! 340: +---------------------------------------------------------------+ ! 341: |XXX: Will need modification to deal with partially | ! 342: | constructed arrays of objects | ! 343: | | ! 344: | Basically, this consists of keeping track of how many | ! 345: | of the objects have been constructed already (this | ! 346: | should be in a register though, so that shouldn't be a | ! 347: | problem. | ! 348: +---------------------------------------------------------------+ ! 349: ! 350: When a catch block is encountered, there is a lot of work to be ! 351: done. ! 352: ! 353: Since we don't want to generate the catch block inline with the ! 354: regular flow of the function, we need to have some way of doing ! 355: so. Luckily, we have a couple of routines "get_last_insn ()" and ! 356: "set_last_insn ()" provided. When the start of a catch block is ! 357: encountered, we save a pointer to the last insn generated. After ! 358: the catch block is generated, we save a pointer to the first ! 359: catch block insn and the last catch block insn with the routines ! 360: "NEXT_INSN ()" and "get_last_insn ()". We then set the last insn ! 361: to be the last insn generated before the catch block, and set the ! 362: NEXT_INSN (last_insn) to zero. ! 363: ! 364: Since catch blocks might be nested inside other catch blocks, and ! 365: we munge the chain of generated insns after the catch block is ! 366: generated, we need to store the pointers to the last insn ! 367: generated in a stack, so that when the end of a catch block is ! 368: encountered, the last insn before the current catch block can be ! 369: popped and set to be the last insn, and the first and last insns ! 370: of the catch block just generated can be enqueue'd for output at ! 371: a later time. ! 372: ! 373: Next we must insure that when the catch block is executed, all ! 374: finalizations for the matching try block have been completed. If ! 375: any of those finalizations throw an exception, we must call ! 376: terminate according to the ARM (section r.15.6.1). What this ! 377: means is that we need to dequeue and emit finalizations for each ! 378: entry in the ehQueue until we get to an entry with a NULL ! 379: finalization field. For any of the finalization entries, if it ! 380: is not a call to terminate (), we must protect it by giving it ! 381: another start label, end label, and exception handler label, ! 382: setting its finalization tree to be a call to terminate (), and ! 383: enqueue'ing this new ehEntry to be output at an outer level. ! 384: Finally, after all that is done, we can get around to outputting ! 385: the catch block which basically wraps all the "catch (...) {...}" ! 386: statements in a big if/then/else construct that matches the ! 387: correct block to call. ! 388: ! 389: ===================================================================== */ ! 390: ! 391: extern rtx emit_insn PROTO((rtx)); ! 392: extern rtx gen_nop PROTO(()); ! 393: ! 394: /* local globals for function calls ! 395: ====================================================================== */ ! 396: ! 397: /* used to cache "terminate ()", "unexpected ()", "set_terminate ()", and ! 398: "set_unexpected ()" after default_conversion. (lib-except.c) */ ! 399: static tree Terminate, Unexpected, SetTerminate, SetUnexpected, CatchMatch; ! 400: ! 401: /* used to cache __find_first_exception_table_match () ! 402: for throw (lib-except.c) */ ! 403: static tree FirstExceptionMatch; ! 404: ! 405: /* used to cache a call to __unwind_function () (lib-except.c) */ ! 406: static tree Unwind; ! 407: ! 408: /* holds a ready to emit call to "terminate ()". */ ! 409: static tree TerminateFunctionCall; ! 410: ! 411: /* ====================================================================== */ ! 412: ! 413: ! 414: ! 415: /* data structures for my various quick and dirty stacks and queues ! 416: Eventually, most of this should go away, because I think it can be ! 417: integrated with stuff already built into the compiler. */ ! 418: ! 419: /* =================================================================== */ ! 420: ! 421: struct labelNode { ! 422: rtx label; ! 423: struct labelNode *chain; ! 424: }; ! 425: ! 426: ! 427: /* this is the most important structure here. Basically this is how I store ! 428: an exception table entry internally. */ ! 429: struct ehEntry { ! 430: rtx start_label; ! 431: rtx end_label; ! 432: rtx exception_handler_label; ! 433: ! 434: tree finalization; ! 435: }; ! 436: ! 437: struct ehNode { ! 438: struct ehEntry *entry; ! 439: struct ehNode *chain; ! 440: }; ! 441: ! 442: struct ehStack { ! 443: struct ehNode *top; ! 444: }; ! 445: ! 446: struct ehQueue { ! 447: struct ehNode *head; ! 448: struct ehNode *tail; ! 449: }; ! 450: ! 451: struct exceptNode { ! 452: rtx catchstart; ! 453: rtx catchend; ! 454: ! 455: struct exceptNode *chain; ! 456: }; ! 457: ! 458: struct exceptStack { ! 459: struct exceptNode *top; ! 460: }; ! 461: /* ========================================================================= */ ! 462: ! 463: ! 464: ! 465: /* local globals - these local globals are for storing data necessary for ! 466: generating the exception table and code in the correct order. ! 467: ! 468: ========================================================================= */ ! 469: ! 470: /* Holds the pc for doing "throw" */ ! 471: rtx saved_pc; ! 472: /* Holds the type of the thing being thrown. */ ! 473: rtx saved_throw_type; ! 474: /* Holds the value being thrown. */ ! 475: rtx saved_throw_value; ! 476: ! 477: rtx throw_label; ! 478: ! 479: static struct ehStack ehstack; ! 480: static struct ehQueue ehqueue; ! 481: static struct ehQueue eh_table_output_queue; ! 482: static struct exceptStack exceptstack; ! 483: static struct labelNode *false_label_stack = NULL; ! 484: static struct labelNode *caught_return_label_stack = NULL; ! 485: /* ========================================================================= */ ! 486: ! 487: /* function prototypes */ ! 488: static struct ehEntry *pop_eh_entry PROTO((struct ehStack *stack)); ! 489: static void enqueue_eh_entry PROTO((struct ehQueue *queue, struct ehEntry *entry)); ! 490: static void push_except_stmts PROTO((struct exceptStack *exceptstack, ! 491: rtx catchstart, rtx catchend)); ! 492: static int pop_except_stmts PROTO((struct exceptStack *exceptstack, ! 493: rtx *catchstart, rtx *catchend)); ! 494: static rtx push_eh_entry PROTO((struct ehStack *stack)); ! 495: static struct ehEntry *dequeue_eh_entry PROTO((struct ehQueue *queue)); ! 496: static void new_eh_queue PROTO((struct ehQueue *queue)); ! 497: static void new_eh_stack PROTO((struct ehStack *stack)); ! 498: static void new_except_stack PROTO((struct exceptStack *queue)); ! 499: static void push_last_insn PROTO(()); ! 500: static rtx pop_last_insn PROTO(()); ! 501: static void push_label_entry PROTO((struct labelNode **labelstack, rtx label)); ! 502: static rtx pop_label_entry PROTO((struct labelNode **labelstack)); ! 503: static rtx top_label_entry PROTO((struct labelNode **labelstack)); ! 504: static struct ehEntry *copy_eh_entry PROTO((struct ehEntry *entry)); ! 505: ! 506: ! 507: ! 508: /* All my cheesy stack/queue/misc data structure handling routines ! 509: ! 510: ========================================================================= */ ! 511: ! 512: static void ! 513: push_label_entry (labelstack, label) ! 514: struct labelNode **labelstack; ! 515: rtx label; ! 516: { ! 517: struct labelNode *newnode=(struct labelNode*)xmalloc (sizeof (struct labelNode)); ! 518: ! 519: newnode->label = label; ! 520: newnode->chain = *labelstack; ! 521: *labelstack = newnode; ! 522: } ! 523: ! 524: static rtx ! 525: pop_label_entry (labelstack) ! 526: struct labelNode **labelstack; ! 527: { ! 528: rtx label; ! 529: struct labelNode *tempnode; ! 530: ! 531: if (! *labelstack) return NULL_RTX; ! 532: ! 533: tempnode = *labelstack; ! 534: label = tempnode->label; ! 535: *labelstack = (*labelstack)->chain; ! 536: free (tempnode); ! 537: ! 538: return label; ! 539: } ! 540: ! 541: static rtx ! 542: top_label_entry (labelstack) ! 543: struct labelNode **labelstack; ! 544: { ! 545: if (! *labelstack) return NULL_RTX; ! 546: ! 547: return (*labelstack)->label; ! 548: } ! 549: ! 550: static void ! 551: push_except_stmts (exceptstack, catchstart, catchend) ! 552: struct exceptStack *exceptstack; ! 553: rtx catchstart, catchend; ! 554: { ! 555: struct exceptNode *newnode = (struct exceptNode*) ! 556: xmalloc (sizeof (struct exceptNode)); ! 557: ! 558: newnode->catchstart = catchstart; ! 559: newnode->catchend = catchend; ! 560: newnode->chain = exceptstack->top; ! 561: ! 562: exceptstack->top = newnode; ! 563: } ! 564: ! 565: static int ! 566: pop_except_stmts (exceptstack, catchstart, catchend) ! 567: struct exceptStack *exceptstack; ! 568: rtx *catchstart, *catchend; ! 569: { ! 570: struct exceptNode *tempnode; ! 571: ! 572: if (!exceptstack->top) { ! 573: *catchstart = *catchend = NULL_RTX; ! 574: return 0; ! 575: } ! 576: ! 577: tempnode = exceptstack->top; ! 578: exceptstack->top = exceptstack->top->chain; ! 579: ! 580: *catchstart = tempnode->catchstart; ! 581: *catchend = tempnode->catchend; ! 582: free (tempnode); ! 583: ! 584: return 1; ! 585: } ! 586: ! 587: /* Push to permanent obstack for rtl generation. ! 588: One level only! */ ! 589: static struct obstack *saved_rtl_obstack; ! 590: void ! 591: push_rtl_perm () ! 592: { ! 593: extern struct obstack permanent_obstack; ! 594: extern struct obstack *rtl_obstack; ! 595: ! 596: saved_rtl_obstack = rtl_obstack; ! 597: rtl_obstack = &permanent_obstack; ! 598: } ! 599: ! 600: /* Pop back to normal rtl handling. */ ! 601: static void ! 602: pop_rtl_from_perm () ! 603: { ! 604: extern struct obstack permanent_obstack; ! 605: extern struct obstack *rtl_obstack; ! 606: ! 607: rtl_obstack = saved_rtl_obstack; ! 608: } ! 609: ! 610: static rtx ! 611: push_eh_entry (stack) ! 612: struct ehStack *stack; ! 613: { ! 614: struct ehNode *node = (struct ehNode*)xmalloc (sizeof (struct ehNode)); ! 615: struct ehEntry *entry = (struct ehEntry*)xmalloc (sizeof (struct ehEntry)); ! 616: ! 617: if (stack == NULL) { ! 618: free (node); ! 619: free (entry); ! 620: return NULL_RTX; ! 621: } ! 622: ! 623: /* These are saved for the exception table. */ ! 624: push_rtl_perm (); ! 625: entry->start_label = gen_label_rtx (); ! 626: entry->end_label = gen_label_rtx (); ! 627: entry->exception_handler_label = gen_label_rtx (); ! 628: pop_rtl_from_perm (); ! 629: ! 630: entry->finalization = NULL_TREE; ! 631: ! 632: node->entry = entry; ! 633: node->chain = stack->top; ! 634: stack->top = node; ! 635: ! 636: enqueue_eh_entry (&eh_table_output_queue, copy_eh_entry (entry)); ! 637: ! 638: return entry->start_label; ! 639: } ! 640: ! 641: static struct ehEntry * ! 642: pop_eh_entry (stack) ! 643: struct ehStack *stack; ! 644: { ! 645: struct ehNode *tempnode; ! 646: struct ehEntry *tempentry; ! 647: ! 648: if (stack && (tempnode = stack->top)) { ! 649: tempentry = tempnode->entry; ! 650: stack->top = stack->top->chain; ! 651: free (tempnode); ! 652: ! 653: return tempentry; ! 654: } ! 655: ! 656: return NULL; ! 657: } ! 658: ! 659: static struct ehEntry * ! 660: copy_eh_entry (entry) ! 661: struct ehEntry *entry; ! 662: { ! 663: struct ehEntry *newentry; ! 664: ! 665: newentry = (struct ehEntry*)xmalloc (sizeof (struct ehEntry)); ! 666: memcpy ((void*)newentry, (void*)entry, sizeof (struct ehEntry)); ! 667: ! 668: return newentry; ! 669: } ! 670: ! 671: static void ! 672: enqueue_eh_entry (queue, entry) ! 673: struct ehQueue *queue; ! 674: struct ehEntry *entry; ! 675: { ! 676: struct ehNode *node = (struct ehNode*)xmalloc (sizeof (struct ehNode)); ! 677: ! 678: node->entry = entry; ! 679: node->chain = NULL; ! 680: ! 681: if (queue->head == NULL) ! 682: { ! 683: queue->head = node; ! 684: } ! 685: else ! 686: { ! 687: queue->tail->chain = node; ! 688: } ! 689: queue->tail = node; ! 690: } ! 691: ! 692: static struct ehEntry * ! 693: dequeue_eh_entry (queue) ! 694: struct ehQueue *queue; ! 695: { ! 696: struct ehNode *tempnode; ! 697: struct ehEntry *tempentry; ! 698: ! 699: if (queue->head == NULL) ! 700: return NULL; ! 701: ! 702: tempnode = queue->head; ! 703: queue->head = queue->head->chain; ! 704: ! 705: tempentry = tempnode->entry; ! 706: free (tempnode); ! 707: ! 708: return tempentry; ! 709: } ! 710: ! 711: static void ! 712: new_eh_queue (queue) ! 713: struct ehQueue *queue; ! 714: { ! 715: queue->head = queue->tail = NULL; ! 716: } ! 717: ! 718: static void ! 719: new_eh_stack (stack) ! 720: struct ehStack *stack; ! 721: { ! 722: stack->top = NULL; ! 723: } ! 724: ! 725: static void ! 726: new_except_stack (stack) ! 727: struct exceptStack *stack; ! 728: { ! 729: stack->top = NULL; ! 730: } ! 731: /* ========================================================================= */ ! 732: ! 733: void ! 734: lang_interim_eh (finalization) ! 735: tree finalization; ! 736: { ! 737: if (finalization) ! 738: end_protect (finalization); ! 739: else ! 740: start_protect (); ! 741: } ! 742: ! 743: /* sets up all the global eh stuff that needs to be initialized at the ! 744: start of compilation. ! 745: ! 746: This includes: ! 747: - Setting up all the function call trees ! 748: - Initializing the ehqueue ! 749: - Initializing the eh_table_output_queue ! 750: - Initializing the ehstack ! 751: - Initializing the exceptstack ! 752: */ ! 753: ! 754: void ! 755: init_exception_processing () ! 756: { ! 757: extern tree define_function (); ! 758: tree unexpected_fndecl, terminate_fndecl; ! 759: tree set_unexpected_fndecl, set_terminate_fndecl; ! 760: tree catch_match_fndecl; ! 761: tree find_first_exception_match_fndecl; ! 762: tree unwind_fndecl; ! 763: tree temp, PFV; ! 764: ! 765: interim_eh_hook = lang_interim_eh; ! 766: ! 767: /* void (*)() */ ! 768: PFV = build_pointer_type (build_function_type (void_type_node, void_list_node)); ! 769: ! 770: /* arg list for the build_function_type call for set_terminate () and ! 771: set_unexpected () */ ! 772: temp = tree_cons (NULL_TREE, PFV, void_list_node); ! 773: ! 774: push_lang_context (lang_name_c); ! 775: ! 776: set_terminate_fndecl = ! 777: define_function ("set_terminate", ! 778: build_function_type (PFV, temp), ! 779: NOT_BUILT_IN, ! 780: pushdecl, ! 781: 0); ! 782: set_unexpected_fndecl = ! 783: define_function ("set_unexpected", ! 784: build_function_type (PFV, temp), ! 785: NOT_BUILT_IN, ! 786: pushdecl, ! 787: 0); ! 788: ! 789: unexpected_fndecl = ! 790: define_function ("unexpected", ! 791: build_function_type (void_type_node, void_list_node), ! 792: NOT_BUILT_IN, ! 793: pushdecl, ! 794: 0); ! 795: terminate_fndecl = ! 796: define_function ("terminate", ! 797: build_function_type (void_type_node, void_list_node), ! 798: NOT_BUILT_IN, ! 799: pushdecl, ! 800: 0); ! 801: catch_match_fndecl = ! 802: define_function ("__throw_type_match", ! 803: build_function_type (integer_type_node, ! 804: tree_cons (NULL_TREE, string_type_node, tree_cons (NULL_TREE, ptr_type_node, void_list_node))), ! 805: NOT_BUILT_IN, ! 806: pushdecl, ! 807: 0); ! 808: find_first_exception_match_fndecl = ! 809: define_function ("__find_first_exception_table_match", ! 810: build_function_type (ptr_type_node, ! 811: tree_cons (NULL_TREE, ptr_type_node, ! 812: void_list_node)), ! 813: NOT_BUILT_IN, ! 814: pushdecl, ! 815: 0); ! 816: unwind_fndecl = ! 817: define_function ("__unwind_function", ! 818: build_function_type (void_type_node, ! 819: tree_cons (NULL_TREE, ptr_type_node, void_list_node)), ! 820: NOT_BUILT_IN, ! 821: pushdecl, ! 822: 0); ! 823: ! 824: Unexpected = default_conversion (unexpected_fndecl); ! 825: Terminate = default_conversion (terminate_fndecl); ! 826: SetTerminate = default_conversion (set_terminate_fndecl); ! 827: SetUnexpected = default_conversion (set_unexpected_fndecl); ! 828: CatchMatch = default_conversion (catch_match_fndecl); ! 829: FirstExceptionMatch = default_conversion (find_first_exception_match_fndecl); ! 830: Unwind = default_conversion (unwind_fndecl); ! 831: BuiltinReturnAddress = default_conversion (builtin_return_address_fndecl); ! 832: ! 833: TerminateFunctionCall = build_function_call (Terminate, NULL_TREE); ! 834: ! 835: pop_lang_context (); ! 836: throw_label = gen_label_rtx (); ! 837: saved_pc = gen_rtx (REG, Pmode, 16); ! 838: saved_throw_type = gen_rtx (REG, Pmode, 17); ! 839: saved_throw_value = gen_rtx (REG, Pmode, 18); ! 840: ! 841: new_eh_queue (&ehqueue); ! 842: new_eh_queue (&eh_table_output_queue); ! 843: new_eh_stack (&ehstack); ! 844: new_except_stack (&exceptstack); ! 845: } ! 846: ! 847: /* call this to begin a block of unwind protection (ie: when an object is ! 848: constructed) */ ! 849: void ! 850: start_protect () ! 851: { ! 852: if (doing_eh (0)) ! 853: { ! 854: emit_label (push_eh_entry (&ehstack)); ! 855: } ! 856: } ! 857: ! 858: /* call this to end a block of unwind protection. the finalization tree is ! 859: the finalization which needs to be run in order to cleanly unwind through ! 860: this level of protection. (ie: call this when a scope is exited)*/ ! 861: void ! 862: end_protect (finalization) ! 863: tree finalization; ! 864: { ! 865: struct ehEntry *entry = pop_eh_entry (&ehstack); ! 866: ! 867: if (! doing_eh (0)) ! 868: return; ! 869: ! 870: emit_label (entry->end_label); ! 871: ! 872: entry->finalization = finalization; ! 873: ! 874: enqueue_eh_entry (&ehqueue, entry); ! 875: } ! 876: ! 877: /* call this on start of a try block. */ ! 878: void ! 879: expand_start_try_stmts () ! 880: { ! 881: if (doing_eh (1)) ! 882: { ! 883: start_protect (); ! 884: } ! 885: } ! 886: ! 887: void ! 888: expand_end_try_stmts () ! 889: { ! 890: end_protect (integer_zero_node); ! 891: } ! 892: ! 893: struct insn_save_node { ! 894: rtx last; ! 895: struct insn_save_node *chain; ! 896: }; ! 897: ! 898: static struct insn_save_node *InsnSave = NULL; ! 899: ! 900: ! 901: /* Used to keep track of where the catch blocks start. */ ! 902: static void ! 903: push_last_insn () ! 904: { ! 905: struct insn_save_node *newnode = (struct insn_save_node*) ! 906: xmalloc (sizeof (struct insn_save_node)); ! 907: ! 908: newnode->last = get_last_insn (); ! 909: newnode->chain = InsnSave; ! 910: InsnSave = newnode; ! 911: } ! 912: ! 913: /* Use to keep track of where the catch blocks start. */ ! 914: static rtx ! 915: pop_last_insn () ! 916: { ! 917: struct insn_save_node *tempnode; ! 918: rtx temprtx; ! 919: ! 920: if (!InsnSave) return NULL_RTX; ! 921: ! 922: tempnode = InsnSave; ! 923: temprtx = tempnode->last; ! 924: InsnSave = InsnSave->chain; ! 925: ! 926: free (tempnode); ! 927: ! 928: return temprtx; ! 929: } ! 930: ! 931: /* call this to start processing of all the catch blocks. */ ! 932: void ! 933: expand_start_all_catch () ! 934: { ! 935: struct ehEntry *entry; ! 936: rtx label; ! 937: ! 938: if (! doing_eh (1)) ! 939: return; ! 940: ! 941: emit_line_note (input_filename, lineno); ! 942: label = gen_label_rtx (); ! 943: /* The label for the exception handling block we will save. */ ! 944: emit_label (label); ! 945: ! 946: push_label_entry (&caught_return_label_stack, label); ! 947: ! 948: /* Remember where we started. */ ! 949: push_last_insn (); ! 950: ! 951: emit_insn (gen_nop ()); ! 952: ! 953: /* Will this help us not stomp on it? */ ! 954: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_type)); ! 955: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_value)); ! 956: ! 957: while (1) ! 958: { ! 959: entry = dequeue_eh_entry (&ehqueue); ! 960: emit_label (entry->exception_handler_label); ! 961: ! 962: expand_expr (entry->finalization, const0_rtx, VOIDmode, 0); ! 963: ! 964: /* When we get down to the matching entry, stop. */ ! 965: if (entry->finalization == integer_zero_node) ! 966: break; ! 967: ! 968: free (entry); ! 969: } ! 970: ! 971: /* This goes when the below moves out of our way. */ ! 972: #if 1 ! 973: label = gen_label_rtx (); ! 974: emit_jump (label); ! 975: #endif ! 976: ! 977: /* All this should be out of line, and saved back in the exception handler ! 978: block area. */ ! 979: #if 1 ! 980: entry->start_label = entry->exception_handler_label; ! 981: /* These are saved for the exception table. */ ! 982: push_rtl_perm (); ! 983: entry->end_label = gen_label_rtx (); ! 984: entry->exception_handler_label = gen_label_rtx (); ! 985: entry->finalization = TerminateFunctionCall; ! 986: pop_rtl_from_perm (); ! 987: emit_label (entry->end_label); ! 988: ! 989: enqueue_eh_entry (&eh_table_output_queue, copy_eh_entry (entry)); ! 990: ! 991: /* After running the finalization, continue on out to the next ! 992: cleanup, if we have nothing better to do. */ ! 993: emit_move_insn (saved_pc, gen_rtx (LABEL_REF, Pmode, entry->end_label)); ! 994: /* Will this help us not stomp on it? */ ! 995: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_type)); ! 996: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_value)); ! 997: emit_jump (throw_label); ! 998: emit_label (entry->exception_handler_label); ! 999: expand_expr (entry->finalization, const0_rtx, VOIDmode, 0); ! 1000: emit_barrier (); ! 1001: #endif ! 1002: emit_label (label); ! 1003: } ! 1004: ! 1005: /* call this to end processing of all the catch blocks. */ ! 1006: void ! 1007: expand_end_all_catch () ! 1008: { ! 1009: rtx catchstart, catchend, last; ! 1010: rtx label; ! 1011: ! 1012: if (! doing_eh (1)) ! 1013: return; ! 1014: ! 1015: /* Find the start of the catch block. */ ! 1016: last = pop_last_insn (); ! 1017: catchstart = NEXT_INSN (last); ! 1018: catchend = get_last_insn (); ! 1019: ! 1020: NEXT_INSN (last) = 0; ! 1021: set_last_insn (last); ! 1022: ! 1023: /* this level of catch blocks is done, so set up the successful catch jump ! 1024: label for the next layer of catch blocks. */ ! 1025: pop_label_entry (&caught_return_label_stack); ! 1026: ! 1027: push_except_stmts (&exceptstack, catchstart, catchend); ! 1028: ! 1029: /* Here we fall through into the continuation code. */ ! 1030: } ! 1031: ! 1032: ! 1033: /* this is called from expand_exception_blocks () to expand the toplevel ! 1034: finalizations for a function. */ ! 1035: void ! 1036: expand_leftover_cleanups () ! 1037: { ! 1038: struct ehEntry *entry; ! 1039: rtx first_label = NULL_RTX; ! 1040: ! 1041: if (! doing_eh (0)) ! 1042: return; ! 1043: ! 1044: /* Will this help us not stomp on it? */ ! 1045: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_type)); ! 1046: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_value)); ! 1047: ! 1048: while ((entry = dequeue_eh_entry (&ehqueue)) != 0) ! 1049: { ! 1050: if (! first_label) ! 1051: first_label = entry->exception_handler_label; ! 1052: emit_label (entry->exception_handler_label); ! 1053: ! 1054: expand_expr (entry->finalization, const0_rtx, VOIDmode, 0); ! 1055: ! 1056: /* leftover try block, opps. */ ! 1057: if (entry->finalization == integer_zero_node) ! 1058: abort (); ! 1059: ! 1060: free (entry); ! 1061: } ! 1062: if (first_label) ! 1063: { ! 1064: rtx label; ! 1065: struct ehEntry entry; ! 1066: /* These are saved for the exception table. */ ! 1067: push_rtl_perm (); ! 1068: label = gen_label_rtx (); ! 1069: entry.start_label = first_label; ! 1070: entry.end_label = label; ! 1071: entry.exception_handler_label = gen_label_rtx (); ! 1072: entry.finalization = TerminateFunctionCall; ! 1073: pop_rtl_from_perm (); ! 1074: emit_label (label); ! 1075: ! 1076: enqueue_eh_entry (&eh_table_output_queue, copy_eh_entry (&entry)); ! 1077: ! 1078: /* After running the finalization, continue on out to the next ! 1079: cleanup, if we have nothing better to do. */ ! 1080: emit_move_insn (saved_pc, gen_rtx (LABEL_REF, Pmode, entry.end_label)); ! 1081: /* Will this help us not stomp on it? */ ! 1082: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_type)); ! 1083: emit_insn (gen_rtx (USE, VOIDmode, saved_throw_value)); ! 1084: emit_jump (throw_label); ! 1085: emit_label (entry.exception_handler_label); ! 1086: expand_expr (entry.finalization, const0_rtx, VOIDmode, 0); ! 1087: emit_barrier (); ! 1088: } ! 1089: } ! 1090: ! 1091: /* call this to start a catch block. Typename is the typename, and identifier ! 1092: is the variable to place the object in or NULL if the variable doesn't ! 1093: matter. If typename is NULL, that means its a "catch (...)" or catch ! 1094: everything. In that case we don't need to do any type checking. ! 1095: (ie: it ends up as the "else" clause rather than an "else if" clause) */ ! 1096: void ! 1097: expand_start_catch_block (declspecs, declarator) ! 1098: tree declspecs, declarator; ! 1099: { ! 1100: rtx false_label_rtx; ! 1101: rtx protect_label_rtx; ! 1102: tree type; ! 1103: tree decl; ! 1104: tree init; ! 1105: ! 1106: if (! doing_eh (1)) ! 1107: return; ! 1108: ! 1109: /* Create a binding level for the parm. */ ! 1110: expand_start_bindings (0); ! 1111: ! 1112: if (declspecs) ! 1113: { ! 1114: tree init_type; ! 1115: decl = grokdeclarator (declarator, declspecs, NORMAL, 1, NULL_TREE); ! 1116: ! 1117: /* Figure out the type that the initializer is. */ ! 1118: init_type = TREE_TYPE (decl); ! 1119: if (TREE_CODE (init_type) != REFERENCE_TYPE) ! 1120: init_type = build_reference_type (init_type); ! 1121: ! 1122: init = convert_from_reference (save_expr (make_tree (init_type, saved_throw_value))); ! 1123: ! 1124: /* Do we need the below two lines? */ ! 1125: /* Let `finish_decl' know that this initializer is ok. */ ! 1126: DECL_INITIAL (decl) = init; ! 1127: /* This needs to be preallocated under the try block, ! 1128: in a union of all catch variables. */ ! 1129: pushdecl (decl); ! 1130: type = TREE_TYPE (decl); ! 1131: ! 1132: /* peel back references, so they match. */ ! 1133: if (TREE_CODE (type) == REFERENCE_TYPE) ! 1134: type = TREE_TYPE (type); ! 1135: } ! 1136: else ! 1137: type = NULL_TREE; ! 1138: ! 1139: /* These are saved for the exception table. */ ! 1140: push_rtl_perm (); ! 1141: false_label_rtx = gen_label_rtx (); ! 1142: protect_label_rtx = gen_label_rtx (); ! 1143: pop_rtl_from_perm (); ! 1144: push_label_entry (&false_label_stack, false_label_rtx); ! 1145: push_label_entry (&false_label_stack, protect_label_rtx); ! 1146: ! 1147: if (type) ! 1148: { ! 1149: tree params; ! 1150: char *typestring; ! 1151: rtx call_rtx, return_value_rtx; ! 1152: tree catch_match_fcall; ! 1153: tree catchmatch_arg, argval; ! 1154: ! 1155: typestring = build_overload_name (type, 1, 1); ! 1156: ! 1157: params = tree_cons (NULL_TREE, ! 1158: combine_strings (build_string (strlen (typestring)+1, typestring)), ! 1159: tree_cons (NULL_TREE, ! 1160: make_tree (ptr_type_node, saved_throw_type), ! 1161: NULL_TREE)); ! 1162: catch_match_fcall = build_function_call (CatchMatch, params); ! 1163: call_rtx = expand_call (catch_match_fcall, NULL_RTX, 0); ! 1164: ! 1165: return_value_rtx = ! 1166: hard_function_value (integer_type_node, catch_match_fcall); ! 1167: ! 1168: /* did the throw type match function return TRUE? */ ! 1169: emit_cmp_insn (return_value_rtx, const0_rtx, NE, NULL_RTX, ! 1170: GET_MODE (return_value_rtx), 0, 0); ! 1171: ! 1172: /* if it returned FALSE, jump over the catch block, else fall into it */ ! 1173: emit_jump_insn (gen_bne (false_label_rtx)); ! 1174: finish_decl (decl, init, NULL_TREE, 0); ! 1175: } ! 1176: else ! 1177: { ! 1178: /* Fall into the catch all section. */ ! 1179: } ! 1180: ! 1181: /* This is the starting of something to protect. */ ! 1182: emit_label (protect_label_rtx); ! 1183: ! 1184: emit_line_note (input_filename, lineno); ! 1185: } ! 1186: ! 1187: ! 1188: /* Call this to end a catch block. Its responsible for emitting the ! 1189: code to handle jumping back to the correct place, and for emitting ! 1190: the label to jump to if this catch block didn't match. */ ! 1191: void expand_end_catch_block () ! 1192: { ! 1193: if (doing_eh (1)) ! 1194: { ! 1195: rtx start_protect_label_rtx; ! 1196: rtx end_protect_label_rtx; ! 1197: tree decls; ! 1198: struct ehEntry entry; ! 1199: ! 1200: /* label we jump to if we caught the exception */ ! 1201: emit_jump (top_label_entry (&caught_return_label_stack)); ! 1202: ! 1203: /* Code to throw out to outer context, if we get an throw from within ! 1204: our catch handler. */ ! 1205: /* These are saved for the exception table. */ ! 1206: push_rtl_perm (); ! 1207: entry.exception_handler_label = gen_label_rtx (); ! 1208: pop_rtl_from_perm (); ! 1209: emit_label (entry.exception_handler_label); ! 1210: emit_move_insn (saved_pc, gen_rtx (LABEL_REF, ! 1211: Pmode, ! 1212: top_label_entry (&caught_return_label_stack))); ! 1213: emit_jump (throw_label); ! 1214: /* No associated finalization. */ ! 1215: entry.finalization = NULL_TREE; ! 1216: ! 1217: /* Because we are reordered out of line, we have to protect this. */ ! 1218: /* label for the start of the protection region. */ ! 1219: start_protect_label_rtx = pop_label_entry (&false_label_stack); ! 1220: ! 1221: /* Cleanup the EH paramater. */ ! 1222: expand_end_bindings (decls = getdecls (), decls != NULL_TREE, 0); ! 1223: ! 1224: /* label we emit to jump to if this catch block didn't match. */ ! 1225: emit_label (end_protect_label_rtx = pop_label_entry (&false_label_stack)); ! 1226: ! 1227: /* Because we are reordered out of line, we have to protect this. */ ! 1228: entry.start_label = start_protect_label_rtx; ! 1229: entry.end_label = end_protect_label_rtx; ! 1230: ! 1231: /* These set up a call to throw the caught exception into the outer ! 1232: context. */ ! 1233: enqueue_eh_entry (&eh_table_output_queue, copy_eh_entry (&entry)); ! 1234: } ! 1235: } ! 1236: ! 1237: /* cheesyness to save some typing. returns the return value rtx */ ! 1238: rtx ! 1239: do_function_call (func, params, return_type) ! 1240: tree func, params, return_type; ! 1241: { ! 1242: tree func_call; ! 1243: func_call = build_function_call (func, params); ! 1244: expand_call (func_call, NULL_RTX, 0); ! 1245: if (return_type != NULL_TREE) ! 1246: return hard_function_value (return_type, func_call); ! 1247: return NULL_RTX; ! 1248: } ! 1249: ! 1250: ! 1251: /* is called from expand_excpetion_blocks () to generate the code in a function ! 1252: to "throw" if anything in the function needs to preform a throw. ! 1253: ! 1254: expands "throw" as the following psuedo code: ! 1255: ! 1256: throw: ! 1257: eh = find_first_exception_match (saved_pc); ! 1258: if (!eh) goto gotta_rethrow_it; ! 1259: goto eh; ! 1260: ! 1261: gotta_rethrow_it: ! 1262: saved_pc = __builtin_return_address (0); ! 1263: pop_to_previous_level (); ! 1264: goto throw; ! 1265: ! 1266: */ ! 1267: static void ! 1268: expand_builtin_throw () ! 1269: { ! 1270: tree fcall; ! 1271: tree params; ! 1272: rtx return_val_rtx; ! 1273: rtx gotta_rethrow_it = gen_label_rtx (); ! 1274: rtx gotta_call_terminate = gen_label_rtx (); ! 1275: rtx unwind_and_throw = gen_label_rtx (); ! 1276: rtx goto_unwind_and_throw = gen_label_rtx (); ! 1277: ! 1278: emit_label (throw_label); ! 1279: ! 1280: /* search for an exception handler for the saved_pc */ ! 1281: return_val_rtx = do_function_call (FirstExceptionMatch, ! 1282: tree_cons (NULL_TREE, make_tree (ptr_type_node, saved_pc), NULL_TREE), ! 1283: ptr_type_node); ! 1284: ! 1285: /* did we find one? */ ! 1286: emit_cmp_insn (return_val_rtx, const0_rtx, EQ, NULL_RTX, ! 1287: GET_MODE (return_val_rtx), 0, 0); ! 1288: ! 1289: /* if not, jump to gotta_rethrow_it */ ! 1290: emit_jump_insn (gen_beq (gotta_rethrow_it)); ! 1291: ! 1292: /* we found it, so jump to it */ ! 1293: emit_indirect_jump (return_val_rtx); ! 1294: ! 1295: /* code to deal with unwinding and looking for it again */ ! 1296: emit_label (gotta_rethrow_it); ! 1297: ! 1298: /* call to __builtin_return_address () */ ! 1299: params=tree_cons (NULL_TREE, integer_zero_node, NULL_TREE); ! 1300: fcall = build_function_call (BuiltinReturnAddress, params); ! 1301: return_val_rtx = expand_expr (fcall, NULL_RTX, SImode, 0); ! 1302: ! 1303: /* did __builtin_return_address () return a valid address? */ ! 1304: emit_cmp_insn (return_val_rtx, const0_rtx, EQ, NULL_RTX, ! 1305: GET_MODE (return_val_rtx), 0, 0); ! 1306: ! 1307: emit_jump_insn (gen_beq (gotta_call_terminate)); ! 1308: ! 1309: /* yes it did */ ! 1310: emit_move_insn (saved_pc, return_val_rtx); ! 1311: do_unwind (throw_label); ! 1312: emit_jump (throw_label); ! 1313: ! 1314: /* no it didn't --> therefore we need to call terminate */ ! 1315: emit_label (gotta_call_terminate); ! 1316: do_function_call (Terminate, NULL_TREE, NULL_TREE); ! 1317: } ! 1318: ! 1319: ! 1320: /* This is called to expand all the toplevel exception handling ! 1321: finalization for a function. It should only be called once per ! 1322: function. */ ! 1323: void ! 1324: expand_exception_blocks () ! 1325: { ! 1326: rtx catchstart, catchend; ! 1327: rtx last; ! 1328: static rtx funcend; ! 1329: ! 1330: funcend = gen_label_rtx (); ! 1331: emit_jump (funcend); ! 1332: /* expand_null_return (); */ ! 1333: ! 1334: while (pop_except_stmts (&exceptstack, &catchstart, &catchend)) { ! 1335: last = get_last_insn (); ! 1336: NEXT_INSN (last) = catchstart; ! 1337: PREV_INSN (catchstart) = last; ! 1338: NEXT_INSN (catchend) = 0; ! 1339: set_last_insn (catchend); ! 1340: } ! 1341: ! 1342: expand_leftover_cleanups (); ! 1343: ! 1344: { ! 1345: static int have_done = 0; ! 1346: if (! have_done && TREE_PUBLIC (current_function_decl) ! 1347: && ! DECL_INLINE (current_function_decl)) ! 1348: { ! 1349: have_done = 1; ! 1350: expand_builtin_throw (); ! 1351: } ! 1352: } ! 1353: emit_label (funcend); ! 1354: } ! 1355: ! 1356: ! 1357: /* call this to expand a throw statement. This follows the following ! 1358: algorithm: ! 1359: ! 1360: 1. Allocate space to save the current PC onto the stack. ! 1361: 2. Generate and emit a label and save its address into the ! 1362: newly allocate stack space since we can't save the pc directly. ! 1363: 3. If this is the first call to throw in this function: ! 1364: generate a label for the throw block ! 1365: 4. jump to the throw block label. */ ! 1366: void ! 1367: expand_throw (exp) ! 1368: tree exp; ! 1369: { ! 1370: rtx label; ! 1371: tree type; ! 1372: ! 1373: if (! doing_eh (1)) ! 1374: return; ! 1375: ! 1376: /* This is the label that represents where in the code we were, when ! 1377: we got an exception. This needs to be updated when we rethrow an ! 1378: exception, so that the matching routine knows to search out. */ ! 1379: label = gen_label_rtx (); ! 1380: emit_label (label); ! 1381: emit_move_insn (saved_pc, gen_rtx (LABEL_REF, Pmode, label)); ! 1382: ! 1383: if (exp) ! 1384: { ! 1385: /* throw expression */ ! 1386: /* First, decay it. */ ! 1387: exp = default_conversion (exp); ! 1388: type = TREE_TYPE (exp); ! 1389: ! 1390: { ! 1391: char *typestring = build_overload_name (type, 1, 1); ! 1392: tree throw_type = build1 (ADDR_EXPR, ptr_type_node, combine_strings (build_string (strlen (typestring)+1, typestring))); ! 1393: rtx throw_type_rtx = expand_expr (throw_type, NULL_RTX, VOIDmode, 0); ! 1394: rtx throw_value_rtx; ! 1395: ! 1396: emit_move_insn (saved_throw_type, throw_type_rtx); ! 1397: exp = convert_to_reference (build_reference_type (build_type_variant (TREE_TYPE (exp), 1, 0)), exp, CONV_STATIC, LOOKUP_COMPLAIN, NULL_TREE); ! 1398: if (exp == error_mark_node) ! 1399: error (" in thrown expression"); ! 1400: throw_value_rtx = expand_expr (build_unary_op (ADDR_EXPR, exp, 0), NULL_RTX, VOIDmode, 0); ! 1401: emit_move_insn (saved_throw_value, throw_value_rtx); ! 1402: } ! 1403: } ! 1404: else ! 1405: { ! 1406: /* rethrow current exception */ ! 1407: /* This part is easy, as we dont' have to do anything else. */ ! 1408: } ! 1409: ! 1410: emit_jump (throw_label); ! 1411: } ! 1412: ! 1413: /* end of: my-cp-except.c */ ! 1414: #endif ! 1415: ! 1416: ! 1417: /* Output the exception table. ! 1418: Return the number of handlers. */ ! 1419: int ! 1420: build_exception_table () ! 1421: { ! 1422: int count = 0; ! 1423: #ifdef TRY_NEW_EH ! 1424: extern FILE *asm_out_file; ! 1425: struct ehEntry *entry; ! 1426: tree eh_node_decl; ! 1427: ! 1428: if (! doing_eh (0)) ! 1429: return 0; ! 1430: ! 1431: while (entry = dequeue_eh_entry (&eh_table_output_queue)) ! 1432: { ! 1433: if (count == 0) ! 1434: { ! 1435: exception_section (); ! 1436: ! 1437: /* Beginning marker for table. */ ! 1438: ASM_OUTPUT_ALIGN (asm_out_file, 2); ! 1439: ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_TABLE__"); ! 1440: fprintf (asm_out_file, " .word 0, 0, 0\n"); ! 1441: } ! 1442: count++; ! 1443: output_exception_table_entry (asm_out_file, ! 1444: entry->start_label, entry->end_label, ! 1445: entry->exception_handler_label); ! 1446: } ! 1447: ! 1448: if (count) ! 1449: { ! 1450: /* Ending marker for table. */ ! 1451: ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_END__"); ! 1452: fprintf (asm_out_file, " .word -1, -1, -1\n"); ! 1453: } ! 1454: ! 1455: #endif /* TRY_NEW_EH */ ! 1456: return count; ! 1457: } ! 1458: ! 1459: void ! 1460: register_exception_table () ! 1461: { ! 1462: #ifdef TRY_NEW_EH ! 1463: emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__register_exceptions"), 0, ! 1464: VOIDmode, 1, ! 1465: gen_rtx (SYMBOL_REF, Pmode, "__EXCEPTION_TABLE__"), ! 1466: Pmode); ! 1467: #endif /* TRY_NEW_EH */ ! 1468: } ! 1469: ! 1470: /* Build a throw expression. */ ! 1471: tree ! 1472: build_throw (e) ! 1473: tree e; ! 1474: { ! 1475: e = build1 (THROW_EXPR, void_type_node, e); ! 1476: TREE_SIDE_EFFECTS (e) = 1; ! 1477: return e; ! 1478: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.