自学教程：C++ DWARF_SET_ERROR函数代码示例

intdwarf_linesrc(Dwarf_Line ln, char **ret_linesrc, Dwarf_Error *error){	Dwarf_LineInfo li;	Dwarf_LineFile lf;	int i;	if (ln == NULL || ret_linesrc == NULL) {		DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	li = ln->ln_li;	assert(li != NULL);	for (i = 1, lf = STAILQ_FIRST(&li->li_lflist);	     (Dwarf_Unsigned) i < ln->ln_fileno && lf != NULL;	     i++, lf = STAILQ_NEXT(lf, lf_next))		;	if (lf == NULL) {		DWARF_SET_ERROR(NULL, error, DW_DLE_LINE_FILE_NUM_BAD);		return (DW_DLV_ERROR);	}	if (lf->lf_fullpath) {		*ret_linesrc = (char *) lf->lf_fullpath;		return (DW_DLV_OK);	}	*ret_linesrc = lf->lf_fname;	return (DW_DLV_OK);}

intdwarf_get_str(Dwarf_Debug dbg, Dwarf_Off offset, char **string,    Dwarf_Signed *ret_strlen, Dwarf_Error *error){	Dwarf_Section *ds;	if (dbg == NULL || offset < 0 || string == NULL || ret_strlen == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	ds = _dwarf_find_section(dbg, ".debug_str");	if (ds == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);		return (DW_DLV_NO_ENTRY);	}	if ((Dwarf_Unsigned) offset > ds->ds_size) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if ((Dwarf_Unsigned) offset == ds->ds_size) {		DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);		return (DW_DLV_NO_ENTRY);	}	*string = (char *) ds->ds_data + offset;	*ret_strlen = strlen(*string);	return (DW_DLV_OK);}

intdwarf_attr_add(Dwarf_Abbrev a, uint64_t attr, uint64_t form, Dwarf_Attribute *atp, Dwarf_Error *error){	Dwarf_Attribute at;	int ret = DWARF_E_NONE;	if (error == NULL)		return DWARF_E_ERROR;	if (a == NULL) {		DWARF_SET_ERROR(error, DWARF_E_ARGUMENT);		return DWARF_E_ARGUMENT;	}	if ((at = malloc(sizeof(struct _Dwarf_Attribute))) == NULL) {		DWARF_SET_ERROR(error, DWARF_E_MEMORY);		return DWARF_E_MEMORY;	}	/* Initialise the attribute structure. */	at->at_attrib	= attr;	at->at_form	= form;	/* Add the attribute to the list in the abbrev. */	STAILQ_INSERT_TAIL(&a->a_attrib, at, at_next);	if (atp != NULL)		*atp = at;	return ret;}

intdwarf_get_abbrev_entry(Dwarf_Abbrev abbrev, Dwarf_Signed ndx,    Dwarf_Half *attr_num, Dwarf_Signed *form, Dwarf_Off *offset,    Dwarf_Error *error){	Dwarf_AttrDef ad;	int i;	if (abbrev == NULL || attr_num == NULL || form == NULL ||	    offset == NULL) {		DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (ndx < 0 || (uint64_t) ndx >= abbrev->ab_atnum) {		DWARF_SET_ERROR(NULL, error, DW_DLE_NO_ENTRY);		return (DW_DLV_NO_ENTRY);	}	ad = STAILQ_FIRST(&abbrev->ab_attrdef);	for (i = 0; i < ndx && ad != NULL; i++)		ad = STAILQ_NEXT(ad, ad_next);	assert(ad != NULL);	*attr_num = ad->ad_attrib;	*form = ad->ad_form;	*offset = ad->ad_offset;	return (DW_DLV_OK);}

intdwarf_get_pubtypes(Dwarf_Debug dbg, Dwarf_Type **pubtypes,    Dwarf_Signed *ret_count, Dwarf_Error *error){	Dwarf_Section *ds;	int ret;	if (dbg == NULL || pubtypes == NULL || ret_count == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (dbg->dbg_pubtypes == NULL) {		if ((ds = _dwarf_find_section(dbg, ".debug_pubtypes")) != NULL) {			ret = _dwarf_nametbl_init(dbg, &dbg->dbg_pubtypes, ds,			    error);			if (ret != DW_DLE_NONE)				return (DW_DLV_ERROR);		}		if (dbg->dbg_pubtypes == NULL) {			DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);			return (DW_DLV_NO_ENTRY);		}	}	*pubtypes = dbg->dbg_pubtypes->ns_array;	*ret_count = dbg->dbg_pubtypes->ns_len;	return (DW_DLV_OK);}

intdwarf_attr(Dwarf_Die die, Dwarf_Half attr, Dwarf_Attribute *atp, Dwarf_Error *err){	Dwarf_Attribute at;	Dwarf_Abbrev	a;	int ret = DWARF_E_NONE;	if (err == NULL)		return DWARF_E_ERROR;	if (die == NULL || atp == NULL || (a = die->die_a) == NULL) {		DWARF_SET_ERROR(err, DWARF_E_ARGUMENT);		return DWARF_E_ARGUMENT;	}	STAILQ_FOREACH(at, &a->a_attrib, at_next)		if (at->at_attrib == attr)			break;	*atp = at;	if (at == NULL) {		DWARF_SET_ERROR(err, DWARF_E_NO_ENTRY);		ret = DWARF_E_NO_ENTRY;	}	return ret;}

int_dwarf_loc_fill_locdesc(Dwarf_Debug dbg, Dwarf_Locdesc *llbuf, uint8_t *in,    uint64_t in_len, uint8_t pointer_size, uint8_t offset_size,    uint8_t version, Dwarf_Error *error){	int num;	assert(llbuf != NULL);	assert(in != NULL);	assert(in_len > 0);	/* Compute the number of locations. */	if ((num = _dwarf_loc_fill_loc(dbg, NULL, pointer_size, offset_size,	    version, in, in_len)) < 0) {		DWARF_SET_ERROR(dbg, error, DW_DLE_LOC_EXPR_BAD);		return (DW_DLE_LOC_EXPR_BAD);	}	llbuf->ld_cents = num;	if (num <= 0)		return (DW_DLE_NONE);	if ((llbuf->ld_s = calloc(num, sizeof(Dwarf_Loc))) == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);		return (DW_DLE_MEMORY);	}	(void) _dwarf_loc_fill_loc(dbg, llbuf, pointer_size, offset_size,	    version, in, in_len);	return (DW_DLE_NONE);}

intdwarf_get_abbrev(Dwarf_Debug dbg, Dwarf_Unsigned offset,    Dwarf_Abbrev *return_abbrev, Dwarf_Unsigned *length,    Dwarf_Unsigned *attr_count, Dwarf_Error *error){	Dwarf_Abbrev ab;	int ret;	if (dbg == NULL || return_abbrev == NULL || length == NULL ||	    attr_count == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	ret = _dwarf_abbrev_parse(dbg, NULL, &offset, &ab, error);	if (ret != DW_DLE_NONE) {		if (ret == DW_DLE_NO_ENTRY) {			DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);			return (DW_DLV_NO_ENTRY);		} else			return (DW_DLV_ERROR);	}	*return_abbrev = ab;	*length = ab->ab_length;	*attr_count = ab->ab_atnum;	return (DW_DLV_OK);}

Dwarf_P_Diedwarf_die_link(Dwarf_P_Die die, Dwarf_P_Die parent,    Dwarf_P_Die child, Dwarf_P_Die left_sibling, Dwarf_P_Die right_sibling,    Dwarf_Error *error){	Dwarf_Debug dbg;	int count;	if (die == NULL) {		DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT);		return (DW_DLV_BADADDR);	}	dbg = die->die_dbg;	count = _dwarf_die_count_links(parent, child, left_sibling,	    right_sibling);	if (count > 1) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_BADADDR);	} else if (count == 0)		return (die);	_dwarf_die_link(die, parent, child, left_sibling, right_sibling);	return (die);}

intdwarf_loclist_from_expr_b(Dwarf_Debug dbg, Dwarf_Ptr bytes_in,    Dwarf_Unsigned bytes_len, Dwarf_Half addr_size, Dwarf_Half offset_size,    Dwarf_Small version, Dwarf_Locdesc **llbuf, Dwarf_Signed *listlen,    Dwarf_Error *error){	Dwarf_Locdesc *ld;	int ret;	if (dbg == NULL || bytes_in == NULL || bytes_len == 0 ||	    llbuf == NULL || listlen == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (addr_size != 4 && addr_size != 8) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (offset_size != 4 && offset_size != 8) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	ret = _dwarf_loc_fill_locexpr(dbg, &ld, bytes_in, bytes_len, addr_size,	    offset_size, version, error);	if (ret != DW_DLE_NONE)		return (DW_DLV_ERROR);	*llbuf = ld;	*listlen = 1;	return (DW_DLV_OK);}

Dwarf_Unsigneddwarf_add_arange_b(Dwarf_P_Debug dbg, Dwarf_Addr start, Dwarf_Unsigned length,    Dwarf_Unsigned symbol_index, Dwarf_Unsigned end_symbol_index,    Dwarf_Addr offset_from_end_symbol, Dwarf_Error *error){	Dwarf_ArangeSet as;	Dwarf_Arange ar;	if (dbg == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (0);	}	as = dbg->dbgp_as;	if (end_symbol_index > 0 &&	    (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (0);	}	if ((ar = calloc(1, sizeof(struct _Dwarf_Arange))) == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);		return (0);	}	ar->ar_as = as;	ar->ar_address = start;	ar->ar_range = length;	ar->ar_symndx = symbol_index;	ar->ar_esymndx = end_symbol_index;	ar->ar_eoff = offset_from_end_symbol;	STAILQ_INSERT_TAIL(&as->as_arlist, ar, ar_next);	return (1);}

intdwarf_next_cu_header_b(Dwarf_Debug dbg, Dwarf_Unsigned *cu_length,    Dwarf_Half *cu_version, Dwarf_Off *cu_abbrev_offset,    Dwarf_Half *cu_pointer_size, Dwarf_Half *cu_offset_size,    Dwarf_Half *cu_extension_size, Dwarf_Unsigned *cu_next_offset,    Dwarf_Error *error){	Dwarf_CU cu;	int ret;	if (dbg == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (dbg->dbg_cu_current == NULL)		ret = _dwarf_info_first_cu(dbg, error);	else		ret = _dwarf_info_next_cu(dbg, error);	if (ret == DW_DLE_NO_ENTRY) {		DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);		return (DW_DLV_NO_ENTRY);	} else if (ret != DW_DLE_NONE)		return (DW_DLV_ERROR);	if (dbg->dbg_cu_current == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);		return (DW_DLV_NO_ENTRY);	}	cu = dbg->dbg_cu_current;	if (cu_length)		*cu_length = cu->cu_length;	if (cu_version)		*cu_version = cu->cu_version;	if (cu_abbrev_offset)		*cu_abbrev_offset = (Dwarf_Off) cu->cu_abbrev_offset;	if (cu_pointer_size)		*cu_pointer_size = cu->cu_pointer_size;	if (cu_offset_size) {		if (cu->cu_length_size == 4)			*cu_offset_size = 4;		else			*cu_offset_size = 8;	}	if (cu_extension_size) {		if (cu->cu_length_size == 4)			*cu_extension_size = 0;		else			*cu_extension_size = 4;	}	if (cu_next_offset)		*cu_next_offset	= dbg->dbg_cu_current->cu_next_offset;	return (DW_DLV_OK);}

intdwarf_get_loclist_entry(Dwarf_Debug dbg, Dwarf_Unsigned offset,    Dwarf_Addr *hipc, Dwarf_Addr *lopc, Dwarf_Ptr *data,    Dwarf_Unsigned *entry_len, Dwarf_Unsigned *next_entry,    Dwarf_Error *error){	Dwarf_Loclist ll, next_ll;	Dwarf_Locdesc *ld;	Dwarf_Section *ds;	int i, ret;	if (dbg == NULL || hipc == NULL || lopc == NULL || data == NULL ||	    entry_len == NULL || next_entry == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	ret = _dwarf_loclist_find(dbg, STAILQ_FIRST(&dbg->dbg_cu), offset, &ll,	    error);	if (ret == DW_DLE_NO_ENTRY) {		DWARF_SET_ERROR(dbg, error, DW_DLV_NO_ENTRY);		return (DW_DLV_NO_ENTRY);	} else if (ret != DW_DLE_NONE)		return (DW_DLV_ERROR);	*hipc = *lopc = 0;	for (i = 0; i < ll->ll_ldlen; i++) {		ld = ll->ll_ldlist[i];		if (i == 0) {			*hipc = ld->ld_hipc;			*lopc = ld->ld_lopc;		} else {			if (ld->ld_lopc < *lopc)				*lopc = ld->ld_lopc;			if (ld->ld_hipc > *hipc)				*hipc = ld->ld_hipc;		}	}	ds = _dwarf_find_section(dbg, ".debug_loc");	assert(ds != NULL);	*data = (uint8_t *) ds->ds_data + ll->ll_offset;	*entry_len = ll->ll_length;	next_ll = TAILQ_NEXT(ll, ll_next);	if (next_ll != NULL)		*next_entry = next_ll->ll_offset;	else		*next_entry = ds->ds_size;	return (DW_DLV_OK);}

intdwarf_get_loclist_entry(Dwarf_Debug dbg, Dwarf_Unsigned offset,    Dwarf_Addr *hipc, Dwarf_Addr *lopc, Dwarf_Ptr *data,    Dwarf_Unsigned *entry_len, Dwarf_Unsigned *next_entry,    Dwarf_Error *error){	Dwarf_Locdesc *ld, **llbuf;	Dwarf_Section *ds;	Dwarf_Signed listlen;	int i, ret;	/*	 * Note that this API sometimes will not work correctly because	 * it assumes that all units have the same pointer size and offset	 * size.	 */	if (dbg == NULL || hipc == NULL || lopc == NULL || data == NULL ||	    entry_len == NULL || next_entry == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	ret = _dwarf_loclist_find(dbg, STAILQ_FIRST(&dbg->dbg_cu), offset,	    &llbuf, &listlen, entry_len, error);	if (ret == DW_DLE_NO_ENTRY) {		DWARF_SET_ERROR(dbg, error, DW_DLV_NO_ENTRY);		return (DW_DLV_NO_ENTRY);	} else if (ret != DW_DLE_NONE)		return (DW_DLV_ERROR);	*hipc = *lopc = 0;	for (i = 0; i < listlen; i++) {		ld = llbuf[i];		if (i == 0) {			*hipc = ld->ld_hipc;			*lopc = ld->ld_lopc;		} else {			if (ld->ld_lopc < *lopc)				*lopc = ld->ld_lopc;			if (ld->ld_hipc > *hipc)				*hipc = ld->ld_hipc;		}	}	ds = _dwarf_find_section(dbg, ".debug_loc");	assert(ds != NULL);	*data = (uint8_t *) ds->ds_data + offset;	*next_entry = offset + *entry_len;	return (DW_DLV_OK);}

intdwarf_get_fde_info_for_reg(Dwarf_Fde fde, Dwarf_Half table_column,    Dwarf_Addr pc_requested, Dwarf_Signed *offset_relevant,    Dwarf_Signed *register_num, Dwarf_Signed *offset, Dwarf_Addr *row_pc,    Dwarf_Error *error){	Dwarf_Regtable3 *rt;	Dwarf_Debug dbg;	Dwarf_Addr pc;	int ret;	dbg = fde != NULL ? fde->fde_dbg : NULL;	if (fde == NULL || offset_relevant == NULL || register_num == NULL ||	    offset == NULL || row_pc == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (pc_requested < fde->fde_initloc ||	    pc_requested >= fde->fde_initloc + fde->fde_adrange) {		DWARF_SET_ERROR(dbg, error, DW_DLE_PC_NOT_IN_FDE_RANGE);		return (DW_DLV_ERROR);	}	ret = _dwarf_frame_get_internal_table(fde, pc_requested, &rt, &pc,	    error);	if (ret != DW_DLE_NONE)		return (DW_DLV_ERROR);	if (table_column == dbg->dbg_frame_cfa_value) {		/* Application ask for CFA. */		*offset_relevant = CFA.dw_offset_relevant;		*register_num = CFA.dw_regnum;		*offset = CFA.dw_offset_or_block_len;	} else {		/* Application ask for normal registers. */		if (table_column >= dbg->dbg_frame_rule_table_size ||		    table_column >= DW_REG_TABLE_SIZE) {			DWARF_SET_ERROR(dbg, error, DW_DLE_FRAME_TABLE_COL_BAD);			return (DW_DLV_ERROR);		}		*offset_relevant = RL.dw_offset_relevant;		*register_num = RL.dw_regnum;		*offset = RL.dw_offset_or_block_len;	}	*row_pc = pc;	return (DW_DLV_OK);}

intdwarf_init(int fd, int mode, Dwarf_Handler errhand, Dwarf_Ptr errarg,    Dwarf_Debug *ret_dbg, Dwarf_Error *error){	Dwarf_Debug dbg;	Elf *elf;	int ret;	if (fd < 0 || ret_dbg == NULL) {		DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (mode != DW_DLC_READ) {		DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (elf_version(EV_CURRENT) == EV_NONE) {		DWARF_SET_ELF_ERROR(NULL, error);		return (DW_DLV_ERROR);	}	if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {		DWARF_SET_ELF_ERROR(NULL, error);		return (DW_DLV_ERROR);	}	if (_dwarf_alloc(&dbg, mode, error) != DW_DLE_NONE)		return (DW_DLV_ERROR);	if (_dwarf_elf_init(dbg, elf, error) != DW_DLE_NONE) {		free(dbg);		return (DW_DLV_ERROR);	}	if ((ret = _dwarf_init(dbg, 0, errhand, errarg, error)) !=	    DW_DLE_NONE) {		_dwarf_elf_deinit(dbg);		free(dbg);		if (ret == DW_DLE_DEBUG_INFO_NULL)			return (DW_DLV_NO_ENTRY);		else			return (DW_DLV_ERROR);	}	*ret_dbg = dbg;	return (DW_DLV_OK);}

Dwarf_Unsigneddwarf_add_frame_fde_b(Dwarf_P_Debug dbg, Dwarf_P_Fde fde, Dwarf_P_Die die,    Dwarf_Unsigned cie, Dwarf_Addr virt_addr, Dwarf_Unsigned code_len,    Dwarf_Unsigned symbol_index, Dwarf_Unsigned end_symbol_index,    Dwarf_Addr offset_from_end_sym, Dwarf_Error *error){	Dwarf_P_Cie ciep;	int i;	/*	 * XXX SGI libdwarf need the DIE arg because later it will insert a	 * DW_AT_MIPS_fde attribute, which points to the offset the	 * correspoding FDE, into this DIE. Do we need this?	 */	(void) die;	if (dbg == NULL || fde == NULL || fde->fde_dbg != dbg) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_NOCOUNT);	}	ciep = STAILQ_FIRST(&dbg->dbgp_cielist);	for (i = 0; (Dwarf_Unsigned) i < cie; i++) {		ciep = STAILQ_NEXT(ciep, cie_next);		if (ciep == NULL)			break;	}	if (ciep == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_NOCOUNT);	}	if (end_symbol_index > 0 &&	    (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_NOCOUNT);	}	fde->fde_cie = ciep;	fde->fde_initloc = virt_addr;	fde->fde_adrange = code_len;	fde->fde_symndx = symbol_index;	fde->fde_esymndx = end_symbol_index;	fde->fde_eoff = offset_from_end_sym;	STAILQ_INSERT_TAIL(&dbg->dbgp_fdelist, fde, fde_next);	return (dbg->dbgp_fdelen++);}

int_dwarf_loc_fill_locexpr(Dwarf_Debug dbg, Dwarf_Locdesc **ret_llbuf, uint8_t *in,    uint64_t in_len, uint8_t pointer_size, Dwarf_Error *error){	Dwarf_Locdesc *llbuf;	int ret;	if ((llbuf = malloc(sizeof(Dwarf_Locdesc))) == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);		return (DW_DLE_MEMORY);	}	llbuf->ld_lopc = 0;	llbuf->ld_hipc = ~0ULL;	llbuf->ld_s = NULL;	ret = _dwarf_loc_fill_locdesc(dbg, llbuf, in, in_len, pointer_size,	    error);	if (ret != DW_DLE_NONE) {		free(llbuf);		return (ret);	}	*ret_llbuf = llbuf;	return (ret);}

intdwarf_var_name_offsets(Dwarf_Var var, char **ret_name, Dwarf_Off *die_offset,    Dwarf_Off *cu_offset, Dwarf_Error *error){	Dwarf_CU cu;	Dwarf_Debug dbg;	Dwarf_NameTbl nt;	dbg = var != NULL ? var->np_nt->nt_cu->cu_dbg : NULL;	if (var == NULL || ret_name == NULL || die_offset == NULL ||	    cu_offset == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	nt = var->np_nt;	assert(nt != NULL);	cu = nt->nt_cu;	assert(cu != NULL);	*ret_name = var->np_name;	*die_offset = nt->nt_cu_offset + var->np_offset;	*cu_offset = cu->cu_1st_offset;	return (DW_DLV_OK);}

intdwarf_object_init(Dwarf_Obj_Access_Interface *iface, Dwarf_Handler errhand,    Dwarf_Ptr errarg, Dwarf_Debug *ret_dbg, Dwarf_Error *error){	Dwarf_Debug dbg;	if (iface == NULL || ret_dbg == NULL) {		DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (_dwarf_alloc(&dbg, DW_DLC_READ, error) != DW_DLE_NONE)		return (DW_DLV_ERROR);	dbg->dbg_iface = iface;	if (_dwarf_init(dbg, 0, errhand, errarg, error) != DW_DLE_NONE) {		free(dbg);		return (DW_DLV_ERROR);	}	*ret_dbg = dbg;	return (DW_DLV_OK);}

intdwarf_get_cie_info(Dwarf_Cie cie, Dwarf_Unsigned *bytes_in_cie,    Dwarf_Small *version, char **augmenter, Dwarf_Unsigned *caf,    Dwarf_Unsigned *daf, Dwarf_Half *ra, Dwarf_Ptr *initinst,    Dwarf_Unsigned *inst_len, Dwarf_Error *error){	if (cie == NULL || bytes_in_cie == NULL || version == NULL ||	    augmenter == NULL || caf == NULL || daf == NULL || ra == NULL ||	    initinst == NULL || inst_len == NULL) {		DWARF_SET_ERROR(NULL, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	*bytes_in_cie = cie->cie_length;	*version = cie->cie_version;	*augmenter = (char *) cie->cie_augment;	*caf = cie->cie_caf;	*daf = cie->cie_daf;	*ra = cie->cie_ra;	*initinst = cie->cie_initinst;	*inst_len = cie->cie_instlen;	return (DW_DLV_OK);}

intdwarf_get_fde_range(Dwarf_Fde fde, Dwarf_Addr *low_pc, Dwarf_Unsigned *func_len,    Dwarf_Ptr *fde_bytes, Dwarf_Unsigned *fde_byte_len, Dwarf_Off *cie_offset,    Dwarf_Signed *cie_index, Dwarf_Off *fde_offset, Dwarf_Error *error){	Dwarf_Debug dbg;	dbg = fde != NULL ? fde->fde_dbg : NULL;	if (fde == NULL || low_pc == NULL || func_len == NULL ||	    fde_bytes == NULL || fde_byte_len == NULL || cie_offset == NULL ||	    cie_index == NULL || fde_offset == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	*low_pc = fde->fde_initloc;	*func_len = fde->fde_adrange;	*fde_bytes = fde->fde_addr;	*fde_byte_len = fde->fde_length;	*cie_offset = fde->fde_cieoff;	*cie_index = fde->fde_cie->cie_index;	*fde_offset = fde->fde_offset;	return (DW_DLV_OK);}

int_dwarf_strtab_gen(Dwarf_P_Debug dbg, Dwarf_Error *error){	Dwarf_P_Section ds;	int ret;	assert(dbg != NULL);	if ((ret = _dwarf_section_init(dbg, &ds, ".debug_str", 0, error)) !=	    DW_DLE_NONE)		return (ret);	if (dbg->dbg_strtab_size > ds->ds_cap) {		ds->ds_data = realloc(ds->ds_data,		    (size_t) dbg->dbg_strtab_size);		if (ds->ds_data == NULL) {			_dwarf_section_free(dbg, &ds);			DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);			return (DW_DLE_MEMORY);		}		ds->ds_cap = dbg->dbg_strtab_size;	}	memcpy(ds->ds_data, dbg->dbg_strtab, dbg->dbg_strtab_size);	ds->ds_size = dbg->dbg_strtab_size;	/*	 * Inform application the creation of .debug_str ELF section.	 * Note that .debug_str use a different format than usual ELF	 * string table, so it should not have SHT_STRTAB as its type.	 */	ret = _dwarf_section_callback(dbg, ds, SHT_PROGBITS, 0, 0, 0, error);	return (ret);}

int_dwarf_strtab_add(Dwarf_Debug dbg, char *string, uint64_t *off,    Dwarf_Error *error){	size_t len;	assert(dbg != NULL && string != NULL);	len = strlen(string) + 1;	while (dbg->dbg_strtab_size + len > dbg->dbg_strtab_cap) {		dbg->dbg_strtab_cap *= 2;		dbg->dbg_strtab = realloc(dbg->dbg_strtab,		    (size_t) dbg->dbg_strtab_cap);		if (dbg->dbg_strtab == NULL) {			DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);			return (DW_DLE_MEMORY);		}	}	if (off != NULL)		*off = dbg->dbg_strtab_size;	strncpy(&dbg->dbg_strtab[dbg->dbg_strtab_size], string, len - 1);	dbg->dbg_strtab_size += len;	dbg->dbg_strtab[dbg->dbg_strtab_size - 1] = '/0';	return (DW_DLE_NONE);}

intdwarf_pubtype_name_offsets(Dwarf_Type pubtype, char **ret_name, Dwarf_Off *die_offset,    Dwarf_Off *cu_offset, Dwarf_Error *error){	Dwarf_CU cu;	Dwarf_Debug dbg;	Dwarf_NameTbl nt;	dbg = pubtype != NULL ? pubtype->np_nt->nt_cu->cu_dbg : NULL;	if (pubtype == NULL || ret_name == NULL || die_offset == NULL ||	    cu_offset == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	nt = pubtype->np_nt;	assert(nt != NULL);	cu = nt->nt_cu;	assert(cu != NULL);	*ret_name = pubtype->np_name;	*die_offset = nt->nt_cu_offset + pubtype->np_offset;	*cu_offset = cu->cu_1st_offset;	return (DW_DLV_OK);}

intdwarf_get_fde_info_for_reg3(Dwarf_Fde fde, Dwarf_Half table_column,    Dwarf_Addr pc_requested, Dwarf_Small *value_type,    Dwarf_Signed *offset_relevant, Dwarf_Signed *register_num,    Dwarf_Signed *offset_or_block_len, Dwarf_Ptr *block_ptr,    Dwarf_Addr *row_pc, Dwarf_Error *error){	Dwarf_Regtable3 *rt;	Dwarf_Debug dbg;	Dwarf_Addr pc;	int ret;	dbg = fde != NULL ? fde->fde_dbg : NULL;	if (fde == NULL || value_type == NULL || offset_relevant == NULL ||	    register_num == NULL || offset_or_block_len == NULL ||	    block_ptr == NULL || row_pc == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_ERROR);	}	if (pc_requested < fde->fde_initloc ||	    pc_requested >= fde->fde_initloc + fde->fde_adrange) {		DWARF_SET_ERROR(dbg, error, DW_DLE_PC_NOT_IN_FDE_RANGE);		return (DW_DLV_ERROR);	}	ret = _dwarf_frame_get_internal_table(fde, pc_requested, &rt, &pc,	    error);	if (ret != DW_DLE_NONE)		return (DW_DLV_ERROR);	if (table_column >= dbg->dbg_frame_rule_table_size) {		DWARF_SET_ERROR(dbg, error, DW_DLE_FRAME_TABLE_COL_BAD);		return (DW_DLV_ERROR);	}	*value_type = RL.dw_value_type;	*offset_relevant = RL.dw_offset_relevant;	*register_num = RL.dw_regnum;	*offset_or_block_len = RL.dw_offset_or_block_len;	*block_ptr = RL.dw_block_ptr;	*row_pc = pc;	return (DW_DLV_OK);}

intdwarf_die_add(Dwarf_CU cu, int level, uint64_t offset, uint64_t abnum, Dwarf_Abbrev a, Dwarf_Die *diep, Dwarf_Error *err){	Dwarf_Die die;	uint64_t key;	int ret = DWARF_E_NONE;	if (err == NULL)		return DWARF_E_ERROR;	if (cu == NULL || a == NULL) {		DWARF_SET_ERROR(err, DWARF_E_ARGUMENT);		return DWARF_E_ARGUMENT;	}	if ((die = malloc(sizeof(struct _Dwarf_Die))) == NULL) {		DWARF_SET_ERROR(err, DWARF_E_MEMORY);		return DWARF_E_MEMORY;	}	/* Initialise the abbrev structure. */	die->die_level	= level;	die->die_offset	= offset;	die->die_abnum	= abnum;	die->die_a	= a;	die->die_cu	= cu;	die->die_name	= anon_name;	/* Initialise the list of attribute values. */	STAILQ_INIT(&die->die_attrval);	/* Add the die to the list in the compilation unit. */	STAILQ_INSERT_TAIL(&cu->cu_die, die, die_next);	/* Add the die to the hash table in the compilation unit. */	key = offset % DWARF_DIE_HASH_SIZE;	STAILQ_INSERT_TAIL(&cu->cu_die_hash[key], die, die_hash);	if (diep != NULL)		*diep = die;	return ret;}

Dwarf_Unsigneddwarf_add_frame_cie(Dwarf_P_Debug dbg, char *augmenter, Dwarf_Small caf,    Dwarf_Small daf, Dwarf_Small ra, Dwarf_Ptr initinst,    Dwarf_Unsigned inst_len, Dwarf_Error *error){	Dwarf_P_Cie cie;	if (dbg == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_NOCOUNT);	}	if ((cie = calloc(1, sizeof(struct _Dwarf_Cie))) == NULL) {		DWARF_SET_ERROR(dbg, error,DW_DLE_MEMORY);		return (DW_DLV_NOCOUNT);	}	STAILQ_INSERT_TAIL(&dbg->dbgp_cielist, cie, cie_next);	cie->cie_index = dbg->dbgp_cielen++;	if (augmenter != NULL) {		cie->cie_augment = (uint8_t *) strdup(augmenter);		if (cie->cie_augment == NULL) {			DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);			return (DW_DLV_NOCOUNT);		}	}	cie->cie_caf = caf;	cie->cie_daf = (int8_t) daf; /* daf is signed. */	cie->cie_ra = ra;	if (initinst != NULL && inst_len > 0) {		cie->cie_initinst = malloc((size_t) inst_len);		if (cie->cie_initinst == NULL) {			DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);			return (DW_DLV_NOCOUNT);		}		memcpy(cie->cie_initinst, initinst, inst_len);		cie->cie_instlen = inst_len;	}	return (cie->cie_index);}

Dwarf_P_Fdedwarf_new_fde(Dwarf_P_Debug dbg, Dwarf_Error *error){	Dwarf_P_Fde fde;	if (dbg == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);		return (DW_DLV_BADADDR);	}	if ((fde = calloc(1, sizeof(struct _Dwarf_Fde))) == NULL) {		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);		return (DW_DLV_BADADDR);	}	fde->fde_dbg = dbg;	return (fde);}

int_dwarf_strtab_init(Dwarf_Debug dbg, Dwarf_Error *error){	Dwarf_Section *ds;	assert(dbg != NULL);	if (dbg->dbg_mode == DW_DLC_READ || dbg->dbg_mode == DW_DLC_RDWR) {		ds = _dwarf_find_section(dbg, ".debug_str");		if (ds == NULL) {			dbg->dbg_strtab = NULL;			dbg->dbg_strtab_cap = dbg->dbg_strtab_size = 0;			return (DW_DLE_NONE);		}		dbg->dbg_strtab_cap = dbg->dbg_strtab_size = ds->ds_size;		if (dbg->dbg_mode == DW_DLC_RDWR) {			if ((dbg->dbg_strtab = malloc((size_t) ds->ds_size)) ==			    NULL) {				DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);				return (DW_DLE_MEMORY);			}			memcpy(dbg->dbg_strtab, ds->ds_data, ds->ds_size);		} else			dbg->dbg_strtab = (char *) ds->ds_data;	} else {		/* DW_DLC_WRITE */		dbg->dbg_strtab_cap = _INIT_DWARF_STRTAB_SIZE;		dbg->dbg_strtab_size = 0;		if ((dbg->dbg_strtab = malloc((size_t) dbg->dbg_strtab_cap)) ==		    NULL) {			DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);			return (DW_DLE_MEMORY);		}		dbg->dbg_strtab[0] = '/0';	}	return (DW_DLE_NONE);}