base/loader/elf_object.cc

   1 /*
   2  * Copyright (c) 2003-2005 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 #include "base/misc.hh"
  46
  47 #include "base/loader/symtab.hh"
  48
  49 #include "base/trace.hh"        // for DPRINTF
  50
  51 #include "sim/byteswap.hh"
  52
  53
  54 using namespace std;
  55
  56 ObjectFile *
  57 ElfObject::tryFile(const string &fname, int fd, size_t len, uint8_t *data)
  58 {
  59     Elf *elf;
  60     GElf_Ehdr ehdr;
  61     Arch arch = UnknownArch;
  62     OpSys opSys = UnknownOpSys;
  63
  64     // check that header matches library version
  65     if (elf_version(EV_CURRENT) == EV_NONE)
  66         panic("wrong elf version number!");
  67
  68     // get a pointer to elf structure
  69     elf = elf_memory((char*)data,len);
  70     // will only fail if fd is invalid
  71     assert(elf != NULL);
  72
  73     // Check that we actually have a elf file
  74     if (gelf_getehdr(elf, &ehdr) ==0) {
  75         DPRINTFR(Loader, "Not ELF\n");
  76         elf_end(elf);
  77         return NULL;
  78     } else {
  79         //Detect the architecture
  80         //Since we don't know how to check for alpha right now, we'll
  81         //just assume if it wasn't something else and it's 64 bit, that's
  82         //what it must be.
  83         if (ehdr.e_machine == EM_SPARC64 ||
  84                 ehdr.e_machine == EM_SPARC ||
  85                 ehdr.e_machine == EM_SPARCV9) {
  86             arch = ObjectFile::SPARC;
  87         } else if (ehdr.e_machine == EM_MIPS
  88                 && ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
  89             arch = ObjectFile::Mips;
  90         } else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) {
  91             arch = ObjectFile::Alpha;
  92         } else {
  93             warn("Unknown architecture: %d\n", ehdr.e_machine);
  94             arch = ObjectFile::UnknownArch;
  95         }
  96
  97         //Detect the operating system
  98         switch (ehdr.e_ident[EI_OSABI])
  99         {
 100
 101           case ELFOSABI_LINUX:
 102             opSys = ObjectFile::Linux;
 103             break;
 104           case ELFOSABI_SOLARIS:
 105             opSys = ObjectFile::Solaris;
 106             break;
 107           case ELFOSABI_TRU64:
 108             opSys = ObjectFile::Tru64;
 109             break;
 110           default:
 111             opSys = ObjectFile::UnknownOpSys;
 112         }
 113
 114         //take a look at the .note.ABI section
 115         //It can let us know what's what.
 116         if (opSys == ObjectFile::UnknownOpSys) {
 117             Elf_Scn *section;
 118             GElf_Shdr shdr;
 119             Elf_Data *data;
 120             uint32_t osAbi;;
 121             int secIdx = 1;
 122
 123             // Get the first section
 124             section = elf_getscn(elf, secIdx);
 125
 126             // While there are no more sections
 127             while (section != NULL && opSys == ObjectFile::UnknownOpSys) {
 128                 gelf_getshdr(section, &shdr);
 129                 if (shdr.sh_type == SHT_NOTE && !strcmp(".note.ABI-tag",
 130                             elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name))) {
 131                     // we have found a ABI note section
 132                     // Check the 5th 32bit word for OS  0 == linux, 1 == hurd,
 133                     // 2 == solaris, 3 == freebsd
 134                     data = elf_rawdata(section, NULL);
 135                     assert(data->d_buf);
 136                     if(ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
 137                         osAbi = htole(((uint32_t*)data->d_buf)[4]);
 138                     else
 139                         osAbi = htobe(((uint32_t*)data->d_buf)[4]);
 140
 141                     switch(osAbi) {
 142                       case 0:
 143                         opSys = ObjectFile::Linux;
 144                         break;
 145                       case 2:
 146                         opSys = ObjectFile::Solaris;
 147                         break;
 148                     }
 149                 } // if section found
 150                 if (!strcmp(".SUNW_version", elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name)))
 151                         opSys = ObjectFile::Solaris;
 152                 if (!strcmp(".stab.index", elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name)))
 153                         opSys = ObjectFile::Solaris;
 154
 155             section = elf_getscn(elf, ++secIdx);
 156             } // while sections
 157         }
 158
 159         elf_end(elf);
 160         return new ElfObject(fname, fd, len, data, arch, opSys);
 161     }
 162 }
 163
 164
 165 ElfObject::ElfObject(const string &_filename, int _fd,
 166                      size_t _len, uint8_t *_data,
 167                      Arch _arch, OpSys _opSys)
 168     : ObjectFile(_filename, _fd, _len, _data, _arch, _opSys)
 169
 170 {
 171     Elf *elf;
 172     GElf_Ehdr ehdr;
 173
 174     // check that header matches library version
 175     if (elf_version(EV_CURRENT) == EV_NONE)
 176         panic("wrong elf version number!");
 177
 178     // get a pointer to elf structure
 179     elf = elf_memory((char*)fileData,len);
 180     // will only fail if fd is invalid
 181     assert(elf != NULL);
 182
 183     // Check that we actually have a elf file
 184     if (gelf_getehdr(elf, &ehdr) ==0) {
 185         panic("Not ELF, shouldn't be here");
 186     }
 187
 188     entry = ehdr.e_entry;
 189
 190
 191     // initialize segment sizes to 0 in case they're not present
 192     text.size = data.size = bss.size = 0;
 193
 194     for (int i = 0; i < ehdr.e_phnum; ++i) {
 195         GElf_Phdr phdr;
 196         if (gelf_getphdr(elf, i, &phdr) == 0) {
 197             panic("gelf_getphdr failed for section %d", i);
 198         }
 199
 200         // for now we don't care about non-loadable segments
 201         if (!(phdr.p_type & PT_LOAD))
 202             continue;
 203
 204         // the headers don't explicitly distinguish text from data,
 205         // but empirically the text segment comes first.
 206         if (text.size == 0) {  // haven't seen text segment yet
 207             text.baseAddr = phdr.p_vaddr;
 208             text.size = phdr.p_filesz;
 209             text.fileImage = fileData + phdr.p_offset;
 210             // if there's any padding at the end that's not in the
 211             // file, call it the bss.  This happens in the "text"
 212             // segment if there's only one loadable segment (as for
 213             // kernel images).
 214             bss.size = phdr.p_memsz - phdr.p_filesz;
 215             bss.baseAddr = phdr.p_vaddr + phdr.p_filesz;
 216             bss.fileImage = NULL;
 217         } else if (data.size == 0) { // have text, this must be data
 218             data.baseAddr = phdr.p_vaddr;
 219             data.size = phdr.p_filesz;
 220             data.fileImage = fileData + phdr.p_offset;
 221             // if there's any padding at the end that's not in the
 222             // file, call it the bss.  Warn if this happens for both
 223             // the text & data segments (should only have one bss).
 224             if (phdr.p_memsz - phdr.p_filesz > 0 && bss.size != 0) {
 225                 warn("Two implied bss segments in file!\n");
 226             }
 227             bss.size = phdr.p_memsz - phdr.p_filesz;
 228             bss.baseAddr = phdr.p_vaddr + phdr.p_filesz;
 229             bss.fileImage = NULL;
 230         } else {
 231             warn("More than two loadable segments in ELF object.");
 232             warn("Ignoring segment @ 0x%x length 0x%x.",
 233                  phdr.p_vaddr, phdr.p_filesz);
 234         }
 235     }
 236
 237     // should have found at least one loadable segment
 238     assert(text.size != 0);
 239
 240     DPRINTFR(Loader, "text: 0x%x %d\ndata: 0x%x %d\nbss: 0x%x %d\n",
 241              text.baseAddr, text.size, data.baseAddr, data.size,
 242              bss.baseAddr, bss.size);
 243
 244     elf_end(elf);
 245
 246     // We will actually read the sections when we need to load them
 247 }
 248
 249
 250 bool
 251 ElfObject::loadSomeSymbols(SymbolTable *symtab, int binding)
 252 {
 253     Elf *elf;
 254     int sec_idx = 1; // there is a 0 but it is nothing, go figure
 255     Elf_Scn *section;
 256     GElf_Shdr shdr;
 257     Elf_Data *data;
 258     int count, ii;
 259     bool found = false;
 260     GElf_Sym sym;
 261
 262     if (!symtab)
 263         return false;
 264
 265     // check that header matches library version
 266     if (elf_version(EV_CURRENT) == EV_NONE)
 267         panic("wrong elf version number!");
 268
 269     // get a pointer to elf structure
 270     elf = elf_memory((char*)fileData,len);
 271
 272     assert(elf != NULL);
 273
 274     // Get the first section
 275     section = elf_getscn(elf, sec_idx);
 276
 277     // While there are no more sections
 278     while (section != NULL) {
 279         gelf_getshdr(section, &shdr);
 280
 281         if (shdr.sh_type == SHT_SYMTAB) {
 282             found = true;
 283             data = elf_getdata(section, NULL);
 284             count = shdr.sh_size / shdr.sh_entsize;
 285             DPRINTF(Loader, "Found Symbol Table, %d symbols present\n", count);
 286
 287             // loop through all the symbols, only loading global ones
 288             for (ii = 0; ii < count; ++ii) {
 289                 gelf_getsym(data, ii, &sym);
 290                 if (GELF_ST_BIND(sym.st_info) == binding) {
 291                    symtab->insert(sym.st_value,
 292                                   elf_strptr(elf, shdr.sh_link, sym.st_name));
 293                 }
 294             }
 295         }
 296         ++sec_idx;
 297         section = elf_getscn(elf, sec_idx);
 298     }
 299
 300     elf_end(elf);
 301
 302     return found;
 303 }
 304
 305 bool
 306 ElfObject::loadGlobalSymbols(SymbolTable *symtab)
 307 {
 308     return loadSomeSymbols(symtab, STB_GLOBAL);
 309 }
 310
 311 bool
 312 ElfObject::loadLocalSymbols(SymbolTable *symtab)
 313 {
 314     return loadSomeSymbols(symtab, STB_LOCAL);
 315 }