--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/elf4rom/libs/dwarf-20071209/libdwarf/dwarf_line.c Fri Jan 15 09:07:44 2010 +0000
@@ -0,0 +1,1827 @@
+/*
+
+ Copyright (C) 2000,2002,2004,2005,2006 Silicon Graphics, Inc. All Rights Reserved.
+ Portions Copyright (C) 2007 David Anderson. All Rights Reserved.
+
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of version 2.1 of the GNU Lesser General Public License
+ as published by the Free Software Foundation.
+
+ This program is distributed in the hope that it would be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ Further, this software is distributed without any warranty that it is
+ free of the rightful claim of any third person regarding infringement
+ or the like. Any license provided herein, whether implied or
+ otherwise, applies only to this software file. Patent licenses, if
+ any, provided herein do not apply to combinations of this program with
+ other software, or any other product whatsoever.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this program; if not, write the Free Software
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
+ USA.
+
+ Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
+ Mountain View, CA 94043, or:
+
+ http://www.sgi.com
+
+ For further information regarding this notice, see:
+
+ http://oss.sgi.com/projects/GenInfo/NoticeExplan
+
+*/
+/* The address of the Free Software Foundation is
+ Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+ SGI has moved from the Crittenden Lane address.
+*/
+
+
+
+
+#include "config.h"
+#include "dwarf_incl.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "dwarf_line.h"
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#endif
+
+
+/*
+ Although source files is supposed to return the
+ source files in the compilation-unit, it does
+ not look for any in the statement program. In
+ other words, it ignores those defined using the
+ extended opcode DW_LNE_define_file.
+*/
+int
+dwarf_srcfiles(Dwarf_Die die,
+ char ***srcfiles,
+ Dwarf_Signed * srcfilecount, Dwarf_Error * error)
+{
+ /*
+ This pointer is used to scan the portion of the .debug_line
+ section for the current cu. */
+ Dwarf_Small *line_ptr;
+
+
+ /*
+ Pointer to a DW_AT_stmt_list attribute in case it exists in the
+ die. */
+ Dwarf_Attribute stmt_list_attr;
+
+ /* Pointer to DW_AT_comp_dir attribute in die. */
+ Dwarf_Attribute comp_dir_attr;
+
+ /* Pointer to name of compilation directory. */
+ Dwarf_Small *comp_dir = 0;
+
+ /* Offset into .debug_line specified by a DW_AT_stmt_list
+ attribute. */
+ Dwarf_Unsigned line_offset = 0;
+
+
+
+ /*
+ This points to a block of char *'s, each of which points to a
+ file name. */
+ char **ret_files = 0;
+
+ /* The Dwarf_Debug this die belongs to. */
+ Dwarf_Debug dbg = 0;
+
+ /* Used to chain the file names. */
+ Dwarf_Chain curr_chain = NULL;
+ Dwarf_Chain prev_chain = NULL;
+ Dwarf_Chain head_chain = NULL;
+ int resattr = 0;
+ int lres = 0;
+ struct Line_Table_Prefix_s line_prefix;
+ int i = 0;
+ int res = 0;
+
+
+ /* ***** BEGIN CODE ***** */
+
+ /* Reset error. */
+ if (error != NULL)
+ *error = NULL;
+
+ CHECK_DIE(die, DW_DLV_ERROR);
+ dbg = die->di_cu_context->cc_dbg;
+
+ resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
+ if (resattr != DW_DLV_OK) {
+ return resattr;
+ }
+
+ if (dbg->de_debug_line_index == 0) {
+ _dwarf_error(dbg, error, DW_DLE_DEBUG_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ res =
+ _dwarf_load_section(dbg,
+ dbg->de_debug_line_index,
+ &dbg->de_debug_line, error);
+ if (res != DW_DLV_OK) {
+ return res;
+ }
+
+ lres = dwarf_formudata(stmt_list_attr, &line_offset, error);
+ if (lres != DW_DLV_OK) {
+ return lres;
+ }
+ if (line_offset >= dbg->de_debug_line_size) {
+ _dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
+ return (DW_DLV_ERROR);
+ }
+ line_ptr = dbg->de_debug_line + line_offset;
+ dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
+
+ /*
+ If die has DW_AT_comp_dir attribute, get the string that names
+ the compilation directory. */
+ resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
+ if (resattr == DW_DLV_ERROR) {
+ return resattr;
+ }
+ if (resattr == DW_DLV_OK) {
+ int cres;
+ char *cdir;
+
+ cres = dwarf_formstring(comp_dir_attr, &cdir, error);
+ if (cres == DW_DLV_ERROR) {
+ return cres;
+ } else if (cres == DW_DLV_OK) {
+ comp_dir = (Dwarf_Small *) cdir;
+ }
+ }
+ if (resattr == DW_DLV_OK) {
+ dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
+ }
+ dwarf_init_line_table_prefix(&line_prefix);
+ {
+ Dwarf_Small *line_ptr_out = 0;
+ int dres = dwarf_read_line_table_prefix(dbg,
+ line_ptr,
+ dbg->de_debug_line_size,
+ &line_ptr_out,
+ &line_prefix, error);
+
+ if (dres == DW_DLV_ERROR) {
+ dwarf_free_line_table_prefix(&line_prefix);
+ return dres;
+ }
+ if (dres == DW_DLV_NO_ENTRY) {
+ dwarf_free_line_table_prefix(&line_prefix);
+ return dres;
+ }
+
+ line_ptr = line_ptr_out;
+ }
+
+ for (i = 0; i < line_prefix.pf_files_count; ++i) {
+ struct Line_Table_File_Entry_s *fe =
+ line_prefix.pf_line_table_file_entries + i;
+ char *file_name = (char *) fe->lte_filename;
+ char *dir_name = 0;
+ char *full_name = 0;
+ Dwarf_Unsigned dir_index = fe->lte_directory_index;
+
+ if (dir_index == 0) {
+ dir_name = (char *) comp_dir;
+ } else {
+ dir_name =
+ (char *) line_prefix.pf_include_directories[fe->
+ lte_directory_index
+ - 1];
+ }
+
+ /* dir_name can be NULL if there is no DW_AT_comp_dir */
+ if ((*file_name) == '/' || dir_name == 0) {
+ /* This is safe because dwarf_dealloc is careful to not
+ dealloc strings which are part of the raw .debug_* data.
+ */
+ full_name = file_name;
+ } else {
+ full_name = (char *) _dwarf_get_alloc(dbg, DW_DLA_STRING,
+ strlen(dir_name) + 1 +
+ strlen(file_name) +
+ 1);
+ if (full_name == NULL) {
+ dwarf_free_line_table_prefix(&line_prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ /* This is not careful to avoid // in the output, Nothing
+ forces a 'canonical' name format here. Unclear if this
+ needs to be fixed. */
+ strcpy(full_name, dir_name);
+ strcat(full_name, "/");
+ strcat(full_name, file_name);
+ }
+ curr_chain =
+ (Dwarf_Chain) _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (curr_chain == NULL) {
+ dwarf_free_line_table_prefix(&line_prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ curr_chain->ch_item = full_name;
+ if (head_chain == NULL)
+ head_chain = prev_chain = curr_chain;
+ else {
+ prev_chain->ch_next = curr_chain;
+ prev_chain = curr_chain;
+ }
+
+
+ }
+
+ curr_chain = (Dwarf_Chain) _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (curr_chain == NULL) {
+ dwarf_free_line_table_prefix(&line_prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+
+
+
+ if (line_prefix.pf_files_count == 0) {
+ *srcfiles = NULL;
+ *srcfilecount = 0;
+ dwarf_free_line_table_prefix(&line_prefix);
+ return (DW_DLV_NO_ENTRY);
+ }
+
+ ret_files = (char **)
+ _dwarf_get_alloc(dbg, DW_DLA_LIST, line_prefix.pf_files_count);
+ if (ret_files == NULL) {
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ dwarf_free_line_table_prefix(&line_prefix);
+ return (DW_DLV_ERROR);
+ }
+
+ curr_chain = head_chain;
+ for (i = 0; i < line_prefix.pf_files_count; i++) {
+ *(ret_files + i) = curr_chain->ch_item;
+ prev_chain = curr_chain;
+ curr_chain = curr_chain->ch_next;
+ dwarf_dealloc(dbg, prev_chain, DW_DLA_CHAIN);
+ }
+
+ *srcfiles = ret_files;
+ *srcfilecount = line_prefix.pf_files_count;
+ dwarf_free_line_table_prefix(&line_prefix);
+ return (DW_DLV_OK);
+}
+
+
+/*
+ return DW_DLV_OK if ok. else DW_DLV_NO_ENTRY or DW_DLV_ERROR
+*/
+int
+_dwarf_internal_srclines(Dwarf_Die die,
+ Dwarf_Line ** linebuf,
+ Dwarf_Signed * count,
+ Dwarf_Bool doaddrs,
+ Dwarf_Bool dolines, Dwarf_Error * error)
+{
+ /*
+ This pointer is used to scan the portion of the .debug_line
+ section for the current cu. */
+ Dwarf_Small *line_ptr = 0;
+
+ /*
+ This points to the last byte of the .debug_line portion for the
+ current cu. */
+ Dwarf_Small *line_ptr_end = 0;
+
+
+ /*
+ Pointer to a DW_AT_stmt_list attribute in case it exists in the
+ die. */
+ Dwarf_Attribute stmt_list_attr = 0;
+
+ /* Pointer to DW_AT_comp_dir attribute in die. */
+ Dwarf_Attribute comp_dir_attr = 0;
+
+ /* Pointer to name of compilation directory. */
+ Dwarf_Small *comp_dir = NULL;
+
+ /*
+ Offset into .debug_line specified by a DW_AT_stmt_list
+ attribute. */
+ Dwarf_Unsigned line_offset = 0;
+
+ Dwarf_File_Entry file_entries = 0;
+
+ /* These are the state machine state variables. */
+ Dwarf_Addr address = 0;
+ Dwarf_Word file = 1;
+ Dwarf_Word line = 1;
+ Dwarf_Word column = 0;
+
+ /* phony init. See below for true initialization. */
+ Dwarf_Bool is_stmt = false;
+
+ Dwarf_Bool basic_block = false;
+ Dwarf_Bool prologue_end = false;
+ Dwarf_Bool epilogue_begin = false;
+ Dwarf_Small isa = 0;
+ Dwarf_Bool end_sequence = false;
+
+ /*
+ These pointers are used to build the list of files names by this
+ cu. cur_file_entry points to the file name being added, and
+ prev_file_entry to the previous one. */
+ Dwarf_File_Entry cur_file_entry, prev_file_entry;
+
+ Dwarf_Sword i = 0;
+ Dwarf_Sword file_entry_count = 0;
+
+ /*
+ This is the current opcode read from the statement program. */
+ Dwarf_Small opcode = 0;
+
+ /*
+ Pointer to a Dwarf_Line_Context_s structure that contains the
+ context such as file names and include directories for the set
+ of lines being generated. */
+ Dwarf_Line_Context line_context = 0;
+
+ /*
+ This is a pointer to the current line being added to the line
+ matrix. */
+ Dwarf_Line curr_line = 0;
+
+ /*
+ These variables are used to decode leb128 numbers. Leb128_num
+ holds the decoded number, and leb128_length is its length in
+ bytes. */
+ Dwarf_Word leb128_num = 0;
+ Dwarf_Word leb128_length = 0;
+ Dwarf_Sword advance_line = 0;
+
+ /*
+ This is the operand of the latest fixed_advance_pc extended
+ opcode. */
+ Dwarf_Half fixed_advance_pc = 0;
+
+ /*
+ Counts the number of lines in the line matrix. */
+ Dwarf_Sword line_count = 0;
+
+ /* This is the length of an extended opcode instr. */
+ Dwarf_Word instr_length = 0;
+ Dwarf_Small ext_opcode = 0;
+ struct Line_Table_Prefix_s prefix;
+
+ /*
+ Used to chain together pointers to line table entries that are
+ later used to create a block of Dwarf_Line entries. */
+ Dwarf_Chain chain_line = NULL;
+ Dwarf_Chain head_chain = NULL;
+ Dwarf_Chain curr_chain = NULL;
+
+ /*
+ This points to a block of Dwarf_Lines, a pointer to which is
+ returned in linebuf. */
+ Dwarf_Line *block_line = 0;
+
+ /* The Dwarf_Debug this die belongs to. */
+ Dwarf_Debug dbg = 0;
+ int resattr = 0;
+ int lres = 0;
+
+ int res = 0;
+
+ /* ***** BEGIN CODE ***** */
+
+ if (error != NULL)
+ *error = NULL;
+
+ CHECK_DIE(die, DW_DLV_ERROR);
+ dbg = die->di_cu_context->cc_dbg;
+
+ res =
+ _dwarf_load_section(dbg,
+ dbg->de_debug_line_index,
+ &dbg->de_debug_line, error);
+ if (res != DW_DLV_OK) {
+ return res;
+ }
+
+ resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
+ if (resattr != DW_DLV_OK) {
+ return resattr;
+ }
+
+
+
+ lres = dwarf_formudata(stmt_list_attr, &line_offset, error);
+ if (lres != DW_DLV_OK) {
+ return lres;
+ }
+
+ if (line_offset >= dbg->de_debug_line_size) {
+ _dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
+ return (DW_DLV_ERROR);
+ }
+ line_ptr = dbg->de_debug_line + line_offset;
+ dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
+
+ /*
+ If die has DW_AT_comp_dir attribute, get the string that names
+ the compilation directory. */
+ resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
+ if (resattr == DW_DLV_ERROR) {
+ return resattr;
+ }
+ if (resattr == DW_DLV_OK) {
+ int cres;
+ char *cdir;
+
+ cres = dwarf_formstring(comp_dir_attr, &cdir, error);
+ if (cres == DW_DLV_ERROR) {
+ return cres;
+ } else if (cres == DW_DLV_OK) {
+ comp_dir = (Dwarf_Small *) cdir;
+ }
+ }
+ if (resattr == DW_DLV_OK) {
+ dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
+ }
+ dwarf_init_line_table_prefix(&prefix);
+
+ {
+ Dwarf_Small *newlinep = 0;
+ int res = dwarf_read_line_table_prefix(dbg,
+ line_ptr,
+ dbg->de_debug_line_size,
+ &newlinep,
+ &prefix,
+ error);
+
+ if (res == DW_DLV_ERROR) {
+ dwarf_free_line_table_prefix(&prefix);
+ return res;
+ }
+ if (res == DW_DLV_NO_ENTRY) {
+ dwarf_free_line_table_prefix(&prefix);
+ return res;
+ }
+ line_ptr_end = prefix.pf_line_ptr_end;
+ line_ptr = newlinep;
+ }
+
+
+ /* Set up context structure for this set of lines. */
+ line_context = (Dwarf_Line_Context)
+ _dwarf_get_alloc(dbg, DW_DLA_LINE_CONTEXT, 1);
+ if (line_context == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ /* Fill out a Dwarf_File_Entry list as we use that to implement the
+ define_file operation. */
+ file_entries = prev_file_entry = NULL;
+ for (i = 0; i < prefix.pf_files_count; ++i) {
+ struct Line_Table_File_Entry_s *pfxfile =
+ prefix.pf_line_table_file_entries + i;
+
+ cur_file_entry = (Dwarf_File_Entry)
+ _dwarf_get_alloc(dbg, DW_DLA_FILE_ENTRY, 1);
+ if (cur_file_entry == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ cur_file_entry->fi_file_name = pfxfile->lte_filename;
+ cur_file_entry->fi_dir_index = pfxfile->lte_directory_index;
+ cur_file_entry->fi_time_last_mod =
+ pfxfile->lte_last_modification_time;
+
+ cur_file_entry->fi_file_length = pfxfile->lte_length_of_file;
+
+ if (file_entries == NULL)
+ file_entries = cur_file_entry;
+ else
+ prev_file_entry->fi_next = cur_file_entry;
+ prev_file_entry = cur_file_entry;
+
+ file_entry_count++;
+ }
+
+
+ /* Initialize the one state machine variable that depends on the
+ prefix. */
+ is_stmt = prefix.pf_default_is_stmt;
+
+
+ /* Start of statement program. */
+ while (line_ptr < line_ptr_end) {
+ int type;
+
+ opcode = *(Dwarf_Small *) line_ptr;
+ line_ptr++;
+
+
+ /* 'type' is the output */
+ WHAT_IS_OPCODE(type, opcode, prefix.pf_opcode_base,
+ prefix.pf_opcode_length_table, line_ptr,
+ prefix.pf_std_op_count);
+
+ if (type == LOP_DISCARD) {
+ int oc;
+ int opcnt = prefix.pf_opcode_length_table[opcode];
+
+ for (oc = 0; oc < opcnt; oc++) {
+ /*
+ ** Read and discard operands we don't
+ ** understand.
+ ** arbitrary choice of unsigned read.
+ ** signed read would work as well.
+ */
+ Dwarf_Unsigned utmp2;
+
+ DECODE_LEB128_UWORD(line_ptr, utmp2);
+ }
+ } else if (type == LOP_SPECIAL) {
+ /* This op code is a special op in the object, no matter
+ that it might fall into the standard op range in this
+ compile. That is, these are special opcodes between
+ opcode_base and MAX_LINE_OP_CODE. (including
+ opcode_base and MAX_LINE_OP_CODE) */
+
+ opcode = opcode - prefix.pf_opcode_base;
+ address = address + prefix.pf_minimum_instruction_length *
+ (opcode / prefix.pf_line_range);
+ line =
+ line + prefix.pf_line_base +
+ opcode % prefix.pf_line_range;
+
+ if (dolines) {
+ curr_line =
+ (Dwarf_Line) _dwarf_get_alloc(dbg, DW_DLA_LINE, 1);
+ if (curr_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ curr_line->li_address = address;
+ curr_line->li_addr_line.li_l_data.li_file =
+ (Dwarf_Sword) file;
+ curr_line->li_addr_line.li_l_data.li_line =
+ (Dwarf_Sword) line;
+ curr_line->li_addr_line.li_l_data.li_column =
+ (Dwarf_Half) column;
+ curr_line->li_addr_line.li_l_data.li_is_stmt = is_stmt;
+ curr_line->li_addr_line.li_l_data.li_basic_block =
+ basic_block;
+ curr_line->li_addr_line.li_l_data.li_end_sequence =
+ curr_line->li_addr_line.li_l_data.
+ li_epilogue_begin = epilogue_begin;
+ curr_line->li_addr_line.li_l_data.li_prologue_end =
+ prologue_end;
+ curr_line->li_addr_line.li_l_data.li_isa = isa;
+ curr_line->li_context = line_context;
+ line_count++;
+
+ chain_line = (Dwarf_Chain)
+ _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (chain_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ chain_line->ch_item = curr_line;
+
+ if (head_chain == NULL)
+ head_chain = curr_chain = chain_line;
+ else {
+ curr_chain->ch_next = chain_line;
+ curr_chain = chain_line;
+ }
+ }
+
+ basic_block = false;
+ } else if (type == LOP_STANDARD) {
+ switch (opcode) {
+
+ case DW_LNS_copy:{
+ if (dolines) {
+
+ curr_line =
+ (Dwarf_Line) _dwarf_get_alloc(dbg,
+ DW_DLA_LINE,
+ 1);
+ if (curr_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ curr_line->li_address = address;
+ curr_line->li_addr_line.li_l_data.li_file =
+ (Dwarf_Sword) file;
+ curr_line->li_addr_line.li_l_data.li_line =
+ (Dwarf_Sword) line;
+ curr_line->li_addr_line.li_l_data.li_column =
+ (Dwarf_Half) column;
+ curr_line->li_addr_line.li_l_data.li_is_stmt =
+ is_stmt;
+ curr_line->li_addr_line.li_l_data.
+ li_basic_block = basic_block;
+ curr_line->li_addr_line.li_l_data.
+ li_end_sequence = end_sequence;
+ curr_line->li_context = line_context;
+ curr_line->li_addr_line.li_l_data.
+ li_epilogue_begin = epilogue_begin;
+ curr_line->li_addr_line.li_l_data.
+ li_prologue_end = prologue_end;
+ curr_line->li_addr_line.li_l_data.li_isa = isa;
+ line_count++;
+
+ chain_line = (Dwarf_Chain)
+ _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (chain_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ chain_line->ch_item = curr_line;
+ if (head_chain == NULL)
+ head_chain = curr_chain = chain_line;
+ else {
+ curr_chain->ch_next = chain_line;
+ curr_chain = chain_line;
+ }
+ }
+
+ basic_block = false;
+ prologue_end = false;
+ epilogue_begin = false;
+ break;
+ }
+
+ case DW_LNS_advance_pc:{
+ Dwarf_Unsigned utmp2;
+
+ DECODE_LEB128_UWORD(line_ptr, utmp2);
+ leb128_num = (Dwarf_Word) utmp2;
+ address =
+ address +
+ prefix.pf_minimum_instruction_length *
+ leb128_num;
+ break;
+ }
+
+ case DW_LNS_advance_line:{
+ Dwarf_Signed stmp;
+
+ DECODE_LEB128_SWORD(line_ptr, stmp);
+ advance_line = (Dwarf_Sword) stmp;
+ line = line + advance_line;
+ break;
+ }
+
+ case DW_LNS_set_file:{
+ Dwarf_Unsigned utmp2;
+
+ DECODE_LEB128_UWORD(line_ptr, utmp2);
+ file = (Dwarf_Word) utmp2;
+ break;
+ }
+
+ case DW_LNS_set_column:{
+ Dwarf_Unsigned utmp2;
+
+ DECODE_LEB128_UWORD(line_ptr, utmp2);
+ column = (Dwarf_Word) utmp2;
+ break;
+ }
+
+ case DW_LNS_negate_stmt:{
+
+ is_stmt = !is_stmt;
+ break;
+ }
+
+ case DW_LNS_set_basic_block:{
+
+ basic_block = true;
+ break;
+ }
+
+ case DW_LNS_const_add_pc:{
+ opcode = MAX_LINE_OP_CODE - prefix.pf_opcode_base;
+ address =
+ address +
+ prefix.pf_minimum_instruction_length * (opcode /
+ prefix.
+ pf_line_range);
+
+ break;
+ }
+
+ case DW_LNS_fixed_advance_pc:{
+
+ READ_UNALIGNED(dbg, fixed_advance_pc, Dwarf_Half,
+ line_ptr, sizeof(Dwarf_Half));
+ line_ptr += sizeof(Dwarf_Half);
+ address = address + fixed_advance_pc;
+ break;
+ }
+
+ /* New in DWARF3 */
+ case DW_LNS_set_prologue_end:{
+
+ prologue_end = true;
+ break;
+
+
+ }
+ /* New in DWARF3 */
+ case DW_LNS_set_epilogue_begin:{
+ epilogue_begin = true;
+ break;
+ }
+
+ /* New in DWARF3 */
+ case DW_LNS_set_isa:{
+ Dwarf_Unsigned utmp2;
+
+ DECODE_LEB128_UWORD(line_ptr, utmp2);
+ isa = utmp2;
+ if (isa != utmp2) {
+ /* The value of the isa did not fit in our
+ local so we record it wrong. declare an
+ error. */
+ dwarf_free_line_table_prefix(&prefix);
+
+ _dwarf_error(dbg, error,
+ DW_DLE_LINE_NUM_OPERANDS_BAD);
+ return (DW_DLV_ERROR);
+ }
+ break;
+ }
+ }
+
+ } else if (type == LOP_EXTENDED) {
+ Dwarf_Unsigned utmp3;
+
+ DECODE_LEB128_UWORD(line_ptr, utmp3);
+ instr_length = (Dwarf_Word) utmp3;
+ /* Dwarf_Small is a ubyte and the extended opcode is a
+ ubyte, though not stated as clearly in the 2.0.0 spec as
+ one might hope. */
+ ext_opcode = *(Dwarf_Small *) line_ptr;
+ line_ptr++;
+ switch (ext_opcode) {
+
+ case DW_LNE_end_sequence:{
+ end_sequence = true;
+
+ if (dolines) {
+ curr_line = (Dwarf_Line)
+ _dwarf_get_alloc(dbg, DW_DLA_LINE, 1);
+ if (curr_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ curr_line->li_address = address;
+ curr_line->li_addr_line.li_l_data.li_file =
+ (Dwarf_Sword) file;
+ curr_line->li_addr_line.li_l_data.li_line =
+ (Dwarf_Sword) line;
+ curr_line->li_addr_line.li_l_data.li_column =
+ (Dwarf_Half) column;
+ curr_line->li_addr_line.li_l_data.li_is_stmt =
+ prefix.pf_default_is_stmt;
+ curr_line->li_addr_line.li_l_data.
+ li_basic_block = basic_block;
+ curr_line->li_addr_line.li_l_data.
+ li_end_sequence = end_sequence;
+ curr_line->li_context = line_context;
+ curr_line->li_addr_line.li_l_data.
+ li_epilogue_begin = epilogue_begin;
+ curr_line->li_addr_line.li_l_data.
+ li_prologue_end = prologue_end;
+ curr_line->li_addr_line.li_l_data.li_isa = isa;
+ line_count++;
+
+ chain_line = (Dwarf_Chain)
+ _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (chain_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ chain_line->ch_item = curr_line;
+
+ if (head_chain == NULL)
+ head_chain = curr_chain = chain_line;
+ else {
+ curr_chain->ch_next = chain_line;
+ curr_chain = chain_line;
+ }
+ }
+
+ address = 0;
+ file = 1;
+ line = 1;
+ column = 0;
+ is_stmt = prefix.pf_default_is_stmt;
+ basic_block = false;
+ end_sequence = false;
+ prologue_end = false;
+ epilogue_begin = false;
+
+
+ break;
+ }
+
+ case DW_LNE_set_address:{
+ if (instr_length - 1 == dbg->de_pointer_size) {
+ READ_UNALIGNED(dbg, address, Dwarf_Addr,
+ line_ptr, dbg->de_pointer_size);
+ if (doaddrs) {
+ curr_line =
+ (Dwarf_Line) _dwarf_get_alloc(dbg,
+ DW_DLA_LINE,
+ 1);
+ if (curr_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error,
+ DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ curr_line->li_address = address;
+ curr_line->li_addr_line.li_offset =
+ line_ptr - dbg->de_debug_line;
+
+ line_count++;
+
+ chain_line = (Dwarf_Chain)
+ _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (chain_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error,
+ DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ chain_line->ch_item = curr_line;
+
+ if (head_chain == NULL)
+ head_chain = curr_chain = chain_line;
+ else {
+ curr_chain->ch_next = chain_line;
+ curr_chain = chain_line;
+ }
+ }
+
+ line_ptr += dbg->de_pointer_size;
+ } else {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error,
+ DW_DLE_LINE_SET_ADDR_ERROR);
+ return (DW_DLV_ERROR);
+ }
+
+ break;
+ }
+
+ case DW_LNE_define_file:{
+
+ if (dolines) {
+ cur_file_entry = (Dwarf_File_Entry)
+ _dwarf_get_alloc(dbg, DW_DLA_FILE_ENTRY, 1);
+ if (cur_file_entry == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ cur_file_entry->fi_file_name =
+ (Dwarf_Small *) line_ptr;
+ line_ptr =
+ line_ptr + strlen((char *) line_ptr) + 1;
+
+ cur_file_entry->fi_dir_index = (Dwarf_Sword)
+ _dwarf_decode_u_leb128(line_ptr,
+ &leb128_length);
+ line_ptr = line_ptr + leb128_length;
+
+ cur_file_entry->fi_time_last_mod =
+ _dwarf_decode_u_leb128(line_ptr,
+ &leb128_length);
+ line_ptr = line_ptr + leb128_length;
+
+ cur_file_entry->fi_file_length =
+ _dwarf_decode_u_leb128(line_ptr,
+ &leb128_length);
+ line_ptr = line_ptr + leb128_length;
+
+ if (file_entries == NULL)
+ file_entries = cur_file_entry;
+ else
+ prev_file_entry->fi_next = cur_file_entry;
+ prev_file_entry = cur_file_entry;
+
+ file_entry_count++;
+ }
+ break;
+ }
+
+ default:{
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error,
+ DW_DLE_LINE_EXT_OPCODE_BAD);
+ return (DW_DLV_ERROR);
+ }
+ }
+
+ }
+ }
+
+ block_line = (Dwarf_Line *)
+ _dwarf_get_alloc(dbg, DW_DLA_LIST, line_count);
+ if (block_line == NULL) {
+ dwarf_free_line_table_prefix(&prefix);
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ curr_chain = head_chain;
+ for (i = 0; i < line_count; i++) {
+ *(block_line + i) = curr_chain->ch_item;
+ head_chain = curr_chain;
+ curr_chain = curr_chain->ch_next;
+ dwarf_dealloc(dbg, head_chain, DW_DLA_CHAIN);
+ }
+
+ line_context->lc_file_entries = file_entries;
+ line_context->lc_file_entry_count = file_entry_count;
+ line_context->lc_include_directories_count =
+ prefix.pf_include_directories_count;
+ if (prefix.pf_include_directories_count > 0) {
+ /* This gets a pointer to the *first* include dir. The others
+ follow directly with the standard DWARF2/3 NUL byte
+ following the last. */
+ line_context->lc_include_directories =
+ prefix.pf_include_directories[0];
+ }
+
+ line_context->lc_line_count = line_count;
+ line_context->lc_compilation_directory = comp_dir;
+ line_context->lc_version_number = prefix.pf_version;
+ line_context->lc_dbg = dbg;
+ *count = line_count;
+
+ *linebuf = block_line;
+ dwarf_free_line_table_prefix(&prefix);
+ return (DW_DLV_OK);
+}
+
+int
+dwarf_srclines(Dwarf_Die die,
+ Dwarf_Line ** linebuf,
+ Dwarf_Signed * linecount, Dwarf_Error * error)
+{
+ Dwarf_Signed count;
+ int res;
+
+ res = _dwarf_internal_srclines(die, linebuf, &count, /* addrlist=
+ */ false,
+ /* linelist= */ true, error);
+ if (res != DW_DLV_OK) {
+ return res;
+ }
+ *linecount = count;
+ return res;
+}
+
+
+
+/* Every line table entry (except DW_DLE_end_sequence,
+ which is returned using dwarf_lineendsequence())
+ potentially has the begin-statement
+ flag marked 'on'. This returns thru *return_bool,
+ the begin-statement flag.
+*/
+
+int
+dwarf_linebeginstatement(Dwarf_Line line,
+ Dwarf_Bool * return_bool, Dwarf_Error * error)
+{
+ if (line == NULL || return_bool == 0) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ *return_bool = (line->li_addr_line.li_l_data.li_is_stmt);
+ return DW_DLV_OK;
+}
+
+/* At the end of any contiguous line-table there may be
+ a DW_LNE_end_sequence operator.
+ This returns non-zero thru *return_bool
+ if and only if this 'line' entry was a DW_LNE_end_sequence.
+
+ Within a compilation unit or function there may be multiple
+ line tables, each ending with a DW_LNE_end_sequence.
+ Each table describes a contiguous region.
+ Because compilers may split function code up in arbitrary ways
+ compilers may need to emit multiple contigous regions (ie
+ line tables) for a single function.
+ See the DWARF3 spec section 6.2.
+*/
+int
+dwarf_lineendsequence(Dwarf_Line line,
+ Dwarf_Bool * return_bool, Dwarf_Error * error)
+{
+ if (line == NULL) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ *return_bool = (line->li_addr_line.li_l_data.li_end_sequence);
+ return DW_DLV_OK;
+}
+
+
+/* Each 'line' entry has a line-number.
+ If the entry is a DW_LNE_end_sequence the line-number is
+ meaningless (see dwarf_lineendsequence(), just above).
+*/
+int
+dwarf_lineno(Dwarf_Line line,
+ Dwarf_Unsigned * ret_lineno, Dwarf_Error * error)
+{
+ if (line == NULL || ret_lineno == 0) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ *ret_lineno = (line->li_addr_line.li_l_data.li_line);
+ return DW_DLV_OK;
+}
+
+/* Each 'line' entry has a file-number, and index into the file table.
+ If the entry is a DW_LNE_end_sequence the index is
+ meaningless (see dwarf_lineendsequence(), just above).
+ The file number returned is an index into the file table
+ produced by dwarf_srcfiles(), but care is required: the
+ li_file begins with 1 for real files, so that the li_file returned here
+ is 1 greater than its index into the dwarf_srcfiles() output array.
+ And entries from DW_LNE_define_file don't appear in
+ the dwarf_srcfiles() output so file indexes from here may exceed
+ the size of the dwarf_srcfiles() output array size.
+*/
+int
+dwarf_line_srcfileno(Dwarf_Line line,
+ Dwarf_Unsigned * ret_fileno, Dwarf_Error * error)
+{
+ if (line == NULL || ret_fileno == 0) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+ /* li_file must be <= line->li_context->lc_file_entry_count else it
+ is trash. li_file 0 means not attributable to any source file
+ per dwarf2/3 spec. */
+
+ *ret_fileno = (line->li_addr_line.li_l_data.li_file);
+ return DW_DLV_OK;
+}
+
+
+/* Each 'line' entry has a line-address.
+ If the entry is a DW_LNE_end_sequence the adddress
+ is one-beyond the last address this contigous region
+ covers, so the address is not inside the region,
+ but is just outside it.
+*/
+int
+dwarf_lineaddr(Dwarf_Line line,
+ Dwarf_Addr * ret_lineaddr, Dwarf_Error * error)
+{
+ if (line == NULL || ret_lineaddr == 0) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ *ret_lineaddr = (line->li_address);
+ return DW_DLV_OK;
+}
+
+
+/* Each 'line' entry has a column-within-line (offset
+ within the line) where the
+ source text begins.
+ If the entry is a DW_LNE_end_sequence the line-number is
+ meaningless (see dwarf_lineendsequence(), just above).
+ Lines of text begin at column 1. The value 0
+ means the line begins at the left edge of the line.
+ (See the DWARF3 spec, section 6.2.2).
+*/
+int
+dwarf_lineoff(Dwarf_Line line,
+ Dwarf_Signed * ret_lineoff, Dwarf_Error * error)
+{
+ if (line == NULL || ret_lineoff == 0) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ *ret_lineoff =
+ (line->li_addr_line.li_l_data.li_column ==
+ 0 ? -1 : line->li_addr_line.li_l_data.li_column);
+ return DW_DLV_OK;
+}
+
+
+int
+dwarf_linesrc(Dwarf_Line line, char **ret_linesrc, Dwarf_Error * error)
+{
+ Dwarf_Signed i;
+ Dwarf_File_Entry file_entry;
+ Dwarf_Small *name_buffer;
+ Dwarf_Small *include_directories;
+ Dwarf_Debug dbg;
+ unsigned int comp_dir_len;
+
+ if (line == NULL) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ if (line->li_context == NULL) {
+ _dwarf_error(NULL, error, DW_DLE_LINE_CONTEXT_NULL);
+ return (DW_DLV_ERROR);
+ }
+ dbg = line->li_context->lc_dbg;
+
+ if (line->li_addr_line.li_l_data.li_file >
+ line->li_context->lc_file_entry_count) {
+ _dwarf_error(dbg, error, DW_DLE_LINE_FILE_NUM_BAD);
+ return (DW_DLV_ERROR);
+ }
+
+ if (line->li_addr_line.li_l_data.li_file == 0) {
+ /* No file name known: see dwarf2/3 spec. */
+ _dwarf_error(dbg, error, DW_DLE_NO_FILE_NAME);
+ return (DW_DLV_ERROR);
+ }
+ file_entry = line->li_context->lc_file_entries;
+ /* ASSERT: li_file > 0, dwarf correctness issue, see line table
+ definition of dwarf2/3 spec. */
+ /* Example: if li_file is 2 and lc_file_entry_count is 3,
+ file_entry is file 3 (1 based), aka 2( 0 based) file_entry->next
+ is file 2 (1 based), aka 1( 0 based) file_entry->next->next is
+ file 1 (1 based), aka 0( 0 based) file_entry->next->next->next
+ is NULL.
+
+ and this loop finds the file_entry we need (2 (1 based) in this
+ case). Because lc_file_entries are in reverse order and
+ effectively zero based as a count whereas li_file is 1 based. */
+ for (i = line->li_addr_line.li_l_data.li_file - 1; i > 0; i--)
+ file_entry = file_entry->fi_next;
+
+ if (file_entry->fi_file_name == NULL) {
+ _dwarf_error(dbg, error, DW_DLE_NO_FILE_NAME);
+ return (DW_DLV_ERROR);
+ }
+
+ if (*(char *) file_entry->fi_file_name == '/') {
+ *ret_linesrc = ((char *) file_entry->fi_file_name);
+ return DW_DLV_OK;
+ }
+
+ if (file_entry->fi_dir_index == 0) {
+
+ /* dir_index of 0 means that the compilation was in the
+ 'current directory of compilation' */
+ if (line->li_context->lc_compilation_directory == NULL) {
+ /* we don't actually *have* a current directory of
+ compilation: DW_AT_comp_dir was not present Rather than
+ emitting DW_DLE_NO_COMP_DIR lets just make an empty name
+ here. In other words, do the best we can with what we do
+ have instead of reporting an error. _dwarf_error(dbg,
+ error, DW_DLE_NO_COMP_DIR); return(DW_DLV_ERROR); */
+ comp_dir_len = 0;
+ } else {
+ comp_dir_len = strlen((char *)
+ (line->li_context->
+ lc_compilation_directory));
+ }
+
+ name_buffer =
+ _dwarf_get_alloc(line->li_context->lc_dbg, DW_DLA_STRING,
+ comp_dir_len + 1 +
+ strlen((char *) file_entry->fi_file_name) +
+ 1);
+ if (name_buffer == NULL) {
+ _dwarf_error(line->li_context->lc_dbg, error,
+ DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ if (comp_dir_len > 0) {
+ /* if comp_dir_len is 0 we do not want to put a / in front
+ of the fi_file_name as we just don't know anything. */
+ strcpy((char *) name_buffer,
+ (char *) (line->li_context->
+ lc_compilation_directory));
+ strcat((char *) name_buffer, "/");
+ }
+ strcat((char *) name_buffer, (char *) file_entry->fi_file_name);
+ *ret_linesrc = ((char *) name_buffer);
+ return DW_DLV_OK;
+ }
+
+ if (file_entry->fi_dir_index >
+ line->li_context->lc_include_directories_count) {
+ _dwarf_error(dbg, error, DW_DLE_INCL_DIR_NUM_BAD);
+ return (DW_DLV_ERROR);
+ }
+
+ include_directories = line->li_context->lc_include_directories;
+ for (i = file_entry->fi_dir_index - 1; i > 0; i--)
+ include_directories += strlen((char *) include_directories) + 1;
+
+ if (line->li_context->lc_compilation_directory) {
+ comp_dir_len = strlen((char *)
+ (line->li_context->
+ lc_compilation_directory));
+ } else {
+ /* No DW_AT_comp_dir present. Do the best we can without it. */
+ comp_dir_len = 0;
+ }
+
+ name_buffer = _dwarf_get_alloc(dbg, DW_DLA_STRING,
+ (*include_directories == '/' ?
+ 0 : comp_dir_len + 1) +
+ strlen((char *) include_directories)
+ + 1 +
+ strlen((char *) file_entry->
+ fi_file_name) + 1);
+ if (name_buffer == NULL) {
+ _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ if (*include_directories != '/') {
+ if (comp_dir_len > 0) {
+ strcpy((char *) name_buffer,
+ (char *) line->li_context->lc_compilation_directory);
+ /* Who provides the / needed after the compilation
+ directory? */
+ if (name_buffer[comp_dir_len - 1] != '/') {
+ /* Here we provide the / separator */
+ name_buffer[comp_dir_len] = '/'; /* overwrite
+ previous nul
+ terminator
+ with needed
+ / */
+ name_buffer[comp_dir_len + 1] = 0;
+ }
+ }
+ } else {
+ strcpy((char *) name_buffer, "");
+ }
+ strcat((char *) name_buffer, (char *) include_directories);
+ strcat((char *) name_buffer, "/");
+ strcat((char *) name_buffer, (char *) file_entry->fi_file_name);
+ *ret_linesrc = ((char *) name_buffer);
+ return DW_DLV_OK;
+}
+
+/* Every line table entry potentially has the basic-block-start
+ flag marked 'on'. This returns thru *return_bool,
+ the basic-block-start flag.
+*/
+int
+dwarf_lineblock(Dwarf_Line line,
+ Dwarf_Bool * return_bool, Dwarf_Error * error)
+{
+ if (line == NULL) {
+ _dwarf_error(NULL, error, DW_DLE_DWARF_LINE_NULL);
+ return (DW_DLV_ERROR);
+ }
+
+ *return_bool = (line->li_addr_line.li_l_data.li_basic_block);
+ return DW_DLV_OK;
+}
+
+
+#if 0 /* Ignore this. This needs major
+ re-work. */
+/*
+ This routine works by looking for exact matches between
+ the current line address and pc, and crossovers from
+ from less than pc value to greater than. At each line
+ that satisfies the above, it records a pointer to the
+ line, and the difference between the address and pc.
+ It then scans these pointers and picks out those with
+ the smallest difference between pc and address.
+*/
+int
+dwarf_pclines(Dwarf_Debug dbg,
+ Dwarf_Addr pc,
+ Dwarf_Line ** linebuf,
+ Dwarf_Signed slide,
+ Dwarf_Signed * linecount, Dwarf_Error * error)
+{
+ /*
+ Scans the line matrix for the current cu to which a pointer
+ exists in dbg. */
+ Dwarf_Line line;
+ Dwarf_Line prev_line;
+
+ /*
+ These flags are for efficiency reasons. Check_line is true
+ initially, but set false when the address of the current line is
+ greater than pc. It is set true only when the address of the
+ current line falls below pc. This assumes that addresses within
+ the same segment increase, and we are only interested in the
+ switch from a less than pc address to a greater than. First_line
+ is set true initially, but set false after the first line is
+ scanned. This is to prevent looking at the address of previous
+ line when slide is DW_DLS_BACKWARD, and the first line is being
+ scanned. */
+ Dwarf_Bool check_line, first_line;
+
+ /*
+ Diff tracks the smallest difference a line address and the input
+ pc value. */
+ Dwarf_Signed diff, i;
+
+ /*
+ For the slide = DW_DLS_BACKWARD case, pc_less is the value of
+ the address of the line immediately preceding the first line
+ that has value greater than pc. For the slide = DW_DLS_FORWARD
+ case, pc_more is the values of address for the first line that
+ is greater than pc. Diff is the difference between either of the
+ these values and pc. */
+ Dwarf_Addr pc_less, pc_more;
+
+ /*
+ Pc_line_buf points to a chain of pointers to lines of which
+ those with a diff equal to the smallest difference will be
+ returned. */
+ Dwarf_Line *pc_line_buf, *pc_line;
+
+ /*
+ Chain_count counts the number of lines in the above chain for
+ which the diff is equal to the smallest difference This is the
+ number returned by this routine. */
+ Dwarf_Signed chain_count;
+
+ chain_head = NULL;
+
+ check_line = true;
+ first_line = true;
+ diff = MAX_LINE_DIFF;
+
+ for (i = 0; i < dbg->de_cu_line_count; i++) {
+
+ line = *(dbg->de_cu_line_ptr + i);
+ prev_line = first_line ? NULL : *(dbg->de_cu_line_ptr + i - 1);
+
+ if (line->li_address == pc) {
+ chain_ptr = (struct chain *)
+ _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (chain_ptr == NULL) {
+ _dwarf_error(NULL, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ chain_ptr->line = line;
+ chain_ptr->diff = diff = 0;
+ chain_ptr->next = chain_head;
+ chain_head = chain_ptr;
+ } else
+ /*
+ Look for crossover from less than pc address to greater
+ than. */
+ if (check_line && line->li_address > pc &&
+ (first_line ? 0 : prev_line->li_address) < pc)
+
+ if (slide == DW_DLS_BACKWARD && !first_line) {
+ pc_less = prev_line->li_address;
+ if (pc - pc_less <= diff) {
+ chain_ptr = (struct chain *)
+ _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (chain_ptr == NULL) {
+ _dwarf_error(NULL, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ chain_ptr->line = prev_line;
+ chain_ptr->diff = diff = pc - pc_less;
+ chain_ptr->next = chain_head;
+ chain_head = chain_ptr;
+ }
+ check_line = false;
+ } else if (slide == DW_DLS_FORWARD) {
+ pc_more = line->li_address;
+ if (pc_more - pc <= diff) {
+ chain_ptr = (struct chain *)
+ _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
+ if (chain_ptr == NULL) {
+ _dwarf_error(NULL, error, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+
+ chain_ptr->line = line;
+ chain_ptr->diff = diff = pc_more - pc;
+ chain_ptr->next = chain_head;
+ chain_head = chain_ptr;
+ }
+ check_line = false;
+ } else
+ /* Check addresses only when they go */
+ /* below pc. */
+ if (line->li_address < pc)
+ check_line = true;
+
+ first_line = false;
+ }
+
+ chain_count = 0;
+ for (chain_ptr = chain_head; chain_ptr != NULL;
+ chain_ptr = chain_ptr->next)
+ if (chain_ptr->diff == diff)
+ chain_count++;
+
+ pc_line_buf = pc_line = (Dwarf_Line)
+ _dwarf_get_alloc(dbg, DW_DLA_LIST, chain_count);
+ for (chain_ptr = chain_head; chain_ptr != NULL;
+ chain_ptr = chain_ptr->next)
+ if (chain_ptr->diff == diff) {
+ *pc_line = chain_ptr->line;
+ pc_line++;
+ }
+
+ for (chain_ptr = chain_head; chain_ptr != NULL;) {
+ chain_head = chain_ptr;
+ chain_ptr = chain_ptr->next;
+ dwarf_dealloc(dbg, chain_head, DW_DLA_CHAIN);
+ }
+
+ *linebuf = pc_line_buf;
+ return (chain_count);
+}
+#endif
+
+
+
+/*
+ It's impossible for callers of dwarf_srclines() to get to and
+ free all the resources (in particular, the li_context and its
+ lc_file_entries).
+ So this function, new July 2005, does it.
+*/
+
+void
+dwarf_srclines_dealloc(Dwarf_Debug dbg, Dwarf_Line * linebuf,
+ Dwarf_Signed count)
+{
+
+ Dwarf_Signed i = 0;
+ struct Dwarf_Line_Context_s *context = 0;
+
+ if (count > 0) {
+ /* All these entries share a single context */
+ context = linebuf[0]->li_context;
+ }
+ for (i = 0; i < count; ++i) {
+ dwarf_dealloc(dbg, linebuf[i], DW_DLA_LINE);
+ }
+ dwarf_dealloc(dbg, linebuf, DW_DLA_LIST);
+
+ if (context) {
+ Dwarf_File_Entry fe = context->lc_file_entries;
+
+ while (fe) {
+ Dwarf_File_Entry fenext = fe->fi_next;
+
+ dwarf_dealloc(dbg, fe, DW_DLA_FILE_ENTRY);
+ fe = fenext;
+ }
+ dwarf_dealloc(dbg, context, DW_DLA_LINE_CONTEXT);
+ }
+
+ return;
+}
+
+/* Operand counts per standard operand.
+ The initial zero is for DW_LNS_copy.
+ This is an economical way to verify we understand the table
+ of standard-opcode-lengths in the line table prologue. */
+#define STANDARD_OPERAND_COUNT_DWARF2 9
+#define STANDARD_OPERAND_COUNT_DWARF3 12
+static unsigned char
+ dwarf_standard_opcode_operand_count[STANDARD_OPERAND_COUNT_DWARF3] = {
+ /* DWARF2 */
+ 0,
+ 1, 1, 1, 1,
+ 0, 0, 0,
+ 1,
+ /* Following are new for DWARF3. */
+ 0, 0, 1
+};
+
+/* Common line table prefix reading code.
+ Returns DW_DLV_OK, DW_DLV_ERROR.
+ DW_DLV_NO_ENTRY cannot be returned, but callers should
+ assume it is possible.
+
+ The prefix_out area must be initialized properly before calling this.
+
+ Has the side effect of allocating arrays which
+ must be freed (see the Line_Table_Prefix_s struct which
+ holds the pointers to space we allocate here).
+*/
+int
+dwarf_read_line_table_prefix(Dwarf_Debug dbg,
+ Dwarf_Small * data_start,
+ Dwarf_Unsigned data_length,
+ Dwarf_Small ** updated_data_start_out,
+ struct Line_Table_Prefix_s *prefix_out,
+ Dwarf_Error * err)
+{
+ Dwarf_Small *line_ptr = data_start;
+ Dwarf_Unsigned total_length = 0;
+ int local_length_size = 0;
+ int local_extension_size = 0;
+ Dwarf_Unsigned prologue_length = 0;
+ Dwarf_Half version = 0;
+ Dwarf_Unsigned directories_count = 0;
+ Dwarf_Unsigned directories_malloc = 0;
+ Dwarf_Unsigned files_count = 0;
+ Dwarf_Unsigned files_malloc = 0;
+ Dwarf_Small *line_ptr_end = 0;
+
+ prefix_out->pf_line_ptr_start = line_ptr;
+ /* READ_AREA_LENGTH updates line_ptr for consumed bytes */
+ READ_AREA_LENGTH(dbg, total_length, Dwarf_Unsigned,
+ line_ptr, local_length_size, local_extension_size);
+
+
+ line_ptr_end = line_ptr + total_length;
+ prefix_out->pf_line_ptr_end = line_ptr_end;
+ prefix_out->pf_length_field_length = local_length_size +
+ local_extension_size;
+ /* ASSERT: prefix_out->pf_length_field_length == line_ptr
+ -prefix_out->pf_line_ptr_start; */
+ if (line_ptr_end > dbg->de_debug_line + dbg->de_debug_line_size) {
+ _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);
+ return (DW_DLV_ERROR);
+ }
+ if (line_ptr_end > data_start + data_length) {
+ _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);
+ return (DW_DLV_ERROR);
+ }
+ prefix_out->pf_total_length = total_length;
+
+ READ_UNALIGNED(dbg, version, Dwarf_Half,
+ line_ptr, sizeof(Dwarf_Half));
+ prefix_out->pf_version = version;
+ line_ptr += sizeof(Dwarf_Half);
+ if (version != CURRENT_VERSION_STAMP &&
+ version != CURRENT_VERSION_STAMP3) {
+ _dwarf_error(dbg, err, DW_DLE_VERSION_STAMP_ERROR);
+ return (DW_DLV_ERROR);
+ }
+
+ READ_UNALIGNED(dbg, prologue_length, Dwarf_Unsigned,
+ line_ptr, local_length_size);
+ prefix_out->pf_prologue_length = prologue_length;
+ line_ptr += local_length_size;
+ prefix_out->pf_line_prologue_start = line_ptr;
+
+
+ prefix_out->pf_minimum_instruction_length =
+ *(unsigned char *) line_ptr;
+ line_ptr = line_ptr + sizeof(Dwarf_Small);
+
+ prefix_out->pf_default_is_stmt = *(unsigned char *) line_ptr;
+ line_ptr = line_ptr + sizeof(Dwarf_Small);
+
+ prefix_out->pf_line_base = *(signed char *) line_ptr;
+ line_ptr = line_ptr + sizeof(Dwarf_Sbyte);
+
+ prefix_out->pf_line_range = *(unsigned char *) line_ptr;
+ line_ptr = line_ptr + sizeof(Dwarf_Small);
+
+ prefix_out->pf_opcode_base = *(unsigned char *) line_ptr;
+ line_ptr = line_ptr + sizeof(Dwarf_Small);
+
+ /* Set up the array of standard opcode lengths. */
+ /* We think this works ok even for cross-endian processing of
+ objects. It might be wrong, we might need to specially process
+ the array of ubyte into host order. */
+ prefix_out->pf_opcode_length_table = line_ptr;
+
+ /* pf_opcode_base is one greater than the size of the array. */
+ line_ptr += prefix_out->pf_opcode_base - 1;
+
+ {
+ /* Determine (as best we can) whether the
+ pf_opcode_length_table holds 9 or 12 standard-conforming
+ entries. gcc4 upped to DWARF3's 12 without updating the
+ version number. */
+ int operand_ck_fail = true;
+
+ if (prefix_out->pf_opcode_base >= STANDARD_OPERAND_COUNT_DWARF3) {
+ int mismatch = memcmp(dwarf_standard_opcode_operand_count,
+ prefix_out->pf_opcode_length_table,
+ STANDARD_OPERAND_COUNT_DWARF3);
+
+ if (!mismatch) {
+ operand_ck_fail = false;
+ prefix_out->pf_std_op_count =
+ STANDARD_OPERAND_COUNT_DWARF3;
+ }
+
+ }
+ if (operand_ck_fail) {
+ if (prefix_out->pf_opcode_base >=
+ STANDARD_OPERAND_COUNT_DWARF2) {
+
+ int mismatch =
+ memcmp(dwarf_standard_opcode_operand_count,
+ prefix_out->pf_opcode_length_table,
+ STANDARD_OPERAND_COUNT_DWARF2);
+
+ if (!mismatch) {
+ operand_ck_fail = false;
+ prefix_out->pf_std_op_count =
+ STANDARD_OPERAND_COUNT_DWARF2;
+ }
+ }
+ }
+ if (operand_ck_fail) {
+ _dwarf_error(dbg, err, DW_DLE_LINE_NUM_OPERANDS_BAD);
+ return (DW_DLV_ERROR);
+ }
+ }
+ /* At this point we no longer need to check operand counts. */
+
+
+ directories_count = 0;
+ directories_malloc = 5;
+ prefix_out->pf_include_directories = malloc(sizeof(Dwarf_Small *) *
+ directories_malloc);
+ if (prefix_out->pf_include_directories == NULL) {
+ _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ memset(prefix_out->pf_include_directories, 0,
+ sizeof(Dwarf_Small *) * directories_malloc);
+
+ while ((*(char *) line_ptr) != '\0') {
+ if (directories_count >= directories_malloc) {
+ Dwarf_Unsigned expand = 2 * directories_malloc;
+ Dwarf_Unsigned bytesalloc = sizeof(Dwarf_Small *) * expand;
+ Dwarf_Small **newdirs =
+ realloc(prefix_out->pf_include_directories,
+ bytesalloc);
+
+ if (!newdirs) {
+ _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ /* Doubled size, zero out second half. */
+ memset(newdirs + directories_malloc, 0,
+ sizeof(Dwarf_Small *) * directories_malloc);
+ directories_malloc = expand;
+ prefix_out->pf_include_directories = newdirs;
+ }
+ prefix_out->pf_include_directories[directories_count] =
+ line_ptr;
+ line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
+ directories_count++;
+ }
+ prefix_out->pf_include_directories_count = directories_count;
+ line_ptr++;
+
+ files_count = 0;
+ files_malloc = 5;
+ prefix_out->pf_line_table_file_entries =
+ malloc(sizeof(struct Line_Table_File_Entry_s) * files_malloc);
+ if (prefix_out->pf_line_table_file_entries == NULL) {
+ _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ memset(prefix_out->pf_line_table_file_entries, 0,
+ sizeof(struct Line_Table_File_Entry_s) * files_malloc);
+
+ while (*(char *) line_ptr != '\0') {
+ Dwarf_Unsigned utmp;
+ Dwarf_Unsigned dir_index = 0;
+ Dwarf_Unsigned lastmod = 0;
+ Dwarf_Unsigned file_length = 0;
+ struct Line_Table_File_Entry_s *curline;
+ Dwarf_Word leb128_length = 0;
+
+
+ if (files_count >= files_malloc) {
+ Dwarf_Unsigned expand = 2 * files_malloc;
+ struct Line_Table_File_Entry_s *newfiles =
+ realloc(prefix_out->pf_line_table_file_entries,
+ sizeof(struct Line_Table_File_Entry_s) *
+ expand);
+ if (!newfiles) {
+ _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
+ return (DW_DLV_ERROR);
+ }
+ memset(newfiles + files_malloc, 0,
+ sizeof(struct Line_Table_File_Entry_s) *
+ files_malloc);
+ files_malloc = expand;
+ prefix_out->pf_line_table_file_entries = newfiles;
+ }
+ curline = prefix_out->pf_line_table_file_entries + files_count;
+
+ curline->lte_filename = line_ptr;
+ line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
+
+ DECODE_LEB128_UWORD(line_ptr, utmp);
+ dir_index = (Dwarf_Sword) utmp;
+ if (dir_index > directories_count) {
+ _dwarf_error(dbg, err, DW_DLE_DIR_INDEX_BAD);
+ return (DW_DLV_ERROR);
+ }
+ curline->lte_directory_index = dir_index;
+
+ lastmod = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
+ line_ptr = line_ptr + leb128_length;
+ curline->lte_last_modification_time = lastmod;
+
+ /* Skip over file length. */
+ file_length = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
+ line_ptr = line_ptr + leb128_length;
+ curline->lte_length_of_file = file_length;
+
+ ++files_count;
+
+ }
+ prefix_out->pf_files_count = files_count;
+ /* Skip trailing nul byte */
+ ++line_ptr;
+
+
+ if (line_ptr != (prefix_out->pf_line_prologue_start +
+ prefix_out->pf_prologue_length)) {
+ _dwarf_error(dbg, err, DW_DLE_LINE_PROLOG_LENGTH_BAD);
+ return (DW_DLV_ERROR);
+ }
+
+
+ *updated_data_start_out = line_ptr;
+ return DW_DLV_OK;
+}
+
+
+/* Initialize the Line_Table_Prefix_s struct.
+ memset is not guaranteed a portable initializer, but works
+ fine for current architectures. AFAIK.
+*/
+void
+dwarf_init_line_table_prefix(struct Line_Table_Prefix_s *pf)
+{
+ memset(pf, 0, sizeof(*pf));
+}
+
+/* Free any malloc'd area. of the Line_Table_Prefix_s struct. */
+void
+dwarf_free_line_table_prefix(struct Line_Table_Prefix_s *pf)
+{
+ if (pf->pf_include_directories) {
+ free(pf->pf_include_directories);
+ pf->pf_include_directories = 0;
+ }
+ if (pf->pf_line_table_file_entries) {
+ free(pf->pf_line_table_file_entries);
+ pf->pf_line_table_file_entries = 0;
+ }
+ return;
+}