]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/compile/compile-loc2c.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove dwarf2_per_cu_data::text_offset
[thirdparty/binutils-gdb.git] / gdb / compile / compile-loc2c.c
CommitLineData
bb2ec1b3
TT		 1/* Convert a DWARF location expression to C
2
b811d2c2 3 Copyright (C) 2014-2020 Free Software Foundation, Inc.
bb2ec1b3
TT		 4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "dwarf2.h"
82ca8957
TT		 22#include "dwarf2/expr.h"
23#include "dwarf2/loc.h"
09ba997f 24#include "dwarf2/read.h"
bb2ec1b3
TT		 25#include "ui-file.h"
26#include "utils.h"
27#include "compile-internal.h"
b7dc48b4 28#include "compile-c.h"
bb2ec1b3
TT		 29#include "compile.h"
30#include "block.h"
82ca8957 31#include "dwarf2/frame.h"
268a13a5 32#include "gdbsupport/gdb_vecs.h"
bb2ec1b3 33#include "value.h"
0d12e84c 34#include "gdbarch.h"
bb2ec1b3
TT		 35
36\f
37
38/* Information about a given instruction. */
39
40struct insn_info
41{
42 /* Stack depth at entry. */
43
44 unsigned int depth;
45
46 /* Whether this instruction has been visited. */
47
48 unsigned int visited : 1;
49
50 /* Whether this instruction needs a label. */
51
52 unsigned int label : 1;
53
4aa4e28b
TT		 54 /* Whether this instruction is DW_OP_GNU_push_tls_address or
55 DW_OP_form_tls_address. This is a hack until we can add a
56 feature to glibc to let us properly generate code for TLS. */
bb2ec1b3
TT		 57
58 unsigned int is_tls : 1;
59};
60
61/* A helper function for compute_stack_depth that does the work. This
62 examines the DWARF expression starting from START and computes
63 stack effects.
64
65 NEED_TEMPVAR is an out parameter which is set if this expression
66 needs a special temporary variable to be emitted (see the code
67 generator).
c6bcad5f 68 INFO is a vector of insn_info objects, indexed by offset from the
bb2ec1b3
TT		 69 start of the DWARF expression.
70 TO_DO is a list of bytecodes which must be examined; it may be
71 added to by this function.
72 BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
73 OP_PTR and OP_END are the bounds of the DWARF expression. */
74
75static void
76compute_stack_depth_worker (int start, int *need_tempvar,
c6bcad5f 77 std::vector<struct insn_info> *info,
711799d5 78 std::vector<int> *to_do,
bb2ec1b3
TT		 79 enum bfd_endian byte_order, unsigned int addr_size,
80 const gdb_byte *op_ptr, const gdb_byte *op_end)
81{
82 const gdb_byte * const base = op_ptr;
83 int stack_depth;
84
85 op_ptr += start;
c6bcad5f
TT		 86 gdb_assert ((*info)[start].visited);
87 stack_depth = (*info)[start].depth;
bb2ec1b3
TT		 88
89 while (op_ptr < op_end)
90 {
aead7601 91 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
bb2ec1b3
TT		 92 uint64_t reg;
93 int64_t offset;
94 int ndx = op_ptr - base;
95
96#define SET_CHECK_DEPTH(WHERE) \
c6bcad5f 97 if ((*info)[WHERE].visited) \
bb2ec1b3 98 { \
c6bcad5f 99 if ((*info)[WHERE].depth != stack_depth) \
bb2ec1b3
TT		 100 error (_("inconsistent stack depths")); \
101 } \
102 else \
103 { \
104 /* Stack depth not set, so set it. */ \
c6bcad5f
TT		 105 (*info)[WHERE].visited = 1; \
106 (*info)[WHERE].depth = stack_depth; \
bb2ec1b3
TT		 107 }
108
109 SET_CHECK_DEPTH (ndx);
110
111 ++op_ptr;
112
113 switch (op)
114 {
115 case DW_OP_lit0:
116 case DW_OP_lit1:
117 case DW_OP_lit2:
118 case DW_OP_lit3:
119 case DW_OP_lit4:
120 case DW_OP_lit5:
121 case DW_OP_lit6:
122 case DW_OP_lit7:
123 case DW_OP_lit8:
124 case DW_OP_lit9:
125 case DW_OP_lit10:
126 case DW_OP_lit11:
127 case DW_OP_lit12:
128 case DW_OP_lit13:
129 case DW_OP_lit14:
130 case DW_OP_lit15:
131 case DW_OP_lit16:
132 case DW_OP_lit17:
133 case DW_OP_lit18:
134 case DW_OP_lit19:
135 case DW_OP_lit20:
136 case DW_OP_lit21:
137 case DW_OP_lit22:
138 case DW_OP_lit23:
139 case DW_OP_lit24:
140 case DW_OP_lit25:
141 case DW_OP_lit26:
142 case DW_OP_lit27:
143 case DW_OP_lit28:
144 case DW_OP_lit29:
145 case DW_OP_lit30:
146 case DW_OP_lit31:
147 ++stack_depth;
148 break;
149
150 case DW_OP_addr:
151 op_ptr += addr_size;
152 ++stack_depth;
153 break;
154
155 case DW_OP_const1u:
156 case DW_OP_const1s:
157 op_ptr += 1;
158 ++stack_depth;
159 break;
160 case DW_OP_const2u:
161 case DW_OP_const2s:
162 op_ptr += 2;
163 ++stack_depth;
164 break;
165 case DW_OP_const4u:
166 case DW_OP_const4s:
167 op_ptr += 4;
168 ++stack_depth;
169 break;
170 case DW_OP_const8u:
171 case DW_OP_const8s:
172 op_ptr += 8;
173 ++stack_depth;
174 break;
175 case DW_OP_constu:
176 case DW_OP_consts:
177 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
178 ++stack_depth;
179 break;
180
181 case DW_OP_reg0:
182 case DW_OP_reg1:
183 case DW_OP_reg2:
184 case DW_OP_reg3:
185 case DW_OP_reg4:
186 case DW_OP_reg5:
187 case DW_OP_reg6:
188 case DW_OP_reg7:
189 case DW_OP_reg8:
190 case DW_OP_reg9:
191 case DW_OP_reg10:
192 case DW_OP_reg11:
193 case DW_OP_reg12:
194 case DW_OP_reg13:
195 case DW_OP_reg14:
196 case DW_OP_reg15:
197 case DW_OP_reg16:
198 case DW_OP_reg17:
199 case DW_OP_reg18:
200 case DW_OP_reg19:
201 case DW_OP_reg20:
202 case DW_OP_reg21:
203 case DW_OP_reg22:
204 case DW_OP_reg23:
205 case DW_OP_reg24:
206 case DW_OP_reg25:
207 case DW_OP_reg26:
208 case DW_OP_reg27:
209 case DW_OP_reg28:
210 case DW_OP_reg29:
211 case DW_OP_reg30:
212 case DW_OP_reg31:
213 ++stack_depth;
214 break;
215
216 case DW_OP_regx:
217 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
218 ++stack_depth;
219 break;
220
221 case DW_OP_breg0:
222 case DW_OP_breg1:
223 case DW_OP_breg2:
224 case DW_OP_breg3:
225 case DW_OP_breg4:
226 case DW_OP_breg5:
227 case DW_OP_breg6:
228 case DW_OP_breg7:
229 case DW_OP_breg8:
230 case DW_OP_breg9:
231 case DW_OP_breg10:
232 case DW_OP_breg11:
233 case DW_OP_breg12:
234 case DW_OP_breg13:
235 case DW_OP_breg14:
236 case DW_OP_breg15:
237 case DW_OP_breg16:
238 case DW_OP_breg17:
239 case DW_OP_breg18:
240 case DW_OP_breg19:
241 case DW_OP_breg20:
242 case DW_OP_breg21:
243 case DW_OP_breg22:
244 case DW_OP_breg23:
245 case DW_OP_breg24:
246 case DW_OP_breg25:
247 case DW_OP_breg26:
248 case DW_OP_breg27:
249 case DW_OP_breg28:
250 case DW_OP_breg29:
251 case DW_OP_breg30:
252 case DW_OP_breg31:
253 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
254 ++stack_depth;
255 break;
256 case DW_OP_bregx:
257 {
258 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
259 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
260 ++stack_depth;
261 }
262 break;
263 case DW_OP_fbreg:
264 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
265 ++stack_depth;
266 break;
267
268 case DW_OP_dup:
269 ++stack_depth;
270 break;
271
272 case DW_OP_drop:
273 --stack_depth;
274 break;
275
276 case DW_OP_pick:
277 ++op_ptr;
278 ++stack_depth;
279 break;
280
281 case DW_OP_rot:
282 case DW_OP_swap:
283 *need_tempvar = 1;
284 break;
285
286 case DW_OP_over:
287 ++stack_depth;
288 break;
289
290 case DW_OP_abs:
291 case DW_OP_neg:
292 case DW_OP_not:
293 case DW_OP_deref:
294 break;
295
296 case DW_OP_deref_size:
297 ++op_ptr;
298 break;
299
300 case DW_OP_plus_uconst:
301 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
302 break;
303
304 case DW_OP_div:
305 case DW_OP_shra:
306 case DW_OP_and:
307 case DW_OP_minus:
308 case DW_OP_mod:
309 case DW_OP_mul:
310 case DW_OP_or:
311 case DW_OP_plus:
312 case DW_OP_shl:
313 case DW_OP_shr:
314 case DW_OP_xor:
315 case DW_OP_le:
316 case DW_OP_ge:
317 case DW_OP_eq:
318 case DW_OP_lt:
319 case DW_OP_gt:
320 case DW_OP_ne:
321 --stack_depth;
322 break;
323
324 case DW_OP_call_frame_cfa:
325 ++stack_depth;
326 break;
327
328 case DW_OP_GNU_push_tls_address:
4aa4e28b 329 case DW_OP_form_tls_address:
c6bcad5f 330 (*info)[ndx].is_tls = 1;
bb2ec1b3
TT		 331 break;
332
333 case DW_OP_skip:
334 offset = extract_signed_integer (op_ptr, 2, byte_order);
335 op_ptr += 2;
336 offset = op_ptr + offset - base;
337 /* If the destination has not been seen yet, add it to the
338 to-do list. */
c6bcad5f 339 if (!(*info)[offset].visited)
711799d5 340 to_do->push_back (offset);
bb2ec1b3 341 SET_CHECK_DEPTH (offset);
c6bcad5f 342 (*info)[offset].label = 1;
bb2ec1b3
TT		 343 /* We're done with this line of code. */
344 return;
345
346 case DW_OP_bra:
347 offset = extract_signed_integer (op_ptr, 2, byte_order);
348 op_ptr += 2;
349 offset = op_ptr + offset - base;
350 --stack_depth;
351 /* If the destination has not been seen yet, add it to the
352 to-do list. */
c6bcad5f 353 if (!(*info)[offset].visited)
711799d5 354 to_do->push_back (offset);
bb2ec1b3 355 SET_CHECK_DEPTH (offset);
c6bcad5f 356 (*info)[offset].label = 1;
bb2ec1b3
TT		 357 break;
358
359 case DW_OP_nop:
360 break;
361
362 default:
363 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
364 }
365 }
366
367 gdb_assert (op_ptr == op_end);
368
369#undef SET_CHECK_DEPTH
370}
371
372/* Compute the maximum needed stack depth of a DWARF expression, and
373 some other information as well.
374
375 BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
376 NEED_TEMPVAR is an out parameter which is set if this expression
377 needs a special temporary variable to be emitted (see the code
378 generator).
379 IS_TLS is an out parameter which is set if this expression refers
380 to a TLS variable.
381 OP_PTR and OP_END are the bounds of the DWARF expression.
382 INITIAL_DEPTH is the initial depth of the DWARF expression stack.
383 INFO is an array of insn_info objects, indexed by offset from the
384 start of the DWARF expression.
385
386 This returns the maximum stack depth. */
387
388static int
389compute_stack_depth (enum bfd_endian byte_order, unsigned int addr_size,
390 int *need_tempvar, int *is_tls,
391 const gdb_byte *op_ptr, const gdb_byte *op_end,
392 int initial_depth,
c6bcad5f 393 std::vector<struct insn_info> *info)
bb2ec1b3 394{
711799d5 395 std::vector<int> to_do;
bb2ec1b3
TT		 396 int stack_depth, i;
397
c6bcad5f 398 info->resize (op_end - op_ptr);
bb2ec1b3 399
711799d5 400 to_do.push_back (0);
bb2ec1b3
TT		 401 (*info)[0].depth = initial_depth;
402 (*info)[0].visited = 1;
403
711799d5 404 while (!to_do.empty ())
bb2ec1b3 405 {
711799d5
TT		 406 int ndx = to_do.back ();
407 to_do.pop_back ();
bb2ec1b3 408
c6bcad5f 409 compute_stack_depth_worker (ndx, need_tempvar, info, &to_do,
bb2ec1b3
TT		 410 byte_order, addr_size,
411 op_ptr, op_end);
412 }
413
414 stack_depth = 0;
415 *is_tls = 0;
416 for (i = 0; i < op_end - op_ptr; ++i)
417 {
418 if ((*info)[i].depth > stack_depth)
419 stack_depth = (*info)[i].depth;
420 if ((*info)[i].is_tls)
421 *is_tls = 1;
422 }
423
bb2ec1b3
TT		 424 return stack_depth + 1;
425}
426
427\f
428
429#define GCC_UINTPTR "__gdb_uintptr"
430#define GCC_INTPTR "__gdb_intptr"
431
432/* Emit code to push a constant. */
433
434static void
d82b3862 435push (int indent, string_file *stream, ULONGEST l)
bb2ec1b3 436{
d82b3862 437 fprintfi_filtered (indent, stream,
3a9558c4 438 "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
bb2ec1b3
TT		 439 hex_string (l));
440}
441
442/* Emit code to push an arbitrary expression. This works like
443 printf. */
444
d82b3862 445static void pushf (int indent, string_file *stream, const char *format, ...)
77b64a49
PA		 446 ATTRIBUTE_PRINTF (3, 4);
447
bb2ec1b3 448static void
d82b3862 449pushf (int indent, string_file *stream, const char *format, ...)
bb2ec1b3
TT		 450{
451 va_list args;
452
d82b3862 453 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos + 1] = ");
bb2ec1b3 454 va_start (args, format);
d82b3862 455 stream->vprintf (format, args);
bb2ec1b3 456 va_end (args);
d82b3862 457 stream->puts (";\n");
bb2ec1b3 458
d82b3862 459 fprintfi_filtered (indent, stream, "++__gdb_tos;\n");
bb2ec1b3
TT		 460}
461
462/* Emit code for a unary expression -- one which operates in-place on
463 the top-of-stack. This works like printf. */
464
d82b3862 465static void unary (int indent, string_file *stream, const char *format, ...)
77b64a49
PA		 466 ATTRIBUTE_PRINTF (3, 4);
467
bb2ec1b3 468static void
d82b3862 469unary (int indent, string_file *stream, const char *format, ...)
bb2ec1b3
TT		 470{
471 va_list args;
472
d82b3862 473 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos] = ");
bb2ec1b3 474 va_start (args, format);
d82b3862 475 stream->vprintf (format, args);
bb2ec1b3 476 va_end (args);
d82b3862 477 stream->puts (";\n");
bb2ec1b3
TT		 478}
479
480/* Emit code for a unary expression -- one which uses the top two
481 stack items, popping the topmost one. This works like printf. */
d82b3862 482static void binary (int indent, string_file *stream, const char *format, ...)
77b64a49 483 ATTRIBUTE_PRINTF (3, 4);
bb2ec1b3
TT		 484
485static void
d82b3862 486binary (int indent, string_file *stream, const char *format, ...)
bb2ec1b3
TT		 487{
488 va_list args;
489
d82b3862 490 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 1] = ");
bb2ec1b3 491 va_start (args, format);
d82b3862 492 stream->vprintf (format, args);
bb2ec1b3 493 va_end (args);
d82b3862
SM		 494 stream->puts (";\n");
495 fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
bb2ec1b3
TT		 496}
497
498/* Print the name of a label given its "SCOPE", an arbitrary integer
499 used for uniqueness, and its TARGET, the bytecode offset
500 corresponding to the label's point of definition. */
501
502static void
d82b3862 503print_label (string_file *stream, unsigned int scope, int target)
bb2ec1b3 504{
d82b3862 505 stream->printf ("__label_%u_%s", scope, pulongest (target));
bb2ec1b3
TT		 506}
507
508/* Emit code that pushes a register's address on the stack.
509 REGISTERS_USED is an out parameter which is updated to note which
510 register was needed by this expression. */
511
512static void
d82b3862 513pushf_register_address (int indent, string_file *stream,
bb2ec1b3
TT		 514 unsigned char *registers_used,
515 struct gdbarch *gdbarch, int regnum)
516{
8f84fb0e 517 std::string regname = compile_register_name_mangled (gdbarch, regnum);
bb2ec1b3
TT		 518
519 registers_used[regnum] = 1;
3a9558c4
JK		 520 pushf (indent, stream,
521 "(" GCC_UINTPTR ") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
8f84fb0e 522 regname.c_str ());
bb2ec1b3
TT		 523}
524
525/* Emit code that pushes a register's value on the stack.
526 REGISTERS_USED is an out parameter which is updated to note which
527 register was needed by this expression. OFFSET is added to the
528 register's value before it is pushed. */
529
530static void
d82b3862 531pushf_register (int indent, string_file *stream,
bb2ec1b3
TT		 532 unsigned char *registers_used,
533 struct gdbarch *gdbarch, int regnum, uint64_t offset)
534{
8f84fb0e 535 std::string regname = compile_register_name_mangled (gdbarch, regnum);
bb2ec1b3
TT		 536
537 registers_used[regnum] = 1;
538 if (offset == 0)
539 pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
8f84fb0e 540 regname.c_str ());
bb2ec1b3 541 else
3a9558c4
JK		 542 pushf (indent, stream,
543 COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s + (" GCC_UINTPTR ") %s",
8f84fb0e 544 regname.c_str (), hex_string (offset));
bb2ec1b3
TT		 545}
546
547/* Compile a DWARF expression to C code.
548
549 INDENT is the indentation level to use.
550 STREAM is the stream where the code should be written.
551
552 TYPE_NAME names the type of the result of the DWARF expression.
553 For locations this is "void *" but for array bounds it will be an
554 integer type.
555
556 RESULT_NAME is the name of a variable in the resulting C code. The
557 result of the expression will be assigned to this variable.
558
559 SYM is the symbol corresponding to this expression.
560 PC is the location at which the expression is being evaluated.
561 ARCH is the architecture to use.
562
563 REGISTERS_USED is an out parameter which is updated to note which
564 registers were needed by this expression.
565
566 ADDR_SIZE is the DWARF address size to use.
567
568 OPT_PTR and OP_END are the bounds of the DWARF expression.
569
570 If non-NULL, INITIAL points to an initial value to write to the
571 stack. If NULL, no initial value is written.
572
573 PER_CU is the per-CU object used for looking up various other
574 things. */
575
576static void
d82b3862 577do_compile_dwarf_expr_to_c (int indent, string_file *stream,
bb2ec1b3
TT		 578 const char *type_name,
579 const char *result_name,
580 struct symbol *sym, CORE_ADDR pc,
581 struct gdbarch *arch,
582 unsigned char *registers_used,
583 unsigned int addr_size,
584 const gdb_byte *op_ptr, const gdb_byte *op_end,
585 CORE_ADDR *initial,
4b167ea1
SM		 586 dwarf2_per_cu_data *per_cu,
587 dwarf2_per_objfile *per_objfile)
bb2ec1b3
TT		 588{
589 /* We keep a counter so that labels and other objects we create have
590 unique names. */
591 static unsigned int scope;
592
593 enum bfd_endian byte_order = gdbarch_byte_order (arch);
594 const gdb_byte * const base = op_ptr;
595 int need_tempvar = 0;
596 int is_tls = 0;
c6bcad5f 597 std::vector<struct insn_info> info;
bb2ec1b3
TT		 598 int stack_depth;
599
600 ++scope;
601
d82b3862 602 fprintfi_filtered (indent, stream, "__attribute__ ((unused)) %s %s;\n",
3a9558c4 603 type_name, result_name);
d82b3862 604 fprintfi_filtered (indent, stream, "{\n");
bb2ec1b3
TT		 605 indent += 2;
606
607 stack_depth = compute_stack_depth (byte_order, addr_size,
608 &need_tempvar, &is_tls,
609 op_ptr, op_end, initial != NULL,
610 &info);
bb2ec1b3
TT		 611
612 /* This is a hack until we can add a feature to glibc to let us
613 properly generate code for TLS. You might think we could emit
614 the address in the ordinary course of translating
615 DW_OP_GNU_push_tls_address, but since the operand appears on the
616 stack, it is relatively hard to find, and the idea of calling
617 target_translate_tls_address with OFFSET==0 and then adding the
618 offset by hand seemed too hackish. */
619 if (is_tls)
620 {
621 struct frame_info *frame = get_selected_frame (NULL);
622 struct value *val;
623
624 if (frame == NULL)
625 error (_("Symbol \"%s\" cannot be used because "
626 "there is no selected frame"),
987012b8 627 sym->print_name ());
bb2ec1b3 628
63e43d3a 629 val = read_var_value (sym, NULL, frame);
bb2ec1b3
TT		 630 if (VALUE_LVAL (val) != lval_memory)
631 error (_("Symbol \"%s\" cannot be used for compilation evaluation "
632 "as its address has not been found."),
987012b8 633 sym->print_name ());
bb2ec1b3
TT		 634
635 warning (_("Symbol \"%s\" is thread-local and currently can only "
636 "be referenced from the current thread in "
637 "compiled code."),
987012b8 638 sym->print_name ());
bb2ec1b3 639
d82b3862 640 fprintfi_filtered (indent, stream, "%s = %s;\n",
bb2ec1b3
TT		 641 result_name,
642 core_addr_to_string (value_address (val)));
d82b3862 643 fprintfi_filtered (indent - 2, stream, "}\n");
bb2ec1b3
TT		 644 return;
645 }
646
d82b3862 647 fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_stack[%d];\n",
bb2ec1b3
TT		 648 stack_depth);
649
650 if (need_tempvar)
d82b3862
SM		 651 fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_tmp;\n");
652 fprintfi_filtered (indent, stream, "int __gdb_tos = -1;\n");
bb2ec1b3
TT		 653
654 if (initial != NULL)
77b64a49 655 pushf (indent, stream, "%s", core_addr_to_string (*initial));
bb2ec1b3
TT		 656
657 while (op_ptr < op_end)
658 {
aead7601 659 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
bb2ec1b3
TT		 660 uint64_t uoffset, reg;
661 int64_t offset;
662
d82b3862 663 print_spaces (indent - 2, stream);
bb2ec1b3
TT		 664 if (info[op_ptr - base].label)
665 {
666 print_label (stream, scope, op_ptr - base);
d82b3862 667 stream->puts (":;");
bb2ec1b3 668 }
d82b3862 669 stream->printf ("/* %s */\n", get_DW_OP_name (op));
bb2ec1b3
TT		 670
671 /* This is handy for debugging the generated code:
672 fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
673 (int) info[op_ptr - base].depth - 1);
674 */
675
676 ++op_ptr;
677
678 switch (op)
679 {
680 case DW_OP_lit0:
681 case DW_OP_lit1:
682 case DW_OP_lit2:
683 case DW_OP_lit3:
684 case DW_OP_lit4:
685 case DW_OP_lit5:
686 case DW_OP_lit6:
687 case DW_OP_lit7:
688 case DW_OP_lit8:
689 case DW_OP_lit9:
690 case DW_OP_lit10:
691 case DW_OP_lit11:
692 case DW_OP_lit12:
693 case DW_OP_lit13:
694 case DW_OP_lit14:
695 case DW_OP_lit15:
696 case DW_OP_lit16:
697 case DW_OP_lit17:
698 case DW_OP_lit18:
699 case DW_OP_lit19:
700 case DW_OP_lit20:
701 case DW_OP_lit21:
702 case DW_OP_lit22:
703 case DW_OP_lit23:
704 case DW_OP_lit24:
705 case DW_OP_lit25:
706 case DW_OP_lit26:
707 case DW_OP_lit27:
708 case DW_OP_lit28:
709 case DW_OP_lit29:
710 case DW_OP_lit30:
711 case DW_OP_lit31:
712 push (indent, stream, op - DW_OP_lit0);
713 break;
714
715 case DW_OP_addr:
266934d1 716 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
bb2ec1b3
TT		 717 op_ptr += addr_size;
718 /* Some versions of GCC emit DW_OP_addr before
719 DW_OP_GNU_push_tls_address. In this case the value is an
720 index, not an address. We don't support things like
721 branching between the address and the TLS op. */
722 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
4b167ea1 723 uoffset += per_objfile->objfile->text_section_offset ();
bb2ec1b3
TT		 724 push (indent, stream, uoffset);
725 break;
726
727 case DW_OP_const1u:
728 push (indent, stream,
729 extract_unsigned_integer (op_ptr, 1, byte_order));
730 op_ptr += 1;
731 break;
732 case DW_OP_const1s:
733 push (indent, stream,
734 extract_signed_integer (op_ptr, 1, byte_order));
735 op_ptr += 1;
736 break;
737 case DW_OP_const2u:
738 push (indent, stream,
739 extract_unsigned_integer (op_ptr, 2, byte_order));
740 op_ptr += 2;
741 break;
742 case DW_OP_const2s:
743 push (indent, stream,
744 extract_signed_integer (op_ptr, 2, byte_order));
745 op_ptr += 2;
746 break;
747 case DW_OP_const4u:
748 push (indent, stream,
749 extract_unsigned_integer (op_ptr, 4, byte_order));
750 op_ptr += 4;
751 break;
752 case DW_OP_const4s:
753 push (indent, stream,
754 extract_signed_integer (op_ptr, 4, byte_order));
755 op_ptr += 4;
756 break;
757 case DW_OP_const8u:
758 push (indent, stream,
759 extract_unsigned_integer (op_ptr, 8, byte_order));
760 op_ptr += 8;
761 break;
762 case DW_OP_const8s:
763 push (indent, stream,
764 extract_signed_integer (op_ptr, 8, byte_order));
765 op_ptr += 8;
766 break;
767 case DW_OP_constu:
768 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
769 push (indent, stream, uoffset);
770 break;
771 case DW_OP_consts:
772 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
773 push (indent, stream, offset);
774 break;
775
776 case DW_OP_reg0:
777 case DW_OP_reg1:
778 case DW_OP_reg2:
779 case DW_OP_reg3:
780 case DW_OP_reg4:
781 case DW_OP_reg5:
782 case DW_OP_reg6:
783 case DW_OP_reg7:
784 case DW_OP_reg8:
785 case DW_OP_reg9:
786 case DW_OP_reg10:
787 case DW_OP_reg11:
788 case DW_OP_reg12:
789 case DW_OP_reg13:
790 case DW_OP_reg14:
791 case DW_OP_reg15:
792 case DW_OP_reg16:
793 case DW_OP_reg17:
794 case DW_OP_reg18:
795 case DW_OP_reg19:
796 case DW_OP_reg20:
797 case DW_OP_reg21:
798 case DW_OP_reg22:
799 case DW_OP_reg23:
800 case DW_OP_reg24:
801 case DW_OP_reg25:
802 case DW_OP_reg26:
803 case DW_OP_reg27:
804 case DW_OP_reg28:
805 case DW_OP_reg29:
806 case DW_OP_reg30:
807 case DW_OP_reg31:
808 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
809 pushf_register_address (indent, stream, registers_used, arch,
0fde2c53
DE		 810 dwarf_reg_to_regnum_or_error
811 (arch, op - DW_OP_reg0));
bb2ec1b3
TT		 812 break;
813
814 case DW_OP_regx:
815 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
816 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
817 pushf_register_address (indent, stream, registers_used, arch,
0fde2c53 818 dwarf_reg_to_regnum_or_error (arch, reg));
bb2ec1b3
TT		 819 break;
820
821 case DW_OP_breg0:
822 case DW_OP_breg1:
823 case DW_OP_breg2:
824 case DW_OP_breg3:
825 case DW_OP_breg4:
826 case DW_OP_breg5:
827 case DW_OP_breg6:
828 case DW_OP_breg7:
829 case DW_OP_breg8:
830 case DW_OP_breg9:
831 case DW_OP_breg10:
832 case DW_OP_breg11:
833 case DW_OP_breg12:
834 case DW_OP_breg13:
835 case DW_OP_breg14:
836 case DW_OP_breg15:
837 case DW_OP_breg16:
838 case DW_OP_breg17:
839 case DW_OP_breg18:
840 case DW_OP_breg19:
841 case DW_OP_breg20:
842 case DW_OP_breg21:
843 case DW_OP_breg22:
844 case DW_OP_breg23:
845 case DW_OP_breg24:
846 case DW_OP_breg25:
847 case DW_OP_breg26:
848 case DW_OP_breg27:
849 case DW_OP_breg28:
850 case DW_OP_breg29:
851 case DW_OP_breg30:
852 case DW_OP_breg31:
853 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
854 pushf_register (indent, stream, registers_used, arch,
0fde2c53
DE		 855 dwarf_reg_to_regnum_or_error (arch,
856 op - DW_OP_breg0),
bb2ec1b3
TT		 857 offset);
858 break;
859 case DW_OP_bregx:
860 {
861 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
862 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
863 pushf_register (indent, stream, registers_used, arch,
0fde2c53 864 dwarf_reg_to_regnum_or_error (arch, reg), offset);
bb2ec1b3
TT		 865 }
866 break;
867 case DW_OP_fbreg:
868 {
869 const gdb_byte *datastart;
870 size_t datalen;
871 const struct block *b;
872 struct symbol *framefunc;
873 char fb_name[50];
874
875 b = block_for_pc (pc);
876
877 if (!b)
878 error (_("No block found for address"));
879
880 framefunc = block_linkage_function (b);
881
882 if (!framefunc)
883 error (_("No function found for block"));
884
885 func_get_frame_base_dwarf_block (framefunc, pc,
886 &datastart, &datalen);
887
888 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
889
890 /* Generate a unique-enough name, in case the frame base
891 is computed multiple times in this expression. */
892 xsnprintf (fb_name, sizeof (fb_name), "__frame_base_%ld",
893 (long) (op_ptr - base));
894
895 do_compile_dwarf_expr_to_c (indent, stream,
3a9558c4 896 GCC_UINTPTR, fb_name,
bb2ec1b3
TT		 897 sym, pc,
898 arch, registers_used, addr_size,
899 datastart, datastart + datalen,
4b167ea1 900 NULL, per_cu, per_objfile);
bb2ec1b3
TT		 901
902 pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
903 }
904 break;
905
906 case DW_OP_dup:
907 pushf (indent, stream, "__gdb_stack[__gdb_tos]");
908 break;
909
910 case DW_OP_drop:
d82b3862 911 fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
bb2ec1b3
TT		 912 break;
913
914 case DW_OP_pick:
915 offset = *op_ptr++;
77b64a49
PA		 916 pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
917 plongest (offset));
bb2ec1b3
TT		 918 break;
919
920 case DW_OP_swap:
d82b3862 921 fprintfi_filtered (indent, stream,
bb2ec1b3 922 "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
d82b3862 923 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 924 "__gdb_stack[__gdb_tos - 1] = "
925 "__gdb_stack[__gdb_tos];\n");
d82b3862
SM		 926 fprintfi_filtered (indent, stream, ("__gdb_stack[__gdb_tos] = "
927 "__gdb_tmp;\n"));
bb2ec1b3
TT		 928 break;
929
930 case DW_OP_over:
931 pushf (indent, stream, "__gdb_stack[__gdb_tos - 1]");
932 break;
933
934 case DW_OP_rot:
d82b3862
SM		 935 fprintfi_filtered (indent, stream, ("__gdb_tmp = "
936 "__gdb_stack[__gdb_tos];\n"));
937 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 938 "__gdb_stack[__gdb_tos] = "
939 "__gdb_stack[__gdb_tos - 1];\n");
d82b3862 940 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 941 "__gdb_stack[__gdb_tos - 1] = "
942 "__gdb_stack[__gdb_tos -2];\n");
d82b3862 943 fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 2] = "
bb2ec1b3
TT		 944 "__gdb_tmp;\n");
945 break;
946
947 case DW_OP_deref:
948 case DW_OP_deref_size:
949 {
950 int size;
951 const char *mode;
952
953 if (op == DW_OP_deref_size)
954 size = *op_ptr++;
955 else
956 size = addr_size;
957
958 mode = c_get_mode_for_size (size);
959 if (mode == NULL)
960 error (_("Unsupported size %d in %s"),
961 size, get_DW_OP_name (op));
962
963 /* Cast to a pointer of the desired type, then
964 dereference. */
d82b3862 965 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 966 "__gdb_stack[__gdb_tos] = "
967 "*((__gdb_int_%s *) "
968 "__gdb_stack[__gdb_tos]);\n",
969 mode);
970 }
971 break;
972
973 case DW_OP_abs:
974 unary (indent, stream,
975 "((" GCC_INTPTR ") __gdb_stack[__gdb_tos]) < 0 ? "
976 "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
977 break;
978
979 case DW_OP_neg:
980 unary (indent, stream, "-__gdb_stack[__gdb_tos]");
981 break;
982
983 case DW_OP_not:
984 unary (indent, stream, "~__gdb_stack[__gdb_tos]");
985 break;
986
987 case DW_OP_plus_uconst:
988 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
989 unary (indent, stream, "__gdb_stack[__gdb_tos] + %s",
990 hex_string (reg));
991 break;
992
993 case DW_OP_div:
994 binary (indent, stream, ("((" GCC_INTPTR
995 ") __gdb_stack[__gdb_tos-1]) / (("
996 GCC_INTPTR ") __gdb_stack[__gdb_tos])"));
997 break;
998
999 case DW_OP_shra:
1000 binary (indent, stream,
1001 "((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) >> "
1002 "__gdb_stack[__gdb_tos]");
1003 break;
1004
1005#define BINARY(OP) \
77b64a49
PA		 1006 binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1007 " __gdb_stack[__gdb_tos]"); \
bb2ec1b3
TT		 1008 break
1009
1010 case DW_OP_and:
1011 BINARY (&);
1012 case DW_OP_minus:
1013 BINARY (-);
1014 case DW_OP_mod:
1015 BINARY (%);
1016 case DW_OP_mul:
1017 BINARY (*);
1018 case DW_OP_or:
1019 BINARY (|);
1020 case DW_OP_plus:
1021 BINARY (+);
1022 case DW_OP_shl:
1023 BINARY (<<);
1024 case DW_OP_shr:
1025 BINARY (>>);
1026 case DW_OP_xor:
1027 BINARY (^);
1028#undef BINARY
1029
1030#define COMPARE(OP) \
1031 binary (indent, stream, \
1032 "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP \
1033 " ((" GCC_INTPTR \
1034 ") __gdb_stack[__gdb_tos]))"); \
1035 break
1036
1037 case DW_OP_le:
1038 COMPARE (<=);
1039 case DW_OP_ge:
1040 COMPARE (>=);
1041 case DW_OP_eq:
1042 COMPARE (==);
1043 case DW_OP_lt:
1044 COMPARE (<);
1045 case DW_OP_gt:
1046 COMPARE (>);
1047 case DW_OP_ne:
1048 COMPARE (!=);
1049#undef COMPARE
1050
1051 case DW_OP_call_frame_cfa:
1052 {
1053 int regnum;
1054 CORE_ADDR text_offset;
1055 LONGEST off;
1056 const gdb_byte *cfa_start, *cfa_end;
1057
1058 if (dwarf2_fetch_cfa_info (arch, pc, per_cu,
1059 &regnum, &off,
1060 &text_offset, &cfa_start, &cfa_end))
1061 {
1062 /* Register. */
1063 pushf_register (indent, stream, registers_used, arch, regnum,
1064 off);
1065 }
1066 else
1067 {
1068 /* Another expression. */
1069 char cfa_name[50];
1070
1071 /* Generate a unique-enough name, in case the CFA is
1072 computed multiple times in this expression. */
1073 xsnprintf (cfa_name, sizeof (cfa_name),
1074 "__cfa_%ld", (long) (op_ptr - base));
1075
1076 do_compile_dwarf_expr_to_c (indent, stream,
3a9558c4 1077 GCC_UINTPTR, cfa_name,
bb2ec1b3
TT		 1078 sym, pc, arch, registers_used,
1079 addr_size,
1080 cfa_start, cfa_end,
4b167ea1 1081 &text_offset, per_cu, per_objfile);
77b64a49 1082 pushf (indent, stream, "%s", cfa_name);
bb2ec1b3
TT		 1083 }
1084 }
1085
1086 break;
1087
1088 case DW_OP_skip:
1089 offset = extract_signed_integer (op_ptr, 2, byte_order);
1090 op_ptr += 2;
d82b3862 1091 fprintfi_filtered (indent, stream, "goto ");
bb2ec1b3 1092 print_label (stream, scope, op_ptr + offset - base);
d82b3862 1093 stream->puts (";\n");
bb2ec1b3
TT		 1094 break;
1095
1096 case DW_OP_bra:
1097 offset = extract_signed_integer (op_ptr, 2, byte_order);
1098 op_ptr += 2;
d82b3862 1099 fprintfi_filtered (indent, stream,
bb2ec1b3
TT		 1100 "if ((( " GCC_INTPTR
1101 ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1102 print_label (stream, scope, op_ptr + offset - base);
d82b3862 1103 stream->puts (";\n");
bb2ec1b3
TT		 1104 break;
1105
1106 case DW_OP_nop:
1107 break;
1108
1109 default:
1110 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
1111 }
1112 }
1113
d82b3862 1114 fprintfi_filtered (indent, stream, "%s = __gdb_stack[__gdb_tos];\n",
3a9558c4 1115 result_name);
d82b3862 1116 fprintfi_filtered (indent - 2, stream, "}\n");
bb2ec1b3
TT		 1117}
1118
1119/* See compile.h. */
1120
1121void
d82b3862 1122compile_dwarf_expr_to_c (string_file *stream, const char *result_name,
bb2ec1b3
TT		 1123 struct symbol *sym, CORE_ADDR pc,
1124 struct gdbarch *arch, unsigned char *registers_used,
1125 unsigned int addr_size,
1126 const gdb_byte *op_ptr, const gdb_byte *op_end,
4b167ea1
SM		 1127 dwarf2_per_cu_data *per_cu,
1128 dwarf2_per_objfile *per_objfile)
bb2ec1b3 1129{
3a9558c4 1130 do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
bb2ec1b3 1131 arch, registers_used, addr_size, op_ptr, op_end,
4b167ea1 1132 NULL, per_cu, per_objfile);
bb2ec1b3
TT		 1133}
1134
1135/* See compile.h. */
1136
1137void
d82b3862 1138compile_dwarf_bounds_to_c (string_file *stream,
bb2ec1b3
TT		 1139 const char *result_name,
1140 const struct dynamic_prop *prop,
1141 struct symbol *sym, CORE_ADDR pc,
1142 struct gdbarch *arch, unsigned char *registers_used,
1143 unsigned int addr_size,
1144 const gdb_byte *op_ptr, const gdb_byte *op_end,
4b167ea1
SM		 1145 dwarf2_per_cu_data *per_cu,
1146 dwarf2_per_objfile *per_objfile)
bb2ec1b3
TT		 1147{
1148 do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
1149 sym, pc, arch, registers_used,
4b167ea1
SM		 1150 addr_size, op_ptr, op_end, NULL, per_cu,
1151 per_objfile);
bb2ec1b3 1152}
A mirror of the official binutils-gdb repository