Merge GDB 7.5.1

gdb/jv-lang.c

 /* Java language support routines for GDB, the GNU debugger.
 
    Copyright (C) 1997-2000, 2003-2005, 2007-2012 Free Software
    Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
@@ skipping 27 matching lines @@
 #include "dictionary.h"
 #include <ctype.h>
 #include "gdb_assert.h"
 #include "charset.h"
 #include "valprint.h"
 
 /* Local functions */
 
 extern void _initialize_java_language (void);
 
-static int java_demangled_signature_length (char *);
-static void java_demangled_signature_copy (char *, char *);
+static int java_demangled_signature_length (const char *);
+static void java_demangled_signature_copy (char *, const char *);
 
 static struct symtab *get_java_class_symtab (struct gdbarch *gdbarch);
 static char *get_java_utf8_name (struct obstack *obstack, struct value *name);
 static int java_class_is_primitive (struct value *clas);
 static struct value *java_value_string (char *ptr, int len);
 
 static void java_emit_char (int c, struct type *type,
                             struct ui_file * stream, int quoter);
 
 static char *java_class_name_from_physname (const char *physname);
@@ skipping 91 matching lines @@
       BLOCKVECTOR_NBLOCKS (bv) = 1;
       BLOCKVECTOR (class_symtab) = bv;
 
       /* Allocate dummy STATIC_BLOCK.  */
       bl = allocate_block (&objfile->objfile_obstack);
       BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
                                             NULL);
       BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
 
       /* Allocate GLOBAL_BLOCK.  */
-      bl = allocate_block (&objfile->objfile_obstack);
+      bl = allocate_global_block (&objfile->objfile_obstack);
       BLOCK_DICT (bl) = dict_create_hashed_expandable ();
+      set_block_symtab (bl, class_symtab);
       BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
 
       /* Arrange to free the dict.  */
       jv_data = objfile_data (objfile, jv_dynamics_objfile_data_key);
       jv_data->dict = BLOCK_DICT (bl);
     }
   return class_symtab;
 }
 
 static void
@@ skipping 161 matching lines @@
   return java_link_class_type (gdbarch, type, clas);
 }
 
 /* Fill in class TYPE with data from the CLAS value.  */
 
 static struct type *
 java_link_class_type (struct gdbarch *gdbarch,
                       struct type *type, struct value *clas)
 {
   struct value *temp;
-  char *unqualified_name;
-  char *name = TYPE_TAG_NAME (type);
+  const char *unqualified_name;
+  const char *name = TYPE_TAG_NAME (type);
   int ninterfaces, nfields, nmethods;
   int type_is_object = 0;
   struct fn_field *fn_fields;
   struct fn_fieldlist *fn_fieldlists;
   struct value *fields;
   struct value *methods;
   struct value *method = NULL;
   struct value *field = NULL;
   int i, j;
   struct objfile *objfile = get_dynamics_objfile (gdbarch);
@@ skipping 117 matching lines @@
         {
           SET_TYPE_FIELD_PRIVATE (type, i);
         }
       if (accflags & 0x0004)    /* protected access */
         {
           SET_TYPE_FIELD_PROTECTED (type, i);
         }
       if (accflags & 0x0008)    /* ACC_STATIC */
         SET_FIELD_PHYSADDR (TYPE_FIELD (type, i), boffset);
       else
-        TYPE_FIELD_BITPOS (type, i) = 8 * boffset;
+        SET_FIELD_BITPOS (TYPE_FIELD (type, i), 8 * boffset);
       if (accflags & 0x8000)    /* FIELD_UNRESOLVED_FLAG */
         {
           TYPE_FIELD_TYPE (type, i) = get_java_object_type ();  /* FIXME */
         }
       else
         {
           struct type *ftype;
 
           temp = field;
           temp = value_struct_elt (&temp, NULL, "type", NULL, "structure");
           ftype = type_from_class (gdbarch, temp);
           if (TYPE_CODE (ftype) == TYPE_CODE_STRUCT)
             ftype = lookup_pointer_type (ftype);
           TYPE_FIELD_TYPE (type, i) = ftype;
         }
     }
 
   temp = clas;
   nmethods = value_as_long (value_struct_elt (&temp, NULL, "method_count",
                                               NULL, "structure"));
-  TYPE_NFN_FIELDS_TOTAL (type) = nmethods;
   j = nmethods * sizeof (struct fn_field);
   fn_fields = (struct fn_field *)
     obstack_alloc (&objfile->objfile_obstack, j);
   memset (fn_fields, 0, j);
   fn_fieldlists = (struct fn_fieldlist *)
     alloca (nmethods * sizeof (struct fn_fieldlist));
 
   methods = NULL;
   for (i = 0; i < nmethods; i++)
     {
-      char *mname;
+      const char *mname;
       int k;
 
       if (methods == NULL)
         {
           temp = clas;
           methods = value_struct_elt (&temp, NULL, "methods",
                                       NULL, "structure");
           method = value_ind (methods);
         }
       else
@@ skipping 85 matching lines @@
     return TYPE_LENGTH (objtype);
 }
 
 int
 is_object_type (struct type *type)
 {
   CHECK_TYPEDEF (type);
   if (TYPE_CODE (type) == TYPE_CODE_PTR)
     {
       struct type *ttype = check_typedef (TYPE_TARGET_TYPE (type));
-      char *name;
+      const char *name;
       if (TYPE_CODE (ttype) != TYPE_CODE_STRUCT)
         return 0;
       while (TYPE_N_BASECLASSES (ttype) > 0)
         ttype = TYPE_BASECLASS (ttype, 0);
       name = TYPE_TAG_NAME (ttype);
       if (name != NULL && strcmp (name, "java.lang.Object") == 0)
         return 1;
       name
         = TYPE_NFIELDS (ttype) > 0 ? TYPE_FIELD_NAME (ttype, 0) : (char *) 0;
       if (name != NULL && strcmp (name, "vtable") == 0)
@@ skipping 29 matching lines @@
       return builtin->builtin_void;
     }
   error (_("unknown signature '%c' for primitive type"), (char) signature);
 }
 
 /* If name[0 .. namelen-1] is the name of a primitive Java type,
    return that type.  Otherwise, return NULL.  */
 
 struct type *
 java_primitive_type_from_name (struct gdbarch *gdbarch,
-                               char *name, int namelen)
+                               const char *name, int namelen)
 {
   const struct builtin_java_type *builtin = builtin_java_type (gdbarch);
 
   switch (name[0])
     {
     case 'b':
       if (namelen == 4 && memcmp (name, "byte", 4) == 0)
         return builtin->builtin_byte;
       if (namelen == 7 && memcmp (name, "boolean", 7) == 0)
         return builtin->builtin_boolean;
@@ skipping 54 matching lines @@
     case 'V':
       return "void";
     }
   error (_("unknown signature '%c' for primitive type"), (char) signature);
 }
 
 /* Return the length (in bytes) of demangled name of the Java type
    signature string SIGNATURE.  */
 
 static int
-java_demangled_signature_length (char *signature)
+java_demangled_signature_length (const char *signature)
 {
   int array = 0;
 
   for (; *signature == '['; signature++)
     array += 2;                 /* Two chars for "[]".  */
   switch (signature[0])
     {
     case 'L':
       /* Subtract 2 for 'L' and ';'.  */
       return strlen (signature) - 2 + array;
     default:
       return strlen (java_primitive_type_name (signature[0])) + array;
     }
 }
 
 /* Demangle the Java type signature SIGNATURE, leaving the result in
    RESULT.  */
 
 static void
-java_demangled_signature_copy (char *result, char *signature)
+java_demangled_signature_copy (char *result, const char *signature)
 {
   int array = 0;
   char *ptr;
   int i;
 
   while (*signature == '[')
     {
       array++;
       signature++;
     }
@@ skipping 22 matching lines @@
     {
       *ptr++ = '[';
       *ptr++ = ']';
     }
 }
 
 /* Return the demangled name of the Java type signature string SIGNATURE,
    as a freshly allocated copy.  */
 
 char *
-java_demangle_type_signature (char *signature)
+java_demangle_type_signature (const char *signature)
 {
   int length = java_demangled_signature_length (signature);
   char *result = xmalloc (length + 1);
 
   java_demangled_signature_copy (result, signature);
   result[length] = '\0';
   return result;
 }
 
 /* Return the type of TYPE followed by DIMS pairs of [ ].
@@ skipping 79 matching lines @@
   generic_printstr (stream, type, string, length, encoding,
                     force_ellipses, '"', 0, options);
 }
 
 static struct value *
 evaluate_subexp_java (struct type *expect_type, struct expression *exp,
                       int *pos, enum noside noside)
 {
   int pc = *pos;
   int i;
-  char *name;
+  const char *name;
   enum exp_opcode op = exp->elts[*pos].opcode;
   struct value *arg1;
   struct value *arg2;
   struct type *type;
 
   switch (op)
     {
     case UNOP_IND:
       if (noside == EVAL_SKIP)
         goto standard;
@@ skipping 255 matching lines @@
   java_parse,
   java_error,
   null_post_parser,
   java_printchar,               /* Print a character constant */
   java_printstr,                /* Function to print string constant */
   java_emit_char,               /* Function to print a single character */
   java_print_type,              /* Print a type using appropriate syntax */
   default_print_typedef,        /* Print a typedef using appropriate syntax */
   java_val_print,               /* Print a value using appropriate syntax */
   java_value_print,             /* Print a top-level value */
+  default_read_var_value,       /* la_read_var_value */
   NULL,                         /* Language specific skip_trampoline */
   "this",                       /* name_of_this */
   basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
   basic_lookup_transparent_type,/* lookup_transparent_type */
   java_demangle,                /* Language specific symbol demangler */
   java_class_name_from_physname,/* Language specific class name */
   java_op_print_tab,            /* expression operators for printing */
   0,                            /* not c-style arrays */
   0,                            /* String lower bound */
   default_word_break_characters,
   default_make_symbol_completion_list,
   java_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
   default_get_string,
-  strcmp_iw_ordered,
+  NULL,                         /* la_get_symbol_name_cmp */
   iterate_over_symbols,
   LANG_MAGIC
 };
 
 static void *
 build_java_types (struct gdbarch *gdbarch)
 {
   struct builtin_java_type *builtin_java_type
     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_java_type);
 
@@ skipping 31 matching lines @@
 _initialize_java_language (void)
 {
   jv_dynamics_objfile_data_key
     = register_objfile_data_with_cleanup (NULL, jv_per_objfile_free);
   jv_dynamics_progspace_key = register_program_space_data ();
 
   java_type_data = gdbarch_data_register_post_init (build_java_types);
 
   add_language (&java_language_defn);
 }