/* Copyright (C) 2007-2010 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
*/
/*
* Contains implementations of classes defined for a variety of DWARF objects.
*/
#include <stdio.h>
#define __STDC_FORMAT_MACROS 1
#include <inttypes.h>
#include "dwarf_die.h"
#include "dwarf_cu.h"
#include "dwarf_utils.h"
#include "elf_file.h"
DIEObject::~DIEObject() {
/* Delete all children of this object. */
DIEObject* to_del = last_child();
while (to_del != NULL) {
DIEObject* next = to_del->prev_sibling();
delete to_del;
to_del = next;
}
}
ElfFile* DIEObject::elf_file() const {
return parent_cu()->elf_file();
}
Dwarf_Tag DIEObject::get_tag() const {
Dwarf_Tag tag;
return advance(NULL, &tag) != NULL ? tag : 0;
}
const char* DIEObject::get_name() const {
DIEAttrib die_attr;
/* Start with the obvious. */
if (get_attrib(DW_AT_name, &die_attr)) {
return die_attr.value()->str;
}
/* Lets see if there is a reference to the abstract origin, or specification,
* and use its name as the name for this DIE. */
if (get_attrib(DW_AT_abstract_origin, &die_attr) ||
get_attrib(DW_AT_specification, &die_attr)) {
DIEObject* org_die_obj =
parent_cu()->get_referenced_die_object(die_attr.value()->u32);
if (org_die_obj != NULL) {
return org_die_obj->get_name();
}
}
/* Lets see if there is a reference to the type DIE, and use
* its name as the name for this DIE. */
if (get_attrib(DW_AT_type, &die_attr)) {
DIEObject* org_die_obj =
parent_cu()->get_referenced_die_object(die_attr.value()->u32);
if (org_die_obj != NULL) {
return org_die_obj->get_name();
}
}
/* Can't figure the name for this DIE. */
return NULL;
}
bool DIEObject::get_attrib(Dwarf_At at_id, DIEAttrib* attr) const {
const Dwarf_Abbr_AT* at_abbr;
/* Advance to DIE attributes. */
const Elf_Byte* die_attr = advance(&at_abbr, NULL);
if (die_attr == NULL) {
_set_errno(EINVAL);
return false;
}
/* Loop through all DIE attributes, looking for the one that's being
* requested. */
while (!at_abbr->is_separator()) {
at_abbr = at_abbr->process(&attr->at_, &attr->form_);
die_attr = parent_cu()->process_attrib(die_attr, attr->form_, &attr->value_);
if (at_id == attr->at()) {
return true;
}
}
_set_errno(EINVAL);
return false;
}
DIEObject* DIEObject::get_leaf_for_address(Elf_Xword address) {
const bool contains = parent_cu()->is_CU_address_64() ?
contains_address<Elf_Xword>(address) :
contains_address<Elf_Word>(address);
if (!contains && !is_cu_die()) {
/* For CU DIEs address range may be zero size, even though its child DIEs
* occupie some address space. So, if CU DIE's address range doesn't
* contain the given address, we still want to go and check the children.
*/
_set_errno(EINVAL);
return NULL;
}
/* This DIE contains given address (or may contain it, if this is a CU DIE).
* Lets iterate through child DIEs to find the leaf (last DIE) that contains
* this address. */
DIEObject* child = last_child();
while (child != NULL) {
DIEObject* leaf = child->get_leaf_for_address(address);
if (leaf != NULL) {
return leaf;
}
child = child->prev_sibling();
}
/* No child DIE contains this address. This DIE is the leaf. */
return contains || !is_cu_die() ? this : NULL;
}
template <typename AddrType>
bool DIEObject::contains_address(Elf_Xword address) {
DIEAttrib die_ranges;
/* DIE can contain either list of ranges (f.i. DIEs that represent a routine
* that is inlined in multiple places will contain list of address ranges
* where that routine is inlined), or a pair "low PC, and high PC" describing
* contiguos address space where routine has been placed by compiler. */
if (get_attrib(DW_AT_ranges, &die_ranges)) {
/* Iterate through this DIE's ranges list, looking for the one that
* contains the given address. */
AddrType low;
AddrType high;
Elf_Word range_off = die_ranges.value()->u32;
while (elf_file()->get_range(range_off, &low, &high) &&
(low != 0 || high != 0)) {
if (address >= low && address < high) {
return true;
}
range_off += sizeof(AddrType) * 2;
}
return false;
} else {
/* This DIE doesn't have ranges. Lets see if it has low_pc and high_pc
* attributes. */
DIEAttrib low_pc;
DIEAttrib high_pc;
if (!get_attrib(DW_AT_low_pc, &low_pc) ||
!get_attrib(DW_AT_high_pc, &high_pc) ||
address < low_pc.value()->u64 ||
address >= high_pc.value()->u64) {
return false;
}
return true;
}
}
DIEObject* DIEObject::find_die_object(const Dwarf_DIE* die_to_find) {
if (die_to_find == die()) {
return this;
}
/* First we will iterate through the list of children, since chances to
* find requested DIE decrease as we go deeper into DIE tree. */
DIEObject* iter = last_child();
while (iter != NULL) {
if (iter->die() == die_to_find) {
return iter;
}
iter = iter->prev_sibling();
};
/* DIE has not been found among the children. Lets go deeper now. */
iter = last_child();
while (iter != NULL) {
DIEObject* ret = iter->find_die_object(die_to_find);
if (ret != NULL) {
return ret;
}
iter = iter->prev_sibling();
}
_set_errno(EINVAL);
return NULL;
}
void DIEObject::dump(bool only_this) const {
const Dwarf_Abbr_AT* at_abbr;
Dwarf_Tag tag;
const Elf_Byte* die_attr = advance(&at_abbr, &tag);
if (die_attr != NULL) {
printf("\n********** DIE[%p(%04X)] %s: %s **********\n",
die_, parent_cu()->get_die_reference(die_), dwarf_tag_name(tag),
get_name());
/* Dump this DIE attributes. */
while (!at_abbr->is_separator()) {
DIEAttrib attr;
at_abbr = at_abbr->process(&attr.at_, &attr.form_);
die_attr = parent_cu()->process_attrib(die_attr, attr.form(), &attr.value_);
dump_attrib(attr.at(), attr.form(), attr.value());
if (attr.at() == DW_AT_ranges) {
/* Dump all ranges for this DIE. */
Elf_Word off = attr.value()->u32;
if (parent_cu()->is_CU_address_64()) {
Elf_Xword low, high;
while (elf_file()->get_range<Elf_Xword>(off, &low, &high) &&
(low != 0 || high != 0)) {
printf(" %08" PRIX64 " - %08" PRIX64 "\n",
low, high);
off += 16;
}
} else {
Elf_Word low, high;
while (elf_file()->get_range<Elf_Word>(off, &low, &high) &&
(low != 0 || high != 0)) {
printf(" %08X - %08X\n",
low, high);
off += 8;
}
}
}
}
}
if (only_this) {
if (parent_die_ != NULL && !parent_die_->is_cu_die()) {
printf("\n-----------> CHILD OF:\n");
parent_die_->dump(true);
}
} else {
/* Dump this DIE's children. */
if (last_child() != NULL) {
last_child()->dump(false);
}
/* Dump this DIE's siblings. */
if (prev_sibling() != NULL) {
prev_sibling()->dump(false);
}
}
}
const Elf_Byte* DIEObject::advance(const Dwarf_Abbr_AT** at_abbr,
Dwarf_Tag* tag) const {
Dwarf_AbbrNum abbr_num;
Dwarf_Tag die_tag;
const Elf_Byte* die_attr = die()->process(&abbr_num);
const Dwarf_Abbr_DIE* abbr = parent_cu()->get_die_abbr(abbr_num);
if (abbr == NULL) {
return NULL;
}
const Dwarf_Abbr_AT* attrib_abbr = abbr->process(NULL, &die_tag);
if (at_abbr != NULL) {
*at_abbr = attrib_abbr;
}
if (tag != NULL) {
*tag = die_tag;
}
return die_attr;
}