diff -r 1af5c1be89f8 -r 92d87f2e53c2 tools/elf4rom/libs/dwarf-20071209/libdwarf/dwarf_query.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/elf4rom/libs/dwarf-20071209/libdwarf/dwarf_query.c	Fri Jan 15 09:07:44 2010 +0000
@@ -0,0 +1,619 @@
+/*
+
+  Copyright (C) 2000,2002,2004 Silicon Graphics, Inc.  All Rights Reserved.
+  Portions Copyright (C) 2007 David Anderson. All Rights Reserved.
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of version 2.1 of the GNU Lesser General Public License 
+  as published by the Free Software Foundation.
+
+  This program is distributed in the hope that it would be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+
+  Further, this software is distributed without any warranty that it is
+  free of the rightful claim of any third person regarding infringement 
+  or the like.  Any license provided herein, whether implied or 
+  otherwise, applies only to this software file.  Patent licenses, if
+  any, provided herein do not apply to combinations of this program with 
+  other software, or any other product whatsoever.  
+
+  You should have received a copy of the GNU Lesser General Public 
+  License along with this program; if not, write the Free Software 
+  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
+  USA.
+
+  Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,
+  Mountain View, CA 94043, or:
+
+  http://www.sgi.com
+
+  For further information regarding this notice, see:
+
+  http://oss.sgi.com/projects/GenInfo/NoticeExplan
+
+*/
+/* The address of the Free Software Foundation is
+   Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, 
+   Boston, MA 02110-1301, USA.
+   SGI has moved from the Crittenden Lane address.
+*/
+
+
+
+
+#include "config.h"
+#include "dwarf_incl.h"
+#include <stdio.h>
+#include "dwarf_die_deliv.h"
+
+int
+dwarf_get_address_size(Dwarf_Debug dbg,
+		       Dwarf_Half * ret_addr_size, Dwarf_Error * error)
+{
+    Dwarf_Half address_size;
+
+    if (dbg == 0) {
+	_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
+	return (DW_DLV_ERROR);
+    }
+    /* length size same as address size */
+    address_size = dbg->de_pointer_size;
+    *ret_addr_size = address_size;
+    return DW_DLV_OK;
+}
+
+int
+dwarf_dieoffset(Dwarf_Die die,
+		Dwarf_Off * ret_offset, Dwarf_Error * error)
+{
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+    *ret_offset = (die->di_debug_info_ptr -
+		   die->di_cu_context->cc_dbg->de_debug_info);
+    return DW_DLV_OK;
+}
+
+
+/*
+    This function returns the offset of
+    the die relative to the start of its
+    compilation-unit rather than .debug_info.
+    Returns DW_DLV_ERROR on error.
+*/
+int
+dwarf_die_CU_offset(Dwarf_Die die,
+		    Dwarf_Off * cu_off, Dwarf_Error * error)
+{
+    Dwarf_CU_Context cu_context;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+    cu_context = die->di_cu_context;
+
+    *cu_off =
+	(die->di_debug_info_ptr - cu_context->cc_dbg->de_debug_info -
+	 cu_context->cc_debug_info_offset);
+    return DW_DLV_OK;
+}
+
+
+int
+dwarf_tag(Dwarf_Die die, Dwarf_Half * tag, Dwarf_Error * error)
+{
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+
+    *tag = (die->di_abbrev_list->ab_tag);
+    return DW_DLV_OK;
+}
+
+
+int
+dwarf_attrlist(Dwarf_Die die,
+	       Dwarf_Attribute ** attrbuf,
+	       Dwarf_Signed * attrcnt, Dwarf_Error * error)
+{
+    Dwarf_Word attr_count = 0;
+    Dwarf_Word i = 0;
+    Dwarf_Half attr = 0;
+    Dwarf_Half attr_form = 0;
+    Dwarf_Byte_Ptr abbrev_ptr = 0;
+    Dwarf_Abbrev_List abbrev_list = 0;
+    Dwarf_Attribute new_attr = 0;
+    Dwarf_Attribute head_attr = NULL;
+    Dwarf_Attribute curr_attr = NULL;
+    Dwarf_Attribute *attr_ptr = 0;
+    Dwarf_Debug dbg = 0;
+    Dwarf_Byte_Ptr info_ptr = 0;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+    dbg = die->di_cu_context->cc_dbg;
+
+    abbrev_list = _dwarf_get_abbrev_for_code(die->di_cu_context,
+					     die->di_abbrev_list->
+					     ab_code);
+    if (abbrev_list == NULL) {
+	_dwarf_error(dbg, error, DW_DLE_DIE_ABBREV_BAD);
+	return (DW_DLV_ERROR);
+    }
+    abbrev_ptr = abbrev_list->ab_abbrev_ptr;
+
+    info_ptr = die->di_debug_info_ptr;
+    SKIP_LEB128_WORD(info_ptr);
+
+    do {
+	Dwarf_Unsigned utmp2;
+
+	DECODE_LEB128_UWORD(abbrev_ptr, utmp2);
+	attr = (Dwarf_Half) utmp2;
+	DECODE_LEB128_UWORD(abbrev_ptr, utmp2);
+	attr_form = (Dwarf_Half) utmp2;
+
+	if (attr != 0) {
+	    new_attr =
+		(Dwarf_Attribute) _dwarf_get_alloc(dbg, DW_DLA_ATTR, 1);
+	    if (new_attr == NULL) {
+		_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+		return (DW_DLV_ERROR);
+	    }
+
+	    new_attr->ar_attribute = attr;
+	    new_attr->ar_attribute_form_direct = attr_form;
+	    new_attr->ar_attribute_form = attr_form;
+	    if (attr_form == DW_FORM_indirect) {
+		Dwarf_Unsigned utmp6;
+
+		/* DECODE_LEB128_UWORD does info_ptr update */
+		DECODE_LEB128_UWORD(info_ptr, utmp6);
+		attr_form = (Dwarf_Half) utmp6;
+		new_attr->ar_attribute_form = attr_form;
+	    }
+	    new_attr->ar_cu_context = die->di_cu_context;
+	    new_attr->ar_debug_info_ptr = info_ptr;
+
+	    info_ptr += _dwarf_get_size_of_val(dbg, attr_form, info_ptr,
+					       die->di_cu_context->
+					       cc_length_size);
+
+	    if (head_attr == NULL)
+		head_attr = curr_attr = new_attr;
+	    else {
+		curr_attr->ar_next = new_attr;
+		curr_attr = new_attr;
+	    }
+	    attr_count++;
+	}
+    } while (attr != 0 || attr_form != 0);
+
+    if (attr_count == 0) {
+	*attrbuf = NULL;
+	*attrcnt = 0;
+	return (DW_DLV_NO_ENTRY);
+    }
+
+    attr_ptr = (Dwarf_Attribute *)
+	_dwarf_get_alloc(dbg, DW_DLA_LIST, attr_count);
+    if (attr_ptr == NULL) {
+	_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+	return (DW_DLV_ERROR);
+    }
+
+    curr_attr = head_attr;
+    for (i = 0; i < attr_count; i++) {
+	*(attr_ptr + i) = curr_attr;
+	curr_attr = curr_attr->ar_next;
+    }
+
+    *attrbuf = attr_ptr;
+    *attrcnt = attr_count;
+    return (DW_DLV_OK);
+}
+
+
+/*
+    This function takes a die, and an attr, and returns
+    a pointer to the start of the value of that attr in
+    the given die in the .debug_info section.  The form
+    is returned in *attr_form.
+
+    Returns NULL on error, or if attr is not found.
+    However, *attr_form is 0 on error, and positive 
+    otherwise.
+*/
+static Dwarf_Byte_Ptr
+_dwarf_get_value_ptr(Dwarf_Die die,
+		     Dwarf_Half attr, Dwarf_Half * attr_form)
+{
+    Dwarf_Byte_Ptr abbrev_ptr;
+    Dwarf_Abbrev_List abbrev_list;
+    Dwarf_Half curr_attr;
+    Dwarf_Half curr_attr_form;
+    Dwarf_Byte_Ptr info_ptr;
+
+    abbrev_list = _dwarf_get_abbrev_for_code(die->di_cu_context,
+					     die->di_abbrev_list->
+					     ab_code);
+    if (abbrev_list == NULL) {
+	*attr_form = 0;
+	return (NULL);
+    }
+    abbrev_ptr = abbrev_list->ab_abbrev_ptr;
+
+    info_ptr = die->di_debug_info_ptr;
+    SKIP_LEB128_WORD(info_ptr);
+
+    do {
+	Dwarf_Unsigned utmp3;
+
+	DECODE_LEB128_UWORD(abbrev_ptr, utmp3);
+	curr_attr = (Dwarf_Half) utmp3;
+	DECODE_LEB128_UWORD(abbrev_ptr, utmp3);
+	curr_attr_form = (Dwarf_Half) utmp3;
+	if (curr_attr_form == DW_FORM_indirect) {
+	    Dwarf_Unsigned utmp6;
+
+	    /* DECODE_LEB128_UWORD updates info_ptr */
+	    DECODE_LEB128_UWORD(info_ptr, utmp6);
+	    curr_attr_form = (Dwarf_Half) utmp6;
+	}
+
+	if (curr_attr == attr) {
+	    *attr_form = curr_attr_form;
+	    return (info_ptr);
+	}
+
+	info_ptr += _dwarf_get_size_of_val(die->di_cu_context->cc_dbg,
+					   curr_attr_form, info_ptr,
+					   die->di_cu_context->
+					   cc_length_size);
+    } while (curr_attr != 0 || curr_attr_form != 0);
+
+    *attr_form = 1;
+    return (NULL);
+}
+
+
+int
+dwarf_diename(Dwarf_Die die, char **ret_name, Dwarf_Error * error)
+{
+    Dwarf_Half attr_form;
+    Dwarf_Debug dbg;
+    Dwarf_Byte_Ptr info_ptr;
+    Dwarf_Unsigned string_offset;
+    int res;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+    info_ptr = _dwarf_get_value_ptr(die, DW_AT_name, &attr_form);
+    if (info_ptr == NULL) {
+	if (attr_form == 0) {
+	    _dwarf_error(die->di_cu_context->cc_dbg, error,
+			 DW_DLE_DIE_BAD);
+	    return (DW_DLV_ERROR);
+	}
+	return DW_DLV_NO_ENTRY;
+    }
+
+    if (attr_form == DW_FORM_string) {
+	*ret_name = (char *) (info_ptr);
+	return DW_DLV_OK;
+    }
+
+    dbg = die->di_cu_context->cc_dbg;
+    if (attr_form != DW_FORM_strp) {
+	_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_BAD);
+	return (DW_DLV_ERROR);
+    }
+
+    READ_UNALIGNED(dbg, string_offset, Dwarf_Unsigned,
+		   info_ptr, die->di_cu_context->cc_length_size);
+
+    if (string_offset >= dbg->de_debug_str_size) {
+	_dwarf_error(dbg, error, DW_DLE_STRING_OFFSET_BAD);
+	return (DW_DLV_ERROR);
+    }
+
+    res =
+	_dwarf_load_section(dbg,
+			    dbg->de_debug_str_index,
+			    &dbg->de_debug_str, error);
+    if (res != DW_DLV_OK) {
+	return res;
+    }
+
+    *ret_name = (char *) (dbg->de_debug_str + string_offset);
+    return DW_DLV_OK;
+}
+
+
+int
+dwarf_hasattr(Dwarf_Die die,
+	      Dwarf_Half attr,
+	      Dwarf_Bool * return_bool, Dwarf_Error * error)
+{
+    Dwarf_Half attr_form;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+    if (_dwarf_get_value_ptr(die, attr, &attr_form) == NULL) {
+	if (attr_form == 0) {
+	    _dwarf_error(die->di_cu_context->cc_dbg, error,
+			 DW_DLE_DIE_BAD);
+	    return (DW_DLV_ERROR);
+	}
+	*return_bool = false;
+	return DW_DLV_OK;
+    }
+
+    *return_bool = (true);
+    return DW_DLV_OK;
+}
+
+
+int
+dwarf_attr(Dwarf_Die die,
+	   Dwarf_Half attr,
+	   Dwarf_Attribute * ret_attr, Dwarf_Error * error)
+{
+    Dwarf_Half attr_form;
+    Dwarf_Attribute attrib;
+    Dwarf_Byte_Ptr info_ptr;
+    Dwarf_Debug dbg;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+    dbg = die->di_cu_context->cc_dbg;
+
+    info_ptr = _dwarf_get_value_ptr(die, attr, &attr_form);
+    if (info_ptr == NULL) {
+	if (attr_form == 0) {
+	    _dwarf_error(dbg, error, DW_DLE_DIE_BAD);
+	    return (DW_DLV_ERROR);
+	}
+	return DW_DLV_NO_ENTRY;
+    }
+
+    attrib = (Dwarf_Attribute) _dwarf_get_alloc(dbg, DW_DLA_ATTR, 1);
+    if (attrib == NULL) {
+	_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+	return (DW_DLV_ERROR);
+    }
+
+    attrib->ar_attribute = attr;
+    attrib->ar_attribute_form = attr_form;
+    attrib->ar_attribute_form_direct = attr_form;
+    attrib->ar_cu_context = die->di_cu_context;
+    attrib->ar_debug_info_ptr = info_ptr;
+    *ret_attr = (attrib);
+    return DW_DLV_OK;
+}
+
+
+int
+dwarf_lowpc(Dwarf_Die die,
+	    Dwarf_Addr * return_addr, Dwarf_Error * error)
+{
+    Dwarf_Addr ret_addr = 0;
+    Dwarf_Byte_Ptr info_ptr = 0;
+    Dwarf_Half attr_form = 0;
+    Dwarf_Debug dbg = 0;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+    dbg = die->di_cu_context->cc_dbg;
+    info_ptr = _dwarf_get_value_ptr(die, DW_AT_low_pc, &attr_form);
+    if ((info_ptr == NULL && attr_form == 0) ||
+	(info_ptr != NULL && attr_form != DW_FORM_addr)) {
+	_dwarf_error(dbg, error, DW_DLE_DIE_BAD);
+	return (DW_DLV_ERROR);
+    }
+    if (info_ptr == NULL) {
+	return (DW_DLV_NO_ENTRY);
+    }
+
+
+    READ_UNALIGNED(dbg, ret_addr, Dwarf_Addr,
+		   info_ptr, dbg->de_pointer_size);
+
+    *return_addr = ret_addr;
+    return (DW_DLV_OK);
+}
+
+
+int
+dwarf_highpc(Dwarf_Die die,
+	     Dwarf_Addr * return_addr, Dwarf_Error * error)
+{
+    Dwarf_Addr ret_addr;
+    Dwarf_Byte_Ptr info_ptr;
+    Dwarf_Half attr_form;
+    Dwarf_Debug dbg;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+    dbg = die->di_cu_context->cc_dbg;
+    info_ptr = _dwarf_get_value_ptr(die, DW_AT_high_pc, &attr_form);
+    if ((info_ptr == NULL && attr_form == 0) ||
+	(info_ptr != NULL && attr_form != DW_FORM_addr)) {
+	_dwarf_error(dbg, error, DW_DLE_DIE_BAD);
+	return (DW_DLV_ERROR);
+    }
+    if (info_ptr == NULL) {
+	return (DW_DLV_NO_ENTRY);
+    }
+
+    READ_UNALIGNED(dbg, ret_addr, Dwarf_Addr,
+		   info_ptr, dbg->de_pointer_size);
+
+    *return_addr = ret_addr;
+    return (DW_DLV_OK);
+}
+
+
+/*
+    Takes a die, an attribute attr, and checks if attr 
+    occurs in die.  Attr is required to be an attribute
+    whose form is in the "constant" class.  If attr occurs 
+    in die, the value is returned.  
+  Returns DW_DLV_OK, DW_DLV_ERROR, or DW_DLV_NO_ENTRY as
+    appropriate. Sets the value thru the pointer return_val.
+    This function is meant to do all the 
+    processing for dwarf_bytesize, dwarf_bitsize, dwarf_bitoffset, 
+    and dwarf_srclang.
+*/
+static int
+_dwarf_die_attr_unsigned_constant(Dwarf_Die die,
+				  Dwarf_Half attr,
+				  Dwarf_Unsigned * return_val,
+				  Dwarf_Error * error)
+{
+    Dwarf_Byte_Ptr info_ptr;
+    Dwarf_Half attr_form;
+    Dwarf_Unsigned ret_value;
+    Dwarf_Debug dbg;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+    dbg = die->di_cu_context->cc_dbg;
+    info_ptr = _dwarf_get_value_ptr(die, attr, &attr_form);
+    if (info_ptr != NULL) {
+	switch (attr_form) {
+
+	case DW_FORM_data1:
+	    *return_val = (*(Dwarf_Small *) info_ptr);
+	    return (DW_DLV_OK);
+
+	case DW_FORM_data2:
+	    READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
+			   info_ptr, sizeof(Dwarf_Shalf));
+	    *return_val = ret_value;
+	    return (DW_DLV_OK);
+
+	case DW_FORM_data4:
+	    READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
+			   info_ptr, sizeof(Dwarf_sfixed));
+	    *return_val = ret_value;
+	    return (DW_DLV_OK);
+
+	case DW_FORM_data8:
+	    READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
+			   info_ptr, sizeof(Dwarf_Unsigned));
+	    *return_val = ret_value;
+	    return (DW_DLV_OK);
+
+	case DW_FORM_udata:
+	    *return_val = (_dwarf_decode_u_leb128(info_ptr, NULL));
+	    return (DW_DLV_OK);
+
+	default:
+	    _dwarf_error(dbg, error, DW_DLE_DIE_BAD);
+	    return (DW_DLV_ERROR);
+	}
+    }
+    if (attr_form == 0) {
+	_dwarf_error(dbg, error, DW_DLE_DIE_BAD);
+	return (DW_DLV_ERROR);
+    }
+    return DW_DLV_NO_ENTRY;
+}
+
+
+int
+dwarf_bytesize(Dwarf_Die die,
+	       Dwarf_Unsigned * ret_size, Dwarf_Error * error)
+{
+    Dwarf_Unsigned luns;
+    int res =
+	_dwarf_die_attr_unsigned_constant(die, DW_AT_byte_size, &luns,
+					  error);
+
+    *ret_size = luns;
+    return res;
+}
+
+
+int
+dwarf_bitsize(Dwarf_Die die,
+	      Dwarf_Unsigned * ret_size, Dwarf_Error * error)
+{
+    Dwarf_Unsigned luns;
+    int res;
+
+    res =
+	_dwarf_die_attr_unsigned_constant(die, DW_AT_bit_size, &luns,
+					  error);
+    *ret_size = luns;
+    return res;
+}
+
+
+int
+dwarf_bitoffset(Dwarf_Die die,
+		Dwarf_Unsigned * ret_size, Dwarf_Error * error)
+{
+    Dwarf_Unsigned luns;
+    int res;
+
+    res =
+	_dwarf_die_attr_unsigned_constant(die, DW_AT_bit_offset, &luns,
+					  error);
+    *ret_size = luns;
+    return res;
+}
+
+
+/* Refer section 3.1, page 21 in Dwarf Definition. */
+int
+dwarf_srclang(Dwarf_Die die,
+	      Dwarf_Unsigned * ret_size, Dwarf_Error * error)
+{
+    Dwarf_Unsigned luns;
+    int res;
+
+    res =
+	_dwarf_die_attr_unsigned_constant(die, DW_AT_language, &luns,
+					  error);
+    *ret_size = luns;
+    return res;
+}
+
+
+/* Refer section 5.4, page 37 in Dwarf Definition. */
+int
+dwarf_arrayorder(Dwarf_Die die,
+		 Dwarf_Unsigned * ret_size, Dwarf_Error * error)
+{
+    Dwarf_Unsigned luns;
+    int res;
+
+    res =
+	_dwarf_die_attr_unsigned_constant(die, DW_AT_ordering, &luns,
+					  error);
+    *ret_size = luns;
+    return res;
+}
+
+/*
+	Return DW_DLV_OK if ok
+	DW_DLV_ERROR if failure.
+
+	If the die and the attr are not related the result is
+	meaningless.
+*/
+int
+dwarf_attr_offset(Dwarf_Die die, Dwarf_Attribute attr, Dwarf_Off * offset,	/* return 
+										   offset 
+										   thru 
+										   this 
+										   ptr 
+										 */
+		  Dwarf_Error * error)
+{
+    Dwarf_Off attroff;
+
+    CHECK_DIE(die, DW_DLV_ERROR);
+
+    attroff = (attr->ar_debug_info_ptr -
+	       die->di_cu_context->cc_dbg->de_debug_info);
+    *offset = attroff;
+    return DW_DLV_OK;
+}