Next: , Previous: libgdb, Up: Top



6 Values

6.1 Values

gdb uses struct value, or values, as an internal abstraction for the representation of a variety of inferior objects and gdb convenience objects.

Values have an associated struct type, that describes a virtual view of the raw data or object stored in or accessed through the value.

A value is in addition discriminated by its lvalue-ness, given its enum lval_type enumeration type:

not_lval
This value is not an lval. It can't be assigned to.
lval_memory
This value represents an object in memory.
lval_register
This value represents an object that lives in a register.
lval_internalvar
Represents the value of an internal variable.
lval_internalvar_component
Represents part of a gdb internal variable. E.g., a structure field.


lval_computed
These are “computed” values. They allow creating specialized value objects for specific purposes, all abstracted away from the core value support code. The creator of such a value writes specialized functions to handle the reading and writing to/from the value's backend data, and optionally, a “copy operator” and a “destructor”.

Pointers to these functions are stored in a struct lval_funcs instance (declared in value.h), and passed to the allocate_computed_value function, as in the example below.

          static void
          nil_value_read (struct value *v)
          {
            /* This callback reads data from some backend, and stores it in V.
               In this case, we always read null data.  You'll want to fill in
               something more interesting.  */
          
            memset (value_contents_all_raw (v),
                    value_offset (v),
                    TYPE_LENGTH (value_type (v)));
          }
          
          static void
          nil_value_write (struct value *v, struct value *fromval)
          {
            /* Takes the data from FROMVAL and stores it in the backend of V.  */
          
            to_oblivion (value_contents_all_raw (fromval),
                         value_offset (v),
                         TYPE_LENGTH (value_type (fromval)));
          }
          
          static struct lval_funcs nil_value_funcs =
            {
              nil_value_read,
              nil_value_write
            };
          
          struct value *
          make_nil_value (void)
          {
             struct type *type;
             struct value *v;
          
             type = make_nils_type ();
             v = allocate_computed_value (type, &nil_value_funcs, NULL);
          
             return v;
          }
     

See the implementation of the $_siginfo convenience variable in infrun.c as a real example use of lval_computed.