libasm/asm_end.c

   1 /* Finalize operations on the assembler context, free all resources.
   2    Copyright (C) 2002, 2003, 2005 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 <error.h>
  36 #include <libintl.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include <sys/stat.h>
  42
  43 #include <libasmP.h>
  44 #include <libelf.h>
  45 #include <system.h>
  46
  47
  48 static int
  49 text_end (AsmCtx_t *ctx __attribute__ ((unused)))
  50 {
  51   if (fclose (ctx->out.file) != 0)
  52     {
  53       __libasm_seterrno (ASM_E_IOERROR);
  54       return -1;
  55     }
  56
  57   return 0;
  58 }
  59
  60
  61 static int
  62 binary_end (AsmCtx_t *ctx)
  63 {
  64   void *symtab = NULL;
  65   struct Ebl_Strent *symscn_strent = NULL;
  66   struct Ebl_Strent *strscn_strent = NULL;
  67   struct Ebl_Strent *xndxscn_strent = NULL;
  68   Elf_Scn *shstrscn;
  69   struct Ebl_Strent *shstrscn_strent;
  70   size_t shstrscnndx;
  71   size_t symscnndx = 0;
  72   size_t strscnndx = 0;
  73   size_t xndxscnndx = 0;
  74   Elf_Data *data;
  75   Elf_Data *shstrtabdata;
  76   Elf_Data *strtabdata = NULL;
  77   Elf_Data *xndxdata = NULL;
  78   GElf_Shdr shdr_mem;
  79   GElf_Shdr *shdr;
  80   GElf_Ehdr ehdr_mem;
  81   GElf_Ehdr *ehdr;
  82   AsmScn_t *asmscn;
  83   int result = 0;
  84
  85   /* Iterate over the created sections and compute the offsets of the
  86      various subsections and fill in the content.  */
  87   for (asmscn = ctx->section_list; asmscn != NULL; asmscn = asmscn->allnext)
  88     {
  89 #if 0
  90       Elf_Scn *scn = elf_getscn (ctx->out.elf, asmscn->data.main.scnndx);
  91 #else
  92       Elf_Scn *scn = asmscn->data.main.scn;
  93 #endif
  94       off_t offset = 0;
  95       AsmScn_t *asmsubscn = asmscn;
  96
  97       do
  98         {
  99           struct AsmData *content = asmsubscn->content;
 100           bool first = true;
 101
 102           offset = ((offset + asmsubscn->max_align - 1)
 103                     & ~(asmsubscn->max_align - 1));
 104
 105           /* Update the offset for this subsection.  This field now
 106              stores the offset of the first by in this subsection.  */
 107           asmsubscn->offset = offset;
 108
 109           /* Note that the content list is circular.  */
 110           if (content != NULL)
 111             do
 112               {
 113                 Elf_Data *newdata = elf_newdata (scn);
 114
 115                 if (newdata == NULL)
 116                   {
 117                     __libasm_seterrno (ASM_E_LIBELF);
 118                     return -1;
 119                   }
 120
 121                 newdata->d_buf = content->data;
 122                 newdata->d_type = ELF_T_BYTE;
 123                 newdata->d_size = content->len;
 124                 newdata->d_off = offset;
 125                 newdata->d_align = first ? asmsubscn->max_align : 1;
 126
 127                 offset += content->len;
 128               }
 129             while ((content = content->next) != asmsubscn->content);
 130         }
 131       while ((asmsubscn = asmsubscn->subnext) != NULL);
 132     }
 133
 134
 135   /* Create the symbol table if necessary.  */
 136   if (ctx->nsymbol_tab > 0)
 137     {
 138       /* Create the symbol table and string table section names.  */
 139       symscn_strent = ebl_strtabadd (ctx->section_strtab, ".symtab", 8);
 140       strscn_strent = ebl_strtabadd (ctx->section_strtab, ".strtab", 8);
 141
 142       /* Create the symbol string table section.  */
 143       Elf_Scn *strscn = elf_newscn (ctx->out.elf);
 144       strtabdata = elf_newdata (strscn);
 145       shdr = gelf_getshdr (strscn, &shdr_mem);
 146       if (strtabdata == NULL || shdr == NULL)
 147         {
 148           __libasm_seterrno (ASM_E_LIBELF);
 149           return -1;
 150         }
 151       strscnndx = elf_ndxscn (strscn);
 152
 153       ebl_strtabfinalize (ctx->symbol_strtab, strtabdata);
 154
 155       shdr->sh_type = SHT_STRTAB;
 156       assert (shdr->sh_entsize == 0);
 157
 158       (void) gelf_update_shdr (strscn, shdr);
 159
 160       /* Create the symbol table section.  */
 161       Elf_Scn *symscn = elf_newscn (ctx->out.elf);
 162       data = elf_newdata (symscn);
 163       shdr = gelf_getshdr (symscn, &shdr_mem);
 164       if (data == NULL || shdr == NULL)
 165         {
 166           __libasm_seterrno (ASM_E_LIBELF);
 167           return -1;
 168         }
 169       symscnndx = elf_ndxscn (symscn);
 170
 171       /* We know how many symbols there will be in the symbol table.  */
 172       data->d_size = gelf_fsize (ctx->out.elf, ELF_T_SYM,
 173                                  ctx->nsymbol_tab + 1, EV_CURRENT);
 174       symtab = malloc (data->d_size);
 175       if (symtab == NULL)
 176         return -1;
 177       data->d_buf = symtab;
 178       data->d_type = ELF_T_SYM;
 179       data->d_off = 0;
 180
 181       /* Clear the first entry.  */
 182       GElf_Sym syment;
 183       memset (&syment, '\0', sizeof (syment));
 184       (void) gelf_update_sym (data, 0, &syment);
 185
 186       /* Iterate over the symbol table.  */
 187       void *runp = NULL;
 188       int ptr_local = 1;        /* Start with index 1; zero remains unused.  */
 189       int ptr_nonlocal = ctx->nsymbol_tab;
 190       uint32_t *xshndx = NULL;
 191       AsmSym_t *sym;
 192       while ((sym = asm_symbol_tab_iterate (&ctx->symbol_tab, &runp)) != NULL)
 193         if (asm_emit_symbol_p (ebl_string (sym->strent)))
 194           {
 195             assert (ptr_local <= ptr_nonlocal);
 196
 197             syment.st_name = ebl_strtaboffset (sym->strent);
 198             syment.st_info = GELF_ST_INFO (sym->binding, sym->type);
 199             syment.st_other = 0;
 200             syment.st_value = sym->scn->offset + sym->offset;
 201             syment.st_size = sym->size;
 202
 203             /* Add local symbols at the beginning, the other from
 204                the end.  */
 205             int ptr = sym->binding == STB_LOCAL ? ptr_local++ : ptr_nonlocal--;
 206
 207             /* Determine the section index.  We have to handle the
 208                overflow correctly.  */
 209             Elf_Scn *scn = (sym->scn->subsection_id == 0
 210                             ? sym->scn->data.main.scn
 211                             : sym->scn->data.up->data.main.scn);
 212
 213             Elf32_Word ndx;
 214             if (unlikely (scn == ASM_ABS_SCN))
 215               ndx = SHN_ABS;
 216             else if (unlikely (scn == ASM_COM_SCN))
 217               ndx = SHN_COMMON;
 218             else if (unlikely ((ndx = elf_ndxscn (scn)) >= SHN_LORESERVE))
 219               {
 220                 if (unlikely (xshndx == NULL))
 221                   {
 222                     /* The extended section index section does not yet
 223                        exist.  */
 224                     Elf_Scn *xndxscn;
 225
 226                     xndxscn = elf_newscn (ctx->out.elf);
 227                     xndxdata = elf_newdata (xndxscn);
 228                     shdr = gelf_getshdr (xndxscn, &shdr_mem);
 229                     if (xndxdata == NULL || shdr == NULL)
 230                       {
 231                         __libasm_seterrno (ASM_E_LIBELF);
 232                         return -1;
 233                       }
 234                     xndxscnndx = elf_ndxscn (xndxscn);
 235
 236                     shdr->sh_type = SHT_SYMTAB_SHNDX;
 237                     shdr->sh_entsize = sizeof (Elf32_Word);
 238                     shdr->sh_addralign = sizeof (Elf32_Word);
 239                     shdr->sh_link = symscnndx;
 240
 241                     (void) gelf_update_shdr (xndxscn, shdr);
 242
 243                     xndxscn_strent = ebl_strtabadd (ctx->section_strtab,
 244                                                     ".symtab_shndx", 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 = ebl_strtabadd (ctx->section_strtab, ".shstrtab", 10);
 303
 304   ebl_strtabfinalize (ctx->section_strtab, shstrtabdata);
 305
 306   shdr->sh_type = SHT_STRTAB;
 307   assert (shdr->sh_entsize == 0);
 308   shdr->sh_name = ebl_strtaboffset (shstrscn_strent);
 309
 310   (void) gelf_update_shdr (shstrscn, shdr);
 311
 312
 313   /* Create the section groups.  */
 314   if (ctx->groups != NULL)
 315     {
 316       AsmScnGrp_t *runp = ctx->groups->next;
 317
 318       do
 319         {
 320           Elf_Scn *scn;
 321           Elf32_Word *grpdata;
 322
 323           scn = runp->scn;
 324           assert (scn != NULL);
 325           shdr = gelf_getshdr (scn, &shdr_mem);
 326           assert (shdr != NULL);
 327
 328           data = elf_newdata (scn);
 329           if (data == NULL)
 330             {
 331               __libasm_seterrno (ASM_E_LIBELF);
 332               return -1;
 333             }
 334
 335           /* It is correct to use 'elf32_fsize' instead of 'gelf_fsize'
 336              here.  */
 337           data->d_size = elf32_fsize (ELF_T_WORD, runp->nmembers + 1,
 338                                       EV_CURRENT);
 339           grpdata = data->d_buf = malloc (data->d_size);
 340           if (grpdata == NULL)
 341             return -1;
 342           data->d_type = ELF_T_WORD;
 343           data->d_off = 0;
 344           data->d_align = elf32_fsize (ELF_T_WORD, 1, EV_CURRENT);
 345
 346           /* The first word of the section is filled with the flag word.  */
 347           *grpdata++ = runp->flags;
 348
 349           if (runp->members != NULL)
 350             {
 351               AsmScn_t *member = runp->members->data.main.next_in_group;
 352
 353               do
 354                 {
 355                   /* Only sections, not subsections, can be registered
 356                      as member of a group.  The subsections get
 357                      automatically included.  */
 358                   assert (member->subsection_id == 0);
 359
 360                   *grpdata++ = elf_ndxscn (member->data.main.scn);
 361                 }
 362               while ((member = member->data.main.next_in_group)
 363                      != runp->members->data.main.next_in_group);
 364             }
 365
 366           /* Construct the section header.  */
 367           shdr->sh_name = ebl_strtaboffset (runp->strent);
 368           shdr->sh_type = SHT_GROUP;
 369           shdr->sh_flags = 0;
 370           shdr->sh_link = symscnndx;
 371           /* If the user did not specify a signature we use the initial
 372              empty symbol in the symbol table as the signature.  */
 373           shdr->sh_info = (runp->signature != NULL
 374                            ? runp->signature->symidx : 0);
 375
 376           (void) gelf_update_shdr (scn, shdr);
 377         }
 378       while ((runp = runp->next) != ctx->groups->next);
 379     }
 380
 381
 382   /* Add the name to the symbol section.  */
 383   if (likely (symscnndx != 0))
 384     {
 385       Elf_Scn *scn = elf_getscn (ctx->out.elf, symscnndx);
 386
 387       shdr = gelf_getshdr (scn, &shdr_mem);
 388
 389       shdr->sh_name = ebl_strtaboffset (symscn_strent);
 390
 391       (void) gelf_update_shdr (scn, shdr);
 392
 393
 394       /* Add the name to the string section.  */
 395       assert (strscnndx != 0);
 396       scn = elf_getscn (ctx->out.elf, strscnndx);
 397
 398       shdr = gelf_getshdr (scn, &shdr_mem);
 399
 400       shdr->sh_name = ebl_strtaboffset (strscn_strent);
 401
 402       (void) gelf_update_shdr (scn, shdr);
 403
 404
 405       /* Add the name to the extended symbol index section.  */
 406       if (xndxscnndx != 0)
 407         {
 408           scn = elf_getscn (ctx->out.elf, xndxscnndx);
 409
 410           shdr = gelf_getshdr (scn, &shdr_mem);
 411
 412           shdr->sh_name = ebl_strtaboffset (xndxscn_strent);
 413
 414           (void) gelf_update_shdr (scn, shdr);
 415         }
 416     }
 417
 418
 419   /* Iterate over the created sections and fill in the names.  */
 420   for (asmscn = ctx->section_list; asmscn != NULL; asmscn = asmscn->allnext)
 421     {
 422       shdr = gelf_getshdr (asmscn->data.main.scn, &shdr_mem);
 423       /* This better should not fail.  */
 424       assert (shdr != NULL);
 425
 426       shdr->sh_name = ebl_strtaboffset (asmscn->data.main.strent);
 427
 428       /* We now know the maximum alignment.  */
 429       shdr->sh_addralign = asmscn->max_align;
 430
 431       (void) gelf_update_shdr (asmscn->data.main.scn, shdr);
 432     }
 433
 434   /* Put the reference to the section header string table in the ELF
 435      header.  */
 436   ehdr = gelf_getehdr (ctx->out.elf, &ehdr_mem);
 437   assert (ehdr != NULL);
 438
 439   shstrscnndx = elf_ndxscn (shstrscn);
 440   if (unlikely (shstrscnndx > SHN_HIRESERVE)
 441       || unlikely (shstrscnndx == SHN_XINDEX))
 442     {
 443       /* The index of the section header string sectio is too large.  */
 444       Elf_Scn *scn = elf_getscn (ctx->out.elf, 0);
 445
 446       /* Get the header for the zeroth section.  */
 447       shdr = gelf_getshdr (scn, &shdr_mem);
 448       /* This better does not fail.  */
 449       assert (shdr != NULL);
 450
 451       /* The sh_link field of the zeroth section header contains the value.  */
 452       shdr->sh_link = shstrscnndx;
 453
 454       (void) gelf_update_shdr (scn, shdr);
 455
 456       /* This is the sign for the overflow.  */
 457       ehdr->e_shstrndx = SHN_XINDEX;
 458     }
 459   else
 460     ehdr->e_shstrndx = elf_ndxscn (shstrscn);
 461
 462   gelf_update_ehdr (ctx->out.elf, ehdr);
 463
 464   /* Write out the ELF file.  */
 465   if (unlikely (elf_update (ctx->out.elf, ELF_C_WRITE_MMAP)) < 0)
 466     {
 467       __libasm_seterrno (ASM_E_LIBELF);
 468       result = -1;
 469     }
 470
 471   /* We do not need the section header and symbol string tables anymore.  */
 472   free (shstrtabdata->d_buf);
 473   if (strtabdata != NULL)
 474     free (strtabdata->d_buf);
 475   /* We might have allocated the extended symbol table index.  */
 476   if (xndxdata != NULL)
 477     free (xndxdata->d_buf);
 478
 479   /* Free section groups memory.  */
 480   AsmScnGrp_t *scngrp = ctx->groups;
 481   if (scngrp != NULL)
 482     do
 483       free (elf_getdata (scngrp->scn, NULL)->d_buf);
 484     while ((scngrp = scngrp->next) != ctx->groups);
 485
 486   /* Finalize the ELF handling.  */
 487   if (unlikely (elf_end (ctx->out.elf)) != 0)
 488     {
 489       __libasm_seterrno (ASM_E_LIBELF);
 490       result = -1;
 491     }
 492
 493   /* Free the temporary resources.  */
 494   free (symtab);
 495
 496   return result;
 497 }
 498
 499
 500 int
 501 asm_end (ctx)
 502      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 __libasm_finictx (ctx)
 559      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       ebl_strtabfree (ctx->section_strtab);
 605       ebl_strtabfree (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 }