## 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.