Merge GDB 7.5.1

gdb/value.h

 /* Definitions for values of C expressions, for GDB.
 
    Copyright (C) 1986-2012 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.
@@ skipping 56 matching lines @@
    gdbarch_bits_big_endian=1 targets, it is the position of the MSB.  */
 
 extern int value_bitpos (const struct value *);
 extern void set_value_bitpos (struct value *, int bit);
 
 /* Only used for bitfields; the containing value.  This allows a
    single read from the target when displaying multiple
    bitfields.  */
 
 struct value *value_parent (struct value *);
+extern void set_value_parent (struct value *value, struct value *parent);
 
 /* Describes offset of a value within lval of a structure in bytes.
    If lval == lval_memory, this is an offset to the address.  If lval
    == lval_register, this is a further offset from location.address
    within the registers structure.  Note also the member
    embedded_offset below.  */
 
 extern int value_offset (const struct value *);
 extern void set_value_offset (struct value *, int offset);
 
@@ skipping 43 matching lines @@
    until you indirect anyway.)
 
    If we're not doing anything fancy, `enclosing_type' is equal to
    `type', and `embedded_offset' is zero, so everything works
    normally.  */
 
 extern struct type *value_enclosing_type (struct value *);
 extern void set_value_enclosing_type (struct value *val,
                                       struct type *new_type);
 
+/* Returns value_type or value_enclosing_type depending on
+   value_print_options.objectprint.
+
+   If RESOLVE_SIMPLE_TYPES is 0 the enclosing type will be resolved
+   only for pointers and references, else it will be returned
+   for all the types (e.g. structures).  This option is useful
+   to prevent retrieving enclosing type for the base classes fields.
+
+   REAL_TYPE_FOUND is used to inform whether the real type was found
+   (or just static type was used).  The NULL may be passed if it is not
+   necessary. */
+
+extern struct type *value_actual_type (struct value *value,
+                                       int resolve_simple_types,
+                                       int *real_type_found);
+
 extern int value_pointed_to_offset (struct value *value);
 extern void set_value_pointed_to_offset (struct value *value, int val);
 extern int value_embedded_offset (struct value *value);
 extern void set_value_embedded_offset (struct value *value, int val);
 
 /* For lval_computed values, this structure holds functions used to
    retrieve and set the value (or portions of the value).
 
    For each function, 'V' is the 'this' pointer: an lval_funcs
    function F may always assume that the V it receives is an
@@ skipping 55 matching lines @@
   void (*free_closure) (struct value *v);
 };
 
 /* Create a computed lvalue, with type TYPE, function pointers FUNCS,
    and closure CLOSURE.  */
 
 extern struct value *allocate_computed_value (struct type *type,
                                               const struct lval_funcs *funcs,
                                               void *closure);
 
+/* Helper function to check the validity of some bits of a value.
+
+   If TYPE represents some aggregate type (e.g., a structure), return 1.
+   
+   Otherwise, any of the bytes starting at OFFSET and extending for
+   TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
+   return 0.  The checking is done using FUNCS.
+   
+   Otherwise, return 1.  */
+
+extern int valprint_check_validity (struct ui_file *stream, struct type *type,
+                                    int embedded_offset,
+                                    const struct value *val);
+
 extern struct value *allocate_optimized_out_value (struct type *type);
 
 /* If VALUE is lval_computed, return its lval_funcs structure.  */
 
 extern const struct lval_funcs *value_computed_funcs (const struct value *);
 
 /* If VALUE is lval_computed, return its closure.  The meaning of the
    returned value depends on the functions VALUE uses.  */
 
 extern void *value_computed_closure (const struct value *value);
@@ skipping 119 matching lines @@
 
 /* Register number if the value is from a register.  */
 extern short *deprecated_value_regnum_hack (struct value *);
 #define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
 
 /* Return value after lval_funcs->coerce_ref (after check_typedef).  Return
    NULL if lval_funcs->coerce_ref is not applicable for whatever reason.  */
 
 extern struct value *coerce_ref_if_computed (const struct value *arg);
 
+/* Setup a new value type and enclosing value type for dereferenced value VALUE.
+   ENC_TYPE is the new enclosing type that should be set.  ORIGINAL_TYPE and
+   ORIGINAL_VAL are the type and value of the original reference or pointer.
+
+   Note, that VALUE is modified by this function.
+
+   It is a common implementation for coerce_ref and value_ind.  */
+
+extern struct value * readjust_indirect_value_type (struct value *value,
+                                                    struct type *enc_type,
+                                                    struct type *original_type,
+                                                    struct value *original_val);
+
 /* Convert a REF to the object referenced.  */
 
 extern struct value *coerce_ref (struct value *value);
 
 /* If ARG is an array, convert it to a pointer.
    If ARG is a function, convert it to a function pointer.
 
    References are dereferenced.  */
 
 extern struct value *coerce_array (struct value *value);
@@ skipping 73 matching lines @@
 extern void read_value_memory (struct value *val, int embedded_offset,
                                int stack, CORE_ADDR memaddr,
                                gdb_byte *buffer, size_t length);
 
 
 
 
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "expression.h"