/*

   Copyright (C) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.

   Portions Copyright (C) 2007-2017 David Anderson. All Rights Reserved.

   Portions Copyright (C) 2010-2012 SN Systems Ltd. All Rights Reserved.

   Portions Copyright (C) 2015-2015 Google, 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.

*/

/*  This is #included twice. Once for

    libdwarf callers and one for dwarfdump which prints

    the internals.

    This way we have just one blob of code that reads

    the table operations.  */

#define TRUE 1

#define FALSE 0

static unsigned char

dwarf_standard_opcode_operand_count[STANDARD_OPERAND_COUNT_TWO_LEVEL] = {

    /* DWARF2 */

    0,

    1, 1, 1, 1,

    0, 0, 0,

    1,

    /* Following are new for DWARF3. */

    0, 0, 1,

    /* Experimental opcodes. */

    1, 2, 0,

};

/* We have a normal standard opcode base, but

   an arm compiler emitted a non-standard table!

   This could lead to problems...

   ARM C/C++ Compiler, RVCT4.0 [Build 4

   00] seems to get the table wrong .  */

static unsigned char

dwarf_arm_standard_opcode_operand_count[STANDARD_OPERAND_COUNT_DWARF3] = {

    /* DWARF2 */

    0,

    1, 1, 1, 1,

    0, 0, 0,

    0,  /* <<< --- this is wrong */

    /* Following are new for DWARF3. */

    0, 0, 1

};

/* Rather like memcmp but identifies which value pair

    mismatches (the return value is non-zero if mismatch,

    zero if match)..

    mismatch_entry returns the table index that mismatches.

    tabval returns the table byte value.

    lineval returns the value from the line table header.  */

static int

operandmismatch(unsigned char * table,unsigned table_length,

    unsigned char *linetable,

    unsigned check_count,

    unsigned * mismatch_entry, unsigned * tabval,unsigned *lineval)

{

    unsigned i = 0;

    /* check_count better be <= table_length */

    for (i = 0; i

        if (i > table_length) {

            *mismatch_entry = i;

            *lineval = linetable[i];

            *tabval = 0; /* No entry present. */

            /* A kind of mismatch */

            return  TRUE;

        }

        if (table[i] == linetable[i]) {

            continue;

        }

        *mismatch_entry = i;

        *tabval = table[i];

        *lineval = linetable[i];

        return  TRUE;

    }

    /* Matches. */

    return FALSE;

}

/* Common line table header reading code.

   Returns DW_DLV_OK, DW_DLV_ERROR.

   DW_DLV_NO_ENTRY cannot be returned, but callers should

   assume it is possible.

   The line_context area must be initialized properly before calling this.

   Has the side effect of allocating arrays which

   must be freed (see the Line_Table_Context which

   holds the pointers to space we allocate here).

   bogus_bytes_ptr and bogus_bytes are output values which

   let a print-program notify the user of some surprising bytes

   after a line table header and before the line table instructions.

   These can be ignored unless one is printing.

   And are ignored if NULL passed as the pointer.

   err_count_out may be NULL, in which case we

   make no attempt to count checking-type errors.

   Checking-type errors do not stop us, we just report them.

   See dw-linetableheader.txt for the ordering of text fields

   across the various dwarf versions. The code

   follows this ordering closely.

   Some of the arguments remaining are in line_context

   so can be deleted from the

   argument list (after a close look for correctness).

*/

static int

_dwarf_read_line_table_header(Dwarf_Debug dbg,

    Dwarf_CU_Context cu_context,

    Dwarf_Small * section_start,

    Dwarf_Small * data_start,

    Dwarf_Unsigned section_length,

    Dwarf_Small ** updated_data_start_out,

    Dwarf_Line_Context  line_context,

    Dwarf_Small ** bogus_bytes_ptr,

    Dwarf_Unsigned *bogus_bytes,

    Dwarf_Error * err,

    int *err_count_out)

{

    Dwarf_Small *line_ptr = data_start;

    Dwarf_Small *starting_line_ptr = data_start;

    Dwarf_Unsigned total_length = 0;

    int local_length_size = 0;

    int local_extension_size = 0;

    Dwarf_Unsigned prologue_length = 0;

    Dwarf_Half version = 0;

    Dwarf_Small *section_end = section_start + section_length;

    Dwarf_Small *line_ptr_end = 0;

    Dwarf_Small *lp_begin = 0;

    int res = 0;

    if (bogus_bytes_ptr) *bogus_bytes_ptr = 0;

    if (bogus_bytes) *bogus_bytes= 0;

    line_context->lc_line_ptr_start = starting_line_ptr;

    /* READ_AREA_LENGTH updates line_ptr for consumed bytes */

    READ_AREA_LENGTH_CK(dbg, total_length, Dwarf_Unsigned,

        line_ptr, local_length_size, local_extension_size,

        err, section_length,section_end);

    line_ptr_end = line_ptr + total_length;

    line_context->lc_line_ptr_end = line_ptr_end;

    line_context->lc_length_field_length = local_length_size +

        local_extension_size;

    line_context->lc_section_offset = starting_line_ptr -

        dbg->de_debug_line.dss_data;

    /*  ASSERT: line_context->lc_length_field_length == line_ptr

        -line_context->lc_line_ptr_start; */

    if (line_ptr_end > section_end) {

        _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);

        return (DW_DLV_ERROR);

    }

    line_context->lc_total_length = total_length;

    READ_UNALIGNED_CK(dbg, version, Dwarf_Half,

        line_ptr, sizeof(Dwarf_Half),

        err,line_ptr_end);

    line_context->lc_version_number = version;

    line_ptr += sizeof(Dwarf_Half);

    if (version != DW_LINE_VERSION2 &&

        version != DW_LINE_VERSION3 &&

        version != DW_LINE_VERSION4 &&

        version != DW_LINE_VERSION5 &&

        version != EXPERIMENTAL_LINE_TABLES_VERSION) {

        _dwarf_error(dbg, err, DW_DLE_VERSION_STAMP_ERROR);

        return (DW_DLV_ERROR);

    }

    if (version == DW_LINE_VERSION5) {

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);

            return (DW_DLV_ERROR);

        }

        line_context->lc_address_size = *(unsigned char *) line_ptr;

        line_ptr = line_ptr + sizeof(Dwarf_Small);

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);

            return (DW_DLV_ERROR);

        }

        line_context->lc_segment_selector_size =

            *(unsigned char *) line_ptr;

        line_ptr = line_ptr + sizeof(Dwarf_Small);

    } else {

        line_context->lc_address_size = cu_context->cc_address_size;

        line_context->lc_segment_selector_size =

            cu_context->cc_segment_selector_size;

    }

    READ_UNALIGNED_CK(dbg, prologue_length, Dwarf_Unsigned,

        line_ptr, local_length_size,

        err,line_ptr_end);

    line_context->lc_prologue_length = prologue_length;

    line_ptr += local_length_size;

    line_context->lc_line_prologue_start = line_ptr;

    if (line_ptr >= line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);

        return (DW_DLV_ERROR);

    }

    line_context->lc_minimum_instruction_length =

        *(unsigned char *) line_ptr;

    line_ptr = line_ptr + sizeof(Dwarf_Small);

    if (version == DW_LINE_VERSION4 ||

        version == DW_LINE_VERSION5 ||

        version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);

            return (DW_DLV_ERROR);

        }

        line_context->lc_maximum_ops_per_instruction =

            *(unsigned char *) line_ptr;

        line_ptr = line_ptr + sizeof(Dwarf_Small);

    }

    if (line_ptr >= line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);

        return (DW_DLV_ERROR);

    }

    line_context->lc_default_is_stmt = *(unsigned char *) line_ptr;

    line_ptr = line_ptr + sizeof(Dwarf_Small);

    if (line_ptr >= line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_LENGTH_BAD);

        return (DW_DLV_ERROR);

    }

    line_context->lc_line_base = *(signed char *) line_ptr;

    line_ptr = line_ptr + sizeof(Dwarf_Sbyte);

    if(line_ptr >= line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

        return DW_DLV_ERROR;

    }

    line_context->lc_line_range = *(unsigned char *) line_ptr;

    if (!line_context->lc_line_range) {

        _dwarf_error(dbg, err, DW_DLE_DEBUG_LINE_RANGE_ZERO);

        return DW_DLV_ERROR;

    }

    line_ptr = line_ptr + sizeof(Dwarf_Small);

    if(line_ptr >= line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

        return DW_DLV_ERROR;

    }

    line_context->lc_opcode_base = *(unsigned char *) line_ptr;

    line_ptr = line_ptr + sizeof(Dwarf_Small);

    /*  Set up the array of standard opcode lengths. */

    /*  We think this works ok even for cross-endian processing of

        objects.  It might be wrong, we might need to specially process

        the array of ubyte into host order.  */

    line_context->lc_opcode_length_table = line_ptr;

    /*  lc_opcode_base is one greater than the size of the array. */

    line_ptr += line_context->lc_opcode_base - 1;

    line_context->lc_std_op_count = line_context->lc_opcode_base -1;

    if(line_ptr >= line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

        return DW_DLV_ERROR;

    }

    {

        /*  Determine (as best we can) whether the

            lc_opcode_length_table holds 9 or 12 standard-conforming

            entries.  gcc4 upped to DWARF3's 12 without updating the

            version number.

            EXPERIMENTAL_LINE_TABLES_VERSION upped to 15.  */

        unsigned check_count = line_context->lc_std_op_count;

        unsigned tab_count = sizeof(dwarf_standard_opcode_operand_count);

        int operand_ck_fail = true;

        if (line_context->lc_std_op_count > tab_count) {

            _dwarf_print_header_issue(dbg,

                "Too many standard operands in linetable header: ",

                data_start,

                line_context->lc_std_op_count,

                0,0,0,

                err_count_out);

            check_count = tab_count;

        }

        {

            unsigned entrynum = 0;

            unsigned tabv     = 0;

            unsigned linetabv     = 0;

            int mismatch = operandmismatch(

                dwarf_standard_opcode_operand_count,

                tab_count,

                line_context->lc_opcode_length_table,

                check_count,&entrynum,&tabv,&linetabv);

            if (mismatch) {

                if (err_count_out) {

                    _dwarf_print_header_issue(dbg,

                        "standard-operands did not match, checked",

                        data_start,

                        check_count,

                        entrynum,tabv,linetabv,err_count_out);

                }

                if (check_count >

                    sizeof(dwarf_arm_standard_opcode_operand_count)) {

                    check_count =

                        sizeof(dwarf_arm_standard_opcode_operand_count);

                }

                mismatch = operandmismatch(

                    dwarf_arm_standard_opcode_operand_count,

                    sizeof(dwarf_arm_standard_opcode_operand_count),

                    line_context->lc_opcode_length_table,

                    check_count,&entrynum,&tabv,&linetabv);

                if (!mismatch && err_count_out) {

                    _dwarf_print_header_issue(dbg,

                        "arm (incorrect) operands in use: ",

                        data_start,

                        check_count,

                        entrynum,tabv,linetabv,err_count_out);

                }

            }

            if (!mismatch) {

                if (version == 2) {

                    if (line_context->lc_std_op_count ==

                        STANDARD_OPERAND_COUNT_DWARF3) {

                        _dwarf_print_header_issue(dbg,

                            "standard DWARF3 operands matched,"

                            " but is DWARF2 linetable: count",

                            data_start,

                            check_count,

                            0,0,0, err_count_out);

                    }

                }

                operand_ck_fail = false;

            }

        }

        if (operand_ck_fail) {

            /* Here we are not sure what the lc_std_op_count is. */

            _dwarf_error(dbg, err, DW_DLE_LINE_NUM_OPERANDS_BAD);

            return (DW_DLV_ERROR);

        }

    }

    /*  At this point we no longer need to check operand counts. */

    if(line_ptr >= line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

        return DW_DLV_ERROR;

    }

    if (version < DW_LINE_VERSION5){

        Dwarf_Unsigned directories_count = 0;

        Dwarf_Unsigned directories_malloc = 5;

        line_context->lc_include_directories = malloc(sizeof(Dwarf_Small *) *

            directories_malloc);

        if (line_context->lc_include_directories == NULL) {

            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

            return (DW_DLV_ERROR);

        }

        memset(line_context->lc_include_directories, 0,

            sizeof(Dwarf_Small *) * directories_malloc);

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

            return (DW_DLV_ERROR);

        }

        while ((*(char *) line_ptr) != '\0') {

            if (directories_count >= directories_malloc) {

                Dwarf_Unsigned expand = 2 * directories_malloc;

                Dwarf_Unsigned bytesalloc = sizeof(Dwarf_Small *) * expand;

                Dwarf_Small **newdirs =

                    realloc(line_context->lc_include_directories,

                        bytesalloc);

                if (!newdirs) {

                    _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

                    return (DW_DLV_ERROR);

                }

                /* Doubled size, zero out second half. */

                memset(newdirs + directories_malloc, 0,

                    sizeof(Dwarf_Small *) * directories_malloc);

                directories_malloc = expand;

                line_context->lc_include_directories = newdirs;

            }

            line_context->lc_include_directories[directories_count] =

                line_ptr;

            res = _dwarf_check_string_valid(dbg,

                data_start,line_ptr,line_ptr_end,

                DW_DLE_LINE_STRING_BAD,err);

            if (res != DW_DLV_OK) {

                return res;

            }

            line_ptr = line_ptr + strlen((char *) line_ptr) + 1;

            directories_count++;

            if (line_ptr >= line_ptr_end) {

                _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                return (DW_DLV_ERROR);

            }

        }

        line_ptr++;

        line_context->lc_include_directories_count = directories_count;

    } else if (version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        /* Empty old style dir entry list. */

        line_ptr++;

    } else if (version == 5) {

        /* handled below */

    } else {

        /* No old style directory entries. */

    }

    if(line_ptr > line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

        return DW_DLV_ERROR;

    }

    if (version < DW_LINE_VERSION5) {

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

            return (DW_DLV_ERROR);

        }

        while (*(char *) line_ptr != '\0') {

            Dwarf_Unsigned utmp;

            Dwarf_Unsigned dir_index = 0;

            Dwarf_Unsigned lastmod = 0;

            Dwarf_Unsigned file_length = 0;

            int resl = 0;

            Dwarf_File_Entry currfile  = 0;

            currfile = (Dwarf_File_Entry)

                malloc(sizeof(struct Dwarf_File_Entry_s));

            if (currfile == NULL) {

                _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

                return (DW_DLV_ERROR);

            }

            memset(currfile,0,sizeof(struct Dwarf_File_Entry_s));

            /*  Insert early so in case of error we can find

                and free the record. */

            _dwarf_add_to_files_list(line_context,currfile);

            currfile->fi_file_name = line_ptr;

            resl = _dwarf_check_string_valid(dbg,

                data_start,line_ptr,line_ptr_end,

                DW_DLE_LINE_STRING_BAD,err);

            if (resl != DW_DLV_OK) {

                return resl;

            }

            line_ptr = line_ptr + strlen((char *) line_ptr) + 1;

            DECODE_LEB128_UWORD_CK(line_ptr, utmp,dbg,err,line_ptr_end);

            dir_index = (Dwarf_Word) utmp;

            if (dir_index > line_context->lc_include_directories_count) {

                _dwarf_error(dbg, err, DW_DLE_DIR_INDEX_BAD);

                return (DW_DLV_ERROR);

            }

            currfile->fi_dir_index = dir_index;

            DECODE_LEB128_UWORD_CK(line_ptr,lastmod,

                dbg,err, line_ptr_end);

            currfile->fi_time_last_mod = lastmod;

            /* Skip over file length. */

            DECODE_LEB128_UWORD_CK(line_ptr,file_length,

                dbg,err, line_ptr_end);

            currfile->fi_file_length = file_length;

            if (line_ptr >= line_ptr_end) {

                _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                return (DW_DLV_ERROR);

            }

        }

        /* Skip trailing nul byte */

        ++line_ptr;

    } else if (version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

            return (DW_DLV_ERROR);

        }

        if (*line_ptr != 0) {

            _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

            return (DW_DLV_ERROR);

        }

        line_ptr++;

    } else if (version == 5) {

        /* handled below */

    } else {

        /* No old style filenames entries. */

    }

    if(line_ptr > line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

        return DW_DLV_ERROR;

    }

    if (version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        static unsigned char expbytes[5] = {0,0xff,0xff,0x7f, 0x7f };

        Dwarf_Unsigned logicals_table_offset = 0;

        Dwarf_Unsigned actuals_table_offset = 0;

        unsigned i = 0;

        for ( ; i < 5; ++i) {

            if (line_ptr >= line_ptr_end) {

                _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                return (DW_DLV_ERROR);

            }

            if (*line_ptr != expbytes[i]) {

                _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                return (DW_DLV_ERROR);

            }

            line_ptr++;

        }

        READ_UNALIGNED_CK(dbg, logicals_table_offset, Dwarf_Unsigned,

            line_ptr, local_length_size,err,line_ptr_end);

        line_context->lc_logicals_table_offset = logicals_table_offset;

        line_ptr += local_length_size;

        READ_UNALIGNED_CK(dbg, actuals_table_offset, Dwarf_Unsigned,

            line_ptr, local_length_size,err,line_ptr_end);

        line_context->lc_actuals_table_offset = actuals_table_offset;

        line_ptr += local_length_size;

        if(line_ptr > line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

            return DW_DLV_ERROR;

        }

    }

    if (version == DW_LINE_VERSION5 ||

        version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        /* DWARF 5.  directory names.*/

        Dwarf_Unsigned directory_format_count = 0;

        Dwarf_Unsigned *directory_entry_types = 0;

        Dwarf_Unsigned *directory_entry_forms = 0;

        Dwarf_Unsigned directories_count = 0;

        Dwarf_Unsigned i = 0;

        Dwarf_Unsigned j = 0;

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

            return (DW_DLV_ERROR);

        }

        directory_format_count = *(unsigned char *) line_ptr;

        line_ptr = line_ptr + sizeof(Dwarf_Small);

        if (directory_format_count > 0) {

            directory_entry_types = malloc(sizeof(Dwarf_Unsigned) *

                directory_format_count);

            if (directory_entry_types == NULL) {

                _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

                return (DW_DLV_ERROR);

            }

            directory_entry_forms = malloc(sizeof(Dwarf_Unsigned) *

                directory_format_count);

            if (directory_entry_forms == NULL) {

                free(directory_entry_types);

                _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

                return (DW_DLV_ERROR);

            }

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

                DECODE_LEB128_UWORD_CK(line_ptr, directory_entry_types[i],

                    dbg,err,line_ptr_end);

                DECODE_LEB128_UWORD_CK(line_ptr, directory_entry_forms[i],

                    dbg,err,line_ptr_end);

            }

        }

        DECODE_LEB128_UWORD_CK(line_ptr, directories_count,

            dbg,err,line_ptr_end);

        line_context->lc_include_directories =

            malloc(sizeof(Dwarf_Small *) * directories_count);

        if (line_context->lc_include_directories == NULL) {

            free(directory_entry_types);

            free(directory_entry_forms);

            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

            return (DW_DLV_ERROR);

        }

        if (directory_format_count ==0 &&

            directories_count > 0) {

            _dwarf_error(dbg, err, DW_DLE_DIRECTORY_FORMAT_COUNT_VS_DIRECTORIES_MISMATCH);

            return (DW_DLV_ERROR);

        }

        memset(line_context->lc_include_directories, 0,

            sizeof(Dwarf_Small *) * directories_count);

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

            for (j = 0; j < directory_format_count; j++) {

                switch (directory_entry_types[j]) {

                case DW_LNCT_path: {

                    char *inc_dir_ptr = 0;

                    res = _dwarf_decode_line_string_form(dbg,

                        directory_entry_forms[j],

                        local_length_size,

                        &line_ptr,

                        line_ptr_end,

                        &inc_dir_ptr,

                        err);

                    if (res != DW_DLV_OK) {

                        free(directory_entry_types);

                        free(directory_entry_forms);

                        return res;

                    }

                    line_context->lc_include_directories[i] =

                        (unsigned char *)inc_dir_ptr;

                    break;

                }

                default:

                    free(directory_entry_types);

                    free(directory_entry_forms);

                    _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                    return (DW_DLV_ERROR);

                }

            }

            if (line_ptr > line_ptr_end) {

                free(directory_entry_types);

                free(directory_entry_forms);

                _dwarf_error(dbg, err,

                    DW_DLE_LINE_NUMBER_HEADER_ERROR);

                return (DW_DLV_ERROR);

            }

        }

        free(directory_entry_types);

        free(directory_entry_forms);

        line_context->lc_include_directories_count = directories_count;

    }

    if (version == DW_LINE_VERSION5 ||

        version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        /* DWARF 5.  file names.*/

        Dwarf_Unsigned filename_format_count = 0;

        Dwarf_Unsigned *filename_entry_types = 0;

        Dwarf_Unsigned *filename_entry_forms = 0;

        Dwarf_Unsigned files_count = 0;

        Dwarf_Unsigned i = 0;

        Dwarf_Unsigned j = 0;

        if (line_ptr >= line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

            return (DW_DLV_ERROR);

        }

        filename_format_count = *(unsigned char *) line_ptr;

        line_ptr = line_ptr + sizeof(Dwarf_Small);

        filename_entry_types = malloc(sizeof(Dwarf_Unsigned) *

            filename_format_count);

        if (filename_entry_types == NULL) {

            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

            return (DW_DLV_ERROR);

        }

        filename_entry_forms = malloc(sizeof(Dwarf_Unsigned) *

            filename_format_count);

        if (filename_entry_forms == NULL) {

            free(filename_entry_types);

            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

            return (DW_DLV_ERROR);

        }

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

            DECODE_LEB128_UWORD_CK(line_ptr, filename_entry_types[i],

                dbg,err,line_ptr_end);

            DECODE_LEB128_UWORD_CK(line_ptr, filename_entry_forms[i],

                dbg,err,line_ptr_end);

        }

        DECODE_LEB128_UWORD_CK(line_ptr, files_count,

            dbg,err,line_ptr_end);

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

            Dwarf_File_Entry curline = 0;

            curline = (Dwarf_File_Entry)

                malloc(sizeof(struct Dwarf_File_Entry_s));

            if (curline == NULL) {

                free(filename_entry_types);

                _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

                return (DW_DLV_ERROR);

            }

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

            _dwarf_add_to_files_list(line_context,curline);

            for(j = 0; j < filename_format_count; j++) {

                Dwarf_Unsigned dirindex = 0;

                switch (filename_entry_types[j]) {

                case DW_LNCT_path:

                    res = _dwarf_decode_line_string_form(dbg,

                        filename_entry_forms[j],

                        local_length_size,

                        &line_ptr,

                        line_ptr_end,

                        (char **)&curline->fi_file_name,

                        err);

                    if (res != DW_DLV_OK) {

                        free(filename_entry_types);

                        free(filename_entry_forms);

                        return res;

                    }

                    break;

                case DW_LNCT_directory_index:

                    res = _dwarf_decode_line_udata_form(dbg,

                        filename_entry_forms[j],

                        &line_ptr,

                        &dirindex,

                        line_ptr_end,

                        err);

                    if (res != DW_DLV_OK) {

                        free(filename_entry_types);

                        free(filename_entry_forms);

                        return res;

                    }

                    curline->fi_dir_index = dirindex;

                    break;

                case DW_LNCT_timestamp:

                    res = _dwarf_decode_line_udata_form(dbg,

                        filename_entry_forms[j],

                        &line_ptr,

                        &curline->fi_time_last_mod,

                        line_ptr_end,

                        err);

                    if (res != DW_DLV_OK) {

                        free(filename_entry_types);

                        free(filename_entry_forms);

                        return res;

                    }

                    break;

                case DW_LNCT_size:

                    res = _dwarf_decode_line_udata_form(dbg,

                        filename_entry_forms[j],

                        &line_ptr,

                        &curline->fi_file_length,

                        line_ptr_end,

                        err);

                    if (res != DW_DLV_OK) {

                        free(filename_entry_types);

                        free(filename_entry_forms);

                        return res;

                    }

                    break;

                case DW_LNCT_MD5: /* Not yet implemented */

                default:

                    free(filename_entry_types);

                    free(filename_entry_forms);

                    _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                    return (DW_DLV_ERROR);

                }

                if (line_ptr > line_ptr_end) {

                    free(filename_entry_types);

                    free(filename_entry_forms);

                    _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                    return (DW_DLV_ERROR);

                }

            }

        }

        free(filename_entry_types);

        free(filename_entry_forms);

    }

    /* For two-level line tables, read the subprograms table. */

    if (version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        Dwarf_Unsigned subprog_format_count = 0;

        Dwarf_Unsigned *subprog_entry_types = 0;

        Dwarf_Unsigned *subprog_entry_forms = 0;

        Dwarf_Unsigned subprogs_count = 0;

        Dwarf_Unsigned i = 0;

        Dwarf_Unsigned j = 0;

        if (line_ptr > line_ptr_end) {

            _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

            return (DW_DLV_ERROR);

        }

        subprog_format_count = *(unsigned char *) line_ptr;

        line_ptr = line_ptr + sizeof(Dwarf_Small);

        subprog_entry_types = malloc(sizeof(Dwarf_Unsigned) *

            subprog_format_count);

        if (subprog_entry_types == NULL) {

            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

            return (DW_DLV_ERROR);

        }

        subprog_entry_forms = malloc(sizeof(Dwarf_Unsigned) *

            subprog_format_count);

        if (subprog_entry_forms == NULL) {

            free(subprog_entry_types);

            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

            return (DW_DLV_ERROR);

        }

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

            DECODE_LEB128_UWORD_CK(line_ptr, subprog_entry_types[i],

                dbg,err,line_ptr_end);

            DECODE_LEB128_UWORD_CK(line_ptr, subprog_entry_forms[i],

                dbg,err,line_ptr_end);

        }

        DECODE_LEB128_UWORD_CK(line_ptr, subprogs_count,

            dbg,err,line_ptr_end);

        line_context->lc_subprogs =

            malloc(sizeof(struct Dwarf_Subprog_Entry_s) * subprogs_count);

        if (line_context->lc_subprogs == NULL) {

            free(subprog_entry_types);

            free(subprog_entry_forms);

            _dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);

            return (DW_DLV_ERROR);

        }

        memset(line_context->lc_subprogs, 0,

            sizeof(struct Dwarf_Subprog_Entry_s) * subprogs_count);

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

            struct Dwarf_Subprog_Entry_s *curline =

                line_context->lc_subprogs + i;

            for (j = 0; j < subprog_format_count; j++) {

                switch (subprog_entry_types[j]) {

                case DW_LNCT_GNU_subprogram_name:

                    res = _dwarf_decode_line_string_form(dbg,

                        subprog_entry_forms[j],

                        local_length_size,

                        &line_ptr,

                        line_ptr_end,

                        (char **)&curline->ds_subprog_name,

                        err);

                    if (res != DW_DLV_OK) {

                        free(subprog_entry_types);

                        free(subprog_entry_forms);

                        return res;

                    }

                    break;

                case DW_LNCT_GNU_decl_file:

                    res = _dwarf_decode_line_udata_form(dbg,

                        subprog_entry_forms[j],

                        &line_ptr,

                        &curline->ds_decl_file,

                        line_ptr_end,

                        err);

                    if (res != DW_DLV_OK) {

                        free(subprog_entry_forms);

                        free(subprog_entry_types);

                        return res;

                    }

                    break;

                case DW_LNCT_GNU_decl_line:

                    res = _dwarf_decode_line_udata_form(dbg,

                        subprog_entry_forms[j],

                        &line_ptr,

                        &curline->ds_decl_line,

                        line_ptr_end,

                        err);

                    if (res != DW_DLV_OK) {

                        free(subprog_entry_forms);

                        free(subprog_entry_types);

                        return res;

                    }

                    break;

                default:

                    free(subprog_entry_forms);

                    free(subprog_entry_types);

                    _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                    return (DW_DLV_ERROR);

                }

                if (line_ptr >= line_ptr_end) {

                    free(subprog_entry_types);

                    free(subprog_entry_forms);

                    _dwarf_error(dbg, err, DW_DLE_LINE_NUMBER_HEADER_ERROR);

                    return (DW_DLV_ERROR);

                }

            }

        }

        free(subprog_entry_types);

        free(subprog_entry_forms);

        line_context->lc_subprogs_count = subprogs_count;

    }

    if (version == EXPERIMENTAL_LINE_TABLES_VERSION) {

        lp_begin = line_context->lc_line_prologue_start +

            line_context->lc_logicals_table_offset;

    } else {

        lp_begin = line_context->lc_line_prologue_start +

            line_context->lc_prologue_length;

    }

    if(line_ptr > line_ptr_end) {

        _dwarf_error(dbg, err, DW_DLE_LINE_OFFSET_BAD);

        return DW_DLV_ERROR;

    }

    if (line_ptr != lp_begin) {

        if (line_ptr > lp_begin) {

            _dwarf_error(dbg, err, DW_DLE_LINE_PROLOG_LENGTH_BAD);

            return (DW_DLV_ERROR);

        } else {

            /*  Bug in compiler. These