Line data Source code
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/Optional.h"
12 : #include "llvm/ADT/SmallString.h"
13 : #include "llvm/ADT/SmallVector.h"
14 : #include "llvm/ADT/StringMap.h"
15 : #include "llvm/ADT/StringRef.h"
16 : #include "llvm/ADT/Twine.h"
17 : #include "llvm/BinaryFormat/COFF.h"
18 : #include "llvm/BinaryFormat/ELF.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/MCSectionMachO.h"
29 : #include "llvm/MC/MCSectionWasm.h"
30 : #include "llvm/MC/MCStreamer.h"
31 : #include "llvm/MC/MCSymbol.h"
32 : #include "llvm/MC/MCSymbolCOFF.h"
33 : #include "llvm/MC/MCSymbolELF.h"
34 : #include "llvm/MC/MCSymbolMachO.h"
35 : #include "llvm/MC/MCSymbolWasm.h"
36 : #include "llvm/MC/SectionKind.h"
37 : #include "llvm/Support/Casting.h"
38 : #include "llvm/Support/CommandLine.h"
39 : #include "llvm/Support/ErrorHandling.h"
40 : #include "llvm/Support/MemoryBuffer.h"
41 : #include "llvm/Support/Signals.h"
42 : #include "llvm/Support/SourceMgr.h"
43 : #include "llvm/Support/raw_ostream.h"
44 : #include <cassert>
45 : #include <cstdlib>
46 : #include <tuple>
47 : #include <utility>
48 :
49 : using namespace llvm;
50 :
51 : static cl::opt<char*>
52 : AsSecureLogFileName("as-secure-log-file-name",
53 : cl::desc("As secure log file name (initialized from "
54 : "AS_SECURE_LOG_FILE env variable)"),
55 : cl::init(getenv("AS_SECURE_LOG_FILE")), cl::Hidden);
56 :
57 39963 : MCContext::MCContext(const MCAsmInfo *mai, const MCRegisterInfo *mri,
58 : const MCObjectFileInfo *mofi, const SourceMgr *mgr,
59 39963 : bool DoAutoReset)
60 : : SrcMgr(mgr), InlineSrcMgr(nullptr), MAI(mai), MRI(mri), MOFI(mofi),
61 : Symbols(Allocator), UsedNames(Allocator),
62 : CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0),
63 239778 : AutoReset(DoAutoReset) {
64 39963 : SecureLogFile = AsSecureLogFileName;
65 :
66 39963 : if (SrcMgr && SrcMgr->getNumBuffers())
67 : MainFileName =
68 25608 : SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())->getBufferIdentifier();
69 39963 : }
70 :
71 397250 : MCContext::~MCContext() {
72 39725 : if (AutoReset)
73 11308 : reset();
74 :
75 : // NOTE: The symbols are all allocated out of a bump pointer allocator,
76 : // we don't need to free them here.
77 39725 : }
78 :
79 : //===----------------------------------------------------------------------===//
80 : // Module Lifetime Management
81 : //===----------------------------------------------------------------------===//
82 :
83 39564 : void MCContext::reset() {
84 : // Call the destructors so the fragments are freed
85 39564 : COFFAllocator.DestroyAll();
86 39564 : ELFAllocator.DestroyAll();
87 39564 : MachOAllocator.DestroyAll();
88 :
89 39564 : MCSubtargetAllocator.DestroyAll();
90 : UsedNames.clear();
91 : Symbols.clear();
92 39564 : Allocator.Reset();
93 39564 : Instances.clear();
94 : CompilationDir.clear();
95 : MainFileName.clear();
96 : MCDwarfLineTablesCUMap.clear();
97 : SectionsForRanges.clear();
98 : MCGenDwarfLabelEntries.clear();
99 39564 : DwarfDebugFlags = StringRef();
100 39564 : DwarfCompileUnitID = 0;
101 39564 : CurrentDwarfLoc = MCDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0);
102 :
103 : CVContext.reset();
104 :
105 39564 : MachOUniquingMap.clear();
106 : ELFUniquingMap.clear();
107 : COFFUniquingMap.clear();
108 : WasmUniquingMap.clear();
109 :
110 39564 : NextID.clear();
111 39564 : AllowTemporaryLabels = true;
112 39564 : DwarfLocSeen = false;
113 39564 : GenDwarfForAssembly = false;
114 39564 : GenDwarfFileNumber = 0;
115 :
116 39564 : HadError = false;
117 39564 : }
118 :
119 : //===----------------------------------------------------------------------===//
120 : // Symbol Manipulation
121 : //===----------------------------------------------------------------------===//
122 :
123 7662643 : MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) {
124 : SmallString<128> NameSV;
125 7662643 : StringRef NameRef = Name.toStringRef(NameSV);
126 :
127 : assert(!NameRef.empty() && "Normal symbols cannot be unnamed!");
128 :
129 7662644 : MCSymbol *&Sym = Symbols[NameRef];
130 7662644 : if (!Sym)
131 3077806 : Sym = createSymbol(NameRef, false, false);
132 :
133 7662644 : return Sym;
134 : }
135 :
136 30 : MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName,
137 : unsigned Idx) {
138 60 : return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
139 60 : "$frame_escape_" + Twine(Idx));
140 : }
141 :
142 31 : MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) {
143 62 : return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
144 31 : "$parent_frame_offset");
145 : }
146 :
147 68 : MCSymbol *MCContext::getOrCreateLSDASymbol(StringRef FuncName) {
148 136 : return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + "__ehtable$" +
149 68 : FuncName);
150 : }
151 :
152 8476336 : MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
153 : bool IsTemporary) {
154 8476336 : if (MOFI) {
155 8476289 : switch (MOFI->getObjectFileType()) {
156 40522 : case MCObjectFileInfo::IsCOFF:
157 81044 : return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
158 8315070 : case MCObjectFileInfo::IsELF:
159 16630140 : return new (Name, *this) MCSymbolELF(Name, IsTemporary);
160 104010 : case MCObjectFileInfo::IsMachO:
161 104010 : return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
162 16679 : case MCObjectFileInfo::IsWasm:
163 16679 : return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
164 : }
165 : }
166 : return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
167 55 : IsTemporary);
168 : }
169 :
170 8476335 : MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
171 : bool CanBeUnnamed) {
172 8476335 : if (CanBeUnnamed && !UseNamesOnTempLabels)
173 5099752 : return createSymbolImpl(nullptr, true);
174 :
175 : // Determine whether this is a user written assembler temporary or normal
176 : // label, if used.
177 : bool IsTemporary = CanBeUnnamed;
178 3376583 : if (AllowTemporaryLabels && !IsTemporary)
179 3086778 : IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix());
180 :
181 : SmallString<128> NewName = Name;
182 : bool AddSuffix = AlwaysAddSuffix;
183 3376584 : unsigned &NextUniqueID = NextID[Name];
184 : while (true) {
185 3376584 : if (AddSuffix) {
186 230655 : NewName.resize(Name.size());
187 461310 : raw_svector_ostream(NewName) << NextUniqueID++;
188 : }
189 6760110 : auto NameEntry = UsedNames.insert(std::make_pair(NewName, true));
190 3380055 : if (NameEntry.second || !NameEntry.first->second) {
191 : // Ok, we found a name.
192 : // Mark it as used for a non-section symbol.
193 3376584 : NameEntry.first->second = true;
194 : // Have the MCSymbol object itself refer to the copy of the string that is
195 : // embedded in the UsedNames entry.
196 3376584 : return createSymbolImpl(&*NameEntry.first, IsTemporary);
197 : }
198 : assert(IsTemporary && "Cannot rename non-temporary symbols");
199 : AddSuffix = true;
200 : }
201 : llvm_unreachable("Infinite loop");
202 : }
203 :
204 5389720 : MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix,
205 : bool CanBeUnnamed) {
206 : SmallString<128> NameSV;
207 5389721 : raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
208 10779440 : return createSymbol(NameSV, AlwaysAddSuffix, CanBeUnnamed);
209 : }
210 :
211 87 : MCSymbol *MCContext::createLinkerPrivateTempSymbol() {
212 : SmallString<128> NameSV;
213 261 : raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp";
214 87 : return createSymbol(NameSV, true, false);
215 : }
216 :
217 3472597 : MCSymbol *MCContext::createTempSymbol(bool CanBeUnnamed) {
218 6945194 : return createTempSymbol("tmp", true, CanBeUnnamed);
219 : }
220 :
221 165 : unsigned MCContext::NextInstance(unsigned LocalLabelVal) {
222 165 : MCLabel *&Label = Instances[LocalLabelVal];
223 165 : if (!Label)
224 54 : Label = new (*this) MCLabel(0);
225 330 : return Label->incInstance();
226 : }
227 :
228 186 : unsigned MCContext::GetInstance(unsigned LocalLabelVal) {
229 186 : MCLabel *&Label = Instances[LocalLabelVal];
230 186 : if (!Label)
231 70 : Label = new (*this) MCLabel(0);
232 186 : return Label->getInstance();
233 : }
234 :
235 351 : MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
236 : unsigned Instance) {
237 351 : MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)];
238 351 : if (!Sym)
239 175 : Sym = createTempSymbol(false);
240 351 : return Sym;
241 : }
242 :
243 165 : MCSymbol *MCContext::createDirectionalLocalSymbol(unsigned LocalLabelVal) {
244 165 : unsigned Instance = NextInstance(LocalLabelVal);
245 165 : return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
246 : }
247 :
248 186 : MCSymbol *MCContext::getDirectionalLocalSymbol(unsigned LocalLabelVal,
249 : bool Before) {
250 186 : unsigned Instance = GetInstance(LocalLabelVal);
251 186 : if (!Before)
252 124 : ++Instance;
253 186 : return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
254 : }
255 :
256 1817 : MCSymbol *MCContext::lookupSymbol(const Twine &Name) const {
257 : SmallString<128> NameSV;
258 1817 : StringRef NameRef = Name.toStringRef(NameSV);
259 1817 : return Symbols.lookup(NameRef);
260 : }
261 :
262 6 : void MCContext::setSymbolValue(MCStreamer &Streamer,
263 : StringRef Sym,
264 : uint64_t Val) {
265 6 : auto Symbol = getOrCreateSymbol(Sym);
266 6 : Streamer.EmitAssignment(Symbol, MCConstantExpr::create(Val, *this));
267 6 : }
268 :
269 : //===----------------------------------------------------------------------===//
270 : // Section Management
271 : //===----------------------------------------------------------------------===//
272 :
273 162231 : MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section,
274 : unsigned TypeAndAttributes,
275 : unsigned Reserved2, SectionKind Kind,
276 : const char *BeginSymName) {
277 : // We unique sections by their segment/section pair. The returned section
278 : // may not have the same flags as the requested section, if so this should be
279 : // diagnosed by the client as an error.
280 :
281 : // Form the name to look up.
282 : SmallString<64> Name;
283 : Name += Segment;
284 162229 : Name.push_back(',');
285 : Name += Section;
286 :
287 : // Do the lookup, if we have a hit, return it.
288 162228 : MCSectionMachO *&Entry = MachOUniquingMap[Name];
289 162231 : if (Entry)
290 : return Entry;
291 :
292 : MCSymbol *Begin = nullptr;
293 160684 : if (BeginSymName)
294 49185 : Begin = createTempSymbol(BeginSymName, false);
295 :
296 : // Otherwise, return a new section.
297 321368 : return Entry = new (MachOAllocator.Allocate()) MCSectionMachO(
298 160684 : Segment, Section, TypeAndAttributes, Reserved2, Kind, Begin);
299 : }
300 :
301 7 : void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) {
302 : StringRef GroupName;
303 7 : if (const MCSymbol *Group = Section->getGroup())
304 : GroupName = Group->getName();
305 :
306 7 : unsigned UniqueID = Section->getUniqueID();
307 : ELFUniquingMap.erase(
308 7 : ELFSectionKey{Section->getSectionName(), GroupName, UniqueID});
309 7 : auto I = ELFUniquingMap.insert(std::make_pair(
310 7 : ELFSectionKey{Name, GroupName, UniqueID},
311 : Section))
312 : .first;
313 : StringRef CachedName = I->first.SectionName;
314 : const_cast<MCSectionELF *>(Section)->setSectionName(CachedName);
315 7 : }
316 :
317 2736488 : MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
318 : unsigned Flags, SectionKind K,
319 : unsigned EntrySize,
320 : const MCSymbolELF *Group,
321 : unsigned UniqueID,
322 : const MCSymbolELF *Associated) {
323 : MCSymbolELF *R;
324 2736488 : MCSymbol *&Sym = Symbols[Section];
325 : // A section symbol can not redefine regular symbols. There may be multiple
326 : // sections with the same name, in which case the first such section wins.
327 3156727 : if (Sym && Sym->isDefined() &&
328 630339 : (!Sym->isInSection() || Sym->getSection().getBeginSymbol() != Sym))
329 1 : reportError(SMLoc(), "invalid symbol redefinition");
330 2946614 : if (Sym && Sym->isUndefined()) {
331 13 : R = cast<MCSymbolELF>(Sym);
332 : } else {
333 2736475 : auto NameIter = UsedNames.insert(std::make_pair(Section, false)).first;
334 2736476 : R = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
335 2736476 : if (!Sym)
336 2526363 : Sym = R;
337 : }
338 2736489 : R->setBinding(ELF::STB_LOCAL);
339 2736489 : R->setType(ELF::STT_SECTION);
340 :
341 : auto *Ret = new (ELFAllocator.Allocate()) MCSectionELF(
342 2736489 : Section, Type, Flags, K, EntrySize, Group, UniqueID, R, Associated);
343 :
344 2736489 : auto *F = new MCDataFragment();
345 : Ret->getFragmentList().insert(Ret->begin(), F);
346 : F->setParent(Ret);
347 : R->setFragment(F);
348 :
349 2736488 : return Ret;
350 : }
351 :
352 178102 : MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type,
353 : unsigned Flags, unsigned EntrySize,
354 : const MCSymbolELF *Group,
355 : const MCSectionELF *RelInfoSection) {
356 178102 : StringMap<bool>::iterator I;
357 : bool Inserted;
358 : std::tie(I, Inserted) =
359 698253 : RelSecNames.insert(std::make_pair(Name.str(), true));
360 :
361 178101 : return createELFSectionImpl(
362 : I->getKey(), Type, Flags, SectionKind::getReadOnly(), EntrySize, Group,
363 178102 : true, cast<MCSymbolELF>(RelInfoSection->getBeginSymbol()));
364 : }
365 :
366 124 : MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix,
367 : const Twine &Suffix, unsigned Type,
368 : unsigned Flags,
369 : unsigned EntrySize) {
370 124 : return getELFSection(Prefix + "." + Suffix, Type, Flags, EntrySize, Suffix);
371 : }
372 :
373 2801443 : MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
374 : unsigned Flags, unsigned EntrySize,
375 : const Twine &Group, unsigned UniqueID,
376 : const MCSymbolELF *Associated) {
377 : MCSymbolELF *GroupSym = nullptr;
378 3848868 : if (!Group.isTriviallyEmpty() && !Group.str().empty())
379 215685 : GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group));
380 :
381 2801444 : return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID,
382 2801444 : Associated);
383 : }
384 :
385 2802252 : MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
386 : unsigned Flags, unsigned EntrySize,
387 : const MCSymbolELF *GroupSym,
388 : unsigned UniqueID,
389 : const MCSymbolELF *Associated) {
390 : StringRef Group = "";
391 2802252 : if (GroupSym)
392 : Group = GroupSym->getName();
393 : // Do the lookup, if we have a hit, return it.
394 : auto IterBool = ELFUniquingMap.insert(
395 5604505 : std::make_pair(ELFSectionKey{Section.str(), Group, UniqueID}, nullptr));
396 : auto &Entry = *IterBool.first;
397 2802253 : if (!IterBool.second)
398 457840 : return Entry.second;
399 :
400 : StringRef CachedName = Entry.first.SectionName;
401 :
402 : SectionKind Kind;
403 2344413 : if (Flags & ELF::SHF_ARM_PURECODE)
404 448 : Kind = SectionKind::getExecuteOnly();
405 2343965 : else if (Flags & ELF::SHF_EXECINSTR)
406 228921 : Kind = SectionKind::getText();
407 : else
408 2115044 : Kind = SectionKind::getReadOnly();
409 :
410 2344413 : MCSectionELF *Result = createELFSectionImpl(
411 : CachedName, Type, Flags, Kind, EntrySize, GroupSym, UniqueID, Associated);
412 2344412 : Entry.second = Result;
413 2344412 : return Result;
414 : }
415 :
416 213974 : MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group) {
417 213974 : return createELFSectionImpl(".group", ELF::SHT_GROUP, 0,
418 : SectionKind::getReadOnly(), 4, Group, ~0,
419 213974 : nullptr);
420 : }
421 :
422 51121 : MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
423 : unsigned Characteristics,
424 : SectionKind Kind,
425 : StringRef COMDATSymName, int Selection,
426 : unsigned UniqueID,
427 : const char *BeginSymName) {
428 : MCSymbol *COMDATSymbol = nullptr;
429 51121 : if (!COMDATSymName.empty()) {
430 851 : COMDATSymbol = getOrCreateSymbol(COMDATSymName);
431 851 : COMDATSymName = COMDATSymbol->getName();
432 : }
433 :
434 :
435 : // Do the lookup, if we have a hit, return it.
436 : COFFSectionKey T{Section, COMDATSymName, Selection, UniqueID};
437 51121 : auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
438 : auto Iter = IterBool.first;
439 51121 : if (!IterBool.second)
440 566 : return Iter->second;
441 :
442 : MCSymbol *Begin = nullptr;
443 50555 : if (BeginSymName)
444 22218 : Begin = createTempSymbol(BeginSymName, false);
445 :
446 : StringRef CachedName = Iter->first.SectionName;
447 : MCSectionCOFF *Result = new (COFFAllocator.Allocate()) MCSectionCOFF(
448 50555 : CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin);
449 :
450 50555 : Iter->second = Result;
451 50555 : return Result;
452 : }
453 :
454 49710 : MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
455 : unsigned Characteristics,
456 : SectionKind Kind,
457 : const char *BeginSymName) {
458 49710 : return getCOFFSection(Section, Characteristics, Kind, "", 0, GenericSectionID,
459 49710 : BeginSymName);
460 : }
461 :
462 0 : MCSectionCOFF *MCContext::getCOFFSection(StringRef Section) {
463 : COFFSectionKey T{Section, "", 0, GenericSectionID};
464 : auto Iter = COFFUniquingMap.find(T);
465 0 : if (Iter == COFFUniquingMap.end())
466 : return nullptr;
467 0 : return Iter->second;
468 : }
469 :
470 765 : MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec,
471 : const MCSymbol *KeySym,
472 : unsigned UniqueID) {
473 : // Return the normal section if we don't have to be associative or unique.
474 765 : if (!KeySym && UniqueID == GenericSectionID)
475 : return Sec;
476 :
477 : // If we have a key symbol, make an associative section with the same name and
478 : // kind as the normal section.
479 181 : unsigned Characteristics = Sec->getCharacteristics();
480 181 : if (KeySym) {
481 154 : Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
482 154 : return getCOFFSection(Sec->getSectionName(), Characteristics,
483 : Sec->getKind(), KeySym->getName(),
484 154 : COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
485 : }
486 :
487 27 : return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(),
488 : "", 0, UniqueID);
489 : }
490 :
491 8735 : MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind K,
492 : const Twine &Group, unsigned UniqueID,
493 : const char *BeginSymName) {
494 : MCSymbolWasm *GroupSym = nullptr;
495 11901 : if (!Group.isTriviallyEmpty() && !Group.str().empty()) {
496 9 : GroupSym = cast<MCSymbolWasm>(getOrCreateSymbol(Group));
497 : GroupSym->setComdat(true);
498 : }
499 :
500 8735 : return getWasmSection(Section, K, GroupSym, UniqueID, BeginSymName);
501 : }
502 :
503 8735 : MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
504 : const MCSymbolWasm *GroupSym,
505 : unsigned UniqueID,
506 : const char *BeginSymName) {
507 : StringRef Group = "";
508 8735 : if (GroupSym)
509 : Group = GroupSym->getName();
510 : // Do the lookup, if we have a hit, return it.
511 : auto IterBool = WasmUniquingMap.insert(
512 17470 : std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr));
513 : auto &Entry = *IterBool.first;
514 8735 : if (!IterBool.second)
515 12 : return Entry.second;
516 :
517 : StringRef CachedName = Entry.first.SectionName;
518 :
519 8723 : MCSymbol *Begin = createSymbol(CachedName, false, false);
520 : cast<MCSymbolWasm>(Begin)->setType(wasm::WASM_SYMBOL_TYPE_SECTION);
521 :
522 : MCSectionWasm *Result = new (WasmAllocator.Allocate())
523 8723 : MCSectionWasm(CachedName, Kind, GroupSym, UniqueID, Begin);
524 8723 : Entry.second = Result;
525 :
526 8723 : auto *F = new MCDataFragment();
527 : Result->getFragmentList().insert(Result->begin(), F);
528 : F->setParent(Result);
529 : Begin->setFragment(F);
530 :
531 8723 : return Result;
532 : }
533 :
534 992 : MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
535 992 : return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
536 : }
537 :
538 2 : void MCContext::addDebugPrefixMapEntry(const std::string &From,
539 : const std::string &To) {
540 2 : DebugPrefixMap.insert(std::make_pair(From, To));
541 2 : }
542 :
543 12357 : void MCContext::RemapDebugPaths() {
544 12357 : const auto &DebugPrefixMap = this->DebugPrefixMap;
545 : const auto RemapDebugPath = [&DebugPrefixMap](std::string &Path) {
546 : for (const auto &Entry : DebugPrefixMap)
547 : if (StringRef(Path).startswith(Entry.first)) {
548 : std::string RemappedPath =
549 : (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
550 : Path.swap(RemappedPath);
551 : }
552 : };
553 :
554 : // Remap compilation directory.
555 : std::string CompDir = CompilationDir.str();
556 12357 : RemapDebugPath(CompDir);
557 : CompilationDir = CompDir;
558 :
559 : // Remap MCDwarfDirs in all compilation units.
560 13513 : for (auto &CUIDTablePair : MCDwarfLineTablesCUMap)
561 2685 : for (auto &Dir : CUIDTablePair.second.getMCDwarfDirs())
562 1529 : RemapDebugPath(Dir);
563 12356 : }
564 :
565 : //===----------------------------------------------------------------------===//
566 : // Dwarf Management
567 : //===----------------------------------------------------------------------===//
568 :
569 : /// getDwarfFile - takes a file name and number to place in the dwarf file and
570 : /// directory tables. If the file number has already been allocated it is an
571 : /// error and zero is returned and the client reports the error, else the
572 : /// allocated file number is returned. The file numbers may be in any order.
573 889181 : Expected<unsigned> MCContext::getDwarfFile(StringRef Directory,
574 : StringRef FileName,
575 : unsigned FileNumber,
576 : MD5::MD5Result *Checksum,
577 : Optional<StringRef> Source,
578 : unsigned CUID) {
579 889181 : MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
580 889181 : return Table.tryGetFile(Directory, FileName, Checksum, Source, FileNumber);
581 : }
582 :
583 : /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
584 : /// currently is assigned and false otherwise.
585 364 : bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
586 364 : const MCDwarfLineTable &LineTable = getMCDwarfLineTable(CUID);
587 364 : if (FileNumber == 0)
588 1 : return getDwarfVersion() >= 5 && LineTable.hasRootFile();
589 363 : if (FileNumber >= LineTable.getMCDwarfFiles().size())
590 : return false;
591 :
592 363 : return !LineTable.getMCDwarfFiles()[FileNumber].Name.empty();
593 : }
594 :
595 : /// Remove empty sections from SectionsForRanges, to avoid generating
596 : /// useless debug info for them.
597 39 : void MCContext::finalizeDwarfSections(MCStreamer &MCOS) {
598 39 : SectionsForRanges.remove_if(
599 46 : [&](MCSection *Sec) { return !MCOS.mayHaveInstructions(*Sec); });
600 39 : }
601 :
602 3747 : CodeViewContext &MCContext::getCVContext() {
603 3747 : if (!CVContext.get())
604 157 : CVContext.reset(new CodeViewContext);
605 3747 : return *CVContext.get();
606 : }
607 :
608 : //===----------------------------------------------------------------------===//
609 : // Error Reporting
610 : //===----------------------------------------------------------------------===//
611 :
612 360 : void MCContext::reportError(SMLoc Loc, const Twine &Msg) {
613 360 : HadError = true;
614 :
615 : // If we have a source manager use it. Otherwise, try using the inline source
616 : // manager.
617 : // If that fails, use the generic report_fatal_error().
618 360 : if (SrcMgr)
619 354 : SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
620 6 : else if (InlineSrcMgr)
621 5 : InlineSrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
622 : else
623 1 : report_fatal_error(Msg, false);
624 359 : }
625 :
626 4 : void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) {
627 4 : reportError(Loc, Msg);
628 :
629 : // If we reached here, we are failing ungracefully. Run the interrupt handlers
630 : // to make sure any special cleanups get done, in particular that we remove
631 : // files registered with RemoveFileOnSignal.
632 4 : sys::RunInterruptHandlers();
633 4 : exit(1);
634 : }
|
