Re: [PATCH] Let dwarf2 CFI's execute_stack_op be used outside of CFI

[Daniel Berlin <dan@dberlin.org>]

On 28 Mar 2002, Jim Blandy wrote:

> 
> I've read through the new Dwarf spec some more.  You're right ---
> they've added a bunch of stuff like DW_OP_push_object_address and
> DW_OP_call, and cases where you're supposed to push stuff on the
> stack, etc.
> 
> But what I'm going for here is something we could, in the long run,
> put in libiberty and just have GDB use from there.  Surely there are
> other applications that could use a Dwarf expression interpreter.

I'm not so sure about this, that's the reason I think you might be 
overengineering it.
1. I doubt DJ would put it in libiberty, it's just not generally useful 
enough.
2. There aren't *that* many things that need support for dwarf 
expressions. Those that do, either already have it, or it's not a 
significant amount of work to make an evaluator.
> 
> Would something like the below be sufficient? 
Sure, but some of it is way overkill.
In particular, you just need some initial value, or no initial value, not 
a push object address value/other types of things that may get pushed to 
the front.
Also, why would something need our evaluator if they already knew how to 
read DIE's at a given offset? It's very likely they can also evaluate 
expressions if they can read DWARF2 at all.

If this evaluator was part of a "libdwarf" type thing, I'd think it was a 
good idea to do the below, but I'm just not sure of general utility.

If, however, this is what GDB people want it to look like, i'll happily 
implement it.  It's not like it'll be that much more work for me.

> free to say, "Yes, but that's way beyond what I offered to do."  Also
> feel free to say, "You look like you're trying to write C++ programs
> in C.")
> 
> 
> struct dwarf_expr_context
> {
>   /* The stack of values, allocated with xmalloc.  */
>   ADDR_TYPE *stack;
> 
>   /* The number of values currently pushed on the stack, and the
>      number of elements allocated to the stack.  */
>   int stack_len, stack_allocated;
> 
>   /* The size of an address, in bits.  */
>   int addr_size;
> 
>   /* Return the value of register number REGNUM.  */
>   ADDR_TYPE (*read_reg) (void *baton, int regnum);
>   void *read_reg_baton;
> 
>   /* Return the LEN-byte value at ADDR.  */
>   ADDR_TYPE (*read_mem) (void *baton, ADDR_TYPE addr, size_t len);
>   void *read_mem_baton;
> 
>   /* Return the location expression for the frame base attribute.  The
>      result must be live until the current expression evaluation is
>      complete.  */
>   unsigned char *(*get_frame_base) (void *baton);
>   void *get_frame_base_baton;
> 
>   /* 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, offset_t offset);
>   void *get_subr_baton;
> 
>   /* Return the `object address' for DW_OP_push_object_address.  */
>   ADDR_TYPE (*get_object_address) (void *baton);
>   void *get_object_address_baton;
> 
>   /* 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;
> 
>   /* Add whatever you want here; the caller is supposed to use
>      new_dwarf_expr_context to make these, which can fill in default
>      values.  */
> };
> 
> 
> /* Return a new context, with no values on the stack.  */ 
> struct dwarf_expr_context *new_dwarf_expr_context ();
> 
> /* Free CONTEXT.  */
> void free_dwarf_expr_context (struct dwarf_expr_context *context);
> 
> /* Push VALUE on CONTEXT's stack.  Reallocate the stack as needed.  */
> void dwarf_expr_push (struct dwarf_expr_context *context, ADDR_TYPE value);
> 
> /* Evaluate the LEN bytes at ADDR as a dwarf expression in CONTEXT.  */
> void dwarf_expr_eval (struct dwarf_expr_context *context,
>                       unsigned char *addr, size_t len);
> 
> /* Return the value N values down from the top of CONTEXT's stack.
>    This raises an error if there aren't at least N+1 values on the stack.  */
> ADDR_TYPE dwarf_expr_fetch (struct dwarf_expr_context *context, int n);
>