diff options
| author | mrg <mrg@NetBSD.org> | 2006-06-02 22:17:11 +0000 |
|---|---|---|
| committer | mrg <mrg@NetBSD.org> | 2006-06-02 22:17:11 +0000 |
| commit | bd88defe28db0f3e04ee650d86c5bbc95f9a481e (patch) | |
| tree | f3e56ee9f07cf1d11f0dd395f7a0029f700cbc62 /gnu/dist/toolchain/gcc/java/except.c | |
| parent | db19e89e04ef4a31ce779771479fada19bccde62 (diff) | |
delete GCC2.95.3 sources.
Diffstat (limited to 'gnu/dist/toolchain/gcc/java/except.c')
| -rw-r--r-- | gnu/dist/toolchain/gcc/java/except.c | 404 |
1 files changed, 0 insertions, 404 deletions
diff --git a/gnu/dist/toolchain/gcc/java/except.c b/gnu/dist/toolchain/gcc/java/except.c deleted file mode 100644 index 920f81a3a42..00000000000 --- a/gnu/dist/toolchain/gcc/java/except.c +++ /dev/null @@ -1,404 +0,0 @@ -/* Handle exceptions for GNU compiler for the Java(TM) language. - Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc. - -This file is part of GNU CC. - -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. - -Java and all Java-based marks are trademarks or registered trademarks -of Sun Microsystems, Inc. in the United States and other countries. -The Free Software Foundation is independent of Sun Microsystems, Inc. */ - -#include "config.h" -#include "system.h" -#include "tree.h" -#include "real.h" -#include "rtl.h" -#include "java-tree.h" -#include "javaop.h" -#include "java-opcodes.h" -#include "jcf.h" -#include "except.h" -#include "java-except.h" -#include "eh-common.h" -#include "toplev.h" - -static void expand_start_java_handler PROTO ((struct eh_range *)); -static void expand_end_java_handler PROTO ((struct eh_range *)); - -extern struct obstack permanent_obstack; - -struct eh_range *current_method_handlers; - -struct eh_range *current_try_block = NULL; - -struct eh_range *eh_range_freelist = NULL; - -/* These variables are used to speed up find_handler. */ - -static int cache_range_start, cache_range_end; -static struct eh_range *cache_range; -static struct eh_range *cache_next_child; - -/* A dummy range that represents the entire method. */ - -struct eh_range whole_range; - -/* Search for the most specific eh_range containing PC. - Assume PC is within RANGE. - CHILD is a list of children of RANGE such that any - previous children have end_pc values that are too low. */ - -static struct eh_range * -find_handler_in_range (pc, range, child) - int pc; - struct eh_range *range; - register struct eh_range *child; -{ - for (; child != NULL; child = child->next_sibling) - { - if (pc < child->start_pc) - break; - if (pc < child->end_pc) - return find_handler_in_range (pc, child, child->first_child); - } - cache_range = range; - cache_range_start = pc; - cache_next_child = child; - cache_range_end = child == NULL ? range->end_pc : child->start_pc; - return range; -} - -/* Find the inner-most handler that contains PC. */ - -struct eh_range * -find_handler (pc) - int pc; -{ - struct eh_range *h; - if (pc >= cache_range_start) - { - h = cache_range; - if (pc < cache_range_end) - return h; - while (pc >= h->end_pc) - { - cache_next_child = h->next_sibling; - h = h->outer; - } - } - else - { - h = &whole_range; - cache_next_child = h->first_child; - } - return find_handler_in_range (pc, h, cache_next_child); -} - -/* Recursive helper routine for check_nested_ranges. */ - -static void -link_handler (range, outer) - struct eh_range *range, *outer; -{ - struct eh_range **ptr; - - if (range->start_pc == outer->start_pc && range->end_pc == outer->end_pc) - { - outer->handlers = chainon (range->handlers, outer->handlers); - return; - } - - /* If the new range completely encloses the `outer' range, then insert it - between the outer range and its parent. */ - if (range->start_pc <= outer->start_pc && range->end_pc >= outer->end_pc) - { - range->outer = outer->outer; - range->next_sibling = NULL; - range->first_child = outer; - { - struct eh_range **pr = &(outer->outer->first_child); - while (*pr != outer) - pr = &(*pr)->next_sibling; - *pr = range; - } - outer->outer = range; - return; - } - - /* Handle overlapping ranges by splitting the new range. */ - if (range->start_pc < outer->start_pc || range->end_pc > outer->end_pc) - { - struct eh_range *h - = (struct eh_range *) oballoc (sizeof (struct eh_range)); - if (range->start_pc < outer->start_pc) - { - h->start_pc = range->start_pc; - h->end_pc = outer->start_pc; - range->start_pc = outer->start_pc; - } - else - { - h->start_pc = outer->end_pc; - h->end_pc = range->end_pc; - range->end_pc = outer->end_pc; - } - h->first_child = NULL; - h->outer = NULL; - h->handlers = build_tree_list (TREE_PURPOSE (range->handlers), - TREE_VALUE (range->handlers)); - h->next_sibling = NULL; - /* Restart both from the top to avoid having to make this - function smart about reentrancy. */ - link_handler (h, &whole_range); - link_handler (range, &whole_range); - return; - } - - ptr = &outer->first_child; - for (;; ptr = &(*ptr)->next_sibling) - { - if (*ptr == NULL || range->end_pc <= (*ptr)->start_pc) - { - range->next_sibling = *ptr; - range->first_child = NULL; - range->outer = outer; - *ptr = range; - return; - } - else if (range->start_pc < (*ptr)->end_pc) - { - link_handler (range, *ptr); - return; - } - /* end_pc > (*ptr)->start_pc && start_pc >= (*ptr)->end_pc. */ - } -} - -/* The first pass of exception range processing (calling add_handler) - constructs a linked list of exception ranges. We turn this into - the data structure expected by the rest of the code, and also - ensure that exception ranges are properly nested. */ - -void -handle_nested_ranges () -{ - struct eh_range *ptr, *next; - - ptr = whole_range.first_child; - whole_range.first_child = NULL; - for (; ptr; ptr = next) - { - next = ptr->next_sibling; - ptr->next_sibling = NULL; - link_handler (ptr, &whole_range); - } -} - - -/* Called to re-initialize the exception machinery for a new method. */ - -void -method_init_exceptions () -{ - whole_range.start_pc = 0; - whole_range.end_pc = DECL_CODE_LENGTH (current_function_decl) + 1; - whole_range.outer = NULL; - whole_range.first_child = NULL; - whole_range.next_sibling = NULL; - cache_range_start = 0xFFFFFF; - java_set_exception_lang_code (); -} - -void -java_set_exception_lang_code () -{ - set_exception_lang_code (EH_LANG_Java); - set_exception_version_code (1); -} - -/* Add an exception range. If we already have an exception range - which has the same handler and label, and the new range overlaps - that one, then we simply extend the existing range. Some bytecode - obfuscators generate seemingly nonoverlapping exception ranges - which, when coalesced, do in fact nest correctly. - - This constructs an ordinary linked list which check_nested_ranges() - later turns into the data structure we actually want. - - We expect the input to come in order of increasing START_PC. This - function doesn't attempt to detect the case where two previously - added disjoint ranges could be coalesced by a new range; that is - what the sorting counteracts. */ - -void -add_handler (start_pc, end_pc, handler, type) - int start_pc, end_pc; - tree handler; - tree type; -{ - struct eh_range *ptr, *prev = NULL, *h; - - for (ptr = whole_range.first_child; ptr; ptr = ptr->next_sibling) - { - if (start_pc >= ptr->start_pc - && start_pc <= ptr->end_pc - && TREE_PURPOSE (ptr->handlers) == type - && TREE_VALUE (ptr->handlers) == handler) - { - /* Already found an overlapping range, so coalesce. */ - ptr->end_pc = MAX (ptr->end_pc, end_pc); - return; - } - prev = ptr; - } - - h = (struct eh_range *) oballoc (sizeof (struct eh_range)); - h->start_pc = start_pc; - h->end_pc = end_pc; - h->first_child = NULL; - h->outer = NULL; - h->handlers = build_tree_list (type, handler); - h->next_sibling = NULL; - - if (prev == NULL) - whole_range.first_child = h; - else - prev->next_sibling = h; -} - - -/* if there are any handlers for this range, issue start of region */ -static void -expand_start_java_handler (range) - struct eh_range *range ATTRIBUTE_UNUSED; -{ - expand_eh_region_start (); -} - -tree -prepare_eh_table_type (type) - tree type; -{ - tree exp; - - /* The "type" (metch_info) in a (Java) exception table is one: - * a) NULL - meaning match any type in a try-finally. - * b) a pointer to a (ccmpiled) class (low-order bit 0). - * c) a pointer to the Utf8Const name of the class, plus one - * (which yields a value with low-order bit 1). */ - - push_obstacks (&permanent_obstack, &permanent_obstack); - if (type == NULL_TREE) - exp = null_pointer_node; - else if (is_compiled_class (type)) - exp = build_class_ref (type); - else - exp = fold (build - (PLUS_EXPR, ptr_type_node, - build_utf8_ref (build_internal_class_name (type)), - size_one_node)); - pop_obstacks (); - return exp; -} - -/* if there are any handlers for this range, isssue end of range, - and then all handler blocks */ -static void -expand_end_java_handler (range) - struct eh_range *range; -{ - tree handler = range->handlers; - expand_start_all_catch (); - for ( ; handler != NULL_TREE; handler = TREE_CHAIN (handler)) - { - start_catch_handler (prepare_eh_table_type (TREE_PURPOSE (handler))); - /* Push the thrown object on the top of the stack */ - expand_goto (TREE_VALUE (handler)); - } - expand_end_all_catch (); -} - -/* Recursive helper routine for maybe_start_handlers. */ - -static void -check_start_handlers (range, pc) - struct eh_range *range; - int pc; -{ - if (range != NULL_EH_RANGE && range->start_pc == pc) - { - check_start_handlers (range->outer, pc); - expand_start_java_handler (range); - } -} - -struct eh_range *current_range; - -/* Emit any start-of-try-range start at PC. */ - -void -maybe_start_try (pc) - int pc; -{ - if (! doing_eh (1)) - return; - - current_range = find_handler (pc); - check_start_handlers (current_range, pc); -} - -/* Emit any end-of-try-range end at PC. */ - -void -maybe_end_try (pc) - int pc; -{ - if (! doing_eh (1)) - return; - - while (current_range != NULL_EH_RANGE && current_range->end_pc <= pc) - { - expand_end_java_handler (current_range); - current_range = current_range->outer; - } -} - -/* Emit the handler labels and their code */ - -void -emit_handlers () -{ - if (catch_clauses) - { - rtx funcend = gen_label_rtx (); - emit_jump (funcend); - - emit_insns (catch_clauses); - expand_leftover_cleanups (); - - emit_label (funcend); - } -} - -/* Resume executing at the statement immediately after the end of an - exception region. */ - -void -expand_resume_after_catch () -{ - expand_goto (top_label_entry (&caught_return_label_stack)); -} |
