if (res < 0) return false; /* error */ \
break /* no sibling exists */
-static bool get_type(struct arg_type_info** info, Dwarf_Die* type_die, struct protolib* plib,
- struct dict* type_dieoffset_hash);
+static struct arg_type_info* get_type(int* newly_allocated_info,
+ Dwarf_Die* type_die, struct protolib* plib,
+ struct dict* type_dieoffset_hash);
#if 0
}
}
+// returns an ltrace ARGTYPE_XXX base type from the given die. If we dont
+// support a particular type (or an error occurred), I regturn ARGTYPE_VOID
static enum arg_type get_base_type(Dwarf_Die* die)
{
int64_t encoding;
dwarf_formref_die(&attr, type_die) != NULL;
}
+
+
+// type_dieoffset_hash dictionary callbacks
static size_t dwarf_die_hash(const void* x)
{
return *(const Dwarf_Off*)x;
return *(const Dwarf_Off*)a == *(const Dwarf_Off*)b;
}
-static bool get_enum(struct arg_type_info* enum_info, Dwarf_Die* parent)
+
+// returns a newly-allocated art_type_info*, or NULL on error
+static struct arg_type_info* get_enum(Dwarf_Die* parent, struct dict* type_dieoffset_hash)
{
+
+#define CLEANUP_AND_RETURN_ERROR(ret) do { \
+ if(dupkey != NULL) \
+ free((void*)dupkey); \
+ if(value != NULL) { \
+ value_destroy(value); \
+ free(value); \
+ } \
+ if(lens != NULL ) { \
+ lens_destroy(&lens->super); \
+ free(lens); \
+ } \
+ if(result != NULL) { \
+ type_destroy(result); \
+ free(result); \
+ } \
+ dict_erase (type_dieoffset_hash, &die_offset, NULL, NULL, NULL); \
+ dict_insert(type_dieoffset_hash, &die_offset, \
+ &(struct arg_type_info*){type_get_simple(ARGTYPE_VOID)}); \
+ return ret; \
+ } while(0)
+
+ struct arg_type_info* result = NULL;
+ struct enum_lens* lens = NULL;
+ const char* dupkey = NULL;
+ struct value* value = NULL;
+
+ Dwarf_Off die_offset = dwarf_dieoffset(parent);
+
+ result = calloc(1, sizeof(struct arg_type_info));
+ if (result == NULL) {
+ complain(type_die, "alloc error");
+ CLEANUP_AND_RETURN_ERROR(NULL);
+ }
+
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+
uint64_t byte_size;
if (!get_die_numeric(&byte_size, parent, DW_AT_byte_size)) {
// No byte size given, assume 'int'
- enum_info->type = ARGTYPE_INT;
+ result->type = ARGTYPE_INT;
} else {
- if(!get_integer_base_type(&enum_info->type, (int)byte_size, true)) {
+ if(!get_integer_base_type(&result->type, (int)byte_size, true)) {
complain(parent, "Unknown integer base type. Using 'int'");
- enum_info->type = ARGTYPE_INT;
+ result->type = ARGTYPE_INT;
}
}
- struct enum_lens *lens = calloc(1, sizeof(struct enum_lens));
+ lens = calloc(1, sizeof(struct enum_lens));
if (lens == NULL) {
complain(parent, "alloc error");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
lens_init_enum(lens);
- enum_info->lens = &lens->super;
+ result->lens = &lens->super;
+ result->own_lens = 1;
Dwarf_Die die;
if (dwarf_child(parent, &die) != 0) {
// empty enum. we're done
- return true;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
+
while(1) {
complain(&die, "enum element: 0x%02x/'%s'", dwarf_tag(&die),
dwarf_diename(&die));
+ dupkey = NULL;
+ value = NULL;
+
if (dwarf_tag(&die) != DW_TAG_enumerator) {
complain(&die, "Enums can have ONLY DW_TAG_enumerator elements");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
if (!dwarf_hasattr(&die, DW_AT_const_value)) {
complain(&die, "Enums MUST have DW_AT_const_value values");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
const char* key = dwarf_diename(&die);
if (key == NULL) {
complain(&die, "Enums must have a DW_AT_name key");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- const char* dupkey = strdup(key);
+ dupkey = strdup(key);
if (dupkey == NULL) {
complain(&die, "Couldn't duplicate enum key");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- struct value* value = calloc(1, sizeof(struct value));
+ value = calloc(1, sizeof(struct value));
if (value == NULL) {
complain(&die, "Couldn't alloc enum value");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- value_init_detached(value, NULL, type_get_simple(enum_info->type), 0);
+ value_init_detached(value, NULL, type_get_simple(result->type), 0);
uint64_t enum_value;
if (!get_die_numeric(&enum_value, &die, DW_AT_const_value)) {
complain(&die, "Couldn't get enum value");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
value_set_word(value, (long)enum_value);
- if (lens_enum_add(lens, dupkey, 0, value, 0)) {
+ if (lens_enum_add(lens, dupkey, 1, value, 1)) {
complain(&die, "Couldn't add enum element");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
NEXT_SIBLING(&die);
}
- return true;
+ return result;
+
+#undef CLEANUP_AND_RETURN_ERROR
}
-static bool get_array(struct arg_type_info* array_info, Dwarf_Die* parent, struct protolib* plib,
- struct dict* type_dieoffset_hash)
+// returns a newly-allocated art_type_info*, or NULL on error
+static struct arg_type_info* get_array( Dwarf_Die* parent, struct protolib* plib,
+ struct dict* type_dieoffset_hash)
{
+
+#define CLEANUP_AND_RETURN_ERROR(ret) do { \
+ if(value != NULL) { \
+ value_destroy(value); \
+ free(value); \
+ } \
+ if(length != NULL) { \
+ expr_destroy(length); \
+ free(length); \
+ } \
+ if(array_type != NULL && newly_allocated_array_type) { \
+ type_destroy(array_type); \
+ free(array_type); \
+ } \
+ if(result != NULL) { \
+ type_destroy(result); \
+ free(result); \
+ } \
+ dict_erase (type_dieoffset_hash, &die_offset, NULL, NULL, NULL); \
+ dict_insert(type_dieoffset_hash, &die_offset, \
+ &(struct arg_type_info*){type_get_simple(ARGTYPE_VOID)}); \
+ return ret; \
+ } while(0)
+
+
+ struct arg_type_info* result = NULL;
+ struct value* value = NULL;
+ struct expr_node* length = NULL;
+ struct arg_type_info* array_type = NULL;
+ int newly_allocated_array_type = 0;
+
+ Dwarf_Off die_offset = dwarf_dieoffset(parent);
+
+ result = calloc(1, sizeof(struct arg_type_info));
+ if (result == NULL) {
+ complain(type_die, "alloc error");
+ CLEANUP_AND_RETURN_ERROR(NULL);
+ }
+
Dwarf_Die type_die;
if (!get_type_die(&type_die, parent)) {
complain(parent, "Array has unknown type");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- struct arg_type_info* info;
- if (!get_type(&info, &type_die, plib, type_dieoffset_hash)) {
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ array_type = get_type(&newly_allocated_array_type,
+ &type_die, plib, type_dieoffset_hash);
+ if( array_type == NULL ) {
complain(parent, "Couldn't figure out array's type");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
Dwarf_Die subrange;
if (dwarf_child(parent, &subrange) != 0) {
complain(parent,
"Array must have a DW_TAG_subrange_type child, but has none");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
Dwarf_Die next_subrange;
if (dwarf_siblingof(&subrange, &next_subrange) <= 0) {
complain(parent,
"Array must have exactly one DW_TAG_subrange_type child");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
if (dwarf_hasattr(&subrange, DW_AT_lower_bound)) {
uint64_t lower_bound;
if (!get_die_numeric(&lower_bound, &subrange, DW_AT_lower_bound)) {
complain(parent, "Couldn't read lower bound");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
if (lower_bound != 0) {
complain(parent,
"Array subrange has a nonzero lower bound. Don't know what to do");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
}
{
if (!get_die_numeric(&N, &subrange, DW_AT_upper_bound)) {
complain(parent, "Couldn't read upper bound");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
N++;
}
// I'm not checking the subrange type. It should be some sort of integer,
// and I don't know what it would mean for it to be something else
- struct value* value = calloc(1, sizeof(struct value));
+ value = calloc(1, sizeof(struct value));
if (value == NULL) {
complain(&subrange, "Couldn't alloc length value");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
value_init_detached(value, NULL, type_get_simple(ARGTYPE_INT), 0);
value_set_word(value, N);
- struct expr_node* length = calloc(1, sizeof(struct expr_node));
+ length = calloc(1, sizeof(struct expr_node));
if (length == NULL) {
complain(&subrange, "Couldn't alloc length expr");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
expr_init_const(length, value);
- type_init_array(array_info, info, 0, length, 0);
+ type_init_array(result, array_type, newly_allocated_array_type,
+ length, 1);
+ return result;
- return true;
+#undef CLEANUP_AND_RETURN_ERROR
}
-static bool get_structure(struct arg_type_info* struct_info, Dwarf_Die* parent, struct protolib* plib,
- struct dict* type_dieoffset_hash)
+// returns a newly-allocated art_type_info*, or NULL on error
+static struct arg_type_info* get_structure(Dwarf_Die* parent, struct protolib* plib,
+ struct dict* type_dieoffset_hash)
{
- type_init_struct(struct_info);
+
+#define CLEANUP_AND_RETURN_ERROR(ret) do { \
+ if(member_type != NULL && newly_allocated_member_type) { \
+ type_destroy(member_type); \
+ free(member_type); \
+ } \
+ if(result != NULL) { \
+ type_destroy(result); \
+ free(result); \
+ } \
+ dict_erase (type_dieoffset_hash, &die_offset, NULL, NULL, NULL); \
+ dict_insert(type_dieoffset_hash, &die_offset, \
+ &(struct arg_type_info*){type_get_simple(ARGTYPE_VOID)}); \
+ return ret; \
+ } while(0)
+
+
+ struct arg_type_info* result = NULL;
+ struct arg_type_info* member_type = NULL;
+ int newly_allocated_member_type = 0;
+
+ Dwarf_Off die_offset = dwarf_dieoffset(parent);
+
+ result = calloc(1, sizeof(struct arg_type_info));
+ if (result == NULL) {
+ complain(type_die, "alloc error");
+ CLEANUP_AND_RETURN_ERROR(NULL);
+ }
+ type_init_struct(result);
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
Dwarf_Die die;
if (dwarf_child(parent, &die) != 0) {
// no elements; we're done
- return true;
+ return result;
}
while(1) {
+ member_type = NULL;
+ newly_allocated_member_type = 0;
+
complain(&die, "member: 0x%02x", dwarf_tag(&die));
if (dwarf_tag(&die) != DW_TAG_member) {
complain(&die, "Structure can have ONLY DW_TAG_member");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
Dwarf_Die type_die;
if (!get_type_die(&type_die, &die)) {
complain(&die, "Couldn't get type of element");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- struct arg_type_info* member_info = NULL;
- if (!get_type(&member_info, &type_die, plib, type_dieoffset_hash)) {
+ member_type = get_type(&newly_allocated_member_type,
+ &type_die, plib, type_dieoffset_hash);
+ if(member_type == NULL) {
complain(&die, "Couldn't parse type from DWARF data");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- type_struct_add(struct_info, member_info, 0);
+ type_struct_add(result, member_type, newly_allocated_member_type);
NEXT_SIBLING(&die);
}
- return true;
+ return result;
+#undef CLEANUP_AND_RETURN_ERROR
}
-// Reads the type in the die into the given structure
-// Returns true on sucess
-static bool get_type(struct arg_type_info** info, Dwarf_Die* type_die, struct protolib* plib,
- struct dict* type_dieoffset_hash)
+// Reads the type in the die and returns the corresponding arg_type_info*. If
+// this was newly allocated on the heap, *newly_allocated_info = true. If an
+// error occurred, returns NULL
+static struct arg_type_info* get_type(int* newly_allocated_result,
+ Dwarf_Die* type_die, struct protolib* plib,
+ struct dict* type_dieoffset_hash)
{
+
+#define CLEANUP_AND_RETURN_ERROR(ret) do { \
+ if(pointee != NULL && newly_allocated_pointee) { \
+ type_destroy(pointee); \
+ free(pointee); \
+ } \
+ if(result != NULL && *newly_allocated_result) { \
+ type_destroy(result); \
+ free(result); \
+ } \
+ dict_erase (type_dieoffset_hash, &die_offset, NULL, NULL, NULL); \
+ dict_insert(type_dieoffset_hash, &die_offset, \
+ &(struct arg_type_info*){type_get_simple(ARGTYPE_VOID)}); \
+ return ret; \
+ } while(0)
+
+ struct arg_type_info* result = NULL;
+ struct arg_type_info* pointee = NULL;
+ int newly_allocated_pointee = 0;
+
Dwarf_Off die_offset = dwarf_dieoffset(type_die);
+
+
+ // by default, we say we allocated nothing. I set this to true later, when I
+ // allocate memory
+ *newly_allocated_result = 0;
+
struct arg_type_info** found_type = dict_find(type_dieoffset_hash, &die_offset);
if (found_type != NULL) {
- *info = *found_type;
- complain(type_die, "Read pre-computed type: %p", *info);
- return true;
+ complain(type_die, "Read pre-computed type");
+ return *found_type;
}
const char* type_name = dwarf_diename(type_die);
complain(type_die,
"Type '%s' defined in a .conf file. Using that instead of DWARF",
type_name);
- *info = already_defined_type->info;
- return true;
+ return already_defined_type->info;
}
}
switch (dwarf_tag(type_die)) {
case DW_TAG_base_type:
- *info = type_get_simple(get_base_type(type_die));
- complain(type_die, "Storing base type: %p", *info);
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return true;
+ complain(type_die, "Storing base type");
+ result = type_get_simple(get_base_type(type_die));
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ return result;
case DW_TAG_subroutine_type:
case DW_TAG_inlined_subroutine:
// function pointers are stored as void*. If ltrace tries to dereference
// these, it'll get a segfault
- *info = type_get_simple(ARGTYPE_VOID);
- complain(type_die, "Storing subroutine type: %p", *info);
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return true;
+ complain(type_die, "Storing subroutine type");
+ result = type_get_simple(ARGTYPE_VOID);
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ return result;
case DW_TAG_pointer_type:
-
if (!get_type_die(&next_die, type_die)) {
// the pointed-to type isn't defined, so I report a void*
- *info = type_get_voidptr();
- complain(type_die, "Storing void-pointer type: %p", *info);
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return true;
+ complain(type_die, "Storing void-pointer type");
+ result = type_get_voidptr();
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ return result;
}
- *info = calloc(1, sizeof(struct arg_type_info));
- if (*info == NULL) {
+ complain(type_die, "Storing pointer type");
+
+ *newly_allocated_result = 1;
+ result = calloc(1, sizeof(struct arg_type_info));
+ if (result == NULL) {
complain(type_die, "alloc error");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- type_init_pointer(*info, NULL, 0);
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ pointee = get_type(&newly_allocated_pointee,
+ &next_die, plib, type_dieoffset_hash);
+ if(pointee == NULL)
+ CLEANUP_AND_RETURN_ERROR(NULL);
- complain(type_die, "Storing pointer type: %p", *info);
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return get_type(&(*info)->u.ptr_info.info, &next_die, plib, type_dieoffset_hash);
+ type_init_pointer(result, pointee, newly_allocated_pointee);
+ return result;
case DW_TAG_structure_type:
- *info = calloc(1, sizeof(struct arg_type_info));
- if (*info == NULL) {
- complain(type_die, "alloc error");
- return false;
- }
+ complain(type_die, "Storing struct type");
+ *newly_allocated_result = 1;
- complain(type_die, "Storing struct type: %p", *info);
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return get_structure(*info, type_die, plib, type_dieoffset_hash);
+ result = get_structure(type_die, plib, type_dieoffset_hash);
+ if(result == NULL)
+ CLEANUP_AND_RETURN_ERROR(NULL);
+ return result;
case DW_TAG_typedef:
case DW_TAG_const_type:
- case DW_TAG_volatile_type: {
+ case DW_TAG_volatile_type:
// Various tags are simply pass-through, so I just keep going
- bool res = true;
if (get_type_die(&next_die, type_die)) {
- complain(type_die, "Storing const/typedef type: %p", *info);
- res = get_type(info, &next_die, plib, type_dieoffset_hash);
+ complain(type_die, "Storing const/typedef type");
+
+ result = get_type(newly_allocated_result, &next_die,
+ plib, type_dieoffset_hash);
+ if(result == NULL)
+ CLEANUP_AND_RETURN_ERROR(NULL);
} else {
// no type. Use 'void'. Normally I'd think this is bogus, but stdio
// typedefs something to void
- *info = type_get_simple(ARGTYPE_VOID);
- complain(type_die, "Storing void type: %p", *info);
+ result = type_get_simple(ARGTYPE_VOID);
+ complain(type_die, "Storing void type");
}
- if (res)
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return res;
- }
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ return result;
case DW_TAG_enumeration_type:
- // We have an enumeration. This has type "int", but has a particular
+ // We have an enumeration. This has a base type, but has a particular
// lens to handle the enum
- *info = calloc(1, sizeof(struct arg_type_info));
- if (*info == NULL) {
- complain(type_die, "alloc error");
- return false;
- }
+ *newly_allocated_result = 1;
- complain(type_die, "Storing enum int: %p", *info);
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return get_enum(*info, type_die);
+ complain(type_die, "Storing enum int");
+ result = get_enum(type_die, type_dieoffset_hash);
+ if(result == NULL)
+ CLEANUP_AND_RETURN_ERROR(NULL);
+ return result;
case DW_TAG_array_type:
- *info = calloc(1, sizeof(struct arg_type_info));
- if (*info == NULL) {
- complain(type_die, "alloc error");
- return false;
- }
+ *newly_allocated_result = 1;
- complain(type_die, "Storing array: %p", *info);
- dict_insert(type_dieoffset_hash, &die_offset, info);
- return get_array(*info, type_die, plib, type_dieoffset_hash);
+ complain(type_die, "Storing array");
+ result = get_array(type_die, plib, type_dieoffset_hash);
+ if(result == NULL)
+ CLEANUP_AND_RETURN_ERROR(NULL);
+ return result;
case DW_TAG_union_type:
- *info = type_get_simple(ARGTYPE_VOID);
- complain(type_die, "Storing union-as-void type: %p", *info);
- return true;
+ result = type_get_simple(ARGTYPE_VOID);
+ complain(type_die, "Storing union-as-void type");
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ return result;
default:
- complain(type_die, "Unknown type tag 0x%x", dwarf_tag(type_die));
- break;
+ complain(type_die, "Unknown type tag 0x%x. Returning void", dwarf_tag(type_die));
+ result = type_get_simple(ARGTYPE_VOID);
+ dict_insert(type_dieoffset_hash, &die_offset, &result);
+ return result;
}
- return false;
+#undef CLEANUP_AND_RETURN_ERROR
}
-static bool get_prototype(struct prototype* proto, Dwarf_Die* subroutine, struct protolib* plib,
- struct dict* type_dieoffset_hash)
+// returns a newly-allocated prototype*, or NULL on error
+static struct prototype* get_prototype( Dwarf_Die* subroutine, struct protolib* plib,
+ struct dict* type_dieoffset_hash)
{
+
+#define CLEANUP_AND_RETURN_ERROR(ret) do { \
+ if(argument_type != NULL && newly_allocated_argument_type) { \
+ type_destroy(argument_type); \
+ free(argument_type); \
+ } \
+ if(result != NULL) { \
+ prototype_destroy(result); \
+ free(result); \
+ } \
+ return ret; \
+ } while(0)
+
+
+ struct prototype* result = NULL;
+ struct arg_type_info* argument_type = NULL;
+ int newly_allocated_argument_type = 0;
+
+ result = calloc(1, sizeof(struct prototype));
+ if (result == NULL) {
+ complain(die, "couldn't alloc prototype");
+ CLEANUP_AND_RETURN_ERROR(NULL);
+ }
+ prototype_init(result);
+
// First, look at the return type. This is stored in a DW_AT_type tag in the
// subroutine DIE. If there is no such tag, this function returns void
Dwarf_Die return_type_die;
if (!get_type_die(&return_type_die, subroutine)) {
- proto->return_info = type_get_simple(ARGTYPE_VOID);
- proto->own_return_info = 0;
+ result->return_info = type_get_simple(ARGTYPE_VOID);
+ result->own_return_info = 0;
} else {
- proto->return_info = calloc(1, sizeof(struct arg_type_info));
- if (proto->return_info == NULL) {
+ result->return_info = calloc(1, sizeof(struct arg_type_info));
+ if (result->return_info == NULL) {
complain(subroutine, "Couldn't alloc return type");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- proto->own_return_info = 0;
+ result->own_return_info = 1;
- if (!get_type(&proto->return_info, &return_type_die, plib, type_dieoffset_hash)) {
+ int newly_allocated_return_type;
+ result->return_info = get_type(&newly_allocated_return_type,
+ &return_type_die, plib, type_dieoffset_hash);
+ if(result->return_info == NULL) {
complain(subroutine, "Couldn't get return type");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
+ result->own_return_info = newly_allocated_return_type;
}
Dwarf_Die arg_die;
if (dwarf_child(subroutine, &arg_die) != 0) {
// no args. We're done
- return true;
+ return result;
}
while(1) {
complain(&arg_die, "arg: 0x%02x", dwarf_tag(&arg_die));
+ argument_type = NULL;
+ newly_allocated_argument_type = false;
+
Dwarf_Die type_die;
if (!get_type_die(&type_die, &arg_die)) {
complain(&arg_die, "Couldn't get the argument type die");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
- struct arg_type_info* arg_type_info = NULL;
- if (!get_type(&arg_type_info, &type_die, plib, type_dieoffset_hash)) {
+
+ argument_type = get_type(&newly_allocated_argument_type,
+ &type_die, plib, type_dieoffset_hash);
+ if(argument_type==NULL) {
complain(&arg_die, "Couldn't parse arg type from DWARF data");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
struct param param;
- param_init_type(¶m, arg_type_info, 0);
- if (prototype_push_param(proto, ¶m) <0) {
+ param_init_type(¶m, argument_type, newly_allocated_argument_type);
+ if (prototype_push_param(result, ¶m) <0) {
complain(&arg_die, "couldn't add argument to the prototype");
- return false;
+ CLEANUP_AND_RETURN_ERROR(NULL);
}
#ifdef DUMP_PROTOTYPES
fprintf(stderr, "Adding argument:\n");
- dump_ltrace_tree(arg_type_info);
+ dump_ltrace_tree(argument_type);
#endif
}
NEXT_SIBLING(&arg_die);
}
- return true;
+ return result;
+#undef CLEANUP_AND_RETURN_ERROR
}
static bool import_subprogram(struct protolib* plib, struct library* lib,
return true;
}
- proto = malloc(sizeof(struct prototype));
- if (proto == NULL) {
- complain(die, "couldn't alloc prototype");
+ proto = get_prototype(die, plib, type_dieoffset_hash);
+ if(proto == NULL) {
+ complain(die, "couldn't get prototype");
return false;
}
- prototype_init(proto);
- if (!get_prototype(proto, die, plib, type_dieoffset_hash)) {
- complain(die, "couldn't get prototype");
+ const char* function_name_dup = strdup(function_name);
+ if( function_name_dup == NULL ) {
+ complain(die, "couldn't strdup");
+ prototype_destroy(proto);
+ free(proto);
return false;
}
-
- protolib_add_prototype(plib, function_name, 0, proto);
+ protolib_add_prototype(plib, function_name_dup, 1, proto);
return true;
}
while (1) {
if (dwarf_tag(&die) == DW_TAG_subprogram)
if(!import_subprogram(plib, lib, type_dieoffset_hash, &die))
- return false;
+ complain(&die, "Error importing subprogram. Skipping");
NEXT_SIBLING(&die);
}
return true;
}
-static bool import(struct protolib* plib, struct library* lib, Dwfl* dwfl)
+static void import(struct protolib* plib, struct library* lib, Dwfl* dwfl)
{
// A map from DIE addresses (Dwarf_Off) to type structures (struct
// arg_type_info*). This is created and filled in at the start of each
dict_init(&type_dieoffset_hash, sizeof(Dwarf_Off), sizeof(struct arg_type_info*),
dwarf_die_hash, dwarf_die_eq, NULL);
- bool result = true;
-
Dwarf_Addr bias;
Dwarf_Die* die = NULL;
while ((die = dwfl_nextcu(dwfl, die, &bias)) != NULL) {
- if (dwarf_tag(die) == DW_TAG_compile_unit) {
- if (!process_die_compileunit(plib, lib, &type_dieoffset_hash, die)) {
- complain(die, "Error reading compile unit");
- exit(1);
-
- result = false;
- break;
- }
- } else {
- complain(die, "DW_TAG_compile_unit expected");
- exit(1);
-
- result = false;
- break;
- }
+ if (dwarf_tag(die) == DW_TAG_compile_unit)
+ process_die_compileunit(plib, lib, &type_dieoffset_hash, die);
+ else
+ complain(die, "A DW_TAG_compile_unit die expected. Skipping this one");
}
dict_destroy(&type_dieoffset_hash, NULL, NULL, NULL);
- return result;
}
bool import_DWARF_prototypes(struct library* lib)
Dwfl* dwfl = lib->dwfl;
if (plib == NULL) {
- plib = protolib_cache_default(&g_protocache, lib->soname, 0);
+
+ const char* soname_dup = strdup(lib->soname);
+ if( soname_dup == NULL ) {
+ fprintf(stderr, "couldn't strdup");
+ return false;
+ }
+
+ plib = protolib_cache_default(&g_protocache, soname_dup, 1);
if (plib == NULL) {
fprintf(stderr, "Error loading protolib %s: %s.\n",
lib->soname, strerror(errno));
}
}
- if (import(plib, lib, dwfl)) {
- lib->protolib = plib;
- return true;
- }
- return false;
+ import(plib, lib, dwfl);
+ lib->protolib = plib;
+
+ return true;
}
/*
- all my *allocs leak
-
*/
projects / platform / upstream / ltrace.git / commitdiff