/* BASE must be a base type DIE referenced by a typed DWARF expression op. */
static void
print_base_type (Dwarf_Die *base)
{
assert (dwarf_tag (base) == DW_TAG_base_type);
Dwarf_Attribute encoding;
Dwarf_Word enctype;
if (dwarf_attr (base, DW_AT_encoding, &encoding) == NULL
|| dwarf_formudata (&encoding, &enctype) != 0)
error (EXIT_FAILURE, 0, "base type without encoding");
Dwarf_Attribute bsize;
Dwarf_Word bits;
if (dwarf_attr (base, DW_AT_byte_size, &bsize) != NULL
&& dwarf_formudata (&bsize, &bits) == 0)
bits *= 8;
else if (dwarf_attr (base, DW_AT_bit_size, &bsize) == NULL
|| dwarf_formudata (&bsize, &bits) != 0)
error (EXIT_FAILURE, 0, "base type without byte or bit size");
printf ("{%s,%s,%" PRIu64 "@[%" PRIx64 "]}",
dwarf_diename (base),
dwarf_encoding_string (enctype),
bits,
dwarf_dieoffset (base));
}
static void DC_resolve_type(Dwarf_Die v, DC_type *t){
/*TODO: Error Handling*/
Dwarf_Error error;
Dwarf_Attribute type;
Dwarf_Off off;
Dwarf_Die typeDie;
Dwarf_Half tag = 0;
/*
* Start with the variable, not its type. The loop
* unwraps all the types.
*/
dwarf_attr(v, DW_AT_type, &type, &error);
dwarf_formref(type, &off, &error);
DC_get_die_from_CU_relative_offset(v, off, &typeDie);
int points = 0;
int arrs = 0;
while( 1 ){
Dwarf_Bool has;
dwarf_hasattr(typeDie,DW_AT_type,&has,&error);
if(!has){
/*We've reached a base or structure type*/
dwarf_diename(typeDie,&(t->name),&error);
Dwarf_Attribute bsize;
dwarf_attr(typeDie,DW_AT_byte_size,&bsize,&error);
dwarf_formudata(bsize,(Dwarf_Unsigned*)(&t->byteSize),&error);
t->indirectionLevel = points;
t->arrayLevel = arrs;
return;
/*Note: I am assuming this must happen eventually. can there
* be mutually referencing types?*/
}
/*Otherwise: this type has a type, so it is a pointer or a typedef
* or an array type. For now, we're only going to correctly
* handle pointer types.(TODO:)
*/
dwarf_tag(typeDie,&tag,&error);
if(tag == DW_TAG_pointer_type){
points++;
}
if(tag == DW_TAG_array_type){
arrs++;
}
dwarf_attr(typeDie, DW_AT_type, &type, &error);
dwarf_formref(type, &off, &error);
/*Note, the next line uses v, because it can use anything in the CU*/
DC_get_die_from_CU_relative_offset(v, off, &typeDie);
}
}
bool supported_language(Dwarf_Die *cu)
{
int ret;
Dwarf_Word lang;
Dwarf_Attribute at;
if (dwarf_attr(cu, DW_AT_language, &at) == NULL)
{
warn("CU %s: unknown language", dwarf_diename(cu));
return false;
}
ret = dwarf_formudata(&at, &lang);
fail_if(ret == -1, "dwarf_formudata");
switch (lang)
{
case DW_LANG_C89:
case DW_LANG_C:
case DW_LANG_C99:
/* good! */
break;
case DW_LANG_C_plus_plus:
warn("CU %s: C++ not supported", dwarf_diename(cu));
return false;
break;
default:
debug("CU %s: unsupported language: 0x%lx",
dwarf_diename(cu), (unsigned long)lang);
return false;
break;
}
return true;
}
/**
* 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;
}
/* Get the size (in words) */
static int get_size(Dwarf_Debug dbg, Dwarf_Die die)
{
Dwarf_Attribute attr;
Dwarf_Unsigned size;
int ret;
ret = dwarf_attr(die, DW_AT_byte_size, &attr, NULL);
if (ret != DW_DLV_OK)
{
fprintf(stderr, "SET dwarf: Error in dwarf_attr()\n");
return 1;
}
ret = dwarf_formudata(attr, &size, NULL);
dwarf_dealloc(dbg, attr, DW_DLA_ATTR);
if (ret != DW_DLV_OK)
{
fprintf(stderr, "SET dwarf: Error in dwarf_formudata()\n");
return 1;
}
/* Increment the parameter number of the function */
func_dwarf[local_func_idx].param_size += (size + 3) >> 2;
return 0;
}
static struct dwarf_subprogram_t *read_from_cus(Dwarf_Debug dbg)
{
Dwarf_Unsigned cu_header_length, abbrev_offset, next_cu_header;
Dwarf_Half version_stamp, address_size;
Dwarf_Error err;
Dwarf_Die no_die = 0, cu_die, child_die;
int ret = DW_DLV_OK;
struct dwarf_subprogram_t *subprograms = NULL;
Dwarf_Unsigned language = 0;
Dwarf_Attribute language_attr = 0;
while (ret == DW_DLV_OK) {
ret = dwarf_next_cu_header(
dbg,
&cu_header_length,
&version_stamp,
&abbrev_offset,
&address_size,
&next_cu_header,
&err);
DWARF_ASSERT(ret, err);
if (ret == DW_DLV_NO_ENTRY)
continue;
/* TODO: If the CU can provide an address range then we can skip over
* all the entire die if none of our addresses match */
/* Expect the CU to have a single sibling - a DIE */
ret = dwarf_siblingof(dbg, no_die, &cu_die, &err);
if (ret == DW_DLV_ERROR) {
continue;
}
DWARF_ASSERT(ret, err);
/* Get compilation unit language attribute */
ret = dwarf_attr(cu_die, DW_AT_language, &language_attr, &err);
DWARF_ASSERT(ret, err);
if (ret != DW_DLV_NO_ENTRY) {
/* Get language attribute data */
ret = dwarf_formudata(language_attr, &language, &err);
DWARF_ASSERT(ret, err);
dwarf_dealloc(dbg, language_attr, DW_DLA_ATTR);
}
/* Expect the CU DIE to have children */
ret = dwarf_child(cu_die, &child_die, &err);
DWARF_ASSERT(ret, err);
handle_die(&subprograms, dbg, cu_die, child_die, language);
dwarf_dealloc(dbg, cu_die, DW_DLA_DIE);
}
return subprograms;
}
static uint64_t MC_dwarf_attr_integrate_uint(Dwarf_Die * die, int attribute,
uint64_t default_value)
{
Dwarf_Attribute attr;
if (dwarf_attr_integrate(die, attribute, &attr) == nullptr)
return default_value;
Dwarf_Word value;
return dwarf_formudata(dwarf_attr_integrate(die, attribute, &attr),
&value) == 0 ? (uint64_t) value : default_value;
}
/** \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 int die_get_byte_size(Dwarf_Die *tp_die)
{
Dwarf_Attribute attr;
Dwarf_Word ret;
if (dwarf_attr(tp_die, DW_AT_byte_size, &attr) == NULL ||
dwarf_formudata(&attr, &ret) != 0)
return 0;
return (int)ret;
}
/**
* die_get_call_lineno - Get callsite line number of inline-function instance
* @in_die: a DIE of an inlined function instance
*
* Get call-site line number of @in_die. This means from where the inline
* function is called.
*/
int die_get_call_lineno(Dwarf_Die *in_die)
{
Dwarf_Attribute attr;
Dwarf_Word ret;
if (!dwarf_attr(in_die, DW_AT_call_line, &attr))
return -ENOENT;
dwarf_formudata(&attr, &ret);
return (int)ret;
}
/* Get attribute and translate it as a udata */
static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
Dwarf_Word *result)
{
Dwarf_Attribute attr;
if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
dwarf_formudata(&attr, result) != 0)
return -ENOENT;
return 0;
}
static bool die_is_signed_type(Dwarf_Die *tp_die)
{
Dwarf_Attribute attr;
Dwarf_Word ret;
if (dwarf_attr(tp_die, DW_AT_encoding, &attr) == NULL ||
dwarf_formudata(&attr, &ret) != 0)
return false;
return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
ret == DW_ATE_signed_fixed);
}
/* Helper routine to avoid code duplication.
*/
static int
_dwarf_get_loclist_header_start(Dwarf_Debug dbg,
Dwarf_Attribute attr,
Dwarf_Unsigned * loclist_offset,
Dwarf_Error * error)
{
int blkres = dwarf_formudata(attr, loclist_offset, error);
if (blkres != DW_DLV_OK) {
return (blkres);
}
if (!dbg->de_debug_loc.dss_data) {
int secload = _dwarf_load_section(dbg, &dbg->de_debug_loc,error);
if (secload != DW_DLV_OK) {
return secload;
}
}
return DW_DLV_OK;
}
static void
get_number(Dwarf_Attribute attr,Dwarf_Unsigned *val)
{
Dwarf_Error error = 0;
int res;
Dwarf_Signed sval = 0;
Dwarf_Unsigned uval = 0;
res = dwarf_formudata(attr,&uval,&error);
if(res == DW_DLV_OK) {
*val = uval;
return;
}
res = dwarf_formsdata(attr,&sval,&error);
if(res == DW_DLV_OK) {
*val = sval;
return;
}
return;
}
int get_small_encoding_value(Dwarf_Attribute attrib, Dwarf_Signed *val, Dwarf_Error *err)
{
Dwarf_Unsigned uval = 0;
int ret = dwarf_formudata(attrib, &uval, err);
if(ret != DW_DLV_OK)
{
Dwarf_Signed sval = 0;
ret = dwarf_formsdata(attrib, &sval, err);
if(ret == DW_DLV_OK)
{
*val = sval;
}
}
else
{
*val = uval;
}
return ret;
}
static int
die_unsigned(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Unsigned *valp,
int req)
{
Dwarf_Attribute attr;
Dwarf_Unsigned val;
if ((attr = die_attr(dw, die, name, req)) == NULL)
return (0); /* die_attr will terminate for us if necessary */
if (dwarf_formudata(attr, &val, &dw->dw_err) != DW_DLV_OK) {
terminate("die %llu: failed to get unsigned (form 0x%x)\n",
die_off(dw, die), die_attr_form(dw, attr));
}
dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR);
*valp = val;
return (1);
}
BT_HIDDEN
int bt_dwarf_die_get_call_line(struct bt_dwarf_die *die,
uint64_t *line_no)
{
int ret = 0;
Dwarf_Attribute *line_attr = NULL;
uint64_t _line_no;
if (!die || !line_no) {
goto error;
}
line_attr = g_new0(Dwarf_Attribute, 1);
if (!line_attr) {
goto error;
}
line_attr = dwarf_attr(die->dwarf_die, DW_AT_call_line, line_attr);
if (!line_attr) {
goto error;
}
ret = dwarf_formudata(line_attr, &_line_no);
if (ret) {
goto error;
}
*line_no = _line_no;
g_free(line_attr);
return 0;
error:
g_free(line_attr);
return -1;
}
int
arm_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
{
/* Start with the function's type, and get the DW_AT_type attribute,
which is the type of the return value. */
Dwarf_Attribute attr_mem;
Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type,
&attr_mem);
if (attr == NULL)
/* The function has no return value, like a `void' function in C. */
return 0;
Dwarf_Die die_mem;
Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem);
int tag = DWARF_TAG_OR_RETURN (typedie);
/* Follow typedefs and qualifiers to get to the actual type. */
while (tag == DW_TAG_typedef
|| tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
|| tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = DWARF_TAG_OR_RETURN (typedie);
}
Dwarf_Word size;
switch (tag)
{
case -1:
return -1;
case DW_TAG_subrange_type:
if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size))
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = DWARF_TAG_OR_RETURN (typedie);
}
/* Fall through. */
case DW_TAG_base_type:
case DW_TAG_enumeration_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
&attr_mem), &size) != 0)
{
if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
size = 4;
else
return -1;
}
if (size <= 16)
{
intreg:
*locp = loc_intreg;
return size <= 4 ? nloc_intreg : nloc_intregs ((size + 3) / 4);
}
aggregate:
*locp = loc_aggregate;
return nloc_aggregate;
case DW_TAG_structure_type:
case DW_TAG_class_type:
case DW_TAG_union_type:
case DW_TAG_array_type:
if (dwarf_aggregate_size (typedie, &size) == 0
&& size > 0 && size <= 4)
goto intreg;
goto aggregate;
}
/* XXX We don't have a good way to return specific errors from ebl calls.
This value means we do not understand the type, but it is well-formed
DWARF and might be valid. */
return -2;
}
QVariant DwarfDie::attributeLocal(Dwarf_Half attributeType) const
{
Dwarf_Attribute attr;
auto res = dwarf_attr(m_die, attributeType, &attr, nullptr);
if (res != DW_DLV_OK)
return {};
Dwarf_Half formType;
res = dwarf_whatform(attr, &formType, nullptr);
if (res != DW_DLV_OK)
return {};
QVariant value;
switch (formType) {
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_data8:
case DW_FORM_udata:
{
Dwarf_Unsigned n;
res = dwarf_formudata(attr, &n, nullptr);
value = n;
break;
}
case DW_FORM_sdata:
{
Dwarf_Signed n;
res = dwarf_formsdata(attr, &n, nullptr);
value = n;
break;
}
case DW_FORM_string:
case DW_FORM_strp:
{
char *str;
res = dwarf_formstring(attr, &str, nullptr);
value = QByteArray(str);
break;
}
case DW_FORM_flag:
case DW_FORM_flag_present:
{
Dwarf_Bool b;
res = dwarf_formflag(attr, &b, nullptr);
value = b ? true : false;
break;
}
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref8:
{
Dwarf_Off offset;
res = dwarf_global_formref(attr, &offset, nullptr);
value = QVariant::fromValue(dwarfInfo()->dieAtOffset(offset));
break;
}
case DW_FORM_sec_offset:
{
Dwarf_Off offset;
res = dwarf_global_formref(attr, &offset, nullptr);
value = offset;
break;
}
case DW_FORM_addr:
{
Dwarf_Addr addr;
res = dwarf_formaddr(attr, &addr, nullptr);
value = addr;
break;
}
case DW_FORM_exprloc:
{
Dwarf_Unsigned len;
Dwarf_Ptr block;
res = dwarf_formexprloc(attr, &len, &block, nullptr);
value = QVariant::fromValue(DwarfExpression(block, len, dwarfInfo()->elfFile()->addressSize()));
break;
}
default:
{
const char* formName;
res = dwarf_get_FORM_name(formType, &formName);
if (res != DW_DLV_OK)
return {};
value = QStringLiteral("TODO: ") + QString::fromLocal8Bit(formName);
break;
}
}
// post-process some well-known types
switch (attributeType) {
case DW_AT_decl_file:
case DW_AT_call_file:
{
const auto fileIndex = value.value<Dwarf_Unsigned>();
// index 0 means not present, TODO handle that
value = compilationUnit()->sourceFileForIndex(fileIndex -1);
break;
}
case DW_AT_ranges:
value = QVariant::fromValue(DwarfRanges(this, value.toLongLong()));
break;
case DW_AT_accessibility:
stringifyEnum(value, &dwarf_get_ACCESS_name);
break;
case DW_AT_language:
stringifyEnum(value, &dwarf_get_LANG_name);
break;
case DW_AT_virtuality:
value = QVariant::fromValue(static_cast<DwarfVirtuality>(value.toInt()));
break;
case DW_AT_visibility:
stringifyEnum(value, &dwarf_get_VIS_name);
break;
case DW_AT_identifier_case:
stringifyEnum(value, &dwarf_get_ID_name);
break;
case DW_AT_inline:
stringifyEnum(value, &dwarf_get_INL_name);
break;
case DW_AT_encoding:
stringifyEnum(value, &dwarf_get_ATE_name);
break;
case DW_AT_ordering:
stringifyEnum(value, &dwarf_get_ORD_name);
break;
case DW_AT_calling_convention:
stringifyEnum(value, &dwarf_get_CC_name);
break;
case DW_AT_discr_list:
stringifyEnum(value, &dwarf_get_DSC_name);
break;
default:
break;
}
return value;
}
void
handle (Dwarf *dbg, Dwarf_Die *die, int n)
{
Dwarf_Die child;
unsigned int tag;
const char *str;
char buf[30];
const char *name;
Dwarf_Off off;
Dwarf_Off cuoff;
size_t cnt;
Dwarf_Addr addr;
int i;
tag = dwarf_tag (die);
if (tag != DW_TAG_invalid)
{
if (tag < ntagnames)
str = tagnames[tag];
else
{
snprintf (buf, sizeof buf, "%#x", tag);
str = buf;
}
}
else
str = "* NO TAG *";
name = dwarf_diename (die);
if (name == 0)
name = "* NO NAME *";
off = dwarf_dieoffset (die);
cuoff = dwarf_cuoffset (die);
printf ("%*s%s\n", n * 5, "", str);
printf ("%*s Name : %s\n", n * 5, "", name);
printf ("%*s Offset : %lld\n", n * 5, "", (long long int) off);
printf ("%*s CU offset : %lld\n", n * 5, "", (long long int) cuoff);
printf ("%*s Attrs :", n * 5, "");
for (cnt = 0; cnt < nattrs; ++cnt)
if (dwarf_hasattr (die, attrs[cnt].code))
printf (" %s", attrs[cnt].name);
puts ("");
if (dwarf_hasattr (die, DW_AT_low_pc) && dwarf_lowpc (die, &addr) == 0)
{
Dwarf_Attribute attr;
Dwarf_Addr addr2;
printf ("%*s low PC : %#llx\n",
n * 5, "", (unsigned long long int) addr);
if (dwarf_attr (die, DW_AT_low_pc, &attr) == NULL
|| dwarf_formaddr (&attr, &addr2) != 0
|| addr != addr2)
puts ("************* DW_AT_low_pc verify failed ************");
else if (! dwarf_hasform (&attr, DW_FORM_addr))
puts ("************* DW_AT_low_pc form failed ************");
else if (dwarf_whatform (&attr) != DW_FORM_addr)
puts ("************* DW_AT_low_pc form (2) failed ************");
else if (dwarf_whatattr (&attr) != DW_AT_low_pc)
puts ("************* DW_AT_low_pc attr failed ************");
}
if (dwarf_hasattr (die, DW_AT_high_pc) && dwarf_highpc (die, &addr) == 0)
{
Dwarf_Attribute attr;
Dwarf_Addr addr2;
printf ("%*s high PC : %#llx\n",
n * 5, "", (unsigned long long int) addr);
if (dwarf_attr (die, DW_AT_high_pc, &attr) == NULL
|| dwarf_formaddr (&attr, &addr2) != 0
|| addr != addr2)
puts ("************* DW_AT_high_pc verify failed ************");
else if (! dwarf_hasform (&attr, DW_FORM_addr))
puts ("************* DW_AT_high_pc form failed ************");
else if (dwarf_whatform (&attr) != DW_FORM_addr)
puts ("************* DW_AT_high_pc form (2) failed ************");
else if (dwarf_whatattr (&attr) != DW_AT_high_pc)
puts ("************* DW_AT_high_pc attr failed ************");
}
if (dwarf_hasattr (die, DW_AT_byte_size) && (i = dwarf_bytesize (die)) != -1)
{
Dwarf_Attribute attr;
Dwarf_Word u2;
unsigned int u;
printf ("%*s byte size : %d\n", n * 5, "", i);
if (dwarf_attr (die, DW_AT_byte_size, &attr) == NULL
|| dwarf_formudata (&attr, &u2) != 0
|| i != (int) u2)
puts ("************* DW_AT_byte_size verify failed ************");
else if (! dwarf_hasform (&attr, DW_FORM_data1)
&& ! dwarf_hasform (&attr, DW_FORM_data2)
&& ! dwarf_hasform (&attr, DW_FORM_data4)
&& ! dwarf_hasform (&attr, DW_FORM_data8)
&& ! dwarf_hasform (&attr, DW_FORM_sdata)
&& ! dwarf_hasform (&attr, DW_FORM_udata))
puts ("************* DW_AT_byte_size form failed ************");
else if ((u = dwarf_whatform (&attr)) == 0
|| (u != DW_FORM_data1
&& u != DW_FORM_data2
&& u != DW_FORM_data4
&& u != DW_FORM_data8
&& u != DW_FORM_sdata
&& u != DW_FORM_udata))
puts ("************* DW_AT_byte_size form (2) failed ************");
else if (dwarf_whatattr (&attr) != DW_AT_byte_size)
puts ("************* DW_AT_byte_size attr failed ************");
}
if (dwarf_hasattr (die, DW_AT_bit_size) && (i = dwarf_bitsize (die)) != -1)
{
Dwarf_Attribute attr;
Dwarf_Word u2;
unsigned int u;
printf ("%*s bit size : %d\n", n * 5, "", i);
if (dwarf_attr (die, DW_AT_bit_size, &attr) == NULL
|| dwarf_formudata (&attr, &u2) != 0
|| i != (int) u2)
puts ("************* DW_AT_bit_size test failed ************");
else if (! dwarf_hasform (&attr, DW_FORM_data1)
&& ! dwarf_hasform (&attr, DW_FORM_data2)
&& ! dwarf_hasform (&attr, DW_FORM_data4)
&& ! dwarf_hasform (&attr, DW_FORM_data8)
&& ! dwarf_hasform (&attr, DW_FORM_sdata)
&& ! dwarf_hasform (&attr, DW_FORM_udata))
puts ("************* DW_AT_bit_size form failed ************");
else if ((u = dwarf_whatform (&attr)) == 0
|| (u != DW_FORM_data1
&& u != DW_FORM_data2
&& u != DW_FORM_data4
&& u != DW_FORM_data8
&& u != DW_FORM_sdata
&& u != DW_FORM_udata))
puts ("************* DW_AT_bit_size form (2) failed ************");
else if (dwarf_whatattr (&attr) != DW_AT_bit_size)
puts ("************* DW_AT_bit_size attr failed ************");
}
if (dwarf_hasattr (die, DW_AT_bit_offset)
&& (i = dwarf_bitoffset (die)) != -1)
{
Dwarf_Attribute attr;
Dwarf_Word u2;
unsigned int u;
printf ("%*s bit offset: %d\n", n * 5, "", i);
if (dwarf_attr (die, DW_AT_bit_offset, &attr) == NULL
|| dwarf_formudata (&attr, &u2) != 0
|| i != (int) u2)
puts ("************* DW_AT_bit_offset test failed ************");
else if (! dwarf_hasform (&attr, DW_FORM_data1)
&& ! dwarf_hasform (&attr, DW_FORM_data2)
&& ! dwarf_hasform (&attr, DW_FORM_data4)
&& ! dwarf_hasform (&attr, DW_FORM_data8)
&& ! dwarf_hasform (&attr, DW_FORM_sdata)
&& ! dwarf_hasform (&attr, DW_FORM_udata))
puts ("************* DW_AT_bit_offset form failed ************");
else if ((u = dwarf_whatform (&attr)) == 0
|| (u != DW_FORM_data1
&& u != DW_FORM_data2
&& u != DW_FORM_data4
&& u != DW_FORM_data8
&& u != DW_FORM_sdata
&& u != DW_FORM_udata))
puts ("************* DW_AT_bit_offset form (2) failed ************");
else if (dwarf_whatattr (&attr) != DW_AT_bit_offset)
puts ("************* DW_AT_bit_offset attr failed ************");
}
if (dwarf_hasattr (die, DW_AT_language) && (i = dwarf_srclang (die)) != -1)
{
Dwarf_Attribute attr;
Dwarf_Word u2;
unsigned int u;
printf ("%*s language : %d\n", n * 5, "", i);
if (dwarf_attr (die, DW_AT_language, &attr) == NULL
|| dwarf_formudata (&attr, &u2) != 0
|| i != (int) u2)
puts ("************* DW_AT_language test failed ************");
else if (! dwarf_hasform (&attr, DW_FORM_data1)
&& ! dwarf_hasform (&attr, DW_FORM_data2)
&& ! dwarf_hasform (&attr, DW_FORM_data4)
&& ! dwarf_hasform (&attr, DW_FORM_data8)
&& ! dwarf_hasform (&attr, DW_FORM_sdata)
&& ! dwarf_hasform (&attr, DW_FORM_udata))
puts ("************* DW_AT_language form failed ************");
else if ((u = dwarf_whatform (&attr)) == 0
|| (u != DW_FORM_data1
&& u != DW_FORM_data2
&& u != DW_FORM_data4
&& u != DW_FORM_data8
&& u != DW_FORM_sdata
&& u != DW_FORM_udata))
puts ("************* DW_AT_language form (2) failed ************");
else if (dwarf_whatattr (&attr) != DW_AT_language)
puts ("************* DW_AT_language attr failed ************");
}
if (dwarf_hasattr (die, DW_AT_ordering)
&& (i = dwarf_arrayorder (die)) != -1)
{
Dwarf_Attribute attr;
Dwarf_Word u2;
unsigned int u;
printf ("%*s ordering : %d\n", n * 5, "", i);
if (dwarf_attr (die, DW_AT_ordering, &attr) == NULL
|| dwarf_formudata (&attr, &u2) != 0
|| i != (int) u2)
puts ("************* DW_AT_ordering test failed ************");
else if (! dwarf_hasform (&attr, DW_FORM_data1)
&& ! dwarf_hasform (&attr, DW_FORM_data2)
&& ! dwarf_hasform (&attr, DW_FORM_data4)
&& ! dwarf_hasform (&attr, DW_FORM_data8)
&& ! dwarf_hasform (&attr, DW_FORM_sdata)
&& ! dwarf_hasform (&attr, DW_FORM_udata))
puts ("************* DW_AT_ordering failed ************");
else if ((u = dwarf_whatform (&attr)) == 0
|| (u != DW_FORM_data1
&& u != DW_FORM_data2
&& u != DW_FORM_data4
&& u != DW_FORM_data8
&& u != DW_FORM_sdata
&& u != DW_FORM_udata))
puts ("************* DW_AT_ordering form (2) failed ************");
else if (dwarf_whatattr (&attr) != DW_AT_ordering)
puts ("************* DW_AT_ordering attr failed ************");
}
if (dwarf_hasattr (die, DW_AT_comp_dir))
{
Dwarf_Attribute attr;
if (dwarf_attr (die, DW_AT_comp_dir, &attr) == NULL
|| (name = dwarf_formstring (&attr)) == NULL)
puts ("************* DW_AT_comp_dir attr failed ************");
else
printf ("%*s directory : %s\n", n * 5, "", name);
}
if (dwarf_hasattr (die, DW_AT_producer))
{
Dwarf_Attribute attr;
if (dwarf_attr (die, DW_AT_producer, &attr) == NULL
|| (name = dwarf_formstring (&attr)) == NULL)
puts ("************* DW_AT_comp_dir attr failed ************");
else
printf ("%*s producer : %s\n", n * 5, "", name);
}
if (dwarf_haschildren (die) != 0 && dwarf_child (die, &child) == 0)
handle (dbg, &child, n + 1);
if (dwarf_siblingof (die, die) == 0)
handle (dbg, die, n);
}
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;
}
int
x86_64_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
{
/* Start with the function's type, and get the DW_AT_type attribute,
which is the type of the return value. */
Dwarf_Attribute attr_mem;
Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type,
&attr_mem);
if (attr == NULL)
/* The function has no return value, like a `void' function in C. */
return 0;
Dwarf_Die die_mem;
Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem);
int tag = DWARF_TAG_OR_RETURN (typedie);
/* Follow typedefs and qualifiers to get to the actual type. */
while (tag == DW_TAG_typedef
|| tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
|| tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = DWARF_TAG_OR_RETURN (typedie);
}
Dwarf_Word size;
switch (tag)
{
case -1:
return -1;
case DW_TAG_subrange_type:
if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size))
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = DWARF_TAG_OR_RETURN (typedie);
}
/* Fall through. */
case DW_TAG_base_type:
case DW_TAG_enumeration_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
&attr_mem), &size) != 0)
{
if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
size = 8;
else
return -1;
}
if (tag == DW_TAG_base_type)
{
Dwarf_Word encoding;
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_encoding,
&attr_mem),
&encoding) != 0)
return -1;
switch (encoding)
{
case DW_ATE_complex_float:
switch (size)
{
case 4 * 2: /* complex float */
case 8 * 2: /* complex double */
*locp = loc_ssereg;
return nloc_sseregpair;
case 16 * 2: /* complex long double */
*locp = loc_x87reg;
return nloc_x87regpair;
}
return -2;
case DW_ATE_float:
switch (size)
{
case 4: /* float */
case 8: /* double */
*locp = loc_ssereg;
return nloc_ssereg;
case 16: /* long double */
/* XXX distinguish __float128, which is sseregpair?? */
*locp = loc_x87reg;
return nloc_x87reg;
}
return -2;
}
}
intreg:
*locp = loc_intreg;
if (size <= 8)
return nloc_intreg;
if (size <= 16)
return nloc_intregpair;
large:
*locp = loc_aggregate;
return nloc_aggregate;
case DW_TAG_structure_type:
case DW_TAG_class_type:
case DW_TAG_union_type:
case DW_TAG_array_type:
if (dwarf_aggregate_size (typedie, &size) != 0)
goto large;
if (size > 16)
goto large;
/* XXX
Must examine the fields in picayune ways to determine the
actual answer. This will be right for small C structs
containing integer types and similarly simple cases.
*/
goto intreg;
}
/* XXX We don't have a good way to return specific errors from ebl calls.
This value means we do not understand the type, but it is well-formed
DWARF and might be valid. */
return -2;
}
/*
return DW_DLV_OK if ok. else DW_DLV_NO_ENTRY or DW_DLV_ERROR
*/
int
_dwarf_internal_printlines(Dwarf_Die die, Dwarf_Error * error)
{
/*
This pointer is used to scan the portion of the .debug_line
section for the current cu. */
Dwarf_Small *line_ptr;
Dwarf_Small *orig_line_ptr;
/*
This points to the last byte of the .debug_line portion for the
current cu. */
Dwarf_Small *line_ptr_end;
/*
This points to the end of the statement program prologue for the
current cu, and serves to check that the prologue was correctly
decoded. */
Dwarf_Small *check_line_ptr;
/*
Pointer to a DW_AT_stmt_list attribute in case it exists in the
die. */
Dwarf_Attribute stmt_list_attr;
/* Pointer to DW_AT_comp_dir attribute in die. */
Dwarf_Attribute comp_dir_attr;
/* Pointer to name of compilation directory. */
Dwarf_Small *comp_dir = NULL;
/*
Offset into .debug_line specified by a DW_AT_stmt_list
attribute. */
Dwarf_Unsigned line_offset;
/* These are the fields of the statement program header. */
Dwarf_Unsigned total_length;
Dwarf_Half version;
Dwarf_Unsigned prologue_length;
Dwarf_Small minimum_instruction_length;
Dwarf_Small default_is_stmt;
Dwarf_Sbyte line_base;
Dwarf_Small line_range;
Dwarf_Small opcode_base;
Dwarf_Small *opcode_length;
/* These are the state machine state variables. */
Dwarf_Addr address;
Dwarf_Word file;
Dwarf_Word line;
Dwarf_Word column;
Dwarf_Bool is_stmt;
Dwarf_Bool basic_block;
Dwarf_Bool end_sequence;
Dwarf_Sword i, file_entry_count, include_directories_count;
/*
This is the current opcode read from the statement program. */
Dwarf_Small opcode;
/*
Pointer to a Dwarf_Line_Context_s structure that contains the
context such as file names and include directories for the set
of lines being generated. */
Dwarf_Line_Context line_context;
/*
These variables are used to decode leb128 numbers. Leb128_num
holds the decoded number, and leb128_length is its length in
bytes. */
Dwarf_Word leb128_num;
Dwarf_Word leb128_length;
Dwarf_Sword advance_line;
/*
This is the operand of the latest fixed_advance_pc extended
opcode. */
Dwarf_Half fixed_advance_pc;
/* This is the length of an extended opcode instr. */
Dwarf_Word instr_length;
Dwarf_Small ext_opcode;
int local_length_size;
/*REFERENCED*/ /* Not used in this instance of the macro */
int local_extension_size;
/* The Dwarf_Debug this die belongs to. */
Dwarf_Debug dbg;
int resattr;
int lres;
int res;
/* ***** BEGIN CODE ***** */
if (error != NULL)
*error = NULL;
CHECK_DIE(die, DW_DLV_ERROR)
dbg = die->di_cu_context->cc_dbg;
res =
_dwarf_load_section(dbg,
dbg->de_debug_line_index,
&dbg->de_debug_line,
error);
if (res != DW_DLV_OK) {
return res;
}
resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
if (resattr != DW_DLV_OK) {
return resattr;
}
lres = dwarf_formudata(stmt_list_attr, &line_offset, error);
if (lres != DW_DLV_OK) {
return lres;
}
if (line_offset >= dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
orig_line_ptr = dbg->de_debug_line;
line_ptr = dbg->de_debug_line + line_offset;
dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
/*
If die has DW_AT_comp_dir attribute, get the string that names
the compilation directory. */
resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
if (resattr == DW_DLV_ERROR) {
return resattr;
}
if (resattr == DW_DLV_OK) {
int cres;
char *cdir;
cres = dwarf_formstring(comp_dir_attr, &cdir, error);
if (cres == DW_DLV_ERROR) {
return cres;
} else if (cres == DW_DLV_OK) {
comp_dir = (Dwarf_Small *) cdir;
}
}
if (resattr == DW_DLV_OK) {
dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
}
/*
Following is a straightforward decoding of the statement
program prologue information. */
/* READ_AREA_LENGTH updates line_ptr for consumed bytes */
READ_AREA_LENGTH(dbg, total_length, Dwarf_Unsigned,
line_ptr, local_length_size, local_extension_size);
line_ptr_end = line_ptr + total_length;
if (line_ptr_end > dbg->de_debug_line + dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_DEBUG_LINE_LENGTH_BAD);
return (DW_DLV_ERROR);
}
printf("total line info length %ld bytes, "
"line offset 0x%llx %lld\n",
(long) total_length,
(long long) line_offset, (long long) line_offset);
printf("compilation_directory %s\n",
comp_dir ? ((char *) comp_dir) : "");
READ_UNALIGNED(dbg, version, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
if (version != CURRENT_VERSION_STAMP) {
_dwarf_error(dbg, error, DW_DLE_VERSION_STAMP_ERROR);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, prologue_length, Dwarf_Unsigned,
line_ptr, local_length_size);
line_ptr += local_length_size;
check_line_ptr = line_ptr;
minimum_instruction_length = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
default_is_stmt = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
line_base = *(Dwarf_Sbyte *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Sbyte);
line_range = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
opcode_base = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
printf(" min instruction length %d\n",
(int) minimum_instruction_length);
printf(" default is stmt %d\n", (int) default_is_stmt);
printf(" line base %d\n", (int) line_base);
printf(" line_range %d\n", (int) line_range);
opcode_length = (Dwarf_Small *)
alloca(sizeof(Dwarf_Small) * opcode_base);
for (i = 1; i < opcode_base; i++) {
opcode_length[i] = *(Dwarf_Small *) line_ptr;
printf(" opcode[%d] length %d\n", (int) i,
(int) opcode_length[i]);
line_ptr = line_ptr + sizeof(Dwarf_Small);
}
include_directories_count = 0;
while ((*(char *) line_ptr) != '\0') {
printf(" include dir[%d] %s\n",
(int) include_directories_count, line_ptr);
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
include_directories_count++;
}
line_ptr++;
file_entry_count = 0;
while (*(char *) line_ptr != '\0') {
Dwarf_Unsigned tlm2;
Dwarf_Unsigned di;
Dwarf_Unsigned fl;
printf(" file[%d] %s\n",
(int) file_entry_count, (char *) line_ptr);
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
di = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
tlm2 = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
fl = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
printf(" dir index %d\n", (int) di);
{
time_t tt = (time_t) tlm2;
printf(" last time 0x%x %s", /* ctime supplies
newline */
(unsigned) tlm2, ctime(&tt));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
file_entry_count++;
}
line_ptr++;
if (line_ptr != check_line_ptr + prologue_length) {
_dwarf_error(dbg, error, DW_DLE_LINE_PROLOG_LENGTH_BAD);
return (DW_DLV_ERROR);
}
/* Set up context structure for this set of lines. */
line_context = (Dwarf_Line_Context)
_dwarf_get_alloc(dbg, DW_DLA_LINE_CONTEXT, 1);
if (line_context == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
printf(" statement prog offset in section: %lld 0x%llx\n",
(long long) (line_ptr - orig_line_ptr),
(long long) (line_ptr - orig_line_ptr));
/* Initialize the state machine. */
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = default_is_stmt;
basic_block = false;
end_sequence = false;
print_line_header();
/* Start of statement program. */
while (line_ptr < line_ptr_end) {
int type;
printf(" [0x%06llx] ", (long long) (line_ptr - orig_line_ptr));
opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
/* 'type' is the output */
WHAT_IS_OPCODE(type, opcode, opcode_base,
opcode_length, line_ptr);
if (type == LOP_DISCARD) {
/* do nothing, necessary ops done */
} else if (type == LOP_SPECIAL) {
/* This op code is a special op in the object, no matter
that it might fall into the standard op range in this
compile Thatis, these are special opcodes between
special_opcode_base and MAX_LINE_OP_CODE. (including
special_opcode_base and MAX_LINE_OP_CODE) */
char special[50];
unsigned origop = opcode;
opcode = opcode - opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
line = line + line_base + opcode % line_range;
sprintf(special, "Specialop %3u", origop);
print_line_detail(special,
opcode, address, (int) file, line, column,
is_stmt, basic_block, end_sequence);
basic_block = false;
} else if (type == LOP_STANDARD) {
switch (opcode) {
case DW_LNS_copy:{
if (opcode_length[DW_LNS_copy] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
print_line_detail("DW_LNS_copy",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence);
basic_block = false;
break;
}
case DW_LNS_advance_pc:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_advance_pc] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
printf("DW_LNS_advance_pc val %lld 0x%llx\n",
(long long) (Dwarf_Word) utmp2,
(long long) (Dwarf_Word) utmp2);
leb128_num = (Dwarf_Word) utmp2;
address =
address +
minimum_instruction_length * leb128_num;
break;
}
case DW_LNS_advance_line:{
Dwarf_Signed stmp;
if (opcode_length[DW_LNS_advance_line] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_SWORD(line_ptr, stmp)
advance_line = (Dwarf_Sword) stmp;
printf("DW_LNS_advance_line val %lld 0x%llx\n",
(long long) advance_line,
(long long) advance_line);
line = line + advance_line;
break;
}
case DW_LNS_set_file:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_file] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
file = (Dwarf_Word) utmp2;
printf("DW_LNS_set_file %ld\n", (long) file);
break;
}
case DW_LNS_set_column:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_column] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
column = (Dwarf_Word) utmp2;
printf("DW_LNS_set_column val %lld 0x%llx\n",
(long long) column, (long long) column);
break;
}
case DW_LNS_negate_stmt:{
if (opcode_length[DW_LNS_negate_stmt] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
is_stmt = !is_stmt;
printf("DW_LNS_negate_stmt\n");
break;
}
case DW_LNS_set_basic_block:{
if (opcode_length[DW_LNS_set_basic_block] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
printf("DW_LNS_set_basic_block\n");
basic_block = true;
break;
}
case DW_LNS_const_add_pc:{
opcode = MAX_LINE_OP_CODE - opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
printf("DW_LNS_const_add_pc new address 0x%llx\n",
(long long) address);
break;
}
case DW_LNS_fixed_advance_pc:{
if (opcode_length[DW_LNS_fixed_advance_pc] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, fixed_advance_pc, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
address = address + fixed_advance_pc;
printf("DW_LNS_fixed_advance_pc val %lld 0x%llx"
" new address 0x%llx\n",
(long long) fixed_advance_pc,
(long long) fixed_advance_pc,
(long long) address);
break;
}
}
} else if (type == LOP_EXTENDED) {
Dwarf_Unsigned utmp3;
DECODE_LEB128_UWORD(line_ptr, utmp3)
instr_length = (Dwarf_Word) utmp3;
ext_opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
switch (ext_opcode) {
case DW_LNE_end_sequence:{
end_sequence = true;
print_line_detail("DW_LNE_end_sequence extended",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence);
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = default_is_stmt;
basic_block = false;
end_sequence = false;
break;
}
case DW_LNE_set_address:{
if (instr_length - 1 == dbg->de_pointer_size) {
READ_UNALIGNED(dbg, address, Dwarf_Addr,
line_ptr, dbg->de_pointer_size);
line_ptr += dbg->de_pointer_size;
printf("DW_LNE_set_address address 0x%llx\n",
(long long) address);
} else {
_dwarf_error(dbg, error,
DW_DLE_LINE_SET_ADDR_ERROR);
return (DW_DLV_ERROR);
}
break;
}
case DW_LNE_define_file:{
Dwarf_Small *fn;
Dwarf_Signed di;
Dwarf_Signed tlm;
Dwarf_Unsigned fl;
fn = (Dwarf_Small *) line_ptr;
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
di = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
tlm =
_dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
fl = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
printf("DW_LNE_define_file %s \n", fn);
printf(" dir index %d\n", (int) di);
{
time_t tt3 = (time_t) tlm;
/* ctime supplies newline */
printf(" last time 0x%x %s",
(unsigned) tlm, ctime(&tt3));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
break;
}
default:{
_dwarf_error(dbg, error,
DW_DLE_LINE_EXT_OPCODE_BAD);
return (DW_DLV_ERROR);
}
}
}
}
return (DW_DLV_OK);
}
/*
return DW_DLV_OK if ok. else DW_DLV_NO_ENTRY or DW_DLV_ERROR
If err_count_out is non-NULL, this is a special 'check'
call.
*/
int
_dwarf_internal_printlines(Dwarf_Die die, Dwarf_Error * error,
int * err_count_out, int only_line_header)
{
/*
This pointer is used to scan the portion of the .debug_line
section for the current cu. */
Dwarf_Small *line_ptr = 0;
Dwarf_Small *orig_line_ptr = 0;
/*
This points to the last byte of the .debug_line portion for the
current cu. */
Dwarf_Small *line_ptr_end = 0;
/*
Pointer to a DW_AT_stmt_list attribute in case it exists in the
die. */
Dwarf_Attribute stmt_list_attr = 0;
/* Pointer to DW_AT_comp_dir attribute in die. */
Dwarf_Attribute comp_dir_attr = 0;
/* Pointer to name of compilation directory. */
Dwarf_Small *comp_dir = NULL;
/*
Offset into .debug_line specified by a DW_AT_stmt_list
attribute. */
Dwarf_Unsigned line_offset = 0;
struct Line_Table_Prefix_s prefix;
/* These are the state machine state variables. */
Dwarf_Addr address = 0;
Dwarf_Word file = 1;
Dwarf_Word line = 1;
Dwarf_Word column = 0;
Dwarf_Bool is_stmt = false;
Dwarf_Bool basic_block = false;
Dwarf_Bool end_sequence = false;
Dwarf_Bool prologue_end = false;
Dwarf_Bool epilogue_begin = false;
Dwarf_Small isa = 0;
Dwarf_Sword i=0;
/*
This is the current opcode read from the statement program. */
Dwarf_Small opcode=0;
/*
These variables are used to decode leb128 numbers. Leb128_num
holds the decoded number, and leb128_length is its length in
bytes. */
Dwarf_Word leb128_num=0;
Dwarf_Word leb128_length=0;
Dwarf_Sword advance_line=0;
/*
This is the operand of the latest fixed_advance_pc extended
opcode. */
Dwarf_Half fixed_advance_pc=0;
/* In case there are wierd bytes 'after' the line table
* prologue this lets us print something. This is a gcc
* compiler bug and we expect the bytes count to be 12.
*/
Dwarf_Small* bogus_bytes_ptr = 0;
Dwarf_Unsigned bogus_bytes_count = 0;
/* The Dwarf_Debug this die belongs to. */
Dwarf_Debug dbg=0;
int resattr = DW_DLV_ERROR;
int lres = DW_DLV_ERROR;
int res = DW_DLV_ERROR;
/* ***** BEGIN CODE ***** */
if (error != NULL) {
*error = NULL;
}
CHECK_DIE(die, DW_DLV_ERROR);
dbg = die->di_cu_context->cc_dbg;
res = _dwarf_load_section(dbg, &dbg->de_debug_line,error);
if (res != DW_DLV_OK) {
return res;
}
resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
if (resattr != DW_DLV_OK) {
return resattr;
}
lres = dwarf_formudata(stmt_list_attr, &line_offset, error);
if (lres != DW_DLV_OK) {
return lres;
}
if (line_offset >= dbg->de_debug_line.dss_size) {
_dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
orig_line_ptr = dbg->de_debug_line.dss_data;
line_ptr = dbg->de_debug_line.dss_data + line_offset;
dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
/*
If die has DW_AT_comp_dir attribute, get the string that names
the compilation directory. */
resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
if (resattr == DW_DLV_ERROR) {
return resattr;
}
if (resattr == DW_DLV_OK) {
int cres = DW_DLV_ERROR;
char *cdir = 0;
cres = dwarf_formstring(comp_dir_attr, &cdir, error);
if (cres == DW_DLV_ERROR) {
return cres;
} else if (cres == DW_DLV_OK) {
comp_dir = (Dwarf_Small *) cdir;
}
}
if (resattr == DW_DLV_OK) {
dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
}
dwarf_init_line_table_prefix(&prefix);
{
Dwarf_Small *line_ptr_out = 0;
int dres = dwarf_read_line_table_prefix(dbg,
line_ptr,dbg->de_debug_line.dss_size - line_offset,
&line_ptr_out,
&prefix,
&bogus_bytes_ptr,
&bogus_bytes_count,
error,
err_count_out);
if (dres == DW_DLV_ERROR) {
dwarf_free_line_table_prefix(&prefix);
return dres;
}
if (dres == DW_DLV_NO_ENTRY) {
dwarf_free_line_table_prefix(&prefix);
return dres;
}
line_ptr_end = prefix.pf_line_ptr_end;
line_ptr = line_ptr_out;
}
if(only_line_header) {
/* Just checking for header errors, nothing more here.*/
dwarf_free_line_table_prefix(&prefix);
return DW_DLV_OK;
}
printf("total line info length %ld bytes, "
"line offset 0x%" DW_PR_DUx " %" DW_PR_DSd "\n",
(long) prefix.pf_total_length,
(Dwarf_Unsigned) line_offset, (Dwarf_Signed) line_offset);
printf("compilation_directory %s\n",
comp_dir ? ((char *) comp_dir) : "");
printf(" min instruction length %d\n",
(int) prefix.pf_minimum_instruction_length);
printf(" default is stmt %d\n", (int)
prefix.pf_default_is_stmt);
printf(" line base %d\n", (int)
prefix.pf_line_base);
printf(" line_range %d\n", (int)
prefix.pf_line_range);
printf(" opcode base %d\n", (int)
prefix.pf_opcode_base);
for (i = 1; i < prefix.pf_opcode_base; i++) {
printf(" opcode[%d] length %d\n", (int) i,
(int) prefix.pf_opcode_length_table[i - 1]);
}
printf(" include directories count %d\n", (int)
prefix.pf_include_directories_count);
for (i = 0; i < prefix.pf_include_directories_count; ++i) {
printf(" include dir[%d] %s\n",
(int) i, prefix.pf_include_directories[i]);
}
printf(" include files count %d\n", (int)
prefix.pf_files_count);
for (i = 0; i < prefix.pf_files_count; ++i) {
struct Line_Table_File_Entry_s *lfile =
prefix.pf_line_table_file_entries + i;
Dwarf_Unsigned tlm2 = lfile->lte_last_modification_time;
Dwarf_Unsigned di = lfile->lte_directory_index;
Dwarf_Unsigned fl = lfile->lte_length_of_file;
printf(" file[%d] %s (file-number: %d) \n",
(int) i, (char *) lfile->lte_filename,
(int)(i+1));
printf(" dir index %d\n", (int) di);
{
time_t tt = (time_t) tlm2;
printf(" last time 0x%x %s", /* ctime supplies
newline */
(unsigned) tlm2, ctime(&tt));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
}
{
Dwarf_Unsigned offset = 0;
if(bogus_bytes_count > 0) {
Dwarf_Unsigned wcount = bogus_bytes_count;
Dwarf_Unsigned boffset = bogus_bytes_ptr - orig_line_ptr;
printf("*** DWARF CHECK: the line table prologue header_length "
" is %" DW_PR_DUu " too high, we pretend it is smaller."
"Section offset: %" DW_PR_DUu " (0x%" DW_PR_DUx ") ***\n",
wcount, boffset,boffset);
*err_count_out += 1;
}
offset = line_ptr - orig_line_ptr;
printf(" statement prog offset in section: %" DW_PR_DUu " 0x%" DW_PR_DUx "\n",
offset, offset);
}
/* Initialize the part of the state machine dependent on the
prefix. */
is_stmt = prefix.pf_default_is_stmt;
print_line_header();
/* Start of statement program. */
while (line_ptr < line_ptr_end) {
int type = 0;
printf(" [0x%06" DW_PR_DSx "] ",
(Dwarf_Signed) (line_ptr - orig_line_ptr));
opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
/* 'type' is the output */
WHAT_IS_OPCODE(type, opcode, prefix.pf_opcode_base,
prefix.pf_opcode_length_table, line_ptr,
prefix.pf_std_op_count);
if (type == LOP_DISCARD) {
int oc;
int opcnt = prefix.pf_opcode_length_table[opcode];
printf("*** DWARF CHECK: DISCARD standard opcode %d "
"with %d operands: "
"not understood.", opcode, opcnt);
*err_count_out += 1;
for (oc = 0; oc < opcnt; oc++) {
/*
* Read and discard operands we don't
* understand.
* Arbitrary choice of unsigned read.
* Signed read would work as well.
*/
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
printf(" %" DW_PR_DUu " (0x%" DW_PR_DUx ")",
(Dwarf_Unsigned) utmp2,
(Dwarf_Unsigned) utmp2);
}
printf("***\n");
/* do nothing, necessary ops done */
} else if (type == LOP_SPECIAL) {
/* This op code is a special op in the object, no matter
that it might fall into the standard op range in this
compile Thatis, these are special opcodes between
special_opcode_base and MAX_LINE_OP_CODE. (including
special_opcode_base and MAX_LINE_OP_CODE) */
char special[50];
unsigned origop = opcode;
opcode = opcode - prefix.pf_opcode_base;
address = address + prefix.pf_minimum_instruction_length *
(opcode / prefix.pf_line_range);
line =
line + prefix.pf_line_base +
opcode % prefix.pf_line_range;
sprintf(special, "Specialop %3u", origop);
print_line_detail(special,
opcode, address, (int) file, line, column,
is_stmt, basic_block, end_sequence,
prologue_end, epilogue_begin, isa);
basic_block = false;
} else if (type == LOP_STANDARD) {
switch (opcode) {
case DW_LNS_copy:{
print_line_detail("DW_LNS_copy",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence, prologue_end,
epilogue_begin, isa);
basic_block = false;
break;
}
case DW_LNS_advance_pc:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
printf("DW_LNS_advance_pc val %" DW_PR_DSd " 0x%" DW_PR_DUx "\n",
(Dwarf_Signed) (Dwarf_Word) utmp2,
(Dwarf_Unsigned) (Dwarf_Word) utmp2);
leb128_num = (Dwarf_Word) utmp2;
address =
address +
prefix.pf_minimum_instruction_length *
leb128_num;
break;
}
case DW_LNS_advance_line:{
Dwarf_Signed stmp;
DECODE_LEB128_SWORD(line_ptr, stmp);
advance_line = (Dwarf_Sword) stmp;
printf("DW_LNS_advance_line val %" DW_PR_DSd " 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) advance_line,
(Dwarf_Signed) advance_line);
line = line + advance_line;
break;
}
case DW_LNS_set_file:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
file = (Dwarf_Word) utmp2;
printf("DW_LNS_set_file %ld\n", (long) file);
break;
}
case DW_LNS_set_column:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
column = (Dwarf_Word) utmp2;
printf("DW_LNS_set_column val %" DW_PR_DSd " 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) column, (Dwarf_Signed) column);
break;
}
case DW_LNS_negate_stmt:{
is_stmt = !is_stmt;
printf("DW_LNS_negate_stmt\n");
break;
}
case DW_LNS_set_basic_block:{
printf("DW_LNS_set_basic_block\n");
basic_block = true;
break;
}
case DW_LNS_const_add_pc:{
opcode = MAX_LINE_OP_CODE - prefix.pf_opcode_base;
address =
address +
prefix.pf_minimum_instruction_length * (opcode /
prefix.
pf_line_range);
printf("DW_LNS_const_add_pc new address 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) address);
break;
}
case DW_LNS_fixed_advance_pc:{
READ_UNALIGNED(dbg, fixed_advance_pc, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
address = address + fixed_advance_pc;
printf("DW_LNS_fixed_advance_pc val %" DW_PR_DSd
" 0x%" DW_PR_DSx " new address 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) fixed_advance_pc,
(Dwarf_Signed) fixed_advance_pc,
(Dwarf_Signed) address);
break;
}
case DW_LNS_set_prologue_end:{
prologue_end = true;
printf("DW_LNS_set_prologue_end set true.\n");
break;
}
/* New in DWARF3 */
case DW_LNS_set_epilogue_begin:{
epilogue_begin = true;
printf("DW_LNS_set_epilogue_begin set true.\n");
break;
}
/* New in DWARF3 */
case DW_LNS_set_isa:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
isa = utmp2;
printf("DW_LNS_set_isa new value 0x%" DW_PR_DUx ".\n",
(Dwarf_Unsigned) utmp2);
if (isa != utmp2) {
/* The value of the isa did not fit in our
local so we record it wrong. declare an
error. */
dwarf_free_line_table_prefix(&prefix);
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
break;
}
}
} else if (type == LOP_EXTENDED) {
Dwarf_Unsigned utmp3 = 0;
Dwarf_Word instr_length = 0;
Dwarf_Small ext_opcode = 0;
DECODE_LEB128_UWORD(line_ptr, utmp3);
instr_length = (Dwarf_Word) utmp3;
ext_opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
switch (ext_opcode) {
case DW_LNE_end_sequence:{
end_sequence = true;
print_line_detail("DW_LNE_end_sequence extended",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence, prologue_end,
epilogue_begin, isa);
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = prefix.pf_default_is_stmt;
basic_block = false;
end_sequence = false;
prologue_end = false;
epilogue_begin = false;
break;
}
case DW_LNE_set_address:{
{
READ_UNALIGNED(dbg, address, Dwarf_Addr,
line_ptr, dbg->de_pointer_size);
line_ptr += dbg->de_pointer_size;
printf("DW_LNE_set_address address 0x%" DW_PR_DUx "\n",
(Dwarf_Unsigned) address);
}
break;
}
case DW_LNE_define_file:{
Dwarf_Unsigned di = 0;
Dwarf_Unsigned tlm = 0;
Dwarf_Unsigned fl = 0;
Dwarf_Small *fn = (Dwarf_Small *) line_ptr;
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
di = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
tlm = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
fl = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
printf("DW_LNE_define_file %s \n", fn);
printf(" dir index %d\n", (int) di);
{
time_t tt3 = (time_t) tlm;
/* ctime supplies newline */
printf(" last time 0x%x %s",
(unsigned) tlm, ctime(&tt3));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
break;
}
default:{
dwarf_free_line_table_prefix(&prefix);
_dwarf_error(dbg, error,
DW_DLE_LINE_EXT_OPCODE_BAD);
return (DW_DLV_ERROR);
}
}
}
}
dwarf_free_line_table_prefix(&prefix);
return (DW_DLV_OK);
}
int
ppc64_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
{
/* Start with the function's type, and get the DW_AT_type attribute,
which is the type of the return value. */
Dwarf_Attribute attr_mem;
Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type,
&attr_mem);
if (attr == NULL)
/* The function has no return value, like a `void' function in C. */
return 0;
Dwarf_Die die_mem;
Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem);
int tag = dwarf_tag (typedie);
/* Follow typedefs and qualifiers to get to the actual type. */
while (tag == DW_TAG_typedef
|| tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
|| tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = dwarf_tag (typedie);
}
Dwarf_Word size;
switch (tag)
{
case -1:
return -1;
case DW_TAG_subrange_type:
if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size))
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = dwarf_tag (typedie);
}
/* Fall through. */
case DW_TAG_base_type:
case DW_TAG_enumeration_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
&attr_mem), &size) != 0)
{
if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
size = 8;
else
return -1;
}
if (tag == DW_TAG_base_type)
{
Dwarf_Word encoding;
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_encoding,
&attr_mem),
&encoding) != 0)
return -1;
if (encoding == DW_ATE_float || encoding == DW_ATE_complex_float)
{
*locp = loc_fpreg;
if (size <= 8)
return nloc_fpreg;
if (size <= 16)
return nloc_fp2regs;
if (size <= 32)
return nloc_fp4regs;
}
}
if (size <= 8)
{
intreg:
*locp = loc_intreg;
return nloc_intreg;
}
/* Else fall through. */
case DW_TAG_structure_type:
case DW_TAG_class_type:
case DW_TAG_union_type:
aggregate:
*locp = loc_aggregate;
return nloc_aggregate;
case DW_TAG_string_type:
case DW_TAG_array_type:
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
&attr_mem), &size) == 0
&& size <= 8)
{
if (tag == DW_TAG_array_type)
{
/* Check if it's a character array. */
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = dwarf_tag (typedie);
if (tag != DW_TAG_base_type)
goto aggregate;
if (dwarf_formudata (dwarf_attr_integrate (typedie,
DW_AT_byte_size,
&attr_mem),
&size) != 0)
return -1;
if (size != 1)
goto aggregate;
}
goto intreg;
}
goto aggregate;
}
/* XXX We don't have a good way to return specific errors from ebl calls.
This value means we do not understand the type, but it is well-formed
DWARF and might be valid. */
return -2;
}
int
ppc_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
{
/* Start with the function's type, and get the DW_AT_type attribute,
which is the type of the return value. */
Dwarf_Attribute attr_mem;
Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type,
&attr_mem);
if (attr == NULL)
/* The function has no return value, like a `void' function in C. */
return 0;
Dwarf_Die die_mem;
Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem);
int tag = dwarf_tag (typedie);
/* Follow typedefs and qualifiers to get to the actual type. */
while (tag == DW_TAG_typedef
|| tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
|| tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = dwarf_tag (typedie);
}
Dwarf_Word size;
switch (tag)
{
case -1:
return -1;
case DW_TAG_subrange_type:
if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size))
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = dwarf_tag (typedie);
}
/* Fall through. */
case DW_TAG_base_type:
case DW_TAG_enumeration_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
&attr_mem), &size) != 0)
{
if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
size = 4;
else
return -1;
}
if (size <= 8)
{
if (tag == DW_TAG_base_type)
{
Dwarf_Word encoding;
if (dwarf_formudata (dwarf_attr_integrate (typedie,
DW_AT_encoding,
&attr_mem),
&encoding) != 0)
return -1;
if (encoding == DW_ATE_float)
{
*locp = loc_fpreg;
return nloc_fpreg;
}
}
intreg:
*locp = loc_intreg;
return size <= 4 ? nloc_intreg : nloc_intregpair;
}
aggregate:
*locp = loc_aggregate;
return nloc_aggregate;
case DW_TAG_array_type:
{
bool is_vector;
if (dwarf_formflag (dwarf_attr_integrate (typedie, DW_AT_GNU_vector,
&attr_mem), &is_vector) == 0
&& is_vector
&& dwarf_aggregate_size (typedie, &size) == 0)
switch (size)
{
case 16:
if (ppc_altivec_abi ())
{
*locp = loc_vmxreg;
return nloc_vmxreg;
}
*locp = loc_intreg;
return nloc_intregquad;
}
}
/* Fall through. */
case DW_TAG_structure_type:
case DW_TAG_class_type:
case DW_TAG_union_type:
if (SVR4_STRUCT_RETURN
&& dwarf_aggregate_size (typedie, &size) == 0
&& size > 0 && size <= 8)
goto intreg;
goto aggregate;
}
/* XXX We don't have a good way to return specific errors from ebl calls.
This value means we do not understand the type, but it is well-formed
DWARF and might be valid. */
return -2;
}
/* If this type is an HFA small enough to be returned in FP registers,
return the number of registers to use. Otherwise 9, or -1 for errors. */
static int
hfa_type (Dwarf_Die *typedie, Dwarf_Word size,
const Dwarf_Op **locp, int fpregs_used)
{
/* Descend the type structure, counting elements and finding their types.
If we find a datum that's not an FP type (and not quad FP), punt.
If we find a datum that's not the same FP type as the first datum, punt.
If we count more than eight total homogeneous FP data, punt. */
inline int hfa (const Dwarf_Op *loc, int nregs)
{
if (fpregs_used == 0)
*locp = loc;
else if (*locp != loc)
return 9;
return fpregs_used + nregs;
}
int tag = DWARF_TAG_OR_RETURN (typedie);
switch (tag)
{
Dwarf_Attribute attr_mem;
case -1:
return -1;
case DW_TAG_base_type:;
Dwarf_Word encoding;
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_encoding,
&attr_mem), &encoding) != 0)
return -1;
switch (encoding)
{
case DW_ATE_float:
switch (size)
{
case 4: /* float */
return hfa (loc_fpreg_4, 1);
case 8: /* double */
return hfa (loc_fpreg_8, 1);
case 10: /* x86-style long double, not really used */
return hfa (loc_fpreg_10, 1);
}
break;
case DW_ATE_complex_float:
switch (size)
{
case 4 * 2: /* complex float */
return hfa (loc_fpreg_4, 2);
case 8 * 2: /* complex double */
return hfa (loc_fpreg_8, 2);
case 10 * 2: /* complex long double (x86-style) */
return hfa (loc_fpreg_10, 2);
}
break;
}
break;
case DW_TAG_structure_type:
case DW_TAG_class_type:
case DW_TAG_union_type:;
Dwarf_Die child_mem;
switch (dwarf_child (typedie, &child_mem))
{
default:
return -1;
case 1: /* No children: empty struct. */
break;
case 0:; /* Look at each element. */
int max_used = fpregs_used;
do
switch (dwarf_tag (&child_mem))
{
case -1:
return -1;
case DW_TAG_member:;
Dwarf_Die child_type_mem;
Dwarf_Die *child_typedie
= dwarf_formref_die (dwarf_attr_integrate (&child_mem,
DW_AT_type,
&attr_mem),
&child_type_mem);
Dwarf_Word child_size;
if (dwarf_aggregate_size (child_typedie, &child_size) != 0)
return -1;
if (tag == DW_TAG_union_type)
{
int used = hfa_type (child_typedie, child_size,
locp, fpregs_used);
if (used < 0 || used > 8)
return used;
if (used > max_used)
max_used = used;
}
else
{
fpregs_used = hfa_type (child_typedie, child_size,
locp, fpregs_used);
if (fpregs_used < 0 || fpregs_used > 8)
return fpregs_used;
}
}
while (dwarf_siblingof (&child_mem, &child_mem) == 0);
if (tag == DW_TAG_union_type)
fpregs_used = max_used;
break;
}
break;
case DW_TAG_array_type:
if (size == 0)
break;
Dwarf_Die base_type_mem;
Dwarf_Die *base_typedie
= dwarf_formref_die (dwarf_attr_integrate (typedie, DW_AT_type,
&attr_mem),
&base_type_mem);
Dwarf_Word base_size;
if (dwarf_aggregate_size (base_typedie, &base_size) != 0)
return -1;
int used = hfa_type (base_typedie, base_size, locp, 0);
if (used < 0 || used > 8)
return used;
if (size % (*locp)[1].number != 0)
return 0;
fpregs_used += used * (size / (*locp)[1].number);
break;
default:
return 9;
}
return fpregs_used;
}
static int
mac (Dwarf_Macro *macro, void *dbg)
{
static int level = 0;
unsigned int opcode;
dwarf_macro_opcode (macro, &opcode);
switch (opcode)
{
case DW_MACRO_GNU_transparent_include:
{
Dwarf_Attribute at;
int r = dwarf_macro_param (macro, 0, &at);
assert (r == 0);
Dwarf_Word w;
r = dwarf_formudata (&at, &w);
assert (r == 0);
printf ("%*sinclude %#" PRIx64 "\n", level, "", w);
++level;
include (dbg, w, DWARF_GETMACROS_START);
--level;
printf ("%*s/include\n", level, "");
break;
}
case DW_MACRO_GNU_start_file:
{
Dwarf_Files *files;
size_t nfiles;
if (dwarf_macro_getsrcfiles (dbg, macro, &files, &nfiles) < 0)
printf ("dwarf_macro_getsrcfiles: %s\n",
dwarf_errmsg (dwarf_errno ()));
Dwarf_Word w = 0;
dwarf_macro_param2 (macro, &w, NULL);
const char *name = dwarf_filesrc (files, (size_t) w, NULL, NULL);
printf ("%*sfile %s\n", level, "", name);
++level;
break;
}
case DW_MACRO_GNU_end_file:
{
--level;
printf ("%*s/file\n", level, "");
break;
}
case DW_MACINFO_define:
case DW_MACRO_GNU_define_indirect:
{
const char *value;
dwarf_macro_param2 (macro, NULL, &value);
printf ("%*s%s\n", level, "", value);
break;
}
case DW_MACINFO_undef:
case DW_MACRO_GNU_undef_indirect:
break;
default:
{
size_t paramcnt;
dwarf_macro_getparamcnt (macro, ¶mcnt);
printf ("%*sopcode %u with %zd arguments\n",
level, "", opcode, paramcnt);
break;
}
}
return DWARF_CB_ABORT;
}
int
ia64_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
{
/* Start with the function's type, and get the DW_AT_type attribute,
which is the type of the return value. */
Dwarf_Attribute attr_mem;
Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type,
&attr_mem);
if (attr == NULL)
/* The function has no return value, like a `void' function in C. */
return 0;
Dwarf_Die die_mem;
Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem);
int tag = DWARF_TAG_OR_RETURN (typedie);
/* Follow typedefs and qualifiers to get to the actual type. */
while (tag == DW_TAG_typedef
|| tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
|| tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
{
attr = dwarf_attr (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = DWARF_TAG_OR_RETURN (typedie);
}
Dwarf_Word size;
switch (tag)
{
case -1:
return -1;
case DW_TAG_subrange_type:
if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size))
{
attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
typedie = dwarf_formref_die (attr, &die_mem);
tag = DWARF_TAG_OR_RETURN (typedie);
}
/* Fall through. */
case DW_TAG_base_type:
case DW_TAG_enumeration_type:
case DW_TAG_pointer_type:
case DW_TAG_ptr_to_member_type:
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
&attr_mem), &size) != 0)
{
if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
size = 8;
else
return -1;
}
if (tag == DW_TAG_base_type)
{
Dwarf_Word encoding;
if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_encoding,
&attr_mem),
&encoding) != 0)
return -1;
switch (encoding)
{
case DW_ATE_float:
switch (size)
{
case 4: /* float */
*locp = loc_fpreg_4;
return nloc_fpreg;
case 8: /* double */
*locp = loc_fpreg_8;
return nloc_fpreg;
case 10: /* x86-style long double, not really used */
*locp = loc_fpreg_10;
return nloc_fpreg;
case 16: /* long double, IEEE quad format */
*locp = loc_intreg;
return nloc_intregs (2);
}
return -2;
case DW_ATE_complex_float:
switch (size)
{
case 4 * 2: /* complex float */
*locp = loc_fpreg_4;
return nloc_fpregs (2);
case 8 * 2: /* complex double */
*locp = loc_fpreg_8;
return nloc_fpregs (2);
case 10 * 2: /* complex long double (x86-style) */
*locp = loc_fpreg_10;
return nloc_fpregs (2);
case 16 * 2: /* complex long double (IEEE quad) */
*locp = loc_intreg;
return nloc_intregs (4);
}
return -2;
}
}
intreg:
*locp = loc_intreg;
if (size <= 8)
return nloc_intreg;
if (size <= 32)
return nloc_intregs ((size + 7) / 8);
large:
*locp = loc_aggregate;
return nloc_aggregate;
case DW_TAG_structure_type:
case DW_TAG_class_type:
case DW_TAG_union_type:
case DW_TAG_array_type:
if (dwarf_aggregate_size (typedie, &size) != 0)
return -1;
/* If this qualifies as an homogeneous floating-point aggregate
(HFA), then it should be returned in FP regs. */
int nfpreg = hfa_type (typedie, size, locp, 0);
if (nfpreg < 0)
return nfpreg;
else if (nfpreg > 0 && nfpreg <= 8)
return nfpreg == 1 ? nloc_fpreg : nloc_fpregs (nfpreg);
if (size > 32)
goto large;
goto intreg;
}
/* XXX We don't have a good way to return specific errors from ebl calls.
This value means we do not understand the type, but it is well-formed
DWARF and might be valid. */
return -2;
}
static VALUE rd_attr_raw_value(VALUE self)
{
rd_attr_t *attr = GetAttr(self);
Dwarf_Half form;
Dwarf_Error err;
union {
Dwarf_Addr addr;
Dwarf_Off off;
Dwarf_Unsigned udata;
Dwarf_Signed sdata;
Dwarf_Bool bool;
char *str;
} val;
VALUE top;
chkerr1(dwarf_whatform(attr->attr, &form, &err), &err, self);
switch (form) {
case DW_FORM_addr:
chkerr1(dwarf_formaddr(attr->attr, &val.addr, &err), &err, self);
return ULL2NUM(val.addr);
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_udata:
chkerr1(dwarf_global_formref(attr->attr, &val.off, &err), &err, self);
top = rb_ivar_get(self, id_at_top);
return rdwarf_die_at(top, LL2NUM(val.off));
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_data8:
case DW_FORM_udata:
chkerr1(dwarf_formudata(attr->attr, &val.udata, &err), &err, self);
return ULL2NUM(val.udata);
case DW_FORM_sdata:
chkerr1(dwarf_formsdata(attr->attr, &val.sdata, &err), &err, self);
return LL2NUM(val.sdata);
case DW_FORM_flag:
chkerr1(dwarf_formflag(attr->attr, &val.bool, &err), &err, self);
return val.bool ? Qtrue : Qfalse;
case DW_FORM_strp:
case DW_FORM_string:
chkerr1(dwarf_formstring(attr->attr, &val.str, &err), &err, self);
return rb_str_new_cstr(val.str);
}
return sym_unsupported_type;
}
