dist/gdb/value.c

178       lazy (1),
210      the contents are in inferior memory at location.address plus offset.
215      watched by hardware watchpoints.  If the lazy flag is set for
220      array element.  If you ever change the way lazy flag is set and
222   unsigned int lazy : 1;
234     /* If lval == lval_memory, this is the address in the inferior  */
235     CORE_ADDR address;
340      valid if lazy is nonzero.  */
357      different string representation and related error strings.  */
372   gdb_assert (!value->lazy);
389   gdb_assert (!value->lazy);
399   if (value->lazy)
408    is lazy, it'll be read now.  Note that RANGE is a pointer to
417   if (value->lazy)
844   gdb_assert (!val1->lazy && !val2->lazy);
920 /* Allocate a lazy value for type TYPE.  Its actual content is
1035   val->lazy = 0;
1235   if (value->lazy)
1243   gdb_assert (!value->lazy);
1299    unavailable accordingly.  Neither DST nor SRC may be lazy
1313   /* A lazy DST would make that this copy operation useless, since as
1315      call, say), the contents would be overwritten.  A lazy SRC would
1317   gdb_assert (!dst->lazy && !src->lazy);
1346    marked unavailable accordingly.  DST must not be lazy.  If SRC is
1347    lazy, it will be fetched now.
1356   if (src->lazy)
1365   return value->lazy;
1371   value->lazy = val;
1398   if (value->lazy)
1408   if (value->optimized_out.empty () && value->lazy)
1531   return value->location.address + value->offset;
1539   return value->location.address;
1546   value->location.address = addr;
1669    It contains the same contents, for same memory address,
1688   val->lazy = arg->lazy;
1761   v->location.address = addr;
1787      update it's value address.  */
1909   /* The variable holds a GDB-provided string.  */
1946   /* A string value used with INTERNALVAR_STRING.  */
1947   char *string;
2147       val = value_cstring (var->u.string, strlen (var->u.string),
2304          The resolved dynamic location is used prior then any other address
2334 set_internalvar_string (struct internalvar *var, const char *string)
2340   var->u.string = xstrdup (string);
2366       xfree (var->u.string);
2654      non-address (e.g. argument to "signal", "info break", etc.), or
2660      don't represent pointers to functions as simply the address of
2669      function address into a function pointer; it has to either find
2678      value_address (val) is the address of the function.  This is what
2684      back into an address.
2689      has no linker-built descriptor.  The address->pointer conversion
2692      directly back into the same address.
2695      function, just return its address directly.  */
2703      addresses onto a single large unified address space.  For
2706      addresses (hence not need a pointer to address conversion) while
2708      pointer to address.  Just assume such architectures handle all
2728      take an address from a disassembly listing and give it to `x/i'.
2945 	 bit.  Assume that the address, offset, and embedded offset
3051    We only use the symbol for its address, so be happy with either a
3087 	 resolve it to the actual code address instead.  */
3440 /* Create a value representing a pointer of type TYPE to the address
3468    is non-null, and whose memory address (in the inferior) is
3477 					    CORE_ADDR address)
3486   set_value_address (v, address);
3491    is non-null, and whose memory address (in the inferior) is
3498 				 CORE_ADDR address)
3503   struct type *resolved_type = resolve_dynamic_type (type, view, address);
3513     address = TYPE_DATA_LOCATION_ADDR (resolved_type_no_typedef);
3515   set_value_address (v, address);
3549   /* Find length of numeral string.  */
3553   /* Make sure numeral string is not part of an identifier.  */
3730    address as a hidden first parameter).  */
3768   /* To read a lazy bitfield, read the entire enclosing value.  This
3809   /* Offsets are not supported here; lazy register values must
3838       /* If we get another lazy lval_register value, it means the
3855   /* If it's still lazy (for instance, a saved register on the
3898 	    fprintf_unfiltered (gdb_stdlog, " address=%s",
3919 /* Load the actual content of a lazy value.  Fetch the data from the
3920    user's process and clear the lazy flag to indicate that the data in
3932   /* A value is either lazy, or fully fetched.  The
3947     internal_error (__FILE__, __LINE__, _("Unexpected lazy value type."));
4158 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
4159 \"$__\" holds the contents of the last address examined with \"x\"."