1 //===- MCAsmBackend.cpp - Target MC Assembly Backend ----------------------===//
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/MCAsmBackend.h"
10 #include "llvm/MC/MCAssembler.h"
11 #include "llvm/MC/MCDXContainerWriter.h"
12 #include "llvm/MC/MCELFObjectWriter.h"
13 #include "llvm/MC/MCGOFFObjectWriter.h"
14 #include "llvm/MC/MCMachObjectWriter.h"
15 #include "llvm/MC/MCObjectWriter.h"
16 #include "llvm/MC/MCSPIRVObjectWriter.h"
17 #include "llvm/MC/MCWasmObjectWriter.h"
18 #include "llvm/MC/MCWinCOFFObjectWriter.h"
19 #include "llvm/MC/MCXCOFFObjectWriter.h"
20 #include <cassert>
21 #include <cstddef>
22 #include <cstdint>
23
24 using namespace llvm;
25
26 MCAsmBackend::~MCAsmBackend() = default;
27
getContext() const28 MCContext &MCAsmBackend::getContext() const { return Asm->getContext(); }
29
30 std::unique_ptr<MCObjectWriter>
createObjectWriter(raw_pwrite_stream & OS) const31 MCAsmBackend::createObjectWriter(raw_pwrite_stream &OS) const {
32 auto TW = createObjectTargetWriter();
33 bool IsLE = Endian == llvm::endianness::little;
34 switch (TW->getFormat()) {
35 case Triple::MachO:
36 return std::make_unique<MachObjectWriter>(
37 cast<MCMachObjectTargetWriter>(std::move(TW)), OS, IsLE);
38 case Triple::COFF:
39 return createWinCOFFObjectWriter(
40 cast<MCWinCOFFObjectTargetWriter>(std::move(TW)), OS);
41 case Triple::ELF:
42 return std::make_unique<ELFObjectWriter>(
43 cast<MCELFObjectTargetWriter>(std::move(TW)), OS, IsLE);
44 case Triple::SPIRV:
45 return createSPIRVObjectWriter(
46 cast<MCSPIRVObjectTargetWriter>(std::move(TW)), OS);
47 case Triple::Wasm:
48 return createWasmObjectWriter(cast<MCWasmObjectTargetWriter>(std::move(TW)),
49 OS);
50 case Triple::GOFF:
51 return createGOFFObjectWriter(cast<MCGOFFObjectTargetWriter>(std::move(TW)),
52 OS);
53 case Triple::XCOFF:
54 return createXCOFFObjectWriter(
55 cast<MCXCOFFObjectTargetWriter>(std::move(TW)), OS);
56 case Triple::DXContainer:
57 return std::make_unique<DXContainerObjectWriter>(
58 cast<MCDXContainerTargetWriter>(std::move(TW)), OS);
59 default:
60 llvm_unreachable("unexpected object format");
61 }
62 }
63
64 std::unique_ptr<MCObjectWriter>
createDwoObjectWriter(raw_pwrite_stream & OS,raw_pwrite_stream & DwoOS) const65 MCAsmBackend::createDwoObjectWriter(raw_pwrite_stream &OS,
66 raw_pwrite_stream &DwoOS) const {
67 auto TW = createObjectTargetWriter();
68 switch (TW->getFormat()) {
69 case Triple::COFF:
70 return createWinCOFFDwoObjectWriter(
71 cast<MCWinCOFFObjectTargetWriter>(std::move(TW)), OS, DwoOS);
72 case Triple::ELF:
73 return std::make_unique<ELFObjectWriter>(
74 cast<MCELFObjectTargetWriter>(std::move(TW)), OS, DwoOS,
75 Endian == llvm::endianness::little);
76 case Triple::Wasm:
77 return createWasmDwoObjectWriter(
78 cast<MCWasmObjectTargetWriter>(std::move(TW)), OS, DwoOS);
79 default:
80 report_fatal_error("dwo only supported with COFF, ELF, and Wasm");
81 }
82 }
83
getFixupKind(StringRef Name) const84 std::optional<MCFixupKind> MCAsmBackend::getFixupKind(StringRef Name) const {
85 return std::nullopt;
86 }
87
getFixupKindInfo(MCFixupKind Kind) const88 MCFixupKindInfo MCAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
89 // clang-format off
90 static const MCFixupKindInfo Builtins[] = {
91 {"FK_NONE", 0, 0, 0},
92 {"FK_Data_1", 0, 8, 0},
93 {"FK_Data_2", 0, 16, 0},
94 {"FK_Data_4", 0, 32, 0},
95 {"FK_Data_8", 0, 64, 0},
96 {"FK_Data_leb128", 0, 0, 0},
97 {"FK_SecRel_1", 0, 8, 0},
98 {"FK_SecRel_2", 0, 16, 0},
99 {"FK_SecRel_4", 0, 32, 0},
100 {"FK_SecRel_8", 0, 64, 0},
101 };
102 // clang-format on
103
104 assert(size_t(Kind - FK_NONE) < std::size(Builtins) && "Unknown fixup kind");
105 return Builtins[Kind - FK_NONE];
106 }
107
fixupNeedsRelaxationAdvanced(const MCFixup & Fixup,const MCValue &,uint64_t Value,bool Resolved) const108 bool MCAsmBackend::fixupNeedsRelaxationAdvanced(const MCFixup &Fixup,
109 const MCValue &, uint64_t Value,
110 bool Resolved) const {
111 if (!Resolved)
112 return true;
113 return fixupNeedsRelaxation(Fixup, Value);
114 }
115
maybeAddReloc(const MCFragment & F,const MCFixup & Fixup,const MCValue & Target,uint64_t & Value,bool IsResolved)116 void MCAsmBackend::maybeAddReloc(const MCFragment &F, const MCFixup &Fixup,
117 const MCValue &Target, uint64_t &Value,
118 bool IsResolved) {
119 if (!IsResolved)
120 Asm->getWriter().recordRelocation(F, Fixup, Target, Value);
121 }
122
isDarwinCanonicalPersonality(const MCSymbol * Sym) const123 bool MCAsmBackend::isDarwinCanonicalPersonality(const MCSymbol *Sym) const {
124 // Consider a NULL personality (ie., no personality encoding) to be canonical
125 // because it's always at 0.
126 if (!Sym)
127 return true;
128
129 if (!Sym->isMachO())
130 llvm_unreachable("Expected MachO symbols only");
131
132 StringRef name = Sym->getName();
133 // XXX: We intentionally leave out "___gcc_personality_v0" because, despite
134 // being system-defined like these two, it is not very commonly-used.
135 // Reserving an empty slot for it seems silly.
136 return name == "___gxx_personality_v0" || name == "___objc_personality_v0";
137 }
138
getSubtargetInfo(const MCFragment & F)139 const MCSubtargetInfo *MCAsmBackend::getSubtargetInfo(const MCFragment &F) {
140 const MCSubtargetInfo *STI = nullptr;
141 if (auto *DF = dyn_cast<MCEncodedFragment>(&F)) {
142 STI = DF->getSubtargetInfo();
143 assert(!DF->hasInstructions() || STI != nullptr);
144 }
145 return STI;
146 }
147