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