1 /* Parser for Java(TM) .class files.
2 Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>.
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. */
25 /* Written by Per Bothner <bothner@cygnus.com> */
29 #include "coretypes.h"
33 #include "java-except.h"
36 #include "java-tree.h"
50 #ifdef HAVE_LANGINFO_CODESET
54 /* A CONSTANT_Utf8 element is converted to an IDENTIFIER_NODE at parse time. */
55 #define JPOOL_UTF(JCF, INDEX) CPOOL_UTF(&(JCF)->cpool, INDEX)
56 #define JPOOL_UTF_LENGTH(JCF, INDEX) IDENTIFIER_LENGTH (JPOOL_UTF (JCF, INDEX))
57 #define JPOOL_UTF_DATA(JCF, INDEX) \
58 ((const unsigned char *) IDENTIFIER_POINTER (JPOOL_UTF (JCF, INDEX)))
59 #define HANDLE_CONSTANT_Utf8(JCF, INDEX, LENGTH) \
61 unsigned char save; unsigned char *text; \
62 JCF_FILL (JCF, (LENGTH)+1); /* Make sure we read 1 byte beyond string. */ \
63 text = (JCF)->read_ptr; \
64 save = text[LENGTH]; \
66 (JCF)->cpool.data[INDEX].t = get_identifier ((const char *) text); \
67 text[LENGTH] = save; \
68 JCF_SKIP (JCF, LENGTH); } while (0)
72 extern struct obstack temporary_obstack
;
74 static GTY(()) tree parse_roots
[2];
76 /* The FIELD_DECL for the current field. */
77 #define current_field parse_roots[0]
79 /* The METHOD_DECL for the current method. */
80 #define current_method parse_roots[1]
82 /* A list of TRANSLATION_UNIT_DECLs for the files to be compiled. */
83 static GTY(()) VEC(tree
,gc
) *current_file_list
;
85 /* Line 0 in current file, if compiling from bytecode. */
86 static location_t file_start_location
;
88 /* The Java archive that provides main_class; the main input file. */
89 static GTY(()) struct JCF
* main_jcf
;
91 /* A list of all the class DECLs seen so far. */
92 static GTY(()) VEC(tree
,gc
) *all_class_list
;
94 /* The number of source files passed to us by -fsource-filename and an
95 array of pointers to each name. Used by find_sourcefile(). */
96 static int num_files
= 0;
97 static char **filenames
;
99 static struct ZipFile
*localToFile
;
101 /* A map of byte offsets in the reflection data that are fields which
103 bitmap field_offsets
;
104 bitmap_obstack bit_obstack
;
106 /* Declarations of some functions used here. */
107 static void handle_innerclass_attribute (int count
, JCF
*, int len
);
108 static tree
give_name_to_class (JCF
*jcf
, int index
);
109 static char *compute_class_name (struct ZipDirectory
*zdir
);
110 static int classify_zip_file (struct ZipDirectory
*zdir
);
111 static void parse_zip_file_entries (void);
112 static void process_zip_dir (FILE *);
113 static void parse_class_file (void);
114 static void handle_deprecated (void);
115 static void set_source_filename (JCF
*, int);
116 static void jcf_parse (struct JCF
*);
117 static void load_inner_classes (tree
);
118 static void handle_annotation (JCF
*jcf
, int level
);
119 static void java_layout_seen_class_methods (void);
121 /* Handle "Deprecated" attribute. */
123 handle_deprecated (void)
125 if (current_field
!= NULL_TREE
)
126 FIELD_DEPRECATED (current_field
) = 1;
127 else if (current_method
!= NULL_TREE
)
128 METHOD_DEPRECATED (current_method
) = 1;
129 else if (current_class
!= NULL_TREE
)
130 CLASS_DEPRECATED (TYPE_NAME (current_class
)) = 1;
133 /* Shouldn't happen. */
140 /* Reverse a string. */
142 reverse (const char *s
)
148 int len
= strlen (s
);
149 char *d
= XNEWVAR (char, len
+ 1);
154 for (dp
= &d
[0], sp
= &s
[len
-1]; sp
>= s
; dp
++, sp
--)
161 /* Compare two strings for qsort(). */
163 cmpstringp (const void *p1
, const void *p2
)
165 /* The arguments to this function are "pointers to
166 pointers to char", but strcmp() arguments are "pointers
167 to char", hence the following cast plus dereference */
169 return strcmp(*(const char *const*) p1
, *(const char *const*) p2
);
172 /* Create an array of strings, one for each source file that we've
173 seen. fsource_filename can either be the name of a single .java
174 file or a file that contains a list of filenames separated by
177 java_read_sourcefilenames (const char *fsource_filename
)
181 && strlen (fsource_filename
) > strlen (".java")
182 && strcmp ((fsource_filename
183 + strlen (fsource_filename
)
187 /* fsource_filename isn't a .java file but a list of filenames
188 separated by newlines */
189 FILE *finput
= fopen (fsource_filename
, "r");
191 int longest_line
= 0;
195 /* Find out how many files there are, and how long the filenames are. */
196 while (! feof (finput
))
198 int ch
= getc (finput
);
202 if (len
> longest_line
)
214 /* Read the filenames. Put a pointer to each filename into the
217 char *linebuf
= (char *) alloca (longest_line
+ 1);
221 filenames
= XNEWVEC (char *, num_files
);
226 int ch
= getc (finput
);
231 linebuf
[charpos
] = 0;
232 gcc_assert (i
< num_files
);
233 /* ??? Perhaps we should use lrealpath() here. Doing
234 so would tidy up things like /../ but the rest of
235 gcc seems to assume relative pathnames, not
236 absolute pathnames. */
237 /* realname = lrealpath (linebuf); */
238 filenames
[i
++] = reverse (linebuf
);
242 gcc_assert (charpos
< longest_line
);
243 linebuf
[charpos
++] = ch
;
247 qsort (filenames
, num_files
, sizeof (char *), cmpstringp
);
253 filenames
= XNEWVEC (char *, 1);
254 filenames
[0] = reverse (fsource_filename
);
259 /* Given a relative pathname such as foo/bar.java, attempt to find a
260 longer pathname with the same suffix.
262 This is a best guess heuristic; with some weird class hierarchies we
263 may fail to pick the correct source file. For example, if we have
264 the filenames foo/bar.java and also foo/foo/bar.java, we do not
265 have enough information to know which one is the right match for
269 find_sourcefile (const char *name
)
271 int i
= 0, j
= num_files
-1;
276 char *revname
= reverse (name
);
281 int cmp
= strncmp (revname
, filenames
[k
], strlen (revname
));
284 /* OK, so we found one. But is it a unique match? */
286 && strncmp (revname
, filenames
[k
-1], strlen (revname
)) == 0)
288 && (strncmp (revname
, filenames
[k
+1], strlen (revname
))
292 found
= filenames
[k
];
305 if (found
&& strlen (found
) > strlen (name
))
306 return reverse (found
);
313 /* Handle "SourceFile" attribute. */
316 set_source_filename (JCF
*jcf
, int index
)
318 tree sfname_id
= get_name_constant (jcf
, index
);
319 const char *sfname
= IDENTIFIER_POINTER (sfname_id
);
320 const char *old_filename
= input_filename
;
321 int new_len
= IDENTIFIER_LENGTH (sfname_id
);
322 if (old_filename
!= NULL
)
324 int old_len
= strlen (old_filename
);
325 /* Use the current input_filename (derived from the class name)
326 if it has a directory prefix, but otherwise matches sfname. */
327 if (old_len
> new_len
328 && strcmp (sfname
, old_filename
+ old_len
- new_len
) == 0
329 && (old_filename
[old_len
- new_len
- 1] == '/'
330 || old_filename
[old_len
- new_len
- 1] == '\\'))
333 if (strchr (sfname
, '/') == NULL
&& strchr (sfname
, '\\') == NULL
)
335 const char *class_name
336 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class
)));
337 const char *dot
= strrchr (class_name
, '.');
340 /* Length of prefix, not counting final dot. */
341 int i
= dot
- class_name
;
342 /* Concatenate current package prefix with new sfname. */
343 char *buf
= XNEWVEC (char, i
+ new_len
+ 2); /* Space for '.' and '\0'. */
344 strcpy (buf
+ i
+ 1, sfname
);
345 /* Copy package from class_name, replacing '.' by DIR_SEPARATOR.
346 Note we start at the end with the final package dot. */
349 char c
= class_name
[i
];
354 sfname_id
= get_identifier (buf
);
356 sfname
= IDENTIFIER_POINTER (sfname_id
);
360 sfname
= find_sourcefile (sfname
);
361 line_table
->maps
[line_table
->used
-1].to_file
= sfname
;
362 if (current_class
== main_class
) main_input_filename
= sfname
;
368 /* Annotation handling.
370 The technique we use here is to copy the annotation data directly
371 from the input class file into the output file. We don't decode the
372 data at all, merely rewriting constant indexes whenever we come
373 across them: this is necessary because the constant pool in the
374 output file isn't the same as the constant pool in in the input.
376 The main advantage of this technique is that the resulting
377 annotation data is pointer-free, so it doesn't have to be relocated
378 at startup time. As a consequence of this, annotations have no
379 performance impact unless they are used. Also, this representation
383 /* Expand TYPE_REFLECTION_DATA by DELTA bytes. Return the address of
384 the start of the newly allocated region. */
386 static unsigned char*
387 annotation_grow (int delta
)
389 unsigned char **data
= &TYPE_REFLECTION_DATA (current_class
);
390 long *datasize
= &TYPE_REFLECTION_DATASIZE (current_class
);
391 long len
= *datasize
;
395 *data
= XNEWVAR (unsigned char, delta
);
399 int newlen
= *datasize
+ delta
;
400 if (floor_log2 (newlen
) != floor_log2 (*datasize
))
401 *data
= XRESIZEVAR (unsigned char, *data
, 2 << (floor_log2 (newlen
)));
407 /* annotation_rewrite_TYPE. Rewrite various int types at p. Use Java
408 byte order (i.e. big endian.) */
411 annotation_rewrite_byte (unsigned int n
, unsigned char *p
)
417 annotation_rewrite_short (unsigned int n
, unsigned char *p
)
424 annotation_rewrite_int (unsigned int n
, unsigned char *p
)
432 /* Read a 16-bit unsigned int in Java byte order (i.e. big
436 annotation_read_short (unsigned char *p
)
439 tmp
= (tmp
<< 8) | p
[1];
443 /* annotation_write_TYPE. Rewrite various int types, appending them
444 to TYPE_REFLECTION_DATA. Use Java byte order (i.e. big
448 annotation_write_byte (unsigned int n
)
450 annotation_rewrite_byte (n
, annotation_grow (1));
454 annotation_write_short (unsigned int n
)
456 annotation_rewrite_short (n
, annotation_grow (2));
460 annotation_write_int (unsigned int n
)
462 annotation_rewrite_int (n
, annotation_grow (4));
465 /* Create a 64-bit constant in the constant pool.
467 This is used for both integer and floating-point types. As a
468 consequence, it will not work if the target floating-point format
469 is anything other than IEEE-754. While this is arguably a bug, the
470 runtime library makes exactly the same assumption and it's unlikely
471 that Java will ever run on a non-IEEE machine. */
474 handle_long_constant (JCF
*jcf
, CPool
*cpool
, enum cpool_tag kind
,
475 int index
, bool big_endian
)
477 /* If we're on a 64-bit platform we can fit a long or double
478 into the same space as a jword. */
479 if (POINTER_SIZE
>= 64)
480 index
= find_constant1 (cpool
, kind
, JPOOL_LONG (jcf
, index
));
482 /* In a compiled program the constant pool is in native word
483 order. How weird is that??? */
485 index
= find_constant2 (cpool
, kind
,
486 JPOOL_INT (jcf
, index
),
487 JPOOL_INT (jcf
, index
+1));
489 index
= find_constant2 (cpool
, kind
,
490 JPOOL_INT (jcf
, index
+1),
491 JPOOL_INT (jcf
, index
));
496 /* Given a class file and an index into its constant pool, create an
497 entry in the outgoing constant pool for the same item. */
500 handle_constant (JCF
*jcf
, int index
, enum cpool_tag purpose
)
503 CPool
*cpool
= cpool_for_class (output_class
);
508 if (! CPOOL_INDEX_IN_RANGE (&jcf
->cpool
, index
))
509 error ("<constant pool index %d not in range>", index
);
511 kind
= JPOOL_TAG (jcf
, index
);
513 if ((kind
& ~CONSTANT_ResolvedFlag
) != purpose
)
515 if (purpose
== CONSTANT_Class
516 && kind
== CONSTANT_Utf8
)
519 error ("<constant pool index %d unexpected type", index
);
525 case CONSTANT_ResolvedClass
:
527 /* For some reason I know not the what of, class names in
528 annotations are UTF-8 strings in the constant pool but
529 class names in EnclosingMethod attributes are real class
530 references. Set CONSTANT_LazyFlag here so that the VM
531 doesn't attempt to resolve them at class initialization
533 tree resolved_class
, class_name
;
534 resolved_class
= get_class_constant (jcf
, index
);
535 class_name
= build_internal_class_name (resolved_class
);
536 index
= alloc_name_constant (CONSTANT_Class
| CONSTANT_LazyFlag
,
538 (IDENTIFIER_POINTER(class_name
),
539 IDENTIFIER_LENGTH(class_name
))));
544 tree utf8
= get_constant (jcf
, index
);
545 if (purpose
== CONSTANT_Class
)
546 /* Create a constant pool entry for a type signature. This
547 one has '.' rather than '/' because it isn't going into a
548 class file, it's going into a compiled object.
550 This has to match the logic in
551 _Jv_ClassReader::prepare_pool_entry(). */
552 utf8
= unmangle_classname (IDENTIFIER_POINTER(utf8
),
553 IDENTIFIER_LENGTH(utf8
));
554 index
= alloc_name_constant (kind
, utf8
);
559 index
= handle_long_constant (jcf
, cpool
, CONSTANT_Long
, index
,
563 case CONSTANT_Double
:
564 index
= handle_long_constant (jcf
, cpool
, CONSTANT_Double
, index
,
565 FLOAT_WORDS_BIG_ENDIAN
);
569 case CONSTANT_Integer
:
570 index
= find_constant1 (cpool
, kind
, JPOOL_INT (jcf
, index
));
573 case CONSTANT_NameAndType
:
575 uint16 name
= JPOOL_USHORT1 (jcf
, index
);
576 uint16 sig
= JPOOL_USHORT2 (jcf
, index
);
577 uint32 name_index
= handle_constant (jcf
, name
, CONSTANT_Utf8
);
578 uint32 sig_index
= handle_constant (jcf
, sig
, CONSTANT_Class
);
579 jword new_index
= (name_index
<< 16) | sig_index
;
580 index
= find_constant1 (cpool
, kind
, new_index
);
591 /* Read an element_value structure from an annotation in JCF. Return
592 the constant pool index for the resulting constant pool entry. */
595 handle_element_value (JCF
*jcf
, int level
)
597 uint8 tag
= JCF_readu (jcf
);
600 annotation_write_byte (tag
);
609 uint16 cindex
= JCF_readu2 (jcf
);
610 index
= handle_constant (jcf
, cindex
,
612 annotation_write_short (index
);
617 uint16 cindex
= JCF_readu2 (jcf
);
618 index
= handle_constant (jcf
, cindex
,
620 annotation_write_short (index
);
625 uint16 cindex
= JCF_readu2 (jcf
);
626 index
= handle_constant (jcf
, cindex
,
628 annotation_write_short (index
);
633 uint16 cindex
= JCF_readu2 (jcf
);
634 index
= handle_constant (jcf
, cindex
,
636 annotation_write_short (index
);
641 uint16 cindex
= JCF_readu2 (jcf
);
642 /* Despite what the JVM spec says, compilers generate a Utf8
643 constant here, not a String. */
644 index
= handle_constant (jcf
, cindex
,
646 annotation_write_short (index
);
652 uint16 type_name_index
= JCF_readu2 (jcf
);
653 uint16 const_name_index
= JCF_readu2 (jcf
);
654 index
= handle_constant (jcf
, type_name_index
,
656 annotation_write_short (index
);
657 index
= handle_constant (jcf
, const_name_index
,
659 annotation_write_short (index
);
664 uint16 class_info_index
= JCF_readu2 (jcf
);
665 index
= handle_constant (jcf
, class_info_index
,
667 annotation_write_short (index
);
672 handle_annotation (jcf
, level
+ 1);
677 uint16 n_array_elts
= JCF_readu2 (jcf
);
678 annotation_write_short (n_array_elts
);
679 while (n_array_elts
--)
680 handle_element_value (jcf
, level
+ 1);
690 /* Read an annotation structure from JCF. Write it to the
691 reflection_data field of the outgoing class. */
694 handle_annotation (JCF
*jcf
, int level
)
696 uint16 type_index
= JCF_readu2 (jcf
);
697 uint16 npairs
= JCF_readu2 (jcf
);
698 int index
= handle_constant (jcf
, type_index
,
700 annotation_write_short (index
);
701 annotation_write_short (npairs
);
704 uint16 name_index
= JCF_readu2 (jcf
);
705 index
= handle_constant (jcf
, name_index
,
707 annotation_write_short (index
);
708 handle_element_value (jcf
, level
+ 2);
712 /* Read an annotation count from JCF, and write the following
713 annotations to the reflection_data field of the outgoing class. */
716 handle_annotations (JCF
*jcf
, int level
)
718 uint16 num
= JCF_readu2 (jcf
);
719 annotation_write_short (num
);
721 handle_annotation (jcf
, level
);
724 /* As handle_annotations(), but perform a sanity check that we write
725 the same number of bytes that we were expecting. */
728 handle_annotation_attribute (int ATTRIBUTE_UNUSED index
, JCF
*jcf
,
731 long old_datasize
= TYPE_REFLECTION_DATASIZE (current_class
);
733 handle_annotations (jcf
, 0);
735 gcc_assert (old_datasize
+ length
736 == TYPE_REFLECTION_DATASIZE (current_class
));
739 /* gcj permutes its fields array after generating annotation_data, so
740 we have to fixup field indexes for fields that have moved. Given
741 ARG, a VEC_int, fixup the field indexes in the reflection_data of
742 the outgoing class. We use field_offsets to tell us where the
746 rewrite_reflection_indexes (void *arg
)
750 VEC(int, heap
) *map
= (VEC(int, heap
) *) arg
;
751 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
755 EXECUTE_IF_SET_IN_BITMAP (field_offsets
, 0, offset
, bi
)
757 uint16 index
= annotation_read_short (data
+ offset
);
758 annotation_rewrite_short
759 (VEC_index (int, map
, index
), data
+ offset
);
764 /* Read the RuntimeVisibleAnnotations from JCF and write them to the
765 reflection_data of the outgoing class. */
768 handle_member_annotations (int member_index
, JCF
*jcf
,
769 const unsigned char *name ATTRIBUTE_UNUSED
,
770 long len
, jv_attr_type member_type
)
772 int new_len
= len
+ 1;
773 annotation_write_byte (member_type
);
774 if (member_type
!= JV_CLASS_ATTR
)
776 annotation_write_int (new_len
);
777 annotation_write_byte (JV_ANNOTATIONS_KIND
);
778 if (member_type
== JV_FIELD_ATTR
)
779 bitmap_set_bit (field_offsets
, TYPE_REFLECTION_DATASIZE (current_class
));
780 if (member_type
!= JV_CLASS_ATTR
)
781 annotation_write_short (member_index
);
782 handle_annotation_attribute (member_index
, jcf
, len
);
785 /* Read the RuntimeVisibleParameterAnnotations from JCF and write them
786 to the reflection_data of the outgoing class. */
789 handle_parameter_annotations (int member_index
, JCF
*jcf
,
790 const unsigned char *name ATTRIBUTE_UNUSED
,
791 long len
, jv_attr_type member_type
)
793 int new_len
= len
+ 1;
795 annotation_write_byte (member_type
);
796 if (member_type
!= JV_CLASS_ATTR
)
798 annotation_write_int (new_len
);
799 annotation_write_byte (JV_PARAMETER_ANNOTATIONS_KIND
);
800 if (member_type
!= JV_CLASS_ATTR
)
801 annotation_write_short (member_index
);
802 num
= JCF_readu (jcf
);
803 annotation_write_byte (num
);
805 handle_annotations (jcf
, 0);
809 /* Read the AnnotationDefault data from JCF and write them to the
810 reflection_data of the outgoing class. */
813 handle_default_annotation (int member_index
, JCF
*jcf
,
814 const unsigned char *name ATTRIBUTE_UNUSED
,
815 long len
, jv_attr_type member_type
)
817 int new_len
= len
+ 1;
818 annotation_write_byte (member_type
);
819 if (member_type
!= JV_CLASS_ATTR
)
821 annotation_write_int (new_len
);
822 annotation_write_byte (JV_ANNOTATION_DEFAULT_KIND
);
823 if (member_type
!= JV_CLASS_ATTR
)
824 annotation_write_short (member_index
);
825 handle_element_value (jcf
, 0);
828 /* As above, for the EnclosingMethod attribute. */
831 handle_enclosingmethod_attribute (int member_index
, JCF
*jcf
,
832 const unsigned char *name ATTRIBUTE_UNUSED
,
833 long len
, jv_attr_type member_type
)
835 int new_len
= len
+ 1;
837 annotation_write_byte (member_type
);
838 if (member_type
!= JV_CLASS_ATTR
)
840 annotation_write_int (new_len
);
841 annotation_write_byte (JV_ENCLOSING_METHOD_KIND
);
842 if (member_type
!= JV_CLASS_ATTR
)
843 annotation_write_short (member_index
);
845 index
= JCF_readu2 (jcf
);
846 index
= handle_constant (jcf
, index
, CONSTANT_Class
);
847 annotation_write_short (index
);
849 index
= JCF_readu2 (jcf
);
850 index
= handle_constant (jcf
, index
, CONSTANT_NameAndType
);
851 annotation_write_short (index
);
854 /* As above, for the Signature attribute. */
857 handle_signature_attribute (int member_index
, JCF
*jcf
,
858 const unsigned char *name ATTRIBUTE_UNUSED
,
859 long len
, jv_attr_type member_type
)
861 int new_len
= len
+ 1;
863 annotation_write_byte (member_type
);
864 if (member_type
!= JV_CLASS_ATTR
)
866 annotation_write_int (new_len
);
867 annotation_write_byte (JV_SIGNATURE_KIND
);
868 if (member_type
!= JV_CLASS_ATTR
)
869 annotation_write_short (member_index
);
871 index
= JCF_readu2 (jcf
);
872 index
= handle_constant (jcf
, index
, CONSTANT_Utf8
);
873 annotation_write_short (index
);
878 #define HANDLE_SOURCEFILE(INDEX) set_source_filename (jcf, INDEX)
880 #define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
881 { tree super_class = SUPER==0 ? NULL_TREE : get_class_constant (jcf, SUPER); \
882 output_class = current_class = give_name_to_class (jcf, THIS); \
883 set_super_info (ACCESS_FLAGS, current_class, super_class, INTERFACES_COUNT);}
885 #define HANDLE_CLASS_INTERFACE(INDEX) \
886 add_interface (current_class, get_class_constant (jcf, INDEX))
888 #define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
889 { int sig_index = SIGNATURE; \
890 current_field = add_field (current_class, get_name_constant (jcf, NAME), \
891 parse_signature (jcf, sig_index), ACCESS_FLAGS); \
892 set_java_signature (TREE_TYPE (current_field), JPOOL_UTF (jcf, sig_index)); \
893 if ((ACCESS_FLAGS) & ACC_FINAL) \
894 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (current_field); \
897 #define HANDLE_END_FIELDS() \
898 (current_field = NULL_TREE)
900 #define HANDLE_CONSTANTVALUE(INDEX) \
901 { tree constant; int index = INDEX; \
902 if (JPOOL_TAG (jcf, index) == CONSTANT_String) { \
903 tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index)); \
904 constant = build_utf8_ref (name); \
907 constant = get_constant (jcf, index); \
908 set_constant_value (current_field, constant); }
910 #define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
911 (current_method = add_method (current_class, ACCESS_FLAGS, \
912 get_name_constant (jcf, NAME), \
913 get_name_constant (jcf, SIGNATURE)), \
914 DECL_LOCALVARIABLES_OFFSET (current_method) = 0, \
915 DECL_LINENUMBERS_OFFSET (current_method) = 0)
917 #define HANDLE_END_METHODS() \
918 { current_method = NULL_TREE; }
920 #define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
921 { DECL_MAX_STACK (current_method) = (MAX_STACK); \
922 DECL_MAX_LOCALS (current_method) = (MAX_LOCALS); \
923 DECL_CODE_LENGTH (current_method) = (CODE_LENGTH); \
924 DECL_CODE_OFFSET (current_method) = JCF_TELL (jcf); }
926 #define HANDLE_LOCALVARIABLETABLE_ATTRIBUTE(COUNT) \
928 DECL_LOCALVARIABLES_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
929 JCF_SKIP (jcf, n * 10); }
931 #define HANDLE_LINENUMBERTABLE_ATTRIBUTE(COUNT) \
933 DECL_LINENUMBERS_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
934 JCF_SKIP (jcf, n * 4); }
936 #define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
939 VEC (tree,gc) *v = VEC_alloc (tree, gc, n); \
940 gcc_assert (DECL_FUNCTION_THROWS (current_method) == NULL); \
943 tree thrown_class = get_class_constant (jcf, JCF_readu2 (jcf)); \
944 VEC_quick_push (tree, v, thrown_class); \
946 DECL_FUNCTION_THROWS (current_method) = v; \
949 #define HANDLE_DEPRECATED_ATTRIBUTE() handle_deprecated ()
951 /* Link seen inner classes to their outer context and register the
952 inner class to its outer context. They will be later loaded. */
953 #define HANDLE_INNERCLASSES_ATTRIBUTE(COUNT) \
954 handle_innerclass_attribute (COUNT, jcf, attribute_length)
956 #define HANDLE_SYNTHETIC_ATTRIBUTE() \
958 /* Irrelevant decls should have been nullified by the END macros. \
959 DECL_ARTIFICIAL on fields is used for something else (See \
960 PUSH_FIELD in java-tree.h) */ \
961 if (current_method) \
962 DECL_ARTIFICIAL (current_method) = 1; \
963 else if (current_field) \
964 FIELD_SYNTHETIC (current_field) = 1; \
966 TYPE_SYNTHETIC (current_class) = 1; \
969 #define HANDLE_GCJCOMPILED_ATTRIBUTE() \
971 if (current_class == object_type_node) \
972 jcf->right_zip = 1; \
975 #define HANDLE_RUNTIMEVISIBLEANNOTATIONS_ATTRIBUTE() \
977 handle_member_annotations (index, jcf, name_data, attribute_length, attr_type); \
980 #define HANDLE_RUNTIMEINVISIBLEANNOTATIONS_ATTRIBUTE() \
982 JCF_SKIP(jcf, attribute_length); \
985 #define HANDLE_RUNTIMEVISIBLEPARAMETERANNOTATIONS_ATTRIBUTE() \
987 handle_parameter_annotations (index, jcf, name_data, attribute_length, attr_type); \
990 #define HANDLE_RUNTIMEINVISIBLEPARAMETERANNOTATIONS_ATTRIBUTE() \
992 JCF_SKIP(jcf, attribute_length); \
995 #define HANDLE_ANNOTATIONDEFAULT_ATTRIBUTE() \
997 handle_default_annotation (index, jcf, name_data, attribute_length, attr_type); \
1000 #define HANDLE_ENCLOSINGMETHOD_ATTRIBUTE() \
1002 handle_enclosingmethod_attribute (index, jcf, name_data, \
1003 attribute_length, attr_type); \
1006 #define HANDLE_SIGNATURE_ATTRIBUTE() \
1008 handle_signature_attribute (index, jcf, name_data, \
1009 attribute_length, attr_type); \
1012 #include "jcf-reader.c"
1015 parse_signature (JCF
*jcf
, int sig_index
)
1017 gcc_assert (sig_index
> 0
1018 && sig_index
< JPOOL_SIZE (jcf
)
1019 && JPOOL_TAG (jcf
, sig_index
) == CONSTANT_Utf8
);
1021 return parse_signature_string (JPOOL_UTF_DATA (jcf
, sig_index
),
1022 JPOOL_UTF_LENGTH (jcf
, sig_index
));
1026 get_constant (JCF
*jcf
, int index
)
1030 if (index
<= 0 || index
>= JPOOL_SIZE(jcf
))
1032 tag
= JPOOL_TAG (jcf
, index
);
1033 if ((tag
& CONSTANT_ResolvedFlag
) || tag
== CONSTANT_Utf8
)
1034 return jcf
->cpool
.data
[index
].t
;
1037 case CONSTANT_Integer
:
1039 jint num
= JPOOL_INT(jcf
, index
);
1040 value
= build_int_cst (int_type_node
, num
);
1045 unsigned HOST_WIDE_INT num
;
1048 num
= JPOOL_UINT (jcf
, index
);
1049 val
= double_int_lshift (uhwi_to_double_int (num
), 32, 64, false);
1050 num
= JPOOL_UINT (jcf
, index
+ 1);
1051 val
= double_int_ior (val
, uhwi_to_double_int (num
));
1053 value
= double_int_to_tree (long_type_node
, val
);
1057 case CONSTANT_Float
:
1059 jint num
= JPOOL_INT(jcf
, index
);
1063 real_from_target_fmt (&d
, &buf
, &ieee_single_format
);
1064 value
= build_real (float_type_node
, d
);
1068 case CONSTANT_Double
:
1070 long buf
[2], lo
, hi
;
1073 hi
= JPOOL_UINT (jcf
, index
);
1074 lo
= JPOOL_UINT (jcf
, index
+1);
1076 if (FLOAT_WORDS_BIG_ENDIAN
)
1077 buf
[0] = hi
, buf
[1] = lo
;
1079 buf
[0] = lo
, buf
[1] = hi
;
1081 real_from_target_fmt (&d
, buf
, &ieee_double_format
);
1082 value
= build_real (double_type_node
, d
);
1086 case CONSTANT_String
:
1088 tree name
= get_name_constant (jcf
, JPOOL_USHORT1 (jcf
, index
));
1089 const char *utf8_ptr
= IDENTIFIER_POINTER (name
);
1090 int utf8_len
= IDENTIFIER_LENGTH (name
);
1091 const unsigned char *utf8
;
1094 /* Check for a malformed Utf8 string. */
1095 utf8
= (const unsigned char *) utf8_ptr
;
1099 int char_len
= UT8_CHAR_LENGTH (*utf8
);
1100 if (char_len
< 0 || char_len
> 3 || char_len
> i
)
1101 fatal_error ("bad string constant");
1107 /* Allocate a new string value. */
1108 value
= build_string (utf8_len
, utf8_ptr
);
1109 TREE_TYPE (value
) = build_pointer_type (string_type_node
);
1115 JPOOL_TAG (jcf
, index
) = tag
| CONSTANT_ResolvedFlag
;
1116 jcf
->cpool
.data
[index
].t
= value
;
1119 internal_error ("bad value constant type %d, index %d",
1120 JPOOL_TAG (jcf
, index
), index
);
1124 get_name_constant (JCF
*jcf
, int index
)
1126 tree name
= get_constant (jcf
, index
);
1127 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1131 /* Handle reading innerclass attributes. If a nonzero entry (denoting
1132 a non anonymous entry) is found, We augment the inner class list of
1133 the outer context with the newly resolved innerclass. */
1136 handle_innerclass_attribute (int count
, JCF
*jcf
, int attribute_length
)
1140 annotation_write_byte (JV_CLASS_ATTR
);
1141 annotation_write_int (attribute_length
+1);
1142 annotation_write_byte (JV_INNER_CLASSES_KIND
);
1143 annotation_write_short (count
);
1147 /* Read inner_class_info_index. This may be 0 */
1148 int icii
= JCF_readu2 (jcf
);
1149 /* Read outer_class_info_index. If the innerclasses attribute
1150 entry isn't a member (like an inner class) the value is 0. */
1151 int ocii
= JCF_readu2 (jcf
);
1152 /* Read inner_name_index. If the class we're dealing with is
1153 an anonymous class, it must be 0. */
1154 int ini
= JCF_readu2 (jcf
);
1155 /* Read the access flag. */
1156 int acc
= JCF_readu2 (jcf
);
1158 annotation_write_short (handle_constant (jcf
, icii
, CONSTANT_Class
));
1159 annotation_write_short (handle_constant (jcf
, ocii
, CONSTANT_Class
));
1160 annotation_write_short (handle_constant (jcf
, ini
, CONSTANT_Utf8
));
1161 annotation_write_short (acc
);
1163 /* If icii is 0, don't try to read the class. */
1166 tree klass
= get_class_constant (jcf
, icii
);
1167 tree decl
= TYPE_NAME (klass
);
1168 /* Skip reading further if ocii is null */
1169 if (DECL_P (decl
) && !CLASS_COMPLETE_P (decl
) && ocii
)
1171 tree outer
= TYPE_NAME (get_class_constant (jcf
, ocii
));
1172 tree alias
= (ini
? get_name_constant (jcf
, ini
) : NULL_TREE
);
1173 set_class_decl_access_flags (acc
, decl
);
1174 DECL_CONTEXT (decl
) = outer
;
1175 DECL_INNER_CLASS_LIST (outer
) =
1176 tree_cons (decl
, alias
, DECL_INNER_CLASS_LIST (outer
));
1177 CLASS_COMPLETE_P (decl
) = 1;
1184 give_name_to_class (JCF
*jcf
, int i
)
1187 && i
< JPOOL_SIZE (jcf
)
1188 && JPOOL_TAG (jcf
, i
) == CONSTANT_Class
);
1191 tree package_name
= NULL_TREE
, tmp
;
1193 int j
= JPOOL_USHORT1 (jcf
, i
);
1194 /* verify_constant_pool confirmed that j is a CONSTANT_Utf8. */
1195 tree class_name
= unmangle_classname ((const char *) JPOOL_UTF_DATA (jcf
, j
),
1196 JPOOL_UTF_LENGTH (jcf
, j
));
1197 this_class
= lookup_class (class_name
);
1199 tree source_name
= identifier_subst (class_name
, "", '.', '/', ".java");
1200 const char *sfname
= find_sourcefile (IDENTIFIER_POINTER (source_name
));
1201 linemap_add (line_table
, LC_ENTER
, false, sfname
, 0);
1202 input_location
= linemap_line_start (line_table
, 0, 1);
1203 file_start_location
= input_location
;
1204 DECL_SOURCE_LOCATION (TYPE_NAME (this_class
)) = input_location
;
1205 if (main_input_filename
== NULL
&& jcf
== main_jcf
)
1206 main_input_filename
= sfname
;
1209 jcf
->cpool
.data
[i
].t
= this_class
;
1210 JPOOL_TAG (jcf
, i
) = CONSTANT_ResolvedClass
;
1211 split_qualified_name (&package_name
, &tmp
,
1212 DECL_NAME (TYPE_NAME (this_class
)));
1213 TYPE_PACKAGE (this_class
) = package_name
;
1218 /* Get the class of the CONSTANT_Class whose constant pool index is I. */
1221 get_class_constant (JCF
*jcf
, int i
)
1225 && i
< JPOOL_SIZE (jcf
)
1226 && (JPOOL_TAG (jcf
, i
) & ~CONSTANT_ResolvedFlag
) == CONSTANT_Class
);
1228 if (JPOOL_TAG (jcf
, i
) != CONSTANT_ResolvedClass
)
1230 int name_index
= JPOOL_USHORT1 (jcf
, i
);
1231 /* verify_constant_pool confirmed that name_index is a CONSTANT_Utf8. */
1232 const char *name
= (const char *) JPOOL_UTF_DATA (jcf
, name_index
);
1233 int nlength
= JPOOL_UTF_LENGTH (jcf
, name_index
);
1235 if (name
[0] == '[') /* Handle array "classes". */
1236 type
= TREE_TYPE (parse_signature_string ((const unsigned char *) name
, nlength
));
1239 tree cname
= unmangle_classname (name
, nlength
);
1240 type
= lookup_class (cname
);
1242 jcf
->cpool
.data
[i
].t
= type
;
1243 JPOOL_TAG (jcf
, i
) = CONSTANT_ResolvedClass
;
1246 type
= jcf
->cpool
.data
[i
].t
;
1250 /* Read a class with the fully qualified-name NAME.
1251 Return 1 iff we read the requested file.
1252 (It is still possible we failed if the file did not
1253 define the class it is supposed to.) */
1256 read_class (tree name
)
1259 tree icv
, klass
= NULL_TREE
;
1260 tree save_current_class
= current_class
;
1261 tree save_output_class
= output_class
;
1262 location_t save_location
= input_location
;
1263 JCF
*save_current_jcf
= current_jcf
;
1265 if ((icv
= IDENTIFIER_CLASS_VALUE (name
)) != NULL_TREE
)
1267 klass
= TREE_TYPE (icv
);
1268 jcf
= TYPE_JCF (klass
);
1275 const char* path_name
;
1276 this_jcf
.zipd
= NULL
;
1279 path_name
= find_class (IDENTIFIER_POINTER (name
),
1280 IDENTIFIER_LENGTH (name
),
1285 free(CONST_CAST (char *, path_name
));
1290 if (klass
== NULL_TREE
|| ! CLASS_PARSED_P (klass
))
1292 output_class
= current_class
= klass
;
1293 if (JCF_SEEN_IN_ZIP (current_jcf
))
1294 read_zip_member(current_jcf
,
1295 current_jcf
->zipd
, current_jcf
->zipd
->zipf
);
1296 jcf_parse (current_jcf
);
1297 /* Parsing might change the class, in which case we have to
1298 put it back where we found it. */
1299 if (current_class
!= klass
&& icv
!= NULL_TREE
)
1300 TREE_TYPE (icv
) = current_class
;
1301 klass
= current_class
;
1303 layout_class (klass
);
1304 load_inner_classes (klass
);
1306 output_class
= save_output_class
;
1307 current_class
= save_current_class
;
1308 input_location
= save_location
;
1309 current_jcf
= save_current_jcf
;
1313 /* Load CLASS_OR_NAME. CLASS_OR_NAME can be a mere identifier if
1314 called from the parser, otherwise it's a RECORD_TYPE node. If
1315 VERBOSE is 1, print error message on failure to load a class. */
1317 load_class (tree class_or_name
, int verbose
)
1320 int class_loaded
= 0;
1321 tree class_decl
= NULL_TREE
;
1322 bool is_compiled_class
= false;
1324 /* We've already failed, don't try again. */
1325 if (TREE_CODE (class_or_name
) == RECORD_TYPE
1326 && TYPE_DUMMY (class_or_name
))
1329 /* class_or_name can be the name of the class we want to load */
1330 if (TREE_CODE (class_or_name
) == IDENTIFIER_NODE
)
1331 name
= class_or_name
;
1332 /* In some cases, it's a dependency that we process earlier that
1334 else if (TREE_CODE (class_or_name
) == TREE_LIST
)
1335 name
= TYPE_NAME (TREE_PURPOSE (class_or_name
));
1336 /* Or it's a type in the making */
1338 name
= DECL_NAME (TYPE_NAME (class_or_name
));
1340 class_decl
= IDENTIFIER_CLASS_VALUE (name
);
1341 if (class_decl
!= NULL_TREE
)
1343 tree type
= TREE_TYPE (class_decl
);
1345 = ((TYPE_JCF (type
) && JCF_SEEN_IN_ZIP (TYPE_JCF (type
)))
1346 || CLASS_FROM_CURRENTLY_COMPILED_P (type
));
1351 /* If flag_verify_invocations is unset, we don't try to load a class
1352 unless we're looking for Object (which is fixed by the ABI) or
1353 it's a class that we're going to compile. */
1354 if (flag_verify_invocations
1355 || class_or_name
== object_type_node
1356 || is_compiled_class
1357 || TREE_CODE (class_or_name
) == IDENTIFIER_NODE
)
1361 const char *separator
;
1363 /* We've already loaded it. */
1364 if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
)
1366 tree tmp_decl
= IDENTIFIER_CLASS_VALUE (name
);
1367 if (CLASS_PARSED_P (TREE_TYPE (tmp_decl
)))
1371 if (read_class (name
))
1374 /* We failed loading name. Now consider that we might be looking
1375 for an inner class. */
1376 if ((separator
= strrchr (IDENTIFIER_POINTER (name
), '$'))
1377 || (separator
= strrchr (IDENTIFIER_POINTER (name
), '.')))
1378 name
= get_identifier_with_length (IDENTIFIER_POINTER (name
),
1380 - IDENTIFIER_POINTER (name
)));
1381 /* Otherwise, we failed, we bail. */
1387 /* have we found the class we're looking for? */
1388 tree type_decl
= IDENTIFIER_CLASS_VALUE (saved
);
1389 tree type
= type_decl
? TREE_TYPE (type_decl
) : NULL
;
1390 class_loaded
= type
&& CLASS_PARSED_P (type
);
1396 if (flag_verify_invocations
|| ! flag_indirect_dispatch
)
1399 error ("cannot find file for class %s", IDENTIFIER_POINTER (saved
));
1403 /* This is just a diagnostic during testing, not a real problem. */
1405 warning (0, "cannot find file for class %s",
1406 IDENTIFIER_POINTER (saved
));
1409 if (TREE_CODE (class_or_name
) == RECORD_TYPE
)
1411 set_super_info (0, class_or_name
, object_type_node
, 0);
1412 TYPE_DUMMY (class_or_name
) = 1;
1413 /* We won't be able to output any debug info for this class. */
1414 DECL_IGNORED_P (TYPE_NAME (class_or_name
)) = 1;
1420 /* Parse the .class file JCF. */
1423 jcf_parse (JCF
* jcf
)
1427 bitmap_clear (field_offsets
);
1429 if (jcf_parse_preamble (jcf
) != 0)
1430 fatal_error ("not a valid Java .class file");
1431 code
= jcf_parse_constant_pool (jcf
);
1433 fatal_error ("error while parsing constant pool");
1434 code
= verify_constant_pool (jcf
);
1436 fatal_error ("error in constant pool entry #%d\n", code
);
1438 jcf_parse_class (jcf
);
1439 if (main_class
== NULL_TREE
)
1440 main_class
= current_class
;
1441 if (! quiet_flag
&& TYPE_NAME (current_class
))
1442 fprintf (stderr
, " %s %s",
1443 (jcf
->access_flags
& ACC_INTERFACE
) ? "interface" : "class",
1444 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class
))));
1445 if (CLASS_PARSED_P (current_class
))
1447 /* FIXME - where was first time */
1448 fatal_error ("reading class %s for the second time from %s",
1449 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class
))),
1452 CLASS_PARSED_P (current_class
) = 1;
1454 for (i
= 1; i
< JPOOL_SIZE(jcf
); i
++)
1456 switch (JPOOL_TAG (jcf
, i
))
1458 case CONSTANT_Class
:
1459 get_class_constant (jcf
, i
);
1464 code
= jcf_parse_fields (jcf
);
1466 fatal_error ("error while parsing fields");
1467 code
= jcf_parse_methods (jcf
);
1469 fatal_error ("error while parsing methods");
1470 code
= jcf_parse_final_attributes (jcf
);
1472 fatal_error ("error while parsing final attributes");
1474 if (TYPE_REFLECTION_DATA (current_class
))
1475 annotation_write_byte (JV_DONE_ATTR
);
1477 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1479 /* The fields of class_type_node are already in correct order. */
1480 if (current_class
!= class_type_node
&& current_class
!= object_type_node
)
1481 TYPE_FIELDS (current_class
) = nreverse (TYPE_FIELDS (current_class
));
1483 if (current_class
== object_type_node
)
1484 layout_class_methods (object_type_node
);
1486 VEC_safe_push (tree
, gc
, all_class_list
, TYPE_NAME (current_class
));
1489 /* If we came across inner classes, load them now. */
1491 load_inner_classes (tree cur_class
)
1494 for (current
= DECL_INNER_CLASS_LIST (TYPE_NAME (cur_class
)); current
;
1495 current
= TREE_CHAIN (current
))
1497 tree name
= DECL_NAME (TREE_PURPOSE (current
));
1498 tree decl
= IDENTIFIER_GLOBAL_VALUE (name
);
1499 if (decl
&& ! CLASS_LOADED_P (TREE_TYPE (decl
))
1500 && !CLASS_BEING_LAIDOUT (TREE_TYPE (decl
)))
1501 load_class (name
, 1);
1506 duplicate_class_warning (const char *filename
)
1508 location_t warn_loc
;
1509 linemap_add (line_table
, LC_RENAME
, 0, filename
, 0);
1510 warn_loc
= linemap_line_start (line_table
, 0, 1);
1511 warning_at (warn_loc
, 0, "duplicate class will only be compiled once");
1515 java_layout_seen_class_methods (void)
1518 unsigned end
= VEC_length (tree
, all_class_list
);
1523 unsigned new_length
;
1525 for (ix
= start
; ix
!= end
; ix
++)
1527 tree decl
= VEC_index (tree
, all_class_list
, ix
);
1528 tree cls
= TREE_TYPE (decl
);
1530 input_location
= DECL_SOURCE_LOCATION (decl
);
1532 if (! CLASS_LOADED_P (cls
))
1533 load_class (cls
, 0);
1535 layout_class_methods (cls
);
1538 /* Note that new classes might have been added while laying out
1539 methods, changing the value of all_class_list. */
1540 new_length
= VEC_length (tree
, all_class_list
);
1541 if (end
!= new_length
)
1552 parse_class_file (void)
1555 location_t save_location
= input_location
;
1557 java_layout_seen_class_methods ();
1559 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (current_class
));
1561 /* Re-enter the current file. */
1562 expanded_location loc
= expand_location (input_location
);
1563 linemap_add (line_table
, LC_ENTER
, 0, loc
.file
, loc
.line
);
1565 file_start_location
= input_location
;
1566 (*debug_hooks
->start_source_file
) (input_line
, input_filename
);
1568 java_mark_class_local (current_class
);
1570 gen_indirect_dispatch_tables (current_class
);
1572 for (method
= TYPE_METHODS (current_class
);
1573 method
!= NULL_TREE
; method
= TREE_CHAIN (method
))
1575 JCF
*jcf
= current_jcf
;
1577 if (METHOD_ABSTRACT (method
) || METHOD_DUMMY (method
))
1580 if (METHOD_NATIVE (method
))
1583 int decl_max_locals
;
1587 /* We need to compute the DECL_MAX_LOCALS. We need to take
1588 the wide types into account too. */
1589 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (method
)), decl_max_locals
= 0;
1590 arg
!= end_params_node
;
1591 arg
= TREE_CHAIN (arg
), decl_max_locals
+= 1)
1593 if (TREE_VALUE (arg
) && TYPE_IS_WIDE (TREE_VALUE (arg
)))
1594 decl_max_locals
+= 1;
1596 DECL_MAX_LOCALS (method
) = decl_max_locals
;
1597 start_java_method (method
);
1598 give_name_to_locals (jcf
);
1599 *get_stmts () = build_jni_stub (method
);
1604 if (DECL_CODE_OFFSET (method
) == 0)
1606 current_function_decl
= method
;
1607 error ("missing Code attribute");
1611 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (current_class
));
1612 if (DECL_LINENUMBERS_OFFSET (method
))
1617 JCF_SEEK (jcf
, DECL_LINENUMBERS_OFFSET (method
));
1618 linenumber_count
= i
= JCF_readu2 (jcf
);
1619 linenumber_table
= ptr
= jcf
->read_ptr
;
1621 for (ptr
+= 2; --i
>= 0; ptr
+= 4)
1623 int line
= GET_u2 (ptr
);
1624 /* Set initial input_line to smallest linenumber.
1625 * Needs to be set before init_function_start. */
1626 if (min_line
== 0 || line
< min_line
)
1630 input_location
= linemap_line_start (line_table
, min_line
, 1);
1634 linenumber_table
= NULL
;
1635 linenumber_count
= 0;
1638 start_java_method (method
);
1640 note_instructions (jcf
, method
);
1642 give_name_to_locals (jcf
);
1644 /* Bump up start_label_pc_this_method so we get a unique label number
1645 and reset highest_label_pc_this_method. */
1646 if (highest_label_pc_this_method
>= 0)
1648 /* We adjust to the next multiple of 1000. This is just a frill
1649 so the last 3 digits of the label number match the bytecode
1650 offset, which might make debugging marginally more convenient. */
1651 start_label_pc_this_method
1652 = ((((start_label_pc_this_method
+ highest_label_pc_this_method
)
1656 highest_label_pc_this_method
= -1;
1659 /* Convert bytecode to trees. */
1660 expand_byte_code (jcf
, method
);
1667 (*debug_hooks
->end_source_file
) (LOCATION_LINE (save_location
));
1668 input_location
= save_location
;
1671 static VEC(tree
,gc
) *predefined_filenames
;
1674 add_predefined_file (tree name
)
1676 VEC_safe_push (tree
, gc
, predefined_filenames
, name
);
1680 predefined_filename_p (tree node
)
1685 for (ix
= 0; VEC_iterate (tree
, predefined_filenames
, ix
, f
); ix
++)
1692 /* Generate a function that does all static initialization for this
1693 translation unit. */
1696 java_emit_static_constructor (void)
1700 emit_register_classes (&body
);
1701 write_resource_constructor (&body
);
1705 tree name
= get_identifier ("_Jv_global_static_constructor");
1708 = build_decl (input_location
, FUNCTION_DECL
, name
,
1709 build_function_type (void_type_node
, void_list_node
));
1711 tree resdecl
= build_decl (input_location
,
1712 RESULT_DECL
, NULL_TREE
, void_type_node
);
1713 DECL_ARTIFICIAL (resdecl
) = 1;
1714 DECL_RESULT (decl
) = resdecl
;
1715 current_function_decl
= decl
;
1716 allocate_struct_function (decl
, false);
1718 TREE_STATIC (decl
) = 1;
1719 TREE_USED (decl
) = 1;
1720 DECL_ARTIFICIAL (decl
) = 1;
1721 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1722 DECL_SAVED_TREE (decl
) = body
;
1723 DECL_UNINLINABLE (decl
) = 1;
1725 DECL_INITIAL (decl
) = make_node (BLOCK
);
1726 TREE_USED (DECL_INITIAL (decl
)) = 1;
1728 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1729 java_genericize (decl
);
1730 cgraph_finalize_function (decl
, false);
1736 java_parse_file (int set_yydebug ATTRIBUTE_UNUSED
)
1738 int filename_count
= 0;
1739 location_t save_location
= input_location
;
1740 char *file_list
= NULL
, *list
, *next
;
1742 FILE *finput
= NULL
;
1746 bitmap_obstack_initialize (&bit_obstack
);
1747 field_offsets
= BITMAP_ALLOC (&bit_obstack
);
1749 if (flag_filelist_file
)
1752 finput
= fopen (main_input_filename
, "r");
1754 fatal_error ("can't open %s: %m", input_filename
);
1755 list
= XNEWVEC (char, avail
);
1762 count
= next
- list
;
1763 avail
= 2 * (count
+ avail
);
1764 list
= XRESIZEVEC (char, list
, avail
);
1765 next
= list
+ count
;
1766 avail
= avail
- count
;
1768 /* Subtract to to guarantee space for final '\0'. */
1769 count
= fread (next
, 1, avail
- 1, finput
);
1772 if (! feof (finput
))
1773 fatal_error ("error closing %s: %m", input_filename
);
1785 list
= CONST_CAST (char *, main_input_filename
);
1789 for (next
= list
; ; )
1792 if (flag_filelist_file
&& ! in_quotes
1793 && (ch
== '\n' || ch
== '\r' || ch
== '\t' || ch
== ' '
1794 || ch
== '&') /* FIXME */)
1808 if (flag_filelist_file
&& ch
== '"')
1810 in_quotes
= ! in_quotes
;
1825 /* Exclude .java files. */
1826 if (strlen (list
) > 5 && ! strcmp (list
+ strlen (list
) - 5, ".java"))
1832 node
= get_identifier (list
);
1836 /* Exclude file that we see twice on the command line. */
1838 if (IS_A_COMMAND_LINE_FILENAME_P (node
))
1839 duplicate_class_warning (IDENTIFIER_POINTER (node
));
1842 tree file_decl
= build_decl (input_location
,
1843 TRANSLATION_UNIT_DECL
, node
, NULL
);
1844 VEC_safe_push (tree
, gc
, current_file_list
, file_decl
);
1845 IS_A_COMMAND_LINE_FILENAME_P (node
) = 1;
1851 if (file_list
!= NULL
)
1854 if (filename_count
== 0)
1855 warning (0, "no input file specified");
1859 const char *resource_filename
;
1861 /* Only one resource file may be compiled at a time. */
1862 assert (VEC_length (tree
, current_file_list
) == 1);
1864 resource_filename
= IDENTIFIER_POINTER (DECL_NAME (VEC_index (tree
, current_file_list
, 0)));
1865 compile_resource_file (resource_name
, resource_filename
);
1870 current_jcf
= main_jcf
;
1871 for (ix
= 0; VEC_iterate (tree
, current_file_list
, ix
, node
); ix
++)
1873 unsigned char magic_string
[4];
1876 tree name
= DECL_NAME (node
);
1878 const char *filename
= IDENTIFIER_POINTER (name
);
1880 /* Skip already parsed files */
1881 real_path
= lrealpath (filename
);
1882 real_file
= get_identifier (real_path
);
1884 if (HAS_BEEN_ALREADY_PARSED_P (real_file
))
1887 /* Close previous descriptor, if any */
1888 if (finput
&& fclose (finput
))
1889 fatal_error ("can't close input file %s: %m", main_input_filename
);
1891 finput
= fopen (filename
, "rb");
1893 fatal_error ("can't open %s: %m", filename
);
1895 #ifdef IO_BUFFER_SIZE
1896 setvbuf (finput
, xmalloc (IO_BUFFER_SIZE
),
1897 _IOFBF
, IO_BUFFER_SIZE
);
1900 /* Figure what kind of file we're dealing with */
1901 if (fread (magic_string
, 1, 4, finput
) == 4)
1903 fseek (finput
, 0L, SEEK_SET
);
1904 magic
= GET_u4 (magic_string
);
1906 if (magic
== 0xcafebabe)
1908 CLASS_FILE_P (node
) = 1;
1909 current_jcf
= ggc_alloc_cleared_JCF ();
1910 current_jcf
->read_state
= finput
;
1911 current_jcf
->filbuf
= jcf_filbuf_from_stdio
;
1912 jcf_parse (current_jcf
);
1913 DECL_SOURCE_LOCATION (node
) = file_start_location
;
1914 TYPE_JCF (current_class
) = current_jcf
;
1915 if (CLASS_FROM_CURRENTLY_COMPILED_P (current_class
))
1917 /* We've already compiled this class. */
1918 duplicate_class_warning (filename
);
1921 CLASS_FROM_CURRENTLY_COMPILED_P (current_class
) = 1;
1922 TREE_TYPE (node
) = current_class
;
1924 else if (magic
== (JCF_u4
)ZIPMAGIC
)
1926 main_jcf
= ggc_alloc_cleared_JCF ();
1927 main_jcf
->read_state
= finput
;
1928 main_jcf
->filbuf
= jcf_filbuf_from_stdio
;
1929 linemap_add (line_table
, LC_ENTER
, false, filename
, 0);
1930 input_location
= linemap_line_start (line_table
, 0, 1);
1931 if (open_in_zip (main_jcf
, filename
, NULL
, 0) < 0)
1932 fatal_error ("bad zip/jar file %s", filename
);
1933 localToFile
= SeenZipFiles
;
1934 /* Register all the classes defined there. */
1935 process_zip_dir ((FILE *) main_jcf
->read_state
);
1936 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1937 parse_zip_file_entries ();
1939 else if (magic
== (JCF_u4
) ZIPEMPTYMAGIC
)
1941 /* Ignore an empty input jar. */
1947 java_push_parser_context ();
1948 java_parser_context_save_global ();
1950 parse_source_file_1 (real_file
, filename
, finput
);
1951 java_parser_context_restore_global ();
1952 java_pop_parser_context (1);
1953 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1958 for (ix
= 0; VEC_iterate (tree
, current_file_list
, ix
, node
); ix
++)
1960 input_location
= DECL_SOURCE_LOCATION (node
);
1961 if (CLASS_FILE_P (node
))
1963 /* FIXME: These two flags really should be independent. We
1964 should be able to compile fully binary compatible, but
1965 with flag_verify_invocations on. */
1966 flag_verify_invocations
= ! flag_indirect_dispatch
;
1967 output_class
= current_class
= TREE_TYPE (node
);
1969 current_jcf
= TYPE_JCF (current_class
);
1970 layout_class (current_class
);
1971 load_inner_classes (current_class
);
1972 parse_class_file ();
1973 JCF_FINISH (current_jcf
);
1976 input_location
= save_location
;
1978 bitmap_obstack_release (&bit_obstack
);
1981 /* Arrange for any necessary initialization to happen. */
1982 java_emit_static_constructor ();
1983 gcc_assert (global_bindings_p ());
1987 /* Return the name of the class corresponding to the name of the file
1988 in this zip entry. The result is newly allocated using ALLOC. */
1990 compute_class_name (struct ZipDirectory
*zdir
)
1992 char *class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
1995 int filename_length
= zdir
->filename_length
;
1997 while (filename_length
> 2 && strncmp (class_name_in_zip_dir
, "./", 2) == 0)
1999 class_name_in_zip_dir
+= 2;
2000 filename_length
-= 2;
2003 filename_length
-= strlen (".class");
2004 class_name
= XNEWVEC (char, filename_length
+ 1);
2005 memcpy (class_name
, class_name_in_zip_dir
, filename_length
);
2006 class_name
[filename_length
] = '\0';
2008 for (i
= 0; i
< filename_length
; i
++)
2009 if (class_name
[i
] == '/')
2010 class_name
[i
] = '.';
2015 /* Return 0 if we should skip this entry, 1 if it is a .class file, 2
2016 if it is a property file of some sort. */
2018 classify_zip_file (struct ZipDirectory
*zdir
)
2020 char *class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2022 if (zdir
->filename_length
> 6
2023 && !strncmp (&class_name_in_zip_dir
[zdir
->filename_length
- 6],
2027 /* For now we drop the manifest, but not other information. */
2028 if (zdir
->filename_length
== 20
2029 && !strncmp (class_name_in_zip_dir
, "META-INF/MANIFEST.MF", 20))
2032 /* Drop directory entries. */
2033 if (zdir
->filename_length
> 0
2034 && class_name_in_zip_dir
[zdir
->filename_length
- 1] == '/')
2040 /* Process all class entries found in the zip file. */
2042 parse_zip_file_entries (void)
2044 struct ZipDirectory
*zdir
;
2047 for (i
= 0, zdir
= (ZipDirectory
*)localToFile
->central_directory
;
2048 i
< localToFile
->count
; i
++, zdir
= ZIPDIR_NEXT (zdir
))
2052 switch (classify_zip_file (zdir
))
2059 char *class_name
= compute_class_name (zdir
);
2060 int previous_alias_set
= -1;
2061 klass
= lookup_class (get_identifier (class_name
));
2063 current_jcf
= TYPE_JCF (klass
);
2064 output_class
= current_class
= klass
;
2066 /* This is a dummy class, and now we're compiling it for
2068 gcc_assert (! TYPE_DUMMY (klass
));
2070 /* This is for a corner case where we have a superclass
2071 but no superclass fields.
2073 This can happen if we earlier failed to lay out this
2074 class because its superclass was still in the process
2075 of being laid out; this occurs when we have recursive
2076 class dependencies via inner classes. We must record
2077 the previous alias set and restore it after laying out
2080 FIXME: this really is a kludge. We should figure out a
2081 way to lay out the class properly before this
2083 if (TYPE_SIZE (klass
) && CLASSTYPE_SUPER (klass
)
2084 && integer_zerop (TYPE_SIZE (klass
)))
2086 TYPE_SIZE (klass
) = NULL_TREE
;
2087 previous_alias_set
= TYPE_ALIAS_SET (klass
);
2088 TYPE_ALIAS_SET (klass
) = -1;
2091 if (! CLASS_LOADED_P (klass
))
2093 if (! CLASS_PARSED_P (klass
))
2095 read_zip_member (current_jcf
, zdir
, localToFile
);
2096 jcf_parse (current_jcf
);
2098 layout_class (current_class
);
2099 load_inner_classes (current_class
);
2102 if (previous_alias_set
!= -1)
2103 TYPE_ALIAS_SET (klass
) = previous_alias_set
;
2105 if (TYPE_SIZE (current_class
) != error_mark_node
)
2107 parse_class_file ();
2108 free (current_jcf
->buffer
); /* No longer necessary */
2109 /* Note: there is a way to free this buffer right after a
2110 class seen in a zip file has been parsed. The idea is the
2111 set its jcf in such a way that buffer will be reallocated
2112 the time the code for the class will be generated. FIXME. */
2119 char *file_name
, *class_name_in_zip_dir
, *buffer
;
2121 file_name
= XNEWVEC (char, zdir
->filename_length
+ 1);
2122 class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2123 strncpy (file_name
, class_name_in_zip_dir
, zdir
->filename_length
);
2124 file_name
[zdir
->filename_length
] = '\0';
2127 jcf
->read_state
= finput
;
2128 jcf
->filbuf
= jcf_filbuf_from_stdio
;
2129 jcf
->classname
= NULL
;
2130 jcf
->filename
= file_name
;
2133 if (read_zip_member (jcf
, zdir
, localToFile
) < 0)
2134 fatal_error ("error while reading %s from zip file", file_name
);
2136 buffer
= XNEWVEC (char, zdir
->filename_length
+ 1 +
2137 (jcf
->buffer_end
- jcf
->buffer
));
2138 strcpy (buffer
, file_name
);
2139 /* This is not a typo: we overwrite the trailing \0 of the
2140 file name; this is just how the data is laid out. */
2141 memcpy (buffer
+ zdir
->filename_length
,
2142 jcf
->buffer
, jcf
->buffer_end
- jcf
->buffer
);
2144 compile_resource_data (file_name
, buffer
,
2145 jcf
->buffer_end
- jcf
->buffer
);
2158 /* Read all the entries of the zip file, creates a class and a JCF. Sets the
2159 jcf up for further processing and link it to the created class. */
2162 process_zip_dir (FILE *finput
)
2167 for (i
= 0, zdir
= (ZipDirectory
*)localToFile
->central_directory
;
2168 i
< localToFile
->count
; i
++, zdir
= ZIPDIR_NEXT (zdir
))
2170 char *class_name
, *file_name
, *class_name_in_zip_dir
;
2174 class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2176 /* Here we skip non-class files; we handle them later. */
2177 if (classify_zip_file (zdir
) != 1)
2180 class_name
= compute_class_name (zdir
);
2181 file_name
= XNEWVEC (char, zdir
->filename_length
+1);
2182 jcf
= ggc_alloc_cleared_JCF ();
2184 strncpy (file_name
, class_name_in_zip_dir
, zdir
->filename_length
);
2185 file_name
[zdir
->filename_length
] = '\0';
2187 klass
= lookup_class (get_identifier (class_name
));
2189 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2191 /* We've already compiled this class. */
2192 duplicate_class_warning (file_name
);
2195 /* This function is only called when processing a zip file seen
2196 on the command line. */
2197 CLASS_FROM_CURRENTLY_COMPILED_P (klass
) = 1;
2199 jcf
->read_state
= finput
;
2200 jcf
->filbuf
= jcf_filbuf_from_stdio
;
2201 jcf
->classname
= class_name
;
2202 jcf
->filename
= file_name
;
2205 TYPE_JCF (klass
) = jcf
;
2209 #include "gt-java-jcf-parse.h"
2210 #include "gtype-java.h"