llvm/lib/MC/MCContext.cpp

   1 //===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===//
   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/MC/MCContext.h"
  10 #include "llvm/ADT/Optional.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/ADT/SmallVector.h"
  13 #include "llvm/ADT/StringMap.h"
  14 #include "llvm/ADT/StringRef.h"
  15 #include "llvm/ADT/Twine.h"
  16 #include "llvm/BinaryFormat/COFF.h"
  17 #include "llvm/BinaryFormat/ELF.h"
  18 #include "llvm/BinaryFormat/XCOFF.h"
  19 #include "llvm/MC/MCAsmInfo.h"
  20 #include "llvm/MC/MCCodeView.h"
  21 #include "llvm/MC/MCDwarf.h"
  22 #include "llvm/MC/MCExpr.h"
  23 #include "llvm/MC/MCFragment.h"
  24 #include "llvm/MC/MCLabel.h"
  25 #include "llvm/MC/MCObjectFileInfo.h"
  26 #include "llvm/MC/MCSectionCOFF.h"
  27 #include "llvm/MC/MCSectionELF.h"
  28 #include "llvm/MC/MCSectionGOFF.h"
  29 #include "llvm/MC/MCSectionMachO.h"
  30 #include "llvm/MC/MCSectionWasm.h"
  31 #include "llvm/MC/MCSectionXCOFF.h"
  32 #include "llvm/MC/MCStreamer.h"
  33 #include "llvm/MC/MCSymbol.h"
  34 #include "llvm/MC/MCSymbolCOFF.h"
  35 #include "llvm/MC/MCSymbolELF.h"
  36 #include "llvm/MC/MCSymbolGOFF.h"
  37 #include "llvm/MC/MCSymbolMachO.h"
  38 #include "llvm/MC/MCSymbolWasm.h"
  39 #include "llvm/MC/MCSymbolXCOFF.h"
  40 #include "llvm/MC/SectionKind.h"
  41 #include "llvm/Support/Casting.h"
  42 #include "llvm/Support/CommandLine.h"
  43 #include "llvm/Support/ErrorHandling.h"
  44 #include "llvm/Support/MemoryBuffer.h"
  45 #include "llvm/Support/Path.h"
  46 #include "llvm/Support/Signals.h"
  47 #include "llvm/Support/SourceMgr.h"
  48 #include "llvm/Support/raw_ostream.h"
  49 #include <cassert>
  50 #include <cstdlib>
  51 #include <tuple>
  52 #include <utility>
  53
  54 using namespace llvm;
  55
  56 static cl::opt<char*>
  57 AsSecureLogFileName("as-secure-log-file-name",
  58         cl::desc("As secure log file name (initialized from "
  59                  "AS_SECURE_LOG_FILE env variable)"),
  60         cl::init(getenv("AS_SECURE_LOG_FILE")), cl::Hidden);
  61
  62 static void defaultDiagHandler(const SMDiagnostic &SMD, bool, const SourceMgr &,
  63                                std::vector<const MDNode *> &) {
  64   SMD.print(nullptr, errs());
  65 }
  66
  67 MCContext::MCContext(const Triple &TheTriple, const MCAsmInfo *mai,
  68                      const MCRegisterInfo *mri, const MCSubtargetInfo *msti,
  69                      const SourceMgr *mgr, MCTargetOptions const *TargetOpts,
  70                      bool DoAutoReset)
  71     : TT(TheTriple), SrcMgr(mgr), InlineSrcMgr(nullptr),
  72       DiagHandler(defaultDiagHandler), MAI(mai), MRI(mri), MSTI(msti),
  73       Symbols(Allocator), UsedNames(Allocator),
  74       InlineAsmUsedLabelNames(Allocator),
  75       CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0),
  76       AutoReset(DoAutoReset), TargetOptions(TargetOpts) {
  77   SecureLogFile = AsSecureLogFileName;
  78
  79   if (SrcMgr && SrcMgr->getNumBuffers())
  80     MainFileName = std::string(SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())
  81                                    ->getBufferIdentifier());
  82
  83   switch (TheTriple.getObjectFormat()) {
  84   case Triple::MachO:
  85     Env = IsMachO;
  86     break;
  87   case Triple::COFF:
  88     if (!TheTriple.isOSWindows())
  89       report_fatal_error(
  90           "Cannot initialize MC for non-Windows COFF object files.");
  91
  92     Env = IsCOFF;
  93     break;
  94   case Triple::ELF:
  95     Env = IsELF;
  96     break;
  97   case Triple::Wasm:
  98     Env = IsWasm;
  99     break;
 100   case Triple::XCOFF:
 101     Env = IsXCOFF;
 102     break;
 103   case Triple::GOFF:
 104     Env = IsGOFF;
 105     break;
 106   case Triple::UnknownObjectFormat:
 107     report_fatal_error("Cannot initialize MC for unknown object file format.");
 108     break;
 109   }
 110 }
 111
 112 MCContext::~MCContext() {
 113   if (AutoReset)
 114     reset();
 115
 116   // NOTE: The symbols are all allocated out of a bump pointer allocator,
 117   // we don't need to free them here.
 118 }
 119
 120 void MCContext::initInlineSourceManager() {
 121   if (!InlineSrcMgr)
 122     InlineSrcMgr.reset(new SourceMgr());
 123 }
 124
 125 //===----------------------------------------------------------------------===//
 126 // Module Lifetime Management
 127 //===----------------------------------------------------------------------===//
 128
 129 void MCContext::reset() {
 130   SrcMgr = nullptr;
 131   InlineSrcMgr.reset();
 132   LocInfos.clear();
 133   DiagHandler = defaultDiagHandler;
 134
 135   // Call the destructors so the fragments are freed
 136   COFFAllocator.DestroyAll();
 137   ELFAllocator.DestroyAll();
 138   GOFFAllocator.DestroyAll();
 139   MachOAllocator.DestroyAll();
 140   XCOFFAllocator.DestroyAll();
 141   MCInstAllocator.DestroyAll();
 142
 143   MCSubtargetAllocator.DestroyAll();
 144   InlineAsmUsedLabelNames.clear();
 145   UsedNames.clear();
 146   Symbols.clear();
 147   Allocator.Reset();
 148   Instances.clear();
 149   CompilationDir.clear();
 150   MainFileName.clear();
 151   MCDwarfLineTablesCUMap.clear();
 152   SectionsForRanges.clear();
 153   MCGenDwarfLabelEntries.clear();
 154   DwarfDebugFlags = StringRef();
 155   DwarfCompileUnitID = 0;
 156   CurrentDwarfLoc = MCDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0);
 157
 158   CVContext.reset();
 159
 160   MachOUniquingMap.clear();
 161   ELFUniquingMap.clear();
 162   GOFFUniquingMap.clear();
 163   COFFUniquingMap.clear();
 164   WasmUniquingMap.clear();
 165   XCOFFUniquingMap.clear();
 166
 167   ELFEntrySizeMap.clear();
 168   ELFSeenGenericMergeableSections.clear();
 169
 170   NextID.clear();
 171   AllowTemporaryLabels = true;
 172   DwarfLocSeen = false;
 173   GenDwarfForAssembly = false;
 174   GenDwarfFileNumber = 0;
 175
 176   HadError = false;
 177 }
 178
 179 //===----------------------------------------------------------------------===//
 180 // MCInst Management
 181 //===----------------------------------------------------------------------===//
 182
 183 MCInst *MCContext::createMCInst() {
 184   return new (MCInstAllocator.Allocate()) MCInst;
 185 }
 186
 187 //===----------------------------------------------------------------------===//
 188 // Symbol Manipulation
 189 //===----------------------------------------------------------------------===//
 190
 191 MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) {
 192   SmallString<128> NameSV;
 193   StringRef NameRef = Name.toStringRef(NameSV);
 194
 195   assert(!NameRef.empty() && "Normal symbols cannot be unnamed!");
 196
 197   MCSymbol *&Sym = Symbols[NameRef];
 198   if (!Sym)
 199     Sym = createSymbol(NameRef, false, false);
 200
 201   return Sym;
 202 }
 203
 204 MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName,
 205                                                  unsigned Idx) {
 206   return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
 207                            "$frame_escape_" + Twine(Idx));
 208 }
 209
 210 MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) {
 211   return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
 212                            "$parent_frame_offset");
 213 }
 214
 215 MCSymbol *MCContext::getOrCreateLSDASymbol(StringRef FuncName) {
 216   return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + "__ehtable$" +
 217                            FuncName);
 218 }
 219
 220 MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
 221                                       bool IsTemporary) {
 222   static_assert(std::is_trivially_destructible<MCSymbolCOFF>(),
 223                 "MCSymbol classes must be trivially destructible");
 224   static_assert(std::is_trivially_destructible<MCSymbolELF>(),
 225                 "MCSymbol classes must be trivially destructible");
 226   static_assert(std::is_trivially_destructible<MCSymbolMachO>(),
 227                 "MCSymbol classes must be trivially destructible");
 228   static_assert(std::is_trivially_destructible<MCSymbolWasm>(),
 229                 "MCSymbol classes must be trivially destructible");
 230   static_assert(std::is_trivially_destructible<MCSymbolXCOFF>(),
 231                 "MCSymbol classes must be trivially destructible");
 232
 233   switch (getObjectFileType()) {
 234   case MCContext::IsCOFF:
 235     return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
 236   case MCContext::IsELF:
 237     return new (Name, *this) MCSymbolELF(Name, IsTemporary);
 238   case MCContext::IsGOFF:
 239     return new (Name, *this) MCSymbolGOFF(Name, IsTemporary);
 240   case MCContext::IsMachO:
 241     return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
 242   case MCContext::IsWasm:
 243     return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
 244   case MCContext::IsXCOFF:
 245     return createXCOFFSymbolImpl(Name, IsTemporary);
 246   }
 247   return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
 248                                     IsTemporary);
 249 }
 250
 251 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
 252                                   bool CanBeUnnamed) {
 253   if (CanBeUnnamed && !UseNamesOnTempLabels)
 254     return createSymbolImpl(nullptr, true);
 255
 256   // Determine whether this is a user written assembler temporary or normal
 257   // label, if used.
 258   bool IsTemporary = CanBeUnnamed;
 259   if (AllowTemporaryLabels && !IsTemporary)
 260     IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix());
 261
 262   SmallString<128> NewName = Name;
 263   bool AddSuffix = AlwaysAddSuffix;
 264   unsigned &NextUniqueID = NextID[Name];
 265   while (true) {
 266     if (AddSuffix) {
 267       NewName.resize(Name.size());
 268       raw_svector_ostream(NewName) << NextUniqueID++;
 269     }
 270     auto NameEntry = UsedNames.insert(std::make_pair(NewName.str(), true));
 271     if (NameEntry.second || !NameEntry.first->second) {
 272       // Ok, we found a name.
 273       // Mark it as used for a non-section symbol.
 274       NameEntry.first->second = true;
 275       // Have the MCSymbol object itself refer to the copy of the string that is
 276       // embedded in the UsedNames entry.
 277       return createSymbolImpl(&*NameEntry.first, IsTemporary);
 278     }
 279     assert(IsTemporary && "Cannot rename non-temporary symbols");
 280     AddSuffix = true;
 281   }
 282   llvm_unreachable("Infinite loop");
 283 }
 284
 285 MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix) {
 286   SmallString<128> NameSV;
 287   raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
 288   return createSymbol(NameSV, AlwaysAddSuffix, true);
 289 }
 290
 291 MCSymbol *MCContext::createNamedTempSymbol(const Twine &Name) {
 292   SmallString<128> NameSV;
 293   raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
 294   return createSymbol(NameSV, true, false);
 295 }
 296
 297 MCSymbol *MCContext::createLinkerPrivateTempSymbol() {
 298   SmallString<128> NameSV;
 299   raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp";
 300   return createSymbol(NameSV, true, false);
 301 }
 302
 303 MCSymbol *MCContext::createTempSymbol() { return createTempSymbol("tmp"); }
 304
 305 MCSymbol *MCContext::createNamedTempSymbol() {
 306   return createNamedTempSymbol("tmp");
 307 }
 308
 309 unsigned MCContext::NextInstance(unsigned LocalLabelVal) {
 310   MCLabel *&Label = Instances[LocalLabelVal];
 311   if (!Label)
 312     Label = new (*this) MCLabel(0);
 313   return Label->incInstance();
 314 }
 315
 316 unsigned MCContext::GetInstance(unsigned LocalLabelVal) {
 317   MCLabel *&Label = Instances[LocalLabelVal];
 318   if (!Label)
 319     Label = new (*this) MCLabel(0);
 320   return Label->getInstance();
 321 }
 322
 323 MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
 324                                                        unsigned Instance) {
 325   MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)];
 326   if (!Sym)
 327     Sym = createNamedTempSymbol();
 328   return Sym;
 329 }
 330
 331 MCSymbol *MCContext::createDirectionalLocalSymbol(unsigned LocalLabelVal) {
 332   unsigned Instance = NextInstance(LocalLabelVal);
 333   return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
 334 }
 335
 336 MCSymbol *MCContext::getDirectionalLocalSymbol(unsigned LocalLabelVal,
 337                                                bool Before) {
 338   unsigned Instance = GetInstance(LocalLabelVal);
 339   if (!Before)
 340     ++Instance;
 341   return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
 342 }
 343
 344 MCSymbol *MCContext::lookupSymbol(const Twine &Name) const {
 345   SmallString<128> NameSV;
 346   StringRef NameRef = Name.toStringRef(NameSV);
 347   return Symbols.lookup(NameRef);
 348 }
 349
 350 void MCContext::setSymbolValue(MCStreamer &Streamer,
 351                               StringRef Sym,
 352                               uint64_t Val) {
 353   auto Symbol = getOrCreateSymbol(Sym);
 354   Streamer.emitAssignment(Symbol, MCConstantExpr::create(Val, *this));
 355 }
 356
 357 void MCContext::registerInlineAsmLabel(MCSymbol *Sym) {
 358   InlineAsmUsedLabelNames[Sym->getName()] = Sym;
 359 }
 360
 361 MCSymbolXCOFF *
 362 MCContext::createXCOFFSymbolImpl(const StringMapEntry<bool> *Name,
 363                                  bool IsTemporary) {
 364   if (!Name)
 365     return new (nullptr, *this) MCSymbolXCOFF(nullptr, IsTemporary);
 366
 367   StringRef OriginalName = Name->first();
 368   if (OriginalName.startswith("._Renamed..") ||
 369       OriginalName.startswith("_Renamed.."))
 370     reportError(SMLoc(), "invalid symbol name from source");
 371
 372   if (MAI->isValidUnquotedName(OriginalName))
 373     return new (Name, *this) MCSymbolXCOFF(Name, IsTemporary);
 374
 375   // Now we have a name that contains invalid character(s) for XCOFF symbol.
 376   // Let's replace with something valid, but save the original name so that
 377   // we could still use the original name in the symbol table.
 378   SmallString<128> InvalidName(OriginalName);
 379
 380   // If it's an entry point symbol, we will keep the '.'
 381   // in front for the convention purpose. Otherwise, add "_Renamed.."
 382   // as prefix to signal this is an renamed symbol.
 383   const bool IsEntryPoint = !InvalidName.empty() && InvalidName[0] == '.';
 384   SmallString<128> ValidName =
 385       StringRef(IsEntryPoint ? "._Renamed.." : "_Renamed..");
 386
 387   // Append the hex values of '_' and invalid characters with "_Renamed..";
 388   // at the same time replace invalid characters with '_'.
 389   for (size_t I = 0; I < InvalidName.size(); ++I) {
 390     if (!MAI->isAcceptableChar(InvalidName[I]) || InvalidName[I] == '_') {
 391       raw_svector_ostream(ValidName).write_hex(InvalidName[I]);
 392       InvalidName[I] = '_';
 393     }
 394   }
 395
 396   // Skip entry point symbol's '.' as we already have a '.' in front of
 397   // "_Renamed".
 398   if (IsEntryPoint)
 399     ValidName.append(InvalidName.substr(1, InvalidName.size() - 1));
 400   else
 401     ValidName.append(InvalidName);
 402
 403   auto NameEntry = UsedNames.insert(std::make_pair(ValidName.str(), true));
 404   assert((NameEntry.second || !NameEntry.first->second) &&
 405          "This name is used somewhere else.");
 406   // Mark the name as used for a non-section symbol.
 407   NameEntry.first->second = true;
 408   // Have the MCSymbol object itself refer to the copy of the string
 409   // that is embedded in the UsedNames entry.
 410   MCSymbolXCOFF *XSym = new (&*NameEntry.first, *this)
 411       MCSymbolXCOFF(&*NameEntry.first, IsTemporary);
 412   XSym->setSymbolTableName(MCSymbolXCOFF::getUnqualifiedName(OriginalName));
 413   return XSym;
 414 }
 415
 416 //===----------------------------------------------------------------------===//
 417 // Section Management
 418 //===----------------------------------------------------------------------===//
 419
 420 MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section,
 421                                            unsigned TypeAndAttributes,
 422                                            unsigned Reserved2, SectionKind Kind,
 423                                            const char *BeginSymName) {
 424   // We unique sections by their segment/section pair.  The returned section
 425   // may not have the same flags as the requested section, if so this should be
 426   // diagnosed by the client as an error.
 427
 428   // Form the name to look up.
 429   assert(Section.size() <= 16 && "section name is too long");
 430   assert(!memchr(Section.data(), '\0', Section.size()) &&
 431          "section name cannot contain NUL");
 432
 433   // Do the lookup, if we have a hit, return it.
 434   auto R = MachOUniquingMap.try_emplace((Segment + Twine(',') + Section).str());
 435   if (!R.second)
 436     return R.first->second;
 437
 438   MCSymbol *Begin = nullptr;
 439   if (BeginSymName)
 440     Begin = createTempSymbol(BeginSymName, false);
 441
 442   // Otherwise, return a new section.
 443   StringRef Name = R.first->first();
 444   R.first->second = new (MachOAllocator.Allocate())
 445       MCSectionMachO(Segment, Name.substr(Name.size() - Section.size()),
 446                      TypeAndAttributes, Reserved2, Kind, Begin);
 447   return R.first->second;
 448 }
 449
 450 void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) {
 451   StringRef GroupName;
 452   if (const MCSymbol *Group = Section->getGroup())
 453     GroupName = Group->getName();
 454
 455   // This function is only used by .debug*, which should not have the
 456   // SHF_LINK_ORDER flag.
 457   unsigned UniqueID = Section->getUniqueID();
 458   ELFUniquingMap.erase(
 459       ELFSectionKey{Section->getName(), GroupName, "", UniqueID});
 460   auto I = ELFUniquingMap
 461                .insert(std::make_pair(
 462                    ELFSectionKey{Name, GroupName, "", UniqueID}, Section))
 463                .first;
 464   StringRef CachedName = I->first.SectionName;
 465   const_cast<MCSectionELF *>(Section)->setSectionName(CachedName);
 466 }
 467
 468 MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
 469                                               unsigned Flags, SectionKind K,
 470                                               unsigned EntrySize,
 471                                               const MCSymbolELF *Group,
 472                                               bool Comdat, unsigned UniqueID,
 473                                               const MCSymbolELF *LinkedToSym) {
 474   MCSymbolELF *R;
 475   MCSymbol *&Sym = Symbols[Section];
 476   // A section symbol can not redefine regular symbols. There may be multiple
 477   // sections with the same name, in which case the first such section wins.
 478   if (Sym && Sym->isDefined() &&
 479       (!Sym->isInSection() || Sym->getSection().getBeginSymbol() != Sym))
 480     reportError(SMLoc(), "invalid symbol redefinition");
 481   if (Sym && Sym->isUndefined()) {
 482     R = cast<MCSymbolELF>(Sym);
 483   } else {
 484     auto NameIter = UsedNames.insert(std::make_pair(Section, false)).first;
 485     R = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
 486     if (!Sym)
 487       Sym = R;
 488   }
 489   R->setBinding(ELF::STB_LOCAL);
 490   R->setType(ELF::STT_SECTION);
 491
 492   auto *Ret = new (ELFAllocator.Allocate())
 493       MCSectionELF(Section, Type, Flags, K, EntrySize, Group, Comdat, UniqueID,
 494                    R, LinkedToSym);
 495
 496   auto *F = new MCDataFragment();
 497   Ret->getFragmentList().insert(Ret->begin(), F);
 498   F->setParent(Ret);
 499   R->setFragment(F);
 500
 501   return Ret;
 502 }
 503
 504 MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type,
 505                                              unsigned Flags, unsigned EntrySize,
 506                                              const MCSymbolELF *Group,
 507                                              const MCSectionELF *RelInfoSection) {
 508   StringMap<bool>::iterator I;
 509   bool Inserted;
 510   std::tie(I, Inserted) =
 511       RelSecNames.insert(std::make_pair(Name.str(), true));
 512
 513   return createELFSectionImpl(
 514       I->getKey(), Type, Flags, SectionKind::getReadOnly(), EntrySize, Group,
 515       true, true, cast<MCSymbolELF>(RelInfoSection->getBeginSymbol()));
 516 }
 517
 518 MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix,
 519                                             const Twine &Suffix, unsigned Type,
 520                                             unsigned Flags,
 521                                             unsigned EntrySize) {
 522   return getELFSection(Prefix + "." + Suffix, Type, Flags, EntrySize, Suffix,
 523                        /*IsComdat=*/true);
 524 }
 525
 526 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
 527                                        unsigned Flags, unsigned EntrySize,
 528                                        const Twine &Group, bool IsComdat,
 529                                        unsigned UniqueID,
 530                                        const MCSymbolELF *LinkedToSym) {
 531   MCSymbolELF *GroupSym = nullptr;
 532   if (!Group.isTriviallyEmpty() && !Group.str().empty())
 533     GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group));
 534
 535   return getELFSection(Section, Type, Flags, EntrySize, GroupSym, IsComdat,
 536                        UniqueID, LinkedToSym);
 537 }
 538
 539 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
 540                                        unsigned Flags, unsigned EntrySize,
 541                                        const MCSymbolELF *GroupSym,
 542                                        bool IsComdat, unsigned UniqueID,
 543                                        const MCSymbolELF *LinkedToSym) {
 544   StringRef Group = "";
 545   if (GroupSym)
 546     Group = GroupSym->getName();
 547   assert(!(LinkedToSym && LinkedToSym->getName().empty()));
 548   // Do the lookup, if we have a hit, return it.
 549   auto IterBool = ELFUniquingMap.insert(std::make_pair(
 550       ELFSectionKey{Section.str(), Group,
 551                     LinkedToSym ? LinkedToSym->getName() : "", UniqueID},
 552       nullptr));
 553   auto &Entry = *IterBool.first;
 554   if (!IterBool.second)
 555     return Entry.second;
 556
 557   StringRef CachedName = Entry.first.SectionName;
 558
 559   SectionKind Kind;
 560   if (Flags & ELF::SHF_ARM_PURECODE)
 561     Kind = SectionKind::getExecuteOnly();
 562   else if (Flags & ELF::SHF_EXECINSTR)
 563     Kind = SectionKind::getText();
 564   else
 565     Kind = SectionKind::getReadOnly();
 566
 567   MCSectionELF *Result =
 568       createELFSectionImpl(CachedName, Type, Flags, Kind, EntrySize, GroupSym,
 569                            IsComdat, UniqueID, LinkedToSym);
 570   Entry.second = Result;
 571
 572   recordELFMergeableSectionInfo(Result->getName(), Result->getFlags(),
 573                                 Result->getUniqueID(), Result->getEntrySize());
 574
 575   return Result;
 576 }
 577
 578 MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group,
 579                                                bool IsComdat) {
 580   return createELFSectionImpl(".group", ELF::SHT_GROUP, 0,
 581                               SectionKind::getReadOnly(), 4, Group, IsComdat,
 582                               MCSection::NonUniqueID, nullptr);
 583 }
 584
 585 void MCContext::recordELFMergeableSectionInfo(StringRef SectionName,
 586                                               unsigned Flags, unsigned UniqueID,
 587                                               unsigned EntrySize) {
 588   bool IsMergeable = Flags & ELF::SHF_MERGE;
 589   if (UniqueID == GenericSectionID)
 590     ELFSeenGenericMergeableSections.insert(SectionName);
 591
 592   // For mergeable sections or non-mergeable sections with a generic mergeable
 593   // section name we enter their Unique ID into the ELFEntrySizeMap so that
 594   // compatible globals can be assigned to the same section.
 595   if (IsMergeable || isELFGenericMergeableSection(SectionName)) {
 596     ELFEntrySizeMap.insert(std::make_pair(
 597         ELFEntrySizeKey{SectionName, Flags, EntrySize}, UniqueID));
 598   }
 599 }
 600
 601 bool MCContext::isELFImplicitMergeableSectionNamePrefix(StringRef SectionName) {
 602   return SectionName.startswith(".rodata.str") ||
 603          SectionName.startswith(".rodata.cst");
 604 }
 605
 606 bool MCContext::isELFGenericMergeableSection(StringRef SectionName) {
 607   return isELFImplicitMergeableSectionNamePrefix(SectionName) ||
 608          ELFSeenGenericMergeableSections.count(SectionName);
 609 }
 610
 611 Optional<unsigned> MCContext::getELFUniqueIDForEntsize(StringRef SectionName,
 612                                                        unsigned Flags,
 613                                                        unsigned EntrySize) {
 614   auto I = ELFEntrySizeMap.find(
 615       MCContext::ELFEntrySizeKey{SectionName, Flags, EntrySize});
 616   return (I != ELFEntrySizeMap.end()) ? Optional<unsigned>(I->second) : None;
 617 }
 618
 619 MCSectionGOFF *MCContext::getGOFFSection(StringRef Section, SectionKind Kind) {
 620   // Do the lookup. If we don't have a hit, return a new section.
 621   auto &GOFFSection = GOFFUniquingMap[Section.str()];
 622   if (!GOFFSection)
 623     GOFFSection = new (GOFFAllocator.Allocate()) MCSectionGOFF(Section, Kind);
 624
 625   return GOFFSection;
 626 }
 627
 628 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
 629                                          unsigned Characteristics,
 630                                          SectionKind Kind,
 631                                          StringRef COMDATSymName, int Selection,
 632                                          unsigned UniqueID,
 633                                          const char *BeginSymName) {
 634   MCSymbol *COMDATSymbol = nullptr;
 635   if (!COMDATSymName.empty()) {
 636     COMDATSymbol = getOrCreateSymbol(COMDATSymName);
 637     COMDATSymName = COMDATSymbol->getName();
 638   }
 639
 640
 641   // Do the lookup, if we have a hit, return it.
 642   COFFSectionKey T{Section, COMDATSymName, Selection, UniqueID};
 643   auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
 644   auto Iter = IterBool.first;
 645   if (!IterBool.second)
 646     return Iter->second;
 647
 648   MCSymbol *Begin = nullptr;
 649   if (BeginSymName)
 650     Begin = createTempSymbol(BeginSymName, false);
 651
 652   StringRef CachedName = Iter->first.SectionName;
 653   MCSectionCOFF *Result = new (COFFAllocator.Allocate()) MCSectionCOFF(
 654       CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin);
 655
 656   Iter->second = Result;
 657   return Result;
 658 }
 659
 660 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
 661                                          unsigned Characteristics,
 662                                          SectionKind Kind,
 663                                          const char *BeginSymName) {
 664   return getCOFFSection(Section, Characteristics, Kind, "", 0, GenericSectionID,
 665                         BeginSymName);
 666 }
 667
 668 MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec,
 669                                                     const MCSymbol *KeySym,
 670                                                     unsigned UniqueID) {
 671   // Return the normal section if we don't have to be associative or unique.
 672   if (!KeySym && UniqueID == GenericSectionID)
 673     return Sec;
 674
 675   // If we have a key symbol, make an associative section with the same name and
 676   // kind as the normal section.
 677   unsigned Characteristics = Sec->getCharacteristics();
 678   if (KeySym) {
 679     Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
 680     return getCOFFSection(Sec->getName(), Characteristics, Sec->getKind(),
 681                           KeySym->getName(),
 682                           COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
 683   }
 684
 685   return getCOFFSection(Sec->getName(), Characteristics, Sec->getKind(), "", 0,
 686                         UniqueID);
 687 }
 688
 689 MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind K,
 690                                          unsigned Flags, const Twine &Group,
 691                                          unsigned UniqueID,
 692                                          const char *BeginSymName) {
 693   MCSymbolWasm *GroupSym = nullptr;
 694   if (!Group.isTriviallyEmpty() && !Group.str().empty()) {
 695     GroupSym = cast<MCSymbolWasm>(getOrCreateSymbol(Group));
 696     GroupSym->setComdat(true);
 697   }
 698
 699   return getWasmSection(Section, K, Flags, GroupSym, UniqueID, BeginSymName);
 700 }
 701
 702 MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
 703                                          unsigned Flags,
 704                                          const MCSymbolWasm *GroupSym,
 705                                          unsigned UniqueID,
 706                                          const char *BeginSymName) {
 707   StringRef Group = "";
 708   if (GroupSym)
 709     Group = GroupSym->getName();
 710   // Do the lookup, if we have a hit, return it.
 711   auto IterBool = WasmUniquingMap.insert(
 712       std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr));
 713   auto &Entry = *IterBool.first;
 714   if (!IterBool.second)
 715     return Entry.second;
 716
 717   StringRef CachedName = Entry.first.SectionName;
 718
 719   MCSymbol *Begin = createSymbol(CachedName, true, false);
 720   Symbols[Begin->getName()] = Begin;
 721   cast<MCSymbolWasm>(Begin)->setType(wasm::WASM_SYMBOL_TYPE_SECTION);
 722
 723   MCSectionWasm *Result = new (WasmAllocator.Allocate())
 724       MCSectionWasm(CachedName, Kind, Flags, GroupSym, UniqueID, Begin);
 725   Entry.second = Result;
 726
 727   auto *F = new MCDataFragment();
 728   Result->getFragmentList().insert(Result->begin(), F);
 729   F->setParent(Result);
 730   Begin->setFragment(F);
 731
 732   return Result;
 733 }
 734
 735 MCSectionXCOFF *MCContext::getXCOFFSection(
 736     StringRef Section, SectionKind Kind,
 737     Optional<XCOFF::CsectProperties> CsectProp, bool MultiSymbolsAllowed,
 738     const char *BeginSymName,
 739     Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSectionSubtypeFlags) {
 740   bool IsDwarfSec = DwarfSectionSubtypeFlags.hasValue();
 741   assert((IsDwarfSec != CsectProp.hasValue()) && "Invalid XCOFF section!");
 742
 743   // Do the lookup. If we have a hit, return it.
 744   auto IterBool = XCOFFUniquingMap.insert(std::make_pair(
 745       IsDwarfSec
 746           ? XCOFFSectionKey(Section.str(), DwarfSectionSubtypeFlags.getValue())
 747           : XCOFFSectionKey(Section.str(), CsectProp->MappingClass),
 748       nullptr));
 749   auto &Entry = *IterBool.first;
 750   if (!IterBool.second) {
 751     MCSectionXCOFF *ExistedEntry = Entry.second;
 752     if (ExistedEntry->isMultiSymbolsAllowed() != MultiSymbolsAllowed)
 753       report_fatal_error("section's multiply symbols policy does not match");
 754
 755     return ExistedEntry;
 756   }
 757
 758   // Otherwise, return a new section.
 759   StringRef CachedName = Entry.first.SectionName;
 760   MCSymbolXCOFF *QualName = nullptr;
 761   // Debug section don't have storage class attribute.
 762   if (IsDwarfSec)
 763     QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(CachedName));
 764   else
 765     QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(
 766         CachedName + "[" +
 767         XCOFF::getMappingClassString(CsectProp->MappingClass) + "]"));
 768
 769   MCSymbol *Begin = nullptr;
 770   if (BeginSymName)
 771     Begin = createTempSymbol(BeginSymName, false);
 772
 773   // QualName->getUnqualifiedName() and CachedName are the same except when
 774   // CachedName contains invalid character(s) such as '$' for an XCOFF symbol.
 775   MCSectionXCOFF *Result = nullptr;
 776   if (IsDwarfSec)
 777     Result = new (XCOFFAllocator.Allocate())
 778         MCSectionXCOFF(QualName->getUnqualifiedName(), Kind, QualName,
 779                        DwarfSectionSubtypeFlags.getValue(), Begin, CachedName,
 780                        MultiSymbolsAllowed);
 781   else
 782     Result = new (XCOFFAllocator.Allocate())
 783         MCSectionXCOFF(QualName->getUnqualifiedName(), CsectProp->MappingClass,
 784                        CsectProp->Type, Kind, QualName, Begin, CachedName,
 785                        MultiSymbolsAllowed);
 786
 787   Entry.second = Result;
 788
 789   auto *F = new MCDataFragment();
 790   Result->getFragmentList().insert(Result->begin(), F);
 791   F->setParent(Result);
 792
 793   if (Begin)
 794     Begin->setFragment(F);
 795
 796   return Result;
 797 }
 798
 799 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
 800   return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
 801 }
 802
 803 void MCContext::addDebugPrefixMapEntry(const std::string &From,
 804                                        const std::string &To) {
 805   DebugPrefixMap.insert(std::make_pair(From, To));
 806 }
 807
 808 void MCContext::RemapDebugPaths() {
 809   const auto &DebugPrefixMap = this->DebugPrefixMap;
 810   if (DebugPrefixMap.empty())
 811     return;
 812
 813   const auto RemapDebugPath = [&DebugPrefixMap](std::string &Path) {
 814     SmallString<256> P(Path);
 815     for (const auto &Entry : DebugPrefixMap) {
 816       if (llvm::sys::path::replace_path_prefix(P, Entry.first, Entry.second)) {
 817         Path = P.str().str();
 818         break;
 819       }
 820     }
 821   };
 822
 823   // Remap compilation directory.
 824   std::string CompDir = std::string(CompilationDir.str());
 825   RemapDebugPath(CompDir);
 826   CompilationDir = CompDir;
 827
 828   // Remap MCDwarfDirs in all compilation units.
 829   for (auto &CUIDTablePair : MCDwarfLineTablesCUMap)
 830     for (auto &Dir : CUIDTablePair.second.getMCDwarfDirs())
 831       RemapDebugPath(Dir);
 832 }
 833
 834 //===----------------------------------------------------------------------===//
 835 // Dwarf Management
 836 //===----------------------------------------------------------------------===//
 837
 838 void MCContext::setGenDwarfRootFile(StringRef InputFileName, StringRef Buffer) {
 839   // MCDwarf needs the root file as well as the compilation directory.
 840   // If we find a '.file 0' directive that will supersede these values.
 841   Optional<MD5::MD5Result> Cksum;
 842   if (getDwarfVersion() >= 5) {
 843     MD5 Hash;
 844     MD5::MD5Result Sum;
 845     Hash.update(Buffer);
 846     Hash.final(Sum);
 847     Cksum = Sum;
 848   }
 849   // Canonicalize the root filename. It cannot be empty, and should not
 850   // repeat the compilation dir.
 851   // The MCContext ctor initializes MainFileName to the name associated with
 852   // the SrcMgr's main file ID, which might be the same as InputFileName (and
 853   // possibly include directory components).
 854   // Or, MainFileName might have been overridden by a -main-file-name option,
 855   // which is supposed to be just a base filename with no directory component.
 856   // So, if the InputFileName and MainFileName are not equal, assume
 857   // MainFileName is a substitute basename and replace the last component.
 858   SmallString<1024> FileNameBuf = InputFileName;
 859   if (FileNameBuf.empty() || FileNameBuf == "-")
 860     FileNameBuf = "<stdin>";
 861   if (!getMainFileName().empty() && FileNameBuf != getMainFileName()) {
 862     llvm::sys::path::remove_filename(FileNameBuf);
 863     llvm::sys::path::append(FileNameBuf, getMainFileName());
 864   }
 865   StringRef FileName = FileNameBuf;
 866   if (FileName.consume_front(getCompilationDir()))
 867     if (llvm::sys::path::is_separator(FileName.front()))
 868       FileName = FileName.drop_front();
 869   assert(!FileName.empty());
 870   setMCLineTableRootFile(
 871       /*CUID=*/0, getCompilationDir(), FileName, Cksum, None);
 872 }
 873
 874 /// getDwarfFile - takes a file name and number to place in the dwarf file and
 875 /// directory tables.  If the file number has already been allocated it is an
 876 /// error and zero is returned and the client reports the error, else the
 877 /// allocated file number is returned.  The file numbers may be in any order.
 878 Expected<unsigned> MCContext::getDwarfFile(StringRef Directory,
 879                                            StringRef FileName,
 880                                            unsigned FileNumber,
 881                                            Optional<MD5::MD5Result> Checksum,
 882                                            Optional<StringRef> Source,
 883                                            unsigned CUID) {
 884   MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
 885   return Table.tryGetFile(Directory, FileName, Checksum, Source, DwarfVersion,
 886                           FileNumber);
 887 }
 888
 889 /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
 890 /// currently is assigned and false otherwise.
 891 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
 892   const MCDwarfLineTable &LineTable = getMCDwarfLineTable(CUID);
 893   if (FileNumber == 0)
 894     return getDwarfVersion() >= 5;
 895   if (FileNumber >= LineTable.getMCDwarfFiles().size())
 896     return false;
 897
 898   return !LineTable.getMCDwarfFiles()[FileNumber].Name.empty();
 899 }
 900
 901 /// Remove empty sections from SectionsForRanges, to avoid generating
 902 /// useless debug info for them.
 903 void MCContext::finalizeDwarfSections(MCStreamer &MCOS) {
 904   SectionsForRanges.remove_if(
 905       [&](MCSection *Sec) { return !MCOS.mayHaveInstructions(*Sec); });
 906 }
 907
 908 CodeViewContext &MCContext::getCVContext() {
 909   if (!CVContext.get())
 910     CVContext.reset(new CodeViewContext);
 911   return *CVContext.get();
 912 }
 913
 914 //===----------------------------------------------------------------------===//
 915 // Error Reporting
 916 //===----------------------------------------------------------------------===//
 917
 918 void MCContext::diagnose(const SMDiagnostic &SMD) {
 919   assert(DiagHandler && "MCContext::DiagHandler is not set");
 920   bool UseInlineSrcMgr = false;
 921   const SourceMgr *SMP = nullptr;
 922   if (SrcMgr) {
 923     SMP = SrcMgr;
 924   } else if (InlineSrcMgr) {
 925     SMP = InlineSrcMgr.get();
 926     UseInlineSrcMgr = true;
 927   } else
 928     llvm_unreachable("Either SourceMgr should be available");
 929   DiagHandler(SMD, UseInlineSrcMgr, *SMP, LocInfos);
 930 }
 931
 932 void MCContext::reportCommon(
 933     SMLoc Loc,
 934     std::function<void(SMDiagnostic &, const SourceMgr *)> GetMessage) {
 935   // * MCContext::SrcMgr is null when the MC layer emits machine code for input
 936   //   other than assembly file, say, for .c/.cpp/.ll/.bc.
 937   // * MCContext::InlineSrcMgr is null when the inline asm is not used.
 938   // * A default SourceMgr is needed for diagnosing when both MCContext::SrcMgr
 939   //   and MCContext::InlineSrcMgr are null.
 940   SourceMgr SM;
 941   const SourceMgr *SMP = &SM;
 942   bool UseInlineSrcMgr = false;
 943
 944   // FIXME: Simplify these by combining InlineSrcMgr & SrcMgr.
 945   //        For MC-only execution, only SrcMgr is used;
 946   //        For non MC-only execution, InlineSrcMgr is only ctor'd if there is
 947   //        inline asm in the IR.
 948   if (Loc.isValid()) {
 949     if (SrcMgr) {
 950       SMP = SrcMgr;
 951     } else if (InlineSrcMgr) {
 952       SMP = InlineSrcMgr.get();
 953       UseInlineSrcMgr = true;
 954     } else
 955       llvm_unreachable("Either SourceMgr should be available");
 956   }
 957
 958   SMDiagnostic D;
 959   GetMessage(D, SMP);
 960   DiagHandler(D, UseInlineSrcMgr, *SMP, LocInfos);
 961 }
 962
 963 void MCContext::reportError(SMLoc Loc, const Twine &Msg) {
 964   HadError = true;
 965   reportCommon(Loc, [&](SMDiagnostic &D, const SourceMgr *SMP) {
 966     D = SMP->GetMessage(Loc, SourceMgr::DK_Error, Msg);
 967   });
 968 }
 969
 970 void MCContext::reportWarning(SMLoc Loc, const Twine &Msg) {
 971   if (TargetOptions && TargetOptions->MCNoWarn)
 972     return;
 973   if (TargetOptions && TargetOptions->MCFatalWarnings) {
 974     reportError(Loc, Msg);
 975   } else {
 976     reportCommon(Loc, [&](SMDiagnostic &D, const SourceMgr *SMP) {
 977       D = SMP->GetMessage(Loc, SourceMgr::DK_Warning, Msg);
 978     });
 979   }
 980 }
 981
 982 void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) {
 983   reportError(Loc, Msg);
 984
 985   // If we reached here, we are failing ungracefully. Run the interrupt handlers
 986   // to make sure any special cleanups get done, in particular that we remove
 987   // files registered with RemoveFileOnSignal.
 988   sys::RunInterruptHandlers();
 989   exit(1);
 990 }