xref: /dflybsd-src/contrib/gdb-7/gdb/dwarf2loc.c (revision de8e141f24382815c10a4012d209bbbf7abf1112)
15796c8dcSSimon Schubert /* DWARF 2 location expression support for GDB.
25796c8dcSSimon Schubert 
3*ef5ccd6cSJohn Marino    Copyright (C) 2003-2013 Free Software Foundation, Inc.
45796c8dcSSimon Schubert 
55796c8dcSSimon Schubert    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
65796c8dcSSimon Schubert 
75796c8dcSSimon Schubert    This file is part of GDB.
85796c8dcSSimon Schubert 
95796c8dcSSimon Schubert    This program is free software; you can redistribute it and/or modify
105796c8dcSSimon Schubert    it under the terms of the GNU General Public License as published by
115796c8dcSSimon Schubert    the Free Software Foundation; either version 3 of the License, or
125796c8dcSSimon Schubert    (at your option) any later version.
135796c8dcSSimon Schubert 
145796c8dcSSimon Schubert    This program is distributed in the hope that it will be useful,
155796c8dcSSimon Schubert    but WITHOUT ANY WARRANTY; without even the implied warranty of
165796c8dcSSimon Schubert    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
175796c8dcSSimon Schubert    GNU General Public License for more details.
185796c8dcSSimon Schubert 
195796c8dcSSimon Schubert    You should have received a copy of the GNU General Public License
205796c8dcSSimon Schubert    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
215796c8dcSSimon Schubert 
225796c8dcSSimon Schubert #include "defs.h"
235796c8dcSSimon Schubert #include "ui-out.h"
245796c8dcSSimon Schubert #include "value.h"
255796c8dcSSimon Schubert #include "frame.h"
265796c8dcSSimon Schubert #include "gdbcore.h"
275796c8dcSSimon Schubert #include "target.h"
285796c8dcSSimon Schubert #include "inferior.h"
295796c8dcSSimon Schubert #include "ax.h"
305796c8dcSSimon Schubert #include "ax-gdb.h"
315796c8dcSSimon Schubert #include "regcache.h"
325796c8dcSSimon Schubert #include "objfiles.h"
335796c8dcSSimon Schubert #include "exceptions.h"
345796c8dcSSimon Schubert #include "block.h"
35a45ae5f8SJohn Marino #include "gdbcmd.h"
365796c8dcSSimon Schubert 
375796c8dcSSimon Schubert #include "dwarf2.h"
385796c8dcSSimon Schubert #include "dwarf2expr.h"
395796c8dcSSimon Schubert #include "dwarf2loc.h"
405796c8dcSSimon Schubert #include "dwarf2-frame.h"
415796c8dcSSimon Schubert 
425796c8dcSSimon Schubert #include "gdb_string.h"
435796c8dcSSimon Schubert #include "gdb_assert.h"
445796c8dcSSimon Schubert 
45*ef5ccd6cSJohn Marino DEF_VEC_I(int);
46*ef5ccd6cSJohn Marino 
47cf7f2e2dSJohn Marino extern int dwarf2_always_disassemble;
48cf7f2e2dSJohn Marino 
49a45ae5f8SJohn Marino static void dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
50cf7f2e2dSJohn Marino 				     const gdb_byte **start, size_t *length);
51cf7f2e2dSJohn Marino 
52a45ae5f8SJohn Marino static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
53a45ae5f8SJohn Marino 
54a45ae5f8SJohn Marino static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
55a45ae5f8SJohn Marino 						    struct frame_info *frame,
56a45ae5f8SJohn Marino 						    const gdb_byte *data,
57*ef5ccd6cSJohn Marino 						    size_t size,
58c50c785cSJohn Marino 						    struct dwarf2_per_cu_data *per_cu,
59c50c785cSJohn Marino 						    LONGEST byte_offset);
60c50c785cSJohn Marino 
61*ef5ccd6cSJohn Marino /* Until these have formal names, we define these here.
62*ef5ccd6cSJohn Marino    ref: http://gcc.gnu.org/wiki/DebugFission
63*ef5ccd6cSJohn Marino    Each entry in .debug_loc.dwo begins with a byte that describes the entry,
64*ef5ccd6cSJohn Marino    and is then followed by data specific to that entry.  */
65*ef5ccd6cSJohn Marino 
66*ef5ccd6cSJohn Marino enum debug_loc_kind
67*ef5ccd6cSJohn Marino {
68*ef5ccd6cSJohn Marino   /* Indicates the end of the list of entries.  */
69*ef5ccd6cSJohn Marino   DEBUG_LOC_END_OF_LIST = 0,
70*ef5ccd6cSJohn Marino 
71*ef5ccd6cSJohn Marino   /* This is followed by an unsigned LEB128 number that is an index into
72*ef5ccd6cSJohn Marino      .debug_addr and specifies the base address for all following entries.  */
73*ef5ccd6cSJohn Marino   DEBUG_LOC_BASE_ADDRESS = 1,
74*ef5ccd6cSJohn Marino 
75*ef5ccd6cSJohn Marino   /* This is followed by two unsigned LEB128 numbers that are indices into
76*ef5ccd6cSJohn Marino      .debug_addr and specify the beginning and ending addresses, and then
77*ef5ccd6cSJohn Marino      a normal location expression as in .debug_loc.  */
78*ef5ccd6cSJohn Marino   DEBUG_LOC_START_END = 2,
79*ef5ccd6cSJohn Marino 
80*ef5ccd6cSJohn Marino   /* This is followed by an unsigned LEB128 number that is an index into
81*ef5ccd6cSJohn Marino      .debug_addr and specifies the beginning address, and a 4 byte unsigned
82*ef5ccd6cSJohn Marino      number that specifies the length, and then a normal location expression
83*ef5ccd6cSJohn Marino      as in .debug_loc.  */
84*ef5ccd6cSJohn Marino   DEBUG_LOC_START_LENGTH = 3,
85*ef5ccd6cSJohn Marino 
86*ef5ccd6cSJohn Marino   /* An internal value indicating there is insufficient data.  */
87*ef5ccd6cSJohn Marino   DEBUG_LOC_BUFFER_OVERFLOW = -1,
88*ef5ccd6cSJohn Marino 
89*ef5ccd6cSJohn Marino   /* An internal value indicating an invalid kind of entry was found.  */
90*ef5ccd6cSJohn Marino   DEBUG_LOC_INVALID_ENTRY = -2
91*ef5ccd6cSJohn Marino };
92*ef5ccd6cSJohn Marino 
93*ef5ccd6cSJohn Marino /* Decode the addresses in a non-dwo .debug_loc entry.
94*ef5ccd6cSJohn Marino    A pointer to the next byte to examine is returned in *NEW_PTR.
95*ef5ccd6cSJohn Marino    The encoded low,high addresses are return in *LOW,*HIGH.
96*ef5ccd6cSJohn Marino    The result indicates the kind of entry found.  */
97*ef5ccd6cSJohn Marino 
98*ef5ccd6cSJohn Marino static enum debug_loc_kind
decode_debug_loc_addresses(const gdb_byte * loc_ptr,const gdb_byte * buf_end,const gdb_byte ** new_ptr,CORE_ADDR * low,CORE_ADDR * high,enum bfd_endian byte_order,unsigned int addr_size,int signed_addr_p)99*ef5ccd6cSJohn Marino decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
100*ef5ccd6cSJohn Marino 			    const gdb_byte **new_ptr,
101*ef5ccd6cSJohn Marino 			    CORE_ADDR *low, CORE_ADDR *high,
102*ef5ccd6cSJohn Marino 			    enum bfd_endian byte_order,
103*ef5ccd6cSJohn Marino 			    unsigned int addr_size,
104*ef5ccd6cSJohn Marino 			    int signed_addr_p)
105*ef5ccd6cSJohn Marino {
106*ef5ccd6cSJohn Marino   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
107*ef5ccd6cSJohn Marino 
108*ef5ccd6cSJohn Marino   if (buf_end - loc_ptr < 2 * addr_size)
109*ef5ccd6cSJohn Marino     return DEBUG_LOC_BUFFER_OVERFLOW;
110*ef5ccd6cSJohn Marino 
111*ef5ccd6cSJohn Marino   if (signed_addr_p)
112*ef5ccd6cSJohn Marino     *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
113*ef5ccd6cSJohn Marino   else
114*ef5ccd6cSJohn Marino     *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
115*ef5ccd6cSJohn Marino   loc_ptr += addr_size;
116*ef5ccd6cSJohn Marino 
117*ef5ccd6cSJohn Marino   if (signed_addr_p)
118*ef5ccd6cSJohn Marino     *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
119*ef5ccd6cSJohn Marino   else
120*ef5ccd6cSJohn Marino     *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
121*ef5ccd6cSJohn Marino   loc_ptr += addr_size;
122*ef5ccd6cSJohn Marino 
123*ef5ccd6cSJohn Marino   *new_ptr = loc_ptr;
124*ef5ccd6cSJohn Marino 
125*ef5ccd6cSJohn Marino   /* A base-address-selection entry.  */
126*ef5ccd6cSJohn Marino   if ((*low & base_mask) == base_mask)
127*ef5ccd6cSJohn Marino     return DEBUG_LOC_BASE_ADDRESS;
128*ef5ccd6cSJohn Marino 
129*ef5ccd6cSJohn Marino   /* An end-of-list entry.  */
130*ef5ccd6cSJohn Marino   if (*low == 0 && *high == 0)
131*ef5ccd6cSJohn Marino     return DEBUG_LOC_END_OF_LIST;
132*ef5ccd6cSJohn Marino 
133*ef5ccd6cSJohn Marino   return DEBUG_LOC_START_END;
134*ef5ccd6cSJohn Marino }
135*ef5ccd6cSJohn Marino 
136*ef5ccd6cSJohn Marino /* Decode the addresses in .debug_loc.dwo entry.
137*ef5ccd6cSJohn Marino    A pointer to the next byte to examine is returned in *NEW_PTR.
138*ef5ccd6cSJohn Marino    The encoded low,high addresses are return in *LOW,*HIGH.
139*ef5ccd6cSJohn Marino    The result indicates the kind of entry found.  */
140*ef5ccd6cSJohn Marino 
141*ef5ccd6cSJohn Marino static enum debug_loc_kind
decode_debug_loc_dwo_addresses(struct dwarf2_per_cu_data * per_cu,const gdb_byte * loc_ptr,const gdb_byte * buf_end,const gdb_byte ** new_ptr,CORE_ADDR * low,CORE_ADDR * high,enum bfd_endian byte_order)142*ef5ccd6cSJohn Marino decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
143*ef5ccd6cSJohn Marino 				const gdb_byte *loc_ptr,
144*ef5ccd6cSJohn Marino 				const gdb_byte *buf_end,
145*ef5ccd6cSJohn Marino 				const gdb_byte **new_ptr,
146*ef5ccd6cSJohn Marino 				CORE_ADDR *low, CORE_ADDR *high,
147*ef5ccd6cSJohn Marino 				enum bfd_endian byte_order)
148*ef5ccd6cSJohn Marino {
149*ef5ccd6cSJohn Marino   uint64_t low_index, high_index;
150*ef5ccd6cSJohn Marino 
151*ef5ccd6cSJohn Marino   if (loc_ptr == buf_end)
152*ef5ccd6cSJohn Marino     return DEBUG_LOC_BUFFER_OVERFLOW;
153*ef5ccd6cSJohn Marino 
154*ef5ccd6cSJohn Marino   switch (*loc_ptr++)
155*ef5ccd6cSJohn Marino     {
156*ef5ccd6cSJohn Marino     case DEBUG_LOC_END_OF_LIST:
157*ef5ccd6cSJohn Marino       *new_ptr = loc_ptr;
158*ef5ccd6cSJohn Marino       return DEBUG_LOC_END_OF_LIST;
159*ef5ccd6cSJohn Marino     case DEBUG_LOC_BASE_ADDRESS:
160*ef5ccd6cSJohn Marino       *low = 0;
161*ef5ccd6cSJohn Marino       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
162*ef5ccd6cSJohn Marino       if (loc_ptr == NULL)
163*ef5ccd6cSJohn Marino 	return DEBUG_LOC_BUFFER_OVERFLOW;
164*ef5ccd6cSJohn Marino       *high = dwarf2_read_addr_index (per_cu, high_index);
165*ef5ccd6cSJohn Marino       *new_ptr = loc_ptr;
166*ef5ccd6cSJohn Marino       return DEBUG_LOC_BASE_ADDRESS;
167*ef5ccd6cSJohn Marino     case DEBUG_LOC_START_END:
168*ef5ccd6cSJohn Marino       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
169*ef5ccd6cSJohn Marino       if (loc_ptr == NULL)
170*ef5ccd6cSJohn Marino 	return DEBUG_LOC_BUFFER_OVERFLOW;
171*ef5ccd6cSJohn Marino       *low = dwarf2_read_addr_index (per_cu, low_index);
172*ef5ccd6cSJohn Marino       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
173*ef5ccd6cSJohn Marino       if (loc_ptr == NULL)
174*ef5ccd6cSJohn Marino 	return DEBUG_LOC_BUFFER_OVERFLOW;
175*ef5ccd6cSJohn Marino       *high = dwarf2_read_addr_index (per_cu, high_index);
176*ef5ccd6cSJohn Marino       *new_ptr = loc_ptr;
177*ef5ccd6cSJohn Marino       return DEBUG_LOC_START_END;
178*ef5ccd6cSJohn Marino     case DEBUG_LOC_START_LENGTH:
179*ef5ccd6cSJohn Marino       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
180*ef5ccd6cSJohn Marino       if (loc_ptr == NULL)
181*ef5ccd6cSJohn Marino 	return DEBUG_LOC_BUFFER_OVERFLOW;
182*ef5ccd6cSJohn Marino       *low = dwarf2_read_addr_index (per_cu, low_index);
183*ef5ccd6cSJohn Marino       if (loc_ptr + 4 > buf_end)
184*ef5ccd6cSJohn Marino 	return DEBUG_LOC_BUFFER_OVERFLOW;
185*ef5ccd6cSJohn Marino       *high = *low;
186*ef5ccd6cSJohn Marino       *high += extract_unsigned_integer (loc_ptr, 4, byte_order);
187*ef5ccd6cSJohn Marino       *new_ptr = loc_ptr + 4;
188*ef5ccd6cSJohn Marino       return DEBUG_LOC_START_LENGTH;
189*ef5ccd6cSJohn Marino     default:
190*ef5ccd6cSJohn Marino       return DEBUG_LOC_INVALID_ENTRY;
191*ef5ccd6cSJohn Marino     }
192*ef5ccd6cSJohn Marino }
193*ef5ccd6cSJohn Marino 
194c50c785cSJohn Marino /* A function for dealing with location lists.  Given a
1955796c8dcSSimon Schubert    symbol baton (BATON) and a pc value (PC), find the appropriate
1965796c8dcSSimon Schubert    location expression, set *LOCEXPR_LENGTH, and return a pointer
1975796c8dcSSimon Schubert    to the beginning of the expression.  Returns NULL on failure.
1985796c8dcSSimon Schubert 
1995796c8dcSSimon Schubert    For now, only return the first matching location expression; there
2005796c8dcSSimon Schubert    can be more than one in the list.  */
2015796c8dcSSimon Schubert 
202c50c785cSJohn Marino const gdb_byte *
dwarf2_find_location_expression(struct dwarf2_loclist_baton * baton,size_t * locexpr_length,CORE_ADDR pc)203c50c785cSJohn Marino dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
2045796c8dcSSimon Schubert 				 size_t *locexpr_length, CORE_ADDR pc)
2055796c8dcSSimon Schubert {
2065796c8dcSSimon Schubert   struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
2075796c8dcSSimon Schubert   struct gdbarch *gdbarch = get_objfile_arch (objfile);
2085796c8dcSSimon Schubert   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2095796c8dcSSimon Schubert   unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
210cf7f2e2dSJohn Marino   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
2115796c8dcSSimon Schubert   /* Adjust base_address for relocatable objects.  */
212cf7f2e2dSJohn Marino   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
2135796c8dcSSimon Schubert   CORE_ADDR base_address = baton->base_address + base_offset;
214*ef5ccd6cSJohn Marino   const gdb_byte *loc_ptr, *buf_end;
2155796c8dcSSimon Schubert 
2165796c8dcSSimon Schubert   loc_ptr = baton->data;
2175796c8dcSSimon Schubert   buf_end = baton->data + baton->size;
2185796c8dcSSimon Schubert 
2195796c8dcSSimon Schubert   while (1)
2205796c8dcSSimon Schubert     {
221*ef5ccd6cSJohn Marino       CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
222*ef5ccd6cSJohn Marino       int length;
223*ef5ccd6cSJohn Marino       enum debug_loc_kind kind;
224*ef5ccd6cSJohn Marino       const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
2255796c8dcSSimon Schubert 
226*ef5ccd6cSJohn Marino       if (baton->from_dwo)
227*ef5ccd6cSJohn Marino 	kind = decode_debug_loc_dwo_addresses (baton->per_cu,
228*ef5ccd6cSJohn Marino 					       loc_ptr, buf_end, &new_ptr,
229*ef5ccd6cSJohn Marino 					       &low, &high, byte_order);
230cf7f2e2dSJohn Marino       else
231*ef5ccd6cSJohn Marino 	kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
232*ef5ccd6cSJohn Marino 					   &low, &high,
233*ef5ccd6cSJohn Marino 					   byte_order, addr_size,
234*ef5ccd6cSJohn Marino 					   signed_addr_p);
235*ef5ccd6cSJohn Marino       loc_ptr = new_ptr;
236*ef5ccd6cSJohn Marino       switch (kind)
237cf7f2e2dSJohn Marino 	{
238*ef5ccd6cSJohn Marino 	case DEBUG_LOC_END_OF_LIST:
239a45ae5f8SJohn Marino 	  *locexpr_length = 0;
2405796c8dcSSimon Schubert 	  return NULL;
241*ef5ccd6cSJohn Marino 	case DEBUG_LOC_BASE_ADDRESS:
242*ef5ccd6cSJohn Marino 	  base_address = high + base_offset;
243*ef5ccd6cSJohn Marino 	  continue;
244*ef5ccd6cSJohn Marino 	case DEBUG_LOC_START_END:
245*ef5ccd6cSJohn Marino 	case DEBUG_LOC_START_LENGTH:
246*ef5ccd6cSJohn Marino 	  break;
247*ef5ccd6cSJohn Marino 	case DEBUG_LOC_BUFFER_OVERFLOW:
248*ef5ccd6cSJohn Marino 	case DEBUG_LOC_INVALID_ENTRY:
249*ef5ccd6cSJohn Marino 	  error (_("dwarf2_find_location_expression: "
250*ef5ccd6cSJohn Marino 		   "Corrupted DWARF expression."));
251*ef5ccd6cSJohn Marino 	default:
252*ef5ccd6cSJohn Marino 	  gdb_assert_not_reached ("bad debug_loc_kind");
253a45ae5f8SJohn Marino 	}
2545796c8dcSSimon Schubert 
255*ef5ccd6cSJohn Marino       /* Otherwise, a location expression entry.
256*ef5ccd6cSJohn Marino 	 If the entry is from a DWO, don't add base address: the entry is
257*ef5ccd6cSJohn Marino 	 from .debug_addr which has absolute addresses.  */
258*ef5ccd6cSJohn Marino       if (! baton->from_dwo)
259*ef5ccd6cSJohn Marino 	{
2605796c8dcSSimon Schubert 	  low += base_address;
2615796c8dcSSimon Schubert 	  high += base_address;
262*ef5ccd6cSJohn Marino 	}
2635796c8dcSSimon Schubert 
2645796c8dcSSimon Schubert       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
2655796c8dcSSimon Schubert       loc_ptr += 2;
2665796c8dcSSimon Schubert 
267a45ae5f8SJohn Marino       if (low == high && pc == low)
268a45ae5f8SJohn Marino 	{
269a45ae5f8SJohn Marino 	  /* This is entry PC record present only at entry point
270a45ae5f8SJohn Marino 	     of a function.  Verify it is really the function entry point.  */
271a45ae5f8SJohn Marino 
272a45ae5f8SJohn Marino 	  struct block *pc_block = block_for_pc (pc);
273a45ae5f8SJohn Marino 	  struct symbol *pc_func = NULL;
274a45ae5f8SJohn Marino 
275a45ae5f8SJohn Marino 	  if (pc_block)
276a45ae5f8SJohn Marino 	    pc_func = block_linkage_function (pc_block);
277a45ae5f8SJohn Marino 
278a45ae5f8SJohn Marino 	  if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
279a45ae5f8SJohn Marino 	    {
280a45ae5f8SJohn Marino 	      *locexpr_length = length;
281a45ae5f8SJohn Marino 	      return loc_ptr;
282a45ae5f8SJohn Marino 	    }
283a45ae5f8SJohn Marino 	}
284a45ae5f8SJohn Marino 
2855796c8dcSSimon Schubert       if (pc >= low && pc < high)
2865796c8dcSSimon Schubert 	{
2875796c8dcSSimon Schubert 	  *locexpr_length = length;
2885796c8dcSSimon Schubert 	  return loc_ptr;
2895796c8dcSSimon Schubert 	}
2905796c8dcSSimon Schubert 
2915796c8dcSSimon Schubert       loc_ptr += length;
2925796c8dcSSimon Schubert     }
2935796c8dcSSimon Schubert }
2945796c8dcSSimon Schubert 
2955796c8dcSSimon Schubert /* This is the baton used when performing dwarf2 expression
2965796c8dcSSimon Schubert    evaluation.  */
2975796c8dcSSimon Schubert struct dwarf_expr_baton
2985796c8dcSSimon Schubert {
2995796c8dcSSimon Schubert   struct frame_info *frame;
300cf7f2e2dSJohn Marino   struct dwarf2_per_cu_data *per_cu;
3015796c8dcSSimon Schubert };
3025796c8dcSSimon Schubert 
3035796c8dcSSimon Schubert /* Helper functions for dwarf2_evaluate_loc_desc.  */
3045796c8dcSSimon Schubert 
3055796c8dcSSimon Schubert /* Using the frame specified in BATON, return the value of register
3065796c8dcSSimon Schubert    REGNUM, treated as a pointer.  */
3075796c8dcSSimon Schubert static CORE_ADDR
dwarf_expr_read_reg(void * baton,int dwarf_regnum)3085796c8dcSSimon Schubert dwarf_expr_read_reg (void *baton, int dwarf_regnum)
3095796c8dcSSimon Schubert {
3105796c8dcSSimon Schubert   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
3115796c8dcSSimon Schubert   struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
3125796c8dcSSimon Schubert   CORE_ADDR result;
3135796c8dcSSimon Schubert   int regnum;
3145796c8dcSSimon Schubert 
3155796c8dcSSimon Schubert   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3165796c8dcSSimon Schubert   result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
3175796c8dcSSimon Schubert 				  regnum, debaton->frame);
3185796c8dcSSimon Schubert   return result;
3195796c8dcSSimon Schubert }
3205796c8dcSSimon Schubert 
3215796c8dcSSimon Schubert /* Read memory at ADDR (length LEN) into BUF.  */
3225796c8dcSSimon Schubert 
3235796c8dcSSimon Schubert static void
dwarf_expr_read_mem(void * baton,gdb_byte * buf,CORE_ADDR addr,size_t len)3245796c8dcSSimon Schubert dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
3255796c8dcSSimon Schubert {
3265796c8dcSSimon Schubert   read_memory (addr, buf, len);
3275796c8dcSSimon Schubert }
3285796c8dcSSimon Schubert 
3295796c8dcSSimon Schubert /* Using the frame specified in BATON, find the location expression
3305796c8dcSSimon Schubert    describing the frame base.  Return a pointer to it in START and
3315796c8dcSSimon Schubert    its length in LENGTH.  */
3325796c8dcSSimon Schubert static void
dwarf_expr_frame_base(void * baton,const gdb_byte ** start,size_t * length)333cf7f2e2dSJohn Marino dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
3345796c8dcSSimon Schubert {
3355796c8dcSSimon Schubert   /* FIXME: cagney/2003-03-26: This code should be using
3365796c8dcSSimon Schubert      get_frame_base_address(), and then implement a dwarf2 specific
3375796c8dcSSimon Schubert      this_base method.  */
3385796c8dcSSimon Schubert   struct symbol *framefunc;
3395796c8dcSSimon Schubert   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
340*ef5ccd6cSJohn Marino   struct block *bl = get_frame_block (debaton->frame, NULL);
341*ef5ccd6cSJohn Marino 
342*ef5ccd6cSJohn Marino   if (bl == NULL)
343*ef5ccd6cSJohn Marino     error (_("frame address is not available."));
3445796c8dcSSimon Schubert 
3455796c8dcSSimon Schubert   /* Use block_linkage_function, which returns a real (not inlined)
3465796c8dcSSimon Schubert      function, instead of get_frame_function, which may return an
3475796c8dcSSimon Schubert      inlined function.  */
348*ef5ccd6cSJohn Marino   framefunc = block_linkage_function (bl);
3495796c8dcSSimon Schubert 
3505796c8dcSSimon Schubert   /* If we found a frame-relative symbol then it was certainly within
3515796c8dcSSimon Schubert      some function associated with a frame. If we can't find the frame,
3525796c8dcSSimon Schubert      something has gone wrong.  */
3535796c8dcSSimon Schubert   gdb_assert (framefunc != NULL);
3545796c8dcSSimon Schubert 
355cf7f2e2dSJohn Marino   dwarf_expr_frame_base_1 (framefunc,
356cf7f2e2dSJohn Marino 			   get_frame_address_in_block (debaton->frame),
357cf7f2e2dSJohn Marino 			   start, length);
358cf7f2e2dSJohn Marino }
359cf7f2e2dSJohn Marino 
360cf7f2e2dSJohn Marino static void
dwarf_expr_frame_base_1(struct symbol * framefunc,CORE_ADDR pc,const gdb_byte ** start,size_t * length)361cf7f2e2dSJohn Marino dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
362cf7f2e2dSJohn Marino 			 const gdb_byte **start, size_t *length)
363cf7f2e2dSJohn Marino {
3645796c8dcSSimon Schubert   if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
365a45ae5f8SJohn Marino     *length = 0;
3665796c8dcSSimon Schubert   else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
3675796c8dcSSimon Schubert     {
3685796c8dcSSimon Schubert       struct dwarf2_loclist_baton *symbaton;
3695796c8dcSSimon Schubert 
3705796c8dcSSimon Schubert       symbaton = SYMBOL_LOCATION_BATON (framefunc);
371c50c785cSJohn Marino       *start = dwarf2_find_location_expression (symbaton, length, pc);
3725796c8dcSSimon Schubert     }
3735796c8dcSSimon Schubert   else
3745796c8dcSSimon Schubert     {
3755796c8dcSSimon Schubert       struct dwarf2_locexpr_baton *symbaton;
376cf7f2e2dSJohn Marino 
3775796c8dcSSimon Schubert       symbaton = SYMBOL_LOCATION_BATON (framefunc);
3785796c8dcSSimon Schubert       if (symbaton != NULL)
3795796c8dcSSimon Schubert 	{
3805796c8dcSSimon Schubert 	  *length = symbaton->size;
3815796c8dcSSimon Schubert 	  *start = symbaton->data;
3825796c8dcSSimon Schubert 	}
3835796c8dcSSimon Schubert       else
384a45ae5f8SJohn Marino 	*length = 0;
3855796c8dcSSimon Schubert     }
3865796c8dcSSimon Schubert 
387a45ae5f8SJohn Marino   if (*length == 0)
3885796c8dcSSimon Schubert     error (_("Could not find the frame base for \"%s\"."),
3895796c8dcSSimon Schubert 	   SYMBOL_NATURAL_NAME (framefunc));
3905796c8dcSSimon Schubert }
3915796c8dcSSimon Schubert 
3925796c8dcSSimon Schubert /* Helper function for dwarf2_evaluate_loc_desc.  Computes the CFA for
3935796c8dcSSimon Schubert    the frame in BATON.  */
3945796c8dcSSimon Schubert 
3955796c8dcSSimon Schubert static CORE_ADDR
dwarf_expr_frame_cfa(void * baton)3965796c8dcSSimon Schubert dwarf_expr_frame_cfa (void *baton)
3975796c8dcSSimon Schubert {
3985796c8dcSSimon Schubert   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
399cf7f2e2dSJohn Marino 
4005796c8dcSSimon Schubert   return dwarf2_frame_cfa (debaton->frame);
4015796c8dcSSimon Schubert }
4025796c8dcSSimon Schubert 
403c50c785cSJohn Marino /* Helper function for dwarf2_evaluate_loc_desc.  Computes the PC for
404c50c785cSJohn Marino    the frame in BATON.  */
405c50c785cSJohn Marino 
406c50c785cSJohn Marino static CORE_ADDR
dwarf_expr_frame_pc(void * baton)407c50c785cSJohn Marino dwarf_expr_frame_pc (void *baton)
408c50c785cSJohn Marino {
409c50c785cSJohn Marino   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
410c50c785cSJohn Marino 
411c50c785cSJohn Marino   return get_frame_address_in_block (debaton->frame);
412c50c785cSJohn Marino }
413c50c785cSJohn Marino 
4145796c8dcSSimon Schubert /* Using the objfile specified in BATON, find the address for the
4155796c8dcSSimon Schubert    current thread's thread-local storage with offset OFFSET.  */
4165796c8dcSSimon Schubert static CORE_ADDR
dwarf_expr_tls_address(void * baton,CORE_ADDR offset)4175796c8dcSSimon Schubert dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
4185796c8dcSSimon Schubert {
4195796c8dcSSimon Schubert   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
420cf7f2e2dSJohn Marino   struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
4215796c8dcSSimon Schubert 
422cf7f2e2dSJohn Marino   return target_translate_tls_address (objfile, offset);
423cf7f2e2dSJohn Marino }
424cf7f2e2dSJohn Marino 
425c50c785cSJohn Marino /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
426c50c785cSJohn Marino    current CU (as is PER_CU).  State of the CTX is not affected by the
427c50c785cSJohn Marino    call and return.  */
428cf7f2e2dSJohn Marino 
429cf7f2e2dSJohn Marino static void
per_cu_dwarf_call(struct dwarf_expr_context * ctx,cu_offset die_offset,struct dwarf2_per_cu_data * per_cu,CORE_ADDR (* get_frame_pc)(void * baton),void * baton)430*ef5ccd6cSJohn Marino per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
431c50c785cSJohn Marino 		   struct dwarf2_per_cu_data *per_cu,
432c50c785cSJohn Marino 		   CORE_ADDR (*get_frame_pc) (void *baton),
433c50c785cSJohn Marino 		   void *baton)
434cf7f2e2dSJohn Marino {
435cf7f2e2dSJohn Marino   struct dwarf2_locexpr_baton block;
436cf7f2e2dSJohn Marino 
437*ef5ccd6cSJohn Marino   block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, get_frame_pc, baton);
438cf7f2e2dSJohn Marino 
439cf7f2e2dSJohn Marino   /* DW_OP_call_ref is currently not supported.  */
440cf7f2e2dSJohn Marino   gdb_assert (block.per_cu == per_cu);
441cf7f2e2dSJohn Marino 
442cf7f2e2dSJohn Marino   dwarf_expr_eval (ctx, block.data, block.size);
443cf7f2e2dSJohn Marino }
444cf7f2e2dSJohn Marino 
445cf7f2e2dSJohn Marino /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc.  */
446cf7f2e2dSJohn Marino 
447cf7f2e2dSJohn Marino static void
dwarf_expr_dwarf_call(struct dwarf_expr_context * ctx,cu_offset die_offset)448*ef5ccd6cSJohn Marino dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
449cf7f2e2dSJohn Marino {
450cf7f2e2dSJohn Marino   struct dwarf_expr_baton *debaton = ctx->baton;
451cf7f2e2dSJohn Marino 
452c50c785cSJohn Marino   per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
453a45ae5f8SJohn Marino 		     ctx->funcs->get_frame_pc, ctx->baton);
454a45ae5f8SJohn Marino }
455a45ae5f8SJohn Marino 
456a45ae5f8SJohn Marino /* Callback function for dwarf2_evaluate_loc_desc.  */
457a45ae5f8SJohn Marino 
458a45ae5f8SJohn Marino static struct type *
dwarf_expr_get_base_type(struct dwarf_expr_context * ctx,cu_offset die_offset)459*ef5ccd6cSJohn Marino dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
460*ef5ccd6cSJohn Marino 			  cu_offset die_offset)
461a45ae5f8SJohn Marino {
462a45ae5f8SJohn Marino   struct dwarf_expr_baton *debaton = ctx->baton;
463a45ae5f8SJohn Marino 
464a45ae5f8SJohn Marino   return dwarf2_get_die_type (die_offset, debaton->per_cu);
465a45ae5f8SJohn Marino }
466a45ae5f8SJohn Marino 
467a45ae5f8SJohn Marino /* See dwarf2loc.h.  */
468a45ae5f8SJohn Marino 
469*ef5ccd6cSJohn Marino unsigned int entry_values_debug = 0;
470a45ae5f8SJohn Marino 
471a45ae5f8SJohn Marino /* Helper to set entry_values_debug.  */
472a45ae5f8SJohn Marino 
473a45ae5f8SJohn Marino static void
show_entry_values_debug(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)474a45ae5f8SJohn Marino show_entry_values_debug (struct ui_file *file, int from_tty,
475a45ae5f8SJohn Marino 			 struct cmd_list_element *c, const char *value)
476a45ae5f8SJohn Marino {
477a45ae5f8SJohn Marino   fprintf_filtered (file,
478a45ae5f8SJohn Marino 		    _("Entry values and tail call frames debugging is %s.\n"),
479a45ae5f8SJohn Marino 		    value);
480a45ae5f8SJohn Marino }
481a45ae5f8SJohn Marino 
482a45ae5f8SJohn Marino /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
483a45ae5f8SJohn Marino    CALLER_FRAME (for registers) can be NULL if it is not known.  This function
484a45ae5f8SJohn Marino    always returns valid address or it throws NO_ENTRY_VALUE_ERROR.  */
485a45ae5f8SJohn Marino 
486a45ae5f8SJohn Marino static CORE_ADDR
call_site_to_target_addr(struct gdbarch * call_site_gdbarch,struct call_site * call_site,struct frame_info * caller_frame)487a45ae5f8SJohn Marino call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
488a45ae5f8SJohn Marino 			  struct call_site *call_site,
489a45ae5f8SJohn Marino 			  struct frame_info *caller_frame)
490a45ae5f8SJohn Marino {
491a45ae5f8SJohn Marino   switch (FIELD_LOC_KIND (call_site->target))
492a45ae5f8SJohn Marino     {
493a45ae5f8SJohn Marino     case FIELD_LOC_KIND_DWARF_BLOCK:
494a45ae5f8SJohn Marino       {
495a45ae5f8SJohn Marino 	struct dwarf2_locexpr_baton *dwarf_block;
496a45ae5f8SJohn Marino 	struct value *val;
497a45ae5f8SJohn Marino 	struct type *caller_core_addr_type;
498a45ae5f8SJohn Marino 	struct gdbarch *caller_arch;
499a45ae5f8SJohn Marino 
500a45ae5f8SJohn Marino 	dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
501a45ae5f8SJohn Marino 	if (dwarf_block == NULL)
502a45ae5f8SJohn Marino 	  {
503a45ae5f8SJohn Marino 	    struct minimal_symbol *msym;
504a45ae5f8SJohn Marino 
505a45ae5f8SJohn Marino 	    msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
506a45ae5f8SJohn Marino 	    throw_error (NO_ENTRY_VALUE_ERROR,
507a45ae5f8SJohn Marino 			 _("DW_AT_GNU_call_site_target is not specified "
508a45ae5f8SJohn Marino 			   "at %s in %s"),
509a45ae5f8SJohn Marino 			 paddress (call_site_gdbarch, call_site->pc),
510a45ae5f8SJohn Marino 			 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
511a45ae5f8SJohn Marino 
512a45ae5f8SJohn Marino 	  }
513a45ae5f8SJohn Marino 	if (caller_frame == NULL)
514a45ae5f8SJohn Marino 	  {
515a45ae5f8SJohn Marino 	    struct minimal_symbol *msym;
516a45ae5f8SJohn Marino 
517a45ae5f8SJohn Marino 	    msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
518a45ae5f8SJohn Marino 	    throw_error (NO_ENTRY_VALUE_ERROR,
519a45ae5f8SJohn Marino 			 _("DW_AT_GNU_call_site_target DWARF block resolving "
520a45ae5f8SJohn Marino 			   "requires known frame which is currently not "
521a45ae5f8SJohn Marino 			   "available at %s in %s"),
522a45ae5f8SJohn Marino 			 paddress (call_site_gdbarch, call_site->pc),
523a45ae5f8SJohn Marino 			 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
524a45ae5f8SJohn Marino 
525a45ae5f8SJohn Marino 	  }
526a45ae5f8SJohn Marino 	caller_arch = get_frame_arch (caller_frame);
527a45ae5f8SJohn Marino 	caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
528a45ae5f8SJohn Marino 	val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
529a45ae5f8SJohn Marino 					dwarf_block->data, dwarf_block->size,
530a45ae5f8SJohn Marino 					dwarf_block->per_cu);
531a45ae5f8SJohn Marino 	/* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
532a45ae5f8SJohn Marino 	   location.  */
533a45ae5f8SJohn Marino 	if (VALUE_LVAL (val) == lval_memory)
534a45ae5f8SJohn Marino 	  return value_address (val);
535a45ae5f8SJohn Marino 	else
536a45ae5f8SJohn Marino 	  return value_as_address (val);
537a45ae5f8SJohn Marino       }
538a45ae5f8SJohn Marino 
539a45ae5f8SJohn Marino     case FIELD_LOC_KIND_PHYSNAME:
540a45ae5f8SJohn Marino       {
541a45ae5f8SJohn Marino 	const char *physname;
542a45ae5f8SJohn Marino 	struct minimal_symbol *msym;
543a45ae5f8SJohn Marino 
544a45ae5f8SJohn Marino 	physname = FIELD_STATIC_PHYSNAME (call_site->target);
545*ef5ccd6cSJohn Marino 
546*ef5ccd6cSJohn Marino 	/* Handle both the mangled and demangled PHYSNAME.  */
547*ef5ccd6cSJohn Marino 	msym = lookup_minimal_symbol (physname, NULL, NULL);
548a45ae5f8SJohn Marino 	if (msym == NULL)
549a45ae5f8SJohn Marino 	  {
550a45ae5f8SJohn Marino 	    msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
551a45ae5f8SJohn Marino 	    throw_error (NO_ENTRY_VALUE_ERROR,
552a45ae5f8SJohn Marino 			 _("Cannot find function \"%s\" for a call site target "
553a45ae5f8SJohn Marino 			   "at %s in %s"),
554a45ae5f8SJohn Marino 			 physname, paddress (call_site_gdbarch, call_site->pc),
555a45ae5f8SJohn Marino 			 msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
556a45ae5f8SJohn Marino 
557a45ae5f8SJohn Marino 	  }
558a45ae5f8SJohn Marino 	return SYMBOL_VALUE_ADDRESS (msym);
559a45ae5f8SJohn Marino       }
560a45ae5f8SJohn Marino 
561a45ae5f8SJohn Marino     case FIELD_LOC_KIND_PHYSADDR:
562a45ae5f8SJohn Marino       return FIELD_STATIC_PHYSADDR (call_site->target);
563a45ae5f8SJohn Marino 
564a45ae5f8SJohn Marino     default:
565a45ae5f8SJohn Marino       internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
566a45ae5f8SJohn Marino     }
567a45ae5f8SJohn Marino }
568a45ae5f8SJohn Marino 
569a45ae5f8SJohn Marino /* Convert function entry point exact address ADDR to the function which is
570a45ae5f8SJohn Marino    compliant with TAIL_CALL_LIST_COMPLETE condition.  Throw
571a45ae5f8SJohn Marino    NO_ENTRY_VALUE_ERROR otherwise.  */
572a45ae5f8SJohn Marino 
573a45ae5f8SJohn Marino static struct symbol *
func_addr_to_tail_call_list(struct gdbarch * gdbarch,CORE_ADDR addr)574a45ae5f8SJohn Marino func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
575a45ae5f8SJohn Marino {
576a45ae5f8SJohn Marino   struct symbol *sym = find_pc_function (addr);
577a45ae5f8SJohn Marino   struct type *type;
578a45ae5f8SJohn Marino 
579a45ae5f8SJohn Marino   if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
580a45ae5f8SJohn Marino     throw_error (NO_ENTRY_VALUE_ERROR,
581a45ae5f8SJohn Marino 		 _("DW_TAG_GNU_call_site resolving failed to find function "
582a45ae5f8SJohn Marino 		   "name for address %s"),
583a45ae5f8SJohn Marino 		 paddress (gdbarch, addr));
584a45ae5f8SJohn Marino 
585a45ae5f8SJohn Marino   type = SYMBOL_TYPE (sym);
586a45ae5f8SJohn Marino   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
587a45ae5f8SJohn Marino   gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
588a45ae5f8SJohn Marino 
589a45ae5f8SJohn Marino   return sym;
590a45ae5f8SJohn Marino }
591a45ae5f8SJohn Marino 
592a45ae5f8SJohn Marino /* Verify function with entry point exact address ADDR can never call itself
593a45ae5f8SJohn Marino    via its tail calls (incl. transitively).  Throw NO_ENTRY_VALUE_ERROR if it
594a45ae5f8SJohn Marino    can call itself via tail calls.
595a45ae5f8SJohn Marino 
596a45ae5f8SJohn Marino    If a funtion can tail call itself its entry value based parameters are
597a45ae5f8SJohn Marino    unreliable.  There is no verification whether the value of some/all
598a45ae5f8SJohn Marino    parameters is unchanged through the self tail call, we expect if there is
599a45ae5f8SJohn Marino    a self tail call all the parameters can be modified.  */
600a45ae5f8SJohn Marino 
601a45ae5f8SJohn Marino static void
func_verify_no_selftailcall(struct gdbarch * gdbarch,CORE_ADDR verify_addr)602a45ae5f8SJohn Marino func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
603a45ae5f8SJohn Marino {
604a45ae5f8SJohn Marino   struct obstack addr_obstack;
605a45ae5f8SJohn Marino   struct cleanup *old_chain;
606a45ae5f8SJohn Marino   CORE_ADDR addr;
607a45ae5f8SJohn Marino 
608a45ae5f8SJohn Marino   /* Track here CORE_ADDRs which were already visited.  */
609a45ae5f8SJohn Marino   htab_t addr_hash;
610a45ae5f8SJohn Marino 
611a45ae5f8SJohn Marino   /* The verification is completely unordered.  Track here function addresses
612a45ae5f8SJohn Marino      which still need to be iterated.  */
613a45ae5f8SJohn Marino   VEC (CORE_ADDR) *todo = NULL;
614a45ae5f8SJohn Marino 
615a45ae5f8SJohn Marino   obstack_init (&addr_obstack);
616a45ae5f8SJohn Marino   old_chain = make_cleanup_obstack_free (&addr_obstack);
617a45ae5f8SJohn Marino   addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
618a45ae5f8SJohn Marino 				    &addr_obstack, hashtab_obstack_allocate,
619a45ae5f8SJohn Marino 				    NULL);
620a45ae5f8SJohn Marino   make_cleanup_htab_delete (addr_hash);
621a45ae5f8SJohn Marino 
622a45ae5f8SJohn Marino   make_cleanup (VEC_cleanup (CORE_ADDR), &todo);
623a45ae5f8SJohn Marino 
624a45ae5f8SJohn Marino   VEC_safe_push (CORE_ADDR, todo, verify_addr);
625a45ae5f8SJohn Marino   while (!VEC_empty (CORE_ADDR, todo))
626a45ae5f8SJohn Marino     {
627a45ae5f8SJohn Marino       struct symbol *func_sym;
628a45ae5f8SJohn Marino       struct call_site *call_site;
629a45ae5f8SJohn Marino 
630a45ae5f8SJohn Marino       addr = VEC_pop (CORE_ADDR, todo);
631a45ae5f8SJohn Marino 
632a45ae5f8SJohn Marino       func_sym = func_addr_to_tail_call_list (gdbarch, addr);
633a45ae5f8SJohn Marino 
634a45ae5f8SJohn Marino       for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
635a45ae5f8SJohn Marino 	   call_site; call_site = call_site->tail_call_next)
636a45ae5f8SJohn Marino 	{
637a45ae5f8SJohn Marino 	  CORE_ADDR target_addr;
638a45ae5f8SJohn Marino 	  void **slot;
639a45ae5f8SJohn Marino 
640a45ae5f8SJohn Marino 	  /* CALLER_FRAME with registers is not available for tail-call jumped
641a45ae5f8SJohn Marino 	     frames.  */
642a45ae5f8SJohn Marino 	  target_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
643a45ae5f8SJohn Marino 
644a45ae5f8SJohn Marino 	  if (target_addr == verify_addr)
645a45ae5f8SJohn Marino 	    {
646a45ae5f8SJohn Marino 	      struct minimal_symbol *msym;
647a45ae5f8SJohn Marino 
648a45ae5f8SJohn Marino 	      msym = lookup_minimal_symbol_by_pc (verify_addr);
649a45ae5f8SJohn Marino 	      throw_error (NO_ENTRY_VALUE_ERROR,
650a45ae5f8SJohn Marino 			   _("DW_OP_GNU_entry_value resolving has found "
651a45ae5f8SJohn Marino 			     "function \"%s\" at %s can call itself via tail "
652a45ae5f8SJohn Marino 			     "calls"),
653a45ae5f8SJohn Marino 			   msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym),
654a45ae5f8SJohn Marino 			   paddress (gdbarch, verify_addr));
655a45ae5f8SJohn Marino 	    }
656a45ae5f8SJohn Marino 
657a45ae5f8SJohn Marino 	  slot = htab_find_slot (addr_hash, &target_addr, INSERT);
658a45ae5f8SJohn Marino 	  if (*slot == NULL)
659a45ae5f8SJohn Marino 	    {
660a45ae5f8SJohn Marino 	      *slot = obstack_copy (&addr_obstack, &target_addr,
661a45ae5f8SJohn Marino 				    sizeof (target_addr));
662a45ae5f8SJohn Marino 	      VEC_safe_push (CORE_ADDR, todo, target_addr);
663a45ae5f8SJohn Marino 	    }
664a45ae5f8SJohn Marino 	}
665a45ae5f8SJohn Marino     }
666a45ae5f8SJohn Marino 
667a45ae5f8SJohn Marino   do_cleanups (old_chain);
668a45ae5f8SJohn Marino }
669a45ae5f8SJohn Marino 
670a45ae5f8SJohn Marino /* Print user readable form of CALL_SITE->PC to gdb_stdlog.  Used only for
671a45ae5f8SJohn Marino    ENTRY_VALUES_DEBUG.  */
672a45ae5f8SJohn Marino 
673a45ae5f8SJohn Marino static void
tailcall_dump(struct gdbarch * gdbarch,const struct call_site * call_site)674a45ae5f8SJohn Marino tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
675a45ae5f8SJohn Marino {
676a45ae5f8SJohn Marino   CORE_ADDR addr = call_site->pc;
677a45ae5f8SJohn Marino   struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (addr - 1);
678a45ae5f8SJohn Marino 
679a45ae5f8SJohn Marino   fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
680a45ae5f8SJohn Marino 		      msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
681a45ae5f8SJohn Marino 
682a45ae5f8SJohn Marino }
683a45ae5f8SJohn Marino 
684a45ae5f8SJohn Marino /* vec.h needs single word type name, typedef it.  */
685a45ae5f8SJohn Marino typedef struct call_site *call_sitep;
686a45ae5f8SJohn Marino 
687a45ae5f8SJohn Marino /* Define VEC (call_sitep) functions.  */
688a45ae5f8SJohn Marino DEF_VEC_P (call_sitep);
689a45ae5f8SJohn Marino 
690a45ae5f8SJohn Marino /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
691a45ae5f8SJohn Marino    only top callers and bottom callees which are present in both.  GDBARCH is
692a45ae5f8SJohn Marino    used only for ENTRY_VALUES_DEBUG.  RESULTP is NULL after return if there are
693a45ae5f8SJohn Marino    no remaining possibilities to provide unambiguous non-trivial result.
694a45ae5f8SJohn Marino    RESULTP should point to NULL on the first (initialization) call.  Caller is
695a45ae5f8SJohn Marino    responsible for xfree of any RESULTP data.  */
696a45ae5f8SJohn Marino 
697a45ae5f8SJohn Marino static void
chain_candidate(struct gdbarch * gdbarch,struct call_site_chain ** resultp,VEC (call_sitep)* chain)698a45ae5f8SJohn Marino chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
699a45ae5f8SJohn Marino 		 VEC (call_sitep) *chain)
700a45ae5f8SJohn Marino {
701a45ae5f8SJohn Marino   struct call_site_chain *result = *resultp;
702a45ae5f8SJohn Marino   long length = VEC_length (call_sitep, chain);
703a45ae5f8SJohn Marino   int callers, callees, idx;
704a45ae5f8SJohn Marino 
705a45ae5f8SJohn Marino   if (result == NULL)
706a45ae5f8SJohn Marino     {
707a45ae5f8SJohn Marino       /* Create the initial chain containing all the passed PCs.  */
708a45ae5f8SJohn Marino 
709a45ae5f8SJohn Marino       result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
710a45ae5f8SJohn Marino 					   * (length - 1));
711a45ae5f8SJohn Marino       result->length = length;
712a45ae5f8SJohn Marino       result->callers = result->callees = length;
713a45ae5f8SJohn Marino       memcpy (result->call_site, VEC_address (call_sitep, chain),
714a45ae5f8SJohn Marino 	      sizeof (*result->call_site) * length);
715a45ae5f8SJohn Marino       *resultp = result;
716a45ae5f8SJohn Marino 
717a45ae5f8SJohn Marino       if (entry_values_debug)
718a45ae5f8SJohn Marino 	{
719a45ae5f8SJohn Marino 	  fprintf_unfiltered (gdb_stdlog, "tailcall: initial:");
720a45ae5f8SJohn Marino 	  for (idx = 0; idx < length; idx++)
721a45ae5f8SJohn Marino 	    tailcall_dump (gdbarch, result->call_site[idx]);
722a45ae5f8SJohn Marino 	  fputc_unfiltered ('\n', gdb_stdlog);
723a45ae5f8SJohn Marino 	}
724a45ae5f8SJohn Marino 
725a45ae5f8SJohn Marino       return;
726a45ae5f8SJohn Marino     }
727a45ae5f8SJohn Marino 
728a45ae5f8SJohn Marino   if (entry_values_debug)
729a45ae5f8SJohn Marino     {
730a45ae5f8SJohn Marino       fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
731a45ae5f8SJohn Marino       for (idx = 0; idx < length; idx++)
732a45ae5f8SJohn Marino 	tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
733a45ae5f8SJohn Marino       fputc_unfiltered ('\n', gdb_stdlog);
734a45ae5f8SJohn Marino     }
735a45ae5f8SJohn Marino 
736a45ae5f8SJohn Marino   /* Intersect callers.  */
737a45ae5f8SJohn Marino 
738a45ae5f8SJohn Marino   callers = min (result->callers, length);
739a45ae5f8SJohn Marino   for (idx = 0; idx < callers; idx++)
740a45ae5f8SJohn Marino     if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
741a45ae5f8SJohn Marino       {
742a45ae5f8SJohn Marino 	result->callers = idx;
743a45ae5f8SJohn Marino 	break;
744a45ae5f8SJohn Marino       }
745a45ae5f8SJohn Marino 
746a45ae5f8SJohn Marino   /* Intersect callees.  */
747a45ae5f8SJohn Marino 
748a45ae5f8SJohn Marino   callees = min (result->callees, length);
749a45ae5f8SJohn Marino   for (idx = 0; idx < callees; idx++)
750a45ae5f8SJohn Marino     if (result->call_site[result->length - 1 - idx]
751a45ae5f8SJohn Marino 	!= VEC_index (call_sitep, chain, length - 1 - idx))
752a45ae5f8SJohn Marino       {
753a45ae5f8SJohn Marino 	result->callees = idx;
754a45ae5f8SJohn Marino 	break;
755a45ae5f8SJohn Marino       }
756a45ae5f8SJohn Marino 
757a45ae5f8SJohn Marino   if (entry_values_debug)
758a45ae5f8SJohn Marino     {
759a45ae5f8SJohn Marino       fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
760a45ae5f8SJohn Marino       for (idx = 0; idx < result->callers; idx++)
761a45ae5f8SJohn Marino 	tailcall_dump (gdbarch, result->call_site[idx]);
762a45ae5f8SJohn Marino       fputs_unfiltered (" |", gdb_stdlog);
763a45ae5f8SJohn Marino       for (idx = 0; idx < result->callees; idx++)
764a45ae5f8SJohn Marino 	tailcall_dump (gdbarch, result->call_site[result->length
765a45ae5f8SJohn Marino 						  - result->callees + idx]);
766a45ae5f8SJohn Marino       fputc_unfiltered ('\n', gdb_stdlog);
767a45ae5f8SJohn Marino     }
768a45ae5f8SJohn Marino 
769a45ae5f8SJohn Marino   if (result->callers == 0 && result->callees == 0)
770a45ae5f8SJohn Marino     {
771a45ae5f8SJohn Marino       /* There are no common callers or callees.  It could be also a direct
772a45ae5f8SJohn Marino 	 call (which has length 0) with ambiguous possibility of an indirect
773a45ae5f8SJohn Marino 	 call - CALLERS == CALLEES == 0 is valid during the first allocation
774a45ae5f8SJohn Marino 	 but any subsequence processing of such entry means ambiguity.  */
775a45ae5f8SJohn Marino       xfree (result);
776a45ae5f8SJohn Marino       *resultp = NULL;
777a45ae5f8SJohn Marino       return;
778a45ae5f8SJohn Marino     }
779a45ae5f8SJohn Marino 
780a45ae5f8SJohn Marino   /* See call_site_find_chain_1 why there is no way to reach the bottom callee
781a45ae5f8SJohn Marino      PC again.  In such case there must be two different code paths to reach
782a45ae5f8SJohn Marino      it, therefore some of the former determined intermediate PCs must differ
783a45ae5f8SJohn Marino      and the unambiguous chain gets shortened.  */
784a45ae5f8SJohn Marino   gdb_assert (result->callers + result->callees < result->length);
785a45ae5f8SJohn Marino }
786a45ae5f8SJohn Marino 
787a45ae5f8SJohn Marino /* Create and return call_site_chain for CALLER_PC and CALLEE_PC.  All the
788a45ae5f8SJohn Marino    assumed frames between them use GDBARCH.  Use depth first search so we can
789a45ae5f8SJohn Marino    keep single CHAIN of call_site's back to CALLER_PC.  Function recursion
790a45ae5f8SJohn Marino    would have needless GDB stack overhead.  Caller is responsible for xfree of
791a45ae5f8SJohn Marino    the returned result.  Any unreliability results in thrown
792a45ae5f8SJohn Marino    NO_ENTRY_VALUE_ERROR.  */
793a45ae5f8SJohn Marino 
794a45ae5f8SJohn Marino static struct call_site_chain *
call_site_find_chain_1(struct gdbarch * gdbarch,CORE_ADDR caller_pc,CORE_ADDR callee_pc)795a45ae5f8SJohn Marino call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
796a45ae5f8SJohn Marino 			CORE_ADDR callee_pc)
797a45ae5f8SJohn Marino {
798*ef5ccd6cSJohn Marino   CORE_ADDR save_callee_pc = callee_pc;
799a45ae5f8SJohn Marino   struct obstack addr_obstack;
800a45ae5f8SJohn Marino   struct cleanup *back_to_retval, *back_to_workdata;
801a45ae5f8SJohn Marino   struct call_site_chain *retval = NULL;
802a45ae5f8SJohn Marino   struct call_site *call_site;
803a45ae5f8SJohn Marino 
804a45ae5f8SJohn Marino   /* Mark CALL_SITEs so we do not visit the same ones twice.  */
805a45ae5f8SJohn Marino   htab_t addr_hash;
806a45ae5f8SJohn Marino 
807a45ae5f8SJohn Marino   /* CHAIN contains only the intermediate CALL_SITEs.  Neither CALLER_PC's
808a45ae5f8SJohn Marino      call_site nor any possible call_site at CALLEE_PC's function is there.
809a45ae5f8SJohn Marino      Any CALL_SITE in CHAIN will be iterated to its siblings - via
810a45ae5f8SJohn Marino      TAIL_CALL_NEXT.  This is inappropriate for CALLER_PC's call_site.  */
811a45ae5f8SJohn Marino   VEC (call_sitep) *chain = NULL;
812a45ae5f8SJohn Marino 
813a45ae5f8SJohn Marino   /* We are not interested in the specific PC inside the callee function.  */
814a45ae5f8SJohn Marino   callee_pc = get_pc_function_start (callee_pc);
815a45ae5f8SJohn Marino   if (callee_pc == 0)
816a45ae5f8SJohn Marino     throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
817*ef5ccd6cSJohn Marino 		 paddress (gdbarch, save_callee_pc));
818a45ae5f8SJohn Marino 
819a45ae5f8SJohn Marino   back_to_retval = make_cleanup (free_current_contents, &retval);
820a45ae5f8SJohn Marino 
821a45ae5f8SJohn Marino   obstack_init (&addr_obstack);
822a45ae5f8SJohn Marino   back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
823a45ae5f8SJohn Marino   addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
824a45ae5f8SJohn Marino 				    &addr_obstack, hashtab_obstack_allocate,
825a45ae5f8SJohn Marino 				    NULL);
826a45ae5f8SJohn Marino   make_cleanup_htab_delete (addr_hash);
827a45ae5f8SJohn Marino 
828a45ae5f8SJohn Marino   make_cleanup (VEC_cleanup (call_sitep), &chain);
829a45ae5f8SJohn Marino 
830a45ae5f8SJohn Marino   /* Do not push CALL_SITE to CHAIN.  Push there only the first tail call site
831a45ae5f8SJohn Marino      at the target's function.  All the possible tail call sites in the
832a45ae5f8SJohn Marino      target's function will get iterated as already pushed into CHAIN via their
833a45ae5f8SJohn Marino      TAIL_CALL_NEXT.  */
834a45ae5f8SJohn Marino   call_site = call_site_for_pc (gdbarch, caller_pc);
835a45ae5f8SJohn Marino 
836a45ae5f8SJohn Marino   while (call_site)
837a45ae5f8SJohn Marino     {
838a45ae5f8SJohn Marino       CORE_ADDR target_func_addr;
839a45ae5f8SJohn Marino       struct call_site *target_call_site;
840a45ae5f8SJohn Marino 
841a45ae5f8SJohn Marino       /* CALLER_FRAME with registers is not available for tail-call jumped
842a45ae5f8SJohn Marino 	 frames.  */
843a45ae5f8SJohn Marino       target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
844a45ae5f8SJohn Marino 
845a45ae5f8SJohn Marino       if (target_func_addr == callee_pc)
846a45ae5f8SJohn Marino 	{
847a45ae5f8SJohn Marino 	  chain_candidate (gdbarch, &retval, chain);
848a45ae5f8SJohn Marino 	  if (retval == NULL)
849a45ae5f8SJohn Marino 	    break;
850a45ae5f8SJohn Marino 
851a45ae5f8SJohn Marino 	  /* There is no way to reach CALLEE_PC again as we would prevent
852a45ae5f8SJohn Marino 	     entering it twice as being already marked in ADDR_HASH.  */
853a45ae5f8SJohn Marino 	  target_call_site = NULL;
854a45ae5f8SJohn Marino 	}
855a45ae5f8SJohn Marino       else
856a45ae5f8SJohn Marino 	{
857a45ae5f8SJohn Marino 	  struct symbol *target_func;
858a45ae5f8SJohn Marino 
859a45ae5f8SJohn Marino 	  target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
860a45ae5f8SJohn Marino 	  target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
861a45ae5f8SJohn Marino 	}
862a45ae5f8SJohn Marino 
863a45ae5f8SJohn Marino       do
864a45ae5f8SJohn Marino 	{
865a45ae5f8SJohn Marino 	  /* Attempt to visit TARGET_CALL_SITE.  */
866a45ae5f8SJohn Marino 
867a45ae5f8SJohn Marino 	  if (target_call_site)
868a45ae5f8SJohn Marino 	    {
869a45ae5f8SJohn Marino 	      void **slot;
870a45ae5f8SJohn Marino 
871a45ae5f8SJohn Marino 	      slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
872a45ae5f8SJohn Marino 	      if (*slot == NULL)
873a45ae5f8SJohn Marino 		{
874a45ae5f8SJohn Marino 		  /* Successfully entered TARGET_CALL_SITE.  */
875a45ae5f8SJohn Marino 
876a45ae5f8SJohn Marino 		  *slot = &target_call_site->pc;
877a45ae5f8SJohn Marino 		  VEC_safe_push (call_sitep, chain, target_call_site);
878a45ae5f8SJohn Marino 		  break;
879a45ae5f8SJohn Marino 		}
880a45ae5f8SJohn Marino 	    }
881a45ae5f8SJohn Marino 
882a45ae5f8SJohn Marino 	  /* Backtrack (without revisiting the originating call_site).  Try the
883a45ae5f8SJohn Marino 	     callers's sibling; if there isn't any try the callers's callers's
884a45ae5f8SJohn Marino 	     sibling etc.  */
885a45ae5f8SJohn Marino 
886a45ae5f8SJohn Marino 	  target_call_site = NULL;
887a45ae5f8SJohn Marino 	  while (!VEC_empty (call_sitep, chain))
888a45ae5f8SJohn Marino 	    {
889a45ae5f8SJohn Marino 	      call_site = VEC_pop (call_sitep, chain);
890a45ae5f8SJohn Marino 
891a45ae5f8SJohn Marino 	      gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
892a45ae5f8SJohn Marino 					  NO_INSERT) != NULL);
893a45ae5f8SJohn Marino 	      htab_remove_elt (addr_hash, &call_site->pc);
894a45ae5f8SJohn Marino 
895a45ae5f8SJohn Marino 	      target_call_site = call_site->tail_call_next;
896a45ae5f8SJohn Marino 	      if (target_call_site)
897a45ae5f8SJohn Marino 		break;
898a45ae5f8SJohn Marino 	    }
899a45ae5f8SJohn Marino 	}
900a45ae5f8SJohn Marino       while (target_call_site);
901a45ae5f8SJohn Marino 
902a45ae5f8SJohn Marino       if (VEC_empty (call_sitep, chain))
903a45ae5f8SJohn Marino 	call_site = NULL;
904a45ae5f8SJohn Marino       else
905a45ae5f8SJohn Marino 	call_site = VEC_last (call_sitep, chain);
906a45ae5f8SJohn Marino     }
907a45ae5f8SJohn Marino 
908a45ae5f8SJohn Marino   if (retval == NULL)
909a45ae5f8SJohn Marino     {
910a45ae5f8SJohn Marino       struct minimal_symbol *msym_caller, *msym_callee;
911a45ae5f8SJohn Marino 
912a45ae5f8SJohn Marino       msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
913a45ae5f8SJohn Marino       msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
914a45ae5f8SJohn Marino       throw_error (NO_ENTRY_VALUE_ERROR,
915a45ae5f8SJohn Marino 		   _("There are no unambiguously determinable intermediate "
916a45ae5f8SJohn Marino 		     "callers or callees between caller function \"%s\" at %s "
917a45ae5f8SJohn Marino 		     "and callee function \"%s\" at %s"),
918a45ae5f8SJohn Marino 		   (msym_caller == NULL
919a45ae5f8SJohn Marino 		    ? "???" : SYMBOL_PRINT_NAME (msym_caller)),
920a45ae5f8SJohn Marino 		   paddress (gdbarch, caller_pc),
921a45ae5f8SJohn Marino 		   (msym_callee == NULL
922a45ae5f8SJohn Marino 		    ? "???" : SYMBOL_PRINT_NAME (msym_callee)),
923a45ae5f8SJohn Marino 		   paddress (gdbarch, callee_pc));
924a45ae5f8SJohn Marino     }
925a45ae5f8SJohn Marino 
926a45ae5f8SJohn Marino   do_cleanups (back_to_workdata);
927a45ae5f8SJohn Marino   discard_cleanups (back_to_retval);
928a45ae5f8SJohn Marino   return retval;
929a45ae5f8SJohn Marino }
930a45ae5f8SJohn Marino 
931a45ae5f8SJohn Marino /* Create and return call_site_chain for CALLER_PC and CALLEE_PC.  All the
932a45ae5f8SJohn Marino    assumed frames between them use GDBARCH.  If valid call_site_chain cannot be
933a45ae5f8SJohn Marino    constructed return NULL.  Caller is responsible for xfree of the returned
934a45ae5f8SJohn Marino    result.  */
935a45ae5f8SJohn Marino 
936a45ae5f8SJohn Marino struct call_site_chain *
call_site_find_chain(struct gdbarch * gdbarch,CORE_ADDR caller_pc,CORE_ADDR callee_pc)937a45ae5f8SJohn Marino call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
938a45ae5f8SJohn Marino 		      CORE_ADDR callee_pc)
939a45ae5f8SJohn Marino {
940a45ae5f8SJohn Marino   volatile struct gdb_exception e;
941a45ae5f8SJohn Marino   struct call_site_chain *retval = NULL;
942a45ae5f8SJohn Marino 
943a45ae5f8SJohn Marino   TRY_CATCH (e, RETURN_MASK_ERROR)
944a45ae5f8SJohn Marino     {
945a45ae5f8SJohn Marino       retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
946a45ae5f8SJohn Marino     }
947a45ae5f8SJohn Marino   if (e.reason < 0)
948a45ae5f8SJohn Marino     {
949a45ae5f8SJohn Marino       if (e.error == NO_ENTRY_VALUE_ERROR)
950a45ae5f8SJohn Marino 	{
951a45ae5f8SJohn Marino 	  if (entry_values_debug)
952a45ae5f8SJohn Marino 	    exception_print (gdb_stdout, e);
953a45ae5f8SJohn Marino 
954a45ae5f8SJohn Marino 	  return NULL;
955a45ae5f8SJohn Marino 	}
956a45ae5f8SJohn Marino       else
957a45ae5f8SJohn Marino 	throw_exception (e);
958a45ae5f8SJohn Marino     }
959a45ae5f8SJohn Marino   return retval;
960a45ae5f8SJohn Marino }
961a45ae5f8SJohn Marino 
962*ef5ccd6cSJohn Marino /* Return 1 if KIND and KIND_U match PARAMETER.  Return 0 otherwise.  */
963*ef5ccd6cSJohn Marino 
964*ef5ccd6cSJohn Marino static int
call_site_parameter_matches(struct call_site_parameter * parameter,enum call_site_parameter_kind kind,union call_site_parameter_u kind_u)965*ef5ccd6cSJohn Marino call_site_parameter_matches (struct call_site_parameter *parameter,
966*ef5ccd6cSJohn Marino 			     enum call_site_parameter_kind kind,
967*ef5ccd6cSJohn Marino 			     union call_site_parameter_u kind_u)
968*ef5ccd6cSJohn Marino {
969*ef5ccd6cSJohn Marino   if (kind == parameter->kind)
970*ef5ccd6cSJohn Marino     switch (kind)
971*ef5ccd6cSJohn Marino       {
972*ef5ccd6cSJohn Marino       case CALL_SITE_PARAMETER_DWARF_REG:
973*ef5ccd6cSJohn Marino 	return kind_u.dwarf_reg == parameter->u.dwarf_reg;
974*ef5ccd6cSJohn Marino       case CALL_SITE_PARAMETER_FB_OFFSET:
975*ef5ccd6cSJohn Marino 	return kind_u.fb_offset == parameter->u.fb_offset;
976*ef5ccd6cSJohn Marino       case CALL_SITE_PARAMETER_PARAM_OFFSET:
977*ef5ccd6cSJohn Marino 	return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
978*ef5ccd6cSJohn Marino       }
979*ef5ccd6cSJohn Marino   return 0;
980*ef5ccd6cSJohn Marino }
981*ef5ccd6cSJohn Marino 
982*ef5ccd6cSJohn Marino /* Fetch call_site_parameter from caller matching KIND and KIND_U.
983*ef5ccd6cSJohn Marino    FRAME is for callee.
984a45ae5f8SJohn Marino 
985a45ae5f8SJohn Marino    Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
986a45ae5f8SJohn Marino    otherwise.  */
987a45ae5f8SJohn Marino 
988a45ae5f8SJohn Marino static struct call_site_parameter *
dwarf_expr_reg_to_entry_parameter(struct frame_info * frame,enum call_site_parameter_kind kind,union call_site_parameter_u kind_u,struct dwarf2_per_cu_data ** per_cu_return)989*ef5ccd6cSJohn Marino dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
990*ef5ccd6cSJohn Marino 				   enum call_site_parameter_kind kind,
991*ef5ccd6cSJohn Marino 				   union call_site_parameter_u kind_u,
992a45ae5f8SJohn Marino 				   struct dwarf2_per_cu_data **per_cu_return)
993a45ae5f8SJohn Marino {
994*ef5ccd6cSJohn Marino   CORE_ADDR func_addr, caller_pc;
995*ef5ccd6cSJohn Marino   struct gdbarch *gdbarch;
996*ef5ccd6cSJohn Marino   struct frame_info *caller_frame;
997a45ae5f8SJohn Marino   struct call_site *call_site;
998a45ae5f8SJohn Marino   int iparams;
999a45ae5f8SJohn Marino   /* Initialize it just to avoid a GCC false warning.  */
1000a45ae5f8SJohn Marino   struct call_site_parameter *parameter = NULL;
1001a45ae5f8SJohn Marino   CORE_ADDR target_addr;
1002a45ae5f8SJohn Marino 
1003*ef5ccd6cSJohn Marino   while (get_frame_type (frame) == INLINE_FRAME)
1004*ef5ccd6cSJohn Marino     {
1005*ef5ccd6cSJohn Marino       frame = get_prev_frame (frame);
1006*ef5ccd6cSJohn Marino       gdb_assert (frame != NULL);
1007*ef5ccd6cSJohn Marino     }
1008*ef5ccd6cSJohn Marino 
1009*ef5ccd6cSJohn Marino   func_addr = get_frame_func (frame);
1010*ef5ccd6cSJohn Marino   gdbarch = get_frame_arch (frame);
1011*ef5ccd6cSJohn Marino   caller_frame = get_prev_frame (frame);
1012a45ae5f8SJohn Marino   if (gdbarch != frame_unwind_arch (frame))
1013a45ae5f8SJohn Marino     {
1014a45ae5f8SJohn Marino       struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
1015a45ae5f8SJohn Marino       struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
1016a45ae5f8SJohn Marino 
1017a45ae5f8SJohn Marino       throw_error (NO_ENTRY_VALUE_ERROR,
1018a45ae5f8SJohn Marino 		   _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1019a45ae5f8SJohn Marino 		     "(of %s (%s)) does not match caller gdbarch %s"),
1020a45ae5f8SJohn Marino 		   gdbarch_bfd_arch_info (gdbarch)->printable_name,
1021a45ae5f8SJohn Marino 		   paddress (gdbarch, func_addr),
1022a45ae5f8SJohn Marino 		   msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym),
1023a45ae5f8SJohn Marino 		   gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
1024a45ae5f8SJohn Marino     }
1025a45ae5f8SJohn Marino 
1026a45ae5f8SJohn Marino   if (caller_frame == NULL)
1027a45ae5f8SJohn Marino     {
1028a45ae5f8SJohn Marino       struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
1029a45ae5f8SJohn Marino 
1030a45ae5f8SJohn Marino       throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
1031a45ae5f8SJohn Marino 					   "requires caller of %s (%s)"),
1032a45ae5f8SJohn Marino 		   paddress (gdbarch, func_addr),
1033a45ae5f8SJohn Marino 		   msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
1034a45ae5f8SJohn Marino     }
1035a45ae5f8SJohn Marino   caller_pc = get_frame_pc (caller_frame);
1036a45ae5f8SJohn Marino   call_site = call_site_for_pc (gdbarch, caller_pc);
1037a45ae5f8SJohn Marino 
1038a45ae5f8SJohn Marino   target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
1039a45ae5f8SJohn Marino   if (target_addr != func_addr)
1040a45ae5f8SJohn Marino     {
1041a45ae5f8SJohn Marino       struct minimal_symbol *target_msym, *func_msym;
1042a45ae5f8SJohn Marino 
1043a45ae5f8SJohn Marino       target_msym = lookup_minimal_symbol_by_pc (target_addr);
1044a45ae5f8SJohn Marino       func_msym = lookup_minimal_symbol_by_pc (func_addr);
1045a45ae5f8SJohn Marino       throw_error (NO_ENTRY_VALUE_ERROR,
1046a45ae5f8SJohn Marino 		   _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1047a45ae5f8SJohn Marino 		     "but the called frame is for %s at %s"),
1048a45ae5f8SJohn Marino 		   (target_msym == NULL ? "???"
1049a45ae5f8SJohn Marino 					: SYMBOL_PRINT_NAME (target_msym)),
1050a45ae5f8SJohn Marino 		   paddress (gdbarch, target_addr),
1051a45ae5f8SJohn Marino 		   func_msym == NULL ? "???" : SYMBOL_PRINT_NAME (func_msym),
1052a45ae5f8SJohn Marino 		   paddress (gdbarch, func_addr));
1053a45ae5f8SJohn Marino     }
1054a45ae5f8SJohn Marino 
1055a45ae5f8SJohn Marino   /* No entry value based parameters would be reliable if this function can
1056a45ae5f8SJohn Marino      call itself via tail calls.  */
1057a45ae5f8SJohn Marino   func_verify_no_selftailcall (gdbarch, func_addr);
1058a45ae5f8SJohn Marino 
1059a45ae5f8SJohn Marino   for (iparams = 0; iparams < call_site->parameter_count; iparams++)
1060a45ae5f8SJohn Marino     {
1061a45ae5f8SJohn Marino       parameter = &call_site->parameter[iparams];
1062*ef5ccd6cSJohn Marino       if (call_site_parameter_matches (parameter, kind, kind_u))
1063a45ae5f8SJohn Marino 	break;
1064a45ae5f8SJohn Marino     }
1065a45ae5f8SJohn Marino   if (iparams == call_site->parameter_count)
1066a45ae5f8SJohn Marino     {
1067a45ae5f8SJohn Marino       struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (caller_pc);
1068a45ae5f8SJohn Marino 
1069a45ae5f8SJohn Marino       /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1070a45ae5f8SJohn Marino 	 determine its value.  */
1071a45ae5f8SJohn Marino       throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
1072a45ae5f8SJohn Marino 					   "at DW_TAG_GNU_call_site %s at %s"),
1073a45ae5f8SJohn Marino 		   paddress (gdbarch, caller_pc),
1074a45ae5f8SJohn Marino 		   msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
1075a45ae5f8SJohn Marino     }
1076a45ae5f8SJohn Marino 
1077a45ae5f8SJohn Marino   *per_cu_return = call_site->per_cu;
1078a45ae5f8SJohn Marino   return parameter;
1079a45ae5f8SJohn Marino }
1080a45ae5f8SJohn Marino 
1081a45ae5f8SJohn Marino /* Return value for PARAMETER matching DEREF_SIZE.  If DEREF_SIZE is -1, return
1082a45ae5f8SJohn Marino    the normal DW_AT_GNU_call_site_value block.  Otherwise return the
1083a45ae5f8SJohn Marino    DW_AT_GNU_call_site_data_value (dereferenced) block.
1084a45ae5f8SJohn Marino 
1085a45ae5f8SJohn Marino    TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1086a45ae5f8SJohn Marino    struct value.
1087a45ae5f8SJohn Marino 
1088a45ae5f8SJohn Marino    Function always returns non-NULL, non-optimized out value.  It throws
1089a45ae5f8SJohn Marino    NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason.  */
1090a45ae5f8SJohn Marino 
1091a45ae5f8SJohn Marino static struct value *
dwarf_entry_parameter_to_value(struct call_site_parameter * parameter,CORE_ADDR deref_size,struct type * type,struct frame_info * caller_frame,struct dwarf2_per_cu_data * per_cu)1092a45ae5f8SJohn Marino dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
1093a45ae5f8SJohn Marino 				CORE_ADDR deref_size, struct type *type,
1094a45ae5f8SJohn Marino 				struct frame_info *caller_frame,
1095a45ae5f8SJohn Marino 				struct dwarf2_per_cu_data *per_cu)
1096a45ae5f8SJohn Marino {
1097a45ae5f8SJohn Marino   const gdb_byte *data_src;
1098a45ae5f8SJohn Marino   gdb_byte *data;
1099a45ae5f8SJohn Marino   size_t size;
1100a45ae5f8SJohn Marino 
1101a45ae5f8SJohn Marino   data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1102a45ae5f8SJohn Marino   size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1103a45ae5f8SJohn Marino 
1104a45ae5f8SJohn Marino   /* DEREF_SIZE size is not verified here.  */
1105a45ae5f8SJohn Marino   if (data_src == NULL)
1106a45ae5f8SJohn Marino     throw_error (NO_ENTRY_VALUE_ERROR,
1107a45ae5f8SJohn Marino 		 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1108a45ae5f8SJohn Marino 
1109a45ae5f8SJohn Marino   /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1110a45ae5f8SJohn Marino      location.  Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1111a45ae5f8SJohn Marino      DWARF block.  */
1112a45ae5f8SJohn Marino   data = alloca (size + 1);
1113a45ae5f8SJohn Marino   memcpy (data, data_src, size);
1114a45ae5f8SJohn Marino   data[size] = DW_OP_stack_value;
1115a45ae5f8SJohn Marino 
1116a45ae5f8SJohn Marino   return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
1117a45ae5f8SJohn Marino }
1118a45ae5f8SJohn Marino 
1119*ef5ccd6cSJohn Marino /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1120*ef5ccd6cSJohn Marino    Choose DEREF_SIZE value of that parameter.  Search caller of the CTX's
1121*ef5ccd6cSJohn Marino    frame.  CTX must be of dwarf_expr_ctx_funcs kind.
1122a45ae5f8SJohn Marino 
1123a45ae5f8SJohn Marino    The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1124a45ae5f8SJohn Marino    can be more simple as it does not support cross-CU DWARF executions.  */
1125a45ae5f8SJohn Marino 
1126a45ae5f8SJohn Marino static void
dwarf_expr_push_dwarf_reg_entry_value(struct dwarf_expr_context * ctx,enum call_site_parameter_kind kind,union call_site_parameter_u kind_u,int deref_size)1127a45ae5f8SJohn Marino dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
1128*ef5ccd6cSJohn Marino 				       enum call_site_parameter_kind kind,
1129*ef5ccd6cSJohn Marino 				       union call_site_parameter_u kind_u,
1130a45ae5f8SJohn Marino 				       int deref_size)
1131a45ae5f8SJohn Marino {
1132a45ae5f8SJohn Marino   struct dwarf_expr_baton *debaton;
1133a45ae5f8SJohn Marino   struct frame_info *frame, *caller_frame;
1134a45ae5f8SJohn Marino   struct dwarf2_per_cu_data *caller_per_cu;
1135a45ae5f8SJohn Marino   struct dwarf_expr_baton baton_local;
1136a45ae5f8SJohn Marino   struct dwarf_expr_context saved_ctx;
1137a45ae5f8SJohn Marino   struct call_site_parameter *parameter;
1138a45ae5f8SJohn Marino   const gdb_byte *data_src;
1139a45ae5f8SJohn Marino   size_t size;
1140a45ae5f8SJohn Marino 
1141a45ae5f8SJohn Marino   gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
1142a45ae5f8SJohn Marino   debaton = ctx->baton;
1143a45ae5f8SJohn Marino   frame = debaton->frame;
1144a45ae5f8SJohn Marino   caller_frame = get_prev_frame (frame);
1145a45ae5f8SJohn Marino 
1146*ef5ccd6cSJohn Marino   parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1147a45ae5f8SJohn Marino 						 &caller_per_cu);
1148a45ae5f8SJohn Marino   data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1149a45ae5f8SJohn Marino   size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1150a45ae5f8SJohn Marino 
1151a45ae5f8SJohn Marino   /* DEREF_SIZE size is not verified here.  */
1152a45ae5f8SJohn Marino   if (data_src == NULL)
1153a45ae5f8SJohn Marino     throw_error (NO_ENTRY_VALUE_ERROR,
1154a45ae5f8SJohn Marino 		 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1155a45ae5f8SJohn Marino 
1156a45ae5f8SJohn Marino   baton_local.frame = caller_frame;
1157a45ae5f8SJohn Marino   baton_local.per_cu = caller_per_cu;
1158a45ae5f8SJohn Marino 
1159a45ae5f8SJohn Marino   saved_ctx.gdbarch = ctx->gdbarch;
1160a45ae5f8SJohn Marino   saved_ctx.addr_size = ctx->addr_size;
1161a45ae5f8SJohn Marino   saved_ctx.offset = ctx->offset;
1162a45ae5f8SJohn Marino   saved_ctx.baton = ctx->baton;
1163a45ae5f8SJohn Marino   ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
1164a45ae5f8SJohn Marino   ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
1165a45ae5f8SJohn Marino   ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
1166a45ae5f8SJohn Marino   ctx->baton = &baton_local;
1167a45ae5f8SJohn Marino 
1168a45ae5f8SJohn Marino   dwarf_expr_eval (ctx, data_src, size);
1169a45ae5f8SJohn Marino 
1170a45ae5f8SJohn Marino   ctx->gdbarch = saved_ctx.gdbarch;
1171a45ae5f8SJohn Marino   ctx->addr_size = saved_ctx.addr_size;
1172a45ae5f8SJohn Marino   ctx->offset = saved_ctx.offset;
1173a45ae5f8SJohn Marino   ctx->baton = saved_ctx.baton;
1174a45ae5f8SJohn Marino }
1175a45ae5f8SJohn Marino 
1176*ef5ccd6cSJohn Marino /* Callback function for dwarf2_evaluate_loc_desc.
1177*ef5ccd6cSJohn Marino    Fetch the address indexed by DW_OP_GNU_addr_index.  */
1178*ef5ccd6cSJohn Marino 
1179*ef5ccd6cSJohn Marino static CORE_ADDR
dwarf_expr_get_addr_index(void * baton,unsigned int index)1180*ef5ccd6cSJohn Marino dwarf_expr_get_addr_index (void *baton, unsigned int index)
1181*ef5ccd6cSJohn Marino {
1182*ef5ccd6cSJohn Marino   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
1183*ef5ccd6cSJohn Marino 
1184*ef5ccd6cSJohn Marino   return dwarf2_read_addr_index (debaton->per_cu, index);
1185*ef5ccd6cSJohn Marino }
1186*ef5ccd6cSJohn Marino 
1187a45ae5f8SJohn Marino /* VALUE must be of type lval_computed with entry_data_value_funcs.  Perform
1188a45ae5f8SJohn Marino    the indirect method on it, that is use its stored target value, the sole
1189a45ae5f8SJohn Marino    purpose of entry_data_value_funcs..  */
1190a45ae5f8SJohn Marino 
1191a45ae5f8SJohn Marino static struct value *
entry_data_value_coerce_ref(const struct value * value)1192a45ae5f8SJohn Marino entry_data_value_coerce_ref (const struct value *value)
1193a45ae5f8SJohn Marino {
1194a45ae5f8SJohn Marino   struct type *checked_type = check_typedef (value_type (value));
1195a45ae5f8SJohn Marino   struct value *target_val;
1196a45ae5f8SJohn Marino 
1197a45ae5f8SJohn Marino   if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
1198a45ae5f8SJohn Marino     return NULL;
1199a45ae5f8SJohn Marino 
1200a45ae5f8SJohn Marino   target_val = value_computed_closure (value);
1201a45ae5f8SJohn Marino   value_incref (target_val);
1202a45ae5f8SJohn Marino   return target_val;
1203a45ae5f8SJohn Marino }
1204a45ae5f8SJohn Marino 
1205a45ae5f8SJohn Marino /* Implement copy_closure.  */
1206a45ae5f8SJohn Marino 
1207a45ae5f8SJohn Marino static void *
entry_data_value_copy_closure(const struct value * v)1208a45ae5f8SJohn Marino entry_data_value_copy_closure (const struct value *v)
1209a45ae5f8SJohn Marino {
1210a45ae5f8SJohn Marino   struct value *target_val = value_computed_closure (v);
1211a45ae5f8SJohn Marino 
1212a45ae5f8SJohn Marino   value_incref (target_val);
1213a45ae5f8SJohn Marino   return target_val;
1214a45ae5f8SJohn Marino }
1215a45ae5f8SJohn Marino 
1216a45ae5f8SJohn Marino /* Implement free_closure.  */
1217a45ae5f8SJohn Marino 
1218a45ae5f8SJohn Marino static void
entry_data_value_free_closure(struct value * v)1219a45ae5f8SJohn Marino entry_data_value_free_closure (struct value *v)
1220a45ae5f8SJohn Marino {
1221a45ae5f8SJohn Marino   struct value *target_val = value_computed_closure (v);
1222a45ae5f8SJohn Marino 
1223a45ae5f8SJohn Marino   value_free (target_val);
1224a45ae5f8SJohn Marino }
1225a45ae5f8SJohn Marino 
1226a45ae5f8SJohn Marino /* Vector for methods for an entry value reference where the referenced value
1227a45ae5f8SJohn Marino    is stored in the caller.  On the first dereference use
1228a45ae5f8SJohn Marino    DW_AT_GNU_call_site_data_value in the caller.  */
1229a45ae5f8SJohn Marino 
1230a45ae5f8SJohn Marino static const struct lval_funcs entry_data_value_funcs =
1231a45ae5f8SJohn Marino {
1232a45ae5f8SJohn Marino   NULL,	/* read */
1233a45ae5f8SJohn Marino   NULL,	/* write */
1234a45ae5f8SJohn Marino   NULL,	/* check_validity */
1235a45ae5f8SJohn Marino   NULL,	/* check_any_valid */
1236a45ae5f8SJohn Marino   NULL,	/* indirect */
1237a45ae5f8SJohn Marino   entry_data_value_coerce_ref,
1238a45ae5f8SJohn Marino   NULL,	/* check_synthetic_pointer */
1239a45ae5f8SJohn Marino   entry_data_value_copy_closure,
1240a45ae5f8SJohn Marino   entry_data_value_free_closure
1241a45ae5f8SJohn Marino };
1242a45ae5f8SJohn Marino 
1243*ef5ccd6cSJohn Marino /* Read parameter of TYPE at (callee) FRAME's function entry.  KIND and KIND_U
1244*ef5ccd6cSJohn Marino    are used to match DW_AT_location at the caller's
1245*ef5ccd6cSJohn Marino    DW_TAG_GNU_call_site_parameter.
1246a45ae5f8SJohn Marino 
1247a45ae5f8SJohn Marino    Function always returns non-NULL value.  It throws NO_ENTRY_VALUE_ERROR if it
1248a45ae5f8SJohn Marino    cannot resolve the parameter for any reason.  */
1249a45ae5f8SJohn Marino 
1250a45ae5f8SJohn Marino static struct value *
value_of_dwarf_reg_entry(struct type * type,struct frame_info * frame,enum call_site_parameter_kind kind,union call_site_parameter_u kind_u)1251a45ae5f8SJohn Marino value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
1252*ef5ccd6cSJohn Marino 			  enum call_site_parameter_kind kind,
1253*ef5ccd6cSJohn Marino 			  union call_site_parameter_u kind_u)
1254a45ae5f8SJohn Marino {
1255a45ae5f8SJohn Marino   struct type *checked_type = check_typedef (type);
1256a45ae5f8SJohn Marino   struct type *target_type = TYPE_TARGET_TYPE (checked_type);
1257a45ae5f8SJohn Marino   struct frame_info *caller_frame = get_prev_frame (frame);
1258a45ae5f8SJohn Marino   struct value *outer_val, *target_val, *val;
1259a45ae5f8SJohn Marino   struct call_site_parameter *parameter;
1260a45ae5f8SJohn Marino   struct dwarf2_per_cu_data *caller_per_cu;
1261a45ae5f8SJohn Marino   CORE_ADDR addr;
1262a45ae5f8SJohn Marino 
1263*ef5ccd6cSJohn Marino   parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1264a45ae5f8SJohn Marino 						 &caller_per_cu);
1265a45ae5f8SJohn Marino 
1266a45ae5f8SJohn Marino   outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
1267a45ae5f8SJohn Marino 					      type, caller_frame,
1268a45ae5f8SJohn Marino 					      caller_per_cu);
1269a45ae5f8SJohn Marino 
1270a45ae5f8SJohn Marino   /* Check if DW_AT_GNU_call_site_data_value cannot be used.  If it should be
1271a45ae5f8SJohn Marino      used and it is not available do not fall back to OUTER_VAL - dereferencing
1272a45ae5f8SJohn Marino      TYPE_CODE_REF with non-entry data value would give current value - not the
1273a45ae5f8SJohn Marino      entry value.  */
1274a45ae5f8SJohn Marino 
1275a45ae5f8SJohn Marino   if (TYPE_CODE (checked_type) != TYPE_CODE_REF
1276a45ae5f8SJohn Marino       || TYPE_TARGET_TYPE (checked_type) == NULL)
1277a45ae5f8SJohn Marino     return outer_val;
1278a45ae5f8SJohn Marino 
1279a45ae5f8SJohn Marino   target_val = dwarf_entry_parameter_to_value (parameter,
1280a45ae5f8SJohn Marino 					       TYPE_LENGTH (target_type),
1281a45ae5f8SJohn Marino 					       target_type, caller_frame,
1282a45ae5f8SJohn Marino 					       caller_per_cu);
1283a45ae5f8SJohn Marino 
1284a45ae5f8SJohn Marino   /* value_as_address dereferences TYPE_CODE_REF.  */
1285a45ae5f8SJohn Marino   addr = extract_typed_address (value_contents (outer_val), checked_type);
1286a45ae5f8SJohn Marino 
1287a45ae5f8SJohn Marino   /* The target entry value has artificial address of the entry value
1288a45ae5f8SJohn Marino      reference.  */
1289a45ae5f8SJohn Marino   VALUE_LVAL (target_val) = lval_memory;
1290a45ae5f8SJohn Marino   set_value_address (target_val, addr);
1291a45ae5f8SJohn Marino 
1292a45ae5f8SJohn Marino   release_value (target_val);
1293a45ae5f8SJohn Marino   val = allocate_computed_value (type, &entry_data_value_funcs,
1294a45ae5f8SJohn Marino 				 target_val /* closure */);
1295a45ae5f8SJohn Marino 
1296a45ae5f8SJohn Marino   /* Copy the referencing pointer to the new computed value.  */
1297a45ae5f8SJohn Marino   memcpy (value_contents_raw (val), value_contents_raw (outer_val),
1298a45ae5f8SJohn Marino 	  TYPE_LENGTH (checked_type));
1299a45ae5f8SJohn Marino   set_value_lazy (val, 0);
1300a45ae5f8SJohn Marino 
1301a45ae5f8SJohn Marino   return val;
1302a45ae5f8SJohn Marino }
1303a45ae5f8SJohn Marino 
1304a45ae5f8SJohn Marino /* Read parameter of TYPE at (callee) FRAME's function entry.  DATA and
1305a45ae5f8SJohn Marino    SIZE are DWARF block used to match DW_AT_location at the caller's
1306a45ae5f8SJohn Marino    DW_TAG_GNU_call_site_parameter.
1307a45ae5f8SJohn Marino 
1308a45ae5f8SJohn Marino    Function always returns non-NULL value.  It throws NO_ENTRY_VALUE_ERROR if it
1309a45ae5f8SJohn Marino    cannot resolve the parameter for any reason.  */
1310a45ae5f8SJohn Marino 
1311a45ae5f8SJohn Marino static struct value *
value_of_dwarf_block_entry(struct type * type,struct frame_info * frame,const gdb_byte * block,size_t block_len)1312a45ae5f8SJohn Marino value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
1313a45ae5f8SJohn Marino 			    const gdb_byte *block, size_t block_len)
1314a45ae5f8SJohn Marino {
1315*ef5ccd6cSJohn Marino   union call_site_parameter_u kind_u;
1316a45ae5f8SJohn Marino 
1317*ef5ccd6cSJohn Marino   kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
1318*ef5ccd6cSJohn Marino   if (kind_u.dwarf_reg != -1)
1319*ef5ccd6cSJohn Marino     return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG,
1320*ef5ccd6cSJohn Marino 				     kind_u);
1321a45ae5f8SJohn Marino 
1322*ef5ccd6cSJohn Marino   if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
1323*ef5ccd6cSJohn Marino     return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET,
1324*ef5ccd6cSJohn Marino                                      kind_u);
1325a45ae5f8SJohn Marino 
1326a45ae5f8SJohn Marino   /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1327a45ae5f8SJohn Marino      suppressed during normal operation.  The expression can be arbitrary if
1328a45ae5f8SJohn Marino      there is no caller-callee entry value binding expected.  */
1329a45ae5f8SJohn Marino   throw_error (NO_ENTRY_VALUE_ERROR,
1330a45ae5f8SJohn Marino 	       _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1331a45ae5f8SJohn Marino 		 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
13325796c8dcSSimon Schubert }
13335796c8dcSSimon Schubert 
13345796c8dcSSimon Schubert struct piece_closure
13355796c8dcSSimon Schubert {
1336cf7f2e2dSJohn Marino   /* Reference count.  */
1337cf7f2e2dSJohn Marino   int refc;
1338cf7f2e2dSJohn Marino 
1339c50c785cSJohn Marino   /* The CU from which this closure's expression came.  */
1340c50c785cSJohn Marino   struct dwarf2_per_cu_data *per_cu;
1341c50c785cSJohn Marino 
13425796c8dcSSimon Schubert   /* The number of pieces used to describe this variable.  */
13435796c8dcSSimon Schubert   int n_pieces;
13445796c8dcSSimon Schubert 
1345cf7f2e2dSJohn Marino   /* The target address size, used only for DWARF_VALUE_STACK.  */
1346cf7f2e2dSJohn Marino   int addr_size;
13475796c8dcSSimon Schubert 
13485796c8dcSSimon Schubert   /* The pieces themselves.  */
13495796c8dcSSimon Schubert   struct dwarf_expr_piece *pieces;
13505796c8dcSSimon Schubert };
13515796c8dcSSimon Schubert 
13525796c8dcSSimon Schubert /* Allocate a closure for a value formed from separately-described
13535796c8dcSSimon Schubert    PIECES.  */
13545796c8dcSSimon Schubert 
13555796c8dcSSimon Schubert static struct piece_closure *
allocate_piece_closure(struct dwarf2_per_cu_data * per_cu,int n_pieces,struct dwarf_expr_piece * pieces,int addr_size)1356c50c785cSJohn Marino allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
1357c50c785cSJohn Marino 			int n_pieces, struct dwarf_expr_piece *pieces,
1358cf7f2e2dSJohn Marino 			int addr_size)
13595796c8dcSSimon Schubert {
13605796c8dcSSimon Schubert   struct piece_closure *c = XZALLOC (struct piece_closure);
1361a45ae5f8SJohn Marino   int i;
13625796c8dcSSimon Schubert 
1363cf7f2e2dSJohn Marino   c->refc = 1;
1364c50c785cSJohn Marino   c->per_cu = per_cu;
13655796c8dcSSimon Schubert   c->n_pieces = n_pieces;
1366cf7f2e2dSJohn Marino   c->addr_size = addr_size;
13675796c8dcSSimon Schubert   c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
13685796c8dcSSimon Schubert 
13695796c8dcSSimon Schubert   memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
1370a45ae5f8SJohn Marino   for (i = 0; i < n_pieces; ++i)
1371a45ae5f8SJohn Marino     if (c->pieces[i].location == DWARF_VALUE_STACK)
1372a45ae5f8SJohn Marino       value_incref (c->pieces[i].v.value);
13735796c8dcSSimon Schubert 
13745796c8dcSSimon Schubert   return c;
13755796c8dcSSimon Schubert }
13765796c8dcSSimon Schubert 
1377cf7f2e2dSJohn Marino /* The lowest-level function to extract bits from a byte buffer.
1378cf7f2e2dSJohn Marino    SOURCE is the buffer.  It is updated if we read to the end of a
1379cf7f2e2dSJohn Marino    byte.
1380cf7f2e2dSJohn Marino    SOURCE_OFFSET_BITS is the offset of the first bit to read.  It is
1381cf7f2e2dSJohn Marino    updated to reflect the number of bits actually read.
1382cf7f2e2dSJohn Marino    NBITS is the number of bits we want to read.  It is updated to
1383cf7f2e2dSJohn Marino    reflect the number of bits actually read.  This function may read
1384cf7f2e2dSJohn Marino    fewer bits.
1385cf7f2e2dSJohn Marino    BITS_BIG_ENDIAN is taken directly from gdbarch.
1386cf7f2e2dSJohn Marino    This function returns the extracted bits.  */
1387cf7f2e2dSJohn Marino 
1388cf7f2e2dSJohn Marino static unsigned int
extract_bits_primitive(const gdb_byte ** source,unsigned int * source_offset_bits,int * nbits,int bits_big_endian)1389cf7f2e2dSJohn Marino extract_bits_primitive (const gdb_byte **source,
1390cf7f2e2dSJohn Marino 			unsigned int *source_offset_bits,
1391cf7f2e2dSJohn Marino 			int *nbits, int bits_big_endian)
1392cf7f2e2dSJohn Marino {
1393cf7f2e2dSJohn Marino   unsigned int avail, mask, datum;
1394cf7f2e2dSJohn Marino 
1395cf7f2e2dSJohn Marino   gdb_assert (*source_offset_bits < 8);
1396cf7f2e2dSJohn Marino 
1397cf7f2e2dSJohn Marino   avail = 8 - *source_offset_bits;
1398cf7f2e2dSJohn Marino   if (avail > *nbits)
1399cf7f2e2dSJohn Marino     avail = *nbits;
1400cf7f2e2dSJohn Marino 
1401cf7f2e2dSJohn Marino   mask = (1 << avail) - 1;
1402cf7f2e2dSJohn Marino   datum = **source;
1403cf7f2e2dSJohn Marino   if (bits_big_endian)
1404cf7f2e2dSJohn Marino     datum >>= 8 - (*source_offset_bits + *nbits);
1405cf7f2e2dSJohn Marino   else
1406cf7f2e2dSJohn Marino     datum >>= *source_offset_bits;
1407cf7f2e2dSJohn Marino   datum &= mask;
1408cf7f2e2dSJohn Marino 
1409cf7f2e2dSJohn Marino   *nbits -= avail;
1410cf7f2e2dSJohn Marino   *source_offset_bits += avail;
1411cf7f2e2dSJohn Marino   if (*source_offset_bits >= 8)
1412cf7f2e2dSJohn Marino     {
1413cf7f2e2dSJohn Marino       *source_offset_bits -= 8;
1414cf7f2e2dSJohn Marino       ++*source;
1415cf7f2e2dSJohn Marino     }
1416cf7f2e2dSJohn Marino 
1417cf7f2e2dSJohn Marino   return datum;
1418cf7f2e2dSJohn Marino }
1419cf7f2e2dSJohn Marino 
1420cf7f2e2dSJohn Marino /* Extract some bits from a source buffer and move forward in the
1421cf7f2e2dSJohn Marino    buffer.
1422cf7f2e2dSJohn Marino 
1423cf7f2e2dSJohn Marino    SOURCE is the source buffer.  It is updated as bytes are read.
1424cf7f2e2dSJohn Marino    SOURCE_OFFSET_BITS is the offset into SOURCE.  It is updated as
1425cf7f2e2dSJohn Marino    bits are read.
1426cf7f2e2dSJohn Marino    NBITS is the number of bits to read.
1427cf7f2e2dSJohn Marino    BITS_BIG_ENDIAN is taken directly from gdbarch.
1428cf7f2e2dSJohn Marino 
1429cf7f2e2dSJohn Marino    This function returns the bits that were read.  */
1430cf7f2e2dSJohn Marino 
1431cf7f2e2dSJohn Marino static unsigned int
extract_bits(const gdb_byte ** source,unsigned int * source_offset_bits,int nbits,int bits_big_endian)1432cf7f2e2dSJohn Marino extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
1433cf7f2e2dSJohn Marino 	      int nbits, int bits_big_endian)
1434cf7f2e2dSJohn Marino {
1435cf7f2e2dSJohn Marino   unsigned int datum;
1436cf7f2e2dSJohn Marino 
1437cf7f2e2dSJohn Marino   gdb_assert (nbits > 0 && nbits <= 8);
1438cf7f2e2dSJohn Marino 
1439cf7f2e2dSJohn Marino   datum = extract_bits_primitive (source, source_offset_bits, &nbits,
1440cf7f2e2dSJohn Marino 				  bits_big_endian);
1441cf7f2e2dSJohn Marino   if (nbits > 0)
1442cf7f2e2dSJohn Marino     {
1443cf7f2e2dSJohn Marino       unsigned int more;
1444cf7f2e2dSJohn Marino 
1445cf7f2e2dSJohn Marino       more = extract_bits_primitive (source, source_offset_bits, &nbits,
1446cf7f2e2dSJohn Marino 				     bits_big_endian);
1447cf7f2e2dSJohn Marino       if (bits_big_endian)
1448cf7f2e2dSJohn Marino 	datum <<= nbits;
1449cf7f2e2dSJohn Marino       else
1450cf7f2e2dSJohn Marino 	more <<= nbits;
1451cf7f2e2dSJohn Marino       datum |= more;
1452cf7f2e2dSJohn Marino     }
1453cf7f2e2dSJohn Marino 
1454cf7f2e2dSJohn Marino   return datum;
1455cf7f2e2dSJohn Marino }
1456cf7f2e2dSJohn Marino 
1457cf7f2e2dSJohn Marino /* Write some bits into a buffer and move forward in the buffer.
1458cf7f2e2dSJohn Marino 
1459cf7f2e2dSJohn Marino    DATUM is the bits to write.  The low-order bits of DATUM are used.
1460cf7f2e2dSJohn Marino    DEST is the destination buffer.  It is updated as bytes are
1461cf7f2e2dSJohn Marino    written.
1462cf7f2e2dSJohn Marino    DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1463cf7f2e2dSJohn Marino    done.
1464cf7f2e2dSJohn Marino    NBITS is the number of valid bits in DATUM.
1465cf7f2e2dSJohn Marino    BITS_BIG_ENDIAN is taken directly from gdbarch.  */
1466cf7f2e2dSJohn Marino 
1467cf7f2e2dSJohn Marino static void
insert_bits(unsigned int datum,gdb_byte * dest,unsigned int dest_offset_bits,int nbits,int bits_big_endian)1468cf7f2e2dSJohn Marino insert_bits (unsigned int datum,
1469cf7f2e2dSJohn Marino 	     gdb_byte *dest, unsigned int dest_offset_bits,
1470cf7f2e2dSJohn Marino 	     int nbits, int bits_big_endian)
1471cf7f2e2dSJohn Marino {
1472cf7f2e2dSJohn Marino   unsigned int mask;
1473cf7f2e2dSJohn Marino 
1474c50c785cSJohn Marino   gdb_assert (dest_offset_bits + nbits <= 8);
1475cf7f2e2dSJohn Marino 
1476cf7f2e2dSJohn Marino   mask = (1 << nbits) - 1;
1477cf7f2e2dSJohn Marino   if (bits_big_endian)
1478cf7f2e2dSJohn Marino     {
1479cf7f2e2dSJohn Marino       datum <<= 8 - (dest_offset_bits + nbits);
1480cf7f2e2dSJohn Marino       mask <<= 8 - (dest_offset_bits + nbits);
1481cf7f2e2dSJohn Marino     }
1482cf7f2e2dSJohn Marino   else
1483cf7f2e2dSJohn Marino     {
1484cf7f2e2dSJohn Marino       datum <<= dest_offset_bits;
1485cf7f2e2dSJohn Marino       mask <<= dest_offset_bits;
1486cf7f2e2dSJohn Marino     }
1487cf7f2e2dSJohn Marino 
1488cf7f2e2dSJohn Marino   gdb_assert ((datum & ~mask) == 0);
1489cf7f2e2dSJohn Marino 
1490cf7f2e2dSJohn Marino   *dest = (*dest & ~mask) | datum;
1491cf7f2e2dSJohn Marino }
1492cf7f2e2dSJohn Marino 
1493cf7f2e2dSJohn Marino /* Copy bits from a source to a destination.
1494cf7f2e2dSJohn Marino 
1495cf7f2e2dSJohn Marino    DEST is where the bits should be written.
1496cf7f2e2dSJohn Marino    DEST_OFFSET_BITS is the bit offset into DEST.
1497cf7f2e2dSJohn Marino    SOURCE is the source of bits.
1498cf7f2e2dSJohn Marino    SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1499cf7f2e2dSJohn Marino    BIT_COUNT is the number of bits to copy.
1500cf7f2e2dSJohn Marino    BITS_BIG_ENDIAN is taken directly from gdbarch.  */
1501cf7f2e2dSJohn Marino 
1502cf7f2e2dSJohn Marino static void
copy_bitwise(gdb_byte * dest,unsigned int dest_offset_bits,const gdb_byte * source,unsigned int source_offset_bits,unsigned int bit_count,int bits_big_endian)1503cf7f2e2dSJohn Marino copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
1504cf7f2e2dSJohn Marino 	      const gdb_byte *source, unsigned int source_offset_bits,
1505cf7f2e2dSJohn Marino 	      unsigned int bit_count,
1506cf7f2e2dSJohn Marino 	      int bits_big_endian)
1507cf7f2e2dSJohn Marino {
1508cf7f2e2dSJohn Marino   unsigned int dest_avail;
1509cf7f2e2dSJohn Marino   int datum;
1510cf7f2e2dSJohn Marino 
1511cf7f2e2dSJohn Marino   /* Reduce everything to byte-size pieces.  */
1512cf7f2e2dSJohn Marino   dest += dest_offset_bits / 8;
1513cf7f2e2dSJohn Marino   dest_offset_bits %= 8;
1514cf7f2e2dSJohn Marino   source += source_offset_bits / 8;
1515cf7f2e2dSJohn Marino   source_offset_bits %= 8;
1516cf7f2e2dSJohn Marino 
1517cf7f2e2dSJohn Marino   dest_avail = 8 - dest_offset_bits % 8;
1518cf7f2e2dSJohn Marino 
1519cf7f2e2dSJohn Marino   /* See if we can fill the first destination byte.  */
1520cf7f2e2dSJohn Marino   if (dest_avail < bit_count)
1521cf7f2e2dSJohn Marino     {
1522cf7f2e2dSJohn Marino       datum = extract_bits (&source, &source_offset_bits, dest_avail,
1523cf7f2e2dSJohn Marino 			    bits_big_endian);
1524cf7f2e2dSJohn Marino       insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1525cf7f2e2dSJohn Marino       ++dest;
1526cf7f2e2dSJohn Marino       dest_offset_bits = 0;
1527cf7f2e2dSJohn Marino       bit_count -= dest_avail;
1528cf7f2e2dSJohn Marino     }
1529cf7f2e2dSJohn Marino 
1530cf7f2e2dSJohn Marino   /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1531cf7f2e2dSJohn Marino      than 8 bits remaining.  */
1532cf7f2e2dSJohn Marino   gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1533cf7f2e2dSJohn Marino   for (; bit_count >= 8; bit_count -= 8)
1534cf7f2e2dSJohn Marino     {
1535cf7f2e2dSJohn Marino       datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1536cf7f2e2dSJohn Marino       *dest++ = (gdb_byte) datum;
1537cf7f2e2dSJohn Marino     }
1538cf7f2e2dSJohn Marino 
1539cf7f2e2dSJohn Marino   /* Finally, we may have a few leftover bits.  */
1540cf7f2e2dSJohn Marino   gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1541cf7f2e2dSJohn Marino   if (bit_count > 0)
1542cf7f2e2dSJohn Marino     {
1543cf7f2e2dSJohn Marino       datum = extract_bits (&source, &source_offset_bits, bit_count,
1544cf7f2e2dSJohn Marino 			    bits_big_endian);
1545cf7f2e2dSJohn Marino       insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1546cf7f2e2dSJohn Marino     }
1547cf7f2e2dSJohn Marino }
1548cf7f2e2dSJohn Marino 
15495796c8dcSSimon Schubert static void
read_pieced_value(struct value * v)15505796c8dcSSimon Schubert read_pieced_value (struct value *v)
15515796c8dcSSimon Schubert {
15525796c8dcSSimon Schubert   int i;
15535796c8dcSSimon Schubert   long offset = 0;
1554cf7f2e2dSJohn Marino   ULONGEST bits_to_skip;
15555796c8dcSSimon Schubert   gdb_byte *contents;
1556c50c785cSJohn Marino   struct piece_closure *c
1557c50c785cSJohn Marino     = (struct piece_closure *) value_computed_closure (v);
15585796c8dcSSimon Schubert   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
1559cf7f2e2dSJohn Marino   size_t type_len;
1560cf7f2e2dSJohn Marino   size_t buffer_size = 0;
1561cf7f2e2dSJohn Marino   char *buffer = NULL;
1562cf7f2e2dSJohn Marino   struct cleanup *cleanup;
1563cf7f2e2dSJohn Marino   int bits_big_endian
1564cf7f2e2dSJohn Marino     = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
1565cf7f2e2dSJohn Marino 
1566cf7f2e2dSJohn Marino   if (value_type (v) != value_enclosing_type (v))
1567cf7f2e2dSJohn Marino     internal_error (__FILE__, __LINE__,
1568cf7f2e2dSJohn Marino 		    _("Should not be able to create a lazy value with "
1569cf7f2e2dSJohn Marino 		      "an enclosing type"));
1570cf7f2e2dSJohn Marino 
1571cf7f2e2dSJohn Marino   cleanup = make_cleanup (free_current_contents, &buffer);
15725796c8dcSSimon Schubert 
15735796c8dcSSimon Schubert   contents = value_contents_raw (v);
1574cf7f2e2dSJohn Marino   bits_to_skip = 8 * value_offset (v);
1575cf7f2e2dSJohn Marino   if (value_bitsize (v))
1576cf7f2e2dSJohn Marino     {
1577cf7f2e2dSJohn Marino       bits_to_skip += value_bitpos (v);
1578cf7f2e2dSJohn Marino       type_len = value_bitsize (v);
1579cf7f2e2dSJohn Marino     }
1580cf7f2e2dSJohn Marino   else
1581cf7f2e2dSJohn Marino     type_len = 8 * TYPE_LENGTH (value_type (v));
1582cf7f2e2dSJohn Marino 
1583cf7f2e2dSJohn Marino   for (i = 0; i < c->n_pieces && offset < type_len; i++)
15845796c8dcSSimon Schubert     {
15855796c8dcSSimon Schubert       struct dwarf_expr_piece *p = &c->pieces[i];
1586cf7f2e2dSJohn Marino       size_t this_size, this_size_bits;
1587cf7f2e2dSJohn Marino       long dest_offset_bits, source_offset_bits, source_offset;
1588cf7f2e2dSJohn Marino       const gdb_byte *intermediate_buffer;
1589cf7f2e2dSJohn Marino 
1590cf7f2e2dSJohn Marino       /* Compute size, source, and destination offsets for copying, in
1591cf7f2e2dSJohn Marino 	 bits.  */
1592cf7f2e2dSJohn Marino       this_size_bits = p->size;
1593cf7f2e2dSJohn Marino       if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1594cf7f2e2dSJohn Marino 	{
1595cf7f2e2dSJohn Marino 	  bits_to_skip -= this_size_bits;
1596cf7f2e2dSJohn Marino 	  continue;
1597cf7f2e2dSJohn Marino 	}
1598cf7f2e2dSJohn Marino       if (this_size_bits > type_len - offset)
1599cf7f2e2dSJohn Marino 	this_size_bits = type_len - offset;
1600cf7f2e2dSJohn Marino       if (bits_to_skip > 0)
1601cf7f2e2dSJohn Marino 	{
1602cf7f2e2dSJohn Marino 	  dest_offset_bits = 0;
1603cf7f2e2dSJohn Marino 	  source_offset_bits = bits_to_skip;
1604cf7f2e2dSJohn Marino 	  this_size_bits -= bits_to_skip;
1605cf7f2e2dSJohn Marino 	  bits_to_skip = 0;
1606cf7f2e2dSJohn Marino 	}
1607cf7f2e2dSJohn Marino       else
1608cf7f2e2dSJohn Marino 	{
1609cf7f2e2dSJohn Marino 	  dest_offset_bits = offset;
1610cf7f2e2dSJohn Marino 	  source_offset_bits = 0;
1611cf7f2e2dSJohn Marino 	}
1612cf7f2e2dSJohn Marino 
1613cf7f2e2dSJohn Marino       this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1614cf7f2e2dSJohn Marino       source_offset = source_offset_bits / 8;
1615cf7f2e2dSJohn Marino       if (buffer_size < this_size)
1616cf7f2e2dSJohn Marino 	{
1617cf7f2e2dSJohn Marino 	  buffer_size = this_size;
1618cf7f2e2dSJohn Marino 	  buffer = xrealloc (buffer, buffer_size);
1619cf7f2e2dSJohn Marino 	}
1620cf7f2e2dSJohn Marino       intermediate_buffer = buffer;
1621cf7f2e2dSJohn Marino 
1622cf7f2e2dSJohn Marino       /* Copy from the source to DEST_BUFFER.  */
16235796c8dcSSimon Schubert       switch (p->location)
16245796c8dcSSimon Schubert 	{
16255796c8dcSSimon Schubert 	case DWARF_VALUE_REGISTER:
16265796c8dcSSimon Schubert 	  {
16275796c8dcSSimon Schubert 	    struct gdbarch *arch = get_frame_arch (frame);
1628a45ae5f8SJohn Marino 	    int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1629cf7f2e2dSJohn Marino 	    int reg_offset = source_offset;
1630cf7f2e2dSJohn Marino 
1631cf7f2e2dSJohn Marino 	    if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1632cf7f2e2dSJohn Marino 		&& this_size < register_size (arch, gdb_regnum))
1633cf7f2e2dSJohn Marino 	      {
1634cf7f2e2dSJohn Marino 		/* Big-endian, and we want less than full size.  */
1635cf7f2e2dSJohn Marino 		reg_offset = register_size (arch, gdb_regnum) - this_size;
1636cf7f2e2dSJohn Marino 		/* We want the lower-order THIS_SIZE_BITS of the bytes
1637cf7f2e2dSJohn Marino 		   we extract from the register.  */
1638cf7f2e2dSJohn Marino 		source_offset_bits += 8 * this_size - this_size_bits;
1639cf7f2e2dSJohn Marino 	      }
1640cf7f2e2dSJohn Marino 
1641cf7f2e2dSJohn Marino 	    if (gdb_regnum != -1)
1642cf7f2e2dSJohn Marino 	      {
1643c50c785cSJohn Marino 		int optim, unavail;
1644c50c785cSJohn Marino 
1645c50c785cSJohn Marino 		if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1646c50c785cSJohn Marino 					       this_size, buffer,
1647c50c785cSJohn Marino 					       &optim, &unavail))
1648c50c785cSJohn Marino 		  {
1649c50c785cSJohn Marino 		    /* Just so garbage doesn't ever shine through.  */
1650c50c785cSJohn Marino 		    memset (buffer, 0, this_size);
1651c50c785cSJohn Marino 
1652c50c785cSJohn Marino 		    if (optim)
1653c50c785cSJohn Marino 		      set_value_optimized_out (v, 1);
1654c50c785cSJohn Marino 		    if (unavail)
1655c50c785cSJohn Marino 		      mark_value_bytes_unavailable (v, offset, this_size);
1656c50c785cSJohn Marino 		  }
1657cf7f2e2dSJohn Marino 	      }
1658cf7f2e2dSJohn Marino 	    else
1659cf7f2e2dSJohn Marino 	      {
1660cf7f2e2dSJohn Marino 		error (_("Unable to access DWARF register number %s"),
1661a45ae5f8SJohn Marino 		       paddress (arch, p->v.regno));
1662cf7f2e2dSJohn Marino 	      }
16635796c8dcSSimon Schubert 	  }
16645796c8dcSSimon Schubert 	  break;
16655796c8dcSSimon Schubert 
16665796c8dcSSimon Schubert 	case DWARF_VALUE_MEMORY:
1667c50c785cSJohn Marino 	  read_value_memory (v, offset,
1668c50c785cSJohn Marino 			     p->v.mem.in_stack_memory,
1669c50c785cSJohn Marino 			     p->v.mem.addr + source_offset,
1670c50c785cSJohn Marino 			     buffer, this_size);
16715796c8dcSSimon Schubert 	  break;
16725796c8dcSSimon Schubert 
16735796c8dcSSimon Schubert 	case DWARF_VALUE_STACK:
16745796c8dcSSimon Schubert 	  {
1675cf7f2e2dSJohn Marino 	    size_t n = this_size;
1676cf7f2e2dSJohn Marino 
1677cf7f2e2dSJohn Marino 	    if (n > c->addr_size - source_offset)
1678cf7f2e2dSJohn Marino 	      n = (c->addr_size >= source_offset
1679cf7f2e2dSJohn Marino 		   ? c->addr_size - source_offset
1680cf7f2e2dSJohn Marino 		   : 0);
1681cf7f2e2dSJohn Marino 	    if (n == 0)
1682cf7f2e2dSJohn Marino 	      {
1683cf7f2e2dSJohn Marino 		/* Nothing.  */
1684cf7f2e2dSJohn Marino 	      }
1685cf7f2e2dSJohn Marino 	    else
1686cf7f2e2dSJohn Marino 	      {
1687a45ae5f8SJohn Marino 		const gdb_byte *val_bytes = value_contents_all (p->v.value);
1688cf7f2e2dSJohn Marino 
1689a45ae5f8SJohn Marino 		intermediate_buffer = val_bytes + source_offset;
1690cf7f2e2dSJohn Marino 	      }
16915796c8dcSSimon Schubert 	  }
16925796c8dcSSimon Schubert 	  break;
16935796c8dcSSimon Schubert 
16945796c8dcSSimon Schubert 	case DWARF_VALUE_LITERAL:
16955796c8dcSSimon Schubert 	  {
1696cf7f2e2dSJohn Marino 	    size_t n = this_size;
1697cf7f2e2dSJohn Marino 
1698cf7f2e2dSJohn Marino 	    if (n > p->v.literal.length - source_offset)
1699cf7f2e2dSJohn Marino 	      n = (p->v.literal.length >= source_offset
1700cf7f2e2dSJohn Marino 		   ? p->v.literal.length - source_offset
1701cf7f2e2dSJohn Marino 		   : 0);
1702cf7f2e2dSJohn Marino 	    if (n != 0)
1703cf7f2e2dSJohn Marino 	      intermediate_buffer = p->v.literal.data + source_offset;
17045796c8dcSSimon Schubert 	  }
17055796c8dcSSimon Schubert 	  break;
17065796c8dcSSimon Schubert 
1707c50c785cSJohn Marino 	  /* These bits show up as zeros -- but do not cause the value
1708c50c785cSJohn Marino 	     to be considered optimized-out.  */
1709c50c785cSJohn Marino 	case DWARF_VALUE_IMPLICIT_POINTER:
1710c50c785cSJohn Marino 	  break;
1711c50c785cSJohn Marino 
1712cf7f2e2dSJohn Marino 	case DWARF_VALUE_OPTIMIZED_OUT:
1713cf7f2e2dSJohn Marino 	  set_value_optimized_out (v, 1);
1714cf7f2e2dSJohn Marino 	  break;
1715cf7f2e2dSJohn Marino 
17165796c8dcSSimon Schubert 	default:
17175796c8dcSSimon Schubert 	  internal_error (__FILE__, __LINE__, _("invalid location type"));
17185796c8dcSSimon Schubert 	}
1719cf7f2e2dSJohn Marino 
1720c50c785cSJohn Marino       if (p->location != DWARF_VALUE_OPTIMIZED_OUT
1721c50c785cSJohn Marino 	  && p->location != DWARF_VALUE_IMPLICIT_POINTER)
1722cf7f2e2dSJohn Marino 	copy_bitwise (contents, dest_offset_bits,
1723cf7f2e2dSJohn Marino 		      intermediate_buffer, source_offset_bits % 8,
1724cf7f2e2dSJohn Marino 		      this_size_bits, bits_big_endian);
1725cf7f2e2dSJohn Marino 
1726cf7f2e2dSJohn Marino       offset += this_size_bits;
17275796c8dcSSimon Schubert     }
1728cf7f2e2dSJohn Marino 
1729cf7f2e2dSJohn Marino   do_cleanups (cleanup);
17305796c8dcSSimon Schubert }
17315796c8dcSSimon Schubert 
17325796c8dcSSimon Schubert static void
write_pieced_value(struct value * to,struct value * from)17335796c8dcSSimon Schubert write_pieced_value (struct value *to, struct value *from)
17345796c8dcSSimon Schubert {
17355796c8dcSSimon Schubert   int i;
17365796c8dcSSimon Schubert   long offset = 0;
1737cf7f2e2dSJohn Marino   ULONGEST bits_to_skip;
1738cf7f2e2dSJohn Marino   const gdb_byte *contents;
1739c50c785cSJohn Marino   struct piece_closure *c
1740c50c785cSJohn Marino     = (struct piece_closure *) value_computed_closure (to);
17415796c8dcSSimon Schubert   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
1742cf7f2e2dSJohn Marino   size_t type_len;
1743cf7f2e2dSJohn Marino   size_t buffer_size = 0;
1744cf7f2e2dSJohn Marino   char *buffer = NULL;
1745cf7f2e2dSJohn Marino   struct cleanup *cleanup;
1746cf7f2e2dSJohn Marino   int bits_big_endian
1747cf7f2e2dSJohn Marino     = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
17485796c8dcSSimon Schubert 
17495796c8dcSSimon Schubert   if (frame == NULL)
17505796c8dcSSimon Schubert     {
17515796c8dcSSimon Schubert       set_value_optimized_out (to, 1);
17525796c8dcSSimon Schubert       return;
17535796c8dcSSimon Schubert     }
17545796c8dcSSimon Schubert 
1755cf7f2e2dSJohn Marino   cleanup = make_cleanup (free_current_contents, &buffer);
1756cf7f2e2dSJohn Marino 
1757cf7f2e2dSJohn Marino   contents = value_contents (from);
1758cf7f2e2dSJohn Marino   bits_to_skip = 8 * value_offset (to);
1759cf7f2e2dSJohn Marino   if (value_bitsize (to))
1760cf7f2e2dSJohn Marino     {
1761cf7f2e2dSJohn Marino       bits_to_skip += value_bitpos (to);
1762cf7f2e2dSJohn Marino       type_len = value_bitsize (to);
1763cf7f2e2dSJohn Marino     }
1764cf7f2e2dSJohn Marino   else
1765cf7f2e2dSJohn Marino     type_len = 8 * TYPE_LENGTH (value_type (to));
1766cf7f2e2dSJohn Marino 
1767cf7f2e2dSJohn Marino   for (i = 0; i < c->n_pieces && offset < type_len; i++)
17685796c8dcSSimon Schubert     {
17695796c8dcSSimon Schubert       struct dwarf_expr_piece *p = &c->pieces[i];
1770cf7f2e2dSJohn Marino       size_t this_size_bits, this_size;
1771cf7f2e2dSJohn Marino       long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1772cf7f2e2dSJohn Marino       int need_bitwise;
1773cf7f2e2dSJohn Marino       const gdb_byte *source_buffer;
1774cf7f2e2dSJohn Marino 
1775cf7f2e2dSJohn Marino       this_size_bits = p->size;
1776cf7f2e2dSJohn Marino       if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1777cf7f2e2dSJohn Marino 	{
1778cf7f2e2dSJohn Marino 	  bits_to_skip -= this_size_bits;
1779cf7f2e2dSJohn Marino 	  continue;
1780cf7f2e2dSJohn Marino 	}
1781cf7f2e2dSJohn Marino       if (this_size_bits > type_len - offset)
1782cf7f2e2dSJohn Marino 	this_size_bits = type_len - offset;
1783cf7f2e2dSJohn Marino       if (bits_to_skip > 0)
1784cf7f2e2dSJohn Marino 	{
1785cf7f2e2dSJohn Marino 	  dest_offset_bits = bits_to_skip;
1786cf7f2e2dSJohn Marino 	  source_offset_bits = 0;
1787cf7f2e2dSJohn Marino 	  this_size_bits -= bits_to_skip;
1788cf7f2e2dSJohn Marino 	  bits_to_skip = 0;
1789cf7f2e2dSJohn Marino 	}
1790cf7f2e2dSJohn Marino       else
1791cf7f2e2dSJohn Marino 	{
1792cf7f2e2dSJohn Marino 	  dest_offset_bits = 0;
1793cf7f2e2dSJohn Marino 	  source_offset_bits = offset;
1794cf7f2e2dSJohn Marino 	}
1795cf7f2e2dSJohn Marino 
1796cf7f2e2dSJohn Marino       this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1797cf7f2e2dSJohn Marino       source_offset = source_offset_bits / 8;
1798cf7f2e2dSJohn Marino       dest_offset = dest_offset_bits / 8;
1799cf7f2e2dSJohn Marino       if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1800cf7f2e2dSJohn Marino 	{
1801cf7f2e2dSJohn Marino 	  source_buffer = contents + source_offset;
1802cf7f2e2dSJohn Marino 	  need_bitwise = 0;
1803cf7f2e2dSJohn Marino 	}
1804cf7f2e2dSJohn Marino       else
1805cf7f2e2dSJohn Marino 	{
1806cf7f2e2dSJohn Marino 	  if (buffer_size < this_size)
1807cf7f2e2dSJohn Marino 	    {
1808cf7f2e2dSJohn Marino 	      buffer_size = this_size;
1809cf7f2e2dSJohn Marino 	      buffer = xrealloc (buffer, buffer_size);
1810cf7f2e2dSJohn Marino 	    }
1811cf7f2e2dSJohn Marino 	  source_buffer = buffer;
1812cf7f2e2dSJohn Marino 	  need_bitwise = 1;
1813cf7f2e2dSJohn Marino 	}
1814cf7f2e2dSJohn Marino 
18155796c8dcSSimon Schubert       switch (p->location)
18165796c8dcSSimon Schubert 	{
18175796c8dcSSimon Schubert 	case DWARF_VALUE_REGISTER:
18185796c8dcSSimon Schubert 	  {
18195796c8dcSSimon Schubert 	    struct gdbarch *arch = get_frame_arch (frame);
1820a45ae5f8SJohn Marino 	    int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
1821cf7f2e2dSJohn Marino 	    int reg_offset = dest_offset;
1822cf7f2e2dSJohn Marino 
1823cf7f2e2dSJohn Marino 	    if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1824cf7f2e2dSJohn Marino 		&& this_size <= register_size (arch, gdb_regnum))
1825cf7f2e2dSJohn Marino 	      /* Big-endian, and we want less than full size.  */
1826cf7f2e2dSJohn Marino 	      reg_offset = register_size (arch, gdb_regnum) - this_size;
1827cf7f2e2dSJohn Marino 
1828cf7f2e2dSJohn Marino 	    if (gdb_regnum != -1)
1829cf7f2e2dSJohn Marino 	      {
1830cf7f2e2dSJohn Marino 		if (need_bitwise)
1831cf7f2e2dSJohn Marino 		  {
1832c50c785cSJohn Marino 		    int optim, unavail;
1833c50c785cSJohn Marino 
1834c50c785cSJohn Marino 		    if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1835c50c785cSJohn Marino 						   this_size, buffer,
1836c50c785cSJohn Marino 						   &optim, &unavail))
1837c50c785cSJohn Marino 		      {
1838c50c785cSJohn Marino 			if (optim)
1839c50c785cSJohn Marino 			  error (_("Can't do read-modify-write to "
1840c50c785cSJohn Marino 				   "update bitfield; containing word has been "
1841c50c785cSJohn Marino 				   "optimized out"));
1842c50c785cSJohn Marino 			if (unavail)
1843c50c785cSJohn Marino 			  throw_error (NOT_AVAILABLE_ERROR,
1844c50c785cSJohn Marino 				       _("Can't do read-modify-write to update "
1845c50c785cSJohn Marino 					 "bitfield; containing word "
1846c50c785cSJohn Marino 					 "is unavailable"));
1847c50c785cSJohn Marino 		      }
1848cf7f2e2dSJohn Marino 		    copy_bitwise (buffer, dest_offset_bits,
1849cf7f2e2dSJohn Marino 				  contents, source_offset_bits,
1850cf7f2e2dSJohn Marino 				  this_size_bits,
1851cf7f2e2dSJohn Marino 				  bits_big_endian);
1852cf7f2e2dSJohn Marino 		  }
1853cf7f2e2dSJohn Marino 
1854cf7f2e2dSJohn Marino 		put_frame_register_bytes (frame, gdb_regnum, reg_offset,
1855cf7f2e2dSJohn Marino 					  this_size, source_buffer);
1856cf7f2e2dSJohn Marino 	      }
1857cf7f2e2dSJohn Marino 	    else
1858cf7f2e2dSJohn Marino 	      {
1859cf7f2e2dSJohn Marino 		error (_("Unable to write to DWARF register number %s"),
1860a45ae5f8SJohn Marino 		       paddress (arch, p->v.regno));
1861cf7f2e2dSJohn Marino 	      }
18625796c8dcSSimon Schubert 	  }
18635796c8dcSSimon Schubert 	  break;
18645796c8dcSSimon Schubert 	case DWARF_VALUE_MEMORY:
1865cf7f2e2dSJohn Marino 	  if (need_bitwise)
1866cf7f2e2dSJohn Marino 	    {
1867cf7f2e2dSJohn Marino 	      /* Only the first and last bytes can possibly have any
1868cf7f2e2dSJohn Marino 		 bits reused.  */
1869cf7f2e2dSJohn Marino 	      read_memory (p->v.mem.addr + dest_offset, buffer, 1);
1870cf7f2e2dSJohn Marino 	      read_memory (p->v.mem.addr + dest_offset + this_size - 1,
1871cf7f2e2dSJohn Marino 			   buffer + this_size - 1, 1);
1872cf7f2e2dSJohn Marino 	      copy_bitwise (buffer, dest_offset_bits,
1873cf7f2e2dSJohn Marino 			    contents, source_offset_bits,
1874cf7f2e2dSJohn Marino 			    this_size_bits,
1875cf7f2e2dSJohn Marino 			    bits_big_endian);
1876cf7f2e2dSJohn Marino 	    }
1877cf7f2e2dSJohn Marino 
1878cf7f2e2dSJohn Marino 	  write_memory (p->v.mem.addr + dest_offset,
1879cf7f2e2dSJohn Marino 			source_buffer, this_size);
18805796c8dcSSimon Schubert 	  break;
18815796c8dcSSimon Schubert 	default:
18825796c8dcSSimon Schubert 	  set_value_optimized_out (to, 1);
1883cf7f2e2dSJohn Marino 	  break;
18845796c8dcSSimon Schubert 	}
1885cf7f2e2dSJohn Marino       offset += this_size_bits;
18865796c8dcSSimon Schubert     }
1887cf7f2e2dSJohn Marino 
1888cf7f2e2dSJohn Marino   do_cleanups (cleanup);
1889cf7f2e2dSJohn Marino }
1890cf7f2e2dSJohn Marino 
1891c50c785cSJohn Marino /* A helper function that checks bit validity in a pieced value.
1892c50c785cSJohn Marino    CHECK_FOR indicates the kind of validity checking.
1893c50c785cSJohn Marino    DWARF_VALUE_MEMORY means to check whether any bit is valid.
1894c50c785cSJohn Marino    DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
1895c50c785cSJohn Marino    optimized out.
1896c50c785cSJohn Marino    DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
1897c50c785cSJohn Marino    implicit pointer.  */
1898c50c785cSJohn Marino 
1899cf7f2e2dSJohn Marino static int
check_pieced_value_bits(const struct value * value,int bit_offset,int bit_length,enum dwarf_value_location check_for)1900cf7f2e2dSJohn Marino check_pieced_value_bits (const struct value *value, int bit_offset,
1901c50c785cSJohn Marino 			 int bit_length,
1902c50c785cSJohn Marino 			 enum dwarf_value_location check_for)
1903cf7f2e2dSJohn Marino {
1904cf7f2e2dSJohn Marino   struct piece_closure *c
1905cf7f2e2dSJohn Marino     = (struct piece_closure *) value_computed_closure (value);
1906cf7f2e2dSJohn Marino   int i;
1907c50c785cSJohn Marino   int validity = (check_for == DWARF_VALUE_MEMORY
1908c50c785cSJohn Marino 		  || check_for == DWARF_VALUE_IMPLICIT_POINTER);
1909cf7f2e2dSJohn Marino 
1910cf7f2e2dSJohn Marino   bit_offset += 8 * value_offset (value);
1911cf7f2e2dSJohn Marino   if (value_bitsize (value))
1912cf7f2e2dSJohn Marino     bit_offset += value_bitpos (value);
1913cf7f2e2dSJohn Marino 
1914cf7f2e2dSJohn Marino   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1915cf7f2e2dSJohn Marino     {
1916cf7f2e2dSJohn Marino       struct dwarf_expr_piece *p = &c->pieces[i];
1917cf7f2e2dSJohn Marino       size_t this_size_bits = p->size;
1918cf7f2e2dSJohn Marino 
1919cf7f2e2dSJohn Marino       if (bit_offset > 0)
1920cf7f2e2dSJohn Marino 	{
1921cf7f2e2dSJohn Marino 	  if (bit_offset >= this_size_bits)
1922cf7f2e2dSJohn Marino 	    {
1923cf7f2e2dSJohn Marino 	      bit_offset -= this_size_bits;
1924cf7f2e2dSJohn Marino 	      continue;
1925cf7f2e2dSJohn Marino 	    }
1926cf7f2e2dSJohn Marino 
1927cf7f2e2dSJohn Marino 	  bit_length -= this_size_bits - bit_offset;
1928cf7f2e2dSJohn Marino 	  bit_offset = 0;
1929cf7f2e2dSJohn Marino 	}
1930cf7f2e2dSJohn Marino       else
1931cf7f2e2dSJohn Marino 	bit_length -= this_size_bits;
1932cf7f2e2dSJohn Marino 
1933c50c785cSJohn Marino       if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
1934c50c785cSJohn Marino 	{
1935c50c785cSJohn Marino 	  if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
1936c50c785cSJohn Marino 	    return 0;
1937c50c785cSJohn Marino 	}
1938c50c785cSJohn Marino       else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
1939c50c785cSJohn Marino 	       || p->location == DWARF_VALUE_IMPLICIT_POINTER)
1940cf7f2e2dSJohn Marino 	{
1941cf7f2e2dSJohn Marino 	  if (validity)
1942cf7f2e2dSJohn Marino 	    return 0;
1943cf7f2e2dSJohn Marino 	}
1944cf7f2e2dSJohn Marino       else
1945cf7f2e2dSJohn Marino 	{
1946cf7f2e2dSJohn Marino 	  if (!validity)
1947cf7f2e2dSJohn Marino 	    return 1;
1948cf7f2e2dSJohn Marino 	}
1949cf7f2e2dSJohn Marino     }
1950cf7f2e2dSJohn Marino 
1951cf7f2e2dSJohn Marino   return validity;
1952cf7f2e2dSJohn Marino }
1953cf7f2e2dSJohn Marino 
1954cf7f2e2dSJohn Marino static int
check_pieced_value_validity(const struct value * value,int bit_offset,int bit_length)1955cf7f2e2dSJohn Marino check_pieced_value_validity (const struct value *value, int bit_offset,
1956cf7f2e2dSJohn Marino 			     int bit_length)
1957cf7f2e2dSJohn Marino {
1958c50c785cSJohn Marino   return check_pieced_value_bits (value, bit_offset, bit_length,
1959c50c785cSJohn Marino 				  DWARF_VALUE_MEMORY);
1960cf7f2e2dSJohn Marino }
1961cf7f2e2dSJohn Marino 
1962cf7f2e2dSJohn Marino static int
check_pieced_value_invalid(const struct value * value)1963cf7f2e2dSJohn Marino check_pieced_value_invalid (const struct value *value)
1964cf7f2e2dSJohn Marino {
1965cf7f2e2dSJohn Marino   return check_pieced_value_bits (value, 0,
1966c50c785cSJohn Marino 				  8 * TYPE_LENGTH (value_type (value)),
1967c50c785cSJohn Marino 				  DWARF_VALUE_OPTIMIZED_OUT);
1968c50c785cSJohn Marino }
1969c50c785cSJohn Marino 
1970c50c785cSJohn Marino /* An implementation of an lval_funcs method to see whether a value is
1971c50c785cSJohn Marino    a synthetic pointer.  */
1972c50c785cSJohn Marino 
1973c50c785cSJohn Marino static int
check_pieced_synthetic_pointer(const struct value * value,int bit_offset,int bit_length)1974c50c785cSJohn Marino check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
1975c50c785cSJohn Marino 				int bit_length)
1976c50c785cSJohn Marino {
1977c50c785cSJohn Marino   return check_pieced_value_bits (value, bit_offset, bit_length,
1978c50c785cSJohn Marino 				  DWARF_VALUE_IMPLICIT_POINTER);
1979c50c785cSJohn Marino }
1980c50c785cSJohn Marino 
1981c50c785cSJohn Marino /* A wrapper function for get_frame_address_in_block.  */
1982c50c785cSJohn Marino 
1983c50c785cSJohn Marino static CORE_ADDR
get_frame_address_in_block_wrapper(void * baton)1984c50c785cSJohn Marino get_frame_address_in_block_wrapper (void *baton)
1985c50c785cSJohn Marino {
1986c50c785cSJohn Marino   return get_frame_address_in_block (baton);
1987c50c785cSJohn Marino }
1988c50c785cSJohn Marino 
1989c50c785cSJohn Marino /* An implementation of an lval_funcs method to indirect through a
1990c50c785cSJohn Marino    pointer.  This handles the synthetic pointer case when needed.  */
1991c50c785cSJohn Marino 
1992c50c785cSJohn Marino static struct value *
indirect_pieced_value(struct value * value)1993c50c785cSJohn Marino indirect_pieced_value (struct value *value)
1994c50c785cSJohn Marino {
1995c50c785cSJohn Marino   struct piece_closure *c
1996c50c785cSJohn Marino     = (struct piece_closure *) value_computed_closure (value);
1997c50c785cSJohn Marino   struct type *type;
1998c50c785cSJohn Marino   struct frame_info *frame;
1999c50c785cSJohn Marino   struct dwarf2_locexpr_baton baton;
2000c50c785cSJohn Marino   int i, bit_offset, bit_length;
2001c50c785cSJohn Marino   struct dwarf_expr_piece *piece = NULL;
2002c50c785cSJohn Marino   LONGEST byte_offset;
2003c50c785cSJohn Marino 
2004a45ae5f8SJohn Marino   type = check_typedef (value_type (value));
2005c50c785cSJohn Marino   if (TYPE_CODE (type) != TYPE_CODE_PTR)
2006c50c785cSJohn Marino     return NULL;
2007c50c785cSJohn Marino 
2008c50c785cSJohn Marino   bit_length = 8 * TYPE_LENGTH (type);
2009c50c785cSJohn Marino   bit_offset = 8 * value_offset (value);
2010c50c785cSJohn Marino   if (value_bitsize (value))
2011c50c785cSJohn Marino     bit_offset += value_bitpos (value);
2012c50c785cSJohn Marino 
2013c50c785cSJohn Marino   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
2014c50c785cSJohn Marino     {
2015c50c785cSJohn Marino       struct dwarf_expr_piece *p = &c->pieces[i];
2016c50c785cSJohn Marino       size_t this_size_bits = p->size;
2017c50c785cSJohn Marino 
2018c50c785cSJohn Marino       if (bit_offset > 0)
2019c50c785cSJohn Marino 	{
2020c50c785cSJohn Marino 	  if (bit_offset >= this_size_bits)
2021c50c785cSJohn Marino 	    {
2022c50c785cSJohn Marino 	      bit_offset -= this_size_bits;
2023c50c785cSJohn Marino 	      continue;
2024c50c785cSJohn Marino 	    }
2025c50c785cSJohn Marino 
2026c50c785cSJohn Marino 	  bit_length -= this_size_bits - bit_offset;
2027c50c785cSJohn Marino 	  bit_offset = 0;
2028c50c785cSJohn Marino 	}
2029c50c785cSJohn Marino       else
2030c50c785cSJohn Marino 	bit_length -= this_size_bits;
2031c50c785cSJohn Marino 
2032c50c785cSJohn Marino       if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
2033c50c785cSJohn Marino 	return NULL;
2034c50c785cSJohn Marino 
2035c50c785cSJohn Marino       if (bit_length != 0)
2036c50c785cSJohn Marino 	error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2037c50c785cSJohn Marino 
2038c50c785cSJohn Marino       piece = p;
2039c50c785cSJohn Marino       break;
2040c50c785cSJohn Marino     }
2041c50c785cSJohn Marino 
2042c50c785cSJohn Marino   frame = get_selected_frame (_("No frame selected."));
2043a45ae5f8SJohn Marino 
2044a45ae5f8SJohn Marino   /* This is an offset requested by GDB, such as value subcripts.  */
2045c50c785cSJohn Marino   byte_offset = value_as_address (value);
2046c50c785cSJohn Marino 
2047c50c785cSJohn Marino   gdb_assert (piece);
2048*ef5ccd6cSJohn Marino   baton
2049*ef5ccd6cSJohn Marino     = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
2050c50c785cSJohn Marino 				     get_frame_address_in_block_wrapper,
2051c50c785cSJohn Marino 				     frame);
2052c50c785cSJohn Marino 
2053a45ae5f8SJohn Marino   return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
2054c50c785cSJohn Marino 					baton.data, baton.size, baton.per_cu,
2055a45ae5f8SJohn Marino 					piece->v.ptr.offset + byte_offset);
20565796c8dcSSimon Schubert }
20575796c8dcSSimon Schubert 
20585796c8dcSSimon Schubert static void *
copy_pieced_value_closure(const struct value * v)2059cf7f2e2dSJohn Marino copy_pieced_value_closure (const struct value *v)
20605796c8dcSSimon Schubert {
2061c50c785cSJohn Marino   struct piece_closure *c
2062c50c785cSJohn Marino     = (struct piece_closure *) value_computed_closure (v);
20635796c8dcSSimon Schubert 
2064cf7f2e2dSJohn Marino   ++c->refc;
2065cf7f2e2dSJohn Marino   return c;
20665796c8dcSSimon Schubert }
20675796c8dcSSimon Schubert 
20685796c8dcSSimon Schubert static void
free_pieced_value_closure(struct value * v)20695796c8dcSSimon Schubert free_pieced_value_closure (struct value *v)
20705796c8dcSSimon Schubert {
2071c50c785cSJohn Marino   struct piece_closure *c
2072c50c785cSJohn Marino     = (struct piece_closure *) value_computed_closure (v);
20735796c8dcSSimon Schubert 
2074cf7f2e2dSJohn Marino   --c->refc;
2075cf7f2e2dSJohn Marino   if (c->refc == 0)
2076cf7f2e2dSJohn Marino     {
2077a45ae5f8SJohn Marino       int i;
2078a45ae5f8SJohn Marino 
2079a45ae5f8SJohn Marino       for (i = 0; i < c->n_pieces; ++i)
2080a45ae5f8SJohn Marino 	if (c->pieces[i].location == DWARF_VALUE_STACK)
2081a45ae5f8SJohn Marino 	  value_free (c->pieces[i].v.value);
2082a45ae5f8SJohn Marino 
20835796c8dcSSimon Schubert       xfree (c->pieces);
20845796c8dcSSimon Schubert       xfree (c);
20855796c8dcSSimon Schubert     }
2086cf7f2e2dSJohn Marino }
20875796c8dcSSimon Schubert 
20885796c8dcSSimon Schubert /* Functions for accessing a variable described by DW_OP_piece.  */
2089a45ae5f8SJohn Marino static const struct lval_funcs pieced_value_funcs = {
20905796c8dcSSimon Schubert   read_pieced_value,
20915796c8dcSSimon Schubert   write_pieced_value,
2092cf7f2e2dSJohn Marino   check_pieced_value_validity,
2093cf7f2e2dSJohn Marino   check_pieced_value_invalid,
2094c50c785cSJohn Marino   indirect_pieced_value,
2095a45ae5f8SJohn Marino   NULL,	/* coerce_ref */
2096c50c785cSJohn Marino   check_pieced_synthetic_pointer,
20975796c8dcSSimon Schubert   copy_pieced_value_closure,
20985796c8dcSSimon Schubert   free_pieced_value_closure
20995796c8dcSSimon Schubert };
21005796c8dcSSimon Schubert 
2101c50c785cSJohn Marino /* Helper function which throws an error if a synthetic pointer is
2102c50c785cSJohn Marino    invalid.  */
2103c50c785cSJohn Marino 
2104c50c785cSJohn Marino static void
invalid_synthetic_pointer(void)2105c50c785cSJohn Marino invalid_synthetic_pointer (void)
2106c50c785cSJohn Marino {
2107c50c785cSJohn Marino   error (_("access outside bounds of object "
2108c50c785cSJohn Marino 	   "referenced via synthetic pointer"));
2109c50c785cSJohn Marino }
2110c50c785cSJohn Marino 
2111a45ae5f8SJohn Marino /* Virtual method table for dwarf2_evaluate_loc_desc_full below.  */
2112a45ae5f8SJohn Marino 
2113a45ae5f8SJohn Marino static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
2114a45ae5f8SJohn Marino {
2115a45ae5f8SJohn Marino   dwarf_expr_read_reg,
2116a45ae5f8SJohn Marino   dwarf_expr_read_mem,
2117a45ae5f8SJohn Marino   dwarf_expr_frame_base,
2118a45ae5f8SJohn Marino   dwarf_expr_frame_cfa,
2119a45ae5f8SJohn Marino   dwarf_expr_frame_pc,
2120a45ae5f8SJohn Marino   dwarf_expr_tls_address,
2121a45ae5f8SJohn Marino   dwarf_expr_dwarf_call,
2122a45ae5f8SJohn Marino   dwarf_expr_get_base_type,
2123*ef5ccd6cSJohn Marino   dwarf_expr_push_dwarf_reg_entry_value,
2124*ef5ccd6cSJohn Marino   dwarf_expr_get_addr_index
2125a45ae5f8SJohn Marino };
2126a45ae5f8SJohn Marino 
21275796c8dcSSimon Schubert /* Evaluate a location description, starting at DATA and with length
2128c50c785cSJohn Marino    SIZE, to find the current location of variable of TYPE in the
2129c50c785cSJohn Marino    context of FRAME.  BYTE_OFFSET is applied after the contents are
2130c50c785cSJohn Marino    computed.  */
2131cf7f2e2dSJohn Marino 
21325796c8dcSSimon Schubert static struct value *
dwarf2_evaluate_loc_desc_full(struct type * type,struct frame_info * frame,const gdb_byte * data,size_t size,struct dwarf2_per_cu_data * per_cu,LONGEST byte_offset)2133c50c785cSJohn Marino dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
2134*ef5ccd6cSJohn Marino 			       const gdb_byte *data, size_t size,
2135c50c785cSJohn Marino 			       struct dwarf2_per_cu_data *per_cu,
2136c50c785cSJohn Marino 			       LONGEST byte_offset)
21375796c8dcSSimon Schubert {
21385796c8dcSSimon Schubert   struct value *retval;
21395796c8dcSSimon Schubert   struct dwarf_expr_baton baton;
21405796c8dcSSimon Schubert   struct dwarf_expr_context *ctx;
2141a45ae5f8SJohn Marino   struct cleanup *old_chain, *value_chain;
2142cf7f2e2dSJohn Marino   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2143c50c785cSJohn Marino   volatile struct gdb_exception ex;
2144c50c785cSJohn Marino 
2145c50c785cSJohn Marino   if (byte_offset < 0)
2146c50c785cSJohn Marino     invalid_synthetic_pointer ();
21475796c8dcSSimon Schubert 
21485796c8dcSSimon Schubert   if (size == 0)
2149a45ae5f8SJohn Marino     return allocate_optimized_out_value (type);
21505796c8dcSSimon Schubert 
21515796c8dcSSimon Schubert   baton.frame = frame;
2152cf7f2e2dSJohn Marino   baton.per_cu = per_cu;
21535796c8dcSSimon Schubert 
21545796c8dcSSimon Schubert   ctx = new_dwarf_expr_context ();
21555796c8dcSSimon Schubert   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2156a45ae5f8SJohn Marino   value_chain = make_cleanup_value_free_to_mark (value_mark ());
21575796c8dcSSimon Schubert 
2158cf7f2e2dSJohn Marino   ctx->gdbarch = get_objfile_arch (objfile);
21595796c8dcSSimon Schubert   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2160a45ae5f8SJohn Marino   ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2161cf7f2e2dSJohn Marino   ctx->offset = dwarf2_per_cu_text_offset (per_cu);
21625796c8dcSSimon Schubert   ctx->baton = &baton;
2163a45ae5f8SJohn Marino   ctx->funcs = &dwarf_expr_ctx_funcs;
21645796c8dcSSimon Schubert 
2165c50c785cSJohn Marino   TRY_CATCH (ex, RETURN_MASK_ERROR)
2166c50c785cSJohn Marino     {
21675796c8dcSSimon Schubert       dwarf_expr_eval (ctx, data, size);
2168c50c785cSJohn Marino     }
2169c50c785cSJohn Marino   if (ex.reason < 0)
2170c50c785cSJohn Marino     {
2171c50c785cSJohn Marino       if (ex.error == NOT_AVAILABLE_ERROR)
2172c50c785cSJohn Marino 	{
2173a45ae5f8SJohn Marino 	  do_cleanups (old_chain);
2174c50c785cSJohn Marino 	  retval = allocate_value (type);
2175c50c785cSJohn Marino 	  mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
2176c50c785cSJohn Marino 	  return retval;
2177c50c785cSJohn Marino 	}
2178a45ae5f8SJohn Marino       else if (ex.error == NO_ENTRY_VALUE_ERROR)
2179a45ae5f8SJohn Marino 	{
2180a45ae5f8SJohn Marino 	  if (entry_values_debug)
2181a45ae5f8SJohn Marino 	    exception_print (gdb_stdout, ex);
2182a45ae5f8SJohn Marino 	  do_cleanups (old_chain);
2183a45ae5f8SJohn Marino 	  return allocate_optimized_out_value (type);
2184a45ae5f8SJohn Marino 	}
2185c50c785cSJohn Marino       else
2186c50c785cSJohn Marino 	throw_exception (ex);
2187c50c785cSJohn Marino     }
2188c50c785cSJohn Marino 
21895796c8dcSSimon Schubert   if (ctx->num_pieces > 0)
21905796c8dcSSimon Schubert     {
21915796c8dcSSimon Schubert       struct piece_closure *c;
21925796c8dcSSimon Schubert       struct frame_id frame_id = get_frame_id (frame);
2193c50c785cSJohn Marino       ULONGEST bit_size = 0;
2194c50c785cSJohn Marino       int i;
21955796c8dcSSimon Schubert 
2196c50c785cSJohn Marino       for (i = 0; i < ctx->num_pieces; ++i)
2197c50c785cSJohn Marino 	bit_size += ctx->pieces[i].size;
2198c50c785cSJohn Marino       if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
2199c50c785cSJohn Marino 	invalid_synthetic_pointer ();
2200c50c785cSJohn Marino 
2201c50c785cSJohn Marino       c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
2202cf7f2e2dSJohn Marino 				  ctx->addr_size);
2203a45ae5f8SJohn Marino       /* We must clean up the value chain after creating the piece
2204a45ae5f8SJohn Marino 	 closure but before allocating the result.  */
2205a45ae5f8SJohn Marino       do_cleanups (value_chain);
2206cf7f2e2dSJohn Marino       retval = allocate_computed_value (type, &pieced_value_funcs, c);
22075796c8dcSSimon Schubert       VALUE_FRAME_ID (retval) = frame_id;
2208c50c785cSJohn Marino       set_value_offset (retval, byte_offset);
22095796c8dcSSimon Schubert     }
22105796c8dcSSimon Schubert   else
22115796c8dcSSimon Schubert     {
22125796c8dcSSimon Schubert       switch (ctx->location)
22135796c8dcSSimon Schubert 	{
22145796c8dcSSimon Schubert 	case DWARF_VALUE_REGISTER:
22155796c8dcSSimon Schubert 	  {
22165796c8dcSSimon Schubert 	    struct gdbarch *arch = get_frame_arch (frame);
2217a45ae5f8SJohn Marino 	    ULONGEST dwarf_regnum = value_as_long (dwarf_expr_fetch (ctx, 0));
22185796c8dcSSimon Schubert 	    int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
2219cf7f2e2dSJohn Marino 
2220c50c785cSJohn Marino 	    if (byte_offset != 0)
2221c50c785cSJohn Marino 	      error (_("cannot use offset on synthetic pointer to register"));
2222a45ae5f8SJohn Marino 	    do_cleanups (value_chain);
2223cf7f2e2dSJohn Marino 	    if (gdb_regnum != -1)
2224cf7f2e2dSJohn Marino 	      retval = value_from_register (type, gdb_regnum, frame);
2225cf7f2e2dSJohn Marino 	    else
2226cf7f2e2dSJohn Marino 	      error (_("Unable to access DWARF register number %s"),
2227cf7f2e2dSJohn Marino 		     paddress (arch, dwarf_regnum));
22285796c8dcSSimon Schubert 	  }
22295796c8dcSSimon Schubert 	  break;
22305796c8dcSSimon Schubert 
22315796c8dcSSimon Schubert 	case DWARF_VALUE_MEMORY:
22325796c8dcSSimon Schubert 	  {
2233cf7f2e2dSJohn Marino 	    CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
22345796c8dcSSimon Schubert 	    int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
22355796c8dcSSimon Schubert 
2236a45ae5f8SJohn Marino 	    do_cleanups (value_chain);
2237c50c785cSJohn Marino 	    retval = allocate_value_lazy (type);
22385796c8dcSSimon Schubert 	    VALUE_LVAL (retval) = lval_memory;
22395796c8dcSSimon Schubert 	    if (in_stack_memory)
22405796c8dcSSimon Schubert 	      set_value_stack (retval, 1);
2241c50c785cSJohn Marino 	    set_value_address (retval, address + byte_offset);
22425796c8dcSSimon Schubert 	  }
22435796c8dcSSimon Schubert 	  break;
22445796c8dcSSimon Schubert 
22455796c8dcSSimon Schubert 	case DWARF_VALUE_STACK:
22465796c8dcSSimon Schubert 	  {
2247a45ae5f8SJohn Marino 	    struct value *value = dwarf_expr_fetch (ctx, 0);
2248a45ae5f8SJohn Marino 	    gdb_byte *contents;
2249a45ae5f8SJohn Marino 	    const gdb_byte *val_bytes;
2250a45ae5f8SJohn Marino 	    size_t n = TYPE_LENGTH (value_type (value));
22515796c8dcSSimon Schubert 
2252c50c785cSJohn Marino 	    if (byte_offset + TYPE_LENGTH (type) > n)
2253c50c785cSJohn Marino 	      invalid_synthetic_pointer ();
2254c50c785cSJohn Marino 
2255a45ae5f8SJohn Marino 	    val_bytes = value_contents_all (value);
2256a45ae5f8SJohn Marino 	    val_bytes += byte_offset;
2257c50c785cSJohn Marino 	    n -= byte_offset;
2258c50c785cSJohn Marino 
2259a45ae5f8SJohn Marino 	    /* Preserve VALUE because we are going to free values back
2260a45ae5f8SJohn Marino 	       to the mark, but we still need the value contents
2261a45ae5f8SJohn Marino 	       below.  */
2262a45ae5f8SJohn Marino 	    value_incref (value);
2263a45ae5f8SJohn Marino 	    do_cleanups (value_chain);
2264a45ae5f8SJohn Marino 	    make_cleanup_value_free (value);
2265a45ae5f8SJohn Marino 
2266cf7f2e2dSJohn Marino 	    retval = allocate_value (type);
2267cf7f2e2dSJohn Marino 	    contents = value_contents_raw (retval);
2268cf7f2e2dSJohn Marino 	    if (n > TYPE_LENGTH (type))
2269a45ae5f8SJohn Marino 	      {
2270a45ae5f8SJohn Marino 		struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2271a45ae5f8SJohn Marino 
2272a45ae5f8SJohn Marino 		if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2273a45ae5f8SJohn Marino 		  val_bytes += n - TYPE_LENGTH (type);
2274cf7f2e2dSJohn Marino 		n = TYPE_LENGTH (type);
2275a45ae5f8SJohn Marino 	      }
2276a45ae5f8SJohn Marino 	    memcpy (contents, val_bytes, n);
22775796c8dcSSimon Schubert 	  }
22785796c8dcSSimon Schubert 	  break;
22795796c8dcSSimon Schubert 
22805796c8dcSSimon Schubert 	case DWARF_VALUE_LITERAL:
22815796c8dcSSimon Schubert 	  {
22825796c8dcSSimon Schubert 	    bfd_byte *contents;
2283c50c785cSJohn Marino 	    const bfd_byte *ldata;
22845796c8dcSSimon Schubert 	    size_t n = ctx->len;
22855796c8dcSSimon Schubert 
2286c50c785cSJohn Marino 	    if (byte_offset + TYPE_LENGTH (type) > n)
2287c50c785cSJohn Marino 	      invalid_synthetic_pointer ();
2288c50c785cSJohn Marino 
2289a45ae5f8SJohn Marino 	    do_cleanups (value_chain);
2290cf7f2e2dSJohn Marino 	    retval = allocate_value (type);
22915796c8dcSSimon Schubert 	    contents = value_contents_raw (retval);
2292c50c785cSJohn Marino 
2293c50c785cSJohn Marino 	    ldata = ctx->data + byte_offset;
2294c50c785cSJohn Marino 	    n -= byte_offset;
2295c50c785cSJohn Marino 
2296cf7f2e2dSJohn Marino 	    if (n > TYPE_LENGTH (type))
2297a45ae5f8SJohn Marino 	      {
2298a45ae5f8SJohn Marino 		struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2299a45ae5f8SJohn Marino 
2300a45ae5f8SJohn Marino 		if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2301a45ae5f8SJohn Marino 		  ldata += n - TYPE_LENGTH (type);
2302cf7f2e2dSJohn Marino 		n = TYPE_LENGTH (type);
2303a45ae5f8SJohn Marino 	      }
2304c50c785cSJohn Marino 	    memcpy (contents, ldata, n);
23055796c8dcSSimon Schubert 	  }
23065796c8dcSSimon Schubert 	  break;
23075796c8dcSSimon Schubert 
2308c50c785cSJohn Marino 	case DWARF_VALUE_OPTIMIZED_OUT:
2309a45ae5f8SJohn Marino 	  do_cleanups (value_chain);
2310a45ae5f8SJohn Marino 	  retval = allocate_optimized_out_value (type);
2311c50c785cSJohn Marino 	  break;
2312c50c785cSJohn Marino 
2313c50c785cSJohn Marino 	  /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2314c50c785cSJohn Marino 	     operation by execute_stack_op.  */
2315c50c785cSJohn Marino 	case DWARF_VALUE_IMPLICIT_POINTER:
2316cf7f2e2dSJohn Marino 	  /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2317cf7f2e2dSJohn Marino 	     it can only be encountered when making a piece.  */
23185796c8dcSSimon Schubert 	default:
23195796c8dcSSimon Schubert 	  internal_error (__FILE__, __LINE__, _("invalid location type"));
23205796c8dcSSimon Schubert 	}
23215796c8dcSSimon Schubert     }
23225796c8dcSSimon Schubert 
23235796c8dcSSimon Schubert   set_value_initialized (retval, ctx->initialized);
23245796c8dcSSimon Schubert 
23255796c8dcSSimon Schubert   do_cleanups (old_chain);
23265796c8dcSSimon Schubert 
23275796c8dcSSimon Schubert   return retval;
23285796c8dcSSimon Schubert }
2329c50c785cSJohn Marino 
2330c50c785cSJohn Marino /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2331c50c785cSJohn Marino    passes 0 as the byte_offset.  */
2332c50c785cSJohn Marino 
2333c50c785cSJohn Marino struct value *
dwarf2_evaluate_loc_desc(struct type * type,struct frame_info * frame,const gdb_byte * data,size_t size,struct dwarf2_per_cu_data * per_cu)2334c50c785cSJohn Marino dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
2335*ef5ccd6cSJohn Marino 			  const gdb_byte *data, size_t size,
2336c50c785cSJohn Marino 			  struct dwarf2_per_cu_data *per_cu)
2337c50c785cSJohn Marino {
2338c50c785cSJohn Marino   return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
2339c50c785cSJohn Marino }
2340c50c785cSJohn Marino 
23415796c8dcSSimon Schubert 
23425796c8dcSSimon Schubert /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
23435796c8dcSSimon Schubert 
23445796c8dcSSimon Schubert struct needs_frame_baton
23455796c8dcSSimon Schubert {
23465796c8dcSSimon Schubert   int needs_frame;
2347cf7f2e2dSJohn Marino   struct dwarf2_per_cu_data *per_cu;
23485796c8dcSSimon Schubert };
23495796c8dcSSimon Schubert 
23505796c8dcSSimon Schubert /* Reads from registers do require a frame.  */
23515796c8dcSSimon Schubert static CORE_ADDR
needs_frame_read_reg(void * baton,int regnum)23525796c8dcSSimon Schubert needs_frame_read_reg (void *baton, int regnum)
23535796c8dcSSimon Schubert {
23545796c8dcSSimon Schubert   struct needs_frame_baton *nf_baton = baton;
2355cf7f2e2dSJohn Marino 
23565796c8dcSSimon Schubert   nf_baton->needs_frame = 1;
23575796c8dcSSimon Schubert   return 1;
23585796c8dcSSimon Schubert }
23595796c8dcSSimon Schubert 
23605796c8dcSSimon Schubert /* Reads from memory do not require a frame.  */
23615796c8dcSSimon Schubert static void
needs_frame_read_mem(void * baton,gdb_byte * buf,CORE_ADDR addr,size_t len)23625796c8dcSSimon Schubert needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
23635796c8dcSSimon Schubert {
23645796c8dcSSimon Schubert   memset (buf, 0, len);
23655796c8dcSSimon Schubert }
23665796c8dcSSimon Schubert 
23675796c8dcSSimon Schubert /* Frame-relative accesses do require a frame.  */
23685796c8dcSSimon Schubert static void
needs_frame_frame_base(void * baton,const gdb_byte ** start,size_t * length)2369cf7f2e2dSJohn Marino needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
23705796c8dcSSimon Schubert {
23715796c8dcSSimon Schubert   static gdb_byte lit0 = DW_OP_lit0;
23725796c8dcSSimon Schubert   struct needs_frame_baton *nf_baton = baton;
23735796c8dcSSimon Schubert 
23745796c8dcSSimon Schubert   *start = &lit0;
23755796c8dcSSimon Schubert   *length = 1;
23765796c8dcSSimon Schubert 
23775796c8dcSSimon Schubert   nf_baton->needs_frame = 1;
23785796c8dcSSimon Schubert }
23795796c8dcSSimon Schubert 
23805796c8dcSSimon Schubert /* CFA accesses require a frame.  */
23815796c8dcSSimon Schubert 
23825796c8dcSSimon Schubert static CORE_ADDR
needs_frame_frame_cfa(void * baton)23835796c8dcSSimon Schubert needs_frame_frame_cfa (void *baton)
23845796c8dcSSimon Schubert {
23855796c8dcSSimon Schubert   struct needs_frame_baton *nf_baton = baton;
2386cf7f2e2dSJohn Marino 
23875796c8dcSSimon Schubert   nf_baton->needs_frame = 1;
23885796c8dcSSimon Schubert   return 1;
23895796c8dcSSimon Schubert }
23905796c8dcSSimon Schubert 
23915796c8dcSSimon Schubert /* Thread-local accesses do require a frame.  */
23925796c8dcSSimon Schubert static CORE_ADDR
needs_frame_tls_address(void * baton,CORE_ADDR offset)23935796c8dcSSimon Schubert needs_frame_tls_address (void *baton, CORE_ADDR offset)
23945796c8dcSSimon Schubert {
23955796c8dcSSimon Schubert   struct needs_frame_baton *nf_baton = baton;
2396cf7f2e2dSJohn Marino 
23975796c8dcSSimon Schubert   nf_baton->needs_frame = 1;
23985796c8dcSSimon Schubert   return 1;
23995796c8dcSSimon Schubert }
24005796c8dcSSimon Schubert 
2401cf7f2e2dSJohn Marino /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame.  */
2402cf7f2e2dSJohn Marino 
2403cf7f2e2dSJohn Marino static void
needs_frame_dwarf_call(struct dwarf_expr_context * ctx,cu_offset die_offset)2404*ef5ccd6cSJohn Marino needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
2405cf7f2e2dSJohn Marino {
2406cf7f2e2dSJohn Marino   struct needs_frame_baton *nf_baton = ctx->baton;
2407cf7f2e2dSJohn Marino 
2408c50c785cSJohn Marino   per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
2409a45ae5f8SJohn Marino 		     ctx->funcs->get_frame_pc, ctx->baton);
2410cf7f2e2dSJohn Marino }
2411cf7f2e2dSJohn Marino 
2412a45ae5f8SJohn Marino /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame.  */
2413a45ae5f8SJohn Marino 
2414a45ae5f8SJohn Marino static void
needs_dwarf_reg_entry_value(struct dwarf_expr_context * ctx,enum call_site_parameter_kind kind,union call_site_parameter_u kind_u,int deref_size)2415a45ae5f8SJohn Marino needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
2416*ef5ccd6cSJohn Marino 			     enum call_site_parameter_kind kind,
2417*ef5ccd6cSJohn Marino 			     union call_site_parameter_u kind_u, int deref_size)
2418a45ae5f8SJohn Marino {
2419a45ae5f8SJohn Marino   struct needs_frame_baton *nf_baton = ctx->baton;
2420a45ae5f8SJohn Marino 
2421a45ae5f8SJohn Marino   nf_baton->needs_frame = 1;
2422*ef5ccd6cSJohn Marino 
2423*ef5ccd6cSJohn Marino   /* The expression may require some stub values on DWARF stack.  */
2424*ef5ccd6cSJohn Marino   dwarf_expr_push_address (ctx, 0, 0);
2425*ef5ccd6cSJohn Marino }
2426*ef5ccd6cSJohn Marino 
2427*ef5ccd6cSJohn Marino /* DW_OP_GNU_addr_index doesn't require a frame.  */
2428*ef5ccd6cSJohn Marino 
2429*ef5ccd6cSJohn Marino static CORE_ADDR
needs_get_addr_index(void * baton,unsigned int index)2430*ef5ccd6cSJohn Marino needs_get_addr_index (void *baton, unsigned int index)
2431*ef5ccd6cSJohn Marino {
2432*ef5ccd6cSJohn Marino   /* Nothing to do.  */
2433*ef5ccd6cSJohn Marino   return 1;
2434a45ae5f8SJohn Marino }
2435a45ae5f8SJohn Marino 
2436a45ae5f8SJohn Marino /* Virtual method table for dwarf2_loc_desc_needs_frame below.  */
2437a45ae5f8SJohn Marino 
2438a45ae5f8SJohn Marino static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
2439a45ae5f8SJohn Marino {
2440a45ae5f8SJohn Marino   needs_frame_read_reg,
2441a45ae5f8SJohn Marino   needs_frame_read_mem,
2442a45ae5f8SJohn Marino   needs_frame_frame_base,
2443a45ae5f8SJohn Marino   needs_frame_frame_cfa,
2444a45ae5f8SJohn Marino   needs_frame_frame_cfa,	/* get_frame_pc */
2445a45ae5f8SJohn Marino   needs_frame_tls_address,
2446a45ae5f8SJohn Marino   needs_frame_dwarf_call,
2447a45ae5f8SJohn Marino   NULL,				/* get_base_type */
2448*ef5ccd6cSJohn Marino   needs_dwarf_reg_entry_value,
2449*ef5ccd6cSJohn Marino   needs_get_addr_index
2450a45ae5f8SJohn Marino };
2451a45ae5f8SJohn Marino 
24525796c8dcSSimon Schubert /* Return non-zero iff the location expression at DATA (length SIZE)
24535796c8dcSSimon Schubert    requires a frame to evaluate.  */
24545796c8dcSSimon Schubert 
24555796c8dcSSimon Schubert static int
dwarf2_loc_desc_needs_frame(const gdb_byte * data,size_t size,struct dwarf2_per_cu_data * per_cu)2456*ef5ccd6cSJohn Marino dwarf2_loc_desc_needs_frame (const gdb_byte *data, size_t size,
24575796c8dcSSimon Schubert 			     struct dwarf2_per_cu_data *per_cu)
24585796c8dcSSimon Schubert {
24595796c8dcSSimon Schubert   struct needs_frame_baton baton;
24605796c8dcSSimon Schubert   struct dwarf_expr_context *ctx;
24615796c8dcSSimon Schubert   int in_reg;
24625796c8dcSSimon Schubert   struct cleanup *old_chain;
2463cf7f2e2dSJohn Marino   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
24645796c8dcSSimon Schubert 
24655796c8dcSSimon Schubert   baton.needs_frame = 0;
2466cf7f2e2dSJohn Marino   baton.per_cu = per_cu;
24675796c8dcSSimon Schubert 
24685796c8dcSSimon Schubert   ctx = new_dwarf_expr_context ();
24695796c8dcSSimon Schubert   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2470a45ae5f8SJohn Marino   make_cleanup_value_free_to_mark (value_mark ());
24715796c8dcSSimon Schubert 
2472cf7f2e2dSJohn Marino   ctx->gdbarch = get_objfile_arch (objfile);
24735796c8dcSSimon Schubert   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2474a45ae5f8SJohn Marino   ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
2475cf7f2e2dSJohn Marino   ctx->offset = dwarf2_per_cu_text_offset (per_cu);
24765796c8dcSSimon Schubert   ctx->baton = &baton;
2477a45ae5f8SJohn Marino   ctx->funcs = &needs_frame_ctx_funcs;
24785796c8dcSSimon Schubert 
24795796c8dcSSimon Schubert   dwarf_expr_eval (ctx, data, size);
24805796c8dcSSimon Schubert 
24815796c8dcSSimon Schubert   in_reg = ctx->location == DWARF_VALUE_REGISTER;
24825796c8dcSSimon Schubert 
24835796c8dcSSimon Schubert   if (ctx->num_pieces > 0)
24845796c8dcSSimon Schubert     {
24855796c8dcSSimon Schubert       int i;
24865796c8dcSSimon Schubert 
24875796c8dcSSimon Schubert       /* If the location has several pieces, and any of them are in
24885796c8dcSSimon Schubert          registers, then we will need a frame to fetch them from.  */
24895796c8dcSSimon Schubert       for (i = 0; i < ctx->num_pieces; i++)
24905796c8dcSSimon Schubert         if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
24915796c8dcSSimon Schubert           in_reg = 1;
24925796c8dcSSimon Schubert     }
24935796c8dcSSimon Schubert 
24945796c8dcSSimon Schubert   do_cleanups (old_chain);
24955796c8dcSSimon Schubert 
24965796c8dcSSimon Schubert   return baton.needs_frame || in_reg;
24975796c8dcSSimon Schubert }
24985796c8dcSSimon Schubert 
2499cf7f2e2dSJohn Marino /* A helper function that throws an unimplemented error mentioning a
2500cf7f2e2dSJohn Marino    given DWARF operator.  */
2501cf7f2e2dSJohn Marino 
25025796c8dcSSimon Schubert static void
unimplemented(unsigned int op)2503cf7f2e2dSJohn Marino unimplemented (unsigned int op)
25045796c8dcSSimon Schubert {
2505*ef5ccd6cSJohn Marino   const char *name = get_DW_OP_name (op);
2506c50c785cSJohn Marino 
2507c50c785cSJohn Marino   if (name)
2508cf7f2e2dSJohn Marino     error (_("DWARF operator %s cannot be translated to an agent expression"),
2509c50c785cSJohn Marino 	   name);
2510c50c785cSJohn Marino   else
2511c50c785cSJohn Marino     error (_("Unknown DWARF operator 0x%02x cannot be translated "
2512c50c785cSJohn Marino 	     "to an agent expression"),
2513c50c785cSJohn Marino 	   op);
25145796c8dcSSimon Schubert }
2515cf7f2e2dSJohn Marino 
2516cf7f2e2dSJohn Marino /* A helper function to convert a DWARF register to an arch register.
2517cf7f2e2dSJohn Marino    ARCH is the architecture.
2518cf7f2e2dSJohn Marino    DWARF_REG is the register.
2519cf7f2e2dSJohn Marino    This will throw an exception if the DWARF register cannot be
2520cf7f2e2dSJohn Marino    translated to an architecture register.  */
2521cf7f2e2dSJohn Marino 
2522cf7f2e2dSJohn Marino static int
translate_register(struct gdbarch * arch,int dwarf_reg)2523cf7f2e2dSJohn Marino translate_register (struct gdbarch *arch, int dwarf_reg)
25245796c8dcSSimon Schubert {
2525cf7f2e2dSJohn Marino   int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
2526cf7f2e2dSJohn Marino   if (reg == -1)
2527cf7f2e2dSJohn Marino     error (_("Unable to access DWARF register number %d"), dwarf_reg);
2528cf7f2e2dSJohn Marino   return reg;
25295796c8dcSSimon Schubert }
2530cf7f2e2dSJohn Marino 
2531cf7f2e2dSJohn Marino /* A helper function that emits an access to memory.  ARCH is the
2532cf7f2e2dSJohn Marino    target architecture.  EXPR is the expression which we are building.
2533cf7f2e2dSJohn Marino    NBITS is the number of bits we want to read.  This emits the
2534cf7f2e2dSJohn Marino    opcodes needed to read the memory and then extract the desired
2535cf7f2e2dSJohn Marino    bits.  */
2536cf7f2e2dSJohn Marino 
2537cf7f2e2dSJohn Marino static void
access_memory(struct gdbarch * arch,struct agent_expr * expr,ULONGEST nbits)2538cf7f2e2dSJohn Marino access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
25395796c8dcSSimon Schubert {
2540cf7f2e2dSJohn Marino   ULONGEST nbytes = (nbits + 7) / 8;
25415796c8dcSSimon Schubert 
2542*ef5ccd6cSJohn Marino   gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));
25435796c8dcSSimon Schubert 
2544cf7f2e2dSJohn Marino   if (trace_kludge)
2545cf7f2e2dSJohn Marino     ax_trace_quick (expr, nbytes);
25465796c8dcSSimon Schubert 
2547cf7f2e2dSJohn Marino   if (nbits <= 8)
2548cf7f2e2dSJohn Marino     ax_simple (expr, aop_ref8);
2549cf7f2e2dSJohn Marino   else if (nbits <= 16)
2550cf7f2e2dSJohn Marino     ax_simple (expr, aop_ref16);
2551cf7f2e2dSJohn Marino   else if (nbits <= 32)
2552cf7f2e2dSJohn Marino     ax_simple (expr, aop_ref32);
2553cf7f2e2dSJohn Marino   else
2554cf7f2e2dSJohn Marino     ax_simple (expr, aop_ref64);
2555cf7f2e2dSJohn Marino 
2556cf7f2e2dSJohn Marino   /* If we read exactly the number of bytes we wanted, we're done.  */
2557cf7f2e2dSJohn Marino   if (8 * nbytes == nbits)
2558cf7f2e2dSJohn Marino     return;
2559cf7f2e2dSJohn Marino 
2560cf7f2e2dSJohn Marino   if (gdbarch_bits_big_endian (arch))
25615796c8dcSSimon Schubert     {
2562cf7f2e2dSJohn Marino       /* On a bits-big-endian machine, we want the high-order
2563cf7f2e2dSJohn Marino 	 NBITS.  */
2564cf7f2e2dSJohn Marino       ax_const_l (expr, 8 * nbytes - nbits);
2565cf7f2e2dSJohn Marino       ax_simple (expr, aop_rsh_unsigned);
25665796c8dcSSimon Schubert     }
25675796c8dcSSimon Schubert   else
2568cf7f2e2dSJohn Marino     {
2569cf7f2e2dSJohn Marino       /* On a bits-little-endian box, we want the low-order NBITS.  */
2570cf7f2e2dSJohn Marino       ax_zero_ext (expr, nbits);
25715796c8dcSSimon Schubert     }
2572cf7f2e2dSJohn Marino }
2573cf7f2e2dSJohn Marino 
2574c50c785cSJohn Marino /* A helper function to return the frame's PC.  */
2575c50c785cSJohn Marino 
2576c50c785cSJohn Marino static CORE_ADDR
get_ax_pc(void * baton)2577c50c785cSJohn Marino get_ax_pc (void *baton)
2578c50c785cSJohn Marino {
2579c50c785cSJohn Marino   struct agent_expr *expr = baton;
2580c50c785cSJohn Marino 
2581c50c785cSJohn Marino   return expr->scope;
2582c50c785cSJohn Marino }
2583c50c785cSJohn Marino 
2584cf7f2e2dSJohn Marino /* Compile a DWARF location expression to an agent expression.
2585cf7f2e2dSJohn Marino 
2586cf7f2e2dSJohn Marino    EXPR is the agent expression we are building.
2587cf7f2e2dSJohn Marino    LOC is the agent value we modify.
2588cf7f2e2dSJohn Marino    ARCH is the architecture.
2589cf7f2e2dSJohn Marino    ADDR_SIZE is the size of addresses, in bytes.
2590cf7f2e2dSJohn Marino    OP_PTR is the start of the location expression.
2591cf7f2e2dSJohn Marino    OP_END is one past the last byte of the location expression.
2592cf7f2e2dSJohn Marino 
2593cf7f2e2dSJohn Marino    This will throw an exception for various kinds of errors -- for
2594cf7f2e2dSJohn Marino    example, if the expression cannot be compiled, or if the expression
2595cf7f2e2dSJohn Marino    is invalid.  */
2596cf7f2e2dSJohn Marino 
2597c50c785cSJohn Marino void
dwarf2_compile_expr_to_ax(struct agent_expr * expr,struct axs_value * loc,struct gdbarch * arch,unsigned int addr_size,const gdb_byte * op_ptr,const gdb_byte * op_end,struct dwarf2_per_cu_data * per_cu)2598c50c785cSJohn Marino dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
2599cf7f2e2dSJohn Marino 			   struct gdbarch *arch, unsigned int addr_size,
2600cf7f2e2dSJohn Marino 			   const gdb_byte *op_ptr, const gdb_byte *op_end,
2601cf7f2e2dSJohn Marino 			   struct dwarf2_per_cu_data *per_cu)
2602cf7f2e2dSJohn Marino {
2603cf7f2e2dSJohn Marino   struct cleanup *cleanups;
2604cf7f2e2dSJohn Marino   int i, *offsets;
2605cf7f2e2dSJohn Marino   VEC(int) *dw_labels = NULL, *patches = NULL;
2606cf7f2e2dSJohn Marino   const gdb_byte * const base = op_ptr;
2607cf7f2e2dSJohn Marino   const gdb_byte *previous_piece = op_ptr;
2608cf7f2e2dSJohn Marino   enum bfd_endian byte_order = gdbarch_byte_order (arch);
2609cf7f2e2dSJohn Marino   ULONGEST bits_collected = 0;
2610cf7f2e2dSJohn Marino   unsigned int addr_size_bits = 8 * addr_size;
2611cf7f2e2dSJohn Marino   int bits_big_endian = gdbarch_bits_big_endian (arch);
2612cf7f2e2dSJohn Marino 
2613cf7f2e2dSJohn Marino   offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
2614cf7f2e2dSJohn Marino   cleanups = make_cleanup (xfree, offsets);
2615cf7f2e2dSJohn Marino 
2616cf7f2e2dSJohn Marino   for (i = 0; i < op_end - op_ptr; ++i)
2617cf7f2e2dSJohn Marino     offsets[i] = -1;
2618cf7f2e2dSJohn Marino 
2619cf7f2e2dSJohn Marino   make_cleanup (VEC_cleanup (int), &dw_labels);
2620cf7f2e2dSJohn Marino   make_cleanup (VEC_cleanup (int), &patches);
2621cf7f2e2dSJohn Marino 
2622cf7f2e2dSJohn Marino   /* By default we are making an address.  */
2623cf7f2e2dSJohn Marino   loc->kind = axs_lvalue_memory;
2624cf7f2e2dSJohn Marino 
2625cf7f2e2dSJohn Marino   while (op_ptr < op_end)
2626cf7f2e2dSJohn Marino     {
2627cf7f2e2dSJohn Marino       enum dwarf_location_atom op = *op_ptr;
2628*ef5ccd6cSJohn Marino       uint64_t uoffset, reg;
2629*ef5ccd6cSJohn Marino       int64_t offset;
2630cf7f2e2dSJohn Marino       int i;
2631cf7f2e2dSJohn Marino 
2632cf7f2e2dSJohn Marino       offsets[op_ptr - base] = expr->len;
2633cf7f2e2dSJohn Marino       ++op_ptr;
2634cf7f2e2dSJohn Marino 
2635cf7f2e2dSJohn Marino       /* Our basic approach to code generation is to map DWARF
2636cf7f2e2dSJohn Marino 	 operations directly to AX operations.  However, there are
2637cf7f2e2dSJohn Marino 	 some differences.
2638cf7f2e2dSJohn Marino 
2639cf7f2e2dSJohn Marino 	 First, DWARF works on address-sized units, but AX always uses
2640cf7f2e2dSJohn Marino 	 LONGEST.  For most operations we simply ignore this
2641cf7f2e2dSJohn Marino 	 difference; instead we generate sign extensions as needed
2642cf7f2e2dSJohn Marino 	 before division and comparison operations.  It would be nice
2643cf7f2e2dSJohn Marino 	 to omit the sign extensions, but there is no way to determine
2644cf7f2e2dSJohn Marino 	 the size of the target's LONGEST.  (This code uses the size
2645cf7f2e2dSJohn Marino 	 of the host LONGEST in some cases -- that is a bug but it is
2646cf7f2e2dSJohn Marino 	 difficult to fix.)
2647cf7f2e2dSJohn Marino 
2648cf7f2e2dSJohn Marino 	 Second, some DWARF operations cannot be translated to AX.
2649cf7f2e2dSJohn Marino 	 For these we simply fail.  See
2650cf7f2e2dSJohn Marino 	 http://sourceware.org/bugzilla/show_bug.cgi?id=11662.  */
2651cf7f2e2dSJohn Marino       switch (op)
2652cf7f2e2dSJohn Marino 	{
2653cf7f2e2dSJohn Marino 	case DW_OP_lit0:
2654cf7f2e2dSJohn Marino 	case DW_OP_lit1:
2655cf7f2e2dSJohn Marino 	case DW_OP_lit2:
2656cf7f2e2dSJohn Marino 	case DW_OP_lit3:
2657cf7f2e2dSJohn Marino 	case DW_OP_lit4:
2658cf7f2e2dSJohn Marino 	case DW_OP_lit5:
2659cf7f2e2dSJohn Marino 	case DW_OP_lit6:
2660cf7f2e2dSJohn Marino 	case DW_OP_lit7:
2661cf7f2e2dSJohn Marino 	case DW_OP_lit8:
2662cf7f2e2dSJohn Marino 	case DW_OP_lit9:
2663cf7f2e2dSJohn Marino 	case DW_OP_lit10:
2664cf7f2e2dSJohn Marino 	case DW_OP_lit11:
2665cf7f2e2dSJohn Marino 	case DW_OP_lit12:
2666cf7f2e2dSJohn Marino 	case DW_OP_lit13:
2667cf7f2e2dSJohn Marino 	case DW_OP_lit14:
2668cf7f2e2dSJohn Marino 	case DW_OP_lit15:
2669cf7f2e2dSJohn Marino 	case DW_OP_lit16:
2670cf7f2e2dSJohn Marino 	case DW_OP_lit17:
2671cf7f2e2dSJohn Marino 	case DW_OP_lit18:
2672cf7f2e2dSJohn Marino 	case DW_OP_lit19:
2673cf7f2e2dSJohn Marino 	case DW_OP_lit20:
2674cf7f2e2dSJohn Marino 	case DW_OP_lit21:
2675cf7f2e2dSJohn Marino 	case DW_OP_lit22:
2676cf7f2e2dSJohn Marino 	case DW_OP_lit23:
2677cf7f2e2dSJohn Marino 	case DW_OP_lit24:
2678cf7f2e2dSJohn Marino 	case DW_OP_lit25:
2679cf7f2e2dSJohn Marino 	case DW_OP_lit26:
2680cf7f2e2dSJohn Marino 	case DW_OP_lit27:
2681cf7f2e2dSJohn Marino 	case DW_OP_lit28:
2682cf7f2e2dSJohn Marino 	case DW_OP_lit29:
2683cf7f2e2dSJohn Marino 	case DW_OP_lit30:
2684cf7f2e2dSJohn Marino 	case DW_OP_lit31:
2685cf7f2e2dSJohn Marino 	  ax_const_l (expr, op - DW_OP_lit0);
2686cf7f2e2dSJohn Marino 	  break;
2687cf7f2e2dSJohn Marino 
2688cf7f2e2dSJohn Marino 	case DW_OP_addr:
2689cf7f2e2dSJohn Marino 	  uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
2690cf7f2e2dSJohn Marino 	  op_ptr += addr_size;
2691cf7f2e2dSJohn Marino 	  /* Some versions of GCC emit DW_OP_addr before
2692cf7f2e2dSJohn Marino 	     DW_OP_GNU_push_tls_address.  In this case the value is an
2693cf7f2e2dSJohn Marino 	     index, not an address.  We don't support things like
2694cf7f2e2dSJohn Marino 	     branching between the address and the TLS op.  */
2695cf7f2e2dSJohn Marino 	  if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
2696cf7f2e2dSJohn Marino 	    uoffset += dwarf2_per_cu_text_offset (per_cu);
2697cf7f2e2dSJohn Marino 	  ax_const_l (expr, uoffset);
2698cf7f2e2dSJohn Marino 	  break;
2699cf7f2e2dSJohn Marino 
2700cf7f2e2dSJohn Marino 	case DW_OP_const1u:
2701cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
2702cf7f2e2dSJohn Marino 	  op_ptr += 1;
2703cf7f2e2dSJohn Marino 	  break;
2704cf7f2e2dSJohn Marino 	case DW_OP_const1s:
2705cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
2706cf7f2e2dSJohn Marino 	  op_ptr += 1;
2707cf7f2e2dSJohn Marino 	  break;
2708cf7f2e2dSJohn Marino 	case DW_OP_const2u:
2709cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
2710cf7f2e2dSJohn Marino 	  op_ptr += 2;
2711cf7f2e2dSJohn Marino 	  break;
2712cf7f2e2dSJohn Marino 	case DW_OP_const2s:
2713cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
2714cf7f2e2dSJohn Marino 	  op_ptr += 2;
2715cf7f2e2dSJohn Marino 	  break;
2716cf7f2e2dSJohn Marino 	case DW_OP_const4u:
2717cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
2718cf7f2e2dSJohn Marino 	  op_ptr += 4;
2719cf7f2e2dSJohn Marino 	  break;
2720cf7f2e2dSJohn Marino 	case DW_OP_const4s:
2721cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
2722cf7f2e2dSJohn Marino 	  op_ptr += 4;
2723cf7f2e2dSJohn Marino 	  break;
2724cf7f2e2dSJohn Marino 	case DW_OP_const8u:
2725cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
2726cf7f2e2dSJohn Marino 	  op_ptr += 8;
2727cf7f2e2dSJohn Marino 	  break;
2728cf7f2e2dSJohn Marino 	case DW_OP_const8s:
2729cf7f2e2dSJohn Marino 	  ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
2730cf7f2e2dSJohn Marino 	  op_ptr += 8;
2731cf7f2e2dSJohn Marino 	  break;
2732cf7f2e2dSJohn Marino 	case DW_OP_constu:
2733*ef5ccd6cSJohn Marino 	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
2734cf7f2e2dSJohn Marino 	  ax_const_l (expr, uoffset);
2735cf7f2e2dSJohn Marino 	  break;
2736cf7f2e2dSJohn Marino 	case DW_OP_consts:
2737*ef5ccd6cSJohn Marino 	  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2738cf7f2e2dSJohn Marino 	  ax_const_l (expr, offset);
2739cf7f2e2dSJohn Marino 	  break;
2740cf7f2e2dSJohn Marino 
2741cf7f2e2dSJohn Marino 	case DW_OP_reg0:
2742cf7f2e2dSJohn Marino 	case DW_OP_reg1:
2743cf7f2e2dSJohn Marino 	case DW_OP_reg2:
2744cf7f2e2dSJohn Marino 	case DW_OP_reg3:
2745cf7f2e2dSJohn Marino 	case DW_OP_reg4:
2746cf7f2e2dSJohn Marino 	case DW_OP_reg5:
2747cf7f2e2dSJohn Marino 	case DW_OP_reg6:
2748cf7f2e2dSJohn Marino 	case DW_OP_reg7:
2749cf7f2e2dSJohn Marino 	case DW_OP_reg8:
2750cf7f2e2dSJohn Marino 	case DW_OP_reg9:
2751cf7f2e2dSJohn Marino 	case DW_OP_reg10:
2752cf7f2e2dSJohn Marino 	case DW_OP_reg11:
2753cf7f2e2dSJohn Marino 	case DW_OP_reg12:
2754cf7f2e2dSJohn Marino 	case DW_OP_reg13:
2755cf7f2e2dSJohn Marino 	case DW_OP_reg14:
2756cf7f2e2dSJohn Marino 	case DW_OP_reg15:
2757cf7f2e2dSJohn Marino 	case DW_OP_reg16:
2758cf7f2e2dSJohn Marino 	case DW_OP_reg17:
2759cf7f2e2dSJohn Marino 	case DW_OP_reg18:
2760cf7f2e2dSJohn Marino 	case DW_OP_reg19:
2761cf7f2e2dSJohn Marino 	case DW_OP_reg20:
2762cf7f2e2dSJohn Marino 	case DW_OP_reg21:
2763cf7f2e2dSJohn Marino 	case DW_OP_reg22:
2764cf7f2e2dSJohn Marino 	case DW_OP_reg23:
2765cf7f2e2dSJohn Marino 	case DW_OP_reg24:
2766cf7f2e2dSJohn Marino 	case DW_OP_reg25:
2767cf7f2e2dSJohn Marino 	case DW_OP_reg26:
2768cf7f2e2dSJohn Marino 	case DW_OP_reg27:
2769cf7f2e2dSJohn Marino 	case DW_OP_reg28:
2770cf7f2e2dSJohn Marino 	case DW_OP_reg29:
2771cf7f2e2dSJohn Marino 	case DW_OP_reg30:
2772cf7f2e2dSJohn Marino 	case DW_OP_reg31:
2773cf7f2e2dSJohn Marino 	  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2774cf7f2e2dSJohn Marino 	  loc->u.reg = translate_register (arch, op - DW_OP_reg0);
2775cf7f2e2dSJohn Marino 	  loc->kind = axs_lvalue_register;
2776cf7f2e2dSJohn Marino 	  break;
2777cf7f2e2dSJohn Marino 
2778cf7f2e2dSJohn Marino 	case DW_OP_regx:
2779*ef5ccd6cSJohn Marino 	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
2780cf7f2e2dSJohn Marino 	  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2781cf7f2e2dSJohn Marino 	  loc->u.reg = translate_register (arch, reg);
2782cf7f2e2dSJohn Marino 	  loc->kind = axs_lvalue_register;
2783cf7f2e2dSJohn Marino 	  break;
2784cf7f2e2dSJohn Marino 
2785cf7f2e2dSJohn Marino 	case DW_OP_implicit_value:
2786cf7f2e2dSJohn Marino 	  {
2787*ef5ccd6cSJohn Marino 	    uint64_t len;
2788cf7f2e2dSJohn Marino 
2789*ef5ccd6cSJohn Marino 	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
2790cf7f2e2dSJohn Marino 	    if (op_ptr + len > op_end)
2791cf7f2e2dSJohn Marino 	      error (_("DW_OP_implicit_value: too few bytes available."));
2792cf7f2e2dSJohn Marino 	    if (len > sizeof (ULONGEST))
2793cf7f2e2dSJohn Marino 	      error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2794cf7f2e2dSJohn Marino 		     (int) len);
2795cf7f2e2dSJohn Marino 
2796cf7f2e2dSJohn Marino 	    ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
2797cf7f2e2dSJohn Marino 							byte_order));
2798cf7f2e2dSJohn Marino 	    op_ptr += len;
2799cf7f2e2dSJohn Marino 	    dwarf_expr_require_composition (op_ptr, op_end,
2800cf7f2e2dSJohn Marino 					    "DW_OP_implicit_value");
2801cf7f2e2dSJohn Marino 
2802cf7f2e2dSJohn Marino 	    loc->kind = axs_rvalue;
2803cf7f2e2dSJohn Marino 	  }
2804cf7f2e2dSJohn Marino 	  break;
2805cf7f2e2dSJohn Marino 
2806cf7f2e2dSJohn Marino 	case DW_OP_stack_value:
2807cf7f2e2dSJohn Marino 	  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
2808cf7f2e2dSJohn Marino 	  loc->kind = axs_rvalue;
2809cf7f2e2dSJohn Marino 	  break;
2810cf7f2e2dSJohn Marino 
2811cf7f2e2dSJohn Marino 	case DW_OP_breg0:
2812cf7f2e2dSJohn Marino 	case DW_OP_breg1:
2813cf7f2e2dSJohn Marino 	case DW_OP_breg2:
2814cf7f2e2dSJohn Marino 	case DW_OP_breg3:
2815cf7f2e2dSJohn Marino 	case DW_OP_breg4:
2816cf7f2e2dSJohn Marino 	case DW_OP_breg5:
2817cf7f2e2dSJohn Marino 	case DW_OP_breg6:
2818cf7f2e2dSJohn Marino 	case DW_OP_breg7:
2819cf7f2e2dSJohn Marino 	case DW_OP_breg8:
2820cf7f2e2dSJohn Marino 	case DW_OP_breg9:
2821cf7f2e2dSJohn Marino 	case DW_OP_breg10:
2822cf7f2e2dSJohn Marino 	case DW_OP_breg11:
2823cf7f2e2dSJohn Marino 	case DW_OP_breg12:
2824cf7f2e2dSJohn Marino 	case DW_OP_breg13:
2825cf7f2e2dSJohn Marino 	case DW_OP_breg14:
2826cf7f2e2dSJohn Marino 	case DW_OP_breg15:
2827cf7f2e2dSJohn Marino 	case DW_OP_breg16:
2828cf7f2e2dSJohn Marino 	case DW_OP_breg17:
2829cf7f2e2dSJohn Marino 	case DW_OP_breg18:
2830cf7f2e2dSJohn Marino 	case DW_OP_breg19:
2831cf7f2e2dSJohn Marino 	case DW_OP_breg20:
2832cf7f2e2dSJohn Marino 	case DW_OP_breg21:
2833cf7f2e2dSJohn Marino 	case DW_OP_breg22:
2834cf7f2e2dSJohn Marino 	case DW_OP_breg23:
2835cf7f2e2dSJohn Marino 	case DW_OP_breg24:
2836cf7f2e2dSJohn Marino 	case DW_OP_breg25:
2837cf7f2e2dSJohn Marino 	case DW_OP_breg26:
2838cf7f2e2dSJohn Marino 	case DW_OP_breg27:
2839cf7f2e2dSJohn Marino 	case DW_OP_breg28:
2840cf7f2e2dSJohn Marino 	case DW_OP_breg29:
2841cf7f2e2dSJohn Marino 	case DW_OP_breg30:
2842cf7f2e2dSJohn Marino 	case DW_OP_breg31:
2843*ef5ccd6cSJohn Marino 	  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2844cf7f2e2dSJohn Marino 	  i = translate_register (arch, op - DW_OP_breg0);
2845cf7f2e2dSJohn Marino 	  ax_reg (expr, i);
2846cf7f2e2dSJohn Marino 	  if (offset != 0)
2847cf7f2e2dSJohn Marino 	    {
2848cf7f2e2dSJohn Marino 	      ax_const_l (expr, offset);
2849cf7f2e2dSJohn Marino 	      ax_simple (expr, aop_add);
2850cf7f2e2dSJohn Marino 	    }
2851cf7f2e2dSJohn Marino 	  break;
2852cf7f2e2dSJohn Marino 	case DW_OP_bregx:
2853cf7f2e2dSJohn Marino 	  {
2854*ef5ccd6cSJohn Marino 	    op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
2855*ef5ccd6cSJohn Marino 	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2856cf7f2e2dSJohn Marino 	    i = translate_register (arch, reg);
2857cf7f2e2dSJohn Marino 	    ax_reg (expr, i);
2858cf7f2e2dSJohn Marino 	    if (offset != 0)
2859cf7f2e2dSJohn Marino 	      {
2860cf7f2e2dSJohn Marino 		ax_const_l (expr, offset);
2861cf7f2e2dSJohn Marino 		ax_simple (expr, aop_add);
2862cf7f2e2dSJohn Marino 	      }
2863cf7f2e2dSJohn Marino 	  }
2864cf7f2e2dSJohn Marino 	  break;
2865cf7f2e2dSJohn Marino 	case DW_OP_fbreg:
2866cf7f2e2dSJohn Marino 	  {
2867cf7f2e2dSJohn Marino 	    const gdb_byte *datastart;
2868cf7f2e2dSJohn Marino 	    size_t datalen;
2869cf7f2e2dSJohn Marino 	    struct block *b;
2870cf7f2e2dSJohn Marino 	    struct symbol *framefunc;
2871cf7f2e2dSJohn Marino 
2872cf7f2e2dSJohn Marino 	    b = block_for_pc (expr->scope);
2873cf7f2e2dSJohn Marino 
2874cf7f2e2dSJohn Marino 	    if (!b)
2875cf7f2e2dSJohn Marino 	      error (_("No block found for address"));
2876cf7f2e2dSJohn Marino 
2877cf7f2e2dSJohn Marino 	    framefunc = block_linkage_function (b);
2878cf7f2e2dSJohn Marino 
2879cf7f2e2dSJohn Marino 	    if (!framefunc)
2880cf7f2e2dSJohn Marino 	      error (_("No function found for block"));
2881cf7f2e2dSJohn Marino 
2882cf7f2e2dSJohn Marino 	    dwarf_expr_frame_base_1 (framefunc, expr->scope,
2883cf7f2e2dSJohn Marino 				     &datastart, &datalen);
2884cf7f2e2dSJohn Marino 
2885*ef5ccd6cSJohn Marino 	    op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2886c50c785cSJohn Marino 	    dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
2887cf7f2e2dSJohn Marino 				       datastart + datalen, per_cu);
2888*ef5ccd6cSJohn Marino 	    if (loc->kind == axs_lvalue_register)
2889*ef5ccd6cSJohn Marino 	      require_rvalue (expr, loc);
2890cf7f2e2dSJohn Marino 
2891cf7f2e2dSJohn Marino 	    if (offset != 0)
2892cf7f2e2dSJohn Marino 	      {
2893cf7f2e2dSJohn Marino 		ax_const_l (expr, offset);
2894cf7f2e2dSJohn Marino 		ax_simple (expr, aop_add);
2895cf7f2e2dSJohn Marino 	      }
2896cf7f2e2dSJohn Marino 
2897cf7f2e2dSJohn Marino 	    loc->kind = axs_lvalue_memory;
2898cf7f2e2dSJohn Marino 	  }
2899cf7f2e2dSJohn Marino 	  break;
2900cf7f2e2dSJohn Marino 
2901cf7f2e2dSJohn Marino 	case DW_OP_dup:
2902cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_dup);
2903cf7f2e2dSJohn Marino 	  break;
2904cf7f2e2dSJohn Marino 
2905cf7f2e2dSJohn Marino 	case DW_OP_drop:
2906cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_pop);
2907cf7f2e2dSJohn Marino 	  break;
2908cf7f2e2dSJohn Marino 
2909cf7f2e2dSJohn Marino 	case DW_OP_pick:
2910cf7f2e2dSJohn Marino 	  offset = *op_ptr++;
2911c50c785cSJohn Marino 	  ax_pick (expr, offset);
2912cf7f2e2dSJohn Marino 	  break;
2913cf7f2e2dSJohn Marino 
2914cf7f2e2dSJohn Marino 	case DW_OP_swap:
2915cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
2916cf7f2e2dSJohn Marino 	  break;
2917cf7f2e2dSJohn Marino 
2918cf7f2e2dSJohn Marino 	case DW_OP_over:
2919c50c785cSJohn Marino 	  ax_pick (expr, 1);
2920cf7f2e2dSJohn Marino 	  break;
2921cf7f2e2dSJohn Marino 
2922cf7f2e2dSJohn Marino 	case DW_OP_rot:
2923c50c785cSJohn Marino 	  ax_simple (expr, aop_rot);
2924cf7f2e2dSJohn Marino 	  break;
2925cf7f2e2dSJohn Marino 
2926cf7f2e2dSJohn Marino 	case DW_OP_deref:
2927cf7f2e2dSJohn Marino 	case DW_OP_deref_size:
2928cf7f2e2dSJohn Marino 	  {
2929cf7f2e2dSJohn Marino 	    int size;
2930cf7f2e2dSJohn Marino 
2931cf7f2e2dSJohn Marino 	    if (op == DW_OP_deref_size)
2932cf7f2e2dSJohn Marino 	      size = *op_ptr++;
2933cf7f2e2dSJohn Marino 	    else
2934cf7f2e2dSJohn Marino 	      size = addr_size;
2935cf7f2e2dSJohn Marino 
2936*ef5ccd6cSJohn Marino 	    if (size != 1 && size != 2 && size != 4 && size != 8)
2937cf7f2e2dSJohn Marino 	      error (_("Unsupported size %d in %s"),
2938*ef5ccd6cSJohn Marino 		     size, get_DW_OP_name (op));
2939*ef5ccd6cSJohn Marino 	    access_memory (arch, expr, size * TARGET_CHAR_BIT);
2940cf7f2e2dSJohn Marino 	  }
2941cf7f2e2dSJohn Marino 	  break;
2942cf7f2e2dSJohn Marino 
2943cf7f2e2dSJohn Marino 	case DW_OP_abs:
2944cf7f2e2dSJohn Marino 	  /* Sign extend the operand.  */
2945cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
2946cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_dup);
2947cf7f2e2dSJohn Marino 	  ax_const_l (expr, 0);
2948cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_less_signed);
2949cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_log_not);
2950cf7f2e2dSJohn Marino 	  i = ax_goto (expr, aop_if_goto);
2951cf7f2e2dSJohn Marino 	  /* We have to emit 0 - X.  */
2952cf7f2e2dSJohn Marino 	  ax_const_l (expr, 0);
2953cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
2954cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_sub);
2955cf7f2e2dSJohn Marino 	  ax_label (expr, i, expr->len);
2956cf7f2e2dSJohn Marino 	  break;
2957cf7f2e2dSJohn Marino 
2958cf7f2e2dSJohn Marino 	case DW_OP_neg:
2959cf7f2e2dSJohn Marino 	  /* No need to sign extend here.  */
2960cf7f2e2dSJohn Marino 	  ax_const_l (expr, 0);
2961cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
2962cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_sub);
2963cf7f2e2dSJohn Marino 	  break;
2964cf7f2e2dSJohn Marino 
2965cf7f2e2dSJohn Marino 	case DW_OP_not:
2966cf7f2e2dSJohn Marino 	  /* Sign extend the operand.  */
2967cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
2968cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_bit_not);
2969cf7f2e2dSJohn Marino 	  break;
2970cf7f2e2dSJohn Marino 
2971cf7f2e2dSJohn Marino 	case DW_OP_plus_uconst:
2972*ef5ccd6cSJohn Marino 	  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
2973cf7f2e2dSJohn Marino 	  /* It would be really weird to emit `DW_OP_plus_uconst 0',
2974cf7f2e2dSJohn Marino 	     but we micro-optimize anyhow.  */
2975cf7f2e2dSJohn Marino 	  if (reg != 0)
2976cf7f2e2dSJohn Marino 	    {
2977cf7f2e2dSJohn Marino 	      ax_const_l (expr, reg);
2978cf7f2e2dSJohn Marino 	      ax_simple (expr, aop_add);
2979cf7f2e2dSJohn Marino 	    }
2980cf7f2e2dSJohn Marino 	  break;
2981cf7f2e2dSJohn Marino 
2982cf7f2e2dSJohn Marino 	case DW_OP_and:
2983cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_bit_and);
2984cf7f2e2dSJohn Marino 	  break;
2985cf7f2e2dSJohn Marino 
2986cf7f2e2dSJohn Marino 	case DW_OP_div:
2987cf7f2e2dSJohn Marino 	  /* Sign extend the operands.  */
2988cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
2989cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
2990cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
2991cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
2992cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_div_signed);
2993cf7f2e2dSJohn Marino 	  break;
2994cf7f2e2dSJohn Marino 
2995cf7f2e2dSJohn Marino 	case DW_OP_minus:
2996cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_sub);
2997cf7f2e2dSJohn Marino 	  break;
2998cf7f2e2dSJohn Marino 
2999cf7f2e2dSJohn Marino 	case DW_OP_mod:
3000cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_rem_unsigned);
3001cf7f2e2dSJohn Marino 	  break;
3002cf7f2e2dSJohn Marino 
3003cf7f2e2dSJohn Marino 	case DW_OP_mul:
3004cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_mul);
3005cf7f2e2dSJohn Marino 	  break;
3006cf7f2e2dSJohn Marino 
3007cf7f2e2dSJohn Marino 	case DW_OP_or:
3008cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_bit_or);
3009cf7f2e2dSJohn Marino 	  break;
3010cf7f2e2dSJohn Marino 
3011cf7f2e2dSJohn Marino 	case DW_OP_plus:
3012cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_add);
3013cf7f2e2dSJohn Marino 	  break;
3014cf7f2e2dSJohn Marino 
3015cf7f2e2dSJohn Marino 	case DW_OP_shl:
3016cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_lsh);
3017cf7f2e2dSJohn Marino 	  break;
3018cf7f2e2dSJohn Marino 
3019cf7f2e2dSJohn Marino 	case DW_OP_shr:
3020cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_rsh_unsigned);
3021cf7f2e2dSJohn Marino 	  break;
3022cf7f2e2dSJohn Marino 
3023cf7f2e2dSJohn Marino 	case DW_OP_shra:
3024cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_rsh_signed);
3025cf7f2e2dSJohn Marino 	  break;
3026cf7f2e2dSJohn Marino 
3027cf7f2e2dSJohn Marino 	case DW_OP_xor:
3028cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_bit_xor);
3029cf7f2e2dSJohn Marino 	  break;
3030cf7f2e2dSJohn Marino 
3031cf7f2e2dSJohn Marino 	case DW_OP_le:
3032cf7f2e2dSJohn Marino 	  /* Sign extend the operands.  */
3033cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3034cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3035cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3036cf7f2e2dSJohn Marino 	  /* Note no swap here: A <= B is !(B < A).  */
3037cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_less_signed);
3038cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_log_not);
3039cf7f2e2dSJohn Marino 	  break;
3040cf7f2e2dSJohn Marino 
3041cf7f2e2dSJohn Marino 	case DW_OP_ge:
3042cf7f2e2dSJohn Marino 	  /* Sign extend the operands.  */
3043cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3044cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3045cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3046cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3047cf7f2e2dSJohn Marino 	  /* A >= B is !(A < B).  */
3048cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_less_signed);
3049cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_log_not);
3050cf7f2e2dSJohn Marino 	  break;
3051cf7f2e2dSJohn Marino 
3052cf7f2e2dSJohn Marino 	case DW_OP_eq:
3053cf7f2e2dSJohn Marino 	  /* Sign extend the operands.  */
3054cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3055cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3056cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3057cf7f2e2dSJohn Marino 	  /* No need for a second swap here.  */
3058cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_equal);
3059cf7f2e2dSJohn Marino 	  break;
3060cf7f2e2dSJohn Marino 
3061cf7f2e2dSJohn Marino 	case DW_OP_lt:
3062cf7f2e2dSJohn Marino 	  /* Sign extend the operands.  */
3063cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3064cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3065cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3066cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3067cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_less_signed);
3068cf7f2e2dSJohn Marino 	  break;
3069cf7f2e2dSJohn Marino 
3070cf7f2e2dSJohn Marino 	case DW_OP_gt:
3071cf7f2e2dSJohn Marino 	  /* Sign extend the operands.  */
3072cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3073cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3074cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3075cf7f2e2dSJohn Marino 	  /* Note no swap here: A > B is B < A.  */
3076cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_less_signed);
3077cf7f2e2dSJohn Marino 	  break;
3078cf7f2e2dSJohn Marino 
3079cf7f2e2dSJohn Marino 	case DW_OP_ne:
3080cf7f2e2dSJohn Marino 	  /* Sign extend the operands.  */
3081cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3082cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_swap);
3083cf7f2e2dSJohn Marino 	  ax_ext (expr, addr_size_bits);
3084cf7f2e2dSJohn Marino 	  /* No need for a swap here.  */
3085cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_equal);
3086cf7f2e2dSJohn Marino 	  ax_simple (expr, aop_log_not);
3087cf7f2e2dSJohn Marino 	  break;
3088cf7f2e2dSJohn Marino 
3089cf7f2e2dSJohn Marino 	case DW_OP_call_frame_cfa:
3090c50c785cSJohn Marino 	  dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
3091c50c785cSJohn Marino 	  loc->kind = axs_lvalue_memory;
3092cf7f2e2dSJohn Marino 	  break;
3093cf7f2e2dSJohn Marino 
3094cf7f2e2dSJohn Marino 	case DW_OP_GNU_push_tls_address:
3095cf7f2e2dSJohn Marino 	  unimplemented (op);
3096cf7f2e2dSJohn Marino 	  break;
3097cf7f2e2dSJohn Marino 
3098cf7f2e2dSJohn Marino 	case DW_OP_skip:
3099cf7f2e2dSJohn Marino 	  offset = extract_signed_integer (op_ptr, 2, byte_order);
3100cf7f2e2dSJohn Marino 	  op_ptr += 2;
3101cf7f2e2dSJohn Marino 	  i = ax_goto (expr, aop_goto);
3102cf7f2e2dSJohn Marino 	  VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3103cf7f2e2dSJohn Marino 	  VEC_safe_push (int, patches, i);
3104cf7f2e2dSJohn Marino 	  break;
3105cf7f2e2dSJohn Marino 
3106cf7f2e2dSJohn Marino 	case DW_OP_bra:
3107cf7f2e2dSJohn Marino 	  offset = extract_signed_integer (op_ptr, 2, byte_order);
3108cf7f2e2dSJohn Marino 	  op_ptr += 2;
3109cf7f2e2dSJohn Marino 	  /* Zero extend the operand.  */
3110cf7f2e2dSJohn Marino 	  ax_zero_ext (expr, addr_size_bits);
3111cf7f2e2dSJohn Marino 	  i = ax_goto (expr, aop_if_goto);
3112cf7f2e2dSJohn Marino 	  VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3113cf7f2e2dSJohn Marino 	  VEC_safe_push (int, patches, i);
3114cf7f2e2dSJohn Marino 	  break;
3115cf7f2e2dSJohn Marino 
3116cf7f2e2dSJohn Marino 	case DW_OP_nop:
3117cf7f2e2dSJohn Marino 	  break;
3118cf7f2e2dSJohn Marino 
3119cf7f2e2dSJohn Marino         case DW_OP_piece:
3120cf7f2e2dSJohn Marino 	case DW_OP_bit_piece:
3121cf7f2e2dSJohn Marino 	  {
3122*ef5ccd6cSJohn Marino 	    uint64_t size, offset;
3123cf7f2e2dSJohn Marino 
3124cf7f2e2dSJohn Marino 	    if (op_ptr - 1 == previous_piece)
3125cf7f2e2dSJohn Marino 	      error (_("Cannot translate empty pieces to agent expressions"));
3126cf7f2e2dSJohn Marino 	    previous_piece = op_ptr - 1;
3127cf7f2e2dSJohn Marino 
3128*ef5ccd6cSJohn Marino             op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
3129cf7f2e2dSJohn Marino 	    if (op == DW_OP_piece)
3130cf7f2e2dSJohn Marino 	      {
3131cf7f2e2dSJohn Marino 		size *= 8;
3132cf7f2e2dSJohn Marino 		offset = 0;
3133cf7f2e2dSJohn Marino 	      }
3134cf7f2e2dSJohn Marino 	    else
3135*ef5ccd6cSJohn Marino 	      op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
3136cf7f2e2dSJohn Marino 
3137cf7f2e2dSJohn Marino 	    if (bits_collected + size > 8 * sizeof (LONGEST))
3138cf7f2e2dSJohn Marino 	      error (_("Expression pieces exceed word size"));
3139cf7f2e2dSJohn Marino 
3140cf7f2e2dSJohn Marino 	    /* Access the bits.  */
3141cf7f2e2dSJohn Marino 	    switch (loc->kind)
3142cf7f2e2dSJohn Marino 	      {
3143cf7f2e2dSJohn Marino 	      case axs_lvalue_register:
3144cf7f2e2dSJohn Marino 		ax_reg (expr, loc->u.reg);
3145cf7f2e2dSJohn Marino 		break;
3146cf7f2e2dSJohn Marino 
3147cf7f2e2dSJohn Marino 	      case axs_lvalue_memory:
3148cf7f2e2dSJohn Marino 		/* Offset the pointer, if needed.  */
3149cf7f2e2dSJohn Marino 		if (offset > 8)
3150cf7f2e2dSJohn Marino 		  {
3151cf7f2e2dSJohn Marino 		    ax_const_l (expr, offset / 8);
3152cf7f2e2dSJohn Marino 		    ax_simple (expr, aop_add);
3153cf7f2e2dSJohn Marino 		    offset %= 8;
3154cf7f2e2dSJohn Marino 		  }
3155cf7f2e2dSJohn Marino 		access_memory (arch, expr, size);
3156cf7f2e2dSJohn Marino 		break;
3157cf7f2e2dSJohn Marino 	      }
3158cf7f2e2dSJohn Marino 
3159cf7f2e2dSJohn Marino 	    /* For a bits-big-endian target, shift up what we already
3160cf7f2e2dSJohn Marino 	       have.  For a bits-little-endian target, shift up the
3161cf7f2e2dSJohn Marino 	       new data.  Note that there is a potential bug here if
3162cf7f2e2dSJohn Marino 	       the DWARF expression leaves multiple values on the
3163cf7f2e2dSJohn Marino 	       stack.  */
3164cf7f2e2dSJohn Marino 	    if (bits_collected > 0)
3165cf7f2e2dSJohn Marino 	      {
3166cf7f2e2dSJohn Marino 		if (bits_big_endian)
3167cf7f2e2dSJohn Marino 		  {
3168cf7f2e2dSJohn Marino 		    ax_simple (expr, aop_swap);
3169cf7f2e2dSJohn Marino 		    ax_const_l (expr, size);
3170cf7f2e2dSJohn Marino 		    ax_simple (expr, aop_lsh);
3171cf7f2e2dSJohn Marino 		    /* We don't need a second swap here, because
3172cf7f2e2dSJohn Marino 		       aop_bit_or is symmetric.  */
3173cf7f2e2dSJohn Marino 		  }
3174cf7f2e2dSJohn Marino 		else
3175cf7f2e2dSJohn Marino 		  {
3176cf7f2e2dSJohn Marino 		    ax_const_l (expr, size);
3177cf7f2e2dSJohn Marino 		    ax_simple (expr, aop_lsh);
3178cf7f2e2dSJohn Marino 		  }
3179cf7f2e2dSJohn Marino 		ax_simple (expr, aop_bit_or);
3180cf7f2e2dSJohn Marino 	      }
3181cf7f2e2dSJohn Marino 
3182cf7f2e2dSJohn Marino 	    bits_collected += size;
3183cf7f2e2dSJohn Marino 	    loc->kind = axs_rvalue;
3184cf7f2e2dSJohn Marino 	  }
3185cf7f2e2dSJohn Marino 	  break;
3186cf7f2e2dSJohn Marino 
3187cf7f2e2dSJohn Marino 	case DW_OP_GNU_uninit:
3188cf7f2e2dSJohn Marino 	  unimplemented (op);
3189cf7f2e2dSJohn Marino 
3190cf7f2e2dSJohn Marino 	case DW_OP_call2:
3191cf7f2e2dSJohn Marino 	case DW_OP_call4:
3192cf7f2e2dSJohn Marino 	  {
3193cf7f2e2dSJohn Marino 	    struct dwarf2_locexpr_baton block;
3194cf7f2e2dSJohn Marino 	    int size = (op == DW_OP_call2 ? 2 : 4);
3195*ef5ccd6cSJohn Marino 	    cu_offset offset;
3196cf7f2e2dSJohn Marino 
3197cf7f2e2dSJohn Marino 	    uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
3198cf7f2e2dSJohn Marino 	    op_ptr += size;
3199cf7f2e2dSJohn Marino 
3200*ef5ccd6cSJohn Marino 	    offset.cu_off = uoffset;
3201*ef5ccd6cSJohn Marino 	    block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
3202c50c785cSJohn Marino 						 get_ax_pc, expr);
3203cf7f2e2dSJohn Marino 
3204cf7f2e2dSJohn Marino 	    /* DW_OP_call_ref is currently not supported.  */
3205cf7f2e2dSJohn Marino 	    gdb_assert (block.per_cu == per_cu);
3206cf7f2e2dSJohn Marino 
3207c50c785cSJohn Marino 	    dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3208cf7f2e2dSJohn Marino 				       block.data, block.data + block.size,
3209cf7f2e2dSJohn Marino 				       per_cu);
3210cf7f2e2dSJohn Marino 	  }
3211cf7f2e2dSJohn Marino 	  break;
3212cf7f2e2dSJohn Marino 
3213cf7f2e2dSJohn Marino 	case DW_OP_call_ref:
3214cf7f2e2dSJohn Marino 	  unimplemented (op);
3215cf7f2e2dSJohn Marino 
3216cf7f2e2dSJohn Marino 	default:
3217c50c785cSJohn Marino 	  unimplemented (op);
3218cf7f2e2dSJohn Marino 	}
3219cf7f2e2dSJohn Marino     }
3220cf7f2e2dSJohn Marino 
3221cf7f2e2dSJohn Marino   /* Patch all the branches we emitted.  */
3222cf7f2e2dSJohn Marino   for (i = 0; i < VEC_length (int, patches); ++i)
3223cf7f2e2dSJohn Marino     {
3224cf7f2e2dSJohn Marino       int targ = offsets[VEC_index (int, dw_labels, i)];
3225cf7f2e2dSJohn Marino       if (targ == -1)
3226cf7f2e2dSJohn Marino 	internal_error (__FILE__, __LINE__, _("invalid label"));
3227cf7f2e2dSJohn Marino       ax_label (expr, VEC_index (int, patches, i), targ);
3228cf7f2e2dSJohn Marino     }
3229cf7f2e2dSJohn Marino 
3230cf7f2e2dSJohn Marino   do_cleanups (cleanups);
3231cf7f2e2dSJohn Marino }
3232cf7f2e2dSJohn Marino 
32335796c8dcSSimon Schubert 
32345796c8dcSSimon Schubert /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
32355796c8dcSSimon Schubert    evaluator to calculate the location.  */
32365796c8dcSSimon Schubert static struct value *
locexpr_read_variable(struct symbol * symbol,struct frame_info * frame)32375796c8dcSSimon Schubert locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
32385796c8dcSSimon Schubert {
32395796c8dcSSimon Schubert   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
32405796c8dcSSimon Schubert   struct value *val;
3241cf7f2e2dSJohn Marino 
3242cf7f2e2dSJohn Marino   val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3243cf7f2e2dSJohn Marino 				  dlbaton->size, dlbaton->per_cu);
32445796c8dcSSimon Schubert 
32455796c8dcSSimon Schubert   return val;
32465796c8dcSSimon Schubert }
32475796c8dcSSimon Schubert 
3248a45ae5f8SJohn Marino /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3249a45ae5f8SJohn Marino    entry.  SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3250a45ae5f8SJohn Marino    will be thrown.  */
3251a45ae5f8SJohn Marino 
3252a45ae5f8SJohn Marino static struct value *
locexpr_read_variable_at_entry(struct symbol * symbol,struct frame_info * frame)3253a45ae5f8SJohn Marino locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
3254a45ae5f8SJohn Marino {
3255a45ae5f8SJohn Marino   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3256a45ae5f8SJohn Marino 
3257a45ae5f8SJohn Marino   return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3258a45ae5f8SJohn Marino 				     dlbaton->size);
3259a45ae5f8SJohn Marino }
3260a45ae5f8SJohn Marino 
32615796c8dcSSimon Schubert /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
32625796c8dcSSimon Schubert static int
locexpr_read_needs_frame(struct symbol * symbol)32635796c8dcSSimon Schubert locexpr_read_needs_frame (struct symbol *symbol)
32645796c8dcSSimon Schubert {
32655796c8dcSSimon Schubert   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3266cf7f2e2dSJohn Marino 
32675796c8dcSSimon Schubert   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
32685796c8dcSSimon Schubert 				      dlbaton->per_cu);
32695796c8dcSSimon Schubert }
32705796c8dcSSimon Schubert 
3271cf7f2e2dSJohn Marino /* Return true if DATA points to the end of a piece.  END is one past
3272cf7f2e2dSJohn Marino    the last byte in the expression.  */
32735796c8dcSSimon Schubert 
3274cf7f2e2dSJohn Marino static int
piece_end_p(const gdb_byte * data,const gdb_byte * end)3275cf7f2e2dSJohn Marino piece_end_p (const gdb_byte *data, const gdb_byte *end)
32765796c8dcSSimon Schubert {
3277cf7f2e2dSJohn Marino   return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3278cf7f2e2dSJohn Marino }
3279cf7f2e2dSJohn Marino 
3280a45ae5f8SJohn Marino /* Helper for locexpr_describe_location_piece that finds the name of a
3281a45ae5f8SJohn Marino    DWARF register.  */
3282a45ae5f8SJohn Marino 
3283a45ae5f8SJohn Marino static const char *
locexpr_regname(struct gdbarch * gdbarch,int dwarf_regnum)3284a45ae5f8SJohn Marino locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
3285a45ae5f8SJohn Marino {
3286a45ae5f8SJohn Marino   int regnum;
3287a45ae5f8SJohn Marino 
3288a45ae5f8SJohn Marino   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3289a45ae5f8SJohn Marino   return gdbarch_register_name (gdbarch, regnum);
3290a45ae5f8SJohn Marino }
3291a45ae5f8SJohn Marino 
3292cf7f2e2dSJohn Marino /* Nicely describe a single piece of a location, returning an updated
3293cf7f2e2dSJohn Marino    position in the bytecode sequence.  This function cannot recognize
3294cf7f2e2dSJohn Marino    all locations; if a location is not recognized, it simply returns
3295*ef5ccd6cSJohn Marino    DATA.  If there is an error during reading, e.g. we run off the end
3296*ef5ccd6cSJohn Marino    of the buffer, an error is thrown.  */
3297cf7f2e2dSJohn Marino 
3298cf7f2e2dSJohn Marino static const gdb_byte *
locexpr_describe_location_piece(struct symbol * symbol,struct ui_file * stream,CORE_ADDR addr,struct objfile * objfile,struct dwarf2_per_cu_data * per_cu,const gdb_byte * data,const gdb_byte * end,unsigned int addr_size)3299cf7f2e2dSJohn Marino locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
3300cf7f2e2dSJohn Marino 				 CORE_ADDR addr, struct objfile *objfile,
3301*ef5ccd6cSJohn Marino 				 struct dwarf2_per_cu_data *per_cu,
3302cf7f2e2dSJohn Marino 				 const gdb_byte *data, const gdb_byte *end,
3303cf7f2e2dSJohn Marino 				 unsigned int addr_size)
3304cf7f2e2dSJohn Marino {
33055796c8dcSSimon Schubert   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3306*ef5ccd6cSJohn Marino   size_t leb128_size;
3307cf7f2e2dSJohn Marino 
3308cf7f2e2dSJohn Marino   if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3309cf7f2e2dSJohn Marino     {
3310cf7f2e2dSJohn Marino       fprintf_filtered (stream, _("a variable in $%s"),
3311a45ae5f8SJohn Marino 			locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
3312cf7f2e2dSJohn Marino       data += 1;
3313cf7f2e2dSJohn Marino     }
3314cf7f2e2dSJohn Marino   else if (data[0] == DW_OP_regx)
3315cf7f2e2dSJohn Marino     {
3316*ef5ccd6cSJohn Marino       uint64_t reg;
3317cf7f2e2dSJohn Marino 
3318*ef5ccd6cSJohn Marino       data = safe_read_uleb128 (data + 1, end, &reg);
3319cf7f2e2dSJohn Marino       fprintf_filtered (stream, _("a variable in $%s"),
3320a45ae5f8SJohn Marino 			locexpr_regname (gdbarch, reg));
3321cf7f2e2dSJohn Marino     }
3322cf7f2e2dSJohn Marino   else if (data[0] == DW_OP_fbreg)
3323cf7f2e2dSJohn Marino     {
3324cf7f2e2dSJohn Marino       struct block *b;
3325cf7f2e2dSJohn Marino       struct symbol *framefunc;
3326cf7f2e2dSJohn Marino       int frame_reg = 0;
3327*ef5ccd6cSJohn Marino       int64_t frame_offset;
3328c50c785cSJohn Marino       const gdb_byte *base_data, *new_data, *save_data = data;
3329cf7f2e2dSJohn Marino       size_t base_size;
3330*ef5ccd6cSJohn Marino       int64_t base_offset = 0;
3331cf7f2e2dSJohn Marino 
3332*ef5ccd6cSJohn Marino       new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
3333cf7f2e2dSJohn Marino       if (!piece_end_p (new_data, end))
3334cf7f2e2dSJohn Marino 	return data;
3335cf7f2e2dSJohn Marino       data = new_data;
3336cf7f2e2dSJohn Marino 
3337cf7f2e2dSJohn Marino       b = block_for_pc (addr);
3338cf7f2e2dSJohn Marino 
3339cf7f2e2dSJohn Marino       if (!b)
3340cf7f2e2dSJohn Marino 	error (_("No block found for address for symbol \"%s\"."),
3341cf7f2e2dSJohn Marino 	       SYMBOL_PRINT_NAME (symbol));
3342cf7f2e2dSJohn Marino 
3343cf7f2e2dSJohn Marino       framefunc = block_linkage_function (b);
3344cf7f2e2dSJohn Marino 
3345cf7f2e2dSJohn Marino       if (!framefunc)
3346cf7f2e2dSJohn Marino 	error (_("No function found for block for symbol \"%s\"."),
3347cf7f2e2dSJohn Marino 	       SYMBOL_PRINT_NAME (symbol));
3348cf7f2e2dSJohn Marino 
3349cf7f2e2dSJohn Marino       dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
3350cf7f2e2dSJohn Marino 
3351cf7f2e2dSJohn Marino       if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3352cf7f2e2dSJohn Marino 	{
3353cf7f2e2dSJohn Marino 	  const gdb_byte *buf_end;
3354cf7f2e2dSJohn Marino 
3355cf7f2e2dSJohn Marino 	  frame_reg = base_data[0] - DW_OP_breg0;
3356*ef5ccd6cSJohn Marino 	  buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
3357*ef5ccd6cSJohn Marino 				       &base_offset);
3358cf7f2e2dSJohn Marino 	  if (buf_end != base_data + base_size)
3359c50c785cSJohn Marino 	    error (_("Unexpected opcode after "
3360c50c785cSJohn Marino 		     "DW_OP_breg%u for symbol \"%s\"."),
3361cf7f2e2dSJohn Marino 		   frame_reg, SYMBOL_PRINT_NAME (symbol));
3362cf7f2e2dSJohn Marino 	}
3363cf7f2e2dSJohn Marino       else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3364cf7f2e2dSJohn Marino 	{
3365cf7f2e2dSJohn Marino 	  /* The frame base is just the register, with no offset.  */
3366cf7f2e2dSJohn Marino 	  frame_reg = base_data[0] - DW_OP_reg0;
3367cf7f2e2dSJohn Marino 	  base_offset = 0;
3368cf7f2e2dSJohn Marino 	}
3369cf7f2e2dSJohn Marino       else
3370cf7f2e2dSJohn Marino 	{
3371cf7f2e2dSJohn Marino 	  /* We don't know what to do with the frame base expression,
3372cf7f2e2dSJohn Marino 	     so we can't trace this variable; give up.  */
3373c50c785cSJohn Marino 	  return save_data;
3374cf7f2e2dSJohn Marino 	}
3375cf7f2e2dSJohn Marino 
3376c50c785cSJohn Marino       fprintf_filtered (stream,
3377c50c785cSJohn Marino 			_("a variable at frame base reg $%s offset %s+%s"),
3378a45ae5f8SJohn Marino 			locexpr_regname (gdbarch, frame_reg),
3379cf7f2e2dSJohn Marino 			plongest (base_offset), plongest (frame_offset));
3380cf7f2e2dSJohn Marino     }
3381cf7f2e2dSJohn Marino   else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3382cf7f2e2dSJohn Marino 	   && piece_end_p (data, end))
3383cf7f2e2dSJohn Marino     {
3384*ef5ccd6cSJohn Marino       int64_t offset;
3385cf7f2e2dSJohn Marino 
3386*ef5ccd6cSJohn Marino       data = safe_read_sleb128 (data + 1, end, &offset);
3387cf7f2e2dSJohn Marino 
3388cf7f2e2dSJohn Marino       fprintf_filtered (stream,
3389cf7f2e2dSJohn Marino 			_("a variable at offset %s from base reg $%s"),
3390cf7f2e2dSJohn Marino 			plongest (offset),
3391a45ae5f8SJohn Marino 			locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
33925796c8dcSSimon Schubert     }
33935796c8dcSSimon Schubert 
33945796c8dcSSimon Schubert   /* The location expression for a TLS variable looks like this (on a
33955796c8dcSSimon Schubert      64-bit LE machine):
33965796c8dcSSimon Schubert 
33975796c8dcSSimon Schubert      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
33985796c8dcSSimon Schubert                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
33995796c8dcSSimon Schubert 
34005796c8dcSSimon Schubert      0x3 is the encoding for DW_OP_addr, which has an operand as long
34015796c8dcSSimon Schubert      as the size of an address on the target machine (here is 8
3402cf7f2e2dSJohn Marino      bytes).  Note that more recent version of GCC emit DW_OP_const4u
3403cf7f2e2dSJohn Marino      or DW_OP_const8u, depending on address size, rather than
3404c50c785cSJohn Marino      DW_OP_addr.  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3405c50c785cSJohn Marino      The operand represents the offset at which the variable is within
3406c50c785cSJohn Marino      the thread local storage.  */
34075796c8dcSSimon Schubert 
3408cf7f2e2dSJohn Marino   else if (data + 1 + addr_size < end
3409cf7f2e2dSJohn Marino 	   && (data[0] == DW_OP_addr
3410cf7f2e2dSJohn Marino 	       || (addr_size == 4 && data[0] == DW_OP_const4u)
3411cf7f2e2dSJohn Marino 	       || (addr_size == 8 && data[0] == DW_OP_const8u))
3412cf7f2e2dSJohn Marino 	   && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3413cf7f2e2dSJohn Marino 	   && piece_end_p (data + 2 + addr_size, end))
34145796c8dcSSimon Schubert     {
3415cf7f2e2dSJohn Marino       ULONGEST offset;
3416cf7f2e2dSJohn Marino       offset = extract_unsigned_integer (data + 1, addr_size,
3417cf7f2e2dSJohn Marino 					 gdbarch_byte_order (gdbarch));
3418cf7f2e2dSJohn Marino 
3419cf7f2e2dSJohn Marino       fprintf_filtered (stream,
3420cf7f2e2dSJohn Marino 			_("a thread-local variable at offset 0x%s "
3421cf7f2e2dSJohn Marino 			  "in the thread-local storage for `%s'"),
3422cf7f2e2dSJohn Marino 			phex_nz (offset, addr_size), objfile->name);
3423cf7f2e2dSJohn Marino 
3424cf7f2e2dSJohn Marino       data += 1 + addr_size + 1;
3425cf7f2e2dSJohn Marino     }
3426*ef5ccd6cSJohn Marino 
3427*ef5ccd6cSJohn Marino   /* With -gsplit-dwarf a TLS variable can also look like this:
3428*ef5ccd6cSJohn Marino      DW_AT_location    : 3 byte block: fc 4 e0
3429*ef5ccd6cSJohn Marino                         (DW_OP_GNU_const_index: 4;
3430*ef5ccd6cSJohn Marino 			 DW_OP_GNU_push_tls_address)  */
3431*ef5ccd6cSJohn Marino   else if (data + 3 <= end
3432*ef5ccd6cSJohn Marino 	   && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
3433*ef5ccd6cSJohn Marino 	   && data[0] == DW_OP_GNU_const_index
3434*ef5ccd6cSJohn Marino 	   && leb128_size > 0
3435*ef5ccd6cSJohn Marino 	   && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
3436*ef5ccd6cSJohn Marino 	   && piece_end_p (data + 2 + leb128_size, end))
3437*ef5ccd6cSJohn Marino     {
3438*ef5ccd6cSJohn Marino       uint64_t offset;
3439*ef5ccd6cSJohn Marino 
3440*ef5ccd6cSJohn Marino       data = safe_read_uleb128 (data + 1, end, &offset);
3441*ef5ccd6cSJohn Marino       offset = dwarf2_read_addr_index (per_cu, offset);
3442*ef5ccd6cSJohn Marino       fprintf_filtered (stream,
3443*ef5ccd6cSJohn Marino 			_("a thread-local variable at offset 0x%s "
3444*ef5ccd6cSJohn Marino 			  "in the thread-local storage for `%s'"),
3445*ef5ccd6cSJohn Marino 			phex_nz (offset, addr_size), objfile->name);
3446*ef5ccd6cSJohn Marino       ++data;
3447*ef5ccd6cSJohn Marino     }
3448*ef5ccd6cSJohn Marino 
3449cf7f2e2dSJohn Marino   else if (data[0] >= DW_OP_lit0
3450cf7f2e2dSJohn Marino 	   && data[0] <= DW_OP_lit31
3451cf7f2e2dSJohn Marino 	   && data + 1 < end
3452cf7f2e2dSJohn Marino 	   && data[1] == DW_OP_stack_value)
3453cf7f2e2dSJohn Marino     {
3454cf7f2e2dSJohn Marino       fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
3455cf7f2e2dSJohn Marino       data += 2;
3456cf7f2e2dSJohn Marino     }
3457cf7f2e2dSJohn Marino 
3458cf7f2e2dSJohn Marino   return data;
3459cf7f2e2dSJohn Marino }
3460cf7f2e2dSJohn Marino 
3461cf7f2e2dSJohn Marino /* Disassemble an expression, stopping at the end of a piece or at the
3462cf7f2e2dSJohn Marino    end of the expression.  Returns a pointer to the next unread byte
3463cf7f2e2dSJohn Marino    in the input expression.  If ALL is nonzero, then this function
3464*ef5ccd6cSJohn Marino    will keep going until it reaches the end of the expression.
3465*ef5ccd6cSJohn Marino    If there is an error during reading, e.g. we run off the end
3466*ef5ccd6cSJohn Marino    of the buffer, an error is thrown.  */
3467cf7f2e2dSJohn Marino 
3468cf7f2e2dSJohn Marino static const gdb_byte *
disassemble_dwarf_expression(struct ui_file * stream,struct gdbarch * arch,unsigned int addr_size,int offset_size,const gdb_byte * start,const gdb_byte * data,const gdb_byte * end,int indent,int all,struct dwarf2_per_cu_data * per_cu)3469cf7f2e2dSJohn Marino disassemble_dwarf_expression (struct ui_file *stream,
3470cf7f2e2dSJohn Marino 			      struct gdbarch *arch, unsigned int addr_size,
3471a45ae5f8SJohn Marino 			      int offset_size, const gdb_byte *start,
3472cf7f2e2dSJohn Marino 			      const gdb_byte *data, const gdb_byte *end,
3473a45ae5f8SJohn Marino 			      int indent, int all,
3474a45ae5f8SJohn Marino 			      struct dwarf2_per_cu_data *per_cu)
3475cf7f2e2dSJohn Marino {
3476cf7f2e2dSJohn Marino   while (data < end
3477cf7f2e2dSJohn Marino 	 && (all
3478cf7f2e2dSJohn Marino 	     || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3479cf7f2e2dSJohn Marino     {
3480cf7f2e2dSJohn Marino       enum dwarf_location_atom op = *data++;
3481*ef5ccd6cSJohn Marino       uint64_t ul;
3482*ef5ccd6cSJohn Marino       int64_t l;
3483cf7f2e2dSJohn Marino       const char *name;
3484cf7f2e2dSJohn Marino 
3485*ef5ccd6cSJohn Marino       name = get_DW_OP_name (op);
3486cf7f2e2dSJohn Marino 
3487cf7f2e2dSJohn Marino       if (!name)
3488cf7f2e2dSJohn Marino 	error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3489a45ae5f8SJohn Marino 	       op, (long) (data - 1 - start));
3490a45ae5f8SJohn Marino       fprintf_filtered (stream, "  %*ld: %s", indent + 4,
3491a45ae5f8SJohn Marino 			(long) (data - 1 - start), name);
3492cf7f2e2dSJohn Marino 
3493cf7f2e2dSJohn Marino       switch (op)
3494cf7f2e2dSJohn Marino 	{
3495cf7f2e2dSJohn Marino 	case DW_OP_addr:
3496cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, addr_size,
3497cf7f2e2dSJohn Marino 					 gdbarch_byte_order (arch));
3498cf7f2e2dSJohn Marino 	  data += addr_size;
3499cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
3500cf7f2e2dSJohn Marino 	  break;
3501cf7f2e2dSJohn Marino 
3502cf7f2e2dSJohn Marino 	case DW_OP_const1u:
3503cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
3504cf7f2e2dSJohn Marino 	  data += 1;
3505cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3506cf7f2e2dSJohn Marino 	  break;
3507cf7f2e2dSJohn Marino 	case DW_OP_const1s:
3508cf7f2e2dSJohn Marino 	  l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
3509cf7f2e2dSJohn Marino 	  data += 1;
3510cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", plongest (l));
3511cf7f2e2dSJohn Marino 	  break;
3512cf7f2e2dSJohn Marino 	case DW_OP_const2u:
3513cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3514cf7f2e2dSJohn Marino 	  data += 2;
3515cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3516cf7f2e2dSJohn Marino 	  break;
3517cf7f2e2dSJohn Marino 	case DW_OP_const2s:
3518cf7f2e2dSJohn Marino 	  l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3519cf7f2e2dSJohn Marino 	  data += 2;
3520cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", plongest (l));
3521cf7f2e2dSJohn Marino 	  break;
3522cf7f2e2dSJohn Marino 	case DW_OP_const4u:
3523cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3524cf7f2e2dSJohn Marino 	  data += 4;
3525cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3526cf7f2e2dSJohn Marino 	  break;
3527cf7f2e2dSJohn Marino 	case DW_OP_const4s:
3528cf7f2e2dSJohn Marino 	  l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
3529cf7f2e2dSJohn Marino 	  data += 4;
3530cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", plongest (l));
3531cf7f2e2dSJohn Marino 	  break;
3532cf7f2e2dSJohn Marino 	case DW_OP_const8u:
3533cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
3534cf7f2e2dSJohn Marino 	  data += 8;
3535cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3536cf7f2e2dSJohn Marino 	  break;
3537cf7f2e2dSJohn Marino 	case DW_OP_const8s:
3538cf7f2e2dSJohn Marino 	  l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
3539cf7f2e2dSJohn Marino 	  data += 8;
3540cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", plongest (l));
3541cf7f2e2dSJohn Marino 	  break;
3542cf7f2e2dSJohn Marino 	case DW_OP_constu:
3543*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3544cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3545cf7f2e2dSJohn Marino 	  break;
3546cf7f2e2dSJohn Marino 	case DW_OP_consts:
3547*ef5ccd6cSJohn Marino 	  data = safe_read_sleb128 (data, end, &l);
3548cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", plongest (l));
3549cf7f2e2dSJohn Marino 	  break;
3550cf7f2e2dSJohn Marino 
3551cf7f2e2dSJohn Marino 	case DW_OP_reg0:
3552cf7f2e2dSJohn Marino 	case DW_OP_reg1:
3553cf7f2e2dSJohn Marino 	case DW_OP_reg2:
3554cf7f2e2dSJohn Marino 	case DW_OP_reg3:
3555cf7f2e2dSJohn Marino 	case DW_OP_reg4:
3556cf7f2e2dSJohn Marino 	case DW_OP_reg5:
3557cf7f2e2dSJohn Marino 	case DW_OP_reg6:
3558cf7f2e2dSJohn Marino 	case DW_OP_reg7:
3559cf7f2e2dSJohn Marino 	case DW_OP_reg8:
3560cf7f2e2dSJohn Marino 	case DW_OP_reg9:
3561cf7f2e2dSJohn Marino 	case DW_OP_reg10:
3562cf7f2e2dSJohn Marino 	case DW_OP_reg11:
3563cf7f2e2dSJohn Marino 	case DW_OP_reg12:
3564cf7f2e2dSJohn Marino 	case DW_OP_reg13:
3565cf7f2e2dSJohn Marino 	case DW_OP_reg14:
3566cf7f2e2dSJohn Marino 	case DW_OP_reg15:
3567cf7f2e2dSJohn Marino 	case DW_OP_reg16:
3568cf7f2e2dSJohn Marino 	case DW_OP_reg17:
3569cf7f2e2dSJohn Marino 	case DW_OP_reg18:
3570cf7f2e2dSJohn Marino 	case DW_OP_reg19:
3571cf7f2e2dSJohn Marino 	case DW_OP_reg20:
3572cf7f2e2dSJohn Marino 	case DW_OP_reg21:
3573cf7f2e2dSJohn Marino 	case DW_OP_reg22:
3574cf7f2e2dSJohn Marino 	case DW_OP_reg23:
3575cf7f2e2dSJohn Marino 	case DW_OP_reg24:
3576cf7f2e2dSJohn Marino 	case DW_OP_reg25:
3577cf7f2e2dSJohn Marino 	case DW_OP_reg26:
3578cf7f2e2dSJohn Marino 	case DW_OP_reg27:
3579cf7f2e2dSJohn Marino 	case DW_OP_reg28:
3580cf7f2e2dSJohn Marino 	case DW_OP_reg29:
3581cf7f2e2dSJohn Marino 	case DW_OP_reg30:
3582cf7f2e2dSJohn Marino 	case DW_OP_reg31:
3583cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " [$%s]",
3584a45ae5f8SJohn Marino 			    locexpr_regname (arch, op - DW_OP_reg0));
3585cf7f2e2dSJohn Marino 	  break;
3586cf7f2e2dSJohn Marino 
3587cf7f2e2dSJohn Marino 	case DW_OP_regx:
3588*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3589cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
3590a45ae5f8SJohn Marino 			    locexpr_regname (arch, (int) ul));
3591cf7f2e2dSJohn Marino 	  break;
3592cf7f2e2dSJohn Marino 
3593cf7f2e2dSJohn Marino 	case DW_OP_implicit_value:
3594*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3595cf7f2e2dSJohn Marino 	  data += ul;
3596cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3597cf7f2e2dSJohn Marino 	  break;
3598cf7f2e2dSJohn Marino 
3599cf7f2e2dSJohn Marino 	case DW_OP_breg0:
3600cf7f2e2dSJohn Marino 	case DW_OP_breg1:
3601cf7f2e2dSJohn Marino 	case DW_OP_breg2:
3602cf7f2e2dSJohn Marino 	case DW_OP_breg3:
3603cf7f2e2dSJohn Marino 	case DW_OP_breg4:
3604cf7f2e2dSJohn Marino 	case DW_OP_breg5:
3605cf7f2e2dSJohn Marino 	case DW_OP_breg6:
3606cf7f2e2dSJohn Marino 	case DW_OP_breg7:
3607cf7f2e2dSJohn Marino 	case DW_OP_breg8:
3608cf7f2e2dSJohn Marino 	case DW_OP_breg9:
3609cf7f2e2dSJohn Marino 	case DW_OP_breg10:
3610cf7f2e2dSJohn Marino 	case DW_OP_breg11:
3611cf7f2e2dSJohn Marino 	case DW_OP_breg12:
3612cf7f2e2dSJohn Marino 	case DW_OP_breg13:
3613cf7f2e2dSJohn Marino 	case DW_OP_breg14:
3614cf7f2e2dSJohn Marino 	case DW_OP_breg15:
3615cf7f2e2dSJohn Marino 	case DW_OP_breg16:
3616cf7f2e2dSJohn Marino 	case DW_OP_breg17:
3617cf7f2e2dSJohn Marino 	case DW_OP_breg18:
3618cf7f2e2dSJohn Marino 	case DW_OP_breg19:
3619cf7f2e2dSJohn Marino 	case DW_OP_breg20:
3620cf7f2e2dSJohn Marino 	case DW_OP_breg21:
3621cf7f2e2dSJohn Marino 	case DW_OP_breg22:
3622cf7f2e2dSJohn Marino 	case DW_OP_breg23:
3623cf7f2e2dSJohn Marino 	case DW_OP_breg24:
3624cf7f2e2dSJohn Marino 	case DW_OP_breg25:
3625cf7f2e2dSJohn Marino 	case DW_OP_breg26:
3626cf7f2e2dSJohn Marino 	case DW_OP_breg27:
3627cf7f2e2dSJohn Marino 	case DW_OP_breg28:
3628cf7f2e2dSJohn Marino 	case DW_OP_breg29:
3629cf7f2e2dSJohn Marino 	case DW_OP_breg30:
3630cf7f2e2dSJohn Marino 	case DW_OP_breg31:
3631*ef5ccd6cSJohn Marino 	  data = safe_read_sleb128 (data, end, &l);
3632c50c785cSJohn Marino 	  fprintf_filtered (stream, " %s [$%s]", plongest (l),
3633a45ae5f8SJohn Marino 			    locexpr_regname (arch, op - DW_OP_breg0));
3634cf7f2e2dSJohn Marino 	  break;
3635cf7f2e2dSJohn Marino 
3636cf7f2e2dSJohn Marino 	case DW_OP_bregx:
3637*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3638*ef5ccd6cSJohn Marino 	  data = safe_read_sleb128 (data, end, &l);
3639cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " register %s [$%s] offset %s",
3640cf7f2e2dSJohn Marino 			    pulongest (ul),
3641a45ae5f8SJohn Marino 			    locexpr_regname (arch, (int) ul),
3642c50c785cSJohn Marino 			    plongest (l));
3643cf7f2e2dSJohn Marino 	  break;
3644cf7f2e2dSJohn Marino 
3645cf7f2e2dSJohn Marino 	case DW_OP_fbreg:
3646*ef5ccd6cSJohn Marino 	  data = safe_read_sleb128 (data, end, &l);
3647c50c785cSJohn Marino 	  fprintf_filtered (stream, " %s", plongest (l));
3648cf7f2e2dSJohn Marino 	  break;
3649cf7f2e2dSJohn Marino 
3650cf7f2e2dSJohn Marino 	case DW_OP_xderef_size:
3651cf7f2e2dSJohn Marino 	case DW_OP_deref_size:
3652cf7f2e2dSJohn Marino 	case DW_OP_pick:
3653cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %d", *data);
3654cf7f2e2dSJohn Marino 	  ++data;
3655cf7f2e2dSJohn Marino 	  break;
3656cf7f2e2dSJohn Marino 
3657cf7f2e2dSJohn Marino 	case DW_OP_plus_uconst:
3658*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3659cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3660cf7f2e2dSJohn Marino 	  break;
3661cf7f2e2dSJohn Marino 
3662cf7f2e2dSJohn Marino 	case DW_OP_skip:
3663cf7f2e2dSJohn Marino 	  l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3664cf7f2e2dSJohn Marino 	  data += 2;
3665cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " to %ld",
3666cf7f2e2dSJohn Marino 			    (long) (data + l - start));
3667cf7f2e2dSJohn Marino 	  break;
3668cf7f2e2dSJohn Marino 
3669cf7f2e2dSJohn Marino 	case DW_OP_bra:
3670cf7f2e2dSJohn Marino 	  l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3671cf7f2e2dSJohn Marino 	  data += 2;
3672cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %ld",
3673cf7f2e2dSJohn Marino 			    (long) (data + l - start));
3674cf7f2e2dSJohn Marino 	  break;
3675cf7f2e2dSJohn Marino 
3676cf7f2e2dSJohn Marino 	case DW_OP_call2:
3677cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3678cf7f2e2dSJohn Marino 	  data += 2;
3679cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
3680cf7f2e2dSJohn Marino 	  break;
3681cf7f2e2dSJohn Marino 
3682cf7f2e2dSJohn Marino 	case DW_OP_call4:
3683cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3684cf7f2e2dSJohn Marino 	  data += 4;
3685cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3686cf7f2e2dSJohn Marino 	  break;
3687cf7f2e2dSJohn Marino 
3688cf7f2e2dSJohn Marino 	case DW_OP_call_ref:
3689cf7f2e2dSJohn Marino 	  ul = extract_unsigned_integer (data, offset_size,
3690cf7f2e2dSJohn Marino 					 gdbarch_byte_order (arch));
3691cf7f2e2dSJohn Marino 	  data += offset_size;
3692cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
3693cf7f2e2dSJohn Marino 	  break;
3694cf7f2e2dSJohn Marino 
3695cf7f2e2dSJohn Marino         case DW_OP_piece:
3696*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3697cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
3698cf7f2e2dSJohn Marino 	  break;
3699cf7f2e2dSJohn Marino 
3700cf7f2e2dSJohn Marino 	case DW_OP_bit_piece:
3701cf7f2e2dSJohn Marino 	  {
3702*ef5ccd6cSJohn Marino 	    uint64_t offset;
3703cf7f2e2dSJohn Marino 
3704*ef5ccd6cSJohn Marino 	    data = safe_read_uleb128 (data, end, &ul);
3705*ef5ccd6cSJohn Marino 	    data = safe_read_uleb128 (data, end, &offset);
3706cf7f2e2dSJohn Marino 	    fprintf_filtered (stream, " size %s offset %s (bits)",
3707cf7f2e2dSJohn Marino 			      pulongest (ul), pulongest (offset));
3708cf7f2e2dSJohn Marino 	  }
3709cf7f2e2dSJohn Marino 	  break;
3710c50c785cSJohn Marino 
3711c50c785cSJohn Marino 	case DW_OP_GNU_implicit_pointer:
3712c50c785cSJohn Marino 	  {
3713c50c785cSJohn Marino 	    ul = extract_unsigned_integer (data, offset_size,
3714c50c785cSJohn Marino 					   gdbarch_byte_order (arch));
3715c50c785cSJohn Marino 	    data += offset_size;
3716c50c785cSJohn Marino 
3717*ef5ccd6cSJohn Marino 	    data = safe_read_sleb128 (data, end, &l);
3718c50c785cSJohn Marino 
3719c50c785cSJohn Marino 	    fprintf_filtered (stream, " DIE %s offset %s",
3720c50c785cSJohn Marino 			      phex_nz (ul, offset_size),
3721c50c785cSJohn Marino 			      plongest (l));
3722c50c785cSJohn Marino 	  }
3723c50c785cSJohn Marino 	  break;
3724a45ae5f8SJohn Marino 
3725a45ae5f8SJohn Marino 	case DW_OP_GNU_deref_type:
3726a45ae5f8SJohn Marino 	  {
3727a45ae5f8SJohn Marino 	    int addr_size = *data++;
3728*ef5ccd6cSJohn Marino 	    cu_offset offset;
3729a45ae5f8SJohn Marino 	    struct type *type;
3730a45ae5f8SJohn Marino 
3731*ef5ccd6cSJohn Marino 	    data = safe_read_uleb128 (data, end, &ul);
3732*ef5ccd6cSJohn Marino 	    offset.cu_off = ul;
3733a45ae5f8SJohn Marino 	    type = dwarf2_get_die_type (offset, per_cu);
3734a45ae5f8SJohn Marino 	    fprintf_filtered (stream, "<");
3735a45ae5f8SJohn Marino 	    type_print (type, "", stream, -1);
3736*ef5ccd6cSJohn Marino 	    fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
3737a45ae5f8SJohn Marino 			      addr_size);
3738a45ae5f8SJohn Marino 	  }
3739a45ae5f8SJohn Marino 	  break;
3740a45ae5f8SJohn Marino 
3741a45ae5f8SJohn Marino 	case DW_OP_GNU_const_type:
3742a45ae5f8SJohn Marino 	  {
3743*ef5ccd6cSJohn Marino 	    cu_offset type_die;
3744a45ae5f8SJohn Marino 	    struct type *type;
3745a45ae5f8SJohn Marino 
3746*ef5ccd6cSJohn Marino 	    data = safe_read_uleb128 (data, end, &ul);
3747*ef5ccd6cSJohn Marino 	    type_die.cu_off = ul;
3748a45ae5f8SJohn Marino 	    type = dwarf2_get_die_type (type_die, per_cu);
3749a45ae5f8SJohn Marino 	    fprintf_filtered (stream, "<");
3750a45ae5f8SJohn Marino 	    type_print (type, "", stream, -1);
3751*ef5ccd6cSJohn Marino 	    fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
3752a45ae5f8SJohn Marino 	  }
3753a45ae5f8SJohn Marino 	  break;
3754a45ae5f8SJohn Marino 
3755a45ae5f8SJohn Marino 	case DW_OP_GNU_regval_type:
3756a45ae5f8SJohn Marino 	  {
3757*ef5ccd6cSJohn Marino 	    uint64_t reg;
3758*ef5ccd6cSJohn Marino 	    cu_offset type_die;
3759a45ae5f8SJohn Marino 	    struct type *type;
3760a45ae5f8SJohn Marino 
3761*ef5ccd6cSJohn Marino 	    data = safe_read_uleb128 (data, end, &reg);
3762*ef5ccd6cSJohn Marino 	    data = safe_read_uleb128 (data, end, &ul);
3763*ef5ccd6cSJohn Marino 	    type_die.cu_off = ul;
3764a45ae5f8SJohn Marino 
3765a45ae5f8SJohn Marino 	    type = dwarf2_get_die_type (type_die, per_cu);
3766a45ae5f8SJohn Marino 	    fprintf_filtered (stream, "<");
3767a45ae5f8SJohn Marino 	    type_print (type, "", stream, -1);
3768*ef5ccd6cSJohn Marino 	    fprintf_filtered (stream, " [0x%s]> [$%s]",
3769*ef5ccd6cSJohn Marino 			      phex_nz (type_die.cu_off, 0),
3770a45ae5f8SJohn Marino 			      locexpr_regname (arch, reg));
3771a45ae5f8SJohn Marino 	  }
3772a45ae5f8SJohn Marino 	  break;
3773a45ae5f8SJohn Marino 
3774a45ae5f8SJohn Marino 	case DW_OP_GNU_convert:
3775a45ae5f8SJohn Marino 	case DW_OP_GNU_reinterpret:
3776a45ae5f8SJohn Marino 	  {
3777*ef5ccd6cSJohn Marino 	    cu_offset type_die;
3778a45ae5f8SJohn Marino 
3779*ef5ccd6cSJohn Marino 	    data = safe_read_uleb128 (data, end, &ul);
3780*ef5ccd6cSJohn Marino 	    type_die.cu_off = ul;
3781a45ae5f8SJohn Marino 
3782*ef5ccd6cSJohn Marino 	    if (type_die.cu_off == 0)
3783a45ae5f8SJohn Marino 	      fprintf_filtered (stream, "<0>");
3784a45ae5f8SJohn Marino 	    else
3785a45ae5f8SJohn Marino 	      {
3786a45ae5f8SJohn Marino 		struct type *type;
3787a45ae5f8SJohn Marino 
3788a45ae5f8SJohn Marino 		type = dwarf2_get_die_type (type_die, per_cu);
3789a45ae5f8SJohn Marino 		fprintf_filtered (stream, "<");
3790a45ae5f8SJohn Marino 		type_print (type, "", stream, -1);
3791*ef5ccd6cSJohn Marino 		fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
3792a45ae5f8SJohn Marino 	      }
3793a45ae5f8SJohn Marino 	  }
3794a45ae5f8SJohn Marino 	  break;
3795a45ae5f8SJohn Marino 
3796a45ae5f8SJohn Marino 	case DW_OP_GNU_entry_value:
3797*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3798a45ae5f8SJohn Marino 	  fputc_filtered ('\n', stream);
3799a45ae5f8SJohn Marino 	  disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
3800a45ae5f8SJohn Marino 					start, data, data + ul, indent + 2,
3801a45ae5f8SJohn Marino 					all, per_cu);
3802a45ae5f8SJohn Marino 	  data += ul;
3803a45ae5f8SJohn Marino 	  continue;
3804*ef5ccd6cSJohn Marino 
3805*ef5ccd6cSJohn Marino 	case DW_OP_GNU_parameter_ref:
3806*ef5ccd6cSJohn Marino 	  ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3807*ef5ccd6cSJohn Marino 	  data += 4;
3808*ef5ccd6cSJohn Marino 	  fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3809*ef5ccd6cSJohn Marino 	  break;
3810*ef5ccd6cSJohn Marino 
3811*ef5ccd6cSJohn Marino 	case DW_OP_GNU_addr_index:
3812*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3813*ef5ccd6cSJohn Marino 	  ul = dwarf2_read_addr_index (per_cu, ul);
3814*ef5ccd6cSJohn Marino 	  fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
3815*ef5ccd6cSJohn Marino 	  break;
3816*ef5ccd6cSJohn Marino 	case DW_OP_GNU_const_index:
3817*ef5ccd6cSJohn Marino 	  data = safe_read_uleb128 (data, end, &ul);
3818*ef5ccd6cSJohn Marino 	  ul = dwarf2_read_addr_index (per_cu, ul);
3819*ef5ccd6cSJohn Marino 	  fprintf_filtered (stream, " %s", pulongest (ul));
3820*ef5ccd6cSJohn Marino 	  break;
3821cf7f2e2dSJohn Marino 	}
3822cf7f2e2dSJohn Marino 
3823cf7f2e2dSJohn Marino       fprintf_filtered (stream, "\n");
3824cf7f2e2dSJohn Marino     }
3825cf7f2e2dSJohn Marino 
3826cf7f2e2dSJohn Marino   return data;
3827cf7f2e2dSJohn Marino }
3828cf7f2e2dSJohn Marino 
3829cf7f2e2dSJohn Marino /* Describe a single location, which may in turn consist of multiple
3830cf7f2e2dSJohn Marino    pieces.  */
3831cf7f2e2dSJohn Marino 
3832cf7f2e2dSJohn Marino static void
locexpr_describe_location_1(struct symbol * symbol,CORE_ADDR addr,struct ui_file * stream,const gdb_byte * data,size_t size,struct objfile * objfile,unsigned int addr_size,int offset_size,struct dwarf2_per_cu_data * per_cu)3833cf7f2e2dSJohn Marino locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
3834cf7f2e2dSJohn Marino 			     struct ui_file *stream,
3835*ef5ccd6cSJohn Marino 			     const gdb_byte *data, size_t size,
3836cf7f2e2dSJohn Marino 			     struct objfile *objfile, unsigned int addr_size,
3837a45ae5f8SJohn Marino 			     int offset_size, struct dwarf2_per_cu_data *per_cu)
3838cf7f2e2dSJohn Marino {
3839cf7f2e2dSJohn Marino   const gdb_byte *end = data + size;
3840cf7f2e2dSJohn Marino   int first_piece = 1, bad = 0;
3841cf7f2e2dSJohn Marino 
3842cf7f2e2dSJohn Marino   while (data < end)
3843cf7f2e2dSJohn Marino     {
3844cf7f2e2dSJohn Marino       const gdb_byte *here = data;
3845cf7f2e2dSJohn Marino       int disassemble = 1;
3846cf7f2e2dSJohn Marino 
3847cf7f2e2dSJohn Marino       if (first_piece)
3848cf7f2e2dSJohn Marino 	first_piece = 0;
3849cf7f2e2dSJohn Marino       else
3850cf7f2e2dSJohn Marino 	fprintf_filtered (stream, _(", and "));
3851cf7f2e2dSJohn Marino 
3852cf7f2e2dSJohn Marino       if (!dwarf2_always_disassemble)
3853cf7f2e2dSJohn Marino 	{
3854c50c785cSJohn Marino 	  data = locexpr_describe_location_piece (symbol, stream,
3855*ef5ccd6cSJohn Marino 						  addr, objfile, per_cu,
3856cf7f2e2dSJohn Marino 						  data, end, addr_size);
3857cf7f2e2dSJohn Marino 	  /* If we printed anything, or if we have an empty piece,
3858cf7f2e2dSJohn Marino 	     then don't disassemble.  */
3859cf7f2e2dSJohn Marino 	  if (data != here
3860cf7f2e2dSJohn Marino 	      || data[0] == DW_OP_piece
3861cf7f2e2dSJohn Marino 	      || data[0] == DW_OP_bit_piece)
3862cf7f2e2dSJohn Marino 	    disassemble = 0;
3863cf7f2e2dSJohn Marino 	}
3864cf7f2e2dSJohn Marino       if (disassemble)
3865a45ae5f8SJohn Marino 	{
3866a45ae5f8SJohn Marino 	  fprintf_filtered (stream, _("a complex DWARF expression:\n"));
3867c50c785cSJohn Marino 	  data = disassemble_dwarf_expression (stream,
3868c50c785cSJohn Marino 					       get_objfile_arch (objfile),
3869a45ae5f8SJohn Marino 					       addr_size, offset_size, data,
3870a45ae5f8SJohn Marino 					       data, end, 0,
3871a45ae5f8SJohn Marino 					       dwarf2_always_disassemble,
3872a45ae5f8SJohn Marino 					       per_cu);
3873a45ae5f8SJohn Marino 	}
3874cf7f2e2dSJohn Marino 
3875cf7f2e2dSJohn Marino       if (data < end)
3876cf7f2e2dSJohn Marino 	{
3877cf7f2e2dSJohn Marino 	  int empty = data == here;
3878cf7f2e2dSJohn Marino 
3879cf7f2e2dSJohn Marino 	  if (disassemble)
3880cf7f2e2dSJohn Marino 	    fprintf_filtered (stream, "   ");
3881cf7f2e2dSJohn Marino 	  if (data[0] == DW_OP_piece)
3882cf7f2e2dSJohn Marino 	    {
3883*ef5ccd6cSJohn Marino 	      uint64_t bytes;
3884cf7f2e2dSJohn Marino 
3885*ef5ccd6cSJohn Marino 	      data = safe_read_uleb128 (data + 1, end, &bytes);
3886cf7f2e2dSJohn Marino 
3887cf7f2e2dSJohn Marino 	      if (empty)
3888cf7f2e2dSJohn Marino 		fprintf_filtered (stream, _("an empty %s-byte piece"),
3889cf7f2e2dSJohn Marino 				  pulongest (bytes));
3890cf7f2e2dSJohn Marino 	      else
3891cf7f2e2dSJohn Marino 		fprintf_filtered (stream, _(" [%s-byte piece]"),
3892cf7f2e2dSJohn Marino 				  pulongest (bytes));
3893cf7f2e2dSJohn Marino 	    }
3894cf7f2e2dSJohn Marino 	  else if (data[0] == DW_OP_bit_piece)
3895cf7f2e2dSJohn Marino 	    {
3896*ef5ccd6cSJohn Marino 	      uint64_t bits, offset;
3897cf7f2e2dSJohn Marino 
3898*ef5ccd6cSJohn Marino 	      data = safe_read_uleb128 (data + 1, end, &bits);
3899*ef5ccd6cSJohn Marino 	      data = safe_read_uleb128 (data, end, &offset);
3900cf7f2e2dSJohn Marino 
3901cf7f2e2dSJohn Marino 	      if (empty)
3902cf7f2e2dSJohn Marino 		fprintf_filtered (stream,
3903cf7f2e2dSJohn Marino 				  _("an empty %s-bit piece"),
3904cf7f2e2dSJohn Marino 				  pulongest (bits));
3905cf7f2e2dSJohn Marino 	      else
3906cf7f2e2dSJohn Marino 		fprintf_filtered (stream,
3907cf7f2e2dSJohn Marino 				  _(" [%s-bit piece, offset %s bits]"),
3908cf7f2e2dSJohn Marino 				  pulongest (bits), pulongest (offset));
3909cf7f2e2dSJohn Marino 	    }
3910cf7f2e2dSJohn Marino 	  else
3911cf7f2e2dSJohn Marino 	    {
3912cf7f2e2dSJohn Marino 	      bad = 1;
3913cf7f2e2dSJohn Marino 	      break;
3914cf7f2e2dSJohn Marino 	    }
3915cf7f2e2dSJohn Marino 	}
3916cf7f2e2dSJohn Marino     }
3917cf7f2e2dSJohn Marino 
3918cf7f2e2dSJohn Marino   if (bad || data > end)
3919cf7f2e2dSJohn Marino     error (_("Corrupted DWARF2 expression for \"%s\"."),
3920cf7f2e2dSJohn Marino 	   SYMBOL_PRINT_NAME (symbol));
3921cf7f2e2dSJohn Marino }
3922cf7f2e2dSJohn Marino 
3923cf7f2e2dSJohn Marino /* Print a natural-language description of SYMBOL to STREAM.  This
3924cf7f2e2dSJohn Marino    version is for a symbol with a single location.  */
3925cf7f2e2dSJohn Marino 
3926cf7f2e2dSJohn Marino static void
locexpr_describe_location(struct symbol * symbol,CORE_ADDR addr,struct ui_file * stream)3927cf7f2e2dSJohn Marino locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
3928cf7f2e2dSJohn Marino 			   struct ui_file *stream)
3929cf7f2e2dSJohn Marino {
3930cf7f2e2dSJohn Marino   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
39315796c8dcSSimon Schubert   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
3932cf7f2e2dSJohn Marino   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
3933cf7f2e2dSJohn Marino   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
3934cf7f2e2dSJohn Marino 
3935c50c785cSJohn Marino   locexpr_describe_location_1 (symbol, addr, stream,
3936c50c785cSJohn Marino 			       dlbaton->data, dlbaton->size,
3937a45ae5f8SJohn Marino 			       objfile, addr_size, offset_size,
3938a45ae5f8SJohn Marino 			       dlbaton->per_cu);
39395796c8dcSSimon Schubert }
39405796c8dcSSimon Schubert 
39415796c8dcSSimon Schubert /* Describe the location of SYMBOL as an agent value in VALUE, generating
3942cf7f2e2dSJohn Marino    any necessary bytecode in AX.  */
39435796c8dcSSimon Schubert 
39445796c8dcSSimon Schubert static void
locexpr_tracepoint_var_ref(struct symbol * symbol,struct gdbarch * gdbarch,struct agent_expr * ax,struct axs_value * value)39455796c8dcSSimon Schubert locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
39465796c8dcSSimon Schubert 			    struct agent_expr *ax, struct axs_value *value)
39475796c8dcSSimon Schubert {
39485796c8dcSSimon Schubert   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3949cf7f2e2dSJohn Marino   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
39505796c8dcSSimon Schubert 
3951a45ae5f8SJohn Marino   if (dlbaton->size == 0)
3952cf7f2e2dSJohn Marino     value->optimized_out = 1;
3953cf7f2e2dSJohn Marino   else
3954c50c785cSJohn Marino     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
3955cf7f2e2dSJohn Marino 			       dlbaton->data, dlbaton->data + dlbaton->size,
3956cf7f2e2dSJohn Marino 			       dlbaton->per_cu);
39575796c8dcSSimon Schubert }
39585796c8dcSSimon Schubert 
39595796c8dcSSimon Schubert /* The set of location functions used with the DWARF-2 expression
39605796c8dcSSimon Schubert    evaluator.  */
39615796c8dcSSimon Schubert const struct symbol_computed_ops dwarf2_locexpr_funcs = {
39625796c8dcSSimon Schubert   locexpr_read_variable,
3963a45ae5f8SJohn Marino   locexpr_read_variable_at_entry,
39645796c8dcSSimon Schubert   locexpr_read_needs_frame,
39655796c8dcSSimon Schubert   locexpr_describe_location,
39665796c8dcSSimon Schubert   locexpr_tracepoint_var_ref
39675796c8dcSSimon Schubert };
39685796c8dcSSimon Schubert 
39695796c8dcSSimon Schubert 
39705796c8dcSSimon Schubert /* Wrapper functions for location lists.  These generally find
39715796c8dcSSimon Schubert    the appropriate location expression and call something above.  */
39725796c8dcSSimon Schubert 
39735796c8dcSSimon Schubert /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
39745796c8dcSSimon Schubert    evaluator to calculate the location.  */
39755796c8dcSSimon Schubert static struct value *
loclist_read_variable(struct symbol * symbol,struct frame_info * frame)39765796c8dcSSimon Schubert loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
39775796c8dcSSimon Schubert {
39785796c8dcSSimon Schubert   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
39795796c8dcSSimon Schubert   struct value *val;
3980cf7f2e2dSJohn Marino   const gdb_byte *data;
39815796c8dcSSimon Schubert   size_t size;
3982c50c785cSJohn Marino   CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
39835796c8dcSSimon Schubert 
3984c50c785cSJohn Marino   data = dwarf2_find_location_expression (dlbaton, &size, pc);
3985cf7f2e2dSJohn Marino   val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
39865796c8dcSSimon Schubert 				  dlbaton->per_cu);
39875796c8dcSSimon Schubert 
39885796c8dcSSimon Schubert   return val;
39895796c8dcSSimon Schubert }
39905796c8dcSSimon Schubert 
3991a45ae5f8SJohn Marino /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
3992a45ae5f8SJohn Marino    entry.  SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3993a45ae5f8SJohn Marino    will be thrown.
3994a45ae5f8SJohn Marino 
3995a45ae5f8SJohn Marino    Function always returns non-NULL value, it may be marked optimized out if
3996a45ae5f8SJohn Marino    inferior frame information is not available.  It throws NO_ENTRY_VALUE_ERROR
3997a45ae5f8SJohn Marino    if it cannot resolve the parameter for any reason.  */
3998a45ae5f8SJohn Marino 
3999a45ae5f8SJohn Marino static struct value *
loclist_read_variable_at_entry(struct symbol * symbol,struct frame_info * frame)4000a45ae5f8SJohn Marino loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
4001a45ae5f8SJohn Marino {
4002a45ae5f8SJohn Marino   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4003a45ae5f8SJohn Marino   const gdb_byte *data;
4004a45ae5f8SJohn Marino   size_t size;
4005a45ae5f8SJohn Marino   CORE_ADDR pc;
4006a45ae5f8SJohn Marino 
4007a45ae5f8SJohn Marino   if (frame == NULL || !get_frame_func_if_available (frame, &pc))
4008a45ae5f8SJohn Marino     return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4009a45ae5f8SJohn Marino 
4010a45ae5f8SJohn Marino   data = dwarf2_find_location_expression (dlbaton, &size, pc);
4011a45ae5f8SJohn Marino   if (data == NULL)
4012a45ae5f8SJohn Marino     return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4013a45ae5f8SJohn Marino 
4014a45ae5f8SJohn Marino   return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
4015a45ae5f8SJohn Marino }
4016a45ae5f8SJohn Marino 
40175796c8dcSSimon Schubert /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
40185796c8dcSSimon Schubert static int
loclist_read_needs_frame(struct symbol * symbol)40195796c8dcSSimon Schubert loclist_read_needs_frame (struct symbol *symbol)
40205796c8dcSSimon Schubert {
40215796c8dcSSimon Schubert   /* If there's a location list, then assume we need to have a frame
40225796c8dcSSimon Schubert      to choose the appropriate location expression.  With tracking of
40235796c8dcSSimon Schubert      global variables this is not necessarily true, but such tracking
40245796c8dcSSimon Schubert      is disabled in GCC at the moment until we figure out how to
40255796c8dcSSimon Schubert      represent it.  */
40265796c8dcSSimon Schubert 
40275796c8dcSSimon Schubert   return 1;
40285796c8dcSSimon Schubert }
40295796c8dcSSimon Schubert 
4030cf7f2e2dSJohn Marino /* Print a natural-language description of SYMBOL to STREAM.  This
4031cf7f2e2dSJohn Marino    version applies when there is a list of different locations, each
4032cf7f2e2dSJohn Marino    with a specified address range.  */
4033cf7f2e2dSJohn Marino 
4034cf7f2e2dSJohn Marino static void
loclist_describe_location(struct symbol * symbol,CORE_ADDR addr,struct ui_file * stream)4035cf7f2e2dSJohn Marino loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
4036cf7f2e2dSJohn Marino 			   struct ui_file *stream)
40375796c8dcSSimon Schubert {
4038cf7f2e2dSJohn Marino   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4039cf7f2e2dSJohn Marino   const gdb_byte *loc_ptr, *buf_end;
4040cf7f2e2dSJohn Marino   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4041cf7f2e2dSJohn Marino   struct gdbarch *gdbarch = get_objfile_arch (objfile);
4042cf7f2e2dSJohn Marino   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4043cf7f2e2dSJohn Marino   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4044cf7f2e2dSJohn Marino   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4045cf7f2e2dSJohn Marino   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
4046cf7f2e2dSJohn Marino   /* Adjust base_address for relocatable objects.  */
4047cf7f2e2dSJohn Marino   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
4048cf7f2e2dSJohn Marino   CORE_ADDR base_address = dlbaton->base_address + base_offset;
4049*ef5ccd6cSJohn Marino   int done = 0;
4050cf7f2e2dSJohn Marino 
4051cf7f2e2dSJohn Marino   loc_ptr = dlbaton->data;
4052cf7f2e2dSJohn Marino   buf_end = dlbaton->data + dlbaton->size;
4053cf7f2e2dSJohn Marino 
4054cf7f2e2dSJohn Marino   fprintf_filtered (stream, _("multi-location:\n"));
4055cf7f2e2dSJohn Marino 
4056cf7f2e2dSJohn Marino   /* Iterate through locations until we run out.  */
4057*ef5ccd6cSJohn Marino   while (!done)
4058cf7f2e2dSJohn Marino     {
4059*ef5ccd6cSJohn Marino       CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
4060*ef5ccd6cSJohn Marino       int length;
4061*ef5ccd6cSJohn Marino       enum debug_loc_kind kind;
4062*ef5ccd6cSJohn Marino       const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
4063cf7f2e2dSJohn Marino 
4064*ef5ccd6cSJohn Marino       if (dlbaton->from_dwo)
4065*ef5ccd6cSJohn Marino 	kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
4066*ef5ccd6cSJohn Marino 					       loc_ptr, buf_end, &new_ptr,
4067*ef5ccd6cSJohn Marino 					       &low, &high, byte_order);
4068cf7f2e2dSJohn Marino       else
4069*ef5ccd6cSJohn Marino 	kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
4070*ef5ccd6cSJohn Marino 					   &low, &high,
4071*ef5ccd6cSJohn Marino 					   byte_order, addr_size,
4072*ef5ccd6cSJohn Marino 					   signed_addr_p);
4073*ef5ccd6cSJohn Marino       loc_ptr = new_ptr;
4074*ef5ccd6cSJohn Marino       switch (kind)
4075cf7f2e2dSJohn Marino 	{
4076*ef5ccd6cSJohn Marino 	case DEBUG_LOC_END_OF_LIST:
4077*ef5ccd6cSJohn Marino 	  done = 1;
4078*ef5ccd6cSJohn Marino 	  continue;
4079*ef5ccd6cSJohn Marino 	case DEBUG_LOC_BASE_ADDRESS:
4080cf7f2e2dSJohn Marino 	  base_address = high + base_offset;
4081cf7f2e2dSJohn Marino 	  fprintf_filtered (stream, _("  Base address %s"),
4082cf7f2e2dSJohn Marino 			    paddress (gdbarch, base_address));
4083cf7f2e2dSJohn Marino 	  continue;
4084*ef5ccd6cSJohn Marino 	case DEBUG_LOC_START_END:
4085*ef5ccd6cSJohn Marino 	case DEBUG_LOC_START_LENGTH:
4086cf7f2e2dSJohn Marino 	  break;
4087*ef5ccd6cSJohn Marino 	case DEBUG_LOC_BUFFER_OVERFLOW:
4088*ef5ccd6cSJohn Marino 	case DEBUG_LOC_INVALID_ENTRY:
4089*ef5ccd6cSJohn Marino 	  error (_("Corrupted DWARF expression for symbol \"%s\"."),
4090*ef5ccd6cSJohn Marino 		 SYMBOL_PRINT_NAME (symbol));
4091*ef5ccd6cSJohn Marino 	default:
4092*ef5ccd6cSJohn Marino 	  gdb_assert_not_reached ("bad debug_loc_kind");
4093*ef5ccd6cSJohn Marino 	}
4094cf7f2e2dSJohn Marino 
4095cf7f2e2dSJohn Marino       /* Otherwise, a location expression entry.  */
4096cf7f2e2dSJohn Marino       low += base_address;
4097cf7f2e2dSJohn Marino       high += base_address;
4098cf7f2e2dSJohn Marino 
4099cf7f2e2dSJohn Marino       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
4100cf7f2e2dSJohn Marino       loc_ptr += 2;
4101cf7f2e2dSJohn Marino 
4102cf7f2e2dSJohn Marino       /* (It would improve readability to print only the minimum
4103cf7f2e2dSJohn Marino 	 necessary digits of the second number of the range.)  */
4104cf7f2e2dSJohn Marino       fprintf_filtered (stream, _("  Range %s-%s: "),
4105cf7f2e2dSJohn Marino 			paddress (gdbarch, low), paddress (gdbarch, high));
4106cf7f2e2dSJohn Marino 
4107cf7f2e2dSJohn Marino       /* Now describe this particular location.  */
4108cf7f2e2dSJohn Marino       locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
4109a45ae5f8SJohn Marino 				   objfile, addr_size, offset_size,
4110a45ae5f8SJohn Marino 				   dlbaton->per_cu);
4111cf7f2e2dSJohn Marino 
4112cf7f2e2dSJohn Marino       fprintf_filtered (stream, "\n");
4113cf7f2e2dSJohn Marino 
4114cf7f2e2dSJohn Marino       loc_ptr += length;
4115cf7f2e2dSJohn Marino     }
41165796c8dcSSimon Schubert }
41175796c8dcSSimon Schubert 
41185796c8dcSSimon Schubert /* Describe the location of SYMBOL as an agent value in VALUE, generating
41195796c8dcSSimon Schubert    any necessary bytecode in AX.  */
41205796c8dcSSimon Schubert static void
loclist_tracepoint_var_ref(struct symbol * symbol,struct gdbarch * gdbarch,struct agent_expr * ax,struct axs_value * value)41215796c8dcSSimon Schubert loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
41225796c8dcSSimon Schubert 			    struct agent_expr *ax, struct axs_value *value)
41235796c8dcSSimon Schubert {
41245796c8dcSSimon Schubert   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4125cf7f2e2dSJohn Marino   const gdb_byte *data;
41265796c8dcSSimon Schubert   size_t size;
4127cf7f2e2dSJohn Marino   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
41285796c8dcSSimon Schubert 
4129c50c785cSJohn Marino   data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
4130a45ae5f8SJohn Marino   if (size == 0)
4131cf7f2e2dSJohn Marino     value->optimized_out = 1;
4132cf7f2e2dSJohn Marino   else
4133c50c785cSJohn Marino     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
4134cf7f2e2dSJohn Marino 			       dlbaton->per_cu);
41355796c8dcSSimon Schubert }
41365796c8dcSSimon Schubert 
41375796c8dcSSimon Schubert /* The set of location functions used with the DWARF-2 expression
41385796c8dcSSimon Schubert    evaluator and location lists.  */
41395796c8dcSSimon Schubert const struct symbol_computed_ops dwarf2_loclist_funcs = {
41405796c8dcSSimon Schubert   loclist_read_variable,
4141a45ae5f8SJohn Marino   loclist_read_variable_at_entry,
41425796c8dcSSimon Schubert   loclist_read_needs_frame,
41435796c8dcSSimon Schubert   loclist_describe_location,
41445796c8dcSSimon Schubert   loclist_tracepoint_var_ref
41455796c8dcSSimon Schubert };
4146a45ae5f8SJohn Marino 
4147*ef5ccd6cSJohn Marino /* Provide a prototype to silence -Wmissing-prototypes.  */
4148*ef5ccd6cSJohn Marino extern initialize_file_ftype _initialize_dwarf2loc;
4149*ef5ccd6cSJohn Marino 
4150a45ae5f8SJohn Marino void
_initialize_dwarf2loc(void)4151a45ae5f8SJohn Marino _initialize_dwarf2loc (void)
4152a45ae5f8SJohn Marino {
4153*ef5ccd6cSJohn Marino   add_setshow_zuinteger_cmd ("entry-values", class_maintenance,
4154a45ae5f8SJohn Marino 			     &entry_values_debug,
4155a45ae5f8SJohn Marino 			     _("Set entry values and tail call frames "
4156a45ae5f8SJohn Marino 			       "debugging."),
4157a45ae5f8SJohn Marino 			     _("Show entry values and tail call frames "
4158a45ae5f8SJohn Marino 			       "debugging."),
4159a45ae5f8SJohn Marino 			     _("When non-zero, the process of determining "
4160a45ae5f8SJohn Marino 			       "parameter values from function entry point "
4161a45ae5f8SJohn Marino 			       "and tail call frames will be printed."),
4162a45ae5f8SJohn Marino 			     NULL,
4163a45ae5f8SJohn Marino 			     show_entry_values_debug,
4164a45ae5f8SJohn Marino 			     &setdebuglist, &showdebuglist);
4165a45ae5f8SJohn Marino }
4166