src/util/elf2efi.c

   1 /*
   2  * Copyright (C) 2009 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <stdint.h>
  21 #include <stddef.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <assert.h>
  28 #include <getopt.h>
  29 #include <bfd.h>
  30 #include <gpxe/efi/efi.h>
  31 #include <gpxe/efi/IndustryStandard/PeImage.h>
  32 #include <libgen.h>
  33
  34 #define eprintf(...) fprintf ( stderr, __VA_ARGS__ )
  35
  36 #define EFI_FILE_ALIGN 0x20
  37
  38 struct pe_section {
  39         struct pe_section *next;
  40         EFI_IMAGE_SECTION_HEADER hdr;
  41         uint8_t contents[0];
  42 };
  43
  44 struct pe_relocs {
  45         struct pe_relocs *next;
  46         unsigned long start_rva;
  47         unsigned int used_relocs;
  48         unsigned int total_relocs;
  49         uint16_t *relocs;
  50 };
  51
  52 struct pe_header {
  53         EFI_IMAGE_DOS_HEADER dos;
  54         uint8_t padding[128];
  55 #if defined(EFI_TARGET_IA32)
  56         EFI_IMAGE_NT_HEADERS32 nt;
  57 #elif defined(EFI_TARGET_X64)
  58         EFI_IMAGE_NT_HEADERS64 nt;
  59 #endif
  60 };
  61
  62 static struct pe_header efi_pe_header = {
  63         .dos = {
  64                 .e_magic = EFI_IMAGE_DOS_SIGNATURE,
  65                 .e_lfanew = offsetof ( typeof ( efi_pe_header ), nt ),
  66         },
  67         .nt = {
  68                 .Signature = EFI_IMAGE_NT_SIGNATURE,
  69                 .FileHeader = {
  70 #if defined(EFI_TARGET_IA32)
  71                         .Machine = EFI_IMAGE_MACHINE_IA32,
  72 #elif defined(EFI_TARGET_X64)
  73                         .Machine = EFI_IMAGE_MACHINE_X64,
  74 #endif
  75                         .TimeDateStamp = 0x10d1a884,
  76                         .SizeOfOptionalHeader =
  77                                 sizeof ( efi_pe_header.nt.OptionalHeader ),
  78                         .Characteristics = ( EFI_IMAGE_FILE_DLL |
  79 #if defined(EFI_TARGET_IA32)
  80                                              EFI_IMAGE_FILE_32BIT_MACHINE |
  81 #endif
  82                                              EFI_IMAGE_FILE_EXECUTABLE_IMAGE ),
  83                 },
  84                 .OptionalHeader = {
  85 #if defined(EFI_TARGET_IA32)
  86                         .Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC,
  87 #elif defined(EFI_TARGET_X64)
  88                         .Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC,
  89 #endif
  90                         .SectionAlignment = EFI_FILE_ALIGN,
  91                         .FileAlignment = EFI_FILE_ALIGN,
  92                         .SizeOfImage = sizeof ( efi_pe_header ),
  93                         .SizeOfHeaders = sizeof ( efi_pe_header ),
  94                         .NumberOfRvaAndSizes =
  95                                 EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES,
  96                 },
  97         },
  98 };
  99
 100 /** Command-line options */
 101 struct options {
 102         unsigned int subsystem;
 103 };
 104
 105 /**
 106  * Allocate memory
 107  *
 108  * @v len               Length of memory to allocate
 109  * @ret ptr             Pointer to allocated memory
 110  */
 111 static void * xmalloc ( size_t len ) {
 112         void *ptr;
 113
 114         ptr = malloc ( len );
 115         if ( ! ptr ) {
 116                 eprintf ( "Could not allocate %zd bytes\n", len );
 117                 exit ( 1 );
 118         }
 119
 120         return ptr;
 121 }
 122
 123 /**
 124  * Align section within PE file
 125  *
 126  * @v offset            Unaligned offset
 127  * @ret aligned_offset  Aligned offset
 128  */
 129 static unsigned long efi_file_align ( unsigned long offset ) {
 130         return ( ( offset + EFI_FILE_ALIGN - 1 ) & ~( EFI_FILE_ALIGN - 1 ) );
 131 }
 132
 133 /**
 134  * Generate entry in PE relocation table
 135  *
 136  * @v pe_reltab         PE relocation table
 137  * @v rva               RVA
 138  * @v size              Size of relocation entry
 139  */
 140 static void generate_pe_reloc ( struct pe_relocs **pe_reltab,
 141                                 unsigned long rva, size_t size ) {
 142         unsigned long start_rva;
 143         uint16_t reloc;
 144         struct pe_relocs *pe_rel;
 145         uint16_t *relocs;
 146
 147         /* Construct */
 148         start_rva = ( rva & ~0xfff );
 149         reloc = ( rva & 0xfff );
 150         switch ( size ) {
 151         case 8:
 152                 reloc |= 0xa000;
 153                 break;
 154         case 4:
 155                 reloc |= 0x3000;
 156                 break;
 157         case 2:
 158                 reloc |= 0x2000;
 159                 break;
 160         default:
 161                 eprintf ( "Unsupported relocation size %zd\n", size );
 162                 exit ( 1 );
 163         }
 164
 165         /* Locate or create PE relocation table */
 166         for ( pe_rel = *pe_reltab ; pe_rel ; pe_rel = pe_rel->next ) {
 167                 if ( pe_rel->start_rva == start_rva )
 168                         break;
 169         }
 170         if ( ! pe_rel ) {
 171                 pe_rel = xmalloc ( sizeof ( *pe_rel ) );
 172                 memset ( pe_rel, 0, sizeof ( *pe_rel ) );
 173                 pe_rel->next = *pe_reltab;
 174                 *pe_reltab = pe_rel;
 175                 pe_rel->start_rva = start_rva;
 176         }
 177
 178         /* Expand relocation list if necessary */
 179         if ( pe_rel->used_relocs < pe_rel->total_relocs ) {
 180                 relocs = pe_rel->relocs;
 181         } else {
 182                 pe_rel->total_relocs = ( pe_rel->total_relocs ?
 183                                          ( pe_rel->total_relocs * 2 ) : 256 );
 184                 relocs = xmalloc ( pe_rel->total_relocs *
 185                                    sizeof ( pe_rel->relocs[0] ) );
 186                 memset ( relocs, 0,
 187                          pe_rel->total_relocs * sizeof ( pe_rel->relocs[0] ) );
 188                 memcpy ( relocs, pe_rel->relocs,
 189                          pe_rel->used_relocs * sizeof ( pe_rel->relocs[0] ) );
 190                 free ( pe_rel->relocs );
 191                 pe_rel->relocs = relocs;
 192         }
 193
 194         /* Store relocation */
 195         pe_rel->relocs[ pe_rel->used_relocs++ ] = reloc;
 196 }
 197
 198 /**
 199  * Calculate size of binary PE relocation table
 200  *
 201  * @v pe_reltab         PE relocation table
 202  * @v buffer            Buffer to contain binary table, or NULL
 203  * @ret size            Size of binary table
 204  */
 205 static size_t output_pe_reltab ( struct pe_relocs *pe_reltab,
 206                                  void *buffer ) {
 207         struct pe_relocs *pe_rel;
 208         unsigned int num_relocs;
 209         size_t size;
 210         size_t total_size = 0;
 211
 212         for ( pe_rel = pe_reltab ; pe_rel ; pe_rel = pe_rel->next ) {
 213                 num_relocs = ( ( pe_rel->used_relocs + 1 ) & ~1 );
 214                 size = ( sizeof ( uint32_t ) /* VirtualAddress */ +
 215                          sizeof ( uint32_t ) /* SizeOfBlock */ +
 216                          ( num_relocs * sizeof ( uint16_t ) ) );
 217                 if ( buffer ) {
 218                         *( (uint32_t *) ( buffer + total_size + 0 ) )
 219                                 = pe_rel->start_rva;
 220                         *( (uint32_t *) ( buffer + total_size + 4 ) ) = size;
 221                         memcpy ( ( buffer + total_size + 8 ), pe_rel->relocs,
 222                                  ( num_relocs * sizeof ( uint16_t ) ) );
 223                 }
 224                 total_size += size;
 225         }
 226
 227         return total_size;
 228 }
 229
 230 /**
 231  * Open input BFD file
 232  *
 233  * @v filename          File name
 234  * @ret ibfd            BFD file
 235  */
 236 static bfd * open_input_bfd ( const char *filename ) {
 237         bfd *bfd;
 238
 239         /* Open the file */
 240         bfd = bfd_openr ( filename, NULL );
 241         if ( ! bfd ) {
 242                 eprintf ( "Cannot open %s: ", filename );
 243                 bfd_perror ( NULL );
 244                 exit ( 1 );
 245         }
 246
 247         /* The call to bfd_check_format() must be present, otherwise
 248          * we get a segfault from later BFD calls.
 249          */
 250         if ( ! bfd_check_format ( bfd, bfd_object ) ) {
 251                 eprintf ( "%s is not an object file: ", filename );
 252                 bfd_perror ( NULL );
 253                 exit ( 1 );
 254         }
 255
 256         return bfd;
 257 }
 258
 259 /**
 260  * Read symbol table
 261  *
 262  * @v bfd               BFD file
 263  */
 264 static asymbol ** read_symtab ( bfd *bfd ) {
 265         long symtab_size;
 266         asymbol **symtab;
 267         long symcount;
 268
 269         /* Get symbol table size */
 270         symtab_size = bfd_get_symtab_upper_bound ( bfd );
 271         if ( symtab_size < 0 ) {
 272                 bfd_perror ( "Could not get symbol table upper bound" );
 273                 exit ( 1 );
 274         }
 275
 276         /* Allocate and read symbol table */
 277         symtab = xmalloc ( symtab_size );
 278         symcount = bfd_canonicalize_symtab ( bfd, symtab );
 279         if ( symcount < 0 ) {
 280                 bfd_perror ( "Cannot read symbol table" );
 281                 exit ( 1 );
 282         }
 283
 284         return symtab;
 285 }
 286
 287 /**
 288  * Read relocation table
 289  *
 290  * @v bfd               BFD file
 291  * @v symtab            Symbol table
 292  * @v section           Section
 293  * @v symtab            Symbol table
 294  * @ret reltab          Relocation table
 295  */
 296 static arelent ** read_reltab ( bfd *bfd, asymbol **symtab,
 297                                 asection *section ) {
 298         long reltab_size;
 299         arelent **reltab;
 300         long numrels;
 301
 302         /* Get relocation table size */
 303         reltab_size = bfd_get_reloc_upper_bound ( bfd, section );
 304         if ( reltab_size < 0 ) {
 305                 bfd_perror ( "Could not get relocation table upper bound" );
 306                 exit ( 1 );
 307         }
 308
 309         /* Allocate and read relocation table */
 310         reltab = xmalloc ( reltab_size );
 311         numrels = bfd_canonicalize_reloc ( bfd, section, reltab, symtab );
 312         if ( numrels < 0 ) {
 313                 bfd_perror ( "Cannot read relocation table" );
 314                 exit ( 1 );
 315         }
 316
 317         return reltab;
 318 }
 319
 320 /**
 321  * Process section
 322  *
 323  * @v bfd               BFD file
 324  * @v pe_header         PE file header
 325  * @v section           Section
 326  * @ret new             New PE section
 327  */
 328 static struct pe_section * process_section ( bfd *bfd,
 329                                              struct pe_header *pe_header,
 330                                              asection *section ) {
 331         struct pe_section *new;
 332         size_t section_memsz;
 333         size_t section_filesz;
 334         unsigned long flags = bfd_get_section_flags ( bfd, section );
 335         unsigned long code_start;
 336         unsigned long code_end;
 337         unsigned long data_start;
 338         unsigned long data_mid;
 339         unsigned long data_end;
 340         unsigned long start;
 341         unsigned long end;
 342         unsigned long *applicable_start;
 343         unsigned long *applicable_end;
 344
 345         /* Extract current RVA limits from file header */
 346         code_start = pe_header->nt.OptionalHeader.BaseOfCode;
 347         code_end = ( code_start + pe_header->nt.OptionalHeader.SizeOfCode );
 348 #if defined(EFI_TARGET_IA32)
 349         data_start = pe_header->nt.OptionalHeader.BaseOfData;
 350 #elif defined(EFI_TARGET_X64)
 351         data_start = code_end;
 352 #endif
 353         data_mid = ( data_start +
 354                      pe_header->nt.OptionalHeader.SizeOfInitializedData );
 355         data_end = ( data_mid +
 356                      pe_header->nt.OptionalHeader.SizeOfUninitializedData );
 357
 358         /* Allocate PE section */
 359         section_memsz = bfd_section_size ( bfd, section );
 360         section_filesz = ( ( flags & SEC_LOAD ) ?
 361                            efi_file_align ( section_memsz ) : 0 );
 362         new = xmalloc ( sizeof ( *new ) + section_filesz );
 363         memset ( new, 0, sizeof ( *new ) + section_filesz );
 364
 365         /* Fill in section header details */
 366         strncpy ( ( char * ) new->hdr.Name, section->name,
 367                   sizeof ( new->hdr.Name ) );
 368         new->hdr.Misc.VirtualSize = section_memsz;
 369         new->hdr.VirtualAddress = bfd_get_section_vma ( bfd, section );
 370         new->hdr.SizeOfRawData = section_filesz;
 371
 372         /* Fill in section characteristics and update RVA limits */
 373         if ( flags & SEC_CODE ) {
 374                 /* .text-type section */
 375                 new->hdr.Characteristics =
 376                         ( EFI_IMAGE_SCN_CNT_CODE |
 377                           EFI_IMAGE_SCN_MEM_NOT_PAGED |
 378                           EFI_IMAGE_SCN_MEM_EXECUTE |
 379                           EFI_IMAGE_SCN_MEM_READ );
 380                 applicable_start = &code_start;
 381                 applicable_end = &code_end;
 382         } else if ( flags & SEC_DATA ) {
 383                 /* .data-type section */
 384                 new->hdr.Characteristics =
 385                         ( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA |
 386                           EFI_IMAGE_SCN_MEM_NOT_PAGED |
 387                           EFI_IMAGE_SCN_MEM_READ |
 388                           EFI_IMAGE_SCN_MEM_WRITE );
 389                 applicable_start = &data_start;
 390                 applicable_end = &data_mid;
 391         } else if ( flags & SEC_READONLY ) {
 392                 /* .rodata-type section */
 393                 new->hdr.Characteristics =
 394                         ( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA |
 395                           EFI_IMAGE_SCN_MEM_NOT_PAGED |
 396                           EFI_IMAGE_SCN_MEM_READ );
 397                 applicable_start = &data_start;
 398                 applicable_end = &data_mid;
 399         } else if ( ! ( flags & SEC_LOAD ) ) {
 400                 /* .bss-type section */
 401                 new->hdr.Characteristics =
 402                         ( EFI_IMAGE_SCN_CNT_UNINITIALIZED_DATA |
 403                           EFI_IMAGE_SCN_MEM_NOT_PAGED |
 404                           EFI_IMAGE_SCN_MEM_READ |
 405                           EFI_IMAGE_SCN_MEM_WRITE );
 406                 applicable_start = &data_mid;
 407                 applicable_end = &data_end;
 408         }
 409
 410         /* Copy in section contents */
 411         if ( flags & SEC_LOAD ) {
 412                 if ( ! bfd_get_section_contents ( bfd, section, new->contents,
 413                                                   0, section_memsz ) ) {
 414                         eprintf ( "Cannot read section %s: ", section->name );
 415                         bfd_perror ( NULL );
 416                         exit ( 1 );
 417                 }
 418         }
 419
 420         /* Update RVA limits */
 421         start = new->hdr.VirtualAddress;
 422         end = ( start + new->hdr.Misc.VirtualSize );
 423         if ( ( ! *applicable_start ) || ( *applicable_start >= start ) )
 424                 *applicable_start = start;
 425         if ( *applicable_end < end )
 426                 *applicable_end = end;
 427         if ( data_start < code_end )
 428                 data_start = code_end;
 429         if ( data_mid < data_start )
 430                 data_mid = data_start;
 431         if ( data_end < data_mid )
 432                 data_end = data_mid;
 433
 434         /* Write RVA limits back to file header */
 435         pe_header->nt.OptionalHeader.BaseOfCode = code_start;
 436         pe_header->nt.OptionalHeader.SizeOfCode = ( code_end - code_start );
 437 #if defined(EFI_TARGET_IA32)
 438         pe_header->nt.OptionalHeader.BaseOfData = data_start;
 439 #endif
 440         pe_header->nt.OptionalHeader.SizeOfInitializedData =
 441                 ( data_mid - data_start );
 442         pe_header->nt.OptionalHeader.SizeOfUninitializedData =
 443                 ( data_end - data_mid );
 444
 445         /* Update remaining file header fields */
 446         pe_header->nt.FileHeader.NumberOfSections++;
 447         pe_header->nt.OptionalHeader.SizeOfHeaders += sizeof ( new->hdr );
 448         pe_header->nt.OptionalHeader.SizeOfImage =
 449                 efi_file_align ( data_end );
 450
 451         return new;
 452 }
 453
 454 /**
 455  * Process relocation record
 456  *
 457  * @v bfd               BFD file
 458  * @v section           Section
 459  * @v rel               Relocation entry
 460  * @v pe_reltab         PE relocation table to fill in
 461  */
 462 static void process_reloc ( bfd *bfd, asection *section, arelent *rel,
 463                             struct pe_relocs **pe_reltab ) {
 464         reloc_howto_type *howto = rel->howto;
 465         asymbol *sym = *(rel->sym_ptr_ptr);
 466         unsigned long offset = ( bfd_get_section_vma ( bfd, section ) +
 467                                  rel->address );
 468
 469         if ( bfd_is_abs_section ( sym->section ) ) {
 470                 /* Skip absolute symbols; the symbol value won't
 471                  * change when the object is loaded.
 472                  */
 473         } else if ( strcmp ( howto->name, "R_X86_64_64" ) == 0 ) {
 474                 /* Generate an 8-byte PE relocation */
 475                 generate_pe_reloc ( pe_reltab, offset, 8 );
 476         } else if ( ( strcmp ( howto->name, "R_386_32" ) == 0 ) ||
 477                     ( strcmp ( howto->name, "R_X86_64_32" ) == 0 ) ) {
 478                 /* Generate a 4-byte PE relocation */
 479                 generate_pe_reloc ( pe_reltab, offset, 4 );
 480         } else if ( strcmp ( howto->name, "R_386_16" ) == 0 ) {
 481                 /* Generate a 2-byte PE relocation */
 482                 generate_pe_reloc ( pe_reltab, offset, 2 );
 483         } else if ( ( strcmp ( howto->name, "R_386_PC32" ) == 0 ) ||
 484                     ( strcmp ( howto->name, "R_X86_64_PC32" ) == 0 ) ) {
 485                 /* Skip PC-relative relocations; all relative offsets
 486                  * remain unaltered when the object is loaded.
 487                  */
 488         } else {
 489                 eprintf ( "Unrecognised relocation type %s\n", howto->name );
 490                 exit ( 1 );
 491         }
 492 }
 493
 494 /**
 495  * Create relocations section
 496  *
 497  * @v pe_header         PE file header
 498  * @v pe_reltab         PE relocation table
 499  * @ret section         Relocation section
 500  */
 501 static struct pe_section *
 502 create_reloc_section ( struct pe_header *pe_header,
 503                        struct pe_relocs *pe_reltab ) {
 504         struct pe_section *reloc;
 505         size_t section_memsz;
 506         size_t section_filesz;
 507         EFI_IMAGE_DATA_DIRECTORY *relocdir;
 508
 509         /* Allocate PE section */
 510         section_memsz = output_pe_reltab ( pe_reltab, NULL );
 511         section_filesz = efi_file_align ( section_memsz );
 512         reloc = xmalloc ( sizeof ( *reloc ) + section_filesz );
 513         memset ( reloc, 0, sizeof ( *reloc ) + section_filesz );
 514
 515         /* Fill in section header details */
 516         strncpy ( ( char * ) reloc->hdr.Name, ".reloc",
 517                   sizeof ( reloc->hdr.Name ) );
 518         reloc->hdr.Misc.VirtualSize = section_memsz;
 519         reloc->hdr.VirtualAddress = pe_header->nt.OptionalHeader.SizeOfImage;
 520         reloc->hdr.SizeOfRawData = section_filesz;
 521         reloc->hdr.Characteristics = ( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA |
 522                                        EFI_IMAGE_SCN_MEM_NOT_PAGED |
 523                                        EFI_IMAGE_SCN_MEM_READ );
 524
 525         /* Copy in section contents */
 526         output_pe_reltab ( pe_reltab, reloc->contents );
 527
 528         /* Update file header details */
 529         pe_header->nt.FileHeader.NumberOfSections++;
 530         pe_header->nt.OptionalHeader.SizeOfHeaders += sizeof ( reloc->hdr );
 531         pe_header->nt.OptionalHeader.SizeOfImage += section_filesz;
 532         relocdir = &(pe_header->nt.OptionalHeader.DataDirectory
 533                      [EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]);
 534         relocdir->VirtualAddress = reloc->hdr.VirtualAddress;
 535         relocdir->Size = reloc->hdr.Misc.VirtualSize;
 536
 537         return reloc;
 538 }
 539
 540 /**
 541  * Create debug section
 542  *
 543  * @v pe_header         PE file header
 544  * @ret section         Debug section
 545  */
 546 static struct pe_section *
 547 create_debug_section ( struct pe_header *pe_header, const char *filename ) {
 548         struct pe_section *debug;
 549         size_t section_memsz;
 550         size_t section_filesz;
 551         EFI_IMAGE_DATA_DIRECTORY *debugdir;
 552         struct {
 553                 EFI_IMAGE_DEBUG_DIRECTORY_ENTRY debug;
 554                 EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY rsds;
 555                 char name[ strlen ( filename ) + 1 ];
 556         } *contents;
 557
 558         /* Allocate PE section */
 559         section_memsz = sizeof ( *contents );
 560         section_filesz = efi_file_align ( section_memsz );
 561         debug = xmalloc ( sizeof ( *debug ) + section_filesz );
 562         memset ( debug, 0, sizeof ( *debug ) + section_filesz );
 563         contents = ( void * ) debug->contents;
 564
 565         /* Fill in section header details */
 566         strncpy ( ( char * ) debug->hdr.Name, ".debug",
 567                   sizeof ( debug->hdr.Name ) );
 568         debug->hdr.Misc.VirtualSize = section_memsz;
 569         debug->hdr.VirtualAddress = pe_header->nt.OptionalHeader.SizeOfImage;
 570         debug->hdr.SizeOfRawData = section_filesz;
 571         debug->hdr.Characteristics = ( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA |
 572                                        EFI_IMAGE_SCN_MEM_NOT_PAGED |
 573                                        EFI_IMAGE_SCN_MEM_READ );
 574
 575         /* Create section contents */
 576         contents->debug.TimeDateStamp = 0x10d1a884;
 577         contents->debug.Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;
 578         contents->debug.SizeOfData =
 579                 ( sizeof ( *contents ) - sizeof ( contents->debug ) );
 580         contents->debug.RVA = ( debug->hdr.VirtualAddress +
 581                                 offsetof ( typeof ( *contents ), rsds ) );
 582         contents->rsds.Signature = CODEVIEW_SIGNATURE_RSDS;
 583         snprintf ( contents->name, sizeof ( contents->name ), "%s",
 584                    filename );
 585
 586         /* Update file header details */
 587         pe_header->nt.FileHeader.NumberOfSections++;
 588         pe_header->nt.OptionalHeader.SizeOfHeaders += sizeof ( debug->hdr );
 589         pe_header->nt.OptionalHeader.SizeOfImage += section_filesz;
 590         debugdir = &(pe_header->nt.OptionalHeader.DataDirectory
 591                      [EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
 592         debugdir->VirtualAddress = debug->hdr.VirtualAddress;
 593         debugdir->Size = debug->hdr.Misc.VirtualSize;
 594
 595         return debug;
 596 }
 597
 598 /**
 599  * Write out PE file
 600  *
 601  * @v pe_header         PE file header
 602  * @v pe_sections       List of PE sections
 603  * @v pe                Output file
 604  */
 605 static void write_pe_file ( struct pe_header *pe_header,
 606                             struct pe_section *pe_sections,
 607                             FILE *pe ) {
 608         struct pe_section *section;
 609         unsigned long fpos = 0;
 610
 611         /* Assign raw data pointers */
 612         fpos = efi_file_align ( pe_header->nt.OptionalHeader.SizeOfHeaders );
 613         for ( section = pe_sections ; section ; section = section->next ) {
 614                 if ( section->hdr.SizeOfRawData ) {
 615                         section->hdr.PointerToRawData = fpos;
 616                         fpos += section->hdr.SizeOfRawData;
 617                         fpos = efi_file_align ( fpos );
 618                 }
 619         }
 620
 621         /* Write file header */
 622         if ( fwrite ( pe_header, sizeof ( *pe_header ), 1, pe ) != 1 ) {
 623                 perror ( "Could not write PE header" );
 624                 exit ( 1 );
 625         }
 626
 627         /* Write section headers */
 628         for ( section = pe_sections ; section ; section = section->next ) {
 629                 if ( fwrite ( &section->hdr, sizeof ( section->hdr ),
 630                               1, pe ) != 1 ) {
 631                         perror ( "Could not write section header" );
 632                         exit ( 1 );
 633                 }
 634         }
 635
 636         /* Write sections */
 637         for ( section = pe_sections ; section ; section = section->next ) {
 638                 if ( fseek ( pe, section->hdr.PointerToRawData,
 639                              SEEK_SET ) != 0 ) {
 640                         eprintf ( "Could not seek to %lx: %s\n",
 641                                   section->hdr.PointerToRawData,
 642                                   strerror ( errno ) );
 643                         exit ( 1 );
 644                 }
 645                 if ( section->hdr.SizeOfRawData &&
 646                      ( fwrite ( section->contents, section->hdr.SizeOfRawData,
 647                                 1, pe ) != 1 ) ) {
 648                         eprintf ( "Could not write section %.8s: %s\n",
 649                                   section->hdr.Name, strerror ( errno ) );
 650                         exit ( 1 );
 651                 }
 652         }
 653 }
 654
 655 /**
 656  * Convert ELF to PE
 657  *
 658  * @v elf_name          ELF file name
 659  * @v pe_name           PE file name
 660  */
 661 static void elf2pe ( const char *elf_name, const char *pe_name,
 662                      struct options *opts ) {
 663         char pe_name_tmp[ strlen ( pe_name ) + 1 ];
 664         bfd *bfd;
 665         asymbol **symtab;
 666         asection *section;
 667         arelent **reltab;
 668         arelent **rel;
 669         struct pe_relocs *pe_reltab = NULL;
 670         struct pe_section *pe_sections = NULL;
 671         struct pe_section **next_pe_section = &pe_sections;
 672         struct pe_header pe_header;
 673         FILE *pe;
 674
 675         /* Create a modifiable copy of the PE name */
 676         memcpy ( pe_name_tmp, pe_name, sizeof ( pe_name_tmp ) );
 677
 678         /* Open the file */
 679         bfd = open_input_bfd ( elf_name );
 680         symtab = read_symtab ( bfd );
 681
 682         /* Initialise the PE header */
 683         memcpy ( &pe_header, &efi_pe_header, sizeof ( pe_header ) );
 684         pe_header.nt.OptionalHeader.AddressOfEntryPoint =
 685                 bfd_get_start_address ( bfd );
 686         pe_header.nt.OptionalHeader.Subsystem = opts->subsystem;
 687
 688         /* For each input section, build an output section and create
 689          * the appropriate relocation records
 690          */
 691         for ( section = bfd->sections ; section ; section = section->next ) {
 692                 /* Discard non-allocatable sections */
 693                 if ( ! ( bfd_get_section_flags ( bfd, section ) & SEC_ALLOC ) )
 694                         continue;
 695                 /* Create output section */
 696                 *(next_pe_section) = process_section ( bfd, &pe_header,
 697                                                        section );
 698                 next_pe_section = &(*next_pe_section)->next;
 699                 /* Add relocations from this section */
 700                 reltab = read_reltab ( bfd, symtab, section );
 701                 for ( rel = reltab ; *rel ; rel++ )
 702                         process_reloc ( bfd, section, *rel, &pe_reltab );
 703                 free ( reltab );
 704         }
 705
 706         /* Create the .reloc section */
 707         *(next_pe_section) = create_reloc_section ( &pe_header, pe_reltab );
 708         next_pe_section = &(*next_pe_section)->next;
 709
 710         /* Create the .reloc section */
 711         *(next_pe_section) = create_debug_section ( &pe_header,
 712                                                     basename ( pe_name_tmp ) );
 713         next_pe_section = &(*next_pe_section)->next;
 714
 715         /* Write out PE file */
 716         pe = fopen ( pe_name, "w" );
 717         if ( ! pe ) {
 718                 eprintf ( "Could not open %s for writing: %s\n",
 719                           pe_name, strerror ( errno ) );
 720                 exit ( 1 );
 721         }
 722         write_pe_file ( &pe_header, pe_sections, pe );
 723         fclose ( pe );
 724
 725         /* Close BFD file */
 726         bfd_close ( bfd );
 727 }
 728
 729 /**
 730  * Print help
 731  *
 732  * @v program_name      Program name
 733  */
 734 static void print_help ( const char *program_name ) {
 735         eprintf ( "Syntax: %s [--subsystem=<number>] infile outfile\n",
 736                   program_name );
 737 }
 738
 739 /**
 740  * Parse command-line options
 741  *
 742  * @v argc              Argument count
 743  * @v argv              Argument list
 744  * @v opts              Options structure to populate
 745  */
 746 static int parse_options ( const int argc, char **argv,
 747                            struct options *opts ) {
 748         char *end;
 749         int c;
 750
 751         while (1) {
 752                 int option_index = 0;
 753                 static struct option long_options[] = {
 754                         { "subsystem", required_argument, NULL, 's' },
 755                         { "help", 0, NULL, 'h' },
 756                         { 0, 0, 0, 0 }
 757                 };
 758
 759                 if ( ( c = getopt_long ( argc, argv, "s:h",
 760                                          long_options,
 761                                          &option_index ) ) == -1 ) {
 762                         break;
 763                 }
 764
 765                 switch ( c ) {
 766                 case 's':
 767                         opts->subsystem = strtoul ( optarg, &end, 0 );
 768                         if ( *end ) {
 769                                 eprintf ( "Invalid subsytem \"%s\"\n",
 770                                           optarg );
 771                                 exit ( 2 );
 772                         }
 773                         break;
 774                 case 'h':
 775                         print_help ( argv[0] );
 776                         exit ( 0 );
 777                 case '?':
 778                 default:
 779                         exit ( 2 );
 780                 }
 781         }
 782         return optind;
 783 }
 784
 785 int main ( int argc, char **argv ) {
 786         struct options opts = {
 787                 .subsystem = EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION,
 788         };
 789         unsigned int infile_index;
 790         const char *infile;
 791         const char *outfile;
 792
 793         /* Initialise libbfd */
 794         bfd_init();
 795
 796         /* Parse command-line arguments */
 797         infile_index = parse_options ( argc, argv, &opts );
 798         if ( argc != ( infile_index + 2 ) ) {
 799                 print_help ( argv[0] );
 800                 exit ( 2 );
 801         }
 802         infile = argv[infile_index];
 803         outfile = argv[infile_index + 1];
 804
 805         /* Convert file */
 806         elf2pe ( infile, outfile, &opts );
 807
 808         return 0;
 809 }