/*

  Copyright (C) 2000,2004 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

*/



#include "config.h"
#include "libdwarfdefs.h"
#include <stdio.h>
#include <string.h>
#include "pro_incl.h"
#include "pro_section.h"
#include "pro_macinfo.h"

/*
        I don't much like the error strings this generates, since
        like the rest of libdwarf they are simple strings with
        no useful numbers in them. But that's not something I can
        fix without more work than I have time for
        right now.  davea Nov 94.
*/

/* these are gross overestimates of the number of
** bytes needed to store a number in LEB form.
** Just estimates, and since blocks are reasonable size,
** the end-block waste is small.
** Of course the waste is NOT present on disk.
*/

#define COMMAND_LEN ENCODE_SPACE_NEEDED
#define LINE_LEN    ENCODE_SPACE_NEEDED
#define BASE_MACINFO_MALLOC_LEN 2048

static int
libdwarf_compose_begin(Dwarf_P_Debug dbg, int code,
                       size_t maxlen, int *compose_error_type)
{
    unsigned char *nextchar;
    struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;

    if (curblk == 0) {
        struct dw_macinfo_block_s *newb;
        size_t len;

        /* initial allocation */
        size_t blen = BASE_MACINFO_MALLOC_LEN;

        if (blen < maxlen) {
            blen = 2 * maxlen;
        }
        len = sizeof(struct dw_macinfo_block_s) + blen;
        newb =
            (struct dw_macinfo_block_s *) _dwarf_p_get_alloc(dbg, len);
        if (!newb) {
            *compose_error_type = DW_DLE_MACINFO_MALLOC_FAIL;
            return DW_DLV_ERROR;
        }
        newb->mb_data =
            (char *) newb + sizeof(struct dw_macinfo_block_s);
        newb->mb_avail_len = blen;
        newb->mb_used_len = 0;
        newb->mb_macinfo_data_space_len = blen;
        dbg->de_first_macinfo = newb;
        dbg->de_current_macinfo = newb;
        curblk = newb;
    } else if (curblk->mb_avail_len < maxlen) {
        struct dw_macinfo_block_s *newb;
        size_t len;

        /* no space left in block: allocate a new block */
        size_t blen =
            dbg->de_current_macinfo->mb_macinfo_data_space_len * 2;
        if (blen < maxlen) {
            blen = 2 * maxlen;
        }
        len = sizeof(struct dw_macinfo_block_s) + blen;
        newb =
            (struct dw_macinfo_block_s *) _dwarf_p_get_alloc(dbg, len);
        if (!newb) {
            *compose_error_type = DW_DLE_MACINFO_MALLOC_FAIL;
            return DW_DLV_ERROR;
        }
        newb->mb_data =
            (char *) newb + sizeof(struct dw_macinfo_block_s);
        newb->mb_avail_len = blen;
        newb->mb_used_len = 0;
        newb->mb_macinfo_data_space_len = blen;
        dbg->de_first_macinfo->mb_next = newb;
        dbg->de_current_macinfo = newb;
        curblk = newb;
    }
    /* now curblk has enough room */
    dbg->de_compose_avail = curblk->mb_avail_len;
    dbg->de_compose_used_len = curblk->mb_used_len;
    nextchar =
        (unsigned char *) (curblk->mb_data + dbg->de_compose_used_len);
    *nextchar = code;
    dbg->de_compose_avail--;
    ++dbg->de_compose_used_len;
    return DW_DLV_OK;
}



static void
libdwarf_compose_add_string(Dwarf_P_Debug dbg, char *string, size_t len)
{
    struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;
    unsigned char *nextchar;

    nextchar =
        (unsigned char *) (curblk->mb_data + dbg->de_compose_used_len);

    len += 1;                   /* count the null terminator */

    memcpy(nextchar, string, len);
    dbg->de_compose_avail -= len;
    dbg->de_compose_used_len += len;
    return;

}
static int
libdwarf_compose_add_line(Dwarf_P_Debug dbg,
                          Dwarf_Unsigned line, int *compose_error_type)
{
    struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;
    unsigned char *nextchar;
    int res;
    int nbytes;

    nextchar =
        (unsigned char *) (curblk->mb_data + dbg->de_compose_used_len);

    /* Put the created leb number directly into the macro buffer If
       dbg->de_compose_avail is > INT_MAX this will not work as the
       'int' will look negative to _dwarf_pro_encode_leb128_nm! */

    res = _dwarf_pro_encode_leb128_nm(line, &nbytes,
                                      (char *) nextchar,
                                      (int) dbg->de_compose_avail);
    if (res != DW_DLV_OK) {
        *compose_error_type = DW_DLE_MACINFO_INTERNAL_ERROR_SPACE;
        return DW_DLV_ERROR;
    }

    dbg->de_compose_avail -= nbytes;
    dbg->de_compose_used_len += nbytes;
    return DW_DLV_OK;
}

/*
   This function actually 'commits' the space used by the
   preceeding calls.
*/
static int
libdwarf_compose_complete(Dwarf_P_Debug dbg, int *compose_error_type)
{
    struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;

    if (dbg->de_compose_used_len > curblk->mb_macinfo_data_space_len) {
        *compose_error_type = DW_DLE_MACINFO_INTERNAL_ERROR_SPACE;
        return DW_DLV_ERROR;
    }
    curblk->mb_avail_len = dbg->de_compose_avail;
    curblk->mb_used_len = dbg->de_compose_used_len;
    return DW_DLV_OK;
}



int
dwarf_def_macro(Dwarf_P_Debug dbg,
                Dwarf_Unsigned line,
                char *macname, char *macvalue, Dwarf_Error * error)
{
    size_t len;
    size_t len2;
    size_t length_est;
    int res;
    int compose_error_type;

    if (dbg == NULL) {
        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
        return (DW_DLV_ERROR);
    }
    if (macname == 0) {
        _dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_NULL);
        return (DW_DLV_ERROR);
    }
    len = strlen(macname) + 1;
    if (len == 0) {
        _dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_EMPTY);
        return (DW_DLV_ERROR);
    }
    if (macvalue) {
        len2 = strlen(macvalue) + 1;
    } else {
        len2 = 0;
    }
    length_est = COMMAND_LEN + LINE_LEN + len + len2 + 1;       /* 1
                                                                   for
                                                                   space 
                                                                   character 
                                                                   we
                                                                   add */
    res = libdwarf_compose_begin(dbg, DW_MACINFO_define, length_est,
                                 &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    res = libdwarf_compose_add_line(dbg, line, &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    libdwarf_compose_add_string(dbg, macname, len);
    libdwarf_compose_add_string(dbg, " ", 1);
    if (macvalue) {
        libdwarf_compose_add_string(dbg, " ", 1);
        libdwarf_compose_add_string(dbg, macvalue, len2);
    }
    res = libdwarf_compose_complete(dbg, &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    return DW_DLV_OK;
}

int
dwarf_undef_macro(Dwarf_P_Debug dbg,
                  Dwarf_Unsigned line,
                  char *macname, Dwarf_Error * error)
{

    size_t len;
    size_t length_est;
    int res;
    int compose_error_type;

    if (dbg == NULL) {
        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
        return (DW_DLV_ERROR);
    }
    if (macname == 0) {
        _dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_NULL);
        return (DW_DLV_ERROR);
    }
    len = strlen(macname) + 1;
    if (len == 0) {
        _dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_EMPTY);
        return (DW_DLV_ERROR);
    }
    length_est = COMMAND_LEN + LINE_LEN + len;
    res = libdwarf_compose_begin(dbg, DW_MACINFO_undef, length_est,
                                 &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    res = libdwarf_compose_add_line(dbg, line, &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    libdwarf_compose_add_string(dbg, macname, len);
    res = libdwarf_compose_complete(dbg, &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    return DW_DLV_OK;
}

int
dwarf_start_macro_file(Dwarf_P_Debug dbg,
                       Dwarf_Unsigned fileindex,
                       Dwarf_Unsigned linenumber, Dwarf_Error * error)
{
    size_t length_est;
    int res;
    int compose_error_type;

    if (dbg == NULL) {
        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
        return (DW_DLV_ERROR);
    }
    length_est = COMMAND_LEN + LINE_LEN + LINE_LEN;
    res = libdwarf_compose_begin(dbg, DW_MACINFO_start_file, length_est,
                                 &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    res = libdwarf_compose_add_line(dbg, fileindex,
                                    &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    res = libdwarf_compose_add_line(dbg, linenumber,
                                    &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    return DW_DLV_OK;
}

int
dwarf_end_macro_file(Dwarf_P_Debug dbg, Dwarf_Error * error)
{
    size_t length_est;
    int res;
    int compose_error_type;

    if (dbg == NULL) {
        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
        return (DW_DLV_ERROR);
    }
    length_est = COMMAND_LEN;
    res = libdwarf_compose_begin(dbg, DW_MACINFO_end_file, length_est,
                                 &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    res = libdwarf_compose_complete(dbg, &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    return DW_DLV_OK;
}

int
dwarf_vendor_ext(Dwarf_P_Debug dbg,
                 Dwarf_Unsigned constant,
                 char *string, Dwarf_Error * error)
{
    size_t len;
    size_t length_est;
    int res;
    int compose_error_type;

    if (dbg == NULL) {
        _dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
        return (DW_DLV_ERROR);
    }
    if (string == 0) {
        _dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_NULL);
        return (DW_DLV_ERROR);
    }
    len = strlen(string) + 1;
    if (len == 0) {
        _dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_EMPTY);
        return (DW_DLV_ERROR);
    }
    length_est = COMMAND_LEN + LINE_LEN + len;
    res = libdwarf_compose_begin(dbg, DW_MACINFO_vendor_ext, length_est,
                                 &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    res = libdwarf_compose_add_line(dbg, constant, &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    libdwarf_compose_add_string(dbg, string, len);
    libdwarf_compose_complete(dbg, &compose_error_type);
    if (res != DW_DLV_OK) {
        _dwarf_p_error(NULL, error, compose_error_type);
        return (DW_DLV_ERROR);
    }
    return DW_DLV_OK;
}



int
_dwarf_pro_transform_macro_info_to_disk(Dwarf_P_Debug dbg,
                                        Dwarf_Error * error)
{
    /* Total num of bytes in .debug_macinfo section. */
    Dwarf_Unsigned mac_num_bytes;

    /* Points to first byte of .debug_macinfo buffer. */
    Dwarf_Small *macinfo;

    /* Fills in the .debug_macinfo buffer. */
    Dwarf_Small *macinfo_ptr;


    /* Used to scan the section data buffers. */
    struct dw_macinfo_block_s *m_prev;
    struct dw_macinfo_block_s *m_sect;


    /* Get the size of the debug_macinfo data */
    mac_num_bytes = 0;
    for (m_sect = dbg->de_first_macinfo; m_sect != NULL;
         m_sect = m_sect->mb_next) {
        mac_num_bytes += m_sect->mb_used_len;
    }
    /* Tthe final entry has a type code of 0 to indicate It is final
       for this CU Takes just 1 byte. */
    mac_num_bytes += 1;

    GET_CHUNK(dbg, dbg->de_elf_sects[DEBUG_MACINFO],
              macinfo, (unsigned long) mac_num_bytes, error);
    if (macinfo == NULL) {
        _dwarf_p_error(dbg, error, DW_DLE_ALLOC_FAIL);
        return (0);
    }

    macinfo_ptr = macinfo;
    m_prev = 0;
    for (m_sect = dbg->de_first_macinfo; m_sect != NULL;
         m_sect = m_sect->mb_next) {
        memcpy(macinfo_ptr, m_sect->mb_data, m_sect->mb_used_len);
        macinfo_ptr += m_sect->mb_used_len;
        if (m_prev) {
            _dwarf_p_dealloc(dbg, (Dwarf_Small *) m_prev);
            m_prev = 0;
        }
        m_prev = m_sect;
    }
    *macinfo_ptr = 0;           /* the type code of 0 as last entry */
    if (m_prev) {
        _dwarf_p_dealloc(dbg, (Dwarf_Small *) m_prev);
        m_prev = 0;
    }

    dbg->de_first_macinfo = NULL;
    dbg->de_current_macinfo = NULL;

    return (int) dbg->de_n_debug_sect;
}