1 /* Parser for Java(TM) .class files.
2 Copyright (C) 1996-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>.
20 Java and all Java-based marks are trademarks or registered trademarks
21 of Sun Microsystems, Inc. in the United States and other countries.
22 The Free Software Foundation is independent of Sun Microsystems, Inc. */
24 /* Written by Per Bothner <bothner@cygnus.com> */
28 #include "coretypes.h"
30 #include "stringpool.h"
33 #include "java-except.h"
36 #include "java-tree.h"
37 #include "diagnostic-core.h"
49 #ifdef HAVE_LANGINFO_CODESET
53 /* A CONSTANT_Utf8 element is converted to an IDENTIFIER_NODE at parse time. */
54 #define JPOOL_UTF(JCF, INDEX) CPOOL_UTF(&(JCF)->cpool, INDEX)
55 #define JPOOL_UTF_LENGTH(JCF, INDEX) IDENTIFIER_LENGTH (JPOOL_UTF (JCF, INDEX))
56 #define JPOOL_UTF_DATA(JCF, INDEX) \
57 ((const unsigned char *) IDENTIFIER_POINTER (JPOOL_UTF (JCF, INDEX)))
58 #define HANDLE_CONSTANT_Utf8(JCF, INDEX, LENGTH) \
60 unsigned char save; unsigned char *text; \
61 JCF_FILL (JCF, (LENGTH)+1); /* Make sure we read 1 byte beyond string. */ \
62 text = (JCF)->read_ptr; \
63 save = text[LENGTH]; \
65 (JCF)->cpool.data[INDEX].t = get_identifier ((const char *) text); \
66 text[LENGTH] = save; \
67 JCF_SKIP (JCF, LENGTH); } while (0)
71 extern struct obstack temporary_obstack
;
73 static GTY(()) tree parse_roots
[2];
75 /* The FIELD_DECL for the current field. */
76 #define current_field parse_roots[0]
78 /* The METHOD_DECL for the current method. */
79 #define current_method parse_roots[1]
81 /* Line 0 in current file, if compiling from bytecode. */
82 static location_t file_start_location
;
84 /* The Java archive that provides main_class; the main input file. */
85 static GTY(()) struct JCF
* main_jcf
;
87 /* A list of all the class DECLs seen so far. */
88 static GTY(()) vec
<tree
, va_gc
> *all_class_list
;
90 /* The number of source files passed to us by -fsource-filename and an
91 array of pointers to each name. Used by find_sourcefile(). */
92 static int num_files
= 0;
93 static char **filenames
;
95 static struct ZipFile
*localToFile
;
97 /* A map of byte offsets in the reflection data that are fields which
100 bitmap_obstack bit_obstack
;
102 /* Declarations of some functions used here. */
103 static void handle_innerclass_attribute (int count
, JCF
*, int len
);
104 static tree
give_name_to_class (JCF
*jcf
, int index
);
105 static char *compute_class_name (struct ZipDirectory
*zdir
);
106 static int classify_zip_file (struct ZipDirectory
*zdir
);
107 static void parse_zip_file_entries (void);
108 static void process_zip_dir (FILE *);
109 static void parse_class_file (void);
110 static void handle_deprecated (void);
111 static void set_source_filename (JCF
*, int);
112 static void jcf_parse (struct JCF
*);
113 static void load_inner_classes (tree
);
114 static void handle_annotation (JCF
*jcf
, int level
);
115 static void java_layout_seen_class_methods (void);
117 /* Handle "Deprecated" attribute. */
119 handle_deprecated (void)
121 if (current_field
!= NULL_TREE
)
122 FIELD_DEPRECATED (current_field
) = 1;
123 else if (current_method
!= NULL_TREE
)
124 METHOD_DEPRECATED (current_method
) = 1;
125 else if (current_class
!= NULL_TREE
)
126 CLASS_DEPRECATED (TYPE_NAME (current_class
)) = 1;
129 /* Shouldn't happen. */
136 /* Reverse a string. */
138 reverse (const char *s
)
144 int len
= strlen (s
);
145 char *d
= XNEWVAR (char, len
+ 1);
150 for (dp
= &d
[0], sp
= &s
[len
-1]; sp
>= s
; dp
++, sp
--)
157 /* Compare two strings for qsort(). */
159 cmpstringp (const void *p1
, const void *p2
)
161 /* The arguments to this function are "pointers to
162 pointers to char", but strcmp() arguments are "pointers
163 to char", hence the following cast plus dereference */
165 return strcmp(*(const char *const*) p1
, *(const char *const*) p2
);
168 /* Create an array of strings, one for each source file that we've
169 seen. fsource_filename can either be the name of a single .java
170 file or a file that contains a list of filenames separated by
173 java_read_sourcefilenames (const char *fsource_filename
)
177 && strlen (fsource_filename
) > strlen (".java")
178 && filename_cmp ((fsource_filename
179 + strlen (fsource_filename
)
183 /* fsource_filename isn't a .java file but a list of filenames
184 separated by newlines */
185 FILE *finput
= fopen (fsource_filename
, "r");
187 int longest_line
= 0;
191 /* Find out how many files there are, and how long the filenames are. */
192 while (! feof (finput
))
194 int ch
= getc (finput
);
198 if (len
> longest_line
)
210 /* Read the filenames. Put a pointer to each filename into the
213 char *linebuf
= (char *) alloca (longest_line
+ 1);
217 filenames
= XNEWVEC (char *, num_files
);
222 int ch
= getc (finput
);
227 linebuf
[charpos
] = 0;
228 gcc_assert (i
< num_files
);
229 /* ??? Perhaps we should use lrealpath() here. Doing
230 so would tidy up things like /../ but the rest of
231 gcc seems to assume relative pathnames, not
232 absolute pathnames. */
233 /* realname = lrealpath (linebuf); */
234 filenames
[i
++] = reverse (linebuf
);
238 gcc_assert (charpos
< longest_line
);
239 linebuf
[charpos
++] = ch
;
243 qsort (filenames
, num_files
, sizeof (char *), cmpstringp
);
249 filenames
= XNEWVEC (char *, 1);
250 filenames
[0] = reverse (fsource_filename
);
255 /* Given a relative pathname such as foo/bar.java, attempt to find a
256 longer pathname with the same suffix.
258 This is a best guess heuristic; with some weird class hierarchies we
259 may fail to pick the correct source file. For example, if we have
260 the filenames foo/bar.java and also foo/foo/bar.java, we do not
261 have enough information to know which one is the right match for
265 find_sourcefile (const char *name
)
267 int i
= 0, j
= num_files
-1;
272 char *revname
= reverse (name
);
277 int cmp
= strncmp (revname
, filenames
[k
], strlen (revname
));
280 /* OK, so we found one. But is it a unique match? */
282 && strncmp (revname
, filenames
[k
-1], strlen (revname
)) == 0)
284 && (strncmp (revname
, filenames
[k
+1], strlen (revname
))
288 found
= filenames
[k
];
301 if (found
&& strlen (found
) > strlen (name
))
302 return reverse (found
);
309 /* Handle "SourceFile" attribute. */
312 set_source_filename (JCF
*jcf
, int index
)
314 tree sfname_id
= get_name_constant (jcf
, index
);
315 const char *sfname
= IDENTIFIER_POINTER (sfname_id
);
316 const char *old_filename
= LOCATION_FILE (input_location
);
317 int new_len
= IDENTIFIER_LENGTH (sfname_id
);
318 if (old_filename
!= NULL
)
320 int old_len
= strlen (old_filename
);
321 /* Use the filename from current input_location (derived from the
322 class name) if it has a directory prefix, but otherwise matches
324 if (old_len
> new_len
325 && filename_cmp (sfname
, old_filename
+ old_len
- new_len
) == 0
326 && (old_filename
[old_len
- new_len
- 1] == '/'
327 || old_filename
[old_len
- new_len
- 1] == '\\'))
330 if (strchr (sfname
, '/') == NULL
&& strchr (sfname
, '\\') == NULL
)
332 const char *class_name
333 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class
)));
334 const char *dot
= strrchr (class_name
, '.');
337 /* Length of prefix, not counting final dot. */
338 int i
= dot
- class_name
;
339 /* Concatenate current package prefix with new sfname. */
340 char *buf
= XNEWVEC (char, i
+ new_len
+ 2); /* Space for '.' and '\0'. */
341 strcpy (buf
+ i
+ 1, sfname
);
342 /* Copy package from class_name, replacing '.' by DIR_SEPARATOR.
343 Note we start at the end with the final package dot. */
346 char c
= class_name
[i
];
351 sfname_id
= get_identifier (buf
);
353 sfname
= IDENTIFIER_POINTER (sfname_id
);
357 sfname
= find_sourcefile (sfname
);
358 ORDINARY_MAP_FILE_NAME (LINEMAPS_LAST_ORDINARY_MAP (line_table
)) = sfname
;
359 if (current_class
== main_class
) main_input_filename
= sfname
;
365 /* Annotation handling.
367 The technique we use here is to copy the annotation data directly
368 from the input class file into the output file. We don't decode the
369 data at all, merely rewriting constant indexes whenever we come
370 across them: this is necessary because the constant pool in the
371 output file isn't the same as the constant pool in the input.
373 The main advantage of this technique is that the resulting
374 annotation data is pointer-free, so it doesn't have to be relocated
375 at startup time. As a consequence of this, annotations have no
376 performance impact unless they are used. Also, this representation
380 /* Expand TYPE_REFLECTION_DATA by DELTA bytes. Return the address of
381 the start of the newly allocated region. */
383 static unsigned char*
384 annotation_grow (int delta
)
386 unsigned char **data
= &TYPE_REFLECTION_DATA (current_class
);
387 long *datasize
= &TYPE_REFLECTION_DATASIZE (current_class
);
388 long len
= *datasize
;
392 *data
= XNEWVAR (unsigned char, delta
);
396 int newlen
= *datasize
+ delta
;
397 if (floor_log2 (newlen
) != floor_log2 (*datasize
))
398 *data
= XRESIZEVAR (unsigned char, *data
, 2 << (floor_log2 (newlen
)));
404 /* annotation_rewrite_TYPE. Rewrite various int types at p. Use Java
405 byte order (i.e. big endian.) */
408 annotation_rewrite_byte (unsigned int n
, unsigned char *p
)
414 annotation_rewrite_short (unsigned int n
, unsigned char *p
)
421 annotation_rewrite_int (unsigned int n
, unsigned char *p
)
429 /* Read a 16-bit unsigned int in Java byte order (i.e. big
433 annotation_read_short (unsigned char *p
)
436 tmp
= (tmp
<< 8) | p
[1];
440 /* annotation_write_TYPE. Rewrite various int types, appending them
441 to TYPE_REFLECTION_DATA. Use Java byte order (i.e. big
445 annotation_write_byte (unsigned int n
)
447 annotation_rewrite_byte (n
, annotation_grow (1));
451 annotation_write_short (unsigned int n
)
453 annotation_rewrite_short (n
, annotation_grow (2));
457 annotation_write_int (unsigned int n
)
459 annotation_rewrite_int (n
, annotation_grow (4));
462 /* Create a 64-bit constant in the constant pool.
464 This is used for both integer and floating-point types. As a
465 consequence, it will not work if the target floating-point format
466 is anything other than IEEE-754. While this is arguably a bug, the
467 runtime library makes exactly the same assumption and it's unlikely
468 that Java will ever run on a non-IEEE machine. */
471 handle_long_constant (JCF
*jcf
, CPool
*cpool
, enum cpool_tag kind
,
472 int index
, bool big_endian
)
474 /* If we're on a 64-bit platform we can fit a long or double
475 into the same space as a jword. */
476 if (POINTER_SIZE
>= 64)
477 index
= find_constant1 (cpool
, kind
, JPOOL_LONG (jcf
, index
));
479 /* In a compiled program the constant pool is in native word
480 order. How weird is that??? */
482 index
= find_constant2 (cpool
, kind
,
483 JPOOL_INT (jcf
, index
),
484 JPOOL_INT (jcf
, index
+1));
486 index
= find_constant2 (cpool
, kind
,
487 JPOOL_INT (jcf
, index
+1),
488 JPOOL_INT (jcf
, index
));
493 /* Given a class file and an index into its constant pool, create an
494 entry in the outgoing constant pool for the same item. */
497 handle_constant (JCF
*jcf
, int index
, enum cpool_tag purpose
)
500 CPool
*cpool
= cpool_for_class (output_class
);
505 if (! CPOOL_INDEX_IN_RANGE (&jcf
->cpool
, index
))
506 error ("<constant pool index %d not in range>", index
);
508 kind
= JPOOL_TAG (jcf
, index
);
510 if ((kind
& ~CONSTANT_ResolvedFlag
) != purpose
)
512 if (purpose
== CONSTANT_Class
513 && kind
== CONSTANT_Utf8
)
516 error ("<constant pool index %d unexpected type", index
);
522 case CONSTANT_ResolvedClass
:
524 /* For some reason I know not the what of, class names in
525 annotations are UTF-8 strings in the constant pool but
526 class names in EnclosingMethod attributes are real class
527 references. Set CONSTANT_LazyFlag here so that the VM
528 doesn't attempt to resolve them at class initialization
530 tree resolved_class
, class_name
;
531 resolved_class
= get_class_constant (jcf
, index
);
532 class_name
= build_internal_class_name (resolved_class
);
533 index
= alloc_name_constant (CONSTANT_Class
| CONSTANT_LazyFlag
,
535 (IDENTIFIER_POINTER(class_name
),
536 IDENTIFIER_LENGTH(class_name
))));
541 tree utf8
= get_constant (jcf
, index
);
542 if (purpose
== CONSTANT_Class
)
543 /* Create a constant pool entry for a type signature. This
544 one has '.' rather than '/' because it isn't going into a
545 class file, it's going into a compiled object.
547 This has to match the logic in
548 _Jv_ClassReader::prepare_pool_entry(). */
549 utf8
= unmangle_classname (IDENTIFIER_POINTER(utf8
),
550 IDENTIFIER_LENGTH(utf8
));
551 index
= alloc_name_constant (kind
, utf8
);
556 index
= handle_long_constant (jcf
, cpool
, CONSTANT_Long
, index
,
557 targetm
.words_big_endian ());
560 case CONSTANT_Double
:
561 index
= handle_long_constant (jcf
, cpool
, CONSTANT_Double
, index
,
562 targetm
.float_words_big_endian ());
566 case CONSTANT_Integer
:
567 index
= find_constant1 (cpool
, kind
, JPOOL_INT (jcf
, index
));
570 case CONSTANT_NameAndType
:
572 uint16 name
= JPOOL_USHORT1 (jcf
, index
);
573 uint16 sig
= JPOOL_USHORT2 (jcf
, index
);
574 uint32 name_index
= handle_constant (jcf
, name
, CONSTANT_Utf8
);
575 uint32 sig_index
= handle_constant (jcf
, sig
, CONSTANT_Class
);
576 jword new_index
= (name_index
<< 16) | sig_index
;
577 index
= find_constant1 (cpool
, kind
, new_index
);
588 /* Read an element_value structure from an annotation in JCF. Return
589 the constant pool index for the resulting constant pool entry. */
592 handle_element_value (JCF
*jcf
, int level
)
594 uint8 tag
= JCF_readu (jcf
);
597 annotation_write_byte (tag
);
606 uint16 cindex
= JCF_readu2 (jcf
);
607 index
= handle_constant (jcf
, cindex
,
609 annotation_write_short (index
);
614 uint16 cindex
= JCF_readu2 (jcf
);
615 index
= handle_constant (jcf
, cindex
,
617 annotation_write_short (index
);
622 uint16 cindex
= JCF_readu2 (jcf
);
623 index
= handle_constant (jcf
, cindex
,
625 annotation_write_short (index
);
630 uint16 cindex
= JCF_readu2 (jcf
);
631 index
= handle_constant (jcf
, cindex
,
633 annotation_write_short (index
);
638 uint16 cindex
= JCF_readu2 (jcf
);
639 /* Despite what the JVM spec says, compilers generate a Utf8
640 constant here, not a String. */
641 index
= handle_constant (jcf
, cindex
,
643 annotation_write_short (index
);
649 uint16 type_name_index
= JCF_readu2 (jcf
);
650 uint16 const_name_index
= JCF_readu2 (jcf
);
651 index
= handle_constant (jcf
, type_name_index
,
653 annotation_write_short (index
);
654 index
= handle_constant (jcf
, const_name_index
,
656 annotation_write_short (index
);
661 uint16 class_info_index
= JCF_readu2 (jcf
);
662 index
= handle_constant (jcf
, class_info_index
,
664 annotation_write_short (index
);
669 handle_annotation (jcf
, level
+ 1);
674 uint16 n_array_elts
= JCF_readu2 (jcf
);
675 annotation_write_short (n_array_elts
);
676 while (n_array_elts
--)
677 handle_element_value (jcf
, level
+ 1);
687 /* Read an annotation structure from JCF. Write it to the
688 reflection_data field of the outgoing class. */
691 handle_annotation (JCF
*jcf
, int level
)
693 uint16 type_index
= JCF_readu2 (jcf
);
694 uint16 npairs
= JCF_readu2 (jcf
);
695 int index
= handle_constant (jcf
, type_index
,
697 annotation_write_short (index
);
698 annotation_write_short (npairs
);
701 uint16 name_index
= JCF_readu2 (jcf
);
702 index
= handle_constant (jcf
, name_index
,
704 annotation_write_short (index
);
705 handle_element_value (jcf
, level
+ 2);
709 /* Read an annotation count from JCF, and write the following
710 annotations to the reflection_data field of the outgoing class. */
713 handle_annotations (JCF
*jcf
, int level
)
715 uint16 num
= JCF_readu2 (jcf
);
716 annotation_write_short (num
);
718 handle_annotation (jcf
, level
);
721 /* As handle_annotations(), but perform a sanity check that we write
722 the same number of bytes that we were expecting. */
725 handle_annotation_attribute (int ATTRIBUTE_UNUSED index
, JCF
*jcf
,
728 long old_datasize
= TYPE_REFLECTION_DATASIZE (current_class
);
730 handle_annotations (jcf
, 0);
732 gcc_assert (old_datasize
+ length
733 == TYPE_REFLECTION_DATASIZE (current_class
));
736 /* gcj permutes its fields array after generating annotation_data, so
737 we have to fixup field indexes for fields that have moved. Given
738 ARG, a VEC_int, fixup the field indexes in the reflection_data of
739 the outgoing class. We use field_offsets to tell us where the
743 rewrite_reflection_indexes (void *arg
)
747 vec
<int> *map
= (vec
<int> *) arg
;
748 unsigned char *data
= TYPE_REFLECTION_DATA (current_class
);
752 EXECUTE_IF_SET_IN_BITMAP (field_offsets
, 0, offset
, bi
)
754 uint16 index
= annotation_read_short (data
+ offset
);
755 annotation_rewrite_short
756 ((*map
)[index
], data
+ offset
);
761 /* Read the RuntimeVisibleAnnotations from JCF and write them to the
762 reflection_data of the outgoing class. */
765 handle_member_annotations (int member_index
, JCF
*jcf
,
766 const unsigned char *name ATTRIBUTE_UNUSED
,
767 long len
, jv_attr_type member_type
)
769 int new_len
= len
+ 1;
770 annotation_write_byte (member_type
);
771 if (member_type
!= JV_CLASS_ATTR
)
773 annotation_write_int (new_len
);
774 annotation_write_byte (JV_ANNOTATIONS_KIND
);
775 if (member_type
== JV_FIELD_ATTR
)
776 bitmap_set_bit (field_offsets
, TYPE_REFLECTION_DATASIZE (current_class
));
777 if (member_type
!= JV_CLASS_ATTR
)
778 annotation_write_short (member_index
);
779 handle_annotation_attribute (member_index
, jcf
, len
);
782 /* Read the RuntimeVisibleParameterAnnotations from JCF and write them
783 to the reflection_data of the outgoing class. */
786 handle_parameter_annotations (int member_index
, JCF
*jcf
,
787 const unsigned char *name ATTRIBUTE_UNUSED
,
788 long len
, jv_attr_type member_type
)
790 int new_len
= len
+ 1;
792 annotation_write_byte (member_type
);
793 if (member_type
!= JV_CLASS_ATTR
)
795 annotation_write_int (new_len
);
796 annotation_write_byte (JV_PARAMETER_ANNOTATIONS_KIND
);
797 if (member_type
!= JV_CLASS_ATTR
)
798 annotation_write_short (member_index
);
799 num
= JCF_readu (jcf
);
800 annotation_write_byte (num
);
802 handle_annotations (jcf
, 0);
806 /* Read the AnnotationDefault data from JCF and write them to the
807 reflection_data of the outgoing class. */
810 handle_default_annotation (int member_index
, JCF
*jcf
,
811 const unsigned char *name ATTRIBUTE_UNUSED
,
812 long len
, jv_attr_type member_type
)
814 int new_len
= len
+ 1;
815 annotation_write_byte (member_type
);
816 if (member_type
!= JV_CLASS_ATTR
)
818 annotation_write_int (new_len
);
819 annotation_write_byte (JV_ANNOTATION_DEFAULT_KIND
);
820 if (member_type
!= JV_CLASS_ATTR
)
821 annotation_write_short (member_index
);
822 handle_element_value (jcf
, 0);
825 /* As above, for the EnclosingMethod attribute. */
828 handle_enclosingmethod_attribute (int member_index
, JCF
*jcf
,
829 const unsigned char *name ATTRIBUTE_UNUSED
,
830 long len
, jv_attr_type member_type
)
832 int new_len
= len
+ 1;
834 annotation_write_byte (member_type
);
835 if (member_type
!= JV_CLASS_ATTR
)
837 annotation_write_int (new_len
);
838 annotation_write_byte (JV_ENCLOSING_METHOD_KIND
);
839 if (member_type
!= JV_CLASS_ATTR
)
840 annotation_write_short (member_index
);
842 index
= JCF_readu2 (jcf
);
843 index
= handle_constant (jcf
, index
, CONSTANT_Class
);
844 annotation_write_short (index
);
846 index
= JCF_readu2 (jcf
);
847 index
= handle_constant (jcf
, index
, CONSTANT_NameAndType
);
848 annotation_write_short (index
);
851 /* As above, for the Signature attribute. */
854 handle_signature_attribute (int member_index
, JCF
*jcf
,
855 const unsigned char *name ATTRIBUTE_UNUSED
,
856 long len
, jv_attr_type member_type
)
858 int new_len
= len
+ 1;
860 annotation_write_byte (member_type
);
861 if (member_type
!= JV_CLASS_ATTR
)
863 annotation_write_int (new_len
);
864 annotation_write_byte (JV_SIGNATURE_KIND
);
865 if (member_type
!= JV_CLASS_ATTR
)
866 annotation_write_short (member_index
);
868 index
= JCF_readu2 (jcf
);
869 index
= handle_constant (jcf
, index
, CONSTANT_Utf8
);
870 annotation_write_short (index
);
875 #define HANDLE_SOURCEFILE(INDEX) set_source_filename (jcf, INDEX)
877 #define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
878 { tree super_class = SUPER==0 ? NULL_TREE : get_class_constant (jcf, SUPER); \
879 output_class = current_class = give_name_to_class (jcf, THIS); \
880 set_super_info (ACCESS_FLAGS, current_class, super_class, INTERFACES_COUNT);}
882 #define HANDLE_CLASS_INTERFACE(INDEX) \
883 add_interface (current_class, get_class_constant (jcf, INDEX))
885 #define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
886 { int sig_index = SIGNATURE; \
887 current_field = add_field (current_class, get_name_constant (jcf, NAME), \
888 parse_signature (jcf, sig_index), ACCESS_FLAGS); \
889 set_java_signature (TREE_TYPE (current_field), JPOOL_UTF (jcf, sig_index)); \
890 if ((ACCESS_FLAGS) & ACC_FINAL) \
891 MAYBE_CREATE_VAR_LANG_DECL_SPECIFIC (current_field); \
894 #define HANDLE_END_FIELDS() \
895 (current_field = NULL_TREE)
897 #define HANDLE_CONSTANTVALUE(INDEX) \
898 { tree constant; int index = INDEX; \
899 if (JPOOL_TAG (jcf, index) == CONSTANT_String) { \
900 tree name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index)); \
901 constant = build_utf8_ref (name); \
904 constant = get_constant (jcf, index); \
905 set_constant_value (current_field, constant); }
907 #define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
908 (current_method = add_method (current_class, ACCESS_FLAGS, \
909 get_name_constant (jcf, NAME), \
910 get_name_constant (jcf, SIGNATURE)), \
911 DECL_LOCALVARIABLES_OFFSET (current_method) = 0, \
912 DECL_LINENUMBERS_OFFSET (current_method) = 0)
914 #define HANDLE_END_METHODS() \
915 { current_method = NULL_TREE; }
917 #define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
918 { DECL_MAX_STACK (current_method) = (MAX_STACK); \
919 DECL_MAX_LOCALS (current_method) = (MAX_LOCALS); \
920 DECL_CODE_LENGTH (current_method) = (CODE_LENGTH); \
921 DECL_CODE_OFFSET (current_method) = JCF_TELL (jcf); }
923 #define HANDLE_LOCALVARIABLETABLE_ATTRIBUTE(COUNT) \
925 DECL_LOCALVARIABLES_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
926 JCF_SKIP (jcf, n * 10); }
928 #define HANDLE_LINENUMBERTABLE_ATTRIBUTE(COUNT) \
930 DECL_LINENUMBERS_OFFSET (current_method) = JCF_TELL (jcf) - 2; \
931 JCF_SKIP (jcf, n * 4); }
933 #define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
936 vec<tree, va_gc> *v; \
938 gcc_assert (!DECL_FUNCTION_THROWS (current_method)); \
941 tree thrown_class = get_class_constant (jcf, JCF_readu2 (jcf)); \
942 v->quick_push (thrown_class); \
944 DECL_FUNCTION_THROWS (current_method) = v; \
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
;
1046 num
= JPOOL_UINT (jcf
, index
);
1047 val
= double_int::from_uhwi (num
).llshift (32, 64);
1048 num
= JPOOL_UINT (jcf
, index
+ 1);
1049 val
|= double_int::from_uhwi (num
);
1051 value
= double_int_to_tree (long_type_node
, val
);
1055 case CONSTANT_Float
:
1057 jint num
= JPOOL_INT(jcf
, index
);
1061 real_from_target_fmt (&d
, &buf
, &ieee_single_format
);
1062 value
= build_real (float_type_node
, d
);
1066 case CONSTANT_Double
:
1068 long buf
[2], lo
, hi
;
1071 hi
= JPOOL_UINT (jcf
, index
);
1072 lo
= JPOOL_UINT (jcf
, index
+1);
1074 if (targetm
.float_words_big_endian ())
1075 buf
[0] = hi
, buf
[1] = lo
;
1077 buf
[0] = lo
, buf
[1] = hi
;
1079 real_from_target_fmt (&d
, buf
, &ieee_double_format
);
1080 value
= build_real (double_type_node
, d
);
1084 case CONSTANT_String
:
1086 tree name
= get_name_constant (jcf
, JPOOL_USHORT1 (jcf
, index
));
1087 const char *utf8_ptr
= IDENTIFIER_POINTER (name
);
1088 int utf8_len
= IDENTIFIER_LENGTH (name
);
1089 const unsigned char *utf8
;
1092 /* Check for a malformed Utf8 string. */
1093 utf8
= (const unsigned char *) utf8_ptr
;
1097 int char_len
= UT8_CHAR_LENGTH (*utf8
);
1098 if (char_len
< 0 || char_len
> 3 || char_len
> i
)
1099 fatal_error ("bad string constant");
1105 /* Allocate a new string value. */
1106 value
= build_string (utf8_len
, utf8_ptr
);
1107 TREE_TYPE (value
) = build_pointer_type (string_type_node
);
1113 JPOOL_TAG (jcf
, index
) = tag
| CONSTANT_ResolvedFlag
;
1114 jcf
->cpool
.data
[index
].t
= value
;
1117 fatal_error ("bad value constant type %d, index %d",
1118 JPOOL_TAG (jcf
, index
), index
);
1122 get_name_constant (JCF
*jcf
, int index
)
1124 tree name
= get_constant (jcf
, index
);
1125 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
1129 /* Handle reading innerclass attributes. If a nonzero entry (denoting
1130 a non anonymous entry) is found, We augment the inner class list of
1131 the outer context with the newly resolved innerclass. */
1134 handle_innerclass_attribute (int count
, JCF
*jcf
, int attribute_length
)
1138 annotation_write_byte (JV_CLASS_ATTR
);
1139 annotation_write_int (attribute_length
+1);
1140 annotation_write_byte (JV_INNER_CLASSES_KIND
);
1141 annotation_write_short (count
);
1145 /* Read inner_class_info_index. This may be 0 */
1146 int icii
= JCF_readu2 (jcf
);
1147 /* Read outer_class_info_index. If the innerclasses attribute
1148 entry isn't a member (like an inner class) the value is 0. */
1149 int ocii
= JCF_readu2 (jcf
);
1150 /* Read inner_name_index. If the class we're dealing with is
1151 an anonymous class, it must be 0. */
1152 int ini
= JCF_readu2 (jcf
);
1153 /* Read the access flag. */
1154 int acc
= JCF_readu2 (jcf
);
1156 annotation_write_short (handle_constant (jcf
, icii
, CONSTANT_Class
));
1157 annotation_write_short (handle_constant (jcf
, ocii
, CONSTANT_Class
));
1158 annotation_write_short (handle_constant (jcf
, ini
, CONSTANT_Utf8
));
1159 annotation_write_short (acc
);
1161 /* If icii is 0, don't try to read the class. */
1164 tree klass
= get_class_constant (jcf
, icii
);
1165 tree decl
= TYPE_NAME (klass
);
1166 /* Skip reading further if ocii is null */
1167 if (DECL_P (decl
) && !CLASS_COMPLETE_P (decl
) && ocii
)
1169 tree outer
= TYPE_NAME (get_class_constant (jcf
, ocii
));
1170 tree alias
= (ini
? get_name_constant (jcf
, ini
) : NULL_TREE
);
1171 set_class_decl_access_flags (acc
, decl
);
1172 DECL_CONTEXT (decl
) = outer
;
1173 DECL_INNER_CLASS_LIST (outer
) =
1174 tree_cons (decl
, alias
, DECL_INNER_CLASS_LIST (outer
));
1175 CLASS_COMPLETE_P (decl
) = 1;
1182 give_name_to_class (JCF
*jcf
, int i
)
1185 && i
< JPOOL_SIZE (jcf
)
1186 && JPOOL_TAG (jcf
, i
) == CONSTANT_Class
);
1189 tree package_name
= NULL_TREE
, tmp
;
1191 int j
= JPOOL_USHORT1 (jcf
, i
);
1192 /* verify_constant_pool confirmed that j is a CONSTANT_Utf8. */
1193 tree class_name
= unmangle_classname ((const char *) JPOOL_UTF_DATA (jcf
, j
),
1194 JPOOL_UTF_LENGTH (jcf
, j
));
1195 this_class
= lookup_class (class_name
);
1197 tree source_name
= identifier_subst (class_name
, "", '.', '/', ".java");
1198 const char *sfname
= find_sourcefile (IDENTIFIER_POINTER (source_name
));
1199 linemap_add (line_table
, LC_ENTER
, false, sfname
, 0);
1200 input_location
= linemap_line_start (line_table
, 0, 1);
1201 file_start_location
= input_location
;
1202 DECL_SOURCE_LOCATION (TYPE_NAME (this_class
)) = input_location
;
1203 if (main_input_filename
== NULL
&& jcf
== main_jcf
)
1204 main_input_filename
= sfname
;
1207 jcf
->cpool
.data
[i
].t
= this_class
;
1208 JPOOL_TAG (jcf
, i
) = CONSTANT_ResolvedClass
;
1209 split_qualified_name (&package_name
, &tmp
,
1210 DECL_NAME (TYPE_NAME (this_class
)));
1211 TYPE_PACKAGE (this_class
) = package_name
;
1216 /* Get the class of the CONSTANT_Class whose constant pool index is I. */
1219 get_class_constant (JCF
*jcf
, int i
)
1223 && i
< JPOOL_SIZE (jcf
)
1224 && (JPOOL_TAG (jcf
, i
) & ~CONSTANT_ResolvedFlag
) == CONSTANT_Class
);
1226 if (JPOOL_TAG (jcf
, i
) != CONSTANT_ResolvedClass
)
1228 int name_index
= JPOOL_USHORT1 (jcf
, i
);
1229 /* verify_constant_pool confirmed that name_index is a CONSTANT_Utf8. */
1230 const char *name
= (const char *) JPOOL_UTF_DATA (jcf
, name_index
);
1231 int nlength
= JPOOL_UTF_LENGTH (jcf
, name_index
);
1233 if (name
[0] == '[') /* Handle array "classes". */
1234 type
= TREE_TYPE (parse_signature_string ((const unsigned char *) name
, nlength
));
1237 tree cname
= unmangle_classname (name
, nlength
);
1238 type
= lookup_class (cname
);
1240 jcf
->cpool
.data
[i
].t
= type
;
1241 JPOOL_TAG (jcf
, i
) = CONSTANT_ResolvedClass
;
1244 type
= jcf
->cpool
.data
[i
].t
;
1248 /* Read a class with the fully qualified-name NAME.
1249 Return 1 iff we read the requested file.
1250 (It is still possible we failed if the file did not
1251 define the class it is supposed to.) */
1254 read_class (tree name
)
1257 tree icv
, klass
= NULL_TREE
;
1258 tree save_current_class
= current_class
;
1259 tree save_output_class
= output_class
;
1260 location_t save_location
= input_location
;
1261 JCF
*save_current_jcf
= current_jcf
;
1263 if ((icv
= IDENTIFIER_CLASS_VALUE (name
)) != NULL_TREE
)
1265 klass
= TREE_TYPE (icv
);
1266 jcf
= TYPE_JCF (klass
);
1273 const char* path_name
;
1274 this_jcf
.zipd
= NULL
;
1277 path_name
= find_class (IDENTIFIER_POINTER (name
),
1278 IDENTIFIER_LENGTH (name
),
1283 free(CONST_CAST (char *, path_name
));
1288 if (klass
== NULL_TREE
|| ! CLASS_PARSED_P (klass
))
1290 output_class
= current_class
= klass
;
1291 if (JCF_SEEN_IN_ZIP (current_jcf
))
1292 read_zip_member(current_jcf
,
1293 current_jcf
->zipd
, current_jcf
->zipd
->zipf
);
1294 jcf_parse (current_jcf
);
1295 /* Parsing might change the class, in which case we have to
1296 put it back where we found it. */
1297 if (current_class
!= klass
&& icv
!= NULL_TREE
)
1298 TREE_TYPE (icv
) = current_class
;
1299 klass
= current_class
;
1301 layout_class (klass
);
1302 load_inner_classes (klass
);
1304 output_class
= save_output_class
;
1305 current_class
= save_current_class
;
1306 input_location
= save_location
;
1307 current_jcf
= save_current_jcf
;
1311 /* Load CLASS_OR_NAME. CLASS_OR_NAME can be a mere identifier if
1312 called from the parser, otherwise it's a RECORD_TYPE node. If
1313 VERBOSE is 1, print error message on failure to load a class. */
1315 load_class (tree class_or_name
, int verbose
)
1318 int class_loaded
= 0;
1319 tree class_decl
= NULL_TREE
;
1320 bool is_compiled_class
= false;
1322 /* We've already failed, don't try again. */
1323 if (TREE_CODE (class_or_name
) == RECORD_TYPE
1324 && TYPE_DUMMY (class_or_name
))
1327 /* class_or_name can be the name of the class we want to load */
1328 if (TREE_CODE (class_or_name
) == IDENTIFIER_NODE
)
1329 name
= class_or_name
;
1330 /* In some cases, it's a dependency that we process earlier that
1332 else if (TREE_CODE (class_or_name
) == TREE_LIST
)
1333 name
= TYPE_NAME (TREE_PURPOSE (class_or_name
));
1334 /* Or it's a type in the making */
1336 name
= DECL_NAME (TYPE_NAME (class_or_name
));
1338 class_decl
= IDENTIFIER_CLASS_VALUE (name
);
1339 if (class_decl
!= NULL_TREE
)
1341 tree type
= TREE_TYPE (class_decl
);
1343 = ((TYPE_JCF (type
) && JCF_SEEN_IN_ZIP (TYPE_JCF (type
)))
1344 || CLASS_FROM_CURRENTLY_COMPILED_P (type
));
1349 /* If flag_verify_invocations is unset, we don't try to load a class
1350 unless we're looking for Object (which is fixed by the ABI) or
1351 it's a class that we're going to compile. */
1352 if (flag_verify_invocations
1353 || class_or_name
== object_type_node
1354 || is_compiled_class
1355 || TREE_CODE (class_or_name
) == IDENTIFIER_NODE
)
1359 const char *separator
;
1361 /* We've already loaded it. */
1362 if (IDENTIFIER_CLASS_VALUE (name
) != NULL_TREE
)
1364 tree tmp_decl
= IDENTIFIER_CLASS_VALUE (name
);
1365 if (CLASS_PARSED_P (TREE_TYPE (tmp_decl
)))
1369 if (read_class (name
))
1372 /* We failed loading name. Now consider that we might be looking
1373 for an inner class. */
1374 if ((separator
= strrchr (IDENTIFIER_POINTER (name
), '$'))
1375 || (separator
= strrchr (IDENTIFIER_POINTER (name
), '.')))
1376 name
= get_identifier_with_length (IDENTIFIER_POINTER (name
),
1378 - IDENTIFIER_POINTER (name
)));
1379 /* Otherwise, we failed, we bail. */
1385 /* have we found the class we're looking for? */
1386 tree type_decl
= IDENTIFIER_CLASS_VALUE (saved
);
1387 tree type
= type_decl
? TREE_TYPE (type_decl
) : NULL
;
1388 class_loaded
= type
&& CLASS_PARSED_P (type
);
1394 if (flag_verify_invocations
|| ! flag_indirect_dispatch
)
1397 error ("cannot find file for class %s", IDENTIFIER_POINTER (saved
));
1401 /* This is just a diagnostic during testing, not a real problem. */
1403 warning (0, "cannot find file for class %s",
1404 IDENTIFIER_POINTER (saved
));
1407 if (TREE_CODE (class_or_name
) == RECORD_TYPE
)
1409 set_super_info (0, class_or_name
, object_type_node
, 0);
1410 TYPE_DUMMY (class_or_name
) = 1;
1411 /* We won't be able to output any debug info for this class. */
1412 DECL_IGNORED_P (TYPE_NAME (class_or_name
)) = 1;
1418 /* Parse the .class file JCF. */
1421 jcf_parse (JCF
* jcf
)
1425 bitmap_clear (field_offsets
);
1427 if (jcf_parse_preamble (jcf
) != 0)
1428 fatal_error ("not a valid Java .class file");
1429 code
= jcf_parse_constant_pool (jcf
);
1431 fatal_error ("error while parsing constant pool");
1432 code
= verify_constant_pool (jcf
);
1434 fatal_error ("error in constant pool entry #%d\n", code
);
1436 jcf_parse_class (jcf
);
1437 if (main_class
== NULL_TREE
)
1438 main_class
= current_class
;
1439 if (! quiet_flag
&& TYPE_NAME (current_class
))
1440 fprintf (stderr
, " %s %s",
1441 (jcf
->access_flags
& ACC_INTERFACE
) ? "interface" : "class",
1442 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class
))));
1443 if (CLASS_PARSED_P (current_class
))
1445 /* FIXME - where was first time */
1446 fatal_error ("reading class %s for the second time from %s",
1447 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (current_class
))),
1450 CLASS_PARSED_P (current_class
) = 1;
1452 for (i
= 1; i
< JPOOL_SIZE(jcf
); i
++)
1454 switch (JPOOL_TAG (jcf
, i
))
1456 case CONSTANT_Class
:
1457 get_class_constant (jcf
, i
);
1462 code
= jcf_parse_fields (jcf
);
1464 fatal_error ("error while parsing fields");
1465 code
= jcf_parse_methods (jcf
);
1467 fatal_error ("error while parsing methods");
1468 code
= jcf_parse_final_attributes (jcf
);
1470 fatal_error ("error while parsing final attributes");
1472 if (TYPE_REFLECTION_DATA (current_class
))
1473 annotation_write_byte (JV_DONE_ATTR
);
1475 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1477 /* The fields of class_type_node are already in correct order. */
1478 if (current_class
!= class_type_node
&& current_class
!= object_type_node
)
1479 TYPE_FIELDS (current_class
) = nreverse (TYPE_FIELDS (current_class
));
1481 if (current_class
== object_type_node
)
1482 layout_class_methods (object_type_node
);
1484 vec_safe_push (all_class_list
, TYPE_NAME (current_class
));
1487 /* If we came across inner classes, load them now. */
1489 load_inner_classes (tree cur_class
)
1492 for (current
= DECL_INNER_CLASS_LIST (TYPE_NAME (cur_class
)); current
;
1493 current
= TREE_CHAIN (current
))
1495 tree name
= DECL_NAME (TREE_PURPOSE (current
));
1496 tree decl
= IDENTIFIER_GLOBAL_VALUE (name
);
1497 if (decl
&& ! CLASS_LOADED_P (TREE_TYPE (decl
))
1498 && !CLASS_BEING_LAIDOUT (TREE_TYPE (decl
)))
1499 load_class (name
, 1);
1504 duplicate_class_warning (const char *filename
)
1506 location_t warn_loc
;
1507 linemap_add (line_table
, LC_RENAME
, 0, filename
, 0);
1508 warn_loc
= linemap_line_start (line_table
, 0, 1);
1509 warning_at (warn_loc
, 0, "duplicate class will only be compiled once");
1513 java_layout_seen_class_methods (void)
1516 unsigned end
= vec_safe_length (all_class_list
);
1521 unsigned new_length
;
1523 for (ix
= start
; ix
!= end
; ix
++)
1525 tree decl
= (*all_class_list
)[ix
];
1526 tree cls
= TREE_TYPE (decl
);
1528 input_location
= DECL_SOURCE_LOCATION (decl
);
1530 if (! CLASS_LOADED_P (cls
))
1531 load_class (cls
, 0);
1533 layout_class_methods (cls
);
1536 /* Note that new classes might have been added while laying out
1537 methods, changing the value of all_class_list. */
1538 new_length
= vec_safe_length (all_class_list
);
1539 if (end
!= new_length
)
1550 parse_class_file (void)
1553 location_t save_location
= input_location
;
1555 java_layout_seen_class_methods ();
1557 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (current_class
));
1559 /* Re-enter the current file. */
1560 expanded_location loc
= expand_location (input_location
);
1561 linemap_add (line_table
, LC_ENTER
, 0, loc
.file
, loc
.line
);
1563 file_start_location
= input_location
;
1564 (*debug_hooks
->start_source_file
) (LOCATION_LINE (input_location
),
1565 LOCATION_FILE (input_location
));
1567 java_mark_class_local (current_class
);
1569 gen_indirect_dispatch_tables (current_class
);
1571 for (method
= TYPE_METHODS (current_class
);
1572 method
!= NULL_TREE
; method
= DECL_CHAIN (method
))
1574 JCF
*jcf
= current_jcf
;
1576 if (METHOD_ABSTRACT (method
) || METHOD_DUMMY (method
))
1579 if (METHOD_NATIVE (method
))
1582 int decl_max_locals
;
1586 /* We need to compute the DECL_MAX_LOCALS. We need to take
1587 the wide types into account too. */
1588 for (arg
= TYPE_ARG_TYPES (TREE_TYPE (method
)), decl_max_locals
= 0;
1589 arg
!= end_params_node
;
1590 arg
= TREE_CHAIN (arg
), decl_max_locals
+= 1)
1592 if (TREE_VALUE (arg
) && TYPE_IS_WIDE (TREE_VALUE (arg
)))
1593 decl_max_locals
+= 1;
1595 DECL_MAX_LOCALS (method
) = decl_max_locals
;
1596 start_java_method (method
);
1597 give_name_to_locals (jcf
);
1598 *get_stmts () = build_jni_stub (method
);
1603 if (DECL_CODE_OFFSET (method
) == 0)
1605 current_function_decl
= method
;
1606 error ("missing Code attribute");
1610 input_location
= DECL_SOURCE_LOCATION (TYPE_NAME (current_class
));
1611 if (DECL_LINENUMBERS_OFFSET (method
))
1616 JCF_SEEK (jcf
, DECL_LINENUMBERS_OFFSET (method
));
1617 linenumber_count
= i
= JCF_readu2 (jcf
);
1618 linenumber_table
= ptr
= jcf
->read_ptr
;
1620 for (ptr
+= 2; --i
>= 0; ptr
+= 4)
1622 int line
= GET_u2 (ptr
);
1623 /* Set initial line of input_location to smallest
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
, va_gc
> *predefined_filenames
;
1674 add_predefined_file (tree name
)
1676 vec_safe_push (predefined_filenames
, name
);
1680 predefined_filename_p (tree node
)
1685 FOR_EACH_VEC_SAFE_ELT (predefined_filenames
, ix
, f
)
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_list (void_type_node
, NULL_TREE
));
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 (void)
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", LOCATION_FILE (input_location
));
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 one 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",
1774 LOCATION_FILE (input_location
));
1786 list
= CONST_CAST (char *, main_input_filename
);
1790 for (next
= list
; ; )
1793 if (flag_filelist_file
&& ! in_quotes
1794 && (ch
== '\n' || ch
== '\r' || ch
== '\t' || ch
== ' '
1795 || ch
== '&') /* FIXME */)
1809 if (flag_filelist_file
&& ch
== '"')
1811 in_quotes
= ! in_quotes
;
1826 /* Exclude .java files. */
1827 if (strlen (list
) > 5 && ! strcmp (list
+ strlen (list
) - 5, ".java"))
1833 node
= get_identifier (list
);
1837 /* Exclude file that we see twice on the command line. */
1839 if (IS_A_COMMAND_LINE_FILENAME_P (node
))
1840 duplicate_class_warning (IDENTIFIER_POINTER (node
));
1843 build_translation_unit_decl (node
);
1844 IS_A_COMMAND_LINE_FILENAME_P (node
) = 1;
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 gcc_assert (all_translation_units
->length () == 1);
1863 = IDENTIFIER_POINTER (DECL_NAME ((*all_translation_units
)[0]));
1864 compile_resource_file (resource_name
, resource_filename
);
1869 current_jcf
= main_jcf
;
1870 FOR_EACH_VEC_ELT (*all_translation_units
, ix
, 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_alloc_cleared_JCF ();
1909 current_jcf
->read_state
= finput
;
1910 current_jcf
->filbuf
= jcf_filbuf_from_stdio
;
1911 jcf_parse (current_jcf
);
1912 DECL_SOURCE_LOCATION (node
) = file_start_location
;
1913 TYPE_JCF (current_class
) = current_jcf
;
1914 if (CLASS_FROM_CURRENTLY_COMPILED_P (current_class
))
1916 /* We've already compiled this class. */
1917 duplicate_class_warning (filename
);
1920 CLASS_FROM_CURRENTLY_COMPILED_P (current_class
) = 1;
1921 TREE_TYPE (node
) = current_class
;
1923 else if (magic
== (JCF_u4
)ZIPMAGIC
)
1925 main_jcf
= ggc_alloc_cleared_JCF ();
1926 main_jcf
->read_state
= finput
;
1927 main_jcf
->filbuf
= jcf_filbuf_from_stdio
;
1928 linemap_add (line_table
, LC_ENTER
, false, filename
, 0);
1929 input_location
= linemap_line_start (line_table
, 0, 1);
1930 if (open_in_zip (main_jcf
, filename
, NULL
, 0) < 0)
1931 fatal_error ("bad zip/jar file %s", filename
);
1932 localToFile
= SeenZipFiles
;
1933 /* Register all the classes defined there. */
1934 process_zip_dir ((FILE *) main_jcf
->read_state
);
1935 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1936 parse_zip_file_entries ();
1938 else if (magic
== (JCF_u4
) ZIPEMPTYMAGIC
)
1940 /* Ignore an empty input jar. */
1946 java_push_parser_context ();
1947 java_parser_context_save_global ();
1949 parse_source_file_1 (real_file
, filename
, finput
);
1950 java_parser_context_restore_global ();
1951 java_pop_parser_context (1);
1952 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
1957 FOR_EACH_VEC_ELT (*all_translation_units
, ix
, node
)
1959 input_location
= DECL_SOURCE_LOCATION (node
);
1960 if (CLASS_FILE_P (node
))
1962 /* FIXME: These two flags really should be independent. We
1963 should be able to compile fully binary compatible, but
1964 with flag_verify_invocations on. */
1965 flag_verify_invocations
= ! flag_indirect_dispatch
;
1966 output_class
= current_class
= TREE_TYPE (node
);
1968 current_jcf
= TYPE_JCF (current_class
);
1969 layout_class (current_class
);
1970 load_inner_classes (current_class
);
1971 parse_class_file ();
1972 JCF_FINISH (current_jcf
);
1975 input_location
= save_location
;
1977 bitmap_obstack_release (&bit_obstack
);
1980 /* Arrange for any necessary initialization to happen. */
1981 java_emit_static_constructor ();
1982 gcc_assert (global_bindings_p ());
1986 /* Return the name of the class corresponding to the name of the file
1987 in this zip entry. The result is newly allocated using ALLOC. */
1989 compute_class_name (struct ZipDirectory
*zdir
)
1991 char *class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
1994 int filename_length
= zdir
->filename_length
;
1996 while (filename_length
> 2 && strncmp (class_name_in_zip_dir
, "./", 2) == 0)
1998 class_name_in_zip_dir
+= 2;
1999 filename_length
-= 2;
2002 filename_length
-= strlen (".class");
2003 class_name
= XNEWVEC (char, filename_length
+ 1);
2004 memcpy (class_name
, class_name_in_zip_dir
, filename_length
);
2005 class_name
[filename_length
] = '\0';
2007 for (i
= 0; i
< filename_length
; i
++)
2008 if (class_name
[i
] == '/')
2009 class_name
[i
] = '.';
2014 /* Return 0 if we should skip this entry, 1 if it is a .class file, 2
2015 if it is a property file of some sort. */
2017 classify_zip_file (struct ZipDirectory
*zdir
)
2019 char *class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2021 if (zdir
->filename_length
> 6
2022 && !strncmp (&class_name_in_zip_dir
[zdir
->filename_length
- 6],
2026 /* For now we drop the manifest, but not other information. */
2027 if (zdir
->filename_length
== 20
2028 && !strncmp (class_name_in_zip_dir
, "META-INF/MANIFEST.MF", 20))
2031 /* Drop directory entries. */
2032 if (zdir
->filename_length
> 0
2033 && class_name_in_zip_dir
[zdir
->filename_length
- 1] == '/')
2039 /* Process all class entries found in the zip file. */
2041 parse_zip_file_entries (void)
2043 struct ZipDirectory
*zdir
;
2046 for (i
= 0, zdir
= (ZipDirectory
*)localToFile
->central_directory
;
2047 i
< localToFile
->count
; i
++, zdir
= ZIPDIR_NEXT (zdir
))
2051 switch (classify_zip_file (zdir
))
2058 char *class_name
= compute_class_name (zdir
);
2059 int previous_alias_set
= -1;
2060 klass
= lookup_class (get_identifier (class_name
));
2062 current_jcf
= TYPE_JCF (klass
);
2063 output_class
= current_class
= klass
;
2065 /* This is a dummy class, and now we're compiling it for
2067 gcc_assert (! TYPE_DUMMY (klass
));
2069 /* This is for a corner case where we have a superclass
2070 but no superclass fields.
2072 This can happen if we earlier failed to lay out this
2073 class because its superclass was still in the process
2074 of being laid out; this occurs when we have recursive
2075 class dependencies via inner classes. We must record
2076 the previous alias set and restore it after laying out
2079 FIXME: this really is a kludge. We should figure out a
2080 way to lay out the class properly before this
2082 if (TYPE_SIZE (klass
) && CLASSTYPE_SUPER (klass
)
2083 && integer_zerop (TYPE_SIZE (klass
)))
2085 TYPE_SIZE (klass
) = NULL_TREE
;
2086 previous_alias_set
= TYPE_ALIAS_SET (klass
);
2087 TYPE_ALIAS_SET (klass
) = -1;
2090 if (! CLASS_LOADED_P (klass
))
2092 if (! CLASS_PARSED_P (klass
))
2094 read_zip_member (current_jcf
, zdir
, localToFile
);
2095 jcf_parse (current_jcf
);
2097 layout_class (current_class
);
2098 load_inner_classes (current_class
);
2101 if (previous_alias_set
!= -1)
2102 TYPE_ALIAS_SET (klass
) = previous_alias_set
;
2104 if (TYPE_SIZE (current_class
) != error_mark_node
)
2106 parse_class_file ();
2107 free (current_jcf
->buffer
); /* No longer necessary */
2108 /* Note: there is a way to free this buffer right after a
2109 class seen in a zip file has been parsed. The idea is the
2110 set its jcf in such a way that buffer will be reallocated
2111 the time the code for the class will be generated. FIXME. */
2118 char *file_name
, *class_name_in_zip_dir
, *buffer
;
2120 file_name
= XNEWVEC (char, zdir
->filename_length
+ 1);
2121 class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2122 strncpy (file_name
, class_name_in_zip_dir
, zdir
->filename_length
);
2123 file_name
[zdir
->filename_length
] = '\0';
2126 jcf
->read_state
= finput
;
2127 jcf
->filbuf
= jcf_filbuf_from_stdio
;
2128 jcf
->classname
= NULL
;
2129 jcf
->filename
= file_name
;
2132 if (read_zip_member (jcf
, zdir
, localToFile
) < 0)
2133 fatal_error ("error while reading %s from zip file", file_name
);
2135 buffer
= XNEWVEC (char, zdir
->filename_length
+ 1 +
2136 (jcf
->buffer_end
- jcf
->buffer
));
2137 strcpy (buffer
, file_name
);
2138 /* This is not a typo: we overwrite the trailing \0 of the
2139 file name; this is just how the data is laid out. */
2140 memcpy (buffer
+ zdir
->filename_length
,
2141 jcf
->buffer
, jcf
->buffer_end
- jcf
->buffer
);
2143 compile_resource_data (file_name
, buffer
,
2144 jcf
->buffer_end
- jcf
->buffer
);
2157 /* Read all the entries of the zip file, creates a class and a JCF. Sets the
2158 jcf up for further processing and link it to the created class. */
2161 process_zip_dir (FILE *finput
)
2166 for (i
= 0, zdir
= (ZipDirectory
*)localToFile
->central_directory
;
2167 i
< localToFile
->count
; i
++, zdir
= ZIPDIR_NEXT (zdir
))
2169 char *class_name
, *file_name
, *class_name_in_zip_dir
;
2173 class_name_in_zip_dir
= ZIPDIR_FILENAME (zdir
);
2175 /* Here we skip non-class files; we handle them later. */
2176 if (classify_zip_file (zdir
) != 1)
2179 class_name
= compute_class_name (zdir
);
2180 file_name
= XNEWVEC (char, zdir
->filename_length
+1);
2181 jcf
= ggc_alloc_cleared_JCF ();
2183 strncpy (file_name
, class_name_in_zip_dir
, zdir
->filename_length
);
2184 file_name
[zdir
->filename_length
] = '\0';
2186 klass
= lookup_class (get_identifier (class_name
));
2188 if (CLASS_FROM_CURRENTLY_COMPILED_P (klass
))
2190 /* We've already compiled this class. */
2191 duplicate_class_warning (file_name
);
2194 /* This function is only called when processing a zip file seen
2195 on the command line. */
2196 CLASS_FROM_CURRENTLY_COMPILED_P (klass
) = 1;
2198 jcf
->read_state
= finput
;
2199 jcf
->filbuf
= jcf_filbuf_from_stdio
;
2200 jcf
->classname
= class_name
;
2201 jcf
->filename
= file_name
;
2204 TYPE_JCF (klass
) = jcf
;
2208 #include "gt-java-jcf-parse.h"
2209 #include "gtype-java.h"