From fea55d4139a791e915a3a5bf1214695479e429a8 Mon Sep 17 00:00:00 2001 From: jbj Date: Tue, 20 May 2003 13:51:54 +0000 Subject: [PATCH] Initial revision CVS patchset: 6867 CVS date: 2003/05/20 13:51:54 --- elfutils/libdw/dwarf_abbrev_hash.c | 29 +++++++ elfutils/libdw/dwarf_abbrev_hash.h | 24 ++++++ elfutils/libdw/dwarf_attr.c | 39 ++++++++++ elfutils/libdw/dwarf_child.c | 149 ++++++++++++++++++++++++++++++++++++ elfutils/libdw/dwarf_diename.c | 30 ++++++++ elfutils/libdw/dwarf_formaddr.c | 43 +++++++++++ elfutils/libdw/dwarf_formref.c | 68 ++++++++++++++++ elfutils/libdw/dwarf_formsdata.c | 70 +++++++++++++++++ elfutils/libdw/dwarf_formstring.c | 57 ++++++++++++++ elfutils/libdw/dwarf_formudata.c | 70 +++++++++++++++++ elfutils/libdw/dwarf_get_abbrev.c | 106 +++++++++++++++++++++++++ elfutils/libdw/dwarf_has_children.c | 48 ++++++++++++ elfutils/libdw/dwarf_highpc.c | 32 ++++++++ elfutils/libdw/dwarf_lowpc.c | 32 ++++++++ elfutils/libdw/dwarf_nextcu.c | 135 ++++++++++++++++++++++++++++++++ elfutils/libdw/dwarf_offdie.c | 54 +++++++++++++ elfutils/libdw/dwarf_siblingof.c | 116 ++++++++++++++++++++++++++++ elfutils/libdw/dwarf_tag.c | 82 ++++++++++++++++++++ elfutils/libdw/libdw_alloc.c | 63 +++++++++++++++ elfutils/libdw/libdw_findcu.c | 108 ++++++++++++++++++++++++++ elfutils/libdw/libdw_form.c | 109 ++++++++++++++++++++++++++ 21 files changed, 1464 insertions(+) create mode 100644 elfutils/libdw/dwarf_abbrev_hash.c create mode 100644 elfutils/libdw/dwarf_abbrev_hash.h create mode 100644 elfutils/libdw/dwarf_attr.c create mode 100644 elfutils/libdw/dwarf_child.c create mode 100644 elfutils/libdw/dwarf_diename.c create mode 100644 elfutils/libdw/dwarf_formaddr.c create mode 100644 elfutils/libdw/dwarf_formref.c create mode 100644 elfutils/libdw/dwarf_formsdata.c create mode 100644 elfutils/libdw/dwarf_formstring.c create mode 100644 elfutils/libdw/dwarf_formudata.c create mode 100644 elfutils/libdw/dwarf_get_abbrev.c create mode 100644 elfutils/libdw/dwarf_has_children.c create mode 100644 elfutils/libdw/dwarf_highpc.c create mode 100644 elfutils/libdw/dwarf_lowpc.c create mode 100644 elfutils/libdw/dwarf_nextcu.c create mode 100644 elfutils/libdw/dwarf_offdie.c create mode 100644 elfutils/libdw/dwarf_siblingof.c create mode 100644 elfutils/libdw/dwarf_tag.c create mode 100644 elfutils/libdw/libdw_alloc.c create mode 100644 elfutils/libdw/libdw_findcu.c create mode 100644 elfutils/libdw/libdw_form.c diff --git a/elfutils/libdw/dwarf_abbrev_hash.c b/elfutils/libdw/dwarf_abbrev_hash.c new file mode 100644 index 0000000..009e757 --- /dev/null +++ b/elfutils/libdw/dwarf_abbrev_hash.c @@ -0,0 +1,29 @@ +/* Implementation of hash table for DWARF .debug_abbrev section content. + Copyright (C) 2000, 2001, 2002 Red Hat, Inc. + Written by Ulrich Drepper , 2000. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#define NO_UNDEF +#include "libdwP.h" + +#define next_prime __libdwarf_next_prime +extern size_t next_prime (size_t) attribute_hidden; + +#include + +#undef next_prime +#define next_prime attribute_hidden __libdwarf_next_prime +#include "../lib/next_prime.c" diff --git a/elfutils/libdw/dwarf_abbrev_hash.h b/elfutils/libdw/dwarf_abbrev_hash.h new file mode 100644 index 0000000..ef3cc48 --- /dev/null +++ b/elfutils/libdw/dwarf_abbrev_hash.h @@ -0,0 +1,24 @@ +/* Hash table for DWARF .debug_abbrev section content. + Copyright (C) 2000, 2001, 2002 Red Hat, Inc. + Written by Ulrich Drepper , 2000. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifndef _DWARF_ABBREV_HASH_H +#define _DWARF_ABBREV_HASH_H 1 + +#define NAME Dwarf_Abbrev_Hash +#define TYPE Dwarf_Abbrev * +#define COMPARE(a, b) (0) + +#include + +#endif /* dwarf_abbrev_hash.h */ diff --git a/elfutils/libdw/dwarf_attr.c b/elfutils/libdw/dwarf_attr.c new file mode 100644 index 0000000..a09f11a --- /dev/null +++ b/elfutils/libdw/dwarf_attr.c @@ -0,0 +1,39 @@ +/* Return specific DWARF attribute of a DIE. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +Dwarf_Attribute * +dwarf_attr (die, search_name, result) + Dwarf_Die *die; + unsigned int search_name; + Dwarf_Attribute *result; +{ + if (die == NULL) + return NULL; + + /* Search for the attribute with the given name. */ + result->valp = __libdw_find_attr (die, search_name, &result->code, + &result->form); + /* Always fill in the CU information. */ + result->cu = die->cu; + + return result->code == search_name ? result : NULL; +} diff --git a/elfutils/libdw/dwarf_child.c b/elfutils/libdw/dwarf_child.c new file mode 100644 index 0000000..e693214 --- /dev/null +++ b/elfutils/libdw/dwarf_child.c @@ -0,0 +1,149 @@ +/* Return vhild of current DIE. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "libdwP.h" +#include + +/* Some arbitrary value not conflicting with any existing code. */ +#define INVALID 0xffffe444 + + +unsigned char * +internal_function +__libdw_find_attr (Dwarf_Die *die, unsigned int search_name, + unsigned int *codep, unsigned int *formp) +{ + Dwarf *dbg = die->cu->dbg; + unsigned char *readp = (unsigned char *) die->addr; + + /* First we have to get the abbreviation code so that we can decode + the data in the DIE. */ + unsigned int abbrev_code; + get_uleb128 (abbrev_code, readp); + + /* Find the abbreviation entry. */ + Dwarf_Abbrev *abbrevp = die->abbrev; + if (abbrevp != (Dwarf_Abbrev *) -1l) + { + abbrevp = __libdw_getabbrev (die->cu, abbrev_code); + die->abbrev = abbrevp ?: (Dwarf_Abbrev *) -1l; + } + if (unlikely (abbrevp == (Dwarf_Abbrev *) -1l)) + { + __libdw_seterrno (DWARF_E_INVALID_DWARF); + return NULL; + } + + /* Search the name attribute. */ + unsigned char *const endp + = ((unsigned char *) dbg->sectiondata[IDX_debug_abbrev]->d_buf + + dbg->sectiondata[IDX_debug_abbrev]->d_size); + + unsigned char *attrp = abbrevp->attrp; + while (1) + { + /* Are we still in bounds? This test needs to be refined. */ + if (unlikely (attrp + 1 >= endp)) + { + __libdw_seterrno (DWARF_E_INVALID_DWARF); + return NULL; + } + + /* Get attribute name and form. + + XXX We don't check whether this reads beyond the end of the + section. */ + unsigned int attr_name; + get_uleb128 (attr_name, attrp); + unsigned int attr_form; + get_uleb128 (attr_form, attrp); + + /* We can stop if we found the attribute with value zero. */ + if (attr_name == 0 && attr_form == 0) + break; + + /* Is this the name attribute? */ + if (attr_name == search_name && search_name != INVALID) + { + if (codep != NULL) + *codep = attr_name; + if (formp != NULL) + *formp = attr_form; + + return readp; + } + + /* Skip over the rest of this attribute (if there is any). */ + if (attr_form != 0) + { + size_t len = __libdw_form_val_len (dbg, die->cu, attr_form, readp); + + if (unlikely (len == (size_t) -1l)) + return NULL; + + // XXX We need better boundary checks. + readp += len; + } + } + + // XXX Do we need other values? + if (codep != NULL) + *codep = INVALID; + if (formp != NULL) + *formp = INVALID; + + return readp; +} + + +Dwarf_Die * +dwarf_child (die, result) + Dwarf_Die *die; + Dwarf_Die *result; +{ + /* Ignore previous errors. */ + if (die == NULL) + return NULL; + + /* Skip past the last attribute. */ + void *addr = NULL; + + /* If we already know there are no children do not search. */ + if (die->abbrev == NULL || die->abbrev->has_children) + addr = __libdw_find_attr (die, INVALID, NULL, NULL); + + /* Make sure the DIE really has children. */ + if (die->abbrev != NULL && ! die->abbrev->has_children) + /* There cannot be any children. But we may have found a sibling. */ + return NULL; + + if (addr == NULL) + return NULL; + + /* Clear the entire DIE structure. This signals we have not yet + determined any of the information. */ + memset (result, '\0', sizeof (Dwarf_Die)); + + /* We have the address. */ + result->addr = addr; + + /* Same CU as the parent. */ + result->cu = die->cu; + + return result; +} diff --git a/elfutils/libdw/dwarf_diename.c b/elfutils/libdw/dwarf_diename.c new file mode 100644 index 0000000..78555dc --- /dev/null +++ b/elfutils/libdw/dwarf_diename.c @@ -0,0 +1,30 @@ +/* Return string in name attribute of DIE. + Copyright (C) 2002 Red Hat, Inc. + Written by Ulrich Drepper , 2002. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +const char * +dwarf_diename (die) + Dwarf_Die *die; +{ + Dwarf_Attribute attr_mem; + + return dwarf_formstring (dwarf_attr (die, DW_AT_name, &attr_mem)); +} diff --git a/elfutils/libdw/dwarf_formaddr.c b/elfutils/libdw/dwarf_formaddr.c new file mode 100644 index 0000000..4e8cdb0 --- /dev/null +++ b/elfutils/libdw/dwarf_formaddr.c @@ -0,0 +1,43 @@ +/* Return address represented by attribute. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +int +dwarf_formaddr (attr, return_addr) + Dwarf_Attribute *attr; + Dwarf_Addr *return_addr; +{ + if (attr == NULL) + return -1; + + if (unlikely (attr->form != DW_FORM_addr)) + { + __libdw_seterrno (DWARF_E_NO_ADDR); + return -1; + } + + if (attr->cu->address_size == 8) + *return_addr = read_8ubyte_unaligned (attr->cu->dbg, attr->valp); + else + *return_addr = read_4ubyte_unaligned (attr->cu->dbg, attr->valp); + + return 0; +} diff --git a/elfutils/libdw/dwarf_formref.c b/elfutils/libdw/dwarf_formref.c new file mode 100644 index 0000000..d6b1f0f --- /dev/null +++ b/elfutils/libdw/dwarf_formref.c @@ -0,0 +1,68 @@ +/* Return reference offset represented by attribute. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +int +dwarf_formref (attr, return_offset) + Dwarf_Attribute *attr; + Dwarf_Off *return_offset; +{ + if (attr == NULL) + return -1; + + unsigned int u128; + unsigned char *datap; + + switch (attr->form) + { + case DW_FORM_ref1: + *return_offset = *attr->valp; + break; + + case DW_FORM_ref2: + *return_offset = read_2ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_ref4: + *return_offset = read_4ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_ref8: + *return_offset = read_8ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_ref_udata: + datap = attr->valp; + get_uleb128 (u128, datap); + *return_offset = u128; + break; + + case DW_FORM_ref_addr: + __libdw_seterrno (DWARF_E_INVALID_REFERENCE); + return -1; + + default: + __libdw_seterrno (DWARF_E_NO_REFERENCE); + return -1; + } + + return 0; +} diff --git a/elfutils/libdw/dwarf_formsdata.c b/elfutils/libdw/dwarf_formsdata.c new file mode 100644 index 0000000..ad84510 --- /dev/null +++ b/elfutils/libdw/dwarf_formsdata.c @@ -0,0 +1,70 @@ +/* Return signed constant represented by attribute. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +int +dwarf_formsdata (attr, return_sval) + Dwarf_Attribute *attr; + Dwarf_Sword *return_sval; +{ + if (attr == NULL) + return -1; + + unsigned int u128; + unsigned char *datap; + + switch (attr->form) + { + case DW_FORM_data1: + *return_sval = *attr->valp; + break; + + case DW_FORM_data2: + *return_sval = read_2ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_data4: + *return_sval = read_4ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_data8: + *return_sval = read_8ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_sdata: + datap = attr->valp; + get_sleb128 (u128, datap); + *return_sval = u128; + break; + + case DW_FORM_udata: + datap = attr->valp; + get_uleb128 (u128, datap); + *return_sval = u128; + break; + + default: + __libdw_seterrno (DWARF_E_NO_CONSTANT); + return -1; + } + + return 0; +} diff --git a/elfutils/libdw/dwarf_formstring.c b/elfutils/libdw/dwarf_formstring.c new file mode 100644 index 0000000..017da7f --- /dev/null +++ b/elfutils/libdw/dwarf_formstring.c @@ -0,0 +1,57 @@ +/* Return string associated with given attribute. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +const char * +dwarf_formstring (attrp) + Dwarf_Attribute *attrp; +{ + /* Ignore earlier errors. */ + if (attrp == NULL) + return NULL; + + /* We found it. Now determine where the string is stored. */ + if (attrp->form == DW_FORM_string) + /* A simple inlined string. */ + return (const char *) attrp->valp; + + Dwarf *dbg = attrp->cu->dbg; + + if (unlikely (attrp->form != DW_FORM_strp) + || dbg->sectiondata[IDX_debug_str] == NULL) + { + invalid_error: + __libdw_seterrno (DWARF_E_NO_STRING); + return NULL; + } + + uint64_t off; + // XXX We need better boundary checks. + if (attrp->cu->address_size == 8) + off = read_8ubyte_unaligned (dbg, attrp->valp); + else + off = read_4ubyte_unaligned (dbg, attrp->valp); + + if (off >= dbg->sectiondata[IDX_debug_str]->d_size) + goto invalid_error; + + return (const char *) dbg->sectiondata[IDX_debug_str]->d_buf + off; +} diff --git a/elfutils/libdw/dwarf_formudata.c b/elfutils/libdw/dwarf_formudata.c new file mode 100644 index 0000000..66b8c2a --- /dev/null +++ b/elfutils/libdw/dwarf_formudata.c @@ -0,0 +1,70 @@ +/* Return unsigned constant represented by attribute. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +int +dwarf_formudata (attr, return_uval) + Dwarf_Attribute *attr; + Dwarf_Word *return_uval; +{ + if (attr == NULL) + return -1; + + unsigned int u128; + unsigned char *datap; + + switch (attr->form) + { + case DW_FORM_data1: + *return_uval = *attr->valp; + break; + + case DW_FORM_data2: + *return_uval = read_2ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_data4: + *return_uval = read_4ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_data8: + *return_uval = read_8ubyte_unaligned (attr->cu->dbg, attr->valp); + break; + + case DW_FORM_sdata: + datap = attr->valp; + get_sleb128 (u128, datap); + *return_uval = u128; + break; + + case DW_FORM_udata: + datap = attr->valp; + get_uleb128 (u128, datap); + *return_uval = u128; + break; + + default: + __libdw_seterrno (DWARF_E_NO_CONSTANT); + return -1; + } + + return 0; +} diff --git a/elfutils/libdw/dwarf_get_abbrev.c b/elfutils/libdw/dwarf_get_abbrev.c new file mode 100644 index 0000000..bb5f51d --- /dev/null +++ b/elfutils/libdw/dwarf_get_abbrev.c @@ -0,0 +1,106 @@ +/* Get abbreviation at given offset. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include "libdwP.h" + + +Dwarf_Abbrev * +dwarf_get_abbrev (cu, offset, lengthp) + struct Dwarf_CU *cu; + Dwarf_Off offset; + size_t *lengthp; +{ + /* Don't fail if there is not .debug_abbrev section. */ + if (cu->dbg->sectiondata[IDX_debug_abbrev] == NULL) + return NULL; + + char *abbrevp = ((char *) cu->dbg->sectiondata[IDX_debug_abbrev]->d_buf + + offset); + char *start_abbrevp = abbrevp; + if (*abbrevp == '\0') + /* We are past the last entry. */ + return NULL; + + /* 7.5.3 Abbreviations Tables + + [...] Each declaration begins with an unsigned LEB128 number + representing the abbreviation code itself. [...] The + abbreviation code is followed by another unsigned LEB128 + number that encodes the entry's tag. [...] + + [...] Following the tag encoding is a 1-byte value that + determines whether a debugging information entry using this + abbreviation has child entries or not. [...] + + [...] Finally, the child encoding is followed by a series of + attribute specifications. Each attribute specification + consists of two parts. The first part is an unsigned LEB128 + number representing the attribute's name. The second part is + an unsigned LEB128 number representing the attribute s form. */ + unsigned int code; + get_uleb128 (code, abbrevp); + + /* Check whether this code is already in the hash table. */ + bool foundit = false; + Dwarf_Abbrev *abb = Dwarf_Abbrev_Hash_find (&cu->abbrev_hash, code, NULL); + if (abb == NULL) + abb = libdw_alloc (cu->dbg, Dwarf_Abbrev); + else + { + foundit = true; + + assert (abb->offset == offset); + + /* If the caller doesn't need the length we are done. */ + if (lengthp == NULL) + goto out; + } + + /* If there is already a value in the hash table we are going to + overwrite its content. This must not be a problem, since the + content better be the same. */ + abb->code = code; + get_uleb128 (abb->tag, abbrevp); + abb->has_children = *abbrevp++ == DW_CHILDREN_yes; + abb->attrp = abbrevp; + abb->offset = offset; + + /* Skip over all the attributes and count them while doing so. */ + abb->attrcnt = 0; + unsigned int attrname; + unsigned int attrform; + do + { + get_uleb128 (attrname, abbrevp); + get_uleb128 (attrform, abbrevp); + } + while (attrname != 0 && attrform != 0 && ++abb->attrcnt); + + /* Return the length to the caller if she asked for it. */ + if (lengthp != NULL) + *lengthp = abbrevp - start_abbrevp; + + /* Add the entry to the hash table. */ + if (! foundit) + (void) Dwarf_Abbrev_Hash_insert (&cu->abbrev_hash, abb->code, abb); + + out: + return abb; +} diff --git a/elfutils/libdw/dwarf_has_children.c b/elfutils/libdw/dwarf_has_children.c new file mode 100644 index 0000000..0afde6f --- /dev/null +++ b/elfutils/libdw/dwarf_has_children.c @@ -0,0 +1,48 @@ +/* Return string associated with given attribute. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "libdwP.h" +#include + + +int +dwarf_has_children (die) + Dwarf_Die *die; +{ + /* Find the abbreviation entry. */ + Dwarf_Abbrev *abbrevp = die->abbrev; + if (abbrevp != (Dwarf_Abbrev *) -1l) + { + unsigned char *readp = (unsigned char *) die->addr; + + /* First we have to get the abbreviation code so that we can decode + the data in the DIE. */ + unsigned int abbrev_code; + get_uleb128 (abbrev_code, readp); + + abbrevp = __libdw_getabbrev (die->cu, abbrev_code); + die->abbrev = abbrevp ?: (Dwarf_Abbrev *) -1l; + } + if (unlikely (abbrevp == (Dwarf_Abbrev *) -1l)) + { + __libdw_seterrno (DWARF_E_INVALID_DWARF); + return 0; + } + + return abbrevp->has_children; +} diff --git a/elfutils/libdw/dwarf_highpc.c b/elfutils/libdw/dwarf_highpc.c new file mode 100644 index 0000000..019cf14 --- /dev/null +++ b/elfutils/libdw/dwarf_highpc.c @@ -0,0 +1,32 @@ +/* Return high PC attribute of DIE. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +int +dwarf_highpc (die, return_addr) + Dwarf_Die *die; + Dwarf_Addr *return_addr; +{ + Dwarf_Attribute attr_mem; + + return dwarf_formaddr (dwarf_attr (die, DW_AT_high_pc, &attr_mem), + return_addr); +} diff --git a/elfutils/libdw/dwarf_lowpc.c b/elfutils/libdw/dwarf_lowpc.c new file mode 100644 index 0000000..95d2912 --- /dev/null +++ b/elfutils/libdw/dwarf_lowpc.c @@ -0,0 +1,32 @@ +/* Return low PC attribute of DIE. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +int +dwarf_lowpc (die, return_addr) + Dwarf_Die *die; + Dwarf_Addr *return_addr; +{ + Dwarf_Attribute attr_mem; + + return dwarf_formaddr (dwarf_attr (die, DW_AT_low_pc, &attr_mem), + return_addr); +} diff --git a/elfutils/libdw/dwarf_nextcu.c b/elfutils/libdw/dwarf_nextcu.c new file mode 100644 index 0000000..88ff740 --- /dev/null +++ b/elfutils/libdw/dwarf_nextcu.c @@ -0,0 +1,135 @@ +/* Advance to next CU header. + Copyright (C) 2002, 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2002. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License version 2 as + published by the Free Software Foundation. + + 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. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include + + +int +dwarf_nextcu (dwarf, off, next_off, header_sizep, abbrev_offsetp, + address_sizep) + Dwarf *dwarf; + Dwarf_Off off; + Dwarf_Off *next_off; + size_t *header_sizep; + Dwarf_Off *abbrev_offsetp; + uint8_t *address_sizep; +{ + /* Maybe there has been an error before. */ + if (dwarf == NULL) + return 0; + + /* If we reached the end before don't do anything. */ + if (off == (Dwarf_Off) -1l + /* Make sure there is enough space in the .debug_info section + for at least the initial word. We cannot test the rest since + we don't know yet whether this is a 64-bit object or not. */ + || unlikely (off + 4 >= dwarf->sectiondata[IDX_debug_info]->d_size)) + { + *next_off = (Dwarf_Off) -1l; + return 1; + } + + /* This points into the .debug_info section to the beginning of the + CU entry. */ + char *bytes = (char *) dwarf->sectiondata[IDX_debug_info]->d_buf + off; + + /* The format of the CU header is described in dwarf2p1 7.5.1: + + 1. A 4-byte or 12-byte unsigned integer representing the length + of the .debug_info contribution for that compilation unit, not + including the length field itself. In the 32-bit DWARF format, + this is a 4-byte unsigned integer (which must be less than + 0xffffff00); in the 64-bit DWARF format, this consists of the + 4-byte value 0xffffffff followed by an 8-byte unsigned integer + that gives the actual length (see Section 7.4). + + 2. A 2-byte unsigned integer representing the version of the + DWARF information for that compilation unit. For DWARF Version + 2.1, the value in this field is 2. + + 3. A 4-byte or 8-byte unsigned offset into the .debug_abbrev + section. This offset associates the compilation unit with a + particular set of debugging information entry abbreviations. In + the 32-bit DWARF format, this is a 4-byte unsigned length; in + the 64-bit DWARF format, this is an 8-byte unsigned length (see + Section 7.4). + + 4. A 1-byte unsigned integer representing the size in bytes of + an address on the target architecture. If the system uses + segmented addressing, this value represents the size of the + offset portion of an address. */ + uint64_t length = read_4ubyte_unaligned (dwarf, bytes); + bytes += 4; + size_t offset_size = 4; + if (length == 0xffffffffu) + offset_size = 8; + + /* Now we know how large the header is. Note the trick in the + computation. If the offset_size is 4 the '- 4' term undoes the + '2 *'. If offset_size is 8 this term computes the size of the + escape value plus the 8 byte offset. */ + if (unlikely (off + 2 * offset_size - 4 + sizeof (uint16_t) + + offset_size + sizeof (uint8_t) + >= dwarf->sectiondata[IDX_debug_info]->d_size)) + { + *next_off = -1; + return 1; + } + + if (length == 0xffffffffu) + { + /* This is a 64-bit DWARF format. */ + length = read_8ubyte_unaligned (dwarf, bytes); + bytes += 8; + } + + /* Read the version stamp. Always a 16-bit value. + XXX Do we need the value? */ + read_2ubyte_unaligned (dwarf, bytes); + bytes += 2; + + /* Get offset in .debug_abbrev. Note that the size of the entry + depends on whether this is a 32-bit or 64-bit DWARF definition. */ + uint64_t abbrev_offset; + if (offset_size == 4) + abbrev_offset = read_4ubyte_unaligned (dwarf, bytes); + else + abbrev_offset = read_8ubyte_unaligned (dwarf, bytes); + if (abbrev_offsetp != NULL) + *abbrev_offsetp = abbrev_offset; + bytes += offset_size; + + /* The address size. Always an 8-bit value. */ + uint8_t address_size = *bytes++; + if (address_sizep != NULL) + *address_sizep = address_size; + + /* Store the header length. */ + if (header_sizep != NULL) + *header_sizep = (bytes + - ((char *) dwarf->sectiondata[IDX_debug_info]->d_buf + + off)); + + /* See above for an explanation of the trick in this formula. */ + *next_off = off + 2 * offset_size - 4 + length; + + return 0; +} diff --git a/elfutils/libdw/dwarf_offdie.c b/elfutils/libdw/dwarf_offdie.c new file mode 100644 index 0000000..6ef5595 --- /dev/null +++ b/elfutils/libdw/dwarf_offdie.c @@ -0,0 +1,54 @@ +/* Return DIE at given offset. + Copyright (C) 2002, 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2002. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include "libdwP.h" + + +Dwarf_Die * +dwarf_offdie (dbg, offset, result) + Dwarf *dbg; + Dwarf_Off offset; + Dwarf_Die *result; +{ + if (dbg == NULL) + return NULL; + + if (offset >= dbg->sectiondata[IDX_debug_info]->d_size) + { + __libdw_seterrno (DWARF_E_INVALID_DWARF); + return NULL; + } + + /* Clear the entire DIE structure. This signals we have not yet + determined any of the information. */ + memset (result, '\0', sizeof (Dwarf_Die)); + + result->addr = (char *) dbg->sectiondata[IDX_debug_info]->d_buf + offset; + + /* Get the CU. */ + result->cu = __libdw_findcu (dbg, offset); + if (result->cu == NULL) + { + /* This should never happen. The input file is malformed. */ + __libdw_seterrno (DWARF_E_INVALID_DWARF); + result = NULL; + } + + return result; +} diff --git a/elfutils/libdw/dwarf_siblingof.c b/elfutils/libdw/dwarf_siblingof.c new file mode 100644 index 0000000..557a142 --- /dev/null +++ b/elfutils/libdw/dwarf_siblingof.c @@ -0,0 +1,116 @@ +/* Return sibling of given DIE. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "libdwP.h" +#include +#include + + +Dwarf_Die * +dwarf_siblingof (die, result) + Dwarf_Die *die; + Dwarf_Die *result; +{ + /* Ignore previous errors. */ + if (die == NULL) + return NULL; + + unsigned int level = 0; + /* The address we are looking at. */ + unsigned char *addr = die->addr; + + /* Copy of the current DIE. */ + Dwarf_Die this_die = *die; + + /* Search for the beginning of the next die on this level. We + must not return the dies for children of the given die. */ + do + { + /* Get the abbreviation code. */ + unsigned int abbrev_code; + get_uleb128 (abbrev_code, addr); + + if (this_die.abbrev == NULL) + { + this_die.abbrev = __libdw_getabbrev (die->cu, abbrev_code); + if (this_die.abbrev == NULL) + this_die.abbrev = (Dwarf_Abbrev *) -1l; + } + if (unlikely (this_die.abbrev == (Dwarf_Abbrev *) -1l)) + { + __libdw_seterrno (DWARF_E_INVALID_DWARF); + return NULL; + } + + /* Does this abbreviation have children? */ + if (this_die.abbrev->has_children) + ++level; + + /* Find the end of the DIE or the sibling attribute. */ + unsigned int code; + addr = __libdw_find_attr (&this_die, DW_AT_sibling, &code, NULL); + if (code == DW_AT_sibling) + { + Dwarf_Off offset; + Dwarf_Attribute sibattr; + + sibattr.valp = addr; + sibattr.cu = die->cu; + if (dwarf_formref (&sibattr, &offset) != 0) + /* Something went wrong. */ + return NULL; + + /* Compute the next address. */ + addr + = ((unsigned char *) die->cu->dbg->sectiondata[IDX_debug_info]->d_buf + + die->cu->start + offset); + + /* Even if the abbreviation has children we have stepped + over them now. */ + if (this_die.abbrev->has_children) + --level; + } + + /* Check that we are not yet at the end. */ + while (*addr == '\0') + { + if (level-- == 0) + /* No more sibling at all. */ + return DWARF_END_DIE; + + ++addr; + } + + /* Initialize the 'current DIE'. */ + this_die.addr = addr; + this_die.abbrev = NULL; + } + while (level > 0); + + /* Clear the entire DIE structure. This signals we have not yet + determined any of the information. */ + memset (result, '\0', sizeof (Dwarf_Die)); + + /* We have the address. */ + result->addr = addr; + + /* Same CU as the parent. */ + result->cu = die->cu; + + return result; +} diff --git a/elfutils/libdw/dwarf_tag.c b/elfutils/libdw/dwarf_tag.c new file mode 100644 index 0000000..756615a --- /dev/null +++ b/elfutils/libdw/dwarf_tag.c @@ -0,0 +1,82 @@ +/* Return tag of given DIE. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "libdwP.h" + + +Dwarf_Abbrev * +internal_function +__libdw_getabbrev (struct Dwarf_CU *cu, unsigned int code) +{ + Dwarf_Abbrev *abb; + + /* See whether the entry is already in the hash table. */ + abb = Dwarf_Abbrev_Hash_find (&cu->abbrev_hash, code, NULL); + if (abb == NULL) + while (cu->last_abbrev_offset != (size_t) -1l) + { + size_t length; + + /* Find the next entry. It gets automatically added to the + hash table. */ + abb = dwarf_get_abbrev (cu, cu->last_abbrev_offset, &length); + if (abb == NULL) + { + /* Make sure we do not try to search for it again. */ + cu->last_abbrev_offset = (size_t) -1l; + break; + } + + cu->last_abbrev_offset += length; + + /* Is this the code we are looking for? */ + if (abb->code == code) + break; + } + + return abb; +} + + +int +dwarf_tag (die) + Dwarf_Die *die; +{ + /* Do we already know the abbreviation? */ + if (die->abbrev == NULL) + { + /* Check that we have not done this before. */ + if (die->abbrev != (Dwarf_Abbrev *) -1l) + { + /* Get the abbreviation code. */ + unsigned int u128; + get_uleb128 (u128, die->addr); + + /* Find the abbreviation. */ + die->abbrev = __libdw_getabbrev (die->cu, u128); + } + + if (die->abbrev == (Dwarf_Abbrev *) -1l) + { + __libdw_seterrno (DWARF_E_INVALID_DWARF); + return DW_TAG_invalid; + } + } + + return die->abbrev->tag; +} diff --git a/elfutils/libdw/libdw_alloc.c b/elfutils/libdw/libdw_alloc.c new file mode 100644 index 0000000..30c61f2 --- /dev/null +++ b/elfutils/libdw/libdw_alloc.c @@ -0,0 +1,63 @@ +/* Memory handling for libdw. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License version 2 as + published by the Free Software Foundation. + + 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. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include +#include +#include "libdwP.h" + + +void * +__libdw_allocate (Dwarf *dbg, size_t minsize) +{ + size_t size = MAX (dbg->mem_default_size, + 2 * minsize + offsetof (struct libdw_memblock, mem)); + struct libdw_memblock *newp = malloc (size); + if (newp == NULL) + dbg->oom_handler (); + + newp->size = newp->remaining = size - offsetof (struct libdw_memblock, mem); + + newp->prev = dbg->mem_tail; + newp->next = NULL; + dbg->mem_tail = newp; + + return newp->mem; +} + + +Dwarf_OOM +dwarf_new_oom_handler (Dwarf *dbg, Dwarf_OOM handler) +{ + Dwarf_OOM old = dbg->oom_handler; + dbg->oom_handler = handler; + return old; +} + + +void +__attribute ((noreturn, visibility ("hidden"))) +__libdw_oom (void) +{ + while (1) + error (EXIT_FAILURE, ENOMEM, "libdw"); +} diff --git a/elfutils/libdw/libdw_findcu.c b/elfutils/libdw/libdw_findcu.c new file mode 100644 index 0000000..7639394 --- /dev/null +++ b/elfutils/libdw/libdw_findcu.c @@ -0,0 +1,108 @@ +/* Find CU for given offset. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License version 2 as + published by the Free Software Foundation. + + 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. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +#include "libdwP.h" + + +static int +findcu_cb (const void *arg1, const void *arg2) +{ + struct Dwarf_CU *cu1 = (struct Dwarf_CU *) arg1; + struct Dwarf_CU *cu2 = (struct Dwarf_CU *) arg2; + + /* Find out which of the two arguments is the search value. It has + length 0. */ + if (cu1->length == 0) + { + if (cu1->start < cu2->start) + return -1; + if (cu1->start >= cu2->start + cu2->length) + return 1; + } + else + { + if (cu2->start < cu1->start) + return 1; + if (cu2->start >= cu1->start + cu1->length) + return -1; + } + + return 0; +} + + +struct Dwarf_CU * +__libdw_findcu (dbg, start) + Dwarf *dbg; + Dwarf_Off start; +{ + /* Maybe we already know that CU. */ + struct Dwarf_CU fake = { .start = start, .length = 0 }; + struct Dwarf_CU **found = tfind (&fake, &dbg->cu_tree, findcu_cb); + if (found != NULL) + return *found; + + if (start < dbg->next_cu_offset) + { + __libdw_seterrno (DWARF_E_INVALID_DWARF); + return NULL; + } + + /* No. Then read more CUs. */ + while (1) + { + Dwarf_Off oldoff = dbg->next_cu_offset; + uint8_t address_size; + Dwarf_Off abbrev_offset; + + if (dwarf_nextcu (dbg, oldoff, &dbg->next_cu_offset, NULL, + &abbrev_offset, &address_size) != 0) + /* No more entries. */ + return NULL; + + /* Create an entry for this CU. */ + struct Dwarf_CU *newp = libdw_alloc (dbg, struct Dwarf_CU); + + newp->dbg = dbg; + newp->start = oldoff; + newp->length = dbg->next_cu_offset - oldoff; + newp->address_size = address_size; + Dwarf_Abbrev_Hash_init (&newp->abbrev_hash, 41); + newp->last_abbrev_offset = abbrev_offset; + + /* Add the new entry to the search tree. */ + if (tsearch (newp, &dbg->cu_tree, findcu_cb) == NULL) + { + /* Something went wrong. Unfo the operation. */ + dbg->next_cu_offset = oldoff; + __libdw_seterrno (DWARF_E_NOMEM); + return NULL; + } + + /* Is this the one we are looking for? */ + if (start < dbg->next_cu_offset) + // XXX Match exact offset. + return newp; + } + /* NOTREACHED */ +} diff --git a/elfutils/libdw/libdw_form.c b/elfutils/libdw/libdw_form.c new file mode 100644 index 0000000..bf7642f --- /dev/null +++ b/elfutils/libdw/libdw_form.c @@ -0,0 +1,109 @@ +/* Helper functions for form handling. + Copyright (C) 2003 Red Hat, Inc. + Written by Ulrich Drepper , 2003. + + This program is Open Source software; you can redistribute it and/or + modify it under the terms of the Open Software License version 1.0 as + published by the Open Source Initiative. + + You should have received a copy of the Open Software License along + with this program; if not, you may obtain a copy of the Open Software + License version 1.0 from http://www.opensource.org/licenses/osl.php or + by writing the Open Source Initiative c/o Lawrence Rosen, Esq., + 3001 King Ranch Road, Ukiah, CA 95482. */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +#include "libdwP.h" + + +size_t +internal_function +__libdw_form_val_len (Dwarf *dbg, struct Dwarf_CU *cu, unsigned int form, + unsigned char *valp) +{ + unsigned char *saved; + unsigned int u128; + size_t result; + + switch (form) + { + case DW_FORM_addr: + case DW_FORM_strp: + case DW_FORM_ref_addr: + result = cu->address_size; + break; + + case DW_FORM_block1: + result = *valp + 1; + break; + + case DW_FORM_block2: + result = read_2ubyte_unaligned (dbg, valp) + 2; + break; + + case DW_FORM_block4: + result = read_4ubyte_unaligned (dbg, valp) + 4; + break; + + case DW_FORM_block: + saved = valp; + get_uleb128 (u128, valp); + result = u128 + (valp - saved); + break; + + case DW_FORM_ref1: + case DW_FORM_data1: + case DW_FORM_flag: + result = 1; + break; + + case DW_FORM_data2: + case DW_FORM_ref2: + result = 2; + break; + + case DW_FORM_data4: + case DW_FORM_ref4: + result = 4; + break; + + case DW_FORM_data8: + case DW_FORM_ref8: + result = 8; + break; + + case DW_FORM_string: + result = strlen ((char *) valp) + 1; + break; + + case DW_FORM_sdata: + case DW_FORM_udata: + case DW_FORM_ref_udata: + saved = valp; + get_uleb128 (u128, valp); + result = valp - saved; + break; + + case DW_FORM_indirect: + saved = valp; + get_uleb128 (u128, valp); + // XXX Is this really correct? + result = __libdw_form_val_len (dbg, cu, u128, valp); + if (result != (size_t) -1) + result += valp - saved; + break; + + default: + __libdw_seterrno (DWARF_E_INVALID_DWARF); + result = (size_t) -1l; + break; + } + + return result; +} -- 2.7.4