| /* Return source lines of compilation unit. |
| Copyright (C) 2000, 2001, 2002 Red Hat, Inc. |
| This file is part of Red Hat elfutils. |
| Written by Ulrich Drepper <drepper@redhat.com>, 2000. |
| |
| Red Hat elfutils is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by the |
| Free Software Foundation; version 2 of the License. |
| |
| Red Hat elfutils is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License along |
| with Red Hat elfutils; if not, write to the Free Software Foundation, |
| Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. |
| |
| Red Hat elfutils is an included package of the Open Invention Network. |
| An included package of the Open Invention Network is a package for which |
| Open Invention Network licensees cross-license their patents. No patent |
| license is granted, either expressly or impliedly, by designation as an |
| included package. Should you wish to participate in the Open Invention |
| Network licensing program, please visit www.openinventionnetwork.com |
| <http://www.openinventionnetwork.com>. */ |
| |
| #ifdef HAVE_CONFIG_H |
| # include <config.h> |
| #endif |
| |
| #include <dwarf.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <libdwarfP.h> |
| |
| |
| struct dirlist |
| { |
| char *dir; |
| size_t len; |
| struct dirlist *next; |
| }; |
| |
| struct filelist |
| { |
| char *name; |
| Dwarf_Unsigned mtime; |
| Dwarf_Unsigned length; |
| struct filelist *next; |
| }; |
| |
| struct linelist |
| { |
| Dwarf_Line line; |
| struct linelist *next; |
| }; |
| |
| |
| /* Adds a new line to the matrix. We cannot definte a function because |
| we want to use alloca. */ |
| #define NEW_LINE(end_seq) \ |
| do { \ |
| /* Add the new line. */ \ |
| new_line = (struct linelist *) alloca (sizeof (struct linelist)); \ |
| new_line->line = (Dwarf_Line) malloc (sizeof (struct Dwarf_Line_s)); \ |
| if (new_line == NULL) \ |
| { \ |
| /* XXX Should we bother to free the memory? */ \ |
| __libdwarf_error (dbg, error, DW_E_NOMEM); \ |
| return DW_DLV_ERROR; \ |
| } \ |
| \ |
| /* Set the line information. */ \ |
| new_line->line->addr = address; \ |
| new_line->line->file = file; \ |
| new_line->line->line = line; \ |
| new_line->line->column = column; \ |
| new_line->line->is_stmt = is_stmt; \ |
| new_line->line->basic_block = basic_block; \ |
| new_line->line->end_sequence = end_seq; \ |
| new_line->line->prologue_end = prologue_end; \ |
| new_line->line->epilogue_begin = epilogue_begin; \ |
| \ |
| new_line->next = linelist; \ |
| linelist = new_line; \ |
| ++nlinelist; \ |
| } while (0) |
| |
| |
| int |
| dwarf_srclines (die, linebuf, linecount, error) |
| Dwarf_Die die; |
| Dwarf_Line **linebuf; |
| Dwarf_Signed *linecount; |
| Dwarf_Error *error; |
| { |
| Dwarf_CU_Info cu = die->cu; |
| Dwarf_Debug dbg = cu->dbg; |
| Dwarf_Attribute stmt_list; |
| Dwarf_Attribute comp_dir_attr; |
| char *comp_dir; |
| Dwarf_Unsigned offset; |
| Dwarf_Small *linep; |
| Dwarf_Small *lineendp; |
| Dwarf_Small *header_start; |
| Dwarf_Unsigned header_length; |
| Dwarf_File files; |
| Dwarf_Line *lines; |
| unsigned int unit_length; |
| unsigned int version; |
| unsigned int opcode_base; |
| Dwarf_Small *standard_opcode_lengths; |
| unsigned int minimum_instruction_length; |
| unsigned int default_is_stmt; |
| int line_base; |
| unsigned int line_range; |
| int length; |
| struct dirlist comp_dir_elem; |
| struct dirlist *dirlist; |
| unsigned int ndirlist; |
| struct dirlist **dirarray; |
| struct filelist *filelist; |
| unsigned int nfilelist; |
| struct filelist null_file; |
| Dwarf_Unsigned address; |
| size_t file; |
| size_t line; |
| size_t column; |
| int is_stmt; |
| int basic_block; |
| int prologue_end; |
| int epilogue_begin; |
| struct linelist *linelist; |
| unsigned int nlinelist; |
| int res; |
| |
| /* The die must be for a compilation unit. */ |
| if (unlikely (die->abbrev->tag != DW_TAG_compile_unit)) |
| { |
| __libdwarf_error (die->cu->dbg, error, DW_E_NO_CU); |
| return DW_DLV_ERROR; |
| } |
| |
| /* The die must have a statement list associated. */ |
| res = dwarf_attr (die, DW_AT_stmt_list, &stmt_list, error); |
| if (unlikely (res != DW_DLV_OK)) |
| return res; |
| |
| /* Get the offset into the .debug_line section. */ |
| res = dwarf_formudata (stmt_list, &offset, error); |
| if (unlikely (res != DW_DLV_OK)) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| return res; |
| } |
| |
| /* We need a .debug_line section. */ |
| if (dbg->sections[IDX_debug_line].addr == NULL) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_NO_DEBUG_LINE); |
| return DW_DLV_ERROR; |
| } |
| |
| linep = (Dwarf_Small *) dbg->sections[IDX_debug_line].addr + offset; |
| lineendp = ((Dwarf_Small *) dbg->sections[IDX_debug_line].addr |
| + dbg->sections[IDX_debug_line].size); |
| |
| /* Test whether at least the first 4 bytes are available. */ |
| if (unlikely (linep + 4 > lineendp)) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| /* Get the compilation directory. */ |
| res = dwarf_attr (die, DW_AT_comp_dir, &comp_dir_attr, error); |
| if (unlikely (res == DW_DLV_ERROR) |
| || (res == DW_DLV_OK |
| && unlikely (dwarf_formstring (comp_dir_attr, &comp_dir, error) |
| == DW_DLV_ERROR))) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| else if (res == DW_DLV_OK) |
| dwarf_dealloc (dbg, comp_dir_attr, DW_DLA_ATTR); |
| else |
| comp_dir = NULL; |
| |
| /* Read the unit_length. */ |
| unit_length = read_4ubyte_unaligned (dbg, linep); |
| linep += 4; |
| length = 4; |
| if (unit_length == 0xffffffff) |
| { |
| if (unlikely (linep + 8 > lineendp)) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| unit_length = read_8ubyte_unaligned (dbg, linep); |
| linep += 8; |
| length = 8; |
| } |
| |
| /* Check whether we have enough room in the section. */ |
| if (unlikely (linep + unit_length > lineendp)) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| lineendp = linep + unit_length; |
| |
| /* The next element of the header is the version identifier. */ |
| version = read_2ubyte_unaligned (dbg, linep); |
| if (unlikely (version != DWARF_VERSION)) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_VERSION_ERROR); |
| return DW_DLV_ERROR; |
| } |
| linep += 2; |
| |
| /* Next comes the header length. */ |
| if (length == 4) |
| { |
| header_length = read_4ubyte_unaligned (dbg, linep); |
| linep += 4; |
| } |
| else |
| { |
| header_length = read_8ubyte_unaligned (dbg, linep); |
| linep += 8; |
| } |
| header_start = linep; |
| |
| /* Next the minimum instruction length. */ |
| minimum_instruction_length = *linep++; |
| |
| /* Then the flag determining the default value of the is_stmt |
| register. */ |
| default_is_stmt = *linep++; |
| |
| /* Now the line base. */ |
| line_base = *((signed char *) linep)++; |
| |
| /* And the line range. */ |
| line_range = *linep++; |
| |
| /* The opcode base. */ |
| opcode_base = *linep++; |
| |
| /* Remember array with the standard opcode length (-1 to account for |
| the opcode with value zero not being mentioned). */ |
| standard_opcode_lengths = linep - 1; |
| linep += opcode_base - 1; |
| |
| /* First comes the list of directories. Add the compilation directory |
| first since the index zero is used for it. */ |
| comp_dir_elem.dir = comp_dir; |
| comp_dir_elem.len = comp_dir ? strlen (comp_dir) : 0; |
| comp_dir_elem.next = NULL; |
| dirlist = &comp_dir_elem; |
| ndirlist = 1; |
| |
| while (*linep != 0) |
| { |
| struct dirlist *new_dir = (struct dirlist *) alloca (sizeof (*new_dir)); |
| |
| new_dir->dir = (char *) linep; |
| new_dir->len = strlen ((char *) linep); |
| new_dir->next = dirlist; |
| dirlist = new_dir; |
| ++ndirlist; |
| linep += new_dir->len + 1; |
| } |
| /* Skip the final NUL byte. */ |
| ++linep; |
| |
| /* Rearrange the list in array form. */ |
| dirarray = (struct dirlist **) alloca (sizeof (*dirarray)); |
| while (ndirlist-- > 0) |
| { |
| dirarray[ndirlist] = dirlist; |
| dirlist = dirlist->next; |
| } |
| |
| comp_dir_elem.dir = comp_dir; |
| comp_dir_elem.len = comp_dir ? strlen (comp_dir) : 0; |
| comp_dir_elem.next = NULL; |
| dirlist = &comp_dir_elem; |
| ndirlist = 1; |
| |
| /* Now read the files. */ |
| null_file.name = "???"; |
| null_file.mtime = 0; |
| null_file.length = 0; |
| null_file.next = NULL; |
| filelist = &null_file; |
| nfilelist = 1; |
| |
| while (*linep != 0) |
| { |
| struct filelist *new_file = |
| (struct filelist *) alloca (sizeof (*new_file)); |
| char *fname; |
| size_t fnamelen; |
| Dwarf_Unsigned diridx; |
| |
| /* First comes the file name. */ |
| fname = (char *) linep; |
| fnamelen = strlen (fname); |
| linep += fnamelen + 1; |
| |
| /* Then the index. */ |
| get_uleb128 (diridx, linep); |
| if (unlikely (diridx >= ndirlist)) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DIR_IDX); |
| return DW_DLV_ERROR; |
| } |
| |
| if (*fname == '/') |
| /* It's an absolute path. */ |
| new_file->name = strdup (fname); |
| else |
| { |
| new_file->name = (char *) malloc (dirarray[diridx]->len + 1 |
| + fnamelen + 1); |
| if (new_file->name != NULL) |
| { |
| char *cp = new_file->name; |
| |
| if (dirarray[diridx]->dir != NULL) |
| /* This value could be NULL in case the DW_AT_comp_dir |
| was not present. We cannot do much in this case. |
| The easiest thing is to convert the path in an |
| absolute path. */ |
| cp = stpcpy (cp, dirarray[diridx]->dir); |
| *cp++ = '/'; |
| strcpy (cp, fname); |
| } |
| } |
| if (new_file->name == NULL) |
| { |
| /* XXX Should we bother to free all the memory? */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_NOMEM); |
| return DW_DLV_ERROR; |
| } |
| |
| /* Next comes the modification time. */ |
| get_uleb128 (new_file->mtime, linep); |
| |
| /* Finally the length of the file. */ |
| get_uleb128 (new_file->length, linep); |
| |
| new_file->next = filelist; |
| filelist = new_file; |
| ++nfilelist; |
| } |
| ++linep; |
| |
| /* Consistency check. */ |
| if (unlikely (linep != header_start + header_length)) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| /* We are about to process the statement program. Initialize the |
| state machine registers (see 6.2.2 in the v2.1 specification). */ |
| address = 0; |
| file = 1; |
| line = 1; |
| column = 0; |
| is_stmt = default_is_stmt; |
| basic_block = 0; |
| prologue_end = 0; |
| epilogue_begin = 0; |
| |
| /* Process the instructions. */ |
| linelist = NULL; |
| nlinelist = 0; |
| while (linep < lineendp) |
| { |
| struct linelist *new_line; |
| unsigned int opcode; |
| unsigned int u128; |
| int s128; |
| |
| /* Read the opcode. */ |
| opcode = *linep++; |
| |
| /* Is this a special opcode? */ |
| if (likely (opcode >= opcode_base)) |
| { |
| /* Yes. Handling this is quite easy since the opcode value |
| is computed with |
| |
| opcode = (desired line increment - line_base) |
| + (line_range * address advance) + opcode_base |
| */ |
| int line_increment = line_base + (opcode - opcode_base) % line_range; |
| unsigned int address_increment = (minimum_instruction_length |
| * ((opcode - opcode_base) |
| / line_range)); |
| |
| /* Perform the increments. */ |
| line += line_increment; |
| address += address_increment; |
| |
| /* Add a new line with the current state machine values. */ |
| NEW_LINE (0); |
| |
| /* Reset the flags. */ |
| basic_block = 0; |
| prologue_end = 0; |
| epilogue_begin = 0; |
| } |
| else if (opcode == 0) |
| { |
| /* This an extended opcode. */ |
| unsigned int len; |
| |
| /* The length. */ |
| len = *linep++; |
| |
| /* The sub-opecode. */ |
| opcode = *linep++; |
| |
| switch (opcode) |
| { |
| case DW_LNE_end_sequence: |
| /* Add a new line with the current state machine values. |
| The is the end of the sequence. */ |
| NEW_LINE (1); |
| |
| /* Reset the registers. */ |
| address = 0; |
| file = 1; |
| line = 1; |
| column = 0; |
| is_stmt = default_is_stmt; |
| basic_block = 0; |
| prologue_end = 0; |
| epilogue_begin = 0; |
| break; |
| |
| case DW_LNE_set_address: |
| if (cu->address_size == 4) |
| address = read_4ubyte_unaligned (dbg, linep); |
| else |
| address = read_8ubyte_unaligned (dbg, linep); |
| linep += cu->address_size; |
| break; |
| |
| case DW_LNE_define_file: |
| { |
| struct filelist *new_file; |
| char *fname; |
| size_t fnamelen; |
| unsigned int diridx; |
| Dwarf_Unsigned mtime; |
| Dwarf_Unsigned length; |
| |
| fname = (char *) linep; |
| fnamelen = strlen (fname); |
| linep += fnamelen + 1; |
| |
| get_uleb128 (diridx, linep); |
| get_uleb128 (mtime, linep); |
| get_uleb128 (length, linep); |
| |
| new_file = (struct filelist *) alloca (sizeof (*new_file)); |
| if (fname[0] == '/') |
| new_file->name = strdup (fname); |
| else |
| { |
| |
| new_file->name = (char *) malloc (dirarray[diridx]->len + 1 |
| + fnamelen + 1); |
| if (new_file->name != NULL) |
| { |
| char *cp = new_file->name; |
| |
| if (dirarray[diridx]->dir != NULL) |
| /* This value could be NULL in case the |
| DW_AT_comp_dir was not present. We |
| cannot do much in this case. The easiest |
| thing is to convert the path in an |
| absolute path. */ |
| cp = stpcpy (cp, dirarray[diridx]->dir); |
| *cp++ = '/'; |
| strcpy (cp, fname); |
| } |
| } |
| if (new_file->name == NULL) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_NOMEM); |
| return DW_DLV_ERROR; |
| } |
| |
| new_file->mtime = mtime; |
| new_file->length = length; |
| new_file->next = filelist; |
| filelist = new_file; |
| ++nfilelist; |
| } |
| break; |
| |
| default: |
| /* Unknown, ignore it. */ |
| linep += len - 1; |
| break; |
| } |
| } |
| else if (opcode <= DW_LNS_set_epilog_begin) |
| { |
| /* This is a known standard opcode. */ |
| switch (opcode) |
| { |
| case DW_LNS_copy: |
| /* Takes no argument. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 0)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| /* Add a new line with the current state machine values. */ |
| NEW_LINE (0); |
| |
| /* Reset the flags. */ |
| basic_block = 0; |
| /* XXX Whether the following two lines are necessary is |
| unclear. I guess the current v2.1 specification has |
| a bug in that it says clearing these two registers is |
| not necessary. */ |
| prologue_end = 0; |
| epilogue_begin = 0; |
| break; |
| |
| case DW_LNS_advance_pc: |
| /* Takes one uleb128 parameter which is added to the address. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 1)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| get_uleb128 (u128, linep); |
| address += minimum_instruction_length * u128; |
| break; |
| |
| case DW_LNS_advance_line: |
| /* Takes one sleb128 parameter which is added to the line. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 1)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| get_sleb128 (s128, linep); |
| line += s128; |
| break; |
| |
| case DW_LNS_set_file: |
| /* Takes one uleb128 parameter which is stored in file. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 1)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| get_uleb128 (u128, linep); |
| file = u128; |
| break; |
| |
| case DW_LNS_set_column: |
| /* Takes one uleb128 parameter which is stored in column. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 1)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| get_uleb128 (u128, linep); |
| column = u128; |
| break; |
| |
| case DW_LNS_negate_stmt: |
| /* Takes no argument. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 0)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| is_stmt = 1 - is_stmt; |
| break; |
| |
| case DW_LNS_set_basic_block: |
| /* Takes no argument. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 0)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| basic_block = 1; |
| break; |
| |
| case DW_LNS_const_add_pc: |
| /* Takes no argument. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 0)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| address += (minimum_instruction_length |
| * ((255 - opcode_base) / line_range)); |
| break; |
| |
| case DW_LNS_fixed_advance_pc: |
| /* Takes one 16 bit parameter which is added to the address. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 1)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| address += read_2ubyte_unaligned (dbg, linep); |
| linep += 2; |
| break; |
| |
| case DW_LNS_set_prologue_end: |
| /* Takes no argument. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 0)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| prologue_end = 1; |
| break; |
| |
| case DW_LNS_set_epilog_begin: |
| /* Takes no argument. */ |
| if (unlikely (standard_opcode_lengths[opcode] != 0)) |
| { |
| /* XXX Free memory. */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| epilogue_begin = 1; |
| break; |
| } |
| } |
| else |
| { |
| /* This is a new opcode the generator but not we know about. |
| Read the parameters associated with it but then discard |
| everything. */ |
| int n; |
| |
| /* Read all the parameters for this opcode. */ |
| for (n = standard_opcode_lengths[opcode]; n > 0; --n) |
| { |
| Dwarf_Unsigned u128; |
| get_uleb128 (u128, linep); |
| } |
| |
| /* Next round, ignore this opcode. */ |
| continue; |
| } |
| } |
| |
| /* Put all the files in an array. */ |
| files = (Dwarf_File) malloc (sizeof (struct Dwarf_File_s) |
| + nfilelist * sizeof (Dwarf_Fileinfo)); |
| if (files == NULL) |
| { |
| /* XXX Should we bother to free all the memory? */ |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_NOMEM); |
| return DW_DLV_ERROR; |
| } |
| |
| files->nfiles = nfilelist; |
| while (nfilelist-- > 0) |
| { |
| files->info[nfilelist].name = filelist->name; |
| files->info[nfilelist].mtime = filelist->mtime; |
| files->info[nfilelist].length = filelist->length; |
| filelist = filelist->next; |
| } |
| |
| /* Remember the debugging descriptor. */ |
| files->dbg = dbg; |
| |
| /* Now put the lines in an array. */ |
| lines = (Dwarf_Line *) malloc (nlinelist * sizeof (Dwarf_Line)); |
| if (lines == NULL) |
| { |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| __libdwarf_error (dbg, error, DW_E_NOMEM); |
| return DW_DLV_ERROR; |
| } |
| |
| *linebuf = lines; |
| *linecount = nlinelist; |
| |
| while (nlinelist--) |
| { |
| lines[nlinelist] = linelist->line; |
| linelist->line->files = files; |
| linelist = linelist->next; |
| } |
| |
| dwarf_dealloc (dbg, stmt_list, DW_DLA_ATTR); |
| |
| return DW_DLV_OK; |
| } |