gcc/java/except.c

   1 /* Handle exceptions for GNU compiler for the Java(TM) language.
   2    Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.
  20
  21 Java and all Java-based marks are trademarks or registered trademarks
  22 of Sun Microsystems, Inc. in the United States and other countries.
  23 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "tree.h"
  28 #include "real.h"
  29 #include "rtl.h"
  30 #include "java-tree.h"
  31 #include "javaop.h"
  32 #include "java-opcodes.h"
  33 #include "jcf.h"
  34 #include "function.h"
  35 #include "except.h"
  36 #include "java-except.h"
  37 #include "eh-common.h"
  38 #include "toplev.h"
  39
  40 static void expand_start_java_handler PARAMS ((struct eh_range *));
  41 static void expand_end_java_handler PARAMS ((struct eh_range *));
  42 static struct eh_range *find_handler_in_range PARAMS ((int, struct eh_range *,
  43                                                       struct eh_range *));
  44 static void link_handler PARAMS ((struct eh_range *, struct eh_range *));
  45 static void check_start_handlers PARAMS ((struct eh_range *, int));
  46 static void free_eh_ranges PARAMS ((struct eh_range *range));
  47
  48 extern struct obstack permanent_obstack;
  49
  50 struct eh_range *current_method_handlers;
  51
  52 struct eh_range *current_try_block = NULL;
  53
  54 struct eh_range *eh_range_freelist = NULL;
  55
  56 /* These variables are used to speed up find_handler. */
  57
  58 static int cache_range_start, cache_range_end;
  59 static struct eh_range *cache_range;
  60 static struct eh_range *cache_next_child;
  61
  62 /* A dummy range that represents the entire method. */
  63
  64 struct eh_range whole_range;
  65
  66 #if defined(DEBUG_JAVA_BINDING_LEVELS)
  67 int binding_depth;
  68 int is_class_level;
  69 int current_pc;
  70 extern void indent ();
  71
  72 #endif
  73
  74 /* Search for the most specific eh_range containing PC.
  75    Assume PC is within RANGE.
  76    CHILD is a list of children of RANGE such that any
  77    previous children have end_pc values that are too low. */
  78
  79 static struct eh_range *
  80 find_handler_in_range (pc, range, child)
  81      int pc;
  82      struct eh_range *range;
  83      register struct eh_range *child;
  84 {
  85   for (; child != NULL;  child = child->next_sibling)
  86     {
  87       if (pc < child->start_pc)
  88         break;
  89       if (pc < child->end_pc)
  90         return find_handler_in_range (pc, child, child->first_child);
  91     }
  92   cache_range = range;
  93   cache_range_start = pc;
  94   cache_next_child = child;
  95   cache_range_end = child == NULL ? range->end_pc : child->start_pc;
  96   return range;
  97 }
  98
  99 /* Find the inner-most handler that contains PC. */
 100
 101 struct eh_range *
 102 find_handler (pc)
 103      int pc;
 104 {
 105   struct eh_range *h;
 106   if (pc >= cache_range_start)
 107     {
 108       h = cache_range;
 109       if (pc < cache_range_end)
 110         return h;
 111       while (pc >= h->end_pc)
 112         {
 113           cache_next_child = h->next_sibling;
 114           h = h->outer;
 115         }
 116     }
 117   else
 118     {
 119       h = &whole_range;
 120       cache_next_child = h->first_child;
 121     }
 122   return find_handler_in_range (pc, h, cache_next_child);
 123 }
 124
 125 /* Recursive helper routine for check_nested_ranges. */
 126
 127 static void
 128 link_handler (range, outer)
 129      struct eh_range *range, *outer;
 130 {
 131   struct eh_range **ptr;
 132
 133   if (range->start_pc == outer->start_pc && range->end_pc == outer->end_pc)
 134     {
 135       outer->handlers = chainon (outer->handlers, range->handlers);
 136       return;
 137     }
 138
 139   /* If the new range completely encloses the `outer' range, then insert it
 140      between the outer range and its parent.  */
 141   if (range->start_pc <= outer->start_pc && range->end_pc >= outer->end_pc)
 142     {
 143       range->outer = outer->outer;
 144       range->next_sibling = NULL;
 145       range->first_child = outer;
 146       {
 147         struct eh_range **pr = &(outer->outer->first_child);
 148         while (*pr != outer)
 149           pr = &(*pr)->next_sibling;
 150         *pr = range;
 151       }
 152       outer->outer = range;
 153       return;
 154     }
 155
 156   /* Handle overlapping ranges by splitting the new range.  */
 157   if (range->start_pc < outer->start_pc || range->end_pc > outer->end_pc)
 158     {
 159       struct eh_range *h
 160         = (struct eh_range *) xmalloc (sizeof (struct eh_range));
 161       if (range->start_pc < outer->start_pc)
 162         {
 163           h->start_pc = range->start_pc;
 164           h->end_pc = outer->start_pc;
 165           range->start_pc = outer->start_pc;
 166         }
 167       else
 168         {
 169           h->start_pc = outer->end_pc;
 170           h->end_pc = range->end_pc;
 171           range->end_pc = outer->end_pc;
 172         }
 173       h->first_child = NULL;
 174       h->outer = NULL;
 175       h->handlers = build_tree_list (TREE_PURPOSE (range->handlers),
 176                                      TREE_VALUE (range->handlers));
 177       h->next_sibling = NULL;
 178       /* Restart both from the top to avoid having to make this
 179          function smart about reentrancy.  */
 180       link_handler (h, &whole_range);
 181       link_handler (range, &whole_range);
 182       return;
 183     }
 184
 185   ptr = &outer->first_child;
 186   for (;; ptr = &(*ptr)->next_sibling)
 187     {
 188       if (*ptr == NULL || range->end_pc <= (*ptr)->start_pc)
 189         {
 190           range->next_sibling = *ptr;
 191           range->first_child = NULL;
 192           range->outer = outer;
 193           *ptr = range;
 194           return;
 195         }
 196       else if (range->start_pc < (*ptr)->end_pc)
 197         {
 198           link_handler (range, *ptr);
 199           return;
 200         }
 201       /* end_pc > (*ptr)->start_pc && start_pc >= (*ptr)->end_pc. */
 202     }
 203 }
 204
 205 /* The first pass of exception range processing (calling add_handler)
 206    constructs a linked list of exception ranges.  We turn this into
 207    the data structure expected by the rest of the code, and also
 208    ensure that exception ranges are properly nested.  */
 209
 210 void
 211 handle_nested_ranges ()
 212 {
 213   struct eh_range *ptr, *next;
 214
 215   ptr = whole_range.first_child;
 216   whole_range.first_child = NULL;
 217   for (; ptr; ptr = next)
 218     {
 219       next = ptr->next_sibling;
 220       ptr->next_sibling = NULL;
 221       link_handler (ptr, &whole_range);
 222     }
 223 }
 224
 225 /* Free RANGE as well as its children and siblings.  */
 226
 227 static void
 228 free_eh_ranges (range)
 229      struct eh_range *range;
 230 {
 231   while (range)
 232     {
 233       struct eh_range *next = range->next_sibling;
 234       free_eh_ranges (range->first_child);
 235       free (range);
 236       range = next;
 237     }
 238 }
 239
 240 /* Called to re-initialize the exception machinery for a new method. */
 241
 242 void
 243 method_init_exceptions ()
 244 {
 245   free_eh_ranges (&whole_range);
 246   whole_range.start_pc = 0;
 247   whole_range.end_pc = DECL_CODE_LENGTH (current_function_decl) + 1;
 248   whole_range.outer = NULL;
 249   whole_range.first_child = NULL;
 250   whole_range.next_sibling = NULL;
 251   cache_range_start = 0xFFFFFF;
 252   java_set_exception_lang_code ();
 253 }
 254
 255 void
 256 java_set_exception_lang_code ()
 257 {
 258   set_exception_lang_code (EH_LANG_Java);
 259   set_exception_version_code (1);
 260 }
 261
 262 /* Add an exception range.  If we already have an exception range
 263    which has the same handler and label, and the new range overlaps
 264    that one, then we simply extend the existing range.  Some bytecode
 265    obfuscators generate seemingly nonoverlapping exception ranges
 266    which, when coalesced, do in fact nest correctly.
 267
 268    This constructs an ordinary linked list which check_nested_ranges()
 269    later turns into the data structure we actually want.
 270
 271    We expect the input to come in order of increasing START_PC.  This
 272    function doesn't attempt to detect the case where two previously
 273    added disjoint ranges could be coalesced by a new range; that is
 274    what the sorting counteracts.  */
 275
 276 void
 277 add_handler (start_pc, end_pc, handler, type)
 278      int start_pc, end_pc;
 279      tree handler;
 280      tree type;
 281 {
 282   struct eh_range *ptr, *prev = NULL, *h;
 283
 284   for (ptr = whole_range.first_child; ptr; ptr = ptr->next_sibling)
 285     {
 286       if (start_pc >= ptr->start_pc
 287           && start_pc <= ptr->end_pc
 288           && TREE_PURPOSE (ptr->handlers) == type
 289           && TREE_VALUE (ptr->handlers) == handler)
 290         {
 291           /* Already found an overlapping range, so coalesce.  */
 292           ptr->end_pc = MAX (ptr->end_pc, end_pc);
 293           return;
 294         }
 295       prev = ptr;
 296     }
 297
 298   h = (struct eh_range *) xmalloc (sizeof (struct eh_range));
 299   h->start_pc = start_pc;
 300   h->end_pc = end_pc;
 301   h->first_child = NULL;
 302   h->outer = NULL;
 303   h->handlers = build_tree_list (type, handler);
 304   h->next_sibling = NULL;
 305   h->expanded = 0;
 306
 307   if (prev == NULL)
 308     whole_range.first_child = h;
 309   else
 310     prev->next_sibling = h;
 311 }
 312
 313
 314 /* if there are any handlers for this range, issue start of region */
 315 static void
 316 expand_start_java_handler (range)
 317   struct eh_range *range;
 318 {
 319 #if defined(DEBUG_JAVA_BINDING_LEVELS)
 320   indent ();
 321   fprintf (stderr, "expand start handler pc %d --> %d\n",
 322            current_pc, range->end_pc);
 323 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
 324   range->expanded = 1;
 325   expand_eh_region_start ();
 326 }
 327
 328 tree
 329 prepare_eh_table_type (type)
 330     tree type;
 331 {
 332   tree exp;
 333
 334   /* The "type" (metch_info) in a (Java) exception table is one:
 335    * a) NULL - meaning match any type in a try-finally.
 336    * b) a pointer to a (ccmpiled) class (low-order bit 0).
 337    * c) a pointer to the Utf8Const name of the class, plus one
 338    * (which yields a value with low-order bit 1). */
 339
 340   if (type == NULL_TREE)
 341     exp = CATCH_ALL_TYPE;
 342   else if (is_compiled_class (type))
 343     exp = build_class_ref (type);
 344   else
 345     exp = fold (build
 346                 (PLUS_EXPR, ptr_type_node,
 347                  build_utf8_ref (build_internal_class_name (type)),
 348                  size_one_node));
 349   return exp;
 350 }
 351
 352 /* if there are any handlers for this range, isssue end of range,
 353    and then all handler blocks */
 354 static void
 355 expand_end_java_handler (range)
 356      struct eh_range *range;
 357 {
 358   tree handler = range->handlers;
 359   force_poplevels (range->start_pc);
 360   expand_start_all_catch ();
 361   for ( ; handler != NULL_TREE; handler = TREE_CHAIN (handler))
 362     {
 363       start_catch_handler (prepare_eh_table_type (TREE_PURPOSE (handler)));
 364       /* Push the thrown object on the top of the stack */
 365       expand_goto (TREE_VALUE (handler));
 366       expand_resume_after_catch ();
 367       end_catch_handler ();
 368     }
 369   expand_end_all_catch ();
 370 #if defined(DEBUG_JAVA_BINDING_LEVELS)
 371   indent ();
 372   fprintf (stderr, "expand end handler pc %d <-- %d\n",
 373            current_pc, range->start_pc);
 374 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
 375 }
 376
 377 /* Recursive helper routine for maybe_start_handlers. */
 378
 379 static void
 380 check_start_handlers (range, pc)
 381      struct eh_range *range;
 382      int pc;
 383 {
 384   if (range != NULL_EH_RANGE && range->start_pc == pc)
 385     {
 386       check_start_handlers (range->outer, pc);
 387       if (!range->expanded)
 388         expand_start_java_handler (range);
 389     }
 390 }
 391
 392
 393 static struct eh_range *current_range;
 394
 395 /* Emit any start-of-try-range starting at start_pc and ending after
 396    end_pc. */
 397
 398 void
 399 maybe_start_try (start_pc, end_pc)
 400      int start_pc;
 401      int end_pc;
 402 {
 403   struct eh_range *range;
 404   if (! doing_eh (1))
 405     return;
 406
 407   range = find_handler (start_pc);
 408   while (range != NULL_EH_RANGE && range->start_pc == start_pc
 409          && range->end_pc < end_pc)
 410     range = range->outer;
 411
 412   current_range = range;
 413   check_start_handlers (range, start_pc);
 414 }
 415
 416 /* Emit any end-of-try-range ending at end_pc and starting before
 417    start_pc. */
 418
 419 void
 420 maybe_end_try (start_pc, end_pc)
 421      int start_pc;
 422      int end_pc;
 423 {
 424   if (! doing_eh (1))
 425     return;
 426
 427   while (current_range != NULL_EH_RANGE && current_range->end_pc <= end_pc
 428          && current_range->start_pc >= start_pc)
 429     {
 430       expand_end_java_handler (current_range);
 431       current_range = current_range->outer;
 432     }
 433 }
 434
 435 /* Emit the handler labels and their code */
 436
 437 void
 438 emit_handlers ()
 439 {
 440   if (catch_clauses)
 441     {
 442       rtx funcend = gen_label_rtx ();
 443       emit_jump (funcend);
 444
 445       emit_insns (catch_clauses);
 446       catch_clauses = catch_clauses_last = NULL_RTX;
 447       expand_leftover_cleanups ();
 448
 449       emit_label (funcend);
 450     }
 451 }
 452
 453 /* Resume executing at the statement immediately after the end of an
 454    exception region. */
 455
 456 void
 457 expand_resume_after_catch ()
 458 {
 459   expand_goto (top_label_entry (&caught_return_label_stack));
 460 }