/* Convert a DWARF location expression to C
- Copyright (C) 2014-2016 Free Software Foundation, Inc.
+ Copyright (C) 2014-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "dwarf2.h"
-#include "dwarf2expr.h"
-#include "dwarf2loc.h"
+#include "dwarf2/expr.h"
+#include "dwarf2/loc.h"
+#include "dwarf2/read.h"
#include "ui-file.h"
#include "utils.h"
#include "compile-internal.h"
+#include "compile-c.h"
#include "compile.h"
#include "block.h"
-#include "dwarf2-frame.h"
-#include "gdb_vecs.h"
+#include "dwarf2/frame.h"
+#include "gdbsupport/gdb_vecs.h"
#include "value.h"
+#include "gdbarch.h"
\f
unsigned int label : 1;
- /* Whether this instruction is DW_OP_GNU_push_tls_address. This is
- a hack until we can add a feature to glibc to let us properly
- generate code for TLS. */
+ /* Whether this instruction is DW_OP_GNU_push_tls_address or
+ DW_OP_form_tls_address. This is a hack until we can add a
+ feature to glibc to let us properly generate code for TLS. */
unsigned int is_tls : 1;
};
NEED_TEMPVAR is an out parameter which is set if this expression
needs a special temporary variable to be emitted (see the code
generator).
- INFO is an array of insn_info objects, indexed by offset from the
+ INFO is a vector of insn_info objects, indexed by offset from the
start of the DWARF expression.
TO_DO is a list of bytecodes which must be examined; it may be
added to by this function.
static void
compute_stack_depth_worker (int start, int *need_tempvar,
- struct insn_info *info,
- VEC (int) **to_do,
+ 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)
{
int stack_depth;
op_ptr += start;
- gdb_assert (info[start].visited);
- stack_depth = info[start].depth;
+ gdb_assert ((*info)[start].visited);
+ stack_depth = (*info)[start].depth;
while (op_ptr < op_end)
{
int ndx = op_ptr - base;
#define SET_CHECK_DEPTH(WHERE) \
- if (info[WHERE].visited) \
+ if ((*info)[WHERE].visited) \
{ \
- if (info[WHERE].depth != stack_depth) \
+ if ((*info)[WHERE].depth != stack_depth) \
error (_("inconsistent stack depths")); \
} \
else \
{ \
/* Stack depth not set, so set it. */ \
- info[WHERE].visited = 1; \
- info[WHERE].depth = stack_depth; \
+ (*info)[WHERE].visited = 1; \
+ (*info)[WHERE].depth = stack_depth; \
}
SET_CHECK_DEPTH (ndx);
break;
case DW_OP_GNU_push_tls_address:
- info[ndx].is_tls = 1;
+ case DW_OP_form_tls_address:
+ (*info)[ndx].is_tls = 1;
break;
case DW_OP_skip:
offset = op_ptr + offset - base;
/* If the destination has not been seen yet, add it to the
to-do list. */
- if (!info[offset].visited)
- VEC_safe_push (int, *to_do, offset);
+ if (!(*info)[offset].visited)
+ to_do->push_back (offset);
SET_CHECK_DEPTH (offset);
- info[offset].label = 1;
+ (*info)[offset].label = 1;
/* We're done with this line of code. */
return;
--stack_depth;
/* If the destination has not been seen yet, add it to the
to-do list. */
- if (!info[offset].visited)
- VEC_safe_push (int, *to_do, offset);
+ if (!(*info)[offset].visited)
+ to_do->push_back (offset);
SET_CHECK_DEPTH (offset);
- info[offset].label = 1;
+ (*info)[offset].label = 1;
break;
case DW_OP_nop:
int *need_tempvar, int *is_tls,
const gdb_byte *op_ptr, const gdb_byte *op_end,
int initial_depth,
- struct insn_info **info)
+ std::vector<struct insn_info> *info)
{
- unsigned char *set;
- struct cleanup *outer_cleanup, *cleanup;
- VEC (int) *to_do = NULL;
+ std::vector<int> to_do;
int stack_depth, i;
- *info = XCNEWVEC (struct insn_info, op_end - op_ptr);
- outer_cleanup = make_cleanup (xfree, *info);
-
- cleanup = make_cleanup (VEC_cleanup (int), &to_do);
+ info->resize (op_end - op_ptr);
- VEC_safe_push (int, to_do, 0);
+ to_do.push_back (0);
(*info)[0].depth = initial_depth;
(*info)[0].visited = 1;
- while (!VEC_empty (int, to_do))
+ while (!to_do.empty ())
{
- int ndx = VEC_pop (int, to_do);
+ int ndx = to_do.back ();
+ to_do.pop_back ();
- compute_stack_depth_worker (ndx, need_tempvar, *info, &to_do,
+ compute_stack_depth_worker (ndx, need_tempvar, info, &to_do,
byte_order, addr_size,
op_ptr, op_end);
}
*is_tls = 1;
}
- do_cleanups (cleanup);
- discard_cleanups (outer_cleanup);
return stack_depth + 1;
}
/* Emit code to push a constant. */
static void
-push (int indent, struct ui_file *stream, ULONGEST l)
+push (int indent, string_file *stream, ULONGEST l)
{
- fprintfi_filtered (indent, stream,
- "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
- hex_string (l));
+ fprintf_filtered (stream,
+ "%*s__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
+ indent, "", hex_string (l));
}
/* Emit code to push an arbitrary expression. This works like
printf. */
-static void pushf (int indent, struct ui_file *stream, const char *format, ...)
+static void pushf (int indent, string_file *stream, const char *format, ...)
ATTRIBUTE_PRINTF (3, 4);
static void
-pushf (int indent, struct ui_file *stream, const char *format, ...)
+pushf (int indent, string_file *stream, const char *format, ...)
{
va_list args;
- fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos + 1] = ");
+ fprintf_filtered (stream, "%*s__gdb_stack[__gdb_tos + 1] = ", indent, "");
va_start (args, format);
- vfprintf_filtered (stream, format, args);
+ stream->vprintf (format, args);
va_end (args);
- fprintf_filtered (stream, ";\n");
+ stream->puts (";\n");
- fprintfi_filtered (indent, stream, "++__gdb_tos;\n");
+ fprintf_filtered (stream, "%*s++__gdb_tos;\n", indent, "");
}
/* Emit code for a unary expression -- one which operates in-place on
the top-of-stack. This works like printf. */
-static void unary (int indent, struct ui_file *stream, const char *format, ...)
+static void unary (int indent, string_file *stream, const char *format, ...)
ATTRIBUTE_PRINTF (3, 4);
static void
-unary (int indent, struct ui_file *stream, const char *format, ...)
+unary (int indent, string_file *stream, const char *format, ...)
{
va_list args;
- fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos] = ");
+ fprintf_filtered (stream, "%*s__gdb_stack[__gdb_tos] = ", indent, "");
va_start (args, format);
- vfprintf_filtered (stream, format, args);
+ stream->vprintf (format, args);
va_end (args);
- fprintf_filtered (stream, ";\n");
+ stream->puts (";\n");
}
/* Emit code for a unary expression -- one which uses the top two
stack items, popping the topmost one. This works like printf. */
-static void binary (int indent, struct ui_file *stream, const char *format, ...)
+static void binary (int indent, string_file *stream, const char *format, ...)
ATTRIBUTE_PRINTF (3, 4);
static void
-binary (int indent, struct ui_file *stream, const char *format, ...)
+binary (int indent, string_file *stream, const char *format, ...)
{
va_list args;
- fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 1] = ");
+ fprintf_filtered (stream, "%*s__gdb_stack[__gdb_tos - 1] = ", indent, "");
va_start (args, format);
- vfprintf_filtered (stream, format, args);
+ stream->vprintf (format, args);
va_end (args);
- fprintf_filtered (stream, ";\n");
- fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
+ stream->puts (";\n");
+ fprintf_filtered (stream, "%*s--__gdb_tos;\n", indent, "");
}
/* Print the name of a label given its "SCOPE", an arbitrary integer
corresponding to the label's point of definition. */
static void
-print_label (struct ui_file *stream, unsigned int scope, int target)
+print_label (string_file *stream, unsigned int scope, int target)
{
- fprintf_filtered (stream, "__label_%u_%s",
- scope, pulongest (target));
+ stream->printf ("__label_%u_%s", scope, pulongest (target));
}
/* Emit code that pushes a register's address on the stack.
register was needed by this expression. */
static void
-pushf_register_address (int indent, struct ui_file *stream,
+pushf_register_address (int indent, string_file *stream,
unsigned char *registers_used,
struct gdbarch *gdbarch, int regnum)
{
- char *regname = compile_register_name_mangled (gdbarch, regnum);
- struct cleanup *cleanups = make_cleanup (xfree, regname);
+ std::string regname = compile_register_name_mangled (gdbarch, regnum);
registers_used[regnum] = 1;
pushf (indent, stream,
"(" GCC_UINTPTR ") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
- regname);
-
- do_cleanups (cleanups);
+ regname.c_str ());
}
/* Emit code that pushes a register's value on the stack.
register's value before it is pushed. */
static void
-pushf_register (int indent, struct ui_file *stream,
+pushf_register (int indent, string_file *stream,
unsigned char *registers_used,
struct gdbarch *gdbarch, int regnum, uint64_t offset)
{
- char *regname = compile_register_name_mangled (gdbarch, regnum);
- struct cleanup *cleanups = make_cleanup (xfree, regname);
+ std::string regname = compile_register_name_mangled (gdbarch, regnum);
registers_used[regnum] = 1;
if (offset == 0)
pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
- regname);
+ regname.c_str ());
else
pushf (indent, stream,
COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s + (" GCC_UINTPTR ") %s",
- regname, hex_string (offset));
-
- do_cleanups (cleanups);
+ regname.c_str (), hex_string (offset));
}
/* Compile a DWARF expression to C code.
things. */
static void
-do_compile_dwarf_expr_to_c (int indent, struct ui_file *stream,
+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,
unsigned int addr_size,
const gdb_byte *op_ptr, const gdb_byte *op_end,
CORE_ADDR *initial,
- struct dwarf2_per_cu_data *per_cu)
+ dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile)
{
/* We keep a counter so that labels and other objects we create have
unique names. */
const gdb_byte * const base = op_ptr;
int need_tempvar = 0;
int is_tls = 0;
- struct cleanup *cleanup;
- struct insn_info *info;
+ std::vector<struct insn_info> info;
int stack_depth;
++scope;
- fprintfi_filtered (indent, stream, "__attribute__ ((unused)) %s %s;\n",
- type_name, result_name);
- fprintfi_filtered (indent, stream, "{\n");
+ fprintf_filtered (stream, "%*s__attribute__ ((unused)) %s %s;\n",
+ indent, "", type_name, result_name);
+ fprintf_filtered (stream, "%*s{\n", indent, "");
indent += 2;
stack_depth = compute_stack_depth (byte_order, addr_size,
&need_tempvar, &is_tls,
op_ptr, op_end, initial != NULL,
&info);
- cleanup = make_cleanup (xfree, info);
/* This is a hack until we can add a feature to glibc to let us
properly generate code for TLS. You might think we could emit
if (frame == NULL)
error (_("Symbol \"%s\" cannot be used because "
"there is no selected frame"),
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
val = read_var_value (sym, NULL, frame);
if (VALUE_LVAL (val) != lval_memory)
error (_("Symbol \"%s\" cannot be used for compilation evaluation "
"as its address has not been found."),
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
warning (_("Symbol \"%s\" is thread-local and currently can only "
"be referenced from the current thread in "
"compiled code."),
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
- fprintfi_filtered (indent, stream, "%s = %s;\n",
- result_name,
- core_addr_to_string (value_address (val)));
- fprintfi_filtered (indent - 2, stream, "}\n");
- do_cleanups (cleanup);
+ fprintf_filtered (stream, "%*s%s = %s;\n",
+ indent, "", result_name,
+ core_addr_to_string (value_address (val)));
+ fprintf_filtered (stream, "%*s}\n", indent - 2, "");
return;
}
- fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_stack[%d];\n",
- stack_depth);
+ fprintf_filtered (stream, "%*s" GCC_UINTPTR " __gdb_stack[%d];\n",
+ indent, "", stack_depth);
if (need_tempvar)
- fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_tmp;\n");
- fprintfi_filtered (indent, stream, "int __gdb_tos = -1;\n");
+ fprintf_filtered (stream, "%*s" GCC_UINTPTR " __gdb_tmp;\n", indent, "");
+ fprintf_filtered (stream, "%*sint __gdb_tos = -1;\n", indent, "");
if (initial != NULL)
pushf (indent, stream, "%s", core_addr_to_string (*initial));
if (info[op_ptr - base].label)
{
print_label (stream, scope, op_ptr - base);
- fprintf_filtered (stream, ":;");
+ stream->puts (":;");
}
- fprintf_filtered (stream, "/* %s */\n", get_DW_OP_name (op));
+ stream->printf ("/* %s */\n", get_DW_OP_name (op));
/* This is handy for debugging the generated code:
fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
break;
case DW_OP_addr:
+ uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
op_ptr += addr_size;
/* Some versions of GCC emit DW_OP_addr before
DW_OP_GNU_push_tls_address. In this case the value is an
index, not an address. We don't support things like
branching between the address and the TLS op. */
if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
- uoffset += dwarf2_per_cu_text_offset (per_cu);
+ uoffset += per_objfile->objfile->text_section_offset ();
push (indent, stream, uoffset);
break;
sym, pc,
arch, registers_used, addr_size,
datastart, datastart + datalen,
- NULL, per_cu);
+ NULL, per_cu, per_objfile);
pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
}
break;
case DW_OP_drop:
- fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
+ fprintf_filtered (stream, "%*s--__gdb_tos;\n", indent, "");
break;
case DW_OP_pick:
break;
case DW_OP_swap:
- fprintfi_filtered (indent, stream,
- "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
- fprintfi_filtered (indent, stream,
- "__gdb_stack[__gdb_tos - 1] = "
- "__gdb_stack[__gdb_tos];\n");
- fprintfi_filtered (indent, stream, ("__gdb_stack[__gdb_tos] = "
- "__gdb_tmp;\n"));
+ fprintf_filtered (stream,
+ "%*s__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n",
+ indent, "");
+ fprintf_filtered (stream,
+ "%*s__gdb_stack[__gdb_tos - 1] = "
+ "__gdb_stack[__gdb_tos];\n",
+ indent, "");
+ fprintf_filtered (stream, ("%*s__gdb_stack[__gdb_tos] = "
+ "__gdb_tmp;\n"),
+ indent, "");
break;
case DW_OP_over:
break;
case DW_OP_rot:
- fprintfi_filtered (indent, stream, ("__gdb_tmp = "
- "__gdb_stack[__gdb_tos];\n"));
- fprintfi_filtered (indent, stream,
- "__gdb_stack[__gdb_tos] = "
- "__gdb_stack[__gdb_tos - 1];\n");
- fprintfi_filtered (indent, stream,
- "__gdb_stack[__gdb_tos - 1] = "
- "__gdb_stack[__gdb_tos -2];\n");
- fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 2] = "
- "__gdb_tmp;\n");
+ fprintf_filtered (stream, ("%*s__gdb_tmp = "
+ "__gdb_stack[__gdb_tos];\n"),
+ indent, "");
+ fprintf_filtered (stream,
+ "%*s__gdb_stack[__gdb_tos] = "
+ "__gdb_stack[__gdb_tos - 1];\n",
+ indent, "");
+ fprintf_filtered (stream,
+ "%*s__gdb_stack[__gdb_tos - 1] = "
+ "__gdb_stack[__gdb_tos -2];\n",
+ indent, "");
+ fprintf_filtered (stream, "%*s__gdb_stack[__gdb_tos - 2] = "
+ "__gdb_tmp;\n",
+ indent, "");
break;
case DW_OP_deref:
/* Cast to a pointer of the desired type, then
dereference. */
- fprintfi_filtered (indent, stream,
- "__gdb_stack[__gdb_tos] = "
- "*((__gdb_int_%s *) "
- "__gdb_stack[__gdb_tos]);\n",
- mode);
+ fprintf_filtered (stream,
+ "%*s__gdb_stack[__gdb_tos] = "
+ "*((__gdb_int_%s *) "
+ "__gdb_stack[__gdb_tos]);\n",
+ indent, "", mode);
}
break;
sym, pc, arch, registers_used,
addr_size,
cfa_start, cfa_end,
- &text_offset, per_cu);
+ &text_offset, per_cu, per_objfile);
pushf (indent, stream, "%s", cfa_name);
}
}
case DW_OP_skip:
offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
- fprintfi_filtered (indent, stream, "goto ");
+ fprintf_filtered (stream, "%*sgoto ", indent, "");
print_label (stream, scope, op_ptr + offset - base);
- fprintf_filtered (stream, ";\n");
+ stream->puts (";\n");
break;
case DW_OP_bra:
offset = extract_signed_integer (op_ptr, 2, byte_order);
op_ptr += 2;
- fprintfi_filtered (indent, stream,
- "if ((( " GCC_INTPTR
- ") __gdb_stack[__gdb_tos--]) != 0) goto ");
+ fprintf_filtered (stream,
+ "%*sif ((( " GCC_INTPTR
+ ") __gdb_stack[__gdb_tos--]) != 0) goto ",
+ indent, "");
print_label (stream, scope, op_ptr + offset - base);
- fprintf_filtered (stream, ";\n");
+ stream->puts (";\n");
break;
case DW_OP_nop:
}
}
- fprintfi_filtered (indent, stream, "%s = __gdb_stack[__gdb_tos];\n",
- result_name);
- fprintfi_filtered (indent - 2, stream, "}\n");
-
- do_cleanups (cleanup);
+ fprintf_filtered (stream, "%*s%s = __gdb_stack[__gdb_tos];\n",
+ indent, "", result_name);
+ fprintf_filtered (stream, "%*s}\n", indent - 2, "");
}
/* See compile.h. */
void
-compile_dwarf_expr_to_c (struct ui_file *stream, const char *result_name,
+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)
+ dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile)
{
do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
arch, registers_used, addr_size, op_ptr, op_end,
- NULL, per_cu);
+ NULL, per_cu, per_objfile);
}
/* See compile.h. */
void
-compile_dwarf_bounds_to_c (struct ui_file *stream,
+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)
+ dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile)
{
do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
sym, pc, arch, registers_used,
- addr_size, op_ptr, op_end, NULL, per_cu);
+ addr_size, op_ptr, op_end, NULL, per_cu,
+ per_objfile);
}