OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [jv-lang.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.