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