![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-except.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-except.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Handle exceptional things in C++.
2: Copyright (C) 1989, 1992, 1993 Free Software Foundation, Inc.
3: Contributed by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: /* High-level class interface. */
23:
24: #include "config.h"
25: #include "tree.h"
26: #include "rtl.h"
27: #include "cp-tree.h"
28: #include "flags.h"
29: /* On Suns this can get you to the right definition if you
30: set the right value for TARGET. */
31: #include <setjmp.h>
32: #ifdef sequent
33: /* Can you believe they forgot this? */
34: #define _JBLEN 11
35: #endif
36:
37: #ifndef _JBLEN
38: #define _JBLEN (sizeof(jmp_buf)/sizeof(int))
39: #endif
40:
41: #undef NULL
42: #define NULL (char *)0
43:
44: /* This should be part of `ansi_opname', or at least be defined by the std. */
45: #define EXCEPTION_NAME_PREFIX "__ex"
46: #define EXCEPTION_NAME_LENGTH 4
47:
48: void init_exception_processing ();
49: void init_exception_processing_1 ();
50:
51: /* If non-zero, a VAR_DECL whose cleanup will cause a throw to the
52: next exception handler. Its value says whether to throw or not.
53: In the case of functions which do not issue a RAISE, it should be
54: possible to optimize away this VAR_DECL (and overhead associated
55: with it). */
56: tree exception_throw_decl;
57: /* Use this to know that we did not set `exception_throw_decl',
58: until GCC optimizer is smart enough to figure it out for itself. */
59: int sets_exception_throw_decl;
60:
61: /* The exception `type' currently in scope, or NULL_TREE if none. */
62: tree current_exception_type;
63:
64: /* The exception handler object for the given scope. */
65: tree current_exception_decl;
66: rtx current_exception_name_as_rtx;
67: rtx current_exception_parms_as_rtx;
68:
69: /* The ``object'' view of the current exception parameters.
70: We cast up from the `parms' field to `current_exception_type'. */
71: tree current_exception_object;
72:
73: /* Cache `setjmp', `longjmp', `raise_exception', and `unhandled_exception'
74: after default conversion. Maybe later they will get built-in. */
75: static tree BISJ, BILJ, BIR, BIUE;
76:
77: /* Local variables which give the appearance that exception
78: handling is part of the language and the execution model. */
79:
80: /* The type of the exception handler stack. */
81: tree EHS_type;
82:
83: /* The global handler stack. */
84: tree EHS_decl;
85:
86: /* Cached component refs to fields of `EHS_decl'. */
87: static tree EHS_prev, EHS_handler, EHS_parms, EHS_name;
88: static rtx EHS_parms_as_rtx, EHS_name_as_rtx;
89:
90: /* The parameter names of this exception type. */
91:
92: static tree last_exception_fields;
93: static tree last_exception_field_types;
94:
95: /* When ID is VOID_TYPE_NODE, it means ``raise all''.
96: Cannot be inline, since it uses `alloca', and that
97: breaks code which pushes the result of this function
98: on the stack. */
99: static tree
100: exception_object_name (prefix, id)
101: tree prefix;
102: tree id;
103: {
104: /* First, cons up the `name' of this exception. */
105: char *name;
106: int length = (id == void_type_node ? 3 : IDENTIFIER_LENGTH (id)) + EXCEPTION_NAME_LENGTH;
107:
108: if (prefix)
109: length += IDENTIFIER_LENGTH (prefix) + 2;
110:
111: name = (char *)alloca (length);
112: strcpy (name, EXCEPTION_NAME_PREFIX);
113: length = EXCEPTION_NAME_LENGTH;
114: if (prefix)
115: {
116: strcpy (name + length, IDENTIFIER_POINTER (prefix));
117: #ifdef JOINER
118: name[length + IDENTIFIER_LENGTH (prefix)] = JOINER;
119: #else
120: name[length + IDENTIFIER_LENGTH (prefix)] = '_';
121: #endif
122: length += IDENTIFIER_LENGTH (prefix) + 1;
123: }
124: if (id == void_type_node)
125: strcpy (name + length, "all");
126: else
127: strcpy (name + length, IDENTIFIER_POINTER (id));
128: return get_identifier (name);
129: }
130:
131: tree
132: lookup_exception_cname (ctype, cname, raise_id)
133: tree ctype, cname;
134: tree raise_id;
135: {
136: tree this_cname = TREE_PURPOSE (raise_id);
137: if (this_cname == NULL_TREE)
138: {
139: if (cname)
140: {
141: tree name = TREE_VALUE (raise_id);
142: if (purpose_member (name, CLASSTYPE_TAGS (ctype)))
143: this_cname = cname;
144: }
145: }
146: else if (this_cname == void_type_node)
147: this_cname = NULL_TREE;
148: else if (TREE_CODE (this_cname) != IDENTIFIER_NODE)
149: {
150: sorry ("multiple scope refs in `cplus_expand_raise_stmt'");
151: this_cname = error_mark_node;
152: }
153: return this_cname;
154: }
155:
156: tree
157: lookup_exception_tname (oname)
158: tree oname;
159: {
160: return get_identifier (IDENTIFIER_POINTER (oname) + EXCEPTION_NAME_LENGTH);
161: }
162:
163: tree
164: lookup_exception_object (cname, name, complain)
165: tree cname, name;
166: int complain;
167: {
168: tree oname;
169: tree decl;
170:
171: if (cname == void_type_node)
172: cname = NULL_TREE;
173: else if (cname && TREE_CODE (cname) != IDENTIFIER_NODE)
174: {
175: sorry ("multiple scope refs in `lookup_exception_object'");
176: cname = NULL_TREE;
177: }
178: oname = exception_object_name (cname, name);
179: decl = IDENTIFIER_GLOBAL_VALUE (oname);
180: if (decl == NULL_TREE || TREE_CODE (decl) != VAR_DECL)
181: {
182: if (complain)
183: {
184: push_obstacks_nochange ();
185:
186: if (cname)
187: error ("no exception name object for name `%s::%s'",
188: IDENTIFIER_POINTER (cname),
189: IDENTIFIER_POINTER (name));
190: else
191: error ("no exception name object for name `%s'",
192: IDENTIFIER_POINTER (name));
193: end_temporary_allocation ();
194: /* Avoid further error messages. */
195: pushdecl_top_level (build_lang_field_decl (VAR_DECL,
196: exception_object_name (cname, name),
197: error_mark_node));
198: pop_obstacks ();
199: }
200: return NULL_TREE;
201: }
202: return decl;
203: }
204:
205: tree
206: lookup_exception_type (ctype, cname, raise_id)
207: tree ctype, cname;
208: tree raise_id;
209: {
210: tree name = TREE_VALUE (raise_id);
211: tree purpose = TREE_PURPOSE (raise_id);
212:
213: if (cname && purpose == NULL_TREE)
214: purpose = cname;
215:
216: if (purpose && purpose != void_type_node)
217: {
218: tree link = NULL_TREE;
219:
220: if (TREE_CODE (purpose) != IDENTIFIER_NODE)
221: {
222: sorry ("multiple scope refs in `lookup_exception_type'");
223: TREE_PURPOSE (raise_id) = NULL_TREE;
224: return NULL_TREE;
225: }
226: if (! is_aggr_typedef (purpose, 1))
227: return NULL_TREE;
228: ctype = IDENTIFIER_TYPE_VALUE (purpose);
229: link = purpose_member (name, CLASSTYPE_TAGS (ctype));
230: if (link)
231: return TREE_VALUE (link);
232: }
233:
234: ctype = lookup_name (name, 1);
235: if (ctype && TREE_CODE (ctype) == TYPE_DECL)
236: ctype = TREE_TYPE (ctype);
237: if (ctype && TREE_CODE (ctype) == RECORD_TYPE
238: && CLASSTYPE_DECLARED_EXCEPTION (ctype))
239: return ctype;
240: return NULL_TREE;
241: }
242:
243: tree
244: finish_exception (e, list_of_fieldlists)
245: tree e;
246: tree list_of_fieldlists;
247: {
248: tree parmtypes = NULL_TREE, name_field;
249: tree cname = TYPE_NAME (e);
250:
251: if (TREE_CODE (cname) == TYPE_DECL)
252: cname = DECL_NAME (cname);
253:
254: if (last_exception_fields)
255: error ("cannot declare exceptions within exceptions");
256: if (list_of_fieldlists && ! ANON_AGGRNAME_P (cname))
257: cp_error ("exception name `%T' must follow body declaration", e);
258: if (list_of_fieldlists)
259: {
260: tree prev, field;
261:
262: /* Note: no public, private, or protected allowed. */
263: if (TREE_CHAIN (list_of_fieldlists))
264: error ("visibility declarations invalid in exception declaration");
265: else if (TREE_PURPOSE (list_of_fieldlists) != (tree)visibility_default)
266: error ("visibility declarations invalid in exception declaration");
267: TREE_PURPOSE (list_of_fieldlists) = (tree)visibility_default;
268:
269: /* Note also: no member function declarations allowed. */
270: for (prev = 0, field = TREE_VALUE (list_of_fieldlists);
271: field; prev = field, field = TREE_CHAIN (field))
272: {
273: switch (TREE_CODE (field))
274: {
275: case FIELD_DECL:
276: /* ok. */
277: parmtypes = tree_cons (NULL_TREE, TREE_TYPE (field), parmtypes);
278: continue;
279: case FUNCTION_DECL:
280: cp_error ("declaration of function `%D' in exception invalid",
281: field);
282: break;
283: case VAR_DECL:
284: if (TREE_STATIC (field))
285: cp_error ("declaration of static variable `%D' in exception invalid", field);
286: else
287: cp_error ("declaration of constant field `%D' in exception invalid", field);
288: break;
289: case CONST_DECL:
290: cp_error ("declaration of enum value `%D' in exception invalid", field);
291: break;
292: case SCOPE_REF:
293: error ("use of `::' in exception context invalid");
294: break;
295: }
296: if (prev)
297: TREE_CHAIN (prev) = TREE_CHAIN (field);
298: else
299: TREE_VALUE (list_of_fieldlists) = TREE_CHAIN (field);
300: }
301: }
302:
303: /* Now that we've cleaned up the fields, add a name identifier at front. */
304: name_field = build_lang_field_decl (FIELD_DECL, get_identifier ("__name"),
305: ptr_type_node);
306: if (list_of_fieldlists)
307: {
308: TREE_CHAIN (name_field) = TREE_VALUE (list_of_fieldlists);
309: TREE_VALUE (list_of_fieldlists) = name_field;
310: }
311: else
312: list_of_fieldlists = build_tree_list (NULL_TREE, name_field);
313:
314: last_exception_fields = TREE_VALUE (list_of_fieldlists);
315: if (parmtypes)
316: {
317: last_exception_field_types = nreverse (parmtypes);
318: /* Set the TREE_CHAIN of what is now at the end of the
319: list to `void_list_node'. */
320: TREE_CHAIN (parmtypes) = void_list_node;
321: }
322: else
323: last_exception_field_types = void_list_node;
324:
325: popclass (0);
326:
327: #if 0
328: /* Remove aggregate types from the list of tags,
329: since these appear at global scope. */
330: while (x && IS_AGGR_TYPE (TREE_VALUE (x)))
331: x = TREE_CHAIN (x);
332: CLASSTYPE_TAGS (t) = x;
333: y = x;
334: while (x)
335: {
336: if (IS_AGGR_TYPE (TREE_VALUE (x)))
337: TREE_CHAIN (y) = TREE_CHAIN (x);
338: x = TREE_CHAIN (x);
339: }
340: #endif
341:
342: if (flag_cadillac)
343: cadillac_finish_exception (e);
344:
345: return e;
346: }
347:
348: void
349: finish_exception_decl (cname, decl)
350: tree cname, decl;
351: {
352: /* In cp-decl.h. */
353: extern tree last_function_parms;
354:
355: /* An exception declaration. */
356: tree t, ctor;
357: tree parmdecls = NULL_TREE, fields;
358: tree list_of_fieldlists = temp_tree_cons (NULL_TREE,
359: copy_list (last_exception_fields),
360: NULL_TREE);
361: tree edecl = build_lang_field_decl (VAR_DECL,
362: exception_object_name (cname, DECL_NAME (decl)),
363: ptr_type_node);
364:
365: DECL_LANGUAGE (edecl) = lang_c;
366: TREE_STATIC (edecl) = 1;
367: TREE_PUBLIC (edecl) = 1;
368: finish_decl (pushdecl (edecl), NULL_TREE, NULL_TREE, 0);
369:
370: /* Now instantiate the exception decl. */
371: t = xref_tag (exception_type_node, DECL_NAME (decl), NULL_TREE);
372:
373: /* finish_struct will pop this. */
374: pushclass (t, 0);
375:
376: /* Now add a constructor which takes as parameters all the types we
377: just defined. */
378: ctor = build_lang_decl (FUNCTION_DECL, DECL_NAME (decl),
379: build_cplus_method_type (t, TYPE_POINTER_TO (t),
380: last_exception_field_types));
381: /* Don't take `name'. The constructor handles that. */
382: fields = TREE_CHAIN (TREE_VALUE (list_of_fieldlists));
383: while (fields)
384: {
385: tree parm = build_decl (PARM_DECL, DECL_NAME (fields), TREE_TYPE (fields));
386: /* Since there is a prototype, args are passed in their own types. */
387: DECL_ARG_TYPE (parm) = TREE_TYPE (parm);
388: #ifdef PROMOTE_PROTOTYPES
389: if ((TREE_CODE (TREE_TYPE (fields)) == INTEGER_TYPE
390: || TREE_CODE (TREE_TYPE (fields)) == ENUMERAL_TYPE)
391: && TYPE_PRECISION (TREE_TYPE (fields)) < TYPE_PRECISION (integer_type_node))
392: DECL_ARG_TYPE (parm) = integer_type_node;
393: #endif
394: TREE_CHAIN (parm) = parmdecls;
395: parmdecls = parm;
396: fields = TREE_CHAIN (fields);
397: }
398: fields = TREE_VALUE (list_of_fieldlists);
399: last_function_parms = nreverse (parmdecls);
400:
401: DECL_CONSTRUCTOR_P (ctor) = 1;
402: TYPE_HAS_CONSTRUCTOR (t) = 1;
403: grokclassfn (t, DECL_NAME (decl), ctor, NO_SPECIAL, NULL_TREE);
404: DECL_EXTERNAL (ctor) = 1;
405: TREE_STATIC (ctor) = 1;
406: TREE_PUBLIC (ctor) = 0;
407: DECL_INLINE (ctor) = 1;
408: make_decl_rtl (ctor, NULL_PTR, 1);
409: finish_decl (ctor, NULL_TREE, NULL_TREE, 0);
410: TREE_CHAIN (ctor) = TREE_VALUE (list_of_fieldlists);
411: TREE_VALUE (list_of_fieldlists) = ctor;
412:
413: finish_struct (t, list_of_fieldlists, 0);
414:
415: if (current_function_decl)
416: error ("cannot define exception inside function scope");
417: else
418: {
419: enum debug_info_type old_write_symbols = write_symbols;
420: write_symbols = NO_DEBUG;
421:
422: /* Now build the constructor for this exception. */
423: parmdecls = DECL_ARGUMENTS (ctor);
424: start_function (NULL_TREE, ctor, 0, 1);
425: store_parm_decls ();
426: pushlevel (0);
427: clear_last_expr ();
428: push_momentary ();
429: expand_start_bindings (0);
430:
431: /* Move all the parameters to the fields, skipping `this'. */
432: parmdecls = TREE_CHAIN (parmdecls);
433: /* Install `name' of this exception handler. */
434: DECL_INITIAL (fields) = build_unary_op (ADDR_EXPR, edecl, 0);
435: fields = TREE_CHAIN (fields);
436: /* Install all the values. */
437: while (fields)
438: {
439: /* Set up the initialization for this field. */
440: DECL_INITIAL (fields) = parmdecls;
441: fields = TREE_CHAIN (fields);
442: parmdecls = TREE_CHAIN (parmdecls);
443: }
444: emit_base_init (t, 0);
445:
446: finish_function (DECL_SOURCE_LINE (ctor), 1);
447: write_symbols = old_write_symbols;
448: }
449: }
450:
451: void
452: end_exception_decls ()
453: {
454: last_exception_field_types = NULL_TREE;
455: last_exception_fields = NULL_TREE;
456: }
457:
458: /* Statement-level exception semantics. */
459:
460: void
461: cplus_expand_start_try (implicit)
462: int implicit;
463: {
464: tree call_to_setjmp;
465: tree handler, ref;
466:
467: /* Start a new block enclosing the whole handler. */
468: if (implicit)
469: {
470: pushlevel_temporary (1);
471: }
472: else
473: {
474: pushlevel (0);
475: clear_last_expr ();
476: push_momentary ();
477:
478: /* Encompass whole exception handler in one big binding contour.
479: If RAISE should throw out of the whole TRY/EXCEPT block, call
480: `expand_start_bindings' with argument of 1. */
481: expand_start_bindings (0);
482: }
483:
484: /* Allocate handler in that block. It's real name will come later.
485: Note that it will be the first name in this binding contour. */
486: handler = get_temp_name (EHS_type, 0);
487: DECL_INITIAL (handler) = error_mark_node;
488: finish_decl (handler, NULL_TREE, NULL_TREE, 0);
489:
490: /* Must come after call to `finish_decl', else the cleanup for the temp
491: for the handler will cause the contour we just created to be popped. */
492: if (implicit)
493: declare_implicit_exception ();
494:
495: /* Catch via `setjmp'. */
496: ref = build_component_ref (handler, get_identifier ("handler"), NULL_TREE, 0);
497: call_to_setjmp = build_function_call (BISJ, build_tree_list (NULL_TREE, ref));
498:
499: /* RAISE throws to EXCEPT part. */
500: expand_start_try (build_binary_op (EQ_EXPR, call_to_setjmp, integer_zero_node, 1), 0, 1);
501: }
502:
503: /* If KEEP is 1, then declarations in the TRY statement are worth keeping.
504: If KEEP is 2, then the TRY statement was generated by the compiler.
505: If KEEP is 0, the declarations in the TRY statement contain errors. */
506:
507: tree
508: cplus_expand_end_try (keep)
509: int keep;
510: {
511: tree decls, decl, block;
512:
513: if (keep < 2)
514: pop_implicit_try_blocks (NULL_TREE);
515:
516: decls = getdecls ();
517:
518: /* Emit code to avoid falling through into a default
519: handler that might come later. */
520: expand_end_try ();
521:
522: /* Pops binding contour local to TRY, and get the exception handler
523: object built by `...start_try'. */
524: switch (keep)
525: {
526: case 0:
527: expand_end_bindings (decls, 0, 1);
528: block = poplevel (0, 0, 0);
529: pop_momentary ();
530: decl = getdecls ();
531: break;
532:
533: case 1:
534: expand_end_bindings (decls, 1, 1);
535: block = poplevel (1, 1, 0);
536: pop_momentary ();
537: decl = getdecls ();
538: break;
539:
540: default:
541: decl = tree_last (decls);
542: block = NULL_TREE;
543: break;
544: }
545:
546: my_friendly_assert (TREE_CODE (decl) == VAR_DECL
547: && TREE_TYPE (decl) == EHS_type, 203);
548: if (block)
549: {
550: BLOCK_HANDLER_BLOCK (block) = 1;
551: TREE_USED (block) = 1;
552: }
553:
554: /* Pass it back so that its rtl can be bound to its name
555: (or vice versa). */
556: return decl;
557: }
558:
559: void
560: cplus_expand_start_except (name, decl)
561: tree name, decl;
562: {
563: int yes;
564: tree tmp, init;
565:
566: expand_start_except (0, 1);
567:
568: /* This is internal `eh'. */
569: current_exception_decl = decl;
570: current_exception_name_as_rtx
571: = expand_expr (build (COMPONENT_REF, ptr_type_node,
572: current_exception_decl, TREE_OPERAND (EHS_name, 1)),
573: 0, 0, 0);
574: init = build (COMPONENT_REF, ptr_type_node, decl, TREE_OPERAND (EHS_parms, 1));
575: current_exception_parms_as_rtx = expand_expr (init, 0, 0, 0);
576:
577: if (name)
578: {
579: /* Get the exception object into scope (user declared `ex'). */
580: tmp = pushdecl (build_decl (VAR_DECL, name, ptr_type_node));
581: DECL_INITIAL (tmp) = error_mark_node;
582: finish_decl (tmp, init, 0, 0);
583: }
584: current_exception_type = NULL_TREE;
585: yes = suspend_momentary ();
586: if (name)
587: {
588: /* From now on, send the user to our faked-up object. */
589: current_exception_object = build1 (INDIRECT_REF, void_type_node, tmp);
590: IDENTIFIER_LOCAL_VALUE (name) = current_exception_object;
591: }
592: resume_momentary (yes);
593:
594: /* Pop exception handler stack. */
595: expand_assignment (EHS_decl, EHS_prev, 0, 0);
596: }
597:
598: /* Generate the call to `unhandled_exception' that is appropriate
599: for this particular unhandled exception. */
600: static tree
601: call_to_unhandled_exception ()
602: {
603: extern int lineno;
604: extern tree combine_strings ();
605: tree parms = tree_cons (NULL_TREE,
606: combine_strings (build_string (strlen (input_filename + 1), input_filename)),
607: build_tree_list (NULL_TREE, build_int_2 (lineno, 0)));
608: return build_function_call (BIUE, parms);
609: }
610:
611: /* Note that this must be mirror image of `...start_try'.
612: DFAULT is the default clause, if there was one.
613: DFAULT is ERROR_MARK_NODE when this ends an implicit handler. */
614: void
615: cplus_expand_end_except (dfault)
616: tree dfault;
617: {
618: extern tree expand_end_except (); /* stmt.c. */
619: tree decls, raised;
620:
621: if (dfault == NULL_TREE)
622: {
623: /* Uncaught exception at outermost level. If raised locally,
624: reraise the exception. Otherwise, generate code to call `abort'. */
625: if (in_try_block (1) == 0)
626: {
627: expand_start_cond (build (EQ_EXPR, integer_type_node,
628: exception_throw_decl, integer_zero_node), 0);
629: expand_expr (call_to_unhandled_exception (), 0, VOIDmode, 0);
630: expand_end_cond ();
631: }
632: /* Try the next handler. */
633: if (! expand_escape_except ())
634: compiler_error ("except nesting botch");
635: }
636:
637: raised = expand_end_except ();
638:
639: decls = getdecls ();
640: expand_end_bindings (decls, decls != 0, 1);
641: poplevel (decls != 0, 1, 0);
642:
643: /* Implicit handlers do not use the momentary obstack. */
644: if (dfault != error_mark_node)
645: pop_momentary ();
646:
647: if (! in_try_block (1))
648: {
649: /* Check that this function is not raising exceptions
650: it is not supposed to. */
651: while (raised)
652: {
653: cp_error ("exception `%D' raised but not declared raisable",
654: TREE_VALUE (raised));
655: raised = TREE_CHAIN (raised);
656: }
657: }
658: else if (dfault == NULL_TREE || dfault == error_mark_node)
659: {
660: expand_start_cond (build (NE_EXPR, integer_type_node,
661: exception_throw_decl,
662: integer_zero_node), 0);
663: /* We fell off the end of this try block. Try going to the next.
664: The escape_label will be the beginning of the next try block. */
665: if (! expand_escape_except ())
666: compiler_error ("except nesting botch");
667: expand_end_cond ();
668: }
669: }
670:
671: /* Generate code to raise exception RAISE_ID.
672: If EXP is NULL_TREE, then PARMS is the list of parameters to use
673: for constructing this exception.
674: If EXP is non-NULL, then it is an already constructed object
675: of the kind that we want.
676:
677: FOR_RERAISE is non-zero if this raise is called by reraise. In
678: this case we do not need to emit extra gotos to avoid warning messages;
679: the caller will do that once after all the exceptions it reraises
680: are handled and raised. */
681: void
682: cplus_expand_raise (raise_id, parms, exp, for_reraise)
683: tree raise_id;
684: tree parms;
685: tree exp;
686: int for_reraise;
687: {
688: /* Allocate new exception of appropriate type, passing
689: PARMS to its constructor. */
690: tree cname, name;
691: tree decl;
692: tree xexp = exp;
693:
694: cname = lookup_exception_cname (current_class_type, current_class_name, raise_id);
695: if (cname == error_mark_node)
696: return;
697: name = TREE_VALUE (raise_id);
698:
699: decl = lookup_exception_object (cname, name, 1);
700: if (decl == NULL_TREE)
701: return;
702:
703: if (exp == NULL_TREE)
704: {
705: exp = build_method_call (NULL_TREE, name, parms, NULL_TREE, LOOKUP_COMPLAIN);
706: if (exp == error_mark_node)
707: return;
708: }
709:
710: if (in_try_block (1))
711: {
712: expand_raise (decl);
713: }
714: else if (! current_function_decl)
715: {
716: if (xexp == NULL_TREE)
717: cp_error ("invalid raise of `%D' outside of functions", decl);
718: else
719: cp_error ("invalid reraise of `%D' outside of functions", decl);
720: }
721: else
722: {
723: /* Test this raise against what this function permits. */
724: tree names = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl));
725: while (names)
726: {
727: if (decl == TREE_TYPE (names))
728: break;
729: names = TREE_CHAIN (names);
730: }
731: if (names == NULL_TREE)
732: {
733: error ("current function not declared to raise exception `%s'",
734: IDENTIFIER_POINTER (name));
735: return;
736: }
737: }
738:
739: store_expr (exp, EHS_parms_as_rtx, 0);
740:
741: /* Set the global exception handler stack's NAME field
742: to the `name' of this exception. The global exception
743: handler stack is the container for the exception object
744: we just built.
745:
746: We go through a function call to make life easier when debugging. */
747: #if 0
748: expand_assignment (EHS_name, build_unary_op (ADDR_EXPR, decl, 0), 0, 0);
749: #else
750: parms = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, EHS_name, 0),
751: build_tree_list (NULL_TREE,
752: build_unary_op (ADDR_EXPR, decl, 0)));
753: expand_expr (build_function_call (BIR, parms), 0, 0, 0);
754: #endif
755:
756: /* Activate thrower. If we are inside a TRY statement,
757: we can cheat and not do this, saving a longjmp. */
758: if (in_try_block (1) == 0)
759: {
760: sets_exception_throw_decl = 1;
761: emit_move_insn (DECL_RTL (exception_throw_decl), const1_rtx);
762: }
763:
764: if (xexp == NULL_TREE)
765: {
766: /* Invoke destructors for current procedure or handler. */
767: if (! expand_escape_except ())
768: compiler_error ("except nesting botch");
769: /* Throw via `longjmp'... Done as side-effect of goto. */
770: }
771: /* To avoid spurious warning messages, we add a goto to the end
772: of the function. This code is dead, and the compiler should
773: know how to delete it, but for now, we are stuck with it. */
774: if (! for_reraise
775: && TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
776: expand_null_return ();
777: }
778:
779: extern tree cplus_exception_name ();
780:
781: tree
782: ansi_exception_object_lookup (type)
783: tree type;
784: {
785: tree raise_id = cplus_exception_name (type);
786: tree decl;
787:
788: decl = IDENTIFIER_GLOBAL_VALUE (raise_id);
789: if (decl == NULL_TREE || TREE_CODE (decl) != VAR_DECL)
790: {
791: push_obstacks_nochange ();
792: end_temporary_allocation ();
793: decl = build_decl (VAR_DECL, raise_id, ptr_type_node);
794: TREE_PUBLIC (decl) = 1;
795: TREE_STATIC (decl) = 1;
796: pushdecl_top_level (decl);
797: make_decl_rtl (decl, (char*)0, 1);
798: pop_obstacks ();
799: }
800: return decl;
801: }
802:
803: /* Generate code to throw an exception using EXP.
804: Usng ANSI syntax and semantics.
805: If EXP is NULL_TREE< re-raise instead. */
806:
807: void
808: cplus_expand_throw (exp)
809: tree exp;
810: {
811: tree parms;
812: int for_reraise;
813: /* Allocate new exception of appropriate type, passing
814: PARMS to its constructor. */
815: tree decl = ansi_exception_object_lookup (TREE_TYPE (exp));
816: tree xexp = exp;
817:
818: if (in_try_block (1))
819: {
820: #if 1
821: my_friendly_abort (35);
822: #else
823: expand_raise (decl);
824: #endif
825: }
826: else if (! current_function_decl)
827: error ("invalid throw outside of functions");
828: else
829: {
830: #if 0
831: /* Test this raise against what this function permits. */
832: tree names = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl));
833: while (names)
834: {
835: if (decl == TREE_TYPE (names))
836: break;
837: names = TREE_CHAIN (names);
838: }
839: if (names == NULL_TREE)
840: {
841: error ("current function not declared to raise exception `%s'",
842: IDENTIFIER_POINTER (name));
843: return;
844: }
845: #endif
846: }
847:
848: store_expr (exp, EHS_parms_as_rtx, 0);
849:
850: /* Set the global exception handler stack's NAME field
851: to the `name' of this exception. The global exception
852: handler stack is the container for the exception object
853: we just built.
854:
855: We go through a function call to make life easier when debugging. */
856: #if 0
857: expand_assignment (EHS_name, build_unary_op (ADDR_EXPR, decl, 0), 0, 0);
858: #else
859: parms = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, EHS_name, 0),
860: build_tree_list (NULL_TREE,
861: build_unary_op (ADDR_EXPR, decl, 0)));
862: expand_expr (build_function_call (BIR, parms), 0, 0, 0);
863: #endif
864:
865: /* Activate thrower. If we are inside a TRY statement,
866: we can cheat and not do this, saving a longjmp. */
867: if (in_try_block (1) == 0)
868: {
869: sets_exception_throw_decl = 1;
870: emit_move_insn (DECL_RTL (exception_throw_decl), const1_rtx);
871: }
872:
873: if (xexp == NULL_TREE)
874: {
875: /* Invoke destructors for current procedure or handler. */
876: if (! expand_escape_except ())
877: compiler_error ("except nesting botch");
878: /* Throw via `longjmp'... Done as side-effect of goto. */
879: }
880:
881: /* XXX: for_reraise is never set above here. */
882: /* To avoid spurious warning messages, we add a goto to the end
883: of the function. This code is dead, and the compiler should
884: know how to delete it, but for now, we are stuck with it. */
885: if (! for_reraise
886: && TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
887: expand_null_return ();
888: }
889:
890: tree
891: cplus_expand_start_catch (raise_id)
892: tree raise_id;
893: {
894: tree cname = lookup_exception_cname (current_class_type, current_class_name, raise_id);
895: tree decl;
896: tree cond;
897:
898: if (cname == error_mark_node)
899: {
900: decl = error_mark_node;
901: cond = error_mark_node;
902: }
903: else
904: {
905: decl = lookup_exception_object (cname, TREE_VALUE (raise_id), 1);
906: if (decl == NULL_TREE)
907: cond = error_mark_node;
908: else
909: cond = build_binary_op (EQ_EXPR, build_unary_op (ADDR_EXPR, decl, 0),
910: build (COMPONENT_REF, ptr_type_node,
911: current_exception_decl,
912: TREE_OPERAND (EHS_name, 1)),
913: 1);
914: }
915: expand_start_cond (cond, 0);
916:
917: /* Does nothing right now. */
918: expand_catch (decl);
919: if (current_exception_type
920: && TYPE_NEEDS_DESTRUCTOR (current_exception_type))
921: {
922: /* Make a cleanup for the name-specific exception object now in scope. */
923: tree cleanup = maybe_build_cleanup (current_exception_object);
924: expand_start_bindings (0);
925: expand_decl_cleanup (NULL_TREE, cleanup);
926: }
927: return decl;
928: }
929: tree
930: ansi_expand_start_catch (raise_type)
931: tree raise_type;
932: {
933: tree decl = ansi_exception_object_lookup (raise_type);
934: tree cond;
935:
936: if (decl == NULL_TREE)
937: cond = error_mark_node;
938: else
939: cond = build_binary_op (EQ_EXPR, build_unary_op (ADDR_EXPR, decl, 0),
940: build (COMPONENT_REF, ptr_type_node,
941: current_exception_decl,
942: TREE_OPERAND (EHS_name, 1)),
943: 1);
944: expand_start_cond (cond, 0);
945:
946: /* Does nothing right now. */
947: expand_catch (decl);
948: return decl;
949: }
950:
951: void
952: cplus_expand_end_catch (for_reraise)
953: int for_reraise;
954: {
955: if (current_exception_type
956: && TYPE_NEEDS_DESTRUCTOR (current_exception_type))
957: {
958: /* Destroy the specific exception object now in scope. */
959: expand_end_bindings (getdecls (), 0, 1);
960: }
961: if (for_reraise)
962: {
963: if (! expand_escape_except ())
964: my_friendly_abort (36);
965: }
966: else
967: {
968: if (! expand_end_catch ())
969: my_friendly_abort (37);
970: }
971: expand_end_cond ();
972: }
973:
974: /* Reraise an exception.
975: If EXCEPTIONS is NULL_TREE, it means reraise whatever exception was caught.
976: If EXCEPTIONS is an IDENTIFIER_NODE, it means reraise the exception
977: object named by EXCEPTIONS. This must be a variable declared in
978: an `except' clause.
979: If EXCEPTIONS is a TREE_LIST, it is the list of exceptions we are
980: willing to reraise. */
981:
982: void
983: cplus_expand_reraise (exceptions)
984: tree exceptions;
985: {
986: tree ex_ptr;
987: tree ex_object = current_exception_object;
988: rtx ex_ptr_as_rtx;
989:
990: if (exceptions && TREE_CODE (exceptions) == IDENTIFIER_NODE)
991: {
992: /* Don't get tripped up if its TREE_TYPE is `error_mark_node'. */
993: ex_object = IDENTIFIER_LOCAL_VALUE (exceptions);
994: if (ex_object == NULL_TREE || TREE_CODE (ex_object) != INDIRECT_REF)
995: {
996: error ("`%s' is not an exception decl", IDENTIFIER_POINTER (exceptions));
997: return;
998: }
999: my_friendly_assert (TREE_CODE (TREE_OPERAND (ex_object, 0)) == VAR_DECL,
1000: 204);
1001: exceptions = NULL_TREE;
1002: }
1003:
1004: ex_ptr = build1 (NOP_EXPR, ptr_type_node, TREE_OPERAND (ex_object, 0));
1005: ex_ptr_as_rtx = expand_expr (ex_ptr, 0, 0, 0);
1006:
1007: /* reraise ALL, used by compiler. */
1008: if (exceptions == NULL_TREE)
1009: {
1010: /* Now treat reraise like catch/raise. */
1011: expand_catch (error_mark_node);
1012: expand_raise (error_mark_node);
1013: emit_move_insn (EHS_name_as_rtx, current_exception_name_as_rtx);
1014: store_expr ((tree) EHS_parms_as_rtx, current_exception_parms_as_rtx, 0);
1015: if (in_try_block (1) == 0)
1016: {
1017: sets_exception_throw_decl = 1;
1018: emit_move_insn (DECL_RTL (exception_throw_decl), const1_rtx);
1019: }
1020: /* Set to zero so that destructor will not be called. */
1021: emit_move_insn (ex_ptr_as_rtx, const0_rtx);
1022: if (! expand_escape_except ())
1023: my_friendly_abort (38);
1024:
1025: /* To avoid spurious warning messages, we add a goto to the end
1026: of the function. This code is dead, and the compiler should
1027: know how to delete it, but for now, we are stuck with it. */
1028: if (TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
1029: expand_null_return ();
1030:
1031: return;
1032: }
1033:
1034: /* reraise from a list of exceptions. */
1035: while (exceptions)
1036: {
1037: tree type = lookup_exception_type (current_class_type, current_class_name,
1038: exceptions);
1039: if (type == NULL_TREE)
1040: {
1041: error ("`%s' is not an exception type",
1042: IDENTIFIER_POINTER (TREE_VALUE (exceptions)));
1043: current_exception_type = NULL_TREE;
1044: TREE_TYPE (ex_object) = error_mark_node;
1045: TREE_TYPE (ex_ptr) = error_mark_node;
1046: }
1047: else
1048: {
1049: current_exception_type = type;
1050: /* In-place union. */
1051: TREE_TYPE (ex_object) = type;
1052: TREE_TYPE (ex_ptr) = TYPE_POINTER_TO (type);
1053: }
1054:
1055: /* Now treat reraise like catch/raise. */
1056: cplus_expand_start_catch (exceptions);
1057: cplus_expand_raise (exceptions, NULL_TREE, ex_ptr, 1);
1058: /* Set to zero so that destructor will not be called. */
1059: if (TREE_TYPE (ex_ptr) != error_mark_node)
1060: emit_move_insn (ex_ptr_as_rtx, const0_rtx);
1061: cplus_expand_end_catch (1);
1062: exceptions = TREE_CHAIN (exceptions);
1063: }
1064: /* Don't propagate any unhandled exceptions. */
1065: expand_expr (call_to_unhandled_exception (), 0, VOIDmode, 0);
1066:
1067: /* To avoid spurious warning messages, we add a goto to the end
1068: of the function. This code is dead, and the compiler should
1069: know how to delete it, but for now, we are stuck with it. */
1070: if (TREE_TYPE (DECL_RESULT (current_function_decl)) != void_type_node)
1071: expand_null_return ();
1072: }
1073:
1074: void
1075: setup_exception_throw_decl ()
1076: {
1077: tree call_to_longjmp, parms;
1078:
1079: int old = suspend_momentary ();
1080:
1081: exception_throw_decl = build_decl (VAR_DECL, get_identifier (THROW_NAME), integer_type_node);
1082: pushdecl (exception_throw_decl);
1083: parms = tree_cons (NULL_TREE, EHS_handler,
1084: build_tree_list (0, integer_one_node));
1085: call_to_longjmp = build_function_call (BILJ, parms);
1086:
1087: expand_decl (exception_throw_decl);
1088: expand_decl_cleanup (exception_throw_decl,
1089: build (COND_EXPR, void_type_node,
1090: exception_throw_decl,
1091: call_to_longjmp, integer_zero_node));
1092: DECL_INITIAL (exception_throw_decl) = integer_zero_node;
1093: sets_exception_throw_decl = 0;
1094: resume_momentary (old);
1095:
1096: /* Cache these, since they won't change throughout the function. */
1097: EHS_parms_as_rtx = expand_expr (EHS_parms, 0, 0, 0);
1098: EHS_name_as_rtx = expand_expr (EHS_name, 0, 0, 0);
1099: }
1100:
1101: void
1102: init_exception_processing ()
1103: {
1104: extern tree build_function_type (), define_function ();
1105: extern tree unhandled_exception_fndecl;
1106: tree cname = get_identifier ("ExceptionHandler");
1107: tree field, chain;
1108: tree ctor, dtor;
1109: tree jmp_buf_type = build_array_type (integer_type_node,
1110: build_index_type (build_int_2 (_JBLEN-1, 0)));
1111: tree jmp_buf_arg_type = build_pointer_type (integer_type_node);
1112:
1113: tree parmtypes = hash_tree_chain (jmp_buf_arg_type, void_list_node);
1114: tree setjmp_fndecl, longjmp_fndecl, raise_fndecl;
1115:
1116: int old_interface_only = interface_only;
1117: int old_interface_unknown = interface_unknown;
1118: interface_only = 1;
1119: interface_unknown = 0;
1120: EHS_type = xref_tag (record_type_node, cname, NULL_TREE);
1121: push_lang_context (lang_name_c);
1122: setjmp_fndecl = define_function ("setjmp",
1123: build_function_type (integer_type_node,
1124: parmtypes),
1125: NOT_BUILT_IN, pushdecl, 0);
1126: BISJ = default_conversion (setjmp_fndecl);
1127: parmtypes = hash_tree_chain (jmp_buf_arg_type,
1128: hash_tree_chain (integer_type_node, void_list_node));
1129: longjmp_fndecl = define_function ("longjmp",
1130: build_function_type (void_type_node, parmtypes),
1131: NOT_BUILT_IN, pushdecl, 0);
1132: raise_fndecl = define_function ("__raise_exception",
1133: build_function_type (void_type_node,
1134: hash_tree_chain (ptr_type_node,
1135: hash_tree_chain (build_pointer_type (ptr_type_node), void_list_node))),
1136: NOT_BUILT_IN, pushdecl, 0);
1137: BILJ = default_conversion (longjmp_fndecl);
1138: BIR = default_conversion (raise_fndecl);
1139: BIUE = default_conversion (unhandled_exception_fndecl);
1140:
1141: pop_lang_context ();
1142:
1143: /* finish_struct will pop this. */
1144: pushclass (EHS_type, 0);
1145: field = build_lang_field_decl (FIELD_DECL, get_identifier ("parms"), ptr_type_node);
1146: chain = field;
1147: field = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
1148: build_pointer_type (default_function_type));
1149: TREE_CHAIN (field) = chain;
1150: chain = field;
1151: field = build_lang_field_decl (FIELD_DECL, get_identifier ("handler"), jmp_buf_type);
1152: TREE_CHAIN (field) = chain;
1153: chain = field;
1154: field = build_lang_field_decl (FIELD_DECL, get_identifier ("prev"),
1155: TYPE_POINTER_TO (EHS_type));
1156: TREE_CHAIN (field) = chain;
1157: chain = field;
1158:
1159: ctor = build_lang_decl (FUNCTION_DECL, cname,
1160: build_cplus_method_type (EHS_type, TYPE_POINTER_TO (EHS_type), void_list_node));
1161: DECL_CONSTRUCTOR_P (ctor) = 1;
1162: TREE_STATIC (ctor) = 1;
1163: TREE_PUBLIC (ctor) = 1;
1164: DECL_EXTERNAL (ctor) = 1;
1165: grokclassfn (EHS_type, cname, ctor, NO_SPECIAL, 0);
1166: grok_ctor_properties (EHS_type, ctor);
1167: finish_decl (pushdecl (ctor), NULL_TREE, NULL_TREE, 0);
1168: /* Must copy the node here because the FUNCTION_DECL
1169: used inside the struct ain't the same as the
1170: FUNCTION_DECL we stick into the global binding
1171: contour. */
1172: ctor = copy_node (ctor);
1173: TREE_CHAIN (ctor) = chain;
1174: chain = ctor;
1175: dtor = build_lang_decl (FUNCTION_DECL, cname,
1176: build_cplus_method_type (EHS_type, TYPE_POINTER_TO (EHS_type), void_list_node));
1177: TREE_STATIC (dtor) = 1;
1178: TREE_PUBLIC (dtor) = 1;
1179: DECL_EXTERNAL (dtor) = 1;
1180: grokclassfn (EHS_type, cname, dtor, DTOR_FLAG, 0);
1181: finish_decl (pushdecl (dtor), NULL_TREE, NULL_TREE, 0);
1182: /* Copy for the same reason as copying ctor. */
1183: dtor = copy_node (dtor);
1184: TREE_CHAIN (dtor) = chain;
1185: chain = dtor;
1186: TYPE_HAS_CONSTRUCTOR (EHS_type) = 1;
1187: TYPE_HAS_DESTRUCTOR (EHS_type) = 1;
1188: finish_struct (EHS_type, temp_tree_cons (NULL_TREE, chain, NULL_TREE), 0);
1189: interface_only = old_interface_only;
1190: interface_unknown = old_interface_unknown;
1191: }
1192:
1193: void
1194: init_exception_processing_1 ()
1195: {
1196: register tree EHS_id = get_identifier ("exceptionHandlerStack");
1197:
1198: EHS_decl = IDENTIFIER_GLOBAL_VALUE (EHS_id);
1199:
1200: /* If we have no other definition, default to library implementation. */
1201: if (EHS_decl == NULL_TREE)
1202: {
1203: EHS_decl = build_decl (VAR_DECL, EHS_id, TYPE_POINTER_TO (EHS_type));
1204: /* If we don't push this, its definition, should it be encountered,
1205: will not be seen. */
1206: EHS_decl = pushdecl (EHS_decl);
1207: DECL_EXTERNAL (EHS_decl) = 1;
1208: TREE_STATIC (EHS_decl) = 1;
1209: TREE_PUBLIC (EHS_decl) = 1;
1210: finish_decl (EHS_decl, NULL_TREE, NULL_TREE, 0);
1211: }
1212: else if (TREE_CODE (EHS_decl) != VAR_DECL
1213: || TREE_TYPE (EHS_decl) != TYPE_POINTER_TO (EHS_type))
1214: fatal ("exception handling declarations conflict with compiler's internal model");
1215:
1216: if (EHS_prev == NULL_TREE)
1217: {
1218: register tree EHS_DECL = build1 (INDIRECT_REF, EHS_type, EHS_decl);
1219: EHS_prev = build_component_ref (EHS_DECL, get_identifier ("prev"), 0, 0);
1220: EHS_handler = build_component_ref (EHS_DECL, get_identifier ("handler"), 0, 0);
1221: EHS_parms = build_component_ref (EHS_DECL, get_identifier ("parms"), 0, 0);
1222: EHS_name = build_component_ref (EHS_DECL, get_identifier ("name"), 0, 0);
1223: }
1224: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.