X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fdwarf2loc.h;h=0932456977f0c94ce3900777ad0aa972596c7205;hb=75ea58593b839653b6d2bc69571a8a73e8adebe4;hp=8ad5fa9e4347a1ac4cdcae7cd5bd48a87bd165db;hpb=1cfdf5340af6f07bb44b97c278f7036ef8db5c43;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/dwarf2loc.h b/gdb/dwarf2loc.h
index 8ad5fa9e43..0932456977 100644
--- a/gdb/dwarf2loc.h
+++ b/gdb/dwarf2loc.h
@@ -1,6 +1,6 @@
 /* DWARF 2 location expression support for GDB.
 
-   Copyright (C) 2003-2014 Free Software Foundation, Inc.
+   Copyright (C) 2003-2015 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -80,6 +80,18 @@ extern const gdb_byte *dwarf2_fetch_constant_bytes (sect_offset,
 struct type *dwarf2_get_die_type (cu_offset die_offset,
 				  struct dwarf2_per_cu_data *per_cu);
 
+/* Find the frame base information for FRAMEFUNC at PC.  START is an
+   out parameter which is set to point to the DWARF expression to
+   compute.  LENGTH is an out parameter which is set to the length of
+   the DWARF expression.  This throws an exception on error or if an
+   expression is not found; the returned length will never be
+   zero.  */
+
+extern void func_get_frame_base_dwarf_block (struct symbol *framefunc,
+					     CORE_ADDR pc,
+					     const gdb_byte **start,
+					     size_t *length);
+
 /* Evaluate a location description, starting at DATA and with length
    SIZE, to find the current location of variable of TYPE in the context
    of FRAME.  */
@@ -90,14 +102,53 @@ struct value *dwarf2_evaluate_loc_desc (struct type *type,
 					size_t size,
 					struct dwarf2_per_cu_data *per_cu);
 
-/* Converts a dynamic property into a static one.  ADDR is the address of
-   the object currently being evaluated and might be nedded.
+/* A chain of addresses that might be needed to resolve a dynamic
+   property.  */
+
+struct property_addr_info
+{
+  /* The type of the object whose dynamic properties, if any, are
+     being resolved.  */
+  struct type *type;
+
+  /* The address of that object.  */
+  CORE_ADDR addr;
+
+  /* If not NULL, a pointer to the info for the object containing
+     the object described by this node.  */
+  struct property_addr_info *next;
+};
+
+/* Converts a dynamic property into a static one.  ADDR_STACK is the stack
+   of addresses that might be needed to evaluate the property.
    Returns 1 if PROP could be converted and the static value is passed back
    into VALUE, otherwise returns 0.  */
 
 int dwarf2_evaluate_property (const struct dynamic_prop *prop,
+			      struct property_addr_info *addr_stack,
 			      CORE_ADDR *value);
 
+/* A helper for the compiler interface that compiles a single dynamic
+   property to C code.
+
+   STREAM is where the C code is to be written.
+   RESULT_NAME is the name of the generated variable.
+   GDBARCH is the architecture to use.
+   REGISTERS_USED is a bit-vector that is filled to note which
+   registers are required by the generated expression.
+   PROP is the property for which code is generated.
+   ADDRESS is the address at which the property is considered to be
+   evaluated.
+   SYM the originating symbol, used for error reporting.  */
+
+void dwarf2_compile_property_to_c (struct ui_file *stream,
+				   const char *result_name,
+				   struct gdbarch *gdbarch,
+				   unsigned char *registers_used,
+				   const struct dynamic_prop *prop,
+				   CORE_ADDR address,
+				   struct symbol *sym);
+
 CORE_ADDR dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
 				  unsigned int addr_index);
 
@@ -143,6 +194,23 @@ struct dwarf2_loclist_baton
   unsigned char from_dwo;
 };
 
+/* The baton used when a dynamic property is an offset to a parent
+   type.  This can be used, for instance, then the bound of an array
+   inside a record is determined by the value of another field inside
+   that record.  */
+
+struct dwarf2_offset_baton
+{
+  /* The offset from the parent type where the value of the property
+     is stored.  In the example provided above, this would be the offset
+     of the field being used as the array bound.  */
+  LONGEST offset;
+
+  /* The type of the object whose property is dynamic.  In the example
+     provided above, this would the the array's index type.  */
+  struct type *type;
+};
+
 /* A dynamic property is either expressed as a single location expression
    or a location list.  If the property is an indirection, pointing to
    another die, keep track of the targeted type in REFERENCED_TYPE.  */
@@ -150,7 +218,7 @@ struct dwarf2_loclist_baton
 struct dwarf2_property_baton
 {
   /* If the property is an indirection, we need to evaluate the location
-     LOCEXPR or LOCLIST in the context of the type REFERENCED_TYPE.
+     in the context of the type REFERENCED_TYPE.
      If NULL, the location is the actual value of the property.  */
   struct type *referenced_type;
   union
@@ -160,6 +228,9 @@ struct dwarf2_property_baton
 
     /* Location list to be evaluated in the context of REFERENCED_TYPE.  */
     struct dwarf2_loclist_baton loclist;
+
+    /* The location is an offset to REFERENCED_TYPE.  */
+    struct dwarf2_offset_baton offset_info;
   };
 };
 
@@ -209,4 +280,12 @@ extern struct call_site_chain *call_site_find_chain (struct gdbarch *gdbarch,
 						     CORE_ADDR caller_pc,
 						     CORE_ADDR callee_pc);
 
+/* A helper function to convert a DWARF register to an arch register.
+   ARCH is the architecture.
+   DWARF_REG is the register.
+   This will throw an exception if the DWARF register cannot be
+   translated to an architecture register.  */
+
+extern int dwarf2_reg_to_regnum_or_error (struct gdbarch *arch, int dwarf_reg);
+
 #endif /* dwarf2loc.h */