1 /* Parser for Java(TM) .class files.
2 Copyright (C) 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009 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"
35 #include "java-except.h"
38 #include "java-tree.h"
52 #ifdef HAVE_LANGINFO_CODESET
56 /* A CONSTANT_Utf8 element is converted to an IDENTIFIER_NODE at parse time. */
57 #define JPOOL_UTF(JCF, INDEX) CPOOL_UTF(&(JCF)->cpool, INDEX)
58 #define JPOOL_UTF_LENGTH(JCF, INDEX) IDENTIFIER_LENGTH (JPOOL_UTF (JCF, INDEX))
59 #define JPOOL_UTF_DATA(JCF, INDEX) \
60 ((const unsigned char *) IDENTIFIER_POINTER (JPOOL_UTF (JCF, INDEX)))
61 #define HANDLE_CONSTANT_Utf8(JCF, INDEX, LENGTH) \
63 unsigned char save; unsigned char *text; \
64 JCF_FILL (JCF, (LENGTH)+1); /* Make sure we read 1 byte beyond string. */ \
65 text = (JCF)->read_ptr; \
66 save = text[LENGTH]; \
68 (JCF)->cpool.data[INDEX].t = get_identifier ((const char *) text); \
69 text[LENGTH] = save; \
70 JCF_SKIP (JCF, LENGTH); } while (0)
74 extern struct obstack temporary_obstack
;
76 static GTY(()) tree parse_roots
[3];
78 /* The FIELD_DECL for the current field. */
79 #define current_field parse_roots[0]
81 /* The METHOD_DECL for the current method. */
82 #define current_method parse_roots[1]
84 /* A list of TRANSLATION_UNIT_DECLs for the files to be compiled. */
85 #define current_file_list parse_roots[2]
87 /* Line 0 in current file, if compiling from bytecode. */
88 static location_t file_start_location
;
90 /* The Java archive that provides main_class; the main input file. */
91 static GTY(()) struct JCF
* main_jcf
;
93 /* The number of source files passed to us by -fsource-filename and an
94 array of pointers to each name. Used by find_sourcefile(). */
95 static int num_files
= 0;
96 static char **filenames
;
98 static struct ZipFile
*localToFile
;
100 /* A map of byte offsets in the reflection data that are fields which
102 bitmap field_offsets
;
103 bitmap_obstack bit_obstack
;
105 /* Declarations of some functions used here. */
106 static void handle_innerclass_attribute (int count
, JCF
*, int len
);
107 static tree
give_name_to_class (JCF
*jcf
, int index
);
108 static char *compute_class_name (struct ZipDirectory
*zdir
);
109 static int classify_zip_file (struct ZipDirectory
*zdir
);
110 static void parse_zip_file_entries (void);
111 static void process_zip_dir (FILE *);
112 static void parse_class_file (void);
113 static void handle_deprecated (void);
114 static void set_source_filename (JCF
*, int);
115 static void jcf_parse (struct JCF
*);
116 static void load_inner_classes (tree
);
117 static void handle_annotation (JCF
*jcf
, int level
);
118 static void java_layout_seen_class_methods (void);
120 /* Handle "Deprecated" attribute. */
122 handle_deprecated (void)
124 if (current_field
!= NULL_TREE
)
125 FIELD_DEPRECATED (current_field
) = 1;
126 else if (current_method
!= NULL_TREE
)
127 METHOD_DEPRECATED (current_method
) = 1;
128 else if (current_class
!= NULL_TREE
)
129 CLASS_DEPRECATED (TYPE_NAME (current_class
)) = 1;
132 /* Shouldn't happen. */
139 /* Reverse a string. */
141 reverse (const char *s
)
147 int len
= strlen (s
);
148 char *d
= XNEWVAR (char, len
+ 1);
153 for (dp
= &d
[0], sp
= &s
[len
-1]; sp
>= s
; dp
++, sp
--)
160 /* Compare two strings for qsort(). */
162 cmpstringp (const void *p1
, const void *p2
)
164 /* The arguments to this function are "pointers to
165 pointers to char", but strcmp() arguments are "pointers
166 to char", hence the following cast plus dereference */
168 return strcmp(*(const char *const*) p1
, *(const char *const*) p2
);
171 /* Create an array of strings, one for each source file that we've
172 seen. fsource_filename can either be the name of a single .java
173 file or a file that contains a list of filenames separated by
176 java_read_sourcefilenames (const char *fsource_filename
)
180 && strlen (fsource_filename
) > strlen (".java")
181 && strcmp ((fsource_filename
182 + strlen (fsource_filename
)
186 /* fsource_filename isn't a .java file but a list of filenames
187 separated by newlines */
188 FILE *finput
= fopen (fsource_filename
, "r");
190 int longest_line
= 0;
194 /* Find out how many files there are, and how long the filenames are. */
195 while (! feof (finput
))
197 int ch
= getc (finput
);
201 if (len
> longest_line
)
213 /* Read the filenames. Put a pointer to each filename into the
216 char *linebuf
= (char *) alloca (longest_line
+ 1);
220 filenames
= XNEWVEC (char *, num_files
);
225 int ch
= getc (finput
);
230 linebuf
[charpos
] = 0;
231 gcc_assert (i
< num_files
);
232 /* ??? Perhaps we should use lrealpath() here. Doing
233 so would tidy up things like /../ but the rest of
234 gcc seems to assume relative pathnames, not
235 absolute pathnames. */
236 /* realname = lrealpath (linebuf); */
237 filenames
[i
++] = reverse (linebuf
);
241 gcc_assert (charpos
< longest_line
);
242 linebuf
[charpos
++] = ch
;
246 qsort (filenames
, num_files
, sizeof (char *), cmpstringp
);
252 filenames
= XNEWVEC (char *, 1);
253 filenames
[0] = reverse (fsource_filename
);
258 /* Given a relative pathname such as foo/bar.java, attempt to find a
259 longer pathname with the same suffix.
261 This is a best guess heuristic; with some weird class hierarchies we
262 may fail to pick the correct source file. For example, if we have
263 the filenames foo/bar.java and also foo/foo/bar.java, we do not
264 have enough information to know which one is the right match for
268 find_sourcefile (const char *name
)
270 int i
= 0, j
= num_files
-1;
275 char *revname
= reverse (name
);
280 int cmp
= strncmp (revname
, filenames
[k
], strlen (revname
));
283 /* OK, so we found one. But is it a unique match? */
285 && strncmp (revname
, filenames
[k
-1], strlen (revname
)) == 0)
287 && (strncmp (revname
, filenames
[k
+1], strlen (revname
))
291 found
= filenames
[k
];
304 if (found
&& strlen (found
) > strlen (name
))
305 return reverse (found
);
312 /* Handle "SourceFile" attribute. */
315 set_source_filename (JCF
*jcf
, int index
)
317 tree sfname_id
= get_name_constant (jcf
, index
);
318 const char *sfname
= IDENTIFIER_POINTER (sfname_id
);
319 const char *old_filename
= input_filename
;
320 int new_len
= IDENTIFIER_LENGTH (sfname_id
);
321 if (old_filename
!= NULL
)
323 int old_len
= strlen (old_filename
);
324 /* Use the current input_filename (derived from the class name)
325 if it has a directory prefix, but otherwise matches sfname. */
326 if (old_len
> new_len
327 && strcmp (sfname
, old_filename
+ old_len
- new_len
) == 0
328 && (old_filename
[old_len
- new_len
- 1] == '/'
329 || old_filename
[old_len
- new_len
- 1] == '\\'))
332 if (strchr (sfname
, '/') == NULL
&& strchr (sfname
, '\\') == NULL
)
334 const char *class_name
335 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class
)));
336 char *dot
= strrchr (class_name
, '.');
339 /* Length of prefix, not counting final dot. */
340 int i
= dot
- class_name
;
341 /* Concatenate current package prefix with new sfname. */
342 char *buf
= XNEWVEC (char, i
+ new_len
+ 2); /* Space for '.' and '\0'. */
343 strcpy (buf
+ i
+ 1, sfname
);
344 /* Copy package from class_name, replacing '.' by DIR_SEPARATOR.
345 Note we start at the end with the final package dot. */
348 char c
= class_name
[i
];
353 sfname_id
= get_identifier (buf
);
355 sfname
= IDENTIFIER_POINTER (sfname_id
);
359 sfname
= find_sourcefile (sfname
);
360 line_table
->maps
[line_table
->used
-1].to_file
= sfname
;
361 if (current_class
== main_class
) main_input_filename
= sfname
;
367 /* Annotation handling.
369 The technique we use here is to copy the annotation data directly
370 from the input class file into the output file. We don't decode the
371 data at all, merely rewriting constant indexes whenever we come
372 across them: this is necessary because the constant pool in the
373 output file isn't the same as the constant pool in in the input.
375 The main advantage of this technique is that the resulting
376 annotation data is pointer-free, so it doesn't have to be relocated
377 at startup time. As a consequence of this, annotations have no
378 performance impact unless they are used. Also, this representation
382 /* Expand TYPE_REFLECTION_DATA by DELTA bytes. Return the address of
383 the start of the newly allocated region. */
385 static unsigned char*
386 annotation_grow (int delta
)
388 unsigned char **data
= &TYPE_REFLECTION_DATA (current_class
);
389 long *datasize
= &TYPE_REFLECTION_DATASIZE (current_class
);
390 long len
= *datasize
;
394 *data
= XNEWVAR (unsigned char, delta
);
398 int newlen
= *datasize
+ delta
;
399 if (floor_log2 (newlen
) != floor_log2 (*datasize
))
400 *data
= XRESIZEVAR (unsigned char, *data
, 2 << (floor_log2 (newlen
)));
406 /* annotation_rewrite_TYPE. Rewrite various int types at p. Use Java
407 byte order (i.e. big endian.) */
410 annotation_rewrite_byte (unsigned int n
, unsigned char *p
)
416 annotation_rewrite_short (unsigned int n
, unsigned char *p
)
423 annotation_rewrite_int (unsigned int n
, unsigned char *p
)
431 /* Read a 16-bit unsigned int in Java byte order (i.e. big
435 annotation_read_short (unsigned char *p
)
438 tmp
= (tmp
<< 8) | p
[1];
442 /* annotation_write_TYPE. Rewrite various int types, appending them
443 to TYPE_REFLECTION_DATA. Use Java byte order (i.e. big
447 annotation_write_byte (unsigned int n
)
449 annotation_rewrite_byte (n
, annotation_grow (1));
453 annotation_write_short (unsigned int n
)
455 annotation_rewrite_short (n
, annotation_grow (2));
459 annotation_write_int (unsigned int n
)
461 annotation_rewrite_int (n
, annotation_grow (4));
464 /* Create a 64-bit constant in the constant pool.
466 This is used for both integer and floating-point types. As a
467 consequence, it will not work if the target floating-point format
468 is anything other than IEEE-754. While this is arguably a bug, the
469 runtime library makes exactly the same assumption and it's unlikely
470 that Java will ever run on a non-IEEE machine. */
473 handle_long_constant (JCF
*jcf
, CPool
*cpool
, enum cpool_tag kind
,
474 int index
, bool big_endian
)
476 /* If we're on a 64-bit platform we can fit a long or double
477 into the same space as a jword. */
478 if (POINTER_SIZE
>= 64)
479 index
= find_constant1 (cpool
, kind
, JPOOL_LONG (jcf
, index
));
481 /* In a compiled program the constant pool is in native word
482 order. How weird is that??? */
484 index
= find_constant2 (cpool
, kind
,
485 JPOOL_INT (jcf
, index
),
486 JPOOL_INT (jcf
, index
+1));
488 index
= find_constant2 (cpool
, kind
,
489 JPOOL_INT (jcf
, index
+1),
490 JPOOL_INT (jcf
, index
));
495 /* Given a class file and an index into its constant pool, create an
496 entry in the outgoing constant pool for the same item. */
499 handle_constant (JCF
*jcf
, int index
, enum cpool_tag purpose
)
502 CPool
*cpool
= cpool_for_class (output_class
);
507 if (! CPOOL_INDEX_IN_RANGE (&jcf
->cpool
, index
))
508 error ("<constant pool index %d not in range>", index
);
510 kind
= JPOOL_TAG (jcf
, index
);
512 if ((kind
& ~CONSTANT_ResolvedFlag
) != purpose
)
514 if (purpose
== CONSTANT_Class
515 && kind
== CONSTANT_Utf8
)
518 error ("<constant pool index %d unexpected type", index
);
524 case CONSTANT_ResolvedClass
:
526 /* For some reason I know not the what of, class names in
527 annotations are UTF-8 strings in the constant pool but
528 class names in EnclosingMethod attributes are real class
529 references. Set CONSTANT_LazyFlag here so that the VM
530 doesn't attempt to resolve them at class initialization
532 tree resolved_class
, class_name
;
533 resolved_class
= get_class_constant (jcf
, index
);
534 class_name
= build_internal_class_name (resolved_class
);
535 index
= alloc_name_constant (CONSTANT_Class
| CONSTANT_LazyFlag
,
537 (IDENTIFIER_POINTER(class_name
),
538 IDENTIFIER_LENGTH(class_name
))));
543 tree utf8
= get_constant (jcf
, index
);
544 if (purpose
== CONSTANT_Class
)
545 /* Create a constant pool entry for a type signature. This
546 one has '.' rather than '/' because it isn't going into a
547 class file, it's going into a compiled object.
549 This has to match the logic in
550 _Jv_ClassReader::prepare_pool_entry(). */
551 utf8
= unmangle_classname (IDENTIFIER_POINTER(utf8
),
552 IDENTIFIER_LENGTH(utf8
));
553 index
= alloc_name_constant (kind
, utf8
);
558 index
= handle_long_constant (jcf
, cpool
, CONSTANT_Long
, index
,
562 case CONSTANT_Double
:
563 index
= handle_long_constant (jcf
, cpool
, CONSTANT_Double
, index
,
564 FLOAT_WORDS_BIG_ENDIAN
);
568 case CONSTANT_Integer
:
569 index
= find_constant1 (cpool
, kind
, JPOOL_INT (jcf
, index
));
572 case CONSTANT_NameAndType
:
574 uint16 name
= JPOOL_USHORT1 (jcf
, index
);
575 uint16 sig
= JPOOL_USHORT2 (jcf
, index
);
576 uint32 name_index
= handle_constant (jcf
, name
, CONSTANT_Utf8
);
577 uint32 sig_index
= handle_constant (jcf
, sig
, CONSTANT_Class
);
578 jword new_index
= (name_index
<< 16) | sig_index
;
579 index
= find_constant1 (cpool
, kind
, new_index
);
590 /* Read an element_value structure from an annotation in JCF. Return
591 the constant pool index for the resulting constant pool entry. */
594 handle_element_value (JCF
*jcf
, int level
)
596 uint8 tag
= JCF_readu (jcf
);
599 annotation_write_byte (tag
);
608 uint16 cindex
= JCF_readu2 (jcf
);
609 index
= handle_constant (jcf
, cindex
,
611 annotation_write_short (index
);
616 uint16 cindex
= JCF_readu2 (jcf
);
617 index
= handle_constant (jcf
, cindex
,
619 annotation_write_short (index
);
624 uint16 cindex
= JCF_readu2 (jcf
);
625 index
= handle_constant (jcf
, cindex
,
627 annotation_write_short (index
);
632 uint16 cindex
= JCF_readu2 (jcf
);
633 index
= handle_constant (jcf
, cindex
,
635 annotation_write_short (index
);
640 uint16 cindex
= JCF_readu2 (jcf
);
641 /* Despite what the JVM spec says, compilers generate a Utf8
642 constant here, not a String. */
643 index
= handle_constant (jcf
, cindex
,
645 annotation_write_short (index
);
651 uint16 type_name_index
= JCF_readu2 (jcf
);
652 uint16 const_name_index
= JCF_readu2 (jcf
);
653 index
= handle_constant (jcf
, type_name_index
,
655 annotation_write_short (index
);
656 index
= handle_constant (jcf
, const_name_index
,
658 annotation_write_short (index
);
663 uint16 class_info_index
= JCF_readu2 (jcf
);
664 index
= handle_constant (jcf
, class_info_index
,
666 annotation_write_short (index
);
671 handle_annotation (jcf
, level
+ 1);
676 uint16 n_array_elts
= JCF_readu2 (jcf
);
677 annotation_write_short (n_array_elts
);
678 while (n_array_elts
--)
679 handle_element_value (jcf
, level
+ 1);
689 /* Read an annotation structure from JCF. Write it to the
690 reflection_data field of the outgoing class. */
693 handle_annotation (JCF
*jcf
, int level
)
695 uint16 type_index
= JCF_readu2 (jcf
);
696 uint16 npairs
= JCF_readu2 (jcf
);
697 int index
= handle_constant (jcf
, type_index
,
699 annotation_write_short (index
);
700 annotation_write_short (npairs
);
703 uint16 name_index
= JCF_readu2 (jcf
);
704 index
= handle_constant (jcf
, name_index
,
706 annotation_write_short (index
);
707 handle_element_value (jcf
, level
+ 2);
711 /* Read an annotation count from JCF, and write the following
712 annotations to the reflection_data field of the outgoing class. */
715 handle_annotations (JCF
*jcf
, int level
)
717 uint16 num
= JCF_readu2 (jcf
);
718 annotation_write_short (num
);
720 handle_annotation (jcf
, level
);
723 /* As handle_annotations(), but perform a sanity check that we write
724 the same number of bytes that we were expecting. */
727 handle_annotation_attribute (int ATTRIBUTE_UNUSED index
, JCF
*jcf
,
730 long old_datasize
= TYPE_REFLECTION_DATASIZE (current_class
);
732 handle_annotations (jcf
, 0);
734 gcc_assert (old_datasize
+ length
735 == TYPE_REFLECTION_DATASIZE (current_class
));
738 /* gcj permutes its fields array after generating annotation_data, so
739 we have to fixup field indexes for fields that have moved. Given
740 ARG, a VEC_int, fixup the field indexes in the reflection_data of
741 the outgoing class. We use field_offsets to tell us where the
745 rewrite_reflection_indexes (void *arg
)
749 VEC(int, heap
) *map
= (VEC(int, heap
) *) arg
;
750 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
754 EXECUTE_IF_SET_IN_BITMAP (field_offsets
, 0, offset
, bi
)
756 uint16 index
= annotation_read_short (data
+ offset
);
757 annotation_rewrite_short
758 (VEC_index (int, map
, index
), data
+ offset
);
763 /* Read the RuntimeVisibleAnnotations from JCF and write them to the
764 reflection_data of the outgoing class. */
767 handle_member_annotations (int member_index
, JCF
*jcf
,
768 const unsigned char *name ATTRIBUTE_UNUSED
,
769 long len
, jv_attr_type member_type
)
771 int new_len
= len
+ 1;
772 annotation_write_byte (member_type
);
773 if (member_type
!= JV_CLASS_ATTR
)
775 annotation_write_int (new_len
);
776 annotation_write_byte (JV_ANNOTATIONS_KIND
);
777 if (member_type
== JV_FIELD_ATTR
)
778 bitmap_set_bit (field_offsets
, TYPE_REFLECTION_DATASIZE (current_class
));
779 if (member_type
!= JV_CLASS_ATTR
)
780 annotation_write_short (member_index
);
781 handle_annotation_attribute (member_index
, jcf
, len
);
784 /* Read the RuntimeVisibleParameterAnnotations from JCF and write them
785 to the reflection_data of the outgoing class. */
788 handle_parameter_annotations (int member_index
, JCF
*jcf
,
789 const unsigned char *name ATTRIBUTE_UNUSED
,
790 long len
, jv_attr_type member_type
)
792 int new_len
= len
+ 1;
794 annotation_write_byte (member_type
);
795 if (member_type
!= JV_CLASS_ATTR
)
797 annotation_write_int (new_len
);
798 annotation_write_byte (JV_PARAMETER_ANNOTATIONS_KIND
);
799 if (member_type
!= JV_CLASS_ATTR
)
800 annotation_write_short (member_index
);
801 num
= JCF_readu (jcf
);
802 annotation_write_byte (num
);
804 handle_annotations (jcf
, 0);
808 /* Read the AnnotationDefault data from JCF and write them to the
809 reflection_data of the outgoing class. */
812 handle_default_annotation (int member_index
, JCF
*jcf
,
813 const unsigned char *name ATTRIBUTE_UNUSED
,
814 long len
, jv_attr_type member_type
)
816 int new_len
= len
+ 1;
817 annotation_write_byte (member_type
);
818 if (member_type
!= JV_CLASS_ATTR
)
820 annotation_write_int (new_len
);
821 annotation_write_byte (JV_ANNOTATION_DEFAULT_KIND
);
822 if (member_type
!= JV_CLASS_ATTR
)
823 annotation_write_short (member_index
);
824 handle_element_value (jcf
, 0);
827 /* As above, for the EnclosingMethod attribute. */
830 handle_enclosingmethod_attribute (int member_index
, JCF
*jcf
,
831 const unsigned char *name ATTRIBUTE_UNUSED
,
832 long len
, jv_attr_type member_type
)
834 int new_len
= len
+ 1;
836 annotation_write_byte (member_type
);
837 if (member_type
!= JV_CLASS_ATTR
)
839 annotation_write_int (new_len
);
840 annotation_write_byte (JV_ENCLOSING_METHOD_KIND
);
841 if (member_type
!= JV_CLASS_ATTR
)
842 annotation_write_short (member_index
);
844 index
= JCF_readu2 (jcf
);
845 index
= handle_constant (jcf
, index
, CONSTANT_Class
);
846 annotation_write_short (index
);
848 index
= JCF_readu2 (jcf
);
849 index
= handle_constant (jcf
, index
, CONSTANT_NameAndType
);
850 annotation_write_short (index
);
853 /* As above, for the Signature attribute. */
856 handle_signature_attribute (int member_index
, JCF
*jcf
,
857 const unsigned char *name ATTRIBUTE_UNUSED
,
858 long len
, jv_attr_type member_type
)
860 int new_len
= len
+ 1;
862 annotation_write_byte (member_type
);
863 if (member_type
!= JV_CLASS_ATTR
)
865 annotation_write_int (new_len
);
866 annotation_write_byte (JV_SIGNATURE_KIND
);
867 if (member_type
!= JV_CLASS_ATTR
)
868 annotation_write_short (member_index
);
870 index
= JCF_readu2 (jcf
);
871 index
= handle_constant (jcf
, index
, CONSTANT_Utf8
);
872 annotation_write_short (index
);
877 #define HANDLE_SOURCEFILE(INDEX) set_source_filename (jcf, INDEX)
879 #define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
880 { tree super_class = SUPER==0 ? NULL_TREE : get_class_constant (jcf, SUPER); \
881 output_class = current_class = give_name_to_class (jcf, THIS); \
882 set_super_info (ACCESS_FLAGS, current_class, super_class, INTERFACES_COUNT);}
884 #define HANDLE_CLASS_INTERFACE(INDEX) \
885 add_interface (current_class, get_class_constant (jcf, INDEX))
887 #define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
888 { int sig_index = SIGNATURE; \
889 current_field = add_field (current_class, get_name_constant (jcf, NAME), \
890 parse_signature (jcf, sig_index), ACCESS_FLAGS); \
891 set_java_signature (TREE_TYPE (current_field), JPOOL_UTF (jcf, sig_index)); \
892 if ((ACCESS_FLAGS) & ACC_FINAL) \
893 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (current_field); \
896 #define HANDLE_END_FIELDS() \
897 (current_field = NULL_TREE)
899 #define HANDLE_CONSTANTVALUE(INDEX) \
900 { tree constant; int index = INDEX; \
901 if (JPOOL_TAG (jcf, index) == CONSTANT_String) { \
902 tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index)); \
903 constant = build_utf8_ref (name); \
906 constant = get_constant (jcf, index); \
907 set_constant_value (current_field, constant); }
909 #define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
910 (current_method = add_method (current_class, ACCESS_FLAGS, \
911 get_name_constant (jcf, NAME), \
912 get_name_constant (jcf, SIGNATURE)), \
913 DECL_LOCALVARIABLES_OFFSET (current_method) = 0, \
914 DECL_LINENUMBERS_OFFSET (current_method) = 0)
916 #define HANDLE_END_METHODS() \
917 { current_method = NULL_TREE; }
919 #define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
920 { DECL_MAX_STACK (current_method) = (MAX_STACK); \
921 DECL_MAX_LOCALS (current_method) = (MAX_LOCALS); \
922 DECL_CODE_LENGTH (current_method) = (CODE_LENGTH); \
923 DECL_CODE_OFFSET (current_method) = JCF_TELL (jcf); }
925 #define HANDLE_LOCALVARIABLETABLE_ATTRIBUTE(COUNT) \
927 DECL_LOCALVARIABLES_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
928 JCF_SKIP (jcf, n * 10); }
930 #define HANDLE_LINENUMBERTABLE_ATTRIBUTE(COUNT) \
932 DECL_LINENUMBERS_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
933 JCF_SKIP (jcf, n * 4); }
935 #define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
938 tree list = DECL_FUNCTION_THROWS (current_method); \
941 tree thrown_class = get_class_constant (jcf, JCF_readu2 (jcf)); \
942 list = tree_cons (NULL_TREE, thrown_class, list); \
944 DECL_FUNCTION_THROWS (current_method) = nreverse (list); \
947 #define HANDLE_DEPRECATED_ATTRIBUTE() handle_deprecated ()
949 /* Link seen inner classes to their outer context and register the
950 inner class to its outer context. They will be later loaded. */
951 #define HANDLE_INNERCLASSES_ATTRIBUTE(COUNT) \
952 handle_innerclass_attribute (COUNT, jcf, attribute_length)
954 #define HANDLE_SYNTHETIC_ATTRIBUTE() \
956 /* Irrelevant decls should have been nullified by the END macros. \
957 DECL_ARTIFICIAL on fields is used for something else (See \
958 PUSH_FIELD in java-tree.h) */ \
959 if (current_method) \
960 DECL_ARTIFICIAL (current_method) = 1; \
961 else if (current_field) \
962 FIELD_SYNTHETIC (current_field) = 1; \
964 TYPE_SYNTHETIC (current_class) = 1; \
967 #define HANDLE_GCJCOMPILED_ATTRIBUTE() \
969 if (current_class == object_type_node) \
970 jcf->right_zip = 1; \
973 #define HANDLE_RUNTIMEVISIBLEANNOTATIONS_ATTRIBUTE() \
975 handle_member_annotations (index, jcf, name_data, attribute_length, attr_type); \
978 #define HANDLE_RUNTIMEINVISIBLEANNOTATIONS_ATTRIBUTE() \
980 JCF_SKIP(jcf, attribute_length); \
983 #define HANDLE_RUNTIMEVISIBLEPARAMETERANNOTATIONS_ATTRIBUTE() \
985 handle_parameter_annotations (index, jcf, name_data, attribute_length, attr_type); \
988 #define HANDLE_RUNTIMEINVISIBLEPARAMETERANNOTATIONS_ATTRIBUTE() \
990 JCF_SKIP(jcf, attribute_length); \
993 #define HANDLE_ANNOTATIONDEFAULT_ATTRIBUTE() \
995 handle_default_annotation (index, jcf, name_data, attribute_length, attr_type); \
998 #define HANDLE_ENCLOSINGMETHOD_ATTRIBUTE() \
1000 handle_enclosingmethod_attribute (index, jcf, name_data, \
1001 attribute_length, attr_type); \
1004 #define HANDLE_SIGNATURE_ATTRIBUTE() \
1006 handle_signature_attribute (index, jcf, name_data, \
1007 attribute_length, attr_type); \
1010 #include "jcf-reader.c"
1013 parse_signature (JCF
*jcf
, int sig_index
)
1015 gcc_assert (sig_index
> 0
1016 && sig_index
< JPOOL_SIZE (jcf
)
1017 && JPOOL_TAG (jcf
, sig_index
) == CONSTANT_Utf8
);
1019 return parse_signature_string (JPOOL_UTF_DATA (jcf
, sig_index
),
1020 JPOOL_UTF_LENGTH (jcf
, sig_index
));
1024 get_constant (JCF
*jcf
, int index
)
1028 if (index
<= 0 || index
>= JPOOL_SIZE(jcf
))
1030 tag
= JPOOL_TAG (jcf
, index
);
1031 if ((tag
& CONSTANT_ResolvedFlag
) || tag
== CONSTANT_Utf8
)
1032 return jcf
->cpool
.data
[index
].t
;
1035 case CONSTANT_Integer
:
1037 jint num
= JPOOL_INT(jcf
, index
);
1038 value
= build_int_cst (int_type_node
, num
);
1043 unsigned HOST_WIDE_INT num
= JPOOL_UINT (jcf
, index
);
1044 unsigned HOST_WIDE_INT lo
;
1047 lshift_double (num
, 0, 32, 64, &lo
, &hi
, 0);
1048 num
= JPOOL_UINT (jcf
, index
+1);
1049 add_double (lo
, hi
, num
, 0, &lo
, &hi
);
1050 value
= build_int_cst_wide_type (long_type_node
, lo
, hi
);
1054 case CONSTANT_Float
:
1056 jint num
= JPOOL_INT(jcf
, index
);
1060 real_from_target_fmt (&d
, &buf
, &ieee_single_format
);
1061 value
= build_real (float_type_node
, d
);
1065 case CONSTANT_Double
:
1067 long buf
[2], lo
, hi
;
1070 hi
= JPOOL_UINT (jcf
, index
);
1071 lo
= JPOOL_UINT (jcf
, index
+1);
1073 if (FLOAT_WORDS_BIG_ENDIAN
)
1074 buf
[0] = hi
, buf
[1] = lo
;
1076 buf
[0] = lo
, buf
[1] = hi
;
1078 real_from_target_fmt (&d
, buf
, &ieee_double_format
);
1079 value
= build_real (double_type_node
, d
);
1083 case CONSTANT_String
:
1085 tree name
= get_name_constant (jcf
, JPOOL_USHORT1 (jcf
, index
));
1086 const char *utf8_ptr
= IDENTIFIER_POINTER (name
);
1087 int utf8_len
= IDENTIFIER_LENGTH (name
);
1088 const unsigned char *utf8
;
1091 /* Check for a malformed Utf8 string. */
1092 utf8
= (const unsigned char *) utf8_ptr
;
1096 int char_len
= UT8_CHAR_LENGTH (*utf8
);
1097 if (char_len
< 0 || char_len
> 3 || char_len
> i
)
1098 fatal_error ("bad string constant");
1104 /* Allocate a new string value. */
1105 value
= build_string (utf8_len
, utf8_ptr
);
1106 TREE_TYPE (value
) = build_pointer_type (string_type_node
);
1112 JPOOL_TAG (jcf
, index
) = tag
| CONSTANT_ResolvedFlag
;
1113 jcf
->cpool
.data
[index
].t
= value
;
1116 internal_error ("bad value constant type %d, index %d",
1117 JPOOL_TAG (jcf
, index
), index
);
1121 get_name_constant (JCF
*jcf
, int index
)
1123 tree name
= get_constant (jcf
, index
);
1124 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1128 /* Handle reading innerclass attributes. If a nonzero entry (denoting
1129 a non anonymous entry) is found, We augment the inner class list of
1130 the outer context with the newly resolved innerclass. */
1133 handle_innerclass_attribute (int count
, JCF
*jcf
, int attribute_length
)
1137 annotation_write_byte (JV_CLASS_ATTR
);
1138 annotation_write_int (attribute_length
+1);
1139 annotation_write_byte (JV_INNER_CLASSES_KIND
);
1140 annotation_write_short (count
);
1144 /* Read inner_class_info_index. This may be 0 */
1145 int icii
= JCF_readu2 (jcf
);
1146 /* Read outer_class_info_index. If the innerclasses attribute
1147 entry isn't a member (like an inner class) the value is 0. */
1148 int ocii
= JCF_readu2 (jcf
);
1149 /* Read inner_name_index. If the class we're dealing with is
1150 an anonymous class, it must be 0. */
1151 int ini
= JCF_readu2 (jcf
);
1152 /* Read the access flag. */
1153 int acc
= JCF_readu2 (jcf
);
1155 annotation_write_short (handle_constant (jcf
, icii
, CONSTANT_Class
));
1156 annotation_write_short (handle_constant (jcf
, ocii
, CONSTANT_Class
));
1157 annotation_write_short (handle_constant (jcf
, ini
, CONSTANT_Utf8
));
1158 annotation_write_short (acc
);
1160 /* If icii is 0, don't try to read the class. */
1163 tree klass
= get_class_constant (jcf
, icii
);
1164 tree decl
= TYPE_NAME (klass
);
1165 /* Skip reading further if ocii is null */
1166 if (DECL_P (decl
) && !CLASS_COMPLETE_P (decl
) && ocii
)
1168 tree outer
= TYPE_NAME (get_class_constant (jcf
, ocii
));
1169 tree alias
= (ini
? get_name_constant (jcf
, ini
) : NULL_TREE
);
1170 set_class_decl_access_flags (acc
, decl
);
1171 DECL_CONTEXT (decl
) = outer
;
1172 DECL_INNER_CLASS_LIST (outer
) =
1173 tree_cons (decl
, alias
, DECL_INNER_CLASS_LIST (outer
));
1174 CLASS_COMPLETE_P (decl
) = 1;
1181 give_name_to_class (JCF
*jcf
, int i
)
1184 && i
< JPOOL_SIZE (jcf
)
1185 && JPOOL_TAG (jcf
, i
) == CONSTANT_Class
);
1188 tree package_name
= NULL_TREE
, tmp
;
1190 int j
= JPOOL_USHORT1 (jcf
, i
);
1191 /* verify_constant_pool confirmed that j is a CONSTANT_Utf8. */
1192 tree class_name
= unmangle_classname ((const char *) JPOOL_UTF_DATA (jcf
, j
),
1193 JPOOL_UTF_LENGTH (jcf
, j
));
1194 this_class
= lookup_class (class_name
);
1196 tree source_name
= identifier_subst (class_name
, "", '.', '/', ".java");
1197 const char *sfname
= find_sourcefile (IDENTIFIER_POINTER (source_name
));
1198 linemap_add (line_table
, LC_ENTER
, false, sfname
, 0);
1199 input_location
= linemap_line_start (line_table
, 0, 1);
1200 file_start_location
= input_location
;
1201 DECL_SOURCE_LOCATION (TYPE_NAME (this_class
)) = input_location
;
1202 if (main_input_filename
== NULL
&& jcf
== main_jcf
)
1203 main_input_filename
= sfname
;
1206 jcf
->cpool
.data
[i
].t
= this_class
;
1207 JPOOL_TAG (jcf
, i
) = CONSTANT_ResolvedClass
;
1208 split_qualified_name (&package_name
, &tmp
,
1209 DECL_NAME (TYPE_NAME (this_class
)));
1210 TYPE_PACKAGE (this_class
) = package_name
;
1215 /* Get the class of the CONSTANT_Class whose constant pool index is I. */
1218 get_class_constant (JCF
*jcf
, int i
)
1222 && i
< JPOOL_SIZE (jcf
)
1223 && (JPOOL_TAG (jcf
, i
) & ~CONSTANT_ResolvedFlag
) == CONSTANT_Class
);
1225 if (JPOOL_TAG (jcf
, i
) != CONSTANT_ResolvedClass
)
1227 int name_index
= JPOOL_USHORT1 (jcf
, i
);
1228 /* verify_constant_pool confirmed that name_index is a CONSTANT_Utf8. */
1229 const char *name
= (const char *) JPOOL_UTF_DATA (jcf
, name_index
);
1230 int nlength
= JPOOL_UTF_LENGTH (jcf
, name_index
);
1232 if (name
[0] == '[') /* Handle array "classes". */
1233 type
= TREE_TYPE (parse_signature_string ((const unsigned char *) name
, nlength
));
1236 tree cname
= unmangle_classname (name
, nlength
);
1237 type
= lookup_class (cname
);
1239 jcf
->cpool
.data
[i
].t
= type
;
1240 JPOOL_TAG (jcf
, i
) = CONSTANT_ResolvedClass
;
1243 type
= jcf
->cpool
.data
[i
].t
;
1247 /* Read a class with the fully qualified-name NAME.
1248 Return 1 iff we read the requested file.
1249 (It is still possible we failed if the file did not
1250 define the class it is supposed to.) */
1253 read_class (tree name
)
1256 tree icv
, klass
= NULL_TREE
;
1257 tree save_current_class
= current_class
;
1258 tree save_output_class
= output_class
;
1259 location_t save_location
= input_location
;
1260 JCF
*save_current_jcf
= current_jcf
;
1262 if ((icv
= IDENTIFIER_CLASS_VALUE (name
)) != NULL_TREE
)
1264 klass
= TREE_TYPE (icv
);
1265 jcf
= TYPE_JCF (klass
);
1272 const char* path_name
;
1273 this_jcf
.zipd
= NULL
;
1276 path_name
= find_class (IDENTIFIER_POINTER (name
),
1277 IDENTIFIER_LENGTH (name
),
1282 free(CONST_CAST (char *, path_name
));
1287 if (klass
== NULL_TREE
|| ! CLASS_PARSED_P (klass
))
1289 output_class
= current_class
= klass
;
1290 if (JCF_SEEN_IN_ZIP (current_jcf
))
1291 read_zip_member(current_jcf
,
1292 current_jcf
->zipd
, current_jcf
->zipd
->zipf
);
1293 jcf_parse (current_jcf
);
1294 /* Parsing might change the class, in which case we have to
1295 put it back where we found it. */
1296 if (current_class
!= klass
&& icv
!= NULL_TREE
)
1297 TREE_TYPE (icv
) = current_class
;
1298 klass
= current_class
;
1300 layout_class (klass
);
1301 load_inner_classes (klass
);
1303 output_class
= save_output_class
;
1304 current_class
= save_current_class
;
1305 input_location
= save_location
;
1306 current_jcf
= save_current_jcf
;
1310 /* Load CLASS_OR_NAME. CLASS_OR_NAME can be a mere identifier if
1311 called from the parser, otherwise it's a RECORD_TYPE node. If
1312 VERBOSE is 1, print error message on failure to load a class. */
1314 load_class (tree class_or_name
, int verbose
)
1317 int class_loaded
= 0;
1318 tree class_decl
= NULL_TREE
;
1319 bool is_compiled_class
= false;
1321 /* We've already failed, don't try again. */
1322 if (TREE_CODE (class_or_name
) == RECORD_TYPE
1323 && TYPE_DUMMY (class_or_name
))
1326 /* class_or_name can be the name of the class we want to load */
1327 if (TREE_CODE (class_or_name
) == IDENTIFIER_NODE
)
1328 name
= class_or_name
;
1329 /* In some cases, it's a dependency that we process earlier that
1331 else if (TREE_CODE (class_or_name
) == TREE_LIST
)
1332 name
= TYPE_NAME (TREE_PURPOSE (class_or_name
));
1333 /* Or it's a type in the making */
1335 name
= DECL_NAME (TYPE_NAME (class_or_name
));
1337 class_decl
= IDENTIFIER_CLASS_VALUE (name
);
1338 if (class_decl
!= NULL_TREE
)
1340 tree type
= TREE_TYPE (class_decl
);
1342 = ((TYPE_JCF (type
) && JCF_SEEN_IN_ZIP (TYPE_JCF (type
)))
1343 || CLASS_FROM_CURRENTLY_COMPILED_P (type
));
1348 /* If flag_verify_invocations is unset, we don't try to load a class
1349 unless we're looking for Object (which is fixed by the ABI) or
1350 it's a class that we're going to compile. */
1351 if (flag_verify_invocations
1352 || class_or_name
== object_type_node
1353 || is_compiled_class
1354 || TREE_CODE (class_or_name
) == IDENTIFIER_NODE
)
1360 /* We've already loaded it. */
1361 if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
)
1363 tree tmp_decl
= IDENTIFIER_CLASS_VALUE (name
);
1364 if (CLASS_PARSED_P (TREE_TYPE (tmp_decl
)))
1368 if (read_class (name
))
1371 /* We failed loading name. Now consider that we might be looking
1372 for an inner class. */
1373 if ((separator
= strrchr (IDENTIFIER_POINTER (name
), '$'))
1374 || (separator
= strrchr (IDENTIFIER_POINTER (name
), '.')))
1378 name
= get_identifier (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 all_class_list
= tree_cons (NULL_TREE
,
1487 TYPE_NAME (current_class
), all_class_list
);
1490 /* If we came across inner classes, load them now. */
1492 load_inner_classes (tree cur_class
)
1495 for (current
= DECL_INNER_CLASS_LIST (TYPE_NAME (cur_class
)); current
;
1496 current
= TREE_CHAIN (current
))
1498 tree name
= DECL_NAME (TREE_PURPOSE (current
));
1499 tree decl
= IDENTIFIER_GLOBAL_VALUE (name
);
1500 if (decl
&& ! CLASS_LOADED_P (TREE_TYPE (decl
))
1501 && !CLASS_BEING_LAIDOUT (TREE_TYPE (decl
)))
1502 load_class (name
, 1);
1507 duplicate_class_warning (const char *filename
)
1509 location_t warn_loc
;
1510 linemap_add (line_table
, LC_RENAME
, 0, filename
, 0);
1511 warn_loc
= linemap_line_start (line_table
, 0, 1);
1512 warning_at (warn_loc
, 0, "duplicate class will only be compiled once");
1516 java_layout_seen_class_methods (void)
1518 tree previous_list
= all_class_list
;
1519 tree end
= NULL_TREE
;
1524 for (current
= previous_list
;
1525 current
!= end
; current
= TREE_CHAIN (current
))
1527 tree decl
= TREE_VALUE (current
);
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. */
1541 if (previous_list
!= all_class_list
)
1543 end
= previous_list
;
1544 previous_list
= all_class_list
;
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
;
1672 add_predefined_file (tree name
)
1674 predef_filenames
= tree_cons (NULL_TREE
, name
, predef_filenames
);
1678 predefined_filename_p (tree node
)
1682 for (iter
= predef_filenames
; iter
!= NULL_TREE
; iter
= TREE_CHAIN (iter
))
1684 if (TREE_VALUE (iter
) == node
)
1690 /* Generate a function that does all static initialization for this
1691 translation unit. */
1694 java_emit_static_constructor (void)
1698 emit_register_classes (&body
);
1699 write_resource_constructor (&body
);
1703 tree name
= get_identifier ("_Jv_global_static_constructor");
1706 = build_decl (input_location
, FUNCTION_DECL
, name
,
1707 build_function_type (void_type_node
, void_list_node
));
1709 tree resdecl
= build_decl (input_location
,
1710 RESULT_DECL
, NULL_TREE
, void_type_node
);
1711 DECL_ARTIFICIAL (resdecl
) = 1;
1712 DECL_RESULT (decl
) = resdecl
;
1713 current_function_decl
= decl
;
1714 allocate_struct_function (decl
, false);
1716 TREE_STATIC (decl
) = 1;
1717 TREE_USED (decl
) = 1;
1718 DECL_ARTIFICIAL (decl
) = 1;
1719 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1720 DECL_SAVED_TREE (decl
) = body
;
1721 DECL_UNINLINABLE (decl
) = 1;
1723 DECL_INITIAL (decl
) = make_node (BLOCK
);
1724 TREE_USED (DECL_INITIAL (decl
)) = 1;
1726 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
1727 java_genericize (decl
);
1728 cgraph_finalize_function (decl
, false);
1734 java_parse_file (int set_yydebug ATTRIBUTE_UNUSED
)
1736 int filename_count
= 0;
1737 location_t save_location
= input_location
;
1738 char *file_list
= NULL
, *list
, *next
;
1740 FILE *finput
= NULL
;
1743 bitmap_obstack_initialize (&bit_obstack
);
1744 field_offsets
= BITMAP_ALLOC (&bit_obstack
);
1746 if (flag_filelist_file
)
1749 finput
= fopen (main_input_filename
, "r");
1751 fatal_error ("can't open %s: %m", input_filename
);
1752 list
= XNEWVEC (char, avail
);
1759 count
= next
- list
;
1760 avail
= 2 * (count
+ avail
);
1761 list
= XRESIZEVEC (char, list
, avail
);
1762 next
= list
+ count
;
1763 avail
= avail
- count
;
1765 /* Subtract to to guarantee space for final '\0'. */
1766 count
= fread (next
, 1, avail
- 1, finput
);
1769 if (! feof (finput
))
1770 fatal_error ("error closing %s: %m", input_filename
);
1782 list
= CONST_CAST (char *, main_input_filename
);
1786 for (next
= list
; ; )
1789 if (flag_filelist_file
&& ! in_quotes
1790 && (ch
== '\n' || ch
== '\r' || ch
== '\t' || ch
== ' '
1791 || ch
== '&') /* FIXME */)
1805 if (flag_filelist_file
&& ch
== '"')
1807 in_quotes
= ! in_quotes
;
1822 /* Exclude .java files. */
1823 if (strlen (list
) > 5 && ! strcmp (list
+ strlen (list
) - 5, ".java"))
1829 node
= get_identifier (list
);
1833 /* Exclude file that we see twice on the command line. */
1835 if (IS_A_COMMAND_LINE_FILENAME_P (node
))
1836 duplicate_class_warning (IDENTIFIER_POINTER (node
));
1839 tree file_decl
= build_decl (input_location
,
1840 TRANSLATION_UNIT_DECL
, node
, NULL
);
1841 TREE_CHAIN (file_decl
) = current_file_list
;
1842 current_file_list
= file_decl
;
1843 IS_A_COMMAND_LINE_FILENAME_P (node
) = 1;
1849 if (file_list
!= NULL
)
1852 if (filename_count
== 0)
1853 warning (0, "no input file specified");
1857 const char *resource_filename
;
1859 /* Only one resource file may be compiled at a time. */
1860 assert (TREE_CHAIN (current_file_list
) == NULL
);
1862 resource_filename
= IDENTIFIER_POINTER (DECL_NAME (current_file_list
));
1863 compile_resource_file (resource_name
, resource_filename
);
1868 current_jcf
= main_jcf
;
1869 current_file_list
= nreverse (current_file_list
);
1870 for (node
= current_file_list
; node
; node
= TREE_CHAIN (node
))
1872 unsigned char magic_string
[4];
1875 tree name
= DECL_NAME (node
);
1877 const char *filename
= IDENTIFIER_POINTER (name
);
1879 /* Skip already parsed files */
1880 real_path
= lrealpath (filename
);
1881 real_file
= get_identifier (real_path
);
1883 if (HAS_BEEN_ALREADY_PARSED_P (real_file
))
1886 /* Close previous descriptor, if any */
1887 if (finput
&& fclose (finput
))
1888 fatal_error ("can't close input file %s: %m", main_input_filename
);
1890 finput
= fopen (filename
, "rb");
1892 fatal_error ("can't open %s: %m", filename
);
1894 #ifdef IO_BUFFER_SIZE
1895 setvbuf (finput
, xmalloc (IO_BUFFER_SIZE
),
1896 _IOFBF
, IO_BUFFER_SIZE
);
1899 /* Figure what kind of file we're dealing with */
1900 if (fread (magic_string
, 1, 4, finput
) == 4)
1902 fseek (finput
, 0L, SEEK_SET
);
1903 magic
= GET_u4 (magic_string
);
1905 if (magic
== 0xcafebabe)
1907 CLASS_FILE_P (node
) = 1;
1908 current_jcf
= GGC_NEW (JCF
);
1909 JCF_ZERO (current_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_NEW (JCF
);
1927 JCF_ZERO (main_jcf
);
1928 main_jcf
->read_state
= finput
;
1929 main_jcf
->filbuf
= jcf_filbuf_from_stdio
;
1930 linemap_add (line_table
, LC_ENTER
, false, filename
, 0);
1931 input_location
= linemap_line_start (line_table
, 0, 1);
1932 if (open_in_zip (main_jcf
, filename
, NULL
, 0) < 0)
1933 fatal_error ("bad zip/jar file %s", filename
);
1934 localToFile
= SeenZipFiles
;
1935 /* Register all the classes defined there. */
1936 process_zip_dir ((FILE *) main_jcf
->read_state
);
1937 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1938 parse_zip_file_entries ();
1940 else if (magic
== (JCF_u4
) ZIPEMPTYMAGIC
)
1942 /* Ignore an empty input jar. */
1948 java_push_parser_context ();
1949 java_parser_context_save_global ();
1951 parse_source_file_1 (real_file
, filename
, finput
);
1952 java_parser_context_restore_global ();
1953 java_pop_parser_context (1);
1954 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1959 for (node
= current_file_list
; node
; node
= TREE_CHAIN (node
))
1961 input_location
= DECL_SOURCE_LOCATION (node
);
1962 if (CLASS_FILE_P (node
))
1964 /* FIXME: These two flags really should be independent. We
1965 should be able to compile fully binary compatible, but
1966 with flag_verify_invocations on. */
1967 flag_verify_invocations
= ! flag_indirect_dispatch
;
1968 output_class
= current_class
= TREE_TYPE (node
);
1970 current_jcf
= TYPE_JCF (current_class
);
1971 layout_class (current_class
);
1972 load_inner_classes (current_class
);
1973 parse_class_file ();
1974 JCF_FINISH (current_jcf
);
1977 input_location
= save_location
;
1979 bitmap_obstack_release (&bit_obstack
);
1982 /* Arrange for any necessary initialization to happen. */
1983 java_emit_static_constructor ();
1984 gcc_assert (global_bindings_p ());
1986 /* Only finalize the compilation unit after we've told cgraph which
1987 functions have their addresses stored. */
1988 cgraph_finalize_compilation_unit ();
1993 /* Return the name of the class corresponding to the name of the file
1994 in this zip entry. The result is newly allocated using ALLOC. */
1996 compute_class_name (struct ZipDirectory
*zdir
)
1998 char *class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2001 int filename_length
= zdir
->filename_length
;
2003 while (filename_length
> 2 && strncmp (class_name_in_zip_dir
, "./", 2) == 0)
2005 class_name_in_zip_dir
+= 2;
2006 filename_length
-= 2;
2009 filename_length
-= strlen (".class");
2010 class_name
= XNEWVEC (char, filename_length
+ 1);
2011 memcpy (class_name
, class_name_in_zip_dir
, filename_length
);
2012 class_name
[filename_length
] = '\0';
2014 for (i
= 0; i
< filename_length
; i
++)
2015 if (class_name
[i
] == '/')
2016 class_name
[i
] = '.';
2021 /* Return 0 if we should skip this entry, 1 if it is a .class file, 2
2022 if it is a property file of some sort. */
2024 classify_zip_file (struct ZipDirectory
*zdir
)
2026 char *class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2028 if (zdir
->filename_length
> 6
2029 && !strncmp (&class_name_in_zip_dir
[zdir
->filename_length
- 6],
2033 /* For now we drop the manifest, but not other information. */
2034 if (zdir
->filename_length
== 20
2035 && !strncmp (class_name_in_zip_dir
, "META-INF/MANIFEST.MF", 20))
2038 /* Drop directory entries. */
2039 if (zdir
->filename_length
> 0
2040 && class_name_in_zip_dir
[zdir
->filename_length
- 1] == '/')
2046 /* Process all class entries found in the zip file. */
2048 parse_zip_file_entries (void)
2050 struct ZipDirectory
*zdir
;
2053 for (i
= 0, zdir
= (ZipDirectory
*)localToFile
->central_directory
;
2054 i
< localToFile
->count
; i
++, zdir
= ZIPDIR_NEXT (zdir
))
2058 switch (classify_zip_file (zdir
))
2065 char *class_name
= compute_class_name (zdir
);
2066 int previous_alias_set
= -1;
2067 klass
= lookup_class (get_identifier (class_name
));
2069 current_jcf
= TYPE_JCF (klass
);
2070 output_class
= current_class
= klass
;
2072 /* This is a dummy class, and now we're compiling it for
2074 gcc_assert (! TYPE_DUMMY (klass
));
2076 /* This is for a corner case where we have a superclass
2077 but no superclass fields.
2079 This can happen if we earlier failed to lay out this
2080 class because its superclass was still in the process
2081 of being laid out; this occurs when we have recursive
2082 class dependencies via inner classes. We must record
2083 the previous alias set and restore it after laying out
2086 FIXME: this really is a kludge. We should figure out a
2087 way to lay out the class properly before this
2089 if (TYPE_SIZE (klass
) && CLASSTYPE_SUPER (klass
)
2090 && integer_zerop (TYPE_SIZE (klass
)))
2092 TYPE_SIZE (klass
) = NULL_TREE
;
2093 previous_alias_set
= TYPE_ALIAS_SET (klass
);
2094 TYPE_ALIAS_SET (klass
) = -1;
2097 if (! CLASS_LOADED_P (klass
))
2099 if (! CLASS_PARSED_P (klass
))
2101 read_zip_member (current_jcf
, zdir
, localToFile
);
2102 jcf_parse (current_jcf
);
2104 layout_class (current_class
);
2105 load_inner_classes (current_class
);
2108 if (previous_alias_set
!= -1)
2109 TYPE_ALIAS_SET (klass
) = previous_alias_set
;
2111 if (TYPE_SIZE (current_class
) != error_mark_node
)
2113 parse_class_file ();
2114 free (current_jcf
->buffer
); /* No longer necessary */
2115 /* Note: there is a way to free this buffer right after a
2116 class seen in a zip file has been parsed. The idea is the
2117 set its jcf in such a way that buffer will be reallocated
2118 the time the code for the class will be generated. FIXME. */
2125 char *file_name
, *class_name_in_zip_dir
, *buffer
;
2127 file_name
= XNEWVEC (char, zdir
->filename_length
+ 1);
2128 class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2129 strncpy (file_name
, class_name_in_zip_dir
, zdir
->filename_length
);
2130 file_name
[zdir
->filename_length
] = '\0';
2133 jcf
->read_state
= finput
;
2134 jcf
->filbuf
= jcf_filbuf_from_stdio
;
2135 jcf
->classname
= NULL
;
2136 jcf
->filename
= file_name
;
2139 if (read_zip_member (jcf
, zdir
, localToFile
) < 0)
2140 fatal_error ("error while reading %s from zip file", file_name
);
2142 buffer
= XNEWVEC (char, zdir
->filename_length
+ 1 +
2143 (jcf
->buffer_end
- jcf
->buffer
));
2144 strcpy (buffer
, file_name
);
2145 /* This is not a typo: we overwrite the trailing \0 of the
2146 file name; this is just how the data is laid out. */
2147 memcpy (buffer
+ zdir
->filename_length
,
2148 jcf
->buffer
, jcf
->buffer_end
- jcf
->buffer
);
2150 compile_resource_data (file_name
, buffer
,
2151 jcf
->buffer_end
- jcf
->buffer
);
2164 /* Read all the entries of the zip file, creates a class and a JCF. Sets the
2165 jcf up for further processing and link it to the created class. */
2168 process_zip_dir (FILE *finput
)
2173 for (i
= 0, zdir
= (ZipDirectory
*)localToFile
->central_directory
;
2174 i
< localToFile
->count
; i
++, zdir
= ZIPDIR_NEXT (zdir
))
2176 char *class_name
, *file_name
, *class_name_in_zip_dir
;
2180 class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2182 /* Here we skip non-class files; we handle them later. */
2183 if (classify_zip_file (zdir
) != 1)
2186 class_name
= compute_class_name (zdir
);
2187 file_name
= XNEWVEC (char, zdir
->filename_length
+1);
2188 jcf
= GGC_NEW (JCF
);
2191 strncpy (file_name
, class_name_in_zip_dir
, zdir
->filename_length
);
2192 file_name
[zdir
->filename_length
] = '\0';
2194 klass
= lookup_class (get_identifier (class_name
));
2196 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2198 /* We've already compiled this class. */
2199 duplicate_class_warning (file_name
);
2202 /* This function is only called when processing a zip file seen
2203 on the command line. */
2204 CLASS_FROM_CURRENTLY_COMPILED_P (klass
) = 1;
2206 jcf
->read_state
= finput
;
2207 jcf
->filbuf
= jcf_filbuf_from_stdio
;
2208 jcf
->classname
= class_name
;
2209 jcf
->filename
= file_name
;
2212 TYPE_JCF (klass
) = jcf
;
2216 #include "gt-java-jcf-parse.h"
2217 #include "gtype-java.h"