tools/dsymutil/dsymutil.cpp

   1 //===-- dsymutil.cpp - Debug info dumping utility for llvm ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This program is a utility that aims to be a dropin replacement for
  11 // Darwin's dsymutil.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "DebugMap.h"
  16 #include "MachOUtils.h"
  17 #include "dsymutil.h"
  18 #include "llvm/Object/MachO.h"
  19 #include "llvm/Support/FileSystem.h"
  20 #include "llvm/Support/FileUtilities.h"
  21 #include "llvm/Support/ManagedStatic.h"
  22 #include "llvm/Support/Options.h"
  23 #include "llvm/Support/PrettyStackTrace.h"
  24 #include "llvm/Support/Signals.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 #include "llvm/Support/TargetSelect.h"
  27 #include <cstdint>
  28 #include <string>
  29
  30 using namespace llvm::dsymutil;
  31
  32 namespace {
  33 using namespace llvm::cl;
  34
  35 OptionCategory DsymCategory("Specific Options");
  36 static opt<bool> Help("h", desc("Alias for -help"), Hidden);
  37 static opt<bool> Version("v", desc("Alias for -version"), Hidden);
  38
  39 static list<std::string> InputFiles(Positional, OneOrMore,
  40                                     desc("<input files>"), cat(DsymCategory));
  41
  42 static opt<std::string>
  43     OutputFileOpt("o",
  44                   desc("Specify the output file. default: <input file>.dwarf"),
  45                   value_desc("filename"), cat(DsymCategory));
  46
  47 static opt<std::string> OsoPrependPath(
  48     "oso-prepend-path",
  49     desc("Specify a directory to prepend to the paths of object files."),
  50     value_desc("path"), cat(DsymCategory));
  51
  52 static opt<bool> DumpStab(
  53     "symtab",
  54     desc("Dumps the symbol table found in executable or object file(s) and\n"
  55          "exits."),
  56     init(false), cat(DsymCategory));
  57 static alias DumpStabA("s", desc("Alias for --symtab"), aliasopt(DumpStab));
  58
  59 static opt<bool> FlatOut("flat",
  60                          desc("Produce a flat dSYM file (not a bundle)."),
  61                          init(false), cat(DsymCategory));
  62 static alias FlatOutA("f", desc("Alias for --flat"), aliasopt(FlatOut));
  63
  64 static opt<bool> Verbose("verbose", desc("Verbosity level"), init(false),
  65                          cat(DsymCategory));
  66
  67 static opt<bool>
  68     NoOutput("no-output",
  69              desc("Do the link in memory, but do not emit the result file."),
  70              init(false), cat(DsymCategory));
  71
  72 static list<std::string> ArchFlags(
  73     "arch",
  74     desc("Link DWARF debug information only for specified CPU architecture\n"
  75          "types. This option can be specified multiple times, once for each\n"
  76          "desired architecture.  All cpu architectures will be linked by\n"
  77          "default."),
  78     ZeroOrMore, cat(DsymCategory));
  79
  80 static opt<bool>
  81     NoODR("no-odr",
  82           desc("Do not use ODR (One Definition Rule) for type uniquing."),
  83           init(false), cat(DsymCategory));
  84
  85 static opt<bool> DumpDebugMap(
  86     "dump-debug-map",
  87     desc("Parse and dump the debug map to standard output. Not DWARF link "
  88          "will take place."),
  89     init(false), cat(DsymCategory));
  90
  91 static opt<bool> InputIsYAMLDebugMap(
  92     "y", desc("Treat the input file is a YAML debug map rather than a binary."),
  93     init(false), cat(DsymCategory));
  94 }
  95
  96 static bool createPlistFile(llvm::StringRef BundleRoot) {
  97   if (NoOutput)
  98     return true;
  99
 100   // Create plist file to write to.
 101   llvm::SmallString<128> InfoPlist(BundleRoot);
 102   llvm::sys::path::append(InfoPlist, "Contents/Info.plist");
 103   std::error_code EC;
 104   llvm::raw_fd_ostream PL(InfoPlist, EC, llvm::sys::fs::F_Text);
 105   if (EC) {
 106     llvm::errs() << "error: cannot create plist file " << InfoPlist << ": "
 107                  << EC.message() << '\n';
 108     return false;
 109   }
 110
 111   // FIXME: Use CoreFoundation to get executable bundle info. Use
 112   // dummy values for now.
 113   std::string bundleVersionStr = "1", bundleShortVersionStr = "1.0",
 114               bundleIDStr;
 115
 116   llvm::StringRef BundleID = *llvm::sys::path::rbegin(BundleRoot);
 117   if (llvm::sys::path::extension(BundleRoot) == ".dSYM")
 118     bundleIDStr = llvm::sys::path::stem(BundleID);
 119   else
 120     bundleIDStr = BundleID;
 121
 122   // Print out information to the plist file.
 123   PL << "<?xml version=\"1.0\" encoding=\"UTF-8\"\?>\n"
 124      << "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" "
 125      << "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
 126      << "<plist version=\"1.0\">\n"
 127      << "\t<dict>\n"
 128      << "\t\t<key>CFBundleDevelopmentRegion</key>\n"
 129      << "\t\t<string>English</string>\n"
 130      << "\t\t<key>CFBundleIdentifier</key>\n"
 131      << "\t\t<string>com.apple.xcode.dsym." << bundleIDStr << "</string>\n"
 132      << "\t\t<key>CFBundleInfoDictionaryVersion</key>\n"
 133      << "\t\t<string>6.0</string>\n"
 134      << "\t\t<key>CFBundlePackageType</key>\n"
 135      << "\t\t<string>dSYM</string>\n"
 136      << "\t\t<key>CFBundleSignature</key>\n"
 137      << "\t\t<string>\?\?\?\?</string>\n"
 138      << "\t\t<key>CFBundleShortVersionString</key>\n"
 139      << "\t\t<string>" << bundleShortVersionStr << "</string>\n"
 140      << "\t\t<key>CFBundleVersion</key>\n"
 141      << "\t\t<string>" << bundleVersionStr << "</string>\n"
 142      << "\t</dict>\n"
 143      << "</plist>\n";
 144
 145   PL.close();
 146   return true;
 147 }
 148
 149 static bool createBundleDir(llvm::StringRef BundleBase) {
 150   if (NoOutput)
 151     return true;
 152
 153   llvm::SmallString<128> Bundle(BundleBase);
 154   llvm::sys::path::append(Bundle, "Contents", "Resources", "DWARF");
 155   if (std::error_code EC = create_directories(Bundle.str(), true,
 156                                               llvm::sys::fs::perms::all_all)) {
 157     llvm::errs() << "error: cannot create directory " << Bundle << ": "
 158                  << EC.message() << "\n";
 159     return false;
 160   }
 161   return true;
 162 }
 163
 164 static std::error_code getUniqueFile(const llvm::Twine &Model, int &ResultFD,
 165                                      llvm::SmallVectorImpl<char> &ResultPath) {
 166   // If in NoOutput mode, use the createUniqueFile variant that
 167   // doesn't open the file but still generates a somewhat unique
 168   // name. In the real usage scenario, we'll want to ensure that the
 169   // file is trully unique, and creating it is the only way to achieve
 170   // that.
 171   if (NoOutput)
 172     return llvm::sys::fs::createUniqueFile(Model, ResultPath);
 173   return llvm::sys::fs::createUniqueFile(Model, ResultFD, ResultPath);
 174 }
 175
 176 static std::string getOutputFileName(llvm::StringRef InputFile,
 177                                      bool TempFile = false) {
 178   if (TempFile) {
 179     llvm::StringRef Basename =
 180         OutputFileOpt.empty() ? InputFile : llvm::StringRef(OutputFileOpt);
 181     llvm::Twine OutputFile = Basename + ".tmp%%%%%%.dwarf";
 182     int FD;
 183     llvm::SmallString<128> UniqueFile;
 184     if (auto EC = getUniqueFile(OutputFile, FD, UniqueFile)) {
 185       llvm::errs() << "error: failed to create temporary outfile '"
 186                    << OutputFile << "': " << EC.message() << '\n';
 187       return "";
 188     }
 189     llvm::sys::RemoveFileOnSignal(UniqueFile);
 190     if (!NoOutput) {
 191       // Close the file immediately. We know it is unique. It will be
 192       // reopened and written to later.
 193       llvm::raw_fd_ostream CloseImmediately(FD, true /* shouldClose */, true);
 194     }
 195     return UniqueFile.str();
 196   }
 197
 198   if (FlatOut) {
 199     // If a flat dSYM has been requested, things are pretty simple.
 200     if (OutputFileOpt.empty()) {
 201       if (InputFile == "-")
 202         return "a.out.dwarf";
 203       return (InputFile + ".dwarf").str();
 204     }
 205
 206     return OutputFileOpt;
 207   }
 208
 209   // We need to create/update a dSYM bundle.
 210   // A bundle hierarchy looks like this:
 211   //   <bundle name>.dSYM/
 212   //       Contents/
 213   //          Info.plist
 214   //          Resources/
 215   //             DWARF/
 216   //                <DWARF file(s)>
 217   std::string DwarfFile =
 218       InputFile == "-" ? llvm::StringRef("a.out") : InputFile;
 219   llvm::SmallString<128> BundleDir(OutputFileOpt);
 220   if (BundleDir.empty())
 221     BundleDir = DwarfFile + ".dSYM";
 222   if (!createBundleDir(BundleDir) || !createPlistFile(BundleDir))
 223     return "";
 224
 225   llvm::sys::path::append(BundleDir, "Contents", "Resources", "DWARF",
 226                           llvm::sys::path::filename(DwarfFile));
 227   return BundleDir.str();
 228 }
 229
 230 void llvm::dsymutil::exitDsymutil(int ExitStatus) {
 231   // Cleanup temporary files.
 232   llvm::sys::RunInterruptHandlers();
 233   exit(ExitStatus);
 234 }
 235
 236 int main(int argc, char **argv) {
 237   llvm::sys::PrintStackTraceOnErrorSignal();
 238   llvm::PrettyStackTraceProgram StackPrinter(argc, argv);
 239   llvm::llvm_shutdown_obj Shutdown;
 240   LinkOptions Options;
 241   void *MainAddr = (void *)(intptr_t)&exitDsymutil;
 242   std::string SDKPath = llvm::sys::fs::getMainExecutable(argv[0], MainAddr);
 243   SDKPath = llvm::sys::path::parent_path(SDKPath);
 244
 245   HideUnrelatedOptions(DsymCategory);
 246   llvm::cl::ParseCommandLineOptions(
 247       argc, argv,
 248       "manipulate archived DWARF debug symbol files.\n\n"
 249       "dsymutil links the DWARF debug information found in the object files\n"
 250       "for the executable <input file> by using debug symbols information\n"
 251       "contained in its symbol table.\n");
 252
 253   if (Help)
 254     PrintHelpMessage();
 255
 256   if (Version) {
 257     llvm::cl::PrintVersionMessage();
 258     return 0;
 259   }
 260
 261   Options.Verbose = Verbose;
 262   Options.NoOutput = NoOutput;
 263   Options.NoODR = NoODR;
 264   Options.PrependPath = OsoPrependPath;
 265
 266   llvm::InitializeAllTargetInfos();
 267   llvm::InitializeAllTargetMCs();
 268   llvm::InitializeAllTargets();
 269   llvm::InitializeAllAsmPrinters();
 270
 271   if (!FlatOut && OutputFileOpt == "-") {
 272     llvm::errs() << "error: cannot emit to standard output without --flat\n";
 273     return 1;
 274   }
 275
 276   if (InputFiles.size() > 1 && FlatOut && !OutputFileOpt.empty()) {
 277     llvm::errs() << "error: cannot use -o with multiple inputs in flat mode\n";
 278     return 1;
 279   }
 280
 281   for (const auto &Arch : ArchFlags)
 282     if (Arch != "*" && Arch != "all" &&
 283         !llvm::object::MachOObjectFile::isValidArch(Arch)) {
 284       llvm::errs() << "error: Unsupported cpu architecture: '" << Arch << "'\n";
 285       exitDsymutil(1);
 286     }
 287
 288   for (auto &InputFile : InputFiles) {
 289     // Dump the symbol table for each input file and requested arch
 290     if (DumpStab) {
 291       if (!dumpStab(InputFile, ArchFlags, OsoPrependPath))
 292         exitDsymutil(1);
 293       continue;
 294     }
 295
 296     auto DebugMapPtrsOrErr = parseDebugMap(InputFile, ArchFlags, OsoPrependPath,
 297                                            Verbose, InputIsYAMLDebugMap);
 298
 299     if (auto EC = DebugMapPtrsOrErr.getError()) {
 300       llvm::errs() << "error: cannot parse the debug map for \"" << InputFile
 301                    << "\": " << EC.message() << '\n';
 302       exitDsymutil(1);
 303     }
 304
 305     if (DebugMapPtrsOrErr->empty()) {
 306       llvm::errs() << "error: no architecture to link\n";
 307       exitDsymutil(1);
 308     }
 309
 310     // If there is more than one link to execute, we need to generate
 311     // temporary files.
 312     bool NeedsTempFiles = !DumpDebugMap && (*DebugMapPtrsOrErr).size() != 1;
 313     llvm::SmallVector<MachOUtils::ArchAndFilename, 4> TempFiles;
 314     for (auto &Map : *DebugMapPtrsOrErr) {
 315       if (Verbose || DumpDebugMap)
 316         Map->print(llvm::outs());
 317
 318       if (DumpDebugMap)
 319         continue;
 320
 321       if (Map->begin() == Map->end())
 322         llvm::errs() << "warning: no debug symbols in executable (-arch "
 323                      << MachOUtils::getArchName(Map->getTriple().getArchName())
 324                      << ")\n";
 325
 326       std::string OutputFile = getOutputFileName(InputFile, NeedsTempFiles);
 327       if (OutputFile.empty() || !linkDwarf(OutputFile, *Map, Options))
 328         exitDsymutil(1);
 329
 330       if (NeedsTempFiles)
 331         TempFiles.emplace_back(Map->getTriple().getArchName().str(),
 332                                OutputFile);
 333     }
 334
 335     if (NeedsTempFiles &&
 336         !MachOUtils::generateUniversalBinary(
 337             TempFiles, getOutputFileName(InputFile), Options, SDKPath))
 338       exitDsymutil(1);
 339   }
 340
 341   exitDsymutil(0);
 342 }