LCOV - code coverage report
Current view: top level - libelf - elf32_updatenull.c (source / functions) Hit Total Coverage
Test: elfutils-0.189 Lines: 148 176 84.1 %
Date: 2023-06-17 20:23:55 Functions: 4 4 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 124 149 83.2 %

           Branch data     Line data    Source code
       1                 :            : /* Update data structures for changes.
       2                 :            :    Copyright (C) 2000-2010, 2015, 2016 Red Hat, Inc.
       3                 :            :    This file is part of elfutils.
       4                 :            :    Written by Ulrich Drepper <drepper@redhat.com>, 2000.
       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 <libelf.h>
      36                 :            : #include <stdbool.h>
      37                 :            : #include <string.h>
      38                 :            : 
      39                 :            : #include "libelfP.h"
      40                 :            : #include "elf-knowledge.h"
      41                 :            : 
      42                 :            : #ifndef LIBELFBITS
      43                 :            : # define LIBELFBITS 32
      44                 :            : #endif
      45                 :            : 
      46                 :            : /* Some fields contain 32/64 sizes.  We cannot use Elf32/64_Word for those,
      47                 :            :    since those are both 32bits.  Elf32/64_Xword is always 64bits.  */
      48                 :            : #define Elf32_SizeWord Elf32_Word
      49                 :            : #define Elf64_SizeWord Elf64_Xword
      50                 :            : 
      51                 :            : 
      52                 :            : static int
      53                 :        700 : ELFW(default_ehdr,LIBELFBITS) (Elf *elf, ElfW2(LIBELFBITS,Ehdr) *ehdr,
      54                 :            :                                size_t shnum, int *change_bop)
      55                 :            : {
      56                 :            :   /* Always write the magic bytes.  */
      57         [ +  + ]:        700 :   if (memcmp (&ehdr->e_ident[EI_MAG0], ELFMAG, SELFMAG) != 0)
      58                 :            :     {
      59                 :        279 :       memcpy (&ehdr->e_ident[EI_MAG0], ELFMAG, SELFMAG);
      60                 :        279 :       elf->state.ELFW(elf,LIBELFBITS).ehdr_flags |= ELF_F_DIRTY;
      61                 :            :     }
      62                 :            : 
      63                 :            :   /* Always set the file class.  */
      64         [ +  + ]:        700 :   update_if_changed (ehdr->e_ident[EI_CLASS], ELFW(ELFCLASS,LIBELFBITS),
      65                 :            :                      elf->state.ELFW(elf,LIBELFBITS).ehdr_flags);
      66                 :            : 
      67                 :            :   /* Set the data encoding if necessary.  */
      68         [ +  + ]:        700 :   if (unlikely (ehdr->e_ident[EI_DATA] == ELFDATANONE))
      69                 :            :     {
      70                 :          4 :       ehdr->e_ident[EI_DATA] =
      71                 :            :         BYTE_ORDER == BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB;
      72                 :          4 :       elf->state.ELFW(elf,LIBELFBITS).ehdr_flags |= ELF_F_DIRTY;
      73                 :            :     }
      74         [ -  + ]:        696 :   else if (unlikely (ehdr->e_ident[EI_DATA] >= ELFDATANUM))
      75                 :            :     {
      76                 :          0 :       __libelf_seterrno (ELF_E_DATA_ENCODING);
      77                 :          0 :       return 1;
      78                 :            :     }
      79                 :            :   else
      80                 :        696 :     *change_bop = ((BYTE_ORDER == LITTLE_ENDIAN
      81                 :            :                     && ehdr->e_ident[EI_DATA] != ELFDATA2LSB)
      82                 :        696 :                    || (BYTE_ORDER == BIG_ENDIAN
      83                 :            :                        && ehdr->e_ident[EI_DATA] != ELFDATA2MSB));
      84                 :            : 
      85                 :            :   /* Unconditionally overwrite the ELF version.  */
      86         [ +  + ]:        700 :   update_if_changed (ehdr->e_ident[EI_VERSION], EV_CURRENT,
      87                 :            :                      elf->state.ELFW(elf,LIBELFBITS).ehdr_flags);
      88                 :            : 
      89         [ +  + ]:        700 :   if (unlikely (ehdr->e_version == EV_NONE))
      90                 :            :     {
      91                 :          4 :       ehdr->e_version = EV_CURRENT;
      92                 :          4 :       elf->state.ELFW(elf,LIBELFBITS).ehdr_flags |= ELF_F_DIRTY;
      93                 :            :     }
      94         [ -  + ]:        696 :   else if (unlikely (ehdr->e_version != EV_CURRENT))
      95                 :            :     {
      96                 :          0 :       __libelf_seterrno (ELF_E_UNKNOWN_VERSION);
      97                 :          0 :       return 1;
      98                 :            :     }
      99                 :            : 
     100         [ +  + ]:        700 :   if (unlikely (shnum >= SHN_LORESERVE))
     101                 :            :     {
     102         [ +  + ]:         17 :       update_if_changed (ehdr->e_shnum, 0,
     103                 :            :                          elf->state.ELFW(elf,LIBELFBITS).ehdr_flags);
     104                 :            :     }
     105                 :            :   else
     106         [ +  + ]:        683 :     update_if_changed (ehdr->e_shnum, shnum,
     107                 :            :                        elf->state.ELFW(elf,LIBELFBITS).ehdr_flags);
     108                 :            : 
     109         [ +  + ]:        700 :   if (unlikely (ehdr->e_ehsize != elf_typesize (LIBELFBITS, ELF_T_EHDR, 1)))
     110                 :            :     {
     111                 :        469 :       ehdr->e_ehsize = elf_typesize (LIBELFBITS, ELF_T_EHDR, 1);
     112                 :        469 :       elf->state.ELFW(elf,LIBELFBITS).ehdr_flags |= ELF_F_DIRTY;
     113                 :            :     }
     114                 :            : 
     115                 :            :   /* If phnum is zero make sure e_phoff is also zero and not some random
     116                 :            :      value.  That would cause trouble in update_file.  */
     117   [ +  +  +  - ]:        700 :   if (ehdr->e_phnum == 0 && ehdr->e_phoff != 0)
     118                 :            :     {
     119                 :          0 :       ehdr->e_phoff = 0;
     120                 :          0 :       elf->state.ELFW(elf,LIBELFBITS).ehdr_flags |= ELF_F_DIRTY;
     121                 :            :     }
     122                 :            : 
     123                 :            :   return 0;
     124                 :            : }
     125                 :            : 
     126                 :            : 
     127                 :            : int64_t
     128                 :            : internal_function
     129                 :        700 : __elfw2(LIBELFBITS,updatenull_wrlock) (Elf *elf, int *change_bop, size_t shnum)
     130                 :            : {
     131                 :        700 :   ElfW2(LIBELFBITS,Ehdr) *ehdr;
     132                 :        700 :   int changed = 0;
     133                 :        700 :   int ehdr_flags = 0;
     134                 :            : 
     135                 :        700 :   ehdr = __elfw2(LIBELFBITS,getehdr_wrlock) (elf);
     136                 :            : 
     137                 :            :   /* Set the default values.  */
     138         [ -  + ]:        700 :   if (ELFW(default_ehdr,LIBELFBITS) (elf, ehdr, shnum, change_bop) != 0)
     139                 :            :     return -1;
     140                 :            : 
     141                 :            :   /* At least the ELF header is there.  */
     142                 :        700 :   ElfW2(LIBELFBITS,SizeWord) size = elf_typesize (LIBELFBITS, ELF_T_EHDR, 1);
     143                 :            : 
     144                 :            :   /* Set the program header position.  */
     145         [ +  + ]:        700 :   if (elf->state.ELFW(elf,LIBELFBITS).phdr == NULL)
     146                 :        296 :     (void) __elfw2(LIBELFBITS,getphdr_wrlock) (elf);
     147         [ +  + ]:        700 :   if (elf->state.ELFW(elf,LIBELFBITS).phdr != NULL)
     148                 :            :     {
     149                 :        433 :       size_t phnum;
     150         [ -  + ]:        433 :       if (unlikely (__elf_getphdrnum_rdlock (elf, &phnum) != 0))
     151                 :          0 :         return -1;
     152                 :            : 
     153         [ +  + ]:        433 :       if (elf->flags & ELF_F_LAYOUT)
     154                 :            :         {
     155                 :            :           /* The user is supposed to fill out e_phoff.  Use it and
     156                 :            :              e_phnum to determine the maximum extend.  */
     157                 :        366 :           size = MAX (size,
     158                 :            :                       ehdr->e_phoff
     159                 :            :                       + elf_typesize (LIBELFBITS, ELF_T_PHDR, phnum));
     160                 :            :         }
     161                 :            :       else
     162                 :            :         {
     163         [ +  + ]:         67 :           update_if_changed (ehdr->e_phoff,
     164                 :            :                              elf_typesize (LIBELFBITS, ELF_T_EHDR, 1),
     165                 :            :                              ehdr_flags);
     166                 :            : 
     167                 :            :           /* We need no alignment here.  */
     168                 :         67 :           size += elf_typesize (LIBELFBITS, ELF_T_PHDR, phnum);
     169                 :            :         }
     170                 :            :     }
     171                 :            : 
     172         [ +  + ]:        700 :   if (shnum > 0)
     173                 :            :     {
     174                 :        685 :       struct Elf_Scn *scn1 = NULL;
     175                 :        685 :       Elf_ScnList *list;
     176                 :        685 :       bool first = true;
     177                 :            : 
     178         [ -  + ]:        685 :       assert (elf->state.ELFW(elf,LIBELFBITS).scns.cnt > 0);
     179                 :            : 
     180         [ +  + ]:        685 :       if (shnum >= SHN_LORESERVE)
     181                 :            :         {
     182                 :            :           /* We have to  fill in the number of sections in the header
     183                 :            :              of the zeroth section.  */
     184                 :         17 :           Elf_Scn *scn0 = &elf->state.ELFW(elf,LIBELFBITS).scns.data[0];
     185                 :            : 
     186         [ +  - ]:         17 :           update_if_changed (scn0->shdr.ELFW(e,LIBELFBITS)->sh_size,
     187                 :            :                              shnum, scn0->shdr_flags);
     188                 :            :         }
     189                 :            : 
     190                 :            :       /* Go over all sections and find out how large they are.  */
     191                 :        685 :       list = &elf->state.ELFW(elf,LIBELFBITS).scns;
     192                 :            : 
     193                 :            :       /* Find the first section. */
     194         [ +  + ]:        685 :       if (list->cnt > 1)
     195                 :        681 :         scn1 = &list->data[1];
     196         [ +  - ]:          4 :       else if (list->next != NULL)
     197                 :          4 :         scn1 = &list->next->data[0];
     198                 :            : 
     199                 :            :       /* Load the section headers if necessary.  This loads the
     200                 :            :          headers for all sections.  */
     201         [ +  + ]:        685 :       if (scn1 != NULL && scn1->shdr.ELFW(e,LIBELFBITS) == NULL)
     202                 :         30 :         (void) __elfw2(LIBELFBITS,getshdr_wrlock) (scn1);
     203                 :            : 
     204                 :       1668 :       do
     205                 :            :         {
     206         [ +  + ]:    1917951 :           for (size_t cnt = first == true; cnt < list->cnt; ++cnt)
     207                 :            :             {
     208                 :    1916283 :               Elf_Scn *scn = &list->data[cnt];
     209                 :    1916283 :               ElfW2(LIBELFBITS,Shdr) *shdr = scn->shdr.ELFW(e,LIBELFBITS);
     210                 :    1916283 :               int64_t offset = 0;
     211                 :            : 
     212         [ -  + ]:    1916283 :               assert (shdr != NULL);
     213                 :    1916283 :               ElfW2(LIBELFBITS,SizeWord) sh_entsize = shdr->sh_entsize;
     214                 :    1916283 :               ElfW2(LIBELFBITS,SizeWord) sh_align = shdr->sh_addralign ?: 1;
     215         [ -  + ]:    1916283 :               if (unlikely (! powerof2 (sh_align)))
     216                 :            :                 {
     217                 :          0 :                   __libelf_seterrno (ELF_E_INVALID_ALIGN);
     218                 :          0 :                   return -1;
     219                 :            :                 }
     220                 :            : 
     221                 :            :               /* Set the sh_entsize value if we can reliably detect it.  */
     222   [ +  +  +  +  :    1916283 :               switch (shdr->sh_type)
          +  +  +  +  -  
                   -  + ]
     223                 :            :                 {
     224                 :        535 :                 case SHT_SYMTAB:
     225                 :        535 :                   sh_entsize = elf_typesize (LIBELFBITS, ELF_T_SYM, 1);
     226                 :        535 :                   break;
     227                 :       1087 :                 case SHT_RELA:
     228                 :       1087 :                   sh_entsize = elf_typesize (LIBELFBITS, ELF_T_RELA, 1);
     229                 :       1087 :                   break;
     230                 :      22026 :                 case SHT_GROUP:
     231                 :            :                   /* Only relocatable files can contain section groups.  */
     232         [ -  + ]:      22026 :                   if (ehdr->e_type != ET_REL)
     233                 :            :                     {
     234                 :          0 :                       __libelf_seterrno (ELF_E_GROUP_NOT_REL);
     235                 :          0 :                       return -1;
     236                 :            :                     }
     237                 :      22028 :                   FALLTHROUGH;
     238                 :            :                 case SHT_SYMTAB_SHNDX:
     239                 :      22028 :                   sh_entsize = elf_typesize (32, ELF_T_WORD, 1);
     240                 :      22028 :                   break;
     241                 :        136 :                 case SHT_HASH:
     242   [ +  +  +  +  :        136 :                   sh_entsize = SH_ENTSIZE_HASH (ehdr);
                   +  + ]
     243                 :            :                   break;
     244                 :        240 :                 case SHT_DYNAMIC:
     245                 :        240 :                   sh_entsize = elf_typesize (LIBELFBITS, ELF_T_DYN, 1);
     246                 :        240 :                   break;
     247                 :        214 :                 case SHT_REL:
     248                 :        214 :                   sh_entsize = elf_typesize (LIBELFBITS, ELF_T_REL, 1);
     249                 :        214 :                   break;
     250                 :        238 :                 case SHT_DYNSYM:
     251                 :        238 :                   sh_entsize = elf_typesize (LIBELFBITS, ELF_T_SYM, 1);
     252                 :        238 :                   break;
     253                 :          0 :                 case SHT_SUNW_move:
     254                 :          0 :                   sh_entsize = elf_typesize (LIBELFBITS, ELF_T_MOVE, 1);
     255                 :          0 :                   break;
     256                 :          0 :                 case SHT_SUNW_syminfo:
     257                 :          0 :                   sh_entsize = elf_typesize (LIBELFBITS, ELF_T_SYMINFO, 1);
     258                 :          0 :                   break;
     259                 :            :                 default:
     260                 :            :                   break;
     261                 :            :                 }
     262                 :            : 
     263                 :            :               /* If the section header contained the wrong entry size
     264                 :            :                  correct it and mark the header as modified.  */
     265         [ +  + ]:    1916283 :               update_if_changed (shdr->sh_entsize, sh_entsize,
     266                 :            :                                  scn->shdr_flags);
     267                 :            : 
     268                 :            :               /* Likewise for the alignment of a compressed section.
     269                 :            :                  For a SHF_COMPRESSED section set the correct
     270                 :            :                  sh_addralign value, which must match the d_align of
     271                 :            :                  the data (see __libelf_set_rawdata in elf_getdata.c).  */
     272         [ +  + ]:    1916283 :               if ((shdr->sh_flags & SHF_COMPRESSED) != 0)
     273                 :            :                 {
     274                 :        492 :                   sh_align = __libelf_type_align (ELFW(ELFCLASS,LIBELFBITS),
     275                 :            :                                                   ELF_T_CHDR);
     276         [ +  + ]:        492 :                   update_if_changed (shdr->sh_addralign, sh_align,
     277                 :            :                                      scn->shdr_flags);
     278                 :            :                 }
     279                 :            : 
     280         [ +  + ]:    1916283 :               if (scn->data_read == 0
     281         [ -  + ]:     263738 :                   && __libelf_set_rawdata_wrlock (scn) != 0)
     282                 :            :                 /* Something went wrong.  The error value is already set.  */
     283                 :            :                 return -1;
     284                 :            : 
     285                 :            :               /* Iterate over all data blocks.  */
     286         [ +  + ]:    1916283 :               if (list->data[cnt].data_list_rear != NULL)
     287                 :            :                 {
     288                 :    1652539 :                   Elf_Data_List *dl = &scn->data_list;
     289                 :            : 
     290         [ +  + ]:    3305228 :                   while (dl != NULL)
     291                 :            :                     {
     292                 :    1652689 :                       Elf_Data *data = &dl->data.d;
     293   [ +  +  +  + ]:    1652689 :                       if (dl == &scn->data_list && data->d_buf == NULL
     294         [ -  + ]:      67917 :                           && scn->rawdata.d.d_buf != NULL)
     295                 :          0 :                         data = &scn->rawdata.d;
     296                 :            : 
     297         [ -  + ]:    1652689 :                       if (unlikely (data->d_version != EV_CURRENT))
     298                 :            :                         {
     299                 :          0 :                           __libelf_seterrno (ELF_E_UNKNOWN_VERSION);
     300                 :          0 :                           return -1;
     301                 :            :                         }
     302                 :            : 
     303         [ -  + ]:    1652689 :                       if (unlikely (! powerof2 (data->d_align)))
     304                 :            :                         {
     305                 :          0 :                           __libelf_seterrno (ELF_E_INVALID_ALIGN);
     306                 :          0 :                           return -1;
     307                 :            :                         }
     308                 :            : 
     309                 :    1652689 :                       sh_align = MAX (sh_align, data->d_align);
     310                 :            : 
     311         [ +  + ]:    1652689 :                       if (elf->flags & ELF_F_LAYOUT)
     312                 :            :                         {
     313                 :            :                           /* The user specified the offset and the size.
     314                 :            :                              All we have to do is check whether this block
     315                 :            :                              fits in the size specified for the section.  */
     316         [ -  + ]:     401302 :                           if (unlikely ((ElfW2(LIBELFBITS,SizeWord))
     317                 :            :                                         (data->d_off + data->d_size)
     318                 :            :                                         > shdr->sh_size))
     319                 :            :                             {
     320                 :          0 :                               __libelf_seterrno (ELF_E_SECTION_TOO_SMALL);
     321                 :          0 :                               return -1;
     322                 :            :                             }
     323                 :            :                         }
     324                 :            :                       else
     325                 :            :                         {
     326                 :            :                           /* Determine the padding.  */
     327                 :    1251387 :                           offset = ((offset + data->d_align - 1)
     328                 :    1251387 :                                     & ~(data->d_align - 1));
     329                 :            : 
     330         [ +  + ]:    1251387 :                           update_if_changed (data->d_off, offset, changed);
     331                 :            : 
     332                 :    1251387 :                           offset += data->d_size;
     333                 :            :                         }
     334                 :            : 
     335                 :            :                       /* Next data block.  */
     336                 :    1652689 :                       dl = dl->next;
     337                 :            :                     }
     338                 :            :                 }
     339                 :            :               else
     340                 :            :                 /* Get the size of the section from the raw data.  If
     341                 :            :                    none is available the value is zero.  */
     342                 :     263744 :                 offset += scn->rawdata.d.d_size;
     343                 :            : 
     344         [ +  + ]:    1916283 :               if (elf->flags & ELF_F_LAYOUT)
     345                 :            :                 {
     346         [ +  + ]:     401994 :                   size = MAX (size,
     347                 :            :                               (shdr->sh_type != SHT_NOBITS
     348                 :            :                                ? shdr->sh_offset + shdr->sh_size : 0));
     349                 :            : 
     350                 :            :                   /* The alignment must be a power of two.  This is a
     351                 :            :                      requirement from the ELF specification.  Additionally
     352                 :            :                      we test for the alignment of the section being large
     353                 :            :                      enough for the largest alignment required by a data
     354                 :            :                      block.  */
     355         [ +  - ]:     401994 :                   if (unlikely (! powerof2 (shdr->sh_addralign))
     356         [ -  + ]:     401994 :                       || unlikely ((shdr->sh_addralign ?: 1) < sh_align))
     357                 :            :                     {
     358                 :          0 :                       __libelf_seterrno (ELF_E_INVALID_ALIGN);
     359                 :          0 :                       return -1;
     360                 :            :                     }
     361                 :            :                 }
     362                 :            :               else
     363                 :            :                 {
     364                 :            :                   /* How much alignment do we need for this section.  */
     365         [ +  + ]:    1514289 :                   update_if_changed (shdr->sh_addralign, sh_align,
     366                 :            :                                      scn->shdr_flags);
     367                 :            : 
     368                 :    1514289 :                   size = (size + sh_align - 1) & ~(sh_align - 1);
     369                 :    1514289 :                   int offset_changed = 0;
     370         [ +  + ]:    1514289 :                   update_if_changed (shdr->sh_offset, size, offset_changed);
     371                 :    2502762 :                   changed |= offset_changed;
     372                 :            : 
     373         [ +  + ]:     988473 :                   if (offset_changed && scn->data_list_rear == NULL)
     374                 :            :                     {
     375                 :            :                       /* The position of the section in the file
     376                 :            :                          changed.  Create the section data list.  */
     377         [ -  + ]:        180 :                       if (__elf_getdata_rdlock (scn, NULL) == NULL)
     378                 :            :                         return -1;
     379                 :            :                     }
     380                 :            : 
     381                 :            :                   /* See whether the section size is correct.  */
     382                 :    1514289 :                   int size_changed = 0;
     383         [ +  + ]:    1514289 :                   update_if_changed (shdr->sh_size,
     384                 :            :                                      (ElfW2(LIBELFBITS,SizeWord)) offset,
     385                 :            :                                      size_changed);
     386                 :    1514289 :                   changed |= size_changed;
     387                 :            : 
     388         [ +  + ]:    1514289 :                   if (shdr->sh_type != SHT_NOBITS)
     389                 :    1447061 :                     size += offset;
     390                 :            : 
     391                 :    1514289 :                   scn->shdr_flags |= (offset_changed | size_changed);
     392                 :    1514289 :                   scn->flags |= changed;
     393                 :            :                 }
     394                 :            : 
     395                 :            :               /* Check that the section size is actually a multiple of
     396                 :            :                  the entry size.  */
     397         [ +  + ]:    1916283 :               if (shdr->sh_entsize != 0 && shdr->sh_entsize != 1
     398         [ +  - ]:      26164 :                   && (elf->flags & ELF_F_PERMISSIVE) == 0)
     399                 :            :                 {
     400                 :            :                   /* For compressed sections check the uncompressed size.  */
     401                 :      26164 :                   ElfW2(LIBELFBITS,SizeWord) sh_size;
     402         [ +  + ]:      26164 :                   if ((shdr->sh_flags & SHF_COMPRESSED) == 0)
     403                 :      26155 :                     sh_size = shdr->sh_size;
     404                 :            :                   else
     405                 :            :                     {
     406                 :          9 :                       ElfW2(LIBELFBITS,Chdr) *chdr;
     407                 :          9 :                       chdr = elfw2(LIBELFBITS,getchdr) (scn);
     408         [ -  + ]:          9 :                       if (unlikely (chdr == NULL))
     409                 :            :                         return -1;
     410                 :          9 :                       sh_size = chdr->ch_size;
     411                 :            :                     }
     412                 :            : 
     413         [ -  + ]:      26164 :                   if (unlikely (sh_size % shdr->sh_entsize != 0))
     414                 :            :                     {
     415                 :          0 :                       __libelf_seterrno (ELF_E_INVALID_SHENTSIZE);
     416                 :          0 :                       return -1;
     417                 :            :                     }
     418                 :            :                 }
     419                 :            :             }
     420                 :            : 
     421   [ +  +  -  + ]:       1668 :           assert (list->next == NULL || list->cnt == list->max);
     422                 :            : 
     423                 :       1668 :           first = false;
     424                 :            :         }
     425         [ +  + ]:       1668 :       while ((list = list->next) != NULL);
     426                 :            : 
     427                 :            :       /* Store section information.  */
     428         [ +  + ]:        685 :       update_if_changed (ehdr->e_shentsize,
     429                 :            :                          elf_typesize (LIBELFBITS, ELF_T_SHDR, 1), ehdr_flags);
     430         [ +  + ]:        685 :       if (elf->flags & ELF_F_LAYOUT)
     431                 :            :         {
     432                 :            :           /* The user is supposed to fill out e_shoff.  Use it and
     433                 :            :              e_shnum (or sh_size of the dummy, first section header)
     434                 :            :              to determine the maximum extend.  */
     435                 :        385 :           size = MAX (size,
     436                 :            :                       (ehdr->e_shoff
     437                 :            :                        + (elf_typesize (LIBELFBITS, ELF_T_SHDR, shnum))));
     438                 :            :         }
     439                 :            :       else
     440                 :            :         {
     441                 :            :           /* Align for section header table.
     442                 :            : 
     443                 :            :              Yes, we use `sizeof' and not `__alignof__' since we do not
     444                 :            :              want to be surprised by architectures with less strict
     445                 :            :              alignment rules.  */
     446                 :            : #define SHDR_ALIGN sizeof (ElfW2(LIBELFBITS,Off))
     447                 :        300 :           size = (size + SHDR_ALIGN - 1) & ~(SHDR_ALIGN - 1);
     448                 :            : 
     449         [ +  + ]:        300 :           update_if_changed (ehdr->e_shoff, size, elf->flags);
     450                 :            : 
     451                 :            :           /* Account for the section header size.  */
     452                 :        300 :           size += elf_typesize (LIBELFBITS, ELF_T_SHDR, shnum);
     453                 :            :         }
     454                 :            :     }
     455                 :            : 
     456                 :        700 :   elf->state.ELFW(elf,LIBELFBITS).ehdr_flags |= ehdr_flags;
     457                 :            : 
     458                 :        700 :   return size;
     459                 :            : }

Generated by: LCOV version 1.16