1 /* Convert a DWARF location expression to C
3 Copyright (C) 2014-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "dwarf2/expr.h"
23 #include "dwarf2/loc.h"
24 #include "dwarf2/read.h"
27 #include "compile-internal.h"
28 #include "compile-c.h"
31 #include "dwarf2/frame.h"
32 #include "gdbsupport/gdb_vecs.h"
38 /* Information about a given instruction. */
42 /* Stack depth at entry. */
46 /* Whether this instruction has been visited. */
48 unsigned int visited
: 1;
50 /* Whether this instruction needs a label. */
52 unsigned int label
: 1;
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. */
58 unsigned int is_tls
: 1;
61 /* A helper function for compute_stack_depth that does the work. This
62 examines the DWARF expression starting from START and computes
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
68 INFO is a vector of insn_info objects, indexed by offset from the
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. */
76 compute_stack_depth_worker (int start
, int *need_tempvar
,
77 std::vector
<struct insn_info
> *info
,
78 std::vector
<int> *to_do
,
79 enum bfd_endian byte_order
, unsigned int addr_size
,
80 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
)
82 const gdb_byte
* const base
= op_ptr
;
86 gdb_assert ((*info
)[start
].visited
);
87 stack_depth
= (*info
)[start
].depth
;
89 while (op_ptr
< op_end
)
91 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
94 int ndx
= op_ptr
- base
;
96 #define SET_CHECK_DEPTH(WHERE) \
97 if ((*info)[WHERE].visited) \
99 if ((*info)[WHERE].depth != stack_depth) \
100 error (_("inconsistent stack depths")); \
104 /* Stack depth not set, so set it. */ \
105 (*info)[WHERE].visited = 1; \
106 (*info)[WHERE].depth = stack_depth; \
109 SET_CHECK_DEPTH (ndx
);
177 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
217 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
253 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
258 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
259 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
264 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
296 case DW_OP_deref_size
:
300 case DW_OP_plus_uconst
:
301 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
324 case DW_OP_call_frame_cfa
:
328 case DW_OP_GNU_push_tls_address
:
329 case DW_OP_form_tls_address
:
330 (*info
)[ndx
].is_tls
= 1;
334 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
336 offset
= op_ptr
+ offset
- base
;
337 /* If the destination has not been seen yet, add it to the
339 if (!(*info
)[offset
].visited
)
340 to_do
->push_back (offset
);
341 SET_CHECK_DEPTH (offset
);
342 (*info
)[offset
].label
= 1;
343 /* We're done with this line of code. */
347 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
349 offset
= op_ptr
+ offset
- base
;
351 /* If the destination has not been seen yet, add it to the
353 if (!(*info
)[offset
].visited
)
354 to_do
->push_back (offset
);
355 SET_CHECK_DEPTH (offset
);
356 (*info
)[offset
].label
= 1;
363 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op
));
367 gdb_assert (op_ptr
== op_end
);
369 #undef SET_CHECK_DEPTH
372 /* Compute the maximum needed stack depth of a DWARF expression, and
373 some other information as well.
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
379 IS_TLS is an out parameter which is set if this expression refers
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.
386 This returns the maximum stack depth. */
389 compute_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
,
393 std::vector
<struct insn_info
> *info
)
395 std::vector
<int> to_do
;
398 info
->resize (op_end
- op_ptr
);
401 (*info
)[0].depth
= initial_depth
;
402 (*info
)[0].visited
= 1;
404 while (!to_do
.empty ())
406 int ndx
= to_do
.back ();
409 compute_stack_depth_worker (ndx
, need_tempvar
, info
, &to_do
,
410 byte_order
, addr_size
,
416 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
418 if ((*info
)[i
].depth
> stack_depth
)
419 stack_depth
= (*info
)[i
].depth
;
420 if ((*info
)[i
].is_tls
)
424 return stack_depth
+ 1;
429 #define GCC_UINTPTR "__gdb_uintptr"
430 #define GCC_INTPTR "__gdb_intptr"
432 /* Emit code to push a constant. */
435 push (int indent
, string_file
*stream
, ULONGEST l
)
437 fprintfi_filtered (indent
, stream
,
438 "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR
") %s;\n",
442 /* Emit code to push an arbitrary expression. This works like
445 static void pushf (int indent
, string_file
*stream
, const char *format
, ...)
446 ATTRIBUTE_PRINTF (3, 4);
449 pushf (int indent
, string_file
*stream
, const char *format
, ...)
453 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos + 1] = ");
454 va_start (args
, format
);
455 stream
->vprintf (format
, args
);
457 stream
->puts (";\n");
459 fprintfi_filtered (indent
, stream
, "++__gdb_tos;\n");
462 /* Emit code for a unary expression -- one which operates in-place on
463 the top-of-stack. This works like printf. */
465 static void unary (int indent
, string_file
*stream
, const char *format
, ...)
466 ATTRIBUTE_PRINTF (3, 4);
469 unary (int indent
, string_file
*stream
, const char *format
, ...)
473 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos] = ");
474 va_start (args
, format
);
475 stream
->vprintf (format
, args
);
477 stream
->puts (";\n");
480 /* Emit code for a unary expression -- one which uses the top two
481 stack items, popping the topmost one. This works like printf. */
482 static void binary (int indent
, string_file
*stream
, const char *format
, ...)
483 ATTRIBUTE_PRINTF (3, 4);
486 binary (int indent
, string_file
*stream
, const char *format
, ...)
490 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos - 1] = ");
491 va_start (args
, format
);
492 stream
->vprintf (format
, args
);
494 stream
->puts (";\n");
495 fprintfi_filtered (indent
, stream
, "--__gdb_tos;\n");
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. */
503 print_label (string_file
*stream
, unsigned int scope
, int target
)
505 stream
->printf ("__label_%u_%s", scope
, pulongest (target
));
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. */
513 pushf_register_address (int indent
, string_file
*stream
,
514 unsigned char *registers_used
,
515 struct gdbarch
*gdbarch
, int regnum
)
517 std::string regname
= compile_register_name_mangled (gdbarch
, regnum
);
519 registers_used
[regnum
] = 1;
520 pushf (indent
, stream
,
521 "(" GCC_UINTPTR
") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME
"->%s",
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. */
531 pushf_register (int indent
, string_file
*stream
,
532 unsigned char *registers_used
,
533 struct gdbarch
*gdbarch
, int regnum
, uint64_t offset
)
535 std::string regname
= compile_register_name_mangled (gdbarch
, regnum
);
537 registers_used
[regnum
] = 1;
539 pushf (indent
, stream
, COMPILE_I_SIMPLE_REGISTER_ARG_NAME
"->%s",
542 pushf (indent
, stream
,
543 COMPILE_I_SIMPLE_REGISTER_ARG_NAME
"->%s + (" GCC_UINTPTR
") %s",
544 regname
.c_str (), hex_string (offset
));
547 /* Compile a DWARF expression to C code.
549 INDENT is the indentation level to use.
550 STREAM is the stream where the code should be written.
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
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.
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.
563 REGISTERS_USED is an out parameter which is updated to note which
564 registers were needed by this expression.
566 ADDR_SIZE is the DWARF address size to use.
568 OPT_PTR and OP_END are the bounds of the DWARF expression.
570 If non-NULL, INITIAL points to an initial value to write to the
571 stack. If NULL, no initial value is written.
573 PER_CU is the per-CU object used for looking up various other
577 do_compile_dwarf_expr_to_c (int indent
, string_file
*stream
,
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
,
586 struct dwarf2_per_cu_data
*per_cu
)
588 /* We keep a counter so that labels and other objects we create have
590 static unsigned int scope
;
592 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
593 const gdb_byte
* const base
= op_ptr
;
594 int need_tempvar
= 0;
596 std::vector
<struct insn_info
> info
;
601 fprintfi_filtered (indent
, stream
, "__attribute__ ((unused)) %s %s;\n",
602 type_name
, result_name
);
603 fprintfi_filtered (indent
, stream
, "{\n");
606 stack_depth
= compute_stack_depth (byte_order
, addr_size
,
607 &need_tempvar
, &is_tls
,
608 op_ptr
, op_end
, initial
!= NULL
,
611 /* This is a hack until we can add a feature to glibc to let us
612 properly generate code for TLS. You might think we could emit
613 the address in the ordinary course of translating
614 DW_OP_GNU_push_tls_address, but since the operand appears on the
615 stack, it is relatively hard to find, and the idea of calling
616 target_translate_tls_address with OFFSET==0 and then adding the
617 offset by hand seemed too hackish. */
620 struct frame_info
*frame
= get_selected_frame (NULL
);
624 error (_("Symbol \"%s\" cannot be used because "
625 "there is no selected frame"),
628 val
= read_var_value (sym
, NULL
, frame
);
629 if (VALUE_LVAL (val
) != lval_memory
)
630 error (_("Symbol \"%s\" cannot be used for compilation evaluation "
631 "as its address has not been found."),
634 warning (_("Symbol \"%s\" is thread-local and currently can only "
635 "be referenced from the current thread in "
639 fprintfi_filtered (indent
, stream
, "%s = %s;\n",
641 core_addr_to_string (value_address (val
)));
642 fprintfi_filtered (indent
- 2, stream
, "}\n");
646 fprintfi_filtered (indent
, stream
, GCC_UINTPTR
" __gdb_stack[%d];\n",
650 fprintfi_filtered (indent
, stream
, GCC_UINTPTR
" __gdb_tmp;\n");
651 fprintfi_filtered (indent
, stream
, "int __gdb_tos = -1;\n");
654 pushf (indent
, stream
, "%s", core_addr_to_string (*initial
));
656 while (op_ptr
< op_end
)
658 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
659 uint64_t uoffset
, reg
;
662 print_spaces (indent
- 2, stream
);
663 if (info
[op_ptr
- base
].label
)
665 print_label (stream
, scope
, op_ptr
- base
);
668 stream
->printf ("/* %s */\n", get_DW_OP_name (op
));
670 /* This is handy for debugging the generated code:
671 fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
672 (int) info[op_ptr - base].depth - 1);
711 push (indent
, stream
, op
- DW_OP_lit0
);
715 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
717 /* Some versions of GCC emit DW_OP_addr before
718 DW_OP_GNU_push_tls_address. In this case the value is an
719 index, not an address. We don't support things like
720 branching between the address and the TLS op. */
721 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
722 uoffset
+= per_cu
->text_offset ();
723 push (indent
, stream
, uoffset
);
727 push (indent
, stream
,
728 extract_unsigned_integer (op_ptr
, 1, byte_order
));
732 push (indent
, stream
,
733 extract_signed_integer (op_ptr
, 1, byte_order
));
737 push (indent
, stream
,
738 extract_unsigned_integer (op_ptr
, 2, byte_order
));
742 push (indent
, stream
,
743 extract_signed_integer (op_ptr
, 2, byte_order
));
747 push (indent
, stream
,
748 extract_unsigned_integer (op_ptr
, 4, byte_order
));
752 push (indent
, stream
,
753 extract_signed_integer (op_ptr
, 4, byte_order
));
757 push (indent
, stream
,
758 extract_unsigned_integer (op_ptr
, 8, byte_order
));
762 push (indent
, stream
,
763 extract_signed_integer (op_ptr
, 8, byte_order
));
767 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
768 push (indent
, stream
, uoffset
);
771 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
772 push (indent
, stream
, offset
);
807 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
808 pushf_register_address (indent
, stream
, registers_used
, arch
,
809 dwarf_reg_to_regnum_or_error
810 (arch
, op
- DW_OP_reg0
));
814 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
815 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
816 pushf_register_address (indent
, stream
, registers_used
, arch
,
817 dwarf_reg_to_regnum_or_error (arch
, reg
));
852 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
853 pushf_register (indent
, stream
, registers_used
, arch
,
854 dwarf_reg_to_regnum_or_error (arch
,
860 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
861 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
862 pushf_register (indent
, stream
, registers_used
, arch
,
863 dwarf_reg_to_regnum_or_error (arch
, reg
), offset
);
868 const gdb_byte
*datastart
;
870 const struct block
*b
;
871 struct symbol
*framefunc
;
874 b
= block_for_pc (pc
);
877 error (_("No block found for address"));
879 framefunc
= block_linkage_function (b
);
882 error (_("No function found for block"));
884 func_get_frame_base_dwarf_block (framefunc
, pc
,
885 &datastart
, &datalen
);
887 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
889 /* Generate a unique-enough name, in case the frame base
890 is computed multiple times in this expression. */
891 xsnprintf (fb_name
, sizeof (fb_name
), "__frame_base_%ld",
892 (long) (op_ptr
- base
));
894 do_compile_dwarf_expr_to_c (indent
, stream
,
895 GCC_UINTPTR
, fb_name
,
897 arch
, registers_used
, addr_size
,
898 datastart
, datastart
+ datalen
,
901 pushf (indent
, stream
, "%s + %s", fb_name
, hex_string (offset
));
906 pushf (indent
, stream
, "__gdb_stack[__gdb_tos]");
910 fprintfi_filtered (indent
, stream
, "--__gdb_tos;\n");
915 pushf (indent
, stream
, "__gdb_stack[__gdb_tos - %s]",
920 fprintfi_filtered (indent
, stream
,
921 "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
922 fprintfi_filtered (indent
, stream
,
923 "__gdb_stack[__gdb_tos - 1] = "
924 "__gdb_stack[__gdb_tos];\n");
925 fprintfi_filtered (indent
, stream
, ("__gdb_stack[__gdb_tos] = "
930 pushf (indent
, stream
, "__gdb_stack[__gdb_tos - 1]");
934 fprintfi_filtered (indent
, stream
, ("__gdb_tmp = "
935 "__gdb_stack[__gdb_tos];\n"));
936 fprintfi_filtered (indent
, stream
,
937 "__gdb_stack[__gdb_tos] = "
938 "__gdb_stack[__gdb_tos - 1];\n");
939 fprintfi_filtered (indent
, stream
,
940 "__gdb_stack[__gdb_tos - 1] = "
941 "__gdb_stack[__gdb_tos -2];\n");
942 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos - 2] = "
947 case DW_OP_deref_size
:
952 if (op
== DW_OP_deref_size
)
957 mode
= c_get_mode_for_size (size
);
959 error (_("Unsupported size %d in %s"),
960 size
, get_DW_OP_name (op
));
962 /* Cast to a pointer of the desired type, then
964 fprintfi_filtered (indent
, stream
,
965 "__gdb_stack[__gdb_tos] = "
966 "*((__gdb_int_%s *) "
967 "__gdb_stack[__gdb_tos]);\n",
973 unary (indent
, stream
,
974 "((" GCC_INTPTR
") __gdb_stack[__gdb_tos]) < 0 ? "
975 "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
979 unary (indent
, stream
, "-__gdb_stack[__gdb_tos]");
983 unary (indent
, stream
, "~__gdb_stack[__gdb_tos]");
986 case DW_OP_plus_uconst
:
987 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
988 unary (indent
, stream
, "__gdb_stack[__gdb_tos] + %s",
993 binary (indent
, stream
, ("((" GCC_INTPTR
994 ") __gdb_stack[__gdb_tos-1]) / (("
995 GCC_INTPTR
") __gdb_stack[__gdb_tos])"));
999 binary (indent
, stream
,
1000 "((" GCC_INTPTR
") __gdb_stack[__gdb_tos-1]) >> "
1001 "__gdb_stack[__gdb_tos]");
1004 #define BINARY(OP) \
1005 binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1006 " __gdb_stack[__gdb_tos]"); \
1029 #define COMPARE(OP) \
1030 binary (indent, stream, \
1031 "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP \
1033 ") __gdb_stack[__gdb_tos]))"); \
1050 case DW_OP_call_frame_cfa
:
1053 CORE_ADDR text_offset
;
1055 const gdb_byte
*cfa_start
, *cfa_end
;
1057 if (dwarf2_fetch_cfa_info (arch
, pc
, per_cu
,
1059 &text_offset
, &cfa_start
, &cfa_end
))
1062 pushf_register (indent
, stream
, registers_used
, arch
, regnum
,
1067 /* Another expression. */
1070 /* Generate a unique-enough name, in case the CFA is
1071 computed multiple times in this expression. */
1072 xsnprintf (cfa_name
, sizeof (cfa_name
),
1073 "__cfa_%ld", (long) (op_ptr
- base
));
1075 do_compile_dwarf_expr_to_c (indent
, stream
,
1076 GCC_UINTPTR
, cfa_name
,
1077 sym
, pc
, arch
, registers_used
,
1080 &text_offset
, per_cu
);
1081 pushf (indent
, stream
, "%s", cfa_name
);
1088 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1090 fprintfi_filtered (indent
, stream
, "goto ");
1091 print_label (stream
, scope
, op_ptr
+ offset
- base
);
1092 stream
->puts (";\n");
1096 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1098 fprintfi_filtered (indent
, stream
,
1099 "if ((( " GCC_INTPTR
1100 ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1101 print_label (stream
, scope
, op_ptr
+ offset
- base
);
1102 stream
->puts (";\n");
1109 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op
));
1113 fprintfi_filtered (indent
, stream
, "%s = __gdb_stack[__gdb_tos];\n",
1115 fprintfi_filtered (indent
- 2, stream
, "}\n");
1118 /* See compile.h. */
1121 compile_dwarf_expr_to_c (string_file
*stream
, const char *result_name
,
1122 struct symbol
*sym
, CORE_ADDR pc
,
1123 struct gdbarch
*arch
, unsigned char *registers_used
,
1124 unsigned int addr_size
,
1125 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1126 struct dwarf2_per_cu_data
*per_cu
)
1128 do_compile_dwarf_expr_to_c (2, stream
, GCC_UINTPTR
, result_name
, sym
, pc
,
1129 arch
, registers_used
, addr_size
, op_ptr
, op_end
,
1133 /* See compile.h. */
1136 compile_dwarf_bounds_to_c (string_file
*stream
,
1137 const char *result_name
,
1138 const struct dynamic_prop
*prop
,
1139 struct symbol
*sym
, CORE_ADDR pc
,
1140 struct gdbarch
*arch
, unsigned char *registers_used
,
1141 unsigned int addr_size
,
1142 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1143 struct dwarf2_per_cu_data
*per_cu
)
1145 do_compile_dwarf_expr_to_c (2, stream
, "unsigned long ", result_name
,
1146 sym
, pc
, arch
, registers_used
,
1147 addr_size
, op_ptr
, op_end
, NULL
, per_cu
);