1 /* Java language support routines for GDB, the GNU debugger.
3 Copyright (C) 1997, 1998, 1999, 2000, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
25 #include "parser-defs.h"
31 #include "gdb_string.h"
38 #include "dictionary.h"
40 #include "gdb_assert.h"
44 extern void _initialize_java_language (void);
46 static int java_demangled_signature_length (char *);
47 static void java_demangled_signature_copy (char *, char *);
49 static struct symtab *get_java_class_symtab (void);
50 static char *get_java_utf8_name (struct obstack *obstack, struct value *name);
51 static int java_class_is_primitive (struct value *clas);
52 static struct value *java_value_string (char *ptr, int len);
54 static void java_emit_char (int c, struct type *type,
55 struct ui_file * stream, int quoter);
57 static char *java_class_name_from_physname (const char *physname);
59 /* This objfile contains symtabs that have been dynamically created
60 to record dynamically loaded Java classes and dynamically
61 compiled java methods. */
63 static struct objfile *dynamics_objfile = NULL;
65 static struct type *java_link_class_type (struct gdbarch *,
66 struct type *, struct value *);
68 /* FIXME: carlton/2003-02-04: This is the main or only caller of
69 allocate_objfile with first argument NULL; as a result, this code
70 breaks every so often. Somebody should write a test case that
71 exercises GDB in various ways (e.g. something involving loading a
72 dynamic library) after this code has been called. */
74 static struct objfile *
75 get_dynamics_objfile (void)
77 if (dynamics_objfile == NULL)
79 dynamics_objfile = allocate_objfile (NULL, 0);
81 return dynamics_objfile;
85 /* symtab contains classes read from the inferior. */
87 static struct symtab *class_symtab = NULL;
89 static void free_class_block (struct symtab *symtab);
91 static struct symtab *
92 get_java_class_symtab (void)
94 if (class_symtab == NULL)
96 struct objfile *objfile = get_dynamics_objfile ();
97 struct blockvector *bv;
99 class_symtab = allocate_symtab ("<java-classes>", objfile);
100 class_symtab->language = language_java;
101 bv = (struct blockvector *)
102 obstack_alloc (&objfile->objfile_obstack,
103 sizeof (struct blockvector) + sizeof (struct block *));
104 BLOCKVECTOR_NBLOCKS (bv) = 1;
105 BLOCKVECTOR (class_symtab) = bv;
107 /* Allocate dummy STATIC_BLOCK. */
108 bl = allocate_block (&objfile->objfile_obstack);
109 BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
111 BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
113 /* Allocate GLOBAL_BLOCK. */
114 bl = allocate_block (&objfile->objfile_obstack);
115 BLOCK_DICT (bl) = dict_create_hashed_expandable ();
116 BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
117 class_symtab->free_func = free_class_block;
123 add_class_symtab_symbol (struct symbol *sym)
125 struct symtab *symtab = get_java_class_symtab ();
126 struct blockvector *bv = BLOCKVECTOR (symtab);
127 dict_add_symbol (BLOCK_DICT (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)), sym);
130 static struct symbol *add_class_symbol (struct type *type, CORE_ADDR addr);
132 static struct symbol *
133 add_class_symbol (struct type *type, CORE_ADDR addr)
136 sym = (struct symbol *)
137 obstack_alloc (&dynamics_objfile->objfile_obstack, sizeof (struct symbol));
138 memset (sym, 0, sizeof (struct symbol));
139 SYMBOL_LANGUAGE (sym) = language_java;
140 SYMBOL_SET_LINKAGE_NAME (sym, TYPE_TAG_NAME (type));
141 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
142 /* SYMBOL_VALUE (sym) = valu; */
143 SYMBOL_TYPE (sym) = type;
144 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
145 SYMBOL_VALUE_ADDRESS (sym) = addr;
149 /* Free the dynamic symbols block. */
151 free_class_block (struct symtab *symtab)
153 struct blockvector *bv = BLOCKVECTOR (symtab);
154 struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
156 dict_free (BLOCK_DICT (bl));
161 java_lookup_class (char *name)
164 sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN, NULL);
166 return SYMBOL_TYPE (sym);
169 if (called from parser)
171 call lookup_class (or similar) in inferior;
175 addr = found in inferior;
180 type = alloc_type (objfile);
181 TYPE_CODE (type) = TYPE_CODE_STRUCT;
182 INIT_CPLUS_SPECIFIC (type);
183 TYPE_TAG_NAME (type) = obsavestring (name, strlen (name), &objfile->objfile_obstack);
184 TYPE_STUB (type) = 1;
188 /* FIXME - should search inferior's symbol table. */
193 /* Return a nul-terminated string (allocated on OBSTACK) for
194 a name given by NAME (which has type Utf8Const*). */
197 get_java_utf8_name (struct obstack *obstack, struct value *name)
200 struct value *temp = name;
203 temp = value_struct_elt (&temp, NULL, "length", NULL, "structure");
204 name_length = (int) value_as_long (temp);
205 data_addr = value_address (temp) + TYPE_LENGTH (value_type (temp));
206 chrs = obstack_alloc (obstack, name_length + 1);
207 chrs[name_length] = '\0';
208 read_memory (data_addr, (gdb_byte *) chrs, name_length);
213 java_class_from_object (struct value *obj_val)
215 /* This is all rather inefficient, since the offsets of vtable and
216 class are fixed. FIXME */
217 struct value *vtable_val;
219 if (TYPE_CODE (value_type (obj_val)) == TYPE_CODE_PTR
220 && TYPE_LENGTH (TYPE_TARGET_TYPE (value_type (obj_val))) == 0)
221 obj_val = value_at (get_java_object_type (),
222 value_as_address (obj_val));
224 vtable_val = value_struct_elt (&obj_val, NULL, "vtable", NULL, "structure");
225 return value_struct_elt (&vtable_val, NULL, "class", NULL, "structure");
228 /* Check if CLASS_IS_PRIMITIVE(value of clas): */
230 java_class_is_primitive (struct value *clas)
232 struct value *vtable = value_struct_elt (&clas, NULL, "vtable", NULL, "struct");
233 CORE_ADDR i = value_as_address (vtable);
234 return (int) (i & 0x7fffffff) == (int) 0x7fffffff;
237 /* Read a GCJ Class object, and generated a gdb (TYPE_CODE_STRUCT) type. */
240 type_from_class (struct gdbarch *gdbarch, struct value *clas)
245 struct objfile *objfile;
246 struct value *utf8_name;
250 struct dict_iterator iter;
253 type = check_typedef (value_type (clas));
254 if (TYPE_CODE (type) == TYPE_CODE_PTR)
256 if (value_logical_not (clas))
258 clas = value_ind (clas);
260 addr = value_address (clas);
263 get_java_class_symtab ();
264 bl = BLOCKVECTOR_BLOCK (BLOCKVECTOR (class_symtab), GLOBAL_BLOCK);
265 ALL_BLOCK_SYMBOLS (block, iter, sym)
267 if (SYMBOL_VALUE_ADDRESS (sym) == addr)
268 return SYMBOL_TYPE (sym);
272 objfile = get_dynamics_objfile ();
273 if (java_class_is_primitive (clas))
277 sig = value_struct_elt (&temp, NULL, "method_count", NULL, "structure");
278 return java_primitive_type (gdbarch, value_as_long (sig));
281 /* Get Class name. */
282 /* if clasloader non-null, prepend loader address. FIXME */
284 utf8_name = value_struct_elt (&temp, NULL, "name", NULL, "structure");
285 name = get_java_utf8_name (&objfile->objfile_obstack, utf8_name);
286 for (nptr = name; *nptr != 0; nptr++)
292 type = java_lookup_class (name);
296 /* Do not use the "fake" dynamics objfile to own dynamically generated
297 types, as it does not provide an architecture, and it would not help
298 manage the lifetime of these types anyway. */
299 type = alloc_type (NULL);
300 TYPE_CODE (type) = TYPE_CODE_STRUCT;
301 INIT_CPLUS_SPECIFIC (type);
305 char *signature = name;
306 int namelen = java_demangled_signature_length (signature);
307 if (namelen > strlen (name))
308 name = obstack_alloc (&objfile->objfile_obstack, namelen + 1);
309 java_demangled_signature_copy (name, signature);
310 name[namelen] = '\0';
313 /* Set array element type. */
314 temp = value_struct_elt (&temp, NULL, "methods", NULL, "structure");
315 deprecated_set_value_type (temp, lookup_pointer_type (value_type (clas)));
316 TYPE_TARGET_TYPE (type) = type_from_class (gdbarch, temp);
319 ALLOCATE_CPLUS_STRUCT_TYPE (type);
320 TYPE_TAG_NAME (type) = name;
322 add_class_symtab_symbol (add_class_symbol (type, addr));
323 return java_link_class_type (gdbarch, type, clas);
326 /* Fill in class TYPE with data from the CLAS value. */
329 java_link_class_type (struct gdbarch *gdbarch,
330 struct type *type, struct value *clas)
333 char *unqualified_name;
334 char *name = TYPE_TAG_NAME (type);
335 int ninterfaces, nfields, nmethods;
336 int type_is_object = 0;
337 struct fn_field *fn_fields;
338 struct fn_fieldlist *fn_fieldlists;
339 struct value *fields;
340 struct value *methods;
341 struct value *method = NULL;
342 struct value *field = NULL;
344 struct objfile *objfile = get_dynamics_objfile ();
347 gdb_assert (name != NULL);
348 unqualified_name = strrchr (name, '.');
349 if (unqualified_name == NULL)
350 unqualified_name = name;
353 temp = value_struct_elt (&temp, NULL, "superclass", NULL, "structure");
354 if (strcmp (name, "java.lang.Object") == 0)
356 tsuper = get_java_object_type ();
357 if (tsuper && TYPE_CODE (tsuper) == TYPE_CODE_PTR)
358 tsuper = TYPE_TARGET_TYPE (tsuper);
362 tsuper = type_from_class (gdbarch, temp);
368 ninterfaces = value_as_long (value_struct_elt (&temp, NULL, "interface_len", NULL, "structure"));
370 TYPE_N_BASECLASSES (type) = (tsuper == NULL ? 0 : 1) + ninterfaces;
372 nfields = value_as_long (value_struct_elt (&temp, NULL, "field_count", NULL, "structure"));
373 nfields += TYPE_N_BASECLASSES (type);
374 nfields++; /* Add one for dummy "class" field. */
375 TYPE_NFIELDS (type) = nfields;
376 TYPE_FIELDS (type) = (struct field *)
377 TYPE_ALLOC (type, sizeof (struct field) * nfields);
379 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
381 TYPE_FIELD_PRIVATE_BITS (type) =
382 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
383 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
385 TYPE_FIELD_PROTECTED_BITS (type) =
386 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
387 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
389 TYPE_FIELD_IGNORE_BITS (type) =
390 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
391 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
393 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *)
394 TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type)));
395 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type));
399 TYPE_BASECLASS (type, 0) = tsuper;
401 SET_TYPE_FIELD_PRIVATE (type, 0);
405 if (i > 2 && name[i - 1] == ']' && tsuper != NULL)
408 TYPE_LENGTH (type) = TYPE_LENGTH (tsuper) + 4; /* size with "length" */
413 temp = value_struct_elt (&temp, NULL, "size_in_bytes", NULL, "structure");
414 TYPE_LENGTH (type) = value_as_long (temp);
418 nfields--; /* First set up dummy "class" field. */
419 SET_FIELD_PHYSADDR (TYPE_FIELD (type, nfields), value_address (clas));
420 TYPE_FIELD_NAME (type, nfields) = "class";
421 TYPE_FIELD_TYPE (type, nfields) = value_type (clas);
422 SET_TYPE_FIELD_PRIVATE (type, nfields);
424 for (i = TYPE_N_BASECLASSES (type); i < nfields; i++)
431 fields = value_struct_elt (&temp, NULL, "fields", NULL, "structure");
432 field = value_ind (fields);
435 { /* Re-use field value for next field. */
437 = value_address (field) + TYPE_LENGTH (value_type (field));
438 set_value_address (field, addr);
439 set_value_lazy (field, 1);
442 temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");
443 TYPE_FIELD_NAME (type, i) =
444 get_java_utf8_name (&objfile->objfile_obstack, temp);
446 accflags = value_as_long (value_struct_elt (&temp, NULL, "accflags",
449 temp = value_struct_elt (&temp, NULL, "info", NULL, "structure");
450 boffset = value_as_long (value_struct_elt (&temp, NULL, "boffset",
452 if (accflags & 0x0001) /* public access */
456 if (accflags & 0x0002) /* private access */
458 SET_TYPE_FIELD_PRIVATE (type, i);
460 if (accflags & 0x0004) /* protected access */
462 SET_TYPE_FIELD_PROTECTED (type, i);
464 if (accflags & 0x0008) /* ACC_STATIC */
465 SET_FIELD_PHYSADDR (TYPE_FIELD (type, i), boffset);
467 TYPE_FIELD_BITPOS (type, i) = 8 * boffset;
468 if (accflags & 0x8000) /* FIELD_UNRESOLVED_FLAG */
470 TYPE_FIELD_TYPE (type, i) = get_java_object_type (); /* FIXME */
476 temp = value_struct_elt (&temp, NULL, "type", NULL, "structure");
477 ftype = type_from_class (gdbarch, temp);
478 if (TYPE_CODE (ftype) == TYPE_CODE_STRUCT)
479 ftype = lookup_pointer_type (ftype);
480 TYPE_FIELD_TYPE (type, i) = ftype;
485 nmethods = value_as_long (value_struct_elt (&temp, NULL, "method_count",
487 TYPE_NFN_FIELDS_TOTAL (type) = nmethods;
488 j = nmethods * sizeof (struct fn_field);
489 fn_fields = (struct fn_field *)
490 obstack_alloc (&dynamics_objfile->objfile_obstack, j);
491 memset (fn_fields, 0, j);
492 fn_fieldlists = (struct fn_fieldlist *)
493 alloca (nmethods * sizeof (struct fn_fieldlist));
496 for (i = 0; i < nmethods; i++)
503 methods = value_struct_elt (&temp, NULL, "methods", NULL, "structure");
504 method = value_ind (methods);
507 { /* Re-use method value for next method. */
509 = value_address (method) + TYPE_LENGTH (value_type (method));
510 set_value_address (method, addr);
511 set_value_lazy (method, 1);
514 /* Get method name. */
516 temp = value_struct_elt (&temp, NULL, "name", NULL, "structure");
517 mname = get_java_utf8_name (&objfile->objfile_obstack, temp);
518 if (strcmp (mname, "<init>") == 0)
519 mname = unqualified_name;
521 /* Check for an existing method with the same name.
522 * This makes building the fn_fieldslists an O(nmethods**2)
523 * operation. That could be using hashing, but I doubt it
524 * is worth it. Note that we do maintain the order of methods
525 * in the inferior's Method table (as long as that is grouped
526 * by method name), which I think is desirable. --PB */
527 for (k = 0, j = TYPE_NFN_FIELDS (type);;)
530 { /* No match - new method name. */
531 j = TYPE_NFN_FIELDS (type)++;
532 fn_fieldlists[j].name = mname;
533 fn_fieldlists[j].length = 1;
534 fn_fieldlists[j].fn_fields = &fn_fields[i];
538 if (strcmp (mname, fn_fieldlists[j].name) == 0)
539 { /* Found an existing method with the same name. */
541 if (mname != unqualified_name)
542 obstack_free (&objfile->objfile_obstack, mname);
543 mname = fn_fieldlists[j].name;
544 fn_fieldlists[j].length++;
545 k = i - k; /* Index of new slot. */
546 /* Shift intervening fn_fields (between k and i) down. */
547 for (l = i; l > k; l--)
548 fn_fields[l] = fn_fields[l - 1];
549 for (l = TYPE_NFN_FIELDS (type); --l > j;)
550 fn_fieldlists[l].fn_fields++;
553 k += fn_fieldlists[j].length;
555 fn_fields[k].physname = "";
556 fn_fields[k].is_stub = 1;
558 fn_fields[k].type = lookup_function_type
559 (builtin_java_type (gdbarch)->builtin_void);
560 TYPE_CODE (fn_fields[k].type) = TYPE_CODE_METHOD;
563 j = TYPE_NFN_FIELDS (type) * sizeof (struct fn_fieldlist);
564 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
565 obstack_alloc (&dynamics_objfile->objfile_obstack, j);
566 memcpy (TYPE_FN_FIELDLISTS (type), fn_fieldlists, j);
571 static struct type *java_object_type;
574 get_java_object_type (void)
576 if (java_object_type == NULL)
579 sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL);
581 error (_("cannot find java.lang.Object"));
582 java_object_type = SYMBOL_TYPE (sym);
584 return java_object_type;
588 get_java_object_header_size (struct gdbarch *gdbarch)
590 struct type *objtype = get_java_object_type ();
592 return (2 * gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
594 return TYPE_LENGTH (objtype);
598 is_object_type (struct type *type)
600 CHECK_TYPEDEF (type);
601 if (TYPE_CODE (type) == TYPE_CODE_PTR)
603 struct type *ttype = check_typedef (TYPE_TARGET_TYPE (type));
605 if (TYPE_CODE (ttype) != TYPE_CODE_STRUCT)
607 while (TYPE_N_BASECLASSES (ttype) > 0)
608 ttype = TYPE_BASECLASS (ttype, 0);
609 name = TYPE_TAG_NAME (ttype);
610 if (name != NULL && strcmp (name, "java.lang.Object") == 0)
612 name = TYPE_NFIELDS (ttype) > 0 ? TYPE_FIELD_NAME (ttype, 0) : (char *) 0;
613 if (name != NULL && strcmp (name, "vtable") == 0)
615 if (java_object_type == NULL)
616 java_object_type = type;
624 java_primitive_type (struct gdbarch *gdbarch, int signature)
626 const struct builtin_java_type *builtin = builtin_java_type (gdbarch);
631 return builtin->builtin_byte;
633 return builtin->builtin_short;
635 return builtin->builtin_int;
637 return builtin->builtin_long;
639 return builtin->builtin_boolean;
641 return builtin->builtin_char;
643 return builtin->builtin_float;
645 return builtin->builtin_double;
647 return builtin->builtin_void;
649 error (_("unknown signature '%c' for primitive type"), (char) signature);
652 /* If name[0 .. namelen-1] is the name of a primitive Java type,
653 return that type. Otherwise, return NULL. */
656 java_primitive_type_from_name (struct gdbarch *gdbarch,
657 char *name, int namelen)
659 const struct builtin_java_type *builtin = builtin_java_type (gdbarch);
664 if (namelen == 4 && memcmp (name, "byte", 4) == 0)
665 return builtin->builtin_byte;
666 if (namelen == 7 && memcmp (name, "boolean", 7) == 0)
667 return builtin->builtin_boolean;
670 if (namelen == 4 && memcmp (name, "char", 4) == 0)
671 return builtin->builtin_char;
673 if (namelen == 6 && memcmp (name, "double", 6) == 0)
674 return builtin->builtin_double;
677 if (namelen == 5 && memcmp (name, "float", 5) == 0)
678 return builtin->builtin_float;
681 if (namelen == 3 && memcmp (name, "int", 3) == 0)
682 return builtin->builtin_int;
685 if (namelen == 4 && memcmp (name, "long", 4) == 0)
686 return builtin->builtin_long;
689 if (namelen == 5 && memcmp (name, "short", 5) == 0)
690 return builtin->builtin_short;
693 if (namelen == 4 && memcmp (name, "void", 4) == 0)
694 return builtin->builtin_void;
701 java_primitive_type_name (int signature)
724 error (_("unknown signature '%c' for primitive type"), (char) signature);
727 /* Return the length (in bytes) of demangled name of the Java type
728 signature string SIGNATURE. */
731 java_demangled_signature_length (char *signature)
734 for (; *signature == '['; signature++)
735 array += 2; /* Two chars for "[]". */
736 switch (signature[0])
739 /* Subtract 2 for 'L' and ';'. */
740 return strlen (signature) - 2 + array;
742 return strlen (java_primitive_type_name (signature[0])) + array;
746 /* Demangle the Java type signature SIGNATURE, leaving the result in RESULT. */
749 java_demangled_signature_copy (char *result, char *signature)
754 while (*signature == '[')
759 switch (signature[0])
762 /* Subtract 2 for 'L' and ';', but add 1 for final nul. */
765 for (; *signature != ';' && *signature != '\0'; signature++)
767 if (*signature == '/')
774 ptr = java_primitive_type_name (signature[0]);
776 strcpy (result, ptr);
787 /* Return the demangled name of the Java type signature string SIGNATURE,
788 as a freshly allocated copy. */
791 java_demangle_type_signature (char *signature)
793 int length = java_demangled_signature_length (signature);
794 char *result = xmalloc (length + 1);
795 java_demangled_signature_copy (result, signature);
796 result[length] = '\0';
800 /* Return the type of TYPE followed by DIMS pairs of [ ].
801 If DIMS == 0, TYPE is returned. */
804 java_array_type (struct type *type, int dims)
806 struct type *range_type;
810 range_type = create_range_type (NULL, builtin_type_int32, 0, 0);
811 /* FIXME This is bogus! Java arrays are not gdb arrays! */
812 type = create_array_type (NULL, type, range_type);
818 /* Create a Java string in the inferior from a (Utf8) literal. */
820 static struct value *
821 java_value_string (char *ptr, int len)
823 error (_("not implemented - java_value_string")); /* FIXME */
826 /* Print the character C on STREAM as part of the contents of a literal
827 string whose delimiter is QUOTER. Note that that format for printing
828 characters and strings is language specific. */
831 java_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
837 fprintf_filtered (stream, "\\%c", c);
840 fputs_filtered ("\\b", stream);
843 fputs_filtered ("\\t", stream);
846 fputs_filtered ("\\n", stream);
849 fputs_filtered ("\\f", stream);
852 fputs_filtered ("\\r", stream);
856 fputc_filtered (c, stream);
858 fprintf_filtered (stream, "\\u%.4x", (unsigned int) c);
863 static struct value *
864 evaluate_subexp_java (struct type *expect_type, struct expression *exp,
865 int *pos, enum noside noside)
870 enum exp_opcode op = exp->elts[*pos].opcode;
877 if (noside == EVAL_SKIP)
880 arg1 = evaluate_subexp_java (NULL_TYPE, exp, pos, EVAL_NORMAL);
881 if (is_object_type (value_type (arg1)))
885 type = type_from_class (exp->gdbarch, java_class_from_object (arg1));
886 arg1 = value_cast (lookup_pointer_type (type), arg1);
888 if (noside == EVAL_SKIP)
890 return value_ind (arg1);
892 case BINOP_SUBSCRIPT:
894 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
895 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
896 if (noside == EVAL_SKIP)
898 /* If the user attempts to subscript something that is not an
899 array or pointer type (like a plain int variable for example),
900 then report this as an error. */
902 arg1 = coerce_ref (arg1);
903 type = check_typedef (value_type (arg1));
904 if (TYPE_CODE (type) == TYPE_CODE_PTR)
905 type = check_typedef (TYPE_TARGET_TYPE (type));
906 name = TYPE_NAME (type);
908 name = TYPE_TAG_NAME (type);
909 i = name == NULL ? 0 : strlen (name);
910 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
911 && i > 2 && name[i - 1] == ']')
915 struct type *el_type;
918 struct value *clas = java_class_from_object (arg1);
919 struct value *temp = clas;
920 /* Get CLASS_ELEMENT_TYPE of the array type. */
921 temp = value_struct_elt (&temp, NULL, "methods",
923 deprecated_set_value_type (temp, value_type (clas));
924 el_type = type_from_class (exp->gdbarch, temp);
925 if (TYPE_CODE (el_type) == TYPE_CODE_STRUCT)
926 el_type = lookup_pointer_type (el_type);
928 if (noside == EVAL_AVOID_SIDE_EFFECTS)
929 return value_zero (el_type, VALUE_LVAL (arg1));
930 address = value_as_address (arg1);
931 address += get_java_object_header_size (exp->gdbarch);
932 read_memory (address, buf4, 4);
933 length = (long) extract_signed_integer (buf4, 4);
934 index = (long) value_as_long (arg2);
935 if (index >= length || index < 0)
936 error (_("array index (%ld) out of bounds (length: %ld)"),
938 address = (address + 4) + index * TYPE_LENGTH (el_type);
939 return value_at (el_type, address);
941 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
943 if (noside == EVAL_AVOID_SIDE_EFFECTS)
944 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
946 return value_subscript (arg1, value_as_long (arg2));
949 error (_("cannot subscript something of type `%s'"), name);
951 error (_("cannot subscript requested type"));
955 i = longest_to_int (exp->elts[pc + 1].longconst);
956 (*pos) += 3 + BYTES_TO_EXP_ELEM (i + 1);
957 if (noside == EVAL_SKIP)
959 return java_value_string (&exp->elts[pc + 2].string, i);
962 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
963 /* Convert object field (such as TYPE.class) to reference. */
964 if (TYPE_CODE (value_type (arg1)) == TYPE_CODE_STRUCT)
965 arg1 = value_addr (arg1);
971 return evaluate_subexp_standard (expect_type, exp, pos, noside);
973 return value_from_longest (builtin_type_int8, (LONGEST) 1);
976 static char *java_demangle (const char *mangled, int options)
978 return cplus_demangle (mangled, options | DMGL_JAVA);
981 /* Find the member function name of the demangled name NAME. NAME
982 must be a method name including arguments, in order to correctly
983 locate the last component.
985 This function return a pointer to the first dot before the
986 member function name, or NULL if the name was not of the
990 java_find_last_component (const char *name)
994 /* Find argument list. */
995 p = strchr (name, '(');
1000 /* Back up and find first dot prior to argument list. */
1001 while (p > name && *p != '.')
1010 /* Return the name of the class containing method PHYSNAME. */
1013 java_class_name_from_physname (const char *physname)
1018 char *demangled_name = java_demangle (physname, DMGL_PARAMS | DMGL_ANSI);
1020 if (demangled_name == NULL)
1023 end = java_find_last_component (demangled_name);
1026 ret = xmalloc (end - demangled_name + 1);
1027 memcpy (ret, demangled_name, end - demangled_name);
1028 ret[end - demangled_name] = '\0';
1031 xfree (demangled_name);
1035 /* Table mapping opcodes into strings for printing operators
1036 and precedences of the operators. */
1038 const struct op_print java_op_print_tab[] =
1040 {",", BINOP_COMMA, PREC_COMMA, 0},
1041 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
1042 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
1043 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
1044 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
1045 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
1046 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
1047 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
1048 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
1049 {"<=", BINOP_LEQ, PREC_ORDER, 0},
1050 {">=", BINOP_GEQ, PREC_ORDER, 0},
1051 {">", BINOP_GTR, PREC_ORDER, 0},
1052 {"<", BINOP_LESS, PREC_ORDER, 0},
1053 {">>", BINOP_RSH, PREC_SHIFT, 0},
1054 {"<<", BINOP_LSH, PREC_SHIFT, 0},
1056 {">>>", BINOP_ ? ? ?, PREC_SHIFT, 0},
1058 {"+", BINOP_ADD, PREC_ADD, 0},
1059 {"-", BINOP_SUB, PREC_ADD, 0},
1060 {"*", BINOP_MUL, PREC_MUL, 0},
1061 {"/", BINOP_DIV, PREC_MUL, 0},
1062 {"%", BINOP_REM, PREC_MUL, 0},
1063 {"-", UNOP_NEG, PREC_PREFIX, 0},
1064 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
1065 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
1066 {"*", UNOP_IND, PREC_PREFIX, 0},
1068 {"instanceof", ? ? ?, ? ? ?, 0},
1070 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1071 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1075 enum java_primitive_types
1077 java_primitive_type_int,
1078 java_primitive_type_short,
1079 java_primitive_type_long,
1080 java_primitive_type_byte,
1081 java_primitive_type_boolean,
1082 java_primitive_type_char,
1083 java_primitive_type_float,
1084 java_primitive_type_double,
1085 java_primitive_type_void,
1086 nr_java_primitive_types
1090 java_language_arch_info (struct gdbarch *gdbarch,
1091 struct language_arch_info *lai)
1093 const struct builtin_java_type *builtin = builtin_java_type (gdbarch);
1095 lai->string_char_type = builtin->builtin_char;
1096 lai->primitive_type_vector
1097 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_java_primitive_types + 1,
1099 lai->primitive_type_vector [java_primitive_type_int]
1100 = builtin->builtin_int;
1101 lai->primitive_type_vector [java_primitive_type_short]
1102 = builtin->builtin_short;
1103 lai->primitive_type_vector [java_primitive_type_long]
1104 = builtin->builtin_long;
1105 lai->primitive_type_vector [java_primitive_type_byte]
1106 = builtin->builtin_byte;
1107 lai->primitive_type_vector [java_primitive_type_boolean]
1108 = builtin->builtin_boolean;
1109 lai->primitive_type_vector [java_primitive_type_char]
1110 = builtin->builtin_char;
1111 lai->primitive_type_vector [java_primitive_type_float]
1112 = builtin->builtin_float;
1113 lai->primitive_type_vector [java_primitive_type_double]
1114 = builtin->builtin_double;
1115 lai->primitive_type_vector [java_primitive_type_void]
1116 = builtin->builtin_void;
1118 lai->bool_type_symbol = "boolean";
1119 lai->bool_type_default = builtin->builtin_boolean;
1122 const struct exp_descriptor exp_descriptor_java =
1124 print_subexp_standard,
1125 operator_length_standard,
1127 dump_subexp_body_standard,
1128 evaluate_subexp_java
1131 const struct language_defn java_language_defn =
1133 "java", /* Language name */
1140 &exp_descriptor_java,
1144 c_printchar, /* Print a character constant */
1145 c_printstr, /* Function to print string constant */
1146 java_emit_char, /* Function to print a single character */
1147 java_print_type, /* Print a type using appropriate syntax */
1148 default_print_typedef, /* Print a typedef using appropriate syntax */
1149 java_val_print, /* Print a value using appropriate syntax */
1150 java_value_print, /* Print a top-level value */
1151 NULL, /* Language specific skip_trampoline */
1152 "this", /* name_of_this */
1153 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1154 basic_lookup_transparent_type,/* lookup_transparent_type */
1155 java_demangle, /* Language specific symbol demangler */
1156 java_class_name_from_physname,/* Language specific class name */
1157 java_op_print_tab, /* expression operators for printing */
1158 0, /* not c-style arrays */
1159 0, /* String lower bound */
1160 default_word_break_characters,
1161 default_make_symbol_completion_list,
1162 java_language_arch_info,
1163 default_print_array_index,
1164 default_pass_by_reference,
1170 build_java_types (struct gdbarch *gdbarch)
1172 struct builtin_java_type *builtin_java_type
1173 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_java_type);
1175 builtin_java_type->builtin_int
1176 = init_type (TYPE_CODE_INT, 4, 0, "int", NULL);
1177 builtin_java_type->builtin_short
1178 = init_type (TYPE_CODE_INT, 2, 0, "short", NULL);
1179 builtin_java_type->builtin_long
1180 = init_type (TYPE_CODE_INT, 8, 0, "long", NULL);
1181 builtin_java_type->builtin_byte
1182 = init_type (TYPE_CODE_INT, 1, 0, "byte", NULL);
1183 builtin_java_type->builtin_boolean
1184 = init_type (TYPE_CODE_BOOL, 1, 0, "boolean", NULL);
1185 builtin_java_type->builtin_char
1186 = init_type (TYPE_CODE_CHAR, 2, TYPE_FLAG_UNSIGNED, "char", NULL);
1187 builtin_java_type->builtin_float
1188 = init_type (TYPE_CODE_FLT, 4, 0, "float", NULL);
1189 builtin_java_type->builtin_double
1190 = init_type (TYPE_CODE_FLT, 8, 0, "double", NULL);
1191 builtin_java_type->builtin_void
1192 = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL);
1194 return builtin_java_type;
1197 static struct gdbarch_data *java_type_data;
1199 const struct builtin_java_type *
1200 builtin_java_type (struct gdbarch *gdbarch)
1202 return gdbarch_data (gdbarch, java_type_data);
1206 _initialize_java_language (void)
1208 java_type_data = gdbarch_data_register_post_init (build_java_types);
1210 add_language (&java_language_defn);