Return to elf2efi.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / util

Annotation of qemu/roms/ipxe/src/util/elf2efi.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (C) 2009 Michael Brown <[email protected]>.
        !             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 <ipxe/efi/efi.h>
        !            31: #include <ipxe/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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.