/*

Copyright (c) 2020, David Anderson

All rights reserved.

Redistribution and use in source and binary forms, with

or without modification, are permitted provided that the

following conditions are met:

    Redistributions of source code must retain the above

    copyright notice, this list of conditions and the following

    disclaimer.

    Redistributions in binary form must reproduce the above

    copyright notice, this list of conditions and the following

    disclaimer in the documentation and/or other materials

    provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include <config.h>

#include <stdlib.h> /* free() malloc() */

#include <stdio.h> /* printf */

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

#if defined(_WIN32) && defined(HAVE_STDAFX_H)

#include "stdafx.h"

#endif /* HAVE_STDAFX_H */

#include "dwarf.h"

#include "libdwarf.h"

#include "libdwarf_private.h"

#include "dwarf_base_types.h"

#include "dwarf_opaque.h"

#include "dwarf_alloc.h"

#include "dwarf_error.h"

#include "dwarf_util.h"

#include "dwarf_string.h"

#include "dwarf_rnglists.h"

#define SIZEOFT8 1

#define SIZEOFT16 2

#define SIZEOFT32 4

#define SIZEOFT64 8

#if 0

static void

dump_bytes(const char *msg,Dwarf_Small * start, long len)

{

    Dwarf_Small *end = start + len;

    Dwarf_Small *cur = start;

    printf("%s (0x%lx) ",msg,(unsigned long)start);

    for (; cur < end; cur++) {

        printf("%02x", *cur);

    }

    printf("\n");

}

#endif /*0*/

#if 0

static void

dump_rh(const char *msg,

    int line,

    struct Dwarf_Rnglists_Head_s *head)

{

    printf("Rnglists_Head: %s  line %d\n",

        msg,line);

    printf("  count of entries: "

        DW_PR_DUu

        "  (0x%" DW_PR_DUx ")\n",

        head->rh_count,head->rh_count);

    printf("  rh_rnglists     : %p\n",(void *)) head->rh_rnglists);

    if (head->rh_first) {

        printf("  rh_first    : %" DW_PR_DUu "\n", head->rh_first);

    if (head->rh_last) {

        printf("  rh_last     :  %" DW_PR_DUu "\n",head->rh_last);

    }

    printf("  rh_bytes total  : %" DW_PR_DUu

        "  (0x%" DW_PR_DUx ")\n",head->rh_bytes_total,

        head->rh_bytes_total);

    printf("  CU Context      : %p",(void *)head->rh_context);

    printf("  Rnglists Context:  %p",(void *)head->rh_localcontext);

}

#endif

/*  Used in case of error reading the

    rnglists headers (not referring to Dwarf_Rnglists_Head

    here), to clean up. */

static void

free_rnglists_chain(Dwarf_Debug dbg, Dwarf_Chain head)

{

    Dwarf_Chain cur = head;

    Dwarf_Chain next = 0;

    if (!head) {

        return;

    }

    for ( ;cur; cur = next) {

        next = cur->ch_next;

        if (cur->ch_item) {

            free(cur->ch_item);

            cur->ch_item = 0;

            dwarf_dealloc(dbg,cur,DW_DLA_CHAIN);

        }

    }

}

static int

read_single_rle_entry(Dwarf_Debug dbg,

    Dwarf_Small   *data,

    Dwarf_Unsigned dataoffset,

    Dwarf_Small   *enddata,

    unsigned       address_size,

    unsigned       *bytes_count_out,

    unsigned       *entry_kind,

    Dwarf_Unsigned *entry_operand1,

    Dwarf_Unsigned *entry_operand2,

    Dwarf_Error* error)

{

    Dwarf_Unsigned count = 0;

    unsigned leblen = 0;

    unsigned code = 0;

    Dwarf_Unsigned val1 = 0;

    Dwarf_Unsigned val2 = 0;

    code = *data;

    ++data;

    ++count;

    switch(code) {

    case DW_RLE_end_of_list: break;

    case DW_RLE_base_addressx:{

        DECODE_LEB128_UWORD_LEN_CK(data,val1,leblen,

            dbg,error,enddata);

        count += leblen;

        }

        break;

    case DW_RLE_startx_endx:

    case DW_RLE_startx_length:

    case DW_RLE_offset_pair: {

        DECODE_LEB128_UWORD_LEN_CK(data,val1,leblen,

            dbg,error,enddata);

        count += leblen;

        DECODE_LEB128_UWORD_LEN_CK(data,val2,leblen,

            dbg,error,enddata);

        count += leblen;

        }

        break;

    case DW_RLE_base_address: {

        READ_UNALIGNED_CK(dbg,val1, Dwarf_Unsigned,

            data,address_size,error,enddata);

        data += address_size;

        count += address_size;

        }

        break;

    case DW_RLE_start_end: {

        READ_UNALIGNED_CK(dbg,val1, Dwarf_Unsigned,

            data,address_size,error,enddata);

        data += address_size;

        count += address_size;

        READ_UNALIGNED_CK(dbg,val2, Dwarf_Unsigned,

            data,address_size,error,enddata);

        data += address_size;

        count += address_size;

        }

        break;

    case DW_RLE_start_length: {

        READ_UNALIGNED_CK(dbg,val1, Dwarf_Unsigned,

            data,address_size,error,enddata);

        data += address_size;

        count += address_size;

        DECODE_LEB128_UWORD_LEN_CK(data,val2,leblen,

            dbg,error,enddata);

        count += leblen;

        }

        break;

    default: {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            "DW_DLE_RNGLISTS_ERROR: "

            "The rangelists entry at .debug_rnglists"

            " offset 0x%x" ,dataoffset);

        dwarfstring_append_printf_u(&m,

            " has code 0x%x which is unknown",code);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

        }

        break;

    }

    *bytes_count_out = count;

    *entry_kind = code;

    *entry_operand1 = val1;

    *entry_operand2 = val2;

    return DW_DLV_OK;

}

/*  Reads the header. Determines the

    various offsets, including offset

    of the next header. Does no memory

    allocations here. */

int

_dwarf_internal_read_rnglists_header(Dwarf_Debug dbg,

    Dwarf_Unsigned contextnum,

    Dwarf_Unsigned sectionlength,

    Dwarf_Small *data,

    Dwarf_Small *end_data,

    Dwarf_Unsigned offset,

    Dwarf_Rnglists_Context  buildhere,

    Dwarf_Unsigned *next_offset,

    Dwarf_Error *error)

{

    Dwarf_Small *startdata = data;

    Dwarf_Unsigned arealen = 0;

    int offset_size = 0;

    int exten_size = 0;

    Dwarf_Unsigned version = 0;

    unsigned address_size = 0;

    unsigned segment_selector_size=  0;

    Dwarf_Unsigned offset_entry_count = 0;

    Dwarf_Unsigned localoff = 0;

    Dwarf_Unsigned lists_len = 0;

    Dwarf_Unsigned secsize_dbg = 0;

    secsize_dbg = dbg->de_debug_rnglists.dss_size;

    /*  Sanity checks */

    if (sectionlength > secsize_dbg) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            "DW_DLE_RNGLISTS_ERROR: "

            " section_length argument (%lu) mismatch vs.",

            sectionlength);

        dwarfstring_append_printf_u(&m,

            ".debug_rnglists"

            " section length",secsize_dbg);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    if (sectionlength > secsize_dbg) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append(&m,

            "DW_DLE_RNGLISTS_ERROR: "

            " section_length argument mismatch vs. .debug_rnglists"

            " section length including header.");

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    buildhere->rc_startaddr = data;

    READ_AREA_LENGTH_CK(dbg,arealen,Dwarf_Unsigned,

        data,offset_size,exten_size,

        error,

        sectionlength,end_data);

    if (arealen > sectionlength ||

        (arealen+offset_size+exten_size) > sectionlength) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            "DW_DLE_RNGLISTS_ERROR: A .debug_rnglists "

            "area size of 0x%x ",arealen);

        dwarfstring_append_printf_u(&m,

            "at offset 0x%x ",offset);

        dwarfstring_append_printf_u(&m,

            "is larger than the entire section size of "

            "0x%x. Corrupt DWARF.",sectionlength);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    localoff = offset_size+exten_size;

    buildhere->rc_length = arealen + localoff;

    buildhere->rc_dbg = dbg;

    buildhere->rc_index = contextnum;

    buildhere->rc_header_offset = offset;

    buildhere->rc_offset_size = offset_size;

    buildhere->rc_extension_size = exten_size;

    buildhere->rc_magic = RNGLISTS_MAGIC;

    READ_UNALIGNED_CK(dbg,version,Dwarf_Unsigned,data,

        SIZEOFT16,error,end_data);

    if (version != DW_CU_VERSION5) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            "DW_DLE_RNGLISTS_ERROR: The version should be 5 "

            "but we find %u instead.",version);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    buildhere->rc_version = version;

    data += SIZEOFT16;

    localoff += SIZEOFT16;

    READ_UNALIGNED_CK(dbg,address_size,unsigned,data,

        SIZEOFT8,error,end_data);

    if (address_size != 4 && address_size != 8 &&

        address_size != 2) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            " DW_DLE_RNGLISTS_ERROR: .debug_rnglists "

            "The address size "

            "of %u is not supported.",address_size);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    buildhere->rc_address_size = address_size;

    localoff++;

    data++;

    READ_UNALIGNED_CK(dbg,segment_selector_size,unsigned,data,

        SIZEOFT8,error,end_data);

    buildhere->rc_segment_selector_size = segment_selector_size;

    data++;

    localoff++;

    if (segment_selector_size) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            " DW_DLE_RNGLISTS_ERROR: .debug_rnglists"

            " The segment selector size "

            "of %u is not supported.",address_size);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    if ((offset+localoff+SIZEOFT32) > secsize_dbg) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            " DW_DLE_RNGLISTS_ERROR: .debug_rnglists"

            " Header runs off the end of the section "

            " with offset %u",offset+localoff+SIZEOFT32);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    READ_UNALIGNED_CK(dbg,offset_entry_count,Dwarf_Unsigned,data,

        SIZEOFT32,error,end_data);

    buildhere->rc_offset_entry_count = offset_entry_count;

    data += SIZEOFT32;

    localoff+= SIZEOFT32;

    if (offset_entry_count ){

        buildhere->rc_offsets_array = data;

    }

    lists_len = offset_size *offset_entry_count;

    if (offset_entry_count >= secsize_dbg ||

        lists_len >= secsize_dbg) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            " DW_DLE_RNGLISTS_ERROR: .debug_rnglists"

            " offset entry count"

            " of %u is clearly impossible. Corrupt data",

            offset_entry_count);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    data += lists_len;

    buildhere->rc_offsets_off_in_sect = offset+localoff;

    localoff += lists_len;

    if (localoff > buildhere->rc_length) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            " DW_DLE_RNGLISTS_ERROR: .debug_rnglists"

            " length of rnglists header too large at"

            " of %u is clearly impossible. Corrupt data",

            localoff);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    buildhere->rc_first_rnglist_offset = offset+localoff;

    buildhere->rc_rnglists_header = startdata;

    buildhere->rc_endaddr = startdata +buildhere->rc_length;

    if (buildhere->rc_endaddr > end_data) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            " DW_DLE_RNGLISTS_ERROR: .debug_rnglists"

            " length of rnglists header (%u) "

            "runs off end of section. Corrupt data",

            buildhere->rc_length);

        _dwarf_error_string(dbg,error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    buildhere->rc_past_last_rnglist_offset =

        buildhere->rc_header_offset +buildhere->rc_length;

    *next_offset =  buildhere->rc_past_last_rnglist_offset;

    return DW_DLV_OK;

}

/*  We return a pointer to an array of contexts

    (not context pointers) through *cxt if

    we succeed and are returning DW_DLV_OK.

    We never return DW_DLV_NO_ENTRY here. */

static int

internal_load_rnglists_contexts(Dwarf_Debug dbg,

    Dwarf_Rnglists_Context **cxt,

    Dwarf_Unsigned *count,

    Dwarf_Error *error)

{

    Dwarf_Unsigned offset = 0;

    Dwarf_Unsigned nextoffset = 0;

    Dwarf_Small  * data = dbg->de_debug_rnglists.dss_data;

    Dwarf_Unsigned section_size = dbg->de_debug_rnglists.dss_size;

    Dwarf_Small  * startdata = data;

    Dwarf_Small  * end_data = data +section_size;

    Dwarf_Chain curr_chain = 0;

    Dwarf_Chain head_chain = 0;

    Dwarf_Chain *plast = &head_chain;

    int res = 0;

    Dwarf_Unsigned chainlength = 0;

    Dwarf_Rnglists_Context *fullarray = 0;

    Dwarf_Unsigned i = 0;

    for (i = 0 ; data < end_data ; ++i,data = startdata+nextoffset) {

        Dwarf_Rnglists_Context newcontext = 0;

        /* sizeof the context struct, not sizeof a pointer */

        newcontext = malloc(sizeof(*newcontext));

        if (!newcontext) {

            free_rnglists_chain(dbg,head_chain);

            _dwarf_error_string(dbg,error,

                DW_DLE_ALLOC_FAIL,

                "DW_DLE_ALLOC_FAIL: Allocation of "

                "Rnglists_Context failed");

            return DW_DLV_ERROR;

        }

        memset(newcontext,0,sizeof(*newcontext));

        newcontext->rc_magic = RNGLISTS_MAGIC;

        res = _dwarf_internal_read_rnglists_header(dbg,

            chainlength,

            section_size,

            data,end_data,offset,

            newcontext,&nextoffset,error);

        if (res == DW_DLV_ERROR) {

            free(newcontext);

            newcontext =  0;

            free_rnglists_chain(dbg,head_chain);

            return res;

        }

        newcontext->rc_magic = RNGLISTS_MAGIC;

        curr_chain = (Dwarf_Chain)

            _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);

        if (curr_chain == NULL) {

            _dwarf_error_string(dbg, error, DW_DLE_ALLOC_FAIL,

                "DW_DLE_ALLOC_FAIL: allocating Rnglists_Context"

                " chain entry");

            free(newcontext);

            newcontext =  0;

            free_rnglists_chain(dbg,head_chain);

            return DW_DLV_ERROR;

        }

        curr_chain->ch_item = newcontext;

        ++chainlength;

        (*plast) = curr_chain;

        plast = &(curr_chain->ch_next);

        offset = nextoffset;

        newcontext = 0;

    }

    fullarray= (Dwarf_Rnglists_Context *)malloc(

        chainlength *sizeof(Dwarf_Rnglists_Context /*pointer*/));

    if (!fullarray) {

        free_rnglists_chain(dbg,head_chain);

        _dwarf_error_string(dbg,error,

            DW_DLE_ALLOC_FAIL,"Allocation of "

            "Rnglists_Context pointer array failed");

        return DW_DLV_ERROR;

    }

    curr_chain = head_chain;

    for (i = 0; i < chainlength; ++i) {

        Dwarf_Chain prev = 0;

        Dwarf_Rnglists_Context c =

            (Dwarf_Rnglists_Context)curr_chain->ch_item;

        fullarray[i] = c;

        curr_chain->ch_item = 0;

        prev = curr_chain;

        curr_chain = curr_chain->ch_next;

        dwarf_dealloc(dbg, prev, DW_DLA_CHAIN);

    }

    /*  ASSERT: the chain is entirely alloc'd

        and the array of pointers points to

        individually malloc'd Dwarf_Rnglists_Context_s */

    *cxt = fullarray;

    *count = chainlength;

    return DW_DLV_OK;

}

/*  Used by dwarfdump to print raw rnglists data.

    Loads all the .debug_rnglists[.dwo]  headers and

    returns DW_DLV_NO_ENTRY if the section

    is missing or empty.

    Intended to be done quite early and

    done exactly once.

    Harmless to do more than once.

    With DW_DLV_OK it returns the number of

    rnglists headers in the section through

    rnglists_count. */

int dwarf_load_rnglists(

    Dwarf_Debug dbg,

    Dwarf_Unsigned *rnglists_count,

    Dwarf_Error *error)

{

    int res = DW_DLV_ERROR;

    Dwarf_Rnglists_Context *cxt = 0;

    Dwarf_Unsigned count = 0;

    CHECK_DBG(dbg,error,"dwarf_load_rnglists");

    if (dbg->de_rnglists_context) {

        if (rnglists_count) {

            *rnglists_count = dbg->de_rnglists_context_count;

        }

        return DW_DLV_OK;

    }

    if (!dbg->de_debug_rnglists.dss_size) {

        /* nothing there. */

        return DW_DLV_NO_ENTRY;

    }

    if (!dbg->de_debug_rnglists.dss_data) {

        res = _dwarf_load_section(dbg, &dbg->de_debug_rnglists,

            error);

        if (res != DW_DLV_OK) {

            return res;

        }

    }

    res = internal_load_rnglists_contexts(dbg,&cxt,&count,error);

    if (res == DW_DLV_ERROR) {

        return res;

    }

    dbg->de_rnglists_context = cxt;

    dbg->de_rnglists_context_count = count;

    if (rnglists_count) {

        *rnglists_count = count;

    }

    return DW_DLV_OK;

}

/*  Frees the memory in use in all rnglists contexts.

    Done by dwarf_finish()  */

void

_dwarf_dealloc_rnglists_context(Dwarf_Debug dbg)

{

    Dwarf_Unsigned i = 0;

    Dwarf_Rnglists_Context * rngcon = 0;

    if (IS_INVALID_DBG(dbg)) {

        return;

    }

    if (!dbg->de_rnglists_context) {

        return;

    }

    rngcon = dbg->de_rnglists_context;

    for ( ; i < dbg->de_rnglists_context_count; ++i) {

        Dwarf_Rnglists_Context con = rngcon[i];

        con->rc_offsets_array = 0;

        con->rc_magic = 0;

        con->rc_offset_entry_count = 0;

        free(con);

        rngcon[i] = 0;

    }

    free(dbg->de_rnglists_context);

    dbg->de_rnglists_context = 0;

    dbg->de_rnglists_context_count = 0;

}

/*  Used by dwarfdump to print raw rnglists data. */

int

dwarf_get_rnglist_offset_index_value(

    Dwarf_Debug dbg,

    Dwarf_Unsigned context_index,

    Dwarf_Unsigned offsetentry_index,

    Dwarf_Unsigned * offset_value_out,

    Dwarf_Unsigned * global_offset_value_out,

    Dwarf_Error *error)

{

    Dwarf_Rnglists_Context con = 0;

    unsigned offset_len = 0;

    Dwarf_Small *offsetptr = 0;

    Dwarf_Unsigned targetoffset = 0;

    Dwarf_Unsigned localoffset = 0;

    CHECK_DBG(dbg,error,"dwarf_get_rnglist_offset_index_value()");

    if (!dbg->de_rnglists_context) {

        return DW_DLV_NO_ENTRY;

    }

    if (!dbg->de_rnglists_context_count) {

        return DW_DLV_NO_ENTRY;

    }

    if (context_index >= dbg->de_rnglists_context_count) {

        return DW_DLV_NO_ENTRY;

    }

    con = dbg->de_rnglists_context[context_index];

    if (con->rc_magic != RNGLISTS_MAGIC) {

        _dwarf_error_string(NULL, error,DW_DLE_DBG_NULL,

            "DW_DLE_DBG_NULL "

            "rnglists context magic wrong "

            "not RNGLISTS_MAGIC");

        return DW_DLV_ERROR;

    }

    if (offsetentry_index >= con->rc_offset_entry_count) {

        return DW_DLV_NO_ENTRY;

    }

    offset_len  = con->rc_offset_size;

    localoffset = offsetentry_index*offset_len;

    offsetptr   = con->rc_offsets_array + localoffset;

    if ((con->rc_offsets_off_in_sect +localoffset +

        offset_len) >

        con->rc_past_last_rnglist_offset) {

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            "DW_DLE_RNGLISTS_ERROR "

            "dwarf_get_rnglist_offset_index_value() "

            " Offset for index %u is too large. ",

            offsetentry_index);

        _dwarf_error_string(dbg, error,DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    READ_UNALIGNED_CK(dbg,targetoffset,Dwarf_Unsigned,

        offsetptr,

        offset_len,error,con->rc_endaddr);

    if (offset_value_out) {

        *offset_value_out = targetoffset;

    }

    if (global_offset_value_out) {

        *global_offset_value_out = targetoffset +

            con->rc_offsets_off_in_sect;

    }

    return DW_DLV_OK;

}

/*  Used by dwarfdump to print basic data from the

    data generated to look at a specific rangelist

    as returned by  dwarf_rnglists_index_get_rle_head()

    or dwarf_rnglists_offset_get_rle_head. */

int dwarf_get_rnglist_head_basics(

    Dwarf_Rnglists_Head head,

    Dwarf_Unsigned * rle_count,

    Dwarf_Unsigned * rle_version,

    Dwarf_Unsigned * rnglists_index_returned,

    Dwarf_Unsigned * bytes_total_in_rle,

    Dwarf_Half     * offset_size,

    Dwarf_Half     * address_size,

    Dwarf_Half     * segment_selector_size,

    Dwarf_Unsigned * overall_offset_of_this_context,

    Dwarf_Unsigned * total_length_of_this_context,

    Dwarf_Unsigned * offset_table_offset,

    Dwarf_Unsigned * offset_table_entrycount,

    Dwarf_Bool     * rnglists_base_present,

    Dwarf_Unsigned * rnglists_base,

    Dwarf_Bool     * rnglists_base_address_present,

    Dwarf_Unsigned * rnglists_base_address,

    Dwarf_Bool     * rnglists_debug_addr_base_present,

    Dwarf_Unsigned * rnglists_debug_addr_base,

    Dwarf_Error *error)

{

    Dwarf_Rnglists_Context rngcontext = 0;

    if (!head || (!head->rh_dbg) ||

        head->rh_magic != RNGLISTS_MAGIC) {

        _dwarf_error_string(NULL, error,DW_DLE_DBG_NULL,

            "DW_DLE_DBG_NULL "

            "NULL or invalid Dwarf_Rnglists_Head "

            "argument passed to "

            "dwarf_get_rnglist_head_basics()");

        return DW_DLV_ERROR;

    }

    *rle_count = head->rh_count;

    *rle_version = head->rh_version;

    *rnglists_index_returned = head->rh_index;

    *bytes_total_in_rle = head->rh_bytes_total;

    *offset_size = head->rh_offset_size;

    *address_size = head->rh_address_size;

    *segment_selector_size = head->rh_segment_selector_size;

    rngcontext = head->rh_localcontext;

    if (rngcontext) {

        *overall_offset_of_this_context =

            rngcontext->rc_header_offset;

        *total_length_of_this_context = rngcontext->rc_length;

        *offset_table_offset = rngcontext->rc_offsets_off_in_sect;

        *offset_table_entrycount = rngcontext->rc_offset_entry_count;

    }

    *rnglists_base_present = head->rh_at_rnglists_base_present;

    *rnglists_base= head->rh_at_rnglists_base;

    *rnglists_base_address_present = head->rh_cu_base_address_present;

    *rnglists_base_address= head->rh_cu_base_address;

    *rnglists_debug_addr_base_present = head->rh_cu_addr_base_present;

    *rnglists_debug_addr_base  = head->rh_cu_addr_base;

    return DW_DLV_OK;

}

/*  Used by dwarfdump to print raw rnglists data.

    Enables printing of details about the Range List Table

    Headers, one header per call. Index starting at 0.

    Returns DW_DLV_NO_ENTRY if index is too high for the table.

    A .debug_rnglists section may contain any number

    of Range List Table Headers with their details.  */

int dwarf_get_rnglist_context_basics(

    Dwarf_Debug dbg,

    Dwarf_Unsigned context_index,

    Dwarf_Unsigned * header_offset,

    Dwarf_Small    * offset_size,

    Dwarf_Small    * extension_size,

    unsigned       * version, /* 5 */

    Dwarf_Small    * address_size,

    Dwarf_Small    * segment_selector_size,

    Dwarf_Unsigned * offset_entry_count,

    Dwarf_Unsigned * offset_of_offset_array,

    Dwarf_Unsigned * offset_of_first_rangeentry,

    Dwarf_Unsigned * offset_past_last_rangeentry,

    Dwarf_Error *error)

{

    Dwarf_Rnglists_Context con = 0;

    CHECK_DBG(dbg,error,"dwarf_get_rnglist_context_basics()");

    if (!dbg->de_rnglists_context_count) {

        return DW_DLV_NO_ENTRY;

    }

    if (context_index >= dbg->de_rnglists_context_count) {

        return DW_DLV_NO_ENTRY;

    }

    con = dbg->de_rnglists_context[context_index];

    if (con->rc_magic != RNGLISTS_MAGIC) {

        _dwarf_error_string(NULL, error,DW_DLE_DBG_NULL,

            "DW_DLE_DBG_NULL "

            "rnglists context "

            "not RNGLISTS_MAGIC "

            "in dwarf_get_rnglist_context_basics()");

        return DW_DLV_ERROR;

    }

    if (header_offset) {

        *header_offset = con->rc_header_offset;

    }

    if (offset_size) {

        *offset_size = con->rc_offset_size;

    }

    if (extension_size) {

        *extension_size = con->rc_extension_size;

    }

    if (version) {

        *version = con->rc_version;

    }

    if (address_size) {

        *address_size = con->rc_address_size;

    }

    if (segment_selector_size) {

        *segment_selector_size = con->rc_segment_selector_size;

    }

    if (offset_entry_count) {

        *offset_entry_count = con->rc_offset_entry_count;

    }

    if (offset_of_offset_array) {

        *offset_of_offset_array = con->rc_offsets_off_in_sect;

    }

    if (offset_of_first_rangeentry) {

        *offset_of_first_rangeentry = con->rc_first_rnglist_offset;

    }

    if (offset_past_last_rangeentry) {

        *offset_past_last_rangeentry =

            con->rc_past_last_rnglist_offset;

    }

    return DW_DLV_OK;

}

/*  Used by dwarfdump to print raw rnglists data.

    entry offset is offset_of_first_rangeentry.

    Stop when the returned *next_entry_offset

    is == offset_past_last_rangentry (from

    dwarf_get_rnglist_context_plus).

    This only makes sense within those ranges.

    This retrieves raw detail from the section,

    no base values or anything are added.

    So this returns raw individual entries

    for a single rnglist header, meaning a

    a single Dwarf_Rnglists_Context.  */

int dwarf_get_rnglist_rle(

    Dwarf_Debug dbg,

    Dwarf_Unsigned contextnumber,

    Dwarf_Unsigned entry_offset,

    Dwarf_Unsigned endoffset,

    unsigned *entrylen,

    unsigned *entry_kind,

    Dwarf_Unsigned *entry_operand1,

    Dwarf_Unsigned *entry_operand2,

    Dwarf_Error *error)

{

    Dwarf_Rnglists_Context con = 0;

    Dwarf_Small *data = 0;

    Dwarf_Small *enddata = 0;

    int res = 0;

    unsigned address_size = 0;

    Dwarf_Unsigned secsize = 0;

    CHECK_DBG(dbg,error,"dwarf_get_rnglist_rle()");

    secsize = dbg->de_debug_rnglists.dss_size;

    if (!dbg->de_rnglists_context_count) {

        return DW_DLV_NO_ENTRY;

    }

    if (!dbg->de_rnglists_context_count) {

        return DW_DLV_NO_ENTRY;

    }

    if (contextnumber >= dbg->de_rnglists_context_count) {

        return DW_DLV_NO_ENTRY;

    }

    if (entry_offset >= secsize) {

        return DW_DLV_NO_ENTRY;

    }

    if (endoffset > secsize) {

        _dwarf_error_string(dbg, error, DW_DLE_RNGLISTS_ERROR,

            " DW_DLE_RNGLISTS_ERROR "

            "The end offset to "

            "dwarf_get_rnglist_rle() is "

            "too large for the section");

        return DW_DLV_ERROR;

    }

    if (endoffset <= entry_offset) {

        _dwarf_error_string(dbg, error, DW_DLE_RNGLISTS_ERROR,

            " DW_DLE_RNGLISTS_ERROR "

            "The end offset to "

            "dwarf_get_rnglist_rle() is smaller than "

            "the entry offset! Corrupt data");

        return DW_DLV_ERROR;

    }

    if ((entry_offset +1) > endoffset) {

        /*  The read_single_rle_entry call will need

            at least 1 byte as it reads at least one

            ULEB */

        dwarfstring m;

        dwarfstring_constructor(&m);

        dwarfstring_append_printf_u(&m,

            " DW_DLE_RNGLISTS_ERROR "

            "The entry offset+1 (%lu) "

            "dwarf_get_rnglist_rle() is too close to the"

            " end",entry_offset+1);

        dwarfstring_append_printf_u(&m,

            " of the offset of the end of the entry (%lu)"

            " Apparently corrupt Dwarf",endoffset);

        _dwarf_error_string(dbg, error, DW_DLE_RNGLISTS_ERROR,

            dwarfstring_string(&m));

        dwarfstring_destructor(&m);

        return DW_DLV_ERROR;

    }

    data = dbg->de_debug_rnglists.dss_data +

        entry_offset;

    enddata = dbg->de_debug_rnglists.dss_data +

        endoffset;

    con = dbg->de_rnglists_context[contextnumber];

    address_size = con->rc_address_size;

    res = read_single_rle_entry(dbg,

        data,entry_offset,enddata,

        address_size,entrylen,

        entry_kind, entry_operand1, entry_operand2,

        error);

    return res;

}

static int

_dwarf_which_rnglists_context(Dwarf_Debug dbg,

    Dwarf_CU_Context ctx,

    Dwarf_Unsigned rnglist_offset,

    Dwarf_Unsigned *index,

    Dwarf_Error *error)

{

    Dwarf_Unsigned count;

    Dwarf_Rnglists_Context *array;

    Dwarf_Unsigned i = 0;

    array = dbg->de_rnglists_context;

    count = dbg->de_rnglists_context_count;

    /*  Using the slow way, a simple linear search. */

    if (!ctx->cc_rnglists_base_present) {

        /* We look at the location of each rnglist context

            to find one with the offset the DIE gave us. */

        for ( i = 0 ; i < count; ++i) {

            Dwarf_Rnglists_Context rcx = array[i];

            Dwarf_Unsigned rcxoff = rcx->rc_header_offset;

            Dwarf_Unsigned rcxend = rcxoff +

                rcx->rc_length;

            if (rnglist_offset < rcxoff){

                continue;

            }

            if (rnglist_offset < rcxend ){

                *index = i;

                return DW_DLV_OK;

            }

        }

        {

            dwarfstring m;

            dwarfstring_constructor(&m);

            dwarfstring_append_printf_u(&m,

                "DW_DLE_RNGLISTS_ERROR: rnglist ran off end "

                " finding target offset of"

                " 0x%" DW_PR_XZEROS DW_PR_DUx ,rnglist_offset);

            dwarfstring_append(&m,

                " Not found anywhere in .debug_rnglists "

                "data. Corrupted data?");

            _dwarf_error_string(dbg,error,

                DW_DLE_RNGLISTS_ERROR,

                dwarfstring_string(&m));

            dwarfstring_destructor(&m);

            return DW_DLV_ERROR;

        }

    } else {

        /*  We have a DW_AT_rnglists_base (cc_rangelists_base),

            let's use it. */

        Dwarf_Unsigned lookfor = 0;;

        lookfor = ctx->cc_rnglists_base;

        for ( i = 0 ; i < count; ++i) {

            dwarfstring m;

            Dwarf_Rnglists_Context rcx = array[i];

            if (rcx->rc_offsets_off_in_sect == lookfor){

                *index = i;

                return DW_DLV_OK;

            }

            if (rcx->rc_offsets_off_in_sect < lookfor){

                continue;

            }

            dwarfstring_constructor(&m);

            dwarfstring_append_printf_u(&m,

                "DW_DLE_RNGLISTS_ERROR: rnglists base of "

                " 0x%" DW_PR_XZEROS DW_PR_DUx ,lookfor);

            dwarfstring_append_printf_u(&m,

                " was not found though we are now at base "

                " 0x%" DW_PR_XZEROS DW_PR_DUx ,

                rcx->rc_offsets_off_in_sect);

            _dwarf_error_string(dbg,error,

                DW_DLE_RNGLISTS_ERROR,

                dwarfstring_string(&m));

            dwarfstring_destructor(&m);

            return DW_DLV_ERROR;

        }

        {

            dwarfstring m;

            dwarfstring_constructor(&m);