GDB (xrefs)

compile-loc2c.c
Go to the documentation of this file.
1 /* Convert a DWARF location expression to C
2
3 Copyright (C) 2014-2018 Free Software Foundation, Inc.
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
34
35 /* Information about a given instruction. */
36
37 struct 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
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. */
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 a vector 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
72 static void
73 compute_stack_depth_worker (int start, int *need_tempvar,
74 std::vector<struct insn_info> *info,
75 std::vector<int> *to_do,
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 {
88 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
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:
326 case DW_OP_form_tls_address:
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)
337 to_do->push_back (offset);
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)
351 to_do->push_back (offset);
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
385 static int
386 compute_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 std::vector<struct insn_info> *info)
391 {
392 std::vector<int> to_do;
393 int stack_depth, i;
394
395 info->resize (op_end - op_ptr);
396
397 to_do.push_back (0);
398 (*info)[0].depth = initial_depth;
399 (*info)[0].visited = 1;
400
401 while (!to_do.empty ())
402 {
403 int ndx = to_do.back ();
404 to_do.pop_back ();
405
406 compute_stack_depth_worker (ndx, need_tempvar, info, &to_do,
407 byte_order, addr_size,
408 op_ptr, op_end);
409 }
410
411 stack_depth = 0;
412 *is_tls = 0;
413 for (i = 0; i < op_end - op_ptr; ++i)
414 {
415 if ((*info)[i].depth > stack_depth)
416 stack_depth = (*info)[i].depth;
417 if ((*info)[i].is_tls)
418 *is_tls = 1;
419 }
420
421 return stack_depth + 1;
422 }
423
424
425
426 #define GCC_UINTPTR "__gdb_uintptr"
427 #define GCC_INTPTR "__gdb_intptr"
428
429 /* Emit code to push a constant. */
430
431 static void
432 push (int indent, string_file &stream, ULONGEST l)
433 {
434 fprintfi_filtered (indent, &stream,
435 "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
436 hex_string (l));
437 }
438
439 /* Emit code to push an arbitrary expression. This works like
440 printf. */
441
442 static void pushf (int indent, string_file &stream, const char *format, ...)
443 ATTRIBUTE_PRINTF (3, 4);
444
445 static void
446 pushf (int indent, string_file &stream, const char *format, ...)
447 {
448 va_list args;
449
450 fprintfi_filtered (indent, &stream, "__gdb_stack[__gdb_tos + 1] = ");
451 va_start (args, format);
452 stream.vprintf (format, args);
453 va_end (args);
454 stream.puts (";\n");
455
456 fprintfi_filtered (indent, &stream, "++__gdb_tos;\n");
457 }
458
459 /* Emit code for a unary expression -- one which operates in-place on
460 the top-of-stack. This works like printf. */
461
462 static void unary (int indent, string_file &stream, const char *format, ...)
463 ATTRIBUTE_PRINTF (3, 4);
464
465 static void
466 unary (int indent, string_file &stream, const char *format, ...)
467 {
468 va_list args;
469
470 fprintfi_filtered (indent, &stream, "__gdb_stack[__gdb_tos] = ");
471 va_start (args, format);
472 stream.vprintf (format, args);
473 va_end (args);
474 stream.puts (";\n");
475 }
476
477 /* Emit code for a unary expression -- one which uses the top two
478 stack items, popping the topmost one. This works like printf. */
479 static void binary (int indent, string_file &stream, const char *format, ...)
480 ATTRIBUTE_PRINTF (3, 4);
481
482 static void
483 binary (int indent, string_file &stream, const char *format, ...)
484 {
485 va_list args;
486
487 fprintfi_filtered (indent, &stream, "__gdb_stack[__gdb_tos - 1] = ");
488 va_start (args, format);
489 stream.vprintf (format, args);
490 va_end (args);
491 stream.puts (";\n");
492 fprintfi_filtered (indent, &stream, "--__gdb_tos;\n");
493 }
494
495 /* Print the name of a label given its "SCOPE", an arbitrary integer
496 used for uniqueness, and its TARGET, the bytecode offset
497 corresponding to the label's point of definition. */
498
499 static void
500 print_label (string_file &stream, unsigned int scope, int target)
501 {
502 stream.printf ("__label_%u_%s", scope, pulongest (target));
503 }
504
505 /* Emit code that pushes a register's address on the stack.
506 REGISTERS_USED is an out parameter which is updated to note which
507 register was needed by this expression. */
508
509 static void
510 pushf_register_address (int indent, string_file &stream,
511 unsigned char *registers_used,
512 struct gdbarch *gdbarch, int regnum)
513 {
514 std::string regname = compile_register_name_mangled (gdbarch, regnum);
515
516 registers_used[regnum] = 1;
517 pushf (indent, stream,
518 "(" GCC_UINTPTR ") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
519 regname.c_str ());
520 }
521
522 /* Emit code that pushes a register's value on the stack.
523 REGISTERS_USED is an out parameter which is updated to note which
524 register was needed by this expression. OFFSET is added to the
525 register's value before it is pushed. */
526
527 static void
528 pushf_register (int indent, string_file &stream,
529 unsigned char *registers_used,
530 struct gdbarch *gdbarch, int regnum, uint64_t offset)
531 {
532 std::string regname = compile_register_name_mangled (gdbarch, regnum);
533
534 registers_used[regnum] = 1;
535 if (offset == 0)
536 pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
537 regname.c_str ());
538 else
539 pushf (indent, stream,
540 COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s + (" GCC_UINTPTR ") %s",
541 regname.c_str (), hex_string (offset));
542 }
543
544 /* Compile a DWARF expression to C code.
545
546 INDENT is the indentation level to use.
547 STREAM is the stream where the code should be written.
548
549 TYPE_NAME names the type of the result of the DWARF expression.
550 For locations this is "void *" but for array bounds it will be an
551 integer type.
552
553 RESULT_NAME is the name of a variable in the resulting C code. The
554 result of the expression will be assigned to this variable.
555
556 SYM is the symbol corresponding to this expression.
557 PC is the location at which the expression is being evaluated.
558 ARCH is the architecture to use.
559
560 REGISTERS_USED is an out parameter which is updated to note which
561 registers were needed by this expression.
562
563 ADDR_SIZE is the DWARF address size to use.
564
565 OPT_PTR and OP_END are the bounds of the DWARF expression.
566
567 If non-NULL, INITIAL points to an initial value to write to the
568 stack. If NULL, no initial value is written.
569
570 PER_CU is the per-CU object used for looking up various other
571 things. */
572
573 static void
574 do_compile_dwarf_expr_to_c (int indent, string_file &stream,
575 const char *type_name,
576 const char *result_name,
577 struct symbol *sym, CORE_ADDR pc,
578 struct gdbarch *arch,
579 unsigned char *registers_used,
580 unsigned int addr_size,
581 const gdb_byte *op_ptr, const gdb_byte *op_end,
582 CORE_ADDR *initial,
583 struct dwarf2_per_cu_data *per_cu)
584 {
585 /* We keep a counter so that labels and other objects we create have
586 unique names. */
587 static unsigned int scope;
588
589 enum bfd_endian byte_order = gdbarch_byte_order (arch);
590 const gdb_byte * const base = op_ptr;
591 int need_tempvar = 0;
592 int is_tls = 0;
593 std::vector<struct insn_info> info;
594 int stack_depth;
595
596 ++scope;
597
598 fprintfi_filtered (indent, &stream, "__attribute__ ((unused)) %s %s;\n",
599 type_name, result_name);
600 fprintfi_filtered (indent, &stream, "{\n");
601 indent += 2;
602
603 stack_depth = compute_stack_depth (byte_order, addr_size,
604 &need_tempvar, &is_tls,
605 op_ptr, op_end, initial != NULL,
606 &info);
607
608 /* This is a hack until we can add a feature to glibc to let us
609 properly generate code for TLS. You might think we could emit
610 the address in the ordinary course of translating
611 DW_OP_GNU_push_tls_address, but since the operand appears on the
612 stack, it is relatively hard to find, and the idea of calling
613 target_translate_tls_address with OFFSET==0 and then adding the
614 offset by hand seemed too hackish. */
615 if (is_tls)
616 {
617 struct frame_info *frame = get_selected_frame (NULL);
618 struct value *val;
619
620 if (frame == NULL)
621 error (_("Symbol \"%s\" cannot be used because "
622 "there is no selected frame"),
623 SYMBOL_PRINT_NAME (sym));
624
625 val = read_var_value (sym, NULL, frame);
626 if (VALUE_LVAL (val) != lval_memory)
627 error (_("Symbol \"%s\" cannot be used for compilation evaluation "
628 "as its address has not been found."),
629 SYMBOL_PRINT_NAME (sym));
630
631 warning (_("Symbol \"%s\" is thread-local and currently can only "
632 "be referenced from the current thread in "
633 "compiled code."),
634 SYMBOL_PRINT_NAME (sym));
635
636 fprintfi_filtered (indent, &stream, "%s = %s;\n",
637 result_name,
638 core_addr_to_string (value_address (val)));
639 fprintfi_filtered (indent - 2, &stream, "}\n");
640 return;
641 }
642
643 fprintfi_filtered (indent, &stream, GCC_UINTPTR " __gdb_stack[%d];\n",
644 stack_depth);
645
646 if (need_tempvar)
647 fprintfi_filtered (indent, &stream, GCC_UINTPTR " __gdb_tmp;\n");
648 fprintfi_filtered (indent, &stream, "int __gdb_tos = -1;\n");
649
650 if (initial != NULL)
651 pushf (indent, stream, "%s", core_addr_to_string (*initial));
652
653 while (op_ptr < op_end)
654 {
655 enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
656 uint64_t uoffset, reg;
657 int64_t offset;
658
659 print_spaces (indent - 2, &stream);
660 if (info[op_ptr - base].label)
661 {
662 print_label (stream, scope, op_ptr - base);
663 stream.puts (":;");
664 }
665 stream.printf ("/* %s */\n", get_DW_OP_name (op));
666
667 /* This is handy for debugging the generated code:
668 fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
669 (int) info[op_ptr - base].depth - 1);
670 */
671
672 ++op_ptr;
673
674 switch (op)
675 {
676 case DW_OP_lit0:
677 case DW_OP_lit1:
678 case DW_OP_lit2:
679 case DW_OP_lit3:
680 case DW_OP_lit4:
681 case DW_OP_lit5:
682 case DW_OP_lit6:
683 case DW_OP_lit7:
684 case DW_OP_lit8:
685 case DW_OP_lit9:
686 case DW_OP_lit10:
687 case DW_OP_lit11:
688 case DW_OP_lit12:
689 case DW_OP_lit13:
690 case DW_OP_lit14:
691 case DW_OP_lit15:
692 case DW_OP_lit16:
693 case DW_OP_lit17:
694 case DW_OP_lit18:
695 case DW_OP_lit19:
696 case DW_OP_lit20:
697 case DW_OP_lit21:
698 case DW_OP_lit22:
699 case DW_OP_lit23:
700 case DW_OP_lit24:
701 case DW_OP_lit25:
702 case DW_OP_lit26:
703 case DW_OP_lit27:
704 case DW_OP_lit28:
705 case DW_OP_lit29:
706 case DW_OP_lit30:
707 case DW_OP_lit31:
708 push (indent, stream, op - DW_OP_lit0);
709 break;
710
711 case DW_OP_addr:
712 uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
713 op_ptr += addr_size;
714 /* Some versions of GCC emit DW_OP_addr before
715 DW_OP_GNU_push_tls_address. In this case the value is an
716 index, not an address. We don't support things like
717 branching between the address and the TLS op. */
718 if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
719 uoffset += dwarf2_per_cu_text_offset (per_cu);
720 push (indent, stream, uoffset);
721 break;
722
723 case DW_OP_const1u:
724 push (indent, stream,
725 extract_unsigned_integer (op_ptr, 1, byte_order));
726 op_ptr += 1;
727 break;
728 case DW_OP_const1s:
729 push (indent, stream,
730 extract_signed_integer (op_ptr, 1, byte_order));
731 op_ptr += 1;
732 break;
733 case DW_OP_const2u:
734 push (indent, stream,
735 extract_unsigned_integer (op_ptr, 2, byte_order));
736 op_ptr += 2;
737 break;
738 case DW_OP_const2s:
739 push (indent, stream,
740 extract_signed_integer (op_ptr, 2, byte_order));
741 op_ptr += 2;
742 break;
743 case DW_OP_const4u:
744 push (indent, stream,
745 extract_unsigned_integer (op_ptr, 4, byte_order));
746 op_ptr += 4;
747 break;
748 case DW_OP_const4s:
749 push (indent, stream,
750 extract_signed_integer (op_ptr, 4, byte_order));
751 op_ptr += 4;
752 break;
753 case DW_OP_const8u:
754 push (indent, stream,
755 extract_unsigned_integer (op_ptr, 8, byte_order));
756 op_ptr += 8;
757 break;
758 case DW_OP_const8s:
759 push (indent, stream,
760 extract_signed_integer (op_ptr, 8, byte_order));
761 op_ptr += 8;
762 break;
763 case DW_OP_constu:
764 op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
765 push (indent, stream, uoffset);
766 break;
767 case DW_OP_consts:
768 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
769 push (indent, stream, offset);
770 break;
771
772 case DW_OP_reg0:
773 case DW_OP_reg1:
774 case DW_OP_reg2:
775 case DW_OP_reg3:
776 case DW_OP_reg4:
777 case DW_OP_reg5:
778 case DW_OP_reg6:
779 case DW_OP_reg7:
780 case DW_OP_reg8:
781 case DW_OP_reg9:
782 case DW_OP_reg10:
783 case DW_OP_reg11:
784 case DW_OP_reg12:
785 case DW_OP_reg13:
786 case DW_OP_reg14:
787 case DW_OP_reg15:
788 case DW_OP_reg16:
789 case DW_OP_reg17:
790 case DW_OP_reg18:
791 case DW_OP_reg19:
792 case DW_OP_reg20:
793 case DW_OP_reg21:
794 case DW_OP_reg22:
795 case DW_OP_reg23:
796 case DW_OP_reg24:
797 case DW_OP_reg25:
798 case DW_OP_reg26:
799 case DW_OP_reg27:
800 case DW_OP_reg28:
801 case DW_OP_reg29:
802 case DW_OP_reg30:
803 case DW_OP_reg31:
804 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
805 pushf_register_address (indent, stream, registers_used, arch,
806 dwarf_reg_to_regnum_or_error
807 (arch, op - DW_OP_reg0));
808 break;
809
810 case DW_OP_regx:
811 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
812 dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
813 pushf_register_address (indent, stream, registers_used, arch,
814 dwarf_reg_to_regnum_or_error (arch, reg));
815 break;
816
817 case DW_OP_breg0:
818 case DW_OP_breg1:
819 case DW_OP_breg2:
820 case DW_OP_breg3:
821 case DW_OP_breg4:
822 case DW_OP_breg5:
823 case DW_OP_breg6:
824 case DW_OP_breg7:
825 case DW_OP_breg8:
826 case DW_OP_breg9:
827 case DW_OP_breg10:
828 case DW_OP_breg11:
829 case DW_OP_breg12:
830 case DW_OP_breg13:
831 case DW_OP_breg14:
832 case DW_OP_breg15:
833 case DW_OP_breg16:
834 case DW_OP_breg17:
835 case DW_OP_breg18:
836 case DW_OP_breg19:
837 case DW_OP_breg20:
838 case DW_OP_breg21:
839 case DW_OP_breg22:
840 case DW_OP_breg23:
841 case DW_OP_breg24:
842 case DW_OP_breg25:
843 case DW_OP_breg26:
844 case DW_OP_breg27:
845 case DW_OP_breg28:
846 case DW_OP_breg29:
847 case DW_OP_breg30:
848 case DW_OP_breg31:
849 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
850 pushf_register (indent, stream, registers_used, arch,
851 dwarf_reg_to_regnum_or_error (arch,
852 op - DW_OP_breg0),
853 offset);
854 break;
855 case DW_OP_bregx:
856 {
857 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
858 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
859 pushf_register (indent, stream, registers_used, arch,
860 dwarf_reg_to_regnum_or_error (arch, reg), offset);
861 }
862 break;
863 case DW_OP_fbreg:
864 {
865 const gdb_byte *datastart;
866 size_t datalen;
867 const struct block *b;
868 struct symbol *framefunc;
869 char fb_name[50];
870
871 b = block_for_pc (pc);
872
873 if (!b)
874 error (_("No block found for address"));
875
876 framefunc = block_linkage_function (b);
877
878 if (!framefunc)
879 error (_("No function found for block"));
880
881 func_get_frame_base_dwarf_block (framefunc, pc,
882 &datastart, &datalen);
883
884 op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
885
886 /* Generate a unique-enough name, in case the frame base
887 is computed multiple times in this expression. */
888 xsnprintf (fb_name, sizeof (fb_name), "__frame_base_%ld",
889 (long) (op_ptr - base));
890
891 do_compile_dwarf_expr_to_c (indent, stream,
892 GCC_UINTPTR, fb_name,
893 sym, pc,
894 arch, registers_used, addr_size,
895 datastart, datastart + datalen,
896 NULL, per_cu);
897
898 pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
899 }
900 break;
901
902 case DW_OP_dup:
903 pushf (indent, stream, "__gdb_stack[__gdb_tos]");
904 break;
905
906 case DW_OP_drop:
907 fprintfi_filtered (indent, &stream, "--__gdb_tos;\n");
908 break;
909
910 case DW_OP_pick:
911 offset = *op_ptr++;
912 pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
913 plongest (offset));
914 break;
915
916 case DW_OP_swap:
917 fprintfi_filtered (indent, &stream,
918 "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
919 fprintfi_filtered (indent, &stream,
920 "__gdb_stack[__gdb_tos - 1] = "
921 "__gdb_stack[__gdb_tos];\n");
922 fprintfi_filtered (indent, &stream, ("__gdb_stack[__gdb_tos] = "
923 "__gdb_tmp;\n"));
924 break;
925
926 case DW_OP_over:
927 pushf (indent, stream, "__gdb_stack[__gdb_tos - 1]");
928 break;
929
930 case DW_OP_rot:
931 fprintfi_filtered (indent, &stream, ("__gdb_tmp = "
932 "__gdb_stack[__gdb_tos];\n"));
933 fprintfi_filtered (indent, &stream,
934 "__gdb_stack[__gdb_tos] = "
935 "__gdb_stack[__gdb_tos - 1];\n");
936 fprintfi_filtered (indent, &stream,
937 "__gdb_stack[__gdb_tos - 1] = "
938 "__gdb_stack[__gdb_tos -2];\n");
939 fprintfi_filtered (indent, &stream, "__gdb_stack[__gdb_tos - 2] = "
940 "__gdb_tmp;\n");
941 break;
942
943 case DW_OP_deref:
944 case DW_OP_deref_size:
945 {
946 int size;
947 const char *mode;
948
949 if (op == DW_OP_deref_size)
950 size = *op_ptr++;
951 else
952 size = addr_size;
953
954 mode = c_get_mode_for_size (size);
955 if (mode == NULL)
956 error (_("Unsupported size %d in %s"),
957 size, get_DW_OP_name (op));
958
959 /* Cast to a pointer of the desired type, then
960 dereference. */
961 fprintfi_filtered (indent, &stream,
962 "__gdb_stack[__gdb_tos] = "
963 "*((__gdb_int_%s *) "
964 "__gdb_stack[__gdb_tos]);\n",
965 mode);
966 }
967 break;
968
969 case DW_OP_abs:
970 unary (indent, stream,
971 "((" GCC_INTPTR ") __gdb_stack[__gdb_tos]) < 0 ? "
972 "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
973 break;
974
975 case DW_OP_neg:
976 unary (indent, stream, "-__gdb_stack[__gdb_tos]");
977 break;
978
979 case DW_OP_not:
980 unary (indent, stream, "~__gdb_stack[__gdb_tos]");
981 break;
982
983 case DW_OP_plus_uconst:
984 op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
985 unary (indent, stream, "__gdb_stack[__gdb_tos] + %s",
986 hex_string (reg));
987 break;
988
989 case DW_OP_div:
990 binary (indent, stream, ("((" GCC_INTPTR
991 ") __gdb_stack[__gdb_tos-1]) / (("
992 GCC_INTPTR ") __gdb_stack[__gdb_tos])"));
993 break;
994
995 case DW_OP_shra:
996 binary (indent, stream,
997 "((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) >> "
998 "__gdb_stack[__gdb_tos]");
999 break;
1000
1001 #define BINARY(OP) \
1002 binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1003 " __gdb_stack[__gdb_tos]"); \
1004 break
1005
1006 case DW_OP_and:
1007 BINARY (&);
1008 case DW_OP_minus:
1009 BINARY (-);
1010 case DW_OP_mod:
1011 BINARY (%);
1012 case DW_OP_mul:
1013 BINARY (*);
1014 case DW_OP_or:
1015 BINARY (|);
1016 case DW_OP_plus:
1017 BINARY (+);
1018 case DW_OP_shl:
1019 BINARY (<<);
1020 case DW_OP_shr:
1021 BINARY (>>);
1022 case DW_OP_xor:
1023 BINARY (^);
1024 #undef BINARY
1025
1026 #define COMPARE(OP) \
1027 binary (indent, stream, \
1028 "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP \
1029 " ((" GCC_INTPTR \
1030 ") __gdb_stack[__gdb_tos]))"); \
1031 break
1032
1033 case DW_OP_le:
1034 COMPARE (<=);
1035 case DW_OP_ge:
1036 COMPARE (>=);
1037 case DW_OP_eq:
1038 COMPARE (==);
1039 case DW_OP_lt:
1040 COMPARE (<);
1041 case DW_OP_gt:
1042 COMPARE (>);
1043 case DW_OP_ne:
1044 COMPARE (!=);
1045 #undef COMPARE
1046
1047 case DW_OP_call_frame_cfa:
1048 {
1049 int regnum;
1050 CORE_ADDR text_offset;
1051 LONGEST off;
1052 const gdb_byte *cfa_start, *cfa_end;
1053
1054 if (dwarf2_fetch_cfa_info (arch, pc, per_cu,
1055 &regnum, &off,
1056 &text_offset, &cfa_start, &cfa_end))
1057 {
1058 /* Register. */
1059 pushf_register (indent, stream, registers_used, arch, regnum,
1060 off);
1061 }
1062 else
1063 {
1064 /* Another expression. */
1065 char cfa_name[50];
1066
1067 /* Generate a unique-enough name, in case the CFA is
1068 computed multiple times in this expression. */
1069 xsnprintf (cfa_name, sizeof (cfa_name),
1070 "__cfa_%ld", (long) (op_ptr - base));
1071
1072 do_compile_dwarf_expr_to_c (indent, stream,
1073 GCC_UINTPTR, cfa_name,
1074 sym, pc, arch, registers_used,
1075 addr_size,
1076 cfa_start, cfa_end,
1077 &text_offset, per_cu);
1078 pushf (indent, stream, "%s", cfa_name);
1079 }
1080 }
1081
1082 break;
1083
1084 case DW_OP_skip:
1085 offset = extract_signed_integer (op_ptr, 2, byte_order);
1086 op_ptr += 2;
1087 fprintfi_filtered (indent, &stream, "goto ");
1088 print_label (stream, scope, op_ptr + offset - base);
1089 stream.puts (";\n");
1090 break;
1091
1092 case DW_OP_bra:
1093 offset = extract_signed_integer (op_ptr, 2, byte_order);
1094 op_ptr += 2;
1095 fprintfi_filtered (indent, &stream,
1096 "if ((( " GCC_INTPTR
1097 ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1098 print_label (stream, scope, op_ptr + offset - base);
1099 stream.puts (";\n");
1100 break;
1101
1102 case DW_OP_nop:
1103 break;
1104
1105 default:
1106 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
1107 }
1108 }
1109
1110 fprintfi_filtered (indent, &stream, "%s = __gdb_stack[__gdb_tos];\n",
1111 result_name);
1112 fprintfi_filtered (indent - 2, &stream, "}\n");
1113 }
1114
1115 /* See compile.h. */
1116
1117 void
1118 compile_dwarf_expr_to_c (string_file &stream, const char *result_name,
1119 struct symbol *sym, CORE_ADDR pc,
1120 struct gdbarch *arch, unsigned char *registers_used,
1121 unsigned int addr_size,
1122 const gdb_byte *op_ptr, const gdb_byte *op_end,
1123 struct dwarf2_per_cu_data *per_cu)
1124 {
1125 do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
1126 arch, registers_used, addr_size, op_ptr, op_end,
1127 NULL, per_cu);
1128 }
1129
1130 /* See compile.h. */
1131
1132 void
1133 compile_dwarf_bounds_to_c (string_file &stream,
1134 const char *result_name,
1135 const struct dynamic_prop *prop,
1136 struct symbol *sym, CORE_ADDR pc,
1137 struct gdbarch *arch, unsigned char *registers_used,
1138 unsigned int addr_size,
1139 const gdb_byte *op_ptr, const gdb_byte *op_end,
1140 struct dwarf2_per_cu_data *per_cu)
1141 {
1142 do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
1143 sym, pc, arch, registers_used,
1144 addr_size, op_ptr, op_end, NULL, per_cu);
1145 }
gdbarch
Definition: gdbarch.c:127
string
const char * string
Definition: signals.c:50
hex_string
char * hex_string(LONGEST num)
Definition: print-utils.c:220
insn_info::is_tls
unsigned int is_tls
Definition: compile-loc2c.c:55
insn_info
Definition: compile-loc2c.c:37
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
dwarf2_fetch_cfa_info
int dwarf2_fetch_cfa_info(struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_per_cu_data *data, int *regnum_out, LONGEST *offset_out, CORE_ADDR *text_offset_out, const gdb_byte **cfa_start_out, const gdb_byte **cfa_end_out)
Definition: dwarf2-frame.c:862
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
COMPARE
#define COMPARE(OP)
compile_dwarf_bounds_to_c
void compile_dwarf_bounds_to_c(string_file &stream, const char *result_name, const struct dynamic_prop *prop, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
Definition: compile-loc2c.c:1133
warning
void warning(const char *fmt,...)
Definition: errors.c:26
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
print_spaces
void print_spaces(int n, struct ui_file *file)
Definition: utils.c:810
block_linkage_function
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
frame_info
Definition: frame.c:85
push
static void push(int indent, string_file &stream, ULONGEST l)
Definition: compile-loc2c.c:432
dwarf_expr_require_composition
void dwarf_expr_require_composition(const gdb_byte *op_ptr, const gdb_byte *op_end, const char *op_name)
Definition: dwarf2expr.c:347
safe_read_uleb128
const gdb_byte * safe_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.c:311
dynamic_prop
Definition: gdbtypes.h:398
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
pushf
static void pushf(int indent, string_file &stream, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: compile-loc2c.c:446
compute_stack_depth_worker
static void compute_stack_depth_worker(int start, int *need_tempvar, std::vector< struct insn_info > *info, std::vector< int > *to_do, enum bfd_endian byte_order, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end)
Definition: compile-loc2c.c:73
VALUE_LVAL
#define VALUE_LVAL(val)
Definition: value.h:414
GCC_UINTPTR
#define GCC_UINTPTR
Definition: compile-loc2c.c:426
block_for_pc
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
utils.h
dwarf2expr.h
lval_memory
Definition: defs.h:383
insn_info::depth
unsigned int depth
Definition: compile-loc2c.c:41
binary
static void binary(int indent, string_file &stream, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: compile-loc2c.c:483
dwarf_reg_to_regnum_or_error
int dwarf_reg_to_regnum_or_error(struct gdbarch *arch, ULONGEST dwarf_reg)
Definition: dwarf2loc.c:2920
value::reg
struct value::@186::@187 reg
read_var_value
struct value * read_var_value(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:807
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
print_label
static void print_label(string_file &stream, unsigned int scope, int target)
Definition: compile-loc2c.c:500
COMPILE_I_SIMPLE_REGISTER_ARG_NAME
#define COMPILE_I_SIMPLE_REGISTER_ARG_NAME
Definition: compile-internal.h:89
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
pulongest
char * pulongest(ULONGEST u)
Definition: print-utils.c:129
ATTRIBUTE_PRINTF
#define ATTRIBUTE_PRINTF
Definition: common-defs.h:70
do_compile_dwarf_expr_to_c
static void do_compile_dwarf_expr_to_c(int indent, string_file &stream, const char *type_name, const char *result_name, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, CORE_ADDR *initial, struct dwarf2_per_cu_data *per_cu)
Definition: compile-loc2c.c:574
pushf_register
static void pushf_register(int indent, string_file &stream, unsigned char *registers_used, struct gdbarch *gdbarch, int regnum, uint64_t offset)
Definition: compile-loc2c.c:528
dwarf2_per_cu_text_offset
CORE_ADDR dwarf2_per_cu_text_offset(struct dwarf2_per_cu_data *cu)
Definition: dwarf2read.c:24898
regnum
int regnum
Definition: aarch64-tdep.c:77
c_get_mode_for_size
const char * c_get_mode_for_size(int size)
Definition: compile-c-support.c:34
ui_file::puts
virtual void puts(const char *str)
Definition: ui-file.h:63
GCC_INTPTR
#define GCC_INTPTR
Definition: compile-loc2c.c:427
dwarf2loc.h
safe_read_sleb128
const gdb_byte * safe_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
Definition: dwarf2expr.c:323
reg
Definition: regdef.h:22
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
value
Definition: value.c:169
fprintfi_filtered
void fprintfi_filtered(int spaces, struct ui_file *stream, const char *format,...)
Definition: utils.c:2031
ui_file::printf
void printf(const char *,...) ATTRIBUTE_PRINTF(2
Definition: ui-file.c:37
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
compile.h
dwarf2-frame.h
compile_register_name_mangled
std::string compile_register_name_mangled(struct gdbarch *gdbarch, int regnum)
Definition: compile.c:651
func_get_frame_base_dwarf_block
void func_get_frame_base_dwarf_block(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: dwarf2loc.c:508
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
SET_CHECK_DEPTH
#define SET_CHECK_DEPTH(WHERE)
compile-internal.h
compile_dwarf_expr_to_c
void compile_dwarf_expr_to_c(string_file &stream, const char *result_name, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
Definition: compile-loc2c.c:1118
offset
int offset
Definition: agent.c:65
gdb_vecs.h
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
value.h
symbol::arch
struct gdbarch * arch
Definition: symtab.h:1071
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
insn_info::label
unsigned int label
Definition: compile-loc2c.c:49
symbol
Definition: symtab.h:1049
core_addr_to_string
const char * core_addr_to_string(const CORE_ADDR addr)
Definition: print-utils.c:295
BINARY
#define BINARY(OP)
compute_stack_depth
static int compute_stack_depth(enum bfd_endian byte_order, unsigned int addr_size, int *need_tempvar, int *is_tls, const gdb_byte *op_ptr, const gdb_byte *op_end, int initial_depth, std::vector< struct insn_info > *info)
Definition: compile-loc2c.c:386
value_address
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1529
insn_info::visited
unsigned int visited
Definition: compile-loc2c.c:45
unary
static void unary(int indent, string_file &stream, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: compile-loc2c.c:466
error
void error(const char *fmt,...)
Definition: errors.c:38
dwarf2_per_cu_data
Definition: dwarf2read.c:781
size
size_t size
Definition: go32-nat.c:242
pushf_register_address
static void pushf_register_address(int indent, string_file &stream, unsigned char *registers_used, struct gdbarch *gdbarch, int regnum)
Definition: compile-loc2c.c:510
block.h
LONGEST
long long LONGEST
Definition: common-types.h:52
string_file
Definition: ui-file.h:106
ui-file.h