freebsd-skq/contrib/elftoolchain/libdwarf/libdwarf_info.c
emaste 89ea455074 Update elftoolchain to upstream rev 3136
This fixes two strip(1) issues found during ports exp-run and adds a
string hash implementation which significantly speeds up certain
operations on objects with large numbers of symbols.

This also improves libdwarf handling for stripped objects with
.eh_frame or .debug_frame (but not other debug) sections.

PR:		196107
Sponsored by:	The FreeBSD Foundation
2014-12-30 03:25:42 +00:00

384 lines
9.2 KiB
C

/*-
* Copyright (c) 2007 John Birrell (jb@freebsd.org)
* Copyright (c) 2010,2011,2014 Kai Wang
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "_libdwarf.h"
ELFTC_VCSID("$Id: libdwarf_info.c 3136 2014-12-24 16:04:38Z kaiwang27 $");
int
_dwarf_info_first_cu(Dwarf_Debug dbg, Dwarf_Error *error)
{
Dwarf_CU cu;
int ret;
assert(dbg->dbg_cu_current == NULL);
cu = STAILQ_FIRST(&dbg->dbg_cu);
if (cu != NULL) {
dbg->dbg_cu_current = cu;
return (DW_DLE_NONE);
}
if (dbg->dbg_info_loaded)
return (DW_DLE_NO_ENTRY);
dbg->dbg_info_off = 0;
ret = _dwarf_info_load(dbg, 0, 1, error);
if (ret != DW_DLE_NONE)
return (ret);
dbg->dbg_cu_current = STAILQ_FIRST(&dbg->dbg_cu);
return (DW_DLE_NONE);
}
int
_dwarf_info_first_tu(Dwarf_Debug dbg, Dwarf_Error *error)
{
Dwarf_CU tu;
int ret;
assert(dbg->dbg_tu_current == NULL);
tu = STAILQ_FIRST(&dbg->dbg_tu);
if (tu != NULL) {
dbg->dbg_tu_current = tu;
return (DW_DLE_NONE);
}
if (dbg->dbg_types_loaded)
return (DW_DLE_NO_ENTRY);
dbg->dbg_types_off = 0;
ret = _dwarf_info_load(dbg, 0, 0, error);
if (ret != DW_DLE_NONE)
return (ret);
dbg->dbg_tu_current = STAILQ_FIRST(&dbg->dbg_tu);
return (DW_DLE_NONE);
}
int
_dwarf_info_next_cu(Dwarf_Debug dbg, Dwarf_Error *error)
{
Dwarf_CU cu;
int ret;
assert(dbg->dbg_cu_current != NULL);
cu = STAILQ_NEXT(dbg->dbg_cu_current, cu_next);
if (cu != NULL) {
dbg->dbg_cu_current = cu;
return (DW_DLE_NONE);
}
if (dbg->dbg_info_loaded) {
dbg->dbg_cu_current = NULL;
return (DW_DLE_NO_ENTRY);
}
ret = _dwarf_info_load(dbg, 0, 1, error);
if (ret != DW_DLE_NONE)
return (ret);
dbg->dbg_cu_current = STAILQ_NEXT(dbg->dbg_cu_current, cu_next);
return (DW_DLE_NONE);
}
int
_dwarf_info_next_tu(Dwarf_Debug dbg, Dwarf_Error *error)
{
Dwarf_CU cu;
int ret;
assert(dbg->dbg_tu_current != NULL);
cu = STAILQ_NEXT(dbg->dbg_tu_current, cu_next);
if (cu != NULL) {
dbg->dbg_tu_current = cu;
return (DW_DLE_NONE);
}
if (dbg->dbg_types_loaded) {
dbg->dbg_tu_current = NULL;
return (DW_DLE_NO_ENTRY);
}
ret = _dwarf_info_load(dbg, 0, 0, error);
if (ret != DW_DLE_NONE)
return (ret);
dbg->dbg_tu_current = STAILQ_NEXT(dbg->dbg_tu_current, cu_next);
return (DW_DLE_NONE);
}
int
_dwarf_info_load(Dwarf_Debug dbg, Dwarf_Bool load_all, Dwarf_Bool is_info,
Dwarf_Error *error)
{
Dwarf_CU cu;
Dwarf_Section *ds;
int dwarf_size, ret;
uint64_t length;
uint64_t next_offset;
uint64_t offset;
ret = DW_DLE_NONE;
if (is_info) {
if (dbg->dbg_info_loaded)
return (ret);
offset = dbg->dbg_info_off;
ds = dbg->dbg_info_sec;
if (ds == NULL)
return (DW_DLE_NO_ENTRY);
} else {
if (dbg->dbg_types_loaded)
return (ret);
offset = dbg->dbg_types_off;
ds = dbg->dbg_types_sec;
if (ds == NULL)
return (DW_DLE_NO_ENTRY);
}
while (offset < ds->ds_size) {
if ((cu = calloc(1, sizeof(struct _Dwarf_CU))) == NULL) {
DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
return (DW_DLE_MEMORY);
}
cu->cu_dbg = dbg;
cu->cu_is_info = is_info;
cu->cu_offset = offset;
length = dbg->read(ds->ds_data, &offset, 4);
if (length == 0xffffffff) {
length = dbg->read(ds->ds_data, &offset, 8);
dwarf_size = 8;
} else
dwarf_size = 4;
cu->cu_dwarf_size = dwarf_size;
/*
* Check if there is enough ELF data for this CU. This assumes
* that libelf gives us the entire section in one Elf_Data
* object.
*/
if (length > ds->ds_size - offset) {
free(cu);
DWARF_SET_ERROR(dbg, error, DW_DLE_CU_LENGTH_ERROR);
return (DW_DLE_CU_LENGTH_ERROR);
}
/* Compute the offset to the next compilation unit: */
next_offset = offset + length;
if (is_info)
dbg->dbg_info_off = next_offset;
else
dbg->dbg_types_off = next_offset;
/* Initialise the compilation unit. */
cu->cu_length = length;
cu->cu_length_size = (dwarf_size == 4 ? 4 : 12);
cu->cu_version = dbg->read(ds->ds_data, &offset, 2);
cu->cu_abbrev_offset = dbg->read(ds->ds_data, &offset,
dwarf_size);
cu->cu_abbrev_offset_cur = cu->cu_abbrev_offset;
cu->cu_pointer_size = dbg->read(ds->ds_data, &offset, 1);
cu->cu_next_offset = next_offset;
/* .debug_types extra fields. */
if (!is_info) {
memcpy(cu->cu_type_sig.signature,
(char *) ds->ds_data + offset, 8);
offset += 8;
cu->cu_type_offset = dbg->read(ds->ds_data, &offset,
dwarf_size);
}
/* Add the compilation unit to the list. */
if (is_info)
STAILQ_INSERT_TAIL(&dbg->dbg_cu, cu, cu_next);
else
STAILQ_INSERT_TAIL(&dbg->dbg_tu, cu, cu_next);
if (cu->cu_version < 2 || cu->cu_version > 4) {
DWARF_SET_ERROR(dbg, error, DW_DLE_VERSION_STAMP_ERROR);
ret = DW_DLE_VERSION_STAMP_ERROR;
break;
}
cu->cu_1st_offset = offset;
offset = next_offset;
if (!load_all)
break;
}
if (is_info) {
if ((Dwarf_Unsigned) dbg->dbg_info_off >= ds->ds_size)
dbg->dbg_info_loaded = 1;
} else {
if ((Dwarf_Unsigned) dbg->dbg_types_off >= ds->ds_size)
dbg->dbg_types_loaded = 1;
}
return (ret);
}
void
_dwarf_info_cleanup(Dwarf_Debug dbg)
{
Dwarf_CU cu, tcu;
assert(dbg != NULL && dbg->dbg_mode == DW_DLC_READ);
STAILQ_FOREACH_SAFE(cu, &dbg->dbg_cu, cu_next, tcu) {
STAILQ_REMOVE(&dbg->dbg_cu, cu, _Dwarf_CU, cu_next);
_dwarf_abbrev_cleanup(cu);
if (cu->cu_lineinfo != NULL) {
_dwarf_lineno_cleanup(cu->cu_lineinfo);
cu->cu_lineinfo = NULL;
}
free(cu);
}
_dwarf_type_unit_cleanup(dbg);
}
void
_dwarf_type_unit_cleanup(Dwarf_Debug dbg)
{
Dwarf_CU cu, tcu;
assert(dbg != NULL && dbg->dbg_mode == DW_DLC_READ);
STAILQ_FOREACH_SAFE(cu, &dbg->dbg_tu, cu_next, tcu) {
STAILQ_REMOVE(&dbg->dbg_tu, cu, _Dwarf_CU, cu_next);
_dwarf_abbrev_cleanup(cu);
free(cu);
}
}
int
_dwarf_info_gen(Dwarf_P_Debug dbg, Dwarf_Error *error)
{
Dwarf_P_Section ds;
Dwarf_Rel_Section drs;
Dwarf_Unsigned offset;
Dwarf_CU cu;
int ret;
assert(dbg != NULL && dbg->write_alloc != NULL);
if (dbg->dbgp_root_die == NULL)
return (DW_DLE_NONE);
/* Create the single CU for this debugging object. */
if ((cu = calloc(1, sizeof(struct _Dwarf_CU))) == NULL) {
DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
return (DW_DLE_MEMORY);
}
cu->cu_dbg = dbg;
cu->cu_version = 2; /* DWARF2 */
cu->cu_pointer_size = dbg->dbg_pointer_size;
STAILQ_INSERT_TAIL(&dbg->dbg_cu, cu, cu_next);
/* Create .debug_info section. */
if ((ret = _dwarf_section_init(dbg, &dbg->dbgp_info, ".debug_info", 0,
error)) != DW_DLE_NONE)
goto gen_fail1;
ds = dbg->dbgp_info;
/* Create relocation section for .debug_init */
if ((ret = _dwarf_reloc_section_init(dbg, &drs, ds, error)) !=
DW_DLE_NONE)
goto gen_fail0;
/* Length placeholder. (We only use 32-bit DWARF format) */
RCHECK(WRITE_VALUE(cu->cu_length, 4));
/* Write CU version */
RCHECK(WRITE_VALUE(cu->cu_version, 2));
/*
* Write abbrev offset. (always 0, we only support single CU)
* Also generate a relocation entry for this offset.
*/
RCHECK(_dwarf_reloc_entry_add(dbg, drs, ds, dwarf_drt_data_reloc, 4,
ds->ds_size, 0, cu->cu_abbrev_offset, ".debug_abbrev", error));
/* Pointer size. */
RCHECK(WRITE_VALUE(cu->cu_pointer_size, 1));
/* Transform the DIE(s) of this CU. */
RCHECK(_dwarf_die_gen(dbg, cu, drs, error));
/* Now we can fill in the length of this CU. */
cu->cu_length = ds->ds_size - 4;
offset = 0;
dbg->write(ds->ds_data, &offset, cu->cu_length, 4);
/* Inform application the creation of .debug_info ELF section. */
RCHECK(_dwarf_section_callback(dbg, ds, SHT_PROGBITS, 0, 0, 0, error));
/*
* Inform application the creation of relocation section for
* .debug_info.
*/
RCHECK(_dwarf_reloc_section_finalize(dbg, drs, error));
return (DW_DLE_NONE);
gen_fail:
_dwarf_reloc_section_free(dbg, &drs);
gen_fail0:
_dwarf_section_free(dbg, &dbg->dbgp_info);
gen_fail1:
STAILQ_REMOVE(&dbg->dbg_cu, cu, _Dwarf_CU, cu_next);
free(cu);
return (ret);
}
void
_dwarf_info_pro_cleanup(Dwarf_P_Debug dbg)
{
Dwarf_CU cu;
assert(dbg != NULL && dbg->dbg_mode == DW_DLC_WRITE);
cu = STAILQ_FIRST(&dbg->dbg_cu);
if (cu != NULL) {
STAILQ_REMOVE(&dbg->dbg_cu, cu, _Dwarf_CU, cu_next);
_dwarf_abbrev_cleanup(cu);
free(cu);
}
}