/*

  Copyright (C) 2000,2002,2003,2004,2005 Silicon Graphics, 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

*/

#if (!defined(HAVE_RAW_LIBELF_OK) && defined(HAVE_LIBELF_OFF64_OK) )

#endif

#include "config.h"

#include "dwarf_incl.h"

#ifdef HAVE_ELF_H

#include <elf.h>

#endif

#ifdef __SGI_FAST_LIBELF

#include <libelf_sgi.h>

#else

#ifdef HAVE_LIBELF_H

#include <libelf.h>

#else

#ifdef HAVE_LIBELF_LIBELF_H

#include <libelf/libelf.h>

#endif

#endif

#endif /* !defined(__SGI_FAST_LIBELF) */

#include <stdio.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <string.h>

#include <stdlib.h>

#include "dwarf_incl.h"

#include "malloc_check.h"

#define DWARF_DBG_ERROR(dbg,errval,retval) \

     _dwarf_error(dbg, error, errval); return(retval);

#define FALSE	0

#define TRUE	1

#ifdef __SGI_FAST_LIBELF

#else

#ifdef HAVE_ELF64_GETEHDR

extern Elf64_Ehdr *elf64_getehdr(Elf *);

#endif

#ifdef HAVE_ELF64_GETSHDR

extern Elf64_Shdr *elf64_getshdr(Elf_Scn *);

#endif

#endif /* !defined(__SGI_FAST_LIBELF) */

/* This static is copied to the dbg on dbg init

   so that the static need not be referenced at

   run time, preserving better locality of

   reference.

   Value is 0 means do the string check.

   Value non-zero means do not do the check.

*/

static Dwarf_Small _dwarf_assume_string_bad;

int

dwarf_set_stringcheck(int newval)

{

    int oldval = _dwarf_assume_string_bad;

    _dwarf_assume_string_bad = newval;

    return oldval;

}

#ifdef __SGI_FAST_LIBELF

/*

	This function translates an elf_sgi error code into a libdwarf

	code.

 */

static int

_dwarf_error_code_from_elf_sgi_error_code(enum elf_sgi_error_type val)

{

    switch (val) {

    case ELF_SGI_ERROR_OK:

	return DW_DLE_NE;

    case ELF_SGI_ERROR_BAD_ALLOC:

	return DW_DLE_MAF;

    case ELF_SGI_ERROR_FORMAT:

	return DW_DLE_MDE;

    case ELF_SGI_ERROR_ERRNO:

	return DW_DLE_IOF;

    case ELF_SGI_ERROR_TOO_BIG:

	return DW_DLE_MOF;

    default:

	return DW_DLE_LEE;

    }

}

#endif

/*

    Given an Elf ptr, set up dbg with pointers

    to all the Dwarf data sections.

    Return NULL on error.

    This function is also responsible for determining

    whether the given object contains Dwarf information

    or not.  The test currently used is that it contains

    either a .debug_info or a .debug_frame section.  If 

    not, it returns DW_DLV_NO_ENTRY causing dwarf_init() also to 

    return DW_DLV_NO_ENTRY.  Earlier, we had thought of using only 

    the presence/absence of .debug_info to test, but we 

    added .debug_frame since there could be stripped objects 

    that have only a .debug_frame section for exception 

    processing.

    DW_DLV_NO_ENTRY or DW_DLV_OK or DW_DLV_ERROR

*/

static int

_dwarf_setup(Dwarf_Debug dbg, dwarf_elf_handle elf, Dwarf_Error * error)

{

#ifdef __SGI_FAST_LIBELF

    Elf64_Ehdr ehdr;

    Elf64_Shdr shdr;

    enum elf_sgi_error_type sres;

    unsigned char const *ehdr_ident = 0;

#else

    Elf32_Ehdr *ehdr32 = 0;

#ifdef HAVE_ELF64_GETEHDR

    Elf64_Ehdr *ehdr64 = 0;

#endif

    Elf32_Shdr *shdr32 = 0;

#ifdef HAVE_ELF64_GETSHDR

    Elf64_Shdr *shdr64 = 0;

#endif

    Elf_Scn *scn = 0;

    char *ehdr_ident = 0;

#endif /* !defined(__SGI_FAST_LIBELF) */

    Dwarf_Half machine = 0;

    char *scn_name = 0;

    int is_64bit = 0;

    int foundDwarf = 0;

    Dwarf_Unsigned section_size = 0;

    Dwarf_Unsigned section_count = 0;

    Dwarf_Half section_index = 0;

    Dwarf_Addr section_addr = 0;

    foundDwarf = FALSE;

    dbg->de_elf = elf;

    dbg->de_assume_string_in_bounds = _dwarf_assume_string_bad;

#ifdef __SGI_FAST_LIBELF

    sres = elf_sgi_ehdr(elf, &ehdr);

    if (sres != ELF_SGI_ERROR_OK) {

	DWARF_DBG_ERROR(dbg,

			_dwarf_error_code_from_elf_sgi_error_code(sres),

			DW_DLV_ERROR);

    }

    ehdr_ident = ehdr.e_ident;

    section_count = ehdr.e_shnum;

    machine = ehdr.e_machine;

#else

    if ((ehdr_ident = elf_getident(elf, NULL)) == NULL) {

	DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETIDENT_ERROR, DW_DLV_ERROR);

    }

#endif

    is_64bit = (ehdr_ident[EI_CLASS] == ELFCLASS64);

    dbg->de_same_endian = 1;

    dbg->de_copy_word = memcpy;

#ifdef WORDS_BIGENDIAN

    dbg->de_big_endian_object = 1;

    if (ehdr_ident[EI_DATA] == ELFDATA2LSB) {

	dbg->de_same_endian = 0;

	dbg->de_big_endian_object = 0;

	dbg->de_copy_word = _dwarf_memcpy_swap_bytes;

    }

#else /* little endian */

    dbg->de_big_endian_object = 0;

    if (ehdr_ident[EI_DATA] == ELFDATA2MSB) {

	dbg->de_same_endian = 0;

	dbg->de_big_endian_object = 1;

	dbg->de_copy_word = _dwarf_memcpy_swap_bytes;

    }

#endif /* !WORDS_BIGENDIAN */

    /* The following de_length_size is Not Too Significant. Only used

       one calculation, and an approximate one at that. */

    dbg->de_length_size = is_64bit ? 8 : 4;

    dbg->de_pointer_size = is_64bit ? 8 : 4;

#ifdef __SGI_FAST_LIBELF

    /* We've already loaded the ELF header, so there's nothing to do

       here */

#else

#ifdef HAVE_ELF64_GETEHDR

    if (is_64bit) {

	ehdr64 = elf64_getehdr(elf);

	if (ehdr64 == NULL) {

	    DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETEHDR_ERROR,

			    DW_DLV_ERROR);

	}

	section_count = ehdr64->e_shnum;

	machine = ehdr64->e_machine;

    } else

#endif

    {

	ehdr32 = elf32_getehdr(elf);

	if (ehdr32 == NULL) {

	    DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETEHDR_ERROR,

			    DW_DLV_ERROR);

	}

	section_count = ehdr32->e_shnum;

	machine = ehdr32->e_machine;

    }

#endif /* !defined(__SGI_FAST_LIBELF) */

    if (is_64bit && machine != EM_MIPS) {

	/* MIPS/IRIX makes pointer size and length size 8 for -64.

	   Other platforms make length 4 always. */

	/* 4 here supports 32bit-offset dwarf2, as emitted by cygnus

	   tools, and the dwarfv2.1 64bit extension setting. */

	dbg->de_length_size = 4;

    }

    /* We start at index 1 to skip the initial empty section. */

    for (section_index = 1; section_index < section_count;

	 ++section_index) {

#ifdef __SGI_FAST_LIBELF

	sres = elf_sgi_shdr(elf, section_index, &shdr);

	if (sres != ELF_SGI_ERROR_OK) {

	    DWARF_DBG_ERROR(dbg,

			    _dwarf_error_code_from_elf_sgi_error_code

			    (sres), DW_DLV_ERROR);

	}

	section_size = shdr.sh_size;

	section_addr = shdr.sh_addr;

	sres =

	    elf_sgi_string(elf, ehdr.e_shstrndx, shdr.sh_name,

			   (char const **) &scn_name);

	if (sres != ELF_SGI_ERROR_OK) {

	    DWARF_DBG_ERROR(dbg,

			    _dwarf_error_code_from_elf_sgi_error_code

			    (sres), DW_DLV_ERROR);

	}

#else /* !defined(__SGI_FAST_LIBELF) */

	scn = elf_getscn(elf, section_index);

	if (scn == NULL) {

	    DWARF_DBG_ERROR(dbg, DW_DLE_MDE, DW_DLV_ERROR);

	}

#ifdef HAVE_ELF64_GETSHDR

	if (is_64bit) {

	    shdr64 = elf64_getshdr(scn);

	    if (shdr64 == NULL) {

		DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETSHDR_ERROR,

				DW_DLV_ERROR);

	    }

	    section_size = shdr64->sh_size;

	    section_addr = shdr64->sh_addr;

	    if ((scn_name = elf_strptr(elf, ehdr64->e_shstrndx,

				       shdr64->sh_name))

		== NULL) {

		DWARF_DBG_ERROR(dbg, DW_DLE_ELF_STRPTR_ERROR,

				DW_DLV_ERROR);

	    }

	} else

#endif /* HAVE_ELF64_GETSHDR */

	{

	    if ((shdr32 = elf32_getshdr(scn)) == NULL) {

		DWARF_DBG_ERROR(dbg, DW_DLE_ELF_GETSHDR_ERROR, 0);

	    }

	    section_size = shdr32->sh_size;

	    section_addr = shdr32->sh_addr;

	    if ((scn_name = elf_strptr(elf, ehdr32->e_shstrndx,

				       shdr32->sh_name)) == NULL) {

		DWARF_DBG_ERROR(dbg, DW_DLE_ELF_STRPTR_ERROR,

				DW_DLV_ERROR);

	    }

	}

#endif /* !defined(__SGI_FAST_LIBELF) */

	if (strncmp(scn_name, ".debug_", 7)

	    && strcmp(scn_name, ".eh_frame")

	    )

	    continue;

	else if (strcmp(scn_name, ".debug_info") == 0) {

	    if (dbg->de_debug_info != NULL) {

		DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_INFO_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* Know no reason to allow empty debug_info section */

		DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_INFO_NULL,

				DW_DLV_ERROR);

	    }

	    foundDwarf = TRUE;

	    dbg->de_debug_info_index = section_index;

	    dbg->de_debug_info_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_abbrev") == 0) {

	    if (dbg->de_debug_abbrev != NULL) {

		DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_ABBREV_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* Know no reason to allow empty debug_abbrev section */

		DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_ABBREV_NULL,

				DW_DLV_ERROR);

	    }

	    dbg->de_debug_abbrev_index = section_index;

	    dbg->de_debug_abbrev_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_aranges") == 0) {

	    if (dbg->de_debug_aranges_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_ARANGES_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_aranges_index = section_index;

	    dbg->de_debug_aranges_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_line") == 0) {

	    if (dbg->de_debug_line_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_LINE_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_line_index = section_index;

	    dbg->de_debug_line_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_frame") == 0) {

	    if (dbg->de_debug_frame_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_FRAME_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_frame_index = section_index;

	    dbg->de_debug_frame_size = section_size;

	    foundDwarf = TRUE;

	} else if (strcmp(scn_name, ".eh_frame") == 0) {

	    /* gnu egcs-1.1.2 data */

	    if (dbg->de_debug_frame_eh_gnu_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_FRAME_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_frame_eh_gnu_index = section_index;

	    dbg->de_debug_frame_size_eh_gnu = section_size;

	    dbg->de_debug_frame_eh_addr = section_addr;

	    foundDwarf = TRUE;

	}

	else if (strcmp(scn_name, ".debug_loc") == 0) {

	    if (dbg->de_debug_loc_index != 0) {

		DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_LOC_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_loc_index = section_index;

	    dbg->de_debug_loc_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_pubnames") == 0) {

	    if (dbg->de_debug_pubnames_index != 0) {

		DWARF_DBG_ERROR(dbg, DW_DLE_DEBUG_PUBNAMES_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_pubnames_index = section_index;

	    dbg->de_debug_pubnames_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_str") == 0) {

	    if (dbg->de_debug_str_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_STR_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_str_index = section_index;

	    dbg->de_debug_str_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_funcnames") == 0) {

	    if (dbg->de_debug_funcnames_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_FUNCNAMES_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_funcnames_index = section_index;

	    dbg->de_debug_funcnames_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_typenames") == 0) {

	    /* SGI IRIX-only, created years before DWARF3. Content

	       essentially identical to .debug_pubtypes.  */

	    if (dbg->de_debug_typenames_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_TYPENAMES_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_typenames_index = section_index;

	    dbg->de_debug_typenames_size = section_size;

	} else if (strcmp(scn_name, ".debug_pubtypes") == 0) {

	    /* Section new in DWARF3.  */

	    if (dbg->de_debug_pubtypes_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_PUBTYPES_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_pubtypes_index = section_index;

	    dbg->de_debug_pubtypes_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_varnames") == 0) {

	    if (dbg->de_debug_varnames_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_VARNAMES_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_varnames_index = section_index;

	    dbg->de_debug_varnames_size = section_size;

	}

	else if (strcmp(scn_name, ".debug_weaknames") == 0) {

	    if (dbg->de_debug_weaknames_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_WEAKNAMES_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {

		/* a zero size section is just empty. Ok, no error */

		continue;

	    }

	    dbg->de_debug_weaknames_index = section_index;

	    dbg->de_debug_weaknames_size = section_size;

	} else if (strcmp(scn_name, ".debug_macinfo") == 0) {

	    if (dbg->de_debug_macinfo_index != 0) {

		DWARF_DBG_ERROR(dbg,

				DW_DLE_DEBUG_MACINFO_DUPLICATE,

				DW_DLV_ERROR);

	    }

	    if (section_size == 0) {