1 /* Convert a DWARF location expression to C
3 Copyright (C) 2014-2019 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 "dwarf2expr.h"
23 #include "dwarf2loc.h"
26 #include "compile-internal.h"
27 #include "compile-c.h"
30 #include "dwarf2-frame.h"
31 #include "gdbsupport/gdb_vecs.h"
37 /* Information about a given instruction. */
41 /* Stack depth at entry. */
45 /* Whether this instruction has been visited. */
47 unsigned int visited
: 1;
49 /* Whether this instruction needs a label. */
51 unsigned int label
: 1;
53 /* Whether this instruction is DW_OP_GNU_push_tls_address or
54 DW_OP_form_tls_address. This is a hack until we can add a
55 feature to glibc to let us properly generate code for TLS. */
57 unsigned int is_tls
: 1;
60 /* A helper function for compute_stack_depth that does the work. This
61 examines the DWARF expression starting from START and computes
64 NEED_TEMPVAR is an out parameter which is set if this expression
65 needs a special temporary variable to be emitted (see the code
67 INFO is a vector of insn_info objects, indexed by offset from the
68 start of the DWARF expression.
69 TO_DO is a list of bytecodes which must be examined; it may be
70 added to by this function.
71 BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
72 OP_PTR and OP_END are the bounds of the DWARF expression. */
75 compute_stack_depth_worker (int start
, int *need_tempvar
,
76 std::vector
<struct insn_info
> *info
,
77 std::vector
<int> *to_do
,
78 enum bfd_endian byte_order
, unsigned int addr_size
,
79 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
)
81 const gdb_byte
* const base
= op_ptr
;
85 gdb_assert ((*info
)[start
].visited
);
86 stack_depth
= (*info
)[start
].depth
;
88 while (op_ptr
< op_end
)
90 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
93 int ndx
= op_ptr
- base
;
95 #define SET_CHECK_DEPTH(WHERE) \
96 if ((*info)[WHERE].visited) \
98 if ((*info)[WHERE].depth != stack_depth) \
99 error (_("inconsistent stack depths")); \
103 /* Stack depth not set, so set it. */ \
104 (*info)[WHERE].visited = 1; \
105 (*info)[WHERE].depth = stack_depth; \
108 SET_CHECK_DEPTH (ndx
);
176 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
216 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
252 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
257 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
258 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
263 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
295 case DW_OP_deref_size
:
299 case DW_OP_plus_uconst
:
300 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
323 case DW_OP_call_frame_cfa
:
327 case DW_OP_GNU_push_tls_address
:
328 case DW_OP_form_tls_address
:
329 (*info
)[ndx
].is_tls
= 1;
333 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
335 offset
= op_ptr
+ offset
- base
;
336 /* If the destination has not been seen yet, add it to the
338 if (!(*info
)[offset
].visited
)
339 to_do
->push_back (offset
);
340 SET_CHECK_DEPTH (offset
);
341 (*info
)[offset
].label
= 1;
342 /* We're done with this line of code. */
346 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
348 offset
= op_ptr
+ offset
- base
;
350 /* If the destination has not been seen yet, add it to the
352 if (!(*info
)[offset
].visited
)
353 to_do
->push_back (offset
);
354 SET_CHECK_DEPTH (offset
);
355 (*info
)[offset
].label
= 1;
362 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op
));
366 gdb_assert (op_ptr
== op_end
);
368 #undef SET_CHECK_DEPTH
371 /* Compute the maximum needed stack depth of a DWARF expression, and
372 some other information as well.
374 BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
375 NEED_TEMPVAR is an out parameter which is set if this expression
376 needs a special temporary variable to be emitted (see the code
378 IS_TLS is an out parameter which is set if this expression refers
380 OP_PTR and OP_END are the bounds of the DWARF expression.
381 INITIAL_DEPTH is the initial depth of the DWARF expression stack.
382 INFO is an array of insn_info objects, indexed by offset from the
383 start of the DWARF expression.
385 This returns the maximum stack depth. */
388 compute_stack_depth (enum bfd_endian byte_order
, unsigned int addr_size
,
389 int *need_tempvar
, int *is_tls
,
390 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
392 std::vector
<struct insn_info
> *info
)
394 std::vector
<int> to_do
;
397 info
->resize (op_end
- op_ptr
);
400 (*info
)[0].depth
= initial_depth
;
401 (*info
)[0].visited
= 1;
403 while (!to_do
.empty ())
405 int ndx
= to_do
.back ();
408 compute_stack_depth_worker (ndx
, need_tempvar
, info
, &to_do
,
409 byte_order
, addr_size
,
415 for (i
= 0; i
< op_end
- op_ptr
; ++i
)
417 if ((*info
)[i
].depth
> stack_depth
)
418 stack_depth
= (*info
)[i
].depth
;
419 if ((*info
)[i
].is_tls
)
423 return stack_depth
+ 1;
428 #define GCC_UINTPTR "__gdb_uintptr"
429 #define GCC_INTPTR "__gdb_intptr"
431 /* Emit code to push a constant. */
434 push (int indent
, string_file
*stream
, ULONGEST l
)
436 fprintfi_filtered (indent
, stream
,
437 "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR
") %s;\n",
441 /* Emit code to push an arbitrary expression. This works like
444 static void pushf (int indent
, string_file
*stream
, const char *format
, ...)
445 ATTRIBUTE_PRINTF (3, 4);
448 pushf (int indent
, string_file
*stream
, const char *format
, ...)
452 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos + 1] = ");
453 va_start (args
, format
);
454 stream
->vprintf (format
, args
);
456 stream
->puts (";\n");
458 fprintfi_filtered (indent
, stream
, "++__gdb_tos;\n");
461 /* Emit code for a unary expression -- one which operates in-place on
462 the top-of-stack. This works like printf. */
464 static void unary (int indent
, string_file
*stream
, const char *format
, ...)
465 ATTRIBUTE_PRINTF (3, 4);
468 unary (int indent
, string_file
*stream
, const char *format
, ...)
472 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos] = ");
473 va_start (args
, format
);
474 stream
->vprintf (format
, args
);
476 stream
->puts (";\n");
479 /* Emit code for a unary expression -- one which uses the top two
480 stack items, popping the topmost one. This works like printf. */
481 static void binary (int indent
, string_file
*stream
, const char *format
, ...)
482 ATTRIBUTE_PRINTF (3, 4);
485 binary (int indent
, string_file
*stream
, const char *format
, ...)
489 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos - 1] = ");
490 va_start (args
, format
);
491 stream
->vprintf (format
, args
);
493 stream
->puts (";\n");
494 fprintfi_filtered (indent
, stream
, "--__gdb_tos;\n");
497 /* Print the name of a label given its "SCOPE", an arbitrary integer
498 used for uniqueness, and its TARGET, the bytecode offset
499 corresponding to the label's point of definition. */
502 print_label (string_file
*stream
, unsigned int scope
, int target
)
504 stream
->printf ("__label_%u_%s", scope
, pulongest (target
));
507 /* Emit code that pushes a register's address on the stack.
508 REGISTERS_USED is an out parameter which is updated to note which
509 register was needed by this expression. */
512 pushf_register_address (int indent
, string_file
*stream
,
513 unsigned char *registers_used
,
514 struct gdbarch
*gdbarch
, int regnum
)
516 std::string regname
= compile_register_name_mangled (gdbarch
, regnum
);
518 registers_used
[regnum
] = 1;
519 pushf (indent
, stream
,
520 "(" GCC_UINTPTR
") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME
"->%s",
524 /* Emit code that pushes a register's value on the stack.
525 REGISTERS_USED is an out parameter which is updated to note which
526 register was needed by this expression. OFFSET is added to the
527 register's value before it is pushed. */
530 pushf_register (int indent
, string_file
*stream
,
531 unsigned char *registers_used
,
532 struct gdbarch
*gdbarch
, int regnum
, uint64_t offset
)
534 std::string regname
= compile_register_name_mangled (gdbarch
, regnum
);
536 registers_used
[regnum
] = 1;
538 pushf (indent
, stream
, COMPILE_I_SIMPLE_REGISTER_ARG_NAME
"->%s",
541 pushf (indent
, stream
,
542 COMPILE_I_SIMPLE_REGISTER_ARG_NAME
"->%s + (" GCC_UINTPTR
") %s",
543 regname
.c_str (), hex_string (offset
));
546 /* Compile a DWARF expression to C code.
548 INDENT is the indentation level to use.
549 STREAM is the stream where the code should be written.
551 TYPE_NAME names the type of the result of the DWARF expression.
552 For locations this is "void *" but for array bounds it will be an
555 RESULT_NAME is the name of a variable in the resulting C code. The
556 result of the expression will be assigned to this variable.
558 SYM is the symbol corresponding to this expression.
559 PC is the location at which the expression is being evaluated.
560 ARCH is the architecture to use.
562 REGISTERS_USED is an out parameter which is updated to note which
563 registers were needed by this expression.
565 ADDR_SIZE is the DWARF address size to use.
567 OPT_PTR and OP_END are the bounds of the DWARF expression.
569 If non-NULL, INITIAL points to an initial value to write to the
570 stack. If NULL, no initial value is written.
572 PER_CU is the per-CU object used for looking up various other
576 do_compile_dwarf_expr_to_c (int indent
, string_file
*stream
,
577 const char *type_name
,
578 const char *result_name
,
579 struct symbol
*sym
, CORE_ADDR pc
,
580 struct gdbarch
*arch
,
581 unsigned char *registers_used
,
582 unsigned int addr_size
,
583 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
585 struct dwarf2_per_cu_data
*per_cu
)
587 /* We keep a counter so that labels and other objects we create have
589 static unsigned int scope
;
591 enum bfd_endian byte_order
= gdbarch_byte_order (arch
);
592 const gdb_byte
* const base
= op_ptr
;
593 int need_tempvar
= 0;
595 std::vector
<struct insn_info
> info
;
600 fprintfi_filtered (indent
, stream
, "__attribute__ ((unused)) %s %s;\n",
601 type_name
, result_name
);
602 fprintfi_filtered (indent
, stream
, "{\n");
605 stack_depth
= compute_stack_depth (byte_order
, addr_size
,
606 &need_tempvar
, &is_tls
,
607 op_ptr
, op_end
, initial
!= NULL
,
610 /* This is a hack until we can add a feature to glibc to let us
611 properly generate code for TLS. You might think we could emit
612 the address in the ordinary course of translating
613 DW_OP_GNU_push_tls_address, but since the operand appears on the
614 stack, it is relatively hard to find, and the idea of calling
615 target_translate_tls_address with OFFSET==0 and then adding the
616 offset by hand seemed too hackish. */
619 struct frame_info
*frame
= get_selected_frame (NULL
);
623 error (_("Symbol \"%s\" cannot be used because "
624 "there is no selected frame"),
625 SYMBOL_PRINT_NAME (sym
));
627 val
= read_var_value (sym
, NULL
, frame
);
628 if (VALUE_LVAL (val
) != lval_memory
)
629 error (_("Symbol \"%s\" cannot be used for compilation evaluation "
630 "as its address has not been found."),
631 SYMBOL_PRINT_NAME (sym
));
633 warning (_("Symbol \"%s\" is thread-local and currently can only "
634 "be referenced from the current thread in "
636 SYMBOL_PRINT_NAME (sym
));
638 fprintfi_filtered (indent
, stream
, "%s = %s;\n",
640 core_addr_to_string (value_address (val
)));
641 fprintfi_filtered (indent
- 2, stream
, "}\n");
645 fprintfi_filtered (indent
, stream
, GCC_UINTPTR
" __gdb_stack[%d];\n",
649 fprintfi_filtered (indent
, stream
, GCC_UINTPTR
" __gdb_tmp;\n");
650 fprintfi_filtered (indent
, stream
, "int __gdb_tos = -1;\n");
653 pushf (indent
, stream
, "%s", core_addr_to_string (*initial
));
655 while (op_ptr
< op_end
)
657 enum dwarf_location_atom op
= (enum dwarf_location_atom
) *op_ptr
;
658 uint64_t uoffset
, reg
;
661 print_spaces (indent
- 2, stream
);
662 if (info
[op_ptr
- base
].label
)
664 print_label (stream
, scope
, op_ptr
- base
);
667 stream
->printf ("/* %s */\n", get_DW_OP_name (op
));
669 /* This is handy for debugging the generated code:
670 fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
671 (int) info[op_ptr - base].depth - 1);
710 push (indent
, stream
, op
- DW_OP_lit0
);
714 uoffset
= extract_unsigned_integer (op_ptr
, addr_size
, byte_order
);
716 /* Some versions of GCC emit DW_OP_addr before
717 DW_OP_GNU_push_tls_address. In this case the value is an
718 index, not an address. We don't support things like
719 branching between the address and the TLS op. */
720 if (op_ptr
>= op_end
|| *op_ptr
!= DW_OP_GNU_push_tls_address
)
721 uoffset
+= dwarf2_per_cu_text_offset (per_cu
);
722 push (indent
, stream
, uoffset
);
726 push (indent
, stream
,
727 extract_unsigned_integer (op_ptr
, 1, byte_order
));
731 push (indent
, stream
,
732 extract_signed_integer (op_ptr
, 1, byte_order
));
736 push (indent
, stream
,
737 extract_unsigned_integer (op_ptr
, 2, byte_order
));
741 push (indent
, stream
,
742 extract_signed_integer (op_ptr
, 2, byte_order
));
746 push (indent
, stream
,
747 extract_unsigned_integer (op_ptr
, 4, byte_order
));
751 push (indent
, stream
,
752 extract_signed_integer (op_ptr
, 4, byte_order
));
756 push (indent
, stream
,
757 extract_unsigned_integer (op_ptr
, 8, byte_order
));
761 push (indent
, stream
,
762 extract_signed_integer (op_ptr
, 8, byte_order
));
766 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, &uoffset
);
767 push (indent
, stream
, uoffset
);
770 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
771 push (indent
, stream
, offset
);
806 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
807 pushf_register_address (indent
, stream
, registers_used
, arch
,
808 dwarf_reg_to_regnum_or_error
809 (arch
, op
- DW_OP_reg0
));
813 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
814 dwarf_expr_require_composition (op_ptr
, op_end
, "DW_OP_regx");
815 pushf_register_address (indent
, stream
, registers_used
, arch
,
816 dwarf_reg_to_regnum_or_error (arch
, reg
));
851 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
852 pushf_register (indent
, stream
, registers_used
, arch
,
853 dwarf_reg_to_regnum_or_error (arch
,
859 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
860 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
861 pushf_register (indent
, stream
, registers_used
, arch
,
862 dwarf_reg_to_regnum_or_error (arch
, reg
), offset
);
867 const gdb_byte
*datastart
;
869 const struct block
*b
;
870 struct symbol
*framefunc
;
873 b
= block_for_pc (pc
);
876 error (_("No block found for address"));
878 framefunc
= block_linkage_function (b
);
881 error (_("No function found for block"));
883 func_get_frame_base_dwarf_block (framefunc
, pc
,
884 &datastart
, &datalen
);
886 op_ptr
= safe_read_sleb128 (op_ptr
, op_end
, &offset
);
888 /* Generate a unique-enough name, in case the frame base
889 is computed multiple times in this expression. */
890 xsnprintf (fb_name
, sizeof (fb_name
), "__frame_base_%ld",
891 (long) (op_ptr
- base
));
893 do_compile_dwarf_expr_to_c (indent
, stream
,
894 GCC_UINTPTR
, fb_name
,
896 arch
, registers_used
, addr_size
,
897 datastart
, datastart
+ datalen
,
900 pushf (indent
, stream
, "%s + %s", fb_name
, hex_string (offset
));
905 pushf (indent
, stream
, "__gdb_stack[__gdb_tos]");
909 fprintfi_filtered (indent
, stream
, "--__gdb_tos;\n");
914 pushf (indent
, stream
, "__gdb_stack[__gdb_tos - %s]",
919 fprintfi_filtered (indent
, stream
,
920 "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
921 fprintfi_filtered (indent
, stream
,
922 "__gdb_stack[__gdb_tos - 1] = "
923 "__gdb_stack[__gdb_tos];\n");
924 fprintfi_filtered (indent
, stream
, ("__gdb_stack[__gdb_tos] = "
929 pushf (indent
, stream
, "__gdb_stack[__gdb_tos - 1]");
933 fprintfi_filtered (indent
, stream
, ("__gdb_tmp = "
934 "__gdb_stack[__gdb_tos];\n"));
935 fprintfi_filtered (indent
, stream
,
936 "__gdb_stack[__gdb_tos] = "
937 "__gdb_stack[__gdb_tos - 1];\n");
938 fprintfi_filtered (indent
, stream
,
939 "__gdb_stack[__gdb_tos - 1] = "
940 "__gdb_stack[__gdb_tos -2];\n");
941 fprintfi_filtered (indent
, stream
, "__gdb_stack[__gdb_tos - 2] = "
946 case DW_OP_deref_size
:
951 if (op
== DW_OP_deref_size
)
956 mode
= c_get_mode_for_size (size
);
958 error (_("Unsupported size %d in %s"),
959 size
, get_DW_OP_name (op
));
961 /* Cast to a pointer of the desired type, then
963 fprintfi_filtered (indent
, stream
,
964 "__gdb_stack[__gdb_tos] = "
965 "*((__gdb_int_%s *) "
966 "__gdb_stack[__gdb_tos]);\n",
972 unary (indent
, stream
,
973 "((" GCC_INTPTR
") __gdb_stack[__gdb_tos]) < 0 ? "
974 "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
978 unary (indent
, stream
, "-__gdb_stack[__gdb_tos]");
982 unary (indent
, stream
, "~__gdb_stack[__gdb_tos]");
985 case DW_OP_plus_uconst
:
986 op_ptr
= safe_read_uleb128 (op_ptr
, op_end
, ®
);
987 unary (indent
, stream
, "__gdb_stack[__gdb_tos] + %s",
992 binary (indent
, stream
, ("((" GCC_INTPTR
993 ") __gdb_stack[__gdb_tos-1]) / (("
994 GCC_INTPTR
") __gdb_stack[__gdb_tos])"));
998 binary (indent
, stream
,
999 "((" GCC_INTPTR
") __gdb_stack[__gdb_tos-1]) >> "
1000 "__gdb_stack[__gdb_tos]");
1003 #define BINARY(OP) \
1004 binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1005 " __gdb_stack[__gdb_tos]"); \
1028 #define COMPARE(OP) \
1029 binary (indent, stream, \
1030 "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP \
1032 ") __gdb_stack[__gdb_tos]))"); \
1049 case DW_OP_call_frame_cfa
:
1052 CORE_ADDR text_offset
;
1054 const gdb_byte
*cfa_start
, *cfa_end
;
1056 if (dwarf2_fetch_cfa_info (arch
, pc
, per_cu
,
1058 &text_offset
, &cfa_start
, &cfa_end
))
1061 pushf_register (indent
, stream
, registers_used
, arch
, regnum
,
1066 /* Another expression. */
1069 /* Generate a unique-enough name, in case the CFA is
1070 computed multiple times in this expression. */
1071 xsnprintf (cfa_name
, sizeof (cfa_name
),
1072 "__cfa_%ld", (long) (op_ptr
- base
));
1074 do_compile_dwarf_expr_to_c (indent
, stream
,
1075 GCC_UINTPTR
, cfa_name
,
1076 sym
, pc
, arch
, registers_used
,
1079 &text_offset
, per_cu
);
1080 pushf (indent
, stream
, "%s", cfa_name
);
1087 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1089 fprintfi_filtered (indent
, stream
, "goto ");
1090 print_label (stream
, scope
, op_ptr
+ offset
- base
);
1091 stream
->puts (";\n");
1095 offset
= extract_signed_integer (op_ptr
, 2, byte_order
);
1097 fprintfi_filtered (indent
, stream
,
1098 "if ((( " GCC_INTPTR
1099 ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1100 print_label (stream
, scope
, op_ptr
+ offset
- base
);
1101 stream
->puts (";\n");
1108 error (_("unhandled DWARF op: %s"), get_DW_OP_name (op
));
1112 fprintfi_filtered (indent
, stream
, "%s = __gdb_stack[__gdb_tos];\n",
1114 fprintfi_filtered (indent
- 2, stream
, "}\n");
1117 /* See compile.h. */
1120 compile_dwarf_expr_to_c (string_file
*stream
, const char *result_name
,
1121 struct symbol
*sym
, CORE_ADDR pc
,
1122 struct gdbarch
*arch
, unsigned char *registers_used
,
1123 unsigned int addr_size
,
1124 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1125 struct dwarf2_per_cu_data
*per_cu
)
1127 do_compile_dwarf_expr_to_c (2, stream
, GCC_UINTPTR
, result_name
, sym
, pc
,
1128 arch
, registers_used
, addr_size
, op_ptr
, op_end
,
1132 /* See compile.h. */
1135 compile_dwarf_bounds_to_c (string_file
*stream
,
1136 const char *result_name
,
1137 const struct dynamic_prop
*prop
,
1138 struct symbol
*sym
, CORE_ADDR pc
,
1139 struct gdbarch
*arch
, unsigned char *registers_used
,
1140 unsigned int addr_size
,
1141 const gdb_byte
*op_ptr
, const gdb_byte
*op_end
,
1142 struct dwarf2_per_cu_data
*per_cu
)
1144 do_compile_dwarf_expr_to_c (2, stream
, "unsigned long ", result_name
,
1145 sym
, pc
, arch
, registers_used
,
1146 addr_size
, op_ptr
, op_end
, NULL
, per_cu
);