/*

  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