simpleperf/read_elf.cpp

   1 /*
   2  * Copyright (C) 2015 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "read_elf.h"
  18 #include "read_apk.h"
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <sys/stat.h>
  23 #include <sys/types.h>
  24
  25 #include <algorithm>
  26 #include <limits>
  27
  28 #include <android-base/file.h>
  29 #include <android-base/logging.h>
  30
  31 #pragma clang diagnostic push
  32 #pragma clang diagnostic ignored "-Wunused-parameter"
  33
  34 #include <llvm/ADT/StringRef.h>
  35 #include <llvm/Object/Binary.h>
  36 #include <llvm/Object/ELFObjectFile.h>
  37 #include <llvm/Object/ObjectFile.h>
  38
  39 #pragma clang diagnostic pop
  40
  41 #include "utils.h"
  42
  43 #define ELF_NOTE_GNU "GNU"
  44 #define NT_GNU_BUILD_ID 3
  45
  46
  47 bool IsValidElfFile(int fd) {
  48   static const char elf_magic[] = {0x7f, 'E', 'L', 'F'};
  49   char buf[4];
  50   return android::base::ReadFully(fd, buf, 4) && memcmp(buf, elf_magic, 4) == 0;
  51 }
  52
  53 bool IsValidElfPath(const std::string& filename) {
  54   if (!IsRegularFile(filename)) {
  55     return false;
  56   }
  57   std::string mode = std::string("rb") + CLOSE_ON_EXEC_MODE;
  58   FILE* fp = fopen(filename.c_str(), mode.c_str());
  59   if (fp == nullptr) {
  60     return false;
  61   }
  62   bool result = IsValidElfFile(fileno(fp));
  63   fclose(fp);
  64   return result;
  65 }
  66
  67 static bool GetBuildIdFromNoteSection(const char* section, size_t section_size, BuildId* build_id) {
  68   const char* p = section;
  69   const char* end = p + section_size;
  70   while (p < end) {
  71     CHECK_LE(p + 12, end);
  72     size_t namesz = *reinterpret_cast<const uint32_t*>(p);
  73     p += 4;
  74     size_t descsz = *reinterpret_cast<const uint32_t*>(p);
  75     p += 4;
  76     uint32_t type = *reinterpret_cast<const uint32_t*>(p);
  77     p += 4;
  78     namesz = ALIGN(namesz, 4);
  79     descsz = ALIGN(descsz, 4);
  80     CHECK_LE(p + namesz + descsz, end);
  81     if ((type == NT_GNU_BUILD_ID) && (strcmp(p, ELF_NOTE_GNU) == 0)) {
  82       *build_id = BuildId(p + namesz, descsz);
  83       return true;
  84     }
  85     p += namesz + descsz;
  86   }
  87   return false;
  88 }
  89
  90 bool GetBuildIdFromNoteFile(const std::string& filename, BuildId* build_id) {
  91   std::string content;
  92   if (!android::base::ReadFileToString(filename, &content)) {
  93     LOG(DEBUG) << "can't read note file " << filename;
  94     return false;
  95   }
  96   if (GetBuildIdFromNoteSection(content.c_str(), content.size(), build_id) == false) {
  97     LOG(DEBUG) << "can't read build_id from note file " << filename;
  98     return false;
  99   }
 100   return true;
 101 }
 102
 103 template <class ELFT>
 104 bool GetBuildIdFromELFFile(const llvm::object::ELFFile<ELFT>* elf, BuildId* build_id) {
 105   for (auto section_iterator = elf->section_begin(); section_iterator != elf->section_end();
 106        ++section_iterator) {
 107     if (section_iterator->sh_type == llvm::ELF::SHT_NOTE) {
 108       auto contents = elf->getSectionContents(&*section_iterator);
 109       if (contents.getError()) {
 110         LOG(DEBUG) << "read note section error";
 111         continue;
 112       }
 113       if (GetBuildIdFromNoteSection(reinterpret_cast<const char*>(contents->data()),
 114                                     contents->size(), build_id)) {
 115         return true;
 116       }
 117     }
 118   }
 119   return false;
 120 }
 121
 122 static bool GetBuildIdFromObjectFile(llvm::object::ObjectFile* obj, BuildId* build_id) {
 123   bool result = false;
 124   if (auto elf = llvm::dyn_cast<llvm::object::ELF32LEObjectFile>(obj)) {
 125     result = GetBuildIdFromELFFile(elf->getELFFile(), build_id);
 126   } else if (auto elf = llvm::dyn_cast<llvm::object::ELF64LEObjectFile>(obj)) {
 127     result = GetBuildIdFromELFFile(elf->getELFFile(), build_id);
 128   } else {
 129     LOG(ERROR) << "unknown elf format in file " << obj->getFileName().data();
 130     return false;
 131   }
 132   if (!result) {
 133     LOG(DEBUG) << "no build id present in file " << obj->getFileName().data();
 134   }
 135   return result;
 136 }
 137
 138 struct BinaryRet {
 139   llvm::object::OwningBinary<llvm::object::Binary> binary;
 140   llvm::object::ObjectFile* obj;
 141
 142   BinaryRet() : obj(nullptr) {
 143   }
 144 };
 145
 146 static BinaryRet OpenObjectFile(const std::string& filename, uint64_t file_offset = 0,
 147                                 uint64_t file_size = 0) {
 148   BinaryRet ret;
 149   FileHelper fhelper = FileHelper::OpenReadOnly(filename);
 150   if (!fhelper) {
 151     PLOG(DEBUG) << "failed to open " << filename;
 152     return ret;
 153   }
 154   if (file_size == 0) {
 155     file_size = GetFileSize(filename);
 156     if (file_size == 0) {
 157       PLOG(ERROR) << "failed to get size of file " << filename;
 158       return ret;
 159     }
 160   }
 161   auto buffer_or_err = llvm::MemoryBuffer::getOpenFileSlice(fhelper.fd(), filename, file_size, file_offset);
 162   if (!buffer_or_err) {
 163     LOG(ERROR) << "failed to read " << filename << " [" << file_offset << "-" << (file_offset + file_size)
 164         << "]: " << buffer_or_err.getError().message();
 165     return ret;
 166   }
 167   auto binary_or_err = llvm::object::createBinary(buffer_or_err.get()->getMemBufferRef());
 168   if (!binary_or_err) {
 169     LOG(ERROR) << filename << " [" << file_offset << "-" << (file_offset + file_size)
 170         << "] is not a binary file: " << binary_or_err.getError().message();
 171     return ret;
 172   }
 173   ret.binary = llvm::object::OwningBinary<llvm::object::Binary>(std::move(binary_or_err.get()),
 174                                                                 std::move(buffer_or_err.get()));
 175   ret.obj = llvm::dyn_cast<llvm::object::ObjectFile>(ret.binary.getBinary());
 176   if (ret.obj == nullptr) {
 177     LOG(ERROR) << filename << " [" << file_offset << "-" << (file_offset + file_size)
 178         << "] is not an object file";
 179   }
 180   return ret;
 181 }
 182
 183 bool GetBuildIdFromElfFile(const std::string& filename, BuildId* build_id) {
 184   if (!IsValidElfPath(filename)) {
 185     return false;
 186   }
 187   bool result = GetBuildIdFromEmbeddedElfFile(filename, 0, 0, build_id);
 188   LOG(VERBOSE) << "GetBuildIdFromElfFile(" << filename << ") => " << build_id->ToString();
 189   return result;
 190 }
 191
 192 bool GetBuildIdFromEmbeddedElfFile(const std::string& filename, uint64_t file_offset,
 193                                    uint32_t file_size, BuildId* build_id) {
 194   BinaryRet ret = OpenObjectFile(filename, file_offset, file_size);
 195   if (ret.obj == nullptr) {
 196     return false;
 197   }
 198   return GetBuildIdFromObjectFile(ret.obj, build_id);
 199 }
 200
 201 bool IsArmMappingSymbol(const char* name) {
 202   // Mapping symbols in arm, which are described in "ELF for ARM Architecture" and
 203   // "ELF for ARM 64-bit Architecture". The regular expression to match mapping symbol
 204   // is ^\$(a|d|t|x)(\..*)?$
 205   return name[0] == '$' && strchr("adtx", name[1]) != nullptr && (name[2] == '\0' || name[2] == '.');
 206 }
 207
 208 template <class ELFT>
 209 void ParseSymbolsFromELFFile(const llvm::object::ELFObjectFile<ELFT>* elf_obj,
 210                              std::function<void(const ElfFileSymbol&)> callback) {
 211   auto elf = elf_obj->getELFFile();
 212   bool is_arm = (elf->getHeader()->e_machine == llvm::ELF::EM_ARM ||
 213                  elf->getHeader()->e_machine == llvm::ELF::EM_AARCH64);
 214   auto begin = elf_obj->symbol_begin();
 215   auto end = elf_obj->symbol_end();
 216   if (begin == end) {
 217     begin = elf_obj->dynamic_symbol_begin();
 218     end = elf_obj->dynamic_symbol_end();
 219   }
 220   for (; begin != end; ++begin) {
 221     ElfFileSymbol symbol;
 222     auto elf_symbol = static_cast<const llvm::object::ELFSymbolRef*>(&*begin);
 223     auto section_it = elf_symbol->getSection();
 224     if (!section_it) {
 225       continue;
 226     }
 227     llvm::StringRef section_name;
 228     if (section_it.get()->getName(section_name) || section_name.empty()) {
 229       continue;
 230     }
 231     if (section_name.str() == ".text") {
 232       symbol.is_in_text_section = true;
 233     }
 234
 235     auto symbol_name = elf_symbol->getName();
 236     if (!symbol_name || symbol_name.get().empty()) {
 237       continue;
 238     }
 239     symbol.name = symbol_name.get();
 240     symbol.vaddr = elf_symbol->getValue();
 241     if ((symbol.vaddr & 1) != 0 && is_arm) {
 242       // Arm sets bit 0 to mark it as thumb code, remove the flag.
 243       symbol.vaddr &= ~1;
 244     }
 245     symbol.len = elf_symbol->getSize();
 246     int type = elf_symbol->getELFType();
 247     if (type == llvm::ELF::STT_FUNC) {
 248       symbol.is_func = true;
 249     } else if (type == llvm::ELF::STT_NOTYPE) {
 250       if (symbol.is_in_text_section) {
 251         symbol.is_label = true;
 252         if (is_arm) {
 253           // Remove mapping symbols in arm.
 254           const char* p = (symbol.name.compare(0, linker_prefix.size(), linker_prefix) == 0)
 255                               ? symbol.name.c_str() + linker_prefix.size()
 256                               : symbol.name.c_str();
 257           if (IsArmMappingSymbol(p)) {
 258             symbol.is_label = false;
 259           }
 260         }
 261       }
 262     }
 263
 264     callback(symbol);
 265   }
 266 }
 267
 268 bool MatchBuildId(llvm::object::ObjectFile* obj, const BuildId& expected_build_id,
 269                   const std::string& debug_filename) {
 270   if (expected_build_id.IsEmpty()) {
 271     return true;
 272   }
 273   BuildId real_build_id;
 274   if (!GetBuildIdFromObjectFile(obj, &real_build_id)) {
 275     return false;
 276   }
 277   if (expected_build_id != real_build_id) {
 278     LOG(DEBUG) << "build id for " << debug_filename << " mismatch: "
 279                << "expected " << expected_build_id.ToString()
 280                << ", real " << real_build_id.ToString();
 281     return false;
 282   }
 283   return true;
 284 }
 285
 286 bool ParseSymbolsFromElfFile(const std::string& filename, const BuildId& expected_build_id,
 287                              std::function<void(const ElfFileSymbol&)> callback) {
 288   if (!IsValidElfPath(filename)) {
 289     return false;
 290   }
 291   return ParseSymbolsFromEmbeddedElfFile(filename, 0, 0, expected_build_id, callback);
 292 }
 293
 294 bool ParseSymbolsFromEmbeddedElfFile(const std::string& filename, uint64_t file_offset,
 295                                      uint32_t file_size, const BuildId& expected_build_id,
 296                                      std::function<void(const ElfFileSymbol&)> callback) {
 297   BinaryRet ret = OpenObjectFile(filename, file_offset, file_size);
 298   if (ret.obj == nullptr || !MatchBuildId(ret.obj, expected_build_id, filename)) {
 299     return false;
 300   }
 301   if (auto elf = llvm::dyn_cast<llvm::object::ELF32LEObjectFile>(ret.obj)) {
 302     ParseSymbolsFromELFFile(elf, callback);
 303   } else if (auto elf = llvm::dyn_cast<llvm::object::ELF64LEObjectFile>(ret.obj)) {
 304     ParseSymbolsFromELFFile(elf, callback);
 305   } else {
 306     LOG(ERROR) << "unknown elf format in file " << filename;
 307     return false;
 308   }
 309   return true;
 310 }
 311
 312 template <class ELFT>
 313 bool ReadMinExecutableVirtualAddress(const llvm::object::ELFFile<ELFT>* elf, uint64_t* p_vaddr) {
 314   bool has_vaddr = false;
 315   uint64_t min_addr = std::numeric_limits<uint64_t>::max();
 316   for (auto it = elf->program_header_begin(); it != elf->program_header_end(); ++it) {
 317     if ((it->p_type == llvm::ELF::PT_LOAD) && (it->p_flags & llvm::ELF::PF_X)) {
 318       if (it->p_vaddr < min_addr) {
 319         min_addr = it->p_vaddr;
 320         has_vaddr = true;
 321       }
 322     }
 323   }
 324   if (has_vaddr) {
 325     *p_vaddr = min_addr;
 326   }
 327   return has_vaddr;
 328 }
 329
 330 bool ReadMinExecutableVirtualAddressFromElfFile(const std::string& filename,
 331                                                 const BuildId& expected_build_id,
 332                                                 uint64_t* min_vaddr) {
 333   if (!IsValidElfPath(filename)) {
 334     return false;
 335   }
 336   BinaryRet ret = OpenObjectFile(filename);
 337   if (ret.obj == nullptr || !MatchBuildId(ret.obj, expected_build_id, filename)) {
 338     return false;
 339   }
 340
 341   bool result = false;
 342   if (auto elf = llvm::dyn_cast<llvm::object::ELF32LEObjectFile>(ret.obj)) {
 343     result = ReadMinExecutableVirtualAddress(elf->getELFFile(), min_vaddr);
 344   } else if (auto elf = llvm::dyn_cast<llvm::object::ELF64LEObjectFile>(ret.obj)) {
 345     result = ReadMinExecutableVirtualAddress(elf->getELFFile(), min_vaddr);
 346   } else {
 347     LOG(ERROR) << "unknown elf format in file" << filename;
 348     return false;
 349   }
 350
 351   if (!result) {
 352     LOG(ERROR) << "no program header in file " << filename;
 353   }
 354   return result;
 355 }
 356
 357 template <class ELFT>
 358 bool ReadSectionFromELFFile(const llvm::object::ELFFile<ELFT>* elf, const std::string& section_name,
 359                             std::string* content) {
 360   for (auto it = elf->section_begin(); it != elf->section_end(); ++it) {
 361     auto name_or_err = elf->getSectionName(&*it);
 362     if (name_or_err && *name_or_err == section_name) {
 363       auto data_or_err = elf->getSectionContents(&*it);
 364       if (!data_or_err) {
 365         LOG(ERROR) << "failed to read section " << section_name;
 366         return false;
 367       }
 368       content->append(data_or_err->begin(), data_or_err->end());
 369       return true;
 370     }
 371   }
 372   LOG(ERROR) << "can't find section " << section_name;
 373   return false;
 374 }
 375
 376 bool ReadSectionFromElfFile(const std::string& filename, const std::string& section_name,
 377                             std::string* content) {
 378   if (!IsValidElfPath(filename)) {
 379     return false;
 380   }
 381   BinaryRet ret = OpenObjectFile(filename);
 382   if (ret.obj == nullptr) {
 383     return false;
 384   }
 385   bool result = false;
 386   if (auto elf = llvm::dyn_cast<llvm::object::ELF32LEObjectFile>(ret.obj)) {
 387     result = ReadSectionFromELFFile(elf->getELFFile(), section_name, content);
 388   } else if (auto elf = llvm::dyn_cast<llvm::object::ELF64LEObjectFile>(ret.obj)) {
 389     result = ReadSectionFromELFFile(elf->getELFFile(), section_name, content);
 390   } else {
 391     LOG(ERROR) << "unknown elf format in file" << filename;
 392     return false;
 393   }
 394   return result;
 395 }