libasm/asm_end.c

   1 /* Finalize operations on the assembler context, free all resources.
   2    Copyright (C) 2002, 2003, 2005, 2016 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 2002.
   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 <libintl.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40 #include <sys/stat.h>
  41
  42 #include <libasmP.h>
  43 #include <libelf.h>
  44 #include <system.h>
  45
  46
  47 static int
  48 text_end (AsmCtx_t *ctx __attribute__ ((unused)))
  49 {
  50   if (fclose (ctx->out.file) != 0)
  51     {
  52       __libasm_seterrno (ASM_E_IOERROR);
  53       return -1;
  54     }
  55
  56   return 0;
  57 }
  58
  59
  60 static int
  61 binary_end (AsmCtx_t *ctx)
  62 {
  63   void *symtab = NULL;
  64   Dwelf_Strent *symscn_strent = NULL;
  65   Dwelf_Strent *strscn_strent = NULL;
  66   Dwelf_Strent *xndxscn_strent = NULL;
  67   Elf_Scn *shstrscn;
  68   Dwelf_Strent *shstrscn_strent;
  69   size_t shstrscnndx;
  70   size_t symscnndx = 0;
  71   size_t strscnndx = 0;
  72   size_t xndxscnndx = 0;
  73   Elf_Data *data;
  74   Elf_Data *shstrtabdata;
  75   Elf_Data *strtabdata = NULL;
  76   Elf_Data *xndxdata = NULL;
  77   GElf_Shdr shdr_mem;
  78   GElf_Shdr *shdr;
  79   GElf_Ehdr ehdr_mem;
  80   GElf_Ehdr *ehdr;
  81   AsmScn_t *asmscn;
  82   int result = 0;
  83
  84   /* Iterate over the created sections and compute the offsets of the
  85      various subsections and fill in the content.  */
  86   for (asmscn = ctx->section_list; asmscn != NULL; asmscn = asmscn->allnext)
  87     {
  88 #if 0
  89       Elf_Scn *scn = elf_getscn (ctx->out.elf, asmscn->data.main.scnndx);
  90 #else
  91       Elf_Scn *scn = asmscn->data.main.scn;
  92 #endif
  93       off_t offset = 0;
  94       AsmScn_t *asmsubscn = asmscn;
  95
  96       do
  97         {
  98           struct AsmData *content = asmsubscn->content;
  99           bool first = true;
 100
 101           offset = ((offset + asmsubscn->max_align - 1)
 102                     & ~(asmsubscn->max_align - 1));
 103
 104           /* Update the offset for this subsection.  This field now
 105              stores the offset of the first by in this subsection.  */
 106           asmsubscn->offset = offset;
 107
 108           /* Note that the content list is circular.  */
 109           if (content != NULL)
 110             do
 111               {
 112                 Elf_Data *newdata = elf_newdata (scn);
 113
 114                 if (newdata == NULL)
 115                   {
 116                     __libasm_seterrno (ASM_E_LIBELF);
 117                     return -1;
 118                   }
 119
 120                 newdata->d_buf = content->data;
 121                 newdata->d_type = ELF_T_BYTE;
 122                 newdata->d_size = content->len;
 123                 newdata->d_off = offset;
 124                 newdata->d_align = first ? asmsubscn->max_align : 1;
 125
 126                 offset += content->len;
 127               }
 128             while ((content = content->next) != asmsubscn->content);
 129         }
 130       while ((asmsubscn = asmsubscn->subnext) != NULL);
 131     }
 132
 133
 134   /* Create the symbol table if necessary.  */
 135   if (ctx->nsymbol_tab > 0)
 136     {
 137       /* Create the symbol table and string table section names.  */
 138       symscn_strent = dwelf_strtab_add_len (ctx->section_strtab, ".symtab", 8);
 139       strscn_strent = dwelf_strtab_add_len (ctx->section_strtab, ".strtab", 8);
 140
 141       /* Create the symbol string table section.  */
 142       Elf_Scn *strscn = elf_newscn (ctx->out.elf);
 143       strtabdata = elf_newdata (strscn);
 144       shdr = gelf_getshdr (strscn, &shdr_mem);
 145       if (strtabdata == NULL || shdr == NULL)
 146         {
 147           __libasm_seterrno (ASM_E_LIBELF);
 148           return -1;
 149         }
 150       strscnndx = elf_ndxscn (strscn);
 151
 152       dwelf_strtab_finalize (ctx->symbol_strtab, strtabdata);
 153
 154       shdr->sh_type = SHT_STRTAB;
 155       assert (shdr->sh_entsize == 0);
 156
 157       (void) gelf_update_shdr (strscn, shdr);
 158
 159       /* Create the symbol table section.  */
 160       Elf_Scn *symscn = elf_newscn (ctx->out.elf);
 161       data = elf_newdata (symscn);
 162       shdr = gelf_getshdr (symscn, &shdr_mem);
 163       if (data == NULL || shdr == NULL)
 164         {
 165           __libasm_seterrno (ASM_E_LIBELF);
 166           return -1;
 167         }
 168       symscnndx = elf_ndxscn (symscn);
 169
 170       /* We know how many symbols there will be in the symbol table.  */
 171       data->d_size = gelf_fsize (ctx->out.elf, ELF_T_SYM,
 172                                  ctx->nsymbol_tab + 1, EV_CURRENT);
 173       symtab = malloc (data->d_size);
 174       if (symtab == NULL)
 175         return -1;
 176       data->d_buf = symtab;
 177       data->d_type = ELF_T_SYM;
 178       data->d_off = 0;
 179
 180       /* Clear the first entry.  */
 181       GElf_Sym syment;
 182       memset (&syment, '\0', sizeof (syment));
 183       (void) gelf_update_sym (data, 0, &syment);
 184
 185       /* Iterate over the symbol table.  */
 186       void *runp = NULL;
 187       int ptr_local = 1;        /* Start with index 1; zero remains unused.  */
 188       int ptr_nonlocal = ctx->nsymbol_tab;
 189       uint32_t *xshndx = NULL;
 190       AsmSym_t *sym;
 191       while ((sym = asm_symbol_tab_iterate (&ctx->symbol_tab, &runp)) != NULL)
 192         if (asm_emit_symbol_p (dwelf_strent_str (sym->strent)))
 193           {
 194             assert (ptr_local <= ptr_nonlocal);
 195
 196             syment.st_name = dwelf_strent_off (sym->strent);
 197             syment.st_info = GELF_ST_INFO (sym->binding, sym->type);
 198             syment.st_other = 0;
 199             syment.st_value = sym->scn->offset + sym->offset;
 200             syment.st_size = sym->size;
 201
 202             /* Add local symbols at the beginning, the other from
 203                the end.  */
 204             int ptr = sym->binding == STB_LOCAL ? ptr_local++ : ptr_nonlocal--;
 205
 206             /* Determine the section index.  We have to handle the
 207                overflow correctly.  */
 208             Elf_Scn *scn = (sym->scn->subsection_id == 0
 209                             ? sym->scn->data.main.scn
 210                             : sym->scn->data.up->data.main.scn);
 211
 212             Elf32_Word ndx;
 213             if (unlikely (scn == ASM_ABS_SCN))
 214               ndx = SHN_ABS;
 215             else if (unlikely (scn == ASM_COM_SCN))
 216               ndx = SHN_COMMON;
 217             else if (unlikely ((ndx = elf_ndxscn (scn)) >= SHN_LORESERVE))
 218               {
 219                 if (unlikely (xshndx == NULL))
 220                   {
 221                     /* The extended section index section does not yet
 222                        exist.  */
 223                     Elf_Scn *xndxscn;
 224
 225                     xndxscn = elf_newscn (ctx->out.elf);
 226                     xndxdata = elf_newdata (xndxscn);
 227                     shdr = gelf_getshdr (xndxscn, &shdr_mem);
 228                     if (xndxdata == NULL || shdr == NULL)
 229                       {
 230                         __libasm_seterrno (ASM_E_LIBELF);
 231                         return -1;
 232                       }
 233                     xndxscnndx = elf_ndxscn (xndxscn);
 234
 235                     shdr->sh_type = SHT_SYMTAB_SHNDX;
 236                     shdr->sh_entsize = sizeof (Elf32_Word);
 237                     shdr->sh_addralign = sizeof (Elf32_Word);
 238                     shdr->sh_link = symscnndx;
 239
 240                     (void) gelf_update_shdr (xndxscn, shdr);
 241
 242                     xndxscn_strent = dwelf_strtab_add_len (ctx->section_strtab,
 243                                                            ".symtab_shndx",
 244                                                            14);
 245
 246                     /* Note that using 'elf32_fsize' instead of
 247                        'gelf_fsize' here is correct.  */
 248                     xndxdata->d_size = elf32_fsize (ELF_T_WORD,
 249                                                     ctx->nsymbol_tab + 1,
 250                                                     EV_CURRENT);
 251                     xshndx = xndxdata->d_buf = calloc (1, xndxdata->d_size);
 252                     if (xshndx == NULL)
 253                       return -1;
 254                     /* Using ELF_T_WORD here relies on the fact that the
 255                        32- and 64-bit types are the same size.  */
 256                     xndxdata->d_type = ELF_T_WORD;
 257                     xndxdata->d_off = 0;
 258                   }
 259
 260                 /* Store the real section index in the extended setion
 261                    index table.  */
 262                 assert ((size_t) ptr < ctx->nsymbol_tab + 1);
 263                 xshndx[ptr] = ndx;
 264
 265                 /* And signal that this happened.  */
 266                 ndx = SHN_XINDEX;
 267               }
 268             syment.st_shndx = ndx;
 269
 270             /* Remember where we put the symbol.  */
 271             sym->symidx = ptr;
 272
 273             (void) gelf_update_sym (data, ptr, &syment);
 274           }
 275
 276       assert (ptr_local == ptr_nonlocal + 1);
 277
 278       shdr->sh_type = SHT_SYMTAB;
 279       shdr->sh_link = strscnndx;
 280       shdr->sh_info = ptr_local;
 281       shdr->sh_entsize = gelf_fsize (ctx->out.elf, ELF_T_SYM, 1, EV_CURRENT);
 282       shdr->sh_addralign = gelf_fsize (ctx->out.elf, ELF_T_ADDR, 1,
 283                                        EV_CURRENT);
 284
 285       (void) gelf_update_shdr (symscn, shdr);
 286     }
 287
 288
 289   /* Create the section header string table section and fill in the
 290      references in the section headers.  */
 291   shstrscn = elf_newscn (ctx->out.elf);
 292   shstrtabdata = elf_newdata (shstrscn);
 293   shdr = gelf_getshdr (shstrscn, &shdr_mem);
 294   if (shstrscn == NULL || shstrtabdata == NULL || shdr == NULL)
 295     {
 296       __libasm_seterrno (ASM_E_LIBELF);
 297       return -1;
 298     }
 299
 300
 301   /* Add the name of the section header string table.  */
 302   shstrscn_strent = dwelf_strtab_add_len (ctx->section_strtab,
 303                                           ".shstrtab", 10);
 304
 305   dwelf_strtab_finalize (ctx->section_strtab, shstrtabdata);
 306
 307   shdr->sh_type = SHT_STRTAB;
 308   assert (shdr->sh_entsize == 0);
 309   shdr->sh_name = dwelf_strent_off (shstrscn_strent);
 310
 311   (void) gelf_update_shdr (shstrscn, shdr);
 312
 313
 314   /* Create the section groups.  */
 315   if (ctx->groups != NULL)
 316     {
 317       AsmScnGrp_t *runp = ctx->groups->next;
 318
 319       do
 320         {
 321           Elf_Scn *scn;
 322           Elf32_Word *grpdata;
 323
 324           scn = runp->scn;
 325           assert (scn != NULL);
 326           shdr = gelf_getshdr (scn, &shdr_mem);
 327           assert (shdr != NULL);
 328
 329           data = elf_newdata (scn);
 330           if (data == NULL)
 331             {
 332               __libasm_seterrno (ASM_E_LIBELF);
 333               return -1;
 334             }
 335
 336           /* It is correct to use 'elf32_fsize' instead of 'gelf_fsize'
 337              here.  */
 338           data->d_size = elf32_fsize (ELF_T_WORD, runp->nmembers + 1,
 339                                       EV_CURRENT);
 340           grpdata = data->d_buf = malloc (data->d_size);
 341           if (grpdata == NULL)
 342             return -1;
 343           data->d_type = ELF_T_WORD;
 344           data->d_off = 0;
 345           data->d_align = elf32_fsize (ELF_T_WORD, 1, EV_CURRENT);
 346
 347           /* The first word of the section is filled with the flag word.  */
 348           *grpdata++ = runp->flags;
 349
 350           if (runp->members != NULL)
 351             {
 352               AsmScn_t *member = runp->members->data.main.next_in_group;
 353
 354               do
 355                 {
 356                   /* Only sections, not subsections, can be registered
 357                      as member of a group.  The subsections get
 358                      automatically included.  */
 359                   assert (member->subsection_id == 0);
 360
 361                   *grpdata++ = elf_ndxscn (member->data.main.scn);
 362                 }
 363               while ((member = member->data.main.next_in_group)
 364                      != runp->members->data.main.next_in_group);
 365             }
 366
 367           /* Construct the section header.  */
 368           shdr->sh_name = dwelf_strent_off (runp->strent);
 369           shdr->sh_type = SHT_GROUP;
 370           shdr->sh_flags = 0;
 371           shdr->sh_link = symscnndx;
 372           /* If the user did not specify a signature we use the initial
 373              empty symbol in the symbol table as the signature.  */
 374           shdr->sh_info = (runp->signature != NULL
 375                            ? runp->signature->symidx : 0);
 376
 377           (void) gelf_update_shdr (scn, shdr);
 378         }
 379       while ((runp = runp->next) != ctx->groups->next);
 380     }
 381
 382
 383   /* Add the name to the symbol section.  */
 384   if (likely (symscnndx != 0))
 385     {
 386       Elf_Scn *scn = elf_getscn (ctx->out.elf, symscnndx);
 387
 388       shdr = gelf_getshdr (scn, &shdr_mem);
 389
 390       shdr->sh_name = dwelf_strent_off (symscn_strent);
 391
 392       (void) gelf_update_shdr (scn, shdr);
 393
 394
 395       /* Add the name to the string section.  */
 396       assert (strscnndx != 0);
 397       scn = elf_getscn (ctx->out.elf, strscnndx);
 398
 399       shdr = gelf_getshdr (scn, &shdr_mem);
 400
 401       shdr->sh_name = dwelf_strent_off (strscn_strent);
 402
 403       (void) gelf_update_shdr (scn, shdr);
 404
 405
 406       /* Add the name to the extended symbol index section.  */
 407       if (xndxscnndx != 0)
 408         {
 409           scn = elf_getscn (ctx->out.elf, xndxscnndx);
 410
 411           shdr = gelf_getshdr (scn, &shdr_mem);
 412
 413           shdr->sh_name = dwelf_strent_off (xndxscn_strent);
 414
 415           (void) gelf_update_shdr (scn, shdr);
 416         }
 417     }
 418
 419
 420   /* Iterate over the created sections and fill in the names.  */
 421   for (asmscn = ctx->section_list; asmscn != NULL; asmscn = asmscn->allnext)
 422     {
 423       shdr = gelf_getshdr (asmscn->data.main.scn, &shdr_mem);
 424       /* This better should not fail.  */
 425       assert (shdr != NULL);
 426
 427       shdr->sh_name = dwelf_strent_off (asmscn->data.main.strent);
 428
 429       /* We now know the maximum alignment.  */
 430       shdr->sh_addralign = asmscn->max_align;
 431
 432       (void) gelf_update_shdr (asmscn->data.main.scn, shdr);
 433     }
 434
 435   /* Put the reference to the section header string table in the ELF
 436      header.  */
 437   ehdr = gelf_getehdr (ctx->out.elf, &ehdr_mem);
 438   assert (ehdr != NULL);
 439
 440   shstrscnndx = elf_ndxscn (shstrscn);
 441   if (unlikely (shstrscnndx > SHN_HIRESERVE)
 442       || unlikely (shstrscnndx == SHN_XINDEX))
 443     {
 444       /* The index of the section header string sectio is too large.  */
 445       Elf_Scn *scn = elf_getscn (ctx->out.elf, 0);
 446
 447       /* Get the header for the zeroth section.  */
 448       shdr = gelf_getshdr (scn, &shdr_mem);
 449       /* This better does not fail.  */
 450       assert (shdr != NULL);
 451
 452       /* The sh_link field of the zeroth section header contains the value.  */
 453       shdr->sh_link = shstrscnndx;
 454
 455       (void) gelf_update_shdr (scn, shdr);
 456
 457       /* This is the sign for the overflow.  */
 458       ehdr->e_shstrndx = SHN_XINDEX;
 459     }
 460   else
 461     ehdr->e_shstrndx = elf_ndxscn (shstrscn);
 462
 463   gelf_update_ehdr (ctx->out.elf, ehdr);
 464
 465   /* Write out the ELF file.  */
 466   if (unlikely (elf_update (ctx->out.elf, ELF_C_WRITE_MMAP) < 0))
 467     {
 468       __libasm_seterrno (ASM_E_LIBELF);
 469       result = -1;
 470     }
 471
 472   /* We do not need the section header and symbol string tables anymore.  */
 473   free (shstrtabdata->d_buf);
 474   if (strtabdata != NULL)
 475     free (strtabdata->d_buf);
 476   /* We might have allocated the extended symbol table index.  */
 477   if (xndxdata != NULL)
 478     free (xndxdata->d_buf);
 479
 480   /* Free section groups memory.  */
 481   AsmScnGrp_t *scngrp = ctx->groups;
 482   if (scngrp != NULL)
 483     do
 484       free (elf_getdata (scngrp->scn, NULL)->d_buf);
 485     while ((scngrp = scngrp->next) != ctx->groups);
 486
 487   /* Finalize the ELF handling.  */
 488   if (unlikely (elf_end (ctx->out.elf)) != 0)
 489     {
 490       __libasm_seterrno (ASM_E_LIBELF);
 491       result = -1;
 492     }
 493
 494   /* Free the temporary resources.  */
 495   free (symtab);
 496
 497   return result;
 498 }
 499
 500
 501 int
 502 asm_end (AsmCtx_t *ctx)
 503 {
 504   int result;
 505
 506   if (ctx == NULL)
 507     /* Something went wrong earlier.  */
 508     return -1;
 509
 510   result = unlikely (ctx->textp) ? text_end (ctx) : binary_end (ctx);
 511   if (result != 0)
 512     return result;
 513
 514   /* Make the new file globally readable and user/group-writable.  */
 515   if (fchmod (ctx->fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH) != 0)
 516     {
 517       __libasm_seterrno (ASM_E_CANNOT_CHMOD);
 518       return -1;
 519     }
 520
 521   /* Rename output file.  */
 522   if (rename (ctx->tmp_fname, ctx->fname) != 0)
 523     {
 524       __libasm_seterrno (ASM_E_CANNOT_RENAME);
 525       return -1;
 526     }
 527
 528   /* Free the resources.  */
 529   __libasm_finictx (ctx);
 530
 531   return 0;
 532 }
 533
 534
 535 static void
 536 free_section (AsmScn_t *scnp)
 537 {
 538   void *oldp;
 539
 540   if (scnp->subnext != NULL)
 541     free_section (scnp->subnext);
 542
 543   struct AsmData *data = scnp->content;
 544   if (data != NULL)
 545     do
 546       {
 547         oldp = data;
 548         data = data->next;
 549         free (oldp);
 550       }
 551     while (oldp != scnp->content);
 552
 553   free (scnp);
 554 }
 555
 556
 557 void
 558 internal_function
 559 __libasm_finictx (AsmCtx_t *ctx)
 560 {
 561   /* Iterate through section table and free individual entries.  */
 562   AsmScn_t *scn = ctx->section_list;
 563   while (scn != NULL)
 564     {
 565       AsmScn_t *oldp = scn;
 566       scn = scn->allnext;
 567       free_section (oldp);
 568     }
 569
 570   /* Free the resources of the symbol table.  */
 571   void *runp = NULL;
 572   AsmSym_t *sym;
 573   while ((sym = asm_symbol_tab_iterate (&ctx->symbol_tab, &runp)) != NULL)
 574     free (sym);
 575   asm_symbol_tab_free (&ctx->symbol_tab);
 576
 577
 578   /* Free section groups.  */
 579   AsmScnGrp_t *scngrp = ctx->groups;
 580   if (scngrp != NULL)
 581     do
 582       {
 583         AsmScnGrp_t *oldp = scngrp;
 584
 585         scngrp = scngrp->next;
 586         free (oldp);
 587       }
 588     while (scngrp != ctx->groups);
 589
 590
 591   if (unlikely (ctx->textp))
 592     {
 593       /* Close the stream.  */
 594       fclose (ctx->out.file);
 595     }
 596   else
 597     {
 598       /* Close the output file.  */
 599       /* XXX We should test for errors here but what would we do if we'd
 600          find any.  */
 601       (void) close (ctx->fd);
 602
 603       /* And the string tables.  */
 604       dwelf_strtab_free (ctx->section_strtab);
 605       dwelf_strtab_free (ctx->symbol_strtab);
 606     }
 607
 608   /* Initialize the lock.  */
 609   rwlock_fini (ctx->lock);
 610
 611   /* Finally free the data structure.   */
 612   free (ctx);
 613 }