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