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