projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Import alloca explicitly
[deliverable/binutils-gdb.git] / gdb / dwarf2loc.c
CommitLineData
4c2df51b 1/* DWARF 2 location expression support for GDB.
feb13ab0 2
ecd75fc8 3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
feb13ab0 4
4c2df51b
DJ		 5 Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7
JB		 11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
4c2df51b 13
a9762ec7
JB		 14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
4c2df51b
DJ		 18
19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
4c2df51b
DJ		 21
22#include "defs.h"
23#include "ui-out.h"
24#include "value.h"
25#include "frame.h"
26#include "gdbcore.h"
27#include "target.h"
28#include "inferior.h"
a55cc764
DJ		 29#include "ax.h"
30#include "ax-gdb.h"
e4adbba9 31#include "regcache.h"
c3228f12 32#include "objfiles.h"
edb3359d 33#include "block.h"
8e3b41a9 34#include "gdbcmd.h"
4c2df51b 35
fa8f86ff 36#include "dwarf2.h"
4c2df51b
DJ		 37#include "dwarf2expr.h"
38#include "dwarf2loc.h"
e7802207 39#include "dwarf2-frame.h"
4c2df51b 40
9eae7c52
TT		 41extern int dwarf2_always_disassemble;
42
1632a688
JK		 43static void dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
44 const gdb_byte **start, size_t *length);
0936ad1d 45
8e3b41a9
JK		 46static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
47
1632a688
JK		 48static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
49 struct frame_info *frame,
50 const gdb_byte *data,
56eb65bd
SP		 51 size_t size,
52 struct dwarf2_per_cu_data *per_cu,
1632a688 53 LONGEST byte_offset);
8cf6f0b1 54
f664829e
DE		 55/* Until these have formal names, we define these here.
56 ref: http://gcc.gnu.org/wiki/DebugFission
57 Each entry in .debug_loc.dwo begins with a byte that describes the entry,
58 and is then followed by data specific to that entry. */
59
60enum debug_loc_kind
61{
62 /* Indicates the end of the list of entries. */
63 DEBUG_LOC_END_OF_LIST = 0,
64
65 /* This is followed by an unsigned LEB128 number that is an index into
66 .debug_addr and specifies the base address for all following entries. */
67 DEBUG_LOC_BASE_ADDRESS = 1,
68
69 /* This is followed by two unsigned LEB128 numbers that are indices into
70 .debug_addr and specify the beginning and ending addresses, and then
71 a normal location expression as in .debug_loc. */
3771a44c
DE		 72 DEBUG_LOC_START_END = 2,
73
74 /* This is followed by an unsigned LEB128 number that is an index into
75 .debug_addr and specifies the beginning address, and a 4 byte unsigned
76 number that specifies the length, and then a normal location expression
77 as in .debug_loc. */
78 DEBUG_LOC_START_LENGTH = 3,
f664829e
DE		 79
80 /* An internal value indicating there is insufficient data. */
81 DEBUG_LOC_BUFFER_OVERFLOW = -1,
82
83 /* An internal value indicating an invalid kind of entry was found. */
84 DEBUG_LOC_INVALID_ENTRY = -2
85};
86
b6807d98
TT		 87/* Helper function which throws an error if a synthetic pointer is
88 invalid. */
89
90static void
91invalid_synthetic_pointer (void)
92{
93 error (_("access outside bounds of object "
94 "referenced via synthetic pointer"));
95}
96
f664829e
DE		 97/* Decode the addresses in a non-dwo .debug_loc entry.
98 A pointer to the next byte to examine is returned in *NEW_PTR.
99 The encoded low,high addresses are return in *LOW,*HIGH.
100 The result indicates the kind of entry found. */
101
102static enum debug_loc_kind
103decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
104 const gdb_byte **new_ptr,
105 CORE_ADDR *low, CORE_ADDR *high,
106 enum bfd_endian byte_order,
107 unsigned int addr_size,
108 int signed_addr_p)
109{
110 CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
111
112 if (buf_end - loc_ptr < 2 * addr_size)
113 return DEBUG_LOC_BUFFER_OVERFLOW;
114
115 if (signed_addr_p)
116 *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
117 else
118 *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
119 loc_ptr += addr_size;
120
121 if (signed_addr_p)
122 *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
123 else
124 *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
125 loc_ptr += addr_size;
126
127 *new_ptr = loc_ptr;
128
129 /* A base-address-selection entry. */
130 if ((*low & base_mask) == base_mask)
131 return DEBUG_LOC_BASE_ADDRESS;
132
133 /* An end-of-list entry. */
134 if (*low == 0 && *high == 0)
135 return DEBUG_LOC_END_OF_LIST;
136
3771a44c 137 return DEBUG_LOC_START_END;
f664829e
DE		 138}
139
140/* Decode the addresses in .debug_loc.dwo entry.
141 A pointer to the next byte to examine is returned in *NEW_PTR.
142 The encoded low,high addresses are return in *LOW,*HIGH.
143 The result indicates the kind of entry found. */
144
145static enum debug_loc_kind
146decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
147 const gdb_byte *loc_ptr,
148 const gdb_byte *buf_end,
149 const gdb_byte **new_ptr,
3771a44c
DE		 150 CORE_ADDR *low, CORE_ADDR *high,
151 enum bfd_endian byte_order)
f664829e 152{
9fccedf7 153 uint64_t low_index, high_index;
f664829e
DE		 154
155 if (loc_ptr == buf_end)
156 return DEBUG_LOC_BUFFER_OVERFLOW;
157
158 switch (*loc_ptr++)
159 {
160 case DEBUG_LOC_END_OF_LIST:
161 *new_ptr = loc_ptr;
162 return DEBUG_LOC_END_OF_LIST;
163 case DEBUG_LOC_BASE_ADDRESS:
164 *low = 0;
165 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
166 if (loc_ptr == NULL)
167 return DEBUG_LOC_BUFFER_OVERFLOW;
168 *high = dwarf2_read_addr_index (per_cu, high_index);
169 *new_ptr = loc_ptr;
170 return DEBUG_LOC_BASE_ADDRESS;
3771a44c 171 case DEBUG_LOC_START_END:
f664829e
DE		 172 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
173 if (loc_ptr == NULL)
174 return DEBUG_LOC_BUFFER_OVERFLOW;
175 *low = dwarf2_read_addr_index (per_cu, low_index);
176 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
177 if (loc_ptr == NULL)
178 return DEBUG_LOC_BUFFER_OVERFLOW;
179 *high = dwarf2_read_addr_index (per_cu, high_index);
180 *new_ptr = loc_ptr;
3771a44c
DE		 181 return DEBUG_LOC_START_END;
182 case DEBUG_LOC_START_LENGTH:
183 loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
184 if (loc_ptr == NULL)
185 return DEBUG_LOC_BUFFER_OVERFLOW;
186 *low = dwarf2_read_addr_index (per_cu, low_index);
187 if (loc_ptr + 4 > buf_end)
188 return DEBUG_LOC_BUFFER_OVERFLOW;
189 *high = *low;
190 *high += extract_unsigned_integer (loc_ptr, 4, byte_order);
191 *new_ptr = loc_ptr + 4;
192 return DEBUG_LOC_START_LENGTH;
f664829e
DE		 193 default:
194 return DEBUG_LOC_INVALID_ENTRY;
195 }
196}
197
8cf6f0b1 198/* A function for dealing with location lists. Given a
0d53c4c4
DJ		 199 symbol baton (BATON) and a pc value (PC), find the appropriate
200 location expression, set *LOCEXPR_LENGTH, and return a pointer
201 to the beginning of the expression. Returns NULL on failure.
202
203 For now, only return the first matching location expression; there
204 can be more than one in the list. */
205
8cf6f0b1
TT		 206const gdb_byte *
207dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
208 size_t *locexpr_length, CORE_ADDR pc)
0d53c4c4 209{
ae0d2f24 210 struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
f7fd4728 211 struct gdbarch *gdbarch = get_objfile_arch (objfile);
e17a4113 212 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ae0d2f24 213 unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
d4a087c7 214 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
8edfa926 215 /* Adjust base_address for relocatable objects. */
9aa1f1e3 216 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
8edfa926 217 CORE_ADDR base_address = baton->base_address + base_offset;
f664829e 218 const gdb_byte *loc_ptr, *buf_end;
0d53c4c4
DJ		 219
220 loc_ptr = baton->data;
221 buf_end = baton->data + baton->size;
222
223 while (1)
224 {
f664829e
DE		 225 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
226 int length;
227 enum debug_loc_kind kind;
228 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
229
230 if (baton->from_dwo)
231 kind = decode_debug_loc_dwo_addresses (baton->per_cu,
232 loc_ptr, buf_end, &new_ptr,
3771a44c 233 &low, &high, byte_order);
d4a087c7 234 else
f664829e
DE		 235 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
236 &low, &high,
237 byte_order, addr_size,
238 signed_addr_p);
239 loc_ptr = new_ptr;
240 switch (kind)
1d6edc3c 241 {
f664829e 242 case DEBUG_LOC_END_OF_LIST:
1d6edc3c
JK		 243 *locexpr_length = 0;
244 return NULL;
f664829e
DE		 245 case DEBUG_LOC_BASE_ADDRESS:
246 base_address = high + base_offset;
247 continue;
3771a44c
DE		 248 case DEBUG_LOC_START_END:
249 case DEBUG_LOC_START_LENGTH:
f664829e
DE		 250 break;
251 case DEBUG_LOC_BUFFER_OVERFLOW:
252 case DEBUG_LOC_INVALID_ENTRY:
253 error (_("dwarf2_find_location_expression: "
254 "Corrupted DWARF expression."));
255 default:
256 gdb_assert_not_reached ("bad debug_loc_kind");
1d6edc3c 257 }
b5758fe4 258
bed911e5
DE		 259 /* Otherwise, a location expression entry.
260 If the entry is from a DWO, don't add base address: the entry is
261 from .debug_addr which has absolute addresses. */
262 if (! baton->from_dwo)
263 {
264 low += base_address;
265 high += base_address;
266 }
0d53c4c4 267
e17a4113 268 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
0d53c4c4
DJ		 269 loc_ptr += 2;
270
e18b2753
JK		 271 if (low == high && pc == low)
272 {
273 /* This is entry PC record present only at entry point
274 of a function. Verify it is really the function entry point. */
275
3977b71f 276 const struct block *pc_block = block_for_pc (pc);
e18b2753
JK		 277 struct symbol *pc_func = NULL;
278
279 if (pc_block)
280 pc_func = block_linkage_function (pc_block);
281
282 if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
283 {
284 *locexpr_length = length;
285 return loc_ptr;
286 }
287 }
288
0d53c4c4
DJ		 289 if (pc >= low && pc < high)
290 {
291 *locexpr_length = length;
292 return loc_ptr;
293 }
294
295 loc_ptr += length;
296 }
297}
298
4c2df51b
DJ		 299/* This is the baton used when performing dwarf2 expression
300 evaluation. */
301struct dwarf_expr_baton
302{
303 struct frame_info *frame;
17ea53c3 304 struct dwarf2_per_cu_data *per_cu;
08412b07 305 CORE_ADDR obj_address;
4c2df51b
DJ		 306};
307
308/* Helper functions for dwarf2_evaluate_loc_desc. */
309
4bc9efe1 310/* Using the frame specified in BATON, return the value of register
0b2b0195 311 REGNUM, treated as a pointer. */
4c2df51b 312static CORE_ADDR
b1370418 313dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum)
4c2df51b 314{
4c2df51b 315 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
5e2b427d 316 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
2ed3c037 317 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
e4adbba9 318
2ed3c037 319 return address_from_register (regnum, debaton->frame);
4c2df51b
DJ		 320}
321
0acf8b65
JB		 322/* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
323
324static struct value *
325dwarf_expr_get_reg_value (void *baton, struct type *type, int dwarf_regnum)
326{
327 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
328 struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
329 int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
330
331 return value_from_register (type, regnum, debaton->frame);
332}
333
4c2df51b
DJ		 334/* Read memory at ADDR (length LEN) into BUF. */
335
336static void
852483bc 337dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
4c2df51b
DJ		 338{
339 read_memory (addr, buf, len);
340}
341
342/* Using the frame specified in BATON, find the location expression
343 describing the frame base. Return a pointer to it in START and
344 its length in LENGTH. */
345static void
0d45f56e 346dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
4c2df51b 347{
da62e633
AC		 348 /* FIXME: cagney/2003-03-26: This code should be using
349 get_frame_base_address(), and then implement a dwarf2 specific
350 this_base method. */
4c2df51b 351 struct symbol *framefunc;
4c2df51b 352 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
3977b71f 353 const struct block *bl = get_frame_block (debaton->frame, NULL);
c90a0773
HZ		 354
355 if (bl == NULL)
356 error (_("frame address is not available."));
0d53c4c4 357
edb3359d
DJ		 358 /* Use block_linkage_function, which returns a real (not inlined)
359 function, instead of get_frame_function, which may return an
360 inlined function. */
c90a0773 361 framefunc = block_linkage_function (bl);
0d53c4c4 362
eff4f95e
JG		 363 /* If we found a frame-relative symbol then it was certainly within
364 some function associated with a frame. If we can't find the frame,
365 something has gone wrong. */
366 gdb_assert (framefunc != NULL);
367
0936ad1d
SS		 368 dwarf_expr_frame_base_1 (framefunc,
369 get_frame_address_in_block (debaton->frame),
370 start, length);
371}
372
f1e6e072
TT		 373/* Implement find_frame_base_location method for LOC_BLOCK functions using
374 DWARF expression for its DW_AT_frame_base. */
375
376static void
377locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
378 const gdb_byte **start, size_t *length)
379{
380 struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
381
382 *length = symbaton->size;
383 *start = symbaton->data;
384}
385
386/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
387 function uses DWARF expression for its DW_AT_frame_base. */
388
389const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
390{
391 locexpr_find_frame_base_location
392};
393
394/* Implement find_frame_base_location method for LOC_BLOCK functions using
395 DWARF location list for its DW_AT_frame_base. */
396
397static void
398loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
399 const gdb_byte **start, size_t *length)
400{
401 struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
402
403 *start = dwarf2_find_location_expression (symbaton, length, pc);
404}
405
406/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
407 function uses DWARF location list for its DW_AT_frame_base. */
408
409const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
410{
411 loclist_find_frame_base_location
412};
413
0936ad1d
SS		 414static void
415dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
0d45f56e 416 const gdb_byte **start, size_t *length)
0936ad1d 417{
f1e6e072 418 if (SYMBOL_BLOCK_OPS (framefunc) != NULL)
0d53c4c4 419 {
f1e6e072 420 const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc);
22c6caba 421
f1e6e072 422 ops_block->find_frame_base_location (framefunc, pc, start, length);
0d53c4c4
DJ		 423 }
424 else
f1e6e072 425 *length = 0;
0d53c4c4 426
1d6edc3c 427 if (*length == 0)
8a3fe4f8 428 error (_("Could not find the frame base for \"%s\"."),
0d53c4c4 429 SYMBOL_NATURAL_NAME (framefunc));
4c2df51b
DJ		 430}
431
e7802207
TT		 432/* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
433 the frame in BATON. */
434
435static CORE_ADDR
436dwarf_expr_frame_cfa (void *baton)
437{
438 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
9a619af0 439
e7802207
TT		 440 return dwarf2_frame_cfa (debaton->frame);
441}
442
8cf6f0b1
TT		 443/* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
444 the frame in BATON. */
445
446static CORE_ADDR
447dwarf_expr_frame_pc (void *baton)
448{
449 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
450
451 return get_frame_address_in_block (debaton->frame);
452}
453
4c2df51b
DJ		 454/* Using the objfile specified in BATON, find the address for the
455 current thread's thread-local storage with offset OFFSET. */
456static CORE_ADDR
457dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
458{
459 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
17ea53c3 460 struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
4c2df51b 461
17ea53c3 462 return target_translate_tls_address (objfile, offset);
4c2df51b
DJ		 463}
464
3e43a32a
MS		 465/* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
466 current CU (as is PER_CU). State of the CTX is not affected by the
467 call and return. */
5c631832
JK		 468
469static void
b64f50a1 470per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
8cf6f0b1
TT		 471 struct dwarf2_per_cu_data *per_cu,
472 CORE_ADDR (*get_frame_pc) (void *baton),
473 void *baton)
5c631832
JK		 474{
475 struct dwarf2_locexpr_baton block;
476
8b9737bf 477 block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, get_frame_pc, baton);
5c631832
JK		 478
479 /* DW_OP_call_ref is currently not supported. */
480 gdb_assert (block.per_cu == per_cu);
481
482 dwarf_expr_eval (ctx, block.data, block.size);
483}
484
485/* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
486
487static void
b64f50a1 488dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
5c631832
JK		 489{
490 struct dwarf_expr_baton *debaton = ctx->baton;
491
37b50a69 492 per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
9e8b7a03 493 ctx->funcs->get_frame_pc, ctx->baton);
5c631832
JK		 494}
495
8a9b8146
TT		 496/* Callback function for dwarf2_evaluate_loc_desc. */
497
498static struct type *
b64f50a1
JK		 499dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
500 cu_offset die_offset)
8a9b8146
TT		 501{
502 struct dwarf_expr_baton *debaton = ctx->baton;
503
504 return dwarf2_get_die_type (die_offset, debaton->per_cu);
505}
506
8e3b41a9
JK		 507/* See dwarf2loc.h. */
508
ccce17b0 509unsigned int entry_values_debug = 0;
8e3b41a9
JK		 510
511/* Helper to set entry_values_debug. */
512
513static void
514show_entry_values_debug (struct ui_file *file, int from_tty,
515 struct cmd_list_element *c, const char *value)
516{
517 fprintf_filtered (file,
518 _("Entry values and tail call frames debugging is %s.\n"),
519 value);
520}
521
522/* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
523 CALLER_FRAME (for registers) can be NULL if it is not known. This function
524 always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
525
526static CORE_ADDR
527call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
528 struct call_site *call_site,
529 struct frame_info *caller_frame)
530{
531 switch (FIELD_LOC_KIND (call_site->target))
532 {
533 case FIELD_LOC_KIND_DWARF_BLOCK:
534 {
535 struct dwarf2_locexpr_baton *dwarf_block;
536 struct value *val;
537 struct type *caller_core_addr_type;
538 struct gdbarch *caller_arch;
539
540 dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
541 if (dwarf_block == NULL)
542 {
7cbd4a93 543 struct bound_minimal_symbol msym;
8e3b41a9
JK		 544
545 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
546 throw_error (NO_ENTRY_VALUE_ERROR,
547 _("DW_AT_GNU_call_site_target is not specified "
548 "at %s in %s"),
549 paddress (call_site_gdbarch, call_site->pc),
7cbd4a93 550 (msym.minsym == NULL ? "???"
efd66ac6 551 : MSYMBOL_PRINT_NAME (msym.minsym)));
8e3b41a9
JK		 552
553 }
554 if (caller_frame == NULL)
555 {
7cbd4a93 556 struct bound_minimal_symbol msym;
8e3b41a9
JK		 557
558 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
559 throw_error (NO_ENTRY_VALUE_ERROR,
560 _("DW_AT_GNU_call_site_target DWARF block resolving "
561 "requires known frame which is currently not "
562 "available at %s in %s"),
563 paddress (call_site_gdbarch, call_site->pc),
7cbd4a93 564 (msym.minsym == NULL ? "???"
efd66ac6 565 : MSYMBOL_PRINT_NAME (msym.minsym)));
8e3b41a9
JK		 566
567 }
568 caller_arch = get_frame_arch (caller_frame);
569 caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
570 val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
571 dwarf_block->data, dwarf_block->size,
572 dwarf_block->per_cu);
573 /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
574 location. */
575 if (VALUE_LVAL (val) == lval_memory)
576 return value_address (val);
577 else
578 return value_as_address (val);
579 }
580
581 case FIELD_LOC_KIND_PHYSNAME:
582 {
583 const char *physname;
3b7344d5 584 struct bound_minimal_symbol msym;
8e3b41a9
JK		 585
586 physname = FIELD_STATIC_PHYSNAME (call_site->target);
9112db09
JK		 587
588 /* Handle both the mangled and demangled PHYSNAME. */
589 msym = lookup_minimal_symbol (physname, NULL, NULL);
3b7344d5 590 if (msym.minsym == NULL)
8e3b41a9 591 {
3b7344d5 592 msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
8e3b41a9
JK		 593 throw_error (NO_ENTRY_VALUE_ERROR,
594 _("Cannot find function \"%s\" for a call site target "
595 "at %s in %s"),
596 physname, paddress (call_site_gdbarch, call_site->pc),
3b7344d5
TT		 597 (msym.minsym == NULL ? "???"
598 : MSYMBOL_PRINT_NAME (msym.minsym)));
8e3b41a9
JK		 599
600 }
77e371c0 601 return BMSYMBOL_VALUE_ADDRESS (msym);
8e3b41a9
JK		 602 }
603
604 case FIELD_LOC_KIND_PHYSADDR:
605 return FIELD_STATIC_PHYSADDR (call_site->target);
606
607 default:
608 internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
609 }
610}
611
111c6489
JK		 612/* Convert function entry point exact address ADDR to the function which is
613 compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
614 NO_ENTRY_VALUE_ERROR otherwise. */
615
616static struct symbol *
617func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
618{
619 struct symbol *sym = find_pc_function (addr);
620 struct type *type;
621
622 if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
623 throw_error (NO_ENTRY_VALUE_ERROR,
624 _("DW_TAG_GNU_call_site resolving failed to find function "
625 "name for address %s"),
626 paddress (gdbarch, addr));
627
628 type = SYMBOL_TYPE (sym);
629 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
630 gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);
631
632 return sym;
633}
634
2d6c5dc2
JK		 635/* Verify function with entry point exact address ADDR can never call itself
636 via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
637 can call itself via tail calls.
638
639 If a funtion can tail call itself its entry value based parameters are
640 unreliable. There is no verification whether the value of some/all
641 parameters is unchanged through the self tail call, we expect if there is
642 a self tail call all the parameters can be modified. */
643
644static void
645func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
646{
647 struct obstack addr_obstack;
648 struct cleanup *old_chain;
649 CORE_ADDR addr;
650
651 /* Track here CORE_ADDRs which were already visited. */
652 htab_t addr_hash;
653
654 /* The verification is completely unordered. Track here function addresses
655 which still need to be iterated. */
656 VEC (CORE_ADDR) *todo = NULL;
657
658 obstack_init (&addr_obstack);
659 old_chain = make_cleanup_obstack_free (&addr_obstack);
660 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
661 &addr_obstack, hashtab_obstack_allocate,
662 NULL);
663 make_cleanup_htab_delete (addr_hash);
664
665 make_cleanup (VEC_cleanup (CORE_ADDR), &todo);
666
667 VEC_safe_push (CORE_ADDR, todo, verify_addr);
668 while (!VEC_empty (CORE_ADDR, todo))
669 {
670 struct symbol *func_sym;
671 struct call_site *call_site;
672
673 addr = VEC_pop (CORE_ADDR, todo);
674
675 func_sym = func_addr_to_tail_call_list (gdbarch, addr);
676
677 for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
678 call_site; call_site = call_site->tail_call_next)
679 {
680 CORE_ADDR target_addr;
681 void **slot;
682
683 /* CALLER_FRAME with registers is not available for tail-call jumped
684 frames. */
685 target_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
686
687 if (target_addr == verify_addr)
688 {
7cbd4a93 689 struct bound_minimal_symbol msym;
2d6c5dc2
JK		 690
691 msym = lookup_minimal_symbol_by_pc (verify_addr);
692 throw_error (NO_ENTRY_VALUE_ERROR,
693 _("DW_OP_GNU_entry_value resolving has found "
694 "function \"%s\" at %s can call itself via tail "
695 "calls"),
7cbd4a93 696 (msym.minsym == NULL ? "???"
efd66ac6 697 : MSYMBOL_PRINT_NAME (msym.minsym)),
2d6c5dc2
JK		 698 paddress (gdbarch, verify_addr));
699 }
700
701 slot = htab_find_slot (addr_hash, &target_addr, INSERT);
702 if (*slot == NULL)
703 {
704 *slot = obstack_copy (&addr_obstack, &target_addr,
705 sizeof (target_addr));
706 VEC_safe_push (CORE_ADDR, todo, target_addr);
707 }
708 }
709 }
710
711 do_cleanups (old_chain);
712}
713
111c6489
JK		 714/* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
715 ENTRY_VALUES_DEBUG. */
716
717static void
718tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
719{
720 CORE_ADDR addr = call_site->pc;
7cbd4a93 721 struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);
111c6489
JK		 722
723 fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
7cbd4a93 724 (msym.minsym == NULL ? "???"
efd66ac6 725 : MSYMBOL_PRINT_NAME (msym.minsym)));
111c6489
JK		 726
727}
728
729/* vec.h needs single word type name, typedef it. */
730typedef struct call_site *call_sitep;
731
732/* Define VEC (call_sitep) functions. */
733DEF_VEC_P (call_sitep);
734
735/* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
736 only top callers and bottom callees which are present in both. GDBARCH is
737 used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
738 no remaining possibilities to provide unambiguous non-trivial result.
739 RESULTP should point to NULL on the first (initialization) call. Caller is
740 responsible for xfree of any RESULTP data. */
741
742static void
743chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
744 VEC (call_sitep) *chain)
745{
746 struct call_site_chain *result = *resultp;
747 long length = VEC_length (call_sitep, chain);
748 int callers, callees, idx;
749
750 if (result == NULL)
751 {
752 /* Create the initial chain containing all the passed PCs. */
753
754 result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
755 * (length - 1));
756 result->length = length;
757 result->callers = result->callees = length;
19a1b230
AA		 758 if (!VEC_empty (call_sitep, chain))
759 memcpy (result->call_site, VEC_address (call_sitep, chain),
760 sizeof (*result->call_site) * length);
111c6489
JK		 761 *resultp = result;
762
763 if (entry_values_debug)
764 {
765 fprintf_unfiltered (gdb_stdlog, "tailcall: initial:");
766 for (idx = 0; idx < length; idx++)
767 tailcall_dump (gdbarch, result->call_site[idx]);
768 fputc_unfiltered ('\n', gdb_stdlog);
769 }
770
771 return;
772 }
773
774 if (entry_values_debug)
775 {
776 fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
777 for (idx = 0; idx < length; idx++)
778 tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
779 fputc_unfiltered ('\n', gdb_stdlog);
780 }
781
782 /* Intersect callers. */
783
784 callers = min (result->callers, length);
785 for (idx = 0; idx < callers; idx++)
786 if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
787 {
788 result->callers = idx;
789 break;
790 }
791
792 /* Intersect callees. */
793
794 callees = min (result->callees, length);
795 for (idx = 0; idx < callees; idx++)
796 if (result->call_site[result->length - 1 - idx]
797 != VEC_index (call_sitep, chain, length - 1 - idx))
798 {
799 result->callees = idx;
800 break;
801 }
802
803 if (entry_values_debug)
804 {
805 fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
806 for (idx = 0; idx < result->callers; idx++)
807 tailcall_dump (gdbarch, result->call_site[idx]);
808 fputs_unfiltered (" |", gdb_stdlog);
809 for (idx = 0; idx < result->callees; idx++)
810 tailcall_dump (gdbarch, result->call_site[result->length
811 - result->callees + idx]);
812 fputc_unfiltered ('\n', gdb_stdlog);
813 }
814
815 if (result->callers == 0 && result->callees == 0)
816 {
817 /* There are no common callers or callees. It could be also a direct
818 call (which has length 0) with ambiguous possibility of an indirect
819 call - CALLERS == CALLEES == 0 is valid during the first allocation
820 but any subsequence processing of such entry means ambiguity. */
821 xfree (result);
822 *resultp = NULL;
823 return;
824 }
825
826 /* See call_site_find_chain_1 why there is no way to reach the bottom callee
827 PC again. In such case there must be two different code paths to reach
828 it, therefore some of the former determined intermediate PCs must differ
829 and the unambiguous chain gets shortened. */
830 gdb_assert (result->callers + result->callees < result->length);
831}
832
833/* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
834 assumed frames between them use GDBARCH. Use depth first search so we can
835 keep single CHAIN of call_site's back to CALLER_PC. Function recursion
836 would have needless GDB stack overhead. Caller is responsible for xfree of
837 the returned result. Any unreliability results in thrown
838 NO_ENTRY_VALUE_ERROR. */
839
840static struct call_site_chain *
841call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
842 CORE_ADDR callee_pc)
843{
c4be5165 844 CORE_ADDR save_callee_pc = callee_pc;
111c6489
JK		 845 struct obstack addr_obstack;
846 struct cleanup *back_to_retval, *back_to_workdata;
847 struct call_site_chain *retval = NULL;
848 struct call_site *call_site;
849
850 /* Mark CALL_SITEs so we do not visit the same ones twice. */
851 htab_t addr_hash;
852
853 /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
854 call_site nor any possible call_site at CALLEE_PC's function is there.
855 Any CALL_SITE in CHAIN will be iterated to its siblings - via
856 TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
857 VEC (call_sitep) *chain = NULL;
858
859 /* We are not interested in the specific PC inside the callee function. */
860 callee_pc = get_pc_function_start (callee_pc);
861 if (callee_pc == 0)
862 throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
c4be5165 863 paddress (gdbarch, save_callee_pc));
111c6489
JK		 864
865 back_to_retval = make_cleanup (free_current_contents, &retval);
866
867 obstack_init (&addr_obstack);
868 back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
869 addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
870 &addr_obstack, hashtab_obstack_allocate,
871 NULL);
872 make_cleanup_htab_delete (addr_hash);
873
874 make_cleanup (VEC_cleanup (call_sitep), &chain);
875
876 /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
877 at the target's function. All the possible tail call sites in the
878 target's function will get iterated as already pushed into CHAIN via their
879 TAIL_CALL_NEXT. */
880 call_site = call_site_for_pc (gdbarch, caller_pc);
881
882 while (call_site)
883 {
884 CORE_ADDR target_func_addr;
885 struct call_site *target_call_site;
886
887 /* CALLER_FRAME with registers is not available for tail-call jumped
888 frames. */
889 target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
890
891 if (target_func_addr == callee_pc)
892 {
893 chain_candidate (gdbarch, &retval, chain);
894 if (retval == NULL)
895 break;
896
897 /* There is no way to reach CALLEE_PC again as we would prevent
898 entering it twice as being already marked in ADDR_HASH. */
899 target_call_site = NULL;
900 }
901 else
902 {
903 struct symbol *target_func;
904
905 target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
906 target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
907 }
908
909 do
910 {
911 /* Attempt to visit TARGET_CALL_SITE. */
912
913 if (target_call_site)
914 {
915 void **slot;
916
917 slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
918 if (*slot == NULL)
919 {
920 /* Successfully entered TARGET_CALL_SITE. */
921
922 *slot = &target_call_site->pc;
923 VEC_safe_push (call_sitep, chain, target_call_site);
924 break;
925 }
926 }
927
928 /* Backtrack (without revisiting the originating call_site). Try the
929 callers's sibling; if there isn't any try the callers's callers's
930 sibling etc. */
931
932 target_call_site = NULL;
933 while (!VEC_empty (call_sitep, chain))
934 {
935 call_site = VEC_pop (call_sitep, chain);
936
937 gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
938 NO_INSERT) != NULL);
939 htab_remove_elt (addr_hash, &call_site->pc);
940
941 target_call_site = call_site->tail_call_next;
942 if (target_call_site)
943 break;
944 }
945 }
946 while (target_call_site);
947
948 if (VEC_empty (call_sitep, chain))
949 call_site = NULL;
950 else
951 call_site = VEC_last (call_sitep, chain);
952 }
953
954 if (retval == NULL)
955 {
7cbd4a93 956 struct bound_minimal_symbol msym_caller, msym_callee;
111c6489
JK		 957
958 msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
959 msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
960 throw_error (NO_ENTRY_VALUE_ERROR,
961 _("There are no unambiguously determinable intermediate "
962 "callers or callees between caller function \"%s\" at %s "
963 "and callee function \"%s\" at %s"),
7cbd4a93 964 (msym_caller.minsym == NULL
efd66ac6 965 ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
111c6489 966 paddress (gdbarch, caller_pc),
7cbd4a93 967 (msym_callee.minsym == NULL
efd66ac6 968 ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
111c6489
JK		 969 paddress (gdbarch, callee_pc));
970 }
971
972 do_cleanups (back_to_workdata);
973 discard_cleanups (back_to_retval);
974 return retval;
975}
976
977/* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
978 assumed frames between them use GDBARCH. If valid call_site_chain cannot be
979 constructed return NULL. Caller is responsible for xfree of the returned
980 result. */
981
982struct call_site_chain *
983call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
984 CORE_ADDR callee_pc)
985{
986 volatile struct gdb_exception e;
987 struct call_site_chain *retval = NULL;
988
989 TRY_CATCH (e, RETURN_MASK_ERROR)
990 {
991 retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
992 }
993 if (e.reason < 0)
994 {
995 if (e.error == NO_ENTRY_VALUE_ERROR)
996 {
997 if (entry_values_debug)
998 exception_print (gdb_stdout, e);
999
1000 return NULL;
1001 }
1002 else
1003 throw_exception (e);
1004 }
1005 return retval;
1006}
1007
24c5c679
JK		 1008/* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1009
1010static int
1011call_site_parameter_matches (struct call_site_parameter *parameter,
1012 enum call_site_parameter_kind kind,
1013 union call_site_parameter_u kind_u)
1014{
1015 if (kind == parameter->kind)
1016 switch (kind)
1017 {
1018 case CALL_SITE_PARAMETER_DWARF_REG:
1019 return kind_u.dwarf_reg == parameter->u.dwarf_reg;
1020 case CALL_SITE_PARAMETER_FB_OFFSET:
1021 return kind_u.fb_offset == parameter->u.fb_offset;
1788b2d3
JK		 1022 case CALL_SITE_PARAMETER_PARAM_OFFSET:
1023 return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
24c5c679
JK		 1024 }
1025 return 0;
1026}
1027
1028/* Fetch call_site_parameter from caller matching KIND and KIND_U.
1029 FRAME is for callee.
8e3b41a9
JK		 1030
1031 Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1032 otherwise. */
1033
1034static struct call_site_parameter *
24c5c679
JK		 1035dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
1036 enum call_site_parameter_kind kind,
1037 union call_site_parameter_u kind_u,
8e3b41a9
JK		 1038 struct dwarf2_per_cu_data **per_cu_return)
1039{
9e3a7d65
JK		 1040 CORE_ADDR func_addr, caller_pc;
1041 struct gdbarch *gdbarch;
1042 struct frame_info *caller_frame;
8e3b41a9
JK		 1043 struct call_site *call_site;
1044 int iparams;
509f0fd9
JK		 1045 /* Initialize it just to avoid a GCC false warning. */
1046 struct call_site_parameter *parameter = NULL;
8e3b41a9
JK		 1047 CORE_ADDR target_addr;
1048
9e3a7d65
JK		 1049 while (get_frame_type (frame) == INLINE_FRAME)
1050 {
1051 frame = get_prev_frame (frame);
1052 gdb_assert (frame != NULL);
1053 }
1054
1055 func_addr = get_frame_func (frame);
1056 gdbarch = get_frame_arch (frame);
1057 caller_frame = get_prev_frame (frame);
8e3b41a9
JK		 1058 if (gdbarch != frame_unwind_arch (frame))
1059 {
7cbd4a93
TT		 1060 struct bound_minimal_symbol msym
1061 = lookup_minimal_symbol_by_pc (func_addr);
8e3b41a9
JK		 1062 struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
1063
1064 throw_error (NO_ENTRY_VALUE_ERROR,
1065 _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1066 "(of %s (%s)) does not match caller gdbarch %s"),
1067 gdbarch_bfd_arch_info (gdbarch)->printable_name,
1068 paddress (gdbarch, func_addr),
7cbd4a93 1069 (msym.minsym == NULL ? "???"
efd66ac6 1070 : MSYMBOL_PRINT_NAME (msym.minsym)),
8e3b41a9
JK		 1071 gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
1072 }
1073
1074 if (caller_frame == NULL)
1075 {
7cbd4a93
TT		 1076 struct bound_minimal_symbol msym
1077 = lookup_minimal_symbol_by_pc (func_addr);
8e3b41a9
JK		 1078
1079 throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
1080 "requires caller of %s (%s)"),
1081 paddress (gdbarch, func_addr),
7cbd4a93 1082 (msym.minsym == NULL ? "???"
efd66ac6 1083 : MSYMBOL_PRINT_NAME (msym.minsym)));
8e3b41a9
JK		 1084 }
1085 caller_pc = get_frame_pc (caller_frame);
1086 call_site = call_site_for_pc (gdbarch, caller_pc);
1087
1088 target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
1089 if (target_addr != func_addr)
1090 {
1091 struct minimal_symbol *target_msym, *func_msym;
1092
7cbd4a93
TT		 1093 target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
1094 func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
8e3b41a9
JK		 1095 throw_error (NO_ENTRY_VALUE_ERROR,
1096 _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1097 "but the called frame is for %s at %s"),
1098 (target_msym == NULL ? "???"
efd66ac6 1099 : MSYMBOL_PRINT_NAME (target_msym)),
8e3b41a9 1100 paddress (gdbarch, target_addr),
efd66ac6 1101 func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
8e3b41a9
JK		 1102 paddress (gdbarch, func_addr));
1103 }
1104
2d6c5dc2
JK		 1105 /* No entry value based parameters would be reliable if this function can
1106 call itself via tail calls. */
1107 func_verify_no_selftailcall (gdbarch, func_addr);
1108
8e3b41a9
JK		 1109 for (iparams = 0; iparams < call_site->parameter_count; iparams++)
1110 {
1111 parameter = &call_site->parameter[iparams];
24c5c679 1112 if (call_site_parameter_matches (parameter, kind, kind_u))
8e3b41a9
JK		 1113 break;
1114 }
1115 if (iparams == call_site->parameter_count)
1116 {
7cbd4a93
TT		 1117 struct minimal_symbol *msym
1118 = lookup_minimal_symbol_by_pc (caller_pc).minsym;
8e3b41a9
JK		 1119
1120 /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1121 determine its value. */
1122 throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
1123 "at DW_TAG_GNU_call_site %s at %s"),
1124 paddress (gdbarch, caller_pc),
efd66ac6 1125 msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
8e3b41a9
JK		 1126 }
1127
1128 *per_cu_return = call_site->per_cu;
1129 return parameter;
1130}
1131
a471c594
JK		 1132/* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1133 the normal DW_AT_GNU_call_site_value block. Otherwise return the
1134 DW_AT_GNU_call_site_data_value (dereferenced) block.
e18b2753
JK		 1135
1136 TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1137 struct value.
1138
1139 Function always returns non-NULL, non-optimized out value. It throws
1140 NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1141
1142static struct value *
1143dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
a471c594 1144 CORE_ADDR deref_size, struct type *type,
e18b2753
JK		 1145 struct frame_info *caller_frame,
1146 struct dwarf2_per_cu_data *per_cu)
1147{
a471c594 1148 const gdb_byte *data_src;
e18b2753 1149 gdb_byte *data;
a471c594
JK		 1150 size_t size;
1151
1152 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1153 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1154
1155 /* DEREF_SIZE size is not verified here. */
1156 if (data_src == NULL)
1157 throw_error (NO_ENTRY_VALUE_ERROR,
1158 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
e18b2753
JK		 1159
1160 /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1161 location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1162 DWARF block. */
a471c594
JK		 1163 data = alloca (size + 1);
1164 memcpy (data, data_src, size);
1165 data[size] = DW_OP_stack_value;
e18b2753 1166
a471c594 1167 return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
e18b2753
JK		 1168}
1169
24c5c679
JK		 1170/* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1171 Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1172 frame. CTX must be of dwarf_expr_ctx_funcs kind.
8e3b41a9
JK		 1173
1174 The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1175 can be more simple as it does not support cross-CU DWARF executions. */
1176
1177static void
1178dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
24c5c679
JK		 1179 enum call_site_parameter_kind kind,
1180 union call_site_parameter_u kind_u,
a471c594 1181 int deref_size)
8e3b41a9
JK		 1182{
1183 struct dwarf_expr_baton *debaton;
1184 struct frame_info *frame, *caller_frame;
1185 struct dwarf2_per_cu_data *caller_per_cu;
1186 struct dwarf_expr_baton baton_local;
1187 struct dwarf_expr_context saved_ctx;
1188 struct call_site_parameter *parameter;
1189 const gdb_byte *data_src;
1190 size_t size;
1191
1192 gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
1193 debaton = ctx->baton;
1194 frame = debaton->frame;
1195 caller_frame = get_prev_frame (frame);
1196
24c5c679 1197 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
8e3b41a9 1198 &caller_per_cu);
a471c594
JK		 1199 data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1200 size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1201
1202 /* DEREF_SIZE size is not verified here. */
1203 if (data_src == NULL)
1204 throw_error (NO_ENTRY_VALUE_ERROR,
1205 _("Cannot resolve DW_AT_GNU_call_site_data_value"));
8e3b41a9
JK		 1206
1207 baton_local.frame = caller_frame;
1208 baton_local.per_cu = caller_per_cu;
08412b07 1209 baton_local.obj_address = 0;
8e3b41a9
JK		 1210
1211 saved_ctx.gdbarch = ctx->gdbarch;
1212 saved_ctx.addr_size = ctx->addr_size;
1213 saved_ctx.offset = ctx->offset;
1214 saved_ctx.baton = ctx->baton;
1215 ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
1216 ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
1217 ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
1218 ctx->baton = &baton_local;
1219
1220 dwarf_expr_eval (ctx, data_src, size);
1221
1222 ctx->gdbarch = saved_ctx.gdbarch;
1223 ctx->addr_size = saved_ctx.addr_size;
1224 ctx->offset = saved_ctx.offset;
1225 ctx->baton = saved_ctx.baton;
1226}
1227
3019eac3
DE		 1228/* Callback function for dwarf2_evaluate_loc_desc.
1229 Fetch the address indexed by DW_OP_GNU_addr_index. */
1230
1231static CORE_ADDR
1232dwarf_expr_get_addr_index (void *baton, unsigned int index)
1233{
1234 struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
1235
1236 return dwarf2_read_addr_index (debaton->per_cu, index);
1237}
1238
08412b07
JB		 1239/* Callback function for get_object_address. Return the address of the VLA
1240 object. */
1241
1242static CORE_ADDR
1243dwarf_expr_get_obj_addr (void *baton)
1244{
1245 struct dwarf_expr_baton *debaton = baton;
1246
1247 gdb_assert (debaton != NULL);
1248
1249 if (debaton->obj_address == 0)
1250 error (_("Location address is not set."));
1251
1252 return debaton->obj_address;
1253}
1254
a471c594
JK		 1255/* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1256 the indirect method on it, that is use its stored target value, the sole
1257 purpose of entry_data_value_funcs.. */
1258
1259static struct value *
1260entry_data_value_coerce_ref (const struct value *value)
1261{
1262 struct type *checked_type = check_typedef (value_type (value));
1263 struct value *target_val;
1264
1265 if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
1266 return NULL;
1267
1268 target_val = value_computed_closure (value);
1269 value_incref (target_val);
1270 return target_val;
1271}
1272
1273/* Implement copy_closure. */
1274
1275static void *
1276entry_data_value_copy_closure (const struct value *v)
1277{
1278 struct value *target_val = value_computed_closure (v);
1279
1280 value_incref (target_val);
1281 return target_val;
1282}
1283
1284/* Implement free_closure. */
1285
1286static void
1287entry_data_value_free_closure (struct value *v)
1288{
1289 struct value *target_val = value_computed_closure (v);
1290
1291 value_free (target_val);
1292}
1293
1294/* Vector for methods for an entry value reference where the referenced value
1295 is stored in the caller. On the first dereference use
1296 DW_AT_GNU_call_site_data_value in the caller. */
1297
1298static const struct lval_funcs entry_data_value_funcs =
1299{
1300 NULL, /* read */
1301 NULL, /* write */
a471c594
JK		 1302 NULL, /* indirect */
1303 entry_data_value_coerce_ref,
1304 NULL, /* check_synthetic_pointer */
1305 entry_data_value_copy_closure,
1306 entry_data_value_free_closure
1307};
1308
24c5c679
JK		 1309/* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1310 are used to match DW_AT_location at the caller's
1311 DW_TAG_GNU_call_site_parameter.
e18b2753
JK		 1312
1313 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1314 cannot resolve the parameter for any reason. */
1315
1316static struct value *
1317value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
24c5c679
JK		 1318 enum call_site_parameter_kind kind,
1319 union call_site_parameter_u kind_u)
e18b2753 1320{
a471c594
JK		 1321 struct type *checked_type = check_typedef (type);
1322 struct type *target_type = TYPE_TARGET_TYPE (checked_type);
e18b2753 1323 struct frame_info *caller_frame = get_prev_frame (frame);
a471c594 1324 struct value *outer_val, *target_val, *val;
e18b2753
JK		 1325 struct call_site_parameter *parameter;
1326 struct dwarf2_per_cu_data *caller_per_cu;
1327
24c5c679 1328 parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
e18b2753
JK		 1329 &caller_per_cu);
1330
a471c594
JK		 1331 outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
1332 type, caller_frame,
1333 caller_per_cu);
1334
1335 /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1336 used and it is not available do not fall back to OUTER_VAL - dereferencing
1337 TYPE_CODE_REF with non-entry data value would give current value - not the
1338 entry value. */
1339
1340 if (TYPE_CODE (checked_type) != TYPE_CODE_REF
1341 || TYPE_TARGET_TYPE (checked_type) == NULL)
1342 return outer_val;
1343
1344 target_val = dwarf_entry_parameter_to_value (parameter,
1345 TYPE_LENGTH (target_type),
1346 target_type, caller_frame,
1347 caller_per_cu);
1348
a471c594
JK		 1349 release_value (target_val);
1350 val = allocate_computed_value (type, &entry_data_value_funcs,
1351 target_val /* closure */);
1352
1353 /* Copy the referencing pointer to the new computed value. */
1354 memcpy (value_contents_raw (val), value_contents_raw (outer_val),
1355 TYPE_LENGTH (checked_type));
1356 set_value_lazy (val, 0);
1357
1358 return val;
e18b2753
JK		 1359}
1360
1361/* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1362 SIZE are DWARF block used to match DW_AT_location at the caller's
1363 DW_TAG_GNU_call_site_parameter.
1364
1365 Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1366 cannot resolve the parameter for any reason. */
1367
1368static struct value *
1369value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
1370 const gdb_byte *block, size_t block_len)
1371{
24c5c679 1372 union call_site_parameter_u kind_u;
e18b2753 1373
24c5c679
JK		 1374 kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
1375 if (kind_u.dwarf_reg != -1)
1376 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG,
1377 kind_u);
e18b2753 1378
24c5c679
JK		 1379 if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
1380 return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET,
1381 kind_u);
e18b2753
JK		 1382
1383 /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1384 suppressed during normal operation. The expression can be arbitrary if
1385 there is no caller-callee entry value binding expected. */
1386 throw_error (NO_ENTRY_VALUE_ERROR,
1387 _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1388 "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1389}
1390
052b9502
NF		 1391struct piece_closure
1392{
88bfdde4
TT		 1393 /* Reference count. */
1394 int refc;
1395
8cf6f0b1
TT		 1396 /* The CU from which this closure's expression came. */
1397 struct dwarf2_per_cu_data *per_cu;
1398
052b9502
NF		 1399 /* The number of pieces used to describe this variable. */
1400 int n_pieces;
1401
6063c216
UW		 1402 /* The target address size, used only for DWARF_VALUE_STACK. */
1403 int addr_size;
cec03d70 1404
052b9502
NF		 1405 /* The pieces themselves. */
1406 struct dwarf_expr_piece *pieces;
1407};
1408
1409/* Allocate a closure for a value formed from separately-described
1410 PIECES. */
1411
1412static struct piece_closure *
8cf6f0b1
TT		 1413allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
1414 int n_pieces, struct dwarf_expr_piece *pieces,
6063c216 1415 int addr_size)
052b9502 1416{
41bf6aca 1417 struct piece_closure *c = XCNEW (struct piece_closure);
8a9b8146 1418 int i;
052b9502 1419
88bfdde4 1420 c->refc = 1;
8cf6f0b1 1421 c->per_cu = per_cu;
052b9502 1422 c->n_pieces = n_pieces;
6063c216 1423 c->addr_size = addr_size;
fc270c35 1424 c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
052b9502
NF		 1425
1426 memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
8a9b8146
TT		 1427 for (i = 0; i < n_pieces; ++i)
1428 if (c->pieces[i].location == DWARF_VALUE_STACK)
1429 value_incref (c->pieces[i].v.value);
052b9502
NF		 1430
1431 return c;
1432}
1433
d3b1e874
TT		 1434/* The lowest-level function to extract bits from a byte buffer.
1435 SOURCE is the buffer. It is updated if we read to the end of a
1436 byte.
1437 SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1438 updated to reflect the number of bits actually read.
1439 NBITS is the number of bits we want to read. It is updated to
1440 reflect the number of bits actually read. This function may read
1441 fewer bits.
1442 BITS_BIG_ENDIAN is taken directly from gdbarch.
1443 This function returns the extracted bits. */
1444
1445static unsigned int
1446extract_bits_primitive (const gdb_byte **source,
1447 unsigned int *source_offset_bits,
1448 int *nbits, int bits_big_endian)
1449{
1450 unsigned int avail, mask, datum;
1451
1452 gdb_assert (*source_offset_bits < 8);
1453
1454 avail = 8 - *source_offset_bits;
1455 if (avail > *nbits)
1456 avail = *nbits;
1457
1458 mask = (1 << avail) - 1;
1459 datum = **source;
1460 if (bits_big_endian)
1461 datum >>= 8 - (*source_offset_bits + *nbits);
1462 else
1463 datum >>= *source_offset_bits;
1464 datum &= mask;
1465
1466 *nbits -= avail;
1467 *source_offset_bits += avail;
1468 if (*source_offset_bits >= 8)
1469 {
1470 *source_offset_bits -= 8;
1471 ++*source;
1472 }
1473
1474 return datum;
1475}
1476
1477/* Extract some bits from a source buffer and move forward in the
1478 buffer.
1479
1480 SOURCE is the source buffer. It is updated as bytes are read.
1481 SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1482 bits are read.
1483 NBITS is the number of bits to read.
1484 BITS_BIG_ENDIAN is taken directly from gdbarch.
1485
1486 This function returns the bits that were read. */
1487
1488static unsigned int
1489extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
1490 int nbits, int bits_big_endian)
1491{
1492 unsigned int datum;
1493
1494 gdb_assert (nbits > 0 && nbits <= 8);
1495
1496 datum = extract_bits_primitive (source, source_offset_bits, &nbits,
1497 bits_big_endian);
1498 if (nbits > 0)
1499 {
1500 unsigned int more;
1501
1502 more = extract_bits_primitive (source, source_offset_bits, &nbits,
1503 bits_big_endian);
1504 if (bits_big_endian)
1505 datum <<= nbits;
1506 else
1507 more <<= nbits;
1508 datum |= more;
1509 }
1510
1511 return datum;
1512}
1513
1514/* Write some bits into a buffer and move forward in the buffer.
1515
1516 DATUM is the bits to write. The low-order bits of DATUM are used.
1517 DEST is the destination buffer. It is updated as bytes are
1518 written.
1519 DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1520 done.
1521 NBITS is the number of valid bits in DATUM.
1522 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1523
1524static void
1525insert_bits (unsigned int datum,
1526 gdb_byte *dest, unsigned int dest_offset_bits,
1527 int nbits, int bits_big_endian)
1528{
1529 unsigned int mask;
1530
8c814cdd 1531 gdb_assert (dest_offset_bits + nbits <= 8);
d3b1e874
TT		 1532
1533 mask = (1 << nbits) - 1;
1534 if (bits_big_endian)
1535 {
1536 datum <<= 8 - (dest_offset_bits + nbits);
1537 mask <<= 8 - (dest_offset_bits + nbits);
1538 }
1539 else
1540 {
1541 datum <<= dest_offset_bits;
1542 mask <<= dest_offset_bits;
1543 }
1544
1545 gdb_assert ((datum & ~mask) == 0);
1546
1547 *dest = (*dest & ~mask) | datum;
1548}
1549
1550/* Copy bits from a source to a destination.
1551
1552 DEST is where the bits should be written.
1553 DEST_OFFSET_BITS is the bit offset into DEST.
1554 SOURCE is the source of bits.
1555 SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1556 BIT_COUNT is the number of bits to copy.
1557 BITS_BIG_ENDIAN is taken directly from gdbarch. */
1558
1559static void
1560copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
1561 const gdb_byte *source, unsigned int source_offset_bits,
1562 unsigned int bit_count,
1563 int bits_big_endian)
1564{
1565 unsigned int dest_avail;
1566 int datum;
1567
1568 /* Reduce everything to byte-size pieces. */
1569 dest += dest_offset_bits / 8;
1570 dest_offset_bits %= 8;
1571 source += source_offset_bits / 8;
1572 source_offset_bits %= 8;
1573
1574 dest_avail = 8 - dest_offset_bits % 8;
1575
1576 /* See if we can fill the first destination byte. */
1577 if (dest_avail < bit_count)
1578 {
1579 datum = extract_bits (&source, &source_offset_bits, dest_avail,
1580 bits_big_endian);
1581 insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1582 ++dest;
1583 dest_offset_bits = 0;
1584 bit_count -= dest_avail;
1585 }
1586
1587 /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1588 than 8 bits remaining. */
1589 gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1590 for (; bit_count >= 8; bit_count -= 8)
1591 {
1592 datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1593 *dest++ = (gdb_byte) datum;
1594 }
1595
1596 /* Finally, we may have a few leftover bits. */
1597 gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1598 if (bit_count > 0)
1599 {
1600 datum = extract_bits (&source, &source_offset_bits, bit_count,
1601 bits_big_endian);
1602 insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1603 }
1604}
1605
052b9502
NF		 1606static void
1607read_pieced_value (struct value *v)
1608{
1609 int i;
1610 long offset = 0;
d3b1e874 1611 ULONGEST bits_to_skip;
052b9502 1612 gdb_byte *contents;
3e43a32a
MS		 1613 struct piece_closure *c
1614 = (struct piece_closure *) value_computed_closure (v);
052b9502 1615 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
afd74c5f 1616 size_t type_len;
d3b1e874 1617 size_t buffer_size = 0;
948f8e3d 1618 gdb_byte *buffer = NULL;
d3b1e874
TT		 1619 struct cleanup *cleanup;
1620 int bits_big_endian
1621 = gdbarch_bits_big_endian (get_type_arch (value_type (v)));
afd74c5f
TT		 1622
1623 if (value_type (v) != value_enclosing_type (v))
1624 internal_error (__FILE__, __LINE__,
1625 _("Should not be able to create a lazy value with "
1626 "an enclosing type"));
052b9502 1627
d3b1e874
TT		 1628 cleanup = make_cleanup (free_current_contents, &buffer);
1629
052b9502 1630 contents = value_contents_raw (v);
d3b1e874 1631 bits_to_skip = 8 * value_offset (v);
0e03807e
TT		 1632 if (value_bitsize (v))
1633 {
1634 bits_to_skip += value_bitpos (v);
1635 type_len = value_bitsize (v);
1636 }
1637 else
1638 type_len = 8 * TYPE_LENGTH (value_type (v));
d3b1e874 1639
afd74c5f 1640 for (i = 0; i < c->n_pieces && offset < type_len; i++)
052b9502
NF		 1641 {
1642 struct dwarf_expr_piece *p = &c->pieces[i];
d3b1e874
TT		 1643 size_t this_size, this_size_bits;
1644 long dest_offset_bits, source_offset_bits, source_offset;
0d45f56e 1645 const gdb_byte *intermediate_buffer;
d3b1e874
TT		 1646
1647 /* Compute size, source, and destination offsets for copying, in
1648 bits. */
1649 this_size_bits = p->size;
1650 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
afd74c5f 1651 {
d3b1e874 1652 bits_to_skip -= this_size_bits;
afd74c5f
TT		 1653 continue;
1654 }
d3b1e874 1655 if (bits_to_skip > 0)
afd74c5f 1656 {
d3b1e874
TT		 1657 dest_offset_bits = 0;
1658 source_offset_bits = bits_to_skip;
1659 this_size_bits -= bits_to_skip;
1660 bits_to_skip = 0;
afd74c5f
TT		 1661 }
1662 else
1663 {
d3b1e874
TT		 1664 dest_offset_bits = offset;
1665 source_offset_bits = 0;
afd74c5f 1666 }
5bd1ef56
TT		 1667 if (this_size_bits > type_len - offset)
1668 this_size_bits = type_len - offset;
9a619af0 1669
d3b1e874
TT		 1670 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1671 source_offset = source_offset_bits / 8;
1672 if (buffer_size < this_size)
1673 {
1674 buffer_size = this_size;
1675 buffer = xrealloc (buffer, buffer_size);
1676 }
1677 intermediate_buffer = buffer;
1678
1679 /* Copy from the source to DEST_BUFFER. */
cec03d70 1680 switch (p->location)
052b9502 1681 {
cec03d70
TT		 1682 case DWARF_VALUE_REGISTER:
1683 {
1684 struct gdbarch *arch = get_frame_arch (frame);
8a9b8146 1685 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
dcbf108f 1686
63b4f126
MGD		 1687 if (gdb_regnum != -1)
1688 {
8dccd430 1689 int optim, unavail;
ca45ab26
VK		 1690 int reg_offset = source_offset;
1691
1692 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1693 && this_size < register_size (arch, gdb_regnum))
1694 {
1695 /* Big-endian, and we want less than full size. */
1696 reg_offset = register_size (arch, gdb_regnum) - this_size;
1697 /* We want the lower-order THIS_SIZE_BITS of the bytes
1698 we extract from the register. */
1699 source_offset_bits += 8 * this_size - this_size_bits;
1700 }
8dccd430
PA		 1701
1702 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1703 this_size, buffer,
1704 &optim, &unavail))
1705 {
1706 /* Just so garbage doesn't ever shine through. */
1707 memset (buffer, 0, this_size);
1708
1709 if (optim)
9a0dc9e3 1710 mark_value_bits_optimized_out (v, offset, this_size_bits);
8dccd430 1711 if (unavail)
bdf22206 1712 mark_value_bits_unavailable (v, offset, this_size_bits);
8dccd430 1713 }
63b4f126
MGD		 1714 }
1715 else
1716 {
1717 error (_("Unable to access DWARF register number %s"),
8a9b8146 1718 paddress (arch, p->v.regno));
63b4f126 1719 }
cec03d70
TT		 1720 }
1721 break;
1722
1723 case DWARF_VALUE_MEMORY:
e6ca34fc
PA		 1724 read_value_memory (v, offset,
1725 p->v.mem.in_stack_memory,
1726 p->v.mem.addr + source_offset,
1727 buffer, this_size);
cec03d70
TT		 1728 break;
1729
1730 case DWARF_VALUE_STACK:
1731 {
afd74c5f 1732 size_t n = this_size;
9a619af0 1733
afd74c5f
TT		 1734 if (n > c->addr_size - source_offset)
1735 n = (c->addr_size >= source_offset
1736 ? c->addr_size - source_offset
1737 : 0);
1738 if (n == 0)
1739 {
1740 /* Nothing. */
1741 }
afd74c5f
TT		 1742 else
1743 {
8a9b8146 1744 const gdb_byte *val_bytes = value_contents_all (p->v.value);
afd74c5f 1745
8a9b8146 1746 intermediate_buffer = val_bytes + source_offset;
afd74c5f 1747 }
cec03d70
TT		 1748 }
1749 break;
1750
1751 case DWARF_VALUE_LITERAL:
1752 {
afd74c5f
TT		 1753 size_t n = this_size;
1754
1755 if (n > p->v.literal.length - source_offset)
1756 n = (p->v.literal.length >= source_offset
1757 ? p->v.literal.length - source_offset
1758 : 0);
1759 if (n != 0)
d3b1e874 1760 intermediate_buffer = p->v.literal.data + source_offset;
cec03d70
TT		 1761 }
1762 break;
1763
8cf6f0b1
TT		 1764 /* These bits show up as zeros -- but do not cause the value
1765 to be considered optimized-out. */
1766 case DWARF_VALUE_IMPLICIT_POINTER:
1767 break;
1768
cb826367 1769 case DWARF_VALUE_OPTIMIZED_OUT:
9a0dc9e3 1770 mark_value_bits_optimized_out (v, offset, this_size_bits);
cb826367
TT		 1771 break;
1772
cec03d70
TT		 1773 default:
1774 internal_error (__FILE__, __LINE__, _("invalid location type"));
052b9502 1775 }
d3b1e874 1776
8cf6f0b1
TT		 1777 if (p->location != DWARF_VALUE_OPTIMIZED_OUT
1778 && p->location != DWARF_VALUE_IMPLICIT_POINTER)
d3b1e874
TT		 1779 copy_bitwise (contents, dest_offset_bits,
1780 intermediate_buffer, source_offset_bits % 8,
1781 this_size_bits, bits_big_endian);
1782
1783 offset += this_size_bits;
052b9502 1784 }
d3b1e874
TT		 1785
1786 do_cleanups (cleanup);
052b9502
NF		 1787}
1788
1789static void
1790write_pieced_value (struct value *to, struct value *from)
1791{
1792 int i;
1793 long offset = 0;
d3b1e874 1794 ULONGEST bits_to_skip;
afd74c5f 1795 const gdb_byte *contents;
3e43a32a
MS		 1796 struct piece_closure *c
1797 = (struct piece_closure *) value_computed_closure (to);
052b9502 1798 struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
afd74c5f 1799 size_t type_len;
d3b1e874 1800 size_t buffer_size = 0;
948f8e3d 1801 gdb_byte *buffer = NULL;
d3b1e874
TT		 1802 struct cleanup *cleanup;
1803 int bits_big_endian
1804 = gdbarch_bits_big_endian (get_type_arch (value_type (to)));
052b9502
NF		 1805
1806 if (frame == NULL)
1807 {
9a0dc9e3 1808 mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
052b9502
NF		 1809 return;
1810 }
1811
d3b1e874
TT		 1812 cleanup = make_cleanup (free_current_contents, &buffer);
1813
afd74c5f 1814 contents = value_contents (from);
d3b1e874 1815 bits_to_skip = 8 * value_offset (to);
0e03807e
TT		 1816 if (value_bitsize (to))
1817 {
1818 bits_to_skip += value_bitpos (to);
1819 type_len = value_bitsize (to);
1820 }
1821 else
1822 type_len = 8 * TYPE_LENGTH (value_type (to));
1823
afd74c5f 1824 for (i = 0; i < c->n_pieces && offset < type_len; i++)
052b9502
NF		 1825 {
1826 struct dwarf_expr_piece *p = &c->pieces[i];
d3b1e874
TT		 1827 size_t this_size_bits, this_size;
1828 long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1829 int need_bitwise;
1830 const gdb_byte *source_buffer;
afd74c5f 1831
d3b1e874
TT		 1832 this_size_bits = p->size;
1833 if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
afd74c5f 1834 {
d3b1e874 1835 bits_to_skip -= this_size_bits;
afd74c5f
TT		 1836 continue;
1837 }
d3b1e874
TT		 1838 if (this_size_bits > type_len - offset)
1839 this_size_bits = type_len - offset;
1840 if (bits_to_skip > 0)
afd74c5f 1841 {
d3b1e874
TT		 1842 dest_offset_bits = bits_to_skip;
1843 source_offset_bits = 0;
1844 this_size_bits -= bits_to_skip;
1845 bits_to_skip = 0;
afd74c5f
TT		 1846 }
1847 else
1848 {
d3b1e874
TT		 1849 dest_offset_bits = 0;
1850 source_offset_bits = offset;
1851 }
1852
1853 this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1854 source_offset = source_offset_bits / 8;
1855 dest_offset = dest_offset_bits / 8;
1856 if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1857 {
1858 source_buffer = contents + source_offset;
1859 need_bitwise = 0;
1860 }
1861 else
1862 {
1863 if (buffer_size < this_size)
1864 {
1865 buffer_size = this_size;
1866 buffer = xrealloc (buffer, buffer_size);
1867 }
1868 source_buffer = buffer;
1869 need_bitwise = 1;
afd74c5f 1870 }
9a619af0 1871
cec03d70 1872 switch (p->location)
052b9502 1873 {
cec03d70
TT		 1874 case DWARF_VALUE_REGISTER:
1875 {
1876 struct gdbarch *arch = get_frame_arch (frame);
8a9b8146 1877 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);
dcbf108f 1878
63b4f126
MGD		 1879 if (gdb_regnum != -1)
1880 {
ca45ab26
VK		 1881 int reg_offset = dest_offset;
1882
1883 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1884 && this_size <= register_size (arch, gdb_regnum))
1885 {
1886 /* Big-endian, and we want less than full size. */
1887 reg_offset = register_size (arch, gdb_regnum) - this_size;
1888 }
1889
d3b1e874
TT		 1890 if (need_bitwise)
1891 {
8dccd430
PA		 1892 int optim, unavail;
1893
1894 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1895 this_size, buffer,
1896 &optim, &unavail))
1897 {
1898 if (optim)
710409a2
PA		 1899 throw_error (OPTIMIZED_OUT_ERROR,
1900 _("Can't do read-modify-write to "
1901 "update bitfield; containing word "
1902 "has been optimized out"));
8dccd430
PA		 1903 if (unavail)
1904 throw_error (NOT_AVAILABLE_ERROR,
1905 _("Can't do read-modify-write to update "
1906 "bitfield; containing word "
1907 "is unavailable"));
1908 }
d3b1e874
TT		 1909 copy_bitwise (buffer, dest_offset_bits,
1910 contents, source_offset_bits,
1911 this_size_bits,
1912 bits_big_endian);
1913 }
1914
63b4f126 1915 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
d3b1e874 1916 this_size, source_buffer);
63b4f126
MGD		 1917 }
1918 else
1919 {
1920 error (_("Unable to write to DWARF register number %s"),
8a9b8146 1921 paddress (arch, p->v.regno));
63b4f126 1922 }
cec03d70
TT		 1923 }
1924 break;
1925 case DWARF_VALUE_MEMORY:
d3b1e874
TT		 1926 if (need_bitwise)
1927 {
1928 /* Only the first and last bytes can possibly have any
1929 bits reused. */
f2c7657e
UW		 1930 read_memory (p->v.mem.addr + dest_offset, buffer, 1);
1931 read_memory (p->v.mem.addr + dest_offset + this_size - 1,
d3b1e874
TT		 1932 buffer + this_size - 1, 1);
1933 copy_bitwise (buffer, dest_offset_bits,
1934 contents, source_offset_bits,
1935 this_size_bits,
1936 bits_big_endian);
1937 }
1938
f2c7657e 1939 write_memory (p->v.mem.addr + dest_offset,
d3b1e874 1940 source_buffer, this_size);
cec03d70
TT		 1941 break;
1942 default:
9a0dc9e3 1943 mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
0e03807e 1944 break;
052b9502 1945 }
d3b1e874 1946 offset += this_size_bits;
052b9502 1947 }
d3b1e874 1948
d3b1e874 1949 do_cleanups (cleanup);
052b9502
NF		 1950}
1951
9a0dc9e3
PA		 1952/* An implementation of an lval_funcs method to see whether a value is
1953 a synthetic pointer. */
8cf6f0b1 1954
0e03807e 1955static int
9a0dc9e3
PA		 1956check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
1957 int bit_length)
0e03807e
TT		 1958{
1959 struct piece_closure *c
1960 = (struct piece_closure *) value_computed_closure (value);
1961 int i;
1962
1963 bit_offset += 8 * value_offset (value);
1964 if (value_bitsize (value))
1965 bit_offset += value_bitpos (value);
1966
1967 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1968 {
1969 struct dwarf_expr_piece *p = &c->pieces[i];
1970 size_t this_size_bits = p->size;
1971
1972 if (bit_offset > 0)
1973 {
1974 if (bit_offset >= this_size_bits)
1975 {
1976 bit_offset -= this_size_bits;
1977 continue;
1978 }
1979
1980 bit_length -= this_size_bits - bit_offset;
1981 bit_offset = 0;
1982 }
1983 else
1984 bit_length -= this_size_bits;
1985
9a0dc9e3
PA		 1986 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
1987 return 0;
0e03807e
TT		 1988 }
1989
9a0dc9e3 1990 return 1;
8cf6f0b1
TT		 1991}
1992
1993/* A wrapper function for get_frame_address_in_block. */
1994
1995static CORE_ADDR
1996get_frame_address_in_block_wrapper (void *baton)
1997{
1998 return get_frame_address_in_block (baton);
1999}
2000
2001/* An implementation of an lval_funcs method to indirect through a
2002 pointer. This handles the synthetic pointer case when needed. */
2003
2004static struct value *
2005indirect_pieced_value (struct value *value)
2006{
2007 struct piece_closure *c
2008 = (struct piece_closure *) value_computed_closure (value);
2009 struct type *type;
2010 struct frame_info *frame;
2011 struct dwarf2_locexpr_baton baton;
2012 int i, bit_offset, bit_length;
2013 struct dwarf_expr_piece *piece = NULL;
8cf6f0b1
TT		 2014 LONGEST byte_offset;
2015
0e37a63c 2016 type = check_typedef (value_type (value));
8cf6f0b1
TT		 2017 if (TYPE_CODE (type) != TYPE_CODE_PTR)
2018 return NULL;
2019
2020 bit_length = 8 * TYPE_LENGTH (type);
2021 bit_offset = 8 * value_offset (value);
2022 if (value_bitsize (value))
2023 bit_offset += value_bitpos (value);
2024
2025 for (i = 0; i < c->n_pieces && bit_length > 0; i++)
2026 {
2027 struct dwarf_expr_piece *p = &c->pieces[i];
2028 size_t this_size_bits = p->size;
2029
2030 if (bit_offset > 0)
2031 {
2032 if (bit_offset >= this_size_bits)
2033 {
2034 bit_offset -= this_size_bits;
2035 continue;
2036 }
2037
2038 bit_length -= this_size_bits - bit_offset;
2039 bit_offset = 0;
2040 }
2041 else
2042 bit_length -= this_size_bits;
2043
2044 if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
2045 return NULL;
2046
2047 if (bit_length != 0)
2048 error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2049
2050 piece = p;
2051 break;
2052 }
2053
2054 frame = get_selected_frame (_("No frame selected."));
543305c9 2055
5bd1ef56
TT		 2056 /* This is an offset requested by GDB, such as value subscripts.
2057 However, due to how synthetic pointers are implemented, this is
2058 always presented to us as a pointer type. This means we have to
2059 sign-extend it manually as appropriate. */
8cf6f0b1 2060 byte_offset = value_as_address (value);
5bd1ef56
TT		 2061 if (TYPE_LENGTH (value_type (value)) < sizeof (LONGEST))
2062 byte_offset = gdb_sign_extend (byte_offset,
2063 8 * TYPE_LENGTH (value_type (value)));
2064 byte_offset += piece->v.ptr.offset;
8cf6f0b1 2065
e0e40094 2066 gdb_assert (piece);
8b9737bf
TT		 2067 baton
2068 = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
2069 get_frame_address_in_block_wrapper,
2070 frame);
8cf6f0b1 2071
b6807d98
TT		 2072 if (baton.data != NULL)
2073 return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
2074 baton.data, baton.size, baton.per_cu,
5bd1ef56 2075 byte_offset);
b6807d98
TT		 2076
2077 {
2078 struct obstack temp_obstack;
2079 struct cleanup *cleanup;
2080 const gdb_byte *bytes;
2081 LONGEST len;
2082 struct value *result;
2083
2084 obstack_init (&temp_obstack);
2085 cleanup = make_cleanup_obstack_free (&temp_obstack);
2086
2087 bytes = dwarf2_fetch_constant_bytes (piece->v.ptr.die, c->per_cu,
2088 &temp_obstack, &len);
2089 if (bytes == NULL)
2090 result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
2091 else
2092 {
2093 if (byte_offset < 0
2094 || byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > len)
2095 invalid_synthetic_pointer ();
2096 bytes += byte_offset;
2097 result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
2098 }
2099
2100 do_cleanups (cleanup);
2101 return result;
2102 }
0e03807e
TT		 2103}
2104
052b9502 2105static void *
0e03807e 2106copy_pieced_value_closure (const struct value *v)
052b9502 2107{
3e43a32a
MS		 2108 struct piece_closure *c
2109 = (struct piece_closure *) value_computed_closure (v);
052b9502 2110
88bfdde4
TT		 2111 ++c->refc;
2112 return c;
052b9502
NF		 2113}
2114
2115static void
2116free_pieced_value_closure (struct value *v)
2117{
3e43a32a
MS		 2118 struct piece_closure *c
2119 = (struct piece_closure *) value_computed_closure (v);
052b9502 2120
88bfdde4
TT		 2121 --c->refc;
2122 if (c->refc == 0)
2123 {
8a9b8146
TT		 2124 int i;
2125
2126 for (i = 0; i < c->n_pieces; ++i)
2127 if (c->pieces[i].location == DWARF_VALUE_STACK)
2128 value_free (c->pieces[i].v.value);
2129
88bfdde4
TT		 2130 xfree (c->pieces);
2131 xfree (c);
2132 }
052b9502
NF		 2133}
2134
2135/* Functions for accessing a variable described by DW_OP_piece. */
c8f2448a 2136static const struct lval_funcs pieced_value_funcs = {
052b9502
NF		 2137 read_pieced_value,
2138 write_pieced_value,
8cf6f0b1 2139 indirect_pieced_value,
a471c594 2140 NULL, /* coerce_ref */
8cf6f0b1 2141 check_pieced_synthetic_pointer,
052b9502
NF		 2142 copy_pieced_value_closure,
2143 free_pieced_value_closure
2144};
2145
9e8b7a03
JK		 2146/* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2147
2148static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
2149{
b1370418 2150 dwarf_expr_read_addr_from_reg,
0acf8b65 2151 dwarf_expr_get_reg_value,
9e8b7a03
JK		 2152 dwarf_expr_read_mem,
2153 dwarf_expr_frame_base,
2154 dwarf_expr_frame_cfa,
2155 dwarf_expr_frame_pc,
2156 dwarf_expr_tls_address,
2157 dwarf_expr_dwarf_call,
8e3b41a9 2158 dwarf_expr_get_base_type,
3019eac3 2159 dwarf_expr_push_dwarf_reg_entry_value,
08412b07
JB		 2160 dwarf_expr_get_addr_index,
2161 dwarf_expr_get_obj_addr
9e8b7a03
JK		 2162};
2163
4c2df51b 2164/* Evaluate a location description, starting at DATA and with length
8cf6f0b1
TT		 2165 SIZE, to find the current location of variable of TYPE in the
2166 context of FRAME. BYTE_OFFSET is applied after the contents are
2167 computed. */
a2d33775 2168
8cf6f0b1
TT		 2169static struct value *
2170dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
56eb65bd 2171 const gdb_byte *data, size_t size,
8cf6f0b1
TT		 2172 struct dwarf2_per_cu_data *per_cu,
2173 LONGEST byte_offset)
4c2df51b 2174{
4c2df51b
DJ		 2175 struct value *retval;
2176 struct dwarf_expr_baton baton;
2177 struct dwarf_expr_context *ctx;
72fc29ff 2178 struct cleanup *old_chain, *value_chain;
ac56253d 2179 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
79e1a869 2180 volatile struct gdb_exception ex;
4c2df51b 2181
8cf6f0b1
TT		 2182 if (byte_offset < 0)
2183 invalid_synthetic_pointer ();
2184
0d53c4c4 2185 if (size == 0)
a7035dbb 2186 return allocate_optimized_out_value (type);
0d53c4c4 2187
4c2df51b 2188 baton.frame = frame;
17ea53c3 2189 baton.per_cu = per_cu;
08412b07 2190 baton.obj_address = 0;
4c2df51b
DJ		 2191
2192 ctx = new_dwarf_expr_context ();
4a227398 2193 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
72fc29ff 2194 value_chain = make_cleanup_value_free_to_mark (value_mark ());
4a227398 2195
ac56253d 2196 ctx->gdbarch = get_objfile_arch (objfile);
ae0d2f24 2197 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
181cebd4 2198 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
9aa1f1e3 2199 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
4c2df51b 2200 ctx->baton = &baton;
9e8b7a03 2201 ctx->funcs = &dwarf_expr_ctx_funcs;
4c2df51b 2202
79e1a869
PA		 2203 TRY_CATCH (ex, RETURN_MASK_ERROR)
2204 {
2205 dwarf_expr_eval (ctx, data, size);
2206 }
2207 if (ex.reason < 0)
2208 {
2209 if (ex.error == NOT_AVAILABLE_ERROR)
2210 {
72fc29ff 2211 do_cleanups (old_chain);
79e1a869
PA		 2212 retval = allocate_value (type);
2213 mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
2214 return retval;
2215 }
8e3b41a9
JK		 2216 else if (ex.error == NO_ENTRY_VALUE_ERROR)
2217 {
2218 if (entry_values_debug)
2219 exception_print (gdb_stdout, ex);
2220 do_cleanups (old_chain);
2221 return allocate_optimized_out_value (type);
2222 }
79e1a869
PA		 2223 else
2224 throw_exception (ex);
2225 }
2226
87808bd6
JB		 2227 if (ctx->num_pieces > 0)
2228 {
052b9502
NF		 2229 struct piece_closure *c;
2230 struct frame_id frame_id = get_frame_id (frame);
8cf6f0b1
TT		 2231 ULONGEST bit_size = 0;
2232 int i;
052b9502 2233
8cf6f0b1
TT		 2234 for (i = 0; i < ctx->num_pieces; ++i)
2235 bit_size += ctx->pieces[i].size;
2236 if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
2237 invalid_synthetic_pointer ();
2238
2239 c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
6063c216 2240 ctx->addr_size);
72fc29ff
TT		 2241 /* We must clean up the value chain after creating the piece
2242 closure but before allocating the result. */
2243 do_cleanups (value_chain);
a2d33775 2244 retval = allocate_computed_value (type, &pieced_value_funcs, c);
052b9502 2245 VALUE_FRAME_ID (retval) = frame_id;
8cf6f0b1 2246 set_value_offset (retval, byte_offset);
87808bd6 2247 }
4c2df51b
DJ		 2248 else
2249 {
cec03d70
TT		 2250 switch (ctx->location)
2251 {
2252 case DWARF_VALUE_REGISTER:
2253 {
2254 struct gdbarch *arch = get_frame_arch (frame);
7c33b57c
PA		 2255 int dwarf_regnum
2256 = longest_to_int (value_as_long (dwarf_expr_fetch (ctx, 0)));
cec03d70 2257 int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
9a619af0 2258
8cf6f0b1
TT		 2259 if (byte_offset != 0)
2260 error (_("cannot use offset on synthetic pointer to register"));
72fc29ff 2261 do_cleanups (value_chain);
901461f8 2262 if (gdb_regnum == -1)
7c33b57c
PA		 2263 error (_("Unable to access DWARF register number %d"),
2264 dwarf_regnum);
901461f8
PA		 2265 retval = value_from_register (type, gdb_regnum, frame);
2266 if (value_optimized_out (retval))
2267 {
9a0dc9e3
PA		 2268 struct value *tmp;
2269
901461f8
PA		 2270 /* This means the register has undefined value / was
2271 not saved. As we're computing the location of some
2272 variable etc. in the program, not a value for
2273 inspecting a register ($pc, $sp, etc.), return a
2274 generic optimized out value instead, so that we show
2275 <optimized out> instead of <not saved>. */
2276 do_cleanups (value_chain);
9a0dc9e3
PA		 2277 tmp = allocate_value (type);
2278 value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
2279 retval = tmp;
901461f8 2280 }
cec03d70
TT		 2281 }
2282 break;
2283
2284 case DWARF_VALUE_MEMORY:
2285 {
f2c7657e 2286 CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
44353522 2287 int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
cec03d70 2288
72fc29ff 2289 do_cleanups (value_chain);
08039c9e 2290 retval = value_at_lazy (type, address + byte_offset);
44353522
DE		 2291 if (in_stack_memory)
2292 set_value_stack (retval, 1);
cec03d70
TT		 2293 }
2294 break;
2295
2296 case DWARF_VALUE_STACK:
2297 {
8a9b8146
TT		 2298 struct value *value = dwarf_expr_fetch (ctx, 0);
2299 gdb_byte *contents;
2300 const gdb_byte *val_bytes;
2301 size_t n = TYPE_LENGTH (value_type (value));
cec03d70 2302
8cf6f0b1
TT		 2303 if (byte_offset + TYPE_LENGTH (type) > n)
2304 invalid_synthetic_pointer ();
2305
8a9b8146
TT		 2306 val_bytes = value_contents_all (value);
2307 val_bytes += byte_offset;
8cf6f0b1
TT		 2308 n -= byte_offset;
2309
72fc29ff
TT		 2310 /* Preserve VALUE because we are going to free values back
2311 to the mark, but we still need the value contents
2312 below. */
2313 value_incref (value);
2314 do_cleanups (value_chain);
2315 make_cleanup_value_free (value);
2316
a2d33775 2317 retval = allocate_value (type);
cec03d70 2318 contents = value_contents_raw (retval);
a2d33775 2319 if (n > TYPE_LENGTH (type))
b6cede78
JK		 2320 {
2321 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2322
2323 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2324 val_bytes += n - TYPE_LENGTH (type);
2325 n = TYPE_LENGTH (type);
2326 }
8a9b8146 2327 memcpy (contents, val_bytes, n);
cec03d70
TT		 2328 }
2329 break;
2330
2331 case DWARF_VALUE_LITERAL:
2332 {
2333 bfd_byte *contents;
8c814cdd 2334 const bfd_byte *ldata;
cec03d70
TT		 2335 size_t n = ctx->len;
2336
8cf6f0b1
TT		 2337 if (byte_offset + TYPE_LENGTH (type) > n)
2338 invalid_synthetic_pointer ();
2339
72fc29ff 2340 do_cleanups (value_chain);
a2d33775 2341 retval = allocate_value (type);
cec03d70 2342 contents = value_contents_raw (retval);
8cf6f0b1 2343
8c814cdd 2344 ldata = ctx->data + byte_offset;
8cf6f0b1
TT		 2345 n -= byte_offset;
2346
a2d33775 2347 if (n > TYPE_LENGTH (type))
b6cede78
JK		 2348 {
2349 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2350
2351 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2352 ldata += n - TYPE_LENGTH (type);
2353 n = TYPE_LENGTH (type);
2354 }
8c814cdd 2355 memcpy (contents, ldata, n);
cec03d70
TT		 2356 }
2357 break;
2358
dd90784c 2359 case DWARF_VALUE_OPTIMIZED_OUT:
72fc29ff 2360 do_cleanups (value_chain);
a7035dbb 2361 retval = allocate_optimized_out_value (type);
dd90784c
JK		 2362 break;
2363
8cf6f0b1
TT		 2364 /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2365 operation by execute_stack_op. */
2366 case DWARF_VALUE_IMPLICIT_POINTER:
cb826367
TT		 2367 /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2368 it can only be encountered when making a piece. */
cec03d70
TT		 2369 default:
2370 internal_error (__FILE__, __LINE__, _("invalid location type"));
2371 }
4c2df51b
DJ		 2372 }
2373
42be36b3
CT		 2374 set_value_initialized (retval, ctx->initialized);
2375
4a227398 2376 do_cleanups (old_chain);
4c2df51b
DJ		 2377
2378 return retval;
2379}
8cf6f0b1
TT		 2380
2381/* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2382 passes 0 as the byte_offset. */
2383
2384struct value *
2385dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
56eb65bd 2386 const gdb_byte *data, size_t size,
8cf6f0b1
TT		 2387 struct dwarf2_per_cu_data *per_cu)
2388{
2389 return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
2390}
2391
80180f79
SA		 2392/* Evaluates a dwarf expression and stores the result in VAL, expecting
2393 that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2394 context (location of a variable) and might be needed to evaluate the
2395 location expression.
2396 Returns 1 on success, 0 otherwise. */
2397
2398static int
2399dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
08412b07 2400 CORE_ADDR addr,
1cfdf534 2401 CORE_ADDR *valp)
80180f79
SA		 2402{
2403 struct dwarf_expr_context *ctx;
2404 struct dwarf_expr_baton baton;
2405 struct objfile *objfile;
2406 struct cleanup *cleanup;
2407
2408 if (dlbaton == NULL || dlbaton->size == 0)
2409 return 0;
2410
2411 ctx = new_dwarf_expr_context ();
2412 cleanup = make_cleanup_free_dwarf_expr_context (ctx);
2413
2414 baton.frame = get_selected_frame (NULL);
2415 baton.per_cu = dlbaton->per_cu;
08412b07 2416 baton.obj_address = addr;
80180f79
SA		 2417
2418 objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2419
2420 ctx->gdbarch = get_objfile_arch (objfile);
2421 ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2422 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu);
2423 ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2424 ctx->funcs = &dwarf_expr_ctx_funcs;
2425 ctx->baton = &baton;
2426
2427 dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size);
2428
2429 switch (ctx->location)
2430 {
2431 case DWARF_VALUE_REGISTER:
2432 case DWARF_VALUE_MEMORY:
2433 case DWARF_VALUE_STACK:
2434 *valp = dwarf_expr_fetch_address (ctx, 0);
2435 if (ctx->location == DWARF_VALUE_REGISTER)
2436 *valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
2437 do_cleanups (cleanup);
2438 return 1;
2439 case DWARF_VALUE_LITERAL:
2440 *valp = extract_signed_integer (ctx->data, ctx->len,
2441 gdbarch_byte_order (ctx->gdbarch));
2442 do_cleanups (cleanup);
2443 return 1;
2444 /* Unsupported dwarf values. */
2445 case DWARF_VALUE_OPTIMIZED_OUT:
2446 case DWARF_VALUE_IMPLICIT_POINTER:
2447 break;
2448 }
2449
2450 do_cleanups (cleanup);
2451 return 0;
2452}
2453
2454/* See dwarf2loc.h. */
2455
2456int
08412b07
JB		 2457dwarf2_evaluate_property (const struct dynamic_prop *prop,
2458 CORE_ADDR address, CORE_ADDR *value)
80180f79
SA		 2459{
2460 if (prop == NULL)
2461 return 0;
2462
2463 switch (prop->kind)
2464 {
2465 case PROP_LOCEXPR:
2466 {
2467 const struct dwarf2_property_baton *baton = prop->data.baton;
2468
08412b07 2469 if (dwarf2_locexpr_baton_eval (&baton->locexpr, address, value))
80180f79
SA		 2470 {
2471 if (baton->referenced_type)
2472 {
2473 struct value *val = value_at (baton->referenced_type, *value);
2474
2475 *value = value_as_address (val);
2476 }
2477 return 1;
2478 }
2479 }
2480 break;
2481
2482 case PROP_LOCLIST:
2483 {
2484 struct dwarf2_property_baton *baton = prop->data.baton;
2485 struct frame_info *frame = get_selected_frame (NULL);
2486 CORE_ADDR pc = get_frame_address_in_block (frame);
2487 const gdb_byte *data;
2488 struct value *val;
2489 size_t size;
2490
2491 data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
2492 if (data != NULL)
2493 {
2494 val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
2495 size, baton->loclist.per_cu);
2496 if (!value_optimized_out (val))
2497 {
2498 *value = value_as_address (val);
2499 return 1;
2500 }
2501 }
2502 }
2503 break;
2504
2505 case PROP_CONST:
2506 *value = prop->data.const_val;
2507 return 1;
2508 }
2509
2510 return 0;
2511}
2512
4c2df51b
DJ		 2513\f
2514/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2515
2516struct needs_frame_baton
2517{
2518 int needs_frame;
17ea53c3 2519 struct dwarf2_per_cu_data *per_cu;
4c2df51b
DJ		 2520};
2521
2522/* Reads from registers do require a frame. */
2523static CORE_ADDR
b1370418 2524needs_frame_read_addr_from_reg (void *baton, int regnum)
4c2df51b
DJ		 2525{
2526 struct needs_frame_baton *nf_baton = baton;
9a619af0 2527
4c2df51b
DJ		 2528 nf_baton->needs_frame = 1;
2529 return 1;
2530}
2531
0acf8b65
JB		 2532/* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2533 Reads from registers do require a frame. */
2534
2535static struct value *
2536needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
2537{
2538 struct needs_frame_baton *nf_baton = baton;
2539
2540 nf_baton->needs_frame = 1;
2541 return value_zero (type, not_lval);
2542}
2543
4c2df51b
DJ		 2544/* Reads from memory do not require a frame. */
2545static void
852483bc 2546needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
4c2df51b
DJ		 2547{
2548 memset (buf, 0, len);
2549}
2550
2551/* Frame-relative accesses do require a frame. */
2552static void
0d45f56e 2553needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
4c2df51b 2554{
852483bc 2555 static gdb_byte lit0 = DW_OP_lit0;
4c2df51b
DJ		 2556 struct needs_frame_baton *nf_baton = baton;
2557
2558 *start = &lit0;
2559 *length = 1;
2560
2561 nf_baton->needs_frame = 1;
2562}
2563
e7802207
TT		 2564/* CFA accesses require a frame. */
2565
2566static CORE_ADDR
2567needs_frame_frame_cfa (void *baton)
2568{
2569 struct needs_frame_baton *nf_baton = baton;
9a619af0 2570
e7802207
TT		 2571 nf_baton->needs_frame = 1;
2572 return 1;
2573}
2574
4c2df51b
DJ		 2575/* Thread-local accesses do require a frame. */
2576static CORE_ADDR
2577needs_frame_tls_address (void *baton, CORE_ADDR offset)
2578{
2579 struct needs_frame_baton *nf_baton = baton;
9a619af0 2580
4c2df51b
DJ		 2581 nf_baton->needs_frame = 1;
2582 return 1;
2583}
2584
5c631832
JK		 2585/* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2586
2587static void
b64f50a1 2588needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
5c631832
JK		 2589{
2590 struct needs_frame_baton *nf_baton = ctx->baton;
2591
37b50a69 2592 per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
9e8b7a03 2593 ctx->funcs->get_frame_pc, ctx->baton);
5c631832
JK		 2594}
2595
8e3b41a9
JK		 2596/* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2597
2598static void
2599needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
24c5c679
JK		 2600 enum call_site_parameter_kind kind,
2601 union call_site_parameter_u kind_u, int deref_size)
8e3b41a9
JK		 2602{
2603 struct needs_frame_baton *nf_baton = ctx->baton;
2604
2605 nf_baton->needs_frame = 1;
1788b2d3
JK		 2606
2607 /* The expression may require some stub values on DWARF stack. */
2608 dwarf_expr_push_address (ctx, 0, 0);
8e3b41a9
JK		 2609}
2610
3019eac3
DE		 2611/* DW_OP_GNU_addr_index doesn't require a frame. */
2612
2613static CORE_ADDR
2614needs_get_addr_index (void *baton, unsigned int index)
2615{
2616 /* Nothing to do. */
2617 return 1;
2618}
2619
08412b07
JB		 2620/* DW_OP_push_object_address has a frame already passed through. */
2621
2622static CORE_ADDR
2623needs_get_obj_addr (void *baton)
2624{
2625 /* Nothing to do. */
2626 return 1;
2627}
2628
9e8b7a03
JK		 2629/* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2630
2631static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
2632{
b1370418 2633 needs_frame_read_addr_from_reg,
0acf8b65 2634 needs_frame_get_reg_value,
9e8b7a03
JK		 2635 needs_frame_read_mem,
2636 needs_frame_frame_base,
2637 needs_frame_frame_cfa,
2638 needs_frame_frame_cfa, /* get_frame_pc */
2639 needs_frame_tls_address,
2640 needs_frame_dwarf_call,
8e3b41a9 2641 NULL, /* get_base_type */
3019eac3 2642 needs_dwarf_reg_entry_value,
08412b07
JB		 2643 needs_get_addr_index,
2644 needs_get_obj_addr
9e8b7a03
JK		 2645};
2646
4c2df51b
DJ		 2647/* Return non-zero iff the location expression at DATA (length SIZE)
2648 requires a frame to evaluate. */
2649
2650static int
56eb65bd 2651dwarf2_loc_desc_needs_frame (const gdb_byte *data, size_t size,
ae0d2f24 2652 struct dwarf2_per_cu_data *per_cu)
4c2df51b
DJ		 2653{
2654 struct needs_frame_baton baton;
2655 struct dwarf_expr_context *ctx;
f630a401 2656 int in_reg;
4a227398 2657 struct cleanup *old_chain;
ac56253d 2658 struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
4c2df51b
DJ		 2659
2660 baton.needs_frame = 0;
17ea53c3 2661 baton.per_cu = per_cu;
4c2df51b
DJ		 2662
2663 ctx = new_dwarf_expr_context ();
4a227398 2664 old_chain = make_cleanup_free_dwarf_expr_context (ctx);
72fc29ff 2665 make_cleanup_value_free_to_mark (value_mark ());
4a227398 2666
ac56253d 2667 ctx->gdbarch = get_objfile_arch (objfile);
ae0d2f24 2668 ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
181cebd4 2669 ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
9aa1f1e3 2670 ctx->offset = dwarf2_per_cu_text_offset (per_cu);
4c2df51b 2671 ctx->baton = &baton;
9e8b7a03 2672 ctx->funcs = &needs_frame_ctx_funcs;
4c2df51b
DJ		 2673
2674 dwarf_expr_eval (ctx, data, size);
2675
cec03d70 2676 in_reg = ctx->location == DWARF_VALUE_REGISTER;
f630a401 2677
87808bd6
JB		 2678 if (ctx->num_pieces > 0)
2679 {
2680 int i;
2681
2682 /* If the location has several pieces, and any of them are in
2683 registers, then we will need a frame to fetch them from. */
2684 for (i = 0; i < ctx->num_pieces; i++)
cec03d70 2685 if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
87808bd6
JB		 2686 in_reg = 1;
2687 }
2688
4a227398 2689 do_cleanups (old_chain);
4c2df51b 2690
f630a401 2691 return baton.needs_frame || in_reg;
4c2df51b
DJ		 2692}
2693
3cf03773
TT		 2694/* A helper function that throws an unimplemented error mentioning a
2695 given DWARF operator. */
2696
2697static void
2698unimplemented (unsigned int op)
0d53c4c4 2699{
f39c6ffd 2700 const char *name = get_DW_OP_name (op);
b1bfef65
TT		 2701
2702 if (name)
2703 error (_("DWARF operator %s cannot be translated to an agent expression"),
2704 name);
2705 else
1ba1b353
TT		 2706 error (_("Unknown DWARF operator 0x%02x cannot be translated "
2707 "to an agent expression"),
b1bfef65 2708 op);
3cf03773 2709}
08922a10 2710
3cf03773
TT		 2711/* A helper function to convert a DWARF register to an arch register.
2712 ARCH is the architecture.
2713 DWARF_REG is the register.
2714 This will throw an exception if the DWARF register cannot be
2715 translated to an architecture register. */
08922a10 2716
3cf03773
TT		 2717static int
2718translate_register (struct gdbarch *arch, int dwarf_reg)
2719{
2720 int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
2721 if (reg == -1)
2722 error (_("Unable to access DWARF register number %d"), dwarf_reg);
2723 return reg;
2724}
08922a10 2725
3cf03773
TT		 2726/* A helper function that emits an access to memory. ARCH is the
2727 target architecture. EXPR is the expression which we are building.
2728 NBITS is the number of bits we want to read. This emits the
2729 opcodes needed to read the memory and then extract the desired
2730 bits. */
08922a10 2731
3cf03773
TT		 2732static void
2733access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
08922a10 2734{
3cf03773
TT		 2735 ULONGEST nbytes = (nbits + 7) / 8;
2736
9df7235c 2737 gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));
3cf03773 2738
92bc6a20 2739 if (expr->tracing)
3cf03773
TT		 2740 ax_trace_quick (expr, nbytes);
2741
2742 if (nbits <= 8)
2743 ax_simple (expr, aop_ref8);
2744 else if (nbits <= 16)
2745 ax_simple (expr, aop_ref16);
2746 else if (nbits <= 32)
2747 ax_simple (expr, aop_ref32);
2748 else
2749 ax_simple (expr, aop_ref64);
2750
2751 /* If we read exactly the number of bytes we wanted, we're done. */
2752 if (8 * nbytes == nbits)
2753 return;
2754
2755 if (gdbarch_bits_big_endian (arch))
0d53c4c4 2756 {
3cf03773
TT		 2757 /* On a bits-big-endian machine, we want the high-order
2758 NBITS. */
2759 ax_const_l (expr, 8 * nbytes - nbits);
2760 ax_simple (expr, aop_rsh_unsigned);
0d53c4c4 2761 }
3cf03773 2762 else
0d53c4c4 2763 {
3cf03773
TT		 2764 /* On a bits-little-endian box, we want the low-order NBITS. */
2765 ax_zero_ext (expr, nbits);
0d53c4c4 2766 }
3cf03773 2767}
0936ad1d 2768
8cf6f0b1
TT		 2769/* A helper function to return the frame's PC. */
2770
2771static CORE_ADDR
2772get_ax_pc (void *baton)
2773{
2774 struct agent_expr *expr = baton;
2775
2776 return expr->scope;
2777}
2778
3cf03773
TT		 2779/* Compile a DWARF location expression to an agent expression.
2780
2781 EXPR is the agent expression we are building.
2782 LOC is the agent value we modify.
2783 ARCH is the architecture.
2784 ADDR_SIZE is the size of addresses, in bytes.
2785 OP_PTR is the start of the location expression.
2786 OP_END is one past the last byte of the location expression.
2787
2788 This will throw an exception for various kinds of errors -- for
2789 example, if the expression cannot be compiled, or if the expression
2790 is invalid. */
0936ad1d 2791
9f6f94ff
TT		 2792void
2793dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
2794 struct gdbarch *arch, unsigned int addr_size,
2795 const gdb_byte *op_ptr, const gdb_byte *op_end,
2796 struct dwarf2_per_cu_data *per_cu)
3cf03773
TT		 2797{
2798 struct cleanup *cleanups;
2799 int i, *offsets;
2800 VEC(int) *dw_labels = NULL, *patches = NULL;
2801 const gdb_byte * const base = op_ptr;
2802 const gdb_byte *previous_piece = op_ptr;
2803 enum bfd_endian byte_order = gdbarch_byte_order (arch);
2804 ULONGEST bits_collected = 0;
2805 unsigned int addr_size_bits = 8 * addr_size;
2806 int bits_big_endian = gdbarch_bits_big_endian (arch);
0936ad1d 2807
3cf03773
TT		 2808 offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
2809 cleanups = make_cleanup (xfree, offsets);
0936ad1d 2810
3cf03773
TT		 2811 for (i = 0; i < op_end - op_ptr; ++i)
2812 offsets[i] = -1;
0936ad1d 2813
3cf03773
TT		 2814 make_cleanup (VEC_cleanup (int), &dw_labels);
2815 make_cleanup (VEC_cleanup (int), &patches);
0936ad1d 2816
3cf03773
TT		 2817 /* By default we are making an address. */
2818 loc->kind = axs_lvalue_memory;
0d45f56e 2819
3cf03773
TT		 2820 while (op_ptr < op_end)
2821 {
2822 enum dwarf_location_atom op = *op_ptr;
9fccedf7
DE		 2823 uint64_t uoffset, reg;
2824 int64_t offset;
3cf03773
TT		 2825 int i;
2826
2827 offsets[op_ptr - base] = expr->len;
2828 ++op_ptr;
2829
2830 /* Our basic approach to code generation is to map DWARF
2831 operations directly to AX operations. However, there are
2832 some differences.
2833
2834 First, DWARF works on address-sized units, but AX always uses
2835 LONGEST. For most operations we simply ignore this
2836 difference; instead we generate sign extensions as needed
2837 before division and comparison operations. It would be nice
2838 to omit the sign extensions, but there is no way to determine
2839 the size of the target's LONGEST. (This code uses the size
2840 of the host LONGEST in some cases -- that is a bug but it is
2841 difficult to fix.)
2842
2843 Second, some DWARF operations cannot be translated to AX.
2844 For these we simply fail. See
2845 http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2846 switch (op)
0936ad1d 2847 {
3cf03773
TT		 2848 case DW_OP_lit0:
2849 case DW_OP_lit1:
2850 case DW_OP_lit2:
2851 case DW_OP_lit3:
2852 case DW_OP_lit4:
2853 case DW_OP_lit5:
2854 case DW_OP_lit6:
2855 case DW_OP_lit7:
2856 case DW_OP_lit8:
2857 case DW_OP_lit9:
2858 case DW_OP_lit10:
2859 case DW_OP_lit11:
2860 case DW_OP_lit12:
2861 case DW_OP_lit13:
2862 case DW_OP_lit14:
2863 case DW_OP_lit15:
2864 case DW_OP_lit16:
2865 case DW_OP_lit17:
2866 case DW_OP_lit18:
2867 case DW_OP_lit19:
2868 case DW_OP_lit20:
2869 case DW_OP_lit21:
2870 case DW_OP_lit22:
2871 case DW_OP_lit23:
2872 case DW_OP_lit24:
2873 case DW_OP_lit25:
2874 case DW_OP_lit26:
2875 case DW_OP_lit27:
2876 case DW_OP_lit28:
2877 case DW_OP_lit29:
2878 case DW_OP_lit30:
2879 case DW_OP_lit31:
2880 ax_const_l (expr, op - DW_OP_lit0);
2881 break;
0d53c4c4 2882
3cf03773 2883 case DW_OP_addr:
ac56253d 2884 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
3cf03773 2885 op_ptr += addr_size;
ac56253d
TT		 2886 /* Some versions of GCC emit DW_OP_addr before
2887 DW_OP_GNU_push_tls_address. In this case the value is an
2888 index, not an address. We don't support things like
2889 branching between the address and the TLS op. */
2890 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
9aa1f1e3 2891 uoffset += dwarf2_per_cu_text_offset (per_cu);
ac56253d 2892 ax_const_l (expr, uoffset);
3cf03773 2893 break;
4c2df51b 2894
3cf03773
TT		 2895 case DW_OP_const1u:
2896 ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
2897 op_ptr += 1;
2898 break;
2899 case DW_OP_const1s:
2900 ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
2901 op_ptr += 1;
2902 break;
2903 case DW_OP_const2u:
2904 ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
2905 op_ptr += 2;
2906 break;
2907 case DW_OP_const2s:
2908 ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
2909 op_ptr += 2;
2910 break;
2911 case DW_OP_const4u:
2912 ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
2913 op_ptr += 4;
2914 break;
2915 case DW_OP_const4s:
2916 ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
2917 op_ptr += 4;
2918 break;
2919 case DW_OP_const8u:
2920 ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
2921 op_ptr += 8;
2922 break;
2923 case DW_OP_const8s:
2924 ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
2925 op_ptr += 8;
2926 break;
2927 case DW_OP_constu:
f664829e 2928 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
3cf03773
TT		 2929 ax_const_l (expr, uoffset);
2930 break;
2931 case DW_OP_consts:
f664829e 2932 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3cf03773
TT		 2933 ax_const_l (expr, offset);
2934 break;
9c238357 2935
3cf03773
TT		 2936 case DW_OP_reg0:
2937 case DW_OP_reg1:
2938 case DW_OP_reg2:
2939 case DW_OP_reg3:
2940 case DW_OP_reg4:
2941 case DW_OP_reg5:
2942 case DW_OP_reg6:
2943 case DW_OP_reg7:
2944 case DW_OP_reg8:
2945 case DW_OP_reg9:
2946 case DW_OP_reg10:
2947 case DW_OP_reg11:
2948 case DW_OP_reg12:
2949 case DW_OP_reg13:
2950 case DW_OP_reg14:
2951 case DW_OP_reg15:
2952 case DW_OP_reg16:
2953 case DW_OP_reg17:
2954 case DW_OP_reg18:
2955 case DW_OP_reg19:
2956 case DW_OP_reg20:
2957 case DW_OP_reg21:
2958 case DW_OP_reg22:
2959 case DW_OP_reg23:
2960 case DW_OP_reg24:
2961 case DW_OP_reg25:
2962 case DW_OP_reg26:
2963 case DW_OP_reg27:
2964 case DW_OP_reg28:
2965 case DW_OP_reg29:
2966 case DW_OP_reg30:
2967 case DW_OP_reg31:
2968 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2969 loc->u.reg = translate_register (arch, op - DW_OP_reg0);
2970 loc->kind = axs_lvalue_register;
2971 break;
9c238357 2972
3cf03773 2973 case DW_OP_regx:
f664829e 2974 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
3cf03773
TT		 2975 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
2976 loc->u.reg = translate_register (arch, reg);
2977 loc->kind = axs_lvalue_register;
2978 break;
08922a10 2979
3cf03773
TT		 2980 case DW_OP_implicit_value:
2981 {
9fccedf7 2982 uint64_t len;
3cf03773 2983
f664829e 2984 op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
3cf03773
TT		 2985 if (op_ptr + len > op_end)
2986 error (_("DW_OP_implicit_value: too few bytes available."));
2987 if (len > sizeof (ULONGEST))
2988 error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
2989 (int) len);
2990
2991 ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
2992 byte_order));
2993 op_ptr += len;
2994 dwarf_expr_require_composition (op_ptr, op_end,
2995 "DW_OP_implicit_value");
2996
2997 loc->kind = axs_rvalue;
2998 }
2999 break;
08922a10 3000
3cf03773
TT		 3001 case DW_OP_stack_value:
3002 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
3003 loc->kind = axs_rvalue;
3004 break;
08922a10 3005
3cf03773
TT		 3006 case DW_OP_breg0:
3007 case DW_OP_breg1:
3008 case DW_OP_breg2:
3009 case DW_OP_breg3:
3010 case DW_OP_breg4:
3011 case DW_OP_breg5:
3012 case DW_OP_breg6:
3013 case DW_OP_breg7:
3014 case DW_OP_breg8:
3015 case DW_OP_breg9:
3016 case DW_OP_breg10:
3017 case DW_OP_breg11:
3018 case DW_OP_breg12:
3019 case DW_OP_breg13:
3020 case DW_OP_breg14:
3021 case DW_OP_breg15:
3022 case DW_OP_breg16:
3023 case DW_OP_breg17:
3024 case DW_OP_breg18:
3025 case DW_OP_breg19:
3026 case DW_OP_breg20:
3027 case DW_OP_breg21:
3028 case DW_OP_breg22:
3029 case DW_OP_breg23:
3030 case DW_OP_breg24:
3031 case DW_OP_breg25:
3032 case DW_OP_breg26:
3033 case DW_OP_breg27:
3034 case DW_OP_breg28:
3035 case DW_OP_breg29:
3036 case DW_OP_breg30:
3037 case DW_OP_breg31:
f664829e 3038 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3cf03773
TT		 3039 i = translate_register (arch, op - DW_OP_breg0);
3040 ax_reg (expr, i);
3041 if (offset != 0)
3042 {
3043 ax_const_l (expr, offset);
3044 ax_simple (expr, aop_add);
3045 }
3046 break;
3047 case DW_OP_bregx:
3048 {
f664829e
DE		 3049 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
3050 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3cf03773
TT		 3051 i = translate_register (arch, reg);
3052 ax_reg (expr, i);
3053 if (offset != 0)
3054 {
3055 ax_const_l (expr, offset);
3056 ax_simple (expr, aop_add);
3057 }
3058 }
3059 break;
3060 case DW_OP_fbreg:
3061 {
3062 const gdb_byte *datastart;
3063 size_t datalen;
3977b71f 3064 const struct block *b;
3cf03773 3065 struct symbol *framefunc;
08922a10 3066
3cf03773
TT		 3067 b = block_for_pc (expr->scope);
3068
3069 if (!b)
3070 error (_("No block found for address"));
3071
3072 framefunc = block_linkage_function (b);
3073
3074 if (!framefunc)
3075 error (_("No function found for block"));
3076
3077 dwarf_expr_frame_base_1 (framefunc, expr->scope,
3078 &datastart, &datalen);
3079
f664829e 3080 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
9f6f94ff
TT		 3081 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
3082 datastart + datalen, per_cu);
d84cf7eb
TT		 3083 if (loc->kind == axs_lvalue_register)
3084 require_rvalue (expr, loc);
3cf03773
TT		 3085
3086 if (offset != 0)
3087 {
3088 ax_const_l (expr, offset);
3089 ax_simple (expr, aop_add);
3090 }
3091
3092 loc->kind = axs_lvalue_memory;
3093 }
08922a10 3094 break;
08922a10 3095
3cf03773
TT		 3096 case DW_OP_dup:
3097 ax_simple (expr, aop_dup);
3098 break;
08922a10 3099
3cf03773
TT		 3100 case DW_OP_drop:
3101 ax_simple (expr, aop_pop);
3102 break;
08922a10 3103
3cf03773
TT		 3104 case DW_OP_pick:
3105 offset = *op_ptr++;
c7f96d2b 3106 ax_pick (expr, offset);
3cf03773
TT		 3107 break;
3108
3109 case DW_OP_swap:
3110 ax_simple (expr, aop_swap);
3111 break;
08922a10 3112
3cf03773 3113 case DW_OP_over:
c7f96d2b 3114 ax_pick (expr, 1);
3cf03773 3115 break;
08922a10 3116
3cf03773 3117 case DW_OP_rot:
c7f96d2b 3118 ax_simple (expr, aop_rot);
3cf03773 3119 break;
08922a10 3120
3cf03773
TT		 3121 case DW_OP_deref:
3122 case DW_OP_deref_size:
3123 {
3124 int size;
08922a10 3125
3cf03773
TT		 3126 if (op == DW_OP_deref_size)
3127 size = *op_ptr++;
3128 else
3129 size = addr_size;
3130
9df7235c 3131 if (size != 1 && size != 2 && size != 4 && size != 8)
f3cec7e6
HZ		 3132 error (_("Unsupported size %d in %s"),
3133 size, get_DW_OP_name (op));
9df7235c 3134 access_memory (arch, expr, size * TARGET_CHAR_BIT);
3cf03773
TT		 3135 }
3136 break;
3137
3138 case DW_OP_abs:
3139 /* Sign extend the operand. */
3140 ax_ext (expr, addr_size_bits);
3141 ax_simple (expr, aop_dup);
3142 ax_const_l (expr, 0);
3143 ax_simple (expr, aop_less_signed);
3144 ax_simple (expr, aop_log_not);
3145 i = ax_goto (expr, aop_if_goto);
3146 /* We have to emit 0 - X. */
3147 ax_const_l (expr, 0);
3148 ax_simple (expr, aop_swap);
3149 ax_simple (expr, aop_sub);
3150 ax_label (expr, i, expr->len);
3151 break;
3152
3153 case DW_OP_neg:
3154 /* No need to sign extend here. */
3155 ax_const_l (expr, 0);
3156 ax_simple (expr, aop_swap);
3157 ax_simple (expr, aop_sub);
3158 break;
3159
3160 case DW_OP_not:
3161 /* Sign extend the operand. */
3162 ax_ext (expr, addr_size_bits);
3163 ax_simple (expr, aop_bit_not);
3164 break;
3165
3166 case DW_OP_plus_uconst:
f664829e 3167 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
3cf03773
TT		 3168 /* It would be really weird to emit `DW_OP_plus_uconst 0',
3169 but we micro-optimize anyhow. */
3170 if (reg != 0)
3171 {
3172 ax_const_l (expr, reg);
3173 ax_simple (expr, aop_add);
3174 }
3175 break;
3176
3177 case DW_OP_and:
3178 ax_simple (expr, aop_bit_and);
3179 break;
3180
3181 case DW_OP_div:
3182 /* Sign extend the operands. */
3183 ax_ext (expr, addr_size_bits);
3184 ax_simple (expr, aop_swap);
3185 ax_ext (expr, addr_size_bits);
3186 ax_simple (expr, aop_swap);
3187 ax_simple (expr, aop_div_signed);
08922a10
SS		 3188 break;
3189
3cf03773
TT		 3190 case DW_OP_minus:
3191 ax_simple (expr, aop_sub);
3192 break;
3193
3194 case DW_OP_mod:
3195 ax_simple (expr, aop_rem_unsigned);
3196 break;
3197
3198 case DW_OP_mul:
3199 ax_simple (expr, aop_mul);
3200 break;
3201
3202 case DW_OP_or:
3203 ax_simple (expr, aop_bit_or);
3204 break;
3205
3206 case DW_OP_plus:
3207 ax_simple (expr, aop_add);
3208 break;
3209
3210 case DW_OP_shl:
3211 ax_simple (expr, aop_lsh);
3212 break;
3213
3214 case DW_OP_shr:
3215 ax_simple (expr, aop_rsh_unsigned);
3216 break;
3217
3218 case DW_OP_shra:
3219 ax_simple (expr, aop_rsh_signed);
3220 break;
3221
3222 case DW_OP_xor:
3223 ax_simple (expr, aop_bit_xor);
3224 break;
3225
3226 case DW_OP_le:
3227 /* Sign extend the operands. */
3228 ax_ext (expr, addr_size_bits);
3229 ax_simple (expr, aop_swap);
3230 ax_ext (expr, addr_size_bits);
3231 /* Note no swap here: A <= B is !(B < A). */
3232 ax_simple (expr, aop_less_signed);
3233 ax_simple (expr, aop_log_not);
3234 break;
3235
3236 case DW_OP_ge:
3237 /* Sign extend the operands. */
3238 ax_ext (expr, addr_size_bits);
3239 ax_simple (expr, aop_swap);
3240 ax_ext (expr, addr_size_bits);
3241 ax_simple (expr, aop_swap);
3242 /* A >= B is !(A < B). */
3243 ax_simple (expr, aop_less_signed);
3244 ax_simple (expr, aop_log_not);
3245 break;
3246
3247 case DW_OP_eq:
3248 /* Sign extend the operands. */
3249 ax_ext (expr, addr_size_bits);
3250 ax_simple (expr, aop_swap);
3251 ax_ext (expr, addr_size_bits);
3252 /* No need for a second swap here. */
3253 ax_simple (expr, aop_equal);
3254 break;
3255
3256 case DW_OP_lt:
3257 /* Sign extend the operands. */
3258 ax_ext (expr, addr_size_bits);
3259 ax_simple (expr, aop_swap);
3260 ax_ext (expr, addr_size_bits);
3261 ax_simple (expr, aop_swap);
3262 ax_simple (expr, aop_less_signed);
3263 break;
3264
3265 case DW_OP_gt:
3266 /* Sign extend the operands. */
3267 ax_ext (expr, addr_size_bits);
3268 ax_simple (expr, aop_swap);
3269 ax_ext (expr, addr_size_bits);
3270 /* Note no swap here: A > B is B < A. */
3271 ax_simple (expr, aop_less_signed);
3272 break;
3273
3274 case DW_OP_ne:
3275 /* Sign extend the operands. */
3276 ax_ext (expr, addr_size_bits);
3277 ax_simple (expr, aop_swap);
3278 ax_ext (expr, addr_size_bits);
3279 /* No need for a swap here. */
3280 ax_simple (expr, aop_equal);
3281 ax_simple (expr, aop_log_not);
3282 break;
3283
3284 case DW_OP_call_frame_cfa:
9f6f94ff
TT		 3285 dwarf2_compile_cfa_to_ax (expr, loc, arch, expr->scope, per_cu);
3286 loc->kind = axs_lvalue_memory;
3cf03773
TT		 3287 break;
3288
3289 case DW_OP_GNU_push_tls_address:
3290 unimplemented (op);
3291 break;
3292
08412b07
JB		 3293 case DW_OP_push_object_address:
3294 unimplemented (op);
3295 break;
3296
3cf03773
TT		 3297 case DW_OP_skip:
3298 offset = extract_signed_integer (op_ptr, 2, byte_order);
3299 op_ptr += 2;
3300 i = ax_goto (expr, aop_goto);
3301 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3302 VEC_safe_push (int, patches, i);
3303 break;
3304
3305 case DW_OP_bra:
3306 offset = extract_signed_integer (op_ptr, 2, byte_order);
3307 op_ptr += 2;
3308 /* Zero extend the operand. */
3309 ax_zero_ext (expr, addr_size_bits);
3310 i = ax_goto (expr, aop_if_goto);
3311 VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3312 VEC_safe_push (int, patches, i);
3313 break;
3314
3315 case DW_OP_nop:
3316 break;
3317
3318 case DW_OP_piece:
3319 case DW_OP_bit_piece:
08922a10 3320 {
9fccedf7 3321 uint64_t size, offset;
3cf03773
TT		 3322
3323 if (op_ptr - 1 == previous_piece)
3324 error (_("Cannot translate empty pieces to agent expressions"));
3325 previous_piece = op_ptr - 1;
3326
f664829e 3327 op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
3cf03773
TT		 3328 if (op == DW_OP_piece)
3329 {
3330 size *= 8;
3331 offset = 0;
3332 }
3333 else
f664829e 3334 op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
08922a10 3335
3cf03773
TT		 3336 if (bits_collected + size > 8 * sizeof (LONGEST))
3337 error (_("Expression pieces exceed word size"));
3338
3339 /* Access the bits. */
3340 switch (loc->kind)
3341 {
3342 case axs_lvalue_register:
3343 ax_reg (expr, loc->u.reg);
3344 break;
3345
3346 case axs_lvalue_memory:
3347 /* Offset the pointer, if needed. */
3348 if (offset > 8)
3349 {
3350 ax_const_l (expr, offset / 8);
3351 ax_simple (expr, aop_add);
3352 offset %= 8;
3353 }
3354 access_memory (arch, expr, size);
3355 break;
3356 }
3357
3358 /* For a bits-big-endian target, shift up what we already
3359 have. For a bits-little-endian target, shift up the
3360 new data. Note that there is a potential bug here if
3361 the DWARF expression leaves multiple values on the
3362 stack. */
3363 if (bits_collected > 0)
3364 {
3365 if (bits_big_endian)
3366 {
3367 ax_simple (expr, aop_swap);
3368 ax_const_l (expr, size);
3369 ax_simple (expr, aop_lsh);
3370 /* We don't need a second swap here, because
3371 aop_bit_or is symmetric. */
3372 }
3373 else
3374 {
3375 ax_const_l (expr, size);
3376 ax_simple (expr, aop_lsh);
3377 }
3378 ax_simple (expr, aop_bit_or);
3379 }
3380
3381 bits_collected += size;
3382 loc->kind = axs_rvalue;
08922a10
SS		 3383 }
3384 break;
08922a10 3385
3cf03773
TT		 3386 case DW_OP_GNU_uninit:
3387 unimplemented (op);
3388
3389 case DW_OP_call2:
3390 case DW_OP_call4:
3391 {
3392 struct dwarf2_locexpr_baton block;
3393 int size = (op == DW_OP_call2 ? 2 : 4);
b64f50a1 3394 cu_offset offset;
3cf03773
TT		 3395
3396 uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
3397 op_ptr += size;
3398
b64f50a1 3399 offset.cu_off = uoffset;
8b9737bf
TT		 3400 block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
3401 get_ax_pc, expr);
3cf03773
TT		 3402
3403 /* DW_OP_call_ref is currently not supported. */
3404 gdb_assert (block.per_cu == per_cu);
3405
9f6f94ff
TT		 3406 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3407 block.data, block.data + block.size,
3408 per_cu);
3cf03773
TT		 3409 }
3410 break;
3411
3412 case DW_OP_call_ref:
3413 unimplemented (op);
3414
3415 default:
b1bfef65 3416 unimplemented (op);
08922a10 3417 }
08922a10 3418 }
3cf03773
TT		 3419
3420 /* Patch all the branches we emitted. */
3421 for (i = 0; i < VEC_length (int, patches); ++i)
3422 {
3423 int targ = offsets[VEC_index (int, dw_labels, i)];
3424 if (targ == -1)
3425 internal_error (__FILE__, __LINE__, _("invalid label"));
3426 ax_label (expr, VEC_index (int, patches, i), targ);
3427 }
3428
3429 do_cleanups (cleanups);
08922a10
SS		 3430}
3431
4c2df51b
DJ		 3432\f
3433/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3434 evaluator to calculate the location. */
3435static struct value *
3436locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
3437{
3438 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3439 struct value *val;
9a619af0 3440
a2d33775
JK		 3441 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3442 dlbaton->size, dlbaton->per_cu);
4c2df51b
DJ		 3443
3444 return val;
3445}
3446
e18b2753
JK		 3447/* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3448 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3449 will be thrown. */
3450
3451static struct value *
3452locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
3453{
3454 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3455
3456 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3457 dlbaton->size);
3458}
3459
4c2df51b
DJ		 3460/* Return non-zero iff we need a frame to evaluate SYMBOL. */
3461static int
3462locexpr_read_needs_frame (struct symbol *symbol)
3463{
3464 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
9a619af0 3465
ae0d2f24
UW		 3466 return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
3467 dlbaton->per_cu);
4c2df51b
DJ		 3468}
3469
9eae7c52
TT		 3470/* Return true if DATA points to the end of a piece. END is one past
3471 the last byte in the expression. */
3472
3473static int
3474piece_end_p (const gdb_byte *data, const gdb_byte *end)
3475{
3476 return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3477}
3478
5e44ecb3
TT		 3479/* Helper for locexpr_describe_location_piece that finds the name of a
3480 DWARF register. */
3481
3482static const char *
3483locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
3484{
3485 int regnum;
3486
3487 regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3488 return gdbarch_register_name (gdbarch, regnum);
3489}
3490
9eae7c52
TT		 3491/* Nicely describe a single piece of a location, returning an updated
3492 position in the bytecode sequence. This function cannot recognize
3493 all locations; if a location is not recognized, it simply returns
f664829e
DE		 3494 DATA. If there is an error during reading, e.g. we run off the end
3495 of the buffer, an error is thrown. */
08922a10 3496
0d45f56e 3497static const gdb_byte *
08922a10
SS		 3498locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
3499 CORE_ADDR addr, struct objfile *objfile,
49f6c839 3500 struct dwarf2_per_cu_data *per_cu,
9eae7c52 3501 const gdb_byte *data, const gdb_byte *end,
0d45f56e 3502 unsigned int addr_size)
4c2df51b 3503{
08922a10 3504 struct gdbarch *gdbarch = get_objfile_arch (objfile);
49f6c839 3505 size_t leb128_size;
08922a10
SS		 3506
3507 if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3508 {
08922a10 3509 fprintf_filtered (stream, _("a variable in $%s"),
5e44ecb3 3510 locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
08922a10
SS		 3511 data += 1;
3512 }
3513 else if (data[0] == DW_OP_regx)
3514 {
9fccedf7 3515 uint64_t reg;
4c2df51b 3516
f664829e 3517 data = safe_read_uleb128 (data + 1, end, &reg);
08922a10 3518 fprintf_filtered (stream, _("a variable in $%s"),
5e44ecb3 3519 locexpr_regname (gdbarch, reg));
08922a10
SS		 3520 }
3521 else if (data[0] == DW_OP_fbreg)
4c2df51b 3522 {
3977b71f 3523 const struct block *b;
08922a10
SS		 3524 struct symbol *framefunc;
3525 int frame_reg = 0;
9fccedf7 3526 int64_t frame_offset;
7155d578 3527 const gdb_byte *base_data, *new_data, *save_data = data;
08922a10 3528 size_t base_size;
9fccedf7 3529 int64_t base_offset = 0;
08922a10 3530
f664829e 3531 new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
9eae7c52
TT		 3532 if (!piece_end_p (new_data, end))
3533 return data;
3534 data = new_data;
3535
08922a10
SS		 3536 b = block_for_pc (addr);
3537
3538 if (!b)
3539 error (_("No block found for address for symbol \"%s\"."),
3540 SYMBOL_PRINT_NAME (symbol));
3541
3542 framefunc = block_linkage_function (b);
3543
3544 if (!framefunc)
3545 error (_("No function found for block for symbol \"%s\"."),
3546 SYMBOL_PRINT_NAME (symbol));
3547
3548 dwarf_expr_frame_base_1 (framefunc, addr, &base_data, &base_size);
3549
3550 if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3551 {
0d45f56e 3552 const gdb_byte *buf_end;
08922a10
SS		 3553
3554 frame_reg = base_data[0] - DW_OP_breg0;
f664829e
DE		 3555 buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
3556 &base_offset);
08922a10 3557 if (buf_end != base_data + base_size)
3e43a32a
MS		 3558 error (_("Unexpected opcode after "
3559 "DW_OP_breg%u for symbol \"%s\"."),
08922a10
SS		 3560 frame_reg, SYMBOL_PRINT_NAME (symbol));
3561 }
3562 else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3563 {
3564 /* The frame base is just the register, with no offset. */
3565 frame_reg = base_data[0] - DW_OP_reg0;
3566 base_offset = 0;
3567 }
3568 else
3569 {
3570 /* We don't know what to do with the frame base expression,
3571 so we can't trace this variable; give up. */
7155d578 3572 return save_data;
08922a10
SS		 3573 }
3574
3e43a32a
MS		 3575 fprintf_filtered (stream,
3576 _("a variable at frame base reg $%s offset %s+%s"),
5e44ecb3 3577 locexpr_regname (gdbarch, frame_reg),
08922a10
SS		 3578 plongest (base_offset), plongest (frame_offset));
3579 }
9eae7c52
TT		 3580 else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3581 && piece_end_p (data, end))
08922a10 3582 {
9fccedf7 3583 int64_t offset;
08922a10 3584
f664829e 3585 data = safe_read_sleb128 (data + 1, end, &offset);
08922a10 3586
4c2df51b 3587 fprintf_filtered (stream,
08922a10
SS		 3588 _("a variable at offset %s from base reg $%s"),
3589 plongest (offset),
5e44ecb3 3590 locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
4c2df51b
DJ		 3591 }
3592
c3228f12
EZ		 3593 /* The location expression for a TLS variable looks like this (on a
3594 64-bit LE machine):
3595
3596 DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3597 (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
09d8bd00 3598
c3228f12
EZ		 3599 0x3 is the encoding for DW_OP_addr, which has an operand as long
3600 as the size of an address on the target machine (here is 8
09d8bd00
TT		 3601 bytes). Note that more recent version of GCC emit DW_OP_const4u
3602 or DW_OP_const8u, depending on address size, rather than
0963b4bd
MS		 3603 DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3604 The operand represents the offset at which the variable is within
3605 the thread local storage. */
c3228f12 3606
9eae7c52 3607 else if (data + 1 + addr_size < end
09d8bd00
TT		 3608 && (data[0] == DW_OP_addr
3609 || (addr_size == 4 && data[0] == DW_OP_const4u)
3610 || (addr_size == 8 && data[0] == DW_OP_const8u))
9eae7c52
TT		 3611 && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3612 && piece_end_p (data + 2 + addr_size, end))
08922a10 3613 {
d4a087c7
UW		 3614 ULONGEST offset;
3615 offset = extract_unsigned_integer (data + 1, addr_size,
3616 gdbarch_byte_order (gdbarch));
9a619af0 3617
08922a10 3618 fprintf_filtered (stream,
d4a087c7 3619 _("a thread-local variable at offset 0x%s "
08922a10 3620 "in the thread-local storage for `%s'"),
4262abfb 3621 phex_nz (offset, addr_size), objfile_name (objfile));
08922a10
SS		 3622
3623 data += 1 + addr_size + 1;
3624 }
49f6c839
DE		 3625
3626 /* With -gsplit-dwarf a TLS variable can also look like this:
3627 DW_AT_location : 3 byte block: fc 4 e0
3628 (DW_OP_GNU_const_index: 4;
3629 DW_OP_GNU_push_tls_address) */
3630 else if (data + 3 <= end
3631 && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
3632 && data[0] == DW_OP_GNU_const_index
3633 && leb128_size > 0
3634 && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
3635 && piece_end_p (data + 2 + leb128_size, end))
3636 {
a55c1f32 3637 uint64_t offset;
49f6c839
DE		 3638
3639 data = safe_read_uleb128 (data + 1, end, &offset);
3640 offset = dwarf2_read_addr_index (per_cu, offset);
3641 fprintf_filtered (stream,
3642 _("a thread-local variable at offset 0x%s "
3643 "in the thread-local storage for `%s'"),
4262abfb 3644 phex_nz (offset, addr_size), objfile_name (objfile));
49f6c839
DE		 3645 ++data;
3646 }
3647
9eae7c52
TT		 3648 else if (data[0] >= DW_OP_lit0
3649 && data[0] <= DW_OP_lit31
3650 && data + 1 < end
3651 && data[1] == DW_OP_stack_value)
3652 {
3653 fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
3654 data += 2;
3655 }
3656
3657 return data;
3658}
3659
3660/* Disassemble an expression, stopping at the end of a piece or at the
3661 end of the expression. Returns a pointer to the next unread byte
3662 in the input expression. If ALL is nonzero, then this function
f664829e
DE		 3663 will keep going until it reaches the end of the expression.
3664 If there is an error during reading, e.g. we run off the end
3665 of the buffer, an error is thrown. */
9eae7c52
TT		 3666
3667static const gdb_byte *
3668disassemble_dwarf_expression (struct ui_file *stream,
3669 struct gdbarch *arch, unsigned int addr_size,
2bda9cc5 3670 int offset_size, const gdb_byte *start,
9eae7c52 3671 const gdb_byte *data, const gdb_byte *end,
2bda9cc5 3672 int indent, int all,
5e44ecb3 3673 struct dwarf2_per_cu_data *per_cu)
9eae7c52 3674{
9eae7c52
TT		 3675 while (data < end
3676 && (all
3677 || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3678 {
3679 enum dwarf_location_atom op = *data++;
9fccedf7
DE		 3680 uint64_t ul;
3681 int64_t l;
9eae7c52
TT		 3682 const char *name;
3683
f39c6ffd 3684 name = get_DW_OP_name (op);
9eae7c52
TT		 3685
3686 if (!name)
3687 error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
06826322 3688 op, (long) (data - 1 - start));
2bda9cc5
JK		 3689 fprintf_filtered (stream, " %*ld: %s", indent + 4,
3690 (long) (data - 1 - start), name);
9eae7c52
TT		 3691
3692 switch (op)
3693 {
3694 case DW_OP_addr:
d4a087c7
UW		 3695 ul = extract_unsigned_integer (data, addr_size,
3696 gdbarch_byte_order (arch));
9eae7c52 3697 data += addr_size;
d4a087c7 3698 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
9eae7c52
TT		 3699 break;
3700
3701 case DW_OP_const1u:
3702 ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
3703 data += 1;
3704 fprintf_filtered (stream, " %s", pulongest (ul));
3705 break;
3706 case DW_OP_const1s:
3707 l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
3708 data += 1;
3709 fprintf_filtered (stream, " %s", plongest (l));
3710 break;
3711 case DW_OP_const2u:
3712 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3713 data += 2;
3714 fprintf_filtered (stream, " %s", pulongest (ul));
3715 break;
3716 case DW_OP_const2s:
3717 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3718 data += 2;
3719 fprintf_filtered (stream, " %s", plongest (l));
3720 break;
3721 case DW_OP_const4u:
3722 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3723 data += 4;
3724 fprintf_filtered (stream, " %s", pulongest (ul));
3725 break;
3726 case DW_OP_const4s:
3727 l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
3728 data += 4;
3729 fprintf_filtered (stream, " %s", plongest (l));
3730 break;
3731 case DW_OP_const8u:
3732 ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
3733 data += 8;
3734 fprintf_filtered (stream, " %s", pulongest (ul));
3735 break;
3736 case DW_OP_const8s:
3737 l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
3738 data += 8;
3739 fprintf_filtered (stream, " %s", plongest (l));
3740 break;
3741 case DW_OP_constu:
f664829e 3742 data = safe_read_uleb128 (data, end, &ul);
9eae7c52
TT		 3743 fprintf_filtered (stream, " %s", pulongest (ul));
3744 break;
3745 case DW_OP_consts:
f664829e 3746 data = safe_read_sleb128 (data, end, &l);
9eae7c52
TT		 3747 fprintf_filtered (stream, " %s", plongest (l));
3748 break;
3749
3750 case DW_OP_reg0:
3751 case DW_OP_reg1:
3752 case DW_OP_reg2:
3753 case DW_OP_reg3:
3754 case DW_OP_reg4:
3755 case DW_OP_reg5:
3756 case DW_OP_reg6:
3757 case DW_OP_reg7:
3758 case DW_OP_reg8:
3759 case DW_OP_reg9:
3760 case DW_OP_reg10:
3761 case DW_OP_reg11:
3762 case DW_OP_reg12:
3763 case DW_OP_reg13:
3764 case DW_OP_reg14:
3765 case DW_OP_reg15:
3766 case DW_OP_reg16:
3767 case DW_OP_reg17:
3768 case DW_OP_reg18:
3769 case DW_OP_reg19:
3770 case DW_OP_reg20:
3771 case DW_OP_reg21:
3772 case DW_OP_reg22:
3773 case DW_OP_reg23:
3774 case DW_OP_reg24:
3775 case DW_OP_reg25:
3776 case DW_OP_reg26:
3777 case DW_OP_reg27:
3778 case DW_OP_reg28:
3779 case DW_OP_reg29:
3780 case DW_OP_reg30:
3781 case DW_OP_reg31:
3782 fprintf_filtered (stream, " [$%s]",
5e44ecb3 3783 locexpr_regname (arch, op - DW_OP_reg0));
9eae7c52
TT		 3784 break;
3785
3786 case DW_OP_regx:
f664829e 3787 data = safe_read_uleb128 (data, end, &ul);
9eae7c52 3788 fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
5e44ecb3 3789 locexpr_regname (arch, (int) ul));
9eae7c52
TT		 3790 break;
3791
3792 case DW_OP_implicit_value:
f664829e 3793 data = safe_read_uleb128 (data, end, &ul);
9eae7c52
TT		 3794 data += ul;
3795 fprintf_filtered (stream, " %s", pulongest (ul));
3796 break;
3797
3798 case DW_OP_breg0:
3799 case DW_OP_breg1:
3800 case DW_OP_breg2:
3801 case DW_OP_breg3:
3802 case DW_OP_breg4:
3803 case DW_OP_breg5:
3804 case DW_OP_breg6:
3805 case DW_OP_breg7:
3806 case DW_OP_breg8:
3807 case DW_OP_breg9:
3808 case DW_OP_breg10:
3809 case DW_OP_breg11:
3810 case DW_OP_breg12:
3811 case DW_OP_breg13:
3812 case DW_OP_breg14:
3813 case DW_OP_breg15:
3814 case DW_OP_breg16:
3815 case DW_OP_breg17:
3816 case DW_OP_breg18:
3817 case DW_OP_breg19:
3818 case DW_OP_breg20:
3819 case DW_OP_breg21:
3820 case DW_OP_breg22:
3821 case DW_OP_breg23:
3822 case DW_OP_breg24:
3823 case DW_OP_breg25:
3824 case DW_OP_breg26:
3825 case DW_OP_breg27:
3826 case DW_OP_breg28:
3827 case DW_OP_breg29:
3828 case DW_OP_breg30:
3829 case DW_OP_breg31:
f664829e 3830 data = safe_read_sleb128 (data, end, &l);
0502ed8c 3831 fprintf_filtered (stream, " %s [$%s]", plongest (l),
5e44ecb3 3832 locexpr_regname (arch, op - DW_OP_breg0));
9eae7c52
TT		 3833 break;
3834
3835 case DW_OP_bregx:
f664829e
DE		 3836 data = safe_read_uleb128 (data, end, &ul);
3837 data = safe_read_sleb128 (data, end, &l);
0502ed8c
JK		 3838 fprintf_filtered (stream, " register %s [$%s] offset %s",
3839 pulongest (ul),
5e44ecb3 3840 locexpr_regname (arch, (int) ul),
0502ed8c 3841 plongest (l));
9eae7c52
TT		 3842 break;
3843
3844 case DW_OP_fbreg:
f664829e 3845 data = safe_read_sleb128 (data, end, &l);
0502ed8c 3846 fprintf_filtered (stream, " %s", plongest (l));
9eae7c52
TT		 3847 break;
3848
3849 case DW_OP_xderef_size:
3850 case DW_OP_deref_size:
3851 case DW_OP_pick:
3852 fprintf_filtered (stream, " %d", *data);
3853 ++data;
3854 break;
3855
3856 case DW_OP_plus_uconst:
f664829e 3857 data = safe_read_uleb128 (data, end, &ul);
9eae7c52
TT		 3858 fprintf_filtered (stream, " %s", pulongest (ul));
3859 break;
3860
3861 case DW_OP_skip:
3862 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3863 data += 2;
3864 fprintf_filtered (stream, " to %ld",
3865 (long) (data + l - start));
3866 break;
3867
3868 case DW_OP_bra:
3869 l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3870 data += 2;
3871 fprintf_filtered (stream, " %ld",
3872 (long) (data + l - start));
3873 break;
3874
3875 case DW_OP_call2:
3876 ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3877 data += 2;
3878 fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
3879 break;
3880
3881 case DW_OP_call4:
3882 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3883 data += 4;
3884 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3885 break;
3886
3887 case DW_OP_call_ref:
3888 ul = extract_unsigned_integer (data, offset_size,
3889 gdbarch_byte_order (arch));
3890 data += offset_size;
3891 fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
3892 break;
3893
3894 case DW_OP_piece:
f664829e 3895 data = safe_read_uleb128 (data, end, &ul);
9eae7c52
TT		 3896 fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
3897 break;
3898
3899 case DW_OP_bit_piece:
3900 {
9fccedf7 3901 uint64_t offset;
9eae7c52 3902
f664829e
DE		 3903 data = safe_read_uleb128 (data, end, &ul);
3904 data = safe_read_uleb128 (data, end, &offset);
9eae7c52
TT		 3905 fprintf_filtered (stream, " size %s offset %s (bits)",
3906 pulongest (ul), pulongest (offset));
3907 }
3908 break;
8cf6f0b1
TT		 3909
3910 case DW_OP_GNU_implicit_pointer:
3911 {
3912 ul = extract_unsigned_integer (data, offset_size,
3913 gdbarch_byte_order (arch));
3914 data += offset_size;
3915
f664829e 3916 data = safe_read_sleb128 (data, end, &l);
8cf6f0b1
TT		 3917
3918 fprintf_filtered (stream, " DIE %s offset %s",
3919 phex_nz (ul, offset_size),
3920 plongest (l));
3921 }
3922 break;
5e44ecb3
TT		 3923
3924 case DW_OP_GNU_deref_type:
3925 {
3926 int addr_size = *data++;
b64f50a1 3927 cu_offset offset;
5e44ecb3
TT		 3928 struct type *type;
3929
f664829e 3930 data = safe_read_uleb128 (data, end, &ul);
b64f50a1 3931 offset.cu_off = ul;
5e44ecb3
TT		 3932 type = dwarf2_get_die_type (offset, per_cu);
3933 fprintf_filtered (stream, "<");
3934 type_print (type, "", stream, -1);
b64f50a1 3935 fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
5e44ecb3
TT		 3936 addr_size);
3937 }
3938 break;
3939
3940 case DW_OP_GNU_const_type:
3941 {
b64f50a1 3942 cu_offset type_die;
5e44ecb3
TT		 3943 struct type *type;
3944
f664829e 3945 data = safe_read_uleb128 (data, end, &ul);
b64f50a1 3946 type_die.cu_off = ul;
5e44ecb3
TT		 3947 type = dwarf2_get_die_type (type_die, per_cu);
3948 fprintf_filtered (stream, "<");
3949 type_print (type, "", stream, -1);
b64f50a1 3950 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
5e44ecb3
TT		 3951 }
3952 break;
3953
3954 case DW_OP_GNU_regval_type:
3955 {
9fccedf7 3956 uint64_t reg;
b64f50a1 3957 cu_offset type_die;
5e44ecb3
TT		 3958 struct type *type;
3959
f664829e
DE		 3960 data = safe_read_uleb128 (data, end, &reg);
3961 data = safe_read_uleb128 (data, end, &ul);
b64f50a1 3962 type_die.cu_off = ul;
5e44ecb3
TT		 3963
3964 type = dwarf2_get_die_type (type_die, per_cu);
3965 fprintf_filtered (stream, "<");
3966 type_print (type, "", stream, -1);
b64f50a1
JK		 3967 fprintf_filtered (stream, " [0x%s]> [$%s]",
3968 phex_nz (type_die.cu_off, 0),
5e44ecb3
TT		 3969 locexpr_regname (arch, reg));
3970 }
3971 break;
3972
3973 case DW_OP_GNU_convert:
3974 case DW_OP_GNU_reinterpret:
3975 {
b64f50a1 3976 cu_offset type_die;
5e44ecb3 3977
f664829e 3978 data = safe_read_uleb128 (data, end, &ul);
b64f50a1 3979 type_die.cu_off = ul;
5e44ecb3 3980
b64f50a1 3981 if (type_die.cu_off == 0)
5e44ecb3
TT		 3982 fprintf_filtered (stream, "<0>");
3983 else
3984 {
3985 struct type *type;
3986
3987 type = dwarf2_get_die_type (type_die, per_cu);
3988 fprintf_filtered (stream, "<");
3989 type_print (type, "", stream, -1);
b64f50a1 3990 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
5e44ecb3
TT		 3991 }
3992 }
3993 break;
2bda9cc5
JK		 3994
3995 case DW_OP_GNU_entry_value:
f664829e 3996 data = safe_read_uleb128 (data, end, &ul);
2bda9cc5
JK		 3997 fputc_filtered ('\n', stream);
3998 disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
3999 start, data, data + ul, indent + 2,
4000 all, per_cu);
4001 data += ul;
4002 continue;
49f6c839 4003
a24f71ab
JK		 4004 case DW_OP_GNU_parameter_ref:
4005 ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
4006 data += 4;
4007 fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
4008 break;
4009
49f6c839
DE		 4010 case DW_OP_GNU_addr_index:
4011 data = safe_read_uleb128 (data, end, &ul);
4012 ul = dwarf2_read_addr_index (per_cu, ul);
4013 fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
4014 break;
4015 case DW_OP_GNU_const_index:
4016 data = safe_read_uleb128 (data, end, &ul);
4017 ul = dwarf2_read_addr_index (per_cu, ul);
4018 fprintf_filtered (stream, " %s", pulongest (ul));
4019 break;
9eae7c52
TT		 4020 }
4021
4022 fprintf_filtered (stream, "\n");
4023 }
c3228f12 4024
08922a10 4025 return data;
4c2df51b
DJ		 4026}
4027
08922a10
SS		 4028/* Describe a single location, which may in turn consist of multiple
4029 pieces. */
a55cc764 4030
08922a10
SS		 4031static void
4032locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
0d45f56e 4033 struct ui_file *stream,
56eb65bd 4034 const gdb_byte *data, size_t size,
9eae7c52 4035 struct objfile *objfile, unsigned int addr_size,
5e44ecb3 4036 int offset_size, struct dwarf2_per_cu_data *per_cu)
08922a10 4037{
0d45f56e 4038 const gdb_byte *end = data + size;
9eae7c52 4039 int first_piece = 1, bad = 0;
08922a10 4040
08922a10
SS		 4041 while (data < end)
4042 {
9eae7c52
TT		 4043 const gdb_byte *here = data;
4044 int disassemble = 1;
4045
4046 if (first_piece)
4047 first_piece = 0;
4048 else
4049 fprintf_filtered (stream, _(", and "));
08922a10 4050
9eae7c52
TT		 4051 if (!dwarf2_always_disassemble)
4052 {
3e43a32a 4053 data = locexpr_describe_location_piece (symbol, stream,
49f6c839 4054 addr, objfile, per_cu,
9eae7c52
TT		 4055 data, end, addr_size);
4056 /* If we printed anything, or if we have an empty piece,
4057 then don't disassemble. */
4058 if (data != here
4059 || data[0] == DW_OP_piece
4060 || data[0] == DW_OP_bit_piece)
4061 disassemble = 0;
08922a10 4062 }
9eae7c52 4063 if (disassemble)
2bda9cc5
JK		 4064 {
4065 fprintf_filtered (stream, _("a complex DWARF expression:\n"));
4066 data = disassemble_dwarf_expression (stream,
4067 get_objfile_arch (objfile),
4068 addr_size, offset_size, data,
4069 data, end, 0,
4070 dwarf2_always_disassemble,
4071 per_cu);
4072 }
9eae7c52
TT		 4073
4074 if (data < end)
08922a10 4075 {
9eae7c52 4076 int empty = data == here;
08922a10 4077
9eae7c52
TT		 4078 if (disassemble)
4079 fprintf_filtered (stream, " ");
4080 if (data[0] == DW_OP_piece)
4081 {
9fccedf7 4082 uint64_t bytes;
08922a10 4083
f664829e 4084 data = safe_read_uleb128 (data + 1, end, &bytes);
08922a10 4085
9eae7c52
TT		 4086 if (empty)
4087 fprintf_filtered (stream, _("an empty %s-byte piece"),
4088 pulongest (bytes));
4089 else
4090 fprintf_filtered (stream, _(" [%s-byte piece]"),
4091 pulongest (bytes));
4092 }
4093 else if (data[0] == DW_OP_bit_piece)
4094 {
9fccedf7 4095 uint64_t bits, offset;
9eae7c52 4096
f664829e
DE		 4097 data = safe_read_uleb128 (data + 1, end, &bits);
4098 data = safe_read_uleb128 (data, end, &offset);
9eae7c52
TT		 4099
4100 if (empty)
4101 fprintf_filtered (stream,
4102 _("an empty %s-bit piece"),
4103 pulongest (bits));
4104 else
4105 fprintf_filtered (stream,
4106 _(" [%s-bit piece, offset %s bits]"),
4107 pulongest (bits), pulongest (offset));
4108 }
4109 else
4110 {
4111 bad = 1;
4112 break;
4113 }
08922a10
SS		 4114 }
4115 }
4116
4117 if (bad || data > end)
4118 error (_("Corrupted DWARF2 expression for \"%s\"."),
4119 SYMBOL_PRINT_NAME (symbol));
4120}
4121
4122/* Print a natural-language description of SYMBOL to STREAM. This
4123 version is for a symbol with a single location. */
a55cc764 4124
08922a10
SS		 4125static void
4126locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
4127 struct ui_file *stream)
4128{
4129 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4130 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4131 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
9eae7c52 4132 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
08922a10 4133
3e43a32a
MS		 4134 locexpr_describe_location_1 (symbol, addr, stream,
4135 dlbaton->data, dlbaton->size,
5e44ecb3
TT		 4136 objfile, addr_size, offset_size,
4137 dlbaton->per_cu);
08922a10
SS		 4138}
4139
4140/* Describe the location of SYMBOL as an agent value in VALUE, generating
4141 any necessary bytecode in AX. */
a55cc764 4142
0d53c4c4 4143static void
505e835d
UW		 4144locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4145 struct agent_expr *ax, struct axs_value *value)
a55cc764
DJ		 4146{
4147 struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3cf03773 4148 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
a55cc764 4149
1d6edc3c 4150 if (dlbaton->size == 0)
cabe9ab6
PA		 4151 value->optimized_out = 1;
4152 else
9f6f94ff
TT		 4153 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
4154 dlbaton->data, dlbaton->data + dlbaton->size,
4155 dlbaton->per_cu);
a55cc764
DJ		 4156}
4157
4c2df51b
DJ		 4158/* The set of location functions used with the DWARF-2 expression
4159 evaluator. */
768a979c 4160const struct symbol_computed_ops dwarf2_locexpr_funcs = {
4c2df51b 4161 locexpr_read_variable,
e18b2753 4162 locexpr_read_variable_at_entry,
4c2df51b
DJ		 4163 locexpr_read_needs_frame,
4164 locexpr_describe_location,
f1e6e072 4165 0, /* location_has_loclist */
a55cc764 4166 locexpr_tracepoint_var_ref
4c2df51b 4167};
0d53c4c4
DJ		 4168
4169
4170/* Wrapper functions for location lists. These generally find
4171 the appropriate location expression and call something above. */
4172
4173/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4174 evaluator to calculate the location. */
4175static struct value *
4176loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
4177{
4178 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4179 struct value *val;
947bb88f 4180 const gdb_byte *data;
b6b08ebf 4181 size_t size;
8cf6f0b1 4182 CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
0d53c4c4 4183
8cf6f0b1 4184 data = dwarf2_find_location_expression (dlbaton, &size, pc);
1d6edc3c
JK		 4185 val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
4186 dlbaton->per_cu);
0d53c4c4
DJ		 4187
4188 return val;
4189}
4190
e18b2753
JK		 4191/* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4192 entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4193 will be thrown.
4194
4195 Function always returns non-NULL value, it may be marked optimized out if
4196 inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4197 if it cannot resolve the parameter for any reason. */
4198
4199static struct value *
4200loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
4201{
4202 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4203 const gdb_byte *data;
4204 size_t size;
4205 CORE_ADDR pc;
4206
4207 if (frame == NULL || !get_frame_func_if_available (frame, &pc))
4208 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4209
4210 data = dwarf2_find_location_expression (dlbaton, &size, pc);
4211 if (data == NULL)
4212 return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4213
4214 return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
4215}
4216
0d53c4c4
DJ		 4217/* Return non-zero iff we need a frame to evaluate SYMBOL. */
4218static int
4219loclist_read_needs_frame (struct symbol *symbol)
4220{
4221 /* If there's a location list, then assume we need to have a frame
4222 to choose the appropriate location expression. With tracking of
4223 global variables this is not necessarily true, but such tracking
4224 is disabled in GCC at the moment until we figure out how to
4225 represent it. */
4226
4227 return 1;
4228}
4229
08922a10
SS		 4230/* Print a natural-language description of SYMBOL to STREAM. This
4231 version applies when there is a list of different locations, each
4232 with a specified address range. */
4233
4234static void
4235loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
4236 struct ui_file *stream)
0d53c4c4 4237{
08922a10 4238 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
947bb88f 4239 const gdb_byte *loc_ptr, *buf_end;
08922a10
SS		 4240 struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4241 struct gdbarch *gdbarch = get_objfile_arch (objfile);
4242 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4243 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
9eae7c52 4244 int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
d4a087c7 4245 int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
08922a10 4246 /* Adjust base_address for relocatable objects. */
9aa1f1e3 4247 CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
08922a10 4248 CORE_ADDR base_address = dlbaton->base_address + base_offset;
f664829e 4249 int done = 0;
08922a10
SS		 4250
4251 loc_ptr = dlbaton->data;
4252 buf_end = dlbaton->data + dlbaton->size;
4253
9eae7c52 4254 fprintf_filtered (stream, _("multi-location:\n"));
08922a10
SS		 4255
4256 /* Iterate through locations until we run out. */
f664829e 4257 while (!done)
08922a10 4258 {
f664829e
DE		 4259 CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
4260 int length;
4261 enum debug_loc_kind kind;
4262 const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
4263
4264 if (dlbaton->from_dwo)
4265 kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
4266 loc_ptr, buf_end, &new_ptr,
3771a44c 4267 &low, &high, byte_order);
d4a087c7 4268 else
f664829e
DE		 4269 kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
4270 &low, &high,
4271 byte_order, addr_size,
4272 signed_addr_p);
4273 loc_ptr = new_ptr;
4274 switch (kind)
08922a10 4275 {
f664829e
DE		 4276 case DEBUG_LOC_END_OF_LIST:
4277 done = 1;
4278 continue;
4279 case DEBUG_LOC_BASE_ADDRESS:
d4a087c7 4280 base_address = high + base_offset;
9eae7c52 4281 fprintf_filtered (stream, _(" Base address %s"),
08922a10 4282 paddress (gdbarch, base_address));
08922a10 4283 continue;
3771a44c
DE		 4284 case DEBUG_LOC_START_END:
4285 case DEBUG_LOC_START_LENGTH:
f664829e
DE		 4286 break;
4287 case DEBUG_LOC_BUFFER_OVERFLOW:
4288 case DEBUG_LOC_INVALID_ENTRY:
4289 error (_("Corrupted DWARF expression for symbol \"%s\"."),
4290 SYMBOL_PRINT_NAME (symbol));
4291 default:
4292 gdb_assert_not_reached ("bad debug_loc_kind");
08922a10
SS		 4293 }
4294
08922a10
SS		 4295 /* Otherwise, a location expression entry. */
4296 low += base_address;
4297 high += base_address;
4298
4299 length = extract_unsigned_integer (loc_ptr, 2, byte_order);
4300 loc_ptr += 2;
4301
08922a10
SS		 4302 /* (It would improve readability to print only the minimum
4303 necessary digits of the second number of the range.) */
9eae7c52 4304 fprintf_filtered (stream, _(" Range %s-%s: "),
08922a10
SS		 4305 paddress (gdbarch, low), paddress (gdbarch, high));
4306
4307 /* Now describe this particular location. */
4308 locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
5e44ecb3
TT		 4309 objfile, addr_size, offset_size,
4310 dlbaton->per_cu);
9eae7c52
TT		 4311
4312 fprintf_filtered (stream, "\n");
08922a10
SS		 4313
4314 loc_ptr += length;
4315 }
0d53c4c4
DJ		 4316}
4317
4318/* Describe the location of SYMBOL as an agent value in VALUE, generating
4319 any necessary bytecode in AX. */
4320static void
505e835d
UW		 4321loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4322 struct agent_expr *ax, struct axs_value *value)
0d53c4c4
DJ		 4323{
4324 struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
947bb88f 4325 const gdb_byte *data;
b6b08ebf 4326 size_t size;
3cf03773 4327 unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
0d53c4c4 4328
8cf6f0b1 4329 data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
1d6edc3c 4330 if (size == 0)
cabe9ab6
PA		 4331 value->optimized_out = 1;
4332 else
9f6f94ff
TT		 4333 dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
4334 dlbaton->per_cu);
0d53c4c4
DJ		 4335}
4336
4337/* The set of location functions used with the DWARF-2 expression
4338 evaluator and location lists. */
768a979c 4339const struct symbol_computed_ops dwarf2_loclist_funcs = {
0d53c4c4 4340 loclist_read_variable,
e18b2753 4341 loclist_read_variable_at_entry,
0d53c4c4
DJ		 4342 loclist_read_needs_frame,
4343 loclist_describe_location,
f1e6e072 4344 1, /* location_has_loclist */
0d53c4c4
DJ		 4345 loclist_tracepoint_var_ref
4346};
8e3b41a9 4347
70221824
PA		 4348/* Provide a prototype to silence -Wmissing-prototypes. */
4349extern initialize_file_ftype _initialize_dwarf2loc;
4350
8e3b41a9
JK		 4351void
4352_initialize_dwarf2loc (void)
4353{
ccce17b0
YQ		 4354 add_setshow_zuinteger_cmd ("entry-values", class_maintenance,
4355 &entry_values_debug,
4356 _("Set entry values and tail call frames "
4357 "debugging."),
4358 _("Show entry values and tail call frames "
4359 "debugging."),
4360 _("When non-zero, the process of determining "
4361 "parameter values from function entry point "
4362 "and tail call frames will be printed."),
4363 NULL,
4364 show_entry_values_debug,
4365 &setdebuglist, &showdebuglist);
8e3b41a9 4366}
GDB Binutils - Deliverables
This page took 1.143705 seconds and 4 git commands to generate.