Import gdb-7.10.1
[dragonfly.git] / contrib / gdb-7 / gdb / jit.c
index 2383a2b..f977ea6 100644 (file)
@@ -1,6 +1,6 @@
 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
 
-   Copyright (C) 2009-2013 Free Software Foundation, Inc.
+   Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -37,8 +37,7 @@
 #include "symtab.h"
 #include "target.h"
 #include "gdb-dlfcn.h"
-#include "gdb_stat.h"
-#include "exceptions.h"
+#include <sys/stat.h>
 #include "gdb_bfd.h"
 
 static const char *jit_reader_dir = NULL;
@@ -127,6 +126,7 @@ mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
 {
   struct target_buffer *buffer = (struct target_buffer*) stream;
 
+  memset (sb, 0, sizeof (struct stat));
   sb->st_size = buffer->size;
   return 0;
 }
@@ -189,7 +189,7 @@ jit_reader_load (const char *file_name)
   if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
     error (_("Reader version does not match GDB version."));
 
-  new_reader = XZALLOC (struct jit_reader);
+  new_reader = XCNEW (struct jit_reader);
   new_reader->functions = funcs;
   new_reader->handle = so;
 
@@ -214,7 +214,7 @@ jit_reader_load_command (char *args, int from_tty)
   if (IS_ABSOLUTE_PATH (args))
     so_name = xstrdup (args);
   else
-    so_name = xstrprintf ("%s%s%s", SLASH_STRING, jit_reader_dir, args);
+    so_name = xstrprintf ("%s%s%s", jit_reader_dir, SLASH_STRING, args);
   prev_cleanup = make_cleanup (xfree, so_name);
 
   loaded_jit_reader = jit_reader_load (so_name);
@@ -288,7 +288,7 @@ get_jit_objfile_data (struct objfile *objf)
   objf_data = objfile_data (objf, jit_objfile_data);
   if (objf_data == NULL)
     {
-      objf_data = XZALLOC (struct jit_objfile_data);
+      objf_data = XCNEW (struct jit_objfile_data);
       set_objfile_data (objf, jit_objfile_data, objf_data);
     }
 
@@ -318,7 +318,7 @@ get_jit_program_space_data (void)
   ps_data = program_space_data (current_program_space, jit_program_space_data);
   if (ps_data == NULL)
     {
-      ps_data = XZALLOC (struct jit_program_space_data);
+      ps_data = XCNEW (struct jit_program_space_data);
       set_program_space_data (current_program_space, jit_program_space_data,
                              ps_data);
     }
@@ -357,7 +357,8 @@ jit_read_descriptor (struct gdbarch *gdbarch,
   if (jit_debug)
     fprintf_unfiltered (gdb_stdlog,
                        "jit_read_descriptor, descriptor_addr = %s\n",
-                       paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
+                       paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
+                                                                 objf_data->descriptor)));
 
   /* Figure out how big the descriptor is on the remote and how to read it.  */
   ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
@@ -366,7 +367,8 @@ jit_read_descriptor (struct gdbarch *gdbarch,
   desc_buf = alloca (desc_size);
 
   /* Read the descriptor.  */
-  err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
+  err = target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
+                                                  objf_data->descriptor),
                            desc_buf, desc_size);
   if (err)
     {
@@ -504,7 +506,7 @@ jit_object_open_impl (struct gdb_symbol_callbacks *cb)
   /* CB is not required right now, but sometime in the future we might
      need a handle to it, and we'd like to do that without breaking
      the ABI.  */
-  return XZALLOC (struct gdb_object);
+  return XCNEW (struct gdb_object);
 }
 
 /* Readers call into this function to open a new gdb_symtab, which,
@@ -519,7 +521,7 @@ jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
 
   /* CB stays unused.  See comment in jit_object_open_impl.  */
 
-  ret = XZALLOC (struct gdb_symtab);
+  ret = XCNEW (struct gdb_symtab);
   ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
   ret->next = object->symtabs;
   object->symtabs = ret;
@@ -531,15 +533,15 @@ jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
 
 static int
 compare_block (const struct gdb_block *const old,
-               const struct gdb_block *const new)
+               const struct gdb_block *const newobj)
 {
   if (old == NULL)
     return 1;
-  if (old->begin < new->begin)
+  if (old->begin < newobj->begin)
     return 1;
-  else if (old->begin == new->begin)
+  else if (old->begin == newobj->begin)
     {
-      if (old->end > new->end)
+      if (old->end > newobj->end)
         return 1;
       else
         return 0;
@@ -557,7 +559,7 @@ jit_block_open_impl (struct gdb_symbol_callbacks *cb,
                      struct gdb_symtab *symtab, struct gdb_block *parent,
                      GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
 {
-  struct gdb_block *block = XZALLOC (struct gdb_block);
+  struct gdb_block *block = XCNEW (struct gdb_block);
 
   block->next = symtab->blocks;
   block->begin = (CORE_ADDR) begin;
@@ -632,44 +634,46 @@ jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
 static void
 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
 {
-  struct symtab *symtab;
+  struct compunit_symtab *cust;
   struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
   struct block *block_iter;
-  int actual_nblocks, i, blockvector_size;
+  int actual_nblocks, i;
+  size_t blockvector_size;
   CORE_ADDR begin, end;
+  struct blockvector *bv;
 
   actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
 
-  symtab = allocate_symtab (stab->file_name, objfile);
+  cust = allocate_compunit_symtab (objfile, stab->file_name);
+  allocate_symtab (cust, stab->file_name);
+  add_compunit_symtab_to_objfile (cust);
+
   /* JIT compilers compile in memory.  */
-  symtab->dirname = NULL;
+  COMPUNIT_DIRNAME (cust) = NULL;
 
   /* Copy over the linetable entry if one was provided.  */
   if (stab->linetable)
     {
-      int size = ((stab->linetable->nitems - 1)
-                  * sizeof (struct linetable_entry)
-                  + sizeof (struct linetable));
-      LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
-      memcpy (LINETABLE (symtab), stab->linetable, size);
-    }
-  else
-    {
-      LINETABLE (symtab) = NULL;
+      size_t size = ((stab->linetable->nitems - 1)
+                    * sizeof (struct linetable_entry)
+                    + sizeof (struct linetable));
+      SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
+       = obstack_alloc (&objfile->objfile_obstack, size);
+      memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)), stab->linetable,
+             size);
     }
 
   blockvector_size = (sizeof (struct blockvector)
                       + (actual_nblocks - 1) * sizeof (struct block *));
-  symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
-                                       blockvector_size);
+  bv = obstack_alloc (&objfile->objfile_obstack, blockvector_size);
+  COMPUNIT_BLOCKVECTOR (cust) = bv;
 
   /* (begin, end) will contain the PC range this entire blockvector
      spans.  */
-  symtab->primary = 1;
-  BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
+  BLOCKVECTOR_MAP (bv) = NULL;
   begin = stab->blocks->begin;
   end = stab->blocks->end;
-  BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
+  BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks;
 
   /* First run over all the gdb_block objects, creating a real block
      object for each.  Simultaneously, keep setting the real_block
@@ -679,8 +683,7 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
        i--, gdb_block_iter = gdb_block_iter->next)
     {
       struct block *new_block = allocate_block (&objfile->objfile_obstack);
-      struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
-                                                 sizeof (struct symbol));
+      struct symbol *block_name = allocate_symbol (objfile);
       struct type *block_type = arch_type (get_objfile_arch (objfile),
                                           TYPE_CODE_VOID,
                                           1,
@@ -693,10 +696,9 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
       BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
 
       /* The name.  */
-      memset (block_name, 0, sizeof (struct symbol));
       SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
-      SYMBOL_CLASS (block_name) = LOC_BLOCK;
-      SYMBOL_SYMTAB (block_name) = symtab;
+      SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
+      symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
       SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
       SYMBOL_BLOCK_VALUE (block_name) = new_block;
 
@@ -706,7 +708,7 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
 
       BLOCK_FUNCTION (new_block) = block_name;
 
-      BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
+      BLOCKVECTOR_BLOCK (bv, i) = new_block;
       if (begin > BLOCK_START (new_block))
         begin = BLOCK_START (new_block);
       if (end < BLOCK_END (new_block))
@@ -732,10 +734,10 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
       BLOCK_START (new_block) = (CORE_ADDR) begin;
       BLOCK_END (new_block) = (CORE_ADDR) end;
 
-      BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
+      BLOCKVECTOR_BLOCK (bv, i) = new_block;
 
       if (i == GLOBAL_BLOCK)
-       set_block_symtab (new_block, symtab);
+       set_block_compunit_symtab (new_block, cust);
     }
 
   /* Fill up the superblock fields for the real blocks, using the
@@ -755,7 +757,7 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
        {
          /* And if not, we set a default parent block.  */
          BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
-           BLOCKVECTOR_BLOCK (symtab->blockvector, STATIC_BLOCK);
+           BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
        }
     }
 
@@ -787,13 +789,12 @@ jit_object_close_impl (struct gdb_symbol_callbacks *cb,
 
   priv_data = cb->priv_data;
 
-  objfile = allocate_objfile (NULL, 0);
-  objfile->gdbarch = target_gdbarch ();
+  objfile = allocate_objfile (NULL, "<< JIT compiled code >>",
+                             OBJF_NOT_FILENAME);
+  objfile->per_bfd->gdbarch = target_gdbarch ();
 
   terminate_minimal_symbol_table (objfile);
 
-  objfile->name = "<< JIT compiled code >>";
-
   j = NULL;
   for (i = obj->symtabs; i; i = j)
     {
@@ -816,7 +817,6 @@ jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
   int status;
   jit_dbg_reader_data priv_data;
   struct gdb_reader_funcs *funcs;
-  volatile struct gdb_exception e;
   struct gdb_symbol_callbacks callbacks =
     {
       jit_object_open_impl,
@@ -839,12 +839,17 @@ jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
   gdb_mem = xmalloc (code_entry->symfile_size);
 
   status = 1;
-  TRY_CATCH (e, RETURN_MASK_ALL)
-    if (target_read_memory (code_entry->symfile_addr, gdb_mem,
-                            code_entry->symfile_size))
+  TRY
+    {
+      if (target_read_memory (code_entry->symfile_addr, gdb_mem,
+                             code_entry->symfile_size))
+       status = 0;
+    }
+  CATCH (e, RETURN_MASK_ALL)
+    {
       status = 0;
-  if (e.reason < 0)
-    status = 0;
+    }
+  END_CATCH
 
   if (status)
     {
@@ -925,10 +930,12 @@ JITed symbol file is not an object file, ignoring it.\n"));
         sai->other[i].sectindex = sec->index;
         ++i;
       }
+  sai->num_sections = i;
 
   /* This call does not take ownership of SAI.  */
   make_cleanup_bfd_unref (nbfd);
-  objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
+  objfile = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd), 0, sai,
+                                     OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
 
   do_cleanups (old_cleanups);
   add_objfile_entry (objfile, entry_addr);
@@ -1016,8 +1023,8 @@ static int
 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
                                struct jit_program_space_data *ps_data)
 {
-  struct minimal_symbol *reg_symbol, *desc_symbol;
-  struct objfile *objf;
+  struct bound_minimal_symbol reg_symbol;
+  struct bound_minimal_symbol desc_symbol;
   struct jit_objfile_data *objf_data;
   CORE_ADDR addr;
 
@@ -1025,24 +1032,27 @@ jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
     {
       /* Lookup the registration symbol.  If it is missing, then we
         assume we are not attached to a JIT.  */
-      reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
-      if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
+      reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
+      if (reg_symbol.minsym == NULL
+         || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
        return 1;
 
-      desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
-      if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
+      desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
+                                          reg_symbol.objfile);
+      if (desc_symbol.minsym == NULL
+         || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
        return 1;
 
-      objf_data = get_jit_objfile_data (objf);
-      objf_data->register_code = reg_symbol;
-      objf_data->descriptor = desc_symbol;
+      objf_data = get_jit_objfile_data (reg_symbol.objfile);
+      objf_data->register_code = reg_symbol.minsym;
+      objf_data->descriptor = desc_symbol.minsym;
 
-      ps_data->objfile = objf;
+      ps_data->objfile = reg_symbol.objfile;
     }
   else
     objf_data = get_jit_objfile_data (ps_data->objfile);
 
-  addr = SYMBOL_VALUE_ADDRESS (objf_data->register_code);
+  addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
 
   if (jit_debug)
     fprintf_unfiltered (gdb_stdlog,
@@ -1180,11 +1190,11 @@ jit_frame_sniffer (const struct frame_unwind *self,
 
   gdb_assert (!*cache);
 
-  *cache = XZALLOC (struct jit_unwind_private);
+  *cache = XCNEW (struct jit_unwind_private);
   priv_data = *cache;
   priv_data->registers =
-    XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
-             struct gdb_reg_value *);
+    XCNEWVEC (struct gdb_reg_value *,        
+             gdbarch_num_regs (get_frame_arch (this_frame)));
   priv_data->this_frame = this_frame;
 
   callbacks.priv_data = priv_data;
@@ -1215,20 +1225,20 @@ static void
 jit_frame_this_id (struct frame_info *this_frame, void **cache,
                    struct frame_id *this_id)
 {
-  struct jit_unwind_private private;
+  struct jit_unwind_private priv;
   struct gdb_frame_id frame_id;
   struct gdb_reader_funcs *funcs;
   struct gdb_unwind_callbacks callbacks;
 
-  private.registers = NULL;
-  private.this_frame = this_frame;
+  priv.registers = NULL;
+  priv.this_frame = this_frame;
 
   /* We don't expect the frame_id function to set any registers, so we
      set reg_set to NULL.  */
   callbacks.reg_get = jit_unwind_reg_get_impl;
   callbacks.reg_set = NULL;
   callbacks.target_read = jit_target_read_impl;
-  callbacks.priv_data = &private;
+  callbacks.priv_data = &priv;
 
   gdb_assert (loaded_jit_reader);
   funcs = loaded_jit_reader->functions;