base/loader/elf_object.cc

   1 /*
   2  * Copyright (c) 2003-2004 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <string>
  30
  31 // Because of the -Wundef flag we have to do this
  32 #define __LIBELF_INTERNAL__     0
  33 // counterintuitive, but the flag below causes libelf to define
  34 // 64-bit elf types that apparently didn't exist in some older
  35 // versions of Linux.  They seem to be there in 2.4.x, so don't
  36 // set this now (it causes things to break on 64-bit platforms).
  37 #define __LIBELF64_LINUX        0
  38 #define __LIBELF_NEED_LINK_H    0
  39 #define __LIBELF_SYMBOL_VERSIONS 0
  40
  41 #include <libelf/libelf.h>
  42 #include <libelf/gelf.h>
  43
  44 #include "base/loader/elf_object.hh"
  45
  46 #include "mem/functional/functional.hh"
  47 #include "base/loader/symtab.hh"
  48
  49 #include "base/trace.hh"        // for DPRINTF
  50
  51
  52 using namespace std;
  53
  54 ObjectFile *
  55 ElfObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data)
  56 {
  57     Elf *elf;
  58     GElf_Ehdr ehdr;
  59
  60     // check that header matches library version
  61     if (elf_version(EV_CURRENT) == EV_NONE)
  62         panic("wrong elf version number!");
  63
  64     // get a pointer to elf structure
  65     elf = elf_memory((char*)data,len);
  66     // will only fail if fd is invalid
  67     assert(elf != NULL);
  68
  69     // Check that we actually have a elf file
  70     if (gelf_getehdr(elf, &ehdr) ==0) {
  71         DPRINTFR(Loader, "Not ELF\n");
  72         elf_end(elf);
  73         return NULL;
  74     }
  75     else {
  76         if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
  77             panic("32 bit ELF Binary, Not Supported");
  78         /* @todo this emachine value isn't offical yet.
  79          *       so we probably shouldn't check it. */
  80 //        if (ehdr.e_machine != EM_ALPHA)
  81 //            panic("Non Alpha Binary, Not Supported");
  82
  83         elf_end(elf);
  84
  85         return new ElfObject(fname, fd, len, data,
  86                              ObjectFile::Alpha, ObjectFile::Linux);
  87     }
  88 }
  89
  90
  91 ElfObject::ElfObject(const string &_filename, int _fd,
  92                      size_t _len, uint8_t *_data,
  93                      Arch _arch, OpSys _opSys)
  94     : ObjectFile(_filename, _fd, _len, _data, _arch, _opSys)
  95
  96 {
  97     Elf *elf;
  98     GElf_Ehdr ehdr;
  99
 100     // check that header matches library version
 101     if (elf_version(EV_CURRENT) == EV_NONE)
 102         panic("wrong elf version number!");
 103
 104     // get a pointer to elf structure
 105     elf = elf_memory((char*)fileData,len);
 106     // will only fail if fd is invalid
 107     assert(elf != NULL);
 108
 109     // Check that we actually have a elf file
 110     if (gelf_getehdr(elf, &ehdr) ==0) {
 111         panic("Not ELF, shouldn't be here");
 112     }
 113
 114     entry = ehdr.e_entry;
 115
 116     // initialize segment sizes to 0 in case they're not present
 117     text.size = data.size = bss.size = 0;
 118
 119     for (int i = 0; i < ehdr.e_phnum; ++i) {
 120         GElf_Phdr phdr;
 121         if (gelf_getphdr(elf, i, &phdr) == 0) {
 122             panic("gelf_getphdr failed for section %d", i);
 123         }
 124
 125         // for now we don't care about non-loadable segments
 126         if (!(phdr.p_type & PT_LOAD))
 127             continue;
 128
 129         // the headers don't explicitly distinguish text from data,
 130         // but empirically the text segment comes first.
 131         if (text.size == 0) {  // haven't seen text segment yet
 132             text.baseAddr = phdr.p_vaddr;
 133             text.size = phdr.p_filesz;
 134             // remember where the data is for loadSections()
 135             fileTextBits = fileData + phdr.p_offset;
 136             // if there's any padding at the end that's not in the
 137             // file, call it the bss.  This happens in the "text"
 138             // segment if there's only one loadable segment (as for
 139             // kernel images).
 140             bss.size = phdr.p_memsz - phdr.p_filesz;
 141             bss.baseAddr = phdr.p_vaddr + phdr.p_filesz;
 142         }
 143         else if (data.size == 0) { // have text, this must be data
 144             data.baseAddr = phdr.p_vaddr;
 145             data.size = phdr.p_filesz;
 146             // remember where the data is for loadSections()
 147             fileDataBits = fileData + phdr.p_offset;
 148             // if there's any padding at the end that's not in the
 149             // file, call it the bss.  Warn if this happens for both
 150             // the text & data segments (should only have one bss).
 151             if (phdr.p_memsz - phdr.p_filesz > 0 && bss.size != 0) {
 152                 warn("Two implied bss segments in file!\n");
 153             }
 154             bss.size = phdr.p_memsz - phdr.p_filesz;
 155             bss.baseAddr = phdr.p_vaddr + phdr.p_filesz;
 156         }
 157     }
 158
 159     // should have found at least one loadable segment
 160     assert(text.size != 0);
 161
 162     DPRINTFR(Loader, "text: 0x%x %d\ndata: 0x%x %d\nbss: 0x%x %d\n",
 163              text.baseAddr, text.size, data.baseAddr, data.size,
 164              bss.baseAddr, bss.size);
 165
 166     elf_end(elf);
 167
 168     // We will actually read the sections when we need to load them
 169 }
 170
 171
 172 bool
 173 ElfObject::loadSections(FunctionalMemory *mem, bool loadPhys)
 174 {
 175     Addr textAddr = text.baseAddr;
 176     Addr dataAddr = data.baseAddr;
 177
 178     if (loadPhys) {
 179         textAddr &= (ULL(1) << 40) - 1;
 180         dataAddr &= (ULL(1) << 40) - 1;
 181     }
 182
 183     // Since we don't really have an MMU and all memory is
 184     // zero-filled, there's no need to set up the BSS segment.
 185     if (text.size != 0)
 186         mem->prot_write(textAddr, fileTextBits, text.size);
 187     if (data.size != 0)
 188         mem->prot_write(dataAddr, fileDataBits, data.size);
 189
 190     return true;
 191 }
 192
 193
 194 bool
 195 ElfObject::loadSomeSymbols(SymbolTable *symtab, int binding)
 196 {
 197     Elf *elf;
 198     int sec_idx = 1; // there is a 0 but it is nothing, go figure
 199     Elf_Scn *section;
 200     GElf_Shdr shdr;
 201     Elf_Data *data;
 202     int count, ii;
 203     bool found = false;
 204     GElf_Sym sym;
 205
 206     if (!symtab)
 207         return false;
 208
 209     // check that header matches library version
 210     if (elf_version(EV_CURRENT) == EV_NONE)
 211         panic("wrong elf version number!");
 212
 213     // get a pointer to elf structure
 214     elf = elf_memory((char*)fileData,len);
 215
 216     assert(elf != NULL);
 217
 218     // Get the first section
 219     section = elf_getscn(elf, sec_idx);
 220
 221     // While there are no more sections
 222     while (section != NULL) {
 223         gelf_getshdr(section, &shdr);
 224
 225         if (shdr.sh_type == SHT_SYMTAB) {
 226             found = true;
 227             data = elf_getdata(section, NULL);
 228             count = shdr.sh_size / shdr.sh_entsize;
 229             DPRINTF(Loader, "Found Symbol Table, %d symbols present\n", count);
 230
 231             // loop through all the symbols, only loading global ones
 232             for (ii = 0; ii < count; ++ii) {
 233                 gelf_getsym(data, ii, &sym);
 234                 if (GELF_ST_BIND(sym.st_info) == binding) {
 235                    symtab->insert(sym.st_value,
 236                                   elf_strptr(elf, shdr.sh_link, sym.st_name));
 237                 }
 238             }
 239         }
 240         ++sec_idx;
 241         section = elf_getscn(elf, sec_idx);
 242     }
 243
 244     elf_end(elf);
 245
 246     return found;
 247 }
 248
 249 bool
 250 ElfObject::loadGlobalSymbols(SymbolTable *symtab)
 251 {
 252     return loadSomeSymbols(symtab, STB_GLOBAL);
 253 }
 254
 255 bool
 256 ElfObject::loadLocalSymbols(SymbolTable *symtab)
 257 {
 258     return loadSomeSymbols(symtab, STB_LOCAL);
 259 }