darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-12-14 07:38:41 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
54815b9a08
darling-gdb/gdb/dwarf2read.c
Peter Schauer 0db3fe94c3 Add support for Irix 6.2 native O32 and N32 ABI. 
* config.in, configure.in, configure:  Check for <objlist.h>.
	* configure.tgt:  Handle mips*-sgi-irix6* like irix5 for now.

	* cp-valprint.c (cp_print_value_fields):  Use SYMBOL_VALUE_ADDRESS
	instead of SYMBOL_BLOCK_VALUE to get the address of a static member.

	* dwarf2read.c:  Turn warnings and recoverable errors into complaints,
	add new complaints where appropriate.
	gcc -Wall cleanup.
	(struct line_head):  Change line_base from char to int to avoid
	problems with compilers whose plain char is represented by an
	unsigned char.
	(struct partial_die_info):  Add is_declaration field.
	(dwarf2_tmp_obstack):  New obstack for allocating temporary storage
	used during symbol reading.
	(cu_header_offset):  New variable for resolving relative reference
	dies.
	(optimized_out, basereg, islocal, frame_base_reg, frame_base_offset):
	New interface variables for decode_locdesc.
	(struct dwarf2_pinfo):  New structure for communication between
	psymtab and symtab reading, passed via pst->read_symtab_private.
	(dwarf2_has_info, dwarf2_build_psymtabs):  Accept objects files
	without line number sections.
	(dwarf2_build_psymtabs_hard):  Initialize temporary obstack
	for symbol reading.
	Allocate and initialize pst->read_symtab_private.
	Relocate pst->textlow and pst->texthigh with baseaddr.
	(scan_partial_symbols):  Do not add DW_AT_declaration symbols
	to the partial symbol table.
	Add file scope enumerator symbols to the partial symbol table.
	Fix typo in highpc computation.
	If we didn't find a lowpc, set it to highpc to avoid complaints
	from `maint check.
	(add_partial_symbol):  Relocate symbol values with baseaddr.
	Add static DW_TAG_subprogram and DW_TAG_variable symbols to the
	minimal symbol table.
        Obtain symbol values for DW_TAG_variable symbols from the location
	descriptor, skip symbols with missing location desciptors.
	Skip symbols for aggregate types without children.
	Handle enumerator symbols.
	(dwarf2_psymtab_to_symtab):  Issue symbol reading message if verbose.
	(psymtab_to_symtab_1):  Set local variables from
	pst->read_symtab_private, set cu_header_offset and baseaddr.
	Initialize temporary obstack for symbol reading, initialize
	buildsym and add a cleanup to really_free_pendings.
	Relocate highpc with baseaddr when calling end_symtab.
	If the compilation is from a C file generated by language
	preprocessors, do not set the symtab language if it was already
	deduced by start_subfile.
	Removed verbose sorting symbol table message.
	(process_die):  Handle DW_TAG_ptr_to_member_type and
	DW_TAG_reference_type.
	Use read_subroutine_type to get the function type for
	DW_TAG_subprogram before calling read_func_scope.
	(read_file_scope):  Initialize file name to <unknown>, start_subfile
	expects a non-NULL name.
	If we didn't find a lowpc, set it to highpc to avoid complaints
	from finish_symbol.
	Relocate lowpc and highpc with baseaddr.
	Get rid of Irix6.2 native cc compile machine prefix in comp_dir.
	Zero out ftypes for each new compilation unit (may be different
	language or different objfile).
	Accept compilation units without line number information, pass
	comp_dir to decode_lines.
	(read_func_scope):  Initialize function name to <unknown> to avoid
	core dumps when DW_AT_name is missing.
	Relocate lowpc and highpc with baseaddr.
	Handle DW_AT_frame_base, keep result for DW_OP_fbreg operations.
	Pass function type to new_symbol.
	(read_lexical_block_scope):  Relocate lowpc and highpc with baseaddr.
	(read_structure_scope):  Set TYPE_TAG_NAME, not TYPE_NAME.
	Handle DW_TAG_class_type.
	Copy fields to type_obstack, release temporary storage for fields.
	Don't add symbol if die is a stub die and has no children.
	Handle C++ static member fields.
	(read_enumeration):  Set TYPE_TAG_NAME, not TYPE_NAME.
	Copy fields to type_obstack, release temporary storage for fields.
	Let new_symbol handle the symbol creation for enumerators
	instead of handcrafting a symbol.
	Determine signedness of enum type from enumerators.
	(dwarf_read_array_type):  Handle variable length arrays.
	Use lookup_pointer_type instead of handcrafting a type.
	Create array type only if a DW_TAG_subrange_type was found.
	(read_tag_pointer_type, read_tag_reference_type):
	Use lookup_pointer_type and lookup_reference_type instead
	of handcrafting a type.
	(read_tag_ptr_to_member_type):  New function to handle
	DW_TAG_ptr_to_member_type.
	(read_subroutine_type):  Handle parameter dies.
	Use lookup_function_type instead of handcrafting a type.
	(read_typedef):  Allocate a TYPE_CODE_TYPEDEF type for the typedef.
	(read_base_type):  If the type has a name, use init_type to create
	a new type instead of second guessing a fundamental type.
	(read_comp_unit):  Reset die reference table before building
	a new one.
	(dwarf2_read_section):  Read section contents into psymbol_obstack.
	(dwarf2_read_abbrevs):  Handle unterminated abbreviations
	for a compile unit gracefully.
	(read_partial_die):  Zero partial die before reading its info.
	Handle DW_AT_declaration.
	Fix typo in handling of DW_FORM_block4.
	(read_full_die):  Fix typo in handling of DW_FORM_block4.
	(read_1_signed_byte, read_2_signed_bytes, read_4_signed_bytes):
	New routines to get signed values from a buffer.
	(read_n_bytes, read_string):  Allocate storage from the temporary
	obstack. If the host char size permits it, return pointer
	to buffer instead of allocating storage.
	(set_cu_language):  Handle DW_LANG_Mips_Assembler.
	(dwarf_attr):  Return NULL if reference die for DW_AT_specification
	or DW_AT_abstract_origin die is not found.
	(record_minimal_symbol):  Removed, replaced with a direct call to
	prim_record_minimal_symbol, it now handles saving the string itself.
	(convert_locdesc):  Removed, partial symtab reading now uses
	decode_locdesc.
	(dwarf_attr):  Use dwarf2_get_ref_die_offset to get the absolute
	offset for the die reference.
	(dwarf_decode_lines):  Complain if the line section info is missing.
	Use read_1_signed_byte to extract lh.line_base to avoid
        problems with compilers whose plain char is represented by an
        unsigned char.
	Add cleanups for allocated temporary storage.
	Start a subfile for the first file in the state machine.
	Fix off by one problem with dirs.dirs access.
	Use comp_dir when directory index is 0.
	Support multiple sequences (from Jason Merrill <jason@cygnus.com>).
	(dwarf2_start_subfile):  Try to keep line numbers from identical
	absolute and relative file names in a common subfile.
	(new_symbol):  Allocate symbol and symbol name on the symbol_obstack.
	Set SYMBOL_LINE from DW_AT_decl_line if present.
	Set SYMBOL_TYPE from passed type if not NULL.
	Change DW_TAG_variable symbol types with missing type entries
	to a sensible type.
	Handle optimized_out, offreg and islocal storage classes.
	Add external symbols with type information whose address isn't
	known as LOC_UNRESOLVED symbols.
	Synthesize typedefs for C++ classes, structs, unions and enumerations.
	Handle DW_TAG_enumerator symbols, complain for unrecognized
	symbol tags.
	(die_type):  A missing DW_AT_type represents a void type.
	Use dwarf2_get_ref_die_offset to get the absolute offset for
	the die reference.
	(die_containing_type):  New function to build type from
	DW_AT_containing_type attribut.
	(read_type_die):  Handle DW_TAG_ptr_to_member_type.
	Treat DW_TAG_subprogram like DW_TAG_subroutine_type.
	(dwarf_base_type):  Fix typo with creation of FT_UNSIGNED_SHORT
	fundamental type.
	(create_name):  Removed, symbol name allocation is now done
	in new_symbol.
	(dump_die):  Use print_address_numeric to print a CORE_ADDR.
	(dwarf2_empty_die_ref_table):  New function to clear the die
	reference table.
	(dwarf2_get_ref_die_offset):  New function to get the absolute
	die offset from a die reference attribute.
	(decode_locdesc):  Complete rewrite using a stack, code mostly
	borrowed from dwarfread.c:locval.
	(dwarf_alloc_type):  Removed, replaced by direct calls to alloc_type.
	(dwarf_alloc_block):  Allocate block on temporary obstack.

	* elfread.c (elf_symtab_read):  When handling Irix dynamic symbols,
	skip section name symbols and relocate all others.
	(elf_symfile_read):  Build dwarf2 psymtab even if offset is non-zero.

	* irix5-nat.c (fetch_core_registers):  Handle core_reg_sect
	from N32 executables. Call registers_fetched after extracting
	the registers.
	(obj_list_variant, struct link_map, LM_OFFSET, LM_ADDR):  New
	definitions to enable support of O32 and N32 format objlists.
	(struct so_list):  New members offset, so_name and lmstart to
	eliminate dependencies from the objlist format used.
	(solib_map_sections, symbol_add_stub, solib_add,
	info_sharedlibrary_command, solib_address, clear_solib):  Use
	so_name and LM_OFFSET.
	(first_link_map_member):  Rewrite to enable support of O32 and N32
	format objlists.
	(next_link_map_member, xfer_link_map_member):  New functions to
	support O32 and N32 format objlists.
	(find_solib):  Use first_link_map_member, next_link_map_member and
	xfer_link_map_member.
	(solib_create_inferior_hook):  Use TARGET_SIGNAL_* instead of
	host signal numbers.

	* mdebugread.c (parse_partial_symbols, handle_psymbol_enumerators):
	Pass CORE_ADDR variant to add_psymbol_to_list.

	* mips-tdep.c (heuristic_proc_desc):  Stop examining the prologue
	if we encounter a positive stack adjustment. Handle `move $30,$sp'.
	Handle `sd reg,offset($sp)' for 32 bit ABIs.

	* symmisc.c (dump_msymbols, print_partial_symbols):  Use
	print_address_numeric to print a SYMBOL_VALUE_ADDRESS.
	(dump_symtab):  Print compilation directory if it is not NULL.

	* valops.c (search_struct_field, value_struct_elt_for_reference):
	Use SYMBOL_VALUE_ADDRESS instead of SYMBOL_BLOCK_VALUE to get the
	address of a static member.
1996-12-01 08:33:39 +00:00

5081 lines
130 KiB
C
Raw Blame History

/* DWARF 2 debugging format support for GDB.
Copyright 1994, 1995, 1996 Free Software Foundation, Inc.
Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
Inc. with support from Florida State University (under contract
with the Ada Joint Program Office), and Silicon Graphics, Inc.
Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
based on Fred Fish's (Cygnus Support) implementation of DWARF 1
support in dwarfread.c
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version.
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. */
#include "defs.h"
#include "bfd.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "symfile.h"
#include "objfiles.h"
#include "elf/dwarf2.h"
#include "buildsym.h"
#include "demangle.h"
#include "expression.h"
#include "language.h"
#include "complaints.h"
#include <fcntl.h>
#include "gdb_string.h"
#include <sys/types.h>
/* .debug_info header for a compilation unit
Because of alignment constraints, this structure has padding and cannot
be mapped directly onto the beginning of the .debug_info section. */
typedef struct comp_unit_header
{
unsigned int length; /* length of the .debug_info
contribution */
unsigned short version; /* version number -- 2 for DWARF
version 2 */
unsigned int abbrev_offset; /* offset into .debug_abbrev section */
unsigned char addr_size; /* byte size of an address -- 4 */
}
_COMP_UNIT_HEADER;
#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
/* .debug_pubnames header
Because of alignment constraints, this structure has padding and cannot
be mapped directly onto the beginning of the .debug_info section. */
typedef struct pubnames_header
{
unsigned int length; /* length of the .debug_pubnames
contribution */
unsigned char version; /* version number -- 2 for DWARF
version 2 */
unsigned int info_offset; /* offset into .debug_info section */
unsigned int info_size; /* byte size of .debug_info section
portion */
}
_PUBNAMES_HEADER;
#define _ACTUAL_PUBNAMES_HEADER_SIZE 13
/* .debug_pubnames header
Because of alignment constraints, this structure has padding and cannot
be mapped directly onto the beginning of the .debug_info section. */
typedef struct aranges_header
{
unsigned int length; /* byte len of the .debug_aranges
contribution */
unsigned short version; /* version number -- 2 for DWARF
version 2 */
unsigned int info_offset; /* offset into .debug_info section */
unsigned char addr_size; /* byte size of an address */
unsigned char seg_size; /* byte size of segment descriptor */
}
_ARANGES_HEADER;
#define _ACTUAL_ARANGES_HEADER_SIZE 12
/* .debug_line statement program prologue
Because of alignment constraints, this structure has padding and cannot
be mapped directly onto the beginning of the .debug_info section. */
typedef struct statement_prologue
{
unsigned int total_length; /* byte length of the statement
information */
unsigned short version; /* version number -- 2 for DWARF
version 2 */
unsigned int prologue_length; /* # bytes between prologue &
stmt program */
unsigned char minimum_instruction_length; /* byte size of
smallest instr */
unsigned char default_is_stmt; /* initial value of is_stmt
register */
char line_base;
unsigned char line_range;
unsigned char opcode_base; /* number assigned to first special
opcode */
unsigned char *standard_opcode_lengths;
}
_STATEMENT_PROLOGUE;
/* offsets and sizes of debugging sections */
static file_ptr dwarf_info_offset;
static file_ptr dwarf_abbrev_offset;
static file_ptr dwarf_line_offset;
static file_ptr dwarf_pubnames_offset;
static file_ptr dwarf_aranges_offset;
static file_ptr dwarf_loc_offset;
static file_ptr dwarf_macinfo_offset;
static file_ptr dwarf_str_offset;
static unsigned int dwarf_info_size;
static unsigned int dwarf_abbrev_size;
static unsigned int dwarf_line_size;
static unsigned int dwarf_pubnames_size;
static unsigned int dwarf_aranges_size;
static unsigned int dwarf_loc_size;
static unsigned int dwarf_macinfo_size;
static unsigned int dwarf_str_size;
/* names of the debugging sections */
#define INFO_SECTION ".debug_info"
#define ABBREV_SECTION ".debug_abbrev"
#define LINE_SECTION ".debug_line"
#define PUBNAMES_SECTION ".debug_pubnames"
#define ARANGES_SECTION ".debug_aranges"
#define LOC_SECTION ".debug_loc"
#define MACINFO_SECTION ".debug_macinfo"
#define STR_SECTION ".debug_str"
/* Get at parts of an attribute structure */
#define DW_STRING(attr) ((attr)->u.str)
#define DW_UNSND(attr) ((attr)->u.unsnd)
#define DW_BLOCK(attr) ((attr)->u.blk)
#define DW_SND(attr) ((attr)->u.snd)
#define DW_ADDR(attr) ((attr)->u.addr)
/* local data types */
/* The data in a compilation unit header looks like this. */
struct comp_unit_head
{
int length;
short version;
int abbrev_offset;
unsigned char addr_size;
};
/* The data in the .debug_line statement prologue looks like this. */
struct line_head
{
unsigned int total_length;
unsigned short version;
unsigned int prologue_length;
unsigned char minimum_instruction_length;
unsigned char default_is_stmt;
int line_base;
unsigned char line_range;
unsigned char opcode_base;
unsigned char *standard_opcode_lengths;
};
/* When we construct a partial symbol table entry we only
need this much information. */
struct partial_die_info
{
unsigned short tag;
unsigned char has_children;
unsigned char is_external;
unsigned char is_declaration;
unsigned int offset;
unsigned int abbrev;
char *name;
CORE_ADDR lowpc;
CORE_ADDR highpc;
struct dwarf_block *locdesc;
unsigned int language;
int value;
};
/* This data structure holds the information of an abbrev. */
struct abbrev_info
{
unsigned int number; /* number identifying abbrev */
unsigned int tag; /* dwarf tag */
int has_children; /* boolean */
unsigned int num_attrs; /* number of attributes */
struct attr_abbrev *attrs; /* an array of attribute descriptions */
struct abbrev_info *next; /* next in chain */
};
struct attr_abbrev
{
unsigned int name;
unsigned int form;
};
/* This data structure holds a complete die structure. */
struct die_info
{
unsigned short tag; /* Tag indicating type of die */
unsigned short has_children; /* Does the die have children */
unsigned int abbrev; /* Abbrev number */
unsigned int offset; /* Offset in .debug_info section */
unsigned int num_attrs; /* Number of attributes */
struct attribute *attrs; /* An array of attributes */
struct die_info *next_ref; /* Next die in ref hash table */
struct die_info *next; /* Next die in linked list */
struct type *type; /* Cached type information */
};
/* Attributes have a name and a value */
struct attribute
{
unsigned short name;
unsigned short form;
union
{
char *str;
struct dwarf_block *blk;
unsigned int unsnd;
int snd;
CORE_ADDR addr;
}
u;
};
/* Blocks are a bunch of untyped bytes. */
struct dwarf_block
{
unsigned int size;
char *data;
};
/* We only hold one compilation unit's abbrevs in
memory at any one time. */
#ifndef ABBREV_HASH_SIZE
#define ABBREV_HASH_SIZE 121
#endif
#ifndef ATTR_ALLOC_CHUNK
#define ATTR_ALLOC_CHUNK 4
#endif
static struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE];
/* A hash table of die offsets for following references. */
#ifndef REF_HASH_SIZE
#define REF_HASH_SIZE 1021
#endif
static struct die_info *die_ref_table[REF_HASH_SIZE];
/* Obstack for allocating temporary storage used during symbol reading. */
static struct obstack dwarf2_tmp_obstack;
/* Offset to the first byte of the current compilation unit header,
for resolving relative reference dies. */
static unsigned int cu_header_offset;
/* Allocate fields for structs, unions and enums in this size. */
#ifndef DW_FIELD_ALLOC_CHUNK
#define DW_FIELD_ALLOC_CHUNK 4
#endif
/* The language we are debugging. */
static enum language cu_language;
static const struct language_defn *cu_language_defn;
/* Actually data from the sections. */
static char *dwarf_info_buffer;
static char *dwarf_abbrev_buffer;
static char *dwarf_line_buffer;
/* A zeroed version of a partial die for initialization purposes. */
static struct partial_die_info zeroed_partial_die;
/* The generic symbol table building routines have separate lists for
file scope symbols and all all other scopes (local scopes). So
we need to select the right one to pass to add_symbol_to_list().
We do it by keeping a pointer to the correct list in list_in_scope.
FIXME: The original dwarf code just treated the file scope as the first
local scope, and all other local scopes as nested local scopes, and worked
fine. Check to see if we really need to distinguish these
in buildsym.c. */
static struct pending **list_in_scope = &file_symbols;
/* FIXME: The following variables pass additional information from
decode_locdesc to the caller. */
static int optimized_out; /* Kludge to identify optimized out variables */
static int isreg; /* Kludge to identify register variables */
static int offreg; /* Kludge to identify basereg references */
static int basereg; /* Which base register is it relative to? */
static int islocal; /* Kludge to identify local variables */
/* DW_AT_frame_base values for the current function.
frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
contains the register number for the frame register.
frame_base_offset is the offset from the frame register to the
virtual stack frame. */
static int frame_base_reg;
static CORE_ADDR frame_base_offset;
/* This value is added to each symbol value. FIXME: Generalize to
the section_offsets structure used by dbxread (once this is done,
pass the appropriate section number to end_symtab). */
static CORE_ADDR baseaddr; /* Add to each symbol value */
/* We put a pointer to this structure in the read_symtab_private field
of the psymtab.
The complete dwarf information for an objfile is kept in the
psymbol_obstack, so that absolute die references can be handled.
Most of the information in this structure is related to an entire
object file and could be passed via the sym_private field of the objfile.
It is however conceivable that dwarf2 might not be the only type
of symbols read from an object file. */
struct dwarf2_pinfo
{
/* Pointer to start of dwarf info buffer for the objfile. */
char *dwarf_info_buffer;
/* Offset in dwarf_info_buffer for this compilation unit. */
unsigned long dwarf_info_offset;
/* Pointer to start of dwarf abbreviation buffer for the objfile. */
char *dwarf_abbrev_buffer;
/* Size of dwarf abbreviation section for the objfile. */
unsigned int dwarf_abbrev_size;
/* Pointer to start of dwarf line buffer for the objfile. */
char *dwarf_line_buffer;
};
#define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
#define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
#define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
#define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
#define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
#define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
/* Maintain an array of referenced fundamental types for the current
compilation unit being read. For DWARF version 1, we have to construct
the fundamental types on the fly, since no information about the
fundamental types is supplied. Each such fundamental type is created by
calling a language dependent routine to create the type, and then a
pointer to that type is then placed in the array at the index specified
by it's FT_<TYPENAME> value. The array has a fixed size set by the
FT_NUM_MEMBERS compile time constant, which is the number of predefined
fundamental types gdb knows how to construct. */
static struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
/* FIXME - set from bfd function */
static int bits_per_byte = 8;
/* Various complaints about symbol reading that don't abort the process */
static struct complaint dwarf2_const_ignored =
{
"type qualifier 'const' ignored", 0, 0
};
static struct complaint dwarf2_volatile_ignored =
{
"type qualifier 'volatile' ignored", 0, 0
};
static struct complaint dwarf2_non_const_array_bound_ignored =
{
"non-constant array bounds form %s ignored", 0, 0
};
static struct complaint dwarf2_missing_line_number_section =
{
"missing .debug_line section", 0, 0
};
static struct complaint dwarf2_mangled_line_number_section =
{
"mangled .debug_line section", 0, 0
};
static struct complaint dwarf2_unsupported_die_ref_attr =
{
"unsupported die ref attribute form: %s", 0, 0
};
static struct complaint dwarf2_unsupported_stack_op =
{
"unsupported stack op: '%s'", 0, 0
};
static struct complaint dwarf2_unsupported_tag =
{
"unsupported tag: '%s'", 0, 0
};
static struct complaint dwarf2_unsupported_at_encoding =
{
"unsupported DW_AT_encoding: '%s'", 0, 0
};
static struct complaint dwarf2_unsupported_at_frame_base =
{
"unsupported DW_AT_frame_base for function '%s'", 0, 0
};
static struct complaint dwarf2_missing_at_frame_base =
{
"DW_AT_frame_base missing for DW_OP_fbreg", 0, 0
};
static struct complaint dwarf2_bad_static_member_name =
{
"unrecognized static data member name %s", 0, 0
};
/* Remember the addr_size read from the dwarf.
If a target expects to link compilation units with differing address
sizes, gdb needs to be sure that the appropriate size is here for
whatever scope is currently getting read. */
static int address_size;
/* Externals references. */
extern int info_verbose; /* From main.c; nonzero => verbose */
/* local function prototypes */
static void dwarf2_locate_sections PARAMS ((bfd *, asection *, PTR));
#if 0
static void dwarf2_build_psymtabs_easy PARAMS ((struct objfile *,
struct section_offsets *,
int));
#endif
static void dwarf2_build_psymtabs_hard PARAMS ((struct objfile *,
struct section_offsets *,
int));
static char *scan_partial_symbols PARAMS ((char *, struct objfile *,
CORE_ADDR *, CORE_ADDR *));
static void add_partial_symbol PARAMS ((struct partial_die_info *,
struct objfile *));
static void dwarf2_psymtab_to_symtab PARAMS ((struct partial_symtab *));
static void psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
static char *dwarf2_read_section PARAMS ((struct objfile *, file_ptr,
unsigned int));
static void dwarf2_read_abbrevs PARAMS ((bfd *, unsigned int));
static void dwarf2_empty_abbrev_table PARAMS ((PTR));
static struct abbrev_info *dwarf2_lookup_abbrev PARAMS ((unsigned int));
static char *read_partial_die PARAMS ((struct partial_die_info *,
bfd *, char *, int *));
static char *read_full_die PARAMS ((struct die_info **, bfd *, char *));
static unsigned int read_1_byte PARAMS ((bfd *, char *));
static int read_1_signed_byte PARAMS ((bfd *, char *));
static unsigned int read_2_bytes PARAMS ((bfd *, char *));
static unsigned int read_4_bytes PARAMS ((bfd *, char *));
static unsigned int read_8_bytes PARAMS ((bfd *, char *));
static CORE_ADDR read_address PARAMS ((bfd *, char *));
static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
static char *read_string PARAMS ((bfd *, char *, unsigned int *));
static unsigned int read_unsigned_leb128 PARAMS ((bfd *, char *,
unsigned int *));
static int read_signed_leb128 PARAMS ((bfd *, char *, unsigned int *));
static void set_cu_language PARAMS ((unsigned int));
static struct attribute *dwarf_attr PARAMS ((struct die_info *,
unsigned int));
static void dwarf_decode_lines PARAMS ((unsigned int, char *, bfd *));
static void dwarf2_start_subfile PARAMS ((char *, char *));
static struct symbol *new_symbol PARAMS ((struct die_info *, struct type *,
struct objfile *));
static struct type *die_type PARAMS ((struct die_info *, struct objfile *));
static struct type *die_containing_type PARAMS ((struct die_info *,
struct objfile *));
#if 0
static struct type *type_at_offset PARAMS ((unsigned int, struct objfile *));
#endif
static struct type *tag_type_to_type PARAMS ((struct die_info *,
struct objfile *));
static void read_type_die PARAMS ((struct die_info *, struct objfile *));
static void read_typedef PARAMS ((struct die_info *, struct objfile *));
static void read_base_type PARAMS ((struct die_info *, struct objfile *));
static void read_file_scope PARAMS ((struct die_info *, struct objfile *));
static void read_func_scope PARAMS ((struct die_info *, struct objfile *));
static void read_lexical_block_scope PARAMS ((struct die_info *,
struct objfile *));
static void read_structure_scope PARAMS ((struct die_info *, struct objfile *));
static void read_common_block PARAMS ((struct die_info *, struct objfile *));
static void read_enumeration PARAMS ((struct die_info *, struct objfile *));
static struct type * dwarf_base_type PARAMS ((int, int));
static CORE_ADDR decode_locdesc PARAMS ((struct dwarf_block *,
struct objfile *));
static void dwarf_read_array_type PARAMS ((struct die_info *,
struct objfile *));
static void read_tag_pointer_type PARAMS ((struct die_info *,
struct objfile *));
static void read_tag_ptr_to_member_type PARAMS ((struct die_info *,
struct objfile *));
static void read_tag_reference_type PARAMS ((struct die_info *,
struct objfile *));
static void read_tag_const_type PARAMS ((struct die_info *, struct objfile *));
static void read_tag_volatile_type PARAMS ((struct die_info *,
struct objfile *));
static void read_tag_string_type PARAMS ((struct die_info *,
struct objfile *));
static void read_subroutine_type PARAMS ((struct die_info *,
struct objfile *));
struct die_info *read_comp_unit PARAMS ((char *, bfd *));
static void free_die_list PARAMS ((struct die_info *));
static void process_die PARAMS ((struct die_info *, struct objfile *));
static char *dwarf_tag_name PARAMS ((unsigned int));
static char *dwarf_attr_name PARAMS ((unsigned int));
static char *dwarf_form_name PARAMS ((unsigned int));
static char *dwarf_stack_op_name PARAMS ((unsigned int));
static char *dwarf_bool_name PARAMS ((unsigned int));
static char *dwarf_bool_name PARAMS ((unsigned int));
static char *dwarf_type_encoding_name PARAMS ((unsigned int));
#if 0
static char *dwarf_cfi_name PARAMS ((unsigned int));
struct die_info *copy_die PARAMS ((struct die_info *));
#endif
struct die_info *sibling_die PARAMS ((struct die_info *));
void dump_die PARAMS ((struct die_info *));
void dump_die_list PARAMS ((struct die_info *));
void store_in_ref_table PARAMS ((unsigned int, struct die_info *));
static void dwarf2_empty_die_ref_table PARAMS ((void));
static unsigned int dwarf2_get_ref_die_offset PARAMS ((struct attribute *));
struct die_info *follow_die_ref PARAMS ((unsigned int));
static struct type *dwarf2_fundamental_type PARAMS ((struct objfile *, int));
/* memory allocation interface */
static void dwarf2_free_tmp_obstack PARAMS ((PTR));
static struct dwarf_block *dwarf_alloc_block PARAMS ((void));
static struct abbrev_info *dwarf_alloc_abbrev PARAMS ((void));
static struct die_info *dwarf_alloc_die PARAMS ((void));
/* Try to locate the sections we need for DWARF 2 debugging
information and return true if we have enough to do something. */
int
dwarf2_has_info (abfd)
bfd *abfd;
{
dwarf_info_offset = dwarf_abbrev_offset = dwarf_line_offset = 0;
bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
if (dwarf_info_offset && dwarf_abbrev_offset)
{
return 1;
}
else
{
return 0;
}
}
/* This function is mapped across the sections and remembers the
offset and size of each of the debugging sections we are interested
in. */
static void
dwarf2_locate_sections (ignore_abfd, sectp, ignore_ptr)
bfd *ignore_abfd;
asection *sectp;
PTR ignore_ptr;
{
if (STREQ (sectp->name, INFO_SECTION))
{
dwarf_info_offset = sectp->filepos;
dwarf_info_size = bfd_get_section_size_before_reloc (sectp);
}
else if (STREQ (sectp->name, ABBREV_SECTION))
{
dwarf_abbrev_offset = sectp->filepos;
dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp);
}
else if (STREQ (sectp->name, LINE_SECTION))
{
dwarf_line_offset = sectp->filepos;
dwarf_line_size = bfd_get_section_size_before_reloc (sectp);
}
else if (STREQ (sectp->name, PUBNAMES_SECTION))
{
dwarf_pubnames_offset = sectp->filepos;
dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp);
}
else if (STREQ (sectp->name, ARANGES_SECTION))
{
dwarf_aranges_offset = sectp->filepos;
dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp);
}
else if (STREQ (sectp->name, LOC_SECTION))
{
dwarf_loc_offset = sectp->filepos;
dwarf_loc_size = bfd_get_section_size_before_reloc (sectp);
}
else if (STREQ (sectp->name, MACINFO_SECTION))
{
dwarf_macinfo_offset = sectp->filepos;
dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp);
}
else if (STREQ (sectp->name, STR_SECTION))
{
dwarf_str_offset = sectp->filepos;
dwarf_str_size = bfd_get_section_size_before_reloc (sectp);
}
}
/* Build a partial symbol table. */
void
dwarf2_build_psymtabs (objfile, section_offsets, mainline)
struct objfile *objfile;
struct section_offsets *section_offsets;
int mainline;
{
/* We definitely need the .debug_info and .debug_abbrev sections */
dwarf_info_buffer = dwarf2_read_section (objfile,
dwarf_info_offset,
dwarf_info_size);
dwarf_abbrev_buffer = dwarf2_read_section (objfile,
dwarf_abbrev_offset,
dwarf_abbrev_size);
dwarf_line_buffer = dwarf2_read_section (objfile,
dwarf_line_offset,
dwarf_line_size);
if (mainline || objfile->global_psymbols.size == 0 ||
objfile->static_psymbols.size == 0)
{
init_psymbol_list (objfile, 1024);
}
#if 0
if (dwarf_aranges_offset && dwarf_pubnames_offset)
{
/* Things are significanlty easier if we have .debug_aranges and
.debug_pubnames sections */
dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline);
}
else
#endif
/* only test this case for now */
{
/* In this case we have to work a bit harder */
dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline);
}
}
#if 0
/* Build the partial symbol table from the information in the
.debug_pubnames and .debug_aranges sections. */
static void
dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline)
struct objfile *objfile;
struct section_offsets *section_offsets;
int mainline;
{
bfd *abfd = objfile->obfd;
char *aranges_buffer, *pubnames_buffer;
char *aranges_ptr, *pubnames_ptr;
unsigned int entry_length, version, info_offset, info_size;
pubnames_buffer = dwarf2_read_section (objfile,
dwarf_pubnames_offset,
dwarf_pubnames_size);
pubnames_ptr = pubnames_buffer;
while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size)
{
entry_length = read_4_bytes (abfd, pubnames_ptr);
pubnames_ptr += 4;
version = read_1_byte (abfd, pubnames_ptr);
pubnames_ptr += 1;
info_offset = read_4_bytes (abfd, pubnames_ptr);
pubnames_ptr += 4;
info_size = read_4_bytes (abfd, pubnames_ptr);
pubnames_ptr += 4;
}
aranges_buffer = dwarf2_read_section (objfile,
dwarf_aranges_offset,
dwarf_aranges_size);
}
#endif
/* Build the partial symbol table by doing a quick pass through the
.debug_info and .debug_abbrev sections. */
static void
dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline)
struct objfile *objfile;
struct section_offsets *section_offsets;
int mainline;
{
/* Instead of reading this into a big buffer, we should probably use
mmap() on architectures that support it. (FIXME) */
bfd *abfd = objfile->obfd;
char *info_ptr, *abbrev_ptr;
char *beg_of_comp_unit;
struct comp_unit_head cu_header;
struct partial_die_info comp_unit_die;
struct partial_symtab *pst;
struct cleanup *back_to;
int comp_unit_has_pc_info;
CORE_ADDR lowpc, highpc;
info_ptr = dwarf_info_buffer;
abbrev_ptr = dwarf_abbrev_buffer;
obstack_init (&dwarf2_tmp_obstack);
back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
while ((unsigned int) (info_ptr - dwarf_info_buffer)
+ ((info_ptr - dwarf_info_buffer) % 4) < dwarf_info_size)
{
beg_of_comp_unit = info_ptr;
cu_header.length = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
cu_header.version = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
cu_header.addr_size = read_1_byte (abfd, info_ptr);
info_ptr += 1;
address_size = cu_header.addr_size;
if (cu_header.version != 2)
{
error ("Dwarf Error: wrong version in compilation unit header.");
return;
}
/* Read the abbrevs for this compilation unit into a table */
dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
make_cleanup (dwarf2_empty_abbrev_table, NULL);
/* Read the compilation unit die */
info_ptr = read_partial_die (&comp_unit_die, abfd,
info_ptr, &comp_unit_has_pc_info);
/* Set the language we're debugging */
set_cu_language (comp_unit_die.language);
/* Allocate a new partial symbol table structure */
pst = start_psymtab_common (objfile, section_offsets,
comp_unit_die.name,
comp_unit_die.lowpc,
objfile->global_psymbols.next,
objfile->static_psymbols.next);
pst->read_symtab_private = (char *)
obstack_alloc (&objfile->psymbol_obstack, sizeof (struct dwarf2_pinfo));
DWARF_INFO_BUFFER(pst) = dwarf_info_buffer;
DWARF_INFO_OFFSET(pst) = beg_of_comp_unit - dwarf_info_buffer;
DWARF_ABBREV_BUFFER(pst) = dwarf_abbrev_buffer;
DWARF_ABBREV_SIZE(pst) = dwarf_abbrev_size;
DWARF_LINE_BUFFER(pst) = dwarf_line_buffer;
baseaddr = ANOFFSET (section_offsets, 0);
/* Store the function that reads in the rest of the symbol table */
pst->read_symtab = dwarf2_psymtab_to_symtab;
/* Read the rest of the partial symbols from this comp unit */
info_ptr = scan_partial_symbols (info_ptr, objfile, &lowpc, &highpc);
/* If the compilation unit didn't have an explicit address range,
then use the information extracted from its child dies. */
if (!comp_unit_has_pc_info)
{
comp_unit_die.lowpc = lowpc;
comp_unit_die.highpc = highpc;
}
pst->textlow = comp_unit_die.lowpc + baseaddr;
pst->texthigh = comp_unit_die.highpc + baseaddr;
pst->n_global_syms = objfile->global_psymbols.next -
(objfile->global_psymbols.list + pst->globals_offset);
pst->n_static_syms = objfile->static_psymbols.next -
(objfile->static_psymbols.list + pst->statics_offset);
sort_pst_symbols (pst);
/* If there is already a psymtab or symtab for a file of this
name, remove it. (If there is a symtab, more drastic things
also happen.) This happens in VxWorks. */
free_named_symtabs (pst->filename);
info_ptr = beg_of_comp_unit + cu_header.length + 4;
}
do_cleanups (back_to);
}
/* Read in all interesting dies to the end of the compilation unit. */
static char *
scan_partial_symbols (info_ptr, objfile, lowpc, highpc)
char *info_ptr;
struct objfile *objfile;
CORE_ADDR *lowpc;
CORE_ADDR *highpc;
{
bfd *abfd = objfile->obfd;
struct partial_die_info pdi;
int nesting_level = 1; /* we've already read in comp_unit_die */
int has_pc_info;
*lowpc = ((CORE_ADDR) -1);
*highpc = ((CORE_ADDR) 0);
do
{
info_ptr = read_partial_die (&pdi, abfd, info_ptr, &has_pc_info);
switch (pdi.tag)
{
case DW_TAG_subprogram:
case DW_TAG_variable:
case DW_TAG_typedef:
case DW_TAG_class_type:
case DW_TAG_structure_type:
case DW_TAG_union_type:
case DW_TAG_enumeration_type:
if (pdi.is_external || nesting_level == 1)
{
if (pdi.name && !pdi.is_declaration)
{
add_partial_symbol (&pdi, objfile);
}
}
if (has_pc_info)
{
if (pdi.lowpc < *lowpc)
{
*lowpc = pdi.lowpc;
}
if (pdi.highpc > *highpc)
{
*highpc = pdi.highpc;
}
}
break;
case DW_TAG_enumerator:
/* File scope enumerators are added to the partial symbol table. */
if (pdi.name && nesting_level == 2)
add_partial_symbol (&pdi, objfile);
break;
}
if (pdi.has_children)
{
nesting_level++;
}
if (pdi.tag == 0)
{
nesting_level--;
}
}
while (nesting_level);
/* If we didn't find a lowpc, set it to highpc to avoid complaints
from `maint check. */
if (*lowpc == ((CORE_ADDR) -1))
*lowpc = *highpc;
return info_ptr;
}
static void
add_partial_symbol (pdi, objfile)
struct partial_die_info *pdi;
struct objfile *objfile;
{
switch (pdi->tag)
{
case DW_TAG_subprogram:
if (pdi->is_external)
{
prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
mst_text, objfile);
add_psymbol_to_list (pdi->name, strlen (pdi->name),
VAR_NAMESPACE, LOC_BLOCK,
&objfile->global_psymbols,
0, pdi->lowpc + baseaddr, cu_language, objfile);
}
else
{
prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
mst_file_text, objfile);
add_psymbol_to_list (pdi->name, strlen (pdi->name),
VAR_NAMESPACE, LOC_BLOCK,
&objfile->static_psymbols,
0, pdi->lowpc + baseaddr, cu_language, objfile);
}
break;
case DW_TAG_variable:
/* Skip symbols without location desciptors, these are external
references. */
if (pdi->locdesc == NULL)
return;
if (pdi->is_external)
{
prim_record_minimal_symbol (pdi->name,
decode_locdesc (pdi->locdesc, objfile)
+ baseaddr,
mst_data, objfile);
add_psymbol_to_list (pdi->name, strlen (pdi->name),
VAR_NAMESPACE, LOC_STATIC,
&objfile->global_psymbols,
0, (CORE_ADDR) 0, cu_language, objfile);
}
else
{
prim_record_minimal_symbol (pdi->name,
decode_locdesc (pdi->locdesc, objfile)
+ baseaddr,
mst_file_data, objfile);
add_psymbol_to_list (pdi->name, strlen (pdi->name),
VAR_NAMESPACE, LOC_STATIC,
&objfile->static_psymbols,
0, (CORE_ADDR) 0, cu_language, objfile);
}
break;
case DW_TAG_typedef:
add_psymbol_to_list (pdi->name, strlen (pdi->name),
VAR_NAMESPACE, LOC_TYPEDEF,
&objfile->static_psymbols,
0, (CORE_ADDR) 0, cu_language, objfile);
break;
case DW_TAG_class_type:
case DW_TAG_structure_type:
case DW_TAG_union_type:
case DW_TAG_enumeration_type:
/* Skip aggregate types without children, these are external
references. */
if (pdi->has_children == 0)
return;
add_psymbol_to_list (pdi->name, strlen (pdi->name),
STRUCT_NAMESPACE, LOC_TYPEDEF,
&objfile->static_psymbols,
0, (CORE_ADDR) 0, cu_language, objfile);
if (cu_language == language_cplus)
{
/* For C++, these implicitly act as typedefs as well. */
add_psymbol_to_list (pdi->name, strlen (pdi->name),
VAR_NAMESPACE, LOC_TYPEDEF,
&objfile->static_psymbols,
0, (CORE_ADDR) 0, cu_language, objfile);
}
break;
case DW_TAG_enumerator:
add_psymbol_to_list (pdi->name, strlen (pdi->name),
VAR_NAMESPACE, LOC_CONST,
&objfile->static_psymbols,
0, (CORE_ADDR) 0, cu_language, objfile);
break;
}
}
/* Expand this partial symbol table into a full symbol table. */
static void
dwarf2_psymtab_to_symtab (pst)
struct partial_symtab *pst;
{
/* FIXME: This is barely more than a stub. */
if (pst != NULL)
{
if (pst->readin)
{
warning ("bug: psymtab for %s is already read in.", pst->filename);
}
else
{
if (info_verbose)
{
printf_filtered ("Reading in symbols for %s...", pst->filename);
gdb_flush (gdb_stdout);
}
psymtab_to_symtab_1 (pst);
/* Finish up the debug error message. */
if (info_verbose)
printf_filtered ("done.\n");
}
}
}
static void
psymtab_to_symtab_1 (pst)
struct partial_symtab *pst;
{
struct objfile *objfile = pst->objfile;
bfd *abfd = objfile->obfd;
struct comp_unit_head cu_header;
struct die_info *dies;
struct attribute *attr;
unsigned long offset;
CORE_ADDR highpc;
struct attribute *high_pc_attr;
struct die_info *child_die;
char *info_ptr;
struct symtab *symtab;
struct cleanup *back_to;
/* Set local variables from the partial symbol table info. */
offset = DWARF_INFO_OFFSET(pst);
dwarf_info_buffer = DWARF_INFO_BUFFER(pst);
dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER(pst);
dwarf_abbrev_size = DWARF_ABBREV_SIZE(pst);
dwarf_line_buffer = DWARF_LINE_BUFFER(pst);
baseaddr = ANOFFSET (pst->section_offsets, 0);
cu_header_offset = offset;
info_ptr = dwarf_info_buffer + offset;
obstack_init (&dwarf2_tmp_obstack);
back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
buildsym_init ();
make_cleanup (really_free_pendings, NULL);
/* read in the comp_unit header */
cu_header.length = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
cu_header.version = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
cu_header.addr_size = read_1_byte (abfd, info_ptr);
info_ptr += 1;
/* Read the abbrevs for this compilation unit */
dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
make_cleanup (dwarf2_empty_abbrev_table, NULL);
dies = read_comp_unit (info_ptr, abfd);
make_cleanup (free_die_list, dies);
/* Do line number decoding in read_file_scope () */
process_die (dies, objfile);
attr = dwarf_attr (dies, DW_AT_high_pc);
if (attr)
{
highpc = DW_ADDR (attr);
}
else
{
/* Some compilers don't define a DW_AT_high_pc attribute for
the compilation unit. If the DW_AT_high_pc is missing,
synthesize it, by scanning the DIE's below the compilation unit. */
highpc = 0;
if (dies->has_children)
{
child_die = dies->next;
while (child_die && child_die->tag)
{
if (child_die->tag == DW_TAG_subprogram)
{
high_pc_attr = dwarf_attr (child_die, DW_AT_high_pc);
if (high_pc_attr)
{
highpc = max (highpc, DW_ADDR (high_pc_attr));
}
}
child_die = sibling_die (child_die);
}
}
}
symtab = end_symtab (highpc + baseaddr, objfile, 0);
/* Set symtab language to language from DW_AT_language.
If the compilation is from a C file generated by language preprocessors,
do not set the language if it was already deduced by start_subfile. */
if (symtab != NULL
&& !(cu_language == language_c && symtab->language != language_c))
{
symtab->language = cu_language;
}
pst->symtab = symtab;
pst->readin = 1;
sort_symtab_syms (pst->symtab);
do_cleanups (back_to);
}
/* Process a die and its children. */
static void
process_die (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
switch (die->tag)
{
case DW_TAG_padding:
break;
case DW_TAG_compile_unit:
read_file_scope (die, objfile);
break;
case DW_TAG_subprogram:
read_subroutine_type (die, objfile);
if (dwarf_attr (die, DW_AT_low_pc))
{
read_func_scope (die, objfile);
}
break;
case DW_TAG_lexical_block:
read_lexical_block_scope (die, objfile);
break;
case DW_TAG_class_type:
case DW_TAG_structure_type:
case DW_TAG_union_type:
read_structure_scope (die, objfile);
break;
case DW_TAG_enumeration_type:
read_enumeration (die, objfile);
break;
case DW_TAG_subroutine_type:
read_subroutine_type (die, objfile);
break;
case DW_TAG_array_type:
dwarf_read_array_type (die, objfile);
break;
case DW_TAG_pointer_type:
read_tag_pointer_type (die, objfile);
break;
case DW_TAG_ptr_to_member_type:
read_tag_ptr_to_member_type (die, objfile);
break;
case DW_TAG_reference_type:
read_tag_reference_type (die, objfile);
break;
case DW_TAG_string_type:
read_tag_string_type (die, objfile);
break;
case DW_TAG_base_type:
read_base_type (die, objfile);
break;
case DW_TAG_common_block:
read_common_block (die, objfile);
break;
case DW_TAG_common_inclusion:
break;
default:
new_symbol (die, NULL, objfile);
break;
}
}
static void
read_file_scope (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
unsigned int line_offset = 0;
CORE_ADDR lowpc = ((CORE_ADDR) -1);
CORE_ADDR highpc = ((CORE_ADDR) 0);
struct attribute *attr, *low_pc_attr, *high_pc_attr;
char *name = "<unknown>";
char *comp_dir = NULL;
struct die_info *child_die;
bfd *abfd = objfile->obfd;
low_pc_attr = dwarf_attr (die, DW_AT_low_pc);
if (low_pc_attr)
{
lowpc = DW_ADDR (low_pc_attr);
}
high_pc_attr = dwarf_attr (die, DW_AT_high_pc);
if (high_pc_attr)
{
highpc = DW_ADDR (high_pc_attr);
}
if (!low_pc_attr || !high_pc_attr)
{
if (die->has_children)
{
child_die = die->next;
while (child_die && child_die->tag)
{
if (child_die->tag == DW_TAG_subprogram)
{
low_pc_attr = dwarf_attr (child_die, DW_AT_low_pc);
if (low_pc_attr)
{
lowpc = min (lowpc, DW_ADDR (low_pc_attr));
}
high_pc_attr = dwarf_attr (child_die, DW_AT_high_pc);
if (high_pc_attr)
{
highpc = max (highpc, DW_ADDR (high_pc_attr));
}
}
child_die = sibling_die (child_die);
}
}
}
/* If we didn't find a lowpc, set it to highpc to avoid complaints
from finish_block. */
if (lowpc == ((CORE_ADDR) -1))
lowpc = highpc;
lowpc += baseaddr;
highpc += baseaddr;
attr = dwarf_attr (die, DW_AT_name);
if (attr)
{
name = DW_STRING (attr);
}
attr = dwarf_attr (die, DW_AT_comp_dir);
if (attr)
{
comp_dir = DW_STRING (attr);
if (comp_dir)
{
/* Irix 6.2 native cc prepends <machine>.: to the compilation
directory, get rid of it. */
char *cp = strchr (comp_dir, ':');
if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
comp_dir = cp + 1;
}
}
if (objfile->ei.entry_point >= lowpc &&
objfile->ei.entry_point < highpc)
{
objfile->ei.entry_file_lowpc = lowpc;
objfile->ei.entry_file_highpc = highpc;
}
attr = dwarf_attr (die, DW_AT_language);
if (attr)
{
set_cu_language (DW_UNSND (attr));
}
#if 0
/* FIXME:Do something here. */
if (dip->at_producer != NULL)
{
handle_producer (dip->at_producer);
}
#endif
/* The compilation unit may be in a different language or objfile,
zero out all remembered fundamental types. */
memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
start_symtab (name, comp_dir, lowpc);
/* Decode line number information if present. */
attr = dwarf_attr (die, DW_AT_stmt_list);
if (attr)
{
line_offset = DW_UNSND (attr);
dwarf_decode_lines (line_offset, comp_dir, abfd);
}
/* Process all dies in compilation unit. */
if (die->has_children)
{
child_die = die->next;
while (child_die && child_die->tag)
{
process_die (child_die, objfile);
child_die = sibling_die (child_die);
}
}
}
static void
read_func_scope (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
register struct context_stack *new;
CORE_ADDR lowpc = 0;
CORE_ADDR highpc = 0;
struct die_info *child_die;
struct attribute *attr;
char *name = "<unknown>";
attr = dwarf_attr (die, DW_AT_name);
if (attr)
{
name = DW_STRING (attr);
}
attr = dwarf_attr (die, DW_AT_low_pc);
if (attr)
{
lowpc = DW_ADDR (attr);
}
attr = dwarf_attr (die, DW_AT_high_pc);
if (attr)
{
highpc = DW_ADDR (attr);
}
lowpc += baseaddr;
highpc += baseaddr;
if (objfile->ei.entry_point >= lowpc &&
objfile->ei.entry_point < highpc)
{
objfile->ei.entry_func_lowpc = lowpc;
objfile->ei.entry_func_highpc = highpc;
}
if (STREQ (name, "main")) /* FIXME: hardwired name */
{
objfile->ei.main_func_lowpc = lowpc;
objfile->ei.main_func_highpc = highpc;
}
/* Decode DW_AT_frame_base location descriptor if present, keep result
for DW_OP_fbreg operands in decode_locdesc. */
frame_base_reg = -1;
frame_base_offset = 0;
attr = dwarf_attr (die, DW_AT_frame_base);
if (attr)
{
CORE_ADDR addr = decode_locdesc (DW_BLOCK (attr), objfile);
if (isreg)
frame_base_reg = addr;
else if (offreg)
{
frame_base_reg = basereg;
frame_base_offset = addr;
}
else
complain (&dwarf2_unsupported_at_frame_base, name);
}
new = push_context (0, lowpc);
new->name = new_symbol (die, die->type, objfile);
list_in_scope = &local_symbols;
if (die->has_children)
{
child_die = die->next;
while (child_die && child_die->tag)
{
process_die (child_die, objfile);
child_die = sibling_die (child_die);
}
}
new = pop_context ();
/* Make a block for the local symbols within. */
finish_block (new->name, &local_symbols, new->old_blocks,
lowpc, highpc, objfile);
list_in_scope = &file_symbols;
}
/* Process all the DIES contained within a lexical block scope. Start
a new scope, process the dies, and then close the scope. */
static void
read_lexical_block_scope (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
register struct context_stack *new;
CORE_ADDR lowpc = 0, highpc = 0;
struct attribute *attr;
struct die_info *child_die;
attr = dwarf_attr (die, DW_AT_low_pc);
if (attr)
{
lowpc = DW_ADDR (attr);
}
attr = dwarf_attr (die, DW_AT_high_pc);
if (attr)
{
highpc = DW_ADDR (attr);
}
lowpc += baseaddr;
highpc += baseaddr;
push_context (0, lowpc);
if (die->has_children)
{
child_die = die->next;
while (child_die && child_die->tag)
{
process_die (child_die, objfile);
child_die = sibling_die (child_die);
}
}
new = pop_context ();
if (local_symbols != NULL)
{
finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
highpc, objfile);
}
local_symbols = new->locals;
}
/* Called when we find the DIE that starts a structure or union scope
(definition) to process all dies that define the members of the
structure or union.
NOTE: we need to call struct_type regardless of whether or not the
DIE has an at_name attribute, since it might be an anonymous
structure or union. This gets the type entered into our set of
user defined types.
However, if the structure is incomplete (an opaque struct/union)
then suppress creating a symbol table entry for it since gdb only
wants to find the one with the complete definition. Note that if
it is complete, we just call new_symbol, which does it's own
checking about whether the struct/union is anonymous or not (and
suppresses creating a symbol table entry itself). */
static void
read_structure_scope (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type;
struct field *fields;
struct die_info *child_die;
struct attribute *attr;
struct symbol *sym;
int num_fields;
type = alloc_type (objfile);
INIT_CPLUS_SPECIFIC (type);
attr = dwarf_attr (die, DW_AT_name);
if (attr)
{
TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
strlen (DW_STRING (attr)),
&objfile->type_obstack);
}
if (die->tag == DW_TAG_structure_type)
{
TYPE_CODE (type) = TYPE_CODE_STRUCT;
}
else if (die->tag == DW_TAG_union_type)
{
TYPE_CODE (type) = TYPE_CODE_UNION;
}
else
{
/* FIXME: This should be changed to TYPE_CODE_CLASS when the rest
of GDB knows how to handle it. */
TYPE_CODE (type) = TYPE_CODE_STRUCT;
}
attr = dwarf_attr (die, DW_AT_byte_size);
if (attr)
{
TYPE_LENGTH (type) = DW_UNSND (attr);
}
else
{
TYPE_LENGTH (type) = 0;
}
/* We need to add the type field to the die immediately so we don't
infinitely recurse when dealing with pointers to the structure
type within the structure itself. */
die->type = type;
num_fields = 0;
fields = NULL;
if (die->has_children)
{
child_die = die->next;
while (child_die && child_die->tag)
{
if (child_die->tag == DW_TAG_member)
{
if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
{
fields = (struct field *)
xrealloc (fields,
(num_fields + DW_FIELD_ALLOC_CHUNK)
* sizeof (struct field));
}
/* Get bit offset of field */
attr = dwarf_attr (child_die, DW_AT_bit_offset);
if (attr)
{
fields[num_fields].bitpos = DW_UNSND (attr);
}
else
{
fields[num_fields].bitpos = 0;
}
attr = dwarf_attr (child_die, DW_AT_data_member_location);
if (attr)
{
fields[num_fields].bitpos +=
decode_locdesc (DW_BLOCK (attr), objfile) * bits_per_byte;
}
/* Get bit size of field (zero if none). */
attr = dwarf_attr (child_die, DW_AT_bit_size);
if (attr)
{
fields[num_fields].bitsize = DW_UNSND (attr);
}
else
{
fields[num_fields].bitsize = 0;
}
/* Get type of member. */
fields[num_fields].type = die_type (child_die, objfile);
/* Get name of member. */
attr = dwarf_attr (child_die, DW_AT_name);
if (attr)
{
fields[num_fields].name =
obsavestring (DW_STRING (attr),
strlen (DW_STRING (attr)),
&objfile->type_obstack);
}
num_fields++;
}
else if (child_die->tag == DW_TAG_variable)
{
char *physname = NULL;
char *fieldname = NULL;
/* C++ static member.
Get physical name, extract field name from physical name. */
attr = dwarf_attr (child_die, DW_AT_name);
if (attr)
{
char *cp;
physname = DW_STRING (attr);
cp = physname;
while (*cp && !is_cplus_marker (*cp))
cp++;
if (*cp)
fieldname = cp + 1;
}
if (physname && fieldname)
{
if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
{
fields = (struct field *)
xrealloc (fields,
(num_fields + DW_FIELD_ALLOC_CHUNK)
* sizeof (struct field));
}
fields[num_fields].bitpos = -1;
fields[num_fields].bitsize = (long)
obsavestring (physname, strlen (physname),
&objfile->type_obstack);
fields[num_fields].type = die_type (child_die, objfile);
fields[num_fields].name =
obsavestring (fieldname, strlen (fieldname),
&objfile->type_obstack);
num_fields++;
}
else
{
complain (&dwarf2_bad_static_member_name,
physname ? physname : "<NULL>");
}
}
else if (child_die->tag == DW_TAG_subprogram)
{
/* FIXME: C++ member function. */
process_die (child_die, objfile);
}
else if (child_die->tag == DW_TAG_inheritance)
{
/* FIXME: C++ inheritance information. */
}
else
{
process_die (child_die, objfile);
}
child_die = sibling_die (child_die);
}
if (num_fields)
{
TYPE_NFIELDS (type) = num_fields;
TYPE_FIELDS (type) = (struct field *)
TYPE_ALLOC (type, sizeof (struct field) * num_fields);
memcpy (TYPE_FIELDS (type), fields,
sizeof (struct field) * num_fields);
free (fields);
}
sym = new_symbol (die, type, objfile);
}
else
{
/* No children, must be stub. */
TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
}
die->type = type;
}
/* Given a pointer to a die which begins an enumeration, process all
the dies that define the members of the enumeration.
This will be much nicer in draft 6 of the DWARF spec when our
members will be dies instead squished into the DW_AT_element_list
attribute.
NOTE: We reverse the order of the element list. */
static void
read_enumeration (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct die_info *child_die;
struct type *type;
struct field *fields;
struct attribute *attr;
struct symbol *sym;
int num_fields;
int unsigned_enum = 1;
type = alloc_type (objfile);
TYPE_CODE (type) = TYPE_CODE_ENUM;
attr = dwarf_attr (die, DW_AT_name);
if (attr)
{
TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
strlen (DW_STRING (attr)),
&objfile->type_obstack);
}
attr = dwarf_attr (die, DW_AT_byte_size);
if (attr)
{
TYPE_LENGTH (type) = DW_UNSND (attr);
}
else
{
TYPE_LENGTH (type) = 0;
}
num_fields = 0;
fields = NULL;
if (die->has_children)
{
child_die = die->next;
while (child_die && child_die->tag)
{
if (child_die->tag != DW_TAG_enumerator)
{
process_die (child_die, objfile);
}
else
{
attr = dwarf_attr (child_die, DW_AT_name);
if (attr)
{
sym = new_symbol (child_die, type, objfile);
if (SYMBOL_VALUE (sym) < 0)
unsigned_enum = 0;
if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
{
fields = (struct field *)
xrealloc (fields,
(num_fields + DW_FIELD_ALLOC_CHUNK)
* sizeof (struct field));
}
fields[num_fields].name = SYMBOL_NAME (sym);
fields[num_fields].type = NULL;
fields[num_fields].bitpos = SYMBOL_VALUE (sym);
fields[num_fields].bitsize = 0;
num_fields++;
}
}
child_die = sibling_die (child_die);
}
if (num_fields)
{
TYPE_NFIELDS (type) = num_fields;
TYPE_FIELDS (type) = (struct field *)
TYPE_ALLOC (type, sizeof (struct field) * num_fields);
memcpy (TYPE_FIELDS (type), fields,
sizeof (struct field) * num_fields);
free (fields);
}
if (unsigned_enum)
TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
}
die->type = type;
sym = new_symbol (die, type, objfile);
}
/* Extract all information from a DW_TAG_array_type DIE and put it in
the DIE's type field. For now, this only handles one dimensional
arrays. */
static void
dwarf_read_array_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct die_info *child_die;
struct type *type = NULL;
struct type *element_type, *range_type, *index_type;
struct attribute *attr;
unsigned int low, high;
/* Return if we've already decoded this type. */
if (die->type)
{
return;
}
element_type = die_type (die, objfile);
/* Irix 6.2 native cc creates array types without children for
variable length arrays. */
if (die->has_children == 0)
{
index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
range_type = create_range_type (NULL, index_type, 0, -1);
die->type = create_array_type (NULL, element_type, range_type);
return;
}
low = 0;
high = 1;
if (cu_language == DW_LANG_Fortran77 || cu_language == DW_LANG_Fortran90)
{
/* FORTRAN implies a lower bound of 1, if not given. */
low = 1;
}
child_die = die->next;
while (child_die && child_die->tag)
{
if (child_die->tag == DW_TAG_subrange_type)
{
index_type = die_type (child_die, objfile);
attr = dwarf_attr (child_die, DW_AT_lower_bound);
if (attr)
{
if (attr->form == DW_FORM_sdata)
{
low = DW_SND (attr);
}
else if (attr->form == DW_FORM_udata
|| attr->form == DW_FORM_data1
|| attr->form == DW_FORM_data2
|| attr->form == DW_FORM_data4)
{
low = DW_UNSND (attr);
}
else
{
complain (&dwarf2_non_const_array_bound_ignored,
dwarf_form_name (attr->form));
#ifdef FORTRAN_HACK
die->type = lookup_pointer_type (element_type);
return;
#else
low = 0;
#endif
}
}
attr = dwarf_attr (child_die, DW_AT_upper_bound);
if (attr)
{
if (attr->form == DW_FORM_sdata)
{
high = DW_SND (attr);
}
else if (attr->form == DW_FORM_udata
|| attr->form == DW_FORM_data1
|| attr->form == DW_FORM_data2
|| attr->form == DW_FORM_data4)
{
high = DW_UNSND (attr);
}
else if (attr->form == DW_FORM_block1)
{
/* GCC encodes arrays with unspecified or dynamic length
with a DW_FORM_block1 attribute.
FIXME: GDB does not yet know how to handle dynamic
arrays properly, treat them as arrays with unspecified
length for now. */
high = -1;
}
else
{
complain (&dwarf2_non_const_array_bound_ignored,
dwarf_form_name (attr->form));
#ifdef FORTRAN_HACK
die->type = lookup_pointer_type (element_type);
return;
#else
high = 1;
#endif
}
}
range_type = create_range_type (NULL, index_type, low, high);
type = create_array_type (NULL, element_type, range_type);
element_type = type;
}
child_die = sibling_die (child_die);
}
/* Install the type in the die. */
die->type = type;
}
/* First cut: install each common block member as a global variable. */
static void
read_common_block (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct die_info *child_die;
struct attribute *attr;
struct symbol *sym;
CORE_ADDR base = (CORE_ADDR) 0;
attr = dwarf_attr (die, DW_AT_location);
if (attr)
{
base = decode_locdesc (DW_BLOCK (attr), objfile);
}
if (die->has_children)
{
child_die = die->next;
while (child_die && child_die->tag)
{
sym = new_symbol (child_die, NULL, objfile);
attr = dwarf_attr (child_die, DW_AT_data_member_location);
if (attr)
{
SYMBOL_VALUE_ADDRESS (sym) =
base + decode_locdesc (DW_BLOCK (attr), objfile);
add_symbol_to_list (sym, &global_symbols);
}
child_die = sibling_die (child_die);
}
}
}
/* Extract all information from a DW_TAG_pointer_type DIE and add to
the user defined type vector. */
static void
read_tag_pointer_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type;
struct attribute *attr;
if (die->type)
{
return;
}
type = lookup_pointer_type (die_type (die, objfile));
attr = dwarf_attr (die, DW_AT_byte_size);
if (attr)
{
TYPE_LENGTH (type) = DW_UNSND (attr);
}
else
{
TYPE_LENGTH (type) = address_size;
}
die->type = type;
}
/* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
the user defined type vector. */
static void
read_tag_ptr_to_member_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type;
struct type *to_type;
struct type *domain;
if (die->type)
{
return;
}
type = alloc_type (objfile);
to_type = die_type (die, objfile);
domain = die_containing_type (die, objfile);
smash_to_member_type (type, domain, to_type);
die->type = type;
}
/* Extract all information from a DW_TAG_reference_type DIE and add to
the user defined type vector. */
static void
read_tag_reference_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type;
struct attribute *attr;
if (die->type)
{
return;
}
type = lookup_reference_type (die_type (die, objfile));
attr = dwarf_attr (die, DW_AT_byte_size);
if (attr)
{
TYPE_LENGTH (type) = DW_UNSND (attr);
}
else
{
TYPE_LENGTH (type) = address_size;
}
die->type = type;
}
static void
read_tag_const_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
if (die->type)
{
return;
}
complain (&dwarf2_const_ignored);
die->type = die_type (die, objfile);
}
static void
read_tag_volatile_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
if (die->type)
{
return;
}
complain (&dwarf2_volatile_ignored);
die->type = die_type (die, objfile);
}
/* Extract all information from a DW_TAG_string_type DIE and add to
the user defined type vector. It isn't really a user defined type,
but it behaves like one, with other DIE's using an AT_user_def_type
attribute to reference it. */
static void
read_tag_string_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type, *range_type, *index_type, *char_type;
struct attribute *attr;
unsigned int length;
if (die->type)
{
return;
}
attr = dwarf_attr (die, DW_AT_string_length);
if (attr)
{
length = DW_UNSND (attr);
}
else
{
length = 1;
}
index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
range_type = create_range_type (NULL, index_type, 1, length);
char_type = dwarf2_fundamental_type (objfile, FT_CHAR);
type = create_string_type (char_type, range_type);
die->type = type;
}
/* Handle DIES due to C code like:
struct foo
{
int (*funcp)(int a, long l);
int b;
};
('funcp' generates a DW_TAG_subroutine_type DIE)
*/
static void
read_subroutine_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type; /* Type that this function returns */
struct type *ftype; /* Function that returns above type */
/* Decode the type that this subroutine returns */
if (die->type)
{
return;
}
type = die_type (die, objfile);
ftype = lookup_function_type (type);
if (die->has_children)
{
struct die_info *child_die;
int nparams = 0;
int iparams = 0;
/* Count the number of parameters.
FIXME: GDB currently has no way to deal with ellipsis,
represented by DW_TAG_unspecified_parameters. */
child_die = die->next;
while (child_die && child_die->tag)
{
if (child_die->tag == DW_TAG_formal_parameter)
nparams++;
child_die = sibling_die (child_die);
}
/* Allocate storage for parameters and fill them in. */
TYPE_NFIELDS (ftype) = nparams;
TYPE_FIELDS (ftype) = (struct field *)
TYPE_ALLOC (ftype, nparams * sizeof (struct field));
child_die = die->next;
while (child_die && child_die->tag)
{
if (child_die->tag == DW_TAG_formal_parameter)
{
TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, objfile);
iparams++;
}
child_die = sibling_die (child_die);
}
}
die->type = ftype;
}
static void
read_typedef (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type;
if (!die->type)
{
struct attribute *attr;
struct type *xtype;
xtype = die_type (die, objfile);
type = alloc_type (objfile);
TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB;
TYPE_TARGET_TYPE (type) = xtype;
attr = dwarf_attr (die, DW_AT_name);
if (attr)
TYPE_NAME (type) = obsavestring (DW_STRING (attr),
strlen (DW_STRING (attr)),
&objfile->type_obstack);
die->type = type;
}
}
/* Find a representation of a given base type and install
it in the TYPE field of the die. */
static void
read_base_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type;
struct attribute *attr;
int encoding = 0, size = 0;
/* If we've already decoded this die, this is a no-op. */
if (die->type)
{
return;
}
attr = dwarf_attr (die, DW_AT_encoding);
if (attr)
{
encoding = DW_UNSND (attr);
}
attr = dwarf_attr (die, DW_AT_byte_size);
if (attr)
{
size = DW_UNSND (attr);
}
attr = dwarf_attr (die, DW_AT_name);
if (attr)
{
enum type_code code = TYPE_CODE_INT;
int is_unsigned = 0;
switch (encoding)
{
case DW_ATE_address:
/* Turn DW_ATE_address into a void * pointer. */
code = TYPE_CODE_PTR;
is_unsigned = 1;
break;
case DW_ATE_boolean:
code = TYPE_CODE_BOOL;
break;
case DW_ATE_complex_float:
code = TYPE_CODE_COMPLEX;
break;
case DW_ATE_float:
code = TYPE_CODE_FLT;
break;
case DW_ATE_signed:
case DW_ATE_signed_char:
break;
case DW_ATE_unsigned:
case DW_ATE_unsigned_char:
is_unsigned = 1;
break;
default:
complain (&dwarf2_unsupported_at_encoding,
dwarf_type_encoding_name (encoding));
break;
}
type = init_type (code, size, is_unsigned, DW_STRING (attr), objfile);
if (encoding == DW_ATE_address)
TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID);
}
else
{
type = dwarf_base_type (encoding, size);
}
die->type = type;
}
/* Read a whole compilation unit into a linked list of dies. */
struct die_info *
read_comp_unit (info_ptr, abfd)
char *info_ptr;
bfd *abfd;
{
struct die_info *first_die, *last_die, *die;
char *cur_ptr;
int nesting_level;
/* Reset die reference table, we are building a new one now. */
dwarf2_empty_die_ref_table ();
cur_ptr = info_ptr;
nesting_level = 0;
first_die = last_die = NULL;
do
{
cur_ptr = read_full_die (&die, abfd, cur_ptr);
if (die->has_children)
{
nesting_level++;
}
if (die->tag == 0)
{
nesting_level--;
}
die->next = NULL;
/* Enter die in reference hash table */
store_in_ref_table (die->offset, die);
if (!first_die)
{
first_die = last_die = die;
}
else
{
last_die->next = die;
last_die = die;
}
}
while (nesting_level > 0);
return first_die;
}
/* Free a linked list of dies. */
static void
free_die_list (dies)
struct die_info *dies;
{
struct die_info *die, *next;
die = dies;
while (die)
{
next = die->next;
free (die->attrs);
free (die);
die = next;
}
}
/* Read the contents of the section at OFFSET and of size SIZE from the
object file specified by OBJFILE into the psymbol_obstack and return it. */
static char *
dwarf2_read_section (objfile, offset, size)
struct objfile *objfile;
file_ptr offset;
unsigned int size;
{
bfd *abfd = objfile->obfd;
char *buf;
if (size == 0)
return NULL;
buf = (char *) obstack_alloc (&objfile->psymbol_obstack, size);
if ((bfd_seek (abfd, offset, SEEK_SET) != 0) ||
(bfd_read (buf, size, 1, abfd) != size))
{
buf = NULL;
error ("Dwarf Error: Can't read DWARF data from '%s'",
bfd_get_filename (abfd));
}
return buf;
}
/* In DWARF version 2, the description of the debugging information is
stored in a separate .debug_abbrev section. Before we read any
dies from a section we read in all abbreviations and install them
in a hash table. */
static void
dwarf2_read_abbrevs (abfd, offset)
bfd * abfd;
unsigned int offset;
{
char *abbrev_ptr;
struct abbrev_info *cur_abbrev;
unsigned int abbrev_number, bytes_read, abbrev_name;
unsigned int abbrev_form, hash_number;
/* empty the table */
dwarf2_empty_abbrev_table (NULL);
abbrev_ptr = dwarf_abbrev_buffer + offset;
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
/* loop until we reach an abbrev number of 0 */
while (abbrev_number)
{
cur_abbrev = dwarf_alloc_abbrev ();
/* read in abbrev header */
cur_abbrev->number = abbrev_number;
cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
abbrev_ptr += 1;
/* now read in declarations */
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
while (abbrev_name)
{
if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
{
cur_abbrev->attrs = (struct attr_abbrev *)
xrealloc (cur_abbrev->attrs,
(cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
* sizeof (struct attr_abbrev));
}
cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
}
hash_number = abbrev_number % ABBREV_HASH_SIZE;
cur_abbrev->next = dwarf2_abbrevs[hash_number];
dwarf2_abbrevs[hash_number] = cur_abbrev;
/* Get next abbreviation.
Under Irix6 the abbreviations for a compilation unit are not
always properly terminated with an abbrev number of 0.
Exit loop if we encounter an abbreviation which we have
already read (which means we are about to read the abbreviations
for the next compile unit) or if the end of the abbreviation
table is reached. */
if ((unsigned int) (abbrev_ptr - dwarf_abbrev_buffer)
>= dwarf_abbrev_size)
break;
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
if (dwarf2_lookup_abbrev (abbrev_number) != NULL)
break;
}
}
/* Empty the abbrev table for a new compilation unit. */
/* ARGSUSED */
static void
dwarf2_empty_abbrev_table (ignore)
PTR ignore;
{
int i;
struct abbrev_info *abbrev, *next;
for (i = 0; i < ABBREV_HASH_SIZE; ++i)
{
next = NULL;
abbrev = dwarf2_abbrevs[i];
while (abbrev)
{
next = abbrev->next;
free (abbrev->attrs);
free (abbrev);
abbrev = next;
}
dwarf2_abbrevs[i] = NULL;
}
}
/* Lookup an abbrev_info structure in the abbrev hash table. */
static struct abbrev_info *
dwarf2_lookup_abbrev (number)
unsigned int number;
{
unsigned int hash_number;
struct abbrev_info *abbrev;
hash_number = number % ABBREV_HASH_SIZE;
abbrev = dwarf2_abbrevs[hash_number];
while (abbrev)
{
if (abbrev->number == number)
return abbrev;
else
abbrev = abbrev->next;
}
return NULL;
}
/* Read a minimal amount of information into the minimal die structure. */
static char *
read_partial_die (part_die, abfd, info_ptr, has_pc_info)
struct partial_die_info *part_die;
bfd * abfd;
char *info_ptr;
int *has_pc_info;
{
unsigned int abbrev_number, bytes_read, i;
struct abbrev_info *abbrev;
char ebuf[256];
int has_low_pc_attr = 0;
int has_high_pc_attr = 0;
*part_die = zeroed_partial_die;
*has_pc_info = 0;
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
if (!abbrev_number)
return info_ptr;
abbrev = dwarf2_lookup_abbrev (abbrev_number);
if (!abbrev)
{
error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number);
}
part_die->offset = info_ptr - dwarf_info_buffer;
part_die->tag = abbrev->tag;
part_die->has_children = abbrev->has_children;
part_die->abbrev = abbrev_number;
{
char *str = "";
struct dwarf_block *blk = 0;
CORE_ADDR addr = ((CORE_ADDR) -1);
unsigned int unsnd = ((unsigned int) -1);
int snd = -1;
for (i = 0; i < abbrev->num_attrs; ++i)
{
/* read the correct type of data */
switch (abbrev->attrs[i].form)
{
case DW_FORM_addr:
addr = read_address (abfd, info_ptr);
info_ptr += address_size;
break;
case DW_FORM_ref_addr:
addr = read_address (abfd, info_ptr);
info_ptr += address_size;
break;
case DW_FORM_block2:
blk = dwarf_alloc_block ();
blk->size = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
break;
case DW_FORM_block4:
blk = dwarf_alloc_block ();
blk->size = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
break;
case DW_FORM_data2:
unsnd = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
break;
case DW_FORM_data4:
unsnd = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
break;
case DW_FORM_data8:
unsnd = read_8_bytes (abfd, info_ptr);
info_ptr += 8;
break;
case DW_FORM_string:
str = read_string (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_block:
blk = dwarf_alloc_block ();
blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
break;
case DW_FORM_block1:
blk = dwarf_alloc_block ();
blk->size = read_1_byte (abfd, info_ptr);
info_ptr += 1;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
break;
case DW_FORM_data1:
unsnd = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_ref1:
unsnd = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_ref2:
unsnd = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
break;
case DW_FORM_ref4:
unsnd = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
break;
case DW_FORM_ref_udata:
unsnd = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_flag:
unsnd = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_sdata:
snd = read_signed_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_udata:
unsnd = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_indirect:
default:
sprintf (ebuf,
"Dwarf Error: Cannot handle %s in DWARF reader.",
dwarf_form_name (abbrev->attrs[i].form));
error (ebuf);
}
/* store the data if it is of an attribute we want to keep in a
partial symbol table */
switch (abbrev->attrs[i].name)
{
case DW_AT_name:
part_die->name = str;
break;
case DW_AT_low_pc:
has_low_pc_attr = 1;
part_die->lowpc = addr;
break;
case DW_AT_high_pc:
has_high_pc_attr = 1;
part_die->highpc = addr;
break;
case DW_AT_location:
part_die->locdesc = blk;
break;
case DW_AT_language:
part_die->language = unsnd;
break;
case DW_AT_external:
part_die->is_external = unsnd;
break;
case DW_AT_declaration:
part_die->is_declaration = unsnd;
break;
}
}
}
*has_pc_info = has_low_pc_attr && has_high_pc_attr;
return info_ptr;
}
/* Read the die from the .debug_info section buffer. And set diep to
point to a newly allocated die with its information. */
static char *
read_full_die (diep, abfd, info_ptr)
struct die_info **diep;
bfd *abfd;
char *info_ptr;
{
unsigned int abbrev_number, bytes_read, i, offset;
struct abbrev_info *abbrev;
struct die_info *die;
char ebuf[256];
offset = info_ptr - dwarf_info_buffer;
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
if (!abbrev_number)
{
die = dwarf_alloc_die ();
die->tag = 0;
die->abbrev = abbrev_number;
die->type = NULL;
*diep = die;
return info_ptr;
}
abbrev = dwarf2_lookup_abbrev (abbrev_number);
if (!abbrev)
{
error ("Dwarf Error: could not find abbrev number %d.", abbrev_number);
}
die = dwarf_alloc_die ();
die->offset = offset;
die->tag = abbrev->tag;
die->has_children = abbrev->has_children;
die->abbrev = abbrev_number;
die->type = NULL;
die->num_attrs = abbrev->num_attrs;
die->attrs = (struct attribute *)
xmalloc (die->num_attrs * sizeof (struct attribute));
{
struct dwarf_block *blk;
for (i = 0; i < abbrev->num_attrs; ++i)
{
/* read the correct type of data */
die->attrs[i].name = abbrev->attrs[i].name;
die->attrs[i].form = abbrev->attrs[i].form;
switch (abbrev->attrs[i].form)
{
case DW_FORM_addr:
case DW_FORM_ref_addr:
die->attrs[i].u.addr = read_address (abfd, info_ptr);
info_ptr += address_size;
break;
case DW_FORM_block2:
blk = dwarf_alloc_block ();
blk->size = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
die->attrs[i].u.blk = blk;
break;
case DW_FORM_block4:
blk = dwarf_alloc_block ();
blk->size = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
die->attrs[i].u.blk = blk;
break;
case DW_FORM_data2:
die->attrs[i].u.unsnd = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
break;
case DW_FORM_data4:
die->attrs[i].u.unsnd = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
break;
case DW_FORM_data8:
die->attrs[i].u.unsnd = read_8_bytes (abfd, info_ptr);
info_ptr += 8;
break;
case DW_FORM_string:
die->attrs[i].u.str = read_string (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_block:
blk = dwarf_alloc_block ();
blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
die->attrs[i].u.blk = blk;
break;
case DW_FORM_block1:
blk = dwarf_alloc_block ();
blk->size = read_1_byte (abfd, info_ptr);
info_ptr += 1;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
die->attrs[i].u.blk = blk;
break;
case DW_FORM_data1:
die->attrs[i].u.unsnd = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_ref1:
die->attrs[i].u.unsnd = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_ref2:
die->attrs[i].u.unsnd = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
break;
case DW_FORM_ref4:
die->attrs[i].u.unsnd = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
break;
case DW_FORM_ref_udata:
die->attrs[i].u.unsnd = read_unsigned_leb128 (abfd,
info_ptr,
&bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_flag:
die->attrs[i].u.unsnd = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_sdata:
die->attrs[i].u.snd = read_signed_leb128 (abfd,
info_ptr,
&bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_udata:
die->attrs[i].u.unsnd = read_unsigned_leb128 (abfd,
info_ptr,
&bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_indirect:
default:
sprintf (ebuf,
"Dwarf Error: Cannot handle %s in DWARF reader.",
dwarf_form_name (abbrev->attrs[i].form));
error (ebuf);
}
}
}
*diep = die;
return info_ptr;
}
/* read dwarf information from a buffer */
static unsigned int
read_1_byte (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_8 (abfd, (bfd_byte *) buf);
}
static int
read_1_signed_byte (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
}
static unsigned int
read_2_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_16 (abfd, (bfd_byte *) buf);
}
static int
read_2_signed_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
}
static unsigned int
read_4_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_32 (abfd, (bfd_byte *) buf);
}
static int
read_4_signed_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
}
static unsigned int
read_8_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_64 (abfd, (bfd_byte *) buf);
}
static CORE_ADDR
read_address (abfd, buf)
bfd *abfd;
char *buf;
{
CORE_ADDR retval = 0;
if (address_size == 4)
{
retval = bfd_get_32 (abfd, (bfd_byte *) buf);
} else { /* *THE* alternative is 8, right? */
retval = bfd_get_64 (abfd, (bfd_byte *) buf);
}
return retval;
}
static char *
read_n_bytes (abfd, buf, size)
bfd * abfd;
char *buf;
unsigned int size;
{
/* If the size of a host char is 8 bits, we can return a pointer
to the buffer, otherwise we have to copy the data to a buffer
allocated on the temporary obstack. */
#if HOST_CHAR_BIT == 8
return buf;
#else
char *ret;
unsigned int i;
ret = obstack_alloc (&dwarf2_tmp_obstack, size);
for (i = 0; i < size; ++i)
{
ret[i] = bfd_get_8 (abfd, (bfd_byte *) buf);
buf++;
}
return ret;
#endif
}
static char *
read_string (abfd, buf, bytes_read_ptr)
bfd *abfd;
char *buf;
unsigned int *bytes_read_ptr;
{
/* If the size of a host char is 8 bits, we can return a pointer
to the string, otherwise we have to copy the string to a buffer
allocated on the temporary obstack. */
#if HOST_CHAR_BIT == 8
if (*buf == '\0')
{
*bytes_read_ptr = 1;
return NULL;
}
*bytes_read_ptr = strlen (buf) + 1;
return buf;
#else
int byte;
unsigned int i = 0;
while ((byte = bfd_get_8 (abfd, (bfd_byte *) buf)) != 0)
{
obstack_1grow (&dwarf2_tmp_obstack, byte);
i++;
buf++;
}
if (i == 0)
{
*bytes_read_ptr = 1;
return NULL;
}
obstack_1grow (&dwarf2_tmp_obstack, '\0');
*bytes_read_ptr = i + 1;
return obstack_finish (&dwarf2_tmp_obstack);
#endif
}
static unsigned int
read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
bfd *abfd;
char *buf;
unsigned int *bytes_read_ptr;
{
unsigned int result, num_read;
int i, shift;
unsigned char byte;
result = 0;
shift = 0;
num_read = 0;
i = 0;
while (1)
{
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
buf++;
num_read++;
result |= ((byte & 127) << shift);
if ((byte & 128) == 0)
{
break;
}
shift += 7;
}
*bytes_read_ptr = num_read;
return result;
}
static int
read_signed_leb128 (abfd, buf, bytes_read_ptr)
bfd *abfd;
char *buf;
unsigned int *bytes_read_ptr;
{
int result;
int i, shift, size, num_read;
unsigned char byte;
result = 0;
shift = 0;
size = 32;
num_read = 0;
i = 0;
while (1)
{
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
buf++;
num_read++;
result |= ((byte & 127) << shift);
shift += 7;
if ((byte & 128) == 0)
{
break;
}
}
if ((shift < size) && (byte & 0x40))
{
result |= -(1 << shift);
}
*bytes_read_ptr = num_read;
return result;
}
static void
set_cu_language (lang)
unsigned int lang;
{
switch (lang)
{
case DW_LANG_C89:
case DW_LANG_C:
case DW_LANG_Fortran77:
cu_language = language_c;
break;
case DW_LANG_C_plus_plus:
cu_language = language_cplus;
break;
case DW_LANG_Mips_Assembler:
cu_language = language_asm;
break;
case DW_LANG_Ada83:
case DW_LANG_Cobol74:
case DW_LANG_Cobol85:
#if 0
case DW_LANG_Fortran77: /* moved up top for now */
#endif
case DW_LANG_Fortran90:
case DW_LANG_Pascal83:
case DW_LANG_Modula2:
default:
cu_language = language_unknown;
break;
}
cu_language_defn = language_def (cu_language);
}
/* Return the named attribute or NULL if not there. */
static struct attribute *
dwarf_attr (die, name)
struct die_info *die;
unsigned int name;
{
unsigned int i;
struct attribute *spec = NULL;
for (i = 0; i < die->num_attrs; ++i)
{
if (die->attrs[i].name == name)
{
return &die->attrs[i];
}
if (die->attrs[i].name == DW_AT_specification
|| die->attrs[i].name == DW_AT_abstract_origin)
spec = &die->attrs[i];
}
if (spec)
{
struct die_info *ref_die =
follow_die_ref (dwarf2_get_ref_die_offset (spec));
if (ref_die)
return dwarf_attr (ref_die, name);
}
return NULL;
}
/* Decode the line number information for the compilation unit whose
line number info is at OFFSET in the .debug_line section.
The compilation directory of the file is passed in COMP_DIR. */
struct filenames
{
unsigned int num_files;
struct fileinfo
{
char *name;
unsigned int dir;
unsigned int time;
unsigned int size;
}
*files;
};
struct directories
{
unsigned int num_dirs;
char **dirs;
};
static void
dwarf_decode_lines (offset, comp_dir, abfd)
unsigned int offset;
char *comp_dir;
bfd *abfd;
{
char *line_ptr;
char *line_end;
struct line_head lh;
struct cleanup *back_to;
unsigned int i, bytes_read;
char *cur_file, *cur_dir;
unsigned char op_code, extended_op, adj_opcode;
#define FILE_ALLOC_CHUNK 5
#define DIR_ALLOC_CHUNK 5
struct filenames files;
struct directories dirs;
if (dwarf_line_buffer == NULL)
{
complain (&dwarf2_missing_line_number_section);
return;
}
files.num_files = 0;
files.files = NULL;
dirs.num_dirs = 0;
dirs.dirs = NULL;
line_ptr = dwarf_line_buffer + offset;
/* read in the prologue */
lh.total_length = read_4_bytes (abfd, line_ptr);
line_ptr += 4;
line_end = line_ptr + lh.total_length;
lh.version = read_2_bytes (abfd, line_ptr);
line_ptr += 2;
lh.prologue_length = read_4_bytes (abfd, line_ptr);
line_ptr += 4;
lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh.default_is_stmt = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh.line_base = read_1_signed_byte (abfd, line_ptr);
line_ptr += 1;
lh.line_range = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh.opcode_base = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh.standard_opcode_lengths = (unsigned char *)
xmalloc (lh.opcode_base * sizeof (unsigned char));
back_to = make_cleanup (free_current_contents, &lh.standard_opcode_lengths);
lh.standard_opcode_lengths[0] = 1;
for (i = 1; i < lh.opcode_base; ++i)
{
lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
line_ptr += 1;
}
/* Read directory table */
while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
{
line_ptr += bytes_read;
if ((dirs.num_dirs % DIR_ALLOC_CHUNK) == 0)
{
dirs.dirs = (char **)
xrealloc (dirs.dirs,
(dirs.num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *));
if (dirs.num_dirs == 0)
make_cleanup (free_current_contents, &dirs.dirs);
}
dirs.dirs[dirs.num_dirs++] = cur_dir;
}
line_ptr += bytes_read;
/* Read file name table */
while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
{
line_ptr += bytes_read;
if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
{
files.files = (struct fileinfo *)
xrealloc (files.files,
(files.num_files + FILE_ALLOC_CHUNK)
* sizeof (struct fileinfo));
if (files.num_files == 0)
make_cleanup (free_current_contents, &files.files);
}
files.files[files.num_files].name = cur_file;
files.files[files.num_files].dir =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
files.files[files.num_files].time =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
files.files[files.num_files].size =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
files.num_files++;
}
line_ptr += bytes_read;
/* Read the statement sequences until there's nothing left. */
while (line_ptr < line_end)
{
/* state machine registers */
unsigned int address = 0;
unsigned int file = 1;
unsigned int line = 1;
unsigned int column = 0;
int is_stmt = lh.default_is_stmt;
int basic_block = 0;
int end_sequence = 0;
/* Start a subfile for the current file of the state machine. */
if (files.num_files >= file)
{
/* The file and directory tables are 0 based, the references
are 1 based. */
dwarf2_start_subfile (files.files[file - 1].name,
(files.files[file - 1].dir
? dirs.dirs[files.files[file - 1].dir - 1]
: comp_dir));
}
/* Decode the table. */
while (! end_sequence)
{
op_code = read_1_byte (abfd, line_ptr);
line_ptr += 1;
switch (op_code)
{
case DW_LNS_extended_op:
line_ptr += 1; /* ignore length */
extended_op = read_1_byte (abfd, line_ptr);
line_ptr += 1;
switch (extended_op)
{
case DW_LNE_end_sequence:
end_sequence = 1;
record_line (current_subfile, line, address);
break;
case DW_LNE_set_address:
address = read_address (abfd, line_ptr) + baseaddr;
line_ptr += address_size;
break;
case DW_LNE_define_file:
cur_file = read_string (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
{
files.files = (struct fileinfo *)
xrealloc (files.files,
(files.num_files + FILE_ALLOC_CHUNK)
* sizeof (struct fileinfo));
if (files.num_files == 0)
make_cleanup (free_current_contents, &files.files);
}
files.files[files.num_files].name = cur_file;
files.files[files.num_files].dir =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
files.files[files.num_files].time =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
files.files[files.num_files].size =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
files.num_files++;
break;
default:
complain (&dwarf2_mangled_line_number_section);
goto done;
}
break;
case DW_LNS_copy:
record_line (current_subfile, line, address);
basic_block = 0;
break;
case DW_LNS_advance_pc:
address += lh.minimum_instruction_length
* read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
break;
case DW_LNS_advance_line:
line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
break;
case DW_LNS_set_file:
/* The file and directory tables are 0 based, the references
are 1 based. */
file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
dwarf2_start_subfile
(files.files[file - 1].name,
(files.files[file - 1].dir
? dirs.dirs[files.files[file - 1].dir - 1]
: comp_dir));
break;
case DW_LNS_set_column:
column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
break;
case DW_LNS_negate_stmt:
is_stmt = (!is_stmt);
break;
case DW_LNS_set_basic_block:
basic_block = 1;
break;
case DW_LNS_const_add_pc:
address += (255 - lh.opcode_base) / lh.line_range;
break;
case DW_LNS_fixed_advance_pc:
address += read_2_bytes (abfd, line_ptr);
line_ptr += 2;
break;
default: /* special operand */
adj_opcode = op_code - lh.opcode_base;
address += (adj_opcode / lh.line_range)
* lh.minimum_instruction_length;
line += lh.line_base + (adj_opcode % lh.line_range);
/* append row to matrix using current values */
record_line (current_subfile, line, address);
basic_block = 1;
}
}
}
done:
do_cleanups (back_to);
}
/* Start a subfile for DWARF. FILENAME is the name of the file and
DIRNAME the name of the source directory which contains FILENAME
or NULL if not known.
This routine tries to keep line numbers from identical absolute and
relative file names in a common subfile.
Using the `list' example from the GDB testsuite, which resides in
/srcdir and compiling it with Irix6.2 cc in /compdir using a filename
of /srcdir/list0.c yields the following debugging information for list0.c:
DW_AT_name: /srcdir/list0.c
DW_AT_comp_dir: /compdir
files.files[0].name: list0.h
files.files[0].dir: /srcdir
files.files[1].name: list0.c
files.files[1].dir: /srcdir
The line number information for list0.c has to end up in a single
subfile, so that `break /srcdir/list0.c:1' works as expected. */
static void
dwarf2_start_subfile (filename, dirname)
char *filename;
char *dirname;
{
/* If the filename isn't absolute, try to match an existing subfile
with the full pathname. */
if (*filename != '/' && dirname != NULL)
{
struct subfile *subfile;
char *fullname = concat (dirname, "/", filename, NULL);
for (subfile = subfiles; subfile; subfile = subfile->next)
{
if (STREQ (subfile->name, fullname))
{
current_subfile = subfile;
free (fullname);
return;
}
}
free (fullname);
}
start_subfile (filename, dirname);
}
/* Given a pointer to a DWARF information entry, figure out if we need
to make a symbol table entry for it, and if so, create a new entry
and return a pointer to it.
If TYPE is NULL, determine symbol type from the die, otherwise
used the passed type.
*/
static struct symbol *
new_symbol (die, type, objfile)
struct die_info *die;
struct type *type;
struct objfile *objfile;
{
struct symbol *sym = NULL;
struct attribute *attr = NULL;
struct attribute *attr2 = NULL;
CORE_ADDR addr;
attr = dwarf_attr (die, DW_AT_name);
if (attr)
{
sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
sizeof (struct symbol));
OBJSTAT (objfile, n_syms++);
memset (sym, 0, sizeof (struct symbol));
SYMBOL_NAME (sym) = obsavestring (DW_STRING (attr),
strlen (DW_STRING (attr)),
&objfile->symbol_obstack);
/* Default assumptions.
Use the passed type or decode it from the die. */
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
SYMBOL_CLASS (sym) = LOC_STATIC;
if (type != NULL)
SYMBOL_TYPE (sym) = type;
else
SYMBOL_TYPE (sym) = die_type (die, objfile);
attr = dwarf_attr (die, DW_AT_decl_line);
if (attr)
{
SYMBOL_LINE (sym) = DW_UNSND (attr);
}
/* If this symbol is from a C++ compilation, then attempt to
cache the demangled form for future reference. This is a
typical time versus space tradeoff, that was decided in favor
of time because it sped up C++ symbol lookups by a factor of
about 20. */
SYMBOL_LANGUAGE (sym) = cu_language;
SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
switch (die->tag)
{
case DW_TAG_label:
attr = dwarf_attr (die, DW_AT_low_pc);
if (attr)
{
SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr);
}
SYMBOL_CLASS (sym) = LOC_LABEL;
break;
case DW_TAG_subprogram:
attr = dwarf_attr (die, DW_AT_low_pc);
if (attr)
{
SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr);
}
SYMBOL_CLASS (sym) = LOC_BLOCK;
attr2 = dwarf_attr (die, DW_AT_external);
if (attr2 && (DW_UNSND (attr2) != 0))
{
add_symbol_to_list (sym, &global_symbols);
}
else
{
add_symbol_to_list (sym, list_in_scope);
}
break;
case DW_TAG_variable:
/* Compilation with minimal debug info may result in variables
with missing type entries. Change the misleading `void' type
to something sensible. */
if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
TARGET_INT_BIT / HOST_CHAR_BIT, 0,
"<variable, no debug info>",
objfile);
attr = dwarf_attr (die, DW_AT_location);
if (attr)
{
attr2 = dwarf_attr (die, DW_AT_external);
if (attr2 && (DW_UNSND (attr2) != 0))
{
SYMBOL_VALUE_ADDRESS (sym) =
decode_locdesc (DW_BLOCK (attr), objfile);
add_symbol_to_list (sym, &global_symbols);
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) += baseaddr;
}
else
{
SYMBOL_VALUE (sym) = addr =
decode_locdesc (DW_BLOCK (attr), objfile);
add_symbol_to_list (sym, list_in_scope);
if (optimized_out)
{
SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
}
else if (isreg)
{
SYMBOL_CLASS (sym) = LOC_REGISTER;
}
else if (offreg)
{
SYMBOL_CLASS (sym) = LOC_BASEREG;
SYMBOL_BASEREG (sym) = basereg;
}
else if (islocal)
{
SYMBOL_CLASS (sym) = LOC_LOCAL;
}
else
{
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = addr + baseaddr;
}
}
}
else
{
/* We do not know the address of this symbol.
If it is an external symbol and we have type information
it, enter the symbol as a LOC_UNRESOLVED symbol.
The address of the variable will then be determined from
the minimal symbol table whenever the variable is
referenced. */
attr2 = dwarf_attr (die, DW_AT_external);
if (attr2 && (DW_UNSND (attr2) != 0)
&& dwarf_attr (die, DW_AT_type) != NULL)
{
SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
add_symbol_to_list (sym, &global_symbols);
}
}
break;
case DW_TAG_formal_parameter:
attr = dwarf_attr (die, DW_AT_location);
if (attr != NULL)
{
SYMBOL_VALUE (sym) = decode_locdesc (DW_BLOCK (attr), objfile);
}
add_symbol_to_list (sym, list_in_scope);
if (isreg)
{
SYMBOL_CLASS (sym) = LOC_REGPARM;
}
else if (offreg)
{
SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
SYMBOL_BASEREG (sym) = basereg;
}
else
{
SYMBOL_CLASS (sym) = LOC_ARG;
}
break;
case DW_TAG_unspecified_parameters:
/* From varargs functions; gdb doesn't seem to have any
interest in this information, so just ignore it for now.
(FIXME?) */
break;
case DW_TAG_class_type:
case DW_TAG_structure_type:
case DW_TAG_union_type:
case DW_TAG_enumeration_type:
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
add_symbol_to_list (sym, list_in_scope);
/* The semantics of C++ state that "struct foo { ... }" also
defines a typedef for "foo". Synthesize a typedef symbol so
that "ptype foo" works as expected. */
if (cu_language == language_cplus)
{
struct symbol *typedef_sym = (struct symbol *)
obstack_alloc (&objfile->symbol_obstack,
sizeof (struct symbol));
*typedef_sym = *sym;
SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym)) =
obsavestring (SYMBOL_NAME (sym),
strlen (SYMBOL_NAME (sym)),
&objfile->type_obstack);
add_symbol_to_list (typedef_sym, list_in_scope);
}
break;
case DW_TAG_typedef:
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, list_in_scope);
break;
case DW_TAG_enumerator:
SYMBOL_CLASS (sym) = LOC_CONST;
attr = dwarf_attr (die, DW_AT_const_value);
if (attr)
{
SYMBOL_VALUE (sym) = DW_UNSND (attr);
}
add_symbol_to_list (sym, list_in_scope);
break;
default:
/* Not a tag we recognize. Hopefully we aren't processing
trash data, but since we must specifically ignore things
we don't recognize, there is nothing else we should do at
this point. */
complain (&dwarf2_unsupported_tag, dwarf_tag_name (die->tag));
break;
}
}
return (sym);
}
/* Return the type of the die in question using its DW_AT_type attribute. */
static struct type *
die_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type;
struct attribute *type_attr;
struct die_info *type_die;
unsigned int ref;
type_attr = dwarf_attr (die, DW_AT_type);
if (!type_attr)
{
/* A missing DW_AT_type represents a void type. */
return dwarf2_fundamental_type (objfile, FT_VOID);
}
else
{
ref = dwarf2_get_ref_die_offset (type_attr);
type_die = follow_die_ref (ref);
if (!type_die)
{
error ("Dwarf Error: Cannot find referent at offset %d.", ref);
return NULL;
}
}
type = tag_type_to_type (type_die, objfile);
if (!type)
{
dump_die (type_die);
error ("Dwarf Error: Problem turning type die at offset into gdb type.");
}
return type;
}
/* Return the containing type of the die in question using its
DW_AT_containing_type attribute. */
static struct type *
die_containing_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
struct type *type = NULL;
struct attribute *type_attr;
struct die_info *type_die = NULL;
unsigned int ref;
type_attr = dwarf_attr (die, DW_AT_containing_type);
if (type_attr)
{
ref = dwarf2_get_ref_die_offset (type_attr);
type_die = follow_die_ref (ref);
if (!type_die)
{
error ("Dwarf Error: Cannot find referent at offset %d.", ref);
return NULL;
}
type = tag_type_to_type (type_die, objfile);
}
if (!type)
{
if (type_die)
dump_die (type_die);
error ("Dwarf Error: Problem turning containing type into gdb type.");
}
return type;
}
#if 0
static struct type *
type_at_offset (offset, objfile)
unsigned int offset;
struct objfile *objfile;
{
struct die_info *die;
struct type *type;
die = follow_die_ref (offset);
if (!die)
{
error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
return NULL;
}
type = tag_type_to_type (die, objfile);
return type;
}
#endif
static struct type *
tag_type_to_type (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
if (die->type)
{
return die->type;
}
else
{
read_type_die (die, objfile);
if (!die->type)
{
dump_die (die);
error ("Dwarf Error: Cannot find type of die.");
}
return die->type;
}
}
static void
read_type_die (die, objfile)
struct die_info *die;
struct objfile *objfile;
{
switch (die->tag)
{
case DW_TAG_class_type:
case DW_TAG_structure_type:
case DW_TAG_union_type:
read_structure_scope (die, objfile);
break;
case DW_TAG_enumeration_type:
read_enumeration (die, objfile);
break;
case DW_TAG_subprogram:
case DW_TAG_subroutine_type:
read_subroutine_type (die, objfile);
break;
case DW_TAG_array_type:
dwarf_read_array_type (die, objfile);
break;
case DW_TAG_pointer_type:
read_tag_pointer_type (die, objfile);
break;
case DW_TAG_ptr_to_member_type:
read_tag_ptr_to_member_type (die, objfile);
break;
case DW_TAG_reference_type:
read_tag_reference_type (die, objfile);
break;
case DW_TAG_const_type:
read_tag_const_type (die, objfile);
break;
case DW_TAG_volatile_type:
read_tag_volatile_type (die, objfile);
break;
case DW_TAG_string_type:
read_tag_string_type (die, objfile);
break;
case DW_TAG_typedef:
read_typedef (die, objfile);
break;
case DW_TAG_base_type:
read_base_type (die, objfile);
break;
case DW_TAG_padding:
case DW_TAG_compile_unit:
case DW_TAG_lexical_block:
default:
break;
}
}
static struct type *
dwarf_base_type (encoding, size)
int encoding;
int size;
{
/* FIXME - this should not produce a new (struct type *)
every time. It should cache base types. */
struct type *type;
switch (encoding)
{
case DW_ATE_address:
type = dwarf2_fundamental_type (current_objfile, FT_VOID);
return type;
case DW_ATE_boolean:
type = dwarf2_fundamental_type (current_objfile, FT_BOOLEAN);
return type;
case DW_ATE_complex_float:
if (size == 16)
{
type = dwarf2_fundamental_type (current_objfile, FT_DBL_PREC_COMPLEX);
}
else
{
type = dwarf2_fundamental_type (current_objfile, FT_COMPLEX);
}
return type;
case DW_ATE_float:
if (size == 8)
{
type = dwarf2_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
}
else
{
type = dwarf2_fundamental_type (current_objfile, FT_FLOAT);
}
return type;
case DW_ATE_signed:
switch (size)
{
case 1:
type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_CHAR);
break;
case 2:
type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_SHORT);
break;
default:
case 4:
type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_INTEGER);
break;
}
return type;
case DW_ATE_signed_char:
type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_CHAR);
return type;
case DW_ATE_unsigned:
switch (size)
{
case 1:
type = dwarf2_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
break;
case 2:
type = dwarf2_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
break;
default:
case 4:
type = dwarf2_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
break;
}
return type;
case DW_ATE_unsigned_char:
type = dwarf2_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
return type;
default:
type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_INTEGER);
return type;
}
}
#if 0
struct die_info *
copy_die (old_die)
struct die_info *old_die;
{
struct die_info *new_die;
int i, num_attrs;
new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
memset (new_die, 0, sizeof (struct die_info));
new_die->tag = old_die->tag;
new_die->has_children = old_die->has_children;
new_die->abbrev = old_die->abbrev;
new_die->offset = old_die->offset;
new_die->type = NULL;
num_attrs = old_die->num_attrs;
new_die->num_attrs = num_attrs;
new_die->attrs = (struct attribute *)
xmalloc (num_attrs * sizeof (struct attribute));
for (i = 0; i < old_die->num_attrs; ++i)
{
new_die->attrs[i].name = old_die->attrs[i].name;
new_die->attrs[i].form = old_die->attrs[i].form;
new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
}
new_die->next = NULL;
return new_die;
}
#endif
/* Return sibling of die, NULL if no sibling. */
struct die_info *
sibling_die (die)
struct die_info *die;
{
int nesting_level = 0;
if (!die->has_children)
{
if (die->next && (die->next->tag == 0))
{
return NULL;
}
else
{
return die->next;
}
}
else
{
do
{
if (die->has_children)
{
nesting_level++;
}
if (die->tag == 0)
{
nesting_level--;
}
die = die->next;
}
while (nesting_level);
if (die && (die->tag == 0))
{
return NULL;
}
else
{
return die;
}
}
}
/* Convert a DIE tag into its string name. */
static char *
dwarf_tag_name (tag)
register unsigned tag;
{
switch (tag)
{
case DW_TAG_padding:
return "DW_TAG_padding";
case DW_TAG_array_type:
return "DW_TAG_array_type";
case DW_TAG_class_type:
return "DW_TAG_class_type";
case DW_TAG_entry_point:
return "DW_TAG_entry_point";
case DW_TAG_enumeration_type:
return "DW_TAG_enumeration_type";
case DW_TAG_formal_parameter:
return "DW_TAG_formal_parameter";
case DW_TAG_imported_declaration:
return "DW_TAG_imported_declaration";
case DW_TAG_label:
return "DW_TAG_label";
case DW_TAG_lexical_block:
return "DW_TAG_lexical_block";
case DW_TAG_member:
return "DW_TAG_member";
case DW_TAG_pointer_type:
return "DW_TAG_pointer_type";
case DW_TAG_reference_type:
return "DW_TAG_reference_type";
case DW_TAG_compile_unit:
return "DW_TAG_compile_unit";
case DW_TAG_string_type:
return "DW_TAG_string_type";
case DW_TAG_structure_type:
return "DW_TAG_structure_type";
case DW_TAG_subroutine_type:
return "DW_TAG_subroutine_type";
case DW_TAG_typedef:
return "DW_TAG_typedef";
case DW_TAG_union_type:
return "DW_TAG_union_type";
case DW_TAG_unspecified_parameters:
return "DW_TAG_unspecified_parameters";
case DW_TAG_variant:
return "DW_TAG_variant";
case DW_TAG_common_block:
return "DW_TAG_common_block";
case DW_TAG_common_inclusion:
return "DW_TAG_common_inclusion";
case DW_TAG_inheritance:
return "DW_TAG_inheritance";
case DW_TAG_inlined_subroutine:
return "DW_TAG_inlined_subroutine";
case DW_TAG_module:
return "DW_TAG_module";
case DW_TAG_ptr_to_member_type:
return "DW_TAG_ptr_to_member_type";
case DW_TAG_set_type:
return "DW_TAG_set_type";
case DW_TAG_subrange_type:
return "DW_TAG_subrange_type";
case DW_TAG_with_stmt:
return "DW_TAG_with_stmt";
case DW_TAG_access_declaration:
return "DW_TAG_access_declaration";
case DW_TAG_base_type:
return "DW_TAG_base_type";
case DW_TAG_catch_block:
return "DW_TAG_catch_block";
case DW_TAG_const_type:
return "DW_TAG_const_type";
case DW_TAG_constant:
return "DW_TAG_constant";
case DW_TAG_enumerator:
return "DW_TAG_enumerator";
case DW_TAG_file_type:
return "DW_TAG_file_type";
case DW_TAG_friend:
return "DW_TAG_friend";
case DW_TAG_namelist:
return "DW_TAG_namelist";
case DW_TAG_namelist_item:
return "DW_TAG_namelist_item";
case DW_TAG_packed_type:
return "DW_TAG_packed_type";
case DW_TAG_subprogram:
return "DW_TAG_subprogram";
case DW_TAG_template_type_param:
return "DW_TAG_template_type_param";
case DW_TAG_template_value_param:
return "DW_TAG_template_value_param";
case DW_TAG_thrown_type:
return "DW_TAG_thrown_type";
case DW_TAG_try_block:
return "DW_TAG_try_block";
case DW_TAG_variant_part:
return "DW_TAG_variant_part";
case DW_TAG_variable:
return "DW_TAG_variable";
case DW_TAG_volatile_type:
return "DW_TAG_volatile_type";
case DW_TAG_MIPS_loop:
return "DW_TAG_MIPS_loop";
case DW_TAG_format_label:
return "DW_TAG_format_label";
case DW_TAG_function_template:
return "DW_TAG_function_template";
case DW_TAG_class_template:
return "DW_TAG_class_template";
default:
return "DW_TAG_<unknown>";
}
}
/* Convert a DWARF attribute code into its string name. */
static char *
dwarf_attr_name (attr)
register unsigned attr;
{
switch (attr)
{
case DW_AT_sibling:
return "DW_AT_sibling";
case DW_AT_location:
return "DW_AT_location";
case DW_AT_name:
return "DW_AT_name";
case DW_AT_ordering:
return "DW_AT_ordering";
case DW_AT_subscr_data:
return "DW_AT_subscr_data";
case DW_AT_byte_size:
return "DW_AT_byte_size";
case DW_AT_bit_offset:
return "DW_AT_bit_offset";
case DW_AT_bit_size:
return "DW_AT_bit_size";
case DW_AT_element_list:
return "DW_AT_element_list";
case DW_AT_stmt_list:
return "DW_AT_stmt_list";
case DW_AT_low_pc:
return "DW_AT_low_pc";
case DW_AT_high_pc:
return "DW_AT_high_pc";
case DW_AT_language:
return "DW_AT_language";
case DW_AT_member:
return "DW_AT_member";
case DW_AT_discr:
return "DW_AT_discr";
case DW_AT_discr_value:
return "DW_AT_discr_value";
case DW_AT_visibility:
return "DW_AT_visibility";
case DW_AT_import:
return "DW_AT_import";
case DW_AT_string_length:
return "DW_AT_string_length";
case DW_AT_common_reference:
return "DW_AT_common_reference";
case DW_AT_comp_dir:
return "DW_AT_comp_dir";
case DW_AT_const_value:
return "DW_AT_const_value";
case DW_AT_containing_type:
return "DW_AT_containing_type";
case DW_AT_default_value:
return "DW_AT_default_value";
case DW_AT_inline:
return "DW_AT_inline";
case DW_AT_is_optional:
return "DW_AT_is_optional";
case DW_AT_lower_bound:
return "DW_AT_lower_bound";
case DW_AT_producer:
return "DW_AT_producer";
case DW_AT_prototyped:
return "DW_AT_prototyped";
case DW_AT_return_addr:
return "DW_AT_return_addr";
case DW_AT_start_scope:
return "DW_AT_start_scope";
case DW_AT_stride_size:
return "DW_AT_stride_size";
case DW_AT_upper_bound:
return "DW_AT_upper_bound";
case DW_AT_abstract_origin:
return "DW_AT_abstract_origin";
case DW_AT_accessibility:
return "DW_AT_accessibility";
case DW_AT_address_class:
return "DW_AT_address_class";
case DW_AT_artificial:
return "DW_AT_artificial";
case DW_AT_base_types:
return "DW_AT_base_types";
case DW_AT_calling_convention:
return "DW_AT_calling_convention";
case DW_AT_count:
return "DW_AT_count";
case DW_AT_data_member_location:
return "DW_AT_data_member_location";
case DW_AT_decl_column:
return "DW_AT_decl_column";
case DW_AT_decl_file:
return "DW_AT_decl_file";
case DW_AT_decl_line:
return "DW_AT_decl_line";
case DW_AT_declaration:
return "DW_AT_declaration";
case DW_AT_discr_list:
return "DW_AT_discr_list";
case DW_AT_encoding:
return "DW_AT_encoding";
case DW_AT_external:
return "DW_AT_external";
case DW_AT_frame_base:
return "DW_AT_frame_base";
case DW_AT_friend:
return "DW_AT_friend";
case DW_AT_identifier_case:
return "DW_AT_identifier_case";
case DW_AT_macro_info:
return "DW_AT_macro_info";
case DW_AT_namelist_items:
return "DW_AT_namelist_items";
case DW_AT_priority:
return "DW_AT_priority";
case DW_AT_segment:
return "DW_AT_segment";
case DW_AT_specification:
return "DW_AT_specification";
case DW_AT_static_link:
return "DW_AT_static_link";
case DW_AT_type:
return "DW_AT_type";
case DW_AT_use_location:
return "DW_AT_use_location";
case DW_AT_variable_parameter:
return "DW_AT_variable_parameter";
case DW_AT_virtuality:
return "DW_AT_virtuality";
case DW_AT_vtable_elem_location:
return "DW_AT_vtable_elem_location";
#ifdef MIPS
case DW_AT_MIPS_fde:
return "DW_AT_MIPS_fde";
case DW_AT_MIPS_loop_begin:
return "DW_AT_MIPS_loop_begin";
case DW_AT_MIPS_tail_loop_begin:
return "DW_AT_MIPS_tail_loop_begin";
case DW_AT_MIPS_epilog_begin:
return "DW_AT_MIPS_epilog_begin";
case DW_AT_MIPS_loop_unroll_factor:
return "DW_AT_MIPS_loop_unroll_factor";
case DW_AT_MIPS_software_pipeline_depth:
return "DW_AT_MIPS_software_pipeline_depth";
case DW_AT_MIPS_linkage_name:
return "DW_AT_MIPS_linkage_name";
#endif
case DW_AT_sf_names:
return "DW_AT_sf_names";
case DW_AT_src_info:
return "DW_AT_src_info";
case DW_AT_mac_info:
return "DW_AT_mac_info";
case DW_AT_src_coords:
return "DW_AT_src_coords";
case DW_AT_body_begin:
return "DW_AT_body_begin";
case DW_AT_body_end:
return "DW_AT_body_end";
default:
return "DW_AT_<unknown>";
}
}
/* Convert a DWARF value form code into its string name. */
static char *
dwarf_form_name (form)
register unsigned form;
{
switch (form)
{
case DW_FORM_addr:
return "DW_FORM_addr";
case DW_FORM_block2:
return "DW_FORM_block2";
case DW_FORM_block4:
return "DW_FORM_block4";
case DW_FORM_data2:
return "DW_FORM_data2";
case DW_FORM_data4:
return "DW_FORM_data4";
case DW_FORM_data8:
return "DW_FORM_data8";
case DW_FORM_string:
return "DW_FORM_string";
case DW_FORM_block:
return "DW_FORM_block";
case DW_FORM_block1:
return "DW_FORM_block1";
case DW_FORM_data1:
return "DW_FORM_data1";
case DW_FORM_flag:
return "DW_FORM_flag";
case DW_FORM_sdata:
return "DW_FORM_sdata";
case DW_FORM_strp:
return "DW_FORM_strp";
case DW_FORM_udata:
return "DW_FORM_udata";
case DW_FORM_ref_addr:
return "DW_FORM_ref_addr";
case DW_FORM_ref1:
return "DW_FORM_ref1";
case DW_FORM_ref2:
return "DW_FORM_ref2";
case DW_FORM_ref4:
return "DW_FORM_ref4";
case DW_FORM_ref8:
return "DW_FORM_ref8";
case DW_FORM_ref_udata:
return "DW_FORM_ref_udata";
case DW_FORM_indirect:
return "DW_FORM_indirect";
default:
return "DW_FORM_<unknown>";
}
}
/* Convert a DWARF stack opcode into its string name. */
static char *
dwarf_stack_op_name (op)
register unsigned op;
{
switch (op)
{
case DW_OP_addr:
return "DW_OP_addr";
case DW_OP_deref:
return "DW_OP_deref";
case DW_OP_const1u:
return "DW_OP_const1u";
case DW_OP_const1s:
return "DW_OP_const1s";
case DW_OP_const2u:
return "DW_OP_const2u";
case DW_OP_const2s:
return "DW_OP_const2s";
case DW_OP_const4u:
return "DW_OP_const4u";
case DW_OP_const4s:
return "DW_OP_const4s";
case DW_OP_const8u:
return "DW_OP_const8u";
case DW_OP_const8s:
return "DW_OP_const8s";
case DW_OP_constu:
return "DW_OP_constu";
case DW_OP_consts:
return "DW_OP_consts";
case DW_OP_dup:
return "DW_OP_dup";
case DW_OP_drop:
return "DW_OP_drop";
case DW_OP_over:
return "DW_OP_over";
case DW_OP_pick:
return "DW_OP_pick";
case DW_OP_swap:
return "DW_OP_swap";
case DW_OP_rot:
return "DW_OP_rot";
case DW_OP_xderef:
return "DW_OP_xderef";
case DW_OP_abs:
return "DW_OP_abs";
case DW_OP_and:
return "DW_OP_and";
case DW_OP_div:
return "DW_OP_div";
case DW_OP_minus:
return "DW_OP_minus";
case DW_OP_mod:
return "DW_OP_mod";
case DW_OP_mul:
return "DW_OP_mul";
case DW_OP_neg:
return "DW_OP_neg";
case DW_OP_not:
return "DW_OP_not";
case DW_OP_or:
return "DW_OP_or";
case DW_OP_plus:
return "DW_OP_plus";
case DW_OP_plus_uconst:
return "DW_OP_plus_uconst";
case DW_OP_shl:
return "DW_OP_shl";
case DW_OP_shr:
return "DW_OP_shr";
case DW_OP_shra:
return "DW_OP_shra";
case DW_OP_xor:
return "DW_OP_xor";
case DW_OP_bra:
return "DW_OP_bra";
case DW_OP_eq:
return "DW_OP_eq";
case DW_OP_ge:
return "DW_OP_ge";
case DW_OP_gt:
return "DW_OP_gt";
case DW_OP_le:
return "DW_OP_le";
case DW_OP_lt:
return "DW_OP_lt";
case DW_OP_ne:
return "DW_OP_ne";
case DW_OP_skip:
return "DW_OP_skip";
case DW_OP_lit0:
return "DW_OP_lit0";
case DW_OP_lit1:
return "DW_OP_lit1";
case DW_OP_lit2:
return "DW_OP_lit2";
case DW_OP_lit3:
return "DW_OP_lit3";
case DW_OP_lit4:
return "DW_OP_lit4";
case DW_OP_lit5:
return "DW_OP_lit5";
case DW_OP_lit6:
return "DW_OP_lit6";
case DW_OP_lit7:
return "DW_OP_lit7";
case DW_OP_lit8:
return "DW_OP_lit8";
case DW_OP_lit9:
return "DW_OP_lit9";
case DW_OP_lit10:
return "DW_OP_lit10";
case DW_OP_lit11:
return "DW_OP_lit11";
case DW_OP_lit12:
return "DW_OP_lit12";
case DW_OP_lit13:
return "DW_OP_lit13";
case DW_OP_lit14:
return "DW_OP_lit14";
case DW_OP_lit15:
return "DW_OP_lit15";
case DW_OP_lit16:
return "DW_OP_lit16";
case DW_OP_lit17:
return "DW_OP_lit17";
case DW_OP_lit18:
return "DW_OP_lit18";
case DW_OP_lit19:
return "DW_OP_lit19";
case DW_OP_lit20:
return "DW_OP_lit20";
case DW_OP_lit21:
return "DW_OP_lit21";
case DW_OP_lit22:
return "DW_OP_lit22";
case DW_OP_lit23:
return "DW_OP_lit23";
case DW_OP_lit24:
return "DW_OP_lit24";
case DW_OP_lit25:
return "DW_OP_lit25";
case DW_OP_lit26:
return "DW_OP_lit26";
case DW_OP_lit27:
return "DW_OP_lit27";
case DW_OP_lit28:
return "DW_OP_lit28";
case DW_OP_lit29:
return "DW_OP_lit29";
case DW_OP_lit30:
return "DW_OP_lit30";
case DW_OP_lit31:
return "DW_OP_lit31";
case DW_OP_reg0:
return "DW_OP_reg0";
case DW_OP_reg1:
return "DW_OP_reg1";
case DW_OP_reg2:
return "DW_OP_reg2";
case DW_OP_reg3:
return "DW_OP_reg3";
case DW_OP_reg4:
return "DW_OP_reg4";
case DW_OP_reg5:
return "DW_OP_reg5";
case DW_OP_reg6:
return "DW_OP_reg6";
case DW_OP_reg7:
return "DW_OP_reg7";
case DW_OP_reg8:
return "DW_OP_reg8";
case DW_OP_reg9:
return "DW_OP_reg9";
case DW_OP_reg10:
return "DW_OP_reg10";
case DW_OP_reg11:
return "DW_OP_reg11";
case DW_OP_reg12:
return "DW_OP_reg12";
case DW_OP_reg13:
return "DW_OP_reg13";
case DW_OP_reg14:
return "DW_OP_reg14";
case DW_OP_reg15:
return "DW_OP_reg15";
case DW_OP_reg16:
return "DW_OP_reg16";
case DW_OP_reg17:
return "DW_OP_reg17";
case DW_OP_reg18:
return "DW_OP_reg18";
case DW_OP_reg19:
return "DW_OP_reg19";
case DW_OP_reg20:
return "DW_OP_reg20";
case DW_OP_reg21:
return "DW_OP_reg21";
case DW_OP_reg22:
return "DW_OP_reg22";
case DW_OP_reg23:
return "DW_OP_reg23";
case DW_OP_reg24:
return "DW_OP_reg24";
case DW_OP_reg25:
return "DW_OP_reg25";
case DW_OP_reg26:
return "DW_OP_reg26";
case DW_OP_reg27:
return "DW_OP_reg27";
case DW_OP_reg28:
return "DW_OP_reg28";
case DW_OP_reg29:
return "DW_OP_reg29";
case DW_OP_reg30:
return "DW_OP_reg30";
case DW_OP_reg31:
return "DW_OP_reg31";
case DW_OP_breg0:
return "DW_OP_breg0";
case DW_OP_breg1:
return "DW_OP_breg1";
case DW_OP_breg2:
return "DW_OP_breg2";
case DW_OP_breg3:
return "DW_OP_breg3";
case DW_OP_breg4:
return "DW_OP_breg4";
case DW_OP_breg5:
return "DW_OP_breg5";
case DW_OP_breg6:
return "DW_OP_breg6";
case DW_OP_breg7:
return "DW_OP_breg7";
case DW_OP_breg8:
return "DW_OP_breg8";
case DW_OP_breg9:
return "DW_OP_breg9";
case DW_OP_breg10:
return "DW_OP_breg10";
case DW_OP_breg11:
return "DW_OP_breg11";
case DW_OP_breg12:
return "DW_OP_breg12";
case DW_OP_breg13:
return "DW_OP_breg13";
case DW_OP_breg14:
return "DW_OP_breg14";
case DW_OP_breg15:
return "DW_OP_breg15";
case DW_OP_breg16:
return "DW_OP_breg16";
case DW_OP_breg17:
return "DW_OP_breg17";
case DW_OP_breg18:
return "DW_OP_breg18";
case DW_OP_breg19:
return "DW_OP_breg19";
case DW_OP_breg20:
return "DW_OP_breg20";
case DW_OP_breg21:
return "DW_OP_breg21";
case DW_OP_breg22:
return "DW_OP_breg22";
case DW_OP_breg23:
return "DW_OP_breg23";
case DW_OP_breg24:
return "DW_OP_breg24";
case DW_OP_breg25:
return "DW_OP_breg25";
case DW_OP_breg26:
return "DW_OP_breg26";
case DW_OP_breg27:
return "DW_OP_breg27";
case DW_OP_breg28:
return "DW_OP_breg28";
case DW_OP_breg29:
return "DW_OP_breg29";
case DW_OP_breg30:
return "DW_OP_breg30";
case DW_OP_breg31:
return "DW_OP_breg31";
case DW_OP_regx:
return "DW_OP_regx";
case DW_OP_fbreg:
return "DW_OP_fbreg";
case DW_OP_bregx:
return "DW_OP_bregx";
case DW_OP_piece:
return "DW_OP_piece";
case DW_OP_deref_size:
return "DW_OP_deref_size";
case DW_OP_xderef_size:
return "DW_OP_xderef_size";
case DW_OP_nop:
return "DW_OP_nop";
default:
return "OP_<unknown>";
}
}
static char *
dwarf_bool_name (bool)
unsigned bool;
{
if (bool)
return "TRUE";
else
return "FALSE";
}
/* Convert a DWARF type code into its string name. */
static char *
dwarf_type_encoding_name (enc)
register unsigned enc;
{
switch (enc)
{
case DW_ATE_address:
return "DW_ATE_address";
case DW_ATE_boolean:
return "DW_ATE_boolean";
case DW_ATE_complex_float:
return "DW_ATE_complex_float";
case DW_ATE_float:
return "DW_ATE_float";
case DW_ATE_signed:
return "DW_ATE_signed";
case DW_ATE_signed_char:
return "DW_ATE_signed_char";
case DW_ATE_unsigned:
return "DW_ATE_unsigned";
case DW_ATE_unsigned_char:
return "DW_ATE_unsigned_char";
default:
return "DW_ATE_<unknown>";
}
}
/* Convert a DWARF call frame info operation to its string name. */
#if 0
static char *
dwarf_cfi_name (cfi_opc)
register unsigned cfi_opc;
{
switch (cfi_opc)
{
case DW_CFA_advance_loc:
return "DW_CFA_advance_loc";
case DW_CFA_offset:
return "DW_CFA_offset";
case DW_CFA_restore:
return "DW_CFA_restore";
case DW_CFA_nop:
return "DW_CFA_nop";
case DW_CFA_set_loc:
return "DW_CFA_set_loc";
case DW_CFA_advance_loc1:
return "DW_CFA_advance_loc1";
case DW_CFA_advance_loc2:
return "DW_CFA_advance_loc2";
case DW_CFA_advance_loc4:
return "DW_CFA_advance_loc4";
case DW_CFA_offset_extended:
return "DW_CFA_offset_extended";
case DW_CFA_restore_extended:
return "DW_CFA_restore_extended";
case DW_CFA_undefined:
return "DW_CFA_undefined";
case DW_CFA_same_value:
return "DW_CFA_same_value";
case DW_CFA_register:
return "DW_CFA_register";
case DW_CFA_remember_state:
return "DW_CFA_remember_state";
case DW_CFA_restore_state:
return "DW_CFA_restore_state";
case DW_CFA_def_cfa:
return "DW_CFA_def_cfa";
case DW_CFA_def_cfa_register:
return "DW_CFA_def_cfa_register";
case DW_CFA_def_cfa_offset:
return "DW_CFA_def_cfa_offset";
/* SGI/MIPS specific */
case DW_CFA_MIPS_advance_loc8:
return "DW_CFA_MIPS_advance_loc8";
default:
return "DW_CFA_<unknown>";
}
}
#endif
void
dump_die (die)
struct die_info *die;
{
unsigned int i;
fprintf (stderr, "Die: %s (abbrev = %d, offset = %d)\n",
dwarf_tag_name (die->tag), die->abbrev, die->offset);
fprintf (stderr, "\thas children: %s\n",
dwarf_bool_name (die->has_children));
fprintf (stderr, "\tattributes:\n");
for (i = 0; i < die->num_attrs; ++i)
{
fprintf (stderr, "\t\t%s (%s) ",
dwarf_attr_name (die->attrs[i].name),
dwarf_form_name (die->attrs[i].form));
switch (die->attrs[i].form)
{
case DW_FORM_ref_addr:
case DW_FORM_addr:
fprintf (stderr, "address: ");
print_address_numeric (die->attrs[i].u.addr, 1, stderr);
break;
case DW_FORM_block2:
case DW_FORM_block4:
case DW_FORM_block:
case DW_FORM_block1:
fprintf (stderr, "block: size %d",
die->attrs[i].u.blk->size);
break;
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_udata:
case DW_FORM_sdata:
fprintf (stderr, "constant: %d", die->attrs[i].u.unsnd);
break;
case DW_FORM_string:
fprintf (stderr, "string: \"%s\"", die->attrs[i].u.str);
break;
case DW_FORM_flag:
if (die->attrs[i].u.unsnd)
fprintf (stderr, "flag: TRUE");
else
fprintf (stderr, "flag: FALSE");
break;
case DW_FORM_strp: /* we do not support separate string
section yet */
case DW_FORM_indirect: /* we do not handle indirect yet */
case DW_FORM_data8: /* we do not have 64 bit quantities */
default:
fprintf (stderr, "unsupported attribute form: %d.",
die->attrs[i].form);
}
fprintf (stderr, "\n");
}
}
void
dump_die_list (die)
struct die_info *die;
{
while (die)
{
dump_die (die);
die = die->next;
}
}
void
store_in_ref_table (offset, die)
unsigned int offset;
struct die_info *die;
{
int h;
struct die_info *old;
h = (offset % REF_HASH_SIZE);
old = die_ref_table[h];
die->next_ref = old;
die_ref_table[h] = die;
}
static void
dwarf2_empty_die_ref_table ()
{
memset (die_ref_table, 0, sizeof (die_ref_table));
}
static unsigned int
dwarf2_get_ref_die_offset (attr)
struct attribute *attr;
{
unsigned int result = 0;
switch (attr->form)
{
case DW_FORM_ref_addr:
result = DW_ADDR (attr);
break;
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref_udata:
result = cu_header_offset + DW_UNSND (attr);
break;
default:
complain (&dwarf2_unsupported_die_ref_attr, dwarf_form_name (attr->form));
}
return result;
}
struct die_info *
follow_die_ref (offset)
unsigned int offset;
{
struct die_info *die;
int h;
h = (offset % REF_HASH_SIZE);
die = die_ref_table[h];
while (die)
{
if (die->offset == offset)
{
return die;
}
die = die->next_ref;
}
return NULL;
}
static struct type *
dwarf2_fundamental_type (objfile, typeid)
struct objfile *objfile;
int typeid;
{
if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
{
error ("Dwarf Error: internal error - invalid fundamental type id %d.",
typeid);
}
/* Look for this particular type in the fundamental type vector. If
one is not found, create and install one appropriate for the
current language and the current target machine. */
if (ftypes[typeid] == NULL)
{
ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
}
return (ftypes[typeid]);
}
/* Decode simple location descriptions.
Given a pointer to a dwarf block that defines a location, compute
the location and return the value.
FIXME: This is a kludge until we figure out a better
way to handle the location descriptions.
Gdb's design does not mesh well with the DWARF2 notion of a location
computing interpreter, which is a shame because the flexibility goes unused.
FIXME: Implement more operations as necessary.
A location description containing no operations indicates that the
object is optimized out. The global optimized_out flag is set for
those, the return value is meaningless.
When the result is a register number, the global isreg flag is set,
otherwise it is cleared.
When the result is a base register offset, the global offreg flag is set
and the register number is returned in basereg, otherwise it is cleared.
When the DW_OP_fbreg operation is encountered without a corresponding
DW_AT_frame_base attribute, the global islocal flag is set.
Hopefully the machine dependent code knows how to set up a virtual
frame pointer for the local references.
Note that stack[0] is unused except as a default error return.
Note that stack overflow is not yet handled. */
static CORE_ADDR
decode_locdesc (blk, objfile)
struct dwarf_block *blk;
struct objfile *objfile;
{
int i;
int size = blk->size;
char *data = blk->data;
CORE_ADDR stack[64];
int stacki;
unsigned int bytes_read, unsnd;
unsigned char op;
i = 0;
stacki = 0;
stack[stacki] = 0;
isreg = 0;
offreg = 0;
islocal = 0;
optimized_out = 1;
while (i < size)
{
optimized_out = 0;
op = data[i++];
switch (op)
{
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
isreg = 1;
stack[++stacki] = op - DW_OP_reg0;
break;
case DW_OP_regx:
isreg = 1;
unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
i += bytes_read;
#if defined(HARRIS_TARGET) && defined(_M88K)
/* The Harris 88110 gdb ports have long kept their special reg
numbers between their gp-regs and their x-regs. This is
not how our dwarf is generated. Punt. */
unsnd += 6;
#endif
stack[++stacki] = unsnd;
break;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
offreg = 1;
basereg = op - DW_OP_breg0;
stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
i += bytes_read;
break;
case DW_OP_fbreg:
stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
i += bytes_read;
if (frame_base_reg >= 0)
{
offreg = 1;
basereg = frame_base_reg;
stack[stacki] += frame_base_offset;
}
else
{
complain (&dwarf2_missing_at_frame_base);
islocal = 1;
}
break;
case DW_OP_addr:
stack[++stacki] = read_address (objfile->obfd, &data[i]);
i += address_size;
break;
case DW_OP_const1u:
stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
i += 1;
break;
case DW_OP_const1s:
stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
i += 1;
break;
case DW_OP_const2u:
stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
i += 2;
break;
case DW_OP_const2s:
stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
i += 2;
break;
case DW_OP_const4u:
stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
i += 4;
break;
case DW_OP_const4s:
stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
i += 4;
break;
case DW_OP_constu:
stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
&bytes_read);
i += bytes_read;
break;
case DW_OP_consts:
stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
i += bytes_read;
break;
case DW_OP_plus:
stack[stacki - 1] += stack[stacki];
stacki--;
break;
case DW_OP_minus:
stack[stacki - 1] = stack[stacki] - stack[stacki - 1];
stacki--;
break;
default:
complain (&dwarf2_unsupported_stack_op, dwarf_stack_op_name(op));
return (stack[stacki]);
}
}
return (stack[stacki]);
}
/* memory allocation interface */
/* ARGSUSED */
static void
dwarf2_free_tmp_obstack (ignore)
PTR ignore;
{
obstack_free (&dwarf2_tmp_obstack, NULL);
}
static struct dwarf_block *
dwarf_alloc_block ()
{
struct dwarf_block *blk;
blk = (struct dwarf_block *)
obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct dwarf_block));
return (blk);
}
static struct abbrev_info *
dwarf_alloc_abbrev ()
{
struct abbrev_info *abbrev;
abbrev = (struct abbrev_info *) xmalloc (sizeof (struct abbrev_info));
memset (abbrev, 0, sizeof (struct abbrev_info));
return (abbrev);
}
static struct die_info *
dwarf_alloc_die ()
{
struct die_info *die;
die = (struct die_info *) xmalloc (sizeof (struct die_info));
memset (die, 0, sizeof (struct die_info));
return (die);
}
Reference in New Issue View Git Blame Copy Permalink