tools/llvm-ifs/llvm-ifs.cpp

   1 //===- llvm-ifs.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 "llvm/ADT/StringRef.h"
  10 #include "llvm/ADT/StringSwitch.h"
  11 #include "llvm/ADT/Triple.h"
  12 #include "llvm/ObjectYAML/yaml2obj.h"
  13 #include "llvm/Support/CommandLine.h"
  14 #include "llvm/Support/Debug.h"
  15 #include "llvm/Support/Errc.h"
  16 #include "llvm/Support/Error.h"
  17 #include "llvm/Support/FileOutputBuffer.h"
  18 #include "llvm/Support/MemoryBuffer.h"
  19 #include "llvm/Support/Path.h"
  20 #include "llvm/Support/VersionTuple.h"
  21 #include "llvm/Support/WithColor.h"
  22 #include "llvm/Support/YAMLTraits.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include "llvm/TextAPI/MachO/InterfaceFile.h"
  25 #include "llvm/TextAPI/MachO/TextAPIReader.h"
  26 #include "llvm/TextAPI/MachO/TextAPIWriter.h"
  27 #include <set>
  28 #include <string>
  29
  30 using namespace llvm;
  31 using namespace llvm::yaml;
  32 using namespace llvm::MachO;
  33
  34 #define DEBUG_TYPE "llvm-ifs"
  35
  36 namespace {
  37 const VersionTuple IFSVersionCurrent(1, 2);
  38 }
  39
  40 static cl::opt<std::string> Action("action", cl::desc("<llvm-ifs action>"),
  41                                    cl::value_desc("write-ifs | write-bin"),
  42                                    cl::init("write-ifs"));
  43
  44 static cl::opt<std::string> ForceFormat("force-format",
  45                                         cl::desc("<force object format>"),
  46                                         cl::value_desc("ELF | TBD"),
  47                                         cl::init(""));
  48
  49 static cl::list<std::string> InputFilenames(cl::Positional,
  50                                             cl::desc("<input ifs files>"),
  51                                             cl::ZeroOrMore);
  52
  53 static cl::opt<std::string> OutputFilename("o", cl::desc("<output file>"),
  54                                            cl::value_desc("path"));
  55
  56 enum class IFSSymbolType {
  57   NoType = 0,
  58   Object,
  59   Func,
  60   // Type information is 4 bits, so 16 is safely out of range.
  61   Unknown = 16,
  62 };
  63
  64 std::string getTypeName(IFSSymbolType Type) {
  65   switch (Type) {
  66   case IFSSymbolType::NoType:
  67     return "NoType";
  68   case IFSSymbolType::Func:
  69     return "Func";
  70   case IFSSymbolType::Object:
  71     return "Object";
  72   case IFSSymbolType::Unknown:
  73     return "Unknown";
  74   }
  75   llvm_unreachable("Unexpected ifs symbol type.");
  76 }
  77
  78 struct IFSSymbol {
  79   IFSSymbol(std::string SymbolName) : Name(SymbolName) {}
  80   std::string Name;
  81   uint64_t Size;
  82   IFSSymbolType Type;
  83   bool Weak;
  84   Optional<std::string> Warning;
  85   bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; }
  86 };
  87
  88 namespace llvm {
  89 namespace yaml {
  90 /// YAML traits for IFSSymbolType.
  91 template <> struct ScalarEnumerationTraits<IFSSymbolType> {
  92   static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
  93     IO.enumCase(SymbolType, "NoType", IFSSymbolType::NoType);
  94     IO.enumCase(SymbolType, "Func", IFSSymbolType::Func);
  95     IO.enumCase(SymbolType, "Object", IFSSymbolType::Object);
  96     IO.enumCase(SymbolType, "Unknown", IFSSymbolType::Unknown);
  97     // Treat other symbol types as noise, and map to Unknown.
  98     if (!IO.outputting() && IO.matchEnumFallback())
  99       SymbolType = IFSSymbolType::Unknown;
 100   }
 101 };
 102
 103 template <> struct ScalarTraits<VersionTuple> {
 104   static void output(const VersionTuple &Value, void *,
 105                      llvm::raw_ostream &Out) {
 106     Out << Value.getAsString();
 107   }
 108
 109   static StringRef input(StringRef Scalar, void *, VersionTuple &Value) {
 110     if (Value.tryParse(Scalar))
 111       return StringRef("Can't parse version: invalid version format.");
 112
 113     if (Value > IFSVersionCurrent)
 114       return StringRef("Unsupported IFS version.");
 115
 116     // Returning empty StringRef indicates successful parse.
 117     return StringRef();
 118   }
 119
 120   // Don't place quotation marks around version value.
 121   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 122 };
 123
 124 /// YAML traits for IFSSymbol.
 125 template <> struct MappingTraits<IFSSymbol> {
 126   static void mapping(IO &IO, IFSSymbol &Symbol) {
 127     IO.mapRequired("Type", Symbol.Type);
 128     // The need for symbol size depends on the symbol type.
 129     if (Symbol.Type == IFSSymbolType::NoType)
 130       IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
 131     else if (Symbol.Type == IFSSymbolType::Func)
 132       Symbol.Size = 0;
 133     else
 134       IO.mapRequired("Size", Symbol.Size);
 135     IO.mapOptional("Weak", Symbol.Weak, false);
 136     IO.mapOptional("Warning", Symbol.Warning);
 137   }
 138
 139   // Compacts symbol information into a single line.
 140   static const bool flow = true;
 141 };
 142
 143 /// YAML traits for set of IFSSymbols.
 144 template <> struct CustomMappingTraits<std::set<IFSSymbol>> {
 145   static void inputOne(IO &IO, StringRef Key, std::set<IFSSymbol> &Set) {
 146     std::string Name = Key.str();
 147     IFSSymbol Sym(Name);
 148     IO.mapRequired(Name.c_str(), Sym);
 149     Set.insert(Sym);
 150   }
 151
 152   static void output(IO &IO, std::set<IFSSymbol> &Set) {
 153     for (auto &Sym : Set)
 154       IO.mapRequired(Sym.Name.c_str(), const_cast<IFSSymbol &>(Sym));
 155   }
 156 };
 157 } // End yaml namespace
 158 } // End llvm namespace
 159
 160 // A cumulative representation of ELF stubs.
 161 // Both textual and binary stubs will read into and write from this object.
 162 class IFSStub {
 163   // TODO: Add support for symbol versioning.
 164 public:
 165   VersionTuple IfsVersion;
 166   std::string Triple;
 167   std::string ObjectFileFormat;
 168   Optional<std::string> SOName;
 169   std::vector<std::string> NeededLibs;
 170   std::set<IFSSymbol> Symbols;
 171
 172   IFSStub() = default;
 173   IFSStub(const IFSStub &Stub)
 174       : IfsVersion(Stub.IfsVersion), Triple(Stub.Triple),
 175         ObjectFileFormat(Stub.ObjectFileFormat), SOName(Stub.SOName),
 176         NeededLibs(Stub.NeededLibs), Symbols(Stub.Symbols) {}
 177   IFSStub(IFSStub &&Stub)
 178       : IfsVersion(std::move(Stub.IfsVersion)), Triple(std::move(Stub.Triple)),
 179         ObjectFileFormat(std::move(Stub.ObjectFileFormat)),
 180         SOName(std::move(Stub.SOName)), NeededLibs(std::move(Stub.NeededLibs)),
 181         Symbols(std::move(Stub.Symbols)) {}
 182 };
 183
 184 namespace llvm {
 185 namespace yaml {
 186 /// YAML traits for IFSStub objects.
 187 template <> struct MappingTraits<IFSStub> {
 188   static void mapping(IO &IO, IFSStub &Stub) {
 189     if (!IO.mapTag("!experimental-ifs-v1", true))
 190       IO.setError("Not a .ifs YAML file.");
 191     IO.mapRequired("IfsVersion", Stub.IfsVersion);
 192     IO.mapOptional("Triple", Stub.Triple);
 193     IO.mapOptional("ObjectFileFormat", Stub.ObjectFileFormat);
 194     IO.mapOptional("SOName", Stub.SOName);
 195     IO.mapOptional("NeededLibs", Stub.NeededLibs);
 196     IO.mapRequired("Symbols", Stub.Symbols);
 197   }
 198 };
 199 } // End yaml namespace
 200 } // End llvm namespace
 201
 202 static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
 203   // Read in file.
 204   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
 205       MemoryBuffer::getFileOrSTDIN(FilePath);
 206   if (!BufOrError)
 207     return createStringError(BufOrError.getError(), "Could not open `%s`",
 208                              FilePath.data());
 209
 210   std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
 211   yaml::Input YamlIn(FileReadBuffer->getBuffer());
 212   std::unique_ptr<IFSStub> Stub(new IFSStub());
 213   YamlIn >> *Stub;
 214
 215   if (std::error_code Err = YamlIn.error())
 216     return createStringError(Err, "Failed reading Interface Stub File.");
 217
 218   return std::move(Stub);
 219 }
 220
 221 int writeTbdStub(const llvm::Triple &T, const std::set<IFSSymbol> &Symbols,
 222                  const StringRef Format, raw_ostream &Out) {
 223   auto ArchOrError =
 224       [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::Architecture> {
 225     switch (T.getArch()) {
 226     default:
 227       return createStringError(errc::not_supported, "Invalid Architecture.");
 228     case llvm::Triple::ArchType::x86:
 229       return AK_i386;
 230     case llvm::Triple::ArchType::x86_64:
 231       return AK_x86_64;
 232     case llvm::Triple::ArchType::arm:
 233       return AK_armv7;
 234     case llvm::Triple::ArchType::aarch64:
 235       return AK_arm64;
 236     }
 237   }(T);
 238
 239   if (!ArchOrError)
 240     return -1;
 241
 242   Architecture Arch = ArchOrError.get();
 243
 244   InterfaceFile File;
 245   File.setFileType(FileType::TBD_V3);
 246   File.setArchitectures(Arch);
 247   File.setPlatform(PlatformKind::macOS);
 248
 249   for (const auto &Symbol : Symbols) {
 250     auto Name = Symbol.Name;
 251     auto Kind = SymbolKind::GlobalSymbol;
 252     switch (Symbol.Type) {
 253     default:
 254     case IFSSymbolType::NoType:
 255       Kind = SymbolKind::GlobalSymbol;
 256       break;
 257     case IFSSymbolType::Object:
 258       Kind = SymbolKind::GlobalSymbol;
 259       break;
 260     case IFSSymbolType::Func:
 261       Kind = SymbolKind::GlobalSymbol;
 262       break;
 263     }
 264     if (Symbol.Weak)
 265       File.addSymbol(Kind, Name, Arch, SymbolFlags::WeakDefined);
 266     else
 267       File.addSymbol(Kind, Name, Arch);
 268   }
 269
 270   SmallString<4096> Buffer;
 271   raw_svector_ostream OS(Buffer);
 272   if (Error Result = TextAPIWriter::writeToStream(OS, File))
 273     return -1;
 274   Out << OS.str();
 275   return 0;
 276 }
 277
 278 int writeElfStub(const llvm::Triple &T, const std::set<IFSSymbol> &Symbols,
 279                  const StringRef Format, raw_ostream &Out) {
 280   SmallString<0> Storage;
 281   Storage.clear();
 282   raw_svector_ostream OS(Storage);
 283
 284   OS << "--- !ELF\n";
 285   OS << "FileHeader:\n";
 286   OS << "  Class:           ELFCLASS";
 287   OS << (T.isArch64Bit() ? "64" : "32");
 288   OS << "\n";
 289   OS << "  Data:            ELFDATA2";
 290   OS << (T.isLittleEndian() ? "LSB" : "MSB");
 291   OS << "\n";
 292   OS << "  Type:            ET_DYN\n";
 293   OS << "  Machine:         "
 294      << llvm::StringSwitch<llvm::StringRef>(T.getArchName())
 295             .Case("x86_64", "EM_X86_64")
 296             .Case("i386", "EM_386")
 297             .Case("i686", "EM_386")
 298             .Case("aarch64", "EM_AARCH64")
 299             .Case("amdgcn", "EM_AMDGPU")
 300             .Case("r600", "EM_AMDGPU")
 301             .Case("arm", "EM_ARM")
 302             .Case("thumb", "EM_ARM")
 303             .Case("avr", "EM_AVR")
 304             .Case("mips", "EM_MIPS")
 305             .Case("mipsel", "EM_MIPS")
 306             .Case("mips64", "EM_MIPS")
 307             .Case("mips64el", "EM_MIPS")
 308             .Case("msp430", "EM_MSP430")
 309             .Case("ppc", "EM_PPC")
 310             .Case("ppc64", "EM_PPC64")
 311             .Case("ppc64le", "EM_PPC64")
 312             .Case("x86", T.isOSIAMCU() ? "EM_IAMCU" : "EM_386")
 313             .Case("x86_64", "EM_X86_64")
 314             .Default("EM_NONE")
 315      << "\nSections:"
 316      << "\n  - Name:            .text"
 317      << "\n    Type:            SHT_PROGBITS"
 318      << "\n  - Name:            .data"
 319      << "\n    Type:            SHT_PROGBITS"
 320      << "\n  - Name:            .rodata"
 321      << "\n    Type:            SHT_PROGBITS"
 322      << "\nSymbols:\n";
 323   for (const auto &Symbol : Symbols) {
 324     OS << "  - Name:            " << Symbol.Name << "\n"
 325        << "    Type:            STT_";
 326     switch (Symbol.Type) {
 327     default:
 328     case IFSSymbolType::NoType:
 329       OS << "NOTYPE";
 330       break;
 331     case IFSSymbolType::Object:
 332       OS << "OBJECT";
 333       break;
 334     case IFSSymbolType::Func:
 335       OS << "FUNC";
 336       break;
 337     }
 338     OS << "\n    Section:         .text"
 339        << "\n    Binding:         STB_" << (Symbol.Weak ? "WEAK" : "GLOBAL")
 340        << "\n";
 341   }
 342   OS << "...\n";
 343
 344   std::string YamlStr = OS.str();
 345
 346   // Only or debugging. Not an offical format.
 347   LLVM_DEBUG({
 348     if (ForceFormat == "ELFOBJYAML") {
 349       Out << YamlStr;
 350       return 0;
 351     }
 352   });
 353
 354   yaml::Input YIn(YamlStr);
 355   if (Error E = convertYAML(YIn, Out)) {
 356     logAllUnhandledErrors(std::move(E), WithColor::error(errs(), "llvm-ifs"));
 357     return 1;
 358   }
 359
 360   return 0;
 361 }
 362
 363 int writeIfso(const IFSStub &Stub, bool IsWriteIfs, raw_ostream &Out) {
 364   if (IsWriteIfs) {
 365     yaml::Output YamlOut(Out, NULL, /*WrapColumn =*/0);
 366     YamlOut << const_cast<IFSStub &>(Stub);
 367     return 0;
 368   }
 369
 370   std::string ObjectFileFormat =
 371       ForceFormat.empty() ? Stub.ObjectFileFormat : ForceFormat;
 372
 373   if (ObjectFileFormat == "ELF" || ForceFormat == "ELFOBJYAML")
 374     return writeElfStub(llvm::Triple(Stub.Triple), Stub.Symbols,
 375                         Stub.ObjectFileFormat, Out);
 376   if (ObjectFileFormat == "TBD")
 377     return writeTbdStub(llvm::Triple(Stub.Triple), Stub.Symbols,
 378                         Stub.ObjectFileFormat, Out);
 379
 380   WithColor::error()
 381       << "Invalid ObjectFileFormat: Only ELF and TBD are supported.\n";
 382   return -1;
 383 }
 384
 385 // New Interface Stubs Yaml Format:
 386 // --- !experimental-ifs-v1
 387 // IfsVersion:      1.0
 388 // Triple:          <llvm triple>
 389 // ObjectFileFormat: <ELF | others not yet supported>
 390 // Symbols:
 391 //   _ZSymbolName: { Type: <type> }
 392 // ...
 393
 394 int main(int argc, char *argv[]) {
 395   // Parse arguments.
 396   cl::ParseCommandLineOptions(argc, argv);
 397
 398   if (InputFilenames.empty())
 399     InputFilenames.push_back("-");
 400
 401   IFSStub Stub;
 402   std::map<std::string, IFSSymbol> SymbolMap;
 403
 404   std::string PreviousInputFilePath = "";
 405   for (const std::string &InputFilePath : InputFilenames) {
 406     Expected<std::unique_ptr<IFSStub>> StubOrErr = readInputFile(InputFilePath);
 407     if (!StubOrErr) {
 408       WithColor::error() << StubOrErr.takeError() << "\n";
 409       return -1;
 410     }
 411     std::unique_ptr<IFSStub> TargetStub = std::move(StubOrErr.get());
 412
 413     if (Stub.Triple.empty()) {
 414       PreviousInputFilePath = InputFilePath;
 415       Stub.IfsVersion = TargetStub->IfsVersion;
 416       Stub.Triple = TargetStub->Triple;
 417       Stub.ObjectFileFormat = TargetStub->ObjectFileFormat;
 418       Stub.SOName = TargetStub->SOName;
 419       Stub.NeededLibs = TargetStub->NeededLibs;
 420     } else {
 421       if (Stub.IfsVersion != TargetStub->IfsVersion) {
 422         if (Stub.IfsVersion.getMajor() != IFSVersionCurrent.getMajor()) {
 423           WithColor::error()
 424               << "Interface Stub: IfsVersion Mismatch."
 425               << "\nFilenames: " << PreviousInputFilePath << " "
 426               << InputFilePath << "\nIfsVersion Values: " << Stub.IfsVersion
 427               << " " << TargetStub->IfsVersion << "\n";
 428           return -1;
 429         }
 430         if (TargetStub->IfsVersion > Stub.IfsVersion)
 431           Stub.IfsVersion = TargetStub->IfsVersion;
 432       }
 433       if (Stub.ObjectFileFormat != TargetStub->ObjectFileFormat) {
 434         WithColor::error() << "Interface Stub: ObjectFileFormat Mismatch."
 435                            << "\nFilenames: " << PreviousInputFilePath << " "
 436                            << InputFilePath << "\nObjectFileFormat Values: "
 437                            << Stub.ObjectFileFormat << " "
 438                            << TargetStub->ObjectFileFormat << "\n";
 439         return -1;
 440       }
 441       if (Stub.Triple != TargetStub->Triple) {
 442         WithColor::error() << "Interface Stub: Triple Mismatch."
 443                            << "\nFilenames: " << PreviousInputFilePath << " "
 444                            << InputFilePath
 445                            << "\nTriple Values: " << Stub.Triple << " "
 446                            << TargetStub->Triple << "\n";
 447         return -1;
 448       }
 449       if (Stub.SOName != TargetStub->SOName) {
 450         WithColor::error() << "Interface Stub: SOName Mismatch."
 451                            << "\nFilenames: " << PreviousInputFilePath << " "
 452                            << InputFilePath
 453                            << "\nSOName Values: " << Stub.SOName << " "
 454                            << TargetStub->SOName << "\n";
 455         return -1;
 456       }
 457       if (Stub.NeededLibs != TargetStub->NeededLibs) {
 458         WithColor::error() << "Interface Stub: NeededLibs Mismatch."
 459                            << "\nFilenames: " << PreviousInputFilePath << " "
 460                            << InputFilePath << "\n";
 461         return -1;
 462       }
 463     }
 464
 465     for (auto Symbol : TargetStub->Symbols) {
 466       auto SI = SymbolMap.find(Symbol.Name);
 467       if (SI == SymbolMap.end()) {
 468         SymbolMap.insert(
 469             std::pair<std::string, IFSSymbol>(Symbol.Name, Symbol));
 470         continue;
 471       }
 472
 473       assert(Symbol.Name == SI->second.Name && "Symbol Names Must Match.");
 474
 475       // Check conflicts:
 476       if (Symbol.Type != SI->second.Type) {
 477         WithColor::error() << "Interface Stub: Type Mismatch for "
 478                            << Symbol.Name << ".\nFilename: " << InputFilePath
 479                            << "\nType Values: " << getTypeName(SI->second.Type)
 480                            << " " << getTypeName(Symbol.Type) << "\n";
 481
 482         return -1;
 483       }
 484       if (Symbol.Size != SI->second.Size) {
 485         WithColor::error() << "Interface Stub: Size Mismatch for "
 486                            << Symbol.Name << ".\nFilename: " << InputFilePath
 487                            << "\nSize Values: " << SI->second.Size << " "
 488                            << Symbol.Size << "\n";
 489
 490         return -1;
 491       }
 492       if (Symbol.Weak != SI->second.Weak) {
 493         // TODO: Add conflict resolution for Weak vs non-Weak.
 494         WithColor::error() << "Interface Stub: Weak Mismatch for "
 495                            << Symbol.Name << ".\nFilename: " << InputFilePath
 496                            << "\nWeak Values: " << SI->second.Weak << " "
 497                            << Symbol.Weak << "\n";
 498
 499         return -1;
 500       }
 501       // TODO: Not checking Warning. Will be dropped.
 502     }
 503
 504     PreviousInputFilePath = InputFilePath;
 505   }
 506
 507   if (Stub.IfsVersion != IFSVersionCurrent)
 508     if (Stub.IfsVersion.getMajor() != IFSVersionCurrent.getMajor()) {
 509       WithColor::error() << "Interface Stub: Bad IfsVersion: "
 510                          << Stub.IfsVersion << ", llvm-ifs supported version: "
 511                          << IFSVersionCurrent << ".\n";
 512       return -1;
 513     }
 514
 515   for (auto &Entry : SymbolMap)
 516     Stub.Symbols.insert(Entry.second);
 517
 518   std::error_code SysErr;
 519
 520   // Open file for writing.
 521   raw_fd_ostream Out(OutputFilename, SysErr);
 522   if (SysErr) {
 523     WithColor::error() << "Couldn't open " << OutputFilename
 524                        << " for writing.\n";
 525     return -1;
 526   }
 527
 528   return writeIfso(Stub, (Action == "write-ifs"), Out);
 529 }