1/* Java language support routines for GDB, the GNU debugger. 2 Copyright 1997, 1998, 1999, 2000, 2003, 2004 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program 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 2 of the License, or 9 (at your option) any later version. 10 11 This program 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. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, 19 Boston, MA 02111-1307, USA. */ 20 21#include "defs.h" 22#include "symtab.h" 23#include "gdbtypes.h" 24#include "expression.h" 25#include "parser-defs.h" 26#include "language.h" 27#include "gdbtypes.h" 28#include "symtab.h" 29#include "symfile.h" 30#include "objfiles.h" 31#include "gdb_string.h" 32#include "value.h" 33#include "c-lang.h" 34#include "jv-lang.h" 35#include "gdbcore.h" 36#include "block.h" 37#include "demangle.h" 38#include "dictionary.h" 39#include <ctype.h> 40 41struct type *java_int_type; 42struct type *java_byte_type; 43struct type *java_short_type; 44struct type *java_long_type; 45struct type *java_boolean_type; 46struct type *java_char_type; 47struct type *java_float_type; 48struct type *java_double_type; 49struct type *java_void_type; 50 51/* Local functions */ 52 53extern void _initialize_java_language (void); 54 55static int java_demangled_signature_length (char *); 56static void java_demangled_signature_copy (char *, char *); 57 58static struct symtab *get_java_class_symtab (void); 59static char *get_java_utf8_name (struct obstack *obstack, struct value *name); 60static int java_class_is_primitive (struct value *clas); 61static struct value *java_value_string (char *ptr, int len); 62 63static void java_emit_char (int c, struct ui_file * stream, int quoter); 64 65static char *java_class_name_from_physname (const char *physname); 66 67/* This objfile contains symtabs that have been dynamically created 68 to record dynamically loaded Java classes and dynamically 69 compiled java methods. */ 70 71static struct objfile *dynamics_objfile = NULL; 72 73static struct type *java_link_class_type (struct type *, struct value *); 74 75/* FIXME: carlton/2003-02-04: This is the main or only caller of 76 allocate_objfile with first argument NULL; as a result, this code 77 breaks every so often. Somebody should write a test case that 78 exercises GDB in various ways (e.g. something involving loading a 79 dynamic library) after this code has been called. */ 80 81static struct objfile * 82get_dynamics_objfile (void) 83{ 84 if (dynamics_objfile == NULL) 85 { 86 dynamics_objfile = allocate_objfile (NULL, 0); 87 } 88 return dynamics_objfile; 89} 90 91#if 1 92/* symtab contains classes read from the inferior. */ 93 94static struct symtab *class_symtab = NULL; 95 96static void free_class_block (struct symtab *symtab); 97 98static struct symtab * 99get_java_class_symtab (void) 100{ 101 if (class_symtab == NULL) 102 { 103 struct objfile *objfile = get_dynamics_objfile (); 104 struct blockvector *bv; 105 struct block *bl; 106 class_symtab = allocate_symtab ("<java-classes>", objfile); 107 class_symtab->language = language_java; 108 bv = (struct blockvector *) 109 obstack_alloc (&objfile->objfile_obstack, 110 sizeof (struct blockvector) + sizeof (struct block *)); 111 BLOCKVECTOR_NBLOCKS (bv) = 1; 112 BLOCKVECTOR (class_symtab) = bv; 113 114 /* Allocate dummy STATIC_BLOCK. */ 115 bl = allocate_block (&objfile->objfile_obstack); 116 BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack, 117 NULL); 118 BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl; 119 120 /* Allocate GLOBAL_BLOCK. */ 121 bl = allocate_block (&objfile->objfile_obstack); 122 BLOCK_DICT (bl) = dict_create_hashed_expandable (); 123 BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl; 124 class_symtab->free_func = free_class_block; 125 } 126 return class_symtab; 127} 128 129static void 130add_class_symtab_symbol (struct symbol *sym) 131{ 132 struct symtab *symtab = get_java_class_symtab (); 133 struct blockvector *bv = BLOCKVECTOR (symtab); 134 dict_add_symbol (BLOCK_DICT (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)), sym); 135} 136 137static struct symbol *add_class_symbol (struct type *type, CORE_ADDR addr); 138 139static struct symbol * 140add_class_symbol (struct type *type, CORE_ADDR addr) 141{ 142 struct symbol *sym; 143 sym = (struct symbol *) 144 obstack_alloc (&dynamics_objfile->objfile_obstack, sizeof (struct symbol)); 145 memset (sym, 0, sizeof (struct symbol)); 146 SYMBOL_LANGUAGE (sym) = language_java; 147 DEPRECATED_SYMBOL_NAME (sym) = TYPE_TAG_NAME (type); 148 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 149 /* SYMBOL_VALUE (sym) = valu; */ 150 SYMBOL_TYPE (sym) = type; 151 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; 152 SYMBOL_VALUE_ADDRESS (sym) = addr; 153 return sym; 154} 155 156/* Free the dynamic symbols block. */ 157static void 158free_class_block (struct symtab *symtab) 159{ 160 struct blockvector *bv = BLOCKVECTOR (symtab); 161 struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 162 163 dict_free (BLOCK_DICT (bl)); 164} 165#endif 166 167struct type * 168java_lookup_class (char *name) 169{ 170 struct symbol *sym; 171 sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN, 172 (int *) 0, (struct symtab **) NULL); 173 if (sym != NULL) 174 return SYMBOL_TYPE (sym); 175#if 0 176 CORE_ADDR addr; 177 if (called from parser) 178 { 179 call lookup_class (or similar) in inferior; 180 if not 181 found: 182 return NULL; 183 addr = found in inferior; 184 } 185 else 186 addr = 0; 187 struct type *type; 188 type = alloc_type (objfile); 189 TYPE_CODE (type) = TYPE_CODE_STRUCT; 190 INIT_CPLUS_SPECIFIC (type); 191 TYPE_TAG_NAME (type) = obsavestring (name, strlen (name), &objfile->objfile_obstack); 192 TYPE_FLAGS (type) |= TYPE_FLAG_STUB; 193 TYPE ? = addr; 194 return type; 195#else 196 /* FIXME - should search inferior's symbol table. */ 197 return NULL; 198#endif 199} 200 201/* Return a nul-terminated string (allocated on OBSTACK) for 202 a name given by NAME (which has type Utf8Const*). */ 203 204char * 205get_java_utf8_name (struct obstack *obstack, struct value *name) 206{ 207 char *chrs; 208 struct value *temp = name; 209 int name_length; 210 CORE_ADDR data_addr; 211 temp = value_struct_elt (&temp, NULL, "length", NULL, "structure"); 212 name_length = (int) value_as_long (temp); 213 data_addr = VALUE_ADDRESS (temp) + VALUE_OFFSET (temp) 214 + TYPE_LENGTH (VALUE_TYPE (temp)); 215 chrs = obstack_alloc (obstack, name_length + 1); 216 chrs[name_length] = '\0'; 217 read_memory (data_addr, chrs, name_length); 218 return chrs; 219} 220 221struct value * 222java_class_from_object (struct value *obj_val) 223{ 224 /* This is all rather inefficient, since the offsets of vtable and 225 class are fixed. FIXME */ 226 struct value *vtable_val; 227 228 if (TYPE_CODE (VALUE_TYPE (obj_val)) == TYPE_CODE_PTR 229 && TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (obj_val))) == 0) 230 obj_val = value_at (get_java_object_type (), 231 value_as_address (obj_val), NULL); 232 233 vtable_val = value_struct_elt (&obj_val, NULL, "vtable", NULL, "structure"); 234 return value_struct_elt (&vtable_val, NULL, "class", NULL, "structure"); 235} 236 237/* Check if CLASS_IS_PRIMITIVE(value of clas): */ 238static int 239java_class_is_primitive (struct value *clas) 240{ 241 struct value *vtable = value_struct_elt (&clas, NULL, "vtable", NULL, "struct"); 242 CORE_ADDR i = value_as_address (vtable); 243 return (int) (i & 0x7fffffff) == (int) 0x7fffffff; 244} 245 246/* Read a GCJ Class object, and generated a gdb (TYPE_CODE_STRUCT) type. */ 247 248struct type * 249type_from_class (struct value *clas) 250{ 251 struct type *type; 252 char *name; 253 struct value *temp; 254 struct objfile *objfile; 255 struct value *utf8_name; 256 char *nptr; 257 CORE_ADDR addr; 258 struct block *bl; 259 struct dict_iterator iter; 260 int is_array = 0; 261 262 type = check_typedef (VALUE_TYPE (clas)); 263 if (TYPE_CODE (type) == TYPE_CODE_PTR) 264 { 265 if (value_logical_not (clas)) 266 return NULL; 267 clas = value_ind (clas); 268 } 269 addr = VALUE_ADDRESS (clas) + VALUE_OFFSET (clas); 270 271#if 0 272 get_java_class_symtab (); 273 bl = BLOCKVECTOR_BLOCK (BLOCKVECTOR (class_symtab), GLOBAL_BLOCK); 274 ALL_BLOCK_SYMBOLS (block, iter, sym) 275 { 276 if (SYMBOL_VALUE_ADDRESS (sym) == addr) 277 return SYMBOL_TYPE (sym); 278 } 279#endif 280 281 objfile = get_dynamics_objfile (); 282 if (java_class_is_primitive (clas)) 283 { 284 struct value *sig; 285 temp = clas; 286 sig = value_struct_elt (&temp, NULL, "method_count", NULL, "structure"); 287 return java_primitive_type (value_as_long (sig)); 288 } 289 290 /* Get Class name. */ 291 /* if clasloader non-null, prepend loader address. FIXME */ 292 temp = clas; 293 utf8_name = value_struct_elt (&temp, NULL, "name", NULL, "structure"); 294 name = get_java_utf8_name (&objfile->objfile_obstack, utf8_name); 295 for (nptr = name; *nptr != 0; nptr++) 296 { 297 if (*nptr == '/') 298 *nptr = '.'; 299 } 300 301 type = java_lookup_class (name); 302 if (type != NULL) 303 return type; 304 305 type = alloc_type (objfile); 306 TYPE_CODE (type) = TYPE_CODE_STRUCT; 307 INIT_CPLUS_SPECIFIC (type); 308 309 if (name[0] == '[') 310 { 311 char *signature = name; 312 int namelen = java_demangled_signature_length (signature); 313 if (namelen > strlen (name)) 314 name = obstack_alloc (&objfile->objfile_obstack, namelen + 1); 315 java_demangled_signature_copy (name, signature); 316 name[namelen] = '\0'; 317 is_array = 1; 318 temp = clas; 319 /* Set array element type. */ 320 temp = value_struct_elt (&temp, NULL, "methods", NULL, "structure"); 321 VALUE_TYPE (temp) = lookup_pointer_type (VALUE_TYPE (clas)); 322 TYPE_TARGET_TYPE (type) = type_from_class (temp); 323 } 324 325 ALLOCATE_CPLUS_STRUCT_TYPE (type); 326 TYPE_TAG_NAME (type) = name; 327 328 add_class_symtab_symbol (add_class_symbol (type, addr)); 329 return java_link_class_type (type, clas); 330} 331 332/* Fill in class TYPE with data from the CLAS value. */ 333 334struct type * 335java_link_class_type (struct type *type, struct value *clas) 336{ 337 struct value *temp; 338 char *unqualified_name; 339 char *name = TYPE_TAG_NAME (type); 340 int ninterfaces, nfields, nmethods; 341 int type_is_object = 0; 342 struct fn_field *fn_fields; 343 struct fn_fieldlist *fn_fieldlists; 344 struct value *fields; 345 struct value *methods; 346 struct value *method = NULL; 347 struct value *field = NULL; 348 int i, j; 349 struct objfile *objfile = get_dynamics_objfile (); 350 struct type *tsuper; 351 352 unqualified_name = strrchr (name, '.'); 353 if (unqualified_name == NULL) 354 unqualified_name = name; 355 356 temp = clas; 357 temp = value_struct_elt (&temp, NULL, "superclass", NULL, "structure"); 358 if (name != NULL && strcmp (name, "java.lang.Object") == 0) 359 { 360 tsuper = get_java_object_type (); 361 if (tsuper && TYPE_CODE (tsuper) == TYPE_CODE_PTR) 362 tsuper = TYPE_TARGET_TYPE (tsuper); 363 type_is_object = 1; 364 } 365 else 366 tsuper = type_from_class (temp); 367 368#if 1 369 ninterfaces = 0; 370#else 371 temp = clas; 372 ninterfaces = value_as_long (value_struct_elt (&temp, NULL, "interface_len", NULL, "structure")); 373#endif 374 TYPE_N_BASECLASSES (type) = (tsuper == NULL ? 0 : 1) + ninterfaces; 375 temp = clas; 376 nfields = value_as_long (value_struct_elt (&temp, NULL, "field_count", NULL, "structure")); 377 nfields += TYPE_N_BASECLASSES (type); 378 nfields++; /* Add one for dummy "class" field. */ 379 TYPE_NFIELDS (type) = nfields; 380 TYPE_FIELDS (type) = (struct field *) 381 TYPE_ALLOC (type, sizeof (struct field) * nfields); 382 383 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields); 384 385 TYPE_FIELD_PRIVATE_BITS (type) = 386 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 387 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields); 388 389 TYPE_FIELD_PROTECTED_BITS (type) = 390 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 391 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields); 392 393 TYPE_FIELD_IGNORE_BITS (type) = 394 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 395 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields); 396 397 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) 398 TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type))); 399 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type)); 400 401 if (tsuper != NULL) 402 { 403 TYPE_BASECLASS (type, 0) = tsuper; 404 if (type_is_object) 405 SET_TYPE_FIELD_PRIVATE (type, 0); 406 } 407 408 i = strlen (name); 409 if (i > 2 && name[i - 1] == ']' && tsuper != NULL) 410 { 411 /* FIXME */ 412 TYPE_LENGTH (type) = TYPE_LENGTH (tsuper) + 4; /* size with "length" */ 413 } 414 else 415 { 416 temp = clas; 417 temp = value_struct_elt (&temp, NULL, "size_in_bytes", NULL, "structure"); 418 TYPE_LENGTH (type) = value_as_long (temp); 419 } 420 421 fields = NULL; 422 nfields--; /* First set up dummy "class" field. */ 423 SET_FIELD_PHYSADDR (TYPE_FIELD (type, nfields), 424 VALUE_ADDRESS (clas) + VALUE_OFFSET (clas)); 425 TYPE_FIELD_NAME (type, nfields) = "class"; 426 TYPE_FIELD_TYPE (type, nfields) = VALUE_TYPE (clas); 427 SET_TYPE_FIELD_PRIVATE (type, nfields); 428 429 for (i = TYPE_N_BASECLASSES (type); i < nfields; i++) 430 { 431 int accflags; 432 int boffset; 433 if (fields == NULL) 434 { 435 temp = clas; 436 fields = value_struct_elt (&temp, NULL, "fields", NULL, "structure"); 437 field = value_ind (fields); 438 } 439 else 440 { /* Re-use field value for next field. */ 441 VALUE_ADDRESS (field) += TYPE_LENGTH (VALUE_TYPE (field)); 442 VALUE_LAZY (field) = 1; 443 } 444 temp = field; 445 temp = value_struct_elt (&temp, NULL, "name", NULL, "structure"); 446 TYPE_FIELD_NAME (type, i) = 447 get_java_utf8_name (&objfile->objfile_obstack, temp); 448 temp = field; 449 accflags = value_as_long (value_struct_elt (&temp, NULL, "accflags", 450 NULL, "structure")); 451 temp = field; 452 temp = value_struct_elt (&temp, NULL, "info", NULL, "structure"); 453 boffset = value_as_long (value_struct_elt (&temp, NULL, "boffset", 454 NULL, "structure")); 455 if (accflags & 0x0001) /* public access */ 456 { 457 /* ??? */ 458 } 459 if (accflags & 0x0002) /* private access */ 460 { 461 SET_TYPE_FIELD_PRIVATE (type, i); 462 } 463 if (accflags & 0x0004) /* protected access */ 464 { 465 SET_TYPE_FIELD_PROTECTED (type, i); 466 } 467 if (accflags & 0x0008) /* ACC_STATIC */ 468 SET_FIELD_PHYSADDR (TYPE_FIELD (type, i), boffset); 469 else 470 TYPE_FIELD_BITPOS (type, i) = 8 * boffset; 471 if (accflags & 0x8000) /* FIELD_UNRESOLVED_FLAG */ 472 { 473 TYPE_FIELD_TYPE (type, i) = get_java_object_type (); /* FIXME */ 474 } 475 else 476 { 477 struct type *ftype; 478 temp = field; 479 temp = value_struct_elt (&temp, NULL, "type", NULL, "structure"); 480 ftype = type_from_class (temp); 481 if (TYPE_CODE (ftype) == TYPE_CODE_STRUCT) 482 ftype = lookup_pointer_type (ftype); 483 TYPE_FIELD_TYPE (type, i) = ftype; 484 } 485 } 486 487 temp = clas; 488 nmethods = value_as_long (value_struct_elt (&temp, NULL, "method_count", 489 NULL, "structure")); 490 TYPE_NFN_FIELDS_TOTAL (type) = nmethods; 491 j = nmethods * sizeof (struct fn_field); 492 fn_fields = (struct fn_field *) 493 obstack_alloc (&dynamics_objfile->objfile_obstack, j); 494 memset (fn_fields, 0, j); 495 fn_fieldlists = (struct fn_fieldlist *) 496 alloca (nmethods * sizeof (struct fn_fieldlist)); 497 498 methods = NULL; 499 for (i = 0; i < nmethods; i++) 500 { 501 char *mname; 502 int k; 503 if (methods == NULL) 504 { 505 temp = clas; 506 methods = value_struct_elt (&temp, NULL, "methods", NULL, "structure"); 507 method = value_ind (methods); 508 } 509 else 510 { /* Re-use method value for next method. */ 511 VALUE_ADDRESS (method) += TYPE_LENGTH (VALUE_TYPE (method)); 512 VALUE_LAZY (method) = 1; 513 } 514 515 /* Get method name. */ 516 temp = method; 517 temp = value_struct_elt (&temp, NULL, "name", NULL, "structure"); 518 mname = get_java_utf8_name (&objfile->objfile_obstack, temp); 519 if (strcmp (mname, "<init>") == 0) 520 mname = unqualified_name; 521 522 /* Check for an existing method with the same name. 523 * This makes building the fn_fieldslists an O(nmethods**2) 524 * operation. That could be using hashing, but I doubt it 525 * is worth it. Note that we do maintain the order of methods 526 * in the inferior's Method table (as long as that is grouped 527 * by method name), which I think is desirable. --PB */ 528 for (k = 0, j = TYPE_NFN_FIELDS (type);;) 529 { 530 if (--j < 0) 531 { /* No match - new method name. */ 532 j = TYPE_NFN_FIELDS (type)++; 533 fn_fieldlists[j].name = mname; 534 fn_fieldlists[j].length = 1; 535 fn_fieldlists[j].fn_fields = &fn_fields[i]; 536 k = i; 537 break; 538 } 539 if (strcmp (mname, fn_fieldlists[j].name) == 0) 540 { /* Found an existing method with the same name. */ 541 int l; 542 if (mname != unqualified_name) 543 obstack_free (&objfile->objfile_obstack, mname); 544 mname = fn_fieldlists[j].name; 545 fn_fieldlists[j].length++; 546 k = i - k; /* Index of new slot. */ 547 /* Shift intervening fn_fields (between k and i) down. */ 548 for (l = i; l > k; l--) 549 fn_fields[l] = fn_fields[l - 1]; 550 for (l = TYPE_NFN_FIELDS (type); --l > j;) 551 fn_fieldlists[l].fn_fields++; 552 break; 553 } 554 k += fn_fieldlists[j].length; 555 } 556 fn_fields[k].physname = ""; 557 fn_fields[k].is_stub = 1; 558 fn_fields[k].type = make_function_type (java_void_type, NULL); /* FIXME */ 559 TYPE_CODE (fn_fields[k].type) = TYPE_CODE_METHOD; 560 } 561 562 j = TYPE_NFN_FIELDS (type) * sizeof (struct fn_fieldlist); 563 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *) 564 obstack_alloc (&dynamics_objfile->objfile_obstack, j); 565 memcpy (TYPE_FN_FIELDLISTS (type), fn_fieldlists, j); 566 567 return type; 568} 569 570static struct type *java_object_type; 571 572struct type * 573get_java_object_type (void) 574{ 575 if (java_object_type == NULL) 576 { 577 struct symbol *sym; 578 sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, 579 (int *) 0, (struct symtab **) NULL); 580 if (sym == NULL) 581 error ("cannot find java.lang.Object"); 582 java_object_type = SYMBOL_TYPE (sym); 583 } 584 return java_object_type; 585} 586 587int 588get_java_object_header_size (void) 589{ 590 struct type *objtype = get_java_object_type (); 591 if (objtype == NULL) 592 return (2 * TARGET_PTR_BIT / TARGET_CHAR_BIT); 593 else 594 return TYPE_LENGTH (objtype); 595} 596 597int 598is_object_type (struct type *type) 599{ 600 CHECK_TYPEDEF (type); 601 if (TYPE_CODE (type) == TYPE_CODE_PTR) 602 { 603 struct type *ttype = check_typedef (TYPE_TARGET_TYPE (type)); 604 char *name; 605 if (TYPE_CODE (ttype) != TYPE_CODE_STRUCT) 606 return 0; 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) 611 return 1; 612 name = TYPE_NFIELDS (ttype) > 0 ? TYPE_FIELD_NAME (ttype, 0) : (char *) 0; 613 if (name != NULL && strcmp (name, "vtable") == 0) 614 { 615 if (java_object_type == NULL) 616 java_object_type = type; 617 return 1; 618 } 619 } 620 return 0; 621} 622 623struct type * 624java_primitive_type (int signature) 625{ 626 switch (signature) 627 { 628 case 'B': 629 return java_byte_type; 630 case 'S': 631 return java_short_type; 632 case 'I': 633 return java_int_type; 634 case 'J': 635 return java_long_type; 636 case 'Z': 637 return java_boolean_type; 638 case 'C': 639 return java_char_type; 640 case 'F': 641 return java_float_type; 642 case 'D': 643 return java_double_type; 644 case 'V': 645 return java_void_type; 646 } 647 error ("unknown signature '%c' for primitive type", (char) signature); 648} 649 650/* If name[0 .. namelen-1] is the name of a primitive Java type, 651 return that type. Otherwise, return NULL. */ 652 653struct type * 654java_primitive_type_from_name (char *name, int namelen) 655{ 656 switch (name[0]) 657 { 658 case 'b': 659 if (namelen == 4 && memcmp (name, "byte", 4) == 0) 660 return java_byte_type; 661 if (namelen == 7 && memcmp (name, "boolean", 7) == 0) 662 return java_boolean_type; 663 break; 664 case 'c': 665 if (namelen == 4 && memcmp (name, "char", 4) == 0) 666 return java_char_type; 667 case 'd': 668 if (namelen == 6 && memcmp (name, "double", 6) == 0) 669 return java_double_type; 670 break; 671 case 'f': 672 if (namelen == 5 && memcmp (name, "float", 5) == 0) 673 return java_float_type; 674 break; 675 case 'i': 676 if (namelen == 3 && memcmp (name, "int", 3) == 0) 677 return java_int_type; 678 break; 679 case 'l': 680 if (namelen == 4 && memcmp (name, "long", 4) == 0) 681 return java_long_type; 682 break; 683 case 's': 684 if (namelen == 5 && memcmp (name, "short", 5) == 0) 685 return java_short_type; 686 break; 687 case 'v': 688 if (namelen == 4 && memcmp (name, "void", 4) == 0) 689 return java_void_type; 690 break; 691 } 692 return NULL; 693} 694 695/* Return the length (in bytes) of demangled name of the Java type 696 signature string SIGNATURE. */ 697 698static int 699java_demangled_signature_length (char *signature) 700{ 701 int array = 0; 702 for (; *signature == '['; signature++) 703 array += 2; /* Two chars for "[]". */ 704 switch (signature[0]) 705 { 706 case 'L': 707 /* Subtract 2 for 'L' and ';'. */ 708 return strlen (signature) - 2 + array; 709 default: 710 return strlen (TYPE_NAME (java_primitive_type (signature[0]))) + array; 711 } 712} 713 714/* Demangle the Java type signature SIGNATURE, leaving the result in RESULT. */ 715 716static void 717java_demangled_signature_copy (char *result, char *signature) 718{ 719 int array = 0; 720 char *ptr; 721 int i; 722 while (*signature == '[') 723 { 724 array++; 725 signature++; 726 } 727 switch (signature[0]) 728 { 729 case 'L': 730 /* Subtract 2 for 'L' and ';', but add 1 for final nul. */ 731 signature++; 732 ptr = result; 733 for (; *signature != ';' && *signature != '\0'; signature++) 734 { 735 if (*signature == '/') 736 *ptr++ = '.'; 737 else 738 *ptr++ = *signature; 739 } 740 break; 741 default: 742 ptr = TYPE_NAME (java_primitive_type (signature[0])); 743 i = strlen (ptr); 744 strcpy (result, ptr); 745 ptr = result + i; 746 break; 747 } 748 while (--array >= 0) 749 { 750 *ptr++ = '['; 751 *ptr++ = ']'; 752 } 753} 754 755/* Return the demangled name of the Java type signature string SIGNATURE, 756 as a freshly allocated copy. */ 757 758char * 759java_demangle_type_signature (char *signature) 760{ 761 int length = java_demangled_signature_length (signature); 762 char *result = xmalloc (length + 1); 763 java_demangled_signature_copy (result, signature); 764 result[length] = '\0'; 765 return result; 766} 767 768/* Return the type of TYPE followed by DIMS pairs of [ ]. 769 If DIMS == 0, TYPE is returned. */ 770 771struct type * 772java_array_type (struct type *type, int dims) 773{ 774 struct type *range_type; 775 776 while (dims-- > 0) 777 { 778 range_type = create_range_type (NULL, builtin_type_int, 0, 0); 779 /* FIXME This is bogus! Java arrays are not gdb arrays! */ 780 type = create_array_type (NULL, type, range_type); 781 } 782 783 return type; 784} 785 786/* Create a Java string in the inferior from a (Utf8) literal. */ 787 788static struct value * 789java_value_string (char *ptr, int len) 790{ 791 error ("not implemented - java_value_string"); /* FIXME */ 792} 793 794/* Print the character C on STREAM as part of the contents of a literal 795 string whose delimiter is QUOTER. Note that that format for printing 796 characters and strings is language specific. */ 797 798static void 799java_emit_char (int c, struct ui_file *stream, int quoter) 800{ 801 switch (c) 802 { 803 case '\\': 804 case '\'': 805 fprintf_filtered (stream, "\\%c", c); 806 break; 807 case '\b': 808 fputs_filtered ("\\b", stream); 809 break; 810 case '\t': 811 fputs_filtered ("\\t", stream); 812 break; 813 case '\n': 814 fputs_filtered ("\\n", stream); 815 break; 816 case '\f': 817 fputs_filtered ("\\f", stream); 818 break; 819 case '\r': 820 fputs_filtered ("\\r", stream); 821 break; 822 default: 823 if (isprint (c)) 824 fputc_filtered (c, stream); 825 else 826 fprintf_filtered (stream, "\\u%.4x", (unsigned int) c); 827 break; 828 } 829} 830 831static struct value * 832evaluate_subexp_java (struct type *expect_type, struct expression *exp, 833 int *pos, enum noside noside) 834{ 835 int pc = *pos; 836 int i; 837 char *name; 838 enum exp_opcode op = exp->elts[*pos].opcode; 839 struct value *arg1; 840 struct value *arg2; 841 struct type *type; 842 switch (op) 843 { 844 case UNOP_IND: 845 if (noside == EVAL_SKIP) 846 goto standard; 847 (*pos)++; 848 arg1 = evaluate_subexp_java (NULL_TYPE, exp, pos, EVAL_NORMAL); 849 if (is_object_type (VALUE_TYPE (arg1))) 850 { 851 struct type *type; 852 853 type = type_from_class (java_class_from_object (arg1)); 854 arg1 = value_cast (lookup_pointer_type (type), arg1); 855 } 856 if (noside == EVAL_SKIP) 857 goto nosideret; 858 return value_ind (arg1); 859 860 case BINOP_SUBSCRIPT: 861 (*pos)++; 862 arg1 = evaluate_subexp_with_coercion (exp, pos, noside); 863 arg2 = evaluate_subexp_with_coercion (exp, pos, noside); 864 if (noside == EVAL_SKIP) 865 goto nosideret; 866 /* If the user attempts to subscript something that is not an 867 array or pointer type (like a plain int variable for example), 868 then report this as an error. */ 869 870 COERCE_REF (arg1); 871 type = check_typedef (VALUE_TYPE (arg1)); 872 if (TYPE_CODE (type) == TYPE_CODE_PTR) 873 type = check_typedef (TYPE_TARGET_TYPE (type)); 874 name = TYPE_NAME (type); 875 if (name == NULL) 876 name = TYPE_TAG_NAME (type); 877 i = name == NULL ? 0 : strlen (name); 878 if (TYPE_CODE (type) == TYPE_CODE_STRUCT 879 && i > 2 && name[i - 1] == ']') 880 { 881 CORE_ADDR address; 882 long length, index; 883 struct type *el_type; 884 char buf4[4]; 885 886 struct value *clas = java_class_from_object (arg1); 887 struct value *temp = clas; 888 /* Get CLASS_ELEMENT_TYPE of the array type. */ 889 temp = value_struct_elt (&temp, NULL, "methods", 890 NULL, "structure"); 891 VALUE_TYPE (temp) = VALUE_TYPE (clas); 892 el_type = type_from_class (temp); 893 if (TYPE_CODE (el_type) == TYPE_CODE_STRUCT) 894 el_type = lookup_pointer_type (el_type); 895 896 if (noside == EVAL_AVOID_SIDE_EFFECTS) 897 return value_zero (el_type, VALUE_LVAL (arg1)); 898 address = value_as_address (arg1); 899 address += JAVA_OBJECT_SIZE; 900 read_memory (address, buf4, 4); 901 length = (long) extract_signed_integer (buf4, 4); 902 index = (long) value_as_long (arg2); 903 if (index >= length || index < 0) 904 error ("array index (%ld) out of bounds (length: %ld)", 905 index, length); 906 address = (address + 4) + index * TYPE_LENGTH (el_type); 907 return value_at (el_type, address, NULL); 908 } 909 else if (TYPE_CODE (type) == TYPE_CODE_ARRAY) 910 { 911 if (noside == EVAL_AVOID_SIDE_EFFECTS) 912 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1)); 913 else 914 return value_subscript (arg1, arg2); 915 } 916 if (name) 917 error ("cannot subscript something of type `%s'", name); 918 else 919 error ("cannot subscript requested type"); 920 921 case OP_STRING: 922 (*pos)++; 923 i = longest_to_int (exp->elts[pc + 1].longconst); 924 (*pos) += 3 + BYTES_TO_EXP_ELEM (i + 1); 925 if (noside == EVAL_SKIP) 926 goto nosideret; 927 return java_value_string (&exp->elts[pc + 2].string, i); 928 929 case STRUCTOP_STRUCT: 930 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside); 931 /* Convert object field (such as TYPE.class) to reference. */ 932 if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT) 933 arg1 = value_addr (arg1); 934 return arg1; 935 default: 936 break; 937 } 938standard: 939 return evaluate_subexp_standard (expect_type, exp, pos, noside); 940nosideret: 941 return value_from_longest (builtin_type_long, (LONGEST) 1); 942} 943 944static struct type * 945java_create_fundamental_type (struct objfile *objfile, int typeid) 946{ 947 switch (typeid) 948 { 949 case FT_VOID: 950 return java_void_type; 951 case FT_BOOLEAN: 952 return java_boolean_type; 953 case FT_CHAR: 954 return java_char_type; 955 case FT_FLOAT: 956 return java_float_type; 957 case FT_DBL_PREC_FLOAT: 958 return java_double_type; 959 case FT_BYTE: 960 case FT_SIGNED_CHAR: 961 return java_byte_type; 962 case FT_SHORT: 963 case FT_SIGNED_SHORT: 964 return java_short_type; 965 case FT_INTEGER: 966 case FT_SIGNED_INTEGER: 967 return java_int_type; 968 case FT_LONG: 969 case FT_SIGNED_LONG: 970 return java_long_type; 971 } 972 return c_create_fundamental_type (objfile, typeid); 973} 974 975static char *java_demangle (const char *mangled, int options) 976{ 977 return cplus_demangle (mangled, options | DMGL_JAVA); 978} 979 980/* Find the member function name of the demangled name NAME. NAME 981 must be a method name including arguments, in order to correctly 982 locate the last component. 983 984 This function return a pointer to the first dot before the 985 member function name, or NULL if the name was not of the 986 expected form. */ 987 988static const char * 989java_find_last_component (const char *name) 990{ 991 const char *p; 992 993 /* Find argument list. */ 994 p = strchr (name, '('); 995 996 if (p == NULL) 997 return NULL; 998 999 /* Back up and find first dot prior to argument list. */ 1000 while (p > name && *p != '.') 1001 p--; 1002 1003 if (p == name) 1004 return NULL; 1005 1006 return p; 1007} 1008 1009/* Return the name of the class containing method PHYSNAME. */ 1010 1011static char * 1012java_class_name_from_physname (const char *physname) 1013{ 1014 char *ret = NULL; 1015 const char *end; 1016 int depth = 0; 1017 char *demangled_name = java_demangle (physname, DMGL_PARAMS | DMGL_ANSI); 1018 1019 if (demangled_name == NULL) 1020 return NULL; 1021 1022 end = java_find_last_component (demangled_name); 1023 if (end != NULL) 1024 { 1025 ret = xmalloc (end - demangled_name + 1); 1026 memcpy (ret, demangled_name, end - demangled_name); 1027 ret[end - demangled_name] = '\0'; 1028 } 1029 1030 xfree (demangled_name); 1031 return ret; 1032} 1033 1034/* Table mapping opcodes into strings for printing operators 1035 and precedences of the operators. */ 1036 1037const struct op_print java_op_print_tab[] = 1038{ 1039 {",", BINOP_COMMA, PREC_COMMA, 0}, 1040 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, 1041 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, 1042 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, 1043 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0}, 1044 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0}, 1045 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0}, 1046 {"==", BINOP_EQUAL, PREC_EQUAL, 0}, 1047 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, 1048 {"<=", BINOP_LEQ, PREC_ORDER, 0}, 1049 {">=", BINOP_GEQ, PREC_ORDER, 0}, 1050 {">", BINOP_GTR, PREC_ORDER, 0}, 1051 {"<", BINOP_LESS, PREC_ORDER, 0}, 1052 {">>", BINOP_RSH, PREC_SHIFT, 0}, 1053 {"<<", BINOP_LSH, PREC_SHIFT, 0}, 1054#if 0 1055 {">>>", BINOP_ ? ? ?, PREC_SHIFT, 0}, 1056#endif 1057 {"+", BINOP_ADD, PREC_ADD, 0}, 1058 {"-", BINOP_SUB, PREC_ADD, 0}, 1059 {"*", BINOP_MUL, PREC_MUL, 0}, 1060 {"/", BINOP_DIV, PREC_MUL, 0}, 1061 {"%", BINOP_REM, PREC_MUL, 0}, 1062 {"-", UNOP_NEG, PREC_PREFIX, 0}, 1063 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, 1064 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0}, 1065 {"*", UNOP_IND, PREC_PREFIX, 0}, 1066#if 0 1067 {"instanceof", ? ? ?, ? ? ?, 0}, 1068#endif 1069 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0}, 1070 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0}, 1071 {NULL, 0, 0, 0} 1072}; 1073 1074const struct exp_descriptor exp_descriptor_java = 1075{ 1076 print_subexp_standard, 1077 operator_length_standard, 1078 op_name_standard, 1079 dump_subexp_body_standard, 1080 evaluate_subexp_java 1081}; 1082 1083const struct language_defn java_language_defn = 1084{ 1085 "java", /* Language name */ 1086 language_java, 1087 NULL, 1088 range_check_off, 1089 type_check_off, 1090 case_sensitive_on, 1091 array_row_major, 1092 &exp_descriptor_java, 1093 java_parse, 1094 java_error, 1095 null_post_parser, 1096 c_printchar, /* Print a character constant */ 1097 c_printstr, /* Function to print string constant */ 1098 java_emit_char, /* Function to print a single character */ 1099 java_create_fundamental_type, /* Create fundamental type in this language */ 1100 java_print_type, /* Print a type using appropriate syntax */ 1101 java_val_print, /* Print a value using appropriate syntax */ 1102 java_value_print, /* Print a top-level value */ 1103 NULL, /* Language specific skip_trampoline */ 1104 value_of_this, /* value_of_this */ 1105 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ 1106 basic_lookup_transparent_type,/* lookup_transparent_type */ 1107 java_demangle, /* Language specific symbol demangler */ 1108 java_class_name_from_physname,/* Language specific class name */ 1109 java_op_print_tab, /* expression operators for printing */ 1110 0, /* not c-style arrays */ 1111 0, /* String lower bound */ 1112 NULL, 1113 default_word_break_characters, 1114 c_language_arch_info, 1115 LANG_MAGIC 1116}; 1117 1118void 1119_initialize_java_language (void) 1120{ 1121 1122 java_int_type = init_type (TYPE_CODE_INT, 4, 0, "int", NULL); 1123 java_short_type = init_type (TYPE_CODE_INT, 2, 0, "short", NULL); 1124 java_long_type = init_type (TYPE_CODE_INT, 8, 0, "long", NULL); 1125 java_byte_type = init_type (TYPE_CODE_INT, 1, 0, "byte", NULL); 1126 java_boolean_type = init_type (TYPE_CODE_BOOL, 1, 0, "boolean", NULL); 1127 java_char_type = init_type (TYPE_CODE_CHAR, 2, TYPE_FLAG_UNSIGNED, "char", NULL); 1128 java_float_type = init_type (TYPE_CODE_FLT, 4, 0, "float", NULL); 1129 java_double_type = init_type (TYPE_CODE_FLT, 8, 0, "double", NULL); 1130 java_void_type = init_type (TYPE_CODE_VOID, 1, 0, "void", NULL); 1131 1132 add_language (&java_language_defn); 1133} 1134 1135/* Cleanup code that should be run on every "run". 1136 We should use make_run_cleanup to have this be called. 1137 But will that mess up values in value histry? FIXME */ 1138 1139extern void java_rerun_cleanup (void); 1140void 1141java_rerun_cleanup (void) 1142{ 1143 if (class_symtab != NULL) 1144 { 1145 free_symtab (class_symtab); /* ??? */ 1146 class_symtab = NULL; 1147 } 1148 if (dynamics_objfile != NULL) 1149 { 1150 free_objfile (dynamics_objfile); 1151 dynamics_objfile = NULL; 1152 } 1153 1154 java_object_type = NULL; 1155} 1156