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