LLVM 17.0.0git
PPCMCTargetDesc.cpp
Go to the documentation of this file.
1//===-- PPCMCTargetDesc.cpp - PowerPC Target Descriptions -----------------===//
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// This file provides PowerPC specific target descriptions.
10//
11//===----------------------------------------------------------------------===//
12
16#include "PPCELFStreamer.h"
17#include "PPCTargetStreamer.h"
18#include "PPCXCOFFStreamer.h"
21#include "llvm/ADT/StringRef.h"
24#include "llvm/MC/MCAssembler.h"
26#include "llvm/MC/MCContext.h"
27#include "llvm/MC/MCDwarf.h"
29#include "llvm/MC/MCExpr.h"
31#include "llvm/MC/MCInstrInfo.h"
35#include "llvm/MC/MCStreamer.h"
37#include "llvm/MC/MCSymbol.h"
38#include "llvm/MC/MCSymbolELF.h"
47
48using namespace llvm;
49
50#define GET_INSTRINFO_MC_DESC
51#define ENABLE_INSTR_PREDICATE_VERIFIER
52#include "PPCGenInstrInfo.inc"
53
54#define GET_SUBTARGETINFO_MC_DESC
55#include "PPCGenSubtargetInfo.inc"
56
57#define GET_REGINFO_MC_DESC
58#include "PPCGenRegisterInfo.inc"
59
61
62// Pin the vtable to this file.
64
66 MCInstrInfo *X = new MCInstrInfo();
67 InitPPCMCInstrInfo(X);
68 return X;
69}
70
72 bool isPPC64 =
73 (TT.getArch() == Triple::ppc64 || TT.getArch() == Triple::ppc64le);
74 unsigned Flavour = isPPC64 ? 0 : 1;
75 unsigned RA = isPPC64 ? PPC::LR8 : PPC::LR;
76
78 InitPPCMCRegisterInfo(X, RA, Flavour, Flavour);
79 return X;
80}
81
83 StringRef CPU, StringRef FS) {
84 // Set some default feature to MC layer.
85 std::string FullFS = std::string(FS);
86
87 if (TT.isOSAIX()) {
88 if (!FullFS.empty())
89 FullFS = "+aix," + FullFS;
90 else
91 FullFS = "+aix";
92 }
93
94 return createPPCMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FullFS);
95}
96
98 const Triple &TheTriple,
99 const MCTargetOptions &Options) {
100 bool isPPC64 = (TheTriple.getArch() == Triple::ppc64 ||
101 TheTriple.getArch() == Triple::ppc64le);
102
103 MCAsmInfo *MAI;
104 if (TheTriple.isOSBinFormatXCOFF())
105 MAI = new PPCXCOFFMCAsmInfo(isPPC64, TheTriple);
106 else
107 MAI = new PPCELFMCAsmInfo(isPPC64, TheTriple);
108
109 // Initial state of the frame pointer is R1.
110 unsigned Reg = isPPC64 ? PPC::X1 : PPC::R1;
111 MCCFIInstruction Inst =
112 MCCFIInstruction::cfiDefCfa(nullptr, MRI.getDwarfRegNum(Reg, true), 0);
113 MAI->addInitialFrameState(Inst);
114
115 return MAI;
116}
117
118static MCStreamer *
120 std::unique_ptr<MCAsmBackend> &&MAB,
121 std::unique_ptr<MCObjectWriter> &&OW,
122 std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll) {
123 return createPPCELFStreamer(Context, std::move(MAB), std::move(OW),
124 std::move(Emitter));
125}
126
128 const Triple &T, MCContext &Context, std::unique_ptr<MCAsmBackend> &&MAB,
129 std::unique_ptr<MCObjectWriter> &&OW,
130 std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll) {
131 return createPPCXCOFFStreamer(Context, std::move(MAB), std::move(OW),
132 std::move(Emitter));
133}
134
135namespace {
136
137class PPCTargetAsmStreamer : public PPCTargetStreamer {
139
140public:
141 PPCTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
142 : PPCTargetStreamer(S), OS(OS) {}
143
144 void emitTCEntry(const MCSymbol &S,
145 MCSymbolRefExpr::VariantKind Kind) override {
146 if (const MCSymbolXCOFF *XSym = dyn_cast<MCSymbolXCOFF>(&S)) {
147 MCSymbolXCOFF *TCSym =
148 cast<MCSectionXCOFF>(Streamer.getCurrentSectionOnly())
149 ->getQualNameSymbol();
150 // If the variant kind is VK_PPC_AIX_TLSGDM the entry represents the
151 // region handle for the symbol, we add the relocation specifier @m.
152 // If the variant kind is VK_PPC_AIX_TLSGD the entry represents the
153 // variable offset for the symbol, we add the relocation specifier @gd.
154 if (Kind == MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGD ||
155 Kind == MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM)
156 OS << "\t.tc " << TCSym->getName() << "," << XSym->getName() << "@"
158 else
159 OS << "\t.tc " << TCSym->getName() << "," << XSym->getName() << '\n';
160
161 if (TCSym->hasRename())
162 Streamer.emitXCOFFRenameDirective(TCSym, TCSym->getSymbolTableName());
163 return;
164 }
165
166 OS << "\t.tc " << S.getName() << "[TC]," << S.getName() << '\n';
167 }
168
169 void emitMachine(StringRef CPU) override {
170 OS << "\t.machine " << CPU << '\n';
171 }
172
173 void emitAbiVersion(int AbiVersion) override {
174 OS << "\t.abiversion " << AbiVersion << '\n';
175 }
176
177 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
178 const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
179
180 OS << "\t.localentry\t";
181 S->print(OS, MAI);
182 OS << ", ";
183 LocalOffset->print(OS, MAI);
184 OS << '\n';
185 }
186};
187
188class PPCTargetELFStreamer : public PPCTargetStreamer {
189public:
190 PPCTargetELFStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
191
192 MCELFStreamer &getStreamer() {
193 return static_cast<MCELFStreamer &>(Streamer);
194 }
195
196 void emitTCEntry(const MCSymbol &S,
197 MCSymbolRefExpr::VariantKind Kind) override {
198 // Creates a R_PPC64_TOC relocation
199 Streamer.emitValueToAlignment(Align(8));
200 Streamer.emitSymbolValue(&S, 8);
201 }
202
203 void emitMachine(StringRef CPU) override {
204 // FIXME: Is there anything to do in here or does this directive only
205 // limit the parser?
206 }
207
208 void emitAbiVersion(int AbiVersion) override {
209 MCAssembler &MCA = getStreamer().getAssembler();
210 unsigned Flags = MCA.getELFHeaderEFlags();
211 Flags &= ~ELF::EF_PPC64_ABI;
212 Flags |= (AbiVersion & ELF::EF_PPC64_ABI);
214 }
215
216 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
217 MCAssembler &MCA = getStreamer().getAssembler();
218
219 // encodePPC64LocalEntryOffset will report an error if it cannot
220 // encode LocalOffset.
221 unsigned Encoded = encodePPC64LocalEntryOffset(LocalOffset);
222
223 unsigned Other = S->getOther();
224 Other &= ~ELF::STO_PPC64_LOCAL_MASK;
225 Other |= Encoded;
226 S->setOther(Other);
227
228 // For GAS compatibility, unless we already saw a .abiversion directive,
229 // set e_flags to indicate ELFv2 ABI.
230 unsigned Flags = MCA.getELFHeaderEFlags();
231 if ((Flags & ELF::EF_PPC64_ABI) == 0)
232 MCA.setELFHeaderEFlags(Flags | 2);
233 }
234
235 void emitAssignment(MCSymbol *S, const MCExpr *Value) override {
236 auto *Symbol = cast<MCSymbolELF>(S);
237
238 // When encoding an assignment to set symbol A to symbol B, also copy
239 // the st_other bits encoding the local entry point offset.
240 if (copyLocalEntry(Symbol, Value))
241 UpdateOther.insert(Symbol);
242 else
243 UpdateOther.erase(Symbol);
244 }
245
246 void finish() override {
247 for (auto *Sym : UpdateOther)
248 if (Sym->isVariable())
249 copyLocalEntry(Sym, Sym->getVariableValue());
250
251 // Clear the set of symbols that needs to be updated so the streamer can
252 // be reused without issues.
253 UpdateOther.clear();
254 }
255
256private:
258
259 bool copyLocalEntry(MCSymbolELF *D, const MCExpr *S) {
260 auto *Ref = dyn_cast<const MCSymbolRefExpr>(S);
261 if (!Ref)
262 return false;
263 const auto &RhsSym = cast<MCSymbolELF>(Ref->getSymbol());
264 unsigned Other = D->getOther();
265 Other &= ~ELF::STO_PPC64_LOCAL_MASK;
266 Other |= RhsSym.getOther() & ELF::STO_PPC64_LOCAL_MASK;
267 D->setOther(Other);
268 return true;
269 }
270
271 unsigned encodePPC64LocalEntryOffset(const MCExpr *LocalOffset) {
272 MCAssembler &MCA = getStreamer().getAssembler();
273 int64_t Offset;
274 if (!LocalOffset->evaluateAsAbsolute(Offset, MCA))
275 MCA.getContext().reportError(LocalOffset->getLoc(),
276 ".localentry expression must be absolute");
277
278 switch (Offset) {
279 default:
281 LocalOffset->getLoc(), ".localentry expression must be a power of 2");
282 return 0;
283 case 0:
284 return 0;
285 case 1:
286 return 1 << ELF::STO_PPC64_LOCAL_BIT;
287 case 4:
288 case 8:
289 case 16:
290 case 32:
291 case 64:
293 }
294 }
295};
296
297class PPCTargetMachOStreamer : public PPCTargetStreamer {
298public:
299 PPCTargetMachOStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
300
301 void emitTCEntry(const MCSymbol &S,
302 MCSymbolRefExpr::VariantKind Kind) override {
303 llvm_unreachable("Unknown pseudo-op: .tc");
304 }
305
306 void emitMachine(StringRef CPU) override {
307 // FIXME: We should update the CPUType, CPUSubType in the Object file if
308 // the new values are different from the defaults.
309 }
310
311 void emitAbiVersion(int AbiVersion) override {
312 llvm_unreachable("Unknown pseudo-op: .abiversion");
313 }
314
315 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
316 llvm_unreachable("Unknown pseudo-op: .localentry");
317 }
318};
319
320class PPCTargetXCOFFStreamer : public PPCTargetStreamer {
321public:
322 PPCTargetXCOFFStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
323
324 void emitTCEntry(const MCSymbol &S,
325 MCSymbolRefExpr::VariantKind Kind) override {
326 const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
327 const unsigned PointerSize = MAI->getCodePointerSize();
328 Streamer.emitValueToAlignment(Align(PointerSize));
329 Streamer.emitValue(MCSymbolRefExpr::create(&S, Kind, Streamer.getContext()),
330 PointerSize);
331 }
332
333 void emitMachine(StringRef CPU) override {
334 llvm_unreachable("Machine pseudo-ops are invalid for XCOFF.");
335 }
336
337 void emitAbiVersion(int AbiVersion) override {
338 llvm_unreachable("ABI-version pseudo-ops are invalid for XCOFF.");
339 }
340
341 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
342 llvm_unreachable("Local-entry pseudo-ops are invalid for XCOFF.");
343 }
344};
345
346} // end anonymous namespace
347
350 MCInstPrinter *InstPrint,
351 bool isVerboseAsm) {
352 return new PPCTargetAsmStreamer(S, OS);
353}
354
356 return new PPCTargetStreamer(S);
357}
358
359static MCTargetStreamer *
361 const Triple &TT = STI.getTargetTriple();
362 if (TT.isOSBinFormatELF())
363 return new PPCTargetELFStreamer(S);
364 if (TT.isOSBinFormatXCOFF())
365 return new PPCTargetXCOFFStreamer(S);
366 return new PPCTargetMachOStreamer(S);
367}
368
370 unsigned SyntaxVariant,
371 const MCAsmInfo &MAI,
372 const MCInstrInfo &MII,
373 const MCRegisterInfo &MRI) {
374 return new PPCInstPrinter(MAI, MII, MRI, T);
375}
376
377namespace {
378
379class PPCMCInstrAnalysis : public MCInstrAnalysis {
380public:
381 explicit PPCMCInstrAnalysis(const MCInstrInfo *Info)
383
384 bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
385 uint64_t &Target) const override {
386 unsigned NumOps = Inst.getNumOperands();
387 if (NumOps == 0 ||
388 Info->get(Inst.getOpcode()).operands()[NumOps - 1].OperandType !=
390 return false;
391 Target = Addr + Inst.getOperand(NumOps - 1).getImm() * Size;
392 return true;
393 }
394};
395
396} // end anonymous namespace
397
399 return new PPCMCInstrAnalysis(Info);
400}
401
405 // Register the MC asm info.
407
408 // Register the MC instruction info.
410
411 // Register the MC register info.
413
414 // Register the MC subtarget info.
416
417 // Register the MC instruction analyzer.
419
420 // Register the MC Code Emitter
422
423 // Register the asm backend.
425
426 // Register the elf streamer.
428
429 // Register the XCOFF streamer.
431
432 // Register the object target streamer.
435
436 // Register the asm target streamer.
438
439 // Register the null target streamer.
441
442 // Register the MCInstPrinter.
444 }
445}
unsigned const MachineRegisterInfo * MRI
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:127
dxil DXContainer Global Emitter
uint64_t Addr
uint64_t Size
std::optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1260
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static LVOptions Options
Definition: LVOptions.cpp:25
static MCTargetStreamer * createNullTargetStreamer(MCStreamer &S)
LLVMContext & Context
static MCTargetStreamer * createAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool isVerboseAsm)
LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCTargetMC()
static MCInstPrinter * createPPCMCInstPrinter(const Triple &T, unsigned SyntaxVariant, const MCAsmInfo &MAI, const MCInstrInfo &MII, const MCRegisterInfo &MRI)
static MCTargetStreamer * createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI)
static MCInstrAnalysis * createPPCMCInstrAnalysis(const MCInstrInfo *Info)
static MCAsmInfo * createPPCMCAsmInfo(const MCRegisterInfo &MRI, const Triple &TheTriple, const MCTargetOptions &Options)
static MCSubtargetInfo * createPPCMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS)
static MCRegisterInfo * createPPCMCRegisterInfo(const Triple &TT)
static MCInstrInfo * createPPCMCInstrInfo()
SI optimize exec mask operations pre RA
raw_pwrite_stream & OS
This file defines the SmallPtrSet class.
@ Flags
Definition: TextStubV5.cpp:93
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
void addInitialFrameState(const MCCFIInstruction &Inst)
Definition: MCAsmInfo.cpp:86
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:550
MCContext & getContext() const
Definition: MCAssembler.h:321
unsigned getELFHeaderEFlags() const
ELF e_header flags.
Definition: MCAssembler.h:276
void setELFHeaderEFlags(unsigned Flags)
Definition: MCAssembler.h:277
static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int Offset)
.cfi_def_cfa defines a rule for computing CFA as: take address from Register and add Offset to it.
Definition: MCDwarf.h:533
Context object for machine code objects.
Definition: MCContext.h:76
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1052
void emitValueToAlignment(Align, int64_t, unsigned, unsigned) override
Emit some number of copies of Value until the byte alignment ByteAlignment is reached.
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
void print(raw_ostream &OS, const MCAsmInfo *MAI, bool InParens=false) const
Definition: MCExpr.cpp:41
SMLoc getLoc() const
Definition: MCExpr.h:82
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:44
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
unsigned getNumOperands() const
Definition: MCInst.h:208
unsigned getOpcode() const
Definition: MCInst.h:198
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:206
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:26
int64_t getImm() const
Definition: MCInst.h:80
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Streaming machine code generation interface.
Definition: MCStreamer.h:212
Generic base class for all target subtargets.
const Triple & getTargetTriple() const
unsigned getOther() const
void setOther(unsigned Other)
static StringRef getVariantKindName(VariantKind Kind)
Definition: MCExpr.cpp:221
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:386
StringRef getSymbolTableName() const
Definition: MCSymbolXCOFF.h:59
bool hasRename() const
Definition: MCSymbolXCOFF.h:55
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition: MCSymbol.cpp:58
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:203
Target specific streamer interface.
Definition: MCStreamer.h:93
~PPCTargetStreamer() override
PPCTargetStreamer(MCStreamer &S)
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
ArchType getArch() const
Get the parsed architecture type of this triple.
Definition: Triple.h:356
bool isOSBinFormatXCOFF() const
Tests whether the OS uses the XCOFF binary format.
Definition: Triple.h:698
LLVM Value Representation.
Definition: Value.h:74
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ EF_PPC64_ABI
Definition: ELF.h:403
@ STO_PPC64_LOCAL_MASK
Definition: ELF.h:409
@ STO_PPC64_LOCAL_BIT
Definition: ELF.h:408
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:406
Target & getThePPC64LETarget()
Target & getThePPC32Target()
MCAsmBackend * createPPCAsmBackend(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options)
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
Definition: MathExtras.h:382
MCXCOFFStreamer * createPPCXCOFFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > MAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
@ Ref
The access may reference the value stored in memory.
Target & getThePPC64Target()
MCCodeEmitter * createPPCMCCodeEmitter(const MCInstrInfo &MCII, MCContext &Ctx)
Target & getThePPC32LETarget()
MCELFStreamer * createPPCELFStreamer(MCContext &Context, std::unique_ptr< MCAsmBackend > MAB, std::unique_ptr< MCObjectWriter > OW, std::unique_ptr< MCCodeEmitter > Emitter)
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn)
RegisterMCRegInfo - Register a MCRegisterInfo implementation for the given target.
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn)
RegisterMCAsmBackend - Register a MCAsmBackend implementation for the given target.
static void RegisterXCOFFStreamer(Target &T, Target::XCOFFStreamerCtorTy Fn)
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn)
RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the given target.
static void RegisterMCSubtargetInfo(Target &T, Target::MCSubtargetInfoCtorFnTy Fn)
RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for the given target.
static void RegisterObjectTargetStreamer(Target &T, Target::ObjectTargetStreamerCtorTy Fn)
static void RegisterMCInstrAnalysis(Target &T, Target::MCInstrAnalysisCtorFnTy Fn)
RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for the given target.
static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn)
static void RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn)
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn)
RegisterMCInstPrinter - Register a MCInstPrinter implementation for the given target.
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn)
RegisterMCInstrInfo - Register a MCInstrInfo implementation for the given target.
static void RegisterAsmTargetStreamer(Target &T, Target::AsmTargetStreamerCtorTy Fn)