/*

  Copyright (C) 2000,2004,2006 Silicon Graphics, Inc.  All Rights Reserved.

  Portions Copyright (C) 2007 David Anderson. All Rights Reserved.

  Portions Copyright 2002 Sun Microsystems, Inc. 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

*/

/* 

   SGI has moved from the Crittenden Lane address.

*/

#include "config.h"

#include "libdwarfdefs.h"

#include <stdio.h>

#include <string.h>

#ifdef   HAVE_ELFACCESS_H

#include <elfaccess.h>

#endif

#include "pro_incl.h"

#include "pro_section.h"

#include "pro_line.h"

#include "pro_frame.h"

#include "pro_die.h"

#include "pro_macinfo.h"

#include "pro_types.h"

#ifndef SHF_MIPS_NOSTRIP

/* if this is not defined, we probably don't need it: just use 0 */

#define SHF_MIPS_NOSTRIP 0

#endif

#ifndef R_MIPS_NONE

#define R_MIPS_NONE 0

#endif

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE 0

#endif

/* must match up with pro_section.h defines of DEBUG_INFO etc 

and sectnames (below).  REL_SEC_PREFIX is either ".rel" or ".rela"

see pro_incl.h

*/

char *_dwarf_rel_section_names[] = {

    REL_SEC_PREFIX ".debug_info",

    REL_SEC_PREFIX ".debug_line",

    REL_SEC_PREFIX ".debug_abbrev",	/* no relocations on this, really */

    REL_SEC_PREFIX ".debug_frame",

    REL_SEC_PREFIX ".debug_aranges",

    REL_SEC_PREFIX ".debug_pubnames",

    REL_SEC_PREFIX ".debug_str",

    REL_SEC_PREFIX ".debug_funcnames",	/* sgi extension */

    REL_SEC_PREFIX ".debug_typenames",	/* sgi extension */

    REL_SEC_PREFIX ".debug_varnames",	/* sgi extension */

    REL_SEC_PREFIX ".debug_weaknames",	/* sgi extension */

    REL_SEC_PREFIX ".debug_macinfo",

    REL_SEC_PREFIX ".debug_loc"

};

/* names of sections. Ensure that it matches the defines 

   in pro_section.h, in the same order 

   Must match also _dwarf_rel_section_names above

*/

char *_dwarf_sectnames[] = {

    ".debug_info",

    ".debug_line",

    ".debug_abbrev",

    ".debug_frame",

    ".debug_aranges",

    ".debug_pubnames",

    ".debug_str",

    ".debug_funcnames",		/* sgi extension */

    ".debug_typenames",		/* sgi extension */

    ".debug_varnames",		/* sgi extension */

    ".debug_weaknames",		/* sgi extension */

    ".debug_macinfo",

    ".debug_loc"

};

static Dwarf_Ubyte std_opcode_len[] = { 0,	/* DW_LNS_copy */

    1,				/* DW_LNS_advance_pc */

    1,				/* DW_LNS_advance_line */

    1,				/* DW_LNS_set_file */

    1,				/* DW_LNS_set_column */

    0,				/* DW_LNS_negate_stmt */

    0,				/* DW_LNS_set_basic_block */

    0,				/* DW_LNS_const_add_pc */

    1,				/* DW_LNS_fixed_advance_pc */

};

/* struct to hold relocation entries. Its mantained as a linked

   list of relocation structs, and will then be written at as a

   whole into the relocation section. Whether its 32 bit or

   64 bit will be obtained from Dwarf_Debug pointer.

*/

typedef struct Dwarf_P_Rel_s *Dwarf_P_Rel;

struct Dwarf_P_Rel_s {

    Dwarf_P_Rel dr_next;

    void *dr_rel_datap;

};

typedef struct Dwarf_P_Rel_Head_s *Dwarf_P_Rel_Head;

struct Dwarf_P_Rel_Head_s {

    struct Dwarf_P_Rel_s *drh_head;

    struct Dwarf_P_Rel_s *drh_tail;

};

static int _dwarf_pro_generate_debugline(Dwarf_P_Debug dbg,

					 Dwarf_Error * error);

static int _dwarf_pro_generate_debugframe(Dwarf_P_Debug dbg,

					  Dwarf_Error * error);

static int _dwarf_pro_generate_debuginfo(Dwarf_P_Debug dbg,

					 Dwarf_Error * error);

static Dwarf_P_Abbrev _dwarf_pro_getabbrev(Dwarf_P_Die, Dwarf_P_Abbrev);

static int _dwarf_pro_match_attr

    (Dwarf_P_Attribute, Dwarf_P_Abbrev, int no_attr);

/* these macros used as return value for below functions */

#define		OPC_INCS_ZERO		-1

#define		OPC_OUT_OF_RANGE	-2

#define		LINE_OUT_OF_RANGE	-3

static int _dwarf_pro_get_opc(Dwarf_Unsigned addr_adv, int line_adv);

/* BEGIN_LEN_SIZE is the size of the 'length' field in total. 

   Which may be 4,8, or 12 bytes! 

   4 is standard DWARF2.

   8 is non-standard MIPS-IRIX 64-bit.

   12 is standard DWARF3 for 64 bit offsets.

   Used in various routines: local variable names

   must match the names here.

*/

#define BEGIN_LEN_SIZE (uwordb_size + extension_size)

/*

	Return TRUE if we need the section, FALSE otherwise

        If any of the 'line-data-related' calls were made

        including file or directory entries,

        produce .debug_line .

*/

static int

dwarf_need_debug_line_section(Dwarf_P_Debug dbg)

{

    if (dbg->de_lines == NULL && dbg->de_file_entries == NULL

	&& dbg->de_inc_dirs == NULL) {

	return FALSE;

    }

    return TRUE;

}

/*

    Convert debug information to  a format such that 

    it can be written on disk.

    Called exactly once per execution.

*/

Dwarf_Signed

dwarf_transform_to_disk_form(Dwarf_P_Debug dbg, Dwarf_Error * error)

{

    /* 

       Section data in written out in a number of buffers. Each

       _generate_*() function returns a cumulative count of buffers for 

       all the sections. get_section_bytes() returns pointers to these

       buffers one at a time. */

    int nbufs;

    int sect;

    int name_idx;

    int err;

    Dwarf_Unsigned du;

    if (dbg->de_version_magic_number != PRO_VERSION_MAGIC) {

	DWARF_P_DBG_ERROR(dbg, DW_DLE_IA, DW_DLV_NOCOUNT);

    }

    /* Create dwarf section headers */

    for (sect = 0; sect < NUM_DEBUG_SECTIONS; sect++) {

	long flags = 0;

	switch (sect) {

	case DEBUG_INFO:

	    if (dbg->de_dies == NULL)

		continue;

	    break;

	case DEBUG_LINE:

	    if (dwarf_need_debug_line_section(dbg) == FALSE) {

		continue;

	    }

	    break;

	case DEBUG_ABBREV:

	    if (dbg->de_dies == NULL)

		continue;

	    break;

	case DEBUG_FRAME:

	    if (dbg->de_frame_cies == NULL)

		continue;

	    flags = SHF_MIPS_NOSTRIP;

	    break;

	case DEBUG_ARANGES:

	    if (dbg->de_arange == NULL)

		continue;

	    break;

	case DEBUG_PUBNAMES:

	    if (dbg->de_simple_name_headers[dwarf_snk_pubname].

		sn_head == NULL)

		continue;

	    break;

	case DEBUG_STR:

	    if (dbg->de_strings == NULL)

		continue;

	    break;

	case DEBUG_FUNCNAMES:

	    if (dbg->de_simple_name_headers[dwarf_snk_funcname].

		sn_head == NULL)

		continue;

	    break;

	case DEBUG_TYPENAMES:

	    if (dbg->de_simple_name_headers[dwarf_snk_typename].

		sn_head == NULL)

		continue;

	    break;

	case DEBUG_VARNAMES:

	    if (dbg->de_simple_name_headers[dwarf_snk_varname].

		sn_head == NULL)

		continue;

	    break;

	case DEBUG_WEAKNAMES:

	    if (dbg->de_simple_name_headers[dwarf_snk_weakname].

		sn_head == NULL)

		continue;

	    break;

	case DEBUG_MACINFO:

	    if (dbg->de_first_macinfo == NULL)

		continue;

	    break;

	case DEBUG_LOC:

	    /* not handled yet */

	    continue;

	default:

	    /* logic error: missing a case */

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_ELF_SECT_ERR, DW_DLV_NOCOUNT);

	}

	{

	    int new_base_elf_sect;

	    if (dbg->de_func_b) {

		new_base_elf_sect =

		    dbg->de_func_b(_dwarf_sectnames[sect],

				   /* rec size */ 1,

				   SECTION_TYPE,

				   flags, SHN_UNDEF, 0, &du, &err);

	    } else {

		new_base_elf_sect = dbg->de_func(_dwarf_sectnames[sect],

						 dbg->

						 de_relocation_record_size,

						 SECTION_TYPE, flags,

						 SHN_UNDEF, 0,

						 &name_idx, &err);

		du = name_idx;

	    }

	    if (new_base_elf_sect == -1) {

		DWARF_P_DBG_ERROR(dbg, DW_DLE_ELF_SECT_ERR,

				  DW_DLV_NOCOUNT);

	    }

	    dbg->de_elf_sects[sect] = new_base_elf_sect;

	    dbg->de_sect_name_idx[sect] = du;

	}

    }

    nbufs = 0;

    /* 

       Changing the order in which the sections are generated may cause 

       problems because of relocations. */

    if (dwarf_need_debug_line_section(dbg) == TRUE) {

	nbufs = _dwarf_pro_generate_debugline(dbg, error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGLINE_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_frame_cies) {

	nbufs = _dwarf_pro_generate_debugframe(dbg, error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGFRAME_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_first_macinfo) {

	nbufs = _dwarf_pro_transform_macro_info_to_disk(dbg, error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGMACINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_dies) {

	nbufs = _dwarf_pro_generate_debuginfo(dbg, error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_arange) {

	nbufs = _dwarf_transform_arange_to_disk(dbg, error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_simple_name_headers[dwarf_snk_pubname].sn_head) {

	nbufs = _dwarf_transform_simplename_to_disk(dbg,

						    dwarf_snk_pubname,

						    DEBUG_PUBNAMES,

						    error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_simple_name_headers[dwarf_snk_funcname].sn_head) {

	nbufs = _dwarf_transform_simplename_to_disk(dbg,

						    dwarf_snk_funcname,

						    DEBUG_FUNCNAMES,

						    error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_simple_name_headers[dwarf_snk_typename].sn_head) {

	nbufs = _dwarf_transform_simplename_to_disk(dbg,

						    dwarf_snk_typename,

						    DEBUG_TYPENAMES,

						    error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_simple_name_headers[dwarf_snk_varname].sn_head) {

	nbufs = _dwarf_transform_simplename_to_disk(dbg,

						    dwarf_snk_varname,

						    DEBUG_VARNAMES,

						    error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    if (dbg->de_simple_name_headers[dwarf_snk_weakname].sn_head) {

	nbufs = _dwarf_transform_simplename_to_disk(dbg,

						    dwarf_snk_weakname,

						    DEBUG_WEAKNAMES,

						    error);

	if (nbufs < 0) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

    }

    {

	Dwarf_Signed new_secs;

	int res;

	res = dbg->de_transform_relocs_to_disk(dbg, &new_secs);

	if (res != DW_DLV_OK) {

	    DWARF_P_DBG_ERROR(dbg, DW_DLE_DEBUGINFO_ERROR,

			      DW_DLV_NOCOUNT);

	}

	nbufs += new_secs;

    }

    return nbufs;

}

/*---------------------------------------------------------------

	Generate debug_line section 

---------------------------------------------------------------*/

static int

_dwarf_pro_generate_debugline(Dwarf_P_Debug dbg, Dwarf_Error * error)

{

    Dwarf_P_Inc_Dir curdir = 0;

    Dwarf_P_F_Entry curentry = 0;

    Dwarf_P_Line curline = 0;

    Dwarf_P_Line prevline = 0;

    /* all data named cur* are used to loop thru linked lists */

    int sum_bytes = 0;

    int prolog_size = 0;

    unsigned char *data = 0;	/* holds disk form data */

    int elfsectno = 0;

    unsigned char *start_line_sec = 0;	/* pointer to the buffer at

					   section start */

    /* temps for memcpy */

    Dwarf_Unsigned du = 0;

    Dwarf_Ubyte db = 0;

    Dwarf_Half dh = 0;

    int res = 0;

    int uwordb_size = dbg->de_offset_size;

    int extension_size = dbg->de_64bit_extension ? 4 : 0;

    int upointer_size = dbg->de_pointer_size;

    char buff1[ENCODE_SPACE_NEEDED];

    sum_bytes = 0;

    elfsectno = dbg->de_elf_sects[DEBUG_LINE];

    /* include directories */

    curdir = dbg->de_inc_dirs;

    while (curdir) {

	prolog_size += strlen(curdir->did_name) + 1;

	curdir = curdir->did_next;

    }

    prolog_size++;		/* last null following last directory

				   entry. */

    /* file entries */

    curentry = dbg->de_file_entries;

    while (curentry) {

	prolog_size +=

	    strlen(curentry->dfe_name) + 1 + curentry->dfe_nbytes;

	curentry = curentry->dfe_next;

    }

    prolog_size++;		/* last null byte */

    prolog_size += BEGIN_LEN_SIZE + sizeof_uhalf(dbg) +	/* version # */

	uwordb_size +		/* header length */

	sizeof_ubyte(dbg) +	/* min_instr length */

	sizeof_ubyte(dbg) +	/* default is_stmt */

	sizeof_ubyte(dbg) +	/* linebase */

	sizeof_ubyte(dbg) +	/* linerange */

	sizeof_ubyte(dbg);	/* opcode base */

    /* length of table specifying # of opnds */

    prolog_size += sizeof(std_opcode_len);

    GET_CHUNK(dbg, elfsectno, data, prolog_size, error);

    start_line_sec = data;

    /* copy over the data */

    /* total_length */

    du = 0;

    if (extension_size) {

	Dwarf_Word x = DISTINGUISHED_VALUE;

	WRITE_UNALIGNED(dbg, (void *) data, (const void *) &x,

			sizeof(x), extension_size);

	data += extension_size;

    }

    WRITE_UNALIGNED(dbg, (void *) data, (const void *) &du,

		    sizeof(du), uwordb_size);

    data += uwordb_size;

    dh = VERSION;

    WRITE_UNALIGNED(dbg, (void *) data, (const void *) &dh,

		    sizeof(dh), sizeof(Dwarf_Half));

    data += sizeof(Dwarf_Half);