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, ®);
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, ®);
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, ®);
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, ®);
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, ®);
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