LCOV - code coverage report
Current view: top level - elfutils/libdw - dwarf_getsrclines.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 219 279 78.5 %
Date: 2013-03-08 Functions: 3 3 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 110 226 48.7 %

           Branch data     Line data    Source code
       1                 :            : /* Return line number information of CU.
       2                 :            :    Copyright (C) 2004-2010 Red Hat, Inc.
       3                 :            :    This file is part of elfutils.
       4                 :            :    Written by Ulrich Drepper <drepper@redhat.com>, 2004.
       5                 :            : 
       6                 :            :    This file is free software; you can redistribute it and/or modify
       7                 :            :    it under the terms of either
       8                 :            : 
       9                 :            :      * the GNU Lesser General Public License as published by the Free
      10                 :            :        Software Foundation; either version 3 of the License, or (at
      11                 :            :        your option) any later version
      12                 :            : 
      13                 :            :    or
      14                 :            : 
      15                 :            :      * the GNU General Public License as published by the Free
      16                 :            :        Software Foundation; either version 2 of the License, or (at
      17                 :            :        your option) any later version
      18                 :            : 
      19                 :            :    or both in parallel, as here.
      20                 :            : 
      21                 :            :    elfutils is distributed in the hope that it will be useful, but
      22                 :            :    WITHOUT ANY WARRANTY; without even the implied warranty of
      23                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      24                 :            :    General Public License for more details.
      25                 :            : 
      26                 :            :    You should have received copies of the GNU General Public License and
      27                 :            :    the GNU Lesser General Public License along with this program.  If
      28                 :            :    not, see <http://www.gnu.org/licenses/>.  */
      29                 :            : 
      30                 :            : #ifdef HAVE_CONFIG_H
      31                 :            : # include <config.h>
      32                 :            : #endif
      33                 :            : 
      34                 :            : #include <assert.h>
      35                 :            : #include <stdlib.h>
      36                 :            : #include <string.h>
      37                 :            : #include "dwarf.h"
      38                 :            : #include "libdwP.h"
      39                 :            : 
      40                 :            : 
      41                 :            : struct filelist
      42                 :            : {
      43                 :            :   Dwarf_Fileinfo info;
      44                 :            :   struct filelist *next;
      45                 :            : };
      46                 :            : 
      47                 :            : struct linelist
      48                 :            : {
      49                 :            :   Dwarf_Line line;
      50                 :            :   struct linelist *next;
      51                 :            : };
      52                 :            : 
      53                 :            : 
      54                 :            : /* Compare by Dwarf_Line.addr, given pointers into an array of pointers.  */
      55                 :            : static int
      56                 :    5105342 : compare_lines (const void *a, const void *b)
      57                 :            : {
      58                 :    5105342 :   Dwarf_Line *const *p1 = a;
      59                 :    5105342 :   Dwarf_Line *const *p2 = b;
      60                 :            : 
      61         [ +  + ]:    5105342 :   if ((*p1)->addr == (*p2)->addr)
      62                 :            :     /* An end_sequence marker precedes a normal record at the same address.  */
      63                 :      10045 :     return (*p2)->end_sequence - (*p1)->end_sequence;
      64                 :            : 
      65                 :    5105342 :   return (*p1)->addr - (*p2)->addr;
      66                 :            : }
      67                 :            : 
      68                 :            : int
      69                 :      14148 : dwarf_getsrclines (Dwarf_Die *cudie, Dwarf_Lines **lines, size_t *nlines)
      70                 :            : {
      71 [ +  - ][ +  - ]:      14148 :   if (unlikely (cudie == NULL
      72                 :            :                 || INTUSE(dwarf_tag) (cudie) != DW_TAG_compile_unit))
      73                 :            :     return -1;
      74                 :            : 
      75                 :      14148 :   int res = -1;
      76                 :            : 
      77                 :            :   /* Get the information if it is not already known.  */
      78                 :      14148 :   struct Dwarf_CU *const cu = cudie->cu;
      79         [ +  + ]:      14148 :   if (cu->lines == NULL)
      80                 :            :     {
      81                 :            :       /* Failsafe mode: no data found.  */
      82                 :      14128 :       cu->lines = (void *) -1l;
      83                 :      14128 :       cu->files = (void *) -1l;
      84                 :            : 
      85                 :            :       /* The die must have a statement list associated.  */
      86                 :            :       Dwarf_Attribute stmt_list_mem;
      87                 :      14128 :       Dwarf_Attribute *stmt_list = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list,
      88                 :            :                                                        &stmt_list_mem);
      89                 :            : 
      90                 :            :       /* Get the offset into the .debug_line section.  NB: this call
      91                 :            :          also checks whether the previous dwarf_attr call failed.  */
      92                 :            :       const unsigned char *lineendp;
      93                 :      14128 :       const unsigned char *linep
      94                 :      14128 :         = __libdw_formptr (stmt_list, IDX_debug_line, DWARF_E_NO_DEBUG_LINE,
      95                 :            :                            (unsigned char **) &lineendp, NULL);
      96         [ +  - ]:      14128 :       if (linep == NULL)
      97                 :            :         goto out;
      98                 :            : 
      99                 :            :       /* Get the compilation directory.  */
     100                 :            :       Dwarf_Attribute compdir_attr_mem;
     101                 :      14128 :       Dwarf_Attribute *compdir_attr = INTUSE(dwarf_attr) (cudie,
     102                 :            :                                                           DW_AT_comp_dir,
     103                 :            :                                                           &compdir_attr_mem);
     104                 :      14128 :       const char *comp_dir = INTUSE(dwarf_formstring) (compdir_attr);
     105                 :            : 
     106         [ -  + ]:      14128 :       if (unlikely (linep + 4 > lineendp))
     107                 :            :         {
     108                 :            :         invalid_data:
     109                 :          0 :           __libdw_seterrno (DWARF_E_INVALID_DEBUG_LINE);
     110                 :            :           goto out;
     111                 :            :         }
     112                 :            : 
     113                 :      14128 :       Dwarf *dbg = cu->dbg;
     114         [ +  + ]:      14128 :       Dwarf_Word unit_length = read_4ubyte_unaligned_inc (dbg, linep);
     115                 :      14128 :       unsigned int length = 4;
     116         [ -  + ]:      14128 :       if (unlikely (unit_length == DWARF3_LENGTH_64_BIT))
     117                 :            :         {
     118         [ #  # ]:          0 :           if (unlikely (linep + 8 > lineendp))
     119                 :            :             goto invalid_data;
     120         [ #  # ]:          0 :           unit_length = read_8ubyte_unaligned_inc (dbg, linep);
     121                 :          0 :           length = 8;
     122                 :            :         }
     123                 :            : 
     124                 :            :       /* Check whether we have enough room in the section.  */
     125         [ -  + ]:      14128 :       if (unit_length < 2 + length + 5 * 1
     126         [ -  + ]:      14128 :           || unlikely (linep + unit_length > lineendp))
     127                 :            :         goto invalid_data;
     128                 :      14128 :       lineendp = linep + unit_length;
     129                 :            : 
     130                 :            :       /* The next element of the header is the version identifier.  */
     131 [ +  + ][ -  + ]:      14128 :       uint_fast16_t version = read_2ubyte_unaligned_inc (dbg, linep);
     132 [ +  - ][ -  + ]:      14128 :       if (unlikely (version < 2) || unlikely (version > 4))
     133                 :            :         {
     134                 :          0 :           __libdw_seterrno (DWARF_E_VERSION);
     135                 :            :           goto out;
     136                 :            :         }
     137                 :            : 
     138                 :            :       /* Next comes the header length.  */
     139                 :            :       Dwarf_Word header_length;
     140         [ +  - ]:      14128 :       if (length == 4)
     141         [ +  + ]:      14141 :         header_length = read_4ubyte_unaligned_inc (dbg, linep);
     142                 :            :       else
     143         [ #  # ]:          0 :         header_length = read_8ubyte_unaligned_inc (dbg, linep);
     144                 :      14128 :       const unsigned char *header_start = linep;
     145                 :            : 
     146                 :            :       /* Next the minimum instruction length.  */
     147                 :      14128 :       uint_fast8_t minimum_instr_len = *linep++;
     148                 :            : 
     149                 :            :       /* Next the maximum operations per instruction, in version 4 format.  */
     150                 :      14128 :       uint_fast8_t max_ops_per_instr = 1;
     151         [ -  + ]:      14128 :       if (version >= 4)
     152                 :            :         {
     153         [ #  # ]:          0 :           if (unlikely (lineendp - linep < 5))
     154                 :            :             goto invalid_data;
     155                 :          0 :           max_ops_per_instr = *linep++;
     156         [ #  # ]:          0 :           if (unlikely (max_ops_per_instr == 0))
     157                 :            :             goto invalid_data;
     158                 :            :         }
     159                 :            : 
     160                 :            :       /* Then the flag determining the default value of the is_stmt
     161                 :            :          register.  */
     162                 :      14128 :       uint_fast8_t default_is_stmt = *linep++;
     163                 :            : 
     164                 :            :       /* Now the line base.  */
     165                 :      14128 :       int_fast8_t line_base = (int8_t) *linep++;
     166                 :            : 
     167                 :            :       /* And the line range.  */
     168                 :      14128 :       uint_fast8_t line_range = *linep++;
     169                 :            : 
     170                 :            :       /* The opcode base.  */
     171                 :      14128 :       uint_fast8_t opcode_base = *linep++;
     172                 :            : 
     173                 :            :       /* Remember array with the standard opcode length (-1 to account for
     174                 :            :          the opcode with value zero not being mentioned).  */
     175                 :      14128 :       const uint8_t *standard_opcode_lengths = linep - 1;
     176         [ -  + ]:      14128 :       if (unlikely (lineendp - linep < opcode_base - 1))
     177                 :            :         goto invalid_data;
     178                 :      14128 :       linep += opcode_base - 1;
     179                 :            : 
     180                 :            :       /* First comes the list of directories.  Add the compilation
     181                 :            :          directory first since the index zero is used for it.  */
     182                 :            :       struct dirlist
     183                 :            :       {
     184                 :            :         const char *dir;
     185                 :            :         size_t len;
     186                 :            :         struct dirlist *next;
     187                 :      28256 :       } comp_dir_elem =
     188                 :            :         {
     189                 :            :           .dir = comp_dir,
     190         [ +  + ]:      14128 :           .len = comp_dir ? strlen (comp_dir) : 0,
     191                 :            :           .next = NULL
     192                 :            :         };
     193                 :      14128 :       struct dirlist *dirlist = &comp_dir_elem;
     194                 :      14128 :       unsigned int ndirlist = 1;
     195                 :            : 
     196                 :            :       // XXX Directly construct array to conserve memory?
     197         [ +  + ]:     101927 :       while (*linep != 0)
     198                 :            :         {
     199                 :      87799 :           struct dirlist *new_dir =
     200                 :            :             (struct dirlist *) alloca (sizeof (*new_dir));
     201                 :            : 
     202                 :      87799 :           new_dir->dir = (char *) linep;
     203                 :      87799 :           uint8_t *endp = memchr (linep, '\0', lineendp - linep);
     204         [ -  + ]:      87799 :           if (endp == NULL)
     205                 :            :             goto invalid_data;
     206                 :      87799 :           new_dir->len = endp - linep;
     207                 :      87799 :           new_dir->next = dirlist;
     208                 :      87799 :           dirlist = new_dir;
     209                 :      87799 :           ++ndirlist;
     210                 :      87799 :           linep = endp + 1;
     211                 :            :         }
     212                 :            :       /* Skip the final NUL byte.  */
     213                 :      14128 :       ++linep;
     214                 :            : 
     215                 :            :       /* Rearrange the list in array form.  */
     216                 :      14128 :       struct dirlist **dirarray
     217                 :      14128 :         = (struct dirlist **) alloca (ndirlist * sizeof (*dirarray));
     218         [ +  + ]:     116055 :       for (unsigned int n = ndirlist; n-- > 0; dirlist = dirlist->next)
     219                 :     101927 :         dirarray[n] = dirlist;
     220                 :            : 
     221                 :            :       /* Now read the files.  */
     222                 :      14128 :       struct filelist null_file =
     223                 :            :         {
     224                 :            :           .info =
     225                 :            :           {
     226                 :            :             .name = "???",
     227                 :            :             .mtime = 0,
     228                 :            :             .length = 0
     229                 :            :           },
     230                 :            :           .next = NULL
     231                 :            :         };
     232                 :      14128 :       struct filelist *filelist = &null_file;
     233                 :      14128 :       unsigned int nfilelist = 1;
     234                 :            : 
     235         [ -  + ]:      14128 :       if (unlikely (linep >= lineendp))
     236                 :            :         goto invalid_data;
     237         [ +  + ]:     217499 :       while (*linep != 0)
     238                 :            :         {
     239                 :     203371 :           struct filelist *new_file =
     240                 :            :             (struct filelist *) alloca (sizeof (*new_file));
     241                 :            : 
     242                 :            :           /* First comes the file name.  */
     243                 :     203371 :           char *fname = (char *) linep;
     244                 :     203371 :           uint8_t *endp = memchr (fname, '\0', lineendp - linep);
     245         [ -  + ]:     203371 :           if (endp == NULL)
     246                 :            :             goto invalid_data;
     247                 :     203371 :           size_t fnamelen = endp - (uint8_t *) fname;
     248                 :     203371 :           linep = endp + 1;
     249                 :            : 
     250                 :            :           /* Then the index.  */
     251                 :            :           Dwarf_Word diridx;
     252         [ -  + ]:     203371 :           get_uleb128 (diridx, linep);
     253         [ -  + ]:     203371 :           if (unlikely (diridx >= ndirlist))
     254                 :            :             {
     255                 :          0 :               __libdw_seterrno (DWARF_E_INVALID_DIR_IDX);
     256                 :            :               goto out;
     257                 :            :             }
     258                 :            : 
     259         [ +  + ]:     203371 :           if (*fname == '/')
     260                 :            :             /* It's an absolute path.  */
     261                 :        226 :             new_file->info.name = fname;
     262                 :            :           else
     263                 :            :             {
     264         [ +  + ]:     203145 :               new_file->info.name = libdw_alloc (dbg, char, 1,
     265                 :            :                                                  dirarray[diridx]->len + 1
     266                 :            :                                                  + fnamelen + 1);
     267                 :     203145 :               char *cp = new_file->info.name;
     268                 :            : 
     269         [ +  + ]:     203145 :               if (dirarray[diridx]->dir != NULL)
     270                 :            :                 {
     271                 :            :                   /* This value could be NULL in case the DW_AT_comp_dir
     272                 :            :                      was not present.  We cannot do much in this case.
     273                 :            :                      The easiest thing is to convert the path in an
     274                 :            :                    absolute path.  */
     275                 :     200721 :                   cp = stpcpy (cp, dirarray[diridx]->dir);
     276                 :            :                 }
     277                 :     203145 :               *cp++ = '/';
     278                 :     203145 :               strcpy (cp, fname);
     279         [ -  + ]:     203145 :               assert (strlen (new_file->info.name)
     280                 :            :                       < dirarray[diridx]->len + 1 + fnamelen + 1);
     281                 :            :             }
     282                 :            : 
     283                 :            :           /* Next comes the modification time.  */
     284         [ -  + ]:     203371 :           get_uleb128 (new_file->info.mtime, linep);
     285                 :            : 
     286                 :            :           /* Finally the length of the file.  */
     287         [ -  + ]:     203371 :           get_uleb128 (new_file->info.length, linep);
     288                 :            : 
     289                 :     203371 :           new_file->next = filelist;
     290                 :     203371 :           filelist = new_file;
     291                 :     203371 :           ++nfilelist;
     292                 :            :         }
     293                 :            :       /* Skip the final NUL byte.  */
     294                 :      14128 :       ++linep;
     295                 :            : 
     296                 :            :       /* Consistency check.  */
     297         [ -  + ]:      14128 :       if (unlikely (linep != header_start + header_length))
     298                 :            :         {
     299                 :          0 :           __libdw_seterrno (DWARF_E_INVALID_DWARF);
     300                 :            :           goto out;
     301                 :            :         }
     302                 :            : 
     303                 :            :         /* We are about to process the statement program.  Initialize the
     304                 :            :            state machine registers (see 6.2.2 in the v2.1 specification).  */
     305                 :      14128 :       Dwarf_Word addr = 0;
     306                 :      14128 :       unsigned int op_index = 0;
     307                 :      14128 :       unsigned int file = 1;
     308                 :      14128 :       int line = 1;
     309                 :      14128 :       unsigned int column = 0;
     310                 :      14128 :       uint_fast8_t is_stmt = default_is_stmt;
     311                 :      14128 :       bool basic_block = false;
     312                 :      14128 :       bool prologue_end = false;
     313                 :      14128 :       bool epilogue_begin = false;
     314                 :      14128 :       unsigned int isa = 0;
     315                 :      14128 :       unsigned int discriminator = 0;
     316                 :            : 
     317                 :            :       /* Apply the "operation advance" from a special opcode
     318                 :            :          or DW_LNS_advance_pc (as per DWARF4 6.2.5.1).  */
     319                 :            :       inline void advance_pc (unsigned int op_advance)
     320                 :            :       {
     321                 :    3058732 :         addr += minimum_instr_len * ((op_index + op_advance)
     322                 :    1529366 :                                      / max_ops_per_instr);
     323                 :     355217 :         op_index = (op_index + op_advance) % max_ops_per_instr;
     324                 :            :       }
     325                 :            : 
     326                 :            :       /* Process the instructions.  */
     327                 :      14128 :       struct linelist *linelist = NULL;
     328                 :      14128 :       unsigned int nlinelist = 0;
     329                 :            : 
     330                 :            :       /* Adds a new line to the matrix.
     331                 :            :          We cannot simply define a function because we want to use alloca.  */
     332                 :            : #define NEW_LINE(end_seq)                                               \
     333                 :            :       do {                                                              \
     334                 :            :         if (unlikely (add_new_line (alloca (sizeof (struct linelist)),  \
     335                 :            :                                     end_seq)))                          \
     336                 :            :           goto invalid_data;                                            \
     337                 :            :       } while (0)
     338                 :            : 
     339                 :    1277975 :       inline bool add_new_line (struct linelist *new_line, bool end_sequence)
     340                 :            :       {
     341                 :            :         /* Set the line information.  For some fields we use bitfields,
     342                 :            :            so we would lose information if the encoded values are too large.
     343                 :            :            Check just for paranoia, and call the data "invalid" if it
     344                 :            :            violates our assumptions on reasonable limits for the values.  */
     345                 :            : #define SET(field)                                                            \
     346                 :            :         do {                                                                  \
     347                 :            :           new_line->line.field = field;                                            \
     348                 :            :           if (unlikely (new_line->line.field != field))                            \
     349                 :            :             return true;                                                      \
     350                 :            :         } while (0)
     351                 :            : 
     352         [ +  - ]:    1277975 :         SET (addr);
     353         [ +  - ]:    1277975 :         SET (op_index);
     354         [ +  - ]:    1277975 :         SET (file);
     355         [ +  - ]:    1277975 :         SET (line);
     356         [ +  - ]:    1277975 :         SET (column);
     357         [ +  - ]:    1277975 :         SET (is_stmt);
     358         [ +  - ]:    1277975 :         SET (basic_block);
     359         [ +  - ]:    1277975 :         SET (end_sequence);
     360         [ +  - ]:    1277975 :         SET (prologue_end);
     361         [ +  - ]:    1277975 :         SET (epilogue_begin);
     362         [ +  - ]:    1277975 :         SET (isa);
     363         [ +  - ]:    1277975 :         SET (discriminator);
     364                 :            : 
     365                 :            : #undef SET
     366                 :            : 
     367                 :    1277975 :         new_line->next = linelist;
     368                 :    1277975 :         linelist = new_line;
     369                 :    1277975 :         ++nlinelist;
     370                 :            : 
     371                 :    1277975 :         return false;
     372                 :            :       }
     373                 :            : 
     374         [ +  + ]:    2473385 :       while (linep < lineendp)
     375                 :            :         {
     376                 :            :           unsigned int opcode;
     377                 :            :           unsigned int u128;
     378                 :            :           int s128;
     379                 :            : 
     380                 :            :           /* Read the opcode.  */
     381                 :    2459257 :           opcode = *linep++;
     382                 :            : 
     383                 :            :           /* Is this a special opcode?  */
     384         [ +  + ]:    2459257 :           if (likely (opcode >= opcode_base))
     385                 :            :             {
     386                 :            :               /* Yes.  Handling this is quite easy since the opcode value
     387                 :            :                  is computed with
     388                 :            : 
     389                 :            :                  opcode = (desired line increment - line_base)
     390                 :            :                            + (line_range * address advance) + opcode_base
     391                 :            :               */
     392                 :    1174149 :               int line_increment = (line_base
     393                 :    1174149 :                                     + (opcode - opcode_base) % line_range);
     394                 :            : 
     395                 :            :               /* Perform the increments.  */
     396                 :    1174149 :               line += line_increment;
     397                 :    1174149 :               advance_pc ((opcode - opcode_base) / line_range);
     398                 :            : 
     399                 :            :               /* Add a new line with the current state machine values.  */
     400         [ -  + ]:    1174149 :               NEW_LINE (0);
     401                 :            : 
     402                 :            :               /* Reset the flags.  */
     403                 :    1174149 :               basic_block = false;
     404                 :    1174149 :               prologue_end = false;
     405                 :    1174149 :               epilogue_begin = false;
     406                 :    1174149 :               discriminator = 0;
     407                 :            :             }
     408         [ +  + ]:    1285108 :           else if (opcode == 0)
     409                 :            :             {
     410                 :            :               /* This an extended opcode.  */
     411         [ -  + ]:     198098 :               if (unlikely (lineendp - linep < 2))
     412                 :            :                 goto invalid_data;
     413                 :            : 
     414                 :            :               /* The length.  */
     415                 :     198098 :               uint_fast8_t len = *linep++;
     416                 :            : 
     417         [ -  + ]:     198098 :               if (unlikely ((size_t) (lineendp - linep) < len))
     418                 :            :                 goto invalid_data;
     419                 :            : 
     420                 :            :               /* The sub-opcode.  */
     421                 :     198098 :               opcode = *linep++;
     422                 :            : 
     423   [ +  +  -  +  :     198098 :               switch (opcode)
                      - ]
     424                 :            :                 {
     425                 :            :                 case DW_LNE_end_sequence:
     426                 :            :                   /* Add a new line with the current state machine values.
     427                 :            :                      The is the end of the sequence.  */
     428         [ -  + ]:      23890 :                   NEW_LINE (1);
     429                 :            : 
     430                 :            :                   /* Reset the registers.  */
     431                 :      23890 :                   addr = 0;
     432                 :      23890 :                   op_index = 0;
     433                 :      23890 :                   file = 1;
     434                 :      23890 :                   line = 1;
     435                 :      23890 :                   column = 0;
     436                 :      23890 :                   is_stmt = default_is_stmt;
     437                 :      23890 :                   basic_block = false;
     438                 :      23890 :                   prologue_end = false;
     439                 :      23890 :                   epilogue_begin = false;
     440                 :      23890 :                   isa = 0;
     441                 :      23890 :                   discriminator = 0;
     442                 :      23890 :                   break;
     443                 :            : 
     444                 :            :                 case DW_LNE_set_address:
     445                 :            :                   /* The value is an address.  The size is defined as
     446                 :            :                      apporiate for the target machine.  We use the
     447                 :            :                      address size field from the CU header.  */
     448                 :      24013 :                   op_index = 0;
     449         [ -  + ]:      24013 :                   if (unlikely (lineendp - linep < cu->address_size))
     450                 :            :                     goto invalid_data;
     451         [ +  - ]:      24013 :                   if (__libdw_read_address_inc (dbg, IDX_debug_line, &linep,
     452                 :            :                                                 cu->address_size, &addr))
     453                 :            :                     goto out;
     454                 :            :                   break;
     455                 :            : 
     456                 :            :                 case DW_LNE_define_file:
     457                 :            :                   {
     458                 :          0 :                     char *fname = (char *) linep;
     459                 :          0 :                     uint8_t *endp = memchr (linep, '\0', lineendp - linep);
     460         [ #  # ]:          0 :                     if (endp == NULL)
     461                 :            :                       goto invalid_data;
     462                 :          0 :                     size_t fnamelen = endp - linep;
     463                 :          0 :                     linep = endp + 1;
     464                 :            : 
     465                 :            :                     unsigned int diridx;
     466         [ #  # ]:          0 :                     get_uleb128 (diridx, linep);
     467                 :            :                     Dwarf_Word mtime;
     468         [ #  # ]:          0 :                     get_uleb128 (mtime, linep);
     469                 :            :                     Dwarf_Word filelength;
     470         [ #  # ]:          0 :                     get_uleb128 (filelength, linep);
     471                 :            : 
     472                 :          0 :                     struct filelist *new_file =
     473                 :            :                       (struct filelist *) alloca (sizeof (*new_file));
     474         [ #  # ]:          0 :                     if (fname[0] == '/')
     475                 :          0 :                       new_file->info.name = fname;
     476                 :            :                     else
     477                 :            :                       {
     478                 :          0 :                         new_file->info.name =
     479         [ #  # ]:          0 :                           libdw_alloc (dbg, char, 1, (dirarray[diridx]->len + 1
     480                 :            :                                                       + fnamelen + 1));
     481                 :          0 :                         char *cp = new_file->info.name;
     482                 :            : 
     483         [ #  # ]:          0 :                         if (dirarray[diridx]->dir != NULL)
     484                 :            :                           /* This value could be NULL in case the
     485                 :            :                              DW_AT_comp_dir was not present.  We
     486                 :            :                              cannot do much in this case.  The easiest
     487                 :            :                              thing is to convert the path in an
     488                 :            :                              absolute path.  */
     489                 :          0 :                           cp = stpcpy (cp, dirarray[diridx]->dir);
     490                 :          0 :                         *cp++ = '/';
     491                 :          0 :                         strcpy (cp, fname);
     492                 :            :                       }
     493                 :            : 
     494                 :          0 :                     new_file->info.mtime = mtime;
     495                 :          0 :                     new_file->info.length = filelength;
     496                 :          0 :                     new_file->next = filelist;
     497                 :          0 :                     filelist = new_file;
     498                 :          0 :                     ++nfilelist;
     499                 :            :                   }
     500                 :          0 :                   break;
     501                 :            : 
     502                 :            :                 case DW_LNE_set_discriminator:
     503                 :            :                   /* Takes one ULEB128 parameter, the discriminator.  */
     504         [ -  + ]:     150195 :                   if (unlikely (standard_opcode_lengths[opcode] != 1))
     505                 :            :                     goto invalid_data;
     506                 :            : 
     507         [ -  + ]:     150195 :                   get_uleb128 (discriminator, linep);
     508                 :            :                   break;
     509                 :            : 
     510                 :            :                 default:
     511                 :            :                   /* Unknown, ignore it.  */
     512         [ #  # ]:          0 :                   if (unlikely ((size_t) (lineendp - (linep - 1)) < len))
     513                 :            :                     goto invalid_data;
     514                 :          0 :                   linep += len - 1;
     515                 :          0 :                   break;
     516                 :            :                 }
     517                 :            :             }
     518         [ +  - ]:    1087010 :           else if (opcode <= DW_LNS_set_isa)
     519                 :            :             {
     520                 :            :               /* This is a known standard opcode.  */
     521   [ +  +  +  +  :    1087010 :               switch (opcode)
          -  +  -  +  -  
             -  -  -  - ]
     522                 :            :                 {
     523                 :            :                 case DW_LNS_copy:
     524                 :            :                   /* Takes no argument.  */
     525         [ -  + ]:      79936 :                   if (unlikely (standard_opcode_lengths[opcode] != 0))
     526                 :            :                     goto invalid_data;
     527                 :            : 
     528                 :            :                   /* Add a new line with the current state machine values.  */
     529         [ -  + ]:      79936 :                   NEW_LINE (0);
     530                 :            : 
     531                 :            :                   /* Reset the flags.  */
     532                 :      79936 :                   basic_block = false;
     533                 :      79936 :                   prologue_end = false;
     534                 :      79936 :                   epilogue_begin = false;
     535                 :      79936 :                   discriminator = 0;
     536                 :      79936 :                   break;
     537                 :            : 
     538                 :            :                 case DW_LNS_advance_pc:
     539                 :            :                   /* Takes one uleb128 parameter which is added to the
     540                 :            :                      address.  */
     541         [ -  + ]:     115681 :                   if (unlikely (standard_opcode_lengths[opcode] != 1))
     542                 :            :                     goto invalid_data;
     543                 :            : 
     544         [ +  + ]:     115681 :                   get_uleb128 (u128, linep);
     545                 :            :                   advance_pc (u128);
     546                 :            :                   break;
     547                 :            : 
     548                 :            :                 case DW_LNS_advance_line:
     549                 :            :                   /* Takes one sleb128 parameter which is added to the
     550                 :            :                      line.  */
     551         [ -  + ]:     454350 :                   if (unlikely (standard_opcode_lengths[opcode] != 1))
     552                 :            :                     goto invalid_data;
     553                 :            : 
     554         [ +  + ]:     454350 :                   get_sleb128 (s128, linep);
     555                 :     454350 :                   line += s128;
     556                 :     454350 :                   break;
     557                 :            : 
     558                 :            :                 case DW_LNS_set_file:
     559                 :            :                   /* Takes one uleb128 parameter which is stored in file.  */
     560         [ -  + ]:     130077 :                   if (unlikely (standard_opcode_lengths[opcode] != 1))
     561                 :            :                     goto invalid_data;
     562                 :            : 
     563         [ -  + ]:     130077 :                   get_uleb128 (u128, linep);
     564                 :     130077 :                   file = u128;
     565                 :     130077 :                   break;
     566                 :            : 
     567                 :            :                 case DW_LNS_set_column:
     568                 :            :                   /* Takes one uleb128 parameter which is stored in column.  */
     569         [ #  # ]:          0 :                   if (unlikely (standard_opcode_lengths[opcode] != 1))
     570                 :            :                     goto invalid_data;
     571                 :            : 
     572         [ #  # ]:          0 :                   get_uleb128 (u128, linep);
     573                 :          0 :                   column = u128;
     574                 :          0 :                   break;
     575                 :            : 
     576                 :            :                 case DW_LNS_negate_stmt:
     577                 :            :                   /* Takes no argument.  */
     578         [ -  + ]:      67430 :                   if (unlikely (standard_opcode_lengths[opcode] != 0))
     579                 :            :                     goto invalid_data;
     580                 :            : 
     581                 :      67430 :                   is_stmt = 1 - is_stmt;
     582                 :      67430 :                   break;
     583                 :            : 
     584                 :            :                 case DW_LNS_set_basic_block:
     585                 :            :                   /* Takes no argument.  */
     586         [ #  # ]:          0 :                   if (unlikely (standard_opcode_lengths[opcode] != 0))
     587                 :            :                     goto invalid_data;
     588                 :            : 
     589                 :          0 :                   basic_block = true;
     590                 :          0 :                   break;
     591                 :            : 
     592                 :            :                 case DW_LNS_const_add_pc:
     593                 :            :                   /* Takes no argument.  */
     594         [ -  + ]:     239536 :                   if (unlikely (standard_opcode_lengths[opcode] != 0))
     595                 :            :                     goto invalid_data;
     596                 :            : 
     597                 :     239536 :                   advance_pc ((255 - opcode_base) / line_range);
     598                 :            :                   break;
     599                 :            : 
     600                 :            :                 case DW_LNS_fixed_advance_pc:
     601                 :            :                   /* Takes one 16 bit parameter which is added to the
     602                 :            :                      address.  */
     603         [ #  # ]:          0 :                   if (unlikely (standard_opcode_lengths[opcode] != 1)
     604         [ #  # ]:          0 :                       || unlikely (lineendp - linep < 2))
     605                 :            :                     goto invalid_data;
     606                 :            : 
     607 [ #  # ][ #  # ]:          0 :                   addr += read_2ubyte_unaligned_inc (dbg, linep);
     608                 :          0 :                   op_index = 0;
     609                 :          0 :                   break;
     610                 :            : 
     611                 :            :                 case DW_LNS_set_prologue_end:
     612                 :            :                   /* Takes no argument.  */
     613         [ #  # ]:          0 :                   if (unlikely (standard_opcode_lengths[opcode] != 0))
     614                 :            :                     goto invalid_data;
     615                 :            : 
     616                 :          0 :                   prologue_end = true;
     617                 :          0 :                   break;
     618                 :            : 
     619                 :            :                 case DW_LNS_set_epilogue_begin:
     620                 :            :                   /* Takes no argument.  */
     621         [ #  # ]:          0 :                   if (unlikely (standard_opcode_lengths[opcode] != 0))
     622                 :            :                     goto invalid_data;
     623                 :            : 
     624                 :          0 :                   epilogue_begin = true;
     625                 :          0 :                   break;
     626                 :            : 
     627                 :            :                 case DW_LNS_set_isa:
     628                 :            :                   /* Takes one uleb128 parameter which is stored in isa.  */
     629         [ #  # ]:          0 :                   if (unlikely (standard_opcode_lengths[opcode] != 1))
     630                 :            :                     goto invalid_data;
     631                 :            : 
     632         [ #  # ]:          0 :                   get_uleb128 (isa, linep);
     633                 :            :                   break;
     634                 :            :                 }
     635                 :            :             }
     636                 :            :           else
     637                 :            :             {
     638                 :            :               /* This is a new opcode the generator but not we know about.
     639                 :            :                  Read the parameters associated with it but then discard
     640                 :            :                  everything.  Read all the parameters for this opcode.  */
     641         [ #  # ]:          0 :               for (int n = standard_opcode_lengths[opcode]; n > 0; --n)
     642         [ #  # ]:          0 :                 get_uleb128 (u128, linep);
     643                 :            : 
     644                 :            :               /* Next round, ignore this opcode.  */
     645                 :    2459257 :               continue;
     646                 :            :             }
     647                 :            :         }
     648                 :            : 
     649                 :            :       /* Put all the files in an array.  */
     650         [ +  + ]:      14128 :       Dwarf_Files *files = libdw_alloc (dbg, Dwarf_Files,
     651                 :            :                                         sizeof (Dwarf_Files)
     652                 :            :                                         + nfilelist * sizeof (Dwarf_Fileinfo)
     653                 :            :                                         + (ndirlist + 1) * sizeof (char *),
     654                 :            :                                         1);
     655                 :      14128 :       const char **dirs = (void *) &files->info[nfilelist];
     656                 :            : 
     657                 :      14128 :       files->nfiles = nfilelist;
     658         [ +  + ]:     231627 :       while (nfilelist-- > 0)
     659                 :            :         {
     660                 :     217499 :           files->info[nfilelist] = filelist->info;
     661                 :     217499 :           filelist = filelist->next;
     662                 :            :         }
     663         [ -  + ]:      14128 :       assert (filelist == NULL);
     664                 :            : 
     665                 :            :       /* Put all the directory strings in an array.  */
     666                 :      14128 :       files->ndirs = ndirlist;
     667         [ +  + ]:     116055 :       for (unsigned int i = 0; i < ndirlist; ++i)
     668                 :     101927 :         dirs[i] = dirarray[i]->dir;
     669                 :      14128 :       dirs[ndirlist] = NULL;
     670                 :            : 
     671                 :            :       /* Remember the referring CU.  */
     672                 :      14128 :       files->cu = cu;
     673                 :            : 
     674                 :            :       /* Make the file data structure available through the CU.  */
     675                 :      14128 :       cu->files = files;
     676                 :            : 
     677         [ +  + ]:      14128 :       void *buf = libdw_alloc (dbg, Dwarf_Lines, (sizeof (Dwarf_Lines)
     678                 :            :                                                   + (sizeof (Dwarf_Line)
     679                 :            :                                                      * nlinelist)), 1);
     680                 :            : 
     681                 :            :       /* First use the buffer for the pointers, and sort the entries.
     682                 :            :          We'll write the pointers in the end of the buffer, and then
     683                 :            :          copy into the buffer from the beginning so the overlap works.  */
     684                 :            :       assert (sizeof (Dwarf_Line) >= sizeof (Dwarf_Line *));
     685                 :      14128 :       Dwarf_Line **sortlines = (buf + sizeof (Dwarf_Lines)
     686                 :      28256 :                                 + ((sizeof (Dwarf_Line)
     687                 :      14128 :                                     - sizeof (Dwarf_Line *)) * nlinelist));
     688                 :            : 
     689                 :            :       /* The list is in LIFO order and usually they come in clumps with
     690                 :            :          ascending addresses.  So fill from the back to probably start with
     691                 :            :          runs already in order before we sort.  */
     692                 :      14128 :       unsigned int i = nlinelist;
     693         [ +  + ]:    1292103 :       while (i-- > 0)
     694                 :            :         {
     695                 :    1277975 :           sortlines[i] = &linelist->line;
     696                 :    1277975 :           linelist = linelist->next;
     697                 :            :         }
     698         [ -  + ]:      14128 :       assert (linelist == NULL);
     699                 :            : 
     700                 :            :       /* Sort by ascending address.  */
     701                 :      14128 :       qsort (sortlines, nlinelist, sizeof sortlines[0], &compare_lines);
     702                 :            : 
     703                 :            :       /* Now that they are sorted, put them in the final array.
     704                 :            :          The buffers overlap, so we've clobbered the early elements
     705                 :            :          of SORTLINES by the time we're reading the later ones.  */
     706                 :      14128 :       cu->lines = buf;
     707                 :      14128 :       cu->lines->nlines = nlinelist;
     708         [ +  + ]:    1292103 :       for (i = 0; i < nlinelist; ++i)
     709                 :            :         {
     710                 :    1277975 :           cu->lines->info[i] = *sortlines[i];
     711                 :    1277975 :           cu->lines->info[i].files = files;
     712                 :            :         }
     713                 :            : 
     714                 :            :       /* Success.  */
     715                 :      14128 :       res = 0;
     716                 :            :     }
     717         [ +  - ]:         20 :   else if (cu->lines != (void *) -1l)
     718                 :            :     /* We already have the information.  */
     719                 :         20 :     res = 0;
     720                 :            : 
     721         [ +  - ]:      14148 :   if (likely (res == 0))
     722                 :            :     {
     723                 :      14148 :       *lines = cu->lines;
     724                 :      14148 :       *nlines = cu->lines->nlines;
     725                 :            :     }
     726                 :            :  out:
     727                 :            : 
     728                 :            :   // XXX Eventually: unlocking here.
     729                 :            : 
     730                 :      14148 :   return res;
     731                 :            : }
     732                 :            : INTDEF(dwarf_getsrclines)

Generated by: LCOV version 1.9