/** \brief Finds the number of elements in a DW_TAG_subrange_type or DW_TAG_enumeration_type DIE
*
* \param die the DIE
* \param unit DIE of the compilation unit
* \return number of elements in the range
* */
static uint64_t MC_dwarf_subrange_element_count(Dwarf_Die * die,
Dwarf_Die * unit)
{
xbt_assert(dwarf_tag(die) == DW_TAG_enumeration_type
|| dwarf_tag(die) == DW_TAG_subrange_type,
"MC_dwarf_subrange_element_count called with DIE of type %s",
simgrid::dwarf::tagname(die));
// Use DW_TAG_count if present:
if (dwarf_hasattr_integrate(die, DW_AT_count))
return MC_dwarf_attr_integrate_uint(die, DW_AT_count, 0);
// Otherwise compute DW_TAG_upper_bound-DW_TAG_lower_bound + 1:
if (not dwarf_hasattr_integrate(die, DW_AT_upper_bound))
// This is not really 0, but the code expects this (we do not know):
return 0;
uint64_t upper_bound = MC_dwarf_attr_integrate_uint(die, DW_AT_upper_bound, static_cast<uint64_t>(-1));
uint64_t lower_bound = 0;
if (dwarf_hasattr_integrate(die, DW_AT_lower_bound))
lower_bound = MC_dwarf_attr_integrate_uint(die, DW_AT_lower_bound, static_cast<uint64_t>(-1));
else
lower_bound = MC_dwarf_default_lower_bound(dwarf_srclang(unit));
return upper_bound - lower_bound + 1;
}
/** \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 Dwarf_Off MC_dwarf_attr_dieoffset(Dwarf_Die * die, int attribute)
{
Dwarf_Attribute attr;
if (dwarf_hasattr_integrate(die, attribute) == 0)
return 0;
dwarf_attr_integrate(die, attribute, &attr);
Dwarf_Die subtype_die;
if (dwarf_formref_die(&attr, &subtype_die) == nullptr)
xbt_die("Could not find DIE");
return dwarf_dieoffset(&subtype_die);
}
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
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;
}
/** \brief Create a MC type object from a DIE
*
* \param info current object info object
* \param die DIE (for a given type)
* \param unit compilation unit of the current DIE
* \return MC representation of the type
*/
static simgrid::mc::Type MC_dwarf_die_to_type(
simgrid::mc::ObjectInformation* info, Dwarf_Die * die,
Dwarf_Die * unit, simgrid::mc::Frame* frame,
const char *ns)
{
simgrid::mc::Type type;
type.type = dwarf_tag(die);
type.name = std::string();
type.element_count = -1;
// Global Offset
type.id = dwarf_dieoffset(die);
const char *prefix = "";
switch (type.type) {
case DW_TAG_structure_type:
prefix = "struct ";
break;
case DW_TAG_union_type:
prefix = "union ";
break;
case DW_TAG_class_type:
prefix = "class ";
break;
default:
prefix = "";
}
const char *name = MC_dwarf_attr_integrate_string(die, DW_AT_name);
if (name != nullptr) {
if (ns)
type.name = simgrid::xbt::string_printf("%s%s::%s", prefix, ns, name);
else
type.name = simgrid::xbt::string_printf("%s%s", prefix, name);
}
type.type_id = MC_dwarf_at_type(die);
// Some compilers do not emit DW_AT_byte_size for pointer_type,
// so we fill this. We currently assume that the model-checked process is in
// the same architecture..
if (type.type == DW_TAG_pointer_type)
type.byte_size = sizeof(void*);
// Computation of the byte_size
if (dwarf_hasattr_integrate(die, DW_AT_byte_size))
type.byte_size = MC_dwarf_attr_integrate_uint(die, DW_AT_byte_size, 0);
else if (type.type == DW_TAG_array_type
|| type.type == DW_TAG_structure_type
|| type.type == DW_TAG_class_type) {
Dwarf_Word size;
if (dwarf_aggregate_size(die, &size) == 0)
type.byte_size = size;
}
switch (type.type) {
case DW_TAG_array_type:
type.element_count = MC_dwarf_array_element_count(die, unit);
// TODO, handle DW_byte_stride and (not) DW_bit_stride
break;
case DW_TAG_pointer_type:
case DW_TAG_reference_type:
case DW_TAG_rvalue_reference_type:
break;
case DW_TAG_structure_type:
case DW_TAG_union_type:
case DW_TAG_class_type:
MC_dwarf_add_members(info, die, unit, &type);
MC_dwarf_handle_children(info, die, unit, frame,
ns ? simgrid::xbt::string_printf("%s::%s", ns, name).c_str() : type.name.c_str());
break;
default:
XBT_DEBUG("Unhandled type: %d (%s)", type.type, simgrid::dwarf::tagname(type.type));
break;
}
return type;
}
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;
}
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;
}
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;
}
