1 /* Program to dump out a Java(TM) .class file.
2 Functionally similar to Sun's javap.
4 Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
5 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.
24 Java and all Java-based marks are trademarks or registered trademarks
25 of Sun Microsystems, Inc. in the United States and other countries.
26 The Free Software Foundation is independent of Sun Microsystems, Inc. */
28 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
31 jcf-dump is a program to print out the contents of class files.
32 Usage: jcf-dump [FLAGS] CLASS
34 + the name of a class in the CLASSPATH (e.g "java.lang.String"), or
35 + the name of a class *file* (e.g. "/home/me/work/package/Foo.class").
36 + The name of a .zip or .jar file (which prints all the classes in the
41 Dis-assemble each method.
45 Print nothing if there is no valid "main" method;
46 otherwise, print only the class name.
48 Print output in the style of Sun's javap program. VERY UNFINISHED.
54 #include "coretypes.h"
61 #include "java-tree.h"
70 /* Name of output file, if NULL if stdout. */
71 char *output_file = NULL;
75 int flag_disassemble_methods = 0;
76 int flag_print_class_info = 1;
77 int flag_print_constant_pool = 0;
78 int flag_print_fields = 1;
79 int flag_print_methods = 1;
80 int flag_print_attributes = 1;
82 /* When nonzero, warn when source file is newer than matching class
86 /* Print names of classes that have a "main" method. */
87 int flag_print_main = 0;
89 /* Index in constant pool of this class. */
90 int this_class_index = 0;
92 int class_access_flags = 0;
94 /* Print in format similar to javap. VERY INCOMPLETE. */
95 int flag_javap_compatible = 0;
97 static void print_access_flags (FILE *, uint16, char);
98 static void print_constant_terse (FILE*, JCF*, int, int);
99 static void print_constant (FILE *, JCF *, int, int);
100 static void print_constant_ref (FILE *, JCF *, int);
101 static void disassemble_method (JCF*, const unsigned char *, int);
102 static void print_name (FILE*, JCF*, int);
103 static void print_signature (FILE*, JCF*, int, int);
104 static int utf8_equal_string (struct JCF*, int, const char *);
105 static void usage (void) ATTRIBUTE_NORETURN;
106 static void help (void) ATTRIBUTE_NORETURN;
107 static void version (void) ATTRIBUTE_NORETURN;
108 static void process_class (struct JCF *);
109 static void print_constant_pool (struct JCF *);
110 static void print_exception_table (struct JCF *, const unsigned char *entries,
113 #define PRINT_SIGNATURE_RESULT_ONLY 1
114 #define PRINT_SIGNATURE_ARGS_ONLY 2
117 utf8_equal_string (JCF *jcf, int index, const char * value)
119 if (CPOOL_INDEX_IN_RANGE (&jcf->cpool, index)
120 && JPOOL_TAG (jcf, index) == CONSTANT_Utf8)
122 int len = strlen (value);
123 if (JPOOL_UTF_LENGTH (jcf, index) == len
124 && memcmp (JPOOL_UTF_DATA (jcf, index), value, len) == 0)
130 #define HANDLE_MAGIC(MAGIC, MINOR, MAJOR) \
131 this_class_index = 0; \
132 if (flag_print_class_info) \
134 "Magic number: 0x%0lx, minor_version: %ld, major_version: %ld.\n",\
135 (long) MAGIC, (long) MINOR, (long) MAJOR)
137 #define HANDLE_START_CONSTANT_POOL(COUNT) \
138 if (flag_print_constant_pool) \
139 fprintf (out, "\nConstant pool (count: %d):\n", COUNT)
141 #define HANDLE_SOURCEFILE(INDEX) \
142 { fprintf (out, "Attribute "); \
143 print_constant_terse (out, jcf, attribute_name, CONSTANT_Utf8); \
144 fprintf (out, ", length:%ld, #%d=", (long) attribute_length, INDEX); \
145 print_constant_terse (out, jcf, INDEX, CONSTANT_Utf8); fputc ('\n', out); }
147 #define HANDLE_CLASS_INFO(ACCESS_FLAGS, THIS, SUPER, INTERFACES_COUNT) \
148 this_class_index = THIS; \
149 class_access_flags = ACCESS_FLAGS; \
150 if (flag_print_class_info) \
151 { fprintf (out, "\nAccess flags: 0x%x", ACCESS_FLAGS); \
152 print_access_flags (out, ACCESS_FLAGS, 'c'); \
154 fprintf (out, "This class: "); \
155 print_constant_terse_with_index (out, jcf, THIS, CONSTANT_Class); \
156 if (flag_print_constant_pool || SUPER != 0) \
157 fprintf (out, ", super: "); \
158 if (flag_print_constant_pool) \
160 fprintf (out, "%d", SUPER); \
165 print_constant_terse (out, jcf, SUPER, CONSTANT_Class); \
166 fprintf (out, "\nInterfaces (count: %d):\n", INTERFACES_COUNT); \
169 #define IGNORE_ATTRIBUTE(JCF, NAME, NAME_LENGTH) \
170 (flag_print_attributes <= 0)
172 #define HANDLE_CLASS_INTERFACE(INDEX) \
173 if (flag_print_class_info) \
174 { fprintf (out, "- Implements: "); \
175 print_constant_terse_with_index (out, jcf, INDEX, CONSTANT_Class); \
178 #define HANDLE_START_FIELDS(FIELDS_COUNT) \
179 if (flag_print_fields) \
180 fprintf (out, "\nFields (count: %d):\n", FIELDS_COUNT)
182 #define HANDLE_START_FIELD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
183 if (flag_print_fields) \
184 { fprintf (out, "Field name:"); \
185 print_constant_terse (out, jcf, NAME, CONSTANT_Utf8); \
186 print_access_flags (out, ACCESS_FLAGS, 'f'); \
187 fprintf (out, " Signature: "); \
188 if (flag_print_constant_pool) \
189 fprintf (out, "%d=", SIGNATURE); \
190 print_signature (out, jcf, SIGNATURE, 0); \
191 fputc ('\n', out); } \
193 flag_print_attributes--;
195 #define HANDLE_END_FIELD() \
196 if (! flag_print_fields) \
197 flag_print_attributes++;
199 #define HANDLE_START_METHODS(METHODS_COUNT) \
200 if (flag_print_methods) \
201 fprintf (out, "\nMethods (count: %d):\n", METHODS_COUNT); \
203 flag_print_attributes--;
206 #define HANDLE_END_METHODS() \
207 if (! flag_print_methods) \
208 flag_print_attributes++;
210 #define HANDLE_METHOD(ACCESS_FLAGS, NAME, SIGNATURE, ATTRIBUTE_COUNT) \
212 if (flag_print_methods) \
214 if (flag_javap_compatible) \
216 fprintf (out, " "); \
217 print_access_flags (out, ACCESS_FLAGS, 'm'); \
219 print_signature (out, jcf, SIGNATURE, PRINT_SIGNATURE_RESULT_ONLY); \
221 print_constant_terse (out, jcf, NAME, CONSTANT_Utf8); \
222 print_signature (out, jcf, SIGNATURE, PRINT_SIGNATURE_ARGS_ONLY); \
227 fprintf (out, "\nMethod name:"); \
228 print_constant_terse (out, jcf, NAME, CONSTANT_Utf8); \
229 print_access_flags (out, ACCESS_FLAGS, 'm'); \
230 fprintf (out, " Signature: "); \
231 if (flag_print_constant_pool) \
232 fprintf (out, "%d=", SIGNATURE); \
233 print_signature (out, jcf, SIGNATURE, 0); \
237 if (flag_print_main && ACCESS_FLAGS == (ACC_STATIC|ACC_PUBLIC) \
238 && utf8_equal_string (jcf, NAME, "main") \
239 && utf8_equal_string (jcf, SIGNATURE, "([Ljava/lang/String;)V") \
240 && this_class_index > 0 \
241 && (class_access_flags & ACC_PUBLIC)) \
243 print_constant_terse(out, jcf, this_class_index, CONSTANT_Class); \
248 #define COMMON_HANDLE_ATTRIBUTE(JCF, INDEX, LENGTH) \
249 ( fprintf (out, "Attribute "), \
250 print_constant_terse (out, jcf, INDEX, CONSTANT_Utf8), \
251 fprintf (out, ", length:%ld", (long) LENGTH) )
253 #define HANDLE_CONSTANTVALUE(VALUE_INDEX) \
254 ( COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length), \
255 fprintf (out, ", value: "), \
256 print_constant_ref (out, jcf, VALUE_INDEX), \
257 fprintf (out, "\n") )
259 #define HANDLE_CODE_ATTRIBUTE(MAX_STACK, MAX_LOCALS, CODE_LENGTH) \
260 { COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length); \
261 fprintf (out, ", max_stack:%ld, max_locals:%ld, code_length:%ld\n", \
262 (long) MAX_STACK, (long) MAX_LOCALS, (long) CODE_LENGTH); \
263 disassemble_method (jcf, jcf->read_ptr, CODE_LENGTH); }
265 #define HANDLE_EXCEPTION_TABLE(ENTRIES, COUNT) \
266 print_exception_table (jcf, ENTRIES, COUNT)
268 #define HANDLE_EXCEPTIONS_ATTRIBUTE(COUNT) \
269 { int n = (COUNT); int i; \
270 COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length); \
271 fprintf (out, ", count: %d\n", n); \
272 for (i = 0; i < n; i++) {\
273 int ex_index = JCF_readu2 (jcf); \
274 fprintf (out, "%3d: ", i); \
275 print_constant_ref (out, jcf, ex_index); \
276 fputc ('\n', out); } }
278 #define HANDLE_LOCALVARIABLETABLE_ATTRIBUTE(COUNT) \
279 { int n = (COUNT); int i; \
280 COMMON_HANDLE_ATTRIBUTE(JCF, attribute_name, attribute_length); \
281 fprintf (out, ", count: %d\n", n); \
282 for (i = 0; i < n; i++) {\
283 int start_pc = JCF_readu2 (jcf); \
284 int length = JCF_readu2 (jcf); \
285 int name_index = JCF_readu2 (jcf); \
286 int signature_index = JCF_readu2 (jcf); \
287 int slot = JCF_readu2 (jcf); \
288 fprintf (out, " slot#%d: name: ", slot); \
289 if (flag_print_constant_pool) \
290 fprintf (out, "%d=", name_index); \
291 print_name (out, jcf, name_index); \
292 fprintf (out, ", type: "); \
293 if (flag_print_constant_pool) \
294 fprintf (out, "%d=", signature_index); \
295 print_signature (out, jcf, signature_index, 0); \
296 fprintf (out, " (pc: %d length: %d)\n", start_pc, length); }}
298 #define HANDLE_LINENUMBERTABLE_ATTRIBUTE(COUNT) \
299 { int n = (COUNT); int i; \
300 COMMON_HANDLE_ATTRIBUTE(jcf, attribute_name, attribute_length); \
301 fprintf (out, ", count: %d\n", n); \
302 if (flag_disassemble_methods) \
303 for (i = 0; i < n; i++) {\
304 int start_pc = JCF_readu2 (jcf); \
305 int line_number = JCF_readu2 (jcf); \
306 fprintf (out, " line: %d at pc: %d\n", line_number, start_pc); }\
308 JCF_SKIP (jcf, 4 * n); }
310 #define HANDLE_INNERCLASSES_ATTRIBUTE(COUNT) \
312 COMMON_HANDLE_ATTRIBUTE(jcf, attribute_name, attribute_length); \
315 uint16 inner_class_info_index = JCF_readu2 (jcf); \
316 uint16 outer_class_info_index = JCF_readu2 (jcf); \
317 uint16 inner_name_index = JCF_readu2 (jcf); \
318 uint16 inner_class_access_flags = JCF_readu2 (jcf); \
320 if (flag_print_class_info) \
322 fprintf (out, "\n inner: "); \
323 if (inner_class_info_index == 0) \
324 fprintf (out, " (no inner info index)"); \
326 print_constant_terse_with_index (out, jcf, \
327 inner_class_info_index, \
329 if (inner_name_index == 0) \
330 fprintf (out, " (anonymous)"); \
331 else if (verbose || flag_print_constant_pool) \
333 fprintf (out, " ("); \
334 print_constant_terse_with_index (out, jcf, inner_name_index, \
338 fprintf (out, ", access flags: 0x%x", inner_class_access_flags); \
339 print_access_flags (out, inner_class_access_flags, 'c'); \
340 fprintf (out, ", outer class: "); \
341 if (outer_class_info_index == 0) \
342 fprintf (out, "(not a member)"); \
344 print_constant_terse_with_index (out, jcf, \
345 outer_class_info_index, \
349 if (flag_print_class_info) \
353 #define HANDLE_SOURCEDEBUGEXTENSION_ATTRIBUTE(LENGTH) \
354 { int i, n = (LENGTH), c = 0; \
355 COMMON_HANDLE_ATTRIBUTE(jcf, attribute_name, attribute_length); \
357 for (i = 0; i < n; i++) { c = JCF_readu(jcf); fputc(c, out); } \
358 if (c != '\r' && c != '\n') fputc('\n', out); }
360 #define PROCESS_OTHER_ATTRIBUTE(JCF, INDEX, LENGTH) \
361 { COMMON_HANDLE_ATTRIBUTE(JCF, INDEX, LENGTH); \
362 fputc ('\n', out); JCF_SKIP (JCF, LENGTH); }
364 #define START_FINAL_ATTRIBUTES(ATTRIBUTES_COUNT) \
365 if (flag_print_attributes > 0) \
366 fprintf (out, "\nAttributes (count: %d):\n", attributes_count);
371 print_constant_ref (FILE *stream, JCF *jcf, int index)
373 if (index <= 0 || index >= JPOOL_SIZE(jcf))
374 fprintf (stream, "<out of range>");
377 if (flag_print_constant_pool)
378 fprintf (stream, "#%d=", index);
380 print_constant (stream, jcf, index, 1);
385 /* Print the access flags given by FLAGS.
386 The CONTEXT is one of 'c' (class flags), 'f' (field flags),
387 or 'm' (method flags). */
390 print_access_flags (FILE *stream, uint16 flags, char context)
392 if (flags & ACC_PUBLIC) fprintf (stream, " public");
393 if (flags & ACC_PRIVATE) fprintf (stream, " private");
394 if (flags & ACC_PROTECTED) fprintf (stream, " protected");
395 if (flags & ACC_ABSTRACT) fprintf (stream, " abstract");
396 if (flags & ACC_STATIC) fprintf (stream, " static");
397 if (flags & ACC_FINAL) fprintf (stream, " final");
398 if (flags & ACC_TRANSIENT) fprintf (stream, " transient");
399 if (flags & ACC_VOLATILE) fprintf (stream, " volatile");
400 if (flags & ACC_NATIVE) fprintf (stream, " native");
401 if (flags & ACC_SYNCHRONIZED)
404 fprintf (stream, " super");
406 fprintf (stream, " synchronized");
408 if (flags & ACC_INTERFACE) fprintf (stream, " interface");
409 if (flags & ACC_STRICT) fprintf (stream, " strictfp");
414 print_name (FILE* stream, JCF* jcf, int name_index)
416 if (JPOOL_TAG (jcf, name_index) != CONSTANT_Utf8)
417 fprintf (stream, "<not a UTF8 constant>");
419 jcf_print_utf8 (stream, JPOOL_UTF_DATA (jcf,name_index),
420 JPOOL_UTF_LENGTH (jcf, name_index));
423 /* If the type of the constant at INDEX matches EXPECTED,
424 print it tersely, otherwise more verbosely. */
427 print_constant_terse (FILE *out, JCF *jcf, int index, int expected)
429 if (! CPOOL_INDEX_IN_RANGE (&jcf->cpool, index))
430 fprintf (out, "<constant pool index %d not in range>", index);
431 else if (JPOOL_TAG (jcf, index) != expected)
433 fprintf (out, "<Unexpected constant type ");
434 print_constant (out, jcf, index, 1);
438 print_constant (out, jcf, index, 0);
442 print_constant_terse_with_index (FILE *out, JCF *jcf, int index, int expected)
444 if (flag_print_constant_pool)
445 fprintf (out, "%d=", index);
446 print_constant_terse (out, jcf, index, expected);
449 /* Print the constant at INDEX in JCF's constant pool.
450 If verbosity==0, print very tersely (no extraneous text).
451 If verbosity==1, prefix the type of the constant.
452 If verbosity==2, add more descriptive text. */
455 print_constant (FILE *out, JCF *jcf, int index, int verbosity)
460 int kind = JPOOL_TAG (jcf, index);
464 n = JPOOL_USHORT1 (jcf, index);
468 fprintf (out, "Class name: %d=", n);
470 fprintf (out, "Class ");
472 if (! CPOOL_INDEX_IN_RANGE (&jcf->cpool, n))
473 fprintf (out, "<out of range>");
474 else if (verbosity < 2 && JPOOL_TAG (jcf, n) == CONSTANT_Utf8)
476 int len = JPOOL_UTF_LENGTH (jcf, n);
477 jcf_print_utf8_replace (out, JPOOL_UTF_DATA(jcf,n), len, '/', '.');
480 print_constant_terse (out, jcf, n, CONSTANT_Utf8);
482 case CONSTANT_Fieldref:
483 str = "Field"; goto field_or_method;
484 case CONSTANT_Methodref:
485 str = "Method"; goto field_or_method;
486 case CONSTANT_InterfaceMethodref:
487 str = "InterfaceMethod"; goto field_or_method;
490 uint16 tclass = JPOOL_USHORT1 (jcf, index);
491 uint16 name_and_type = JPOOL_USHORT2 (jcf, index);
493 fprintf (out, "%sref class: %d=", str, tclass);
494 else if (verbosity > 0)
495 fprintf (out, "%s ", str);
496 print_constant_terse (out, jcf, tclass, CONSTANT_Class);
500 fprintf (out, " name_and_type: %d=<", name_and_type);
501 print_constant_terse (out, jcf, name_and_type, CONSTANT_NameAndType);
506 case CONSTANT_String:
507 j = JPOOL_USHORT1 (jcf, index);
511 fprintf (out, "String %d=", j);
513 fprintf (out, "String ");
515 print_constant_terse (out, jcf, j, CONSTANT_Utf8);
517 case CONSTANT_Integer:
519 fprintf (out, "Integer ");
520 num = JPOOL_INT (jcf, index);
524 fprintf (out, "Long ");
525 num = JPOOL_LONG (jcf, index);
530 format_int (buffer, num, 10);
531 fprintf (out, "%s", buffer);
534 format_uint (buffer, (uint64)num, 16);
535 fprintf (out, "=0x%s", buffer);
541 jfloat fnum = JPOOL_FLOAT (jcf, index);
544 fputs ("Float ", out);
549 if (JFLOAT_FINITE (fnum))
552 int exponent = fnum.exponent - JFLOAT_EXP_BIAS;
554 uint32 mantissa = fnum.mantissa;
555 if (fnum.exponent == 0)
559 /* Normal; add the implicit bit. */
560 mantissa |= ((uint32)1 << 23);
562 f = frexp (mantissa, &dummy);
563 f = ldexp (f, exponent + 1);
564 fprintf (out, "%.10g", f);
568 if (fnum.mantissa == 0)
570 else if (fnum.mantissa & JFLOAT_QNAN_MASK)
571 fprintf (out, "QNaN(%u)", (fnum.mantissa & ~JFLOAT_QNAN_MASK));
573 fprintf (out, "SNaN(%u)", (fnum.mantissa & ~JFLOAT_QNAN_MASK));
577 fprintf (out, ", bits = 0x%08lx", JPOOL_UINT (jcf, index));
581 case CONSTANT_Double:
583 jdouble dnum = JPOOL_DOUBLE (jcf, index);
586 fputs ("Double ", out);
591 if (JDOUBLE_FINITE (dnum))
594 int exponent = dnum.exponent - JDOUBLE_EXP_BIAS;
596 uint64 mantissa = ((((uint64) dnum.mantissa0) << 32)
598 if (dnum.exponent == 0)
602 /* Normal; add the implicit bit. */
603 mantissa |= ((uint64)1 << 52);
605 d = frexp (mantissa, &dummy);
606 d = ldexp (d, exponent + 1);
607 fprintf (out, "%.20g", d);
611 uint64 mantissa = dnum.mantissa0 & ~JDOUBLE_QNAN_MASK;
612 mantissa = (mantissa << 32) + dnum.mantissa1;
614 if (dnum.mantissa0 == 0 && dnum.mantissa1 == 0)
616 else if (dnum.mantissa0 & JDOUBLE_QNAN_MASK)
617 fprintf (out, "QNaN(%llu)", (unsigned long long)mantissa);
619 fprintf (out, "SNaN(%llu)", (unsigned long long)mantissa);
624 hi = JPOOL_UINT (jcf, index);
625 lo = JPOOL_UINT (jcf, index + 1);
626 fprintf (out, ", bits = 0x%08lx%08lx", (long) hi, (long) lo);
630 case CONSTANT_NameAndType:
632 uint16 name = JPOOL_USHORT1 (jcf, index);
633 uint16 sig = JPOOL_USHORT2 (jcf, index);
637 fprintf (out, "NameAndType name: %d=", name);
639 fprintf (out, "NameAndType ");
641 print_name (out, jcf, name);
645 fprintf (out, ", signature: %d=", sig);
646 print_signature (out, jcf, sig, 0);
651 const unsigned char *str = JPOOL_UTF_DATA (jcf, index);
652 int length = JPOOL_UTF_LENGTH (jcf, index);
654 { /* Print as 8-bit bytes. */
655 fputs ("Utf8: \"", out);
656 while (--length >= 0)
657 jcf_print_char (out, *str++);
660 { /* Print as Unicode. */
662 jcf_print_utf8 (out, str, length);
668 fprintf (out, "(Unknown constant type %d)", kind);
673 print_constant_pool (JCF *jcf)
676 for (i = 1; i < JPOOL_SIZE(jcf); i++)
678 int kind = JPOOL_TAG (jcf, i);
679 fprintf (out, "#%d: ", i);
680 print_constant (out, jcf, i, 2);
682 if (kind == CONSTANT_Double || kind == CONSTANT_Long)
683 i++; /* These take up two slots in the constant table */
688 print_signature_type (FILE* stream, const unsigned char **ptr,
689 const unsigned char *limit)
698 for ((*ptr)++; (*ptr) < limit && ISDIGIT (**ptr); (*ptr)++)
700 array_size = (array_size < 0 ? 0 : 10 * array_size) + *(*ptr) - '0';
702 print_signature_type (stream, ptr, limit);
703 if (array_size == -1)
704 fprintf (stream, "[]");
706 fprintf (stream, "[%d]", array_size);
711 fputc (*(*ptr)++, stream);
712 for (; **ptr != ')' && *ptr < limit; nargs++)
716 print_signature_type (stream, ptr, limit);
720 fputc (*(*ptr)++, stream);
721 print_signature_type (stream, ptr, limit);
724 fprintf (stream, "???");
728 case 'B': fprintf (stream, "byte"); (*ptr)++; break;
729 case 'C': fprintf (stream, "char"); (*ptr)++; break;
730 case 'D': fprintf (stream, "double"); (*ptr)++; break;
731 case 'F': fprintf (stream, "float"); (*ptr)++; break;
732 case 'S': fprintf (stream, "short"); (*ptr)++; break;
733 case 'I': fprintf (stream, "int"); (*ptr)++; break;
734 case 'J': fprintf (stream, "long"); (*ptr)++; break;
735 case 'Z': fprintf (stream, "boolean"); (*ptr)++; break;
736 case 'V': fprintf (stream, "void"); (*ptr)++; break;
739 for ((*ptr)++; (*ptr)<limit && *(*ptr) != ';'; (*ptr)++)
740 jcf_print_char (stream, *(*ptr) == '/' ? '.' : *(*ptr));
745 jcf_print_char (stream, *(*ptr)++);
750 print_signature (FILE* stream, JCF *jcf, int signature_index, int options)
752 if (JPOOL_TAG (jcf, signature_index) != CONSTANT_Utf8)
753 print_constant_terse (out, jcf, signature_index, CONSTANT_Utf8);
756 const unsigned char *str = JPOOL_UTF_DATA (jcf, signature_index);
757 int length = JPOOL_UTF_LENGTH (jcf, signature_index);
758 const unsigned char *limit;
759 limit = str + length;
761 fprintf (stream, "<empty signature string>");
764 if (options & PRINT_SIGNATURE_RESULT_ONLY)
766 while (str < limit && *str++ != ')') ;
768 if (options & PRINT_SIGNATURE_ARGS_ONLY)
772 while (str < limit && *str != ')')
774 print_signature_type (stream, &str, limit);
776 fputs (", ", stream);
782 print_signature_type (stream, &str, limit);
785 fprintf (stream, "<junk:");
786 jcf_print_utf8 (stream, str, limit - str);
796 print_exception_table (JCF *jcf, const unsigned char *entries, int count)
798 /* Print exception table. */
802 const unsigned char *ptr = entries;
803 fprintf (out, "Exceptions (count: %d):\n", i);
804 for (; --i >= 0; ptr+= 8)
806 int start_pc = GET_u2 (ptr);
807 int end_pc = GET_u2 (ptr+2);
808 int handler_pc = GET_u2 (ptr+4);
809 int catch_type = GET_u2 (ptr+6);
810 fprintf (out, " start: %d, end: %d, handler: %d, type: ",
811 start_pc, end_pc, handler_pc);
813 fputs ("0 /* finally */", out);
815 print_constant_terse_with_index (out, jcf,
816 catch_type, CONSTANT_Class);
822 #include "jcf-reader.c"
825 process_class (JCF *jcf)
828 if (jcf_parse_preamble (jcf) != 0)
829 fprintf (stderr, _("Not a valid Java .class file.\n"));
831 /* Parse and possibly print constant pool */
832 code = jcf_parse_constant_pool (jcf);
835 fprintf (stderr, _("error while parsing constant pool\n"));
836 exit (FATAL_EXIT_CODE);
838 code = verify_constant_pool (jcf);
841 fprintf (stderr, _("error in constant pool entry #%d\n"), code);
842 exit (FATAL_EXIT_CODE);
844 if (flag_print_constant_pool)
845 print_constant_pool (jcf);
847 jcf_parse_class (jcf);
848 code = jcf_parse_fields (jcf);
851 fprintf (stderr, _("error while parsing fields\n"));
852 exit (FATAL_EXIT_CODE);
854 code = jcf_parse_methods (jcf);
857 fprintf (stderr, _("error while parsing methods\n"));
858 exit (FATAL_EXIT_CODE);
860 code = jcf_parse_final_attributes (jcf);
863 fprintf (stderr, _("error while parsing final attributes\n"));
864 exit (FATAL_EXIT_CODE);
866 jcf->filename = NULL;
871 /* This is used to mark options with no short value. */
872 #define LONG_OPT(Num) ((Num) + 128)
874 #define OPT_classpath LONG_OPT (0)
875 #define OPT_CLASSPATH OPT_classpath
876 #define OPT_bootclasspath LONG_OPT (1)
877 #define OPT_extdirs LONG_OPT (2)
878 #define OPT_HELP LONG_OPT (3)
879 #define OPT_VERSION LONG_OPT (4)
880 #define OPT_JAVAP LONG_OPT (5)
882 static const struct option options[] =
884 { "classpath", required_argument, NULL, OPT_classpath },
885 { "bootclasspath", required_argument, NULL, OPT_bootclasspath },
886 { "extdirs", required_argument, NULL, OPT_extdirs },
887 { "CLASSPATH", required_argument, NULL, OPT_CLASSPATH },
888 { "help", no_argument, NULL, OPT_HELP },
889 { "verbose", no_argument, NULL, 'v' },
890 { "version", no_argument, NULL, OPT_VERSION },
891 { "javap", no_argument, NULL, OPT_JAVAP },
892 { "print-main", no_argument, &flag_print_main, 1 },
893 { "print-constants", no_argument, &flag_print_constant_pool, 1 },
894 { NULL, no_argument, NULL, 0 }
900 fprintf (stderr, _("Try 'jcf-dump --help' for more information.\n"));
907 printf (_("Usage: jcf-dump [OPTION]... CLASS...\n\n"));
908 printf (_("Display contents of a class file in readable form.\n\n"));
909 printf (_(" -c Disassemble method bodies\n"));
910 printf (_(" --javap Generate output in 'javap' format\n"));
912 printf (_(" --classpath PATH Set path to find .class files\n"));
913 printf (_(" -IDIR Append directory to class path\n"));
914 printf (_(" --bootclasspath PATH Override built-in class path\n"));
915 printf (_(" --extdirs PATH Set extensions directory path\n"));
916 printf (_(" -o FILE Set output file name\n"));
918 printf (_(" --help Print this help, then exit\n"));
919 printf (_(" --version Print version number, then exit\n"));
920 printf (_(" -v, --verbose Print extra information while running\n"));
922 printf (_("For bug reporting instructions, please see:\n"
923 "%s.\n"), bug_report_url);
930 printf ("jcf-dump (GCC) %s\n\n", version_string);
931 printf ("Copyright %s 2004 Free Software Foundation, Inc.\n", _("(C)"));
932 printf (_("This is free software; see the source for copying conditions. There is NO\n"
933 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
938 main (int argc, char** argv)
943 /* Unlock the stdio streams. */
944 unlock_stream (stdin);
945 unlock_stream (stdout);
946 unlock_stream (stderr);
952 fprintf (stderr, _("jcf-dump: no classes specified\n"));
958 /* We use getopt_long_only to allow single `-' long options. For
959 some of our options this is more natural. */
960 while ((opt = getopt_long_only (argc, argv, "o:I:vc", options, NULL)) != -1)
965 /* Already handled. */
969 output_file = optarg;
973 jcf_path_include_arg (optarg);
981 flag_disassemble_methods = 1;
985 jcf_path_classpath_arg (optarg);
988 case OPT_bootclasspath:
989 jcf_path_bootclasspath_arg (optarg);
993 jcf_path_extdirs_arg (optarg);
1005 flag_javap_compatible++;
1006 flag_print_constant_pool = 0;
1007 flag_print_attributes = 0;
1015 if (verbose && ! flag_javap_compatible)
1016 flag_print_constant_pool = 1;
1020 fprintf (stderr, _("jcf-dump: no classes specified\n"));
1024 jcf_path_seal (verbose);
1026 if (flag_print_main)
1028 flag_print_fields = 0;
1029 flag_print_methods = 0;
1030 flag_print_constant_pool = 0;
1031 flag_print_attributes = 0;
1032 flag_print_class_info = 0;
1037 out = fopen (output_file, "w");
1040 fprintf (stderr, _("Cannot open '%s' for output.\n"), output_file);
1041 return FATAL_EXIT_CODE;
1049 fprintf (out, "Reading .class from <standard input>.\n");
1050 open_class ("<stdio>", jcf, 0, NULL);
1051 process_class (jcf);
1055 for (argi = optind; argi < argc; argi++)
1057 char *arg = argv[argi];
1058 const char *class_filename = find_class (arg, strlen (arg), jcf, 0);
1059 if (class_filename == NULL)
1060 class_filename = find_classfile (arg, jcf, NULL);
1061 if (class_filename == NULL)
1063 perror ("Could not find class");
1064 return FATAL_EXIT_CODE;
1067 if (GET_u4 (jcf->read_ptr) == ZIPMAGIC)
1069 long compressed_size, member_size;
1070 int compression_method, filename_length, extra_length;
1071 int general_purpose_bits;
1072 const char *filename;
1074 if (flag_print_class_info)
1075 fprintf (out, "Reading classes from archive %s.\n",
1080 jcf_filbuf_t save_filbuf = jcf->filbuf;
1081 long magic = JCF_readu4_le (jcf);
1082 if (magic == 0x02014b50 || magic == 0x06054b50)
1083 break; /* got to central directory */
1084 if (magic != 0x04034b50) /* ZIPMAGIC (little-endian) */
1086 fprintf (stderr, _("bad format of .zip/.jar archive\n"));
1087 return FATAL_EXIT_CODE;
1091 general_purpose_bits = JCF_readu2_le (jcf);
1092 compression_method = JCF_readu2_le (jcf);
1094 compressed_size = JCF_readu4_le (jcf);
1095 member_size = JCF_readu4_le (jcf);
1096 filename_length = JCF_readu2_le (jcf);
1097 extra_length = JCF_readu2_le (jcf);
1098 total_length = filename_length + extra_length
1100 if (jcf->read_end - jcf->read_ptr < total_length)
1101 jcf_trim_old_input (jcf);
1102 JCF_FILL (jcf, total_length);
1103 filename = (const char *) jcf->read_ptr;
1104 JCF_SKIP (jcf, filename_length);
1105 JCF_SKIP (jcf, extra_length);
1106 if (filename_length > 0
1107 && filename[filename_length-1] == '/')
1109 if (flag_print_class_info)
1110 fprintf (out, "[Skipping directory %.*s]\n",
1111 filename_length, filename);
1114 else if (compression_method != 0)
1116 if (flag_print_class_info)
1117 fprintf (out, "[Skipping compressed file %.*s]\n",
1118 filename_length, filename);
1121 else if (member_size < 4
1122 || GET_u4 (jcf->read_ptr) != 0xcafebabe)
1124 if (flag_print_class_info)
1125 fprintf (out, "[Skipping non-.class member %.*s]\n",
1126 filename_length, filename);
1131 if (flag_print_class_info)
1132 fprintf (out, "Reading class member: %.*s.\n",
1133 filename_length, filename);
1137 JCF_SKIP (jcf, compressed_size);
1141 unsigned char *save_end;
1142 jcf->filbuf = jcf_unexpected_eof;
1143 save_end = jcf->read_end;
1144 jcf->read_end = jcf->read_ptr + compressed_size;
1145 process_class (jcf);
1146 jcf->filbuf = save_filbuf;
1147 jcf->read_end = save_end;
1153 if (flag_print_class_info)
1154 fprintf (out, "Reading .class from %s.\n", class_filename);
1155 process_class (jcf);
1161 return SUCCESS_EXIT_CODE;
1167 disassemble_method (JCF* jcf, const unsigned char *byte_ops, int len)
1173 if (flag_disassemble_methods == 0)
1175 #define BCODE byte_ops
1176 for (PC = 0; PC < len;)
1181 switch (byte_ops[PC++])
1184 /* This is the actual code emitted for each of opcodes in javaops.def.
1185 The actual opcode-specific stuff is handled by the OPKIND macro.
1186 I.e. for an opcode whose OPKIND is BINOP, the BINOP will be called.
1187 Those macros are defined below. The OPKINDs that do not have any
1188 inline parameters (such as BINOP) and therefore do mot need anything
1189 else to me printed out just use an empty body. */
1191 #define JAVAOP(OPNAME, OPCODE, OPKIND, OPERAND_TYPE, OPERAND_VALUE) \
1193 fprintf (out, "%3d: %s", oldpc, #OPNAME); \
1194 OPKIND(OPERAND_TYPE, OPERAND_VALUE); \
1195 fputc ('\n', out); \
1198 #define CONST_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
1199 #define CONST_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
1200 #define VAR_INDEX_1 (saw_index = 1, IMMEDIATE_u1)
1201 #define VAR_INDEX_2 (saw_index = 1, IMMEDIATE_u2)
1203 #define CHECK_PC_IN_RANGE(PC) (PC < 0 || PC > len ? \
1204 (fprintf(stderr, _("Bad byte codes.\n")), exit(-1), 0) : 1)
1206 /* Print out operand (if not implied by the opcode) for PUSCH opcodes.
1207 These all push a constant onto the opcode stack. */
1208 #define PUSHC(OPERAND_TYPE, OPERAND_VALUE) \
1209 saw_index = 0, i = (OPERAND_VALUE); \
1210 if (oldpc+1 == PC) /* nothing */; \
1211 else if (saw_index) fprintf (out, " "), print_constant_ref (out, jcf, i); \
1212 else fprintf (out, " %d", i);
1214 /* Print out operand (a local variable index) for LOAD opcodes.
1215 These all push local variable onto the opcode stack. */
1216 #define LOAD(OPERAND_TYPE, OPERAND_VALUE) \
1217 INT_temp = saw_wide ? IMMEDIATE_u2 : (OPERAND_VALUE); goto load_store;
1219 /* Handle STORE opcodes same as LOAD opcodes.
1220 These all store a value from the opcode stack in a local variable. */
1223 /* Handle more kind of opcodes. */
1224 #define STACK(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
1225 #define UNOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
1226 #define BINOP(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
1227 #define CONVERT(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
1228 #define CONVERT2(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
1229 #define RETURN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
1230 #define UNKNOWN(OPERAND_TYPE, OPERAND_VALUE) /* nothing */
1232 /* Handle putfield and getfield opcodes, with static versions. */
1233 #define FIELD(MAYBE_STATIC, PUT_OR_GET) \
1234 fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2)
1236 /* Print operand for invoke opcodes. */
1237 #define INVOKE(OPERAND_TYPE, OPERAND_VALUE) \
1238 fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2);\
1239 if (OPERAND_VALUE) /* for invokeinterface */ \
1240 { int nargs = IMMEDIATE_u1; PC++; \
1241 fprintf (out, " nargs:%d", nargs); }
1243 #define OBJECT(OPERAND_TYPE, OPERAND_VALUE) \
1244 fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2);
1246 #define ARRAY(OPERAND_TYPE, SUBOP) \
1247 ARRAY_##SUBOP(OPERAND_TYPE)
1248 /* Handle sub-categories of ARRAY opcodes. */
1249 #define ARRAY_LOAD(TYPE) /* nothing */
1250 #define ARRAY_STORE(TYPE) /* nothing */
1251 #define ARRAY_LENGTH(TYPE) /* nothing */
1252 #define ARRAY_NEW(TYPE) ARRAY_NEW_##TYPE
1253 #define ARRAY_NEW_NUM \
1254 INT_temp = IMMEDIATE_u1; \
1255 { switch ((int) INT_temp) { \
1256 case 4: fputs (" boolean", out); break; \
1257 case 5: fputs (" char", out); break; \
1258 case 6: fputs (" float", out); break; \
1259 case 7: fputs (" double", out); break; \
1260 case 8: fputs (" byte", out); break; \
1261 case 9: fputs (" short", out); break; \
1262 case 10: fputs (" int", out); break; \
1263 case 11: fputs (" long", out); break; \
1264 default: fprintf (out, " <unknown type code %ld>", (long)INT_temp); break;\
1267 #define ARRAY_NEW_PTR \
1268 fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2);
1270 #define ARRAY_NEW_MULTI \
1271 fputc (' ', out); print_constant_ref (out, jcf, IMMEDIATE_u2); \
1272 fprintf (out, " %d", IMMEDIATE_u1); /* number of dimensions */
1274 #define TEST(OPERAND_TYPE, OPERAND_VALUE) \
1275 fprintf (out, " %d", oldpc + IMMEDIATE_s2)
1277 #define BRANCH(OPERAND_TYPE, OPERAND_VALUE) \
1278 saw_index = 0, INT_temp = (OPERAND_VALUE); \
1279 fprintf (out, " %ld", (long) (saw_index ? INT_temp : oldpc + INT_temp))
1281 #define JSR(OPERAND_TYPE, OPERAND_VALUE) \
1282 saw_index = 0, INT_temp = (OPERAND_VALUE); \
1283 fprintf (out, " %ld", (long) (saw_index ? INT_temp : oldpc + INT_temp))
1285 #undef RET /* Defined by config/i386/i386.h */
1286 #define RET(OPERAND_TYPE, OPERAND_VALUE) \
1287 INT_temp = saw_wide ? IMMEDIATE_u2 : (OPERAND_VALUE); \
1289 fprintf (out, " %ld", (long) INT_temp);
1291 #define SWITCH(OPERAND_TYPE, TABLE_OR_LOOKUP) \
1292 PC = (PC + 3) / 4 * 4; TABLE_OR_LOOKUP##_SWITCH
1294 #define LOOKUP_SWITCH \
1295 { jint default_offset = IMMEDIATE_s4; jint npairs = IMMEDIATE_s4; \
1296 fprintf (out, " npairs=%ld, default=%ld", (long) npairs, (long) default_offset+oldpc); \
1297 while (--npairs >= 0) { \
1298 jint match = IMMEDIATE_s4; jint offset = IMMEDIATE_s4; \
1299 fprintf (out, "\n%10ld: %ld", (long)match, (long)(offset+oldpc)); } \
1302 #define TABLE_SWITCH \
1303 { jint default_offset = IMMEDIATE_s4; \
1304 jint low = IMMEDIATE_s4; jint high = IMMEDIATE_s4; \
1305 fprintf (out, " low=%ld, high=%ld, default=%ld", \
1306 (long) low, (long) high, (long) default_offset+oldpc); \
1307 for (; low <= high; low++) { \
1308 jint offset = IMMEDIATE_s4; \
1309 fprintf (out, "\n%10ld: %ld", (long)low, (long)(offset+oldpc)); } \
1312 #define SPECIAL(OPERAND_TYPE, OPERAND_VALUE) \
1313 SPECIAL_##OPERAND_VALUE(OPERAND_TYPE)
1315 #define SPECIAL_IINC(OPERAND_TYPE) \
1316 i = saw_wide ? IMMEDIATE_u2 : IMMEDIATE_u1; \
1317 fprintf (out, " %d", i); \
1318 i = saw_wide ? IMMEDIATE_s2 : IMMEDIATE_s1; \
1320 fprintf (out, " %d", i)
1322 #define SPECIAL_WIDE(OPERAND_TYPE) \
1325 #define SPECIAL_EXIT(OPERAND_TYPE) /* nothing */
1326 #define SPECIAL_ENTER(OPERAND_TYPE) /* nothing */
1327 #define SPECIAL_BREAK(OPERAND_TYPE) /* nothing */
1328 #define SPECIAL_THROW(OPERAND_TYPE) /* nothing */
1330 #define IMPL(OPERAND_TYPE, OPERAND_VALUE) \
1331 fprintf (out, " %d", IMMEDIATE_u##OPERAND_VALUE)
1333 #define COND(OPERAND_TYPE, OPERAND_VALUE) \
1334 TEST(OPERAND_TYPE, OPERAND_VALUE)
1336 #include "javaop.def"
1339 if (oldpc+1 == PC) /* nothing - local index implied by opcode */;
1343 fprintf (out, " %ld", (long) INT_temp);
1349 fprintf (out, "%3d: unknown(%3d)\n", oldpc, byte_ops[PC]);