GDB 7.6.50

gdb/value.h

 /* Definitions for values of C expressions, for GDB.
 
-   Copyright (C) 1986-2012 Free Software Foundation, Inc.
+   Copyright (C) 1986-2013 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 3 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
@@ skipping 69 matching lines @@
    embedded_offset below.  */
 
 extern int value_offset (const struct value *);
 extern void set_value_offset (struct value *, int offset);
 
 /* The comment from "struct value" reads: ``Is it modifiable?  Only
    relevant if lval != not_lval.''.  Shouldn't the value instead be
    not_lval and be done with it?  */
 
 extern int deprecated_value_modifiable (struct value *value);
-extern void deprecated_set_value_modifiable (struct value *value,
-                                             int modifiable);
 
 /* If a value represents a C++ object, then the `type' field gives the
    object's compile-time type.  If the object actually belongs to some
    class derived from `type', perhaps with other base classes and
    additional members, then `type' is just a subobject of the real
    thing, and the full object is probably larger than `type' would
    suggest.
 
    If `type' is a dynamic class (i.e. one with a vtable), then GDB can
    actually determine the object's run-time type by looking at the
@@ skipping 163 matching lines @@
    when the user wants to watch a single struct member or array
    element.  If you ever change the way lazy flag is set and reset, be
    sure to consider this use as well!  */
 
 extern int value_lazy (struct value *);
 extern void set_value_lazy (struct value *value, int val);
 
 extern int value_stack (struct value *);
 extern void set_value_stack (struct value *value, int val);
 
+/* Throw an error complaining that the value has been optimized
+   out.  */
+
+extern void error_value_optimized_out (void);
+
 /* value_contents() and value_contents_raw() both return the address
    of the gdb buffer used to hold a copy of the contents of the lval.
    value_contents() is used when the contents of the buffer are needed
    -- it uses value_fetch_lazy() to load the buffer from the process
    being debugged if it hasn't already been loaded
    (value_contents_writeable() is used when a writeable but fetched
    buffer is required)..  value_contents_raw() is used when data is
    being stored into the buffer, or when it is certain that the
    contents of the buffer are valid.
 
@@ skipping 26 matching lines @@
 /* Like value_contents_for_printing, but accepts a constant value
    pointer.  Unlike value_contents_for_printing however, the pointed
    value must _not_ be lazy.  */
 extern const gdb_byte *
   value_contents_for_printing_const (const struct value *value);
 
 extern int value_fetch_lazy (struct value *val);
 extern int value_contents_equal (struct value *val1, struct value *val2);
 
 /* If nonzero, this is the value of a variable which does not actually
-   exist in the program.  */
+   exist in the program, at least partially.  If the value is lazy,
+   this may fetch it now.  */
 extern int value_optimized_out (struct value *value);
 extern void set_value_optimized_out (struct value *value, int val);
 
+/* Like value_optimized_out, but don't fetch the value even if it is
+   lazy.  Mainly useful for constructing other values using VALUE as
+   template.  */
+extern int value_optimized_out_const (const struct value *value);
+
 /* Like value_optimized_out, but return false if any bit in the object
    is valid.  */
 extern int value_entirely_optimized_out (const struct value *value);
 
 /* Set or return field indicating whether a variable is initialized or
    not, based on debugging information supplied by the compiler.
    1 = initialized; 0 = uninitialized.  */
 extern int value_initialized (struct value *);
 extern void set_value_initialized (struct value *, int);
 
@@ skipping 86 matching lines @@
    nonzero if all bytes in the given range are available, zero if any
    byte is unavailable.  */
 
 extern int value_bytes_available (const struct value *value,
                                   int offset, int length);
 
 /* Like value_bytes_available, but return false if any byte in the
    whole object is unavailable.  */
 extern int value_entirely_available (struct value *value);
 
+/* Like value_entirely_available, but return false if any byte in the
+   whole object is available.  */
+extern int value_entirely_unavailable (struct value *value);
+
 /* Mark VALUE's content bytes starting at OFFSET and extending for
    LENGTH bytes as unavailable.  */
 
 extern void mark_value_bytes_unavailable (struct value *value,
                                           int offset, int length);
 
 /* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
    LENGTH bytes of VAL2's contents starting at OFFSET2.
 
    Note that "contents" refers to the whole value's contents
@@ skipping 14 matching lines @@
    contents: xxxxVVVVxxxxVVZZ
 
    then:
 
    value_available_contents_eq(val, 0, val, 8, 6) => 1
    value_available_contents_eq(val, 0, val, 4, 4) => 1
    value_available_contents_eq(val, 0, val, 8, 8) => 0
    value_available_contents_eq(val, 4, val, 12, 2) => 1
    value_available_contents_eq(val, 4, val, 12, 4) => 0
    value_available_contents_eq(val, 3, val, 4, 4) => 0
-*/
+
+   We only know whether a value chunk is available if we've tried to
+   read it.  As this routine is used by printing routines, which may
+   be printing values in the value history, long after the inferior is
+   gone, it works with const values.  Therefore, this routine must not
+   be called with lazy values.  */
 
 extern int value_available_contents_eq (const struct value *val1, int offset1,
                                         const struct value *val2, int offset2,
                                         int length);
 
 /* Read LENGTH bytes of memory starting at MEMADDR into BUFFER, which
    is (or will be copied to) VAL's contents buffer offset by
    EMBEDDED_OFFSET (that is, to &VAL->contents[EMBEDDED_OFFSET]).
    Marks value contents ranges as unavailable if the corresponding
    memory is likewise unavailable.  STACK indicates whether the memory
    is known to be stack memory.  */
 
 extern void read_value_memory (struct value *val, int embedded_offset,