gcc/java/except.c

   1 /* Handle exceptions for GNU compiler for the Java(TM) language.
   2    Copyright (C) 1997-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC 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 3, or (at your option)
   9 any later version.
  10
  11 GCC 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 GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.
  19
  20 Java and all Java-based marks are trademarks or registered trademarks
  21 of Sun Microsystems, Inc. in the United States and other countries.
  22 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "tree.h"
  29 #include "stringpool.h"
  30 #include "diagnostic-core.h"
  31 #include "fold-const.h"
  32 #include "stor-layout.h"
  33 #include "java-tree.h"
  34 #include "java-except.h"
  35 #include "toplev.h"
  36 #include "tree-iterator.h"
  37
  38
  39 static void expand_start_java_handler (struct eh_range *);
  40 static struct eh_range *find_handler_in_range (int, struct eh_range *,
  41                                                struct eh_range *);
  42 static void check_start_handlers (struct eh_range *, int);
  43 static void free_eh_ranges (struct eh_range *range);
  44
  45 struct eh_range *current_method_handlers;
  46
  47 struct eh_range *current_try_block = NULL;
  48
  49 /* These variables are used to speed up find_handler. */
  50
  51 static int cache_range_start, cache_range_end;
  52 static struct eh_range *cache_range;
  53 static struct eh_range *cache_next_child;
  54
  55 /* A dummy range that represents the entire method. */
  56
  57 struct eh_range whole_range;
  58
  59 /* Check the invariants of the structure we're using to contain
  60    exception regions.  Either returns true or fails an assertion
  61    check.  */
  62
  63 bool
  64 sanity_check_exception_range (struct eh_range *range)
  65 {
  66   struct eh_range *ptr = range->first_child;
  67   for (; ptr; ptr = ptr->next_sibling)
  68     {
  69       gcc_assert (ptr->outer == range
  70                   && ptr->end_pc > ptr->start_pc);
  71       if (ptr->next_sibling)
  72         gcc_assert (ptr->next_sibling->start_pc >= ptr->end_pc);
  73       gcc_assert (ptr->start_pc >= ptr->outer->start_pc
  74                   && ptr->end_pc <=  ptr->outer->end_pc);
  75       (void) sanity_check_exception_range (ptr);
  76     }
  77   return true;
  78 }
  79
  80 #if defined(DEBUG_JAVA_BINDING_LEVELS)
  81 extern int is_class_level;
  82 extern int current_pc;
  83 extern int binding_depth;
  84 extern void indent (void);
  85 static void
  86 print_ranges (struct eh_range *range)
  87 {
  88   if (! range)
  89     return;
  90
  91   struct eh_range *child = range->first_child;
  92
  93   indent ();
  94   fprintf (stderr, "handler pc %d --> %d ", range->start_pc, range->end_pc);
  95
  96   tree handler = range->handlers;
  97   for ( ; handler != NULL_TREE; handler = TREE_CHAIN (handler))
  98     {
  99       tree type = TREE_PURPOSE (handler);
 100       if (type == NULL)
 101         type = throwable_type_node;
 102       fprintf (stderr, " type=%s ", IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
 103     }
 104   fprintf (stderr, "\n");
 105
 106   int saved = binding_depth;
 107   binding_depth++;
 108   print_ranges (child);
 109   binding_depth = saved;
 110
 111   print_ranges (range->next_sibling);
 112 }
 113 #endif
 114
 115 /* Search for the most specific eh_range containing PC.
 116    Assume PC is within RANGE.
 117    CHILD is a list of children of RANGE such that any
 118    previous children have end_pc values that are too low. */
 119
 120 static struct eh_range *
 121 find_handler_in_range (int pc, struct eh_range *range, struct eh_range *child)
 122 {
 123   for (; child != NULL;  child = child->next_sibling)
 124     {
 125       if (pc < child->start_pc)
 126         break;
 127       if (pc < child->end_pc)
 128         return find_handler_in_range (pc, child, child->first_child);
 129     }
 130   cache_range = range;
 131   cache_range_start = pc;
 132   cache_next_child = child;
 133   cache_range_end = child == NULL ? range->end_pc : child->start_pc;
 134   return range;
 135 }
 136
 137 /* Find the inner-most handler that contains PC. */
 138
 139 struct eh_range *
 140 find_handler (int pc)
 141 {
 142   struct eh_range *h;
 143   if (pc >= cache_range_start)
 144     {
 145       h = cache_range;
 146       if (pc < cache_range_end)
 147         return h;
 148       while (pc >= h->end_pc)
 149         {
 150           cache_next_child = h->next_sibling;
 151           h = h->outer;
 152         }
 153     }
 154   else
 155     {
 156       h = &whole_range;
 157       cache_next_child = h->first_child;
 158     }
 159   return find_handler_in_range (pc, h, cache_next_child);
 160 }
 161
 162 static void
 163 free_eh_ranges (struct eh_range *range)
 164 {
 165   while (range)
 166     {
 167       struct eh_range *next = range->next_sibling;
 168       free_eh_ranges (range->first_child);
 169       if (range != &whole_range)
 170         free (range);
 171       range = next;
 172     }
 173 }
 174
 175 /* Called to re-initialize the exception machinery for a new method. */
 176
 177 void
 178 method_init_exceptions (void)
 179 {
 180   free_eh_ranges (&whole_range);
 181   whole_range.start_pc = 0;
 182   whole_range.end_pc = DECL_CODE_LENGTH (current_function_decl) + 1;
 183   whole_range.outer = NULL;
 184   whole_range.first_child = NULL;
 185   whole_range.next_sibling = NULL;
 186   cache_range_start = 0xFFFFFF;
 187 }
 188
 189 /* Split an exception range into two at PC.  The sub-ranges that
 190    belong to the range are split and distributed between the two new
 191    ranges.  */
 192
 193 static void
 194 split_range (struct eh_range *range, int pc)
 195 {
 196   struct eh_range *ptr;
 197   struct eh_range **first_child, **second_child;
 198   struct eh_range *h;
 199
 200   /* First, split all the sub-ranges.  */
 201   for (ptr = range->first_child; ptr; ptr = ptr->next_sibling)
 202     {
 203       if (pc > ptr->start_pc
 204           && pc < ptr->end_pc)
 205         {
 206           split_range (ptr, pc);
 207         }
 208     }
 209
 210   /* Create a new range.  */
 211   h = XNEW (struct eh_range);
 212
 213   h->start_pc = pc;
 214   h->end_pc = range->end_pc;
 215   h->next_sibling = range->next_sibling;
 216   range->next_sibling = h;
 217   range->end_pc = pc;
 218   h->handlers = build_tree_list (TREE_PURPOSE (range->handlers),
 219                                  TREE_VALUE (range->handlers));
 220   h->next_sibling = NULL;
 221   h->expanded = 0;
 222   h->stmt = NULL;
 223   h->outer = range->outer;
 224   h->first_child = NULL;
 225
 226   ptr = range->first_child;
 227   first_child = &range->first_child;
 228   second_child = &h->first_child;
 229
 230   /* Distribute the sub-ranges between the two new ranges.  */
 231   for (ptr = range->first_child; ptr; ptr = ptr->next_sibling)
 232     {
 233       if (ptr->start_pc < pc)
 234         {
 235           *first_child = ptr;
 236           ptr->outer = range;
 237           first_child = &ptr->next_sibling;
 238         }
 239       else
 240         {
 241           *second_child = ptr;
 242           ptr->outer = h;
 243           second_child = &ptr->next_sibling;
 244         }
 245     }
 246   *first_child = NULL;
 247   *second_child = NULL;
 248 }
 249
 250
 251 /* Add an exception range.
 252
 253    There are some missed optimization opportunities here.  For
 254    example, some bytecode obfuscators generate seemingly
 255    nonoverlapping exception ranges which, when coalesced, do in fact
 256    nest correctly.  We could merge these, but we'd have to fix up all
 257    the enclosed regions first and perhaps create a new range anyway if
 258    it overlapped existing ranges.
 259
 260    Also, we don't attempt to detect the case where two previously
 261    added disjoint ranges could be coalesced by a new range.  */
 262
 263 void
 264 add_handler (int start_pc, int end_pc, tree handler, tree type)
 265 {
 266   struct eh_range *ptr, *h;
 267   struct eh_range **first_child, **prev;
 268
 269   /* First, split all the existing ranges that we need to enclose.  */
 270   for (ptr = whole_range.first_child; ptr; ptr = ptr->next_sibling)
 271     {
 272       if (start_pc > ptr->start_pc
 273           && start_pc < ptr->end_pc)
 274         {
 275           split_range (ptr, start_pc);
 276         }
 277
 278       if (end_pc > ptr->start_pc
 279           && end_pc < ptr->end_pc)
 280         {
 281           split_range (ptr, end_pc);
 282         }
 283
 284       if (ptr->start_pc >= end_pc)
 285         break;
 286     }
 287
 288   /* Create the new range.  */
 289   h = XNEW (struct eh_range);
 290   first_child = &h->first_child;
 291
 292   h->start_pc = start_pc;
 293   h->end_pc = end_pc;
 294   h->first_child = NULL;
 295   h->outer = NULL_EH_RANGE;
 296   h->handlers = build_tree_list (type, handler);
 297   h->next_sibling = NULL;
 298   h->expanded = 0;
 299   h->stmt = NULL;
 300
 301   /* Find every range at the top level that will be a sub-range of the
 302      range we're inserting and make it so.  */
 303   {
 304     struct eh_range **prev = &whole_range.first_child;
 305     for (ptr = *prev; ptr;)
 306       {
 307         struct eh_range *next = ptr->next_sibling;
 308
 309         if (ptr->start_pc >= end_pc)
 310           break;
 311
 312         if (ptr->start_pc < start_pc)
 313           {
 314             prev = &ptr->next_sibling;
 315           }
 316         else if (ptr->start_pc >= start_pc
 317                  && ptr->start_pc < end_pc)
 318           {
 319             *prev = next;
 320             *first_child = ptr;
 321             first_child = &ptr->next_sibling;
 322             ptr->outer = h;
 323             ptr->next_sibling = NULL;
 324           }
 325
 326         ptr = next;
 327       }
 328   }
 329
 330   /* Find the right place to insert the new range.  */
 331   prev = &whole_range.first_child;
 332   for (ptr = *prev; ptr; prev = &ptr->next_sibling, ptr = ptr->next_sibling)
 333     {
 334       gcc_assert (ptr->outer == NULL_EH_RANGE);
 335       if (ptr->start_pc >= start_pc)
 336         break;
 337     }
 338
 339   /* And insert it there.  */
 340   *prev = h;
 341   if (ptr)
 342     {
 343       h->next_sibling = ptr;
 344       h->outer = ptr->outer;
 345     }
 346 }
 347
 348
 349 /* if there are any handlers for this range, issue start of region */
 350 static void
 351 expand_start_java_handler (struct eh_range *range)
 352 {
 353 #if defined(DEBUG_JAVA_BINDING_LEVELS)
 354   indent ();
 355   fprintf (stderr, "expand start handler pc %d --> %d\n",
 356            current_pc, range->end_pc);
 357 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
 358   pushlevel (0);
 359   register_exception_range (range,  range->start_pc, range->end_pc);
 360   range->expanded = 1;
 361 }
 362
 363 tree
 364 prepare_eh_table_type (tree type)
 365 {
 366   tree exp;
 367   tree *slot;
 368   const char *name;
 369   char *buf;
 370   tree decl;
 371   tree utf8_ref;
 372
 373   /* The "type" (match_info) in a (Java) exception table is a pointer to:
 374    * a) NULL - meaning match any type in a try-finally.
 375    * b) a pointer to a pointer to a class.
 376    * c) a pointer to a pointer to a utf8_ref.  The pointer is
 377    * rewritten to point to the appropriate class.  */
 378
 379   if (type == NULL_TREE)
 380     return NULL_TREE;
 381
 382   if (TYPE_TO_RUNTIME_MAP (output_class) == NULL)
 383     TYPE_TO_RUNTIME_MAP (output_class) = java_treetreehash_create (10);
 384
 385   slot = java_treetreehash_new (TYPE_TO_RUNTIME_MAP (output_class), type);
 386   if (*slot != NULL)
 387     return TREE_VALUE (*slot);
 388
 389   if (is_compiled_class (type) && !flag_indirect_dispatch)
 390     {
 391       name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
 392       buf = (char *) alloca (strlen (name) + 5);
 393       sprintf (buf, "%s_ref", name);
 394       decl = build_decl (input_location,
 395                          VAR_DECL, get_identifier (buf), ptr_type_node);
 396       TREE_STATIC (decl) = 1;
 397       DECL_ARTIFICIAL (decl) = 1;
 398       DECL_IGNORED_P (decl) = 1;
 399       TREE_READONLY (decl) = 1;
 400       TREE_THIS_VOLATILE (decl) = 0;
 401       DECL_INITIAL (decl) = build_class_ref (type);
 402       layout_decl (decl, 0);
 403       pushdecl (decl);
 404       exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (decl)), decl);
 405     }
 406   else
 407     {
 408       utf8_ref = build_utf8_ref (DECL_NAME (TYPE_NAME (type)));
 409       name = IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (utf8_ref, 0)));
 410       buf = (char *) alloca (strlen (name) + 5);
 411       sprintf (buf, "%s_ref", name);
 412       decl = build_decl (input_location,
 413                          VAR_DECL, get_identifier (buf), utf8const_ptr_type);
 414       TREE_STATIC (decl) = 1;
 415       DECL_ARTIFICIAL (decl) = 1;
 416       DECL_IGNORED_P (decl) = 1;
 417       TREE_READONLY (decl) = 1;
 418       TREE_THIS_VOLATILE (decl) = 0;
 419       layout_decl (decl, 0);
 420       pushdecl (decl);
 421       exp = build1 (ADDR_EXPR, build_pointer_type (utf8const_ptr_type), decl);
 422       CONSTRUCTOR_APPEND_ELT (TYPE_CATCH_CLASSES (output_class),
 423                               NULL_TREE,
 424                               make_catch_class_record (exp, utf8_ref));
 425     }
 426
 427   exp = convert (ptr_type_node, exp);
 428
 429   *slot = tree_cons (type, exp, NULL_TREE);
 430
 431   return exp;
 432 }
 433
 434 int
 435 expand_catch_class (treetreehash_entry **entry, int)
 436 {
 437   struct treetreehash_entry *ite = *entry;
 438   tree addr = TREE_VALUE ((tree)ite->value);
 439   tree decl;
 440   STRIP_NOPS (addr);
 441   decl = TREE_OPERAND (addr, 0);
 442   rest_of_decl_compilation (decl, global_bindings_p (), 0);
 443   return true;
 444 }
 445
 446 /* For every class in the TYPE_TO_RUNTIME_MAP, expand the
 447    corresponding object that is used by the runtime type matcher.  */
 448
 449 void
 450 java_expand_catch_classes (tree this_class)
 451 {
 452   if (TYPE_TO_RUNTIME_MAP (this_class))
 453     TYPE_TO_RUNTIME_MAP (this_class)->traverse<int, expand_catch_class> (0);
 454 }
 455
 456 /* Build and push the variable that will hold the exception object
 457    within this function.  */
 458
 459 static tree
 460 build_exception_object_var (void)
 461 {
 462   tree decl = DECL_FUNCTION_EXC_OBJ (current_function_decl);
 463   if (decl == NULL)
 464     {
 465       decl = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
 466                          VAR_DECL, get_identifier ("#exc_obj"), ptr_type_node);
 467       DECL_IGNORED_P (decl) = 1;
 468       DECL_ARTIFICIAL (decl) = 1;
 469
 470       DECL_FUNCTION_EXC_OBJ (current_function_decl) = decl;
 471       pushdecl_function_level (decl);
 472     }
 473   return decl;
 474 }
 475
 476 /* Build a reference to the jthrowable object being carried in the
 477    exception header.  */
 478
 479 tree
 480 build_exception_object_ref (tree type)
 481 {
 482   tree obj;
 483
 484   /* Java only passes object via pointer and doesn't require adjusting.
 485      The java object is immediately before the generic exception header.  */
 486   obj = build_exception_object_var ();
 487   obj = fold_convert (build_pointer_type (type), obj);
 488   obj = fold_build_pointer_plus (obj,
 489                 fold_build1 (NEGATE_EXPR, sizetype,
 490                              TYPE_SIZE_UNIT (TREE_TYPE (obj))));
 491   obj = build1 (INDIRECT_REF, type, obj);
 492
 493   return obj;
 494 }
 495
 496 /* If there are any handlers for this range, issue end of range,
 497    and then all handler blocks */
 498 void
 499 expand_end_java_handler (struct eh_range *range)
 500 {
 501   tree handler = range->handlers;
 502   if (handler)
 503     {
 504       tree exc_obj = build_exception_object_var ();
 505       tree catches = make_node (STATEMENT_LIST);
 506       tree_stmt_iterator catches_i = tsi_last (catches);
 507       tree *body;
 508
 509       for (; handler; handler = TREE_CHAIN (handler))
 510         {
 511           tree type, eh_type, x;
 512           tree stmts = make_node (STATEMENT_LIST);
 513           tree_stmt_iterator stmts_i = tsi_last (stmts);
 514
 515           type = TREE_PURPOSE (handler);
 516           if (type == NULL)
 517             type = throwable_type_node;
 518           eh_type = prepare_eh_table_type (type);
 519
 520           x = build_call_expr (builtin_decl_explicit (BUILT_IN_EH_POINTER),
 521                                1, integer_zero_node);
 522           x = build2 (MODIFY_EXPR, void_type_node, exc_obj, x);
 523           tsi_link_after (&stmts_i, x, TSI_CONTINUE_LINKING);
 524
 525           x = build1 (GOTO_EXPR, void_type_node, TREE_VALUE (handler));
 526           tsi_link_after (&stmts_i, x, TSI_CONTINUE_LINKING);
 527
 528           x = build2 (CATCH_EXPR, void_type_node, eh_type, stmts);
 529           tsi_link_after (&catches_i, x, TSI_CONTINUE_LINKING);
 530
 531           /* Throwable can match anything in Java, and therefore
 532              any subsequent handlers are unreachable.  */
 533           /* ??? If we're assured of no foreign language exceptions,
 534              we'd be better off using NULL as the exception type
 535              for the catch.  */
 536           if (type == throwable_type_node)
 537             break;
 538         }
 539
 540       body = get_stmts ();
 541       *body = build2 (TRY_CATCH_EXPR, void_type_node, *body, catches);
 542     }
 543
 544 #if defined(DEBUG_JAVA_BINDING_LEVELS)
 545   indent ();
 546   fprintf (stderr, "expand end handler pc %d <-- %d\n",
 547            current_pc, range->start_pc);
 548 #endif /* defined(DEBUG_JAVA_BINDING_LEVELS) */
 549 }
 550
 551 /* Recursive helper routine for maybe_start_handlers. */
 552
 553 static void
 554 check_start_handlers (struct eh_range *range, int pc)
 555 {
 556   if (range != NULL_EH_RANGE && range->start_pc == pc)
 557     {
 558       check_start_handlers (range->outer, pc);
 559       if (!range->expanded)
 560         expand_start_java_handler (range);
 561     }
 562 }
 563
 564
 565 /* Routine to see if exception handling is turned on.
 566    DO_WARN is nonzero if we want to inform the user that exception
 567    handling is turned off.
 568
 569    This is used to ensure that -fexceptions has been specified if the
 570    compiler tries to use any exception-specific functions.  */
 571
 572 static inline int
 573 doing_eh (void)
 574 {
 575   if (! flag_exceptions)
 576     {
 577       static int warned = 0;
 578       if (! warned)
 579         {
 580           error ("exception handling disabled, use -fexceptions to enable");
 581           warned = 1;
 582         }
 583       return 0;
 584     }
 585   return 1;
 586 }
 587
 588 static struct eh_range *current_range;
 589
 590 /* Emit any start-of-try-range starting at start_pc and ending after
 591    end_pc. */
 592
 593 void
 594 maybe_start_try (int start_pc, int end_pc)
 595 {
 596   struct eh_range *range;
 597   if (! doing_eh ())
 598     return;
 599
 600   range = find_handler (start_pc);
 601   while (range != NULL_EH_RANGE && range->start_pc == start_pc
 602          && range->end_pc < end_pc)
 603     range = range->outer;
 604
 605   current_range = range;
 606   check_start_handlers (range, start_pc);
 607 }
 608