llvm/tools/dsymutil/SymbolMap.cpp

   1 //===- tools/dsymutil/SymbolMap.cpp ---------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "SymbolMap.h"
  10 #include "DebugMap.h"
  11 #include "MachOUtils.h"
  12
  13 #include "llvm/Support/FileSystem.h"
  14 #include "llvm/Support/Path.h"
  15 #include "llvm/Support/WithColor.h"
  16
  17 #ifdef __APPLE__
  18 #include <CoreFoundation/CoreFoundation.h>
  19 #include <uuid/uuid.h>
  20 #endif
  21
  22 namespace llvm {
  23 namespace dsymutil {
  24
  25 StringRef SymbolMapTranslator::operator()(StringRef Input) {
  26   if (!Input.startswith("__hidden#") && !Input.startswith("___hidden#"))
  27     return Input;
  28
  29   bool MightNeedUnderscore = false;
  30   StringRef Line = Input.drop_front(sizeof("__hidden#") - 1);
  31   if (Line[0] == '#') {
  32     Line = Line.drop_front();
  33     MightNeedUnderscore = true;
  34   }
  35
  36   std::size_t LineNumber = std::numeric_limits<std::size_t>::max();
  37   Line.split('_').first.getAsInteger(10, LineNumber);
  38   if (LineNumber >= UnobfuscatedStrings.size()) {
  39     WithColor::warning() << "reference to a unexisting unobfuscated string "
  40                          << Input << ": symbol map mismatch?\n"
  41                          << Line << '\n';
  42     return Input;
  43   }
  44
  45   const std::string &Translation = UnobfuscatedStrings[LineNumber];
  46   if (!MightNeedUnderscore || !MangleNames)
  47     return Translation;
  48
  49   // Objective-C symbols for the MachO symbol table start with a \1. Please see
  50   // `MangleContext::mangleObjCMethodName` in clang.
  51   if (Translation[0] == 1)
  52     return StringRef(Translation).drop_front();
  53
  54   // We need permanent storage for the string we are about to create. Just
  55   // append it to the vector containing translations. This should only happen
  56   // during MachO symbol table translation, thus there should be no risk on
  57   // exponential growth.
  58   UnobfuscatedStrings.emplace_back("_" + Translation);
  59   return UnobfuscatedStrings.back();
  60 }
  61
  62 SymbolMapTranslator SymbolMapLoader::Load(StringRef InputFile,
  63                                           const DebugMap &Map) const {
  64   if (SymbolMap.empty())
  65     return {};
  66
  67   std::string SymbolMapPath = SymbolMap;
  68
  69 #if __APPLE__
  70   // Look through the UUID Map.
  71   if (sys::fs::is_directory(SymbolMapPath) && !Map.getUUID().empty()) {
  72     uuid_string_t UUIDString;
  73     uuid_unparse_upper((const uint8_t *)Map.getUUID().data(), UUIDString);
  74
  75     SmallString<256> PlistPath(
  76         sys::path::parent_path(sys::path::parent_path(InputFile)));
  77     sys::path::append(PlistPath, StringRef(UUIDString).str() + ".plist");
  78
  79     CFStringRef plistFile = CFStringCreateWithCString(
  80         kCFAllocatorDefault, PlistPath.c_str(), kCFStringEncodingUTF8);
  81     CFURLRef fileURL = CFURLCreateWithFileSystemPath(
  82         kCFAllocatorDefault, plistFile, kCFURLPOSIXPathStyle, false);
  83     CFReadStreamRef resourceData =
  84         CFReadStreamCreateWithFile(kCFAllocatorDefault, fileURL);
  85     if (resourceData) {
  86       CFReadStreamOpen(resourceData);
  87       CFDictionaryRef plist = (CFDictionaryRef)CFPropertyListCreateWithStream(
  88           kCFAllocatorDefault, resourceData, 0, kCFPropertyListImmutable,
  89           nullptr, nullptr);
  90
  91       if (plist) {
  92         if (CFDictionaryContainsKey(plist, CFSTR("DBGOriginalUUID"))) {
  93           CFStringRef OldUUID = (CFStringRef)CFDictionaryGetValue(
  94               plist, CFSTR("DBGOriginalUUID"));
  95
  96           StringRef UUID(CFStringGetCStringPtr(OldUUID, kCFStringEncodingUTF8));
  97           SmallString<256> BCSymbolMapPath(SymbolMapPath);
  98           sys::path::append(BCSymbolMapPath, UUID.str() + ".bcsymbolmap");
  99           SymbolMapPath = std::string(BCSymbolMapPath);
 100         }
 101         CFRelease(plist);
 102       }
 103       CFReadStreamClose(resourceData);
 104       CFRelease(resourceData);
 105     }
 106     CFRelease(fileURL);
 107     CFRelease(plistFile);
 108   }
 109 #endif
 110
 111   if (sys::fs::is_directory(SymbolMapPath)) {
 112     SymbolMapPath += (Twine("/") + sys::path::filename(InputFile) + "-" +
 113                       MachOUtils::getArchName(Map.getTriple().getArchName()) +
 114                       ".bcsymbolmap")
 115                          .str();
 116   }
 117
 118   auto ErrOrMemBuffer = MemoryBuffer::getFile(SymbolMapPath);
 119   if (auto EC = ErrOrMemBuffer.getError()) {
 120     WithColor::warning() << SymbolMapPath << ": " << EC.message()
 121                          << ": not unobfuscating.\n";
 122     return {};
 123   }
 124
 125   std::vector<std::string> UnobfuscatedStrings;
 126   auto &MemBuf = **ErrOrMemBuffer;
 127   StringRef Data(MemBuf.getBufferStart(),
 128                  MemBuf.getBufferEnd() - MemBuf.getBufferStart());
 129   StringRef LHS;
 130   std::tie(LHS, Data) = Data.split('\n');
 131   bool MangleNames = false;
 132
 133   // Check version string first.
 134   if (!LHS.startswith("BCSymbolMap Version:")) {
 135     // Version string not present, warns but try to parse it.
 136     WithColor::warning() << SymbolMapPath
 137                          << " is missing version string: assuming 1.0.\n";
 138     UnobfuscatedStrings.emplace_back(LHS);
 139   } else if (LHS.equals("BCSymbolMap Version: 1.0")) {
 140     MangleNames = true;
 141   } else if (LHS.equals("BCSymbolMap Version: 2.0")) {
 142     MangleNames = false;
 143   } else {
 144     StringRef VersionNum;
 145     std::tie(LHS, VersionNum) = LHS.split(':');
 146     WithColor::warning() << SymbolMapPath
 147                          << " has unsupported symbol map version" << VersionNum
 148                          << ": not unobfuscating.\n";
 149     return {};
 150   }
 151
 152   while (!Data.empty()) {
 153     std::tie(LHS, Data) = Data.split('\n');
 154     UnobfuscatedStrings.emplace_back(LHS);
 155   }
 156
 157   return SymbolMapTranslator(std::move(UnobfuscatedStrings), MangleNames);
 158 }
 159
 160 } // namespace dsymutil
 161 } // namespace llvm