* value.h (struct internalvar): Remove.

[deliverable/binutils-gdb.git] / gdb / dwarf2loc.c

diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index a4141a0432c0e9de640388e5803de09654c1be30..5ffccd382867e76d970b111b7463b05d43960970 100644 (file)
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -1,23 +1,23 @@
 /* DWARF 2 location expression support for GDB.
 /* DWARF 2 location expression support for GDB.

-   Copyright 2003 Free Software Foundation, Inc.
+
+   Copyright (C) 2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+

    Contributed by Daniel Jacobowitz, MontaVista Software, 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
    Contributed by Daniel Jacobowitz, MontaVista Software, 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 2 of the License, or (at
-   your option) any later version.
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.

 
 

-   This program is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.

 
    You should have received a copy of the GNU General Public License
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "ui-out.h"
 
 #include "defs.h"
 #include "ui-out.h"


@@ -30,16 +30,14 @@
 #include "ax-gdb.h"
 #include "regcache.h"
 #include "objfiles.h"
 #include "ax-gdb.h"
 #include "regcache.h"
 #include "objfiles.h"

+#include "exceptions.h"

 
 #include "elf/dwarf2.h"
 #include "dwarf2expr.h"
 #include "dwarf2loc.h"
 
 #include "gdb_string.h"
 
 #include "elf/dwarf2.h"
 #include "dwarf2expr.h"
 #include "dwarf2loc.h"
 
 #include "gdb_string.h"

-
-#ifndef DWARF2_REG_TO_REGNUM
-#define DWARF2_REG_TO_REGNUM(REG) (REG)
-#endif
+#include "gdb_assert.h"

 
 /* A helper function for dealing with location lists.  Given a
    symbol baton (BATON) and a pc value (PC), find the appropriate
 
 /* A helper function for dealing with location lists.  Given a
    symbol baton (BATON) and a pc value (PC), find the appropriate


@@ -49,25 +47,31 @@
    For now, only return the first matching location expression; there
    can be more than one in the list.  */
 
    For now, only return the first matching location expression; there
    can be more than one in the list.  */
 

-static char *
+static gdb_byte *

 find_location_expression (struct dwarf2_loclist_baton *baton,
                          size_t *locexpr_length, CORE_ADDR pc)
 {
 find_location_expression (struct dwarf2_loclist_baton *baton,
                          size_t *locexpr_length, CORE_ADDR pc)
 {

-  CORE_ADDR base_address = baton->base_address;

   CORE_ADDR low, high;
   CORE_ADDR low, high;

-  char *loc_ptr, *buf_end;
-  unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT, length;
+  gdb_byte *loc_ptr, *buf_end;
+  int length;
+  struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);

   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));

+  /* Adjust base_address for relocatable objects.  */
+  CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
+                                   SECT_OFF_TEXT (objfile));
+  CORE_ADDR base_address = baton->base_address + base_offset;

 
   loc_ptr = baton->data;
   buf_end = baton->data + baton->size;
 
   while (1)
     {
 
   loc_ptr = baton->data;
   buf_end = baton->data + baton->size;
 
   while (1)
     {

-      low = dwarf2_read_address (loc_ptr, buf_end, &length);
-      loc_ptr += length;
-      high = dwarf2_read_address (loc_ptr, buf_end, &length);
-      loc_ptr += length;
+      low = dwarf2_read_address (gdbarch, loc_ptr, buf_end, addr_size);
+      loc_ptr += addr_size;
+      high = dwarf2_read_address (gdbarch, loc_ptr, buf_end, addr_size);
+      loc_ptr += addr_size;

 
       /* An end-of-list entry.  */
       if (low == 0 && high == 0)
 
       /* An end-of-list entry.  */
       if (low == 0 && high == 0)


@@ -107,35 +111,26 @@ struct dwarf_expr_baton
 
 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 
 
 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 

-/* Using the frame specified in BATON, read register REGNUM.  The lval
-   type will be returned in LVALP, and for lval_memory the register
-   save address will be returned in ADDRP.  */
+/* Using the frame specified in BATON, return the value of register
+   REGNUM, treated as a pointer.  */

 static CORE_ADDR
 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 {
   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 static CORE_ADDR
 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 {
   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;

-  CORE_ADDR result, save_addr;
-  enum lval_type lval_type;
-  char *buf;
-  int optimized, regnum, realnum, regsize;
-
-  regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
-  regsize = register_size (current_gdbarch, regnum);
-  buf = (char *) alloca (regsize);
-
-  frame_register (debaton->frame, regnum, &optimized, &lval_type, &save_addr,
-                 &realnum, buf);
-  /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
-     address is always unsigned.  That may or may not be true.  */
-  result = extract_unsigned_integer (buf, regsize);
+  struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
+  CORE_ADDR result;
+  int regnum;

 
 

+  regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
+  result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
+                                 regnum, debaton->frame);

   return result;
 }
 
 /* Read memory at ADDR (length LEN) into BUF.  */
 
 static void
   return result;
 }
 
 /* Read memory at ADDR (length LEN) into BUF.  */
 
 static void

-dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
+dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)

 {
   read_memory (addr, buf, len);
 }
 {
   read_memory (addr, buf, len);
 }


@@ -144,7 +139,7 @@ dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
    describing the frame base.  Return a pointer to it in START and
    its length in LENGTH.  */
 static void
    describing the frame base.  Return a pointer to it in START and
    its length in LENGTH.  */
 static void

-dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
+dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length)

 {
   /* FIXME: cagney/2003-03-26: This code should be using
      get_frame_base_address(), and then implement a dwarf2 specific
 {
   /* FIXME: cagney/2003-03-26: This code should be using
      get_frame_base_address(), and then implement a dwarf2 specific


@@ -154,23 +149,35 @@ dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
 
   framefunc = get_frame_function (debaton->frame);
 
 
   framefunc = get_frame_function (debaton->frame);
 

-  if (SYMBOL_LOCATION_FUNCS (framefunc) == &dwarf2_loclist_funcs)
+  /* If we found a frame-relative symbol then it was certainly within
+     some function associated with a frame. If we can't find the frame,
+     something has gone wrong.  */
+  gdb_assert (framefunc != NULL);
+
+  if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs)

     {
       struct dwarf2_loclist_baton *symbaton;
     {
       struct dwarf2_loclist_baton *symbaton;

+      struct frame_info *frame = debaton->frame;
+

       symbaton = SYMBOL_LOCATION_BATON (framefunc);
       *start = find_location_expression (symbaton, length,
       symbaton = SYMBOL_LOCATION_BATON (framefunc);
       *start = find_location_expression (symbaton, length,

-                                        get_frame_pc (debaton->frame));
+                                        get_frame_address_in_block (frame));

     }
   else
     {
       struct dwarf2_locexpr_baton *symbaton;
       symbaton = SYMBOL_LOCATION_BATON (framefunc);
     }
   else
     {
       struct dwarf2_locexpr_baton *symbaton;
       symbaton = SYMBOL_LOCATION_BATON (framefunc);

-      *length = symbaton->size;
-      *start = symbaton->data;
+      if (symbaton != NULL)
+       {
+         *length = symbaton->size;
+         *start = symbaton->data;
+       }
+      else
+       *start = NULL;

     }
 
   if (*start == NULL)
     }
 
   if (*start == NULL)

-    error ("Could not find the frame base for \"%s\".",
+    error (_("Could not find the frame base for \"%s\"."),

           SYMBOL_NATURAL_NAME (framefunc));
 }
 
           SYMBOL_NATURAL_NAME (framefunc));
 }
 


@@ -180,18 +187,8 @@ static CORE_ADDR
 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 {
   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 {
   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;

-  CORE_ADDR addr;
-
-  if (target_get_thread_local_address_p ())
-    addr = target_get_thread_local_address (inferior_ptid,
-                                           debaton->objfile,
-                                           offset);
-  /* It wouldn't be wrong here to try a gdbarch method, too; finding
-     TLS is an ABI-specific thing.  But we don't do that yet.  */
-  else
-    error ("Cannot find thread-local variables on this target");

 
 

-  return addr;
+  return target_translate_tls_address (debaton->objfile, offset);

 }
 
 /* Evaluate a location description, starting at DATA and with length
 }
 
 /* Evaluate a location description, starting at DATA and with length


@@ -199,10 +196,9 @@ dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
    of FRAME.  */
 static struct value *
 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
    of FRAME.  */
 static struct value *
 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,

-                         unsigned char *data, unsigned short size,
-                         struct objfile *objfile)
+                         gdb_byte *data, unsigned short size,
+                         struct dwarf2_per_cu_data *per_cu)

 {
 {

-  CORE_ADDR result;

   struct value *retval;
   struct dwarf_expr_baton baton;
   struct dwarf_expr_context *ctx;
   struct value *retval;
   struct dwarf_expr_baton baton;
   struct dwarf_expr_context *ctx;


@@ -211,13 +207,16 @@ dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
     {
       retval = allocate_value (SYMBOL_TYPE (var));
       VALUE_LVAL (retval) = not_lval;
     {
       retval = allocate_value (SYMBOL_TYPE (var));
       VALUE_LVAL (retval) = not_lval;

-      VALUE_OPTIMIZED_OUT (retval) = 1;
+      set_value_optimized_out (retval, 1);
+      return retval;

     }
 
   baton.frame = frame;
     }
 
   baton.frame = frame;

-  baton.objfile = objfile;
+  baton.objfile = dwarf2_per_cu_objfile (per_cu);

 
   ctx = new_dwarf_expr_context ();
 
   ctx = new_dwarf_expr_context ();

+  ctx->gdbarch = get_objfile_arch (baton.objfile);
+  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);

   ctx->baton = &baton;
   ctx->read_reg = dwarf_expr_read_reg;
   ctx->read_mem = dwarf_expr_read_mem;
   ctx->baton = &baton;
   ctx->read_reg = dwarf_expr_read_reg;
   ctx->read_mem = dwarf_expr_read_mem;


@@ -225,23 +224,51 @@ dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
   ctx->get_tls_address = dwarf_expr_tls_address;
 
   dwarf_expr_eval (ctx, data, size);
   ctx->get_tls_address = dwarf_expr_tls_address;
 
   dwarf_expr_eval (ctx, data, size);

-  result = dwarf_expr_fetch (ctx, 0);
+  if (ctx->num_pieces > 0)
+    {
+      int i;
+      long offset = 0;
+      bfd_byte *contents;

 
 

-  if (ctx->in_reg)
+      retval = allocate_value (SYMBOL_TYPE (var));
+      contents = value_contents_raw (retval);
+      for (i = 0; i < ctx->num_pieces; i++)
+       {
+         struct dwarf_expr_piece *p = &ctx->pieces[i];
+         if (p->in_reg)
+           {
+             struct gdbarch *arch = get_frame_arch (frame);
+             bfd_byte regval[MAX_REGISTER_SIZE];
+             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->value);
+             get_frame_register (frame, gdb_regnum, regval);
+             memcpy (contents + offset, regval, p->size);
+           }
+         else /* In memory?  */
+           {
+             read_memory (p->value, contents + offset, p->size);
+           }
+         offset += p->size;
+       }
+    }
+  else if (ctx->in_reg)

     {
     {

-      int regnum = DWARF2_REG_TO_REGNUM (result);
-      retval = value_from_register (SYMBOL_TYPE (var), regnum, frame);
+      struct gdbarch *arch = get_frame_arch (frame);
+      CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
+      int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
+      retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);

     }
   else
     {
     }
   else
     {

-      retval = allocate_value (SYMBOL_TYPE (var));
-      VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
+      CORE_ADDR address = dwarf_expr_fetch (ctx, 0);

 
 

+      retval = allocate_value (SYMBOL_TYPE (var));

       VALUE_LVAL (retval) = lval_memory;
       VALUE_LVAL (retval) = lval_memory;

-      VALUE_LAZY (retval) = 1;
-      VALUE_ADDRESS (retval) = result;
+      set_value_lazy (retval, 1);
+      set_value_address (retval, address);

     }
 
     }
 

+  set_value_initialized (retval, ctx->initialized);
+

   free_dwarf_expr_context (ctx);
 
   return retval;
   free_dwarf_expr_context (ctx);
 
   return retval;


@@ -269,16 +296,16 @@ needs_frame_read_reg (void *baton, int regnum)
 
 /* Reads from memory do not require a frame.  */
 static void
 
 /* Reads from memory do not require a frame.  */
 static void

-needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
+needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)

 {
   memset (buf, 0, len);
 }
 
 /* Frame-relative accesses do require a frame.  */
 static void
 {
   memset (buf, 0, len);
 }
 
 /* Frame-relative accesses do require a frame.  */
 static void

-needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
+needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)

 {
 {

-  static char lit0 = DW_OP_lit0;
+  static gdb_byte lit0 = DW_OP_lit0;

   struct needs_frame_baton *nf_baton = baton;
 
   *start = &lit0;
   struct needs_frame_baton *nf_baton = baton;
 
   *start = &lit0;


@@ -300,14 +327,18 @@ needs_frame_tls_address (void *baton, CORE_ADDR offset)
    requires a frame to evaluate.  */
 
 static int
    requires a frame to evaluate.  */
 
 static int

-dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
+dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
+                            struct dwarf2_per_cu_data *per_cu)

 {
   struct needs_frame_baton baton;
   struct dwarf_expr_context *ctx;
 {
   struct needs_frame_baton baton;
   struct dwarf_expr_context *ctx;

+  int in_reg;

 
   baton.needs_frame = 0;
 
   ctx = new_dwarf_expr_context ();
 
   baton.needs_frame = 0;
 
   ctx = new_dwarf_expr_context ();

+  ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (per_cu));
+  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);

   ctx->baton = &baton;
   ctx->read_reg = needs_frame_read_reg;
   ctx->read_mem = needs_frame_read_mem;
   ctx->baton = &baton;
   ctx->read_reg = needs_frame_read_reg;
   ctx->read_mem = needs_frame_read_mem;


@@ -316,18 +347,31 @@ dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
 
   dwarf_expr_eval (ctx, data, size);
 
 
   dwarf_expr_eval (ctx, data, size);
 

+  in_reg = ctx->in_reg;
+
+  if (ctx->num_pieces > 0)
+    {
+      int i;
+
+      /* If the location has several pieces, and any of them are in
+         registers, then we will need a frame to fetch them from.  */
+      for (i = 0; i < ctx->num_pieces; i++)
+        if (ctx->pieces[i].in_reg)
+          in_reg = 1;
+    }
+

   free_dwarf_expr_context (ctx);
 
   free_dwarf_expr_context (ctx);
 

-  return baton.needs_frame;
+  return baton.needs_frame || in_reg;

 }
 
 static void
 }
 
 static void

-dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
-                          struct axs_value * value, unsigned char *data,
+dwarf2_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
+                          struct axs_value *value, gdb_byte *data,

                           int size)
 {
   if (size == 0)
                           int size)
 {
   if (size == 0)

-    error ("Symbol \"%s\" has been optimized out.",
+    error (_("Symbol \"%s\" has been optimized out."),

           SYMBOL_PRINT_NAME (symbol));
 
   if (size == 1
           SYMBOL_PRINT_NAME (symbol));
 
   if (size == 1


@@ -350,25 +394,43 @@ dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
         as above.  */
       int frame_reg;
       LONGEST frame_offset;
         as above.  */
       int frame_reg;
       LONGEST frame_offset;

-      unsigned char *buf_end;
+      gdb_byte *buf_end;

 
       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
       if (buf_end != data + size)
 
       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
       if (buf_end != data + size)

-       error ("Unexpected opcode after DW_OP_fbreg for symbol \"%s\".",
+       error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),

               SYMBOL_PRINT_NAME (symbol));
 
               SYMBOL_PRINT_NAME (symbol));
 

-      TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
+      gdbarch_virtual_frame_pointer (current_gdbarch, 
+                                    ax->scope, &frame_reg, &frame_offset);

       ax_reg (ax, frame_reg);
       ax_const_l (ax, frame_offset);
       ax_simple (ax, aop_add);
 
       ax_reg (ax, frame_reg);
       ax_const_l (ax, frame_offset);
       ax_simple (ax, aop_add);
 

-      ax_const_l (ax, frame_offset);
+      value->kind = axs_lvalue_memory;
+    }
+  else if (data[0] >= DW_OP_breg0
+          && data[0] <= DW_OP_breg31)
+    {
+      unsigned int reg;
+      LONGEST offset;
+      gdb_byte *buf_end;
+
+      reg = data[0] - DW_OP_breg0;
+      buf_end = read_sleb128 (data + 1, data + size, &offset);
+      if (buf_end != data + size)
+       error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
+              reg, SYMBOL_PRINT_NAME (symbol));
+
+      ax_reg (ax, reg);
+      ax_const_l (ax, offset);

       ax_simple (ax, aop_add);
       ax_simple (ax, aop_add);

+

       value->kind = axs_lvalue_memory;
     }
   else
       value->kind = axs_lvalue_memory;
     }
   else

-    error ("Unsupported DWARF opcode in the location of \"%s\".",
-          SYMBOL_PRINT_NAME (symbol));
+    error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
+          data[0], SYMBOL_PRINT_NAME (symbol));

 }
 \f
 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 }
 \f
 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression


@@ -379,7 +441,7 @@ locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
   struct value *val;
   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
   struct value *val;
   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,

-                                 dlbaton->objfile);
+                                 dlbaton->per_cu);

 
   return val;
 }
 
   return val;
 }


@@ -389,7 +451,8 @@ static int
 locexpr_read_needs_frame (struct symbol *symbol)
 {
   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 locexpr_read_needs_frame (struct symbol *symbol)
 {
   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);

-  return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
+  return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
+                                     dlbaton->per_cu);

 }
 
 /* Print a natural-language description of SYMBOL to STREAM.  */
 }
 
 /* Print a natural-language description of SYMBOL to STREAM.  */


@@ -398,14 +461,19 @@ locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 {
   /* FIXME: be more extensive.  */
   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 {
   /* FIXME: be more extensive.  */
   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);

+  int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);

 
   if (dlbaton->size == 1
       && dlbaton->data[0] >= DW_OP_reg0
       && dlbaton->data[0] <= DW_OP_reg31)
     {
 
   if (dlbaton->size == 1
       && dlbaton->data[0] >= DW_OP_reg0
       && dlbaton->data[0] <= DW_OP_reg31)
     {

-      int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
+      struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
+      struct gdbarch *gdbarch = get_objfile_arch (objfile);
+      int regno = gdbarch_dwarf2_reg_to_regnum (gdbarch,
+                                               dlbaton->data[0] - DW_OP_reg0);

       fprintf_filtered (stream,
       fprintf_filtered (stream,

-                       "a variable in register %s", REGISTER_NAME (regno));
+                       "a variable in register %s",
+                       gdbarch_register_name (gdbarch, regno));

       return 1;
     }
 
       return 1;
     }
 


@@ -425,14 +493,16 @@ locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
     if (dlbaton->data[0] == DW_OP_addr)
       {
       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
     if (dlbaton->data[0] == DW_OP_addr)
       {

-       int bytes_read;
-       CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
+       struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
+       struct gdbarch *gdbarch = get_objfile_arch (objfile);
+       CORE_ADDR offset = dwarf2_read_address (gdbarch,
+                                               &dlbaton->data[1],

                                                &dlbaton->data[dlbaton->size - 1],
                                                &dlbaton->data[dlbaton->size - 1],

-                                               &bytes_read);
+                                               addr_size);

        fprintf_filtered (stream, 
                          "a thread-local variable at offset %s in the "
                          "thread-local storage for `%s'",
        fprintf_filtered (stream, 
                          "a thread-local variable at offset %s in the "
                          "thread-local storage for `%s'",

-                         paddr_nz (offset), dlbaton->objfile->name);
+                         paddr_nz (offset), objfile->name);

        return 1;
       }
   
        return 1;
       }
   


@@ -462,7 +532,7 @@ locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 
 /* The set of location functions used with the DWARF-2 expression
    evaluator.  */
 
 /* The set of location functions used with the DWARF-2 expression
    evaluator.  */

-struct location_funcs dwarf2_locexpr_funcs = {
+const struct symbol_ops dwarf2_locexpr_funcs = {

   locexpr_read_variable,
   locexpr_read_needs_frame,
   locexpr_describe_location,
   locexpr_read_variable,
   locexpr_read_needs_frame,
   locexpr_describe_location,


@@ -480,15 +550,21 @@ loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 {
   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
   struct value *val;
 {
   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
   struct value *val;

-  unsigned char *data;
+  gdb_byte *data;

   size_t size;
 
   data = find_location_expression (dlbaton, &size,
   size_t size;
 
   data = find_location_expression (dlbaton, &size,

-                                  frame ? get_frame_pc (frame) : 0);
+                                  frame ? get_frame_address_in_block (frame)
+                                  : 0);

   if (data == NULL)
   if (data == NULL)

-    error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
-
-  val = dwarf2_evaluate_loc_desc (symbol, frame, data, size, dlbaton->objfile);
+    {
+      val = allocate_value (SYMBOL_TYPE (symbol));
+      VALUE_LVAL (val) = not_lval;
+      set_value_optimized_out (val, 1);
+    }
+  else
+    val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
+                                   dlbaton->per_cu);

 
   return val;
 }
 
   return val;
 }


@@ -522,19 +598,19 @@ loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
                            struct axs_value * value)
 {
   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
                            struct axs_value * value)
 {
   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);

-  unsigned char *data;
+  gdb_byte *data;

   size_t size;
 
   data = find_location_expression (dlbaton, &size, ax->scope);
   if (data == NULL)
   size_t size;
 
   data = find_location_expression (dlbaton, &size, ax->scope);
   if (data == NULL)

-    error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
+    error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));

 
   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 }
 
 /* The set of location functions used with the DWARF-2 expression
    evaluator and location lists.  */
 
   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 }
 
 /* The set of location functions used with the DWARF-2 expression
    evaluator and location lists.  */

-struct location_funcs dwarf2_loclist_funcs = {
+const struct symbol_ops dwarf2_loclist_funcs = {

   loclist_read_variable,
   loclist_read_needs_frame,
   loclist_describe_location,
   loclist_read_variable,
   loclist_read_needs_frame,
   loclist_describe_location,