1 //===-- PPCMCTargetDesc.cpp - PowerPC Target Descriptions -----------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file provides PowerPC specific target descriptions.
11 //===----------------------------------------------------------------------===//
13 #include "MCTargetDesc/PPCMCTargetDesc.h"
14 #include "MCTargetDesc/PPCInstPrinter.h"
15 #include "MCTargetDesc/PPCMCAsmInfo.h"
16 #include "PPCELFStreamer.h"
17 #include "PPCTargetStreamer.h"
18 #include "TargetInfo/PowerPCTargetInfo.h"
19 #include "llvm/ADT/SmallPtrSet.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/BinaryFormat/ELF.h"
23 #include "llvm/MC/MCAssembler.h"
24 #include "llvm/MC/MCAsmBackend.h"
25 #include "llvm/MC/MCCodeEmitter.h"
26 #include "llvm/MC/MCContext.h"
27 #include "llvm/MC/MCDwarf.h"
28 #include "llvm/MC/MCELFStreamer.h"
29 #include "llvm/MC/MCExpr.h"
30 #include "llvm/MC/MCInstrInfo.h"
31 #include "llvm/MC/MCObjectWriter.h"
32 #include "llvm/MC/MCRegisterInfo.h"
33 #include "llvm/MC/MCStreamer.h"
34 #include "llvm/MC/MCSubtargetInfo.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/MC/MCSymbolELF.h"
37 #include "llvm/MC/MCSymbolXCOFF.h"
38 #include "llvm/Support/Casting.h"
39 #include "llvm/Support/CodeGen.h"
40 #include "llvm/Support/ErrorHandling.h"
41 #include "llvm/Support/FormattedStream.h"
42 #include "llvm/Support/TargetRegistry.h"
43 #include "llvm/Support/raw_ostream.h"
47 #define GET_INSTRINFO_MC_DESC
48 #include "PPCGenInstrInfo.inc"
50 #define GET_SUBTARGETINFO_MC_DESC
51 #include "PPCGenSubtargetInfo.inc"
53 #define GET_REGINFO_MC_DESC
54 #include "PPCGenRegisterInfo.inc"
56 PPCTargetStreamer::PPCTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
58 // Pin the vtable to this file.
59 PPCTargetStreamer::~PPCTargetStreamer() = default;
61 static MCInstrInfo *createPPCMCInstrInfo() {
62 MCInstrInfo *X = new MCInstrInfo();
63 InitPPCMCInstrInfo(X);
67 static MCRegisterInfo *createPPCMCRegisterInfo(const Triple &TT) {
69 (TT.getArch() == Triple::ppc64 || TT.getArch() == Triple::ppc64le);
70 unsigned Flavour = isPPC64 ? 0 : 1;
71 unsigned RA = isPPC64 ? PPC::LR8 : PPC::LR;
73 MCRegisterInfo *X = new MCRegisterInfo();
74 InitPPCMCRegisterInfo(X, RA, Flavour, Flavour);
78 static MCSubtargetInfo *createPPCMCSubtargetInfo(const Triple &TT,
79 StringRef CPU, StringRef FS) {
80 return createPPCMCSubtargetInfoImpl(TT, CPU, FS);
83 static MCAsmInfo *createPPCMCAsmInfo(const MCRegisterInfo &MRI,
84 const Triple &TheTriple,
85 const MCTargetOptions &Options) {
86 bool isPPC64 = (TheTriple.getArch() == Triple::ppc64 ||
87 TheTriple.getArch() == Triple::ppc64le);
90 if (TheTriple.isOSBinFormatXCOFF())
91 MAI = new PPCXCOFFMCAsmInfo(isPPC64, TheTriple);
93 MAI = new PPCELFMCAsmInfo(isPPC64, TheTriple);
95 // Initial state of the frame pointer is R1.
96 unsigned Reg = isPPC64 ? PPC::X1 : PPC::R1;
97 MCCFIInstruction Inst =
98 MCCFIInstruction::cfiDefCfa(nullptr, MRI.getDwarfRegNum(Reg, true), 0);
99 MAI->addInitialFrameState(Inst);
104 static MCStreamer *createPPCMCStreamer(const Triple &T, MCContext &Context,
105 std::unique_ptr<MCAsmBackend> &&MAB,
106 std::unique_ptr<MCObjectWriter> &&OW,
107 std::unique_ptr<MCCodeEmitter> &&Emitter,
109 return createPPCELFStreamer(Context, std::move(MAB), std::move(OW),
115 class PPCTargetAsmStreamer : public PPCTargetStreamer {
116 formatted_raw_ostream &OS;
119 PPCTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
120 : PPCTargetStreamer(S), OS(OS) {}
122 void emitTCEntry(const MCSymbol &S) override {
123 if (const MCSymbolXCOFF *XSym = dyn_cast<MCSymbolXCOFF>(&S)) {
124 MCSymbolXCOFF *TCSym =
125 cast<MCSymbolXCOFF>(Streamer.getContext().getOrCreateSymbol(
126 XSym->getSymbolTableName() + "[TC]"));
127 if (TCSym->hasRename())
128 Streamer.emitXCOFFRenameDirective(TCSym, TCSym->getSymbolTableName());
129 OS << "\t.tc " << TCSym->getName() << "," << XSym->getName() << '\n';
133 OS << "\t.tc " << S.getName() << "[TC]," << S.getName() << '\n';
136 void emitMachine(StringRef CPU) override {
137 OS << "\t.machine " << CPU << '\n';
140 void emitAbiVersion(int AbiVersion) override {
141 OS << "\t.abiversion " << AbiVersion << '\n';
144 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
145 const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
147 OS << "\t.localentry\t";
150 LocalOffset->print(OS, MAI);
155 class PPCTargetELFStreamer : public PPCTargetStreamer {
157 PPCTargetELFStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
159 MCELFStreamer &getStreamer() {
160 return static_cast<MCELFStreamer &>(Streamer);
163 void emitTCEntry(const MCSymbol &S) override {
164 // Creates a R_PPC64_TOC relocation
165 Streamer.emitValueToAlignment(8);
166 Streamer.emitSymbolValue(&S, 8);
169 void emitMachine(StringRef CPU) override {
170 // FIXME: Is there anything to do in here or does this directive only
174 void emitAbiVersion(int AbiVersion) override {
175 MCAssembler &MCA = getStreamer().getAssembler();
176 unsigned Flags = MCA.getELFHeaderEFlags();
177 Flags &= ~ELF::EF_PPC64_ABI;
178 Flags |= (AbiVersion & ELF::EF_PPC64_ABI);
179 MCA.setELFHeaderEFlags(Flags);
182 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
183 MCAssembler &MCA = getStreamer().getAssembler();
185 // encodePPC64LocalEntryOffset will report an error if it cannot
186 // encode LocalOffset.
187 unsigned Encoded = encodePPC64LocalEntryOffset(LocalOffset);
189 unsigned Other = S->getOther();
190 Other &= ~ELF::STO_PPC64_LOCAL_MASK;
194 // For GAS compatibility, unless we already saw a .abiversion directive,
195 // set e_flags to indicate ELFv2 ABI.
196 unsigned Flags = MCA.getELFHeaderEFlags();
197 if ((Flags & ELF::EF_PPC64_ABI) == 0)
198 MCA.setELFHeaderEFlags(Flags | 2);
201 void emitAssignment(MCSymbol *S, const MCExpr *Value) override {
202 auto *Symbol = cast<MCSymbolELF>(S);
204 // When encoding an assignment to set symbol A to symbol B, also copy
205 // the st_other bits encoding the local entry point offset.
206 if (copyLocalEntry(Symbol, Value))
207 UpdateOther.insert(Symbol);
209 UpdateOther.erase(Symbol);
212 void finish() override {
213 for (auto *Sym : UpdateOther)
214 if (Sym->isVariable())
215 copyLocalEntry(Sym, Sym->getVariableValue());
217 // Clear the set of symbols that needs to be updated so the streamer can
218 // be reused without issues.
223 SmallPtrSet<MCSymbolELF *, 32> UpdateOther;
225 bool copyLocalEntry(MCSymbolELF *D, const MCExpr *S) {
226 auto *Ref = dyn_cast<const MCSymbolRefExpr>(S);
229 const auto &RhsSym = cast<MCSymbolELF>(Ref->getSymbol());
230 unsigned Other = D->getOther();
231 Other &= ~ELF::STO_PPC64_LOCAL_MASK;
232 Other |= RhsSym.getOther() & ELF::STO_PPC64_LOCAL_MASK;
237 unsigned encodePPC64LocalEntryOffset(const MCExpr *LocalOffset) {
238 MCAssembler &MCA = getStreamer().getAssembler();
240 if (!LocalOffset->evaluateAsAbsolute(Offset, MCA))
241 MCA.getContext().reportFatalError(
242 LocalOffset->getLoc(), ".localentry expression must be absolute.");
246 MCA.getContext().reportFatalError(
247 LocalOffset->getLoc(),
248 ".localentry expression is not a valid power of 2.");
252 return 1 << ELF::STO_PPC64_LOCAL_BIT;
258 return (int)Log2(Offset) << (int)ELF::STO_PPC64_LOCAL_BIT;
263 class PPCTargetMachOStreamer : public PPCTargetStreamer {
265 PPCTargetMachOStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
267 void emitTCEntry(const MCSymbol &S) override {
268 llvm_unreachable("Unknown pseudo-op: .tc");
271 void emitMachine(StringRef CPU) override {
272 // FIXME: We should update the CPUType, CPUSubType in the Object file if
273 // the new values are different from the defaults.
276 void emitAbiVersion(int AbiVersion) override {
277 llvm_unreachable("Unknown pseudo-op: .abiversion");
280 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
281 llvm_unreachable("Unknown pseudo-op: .localentry");
285 class PPCTargetXCOFFStreamer : public PPCTargetStreamer {
287 PPCTargetXCOFFStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
289 void emitTCEntry(const MCSymbol &S) override {
290 const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
291 const unsigned PointerSize = MAI->getCodePointerSize();
292 Streamer.emitValueToAlignment(PointerSize);
293 Streamer.emitSymbolValue(&S, PointerSize);
296 void emitMachine(StringRef CPU) override {
297 llvm_unreachable("Machine pseudo-ops are invalid for XCOFF.");
300 void emitAbiVersion(int AbiVersion) override {
301 llvm_unreachable("ABI-version pseudo-ops are invalid for XCOFF.");
304 void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
305 llvm_unreachable("Local-entry pseudo-ops are invalid for XCOFF.");
309 } // end anonymous namespace
311 static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
312 formatted_raw_ostream &OS,
313 MCInstPrinter *InstPrint,
315 return new PPCTargetAsmStreamer(S, OS);
318 static MCTargetStreamer *
319 createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
320 const Triple &TT = STI.getTargetTriple();
321 if (TT.isOSBinFormatELF())
322 return new PPCTargetELFStreamer(S);
323 if (TT.isOSBinFormatXCOFF())
324 return new PPCTargetXCOFFStreamer(S);
325 return new PPCTargetMachOStreamer(S);
328 static MCInstPrinter *createPPCMCInstPrinter(const Triple &T,
329 unsigned SyntaxVariant,
330 const MCAsmInfo &MAI,
331 const MCInstrInfo &MII,
332 const MCRegisterInfo &MRI) {
333 return new PPCInstPrinter(MAI, MII, MRI, T);
336 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCTargetMC() {
338 {&getThePPC32Target(), &getThePPC64Target(), &getThePPC64LETarget()}) {
339 // Register the MC asm info.
340 RegisterMCAsmInfoFn C(*T, createPPCMCAsmInfo);
342 // Register the MC instruction info.
343 TargetRegistry::RegisterMCInstrInfo(*T, createPPCMCInstrInfo);
345 // Register the MC register info.
346 TargetRegistry::RegisterMCRegInfo(*T, createPPCMCRegisterInfo);
348 // Register the MC subtarget info.
349 TargetRegistry::RegisterMCSubtargetInfo(*T, createPPCMCSubtargetInfo);
351 // Register the MC Code Emitter
352 TargetRegistry::RegisterMCCodeEmitter(*T, createPPCMCCodeEmitter);
354 // Register the asm backend.
355 TargetRegistry::RegisterMCAsmBackend(*T, createPPCAsmBackend);
357 // Register the elf streamer.
358 TargetRegistry::RegisterELFStreamer(*T, createPPCMCStreamer);
360 // Register the object target streamer.
361 TargetRegistry::RegisterObjectTargetStreamer(*T,
362 createObjectTargetStreamer);
364 // Register the asm target streamer.
365 TargetRegistry::RegisterAsmTargetStreamer(*T, createAsmTargetStreamer);
367 // Register the MCInstPrinter.
368 TargetRegistry::RegisterMCInstPrinter(*T, createPPCMCInstPrinter);