/**
* die_get_data_member_location - Get the data-member offset
* @mb_die: a DIE of a member of a data structure
* @offs: The offset of the member in the data structure
*
* Get the offset of @mb_die in the data structure including @mb_die, and
* stores result offset to @offs. If any error occurs this returns errno.
*/
int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
{
Dwarf_Attribute attr;
Dwarf_Op *expr;
size_t nexpr;
int ret;
if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
return -ENOENT;
if (dwarf_formudata(&attr, offs) != 0) {
/* DW_AT_data_member_location should be DW_OP_plus_uconst */
ret = dwarf_getlocation(&attr, &expr, &nexpr);
if (ret < 0 || nexpr == 0)
return -ENOENT;
if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
expr[0].atom, nexpr);
return -ENOTSUP;
}
*offs = (Dwarf_Word)expr[0].number;
}
return 0;
}
/** \brief Initialize the location of a member of a type
* (DW_AT_data_member_location of a DW_TAG_member).
*
* \param type a type (struct, class)
* \param member the member of the type
* \param child DIE of the member (DW_TAG_member)
*/
static void MC_dwarf_fill_member_location(
simgrid::mc::Type* type, simgrid::mc::Member* member, Dwarf_Die * child)
{
if (dwarf_hasattr(child, DW_AT_data_bit_offset))
xbt_die("Can't groke DW_AT_data_bit_offset.");
if (not dwarf_hasattr_integrate(child, DW_AT_data_member_location)) {
if (type->type == DW_TAG_union_type)
return;
xbt_die
("Missing DW_AT_data_member_location field in DW_TAG_member %s of type <%"
PRIx64 ">%s", member->name.c_str(),
(uint64_t) type->id, type->name.c_str());
}
Dwarf_Attribute attr;
dwarf_attr_integrate(child, DW_AT_data_member_location, &attr);
int form = dwarf_whatform(&attr);
simgrid::dwarf::FormClass form_class = simgrid::dwarf::classify_form(form);
switch (form_class) {
case simgrid::dwarf::FormClass::ExprLoc:
case simgrid::dwarf::FormClass::Block:
// Location expression:
{
Dwarf_Op *expr;
size_t len;
if (dwarf_getlocation(&attr, &expr, &len))
xbt_die
("Could not read location expression DW_AT_data_member_location in DW_TAG_member %s of type <%"
PRIx64 ">%s", MC_dwarf_attr_integrate_string(child, DW_AT_name),
(uint64_t) type->id, type->name.c_str());
member->location_expression = simgrid::dwarf::DwarfExpression(expr, expr+len);
break;
}
case simgrid::dwarf::FormClass::Constant:
// Offset from the base address of the object:
{
Dwarf_Word offset;
if (not dwarf_formudata(&attr, &offset))
member->offset(offset);
else
xbt_die("Cannot get %s location <%" PRIx64 ">%s",
MC_dwarf_attr_integrate_string(child, DW_AT_name),
(uint64_t) type->id, type->name.c_str());
break;
}
default:
// includes FormClass::LocListPtr (reference to a location list: TODO) and FormClass::Reference (it's supposed to be
// possible in DWARF2 but I couldn't find its semantic in the spec)
xbt_die("Can't handle form class (%d) / form 0x%x as DW_AT_member_location", (int)form_class, (unsigned)form);
}
}
static std::unique_ptr<simgrid::mc::Variable> MC_die_to_variable(
simgrid::mc::ObjectInformation* info, Dwarf_Die * die,
Dwarf_Die * unit, simgrid::mc::Frame* frame,
const char *ns)
{
// Skip declarations:
if (MC_dwarf_attr_flag(die, DW_AT_declaration, false))
return nullptr;
// Skip compile time constants:
if (dwarf_hasattr(die, DW_AT_const_value))
return nullptr;
Dwarf_Attribute attr_location;
if (dwarf_attr(die, DW_AT_location, &attr_location) == nullptr)
// No location: do not add it ?
return nullptr;
std::unique_ptr<simgrid::mc::Variable> variable =
std::unique_ptr<simgrid::mc::Variable>(new simgrid::mc::Variable());
variable->id = dwarf_dieoffset(die);
variable->global = frame == nullptr; // Can be override base on DW_AT_location
variable->object_info = info;
const char *name = MC_dwarf_attr_integrate_string(die, DW_AT_name);
if (name)
variable->name = name;
variable->type_id = MC_dwarf_at_type(die);
int form = dwarf_whatform(&attr_location);
simgrid::dwarf::FormClass form_class;
if (form == DW_FORM_sec_offset)
form_class = simgrid::dwarf::FormClass::Constant;
else
form_class = simgrid::dwarf::classify_form(form);
switch (form_class) {
case simgrid::dwarf::FormClass::ExprLoc:
case simgrid::dwarf::FormClass::Block:
// Location expression:
{
Dwarf_Op *expr;
size_t len;
if (dwarf_getlocation(&attr_location, &expr, &len)) {
xbt_die(
"Could not read location expression in DW_AT_location "
"of variable <%" PRIx64 ">%s",
(uint64_t) variable->id,
variable->name.c_str());
}
if (len == 1 && expr[0].atom == DW_OP_addr) {
variable->global = true;
uintptr_t offset = (uintptr_t) expr[0].number;
uintptr_t base = (uintptr_t) info->base_address();
variable->address = (void *) (base + offset);
} else
variable->location_list = {
simgrid::dwarf::LocationListEntry(simgrid::dwarf::DwarfExpression(expr, expr + len))};
break;
}
case simgrid::dwarf::FormClass::LocListPtr:
case simgrid::dwarf::FormClass::Constant:
// Reference to location list:
variable->location_list = simgrid::dwarf::location_list(
*info, attr_location);
break;
default:
xbt_die("Unexpected form 0x%x (%i), class 0x%x (%i) list for location in <%" PRIx64 ">%s", (unsigned)form, form,
(unsigned)form_class, (int)form_class, (uint64_t)variable->id, variable->name.c_str());
}
// Handle start_scope:
if (dwarf_hasattr(die, DW_AT_start_scope)) {
Dwarf_Attribute attr;
dwarf_attr(die, DW_AT_start_scope, &attr);
int form = dwarf_whatform(&attr);
simgrid::dwarf::FormClass form_class = simgrid::dwarf::classify_form(form);
if (form_class == simgrid::dwarf::FormClass::Constant) {
Dwarf_Word value;
variable->start_scope = dwarf_formudata(&attr, &value) == 0 ? (size_t)value : 0;
} else {
// TODO: FormClass::RangeListPtr
xbt_die("Unhandled form 0x%x, class 0x%X for DW_AT_start_scope of variable %s", (unsigned)form,
(unsigned)form_class, name == nullptr ? "?" : name);
}
}
if (ns && variable->global)
variable->name =
std::string(ns) + "::" + variable->name;
// The current code needs a variable name,
// generate a fake one:
if (variable->name.empty()) {
variable->name = "@anonymous#" + std::to_string(mc_anonymous_variable_index);
mc_anonymous_variable_index++;
}
return variable;
}
/* Get all variables and print their value expressions. */
static void
print_varlocs (Dwarf_Die *funcdie)
{
// Display frame base for function if it exists.
// Should be used for DW_OP_fbreg.
has_frame_base = dwarf_hasattr (funcdie, DW_AT_frame_base);
if (has_frame_base)
{
Dwarf_Attribute fb_attr;
if (dwarf_attr (funcdie, DW_AT_frame_base, &fb_attr) == NULL)
error (EXIT_FAILURE, 0, "dwarf_attr fb: %s", dwarf_errmsg (-1));
Dwarf_Op *fb_expr;
size_t fb_exprlen;
if (dwarf_getlocation (&fb_attr, &fb_expr, &fb_exprlen) == 0)
{
// Covers all of function.
Dwarf_Addr entrypc;
if (dwarf_entrypc (funcdie, &entrypc) != 0)
error (EXIT_FAILURE, 0, "dwarf_entrypc: %s", dwarf_errmsg (-1));
printf (" frame_base: ");
if (entrypc == 0)
printf ("XXX zero address"); // XXX bad DWARF?
else
print_expr_block (&fb_attr, fb_expr, fb_exprlen, entrypc);
printf ("\n");
}
else
{
Dwarf_Addr base, start, end;
ptrdiff_t off = 0;
printf (" frame_base:\n");
while ((off = dwarf_getlocations (&fb_attr, off, &base,
&start, &end,
&fb_expr, &fb_exprlen)) > 0)
{
printf (" (%" PRIx64 ",%" PRIx64 ") ", start, end);
print_expr_block (&fb_attr, fb_expr, fb_exprlen, start);
printf ("\n");
}
if (off < 0)
error (EXIT_FAILURE, 0, "dwarf_getlocations fb: %s",
dwarf_errmsg (-1));
}
}
else if (dwarf_tag (funcdie) == DW_TAG_inlined_subroutine)
{
// See whether the subprogram we are inlined into has a frame
// base we should use.
Dwarf_Die *scopes;
int n = dwarf_getscopes_die (funcdie, &scopes);
if (n <= 0)
error (EXIT_FAILURE, 0, "dwarf_getscopes_die: %s", dwarf_errmsg (-1));
while (n-- > 0)
if (dwarf_tag (&scopes[n]) == DW_TAG_subprogram
&& dwarf_hasattr (&scopes[n], DW_AT_frame_base))
{
has_frame_base = true;
break;
}
free (scopes);
}
if (! dwarf_haschildren (funcdie))
return;
Dwarf_Die child;
int res = dwarf_child (funcdie, &child);
if (res < 0)
error (EXIT_FAILURE, 0, "dwarf_child: %s", dwarf_errmsg (-1));
/* We thought there was a child, but the child list was actually
empty. This isn't technically an error in the DWARF, but it is
certainly non-optimimal. */
if (res == 1)
return;
do
{
int tag = dwarf_tag (&child);
if (tag == DW_TAG_variable || tag == DW_TAG_formal_parameter)
{
const char *what = tag == DW_TAG_variable ? "variable" : "parameter";
print_die (&child, what, 2);
if (dwarf_hasattr (&child, DW_AT_location))
{
Dwarf_Attribute attr;
if (dwarf_attr (&child, DW_AT_location, &attr) == NULL)
error (EXIT_FAILURE, 0, "dwarf_attr: %s", dwarf_errmsg (-1));
Dwarf_Op *expr;
size_t exprlen;
if (dwarf_getlocation (&attr, &expr, &exprlen) == 0)
{
// Covers all ranges of the function.
// Evaluate the expression block for each range.
ptrdiff_t offset = 0;
Dwarf_Addr base, begin, end;
do
{
offset = dwarf_ranges (funcdie, offset, &base,
&begin, &end);
if (offset < 0)
error (EXIT_FAILURE, 0, "dwarf_ranges: %s",
dwarf_errmsg (-1));
if (offset > 0)
{
if (exprlen == 0)
printf (" (%"
PRIx64 ",%" PRIx64
") <empty expression>\n", begin, end);
else
print_expr_block_addrs (&attr, begin, end,
expr, exprlen);
}
}
while (offset > 0);
if (offset < 0)
error (EXIT_FAILURE, 0, "dwarf_ranges: %s",
dwarf_errmsg (-1));
}
else
{
Dwarf_Addr base, begin, end;
ptrdiff_t offset = 0;
while ((offset = dwarf_getlocations (&attr, offset,
&base, &begin, &end,
&expr, &exprlen)) > 0)
if (begin >= end)
printf (" (%" PRIx64 ",%" PRIx64
") <empty range>\n", begin, end); // XXX report?
else
{
print_expr_block_addrs (&attr, begin, end,
expr, exprlen);
// Extra sanity check for dwarf_getlocation_addr
// Must at least find one range for begin and end-1.
Dwarf_Op *expraddr;
size_t expraddr_len;
int locs = dwarf_getlocation_addr (&attr, begin,
&expraddr,
&expraddr_len, 1);
assert (locs == 1);
locs = dwarf_getlocation_addr (&attr, end - 1,
&expraddr,
&expraddr_len, 1);
assert (locs == 1);
}
if (offset < 0)
error (EXIT_FAILURE, 0, "dwarf_getlocations: %s",
dwarf_errmsg (-1));
}
}
else if (dwarf_hasattr (&child, DW_AT_const_value))
{
printf (" <constant value>\n"); // Lookup type and print.
}
else
{
printf (" <no value>\n");
}
}
}
while (dwarf_siblingof (&child, &child) == 0);
}
static void
print_expr (Dwarf_Attribute *attr, Dwarf_Op *expr, Dwarf_Addr addr)
{
uint8_t atom = expr->atom;
const char *opname = dwarf_opcode_string (atom);
assert (opname != NULL);
switch (atom)
{
case DW_OP_deref:
case DW_OP_dup:
case DW_OP_drop:
case DW_OP_over:
case DW_OP_swap:
case DW_OP_rot:
case DW_OP_xderef:
case DW_OP_abs:
case DW_OP_and:
case DW_OP_div:
case DW_OP_minus:
case DW_OP_mod:
case DW_OP_mul:
case DW_OP_neg:
case DW_OP_not:
case DW_OP_or:
case DW_OP_plus:
case DW_OP_shl:
case DW_OP_shr:
case DW_OP_shra:
case DW_OP_xor:
case DW_OP_eq:
case DW_OP_ge:
case DW_OP_gt:
case DW_OP_le:
case DW_OP_lt:
case DW_OP_ne:
case DW_OP_lit0 ... DW_OP_lit31:
case DW_OP_reg0 ... DW_OP_reg31:
case DW_OP_nop:
case DW_OP_stack_value:
/* No arguments. */
printf ("%s", opname);
break;
case DW_OP_form_tls_address:
/* No arguments. Special. Pops an address and pushes the
corresponding address in the current thread local
storage. Uses the thread local storage block of the defining
module (executable, shared library). */
printf ("%s", opname);
break;
case DW_OP_GNU_push_tls_address:
/* No arguments. Special. Not the same as DW_OP_form_tls_address.
Pops an offset into the current thread local strorage and
pushes back the actual address. */
printf ("%s", opname);
break;
case DW_OP_call_frame_cfa:
/* No arguments. Special. Pushes Call Frame Address as computed
by CFI data (dwarf_cfi_addrframe will fetch that info (either from
the .eh_frame or .debug_frame CFI) and dwarf_frame_cfa translatesr
the CFI instructions into a plain DWARF expression.
Never used in CFI itself. */
if (attr == NULL)
error (EXIT_FAILURE, 0, "%s used in CFI", opname);
printf ("%s ", opname);
if (cfi_eh == NULL && cfi_debug == NULL)
error (EXIT_FAILURE, 0, "DW_OP_call_frame_cfa used but no cfi found.");
Dwarf_Frame *frame;
if (dwarf_cfi_addrframe (cfi_eh, addr + cfi_eh_bias, &frame) != 0
&& dwarf_cfi_addrframe (cfi_debug, addr, &frame) != 0)
error (EXIT_FAILURE, 0, "dwarf_cfi_addrframe 0x%" PRIx64 ": %s",
addr, dwarf_errmsg (-1));
Dwarf_Op *cfa_ops;
size_t cfa_nops;
if (dwarf_frame_cfa (frame, &cfa_ops, &cfa_nops) != 0)
error (EXIT_FAILURE, 0, "dwarf_frame_cfa 0x%" PRIx64 ": %s",
addr, dwarf_errmsg (-1));
if (cfa_nops < 1)
error (EXIT_FAILURE, 0, "dwarf_frame_cfa no ops");
print_expr_block (NULL, cfa_ops, cfa_nops, 0);
free (frame);
break;
case DW_OP_push_object_address:
/* No arguments. Special. Pushes object address explicitly.
Normally only done implicitly by DW_AT_data_member_location.
Never used in CFI. */
if (attr == NULL)
error (EXIT_FAILURE, 0, "%s used in CFI", opname);
printf ("%s", opname);
break;
case DW_OP_addr:
/* 1 address argument. */
printf ("%s(0x%" PRIx64 ")", opname, (Dwarf_Addr) expr->number);
break;
case DW_OP_const1u:
case DW_OP_const2u:
case DW_OP_const4u:
case DW_OP_const8u:
case DW_OP_constu:
case DW_OP_pick:
case DW_OP_plus_uconst:
case DW_OP_regx:
case DW_OP_piece:
case DW_OP_deref_size:
case DW_OP_xderef_size:
/* 1 numeric unsigned argument. */
printf ("%s(%" PRIu64 ")", opname, expr->number);
break;
case DW_OP_call2:
case DW_OP_call4:
case DW_OP_call_ref:
/* 1 DIE offset argument for more ops in location attribute of DIE.
Never used in CFI. */
{
if (attr == NULL)
error (EXIT_FAILURE, 0, "%s used in CFI", opname);
Dwarf_Attribute call_attr;
if (dwarf_getlocation_attr (attr, expr, &call_attr) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_attr for %s error %s",
opname, dwarf_errmsg (-1));
Dwarf_Die call_die;
if (dwarf_getlocation_die (attr, expr, &call_die) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_die for %s error %s",
opname, dwarf_errmsg (-1));
Dwarf_Op *call_ops;
size_t call_len;
if (dwarf_getlocation (&call_attr, &call_ops, &call_len) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation for entry: %s",
dwarf_errmsg (-1));
printf ("%s([%" PRIx64 "]) ", opname, dwarf_dieoffset (&call_die));
print_expr_block (&call_attr, call_ops, call_len, addr);
}
break;
case DW_OP_const1s:
case DW_OP_const2s:
case DW_OP_const4s:
case DW_OP_const8s:
case DW_OP_consts:
case DW_OP_skip:
case DW_OP_bra:
case DW_OP_breg0 ... DW_OP_breg31:
/* 1 numeric signed argument. */
printf ("%s(%" PRId64 ")", opname, (Dwarf_Sword) expr->number);
break;
case DW_OP_fbreg:
/* 1 numeric signed argument. Offset from frame base. */
if (attr == NULL)
error (EXIT_FAILURE, 0, "%s used in CFI", opname);
if (! has_frame_base)
error (EXIT_FAILURE, 0, "DW_OP_fbreg used without a frame base");
printf ("%s(%" PRId64 ")", opname, (Dwarf_Sword) expr->number);
break;
case DW_OP_bregx:
/* 2 arguments, unsigned register number, signed offset. */
printf ("%s(%" PRIu64 ",%" PRId64 ")", opname,
expr->number, (Dwarf_Sword) expr->number2);
break;
case DW_OP_bit_piece:
/* 2 arguments, unsigned size, unsigned offset. */
printf ("%s(%" PRIu64 ",%" PRIu64 ")", opname,
expr->number, expr->number2);
break;
case DW_OP_implicit_value:
/* Special, unsigned size plus block. */
{
Dwarf_Attribute const_attr;
Dwarf_Block block;
if (dwarf_getlocation_attr (attr, expr, &const_attr) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_attr: %s",
dwarf_errmsg (-1));
if (dwarf_formblock (&const_attr, &block) != 0)
error (EXIT_FAILURE, 0, "dwarf_formblock: %s",
dwarf_errmsg (-1));
/* This is the "old" way. Check they result in the same. */
Dwarf_Block block_impl;
if (dwarf_getlocation_implicit_value (attr, expr, &block_impl) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_implicit_value: %s",
dwarf_errmsg (-1));
assert (expr->number == block.length);
assert (block.length == block_impl.length);
printf ("%s(%" PRIu64 "){", opname, block.length);
for (size_t i = 0; i < block.length; i++)
{
printf ("%02x", block.data[i]);
assert (block.data[i] == block_impl.data[i]);
}
printf("}");
}
break;
case DW_OP_GNU_implicit_pointer:
/* Special, DIE offset, signed offset. Referenced DIE has a
location or const_value attribute. */
{
if (attr == NULL)
error (EXIT_FAILURE, 0, "%s used in CFI", opname);
Dwarf_Attribute attrval;
if (dwarf_getlocation_implicit_pointer (attr, expr, &attrval) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_implicit_pointer: %s",
dwarf_errmsg (-1));
// Sanity check, results should be the same.
Dwarf_Attribute attrval2;
if (dwarf_getlocation_attr (attr, expr, &attrval2) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_attr: %s",
dwarf_errmsg (-1));
assert (dwarf_whatattr (&attrval) == dwarf_whatattr (&attrval2));
assert (dwarf_whatform (&attrval) == dwarf_whatform (&attrval2));
// In theory two different valp pointers could point to the same
// value. But here we really expect them to be the equal.
assert (attrval.valp == attrval2.valp);
Dwarf_Die impl_die;
if (dwarf_getlocation_die (attr, expr, &impl_die) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_due: %s",
dwarf_errmsg (-1));
printf ("%s([%" PRIx64 "],%" PRId64 ") ", opname,
dwarf_dieoffset (&impl_die), expr->number2);
if (dwarf_whatattr (&attrval) == DW_AT_const_value)
printf ("<constant value>"); // Lookup type...
else
{
// Lookup the location description at the current address.
Dwarf_Op *exprval;
size_t exprval_len;
int locs = dwarf_getlocation_addr (&attrval, addr,
&exprval, &exprval_len, 1);
if (locs == 0)
printf ("<no location>"); // This means "optimized out".
else if (locs == 1)
print_expr_block (&attrval, exprval, exprval_len, addr);
else
error (EXIT_FAILURE, 0,
"dwarf_getlocation_addr attrval at addr 0x%" PRIx64
", locs (%d): %s", addr, locs, dwarf_errmsg (-1));
}
}
break;
case DW_OP_GNU_entry_value:
/* Special, unsigned size plus expression block. All registers
inside the block should be interpreted as they had on
entering the function. dwarf_getlocation_attr will return an
attribute containing the block as locexpr which can be
retrieved with dwarf_getlocation. */
{
Dwarf_Attribute entry_attr;
if (dwarf_getlocation_attr (attr, expr, &entry_attr) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_attr: %s",
dwarf_errmsg (-1));
Dwarf_Op *entry_ops;
size_t entry_len;
if (dwarf_getlocation (&entry_attr, &entry_ops, &entry_len) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation for entry: %s",
dwarf_errmsg (-1));
printf ("%s(%zd) ", opname, entry_len);
print_expr_block (attr, entry_ops, entry_len, addr);
}
break;
case DW_OP_GNU_parameter_ref:
/* Special, unsigned CU relative DIE offset pointing to a
DW_TAG_formal_parameter. The value that parameter had at the
call site of the current function will be put on the DWARF
stack. The value can be retrieved by finding the
DW_TAG_GNU_call_site_parameter which has as
DW_AT_abstract_origin the same formal parameter DIE. */
{
Dwarf_Die param;
if (dwarf_getlocation_die (attr, expr, ¶m) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_die: %s",
dwarf_errmsg (-1));
// XXX actually lookup DW_TAG_GNU_call_site_parameter
printf ("%s[%" PRIx64 "]", opname, dwarf_dieoffset (¶m));
assert (expr->number == dwarf_cuoffset (¶m));
assert (dwarf_tag (¶m) == DW_TAG_formal_parameter);
}
break;
case DW_OP_GNU_convert:
case DW_OP_GNU_reinterpret:
/* Special, unsigned CU relative DIE offset pointing to a
DW_TAG_base_type. Pops a value, converts or reinterprets the
value to the given type. When the argument is zero the value
becomes untyped again. */
{
Dwarf_Die type;
Dwarf_Off off = expr->number;
if (off != 0)
{
if (dwarf_getlocation_die (attr, expr, &type) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_die: %s",
dwarf_errmsg (-1));
off = dwarf_dieoffset (&type);
assert (expr->number == dwarf_cuoffset (&type));
printf ("%s", opname);
print_base_type (&type);
}
else
printf ("%s[%" PRIu64 "]", opname, off);
}
break;
case DW_OP_GNU_regval_type:
/* Special, unsigned register number plus unsigned CU relative
DIE offset pointing to a DW_TAG_base_type. */
{
Dwarf_Die type;
if (dwarf_getlocation_die (attr, expr, &type) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_die: %s",
dwarf_errmsg (-1));
assert (expr->number2 == dwarf_cuoffset (&type));
// XXX check size against base_type size?
printf ("%s(reg%" PRIu64 ")", opname, expr->number);
print_base_type (&type);
}
break;
case DW_OP_GNU_deref_type:
/* Special, unsigned size plus unsigned CU relative DIE offset
pointing to a DW_TAG_base_type. */
{
Dwarf_Die type;
if (dwarf_getlocation_die (attr, expr, &type) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_die: %s",
dwarf_errmsg (-1));
assert (expr->number2 == dwarf_cuoffset (&type));
// XXX check size against base_type size?
printf ("%s(%" PRIu64 ")", opname, expr->number);
print_base_type (&type);
}
break;
case DW_OP_GNU_const_type:
/* Special, unsigned CU relative DIE offset pointing to a
DW_TAG_base_type, an unsigned size length plus a block with
the constant value. */
{
Dwarf_Die type;
if (dwarf_getlocation_die (attr, expr, &type) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_die: %s",
dwarf_errmsg (-1));
assert (expr->number == dwarf_cuoffset (&type));
Dwarf_Attribute const_attr;
if (dwarf_getlocation_attr (attr, expr, &const_attr) != 0)
error (EXIT_FAILURE, 0, "dwarf_getlocation_attr for type: %s",
dwarf_errmsg (-1));
Dwarf_Block block;
if (dwarf_formblock (&const_attr, &block) != 0)
error (EXIT_FAILURE, 0, "dwarf_formblock for type: %s",
dwarf_errmsg (-1));
printf ("%s", opname);
print_base_type (&type);
printf ("(%" PRIu64 ")[", block.length);
for (size_t i = 0; i < block.length; i++)
printf ("%02x", block.data[i]);
printf("]");
}
break;
default:
error (EXIT_FAILURE, 0, "unhandled opcode: DW_OP_%s (0x%x)",
opname, atom);
}
}
