/*
Copyright (C) 2020 David Anderson. All Rights Reserved.

    This program is free software; you can redistribute it
    and/or modify it under the terms of version 2 of the GNU
    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 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.
*/

/*  DWARF5 has the new .debug_loclists section.
    Here we print that data.
    The raw printing covers all the content of the
    section but without relating it to any
    compilation unit.

    Printing the actual address means printing
    with the actual DIEs on hand.
*/

#include "config.h"
#include "globals.h"
#include "esb.h"
#include "esb_using_functions.h"
#include "sanitized.h"

static void
print_sec_name(Dwarf_Debug dbg)
{
    struct esb_s truename;
    char buf[DWARF_SECNAME_BUFFER_SIZE];

    esb_constructor_fixed(&truename,buf,sizeof(buf));
    get_true_section_name(dbg,".debug_loclists",
        &truename,TRUE);
    printf("\n%s\n\n",sanitized(esb_get_string(&truename)));
    esb_destructor(&truename);
}

static int
print_offset_entry_table(Dwarf_Debug dbg,
    Dwarf_Unsigned contextnum,
    Dwarf_Unsigned offset_entry_count,
    Dwarf_Error *error)
{
    Dwarf_Unsigned e = 0;
    unsigned colmax = 4;
    unsigned col = 0;
    int res = 0;
    int hasnewline = TRUE;

    for ( ; e < offset_entry_count; ++e) {
        Dwarf_Unsigned value = 0;

        if (e == 0) {
            printf("   Location Offset Table :\n");
        }
        hasnewline = FALSE;
        res = dwarf_get_loclist_offset_index_value(dbg,
            contextnum,e,&value,0,error);
        if (res != DW_DLV_OK) {
            return res;
        }
        if (col == 0) {
            printf("   [%2" DW_PR_DUu "]",e);
        }
        printf(" 0x%" DW_PR_XZEROS DW_PR_DUx, value);
        col++;
        if (col == colmax) {
            printf("\n");
            hasnewline = TRUE;
            col = 0;
        }
    }
    if (!hasnewline) {
        printf("\n");
    }
    return DW_DLV_OK;
}

static void
print_opsbytes(Dwarf_Unsigned expr_ops_blocklen,
    Dwarf_Small* expr_ops)
{
    Dwarf_Unsigned i = 0;

    if (!expr_ops_blocklen) {
        return;
    }
    printf(" opsbytes:");
    for( ; i < expr_ops_blocklen; ++i ) {
        Dwarf_Small *b =  expr_ops+i;
        printf(" %02x", *b);
    }
    printf(" ");
}

/*  Print single raw lle */
static int
print_single_lle(UNUSEDARG Dwarf_Debug dbg,
    UNUSEDARG Dwarf_Unsigned contextnum,
    Dwarf_Unsigned lineoffset,
    Dwarf_Unsigned code,
    Dwarf_Unsigned v1,
    Dwarf_Unsigned v2,
    Dwarf_Unsigned expr_ops_blocklen,
    UNUSEDARG Dwarf_Unsigned expr_ops_offset,
    Dwarf_Small    *expr_ops,
    Dwarf_Unsigned entrylen)
{
    int res = DW_DLV_OK;

    const char *name = "";
    struct esb_s m;

    esb_constructor(&m);
    res = dwarf_get_LLE_name(code,&name);
    if (res != DW_DLV_OK) {
        /* ASSERT: res == DW_DLV_NO_ENTRY, see dwarf_names.c */
        esb_append_printf_u(&m, "<ERROR: lle code 0x%" DW_PR_DUx
            "unknown>",code);
    } else {
        esb_append(&m,name);
    }
    printf("    ");
    printf("<0x%" DW_PR_XZEROS DW_PR_DUx "> %-20s",
        lineoffset,esb_get_string(&m));
    switch(code) {
    case DW_LLE_end_of_list:
        printf("           ");
        printf("           ");
        break;
    case DW_LLE_base_addressx:
        printf(" 0x%" DW_PR_XZEROS DW_PR_DUx ,v1);
        printf("           ");
        break;
    case DW_LLE_startx_endx:
        printf(
            " 0x%" DW_PR_XZEROS DW_PR_DUx
            " 0x%" DW_PR_XZEROS DW_PR_DUx ,v1,v2);
        break;
    case DW_LLE_startx_length:
        printf(
            " 0x%" DW_PR_XZEROS DW_PR_DUx
            " 0x%" DW_PR_XZEROS DW_PR_DUx ,v1,v2);
        break;
    case DW_LLE_offset_pair:
        printf(
            " 0x%" DW_PR_XZEROS DW_PR_DUx
            " 0x%" DW_PR_XZEROS DW_PR_DUx ,v1,v2);
        break;
    case DW_LLE_default_location:
        printf(
            " 0x%" DW_PR_XZEROS DW_PR_DUx
            " 0x%" DW_PR_XZEROS DW_PR_DUx ,v1,v2);
        break;
    case DW_LLE_base_address:
        printf(
            " 0x%" DW_PR_XZEROS DW_PR_DUx ,v1);
        printf("           ");
        break;
    case DW_LLE_start_end:
        printf(
            " 0x%" DW_PR_XZEROS DW_PR_DUx
            " 0x%" DW_PR_XZEROS DW_PR_DUx ,v1,v2);
        break;
    case DW_LLE_start_length:
        printf(
            " 0x%" DW_PR_XZEROS DW_PR_DUx
            " 0x%" DW_PR_XZEROS DW_PR_DUx ,v1,v2);
        break;
    default:
        printf(" ERROR: Unknown LLE code in .debug_loclists. %s\n",
            esb_get_string(&m));
        simple_err_return_msg_either_action(res,
            esb_get_string(&m));
        break;
    }
    printf( " %" DW_PR_DUu,entrylen);
    esb_destructor(&m);
    if (glflags.verbose && expr_ops_blocklen > 0) {
        printf("\n");
        printf("    ");
        printf(" opslen %" DW_PR_DUu,expr_ops_blocklen);
        print_opsbytes(expr_ops_blocklen,expr_ops);
    }
    printf("\n");
    return res;
}

/*  Prints the raw content. Exactly as in .debug_loclists */
static int
print_entire_loclist(Dwarf_Debug dbg,
    Dwarf_Unsigned contextnumber,
    Dwarf_Unsigned offset_of_first_loc,
    Dwarf_Unsigned offset_past_last_locentry,
    Dwarf_Error *error)
{
    /*  These offsets are rnglists section global offsets,
        not rnglist context local offsets. */
    Dwarf_Unsigned curoffset = offset_of_first_loc;
    Dwarf_Unsigned endoffset = offset_past_last_locentry;
    int res = 0;
    Dwarf_Unsigned ct = 0;

    for ( ; curoffset < endoffset; ++ct ) {
        unsigned entrylen = 0;
        unsigned code = 0;
        Dwarf_Unsigned v1 = 0;
        Dwarf_Unsigned v2 = 0;
        Dwarf_Unsigned expr_ops_blocksize = 0;
        Dwarf_Unsigned expr_ops_offset = 0;
        Dwarf_Small   *expr_ops_data = 0;

        if (!ct) {
            printf("   Loc  (raw)\n");
            printf("     Offset      entryname            val1 "
                "      val2   entrylen\n");
        }
        /*  This returns ops data as in DWARF. No
            application of base addresses or anything. */
        res = dwarf_get_loclist_lle(dbg,contextnumber,
            curoffset,endoffset,
            &entrylen,
            &code,&v1,&v2,
            &expr_ops_blocksize,&expr_ops_offset,&expr_ops_data,
            error);
        if (res != DW_DLV_OK) {
            return res;
        }
        print_single_lle(dbg,contextnumber,curoffset,
            code,v1,v2,expr_ops_blocksize,expr_ops_offset,
            expr_ops_data,entrylen);
        curoffset += entrylen;
        if (curoffset > endoffset) {
            struct esb_s m;

            esb_constructor(&m);
            esb_append_printf_u(&m, "DW_DLE_USER_DECLARED_ERROR: "
                "final RLE in "
                ".debug_rnglists runs past end of its area "
                "so current offset 0x%" DW_PR_DUx,curoffset);

            esb_append_printf_u(&m," exceeds context 1-past-end"
                " offset of 0x%" DW_PR_DUx ".",endoffset);
            dwarf_error_creation(dbg,error,
                esb_get_string(&m));
            esb_destructor(&m);
            return DW_DLV_ERROR;
        }
    }
    return DW_DLV_OK;
}



int
print_raw_all_loclists(Dwarf_Debug dbg,
    Dwarf_Error *error)
{
    int res = 0;
    Dwarf_Unsigned count = 0;
    Dwarf_Unsigned i = 0;

    res = dwarf_load_loclists(dbg,&count,error);
    if (res != DW_DLV_OK) {
        return res;
    }
    print_sec_name(dbg);

    printf(" Number of loclists contexts:  %" DW_PR_DUu "\n",
        count);
    for (i = 0; i < count ; ++i) {
        Dwarf_Unsigned header_offset = 0;
        Dwarf_Small   offset_size = 0;
        Dwarf_Small   extension_size = 0;
        unsigned      version = 0; /* 5 */
        Dwarf_Small   address_size = 0;
        Dwarf_Small   segment_selector_size = 0;
        Dwarf_Unsigned offset_entry_count = 0;
        Dwarf_Unsigned offset_of_offset_array = 0;
        Dwarf_Unsigned offset_of_first_locentry = 0;
        Dwarf_Unsigned offset_past_last_locentry = 0;

        res = dwarf_get_loclist_context_basics(dbg,i,
            &header_offset,
            &offset_size,
            &extension_size,
            &version,&address_size,&segment_selector_size,
            &offset_entry_count,&offset_of_offset_array,
            &offset_of_first_locentry,
            &offset_past_last_locentry,
            error);
        if (res != DW_DLV_OK) {
            struct esb_s m;

            esb_constructor(&m);
            esb_append_printf_u(&m,"ERROR: Getting debug_rnglists "
                "entry %u we unexpectedly stop early.",i);
            simple_err_return_msg_either_action(res,
                esb_get_string(&m));
            esb_destructor(&m);
            return res;
        }
        printf("  Context number         : %3" DW_PR_DUu "\n",i);
        printf("   Version               : %3u\n",version);
        printf("   address size          : %3u\n",address_size);
        printf("   offset size           : %3u\n",offset_size);
        if(glflags.verbose) {
            printf("   extension size        : %3u\n",extension_size);
        }
        printf("   segment selector size : %3u\n",
            segment_selector_size);
        printf("   offset entry count    : %3" DW_PR_DUu "\n",
            offset_entry_count);
        printf("   context size in bytes : %3" DW_PR_DUu "\n",
            offset_past_last_locentry - header_offset);
        if(glflags.verbose) {
            printf("   Offset in section     : 0x%"
                DW_PR_XZEROS DW_PR_DUx"\n",
                header_offset);
            printf("   Offset  of offsets    : 0x%"
                DW_PR_XZEROS DW_PR_DUx"\n",
                offset_of_offset_array);
            printf("   Offsetof first loc    : 0x%"
                DW_PR_XZEROS DW_PR_DUx"\n",
                offset_of_first_locentry);
            printf("   Offset past locations : 0x%"
                DW_PR_XZEROS DW_PR_DUx"\n",
                offset_past_last_locentry);
        }
        if (offset_entry_count) {
            res = print_offset_entry_table(dbg,i,offset_entry_count,
                error);
            if (res == DW_DLV_ERROR) {
                return res;
            }
        }
        if ((offset_of_first_locentry+1) <
            offset_past_last_locentry) {
            res = print_entire_loclist(dbg,i,
                offset_of_first_locentry,
                offset_past_last_locentry,
                error);
            if(res != DW_DLV_OK) {
                return res;
            }
        }
    }
    return DW_DLV_OK;
}