1 /* Process declarations and variables for the GNU compiler for the
4 Copyright (C) 1996, 1998 Free Software Foundation, Inc.
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc. */
27 /* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
32 #include "java-tree.h"
37 #define INT_TYPE_SIZE BITS_PER_WORD
40 /* The DECL_MAP is a mapping from (index, type) to a decl node.
41 If index < max_locals, it is the index of a local variable.
42 if index >= max_locals, then index-max_locals is a stack slot.
43 The DECL_MAP mapping is represented as a TREE_VEC whose elements
44 are a list of decls (VAR_DECL or PARM_DECL) chained by
45 DECL_LOCAL_SLOT_CHAIN; the index finds the TREE_VEC element, and then
46 we search the chain for a decl with a matching TREE_TYPE. */
50 /* A list of local variables VAR_DECLs for this method that we have seen
51 debug information, but we have not reached their starting (byte) PC yet. */
53 tree pending_local_decls = NULL_TREE;
55 /* Push a local variable or stack slot into the decl_map,
56 and assign it an rtl. */
59 push_jvm_slot (index, decl)
63 struct rtx_def *rtl = NULL;
64 tree type = TREE_TYPE (decl);
67 DECL_CONTEXT (decl) = current_function_decl;
68 layout_decl (decl, 0);
70 /* See if we have an appropriate rtl (i.e. same mode) at this index.
71 If so, we must use it. */
72 tmp = TREE_VEC_ELT (decl_map, index);
73 while (tmp != NULL_TREE)
75 if (TYPE_MODE (type) == TYPE_MODE (TREE_TYPE (tmp)))
79 tmp = DECL_LOCAL_SLOT_CHAIN (tmp);
82 DECL_RTL (decl) = rtl;
85 if (index >= DECL_MAX_LOCALS (current_function_decl))
86 DECL_REGISTER (decl) = 1;
90 /* Now link the decl into the decl_map. */
91 if (DECL_LANG_SPECIFIC (decl) == NULL)
93 DECL_LANG_SPECIFIC (decl)
94 = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
95 DECL_LOCAL_START_PC (decl) = 0;
96 DECL_LOCAL_END_PC (decl) = DECL_CODE_LENGTH (current_function_decl);
97 DECL_LOCAL_SLOT_NUMBER (decl) = index;
99 DECL_LOCAL_SLOT_CHAIN (decl) = TREE_VEC_ELT (decl_map, index);
100 TREE_VEC_ELT (decl_map, index) = decl;
104 /* Find a VAR_DECL (or PARM_DECL) at local index INDEX that has type TYPE,
105 that is valid at PC (or -1 if any pc).
106 If there is no existing matching decl, allocate one.
107 If we find a decl with matching modes but different types,
108 we re-use the rtl, but create a new decl. */
111 find_local_variable (index, type, pc)
116 struct rtx_def *rtl = NULL;
117 tree decl = TREE_VEC_ELT (decl_map, index);
118 tree best = NULL_TREE;
119 while (decl != NULL_TREE)
123 || (pc >= DECL_LOCAL_START_PC (decl)
124 && pc < DECL_LOCAL_END_PC (decl));
126 if ((TREE_TYPE (decl) == type
127 || (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
128 && type == ptr_type_node))
131 if (best == NULL_TREE
132 || (TREE_TYPE (decl) == type && TREE_TYPE (best) != type)
133 || DECL_LOCAL_START_PC (decl) > DECL_LOCAL_START_PC (best)
134 || DECL_LOCAL_END_PC (decl) < DECL_LOCAL_START_PC (decl))
137 decl = DECL_LOCAL_SLOT_CHAIN (decl);
139 if (best != NULL_TREE)
141 return push_jvm_slot (index, build_decl (VAR_DECL, NULL_TREE, type));
145 /* Same as find_local_index, except that INDEX is a stack index. */
148 find_stack_slot (index, type)
152 return find_local_variable (index + DECL_MAX_LOCALS (current_function_decl),
158 /* A chain of _DECL nodes for all variables, constants, functions,
159 * and typedef types. These are in the reverse of the order supplied.
163 /* For each level, a list of shadowed outer-level local definitions
164 to be restored when this level is popped.
165 Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
166 whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
169 /* For each level (except not the global one),
170 a chain of BLOCK nodes for all the levels
171 that were entered and exited one level down. */
174 /* The BLOCK node for this level, if one has been preallocated.
175 If 0, the BLOCK is allocated (if needed) when the level is popped. */
178 /* The binding level which this one is contained in (inherits from). */
179 struct binding_level *level_chain;
181 /* 1 means make a BLOCK for this level regardless of all else.
182 2 for temporary binding contours created by the compiler. */
185 /* Nonzero means make a BLOCK if this level has any subblocks. */
186 char keep_if_subblocks;
188 /* Nonzero if this level can safely have additional
189 cleanup-needing variables added to it. */
190 char more_cleanups_ok;
193 /* The bytecode PC that marks the end of this level. */
197 #define NULL_BINDING_LEVEL (struct binding_level *) NULL
199 /* The binding level currently in effect. */
201 static struct binding_level *current_binding_level;
203 /* A chain of binding_level structures awaiting reuse. */
205 static struct binding_level *free_binding_level;
207 /* The outermost binding level, for names of file scope.
208 This is created when the compiler is started and exists
209 through the entire run. */
211 static struct binding_level *global_binding_level;
213 /* Binding level structures are initialized by copying this one. */
215 static struct binding_level clear_binding_level
216 = {NULL_TREE, NULL_TREE, NULL_TREE, NULL_TREE,
217 NULL_BINDING_LEVEL, 0, 0, 0, 0, 1000000000};
220 /* A list (chain of TREE_LIST nodes) of all LABEL_DECLs in the function
221 that have names. Here so we can clear out their names' definitions
222 at the end of the function. */
224 static tree named_labels;
226 /* A list of LABEL_DECLs from outer contexts that are currently shadowed. */
228 static tree shadowed_labels;
231 int flag_traditional;
233 /* Nonzero means unconditionally make a BLOCK for the next level pushed. */
235 static int keep_next_level_flag;
237 /* Nonzero means make a BLOCK for the next level pushed
238 if it has subblocks. */
240 static int keep_next_if_subblocks;
242 /* The FUNCTION_DECL for the function currently being compiled,
243 or 0 if between functions. */
244 tree current_function_decl;
246 /* The type node for the ordinary character type. */
249 tree object_type_node;
250 tree object_ptr_type_node;
251 tree string_type_node;
252 tree throwable_type_node;
253 tree runtime_exception_type_node;
254 tree error_exception_type_node;
256 tree boolean_type_node;
258 tree float_type_node;
259 tree double_type_node;
261 /* a VOID_TYPE node. */
265 tree return_address_type_node;
267 tree integer_type_node;
270 tree short_type_node;
274 tree promoted_byte_type_node;
275 tree promoted_short_type_node;
276 tree promoted_char_type_node;
277 tree promoted_boolean_type_node;
279 tree unsigned_byte_type_node;
280 tree unsigned_short_type_node;
281 tree unsigned_int_type_node;
282 tree unsigned_long_type_node;
284 /* The type for struct methodtable. */
285 tree methodtable_type;
286 tree methodtable_ptr_type;
289 tree utf8const_ptr_type;
290 tree class_type_node;
292 tree field_type_node;
293 tree field_ptr_type_node;
294 tree field_info_union_node;
295 tree jexception_type;
296 tree jexception_ptr_type;
297 tree lineNumberEntry_type;
298 tree lineNumbers_type;
299 tree constants_type_node;
301 tree dtable_ptr_type;
302 tree method_type_node;
303 tree method_ptr_type_node;
304 tree nativecode_ptr_array_type_node;
305 tree one_elt_array_domain_type;
306 tree access_flags_type_node;
307 tree class_dtable_decl;
309 /* a node which has tree code ERROR_MARK, and whose type is itself.
310 All erroneous expressions are replaced with this node. All functions
311 that accept nodes as arguments should avoid generating error messages
312 if this node is one of the arguments, since it is undesirable to get
313 multiple error messages from one error in the input. */
315 tree error_mark_node;
317 /* Two expressions that are constants with value zero.
318 The first is of type `int', the second of type `void *'. */
319 tree integer_zero_node;
320 tree null_pointer_node;
322 /* Nodes for boolean constants TRUE and FALSE. */
323 tree boolean_true_node, boolean_false_node;
325 tree TYPE_identifier_node;
326 tree init_identifier_node;
327 tree clinit_identifier_node;
328 tree void_signature_node;
329 tree length_identifier_node;
330 tree this_identifier_node;
331 tree super_identifier_node;
333 /* References to internal libjava functions we use. */
334 tree alloc_object_node;
335 tree soft_instanceof_node;
336 tree soft_checkcast_node;
337 tree soft_initclass_node;
338 tree soft_newarray_node;
339 tree soft_anewarray_node;
340 tree soft_multianewarray_node;
341 tree soft_badarrayindex_node;
343 tree soft_checkarraystore_node;
344 tree soft_monitorenter_node;
345 tree soft_monitorexit_node;
346 tree soft_lookupinterfacemethod_node;
348 tree soft_exceptioninfo_call_node;
350 /* Build (and pushdecl) a "promoted type" for all standard
351 types shorter than int. */
354 push_promoted_type (name, actual_type)
358 tree type = make_node (TREE_CODE (actual_type));
360 tree in_min = TYPE_MIN_VALUE (int_type_node);
361 tree in_max = TYPE_MAX_VALUE (int_type_node);
363 tree in_min = TYPE_MIN_VALUE (actual_type);
364 tree in_max = TYPE_MAX_VALUE (actual_type);
366 TYPE_MIN_VALUE (type) = build_int_2 (TREE_INT_CST_LOW (in_min),
367 TREE_INT_CST_HIGH (in_min));
368 TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
369 TYPE_MAX_VALUE (type) = build_int_2 (TREE_INT_CST_LOW (in_max),
370 TREE_INT_CST_HIGH (in_max));
371 TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
372 TYPE_PRECISION (type) = TYPE_PRECISION (int_type_node);
374 pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
378 /* Nodes for integer constants. */
379 tree integer_one_node, integer_two_node, integer_four_node;
380 tree integer_negative_one_node;
382 /* Return a definition for a builtin function named NAME and whose data type
383 is TYPE. TYPE should be a function type with argument types.
384 FUNCTION_CODE tells later passes how to compile calls to this function.
385 See tree.h for its possible values.
387 If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
388 the name to be called if we can't opencode the function. */
391 builtin_function (name, type, function_code, library_name)
394 enum built_in_function function_code;
397 tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
398 DECL_EXTERNAL (decl) = 1;
399 TREE_PUBLIC (decl) = 1;
401 DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
402 make_decl_rtl (decl, NULL_PTR, 1);
404 if (function_code != NOT_BUILT_IN)
406 DECL_BUILT_IN (decl) = 1;
407 DECL_FUNCTION_CODE (decl) = function_code;
413 init_decl_processing ()
418 current_function_decl = NULL;
419 current_binding_level = NULL_BINDING_LEVEL;
420 free_binding_level = NULL_BINDING_LEVEL;
421 pushlevel (0); /* make the binding_level structure for global names */
422 global_binding_level = current_binding_level;
424 error_mark_node = make_node (ERROR_MARK);
425 TREE_TYPE (error_mark_node) = error_mark_node;
427 /* Create sizetype first - needed for other types. */
428 sizetype = make_unsigned_type (POINTER_SIZE);
429 size_zero_node = build_int_2 (0, 0);
430 TREE_TYPE (size_zero_node) = sizetype;
431 size_one_node = build_int_2 (1, 0);
432 TREE_TYPE (size_one_node) = sizetype;
434 byte_type_node = make_signed_type (8);
435 pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"), byte_type_node));
436 short_type_node = make_signed_type (16);
437 pushdecl (build_decl (TYPE_DECL, get_identifier ("short"), short_type_node));
438 int_type_node = make_signed_type (32);
439 pushdecl (build_decl (TYPE_DECL, get_identifier ("int"), int_type_node));
440 long_type_node = make_signed_type (64);
441 pushdecl (build_decl (TYPE_DECL, get_identifier ("long"), long_type_node));
443 unsigned_byte_type_node = make_unsigned_type (8);
444 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"),
445 unsigned_byte_type_node));
446 unsigned_short_type_node = make_unsigned_type (16);
447 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned short"),
448 unsigned_short_type_node));
449 unsigned_int_type_node = make_unsigned_type (32);
450 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
451 unsigned_int_type_node));
452 unsigned_long_type_node = make_unsigned_type (64);
453 pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned long"),
454 unsigned_long_type_node));
456 integer_type_node = type_for_size (INT_TYPE_SIZE, 0);
458 integer_zero_node = build_int_2 (0, 0);
459 integer_one_node = build_int_2 (1, 0);
460 integer_two_node = build_int_2 (2, 0);
461 integer_four_node = build_int_2 (4, 0);
462 integer_negative_one_node = build_int_2 (-1, 0);
464 void_type_node = make_node (VOID_TYPE);
465 pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
466 layout_type (void_type_node); /* Uses size_zero_node */
467 ptr_type_node = build_pointer_type (void_type_node);
468 t = make_node (VOID_TYPE);
469 layout_type (t); /* Uses size_zero_node */
470 return_address_type_node = build_pointer_type (t);
472 null_pointer_node = build_int_2 (0, 0);
473 TREE_TYPE (null_pointer_node) = ptr_type_node;
476 /* Make a type to be the domain of a few array types
477 whose domains don't really matter.
478 200 is small enough that it always fits in size_t
479 and large enough that it can hold most function names for the
480 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
481 short_array_type_node = build_prim_array_type (short_type_node, 200);
483 char_type_node = make_node (CHAR_TYPE);
484 TYPE_PRECISION (char_type_node) = 16;
485 fixup_unsigned_type (char_type_node);
486 pushdecl (build_decl (TYPE_DECL, get_identifier ("char"), char_type_node));
488 boolean_type_node = make_node (BOOLEAN_TYPE);
489 TYPE_PRECISION (boolean_type_node) = 1;
490 fixup_unsigned_type (boolean_type_node);
491 pushdecl (build_decl (TYPE_DECL, get_identifier ("boolean"),
493 boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
494 boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
496 promoted_byte_type_node
497 = push_promoted_type ("promoted_byte", byte_type_node);
498 promoted_short_type_node
499 = push_promoted_type ("promoted_short", short_type_node);
500 promoted_char_type_node
501 = push_promoted_type ("promoted_char", char_type_node);
502 promoted_boolean_type_node
503 = push_promoted_type ("promoted_boolean", boolean_type_node);
505 float_type_node = make_node (REAL_TYPE);
506 TYPE_PRECISION (float_type_node) = 32;
507 pushdecl (build_decl (TYPE_DECL, get_identifier ("float"),
509 layout_type (float_type_node);
511 double_type_node = make_node (REAL_TYPE);
512 TYPE_PRECISION (double_type_node) = 64;
513 pushdecl (build_decl (TYPE_DECL, get_identifier ("double"),
515 layout_type (double_type_node);
517 object_type_node = lookup_class (get_identifier ("java.lang.Object"));
518 object_ptr_type_node = promote_type (object_type_node);
519 string_type_node = lookup_class (get_identifier ("java.lang.String"));
520 class_type_node = lookup_class (get_identifier ("java.lang.Class"));
521 throwable_type_node = lookup_class (get_identifier ("java.lang.Throwable"));
522 runtime_exception_type_node =
523 lookup_class (get_identifier ("java.lang.RuntimeException"));
524 error_exception_type_node =
525 lookup_class (get_identifier ("java.lang.Error"));
527 methodtable_type = make_node (RECORD_TYPE);
528 layout_type (methodtable_type);
529 pushdecl (build_decl (TYPE_DECL, get_identifier ("methodtable"),
531 methodtable_ptr_type = build_pointer_type (methodtable_type);
533 TYPE_identifier_node = get_identifier ("TYPE");
534 init_identifier_node = get_identifier ("<init>");
535 clinit_identifier_node = get_identifier ("<clinit>");
536 void_signature_node = get_identifier ("()V");
537 length_identifier_node = get_identifier ("length");
538 this_identifier_node = get_identifier ("this");
539 super_identifier_node = get_identifier ("super");
541 /* for lack of a better place to put this stub call */
542 init_expr_processing();
544 utf8const_type = make_node (RECORD_TYPE);
545 PUSH_FIELD (utf8const_type, field, "hash", unsigned_short_type_node);
546 PUSH_FIELD (utf8const_type, field, "length", unsigned_short_type_node);
547 FINISH_RECORD (utf8const_type);
548 utf8const_ptr_type = build_pointer_type (utf8const_type);
550 constants_type_node = make_node (RECORD_TYPE);
551 PUSH_FIELD (constants_type_node, field, "size", unsigned_int_type_node);
552 PUSH_FIELD (constants_type_node, field, "tags", ptr_type_node);
553 PUSH_FIELD (constants_type_node, field, "data", ptr_type_node);
554 FINISH_RECORD (constants_type_node);
555 pushdecl (build_decl (TYPE_DECL, get_identifier ("constants"),
556 constants_type_node));
558 access_flags_type_node = unsigned_short_type_node;
560 dtable_type = make_node (RECORD_TYPE);
561 dtable_ptr_type = build_pointer_type (dtable_type);
563 PUSH_FIELD (object_type_node, field, "dtable", dtable_ptr_type);
564 PUSH_FIELD (object_type_node, field, "sync_info", ptr_type_node);
565 for (t = TYPE_FIELDS (object_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
566 FIELD_PRIVATE (t) = 1;
567 FINISH_RECORD (object_type_node);
569 class_dtable_decl = build_dtable_decl (class_type_node);
570 TREE_STATIC (class_dtable_decl) = 1;
571 DECL_ARTIFICIAL (class_dtable_decl) = 1;
572 DECL_IGNORED_P (class_dtable_decl) = 1;
573 rest_of_decl_compilation (class_dtable_decl, (char*) 0, 1, 0);
575 field_type_node = make_node (RECORD_TYPE);
576 field_ptr_type_node = build_pointer_type (field_type_node);
577 method_type_node = make_node (RECORD_TYPE);
578 method_ptr_type_node = build_pointer_type (method_type_node);
580 set_super_info (0, class_type_node, object_type_node, 0);
581 set_super_info (0, string_type_node, object_type_node, 0);
582 class_ptr_type = build_pointer_type (class_type_node);
584 PUSH_FIELD (class_type_node, field, "next", class_ptr_type);
585 PUSH_FIELD (class_type_node, field, "name", utf8const_ptr_type);
586 PUSH_FIELD (class_type_node, field, "accflags", access_flags_type_node);
587 PUSH_FIELD (class_type_node, field, "superclass", class_ptr_type);
588 PUSH_FIELD (class_type_node, field, "subclass_head", class_ptr_type);
589 PUSH_FIELD (class_type_node, field, "subclass_next", class_ptr_type);
590 PUSH_FIELD (class_type_node, field, "constants", constants_type_node);
591 PUSH_FIELD (class_type_node, field, "methods", method_ptr_type_node);
592 PUSH_FIELD (class_type_node, field, "nmethods", short_type_node);
593 PUSH_FIELD (class_type_node, field, "msize", short_type_node);
594 PUSH_FIELD (class_type_node, field, "fields", field_ptr_type_node);
595 PUSH_FIELD (class_type_node, field, "bfsize", int_type_node);
596 PUSH_FIELD (class_type_node, field, "nfields", short_type_node);
597 PUSH_FIELD (class_type_node, field, "nsfields", short_type_node);
598 PUSH_FIELD (class_type_node, field, "dtable", dtable_ptr_type);
599 PUSH_FIELD (class_type_node, field, "interfaces",
600 build_pointer_type (class_ptr_type));
601 PUSH_FIELD (class_type_node, field, "loader", ptr_type_node);
602 PUSH_FIELD (class_type_node, field, "interface_len", short_type_node);
603 PUSH_FIELD (class_type_node, field, "state", byte_type_node);
604 PUSH_FIELD (class_type_node, field, "thread", ptr_type_node);
605 for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
606 FIELD_PRIVATE (t) = 1;
607 push_super_field (class_type_node, object_type_node);
608 FINISH_RECORD (class_type_node);
609 pushdecl (build_decl (TYPE_DECL, get_identifier ("Class"), class_type_node));
611 field_info_union_node = make_node (UNION_TYPE);
612 PUSH_FIELD (field_info_union_node, field, "boffset", int_type_node);
613 PUSH_FIELD (field_info_union_node, field, "addr", ptr_type_node);
615 PUSH_FIELD (field_info_union_node, field, "idx", unsigned_short_type_node);
617 layout_type (field_info_union_node);
619 PUSH_FIELD (field_type_node, field, "name", utf8const_ptr_type);
620 PUSH_FIELD (field_type_node, field, "type", class_ptr_type);
621 PUSH_FIELD (field_type_node, field, "accflags", access_flags_type_node);
622 PUSH_FIELD (field_type_node, field, "bsize", unsigned_short_type_node);
623 PUSH_FIELD (field_type_node, field, "info", field_info_union_node);
624 FINISH_RECORD (field_type_node);
625 CLASS_LOADED_P (field_type_node) = 1;
626 pushdecl (build_decl (TYPE_DECL, get_identifier ("Field"), field_type_node));
628 one_elt_array_domain_type = build_index_type (integer_one_node);
629 nativecode_ptr_array_type_node
630 = build_array_type (nativecode_ptr_type_node, one_elt_array_domain_type);
632 PUSH_FIELD (dtable_type, field, "class", class_ptr_type);
633 PUSH_FIELD (dtable_type, field, "methods", nativecode_ptr_array_type_node);
634 FINISH_RECORD (dtable_type);
635 pushdecl (build_decl (TYPE_DECL, get_identifier ("dispatchTable"), dtable_type));
637 #define jint_type int_type_node
638 #define jint_ptr_type ptr_type_node
640 jexception_type = make_node (RECORD_TYPE);
641 PUSH_FIELD (jexception_type, field, "start_pc", ptr_type_node);
642 PUSH_FIELD (jexception_type, field, "end_pc", ptr_type_node);
643 PUSH_FIELD (jexception_type, field, "handler_pc", ptr_type_node);
644 PUSH_FIELD (jexception_type, field, "catch_type", class_ptr_type);
645 FINISH_RECORD (jexception_type);
646 pushdecl (build_decl (TYPE_DECL, get_identifier ("jexception"), field_type_node));
647 jexception_ptr_type = build_pointer_type (jexception_type);
649 lineNumberEntry_type = make_node (RECORD_TYPE);
650 PUSH_FIELD (lineNumberEntry_type, field, "line_nr", unsigned_short_type_node);
651 PUSH_FIELD (lineNumberEntry_type, field, "start_pc", ptr_type_node);
652 FINISH_RECORD (lineNumberEntry_type);
654 lineNumbers_type = make_node (RECORD_TYPE);
655 PUSH_FIELD (lineNumbers_type, field, "length", unsigned_int_type_node);
656 FINISH_RECORD (lineNumbers_type);
658 #define instn_ptr_type_node ptr_type_node /* XXX JH */
660 #define lineNumbers_ptr_type_node build_pointer_type(lineNumbers_type)
662 PUSH_FIELD (method_type_node, field, "name", utf8const_ptr_type);
663 PUSH_FIELD (method_type_node, field, "signature", utf8const_ptr_type);
664 PUSH_FIELD (method_type_node, field, "accflags", access_flags_type_node);
665 PUSH_FIELD (method_type_node, field, "ncode", nativecode_ptr_type_node);
666 FINISH_RECORD (method_type_node);
667 CLASS_LOADED_P (method_type_node) = 1;
668 pushdecl (build_decl (TYPE_DECL, get_identifier ("Method"), method_type_node));
670 t = tree_cons (NULL_TREE, class_ptr_type,
671 build_tree_list (NULL_TREE, int_type_node));
672 alloc_object_node = builtin_function ("_Jv_AllocObject",
673 build_function_type (ptr_type_node, t),
674 NOT_BUILT_IN, NULL_PTR);
675 soft_initclass_node = builtin_function ("_Jv_InitClass",
676 build_function_type (void_type_node,
678 NOT_BUILT_IN, NULL_PTR);
679 t = build_tree_list (NULL_TREE, void_type_node);
680 throw_node = builtin_function ("_Jv_Throw",
681 build_function_type (ptr_type_node, t),
682 NOT_BUILT_IN, NULL_PTR);
683 soft_monitorenter_node
684 = builtin_function ("_Jv_MonitorEnter",
685 build_function_type (int_type_node, t),
686 NOT_BUILT_IN, NULL_PTR);
687 soft_monitorexit_node
688 = builtin_function ("_Jv_MonitorExit",
689 build_function_type (int_type_node, t),
690 NOT_BUILT_IN, NULL_PTR);
692 t = tree_cons (NULL_TREE, int_type_node,
693 build_tree_list (NULL_TREE, int_type_node));
695 = builtin_function ("_Jv_NewArray",
696 build_function_type(ptr_type_node, t),
697 NOT_BUILT_IN, NULL_PTR );
699 t = tree_cons (NULL_TREE, int_type_node,
700 tree_cons (NULL_TREE, class_ptr_type,
701 build_tree_list (NULL_TREE,
702 object_ptr_type_node)));
704 = builtin_function ("_Jv_NewObjectArray",
705 build_function_type (ptr_type_node, t),
706 NOT_BUILT_IN, NULL_PTR );
708 t = tree_cons (NULL_TREE, ptr_type_node,
709 build_tree_list (NULL_TREE, int_type_node));
710 soft_multianewarray_node
711 = builtin_function ("_Jv_NewMultiArray",
712 build_function_type (ptr_type_node, t),
713 NOT_BUILT_IN, NULL_PTR );
715 t = build_function_type (void_type_node,
716 build_tree_list (NULL_TREE, int_type_node));
717 soft_badarrayindex_node
718 = builtin_function ("_Jv_ThrowBadArrayIndex", t,
719 NOT_BUILT_IN, NULL_PTR);
720 TREE_THIS_VOLATILE (soft_badarrayindex_node) = 1;
721 TREE_SIDE_EFFECTS (soft_badarrayindex_node) = 1;
723 t = tree_cons (NULL_TREE, class_ptr_type,
724 build_tree_list (NULL_TREE, object_ptr_type_node));
726 = builtin_function ("_Jv_CheckCast",
727 build_function_type (ptr_type_node, t),
728 NOT_BUILT_IN, NULL_PTR);
729 t = tree_cons (NULL_TREE, object_ptr_type_node,
730 build_tree_list (NULL_TREE, class_ptr_type));
732 = builtin_function ("_Jv_IsInstanceOf",
733 build_function_type (promoted_boolean_type_node, t),
734 NOT_BUILT_IN, NULL_PTR);
735 t = tree_cons (NULL_TREE, object_ptr_type_node,
736 build_tree_list (NULL_TREE, object_ptr_type_node));
737 soft_checkarraystore_node
738 = builtin_function ("_Jv_CheckArrayStore",
739 build_function_type (void_type_node, t),
740 NOT_BUILT_IN, NULL_PTR);
741 t = tree_cons (NULL_TREE, ptr_type_node,
742 tree_cons (NULL_TREE, ptr_type_node,
743 build_tree_list (NULL_TREE, ptr_type_node)));
744 soft_lookupinterfacemethod_node
745 = builtin_function ("_Jv_LookupInterfaceMethod",
746 build_function_type (ptr_type_node, t),
747 NOT_BUILT_IN, NULL_PTR);
748 t = tree_cons (NULL_TREE, double_type_node,
749 build_tree_list (NULL_TREE, double_type_node));
751 = builtin_function ("__builtin_fmod",
752 build_function_type (double_type_node, t),
753 BUILT_IN_FMOD, "fmod");
755 t = build_tree_list (NULL_TREE, void_type_node);
756 soft_exceptioninfo_call_node
760 (builtin_function ("_Jv_exception_info",
761 build_function_type (ptr_type_node, t),
762 NOT_BUILT_IN, NULL_PTR)),
763 NULL_TREE, NULL_TREE);
764 TREE_SIDE_EFFECTS (soft_exceptioninfo_call_node) = 1;
766 t = tree_cons (NULL_TREE, float_type_node,
767 build_tree_list (NULL_TREE, float_type_node));
769 = builtin_function ("__builtin_fmodf",
770 build_function_type (float_type_node, t),
771 BUILT_IN_FMOD, "fmodf");
774 init_class_processing ();
778 /* Look up NAME in the current binding level and its superiors
779 in the namespace of variables, functions and typedefs.
780 Return a ..._DECL node of some kind representing its definition,
781 or return 0 if it is undefined. */
788 if (current_binding_level != global_binding_level
789 && IDENTIFIER_LOCAL_VALUE (name))
790 val = IDENTIFIER_LOCAL_VALUE (name);
792 val = IDENTIFIER_GLOBAL_VALUE (name);
796 /* Similar to `lookup_name' but look only at current binding level and
797 the previous one if its the parameter level. */
800 lookup_name_current_level (name)
805 if (current_binding_level == global_binding_level)
806 return IDENTIFIER_GLOBAL_VALUE (name);
808 if (IDENTIFIER_LOCAL_VALUE (name) == 0)
811 for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
812 if (DECL_NAME (t) == name)
818 /* Use a binding level to record a labeled block declaration */
821 push_labeled_block (lb)
824 register tree name = DECL_NAME (LABELED_BLOCK_LABEL (lb));
825 register struct binding_level *b = current_binding_level;
826 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
828 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
829 TREE_CHAIN (lb) = b->names;
831 IDENTIFIER_LOCAL_VALUE (name) = lb;
834 /* Pop the current binding level, reinstalling values for the previous
840 struct binding_level *b = current_binding_level;
841 tree label = b->names;
842 IDENTIFIER_LOCAL_VALUE (DECL_NAME (LABELED_BLOCK_LABEL (label))) =
845 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (b->shadowed)) =
846 TREE_VALUE (b->shadowed);
848 /* Pop the current level, and free the structure for reuse. */
849 current_binding_level = current_binding_level->level_chain;
850 b->level_chain = free_binding_level;
851 free_binding_level = b;
854 /* Record a decl-node X as belonging to the current lexical scope.
855 Check for errors (such as an incompatible declaration for the same
856 name already seen in the same scope).
858 Returns either X or an old decl for the same name.
859 If an old decl is returned, it may have been smashed
860 to agree with what X says. */
867 register tree name = DECL_NAME (x);
868 register struct binding_level *b = current_binding_level;
870 DECL_CONTEXT (x) = current_function_decl;
875 int different_binding_level = 0;
877 t = lookup_name_current_level (name);
878 if (t != 0 && t == error_mark_node)
879 /* error_mark_node is 0 for a while during initialization! */
882 error_with_decl (x, "`%s' used prior to declaration");
887 file = DECL_SOURCE_FILE (t);
888 line = DECL_SOURCE_LINE (t);
891 /* If we're naming a hitherto-unnamed type, set its TYPE_NAME
892 to point to the TYPE_DECL.
893 Since Java does not have typedefs, a type can only have
894 one (true) name, given by a class, interface, or builtin. */
895 if (TREE_CODE (x) == TYPE_DECL
896 && TYPE_NAME (TREE_TYPE (x)) == 0
897 && TREE_TYPE (x) != error_mark_node)
899 TYPE_NAME (TREE_TYPE (x)) = x;
900 TYPE_STUB_DECL (TREE_TYPE (x)) = x;
903 /* This name is new in its binding level.
904 Install the new declaration and return it. */
905 if (b == global_binding_level)
907 /* Install a global value. */
909 IDENTIFIER_GLOBAL_VALUE (name) = x;
913 /* Here to install a non-global value. */
914 tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
915 tree oldglobal = IDENTIFIER_GLOBAL_VALUE (name);
916 IDENTIFIER_LOCAL_VALUE (name) = x;
919 /* Warn if shadowing an argument at the top level of the body. */
920 if (oldlocal != 0 && !DECL_EXTERNAL (x)
921 /* This warning doesn't apply to the parms of a nested fcn. */
922 && ! current_binding_level->parm_flag
923 /* Check that this is one level down from the parms. */
924 && current_binding_level->level_chain->parm_flag
925 /* Check that the decl being shadowed
926 comes from the parm level, one level up. */
927 && chain_member (oldlocal, current_binding_level->level_chain->names))
929 if (TREE_CODE (oldlocal) == PARM_DECL)
930 pedwarn ("declaration of `%s' shadows a parameter",
931 IDENTIFIER_POINTER (name));
933 pedwarn ("declaration of `%s' shadows a symbol from the parameter list",
934 IDENTIFIER_POINTER (name));
937 /* Maybe warn if shadowing something else. */
938 else if (warn_shadow && !DECL_EXTERNAL (x)
939 /* No shadow warnings for internally generated vars. */
940 && DECL_SOURCE_LINE (x) != 0
941 /* No shadow warnings for vars made for inlining. */
942 && ! DECL_FROM_INLINE (x))
944 char *warnstring = 0;
946 if (TREE_CODE (x) == PARM_DECL
947 && current_binding_level->level_chain->parm_flag)
948 /* Don't warn about the parm names in function declarator
949 within a function declarator.
950 It would be nice to avoid warning in any function
951 declarator in a declaration, as opposed to a definition,
952 but there is no way to tell it's not a definition. */
954 else if (oldlocal != 0 && TREE_CODE (oldlocal) == PARM_DECL)
955 warnstring = "declaration of `%s' shadows a parameter";
956 else if (oldlocal != 0)
957 warnstring = "declaration of `%s' shadows previous local";
958 else if (IDENTIFIER_GLOBAL_VALUE (name) != 0
959 && IDENTIFIER_GLOBAL_VALUE (name) != error_mark_node)
960 warnstring = "declaration of `%s' shadows global declaration";
963 warning (warnstring, IDENTIFIER_POINTER (name));
967 /* If storing a local value, there may already be one (inherited).
968 If so, record it for restoration when this binding level ends. */
970 b->shadowed = tree_cons (name, oldlocal, b->shadowed);
974 /* Put decls on list in reverse order.
975 We will reverse them later if necessary. */
976 TREE_CHAIN (x) = b->names;
982 pushdecl_force_head (x)
985 current_binding_level->names = x;
988 /* Like pushdecl, only it places X in GLOBAL_BINDING_LEVEL, if appropriate. */
991 pushdecl_top_level (x)
995 register struct binding_level *b = current_binding_level;
997 current_binding_level = global_binding_level;
999 current_binding_level = b;
1003 /* Nonzero if we are currently in the global binding level. */
1006 global_bindings_p ()
1008 return current_binding_level == global_binding_level;
1011 /* Return the list of declarations of the current level.
1012 Note that this list is in reverse order unless/until
1013 you nreverse it; and when you do nreverse it, you must
1014 store the result back using `storedecls' or you will lose. */
1019 return current_binding_level->names;
1022 /* Create a new `struct binding_level'. */
1025 struct binding_level *
1026 make_binding_level ()
1029 return (struct binding_level *) xmalloc (sizeof (struct binding_level));
1036 register struct binding_level *newlevel = NULL_BINDING_LEVEL;
1039 /* If this is the top level of a function,
1040 just make sure that NAMED_LABELS is 0. */
1042 if (current_binding_level == global_binding_level)
1046 /* Reuse or create a struct for this binding level. */
1048 if (free_binding_level)
1050 newlevel = free_binding_level;
1051 free_binding_level = free_binding_level->level_chain;
1055 newlevel = make_binding_level ();
1058 /* Add this level to the front of the chain (stack) of levels that
1061 *newlevel = clear_binding_level;
1062 newlevel->level_chain = current_binding_level;
1063 current_binding_level = newlevel;
1064 newlevel->keep = keep_next_level_flag;
1065 keep_next_level_flag = 0;
1066 newlevel->keep_if_subblocks = keep_next_if_subblocks;
1067 keep_next_if_subblocks = 0;
1070 /* Exit a binding level.
1071 Pop the level off, and restore the state of the identifier-decl mappings
1072 that were in effect when this level was entered.
1074 If KEEP is nonzero, this level had explicit declarations, so
1075 and create a "block" (a BLOCK node) for the level
1076 to record its declarations and subblocks for symbol table output.
1078 If FUNCTIONBODY is nonzero, this level is the body of a function,
1079 so create a block as if KEEP were set and also clear out all
1082 If REVERSE is nonzero, reverse the order of decls before putting
1083 them into the BLOCK. */
1086 poplevel (keep, reverse, functionbody)
1092 /* The chain of decls was accumulated in reverse order.
1093 Put it into forward order, just for cleanliness. */
1095 tree subblocks = current_binding_level->blocks;
1098 int block_previously_created;
1100 keep |= current_binding_level->keep;
1102 /* Get the decls in the order they were written.
1103 Usually current_binding_level->names is in reverse order.
1104 But parameter decls were previously put in forward order. */
1107 current_binding_level->names
1108 = decls = nreverse (current_binding_level->names);
1110 decls = current_binding_level->names;
1112 /* Output any nested inline functions within this block
1113 if they weren't already output. */
1115 for (decl = decls; decl; decl = TREE_CHAIN (decl))
1116 if (TREE_CODE (decl) == FUNCTION_DECL
1117 && ! TREE_ASM_WRITTEN (decl)
1118 && DECL_INITIAL (decl) != 0
1119 && TREE_ADDRESSABLE (decl))
1121 /* If this decl was copied from a file-scope decl
1122 on account of a block-scope extern decl,
1123 propagate TREE_ADDRESSABLE to the file-scope decl.
1125 DECL_ABSTRACT_ORIGIN can be set to itself if warn_return_type is
1126 true, since then the decl goes through save_for_inline_copying. */
1127 if (DECL_ABSTRACT_ORIGIN (decl) != 0
1128 && DECL_ABSTRACT_ORIGIN (decl) != decl)
1129 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
1132 push_function_context ();
1133 output_inline_function (decl);
1134 pop_function_context ();
1138 /* If there were any declarations in that level,
1139 or if this level is a function body,
1140 create a BLOCK to record them for the life of this function. */
1143 block_previously_created = (current_binding_level->this_block != 0);
1144 if (block_previously_created)
1145 block = current_binding_level->this_block;
1146 else if (keep || functionbody
1147 || (current_binding_level->keep_if_subblocks && subblocks != 0))
1148 block = make_node (BLOCK);
1151 BLOCK_VARS (block) = decls;
1152 BLOCK_TYPE_TAGS (block) = NULL_TREE;
1153 BLOCK_SUBBLOCKS (block) = subblocks;
1154 remember_end_note (block);
1157 /* In each subblock, record that this is its superior. */
1159 for (link = subblocks; link; link = TREE_CHAIN (link))
1160 BLOCK_SUPERCONTEXT (link) = block;
1162 /* Clear out the meanings of the local variables of this level. */
1164 for (link = decls; link; link = TREE_CHAIN (link))
1166 tree name = DECL_NAME (link);
1167 if (name != 0 && IDENTIFIER_LOCAL_VALUE (name) == link)
1169 /* If the ident. was used or addressed via a local extern decl,
1170 don't forget that fact. */
1171 if (DECL_EXTERNAL (link))
1173 if (TREE_USED (link))
1174 TREE_USED (name) = 1;
1175 if (TREE_ADDRESSABLE (link))
1176 TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (link)) = 1;
1178 IDENTIFIER_LOCAL_VALUE (name) = 0;
1182 /* Restore all name-meanings of the outer levels
1183 that were shadowed by this level. */
1185 for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
1186 IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
1188 /* If the level being exited is the top level of a function,
1189 check over all the labels, and clear out the current
1190 (function local) meanings of their names. */
1194 /* If this is the top level block of a function,
1195 the vars are the function's parameters.
1196 Don't leave them in the BLOCK because they are
1197 found in the FUNCTION_DECL instead. */
1199 BLOCK_VARS (block) = 0;
1201 /* Clear out the definitions of all label names,
1202 since their scopes end here,
1203 and add them to BLOCK_VARS. */
1206 for (link = named_labels; link; link = TREE_CHAIN (link))
1208 register tree label = TREE_VALUE (link);
1210 if (DECL_INITIAL (label) == 0)
1212 error_with_decl (label, "label `%s' used but not defined");
1213 /* Avoid crashing later. */
1214 define_label (input_filename, lineno,
1217 else if (warn_unused && !TREE_USED (label))
1218 warning_with_decl (label, "label `%s' defined but not used");
1219 IDENTIFIER_LABEL_VALUE (DECL_NAME (label)) = 0;
1221 /* Put the labels into the "variables" of the
1222 top-level block, so debugger can see them. */
1223 TREE_CHAIN (label) = BLOCK_VARS (block);
1224 BLOCK_VARS (block) = label;
1229 /* Pop the current level, and free the structure for reuse. */
1232 register struct binding_level *level = current_binding_level;
1233 current_binding_level = current_binding_level->level_chain;
1235 level->level_chain = free_binding_level;
1236 free_binding_level = level;
1239 /* Dispose of the block that we just made inside some higher level. */
1241 DECL_INITIAL (current_function_decl) = block;
1244 if (!block_previously_created)
1245 current_binding_level->blocks
1246 = chainon (current_binding_level->blocks, block);
1248 /* If we did not make a block for the level just exited,
1249 any blocks made for inner levels
1250 (since they cannot be recorded as subblocks in that level)
1251 must be carried forward so they will later become subblocks
1252 of something else. */
1254 current_binding_level->blocks
1255 = chainon (current_binding_level->blocks, subblocks);
1257 /* Set the TYPE_CONTEXTs for all of the tagged types belonging to this
1258 binding contour so that they point to the appropriate construct, i.e.
1259 either to the current FUNCTION_DECL node, or else to the BLOCK node
1260 we just constructed.
1262 Note that for tagged types whose scope is just the formal parameter
1263 list for some function type specification, we can't properly set
1264 their TYPE_CONTEXTs here, because we don't have a pointer to the
1265 appropriate FUNCTION_TYPE node readily available to us. For those
1266 cases, the TYPE_CONTEXTs of the relevant tagged type nodes get set
1267 in `grokdeclarator' as soon as we have created the FUNCTION_TYPE
1268 node which will represent the "scope" for these "parameter list local"
1273 TREE_USED (block) = 1;
1278 maybe_pushlevels (pc)
1281 while (pending_local_decls != NULL_TREE &&
1282 DECL_LOCAL_START_PC (pending_local_decls) <= pc)
1284 tree *ptr = &pending_local_decls;
1286 int end_pc = DECL_LOCAL_END_PC (decl);
1288 while (*ptr != NULL_TREE
1289 && DECL_LOCAL_START_PC (*ptr) <= pc
1290 && DECL_LOCAL_END_PC (*ptr) == end_pc)
1291 ptr = &TREE_CHAIN (*ptr);
1292 pending_local_decls = *ptr;
1295 /* Force non-nested range to be nested in current range. */
1296 if (end_pc > current_binding_level->end_pc)
1297 end_pc = current_binding_level->end_pc;
1300 expand_start_bindings (0);
1301 current_binding_level->end_pc = end_pc;
1303 current_binding_level->names = decl;
1304 for ( ; decl != NULL_TREE; decl = TREE_CHAIN (decl))
1306 push_jvm_slot (DECL_LOCAL_SLOT_NUMBER (decl), decl);
1312 maybe_poplevels (pc)
1315 while (current_binding_level->end_pc <= pc)
1317 expand_end_bindings (getdecls (), 1, 0);
1322 /* Insert BLOCK at the end of the list of subblocks of the
1323 current binding level. This is used when a BIND_EXPR is expanded,
1324 to handle the BLOCK node inside the BIND_EXPR. */
1327 insert_block (block)
1330 TREE_USED (block) = 1;
1332 current_binding_level->blocks
1333 = chainon (current_binding_level->blocks, block);
1336 /* Set the BLOCK node for the innermost scope
1337 (the one we are currently in). */
1341 register tree block;
1343 current_binding_level->this_block = block;
1346 /* integrate_decl_tree calls this function. */
1349 copy_lang_decl (node)
1353 = TREE_CODE (node) == VAR_DECL ? sizeof (struct lang_decl_var)
1354 : sizeof (struct lang_decl);
1355 struct lang_decl *x = (struct lang_decl *) oballoc (lang_decl_size);
1356 bcopy (DECL_LANG_SPECIFIC (node), x, lang_decl_size);
1357 DECL_LANG_SPECIFIC (node) = x;
1360 /* If DECL has a cleanup, build and return that cleanup here.
1361 This is a callback called by expand_expr. */
1364 maybe_build_cleanup (decl)
1367 /* There are no cleanups in Java (I think). */
1372 give_name_to_locals (jcf)
1375 int i, n = DECL_LOCALVARIABLES_OFFSET (current_function_decl);
1377 pending_local_decls = NULL_TREE;
1381 n = JCF_readu2 (jcf);
1382 for (i = 0; i < n; i++)
1384 int start_pc = JCF_readu2 (jcf);
1385 int length = JCF_readu2 (jcf);
1386 int name_index = JCF_readu2 (jcf);
1387 int signature_index = JCF_readu2 (jcf);
1388 int slot = JCF_readu2 (jcf);
1389 tree name = get_name_constant (jcf, name_index);
1390 tree type = parse_signature (jcf, signature_index);
1391 if (slot < DECL_ARG_SLOT_COUNT (current_function_decl)
1393 && length == DECL_CODE_LENGTH (current_function_decl))
1395 tree decl = TREE_VEC_ELT (decl_map, slot);
1396 DECL_NAME (decl) = name;
1397 DECL_ASSEMBLER_NAME (decl) = name;
1398 if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
1399 warning ("bad type in parameter debug info");
1404 int end_pc = start_pc + length;
1405 tree decl = build_decl (VAR_DECL, name, type);
1406 if (end_pc > DECL_CODE_LENGTH (current_function_decl))
1408 warning_with_decl (decl,
1409 "bad PC range for debug info for local `%s'");
1410 end_pc = DECL_CODE_LENGTH (current_function_decl);
1412 DECL_LANG_SPECIFIC (decl)
1413 = (struct lang_decl *) permalloc (sizeof (struct lang_decl_var));
1414 DECL_LOCAL_SLOT_NUMBER (decl) = slot;
1415 DECL_LOCAL_START_PC (decl) = start_pc;
1416 DECL_LOCAL_END_PC (decl) = end_pc;
1418 /* Now insert the new decl in the proper place in
1419 pending_local_decls. We are essentially doing an insertion sort,
1420 which works fine, since the list input will normally already
1422 ptr = &pending_local_decls;
1423 while (*ptr != NULL_TREE
1424 && (DECL_LOCAL_START_PC (*ptr) > start_pc
1425 || (DECL_LOCAL_START_PC (*ptr) == start_pc
1426 && DECL_LOCAL_END_PC (*ptr) < end_pc)))
1427 ptr = &TREE_CHAIN (*ptr);
1428 TREE_CHAIN (decl) = *ptr;
1433 pending_local_decls = nreverse (pending_local_decls);
1435 /* Fill in default names for the parameters. */
1436 for (parm = DECL_ARGUMENTS (current_function_decl), i = 0;
1437 parm != NULL_TREE; parm = TREE_CHAIN (parm), i++)
1439 if (DECL_NAME (parm) == NULL_TREE)
1441 int arg_i = METHOD_STATIC (current_function_decl) ? i+1 : i;
1443 DECL_NAME (parm) = get_identifier ("this");
1447 sprintf (buffer, "ARG_%d", arg_i);
1448 DECL_NAME (parm) = get_identifier (buffer);
1450 DECL_ASSEMBLER_NAME (parm) = DECL_NAME (parm);
1456 complete_start_java_method (fndecl)
1459 tree restype = TREE_TYPE (TREE_TYPE (fndecl));
1460 /* To be compatible with C_PROMOTING_INTEGER_TYPE_P in cc1/cc1plus. */
1461 if (INTEGRAL_TYPE_P (restype)
1462 && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
1463 restype = integer_type_node;
1464 DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, restype);
1466 if (! flag_emit_class_files)
1468 /* Initialize the RTL code for the function. */
1469 init_function_start (fndecl, input_filename, lineno);
1471 /* Set up parameters and prepare for return, for the function. */
1472 expand_function_start (fndecl, 0);
1475 /* Allocate further tree nodes temporarily during compilation
1476 of this function only. */
1477 temporary_allocation ();
1480 /* If this fcn was already referenced via a block-scope `extern' decl (or
1481 an implicit decl), propagate certain information about the usage. */
1482 if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl)))
1483 TREE_ADDRESSABLE (current_function_decl) = 1;
1487 if (METHOD_STATIC (fndecl) && ! METHOD_PRIVATE (fndecl))
1489 tree clas = DECL_CONTEXT (fndecl);
1490 tree init = build (CALL_EXPR, void_type_node,
1491 build_address_of (soft_initclass_node),
1492 build_tree_list (NULL_TREE, build_class_ref (clas)),
1494 TREE_SIDE_EFFECTS (init) = 1;
1495 expand_expr_stmt (init);
1498 if (METHOD_SYNCHRONIZED (fndecl))
1500 /* FIXME: surround the function body by a try/finally set. */
1503 /* Push local variables. Function compiled from source code are
1504 using a different local variables management, and for them,
1505 pushlevel shouldn't be called from here. */
1506 if (!CLASS_FROM_SOURCE_P (DECL_CONTEXT (fndecl)))
1509 if (! flag_emit_class_files)
1510 expand_start_bindings (1);
1515 start_java_method (fndecl)
1521 current_function_decl = fndecl;
1522 announce_function (fndecl);
1524 i = DECL_MAX_LOCALS(fndecl) + DECL_MAX_STACK(fndecl);
1525 decl_map = make_tree_vec (i);
1526 type_map = (tree *) oballoc (i * sizeof (tree));
1528 pushlevel (1); /* Push parameters. */
1530 ptr = &DECL_ARGUMENTS (fndecl);
1531 for (tem = TYPE_ARG_TYPES (TREE_TYPE (fndecl)), i = 0;
1532 tem != NULL_TREE; tem = TREE_CHAIN (tem), i++)
1534 tree parm_name = NULL_TREE, parm_decl;
1535 tree parm_type = TREE_VALUE (tem);
1536 if (i >= DECL_MAX_LOCALS(fndecl))
1537 fatal ("function has more parameters than local slots");
1539 parm_decl = build_decl (PARM_DECL, parm_name, parm_type);
1540 DECL_CONTEXT (parm_decl) = fndecl;
1541 #ifdef PROMOTE_PROTOTYPES
1542 if (TYPE_PRECISION (parm_type) < TYPE_PRECISION (integer_type_node)
1543 && INTEGRAL_TYPE_P (parm_type))
1544 parm_type = integer_type_node;
1546 DECL_ARG_TYPE (parm_decl) = parm_type;
1549 ptr = &TREE_CHAIN (parm_decl);
1551 /* Add parm_decl to the decl_map. */
1552 push_jvm_slot (i, parm_decl);
1554 type_map[i] = TREE_TYPE (parm_decl);
1555 if (TYPE_IS_WIDE (TREE_TYPE (parm_decl)))
1558 type_map[i] = void_type_node;
1562 DECL_ARG_SLOT_COUNT (current_function_decl) = i;
1564 while (i < DECL_MAX_LOCALS(fndecl))
1565 type_map[i++] = NULL_TREE;
1567 complete_start_java_method (fndecl);
1573 tree fndecl = current_function_decl;
1575 expand_end_bindings (getdecls (), 1, 0);
1576 /* pop out of function */
1579 /* pop out of its parameters */
1582 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
1586 /* Generate rtl for function exit. */
1587 expand_function_end (input_filename, lineno, 0);
1589 /* Run the optimizers and output assembler code for this function. */
1590 rest_of_compilation (fndecl);
1592 current_function_decl = NULL_TREE;
1593 permanent_allocation (1);
1597 build_decl_no_layout (code, name, type)
1598 enum tree_code code;
1601 tree decl = build_decl (TYPE_DECL, name, type);
1602 TREE_SET_CODE (decl, code);