1 //===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===// 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 #include "llvm/MC/MCContext.h" 11 #include "llvm/ADT/SmallString.h" 12 #include "llvm/ADT/Twine.h" 13 #include "llvm/MC/MCAsmInfo.h" 14 #include "llvm/MC/MCAssembler.h" 15 #include "llvm/MC/MCCodeView.h" 16 #include "llvm/MC/MCDwarf.h" 17 #include "llvm/MC/MCLabel.h" 18 #include "llvm/MC/MCObjectFileInfo.h" 19 #include "llvm/MC/MCRegisterInfo.h" 20 #include "llvm/MC/MCSectionCOFF.h" 21 #include "llvm/MC/MCSectionELF.h" 22 #include "llvm/MC/MCSectionMachO.h" 23 #include "llvm/MC/MCStreamer.h" 24 #include "llvm/MC/MCSymbolCOFF.h" 25 #include "llvm/MC/MCSymbolELF.h" 26 #include "llvm/MC/MCSymbolMachO.h" 27 #include "llvm/Support/COFF.h" 28 #include "llvm/Support/CommandLine.h" 29 #include "llvm/Support/ELF.h" 30 #include "llvm/Support/ErrorHandling.h" 31 #include "llvm/Support/MemoryBuffer.h" 32 #include "llvm/Support/Signals.h" 33 #include "llvm/Support/SourceMgr.h" 34 35 using namespace llvm; 36 37 static cl::opt<char*> 38 AsSecureLogFileName("as-secure-log-file-name", 39 cl::desc("As secure log file name (initialized from " 40 "AS_SECURE_LOG_FILE env variable)"), 41 cl::init(getenv("AS_SECURE_LOG_FILE")), cl::Hidden); 42 43 44 MCContext::MCContext(const MCAsmInfo *mai, const MCRegisterInfo *mri, 45 const MCObjectFileInfo *mofi, const SourceMgr *mgr, 46 bool DoAutoReset) 47 : SrcMgr(mgr), MAI(mai), MRI(mri), MOFI(mofi), Allocator(), 48 Symbols(Allocator), UsedNames(Allocator), 49 CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0), DwarfLocSeen(false), 50 GenDwarfForAssembly(false), GenDwarfFileNumber(0), DwarfVersion(4), 51 AllowTemporaryLabels(true), DwarfCompileUnitID(0), 52 AutoReset(DoAutoReset), HadError(false) { 53 SecureLogFile = AsSecureLogFileName; 54 SecureLog = nullptr; 55 SecureLogUsed = false; 56 57 if (SrcMgr && SrcMgr->getNumBuffers()) 58 MainFileName = 59 SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())->getBufferIdentifier(); 60 } 61 62 MCContext::~MCContext() { 63 if (AutoReset) 64 reset(); 65 66 // NOTE: The symbols are all allocated out of a bump pointer allocator, 67 // we don't need to free them here. 68 } 69 70 //===----------------------------------------------------------------------===// 71 // Module Lifetime Management 72 //===----------------------------------------------------------------------===// 73 74 void MCContext::reset() { 75 // Call the destructors so the fragments are freed 76 COFFAllocator.DestroyAll(); 77 ELFAllocator.DestroyAll(); 78 MachOAllocator.DestroyAll(); 79 80 MCSubtargetAllocator.DestroyAll(); 81 UsedNames.clear(); 82 Symbols.clear(); 83 SectionSymbols.clear(); 84 Allocator.Reset(); 85 Instances.clear(); 86 CompilationDir.clear(); 87 MainFileName.clear(); 88 MCDwarfLineTablesCUMap.clear(); 89 SectionsForRanges.clear(); 90 MCGenDwarfLabelEntries.clear(); 91 DwarfDebugFlags = StringRef(); 92 DwarfCompileUnitID = 0; 93 CurrentDwarfLoc = MCDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0); 94 95 CVContext.reset(); 96 97 MachOUniquingMap.clear(); 98 ELFUniquingMap.clear(); 99 COFFUniquingMap.clear(); 100 101 NextID.clear(); 102 AllowTemporaryLabels = true; 103 DwarfLocSeen = false; 104 GenDwarfForAssembly = false; 105 GenDwarfFileNumber = 0; 106 107 HadError = false; 108 } 109 110 //===----------------------------------------------------------------------===// 111 // Symbol Manipulation 112 //===----------------------------------------------------------------------===// 113 114 MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) { 115 SmallString<128> NameSV; 116 StringRef NameRef = Name.toStringRef(NameSV); 117 118 assert(!NameRef.empty() && "Normal symbols cannot be unnamed!"); 119 120 MCSymbol *&Sym = Symbols[NameRef]; 121 if (!Sym) 122 Sym = createSymbol(NameRef, false, false); 123 124 return Sym; 125 } 126 127 MCSymbolELF *MCContext::getOrCreateSectionSymbol(const MCSectionELF &Section) { 128 MCSymbolELF *&Sym = SectionSymbols[&Section]; 129 if (Sym) 130 return Sym; 131 132 StringRef Name = Section.getSectionName(); 133 auto NameIter = UsedNames.insert(std::make_pair(Name, false)).first; 134 Sym = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false); 135 136 return Sym; 137 } 138 139 MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName, 140 unsigned Idx) { 141 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName + 142 "$frame_escape_" + Twine(Idx)); 143 } 144 145 MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) { 146 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName + 147 "$parent_frame_offset"); 148 } 149 150 MCSymbol *MCContext::getOrCreateLSDASymbol(StringRef FuncName) { 151 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + "__ehtable$" + 152 FuncName); 153 } 154 155 MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name, 156 bool IsTemporary) { 157 if (MOFI) { 158 switch (MOFI->getObjectFileType()) { 159 case MCObjectFileInfo::IsCOFF: 160 return new (Name, *this) MCSymbolCOFF(Name, IsTemporary); 161 case MCObjectFileInfo::IsELF: 162 return new (Name, *this) MCSymbolELF(Name, IsTemporary); 163 case MCObjectFileInfo::IsMachO: 164 return new (Name, *this) MCSymbolMachO(Name, IsTemporary); 165 } 166 } 167 return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name, 168 IsTemporary); 169 } 170 171 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix, 172 bool CanBeUnnamed) { 173 if (CanBeUnnamed && !UseNamesOnTempLabels) 174 return createSymbolImpl(nullptr, true); 175 176 // Determine whether this is an user writter assembler temporary or normal 177 // label, if used. 178 bool IsTemporary = CanBeUnnamed; 179 if (AllowTemporaryLabels && !IsTemporary) 180 IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix()); 181 182 SmallString<128> NewName = Name; 183 bool AddSuffix = AlwaysAddSuffix; 184 unsigned &NextUniqueID = NextID[Name]; 185 for (;;) { 186 if (AddSuffix) { 187 NewName.resize(Name.size()); 188 raw_svector_ostream(NewName) << NextUniqueID++; 189 } 190 auto NameEntry = UsedNames.insert(std::make_pair(NewName, true)); 191 if (NameEntry.second || !NameEntry.first->second) { 192 // Ok, we found a name. 193 // Mark it as used for a non-section symbol. 194 NameEntry.first->second = true; 195 // Have the MCSymbol object itself refer to the copy of the string that is 196 // embedded in the UsedNames entry. 197 return createSymbolImpl(&*NameEntry.first, IsTemporary); 198 } 199 assert(IsTemporary && "Cannot rename non-temporary symbols"); 200 AddSuffix = true; 201 } 202 llvm_unreachable("Infinite loop"); 203 } 204 205 MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix, 206 bool CanBeUnnamed) { 207 SmallString<128> NameSV; 208 raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name; 209 return createSymbol(NameSV, AlwaysAddSuffix, CanBeUnnamed); 210 } 211 212 MCSymbol *MCContext::createLinkerPrivateTempSymbol() { 213 SmallString<128> NameSV; 214 raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp"; 215 return createSymbol(NameSV, true, false); 216 } 217 218 MCSymbol *MCContext::createTempSymbol(bool CanBeUnnamed) { 219 return createTempSymbol("tmp", true, CanBeUnnamed); 220 } 221 222 unsigned MCContext::NextInstance(unsigned LocalLabelVal) { 223 MCLabel *&Label = Instances[LocalLabelVal]; 224 if (!Label) 225 Label = new (*this) MCLabel(0); 226 return Label->incInstance(); 227 } 228 229 unsigned MCContext::GetInstance(unsigned LocalLabelVal) { 230 MCLabel *&Label = Instances[LocalLabelVal]; 231 if (!Label) 232 Label = new (*this) MCLabel(0); 233 return Label->getInstance(); 234 } 235 236 MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal, 237 unsigned Instance) { 238 MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)]; 239 if (!Sym) 240 Sym = createTempSymbol(false); 241 return Sym; 242 } 243 244 MCSymbol *MCContext::createDirectionalLocalSymbol(unsigned LocalLabelVal) { 245 unsigned Instance = NextInstance(LocalLabelVal); 246 return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance); 247 } 248 249 MCSymbol *MCContext::getDirectionalLocalSymbol(unsigned LocalLabelVal, 250 bool Before) { 251 unsigned Instance = GetInstance(LocalLabelVal); 252 if (!Before) 253 ++Instance; 254 return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance); 255 } 256 257 MCSymbol *MCContext::lookupSymbol(const Twine &Name) const { 258 SmallString<128> NameSV; 259 StringRef NameRef = Name.toStringRef(NameSV); 260 return Symbols.lookup(NameRef); 261 } 262 263 //===----------------------------------------------------------------------===// 264 // Section Management 265 //===----------------------------------------------------------------------===// 266 267 MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section, 268 unsigned TypeAndAttributes, 269 unsigned Reserved2, SectionKind Kind, 270 const char *BeginSymName) { 271 272 // We unique sections by their segment/section pair. The returned section 273 // may not have the same flags as the requested section, if so this should be 274 // diagnosed by the client as an error. 275 276 // Form the name to look up. 277 SmallString<64> Name; 278 Name += Segment; 279 Name.push_back(','); 280 Name += Section; 281 282 // Do the lookup, if we have a hit, return it. 283 MCSectionMachO *&Entry = MachOUniquingMap[Name]; 284 if (Entry) 285 return Entry; 286 287 MCSymbol *Begin = nullptr; 288 if (BeginSymName) 289 Begin = createTempSymbol(BeginSymName, false); 290 291 // Otherwise, return a new section. 292 return Entry = new (MachOAllocator.Allocate()) MCSectionMachO( 293 Segment, Section, TypeAndAttributes, Reserved2, Kind, Begin); 294 } 295 296 void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) { 297 StringRef GroupName; 298 if (const MCSymbol *Group = Section->getGroup()) 299 GroupName = Group->getName(); 300 301 unsigned UniqueID = Section->getUniqueID(); 302 ELFUniquingMap.erase( 303 ELFSectionKey{Section->getSectionName(), GroupName, UniqueID}); 304 auto I = ELFUniquingMap.insert(std::make_pair( 305 ELFSectionKey{Name, GroupName, UniqueID}, 306 Section)) 307 .first; 308 StringRef CachedName = I->first.SectionName; 309 const_cast<MCSectionELF *>(Section)->setSectionName(CachedName); 310 } 311 312 MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type, 313 unsigned Flags, unsigned EntrySize, 314 const MCSymbolELF *Group, 315 const MCSectionELF *Associated) { 316 StringMap<bool>::iterator I; 317 bool Inserted; 318 std::tie(I, Inserted) = 319 ELFRelSecNames.insert(std::make_pair(Name.str(), true)); 320 321 return new (ELFAllocator.Allocate()) 322 MCSectionELF(I->getKey(), Type, Flags, SectionKind::getReadOnly(), 323 EntrySize, Group, true, nullptr, Associated); 324 } 325 326 MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix, 327 const Twine &Suffix, unsigned Type, 328 unsigned Flags, 329 unsigned EntrySize) { 330 return getELFSection(Prefix + "." + Suffix, Type, Flags, EntrySize, Suffix); 331 } 332 333 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type, 334 unsigned Flags, unsigned EntrySize, 335 const Twine &Group, unsigned UniqueID, 336 const char *BeginSymName) { 337 MCSymbolELF *GroupSym = nullptr; 338 if (!Group.isTriviallyEmpty() && !Group.str().empty()) 339 GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group)); 340 341 return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID, 342 BeginSymName, nullptr); 343 } 344 345 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type, 346 unsigned Flags, unsigned EntrySize, 347 const MCSymbolELF *GroupSym, 348 unsigned UniqueID, 349 const char *BeginSymName, 350 const MCSectionELF *Associated) { 351 StringRef Group = ""; 352 if (GroupSym) 353 Group = GroupSym->getName(); 354 // Do the lookup, if we have a hit, return it. 355 auto IterBool = ELFUniquingMap.insert( 356 std::make_pair(ELFSectionKey{Section.str(), Group, UniqueID}, nullptr)); 357 auto &Entry = *IterBool.first; 358 if (!IterBool.second) 359 return Entry.second; 360 361 StringRef CachedName = Entry.first.SectionName; 362 363 SectionKind Kind; 364 if (Flags & ELF::SHF_EXECINSTR) 365 Kind = SectionKind::getText(); 366 else 367 Kind = SectionKind::getReadOnly(); 368 369 MCSymbol *Begin = nullptr; 370 if (BeginSymName) 371 Begin = createTempSymbol(BeginSymName, false); 372 373 MCSectionELF *Result = new (ELFAllocator.Allocate()) 374 MCSectionELF(CachedName, Type, Flags, Kind, EntrySize, GroupSym, UniqueID, 375 Begin, Associated); 376 Entry.second = Result; 377 return Result; 378 } 379 380 MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group) { 381 MCSectionELF *Result = new (ELFAllocator.Allocate()) 382 MCSectionELF(".group", ELF::SHT_GROUP, 0, SectionKind::getReadOnly(), 4, 383 Group, ~0, nullptr, nullptr); 384 return Result; 385 } 386 387 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section, 388 unsigned Characteristics, 389 SectionKind Kind, 390 StringRef COMDATSymName, int Selection, 391 unsigned UniqueID, 392 const char *BeginSymName) { 393 MCSymbol *COMDATSymbol = nullptr; 394 if (!COMDATSymName.empty()) { 395 COMDATSymbol = getOrCreateSymbol(COMDATSymName); 396 COMDATSymName = COMDATSymbol->getName(); 397 } 398 399 400 // Do the lookup, if we have a hit, return it. 401 COFFSectionKey T{Section, COMDATSymName, Selection, UniqueID}; 402 auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr)); 403 auto Iter = IterBool.first; 404 if (!IterBool.second) 405 return Iter->second; 406 407 MCSymbol *Begin = nullptr; 408 if (BeginSymName) 409 Begin = createTempSymbol(BeginSymName, false); 410 411 StringRef CachedName = Iter->first.SectionName; 412 MCSectionCOFF *Result = new (COFFAllocator.Allocate()) MCSectionCOFF( 413 CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin); 414 415 Iter->second = Result; 416 return Result; 417 } 418 419 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section, 420 unsigned Characteristics, 421 SectionKind Kind, 422 const char *BeginSymName) { 423 return getCOFFSection(Section, Characteristics, Kind, "", 0, GenericSectionID, 424 BeginSymName); 425 } 426 427 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section) { 428 COFFSectionKey T{Section, "", 0, GenericSectionID}; 429 auto Iter = COFFUniquingMap.find(T); 430 if (Iter == COFFUniquingMap.end()) 431 return nullptr; 432 return Iter->second; 433 } 434 435 MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec, 436 const MCSymbol *KeySym, 437 unsigned UniqueID) { 438 // Return the normal section if we don't have to be associative or unique. 439 if (!KeySym && UniqueID == GenericSectionID) 440 return Sec; 441 442 // If we have a key symbol, make an associative section with the same name and 443 // kind as the normal section. 444 unsigned Characteristics = Sec->getCharacteristics(); 445 if (KeySym) { 446 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 447 return getCOFFSection(Sec->getSectionName(), Characteristics, 448 Sec->getKind(), KeySym->getName(), 449 COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID); 450 } 451 452 return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(), 453 "", 0, UniqueID); 454 } 455 456 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) { 457 return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI); 458 } 459 460 //===----------------------------------------------------------------------===// 461 // Dwarf Management 462 //===----------------------------------------------------------------------===// 463 464 /// getDwarfFile - takes a file name an number to place in the dwarf file and 465 /// directory tables. If the file number has already been allocated it is an 466 /// error and zero is returned and the client reports the error, else the 467 /// allocated file number is returned. The file numbers may be in any order. 468 unsigned MCContext::getDwarfFile(StringRef Directory, StringRef FileName, 469 unsigned FileNumber, unsigned CUID) { 470 MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID]; 471 return Table.getFile(Directory, FileName, FileNumber); 472 } 473 474 /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it 475 /// currently is assigned and false otherwise. 476 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) { 477 const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles = getMCDwarfFiles(CUID); 478 if (FileNumber == 0 || FileNumber >= MCDwarfFiles.size()) 479 return false; 480 481 return !MCDwarfFiles[FileNumber].Name.empty(); 482 } 483 484 /// Remove empty sections from SectionStartEndSyms, to avoid generating 485 /// useless debug info for them. 486 void MCContext::finalizeDwarfSections(MCStreamer &MCOS) { 487 SectionsForRanges.remove_if( 488 [&](MCSection *Sec) { return !MCOS.mayHaveInstructions(*Sec); }); 489 } 490 491 CodeViewContext &MCContext::getCVContext() { 492 if (!CVContext.get()) 493 CVContext.reset(new CodeViewContext); 494 return *CVContext.get(); 495 } 496 497 unsigned MCContext::getCVFile(StringRef FileName, unsigned FileNumber) { 498 return getCVContext().addFile(FileNumber, FileName) ? FileNumber : 0; 499 } 500 501 bool MCContext::isValidCVFileNumber(unsigned FileNumber) { 502 return getCVContext().isValidFileNumber(FileNumber); 503 } 504 505 //===----------------------------------------------------------------------===// 506 // Error Reporting 507 //===----------------------------------------------------------------------===// 508 509 void MCContext::reportError(SMLoc Loc, const Twine &Msg) { 510 HadError = true; 511 512 // If we have a source manager use it. Otherwise just use the generic 513 // report_fatal_error(). 514 if (!SrcMgr) 515 report_fatal_error(Msg, false); 516 517 // Use the source manager to print the message. 518 SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg); 519 } 520 521 void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) { 522 reportError(Loc, Msg); 523 524 // If we reached here, we are failing ungracefully. Run the interrupt handlers 525 // to make sure any special cleanups get done, in particular that we remove 526 // files registered with RemoveFileOnSignal. 527 sys::RunInterruptHandlers(); 528 exit(1); 529 } 530