/*
  Copyright (C) 2000,2004 Silicon Graphics, Inc.  All Rights Reserved.
  Portions Copyright 2002-2010 Sun Microsystems, Inc. All rights reserved.
  Portions Copyright 2008-2017 David Anderson, Inc. All rights reserved.
  Portions Copyright 2012 SN Systems Ltd. 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.

*/

#include <config.h>

#include <stddef.h> /* NULL */
#include <string.h> /* memset() strcmp() */

#ifdef HAVE_STDINT_H
#include <stdint.h> /* uintptr_t */
#endif

#ifdef DWARF_WITH_LIBELF
#ifdef HAVE_LIBELF_H
#include <libelf.h>
#endif /* HAVE_LIBELF_H */
#ifdef HAVE_LIBELF_LIBELF_H
#include <libelf/libelf.h>
#endif /* HAVE_LIBELF_LIBELF_H */
#ifdef HAVE_ELF_H /* does includes of elf.h libelf.h here. */
#include <elf.h>
#endif /* HAVE_ELF_H */
#endif /* DWARF_WITH_LIBELF */

#include "dwarf.h"
#include "libdwarf.h"
#include "dwarf_base_types.h"
#include "libdwarfp.h"
#include "dwarf_pro_incl.h"
#include "dwarf_pro_opaque.h"
#include "dwarf_pro_error.h"
#include "dwarf_pro_alloc.h"
#include "dwarf_pro_line.h"
#include "dwarf_memcpy_swap.h"
#include "dwarf_pro_section.h"        /* for MAGIC_SECT_NO */
#include "dwarf_pro_reloc_symbolic.h"
#include "dwarf_pro_reloc_stream.h"
#include "dwarf_tsearch.h"
#include "dwarf_string.h"

#define IS_64BITPTR(dbg) ((dbg)->de_flags & DW_DLC_POINTER64 ? 1 : 0)
#define ISA_IA64(dbg) ((dbg)->de_flags & DW_DLC_ISA_IA64 ? 1 : 0)

struct isa_relocs_s {
    const char *name_;
    int         reloc32_;
    int         reloc64_;
    int         segrel_; /* only used if IRIX */
};

/*  Some of these may be the wrong relocation for DWARF
    relocations. FIXME. Most will be unusable without
    additional effort as they have not been tested.
*/
#define R_MIPS_32         2
#define R_MIPS_64         18
#define R_MIPS_SCN_DISP   32
#define R_386_32          1
#define R_386_64          0  /* impossible */
#define R_X86_64_32       10
#define R_X86_64_64       1
#define R_SPARC_UA32      23
#define R_SPARC_UA64      54
#define R_ARM_ABS32       2
#define R_ARM_ABS64       0 /* impossible */
#define R_AARCH64_ABS32   258
#define R_AARCH64_ABS64   257
#define R_IA64_DIR32LSB   0x25
#define R_IA64_DIR64LSB   0x27
#define R_PPC_REL32       26
#define R_PPC_REL64       44
#define R_PPC64_REL32     R_PPC_REL32
#define R_PPC64_REL64     44

static struct isa_relocs_s isa_relocs[] = {
{"irix",  R_MIPS_32,R_MIPS_64,R_MIPS_SCN_DISP},
{"mips",  R_MIPS_32,R_MIPS_64,0},
{"x86",   R_386_32, R_386_64,0},
{"x86_64",R_X86_64_32,R_X86_64_64,0},
{"ia64",  R_IA64_DIR32LSB,R_IA64_DIR64LSB,0},
{"arm64", R_AARCH64_ABS32,R_AARCH64_ABS64,0},
{"arm",   R_ARM_ABS32,R_ARM_ABS64,0},
{"ppc",   R_PPC_REL32,R_PPC_REL64,0},
{"ppc64", R_PPC64_REL32,R_PPC64_REL64,0},
{"sparc", R_SPARC_UA32,R_SPARC_UA64,0},
/*  The last entry MUST be all zeros. */
{0,0,0,0}
};

static int common_init(Dwarf_P_Debug dbg, Dwarf_Unsigned flags,
    const char *abiname, const char *dwarf_version,
    const char *extrainfo,
    int *error_ret);

/*  This function sets up a new dwarf producing region.
    flags: Indicates type of access method, one of DW_DLC* macros
    func(): Used to create a new object file, a call back function
    errhand(): Error Handler provided by user
    errarg: Argument to errhand()
    error: returned error value */
    /*  We want the following to have an elf section
        number that matches 'nothing' */
static struct Dwarf_P_Section_Data_s init_sect = {
    MAGIC_SECT_NO, 0, 0, 0, 0
};
static struct Dwarf_P_Section_Data_s init_sect_debug_str = {
    MAGIC_SECT_NO, 0, 0, 0, 0
};
static struct Dwarf_P_Section_Data_s init_sect_debug_line_str = {
    MAGIC_SECT_NO, 0, 0, 0, 0
};

/*  New April 2014.
    Replaces all previous producer init functions.
    It adds a string to select the relevant ABI/ISA and
    a string defining the selected DWARF version to
    output.
    There are some overlaps between the flags and the ISA/ABI
    string choices. ( it is neither strictly ABI nor strictly
    ISA name, but a useful name for both.)
    Generally, the function inteprets these
    in a tolerant fashion, so inconsistencies in the
    selections are not noticed...but they may have a surprising
    effect.

    The extra string is a way to allow new options without
    changing the interface. The idea is the caller might
    supply a list of such things as one string, comma-separated.
    The interface is not intended to allow spaces or tabs in the
    names, so don't do that  :-)
    If no extra strings are needed (none are defined initially)
    then pass a NULL pointer or an empty string as the 'extra'
    parameter.
    */
int
dwarf_producer_init(Dwarf_Unsigned flags,
    Dwarf_Callback_Func func,
    Dwarf_Handler errhand,
    Dwarf_Ptr errarg,
    void * user_data,
    const char *isa_name, /* See isa_reloc_s. */
    const char *dwarf_version, /* V2 V3 V4 or V5. */
    const char *extra, /* Extra input strings, comma separated. */
    Dwarf_P_Debug *dbg_returned,
    Dwarf_Error * error)
{
    Dwarf_P_Debug dbg = 0;
    int res = 0;
    int err_ret = 0;
    dbg = (Dwarf_P_Debug) _dwarf_p_get_alloc(NULL,
        sizeof(struct Dwarf_P_Debug_s));
    if (dbg == NULL) {
        DWARF_P_DBG_ERROR(dbg, DW_DLE_DBG_ALLOC,
            DW_DLV_ERROR);
    }
    memset((void *) dbg, 0, sizeof(struct Dwarf_P_Debug_s));
    /* For the time being */
    if (func == NULL) {
        DWARF_P_DBG_ERROR(dbg, DW_DLE_NO_CALLBACK_FUNC,
            DW_DLV_ERROR);
    }
    dbg->de_callback_func = func;
    dbg->de_errhand = errhand;
    dbg->de_errarg = errarg;
    dbg->de_user_data = user_data;
    res = common_init(dbg, flags,isa_name,dwarf_version,
        extra,&err_ret);
    if (res != DW_DLV_OK) {
        DWARF_P_DBG_ERROR(dbg, err_ret, DW_DLV_ERROR);
    }
    *dbg_returned = dbg;
    return DW_DLV_OK;
}

int
dwarf_pro_set_default_string_form(Dwarf_P_Debug dbg,
    int form,
    Dwarf_Error * error)
{
    (void)error;
    if (form != DW_FORM_string &&
        form != DW_FORM_strp) {
        _dwarf_p_error(dbg, error, DW_DLE_BAD_STRING_FORM);
        return DW_DLV_ERROR;
    }
    dbg->de_debug_default_str_form = form;
    return DW_DLV_OK;
}

static int
set_reloc_numbers(Dwarf_P_Debug dbg,
    Dwarf_Unsigned flags,
    const char *abiname)
{
    struct isa_relocs_s *isap = 0;

    (void)flags;
    if (!abiname) {
        return DW_DLV_NO_ENTRY;
    }
    for (isap = &isa_relocs[0];  ;isap++) {
        if (!isap->name_) {
            /* No more names known. Never found the one we wanted. */
            return DW_DLV_NO_ENTRY;
        }
        if (!strcmp(abiname,isap->name_)) {
            if (dbg->de_pointer_size == 4) {
                dbg->de_ptr_reloc = isap->reloc32_;
            } else {
                dbg->de_ptr_reloc = isap->reloc64_;
            }
            if (dbg->de_dwarf_offset_size == 4) {
                dbg->de_offset_reloc = isap->reloc32_;
            } else {
                dbg->de_offset_reloc = isap->reloc64_;
            }
            /*  segrel only meaningful for IRIX, otherwise
                harmless, unused. */
            dbg->de_exc_reloc = isap->segrel_;
            return DW_DLV_OK;
        }
    }
    /* UNREACHED */
}

/*  This is the Daniel J Bernstein hash function
    originally posted to Usenet news.
    http://en.wikipedia.org/wiki/List_of_hash_functions or
    http://stackoverflow.com/questions/\
    10696223/reason-for-5381-number-in-djb-hash-function).
    See Also DWARF5 Section 7.33
*/
static DW_TSHASHTYPE
_dwarf_string_hashfunc(const char *str)
{
    DW_TSHASHTYPE up = 0;
    DW_TSHASHTYPE hash = 5381;
    int c  = 0;

    /*  Extra parens suppress warning about assign in test. */
    while ((c = *str++)) {
        hash = hash * 33 + c ;
    }
    up = hash;
    return up;
}
static DW_TSHASHTYPE
key_simple_string_hashfunc(const void *keyp)
{
    struct Dwarf_P_debug_str_entry_s* mt =
        (struct Dwarf_P_debug_str_entry_s*) keyp;
    const char *str = 0;

    if (mt->dse_has_table_offset) {
        /*  ASSERT: mt->dse_dbg->de_debug_str->ds_data not zero. */
        str = (const char *)mt->dse_dbg->de_debug_str->ds_data +
            mt->dse_table_offset;
    } else {
        /*  ASSERT: dse_name != 0 */
        str = (const char *)mt->dse_name;
    }
    return _dwarf_string_hashfunc(str);
}

static int
common_init(Dwarf_P_Debug dbg,
    Dwarf_Unsigned flags,
    const char *abiname,
    const char *dwarf_version,
    const char *extra,
    int *err_ret)
{
    unsigned int k = 0;
    int res = 0;

    dbg->de_version_magic_number = PRO_VERSION_MAGIC;
    dbg->de_n_debug_sect = 0;
    dbg->de_debug_sects = &init_sect;
    dbg->de_debug_str = &init_sect_debug_str;
    dbg->de_debug_line_str = &init_sect_debug_line_str;
    dbg->de_current_active_section = &init_sect;
    dbg->de_flags = flags;

    /* DW_DLC_POINTER32 assumed. */
    dbg->de_pointer_size = 4;
    /* Standard DWARF 64bit offset, length field 12 bytes */
    dbg->de_dwarf_offset_size = 4;
    dbg->de_elf_offset_size = 4;
    dbg->de_64bit_extension = 0;

    dbg->de_big_endian = (dbg->de_flags&DW_DLC_TARGET_BIGENDIAN)?
        TRUE:FALSE;
    /*  DW_DLC_POINTER64 is identical to DW_DLC_SIZE_64 */
    if (dbg->de_flags & DW_DLC_POINTER64) {
        dbg->de_pointer_size = 8;
    }
    if (dbg->de_flags & DW_DLC_OFFSET64) {
        dbg->de_pointer_size = 8;
        dbg->de_dwarf_offset_size = 4;
        dbg->de_64bit_extension = 0;
        /*  When dwarf_offset_size == 8 then for
            standard dwarf set
            de_64bit_extension to 1. */
        dbg->de_elf_offset_size = 8;
    } else {
        if (dbg->de_flags & DW_DLC_IRIX_OFFSET64) {
            dbg->de_pointer_size = 8;
            dbg->de_big_endian = TRUE;
            dbg->de_dwarf_offset_size = 8;
            dbg->de_64bit_extension = 0;
            dbg->de_elf_offset_size = 8;
        }
    }

    if (abiname && (!strcmp(abiname,"irix"))) {
        dbg->de_irix_exc_augmentation = 1;
    } else {
        dbg->de_irix_exc_augmentation = 0;
    }
    /*  We must set reloc numbers even if doing symbolic
        relocations because we use the numbers up until
        we are generating debug.  A zero is interpreted
        as no relocations.  So ensure we have real
        relocations. */
    res = set_reloc_numbers(dbg,flags,abiname);
    if (res != DW_DLV_OK) {
        *err_ret = DW_DLE_BAD_ABINAME;
        return DW_DLV_ERROR;
    }
    dbg->de_output_version = 2;
    if (dwarf_version) {
        if (!strcmp(dwarf_version,"V2")) {
            dbg->de_output_version = 2;
        } else if (!strcmp(dwarf_version,"V3")) {
            dbg->de_output_version = 3;
        } else if (!strcmp(dwarf_version,"V4")) {
            dbg->de_output_version = 4;
        } else if (!strcmp(dwarf_version,"V5")) {
            dbg->de_output_version = 5;
        } else {
            *err_ret = DW_DLE_VERSION_STAMP_ERROR;
            return DW_DLV_ERROR;
        }
    }
    _dwarf_init_default_line_header_vals(dbg);
    res = _dwarf_log_extra_flagstrings(dbg,extra,err_ret);
    if (res == DW_DLV_ERROR) {
        return res;
    }

    if (flags & DW_DLC_SYMBOLIC_RELOCATIONS) {
        dbg->de_relocation_record_size =
            sizeof(struct Dwarf_Relocation_Data_s);
    } else {
        /*  This is only going to work when the HOST == TARGET,
            surely? */
#ifdef DWARF_WITH_LIBELF
#if HAVE_ELF64_GETEHDR
        dbg->de_relocation_record_size =
            ((dbg->de_pointer_size == 8)?
            sizeof(REL64) : sizeof(REL32));
#else
        dbg->de_relocation_record_size = sizeof(REL32);
#endif
#else /* DWARF_WITH_LIBELF */
        *err_ret = DW_DLE_NO_STREAM_RELOC_SUPPORT;
        return DW_DLV_ERROR;
#endif /* DWARF_WITH_LIBELF */
    }

    /* For .debug_str creation. */
    dwarf_initialize_search_hash(&dbg->de_debug_str_hashtab,
        key_simple_string_hashfunc,0);
    dbg->de_debug_default_str_form = DW_FORM_string;
    dwarf_initialize_search_hash(&dbg->de_debug_line_str_hashtab,
        key_simple_string_hashfunc,0);

    if (dbg->de_dwarf_offset_size == 8) {
        if (dbg->de_output_version <= 3) {
            dbg->de_ar_data_attribute_form = DW_FORM_data8;
        } else {
            dbg->de_ar_data_attribute_form = DW_FORM_sec_offset;
        }
        dbg->de_ar_ref_attr_form = DW_FORM_ref8;
    } else {
        if (dbg->de_output_version <= 3) {
            dbg->de_ar_data_attribute_form = DW_FORM_data4;
        } else {
            dbg->de_ar_data_attribute_form = DW_FORM_sec_offset;
        }
        dbg->de_ar_ref_attr_form = DW_FORM_ref4;
    }

    if (flags & DW_DLC_SYMBOLIC_RELOCATIONS) {
        dbg->de_relocate_by_name_symbol =
            _dwarf_pro_reloc_name_symbolic;
        dbg->de_relocate_pair_by_symbol =
            _dwarf_pro_reloc_length_symbolic;
        dbg->de_transform_relocs_to_disk =
            _dwarf_symbolic_relocs_to_disk;
    } else {
#ifdef DWARF_WITH_LIBELF
        if (IS_64BITPTR(dbg)) {
            dbg->de_relocate_by_name_symbol =
                _dwarf_pro_reloc_name_stream64;
        } else {
            dbg->de_relocate_by_name_symbol =
                _dwarf_pro_reloc_name_stream32;
        }
        dbg->de_relocate_pair_by_symbol = 0;
        dbg->de_transform_relocs_to_disk =
            _dwarf_stream_relocs_to_disk;
#else /* DWARF_WITH_LIBELF */
        *err_ret = DW_DLE_NO_STREAM_RELOC_SUPPORT;
        return DW_DLV_ERROR;
#endif /* DWARF_WITH_LIBELF */
    }
    for (k = 0; k < NUM_DEBUG_SECTIONS; ++k) {

        Dwarf_P_Per_Reloc_Sect prel = &dbg->de_reloc_sect[k];

        prel->pr_slots_per_block_to_alloc = DEFAULT_SLOTS_PER_BLOCK;
    }
    /* First assume host, target same endianness  FIXME */
    dbg->de_same_endian = 1;
    dbg->de_copy_word =  _dwarf_memcpy_noswap_bytes;
#ifdef WORDS_BIGENDIAN
    /* host is big endian, so what endian is target? */
    if (flags & DW_DLC_TARGET_LITTLEENDIAN) {
        dbg->de_same_endian = 0;
        dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
    }
#else /* little endian */
    /* host is little endian, so what endian is target? */
    if (flags & DW_DLC_TARGET_BIGENDIAN) {
        dbg->de_same_endian = 0;
        dbg->de_copy_word = _dwarf_memcpy_swap_bytes;
    }
#endif /* !WORDS_BIGENDIAN */
    return DW_DLV_OK;
}
