Return to elf32.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / lib / libelf

Annotation of qemu/roms/SLOF/lib/libelf/elf32.c, revision 1.1.1.1

1.1       root        1: /******************************************************************************
                      2:  * Copyright (c) 2004, 2011 IBM Corporation
                      3:  * All rights reserved.
                      4:  * This program and the accompanying materials
                      5:  * are made available under the terms of the BSD License
                      6:  * which accompanies this distribution, and is available at
                      7:  * http://www.opensource.org/licenses/bsd-license.php
                      8:  *
                      9:  * Contributors:
                     10:  *     IBM Corporation - initial implementation
                     11:  *****************************************************************************/
                     12: 
                     13: /*
                     14:  * 32-bit ELF loader
                     15:  */
                     16:  
                     17: #include <string.h>
                     18: #include <libelf.h>
                     19: 
                     20: struct ehdr32 {
                     21:        uint32_t ei_ident;
                     22:        uint8_t ei_class;
                     23:        uint8_t ei_data;
                     24:        uint8_t ei_version;
                     25:        uint8_t ei_pad[9];
                     26:        uint16_t e_type;
                     27:        uint16_t e_machine;
                     28:        uint32_t e_version;
                     29:        uint32_t e_entry;
                     30:        uint32_t e_phoff;
                     31:        uint32_t e_shoff;
                     32:        uint32_t e_flags;
                     33:        uint16_t e_ehsize;
                     34:        uint16_t e_phentsize;
                     35:        uint16_t e_phnum;
                     36:        uint16_t e_shentsize;
                     37:        uint16_t e_shnum;
                     38:        uint16_t e_shstrndx;
                     39: };
                     40: 
                     41: struct phdr32 {
                     42:        uint32_t p_type;
                     43:        uint32_t p_offset;
                     44:        uint32_t p_vaddr;
                     45:        uint32_t p_paddr;
                     46:        uint32_t p_filesz;
                     47:        uint32_t p_memsz;
                     48:        uint32_t p_flags;
                     49:        uint32_t p_align;
                     50: };
                     51: 
                     52: 
                     53: static struct phdr32*
                     54: get_phdr32(void *file_addr)
                     55: {
                     56:        return (struct phdr32 *) (((unsigned char *)file_addr)
                     57:                + ((struct ehdr32 *)file_addr)->e_phoff);
                     58: }
                     59: 
                     60: static void
                     61: load_segment(void *file_addr, struct phdr32 *phdr, signed long offset,
                     62:              int (*pre_load)(void*, long),
                     63:              void (*post_load)(void*, long))
                     64: {
                     65:        unsigned long src = phdr->p_offset + (unsigned long) file_addr;
                     66:        unsigned long destaddr;
                     67: 
                     68:        destaddr = (unsigned long)phdr->p_paddr;
                     69:        destaddr = destaddr + offset;
                     70: 
                     71:        /* check if we're allowed to copy */
                     72:        if (pre_load != NULL) {
                     73:                if (pre_load((void*)destaddr, phdr->p_memsz) != 0)
                     74:                        return;
                     75:        }
                     76: 
                     77:        /* copy into storage */
                     78:        memmove((void *)destaddr, (void *)src, phdr->p_filesz);
                     79: 
                     80:        /* clear bss */
                     81:        memset((void *)(destaddr + phdr->p_filesz), 0,
                     82:               phdr->p_memsz - phdr->p_filesz);
                     83: 
                     84:        if (phdr->p_memsz && post_load) {
                     85:                post_load((void*)destaddr, phdr->p_memsz);
                     86:        }
                     87: }
                     88: 
                     89: unsigned int
                     90: elf_load_segments32(void *file_addr, signed long offset,
                     91:                     int (*pre_load)(void*, long),
                     92:                     void (*post_load)(void*, long))
                     93: {
                     94:        struct ehdr32 *ehdr = (struct ehdr32 *) file_addr;
                     95:        /* Calculate program header address */
                     96:        struct phdr32 *phdr = get_phdr32(file_addr);
                     97:        int i;
                     98:        signed int virt2phys = 0;       /* Offset between virtual and physical */
                     99: 
                    100:        /* loop e_phnum times */
                    101:        for (i = 0; i <= ehdr->e_phnum; i++) {
                    102:                /* PT_LOAD ? */
                    103:                if (phdr->p_type == 1) {
                    104:                        if (!virt2phys) {
                    105:                                virt2phys = phdr->p_paddr - phdr->p_vaddr;
                    106:                        }
                    107:                        /* copy segment */
                    108:                        load_segment(file_addr, phdr, offset, pre_load,
                    109:                                     post_load);
                    110:                }
                    111:                /* step to next header */
                    112:                phdr = (struct phdr32 *)(((uint8_t *)phdr) + ehdr->e_phentsize);
                    113:        }
                    114: 
                    115:        /* Entry point is always a virtual address, so translate it
                    116:         * to physical before returning it */
                    117:        return ehdr->e_entry + virt2phys;
                    118: }
                    119: 
                    120: /**
                    121:  * Return the base address for loading (i.e. the address of the first PT_LOAD
                    122:  * segment)
                    123:  * @param  file_addr   pointer to the ELF file in memory
                    124:  * @return             the base address
                    125:  */
                    126: long
                    127: elf_get_base_addr32(void *file_addr)
                    128: {
                    129:        struct ehdr32 *ehdr = (struct ehdr32 *) file_addr;
                    130:        struct phdr32 *phdr = get_phdr32(file_addr);
                    131:        int i;
                    132: 
                    133:        /* loop e_phnum times */
                    134:        for (i = 0; i <= ehdr->e_phnum; i++) {
                    135:                /* PT_LOAD ? */
                    136:                if (phdr->p_type == 1) {
                    137:                        return phdr->p_paddr;
                    138:                }
                    139:                /* step to next header */
                    140:                phdr = (struct phdr32 *)(((uint8_t *)phdr) + ehdr->e_phentsize);
                    141:        }
                    142: 
                    143:        return 0;
                    144: }

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