Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Michael Elizabeth Chastain]

Daniel J asks:
> I'd rather discuss a transition to C++ than any particular instance of
> this problem.  Do you think it's feasible?

At this moment in time, I don't think it's even feasible to have a
discussion about C++.  I'm referring to people's communication
bandwidth rather than the topic.

My two cents,

Michael C

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Daniel Jacobowitz]

On Sun, Feb 23, 2003 at 09:30:18PM -0600, Michael Elizabeth Chastain wrote:
> Daniel J asks:
> > I'd rather discuss a transition to C++ than any particular instance of
> > this problem.  Do you think it's feasible?
> 
> At this moment in time, I don't think it's even feasible to have a
> discussion about C++.  I'm referring to people's communication
> bandwidth rather than the topic.

Put that way, you're almost certainly right :)

-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Jim Blandy]

I've only found obvious-fix problems with this, so if you change the
things I note here, this can go in.  (Whew.)

I think I found some switches that still need LOC_COMPUTED{,_ARG} cases:
- ada-lang.c (ada_resolve_subexp, symtab_for_sym,
    ada_add_block_symbols, fill_in_ada_prototype) 
- symtab.c (lookup_block_symbol)
- mi-cmd-stack.c (list_args_or_locals)

Daniel Jacobowitz <drow@mvista.com> writes:
> On Wed, Feb 05, 2003 at 12:24:34AM -0500, Jim Blandy wrote:
> > The comment needs to come clean about this:
> > 
> >   /* For a LOC_COMPUTED symbol, this is the baton and location_funcs
> >      structure to find its value.  For a LOC_BLOCK symbol for a
> >      function in a compilation unit compiled with Dwarf 2 information,
> >      this is information used internally by the Dwarf 2 code ---
> >      specifically, the Dwarf location description that computes frame
> >      base for that function.  */
> > 
> > Maybe I'm going too far, but that is at least more honest about how
> > messy this is.  I'm still not sure I'm cool with this.
> 
> I've adapted your comment.  I'd like to leave this for another time, to
> be honest... after we kill some of the current excess memory usage in
> symbols, like the dead aliases/ranges code which this is obsoleting.
> 
> Another way we could do this would be to make the frame base a magic
> symbol in the function's block, and look it up.  That's probably a
> safer approach; more memory per-function but that doesn't bother me as
> much as per-symbol does.  And easier to look up, too.

Okay.  Since we're putting this off for later, can you file a PR, or
record the idea for the improvement in a comment the code?

> 2003-02-05  Daniel Jacobowitz  <drow@mvista.com>
> 
> 	Based on a patch from Daniel Berlin (dberlin@dberlin.org).
> 	* symtab.h: Add opaque declarations of struct axs_value and
> 	struct agent_expr.
> 	(enum address_class): Add LOC_COMPUTED and LOC_COMPUTED_ARG.
> 	(struct location_funcs): New type.
> 	(struct symbol): Add "loc" to aux_value.
> 	(SYMBOL_LOCATION_BATON, SYMBOL_LOCATION_FUNCS): New macros.
> 	* dwarf2read.c: Include "dwarf2expr.h".
> 	(dwarf2_symbol_mark_computed): New function.
> 	(read_func_scope): Use it.
> 	(var_decode_location): New function.
> 	(new_symbol): Use it.
> 	* dwarf2expr.c, dwarf2expr.h, dwarf2loc.c: New files.

Don't forget dwarf2loc.h!

> +/* Return the type of an address, for unsigned arithmetic.  */
> +
> +static struct type *
> +unsigned_address_type (void)
> +{
> +  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
> +    {
> +    case 4:
> +      return builtin_type_uint32;
> +    case 8:
> +      return builtin_type_uint64;
> +    default:
> +      internal_error (__FILE__, __LINE__,
> +		      "Unsupported address size.\n");
> +    }
> +}
> +
> +/* Return the type of an address, for signed arithmetic.  */
> +
> +static struct type *
> +signed_address_type (void)
> +{
> +  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
> +    {
> +    case 4:
> +      return builtin_type_int32;
> +    case 8:
> +      return builtin_type_int64;
> +    default:
> +      internal_error (__FILE__, __LINE__,
> +		      "Unsupported address size.\n");
> +    }
> +}

These will both need a case for 16 bits, too.  I'm pretty sure I know
of a 16-bit target that uses Dwarf 2.

Also, shouldn't we be using the address size from the compilation unit
header, instead of TARGET_ADDR_BIT?  (I have this strong impression
we've discussed this before, but I've not been able to find it in the
ML archives to see what we decided.)  On a 16-bit machine in 32-bit
ELF, it's not clear to me what the compilation unit header's address
size will be: if the architecture has separate code and data address
spaces, and we treat them as 64k subranges of a unified 32-bit address
space for linking, as is often done, it seems to me the compilation
unit header's address size could be 32 bits, since that's what you
need to store a symbol's value.

Since there's no easy way at the moment to get that compilation unit
header address size (it's thrown away after we're done reading Dwarf 2
info, and the baton needs to be small), this could be a PR.

> +	case DW_OP_reg29:
> +	case DW_OP_reg30:
> +	case DW_OP_reg31:
> +	  if (op_ptr != op_end)
> +	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
> +		   "used alone.");
> +
> +	  result = (ctx->read_reg) (ctx->baton, op - DW_OP_reg0, &expr_lval,
> +				    &memaddr);
> +
> +	  if (expr_lval == lval_register)
> +	    {
> +	      ctx->regnum = op - DW_OP_reg0;
> +	      ctx->in_reg = 1;
> +	    }
> +	  else
> +	    result = memaddr;
> +
> +	  break;
> +
> +	case DW_OP_regx:
> +	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
> +	  if (op_ptr != op_end)
> +	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
> +		   "used alone.");
> +
> +	  result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
> +
> +	  if (expr_lval == lval_register)
> +	    {
> +	      ctx->regnum = reg;
> +	      ctx->in_reg = 1;
> +	    }
> +	  else
> +	    result = memaddr;
> +
> +	  break;

This also isn't worth delaying the patch for, but it's something I
don't really understand, so I'll ask here before I forget: why do the
register name operators have to do anything beyond simply setting
ctx->in_reg and ctx->regnum, and returning?  The caller should be
responsible for figuring out whether that register has been saved on
the stack or not, as it already does for all the other register
address classes.

> Index: dwarf2loc.c
...
> +/* This is the baton used when performing dwarf2 expression
> +   evaluation.  */
> +struct dwarf_expr_baton
> +{
> +  struct symbol *var;
> +  struct frame_info *frame;
> +  struct objfile *objfile;
> +};

You forgot to delete this definition of 'struct dwarf_expr_baton' from
dwarf2loc.c after putting it in dwarf2loc.h.

> +/* Using the objfile specified in BATON, find the address for the
> +   current thread's thread-local storage with offset OFFSET.  */
> +static CORE_ADDR
> +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,
> +					    SYMBOL_OBJFILE (debaton->var),
> +					    offset);

Don't you mean 'debaton->objfile', not 'SYMBOL_OBJFILE (debaton->var)'?

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Daniel Jacobowitz]

On Thu, Feb 20, 2003 at 06:01:56PM -0500, Jim Blandy wrote:
> 
> I've only found obvious-fix problems with this, so if you change the
> things I note here, this can go in.  (Whew.)

Thanks!  Let me see what I can do about your (much appreciated)
comments.

> I think I found some switches that still need LOC_COMPUTED{,_ARG} cases:
> - ada-lang.c (ada_resolve_subexp, symtab_for_sym,
>     ada_add_block_symbols, fill_in_ada_prototype) 

OK, what's up with that?  The code bits in ada_resolve_subexp all
appear to be commented out.  Is this code going away?  And the list in
ada_resolve_subexp doesn't appear to be complete or make sense, either. 
Things being what they are, I've added LOC_COMPUTED just in case, but
if this code ever gets activated it should probably be re-examined.

symtab_for_sym is pretty hokey too.  All the Ada code reads like
someone wanted to keep changes local to ada-lang.c when they were
addressing general symtab weaknesses.  I hope it can all go away
someday.  The amount of duplication is pretty scary, too.

In any case, I agree with you that all four needed new cases.

> - symtab.c (lookup_block_symbol)

Huh.  How'd I miss that?  Thank you for spotting it.  Although I want
to delete that whole block of code...

> - mi-cmd-stack.c (list_args_or_locals)

Got it now.

In a streak of brilliance, I remembered to check Insight for similar
cases.  There were three in gdbtk-stack.c, so I added those also.

> Daniel Jacobowitz <drow@mvista.com> writes:
> > On Wed, Feb 05, 2003 at 12:24:34AM -0500, Jim Blandy wrote:
> > > The comment needs to come clean about this:
> > > 
> > >   /* For a LOC_COMPUTED symbol, this is the baton and location_funcs
> > >      structure to find its value.  For a LOC_BLOCK symbol for a
> > >      function in a compilation unit compiled with Dwarf 2 information,
> > >      this is information used internally by the Dwarf 2 code ---
> > >      specifically, the Dwarf location description that computes frame
> > >      base for that function.  */
> > > 
> > > Maybe I'm going too far, but that is at least more honest about how
> > > messy this is.  I'm still not sure I'm cool with this.
> > 
> > I've adapted your comment.  I'd like to leave this for another time, to
> > be honest... after we kill some of the current excess memory usage in
> > symbols, like the dead aliases/ranges code which this is obsoleting.
> > 
> > Another way we could do this would be to make the frame base a magic
> > symbol in the function's block, and look it up.  That's probably a
> > safer approach; more memory per-function but that doesn't bother me as
> > much as per-symbol does.  And easier to look up, too.
> 
> Okay.  Since we're putting this off for later, can you file a PR, or
> record the idea for the improvement in a comment the code?

Certainly.  I'm still not sure it's a win to do this, so I'll comment
the issue in symtab.h.

> > 2003-02-05  Daniel Jacobowitz  <drow@mvista.com>
> > 
> > 	Based on a patch from Daniel Berlin (dberlin@dberlin.org).
> > 	* symtab.h: Add opaque declarations of struct axs_value and
> > 	struct agent_expr.
> > 	(enum address_class): Add LOC_COMPUTED and LOC_COMPUTED_ARG.
> > 	(struct location_funcs): New type.
> > 	(struct symbol): Add "loc" to aux_value.
> > 	(SYMBOL_LOCATION_BATON, SYMBOL_LOCATION_FUNCS): New macros.
> > 	* dwarf2read.c: Include "dwarf2expr.h".
> > 	(dwarf2_symbol_mark_computed): New function.
> > 	(read_func_scope): Use it.
> > 	(var_decode_location): New function.
> > 	(new_symbol): Use it.
> > 	* dwarf2expr.c, dwarf2expr.h, dwarf2loc.c: New files.
> 
> Don't forget dwarf2loc.h!

Eek, thank you.

> > +/* Return the type of an address, for unsigned arithmetic.  */
> > +
> > +static struct type *
> > +unsigned_address_type (void)
> > +{
> > +  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
> > +    {
> > +    case 4:
> > +      return builtin_type_uint32;
> > +    case 8:
> > +      return builtin_type_uint64;
> > +    default:
> > +      internal_error (__FILE__, __LINE__,
> > +		      "Unsupported address size.\n");
> > +    }
> > +}
> > +
> > +/* Return the type of an address, for signed arithmetic.  */
> > +
> > +static struct type *
> > +signed_address_type (void)
> > +{
> > +  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
> > +    {
> > +    case 4:
> > +      return builtin_type_int32;
> > +    case 8:
> > +      return builtin_type_int64;
> > +    default:
> > +      internal_error (__FILE__, __LINE__,
> > +		      "Unsupported address size.\n");
> > +    }
> > +}
> 
> These will both need a case for 16 bits, too.  I'm pretty sure I know
> of a 16-bit target that uses Dwarf 2.

Sure.

> Also, shouldn't we be using the address size from the compilation unit
> header, instead of TARGET_ADDR_BIT?  (I have this strong impression
> we've discussed this before, but I've not been able to find it in the
> ML archives to see what we decided.)  On a 16-bit machine in 32-bit
> ELF, it's not clear to me what the compilation unit header's address
> size will be: if the architecture has separate code and data address
> spaces, and we treat them as 64k subranges of a unified 32-bit address
> space for linking, as is often done, it seems to me the compilation
> unit header's address size could be 32 bits, since that's what you
> need to store a symbol's value.
> 
> Since there's no easy way at the moment to get that compilation unit
> header address size (it's thrown away after we're done reading Dwarf 2
> info, and the baton needs to be small), this could be a PR.

PR filed - well, I sent it to GNATS, let's see if it goes in.  The
machine is misbehaving just now.

In order to save the address size (and signed address property) I
needed another word in the baton.  Let's punt on this until we see a
target that cares.

> 
> > +	case DW_OP_reg29:
> > +	case DW_OP_reg30:
> > +	case DW_OP_reg31:
> > +	  if (op_ptr != op_end)
> > +	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
> > +		   "used alone.");
> > +
> > +	  result = (ctx->read_reg) (ctx->baton, op - DW_OP_reg0, &expr_lval,
> > +				    &memaddr);
> > +
> > +	  if (expr_lval == lval_register)
> > +	    {
> > +	      ctx->regnum = op - DW_OP_reg0;
> > +	      ctx->in_reg = 1;
> > +	    }
> > +	  else
> > +	    result = memaddr;
> > +
> > +	  break;
> > +
> > +	case DW_OP_regx:
> > +	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
> > +	  if (op_ptr != op_end)
> > +	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
> > +		   "used alone.");
> > +
> > +	  result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
> > +
> > +	  if (expr_lval == lval_register)
> > +	    {
> > +	      ctx->regnum = reg;
> > +	      ctx->in_reg = 1;
> > +	    }
> > +	  else
> > +	    result = memaddr;
> > +
> > +	  break;
> 
> This also isn't worth delaying the patch for, but it's something I
> don't really understand, so I'll ask here before I forget: why do the
> register name operators have to do anything beyond simply setting
> ctx->in_reg and ctx->regnum, and returning?  The caller should be
> responsible for figuring out whether that register has been saved on
> the stack or not, as it already does for all the other register
> address classes.

Hmm.  We need to sort it out in dwarf2_evaluate_loc_desc at the latest;
the interface to that returns a value, and the value has an lval_type,
and lval_memory/lval_register must be set by that point.  We could
probably move the read_reg for this case out to the parent, and it's
probably a good idea; it would simplify the interface.  It works either
way.

I can safely promise that I'll be back to this; I plan to implement
DW_OP_piece, which will require a new lval_type, and touches all of
this code again.  If no one beats me to it, at least.  I've added some
FIXMEs to remind myself.

> > +/* This is the baton used when performing dwarf2 expression
> > +   evaluation.  */
> > +struct dwarf_expr_baton
> > +{
> > +  struct symbol *var;
> > +  struct frame_info *frame;
> > +  struct objfile *objfile;
> > +};
> 
> You forgot to delete this definition of 'struct dwarf_expr_baton' from
> dwarf2loc.c after putting it in dwarf2loc.h.

No, they're different.  The one in dwarf2loc.h is a
dwarf_locexpr_baton, and is used as the baton paired with a
LOC_COMPUTED.  The one you see above is a dwarf_expr_baton, and is used
only within an expression evaluation.

> > +/* Using the objfile specified in BATON, find the address for the
> > +   current thread's thread-local storage with offset OFFSET.  */
> > +static CORE_ADDR
> > +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,
> > +					    SYMBOL_OBJFILE (debaton->var),
> > +					    offset);
> 
> Don't you mean 'debaton->objfile', not 'SYMBOL_OBJFILE (debaton->var)'?

Uh, yes.  How'd I miss that again?  Cutely, now no one uses the var
member of the baton, so I've removed it; easy enough to put it back
later.

I'm going to re-regtest this patch and check it in; the updated version
is attached.  Thanks for putting up with my nagging.

[The test is done now.  It showed one new failure in tracepoints and no
other changes, exactly as expected.  What do you want to do about the
tracepoint failure?  Just kfail it for now?]

-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer

2003-02-21  Daniel Jacobowitz  <drow@mvista.com>

	Based on a patch from Daniel Berlin (dberlin@dberlin.org).
	* symtab.h: Add opaque declarations of struct axs_value and
	struct agent_expr.
	(enum address_class): Add LOC_COMPUTED and LOC_COMPUTED_ARG.
	(struct location_funcs): New type.
	(struct symbol): Add "loc" to aux_value.
	(SYMBOL_LOCATION_BATON, SYMBOL_LOCATION_FUNCS): New macros.
	* dwarf2read.c: Include "dwarf2expr.h".
	(dwarf2_symbol_mark_computed): New function.
	(read_func_scope): Use it.
	(var_decode_location): New function.
	(new_symbol): Use it.
	* dwarf2expr.c, dwarf2expr.h, dwarf2loc.c, dwarf2loc.h: New files.

	* Makefile.in (SFILES): Add dwarf2loc.c and dwarf2expr.c.
	(dwarf2expr_h, dwarf2loc_h): New variables.
	(COMMON_OBS): Add dwarf2expr.o and dwarf2loc.o.
	(dwarf2expr.o, dwarf2loc.o): New rules.
	(dwarf2read.o): Add $(dwarf2expr_h) and $(dwarf2loc_h).
	* buildsym.c (finish_block): Handle LOC_COMPUTED and
	LOC_COMPUTED_ARG.
	* findvar.c (symbol_read_needs_frame, read_var_value): Likewise.
	* m2-exp.y (yylex): Likewise.
	* printcmd.c (address_info, print_frame_args): Likewise.
	* stack.c (print_block_frame_locals, print_frame_arg_vars): Likewise.
	* symmisc.c (print_symbol, print_partial_symbols): Likewise.
	* ada-lang.c (ada_resolve_subexp, symtab_for_sym)
	(ada_add_block_symbols, fill_in_ada_prototype): Likewise.
	* symtab.c (lookup_block_symbol): Likewise.

2003-02-21  Daniel Jacobowitz  <drow@mvista.com>

	* mi-cmd-stack.c (list_args_or_locals): Handle LOC_COMPUTED and
	LOC_COMPUTED_ARG.

2003-02-21  Daniel Jacobowitz  <drow@mvista.com>

	* generic/gdbtk-stack.c (gdb_get_blocks, gdb_block_vars)
	(gdb_get_vars_command): Handle LOC_COMPUTED and LOC_COMPUTED_ARG.

Index: Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.334
diff -u -p -r1.334 Makefile.in
--- Makefile.in	20 Feb 2003 03:12:46 -0000	1.334
+++ Makefile.in	21 Feb 2003 15:01:29 -0000
@@ -513,7 +513,7 @@ SFILES = ada-exp.y ada-lang.c ada-typepr
 	complaints.c completer.c corefile.c \
 	cp-abi.c cp-support.c cp-valprint.c \
 	dbxread.c demangle.c disasm.c doublest.c \
-	dummy-frame.c dwarfread.c dwarf2read.c \
+	dummy-frame.c dwarfread.c dwarf2expr.c dwarf2loc.c dwarf2read.c \
 	elfread.c environ.c eval.c event-loop.c event-top.c expprint.c \
 	f-exp.y f-lang.c f-typeprint.c f-valprint.c findvar.c frame.c \
 	frame-unwind.c \
@@ -628,6 +628,8 @@ doublest_h = doublest.h $(floatformat_h)
 dst_h = dst.h
 dummy_frame_h = dummy-frame.h
 dwarf2cfi_h = dwarf2cfi.h
+dwarf2expr_h = dwarf2expr.h
+dwarf2loc_h = dwarf2loc.h
 environ_h = environ.h
 event_loop_h = event-loop.h
 event_top_h = event-top.h
@@ -837,6 +839,7 @@ COMMON_OBS = version.o blockframe.o brea
 	exec.o bcache.o objfiles.o minsyms.o maint.o demangle.o \
 	dbxread.o coffread.o coff-pe-read.o elfread.o \
 	dwarfread.o dwarf2read.o mipsread.o stabsread.o corefile.o \
+	dwarf2expr.o dwarf2loc.o \
 	c-lang.o f-lang.o \
 	ui-out.o cli-out.o \
 	varobj.o wrapper.o \
@@ -1632,11 +1635,16 @@ dve3900-rom.o: dve3900-rom.c $(defs_h) $
 dwarf2cfi.o: dwarf2cfi.c $(defs_h) $(gdbcore_h) $(symtab_h) $(symfile_h) \
 	$(objfiles_h) $(target_h) $(elf_dwarf2_h) $(inferior_h) \
 	$(regcache_h) $(dwarf2cfi_h) $(gdb_assert_h)
+dwarf2expr.o: dwarf2expr.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(value_h) \
+	 $(gdbcore_h) $(dwarf2expr_h)
+dwarf2loc.o: dwarf2loc.c $(defs_h) $(ui_out_h) $(value_h) $(frame_h) \
+	$(gdbcore_h) $(target_h) $(inferior_h) $(dwarf2expr_h) \
+	$(dwarf2loc_h) $(gdb_string_h)
 dwarf2read.o: dwarf2read.c $(defs_h) $(bfd_h) $(symtab_h) $(gdbtypes_h) \
 	$(symfile_h) $(objfiles_h) $(elf_dwarf2_h) $(buildsym_h) \
 	$(demangle_h) $(expression_h) $(filenames_h) $(macrotab_h) \
-	$(language_h) $(complaints_h) $(bcache_h) $(gdb_string_h) \
-	$(gdb_assert_h)
+	$(language_h) $(complaints_h) $(bcache_h) $(dwarf2expr_h) \
+	$(dwarf2loc_h) $(gdb_string_h) $(gdb_assert_h)
 dwarfread.o: dwarfread.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(symfile_h) \
 	$(objfiles_h) $(elf_dwarf_h) $(buildsym_h) $(demangle_h) \
 	$(expression_h) $(language_h) $(complaints_h) $(gdb_string_h)
Index: ada-lang.c
===================================================================
RCS file: /cvs/src/src/gdb/ada-lang.c,v
retrieving revision 1.19
diff -u -p -r1.19 ada-lang.c
--- ada-lang.c	20 Feb 2003 17:17:22 -0000	1.19
+++ ada-lang.c	21 Feb 2003 15:01:30 -0000
@@ -2172,6 +2172,8 @@ ada_resolve_subexp (struct expression **
    case LOC_LOCAL_ARG:
    case LOC_BASEREG:
    case LOC_BASEREG_ARG:
+   case LOC_COMPUTED:
+   case LOC_COMPUTED_ARG:
    goto FoundNonType;
    default:
    break;
@@ -3466,6 +3468,8 @@ symtab_for_sym (struct symbol *sym)
       case LOC_LOCAL_ARG:
       case LOC_BASEREG:
       case LOC_BASEREG_ARG:
+      case LOC_COMPUTED:
+      case LOC_COMPUTED_ARG:
 	for (j = FIRST_LOCAL_BLOCK;
 	     j < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (s)); j += 1)
 	  {
@@ -3970,6 +3974,7 @@ ada_add_block_symbols (struct block *blo
 	      case LOC_REGPARM:
 	      case LOC_REGPARM_ADDR:
 	      case LOC_BASEREG_ARG:
+	      case LOC_COMPUTED_ARG:
 		arg_sym = sym;
 		break;
 	      case LOC_UNRESOLVED:
@@ -4033,6 +4038,7 @@ ada_add_block_symbols (struct block *blo
 		      case LOC_REGPARM:
 		      case LOC_REGPARM_ADDR:
 		      case LOC_BASEREG_ARG:
+		      case LOC_COMPUTED_ARG:
 			arg_sym = sym;
 			break;
 		      case LOC_UNRESOLVED:
@@ -4117,6 +4123,7 @@ ada_add_block_symbols (struct block *blo
 		      case LOC_REGPARM:
 		      case LOC_REGPARM_ADDR:
 		      case LOC_BASEREG_ARG:
+		      case LOC_COMPUTED_ARG:
 			arg_sym = sym;
 			break;
 		      case LOC_UNRESOLVED:
@@ -4201,6 +4208,7 @@ fill_in_ada_prototype (struct symbol *fu
       case LOC_REGPARM:
       case LOC_LOCAL_ARG:
       case LOC_BASEREG_ARG:
+      case LOC_COMPUTED_ARG:
 	TYPE_FIELD_BITPOS (ftype, nargs) = nargs;
 	TYPE_FIELD_BITSIZE (ftype, nargs) = 0;
 	TYPE_FIELD_STATIC_KIND (ftype, nargs) = 0;
Index: buildsym.c
===================================================================
RCS file: /cvs/src/src/gdb/buildsym.c,v
retrieving revision 1.29
diff -u -p -r1.29 buildsym.c
--- buildsym.c	20 Feb 2003 17:17:23 -0000	1.29
+++ buildsym.c	21 Feb 2003 15:01:31 -0000
@@ -309,6 +309,7 @@ finish_block (struct symbol *symbol, str
 		case LOC_REGPARM_ADDR:
 		case LOC_BASEREG_ARG:
 		case LOC_LOCAL_ARG:
+		case LOC_COMPUTED_ARG:
 		  nparams++;
 		  break;
 		case LOC_UNDEF:
@@ -324,6 +325,7 @@ finish_block (struct symbol *symbol, str
 		case LOC_BASEREG:
 		case LOC_UNRESOLVED:
 		case LOC_OPTIMIZED_OUT:
+		case LOC_COMPUTED:
 		default:
 		  break;
 		}
@@ -345,6 +347,7 @@ finish_block (struct symbol *symbol, str
 		    case LOC_REGPARM_ADDR:
 		    case LOC_BASEREG_ARG:
 		    case LOC_LOCAL_ARG:
+		    case LOC_COMPUTED_ARG:
 		      TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
 		      TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
 		      iparams++;
@@ -362,6 +365,7 @@ finish_block (struct symbol *symbol, str
 		    case LOC_BASEREG:
 		    case LOC_UNRESOLVED:
 		    case LOC_OPTIMIZED_OUT:
+		    case LOC_COMPUTED:
 		    default:
 		      break;
 		    }
Index: dwarf2expr.c
===================================================================
RCS file: dwarf2expr.c
diff -N dwarf2expr.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dwarf2expr.c	21 Feb 2003 15:01:31 -0000
@@ -0,0 +1,687 @@
+/* Dwarf2 Expression Evaluator
+   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
+   Contributed by Daniel Berlin (dan@dberlin.org)
+
+   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.
+
+   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
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "value.h"
+#include "gdbcore.h"
+#include "elf/dwarf2.h"
+#include "dwarf2expr.h"
+
+/* Local prototypes.  */
+
+static void execute_stack_op (struct dwarf_expr_context *,
+			      unsigned char *, unsigned char *);
+
+/* Create a new context for the expression evaluator.  */
+
+struct dwarf_expr_context *
+new_dwarf_expr_context ()
+{
+  struct dwarf_expr_context *retval;
+  retval = xcalloc (1, sizeof (struct dwarf_expr_context));
+  retval->stack_len = 10;
+  retval->stack = xmalloc (10 * sizeof (CORE_ADDR));
+  return retval;
+}
+
+/* Release the memory allocated to CTX.  */
+
+void
+free_dwarf_expr_context (struct dwarf_expr_context *ctx)
+{
+  xfree (ctx->stack);
+  xfree (ctx);
+}
+
+/* Expand the memory allocated to CTX's stack to contain at least
+   NEED more elements than are currently used.  */
+
+static void
+dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
+{
+  if (ctx->stack_len + need > ctx->stack_allocated)
+    {
+      size_t templen = ctx->stack_len * 2;
+      while (templen < (ctx->stack_len + need))
+	   templen *= 2;
+      ctx->stack = xrealloc (ctx->stack,
+			     templen * sizeof (CORE_ADDR));
+      ctx->stack_allocated = templen;
+    }
+}
+
+/* Push VALUE onto CTX's stack.  */
+
+void
+dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
+{
+  dwarf_expr_grow_stack (ctx, 1);
+  ctx->stack[ctx->stack_len++] = value;
+}
+
+/* Pop the top item off of CTX's stack.  */
+
+void
+dwarf_expr_pop (struct dwarf_expr_context *ctx)
+{
+  if (ctx->stack_len <= 0)
+    error ("dwarf expression stack underflow");
+  ctx->stack_len--;
+}
+
+/* Retrieve the N'th item on CTX's stack.  */
+
+CORE_ADDR
+dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
+{
+  if (ctx->stack_len < n)
+     error ("Asked for position %d of stack, stack only has %d elements on it\n",
+	    n, ctx->stack_len);
+  return ctx->stack[ctx->stack_len - (1 + n)];
+
+}
+
+/* Evaluate the expression at ADDR (LEN bytes long) using the context
+   CTX.  */
+
+void
+dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
+		 size_t len)
+{
+  execute_stack_op (ctx, addr, addr + len);
+}
+
+/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
+   by R, and return the new value of BUF.  Verify that it doesn't extend
+   past BUF_END.  */
+
+static unsigned char *
+read_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r)
+{
+  unsigned shift = 0;
+  ULONGEST result = 0;
+  unsigned char byte;
+
+  while (1)
+    {
+      if (buf >= buf_end)
+	error ("read_uleb128: Corrupted DWARF expression.");
+
+      byte = *buf++;
+      result |= (byte & 0x7f) << shift;
+      if ((byte & 0x80) == 0)
+	break;
+      shift += 7;
+    }
+  *r = result;
+  return buf;
+}
+
+/* Decode the signed LEB128 constant at BUF into the variable pointed to
+   by R, and return the new value of BUF.  Verify that it doesn't extend
+   past BUF_END.  */
+
+static unsigned char *
+read_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r)
+{
+  unsigned shift = 0;
+  LONGEST result = 0;
+  unsigned char byte;
+
+  while (1)
+    {
+      if (buf >= buf_end)
+	error ("read_sleb128: Corrupted DWARF expression.");
+
+      byte = *buf++;
+      result |= (byte & 0x7f) << shift;
+      shift += 7;
+      if ((byte & 0x80) == 0)
+	break;
+    }
+  if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
+    result |= -(1 << shift);
+
+  *r = result;
+  return buf;
+}
+
+/* Read an address from BUF, and verify that it doesn't extend past
+   BUF_END.  The address is returned, and *BYTES_READ is set to the
+   number of bytes read from BUF.  */
+
+static CORE_ADDR
+read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read)
+{
+  CORE_ADDR result;
+
+  if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
+    error ("read_address: Corrupted DWARF expression.");
+
+  *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
+  result = extract_address (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
+  return result;
+}
+
+/* Return the type of an address, for unsigned arithmetic.  */
+
+static struct type *
+unsigned_address_type (void)
+{
+  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
+    {
+    case 2:
+      return builtin_type_uint16;
+    case 4:
+      return builtin_type_uint32;
+    case 8:
+      return builtin_type_uint64;
+    default:
+      internal_error (__FILE__, __LINE__,
+		      "Unsupported address size.\n");
+    }
+}
+
+/* Return the type of an address, for signed arithmetic.  */
+
+static struct type *
+signed_address_type (void)
+{
+  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
+    {
+    case 2:
+      return builtin_type_int16;
+    case 4:
+      return builtin_type_int32;
+    case 8:
+      return builtin_type_int64;
+    default:
+      internal_error (__FILE__, __LINE__,
+		      "Unsupported address size.\n");
+    }
+}
+\f
+/* The engine for the expression evaluator.  Using the context in CTX,
+   evaluate the expression between OP_PTR and OP_END.  */
+
+static void
+execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
+		  unsigned char *op_end)
+{
+  while (op_ptr < op_end)
+    {
+      enum dwarf_location_atom op = *op_ptr++;
+      CORE_ADDR result, memaddr;
+      ULONGEST uoffset, reg;
+      LONGEST offset;
+      int bytes_read;
+      enum lval_type expr_lval;
+
+      ctx->in_reg = 0;
+
+      switch (op)
+	{
+	case DW_OP_lit0:
+	case DW_OP_lit1:
+	case DW_OP_lit2:
+	case DW_OP_lit3:
+	case DW_OP_lit4:
+	case DW_OP_lit5:
+	case DW_OP_lit6:
+	case DW_OP_lit7:
+	case DW_OP_lit8:
+	case DW_OP_lit9:
+	case DW_OP_lit10:
+	case DW_OP_lit11:
+	case DW_OP_lit12:
+	case DW_OP_lit13:
+	case DW_OP_lit14:
+	case DW_OP_lit15:
+	case DW_OP_lit16:
+	case DW_OP_lit17:
+	case DW_OP_lit18:
+	case DW_OP_lit19:
+	case DW_OP_lit20:
+	case DW_OP_lit21:
+	case DW_OP_lit22:
+	case DW_OP_lit23:
+	case DW_OP_lit24:
+	case DW_OP_lit25:
+	case DW_OP_lit26:
+	case DW_OP_lit27:
+	case DW_OP_lit28:
+	case DW_OP_lit29:
+	case DW_OP_lit30:
+	case DW_OP_lit31:
+	  result = op - DW_OP_lit0;
+	  break;
+
+	case DW_OP_addr:
+	  result = read_address (op_ptr, op_end, &bytes_read);
+	  op_ptr += bytes_read;
+	  break;
+
+	case DW_OP_const1u:
+	  result = extract_unsigned_integer (op_ptr, 1);
+	  op_ptr += 1;
+	  break;
+	case DW_OP_const1s:
+	  result = extract_signed_integer (op_ptr, 1);
+	  op_ptr += 1;
+	  break;
+	case DW_OP_const2u:
+	  result = extract_unsigned_integer (op_ptr, 2);
+	  op_ptr += 2;
+	  break;
+	case DW_OP_const2s:
+	  result = extract_signed_integer (op_ptr, 2);
+	  op_ptr += 2;
+	  break;
+	case DW_OP_const4u:
+	  result = extract_unsigned_integer (op_ptr, 4);
+	  op_ptr += 4;
+	  break;
+	case DW_OP_const4s:
+	  result = extract_signed_integer (op_ptr, 4);
+	  op_ptr += 4;
+	  break;
+	case DW_OP_const8u:
+	  result = extract_unsigned_integer (op_ptr, 8);
+	  op_ptr += 8;
+	  break;
+	case DW_OP_const8s:
+	  result = extract_signed_integer (op_ptr, 8);
+	  op_ptr += 8;
+	  break;
+	case DW_OP_constu:
+	  op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
+	  result = uoffset;
+	  break;
+	case DW_OP_consts:
+	  op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	  result = offset;
+	  break;
+
+	/* The DW_OP_reg operations are required to occur alone in
+	   location expressions.  */
+	case DW_OP_reg0:
+	case DW_OP_reg1:
+	case DW_OP_reg2:
+	case DW_OP_reg3:
+	case DW_OP_reg4:
+	case DW_OP_reg5:
+	case DW_OP_reg6:
+	case DW_OP_reg7:
+	case DW_OP_reg8:
+	case DW_OP_reg9:
+	case DW_OP_reg10:
+	case DW_OP_reg11:
+	case DW_OP_reg12:
+	case DW_OP_reg13:
+	case DW_OP_reg14:
+	case DW_OP_reg15:
+	case DW_OP_reg16:
+	case DW_OP_reg17:
+	case DW_OP_reg18:
+	case DW_OP_reg19:
+	case DW_OP_reg20:
+	case DW_OP_reg21:
+	case DW_OP_reg22:
+	case DW_OP_reg23:
+	case DW_OP_reg24:
+	case DW_OP_reg25:
+	case DW_OP_reg26:
+	case DW_OP_reg27:
+	case DW_OP_reg28:
+	case DW_OP_reg29:
+	case DW_OP_reg30:
+	case DW_OP_reg31:
+	  /* NOTE: in the presence of DW_OP_piece this check is incorrect.  */
+	  if (op_ptr != op_end)
+	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
+		   "used alone.");
+
+	  /* FIXME drow/2003-02-21: This call to read_reg could be pushed
+	     into the evaluator's caller by changing the semantics for in_reg.
+	     Then we wouldn't need to return an lval_type and a memaddr.  */
+	  result = (ctx->read_reg) (ctx->baton, op - DW_OP_reg0, &expr_lval,
+				    &memaddr);
+
+	  if (expr_lval == lval_register)
+	    {
+	      ctx->regnum = op - DW_OP_reg0;
+	      ctx->in_reg = 1;
+	    }
+	  else
+	    result = memaddr;
+
+	  break;
+
+	case DW_OP_regx:
+	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
+	  if (op_ptr != op_end)
+	    error ("DWARF-2 expression error: DW_OP_reg operations must be "
+		   "used alone.");
+
+	  result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
+
+	  if (expr_lval == lval_register)
+	    {
+	      ctx->regnum = reg;
+	      ctx->in_reg = 1;
+	    }
+	  else
+	    result = memaddr;
+
+	  break;
+
+	case DW_OP_breg0:
+	case DW_OP_breg1:
+	case DW_OP_breg2:
+	case DW_OP_breg3:
+	case DW_OP_breg4:
+	case DW_OP_breg5:
+	case DW_OP_breg6:
+	case DW_OP_breg7:
+	case DW_OP_breg8:
+	case DW_OP_breg9:
+	case DW_OP_breg10:
+	case DW_OP_breg11:
+	case DW_OP_breg12:
+	case DW_OP_breg13:
+	case DW_OP_breg14:
+	case DW_OP_breg15:
+	case DW_OP_breg16:
+	case DW_OP_breg17:
+	case DW_OP_breg18:
+	case DW_OP_breg19:
+	case DW_OP_breg20:
+	case DW_OP_breg21:
+	case DW_OP_breg22:
+	case DW_OP_breg23:
+	case DW_OP_breg24:
+	case DW_OP_breg25:
+	case DW_OP_breg26:
+	case DW_OP_breg27:
+	case DW_OP_breg28:
+	case DW_OP_breg29:
+	case DW_OP_breg30:
+	case DW_OP_breg31:
+	  {
+	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0,
+				      &expr_lval, &memaddr);
+	    result += offset;
+	  }
+	  break;
+	case DW_OP_bregx:
+	  {
+	    op_ptr = read_uleb128 (op_ptr, op_end, &reg);
+	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
+	    result += offset;
+	  }
+	  break;
+	case DW_OP_fbreg:
+	  {
+	    unsigned char *datastart;
+	    size_t datalen;
+	    unsigned int before_stack_len;
+
+	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
+	    /* Rather than create a whole new context, we simply
+	       record the stack length before execution, then reset it
+	       afterwards, effectively erasing whatever the recursive
+	       call put there.  */
+	    before_stack_len = ctx->stack_len;
+	    (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
+	    dwarf_expr_eval (ctx, datastart, datalen);
+	    result = dwarf_expr_fetch (ctx, 0);
+	    if (! ctx->in_reg)
+	      {
+		char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
+		int bytes_read;
+
+		(ctx->read_mem) (ctx->baton, buf, result,
+				 TARGET_ADDR_BIT / TARGET_CHAR_BIT);
+		result = read_address (buf,
+				       buf + TARGET_ADDR_BIT / TARGET_CHAR_BIT,
+				       &bytes_read);
+	      }
+	    result = result + offset;
+	    ctx->stack_len = before_stack_len;
+	    ctx->in_reg = 0;
+	  }
+	  break;
+	case DW_OP_dup:
+	  result = dwarf_expr_fetch (ctx, 0);
+	  break;
+
+	case DW_OP_drop:
+	  dwarf_expr_pop (ctx);
+	  goto no_push;
+
+	case DW_OP_pick:
+	  offset = *op_ptr++;
+	  result = dwarf_expr_fetch (ctx, offset);
+	  break;
+
+	case DW_OP_over:
+	  result = dwarf_expr_fetch (ctx, 1);
+	  break;
+
+	case DW_OP_rot:
+	  {
+	    CORE_ADDR t1, t2, t3;
+
+	    if (ctx->stack_len < 3)
+	       error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
+		      ctx->stack_len);
+	    t1 = ctx->stack[ctx->stack_len - 1];
+	    t2 = ctx->stack[ctx->stack_len - 2];
+	    t3 = ctx->stack[ctx->stack_len - 3];
+	    ctx->stack[ctx->stack_len - 1] = t2;
+	    ctx->stack[ctx->stack_len - 2] = t3;
+	    ctx->stack[ctx->stack_len - 3] = t1;
+	    goto no_push;
+	  }
+
+	case DW_OP_deref:
+	case DW_OP_deref_size:
+	case DW_OP_abs:
+	case DW_OP_neg:
+	case DW_OP_not:
+	case DW_OP_plus_uconst:
+	  /* Unary operations.  */
+	  result = dwarf_expr_fetch (ctx, 0);
+	  dwarf_expr_pop (ctx);
+
+	  switch (op)
+	    {
+	    case DW_OP_deref:
+	      {
+		char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
+		int bytes_read;
+
+		(ctx->read_mem) (ctx->baton, buf, result,
+				 TARGET_ADDR_BIT / TARGET_CHAR_BIT);
+		result = read_address (buf,
+				       buf + TARGET_ADDR_BIT / TARGET_CHAR_BIT,
+				       &bytes_read);
+	      }
+	      break;
+
+	    case DW_OP_deref_size:
+	      {
+		char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
+		int bytes_read;
+
+		(ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
+		result = read_address (buf,
+				       buf + TARGET_ADDR_BIT / TARGET_CHAR_BIT,
+				       &bytes_read);
+	      }
+	      break;
+
+	    case DW_OP_abs:
+	      if ((signed int) result < 0)
+		result = -result;
+	      break;
+	    case DW_OP_neg:
+	      result = -result;
+	      break;
+	    case DW_OP_not:
+	      result = ~result;
+	      break;
+	    case DW_OP_plus_uconst:
+	      op_ptr = read_uleb128 (op_ptr, op_end, &reg);
+	      result += reg;
+	      break;
+	    }
+	  break;
+
+	case DW_OP_and:
+	case DW_OP_div:
+	case DW_OP_minus:
+	case DW_OP_mod:
+	case DW_OP_mul:
+	case DW_OP_or:
+	case DW_OP_plus:
+	case DW_OP_shl:
+	case DW_OP_shr:
+	case DW_OP_shra:
+	case DW_OP_xor:
+	case DW_OP_le:
+	case DW_OP_ge:
+	case DW_OP_eq:
+	case DW_OP_lt:
+	case DW_OP_gt:
+	case DW_OP_ne:
+	  {
+	    /* Binary operations.  Use the value engine to do computations in
+	       the right width.  */
+	    CORE_ADDR first, second;
+	    enum exp_opcode binop;
+	    struct value *val1, *val2;
+
+	    second = dwarf_expr_fetch (ctx, 0);
+	    dwarf_expr_pop (ctx);
+
+	    first = dwarf_expr_fetch (ctx, 1);
+	    dwarf_expr_pop (ctx);
+
+	    val1 = value_from_longest (unsigned_address_type (), first);
+	    val2 = value_from_longest (unsigned_address_type (), second);
+
+	    switch (op)
+	      {
+	      case DW_OP_and:
+		binop = BINOP_BITWISE_AND;
+		break;
+	      case DW_OP_div:
+		binop = BINOP_DIV;
+	      case DW_OP_minus:
+		binop = BINOP_SUB;
+		break;
+	      case DW_OP_mod:
+		binop = BINOP_MOD;
+		break;
+	      case DW_OP_mul:
+		binop = BINOP_MUL;
+		break;
+	      case DW_OP_or:
+		binop = BINOP_BITWISE_IOR;
+		break;
+	      case DW_OP_plus:
+		binop = BINOP_ADD;
+		break;
+	      case DW_OP_shl:
+		binop = BINOP_LSH;
+		break;
+	      case DW_OP_shr:
+		binop = BINOP_RSH;
+	      case DW_OP_shra:
+		binop = BINOP_RSH;
+		val1 = value_from_longest (signed_address_type (), first);
+		break;
+	      case DW_OP_xor:
+		binop = BINOP_BITWISE_XOR;
+		break;
+	      case DW_OP_le:
+		binop = BINOP_LEQ;
+		break;
+	      case DW_OP_ge:
+		binop = BINOP_GEQ;
+		break;
+	      case DW_OP_eq:
+		binop = BINOP_EQUAL;
+		break;
+	      case DW_OP_lt:
+		binop = BINOP_LESS;
+		break;
+	      case DW_OP_gt:
+		binop = BINOP_GTR;
+		break;
+	      case DW_OP_ne:
+		binop = BINOP_NOTEQUAL;
+		break;
+	      default:
+		internal_error (__FILE__, __LINE__,
+				"Can't be reached.");
+	      }
+	    result = value_as_long (value_binop (val1, val2, binop));
+	  }
+	  break;
+
+	case DW_OP_GNU_push_tls_address:
+	  result = dwarf_expr_fetch (ctx, 0);
+	  dwarf_expr_pop (ctx);
+	  result = (ctx->get_tls_address) (ctx->baton, result);
+	  break;
+
+	case DW_OP_skip:
+	  offset = extract_signed_integer (op_ptr, 2);
+	  op_ptr += 2;
+	  op_ptr += offset;
+	  goto no_push;
+
+	case DW_OP_bra:
+	  offset = extract_signed_integer (op_ptr, 2);
+	  op_ptr += 2;
+	  if (dwarf_expr_fetch (ctx, 0) != 0)
+	    op_ptr += offset;
+	  dwarf_expr_pop (ctx);
+	  goto no_push;
+
+	case DW_OP_nop:
+	  goto no_push;
+
+	default:
+	  error ("Unhandled dwarf expression opcode");
+	}
+
+      /* Most things push a result value.  */
+      dwarf_expr_push (ctx, result);
+    no_push:;
+    }
+}
Index: dwarf2expr.h
===================================================================
RCS file: dwarf2expr.h
diff -N dwarf2expr.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dwarf2expr.h	21 Feb 2003 15:01:31 -0000
@@ -0,0 +1,97 @@
+/* Dwarf2 Expression Evaluator
+   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
+   Contributed by Daniel Berlin (dan@dberlin.org)
+   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.
+
+   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
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#if !defined (DWARF2EXPR_H)
+#define DWARF2EXPR_H
+
+/* The expression evaluator works with a dwarf_expr_context, describing
+   its current state and its callbacks.  */
+struct dwarf_expr_context
+{
+  /* The stack of values, allocated with xmalloc.  */
+  CORE_ADDR *stack;
+
+  /* The number of values currently pushed on the stack, and the
+     number of elements allocated to the stack.  */
+  int stack_len, stack_allocated;
+
+  /* An opaque argument provided by the caller, which will be passed
+     to all of the callback functions.  */
+  void *baton;
+
+  /* Return the value of register number REGNUM.  LVALP will be set
+     to the kind of lval this register is (generally lval_register
+     for the current frame's registers or lval_memory for a register
+     saved to the stack).  For lval_memory ADDRP will be set to the
+     saved location of the register.  */
+  CORE_ADDR (*read_reg) (void *baton, int regnum, enum lval_type *lvalp,
+			 CORE_ADDR *addrp);
+
+  /* Read LENGTH bytes at ADDR into BUF.  */
+  void (*read_mem) (void *baton, char *buf, CORE_ADDR addr,
+		    size_t length);
+
+  /* Return the location expression for the frame base attribute, in
+     START and LENGTH.  The result must be live until the current
+     expression evaluation is complete.  */
+  void (*get_frame_base) (void *baton, unsigned char **start,
+			 size_t *length);
+
+  /* Return the thread-local storage address for
+     DW_OP_GNU_push_tls_address.  */
+  CORE_ADDR (*get_tls_address) (void *baton, CORE_ADDR offset);
+
+#if 0
+  /* Not yet implemented.  */
+
+  /* Return the location expression for the dwarf expression
+     subroutine in the die at OFFSET in the current compilation unit.
+     The result must be live until the current expression evaluation
+     is complete.  */
+  unsigned char *(*get_subr) (void *baton, off_t offset, size_t *length);
+
+  /* Return the `object address' for DW_OP_push_object_address.  */
+  CORE_ADDR (*get_object_address) (void *baton);
+#endif
+
+  /* The current depth of dwarf expression recursion, via DW_OP_call*,
+     DW_OP_fbreg, DW_OP_push_object_address, etc., and the maximum
+     depth we'll tolerate before raising an error.  */
+  int recursion_depth, max_recursion_depth;
+
+  /* Non-zero if the result is in a register.  The register number
+     will be in REGNUM, and the result will be the contents of the
+     register.  */
+  int in_reg;
+
+  /* If the result is in a register, the register number.  */
+  int regnum;
+};
+
+struct dwarf_expr_context *new_dwarf_expr_context ();
+void free_dwarf_expr_context (struct dwarf_expr_context *ctx);
+
+void dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value);
+void dwarf_expr_pop (struct dwarf_expr_context *ctx);
+void dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
+		      size_t len);
+CORE_ADDR dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n);
+
+#endif
Index: dwarf2loc.c
===================================================================
RCS file: dwarf2loc.c
diff -N dwarf2loc.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dwarf2loc.c	21 Feb 2003 15:01:31 -0000
@@ -0,0 +1,287 @@
+/* DWARF 2 location expression support for GDB.
+   Copyright 2003 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
+   the Free Software Foundation; either version 2 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.
+
+   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.  */
+
+#include "defs.h"
+#include "ui-out.h"
+#include "value.h"
+#include "frame.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "inferior.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
+
+/* This is the baton used when performing dwarf2 expression
+   evaluation.  */
+struct dwarf_expr_baton
+{
+  struct frame_info *frame;
+  struct objfile *objfile;
+};
+
+/* 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.  */
+static CORE_ADDR
+dwarf_expr_read_reg (void *baton, int regnum, enum lval_type *lvalp,
+		     CORE_ADDR *addrp)
+{
+  CORE_ADDR result;
+  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
+  char *buf = (char *) alloca (MAX_REGISTER_RAW_SIZE);
+  int optimized, realnum;
+
+  frame_register (debaton->frame, DWARF2_REG_TO_REGNUM (regnum),
+		  &optimized, lvalp, addrp, &realnum, buf);
+  result = extract_address (buf, REGISTER_RAW_SIZE (regnum));
+
+  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)
+{
+  read_memory (addr, buf, len);
+}
+
+/* Using the frame specified in BATON, find the location expression
+   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)
+{
+  struct symbol *framefunc;
+  struct dwarf2_locexpr_baton *symbaton;
+  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
+  framefunc = get_frame_function (debaton->frame);
+  symbaton = SYMBOL_LOCATION_BATON (framefunc);
+  *start = symbaton->data;
+  *length = symbaton->size;
+}
+
+/* Using the objfile specified in BATON, find the address for the
+   current thread's thread-local storage with offset OFFSET.  */
+static CORE_ADDR
+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);
+  else
+    error ("Cannot find thread-local variables on this target");
+
+  return addr;
+}
+
+/* Evaluate a location description, starting at DATA and with length
+   SIZE, to find the current location of variable VAR in the context
+   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)
+{
+  CORE_ADDR result;
+  struct value *retval;
+  struct dwarf_expr_baton baton;
+  struct dwarf_expr_context *ctx;
+
+  baton.frame = frame;
+  baton.objfile = objfile;
+
+  ctx = new_dwarf_expr_context ();
+  ctx->baton = &baton;
+  ctx->read_reg = dwarf_expr_read_reg;
+  ctx->read_mem = dwarf_expr_read_mem;
+  ctx->get_frame_base = dwarf_expr_frame_base;
+  ctx->get_tls_address = dwarf_expr_tls_address;
+
+  dwarf_expr_eval (ctx, data, size);
+
+  retval = allocate_value (SYMBOL_TYPE (var));
+  VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
+
+  if (ctx->in_reg)
+    {
+      store_unsigned_integer (VALUE_CONTENTS_RAW (retval),
+			      TYPE_LENGTH (SYMBOL_TYPE (var)),
+			      dwarf_expr_fetch (ctx, 0));
+      VALUE_LVAL (retval) = lval_register;
+      VALUE_REGNO (retval) = ctx->regnum;
+    }
+  else
+    {
+      result = dwarf_expr_fetch (ctx, 0);
+      VALUE_LVAL (retval) = lval_memory;
+      VALUE_LAZY (retval) = 1;
+      VALUE_ADDRESS (retval) = result;
+    }
+
+  free_dwarf_expr_context (ctx);
+
+  return retval;
+}
+
+
+
+
+\f
+/* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
+
+struct needs_frame_baton
+{
+  int needs_frame;
+};
+
+/* Reads from registers do require a frame.  */
+static CORE_ADDR
+needs_frame_read_reg (void *baton, int regnum, enum lval_type *lvalp,
+			    CORE_ADDR *addrp)
+{
+  struct needs_frame_baton *nf_baton = baton;
+  nf_baton->needs_frame = 1;
+  return 1;
+}
+
+/* Reads from memory do not require a frame.  */
+static void
+needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
+{
+  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)
+{
+  static char lit0 = DW_OP_lit0;
+  struct needs_frame_baton *nf_baton = baton;
+
+  *start = &lit0;
+  *length = 1;
+
+  nf_baton->needs_frame = 1;
+}
+
+/* Thread-local accesses do require a frame.  */
+static CORE_ADDR
+needs_frame_tls_address (void *baton, CORE_ADDR offset)
+{
+  struct needs_frame_baton *nf_baton = baton;
+  nf_baton->needs_frame = 1;
+  return 1;
+}
+
+/* Return non-zero iff the location expression at DATA (length SIZE)
+   requires a frame to evaluate.  */
+
+static int
+dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
+{
+  struct needs_frame_baton baton;
+  struct dwarf_expr_context *ctx;
+
+  baton.needs_frame = 0;
+
+  ctx = new_dwarf_expr_context ();
+  ctx->baton = &baton;
+  ctx->read_reg = needs_frame_read_reg;
+  ctx->read_mem = needs_frame_read_mem;
+  ctx->get_frame_base = needs_frame_frame_base;
+  ctx->get_tls_address = needs_frame_tls_address;
+
+  dwarf_expr_eval (ctx, data, size);
+
+  free_dwarf_expr_context (ctx);
+
+  return baton.needs_frame;
+}
+
+
+
+\f
+/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
+   evaluator to calculate the location.  */
+static struct value *
+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,
+				  dlbaton->objfile);
+
+  return val;
+}
+
+/* Return non-zero iff we need a frame to evaluate SYMBOL.  */
+static int
+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);
+}
+
+/* Print a natural-language description of SYMBOL to STREAM.  */
+static int
+locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
+{
+  /* FIXME: be more extensive.  */
+  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+
+  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);
+      fprintf_filtered (stream,
+			"a variable in register %s", REGISTER_NAME (regno));
+      return 1;
+    }
+
+  fprintf_filtered (stream,
+		    "a variable with complex or multiple locations (DWARF2)");
+  return 1;
+}
+
+/* The set of location functions used with the DWARF-2 expression
+   evaluator.  */
+struct location_funcs dwarf2_locexpr_funcs = {
+  locexpr_read_variable,
+  locexpr_read_needs_frame,
+  locexpr_describe_location,
+  NULL
+};
Index: dwarf2loc.h
===================================================================
RCS file: dwarf2loc.h
diff -N dwarf2loc.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ dwarf2loc.h	21 Feb 2003 15:01:31 -0000
@@ -0,0 +1,39 @@
+/* Dwarf2 location expression support for GDB.
+   Copyright 2003 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 2 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.
+
+   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.  */
+
+#if !defined (DWARF2LOC_H)
+#define DWARF2LOC_H
+
+/* This header is private to the DWARF-2 reader.  It is shared between
+   dwarf2read.c and dwarf2loc.c.  */
+
+/* The symbol location baton type used by the DWARF-2 reader (i.e.
+   SYMBOL_LOCATION_BATON for a LOC_COMPUTED symbol).  */
+
+struct dwarf2_locexpr_baton
+{
+  unsigned char *data;
+  unsigned short size;
+  struct objfile *objfile;
+};
+
+extern struct location_funcs dwarf2_locexpr_funcs;
+
+#endif
Index: dwarf2read.c
===================================================================
RCS file: /cvs/src/src/gdb/dwarf2read.c,v
retrieving revision 1.86
diff -u -p -r1.86 dwarf2read.c
--- dwarf2read.c	14 Feb 2003 19:05:52 -0000	1.86
+++ dwarf2read.c	21 Feb 2003 15:01:32 -0000
@@ -38,10 +38,12 @@
 #include "expression.h"
 #include "filenames.h"	/* for DOSish file names */
 #include "macrotab.h"
-
 #include "language.h"
 #include "complaints.h"
 #include "bcache.h"
+#include "dwarf2expr.h"
+#include "dwarf2loc.h"
+
 #include <fcntl.h>
 #include "gdb_string.h"
 #include "gdb_assert.h"
@@ -905,6 +907,11 @@ static void dwarf_decode_macros (struct 
 
 static int attr_form_is_block (struct attribute *);
 
+static void
+dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
+			     const struct comp_unit_head *,
+			     struct objfile *objfile);
+
 /* Try to locate the sections we need for DWARF 2 debugging
    information and return true if we have enough to do something.  */
 
@@ -1998,6 +2005,13 @@ read_func_scope (struct die_info *die, s
 
   new = push_context (0, lowpc);
   new->name = new_symbol (die, die->type, objfile, cu_header);
+
+  /* If there was a location expression for DW_AT_frame_base above,
+     record it.  We still need to decode it above because not all
+     symbols use location expressions exclusively.  */
+  if (attr)
+    dwarf2_symbol_mark_computed (attr, new->name, cu_header, objfile);
+
   list_in_scope = &local_symbols;
 
   if (die->has_children)
@@ -4930,6 +4944,61 @@ dwarf2_start_subfile (char *filename, ch
   start_subfile (filename, dirname);
 }
 
+static void
+var_decode_location (struct attribute *attr, struct symbol *sym,
+		     struct objfile *objfile,
+		     const struct comp_unit_head *cu_header)
+{
+  /* NOTE drow/2003-01-30: There used to be a comment and some special
+     code here to turn a symbol with DW_AT_external and a
+     SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol.  This was
+     necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
+     with some versions of binutils) where shared libraries could have
+     relocations against symbols in their debug information - the
+     minimal symbol would have the right address, but the debug info
+     would not.  It's no longer necessary, because we will explicitly
+     apply relocations when we read in the debug information now.  */
+
+  /* A DW_AT_location attribute with no contents indicates that a
+     variable has been optimized away.  */
+  if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
+    {
+      SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
+      return;
+    }
+
+  /* Handle one degenerate form of location expression specially, to
+     preserve GDB's previous behavior when section offsets are
+     specified.  If this is just a DW_OP_addr then mark this symbol
+     as LOC_STATIC.  */
+
+  if (attr_form_is_block (attr)
+      && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
+      && DW_BLOCK (attr)->data[0] == DW_OP_addr)
+    {
+      int dummy;
+
+      SYMBOL_VALUE_ADDRESS (sym) =
+	read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu_header,
+		      &dummy);
+      fixup_symbol_section (sym, objfile);
+      SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
+					      SYMBOL_SECTION (sym));
+      SYMBOL_CLASS (sym) = LOC_STATIC;
+      return;
+    }
+
+  /* NOTE drow/2002-01-30: It might be worthwhile to have a static
+     expression evaluator, and use LOC_COMPUTED only when necessary
+     (i.e. when the value of a register or memory location is
+     referenced, or a thread-local block, etc.).  Then again, it might
+     not be worthwhile.  I'm assuming that it isn't unless performance
+     or memory numbers show me otherwise.  */
+
+  dwarf2_symbol_mark_computed (attr, sym, cu_header, objfile);
+  SYMBOL_CLASS (sym) = LOC_COMPUTED;
+}
+
 /* Given a pointer to a DWARF information entry, figure out if we need
    to make a symbol table entry for it, and if so, create a new entry
    and return a pointer to it.
@@ -5018,106 +5087,12 @@ new_symbol (struct die_info *die, struct
 	  attr = dwarf_attr (die, DW_AT_location);
 	  if (attr)
 	    {
+	      var_decode_location (attr, sym, objfile, cu_header);
 	      attr2 = dwarf_attr (die, DW_AT_external);
 	      if (attr2 && (DW_UNSND (attr2) != 0))
-		{
-                  /* Support the .debug_loc offsets */
-                  if (attr_form_is_block (attr))
-                    {
-		      SYMBOL_VALUE_ADDRESS (sym) =
-		        decode_locdesc (DW_BLOCK (attr), objfile, cu_header);
-                    }
-                  else if (attr->form == DW_FORM_data4
-                           || attr->form == DW_FORM_data8)
-                    {
-		      dwarf2_complex_location_expr_complaint ();
-                    }
-                  else
-                    {
-		      dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
-							     "external variable");
-                    }
-		  add_symbol_to_list (sym, &global_symbols);
-                  if (is_thread_local)
-                    {
-                      /* SYMBOL_VALUE_ADDRESS contains at this point the
-		         offset of the variable within the thread local
-			 storage.  */
-                      SYMBOL_CLASS (sym) = LOC_THREAD_LOCAL_STATIC;
-                      SYMBOL_OBJFILE (sym) = objfile;
-                    }
-
-		  /* In shared libraries the address of the variable
-		     in the location descriptor might still be relocatable,
-		     so its value could be zero.
-		     Enter the symbol as a LOC_UNRESOLVED symbol, if its
-		     value is zero, the address of the variable will then
-		     be determined from the minimal symbol table whenever
-		     the variable is referenced.  */
-		  else if (SYMBOL_VALUE_ADDRESS (sym))
-		    {
-		      fixup_symbol_section (sym, objfile);
-		      SYMBOL_VALUE_ADDRESS (sym) +=
-			ANOFFSET (objfile->section_offsets,
-			          SYMBOL_SECTION (sym));
-		      SYMBOL_CLASS (sym) = LOC_STATIC;
-		    }
-		  else
-		    SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
-		}
+		add_symbol_to_list (sym, &global_symbols);
 	      else
-		{
-                  /* Support the .debug_loc offsets */
-                  if (attr_form_is_block (attr))
-                    {
-		      SYMBOL_VALUE (sym) = addr =
-		        decode_locdesc (DW_BLOCK (attr), objfile, cu_header);
-                    }
-                  else if (attr->form == DW_FORM_data4
-                           || attr->form == DW_FORM_data8)
-                    {
-		      dwarf2_complex_location_expr_complaint ();
-                    }
-                  else
-                    {
-		      dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
-							     "external variable");
-                      addr = 0;
-                    }
-		  add_symbol_to_list (sym, list_in_scope);
-		  if (optimized_out)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
-		    }
-		  else if (isreg)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_REGISTER;
-		      SYMBOL_VALUE (sym) = 
-			DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym));
-		    }
-		  else if (offreg)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_BASEREG;
-		      SYMBOL_BASEREG (sym) = DWARF2_REG_TO_REGNUM (basereg);
-		    }
-		  else if (islocal)
-		    {
-		      SYMBOL_CLASS (sym) = LOC_LOCAL;
-		    }
-                  else if (is_thread_local)
-                    {
-                      SYMBOL_CLASS (sym) = LOC_THREAD_LOCAL_STATIC;
-                      SYMBOL_OBJFILE (sym) = objfile;
-                    }
-		  else
-		    {
-		      fixup_symbol_section (sym, objfile);
-		      SYMBOL_VALUE_ADDRESS (sym) =
-		        addr + ANOFFSET (objfile->section_offsets,
-			                 SYMBOL_SECTION (sym));
-		      SYMBOL_CLASS (sym) = LOC_STATIC;
-		    }
-		}
+		add_symbol_to_list (sym, list_in_scope);
 	    }
 	  else
 	    {
@@ -7346,4 +7321,33 @@ attr_form_is_block (struct attribute *at
       || attr->form == DW_FORM_block2
       || attr->form == DW_FORM_block4
       || attr->form == DW_FORM_block);
+}
+
+static void
+dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
+			     const struct comp_unit_head *cu_header,
+			     struct objfile *objfile)
+{
+  struct dwarf2_locexpr_baton *baton;
+
+  /* When support for location lists is added, this will go away.  */
+  if (!attr_form_is_block (attr))
+    {
+      dwarf2_complex_location_expr_complaint ();
+      return;
+    }
+
+  baton = obstack_alloc (&objfile->symbol_obstack,
+			 sizeof (struct dwarf2_locexpr_baton));
+  baton->objfile = objfile;
+
+  /* Note that we're just copying the block's data pointer here, not
+     the actual data.  We're still pointing into the dwarf_info_buffer
+     for SYM's objfile; right now we never release that buffer, but
+     when we do clean up properly this may need to change.  */
+  baton->size = DW_BLOCK (attr)->size;
+  baton->data = DW_BLOCK (attr)->data;
+
+  SYMBOL_LOCATION_FUNCS (sym) = &dwarf2_locexpr_funcs;
+  SYMBOL_LOCATION_BATON (sym) = baton;
 }
Index: findvar.c
===================================================================
RCS file: /cvs/src/src/gdb/findvar.c,v
retrieving revision 1.47
diff -u -p -r1.47 findvar.c
--- findvar.c	20 Feb 2003 17:17:23 -0000	1.47
+++ findvar.c	21 Feb 2003 15:01:32 -0000
@@ -384,6 +384,14 @@ symbol_read_needs_frame (struct symbol *
     {
       /* All cases listed explicitly so that gcc -Wall will detect it if
          we failed to consider one.  */
+    case LOC_COMPUTED:
+    case LOC_COMPUTED_ARG:
+      {
+	struct location_funcs *symfuncs = SYMBOL_LOCATION_FUNCS (sym);
+	return (symfuncs->read_needs_frame) (sym);
+      }
+      break;
+
     case LOC_REGISTER:
     case LOC_ARG:
     case LOC_REF_ARG:
@@ -602,6 +610,18 @@ addresses have not been bound by the dyn
 	      error ("Value of register variable not available.");
 	    return regval;
 	  }
+      }
+      break;
+
+    case LOC_COMPUTED:
+    case LOC_COMPUTED_ARG:
+      {
+	struct location_funcs *funcs = SYMBOL_LOCATION_FUNCS (var);
+
+	if (frame == 0 && (funcs->read_needs_frame) (var))
+	  return 0;
+	return (funcs->read_variable) (var, frame);
+
       }
       break;
 
Index: m2-exp.y
===================================================================
RCS file: /cvs/src/src/gdb/m2-exp.y,v
retrieving revision 1.8
diff -u -p -r1.8 m2-exp.y
--- m2-exp.y	20 Feb 2003 00:01:05 -0000	1.8
+++ m2-exp.y	21 Feb 2003 15:01:32 -0000
@@ -1041,6 +1041,8 @@ yylex ()
        case LOC_CONST:
        case LOC_CONST_BYTES:
        case LOC_OPTIMIZED_OUT:
+       case LOC_COMPUTED:
+       case LOC_COMPUTED_ARG:
 	  return NAME;
 
        case LOC_TYPEDEF:
Index: printcmd.c
===================================================================
RCS file: /cvs/src/src/gdb/printcmd.c,v
retrieving revision 1.54
diff -u -p -r1.54 printcmd.c
--- printcmd.c	20 Feb 2003 17:17:24 -0000	1.54
+++ printcmd.c	21 Feb 2003 15:01:33 -0000
@@ -1149,6 +1149,11 @@ address_info (char *exp, int from_tty)
 	}
       break;
 
+    case LOC_COMPUTED:
+    case LOC_COMPUTED_ARG:
+      (SYMBOL_LOCATION_FUNCS (sym)->describe_location) (sym, gdb_stdout);
+      break;
+
     case LOC_REGISTER:
       printf_filtered ("a variable in register %s", REGISTER_NAME (val));
       break;
@@ -1814,6 +1819,7 @@ print_frame_args (struct symbol *func, s
 	    case LOC_REGPARM_ADDR:
 	    case LOC_LOCAL_ARG:
 	    case LOC_BASEREG_ARG:
+	    case LOC_COMPUTED_ARG:
 	      break;
 
 	    /* Other types of symbols we just skip over.  */
Index: stack.c
===================================================================
RCS file: /cvs/src/src/gdb/stack.c,v
retrieving revision 1.67
diff -u -p -r1.67 stack.c
--- stack.c	20 Feb 2003 17:17:25 -0000	1.67
+++ stack.c	21 Feb 2003 15:01:33 -0000
@@ -1083,6 +1083,7 @@ print_block_frame_locals (struct block *
 	case LOC_REGISTER:
 	case LOC_STATIC:
 	case LOC_BASEREG:
+	case LOC_COMPUTED:
 	  values_printed = 1;
 	  for (j = 0; j < num_tabs; j++)
 	    fputs_filtered ("\t", stream);
@@ -1309,6 +1310,7 @@ print_frame_arg_vars (register struct fr
 	case LOC_REGPARM:
 	case LOC_REGPARM_ADDR:
 	case LOC_BASEREG_ARG:
+	case LOC_COMPUTED_ARG:
 	  values_printed = 1;
 	  fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
 	  fputs_filtered (" = ", stream);
Index: symmisc.c
===================================================================
RCS file: /cvs/src/src/gdb/symmisc.c,v
retrieving revision 1.17
diff -u -p -r1.17 symmisc.c
--- symmisc.c	20 Feb 2003 17:17:25 -0000	1.17
+++ symmisc.c	21 Feb 2003 15:01:33 -0000
@@ -752,6 +752,11 @@ print_symbol (void *args)
 			       SYMBOL_BFD_SECTION (symbol)));
 	  break;
 
+	case LOC_COMPUTED:
+	case LOC_COMPUTED_ARG:
+	  fprintf_filtered (outfile, "computed at runtime");
+	  break;
+
 	case LOC_UNRESOLVED:
 	  fprintf_filtered (outfile, "unresolved");
 	  break;
@@ -902,6 +907,10 @@ print_partial_symbols (struct partial_sy
 	  break;
 	case LOC_OPTIMIZED_OUT:
 	  fputs_filtered ("optimized out", outfile);
+	  break;
+	case LOC_COMPUTED:
+	case LOC_COMPUTED_ARG:
+	  fputs_filtered ("computed at runtime", outfile);
 	  break;
 	default:
 	  fputs_filtered ("<invalid location>", outfile);
Index: symtab.c
===================================================================
RCS file: /cvs/src/src/gdb/symtab.c,v
retrieving revision 1.91
diff -u -p -r1.91 symtab.c
--- symtab.c	21 Feb 2003 03:00:27 -0000	1.91
+++ symtab.c	21 Feb 2003 15:01:34 -0000
@@ -1739,7 +1739,8 @@ lookup_block_symbol (register const stru
 		  SYMBOL_CLASS (sym) != LOC_REF_ARG &&
 		  SYMBOL_CLASS (sym) != LOC_REGPARM &&
 		  SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR &&
-		  SYMBOL_CLASS (sym) != LOC_BASEREG_ARG)
+		  SYMBOL_CLASS (sym) != LOC_BASEREG_ARG &&
+		  SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG)
 		{
 		  break;
 		}
Index: symtab.h
===================================================================
RCS file: /cvs/src/src/gdb/symtab.h,v
retrieving revision 1.61
diff -u -p -r1.61 symtab.h
--- symtab.h	21 Feb 2003 03:00:27 -0000	1.61
+++ symtab.h	21 Feb 2003 15:01:35 -0000
@@ -30,6 +30,8 @@ struct obstack;
 struct objfile;
 struct block;
 struct blockvector;
+struct axs_value;
+struct agent_expr;
 
 /* Don't do this; it means that if some .o's are compiled with GNU C
    and some are not (easy to do accidentally the way we configure
@@ -474,7 +476,58 @@ enum address_class
    * with a level of indirection.
    */
 
-  LOC_INDIRECT
+  LOC_INDIRECT,
+
+  /* The variable's address is computed by a set of location
+     functions (see "struct location_funcs" below).  */
+  LOC_COMPUTED,
+
+  /* Same as LOC_COMPUTED, but for function arguments.  */
+  LOC_COMPUTED_ARG
+};
+
+/* A structure of function pointers describing the location of a
+   variable, structure member, or structure base class.
+
+   These functions' BATON arguments are generic data pointers, holding
+   whatever data the functions need --- the code which provides this
+   structure also provides the actual contents of the baton, and
+   decides its form.  However, there may be other rules about where
+   the baton data must be allocated; whoever is pointing to this
+   `struct location_funcs' object will know the rules.  For example,
+   when a symbol S's location is LOC_COMPUTED, then
+   SYMBOL_LOCATION_FUNCS(S) is pointing to a location_funcs structure,
+   and SYMBOL_LOCATION_BATON(S) is the baton, which must be allocated
+   on the same obstack as the symbol itself.  */
+
+struct location_funcs
+{
+
+  /* Return the value of the variable SYMBOL, relative to the stack
+     frame FRAME.  If the variable has been optimized out, return
+     zero.
+
+     Iff `read_needs_frame (SYMBOL)' is zero, then FRAME may be zero.  */
+
+  struct value *(*read_variable) (struct symbol * symbol,
+				  struct frame_info * frame);
+
+  /* Return non-zero if we need a frame to find the value of the SYMBOL.  */
+  int (*read_needs_frame) (struct symbol * symbol);
+
+  /* Write to STREAM a natural-language description of the location of
+     SYMBOL.  */
+  int (*describe_location) (struct symbol * symbol, struct ui_file * stream);
+
+  /* Tracepoint support.  Append bytecodes to the tracepoint agent
+     expression AX that push the address of the object SYMBOL.  Set
+     VALUE appropriately.  Note --- for objects in registers, this
+     needn't emit any code; as long as it sets VALUE properly, then
+     the caller will generate the right code in the process of
+     treating this as an lvalue or rvalue.  */
+
+  void (*tracepoint_var_ref) (struct symbol * symbol, struct agent_expr * ax,
+			      struct axs_value * value);
 };
 
 /* Linked list of symbol's live ranges. */
@@ -536,6 +589,21 @@ struct symbol
        variable declared with the `__thread' storage class), we may
        need to know which object file it's in.  */
     struct objfile *objfile;
+
+    /* For a LOC_COMPUTED or LOC_COMPUTED_ARG symbol, this is the
+       baton and location_funcs structure to find its location.  For a
+       LOC_BLOCK symbol for a function in a compilation unit compiled
+       with DWARF 2 information, this is information used internally
+       by the DWARF 2 code --- specifically, the location expression
+       for the frame base for this function.  */
+    /* FIXME drow/2003-02-21: For the LOC_BLOCK case, it might be better
+       to add a magic symbol to the block containing this information,
+       or to have a generic debug info annotation slot for symbols.  */
+    struct
+    {
+      void *baton;
+      struct location_funcs *funcs;
+    } loc;
   }
   aux_value;
 
@@ -560,6 +628,8 @@ struct symbol
 #define SYMBOL_OBJFILE(symbol)          (symbol)->aux_value.objfile
 #define SYMBOL_ALIASES(symbol)		(symbol)->aliases
 #define SYMBOL_RANGES(symbol)		(symbol)->ranges
+#define SYMBOL_LOCATION_BATON(symbol)   (symbol)->aux_value.loc.baton
+#define SYMBOL_LOCATION_FUNCS(symbol)   (symbol)->aux_value.loc.funcs
 \f
 /* A partial_symbol records the name, namespace, and address class of
    symbols whose types we have not parsed yet.  For functions, it also
Index: mi/mi-cmd-stack.c
===================================================================
RCS file: /cvs/src/src/gdb/mi/mi-cmd-stack.c,v
retrieving revision 1.14
diff -u -p -r1.14 mi-cmd-stack.c
--- mi/mi-cmd-stack.c	20 Feb 2003 00:01:07 -0000	1.14
+++ mi/mi-cmd-stack.c	21 Feb 2003 15:01:35 -0000
@@ -253,6 +253,7 @@ list_args_or_locals (int locals, int val
 	    case LOC_REGPARM_ADDR:	/* indirect register arg */
 	    case LOC_LOCAL_ARG:	/* stack arg             */
 	    case LOC_BASEREG_ARG:	/* basereg arg           */
+	    case LOC_COMPUTED_ARG:	/* arg with computed location */
 	      if (!locals)
 		print_me = 1;
 	      break;
@@ -261,6 +262,7 @@ list_args_or_locals (int locals, int val
 	    case LOC_BASEREG:	/* basereg local         */
 	    case LOC_STATIC:	/* static                */
 	    case LOC_REGISTER:	/* register              */
+	    case LOC_COMPUTED:	/* computed location     */
 	      if (locals)
 		print_me = 1;
 	      break;
Index: gdbtk/generic/gdbtk-stack.c
===================================================================
RCS file: /cvs/src/src/gdb/gdbtk/generic/gdbtk-stack.c,v
retrieving revision 1.15
diff -u -p -r1.15 gdbtk-stack.c
--- gdbtk/generic/gdbtk-stack.c	20 Feb 2003 12:12:33 -0000	1.15
+++ gdbtk/generic/gdbtk-stack.c	21 Feb 2003 15:15:09 -0000
@@ -122,6 +122,8 @@ gdb_block_vars (ClientData clientData, T
 		case LOC_BASEREG:	  /* basereg local         */
 		case LOC_STATIC:	  /* static                */
 		case LOC_REGISTER:        /* register              */
+		case LOC_COMPUTED:	  /* computed location     */
+		case LOC_COMPUTED_ARG:	  /* computed location arg */
 		  Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
 					    Tcl_NewStringObj (SYMBOL_NAME (sym),
 							      -1));
@@ -193,11 +195,13 @@ gdb_get_blocks (ClientData clientData, T
 		case LOC_REGPARM_ADDR:    /* indirect register arg */
 		case LOC_LOCAL_ARG:	  /* stack arg             */
 		case LOC_BASEREG_ARG:	  /* basereg arg           */
+		case LOC_COMPUTED_ARG:	  /* computed location arg */
 
 		case LOC_LOCAL:	          /* stack local           */
 		case LOC_BASEREG:	  /* basereg local         */
 		case LOC_STATIC:	  /* static                */
 		case LOC_REGISTER:        /* register              */
+		case LOC_COMPUTED:	  /* computed location     */
 		  junk = 0;
 		  break;
 		}
@@ -338,6 +342,7 @@ gdb_get_vars_command (ClientData clientD
 	    case LOC_REGPARM_ADDR:	/* indirect register arg */
 	    case LOC_LOCAL_ARG:	/* stack arg             */
 	    case LOC_BASEREG_ARG:	/* basereg arg           */
+	    case LOC_COMPUTED_ARG:	/* computed location arg */
 	      if (arguments)
 		Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
 					  Tcl_NewStringObj (SYMBOL_NAME (sym), -1));
@@ -346,6 +351,7 @@ gdb_get_vars_command (ClientData clientD
 	    case LOC_BASEREG:	/* basereg local         */
 	    case LOC_STATIC:	/* static                */
 	    case LOC_REGISTER:	/* register              */
+	    case LOC_COMPUTED:	/* computed location     */
 	      if (!arguments)
 		Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
 					  Tcl_NewStringObj (SYMBOL_NAME (sym), -1));

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Andrew Cagney]

Just a generic heads up on the structure of this code and these, er, 
batons (from the point of view of the architecture).

This is implementing something like (I've not hacked C++ in > 10 years):

	// some base classes
	class A;
	class B;

	// a derived class (wonder if I got the order right).
	class B::class B1;

	// A `uses' B but is parameterized with the specific instance
	class A->method (class B B);

in C.

I honestly think that using baton's distract from what is a simple O-O 
construct and standard O-O terminology.

The frame and architecture code both reflect this structure - pass in 
the object and then use methods supplied as part of the object.

Once all this is settled, I think I'll look to re-factor (hmm, buzword) 
the code so that its structure better refects what is going on.

enjoy,
Andrew

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Daniel Jacobowitz]

On Fri, Feb 21, 2003 at 12:12:41PM -0500, Andrew Cagney wrote:
> Just a generic heads up on the structure of this code and these, er, 
> batons (from the point of view of the architecture).
> 
> This is implementing something like (I've not hacked C++ in > 10 years):
> 
> 	// some base classes
> 	class A;
> 	class B;
> 
> 	// a derived class (wonder if I got the order right).
> 	class B::class B1;
> 
> 	// A `uses' B but is parameterized with the specific instance
> 	class A->method (class B B);
> 
> in C.
> 
> I honestly think that using baton's distract from what is a simple O-O 
> construct and standard O-O terminology.
> 
> The frame and architecture code both reflect this structure - pass in 
> the object and then use methods supplied as part of the object.
> 
> Once all this is settled, I think I'll look to re-factor (hmm, buzword) 
> the code so that its structure better refects what is going on.

I don't think I agree with you on this, but if you want to change it by
all means post a patch for some concrete discussion :)  This is another
point when I am willing to sacrifice a certain amount of clarity to not
carry around an extra set of method pointers; there are a _large_
number of these batons.

I'd rather discuss a transition to C++ than any particular instance of
this problem.  Do you think it's feasible?

-- 
Daniel Jacobowitz
MontaVista Software                         Debian GNU/Linux Developer

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Andrew Cagney]

> I don't think I agree with you on this, but if you want to change it by
> all means post a patch for some concrete discussion :)  This is another
> point when I am willing to sacrifice a certain amount of clarity to not
> carry around an extra set of method pointers; there are a _large_
> number of these batons.

The other foucus would be reviewing the interfaces with an eye for 
simplicity.

> I'd rather discuss a transition to C++ than any particular instance of
> this problem.  Do you think it's feasible?

Andrew

Re: [drow@mvista.com: Re: RFA: LOC_COMPUTED support]

[Joel Brobecker]

> > I think I found some switches that still need LOC_COMPUTED{,_ARG} cases:
> > - ada-lang.c (ada_resolve_subexp, symtab_for_sym,
> >     ada_add_block_symbols, fill_in_ada_prototype) 
> 
> OK, what's up with that?  The code bits in ada_resolve_subexp all
> appear to be commented out.  Is this code going away?

Just from the top of my head, since I haven't directly been involved
with the process of getting this file in: I think they are commented
out until we can add the different pieces that would make them
compilable and/or activatable. 

They will for sure be re-examined when we activate this code.

> symtab_for_sym is pretty hokey too.  All the Ada code reads like
> someone wanted to keep changes local to ada-lang.c when they were
> addressing general symtab weaknesses.  I hope it can all go away
> someday.  The amount of duplication is pretty scary, too.

I don't know the history of this code, Paul Hilfinger will probably know
more, but I agree that getting rid of this code one day would be a
tremendous improvement.

Thanks for taking care of ada-lang.c in the interim. If any problem
arises with the maintenance of these file, please let me and Paul know,
we'll jump in to help.

-- 
Joel