/*

  SPDX-License-Identifier: GPL-2.0-only

  Copyright (C) 2008 Arnaldo Carvalho de Melo <acme@redhat.com>

*/

#include <assert.h>

#include <dirent.h>

#include <dwarf.h>

#include <elfutils/libdwfl.h>

#include <errno.h>

#include <fcntl.h>

#include <fnmatch.h>

#include <libelf.h>

#include <obstack.h>

#include <search.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "config.h"

#include "list.h"

#include "dwarves.h"

#include "dutil.h"

#include "strings.h"

#include "hash.h"

struct strings *strings;

#ifndef DW_AT_GNU_vector

#define DW_AT_GNU_vector 0x2107

#endif

#ifndef DW_TAG_GNU_call_site

#define DW_TAG_GNU_call_site 0x4109

#define DW_TAG_GNU_call_site_parameter 0x410a

#endif

#define hashtags__fn(key) hash_64(key, HASHTAGS__BITS)

bool no_bitfield_type_recode = true;

static void __tag__print_not_supported(uint32_t tag, const char *func)

{

	static bool dwarf_tags_warned[DW_TAG_GNU_call_site_parameter + 64];

	if (tag < sizeof(dwarf_tags_warned)) {

		if (dwarf_tags_warned[tag])

			return;

		dwarf_tags_warned[tag] = true;

	}

	fprintf(stderr, "%s: tag not supported %#x (%s)!\n", func,

		tag, dwarf_tag_name(tag));

}

#define tag__print_not_supported(tag) \

	__tag__print_not_supported(tag, __func__)

struct dwarf_off_ref {

	unsigned int	from_types : 1;

	Dwarf_Off	off;

};

typedef struct dwarf_off_ref dwarf_off_ref;

struct dwarf_tag {

	struct hlist_node hash_node;

	dwarf_off_ref	 type;

	Dwarf_Off	 id;

	union {

		dwarf_off_ref abstract_origin;

		dwarf_off_ref containing_type;

	};

	struct tag	 *tag;

	uint32_t         small_id;

	strings_t        decl_file;

	uint16_t         decl_line;

};

static dwarf_off_ref dwarf_tag__spec(struct dwarf_tag *dtag)

{

	return *(dwarf_off_ref *)(dtag + 1);

}

static void dwarf_tag__set_spec(struct dwarf_tag *dtag, dwarf_off_ref spec)

{

	*(dwarf_off_ref *)(dtag + 1) = spec;

}

#define HASHTAGS__BITS 8

#define HASHTAGS__SIZE (1UL << HASHTAGS__BITS)

#define obstack_chunk_alloc malloc

#define obstack_chunk_free free

static void *obstack_zalloc(struct obstack *obstack, size_t size)

{

	void *o = obstack_alloc(obstack, size);

	if (o)

		memset(o, 0, size);

	return o;

}

struct dwarf_cu {

	struct hlist_head hash_tags[HASHTAGS__SIZE];

	struct hlist_head hash_types[HASHTAGS__SIZE];

	struct obstack obstack;

	struct cu *cu;

	struct dwarf_cu *type_unit;

};

static void dwarf_cu__init(struct dwarf_cu *dcu)

{

	unsigned int i;

	for (i = 0; i < HASHTAGS__SIZE; ++i) {

		INIT_HLIST_HEAD(&dcu->hash_tags[i]);

		INIT_HLIST_HEAD(&dcu->hash_types[i]);

	}

	obstack_init(&dcu->obstack);

	dcu->type_unit = NULL;

}

static void hashtags__hash(struct hlist_head *hashtable,

			   struct dwarf_tag *dtag)

{

	struct hlist_head *head = hashtable + hashtags__fn(dtag->id);

	hlist_add_head(&dtag->hash_node, head);

}

static struct dwarf_tag *hashtags__find(const struct hlist_head *hashtable,

					const Dwarf_Off id)

{

	if (id == 0)

		return NULL;

	struct dwarf_tag *tpos;

	struct hlist_node *pos;

	uint16_t bucket = hashtags__fn(id);

	const struct hlist_head *head = hashtable + bucket;

	hlist_for_each_entry(tpos, pos, head, hash_node) {

		if (tpos->id == id)

			return tpos;

	}

	return NULL;

}

static void cu__hash(struct cu *cu, struct tag *tag)

{

	struct dwarf_cu *dcu = cu->priv;

	struct hlist_head *hashtable = tag__is_tag_type(tag) ?

							dcu->hash_types :

							dcu->hash_tags;

	hashtags__hash(hashtable, tag->priv);

}

static struct dwarf_tag *dwarf_cu__find_tag_by_ref(const struct dwarf_cu *cu,

						   const struct dwarf_off_ref *ref)

{

	if (cu == NULL)

		return NULL;

	if (ref->from_types) {

		return NULL;

	}

	return hashtags__find(cu->hash_tags, ref->off);

}

static struct dwarf_tag *dwarf_cu__find_type_by_ref(const struct dwarf_cu *dcu,

						    const struct dwarf_off_ref *ref)

{

	if (dcu == NULL)

		return NULL;

	if (ref->from_types) {

		dcu = dcu->type_unit;

		if (dcu == NULL) {

			return NULL;

		}

	}

	return hashtags__find(dcu->hash_types, ref->off);

}

extern struct strings *strings;

static void *memdup(const void *src, size_t len, struct cu *cu)

{

	void *s = obstack_alloc(&cu->obstack, len);

	if (s != NULL)

		memcpy(s, src, len);

	return s;

}

/* Number decoding macros.  See 7.6 Variable Length Data.  */

#define get_uleb128_step(var, addr, nth, break)			\

	__b = *(addr)++;					\

	var |= (uintmax_t) (__b & 0x7f) << (nth * 7);		\

	if ((__b & 0x80) == 0)					\

		break

#define get_uleb128_rest_return(var, i, addrp)			\

	do {							\

		for (; i < 10; ++i) {				\

			get_uleb128_step(var, *addrp, i,	\

					  return var);		\

	}							\

	/* Other implementations set VALUE to UINT_MAX in this	\

	  case. So we better do this as well.  */		\

	return UINT64_MAX;					\

  } while (0)

static uint64_t __libdw_get_uleb128(uint64_t acc, uint32_t i,

				    const uint8_t **addrp)

{

	uint8_t __b;

	get_uleb128_rest_return (acc, i, addrp);

}

#define get_uleb128(var, addr)					\

	do {							\

		uint8_t __b;				\

		var = 0;					\

		get_uleb128_step(var, addr, 0, break);		\

		var = __libdw_get_uleb128 (var, 1, &(addr));	\

	} while (0)

static uint64_t attr_numeric(Dwarf_Die *die, uint32_t name)

{

	Dwarf_Attribute attr;

	uint32_t form;

	if (dwarf_attr(die, name, &attr) == NULL)

		return 0;

	form = dwarf_whatform(&attr);

	switch (form) {

	case DW_FORM_addr: {

		Dwarf_Addr addr;

		if (dwarf_formaddr(&attr, &addr) == 0)

			return addr;

	}

		break;

	case DW_FORM_data1:

	case DW_FORM_data2:

	case DW_FORM_data4:

	case DW_FORM_data8:

	case DW_FORM_sdata:

	case DW_FORM_udata: {

		Dwarf_Word value;

		if (dwarf_formudata(&attr, &value) == 0)

			return value;

	}

		break;

	case DW_FORM_flag:

	case DW_FORM_flag_present: {

		bool value;

		if (dwarf_formflag(&attr, &value) == 0)

			return value;

	}

		break;

	default:

		fprintf(stderr, "DW_AT_<0x%x>=0x%x\n", name, form);

		break;

	}

	return 0;

}

static uint64_t dwarf_expr(const uint8_t *expr, uint32_t len __unused)

{

	/* Common case: offset from start of the class */

	if (expr[0] == DW_OP_plus_uconst ||

	    expr[0] == DW_OP_constu) {

		uint64_t result;

		++expr;

		get_uleb128(result, expr);

		return result;

	}

	fprintf(stderr, "%s: unhandled %#x DW_OP_ operation\n",

		__func__, *expr);

	return UINT64_MAX;

}

static Dwarf_Off attr_offset(Dwarf_Die *die, const uint32_t name)

{

	Dwarf_Attribute attr;

	Dwarf_Block block;

	if (dwarf_attr(die, name, &attr) == NULL)

		return 0;

	switch (dwarf_whatform(&attr)) {

	case DW_FORM_data1:

	case DW_FORM_data2:

	case DW_FORM_data4:

	case DW_FORM_data8:

	case DW_FORM_sdata:

	case DW_FORM_udata: {

		Dwarf_Word value;

		if (dwarf_formudata(&attr, &value) == 0)

			return value;

		break;

	}

	default:

		if (dwarf_formblock(&attr, &block) == 0)

			return dwarf_expr(block.data, block.length);

	}

	return 0;

}

static const char *attr_string(Dwarf_Die *die, uint32_t name)

{

	Dwarf_Attribute attr;

	if (dwarf_attr(die, name, &attr) != NULL)

		return dwarf_formstring(&attr);

	return NULL;

}

static struct dwarf_off_ref attr_type(Dwarf_Die *die, uint32_t attr_name)

{

	Dwarf_Attribute attr;

	struct dwarf_off_ref ref;

	if (dwarf_attr(die, attr_name, &attr) != NULL) {

		Dwarf_Die type_die;

		if (dwarf_formref_die(&attr, &type_die) != NULL) {

			ref.from_types = attr.form == DW_FORM_ref_sig8;

			ref.off = dwarf_dieoffset(&type_die);

			return ref;

		}

	}

	memset(&ref, 0, sizeof(ref));

	return ref;

}

static int attr_location(Dwarf_Die *die, Dwarf_Op **expr, size_t *exprlen)

{

	Dwarf_Attribute attr;

	if (dwarf_attr(die, DW_AT_location, &attr) != NULL) {

		if (dwarf_getlocation(&attr, expr, exprlen) == 0)

			return 0;

	}

	return 1;

}

static void *__tag__alloc(struct dwarf_cu *dcu, size_t size, bool spec)

{

	struct dwarf_tag *dtag = obstack_zalloc(&dcu->obstack,

						(sizeof(*dtag) +

						 (spec ? sizeof(dwarf_off_ref) : 0)));

	if (dtag == NULL)

		return NULL;

	struct tag *tag = obstack_zalloc(&dcu->cu->obstack, size);

	if (tag == NULL)

		return NULL;

	dtag->tag = tag;

	tag->priv = dtag;

	tag->type = 0;

	tag->top_level = 0;

	return tag;

}

static void *tag__alloc(struct cu *cu, size_t size)

{

	return __tag__alloc(cu->priv, size, false);

}

static void *tag__alloc_with_spec(struct cu *cu, size_t size)

{

	return __tag__alloc(cu->priv, size, true);

}

static void tag__init(struct tag *tag, struct cu *cu, Dwarf_Die *die)

{

	struct dwarf_tag *dtag = tag->priv;

	tag->tag = dwarf_tag(die);

	dtag->id  = dwarf_dieoffset(die);

	if (tag->tag == DW_TAG_imported_module ||

	    tag->tag == DW_TAG_imported_declaration)

		dtag->type = attr_type(die, DW_AT_import);

	else

		dtag->type = attr_type(die, DW_AT_type);

	dtag->abstract_origin = attr_type(die, DW_AT_abstract_origin);

	tag->recursivity_level = 0;

	if (cu->extra_dbg_info) {

		int32_t decl_line;

		const char *decl_file = dwarf_decl_file(die);

		static const char *last_decl_file;

		static uint32_t last_decl_file_idx;

		if (decl_file != last_decl_file) {

			last_decl_file_idx = strings__add(strings, decl_file);

			last_decl_file = decl_file;

		}

		dtag->decl_file = last_decl_file_idx;

		dwarf_decl_line(die, &decl_line);

		dtag->decl_line = decl_line;

	}

	INIT_LIST_HEAD(&tag->node);

}

static struct tag *tag__new(Dwarf_Die *die, struct cu *cu)

{

	struct tag *tag = tag__alloc(cu, sizeof(*tag));

	if (tag != NULL)

		tag__init(tag, cu, die);

	return tag;

}

static struct ptr_to_member_type *ptr_to_member_type__new(Dwarf_Die *die,

							  struct cu *cu)

{

	struct ptr_to_member_type *ptr = tag__alloc(cu, sizeof(*ptr));

	if (ptr != NULL) {

		tag__init(&ptr->tag, cu, die);

		struct dwarf_tag *dtag = ptr->tag.priv;

		dtag->containing_type = attr_type(die, DW_AT_containing_type);

	}

	return ptr;

}

static struct base_type *base_type__new(Dwarf_Die *die, struct cu *cu)

{

	struct base_type *bt = tag__alloc(cu, sizeof(*bt));

	if (bt != NULL) {

		tag__init(&bt->tag, cu, die);

		bt->name = strings__add(strings, attr_string(die, DW_AT_name));

		bt->bit_size = attr_numeric(die, DW_AT_byte_size) * 8;

		uint64_t encoding = attr_numeric(die, DW_AT_encoding);

		bt->is_bool = encoding == DW_ATE_boolean;

		bt->is_signed = encoding == DW_ATE_signed;

		bt->is_varargs = false;

		bt->name_has_encoding = true;

	}

	return bt;

}

static struct array_type *array_type__new(Dwarf_Die *die, struct cu *cu)

{

	struct array_type *at = tag__alloc(cu, sizeof(*at));

	if (at != NULL) {

		tag__init(&at->tag, cu, die);

		at->dimensions = 0;

		at->nr_entries = NULL;

		at->is_vector	 = dwarf_hasattr(die, DW_AT_GNU_vector);

	}

	return at;

}

static void namespace__init(struct namespace *namespace, Dwarf_Die *die,

			    struct cu *cu)

{

	tag__init(&namespace->tag, cu, die);

	INIT_LIST_HEAD(&namespace->tags);

	namespace->sname = 0;

	namespace->name  = strings__add(strings, attr_string(die, DW_AT_name));

	namespace->nr_tags = 0;

	namespace->shared_tags = 0;

}

static struct namespace *namespace__new(Dwarf_Die *die, struct cu *cu)

{

	struct namespace *namespace = tag__alloc(cu, sizeof(*namespace));

	if (namespace != NULL)

		namespace__init(namespace, die, cu);

	return namespace;

}

static void type__init(struct type *type, Dwarf_Die *die, struct cu *cu)

{

	namespace__init(&type->namespace, die, cu);

	INIT_LIST_HEAD(&type->node);

	type->size		 = attr_numeric(die, DW_AT_byte_size);

	type->alignment		 = attr_numeric(die, DW_AT_alignment);

	type->declaration	 = attr_numeric(die, DW_AT_declaration);

	dwarf_tag__set_spec(type->namespace.tag.priv,

			    attr_type(die, DW_AT_specification));

	type->definition_emitted = 0;

	type->fwd_decl_emitted	 = 0;

	type->resized		 = 0;

	type->nr_members	 = 0;

	type->nr_static_members	 = 0;

}

static struct type *type__new(Dwarf_Die *die, struct cu *cu)

{

	struct type *type = tag__alloc_with_spec(cu, sizeof(*type));

	if (type != NULL)

		type__init(type, die, cu);

	return type;

}

static struct enumerator *enumerator__new(Dwarf_Die *die, struct cu *cu)

{

	struct enumerator *enumerator = tag__alloc(cu, sizeof(*enumerator));

	if (enumerator != NULL) {

		tag__init(&enumerator->tag, cu, die);

		enumerator->name = strings__add(strings, attr_string(die, DW_AT_name));

		enumerator->value = attr_numeric(die, DW_AT_const_value);

	}

	return enumerator;

}

static enum vscope dwarf__location(Dwarf_Die *die, uint64_t *addr, struct location *location)

{

	enum vscope scope = VSCOPE_UNKNOWN;

	if (attr_location(die, &location->expr, &location->exprlen) != 0)

		scope = VSCOPE_OPTIMIZED;

	else if (location->exprlen != 0) {

		Dwarf_Op *expr = location->expr;

		switch (expr->atom) {

		case DW_OP_addr:

			scope = VSCOPE_GLOBAL;

			*addr = expr[0].number;

			break;

		case DW_OP_reg1 ... DW_OP_reg31:

		case DW_OP_breg0 ... DW_OP_breg31:

			scope = VSCOPE_REGISTER;	break;

		case DW_OP_fbreg:

			scope = VSCOPE_LOCAL;	break;

		}

	}

	return scope;

}

enum vscope variable__scope(const struct variable *var)

{

	return var->scope;

}

const char *variable__scope_str(const struct variable *var)

{

	switch (var->scope) {

	case VSCOPE_LOCAL:	return "local";

	case VSCOPE_GLOBAL:	return "global";

	case VSCOPE_REGISTER:	return "register";

	case VSCOPE_OPTIMIZED:	return "optimized";

	default: break;

	};

	return "unknown";

}

static struct variable *variable__new(Dwarf_Die *die, struct cu *cu)

{

	struct variable *var = tag__alloc(cu, sizeof(*var));

	if (var != NULL) {

		tag__init(&var->ip.tag, cu, die);

		var->name = strings__add(strings, attr_string(die, DW_AT_name));

		/* variable is visible outside of its enclosing cu */

		var->external = dwarf_hasattr(die, DW_AT_external);

		/* non-defining declaration of an object */

		var->declaration = dwarf_hasattr(die, DW_AT_declaration);

		var->scope = VSCOPE_UNKNOWN;

		var->ip.addr = 0;

		if (!var->declaration && cu->has_addr_info)

			var->scope = dwarf__location(die, &var->ip.addr, &var->location);

	}

	return var;

}

static int tag__recode_dwarf_bitfield(struct tag *tag, struct cu *cu, uint16_t bit_size)

{

	int id;

	type_id_t short_id;

	struct tag *recoded;

	/* in all the cases the name is at the same offset */

	strings_t name = tag__namespace(tag)->name;

	switch (tag->tag) {

	case DW_TAG_typedef: {

		const struct dwarf_tag *dtag = tag->priv;

		struct dwarf_tag *dtype = dwarf_cu__find_type_by_ref(cu->priv,

								     &dtag->type);

		struct tag *type = dtype->tag;

		id = tag__recode_dwarf_bitfield(type, cu, bit_size);

		if (id < 0)

			return id;

		struct type *new_typedef = obstack_zalloc(&cu->obstack,

							  sizeof(*new_typedef));

		if (new_typedef == NULL)

			return -ENOMEM;

		recoded = (struct tag *)new_typedef;

		recoded->tag = DW_TAG_typedef;

		recoded->type = id;

		new_typedef->namespace.name = tag__namespace(tag)->name;

	}

		break;

	case DW_TAG_const_type:

	case DW_TAG_volatile_type: {

		const struct dwarf_tag *dtag = tag->priv;

		struct dwarf_tag *dtype = dwarf_cu__find_type_by_ref(cu->priv, &dtag->type);

		struct tag *type = dtype->tag;

		id = tag__recode_dwarf_bitfield(type, cu, bit_size);

		if (id == tag->type)

			return id;

		recoded = obstack_zalloc(&cu->obstack, sizeof(*recoded));

		if (recoded == NULL)

			return -ENOMEM;

		recoded->tag = DW_TAG_volatile_type;

		recoded->type = id;

	}

		break;

	case DW_TAG_base_type:

		/*

		 * Here we must search on the final, core cu, not on

		 * the dwarf_cu as in dwarf there are no such things

		 * as base_types of less than 8 bits, etc.

		 */

		recoded = cu__find_base_type_by_sname_and_size(cu, name, bit_size, &short_id);

		if (recoded != NULL)

			return short_id;

		struct base_type *new_bt = obstack_zalloc(&cu->obstack,

							  sizeof(*new_bt));

		if (new_bt == NULL)

			return -ENOMEM;

		recoded = (struct tag *)new_bt;

		recoded->tag = DW_TAG_base_type;

		recoded->top_level = 1;

		new_bt->name = name;

		new_bt->bit_size = bit_size;

		break;

	case DW_TAG_enumeration_type:

		/*

		 * Here we must search on the final, core cu, not on

		 * the dwarf_cu as in dwarf there are no such things

		 * as enumeration_types of less than 8 bits, etc.

		 */

		recoded = cu__find_enumeration_by_sname_and_size(cu, name, bit_size, &short_id);

		if (recoded != NULL)

			return short_id;

		struct type *alias = tag__type(tag);

		struct type *new_enum = obstack_zalloc(&cu->obstack, sizeof(*new_enum));

		if (new_enum == NULL)

			return -ENOMEM;

		recoded = (struct tag *)new_enum;

		recoded->tag = DW_TAG_enumeration_type;

		recoded->top_level = 1;

		new_enum->nr_members = alias->nr_members;

		/*

		 * Share the tags

		 */

		new_enum->namespace.tags.next = &alias->namespace.tags;

		new_enum->namespace.shared_tags = 1;

		new_enum->namespace.name = name;

		new_enum->size = bit_size;

		break;

	default:

		fprintf(stderr, "%s: tag=%s, name=%s, bit_size=%d\n",

			__func__, dwarf_tag_name(tag->tag),

			strings__ptr(strings, name), bit_size);

		return -EINVAL;

	}

	uint32_t new_id;

	if (cu__add_tag(cu, recoded, &new_id) == 0)

		return new_id;

	obstack_free(&cu->obstack, recoded);

	return -ENOMEM;

}

int class_member__dwarf_recode_bitfield(struct class_member *member,

					struct cu *cu)

{

	struct dwarf_tag *dtag = member->tag.priv;

	struct dwarf_tag *type = dwarf_cu__find_type_by_ref(cu->priv, &dtag->type);

	int recoded_type_id;

	if (type == NULL)

		return -ENOENT;

	recoded_type_id = tag__recode_dwarf_bitfield(type->tag, cu, member->bitfield_size);

	if (recoded_type_id < 0)

		return recoded_type_id;

	member->tag.type = recoded_type_id;

	return 0;

}

static struct class_member *class_member__new(Dwarf_Die *die, struct cu *cu,

					      bool in_union)

{

	struct class_member *member = tag__alloc(cu, sizeof(*member));

	if (member != NULL) {

		tag__init(&member->tag, cu, die);

		member->name = strings__add(strings, attr_string(die, DW_AT_name));

		member->is_static   = !in_union && !dwarf_hasattr(die, DW_AT_data_member_location);

		member->const_value = attr_numeric(die, DW_AT_const_value);

		member->alignment = attr_numeric(die, DW_AT_alignment);

		member->byte_offset = attr_offset(die, DW_AT_data_member_location);

		/*

		 * Bit offset calculated here is valid only for byte-aligned

		 * fields. For bitfields on little-endian archs we need to

		 * adjust them taking into account byte size of the field,

		 * which might not be yet known. So we'll re-calculate bit

		 * offset later, in class_member__cache_byte_size.

		 */

		member->bit_offset = member->byte_offset * 8;

		/*

		 * If DW_AT_byte_size is not present, byte size will be

		 * determined later in class_member__cache_byte_size using

		 * base integer/enum type

		 */

		member->byte_size = attr_numeric(die, DW_AT_byte_size);

		member->bitfield_offset = attr_numeric(die, DW_AT_bit_offset);

		member->bitfield_size = attr_numeric(die, DW_AT_bit_size);

		member->bit_hole = 0;

		member->bitfield_end = 0;

		member->visited = 0;

		member->accessibility = attr_numeric(die, DW_AT_accessibility);

		member->virtuality    = attr_numeric(die, DW_AT_virtuality);

		member->hole = 0;

	}

	return member;

}

static struct parameter *parameter__new(Dwarf_Die *die, struct cu *cu)

{

	struct parameter *parm = tag__alloc(cu, sizeof(*parm));

	if (parm != NULL) {

		tag__init(&parm->tag, cu, die);

		parm->name = strings__add(strings, attr_string(die, DW_AT_name));

	}

	return parm;

}

static struct inline_expansion *inline_expansion__new(Dwarf_Die *die,

						      struct cu *cu)

{

	struct inline_expansion *exp = tag__alloc(cu, sizeof(*exp));

	if (exp != NULL) {

		struct dwarf_tag *dtag = exp->ip.tag.priv;

		tag__init(&exp->ip.tag, cu, die);

		dtag->decl_file =

			strings__add(strings, attr_string(die, DW_AT_call_file));

		dtag->decl_line = attr_numeric(die, DW_AT_call_line);

		dtag->type = attr_type(die, DW_AT_abstract_origin);

		exp->ip.addr = 0;

		exp->high_pc = 0;

		if (!cu->has_addr_info)

			goto out;

		if (dwarf_lowpc(die, &exp->ip.addr))

			exp->ip.addr = 0;

		if (dwarf_lowpc(die, &exp->high_pc))

			exp->high_pc = 0;

		exp->size = exp->high_pc - exp->ip.addr;

		if (exp->size == 0) {

			Dwarf_Addr base, start;

			ptrdiff_t offset = 0;

			while (1) {

				offset = dwarf_ranges(die, offset, &base, &start,

						      &exp->high_pc);

				start = (unsigned long)start;

				exp->high_pc = (unsigned long)exp->high_pc;

				if (offset <= 0)

					break;

				exp->size += exp->high_pc - start;

				if (exp->ip.addr == 0)

					exp->ip.addr = start;

			}

		}

	}

out:

	return exp;

}

static struct label *label__new(Dwarf_Die *die, struct cu *cu)

{

	struct label *label = tag__alloc(cu, sizeof(*label));

	if (label != NULL) {

		tag__init(&label->ip.tag, cu, die);

		label->name = strings__add(strings, attr_string(die, DW_AT_name));

		if (!cu->has_addr_info || dwarf_lowpc(die, &label->ip.addr))

			label->ip.addr = 0;

	}

	return label;

}

static struct class *class__new(Dwarf_Die *die, struct cu *cu)

{

	struct class *class = tag__alloc_with_spec(cu, sizeof(*class));

	if (class != NULL) {

		type__init(&class->type, die, cu);

		INIT_LIST_HEAD(&class->vtable);

		class->nr_vtable_entries =

		  class->nr_holes =

		  class->nr_bit_holes =

		  class->padding =

		  class->bit_padding = 0;

		class->priv = NULL;

	}

	return class;

}

static void lexblock__init(struct lexblock *block, struct cu *cu,

			   Dwarf_Die *die)

{

	Dwarf_Off high_pc;

	if (!cu->has_addr_info || dwarf_lowpc(die, &block->ip.addr)) {

		block->ip.addr = 0;

		block->size = 0;

	} else if (dwarf_highpc(die, &high_pc))

		block->size = 0;

	else

		block->size = high_pc - block->ip.addr;

	INIT_LIST_HEAD(&block->tags);

	block->size_inline_expansions =

	block->nr_inline_expansions =

		block->nr_labels =

		block->nr_lexblocks =

		block->nr_variables = 0;

}

static struct lexblock *lexblock__new(Dwarf_Die *die, struct cu *cu)