xref: /llvm-project/llvm/lib/Target/XCore/XCoreAsmPrinter.cpp (revision ed8019d9fbed2e6a6b08f8f73e9fa54a24f3ed52) 
1 //===-- XCoreAsmPrinter.cpp - XCore LLVM assembly writer ------------------===//
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 contains a printer that converts from our internal representation
10 // of machine-dependent LLVM code to the XAS-format XCore assembly language.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "MCTargetDesc/XCoreInstPrinter.h"
15 #include "TargetInfo/XCoreTargetInfo.h"
16 #include "XCore.h"
17 #include "XCoreMCInstLower.h"
18 #include "XCoreSubtarget.h"
19 #include "XCoreTargetMachine.h"
20 #include "XCoreTargetStreamer.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/CodeGen/AsmPrinter.h"
24 #include "llvm/CodeGen/MachineConstantPool.h"
25 #include "llvm/CodeGen/MachineInstr.h"
26 #include "llvm/CodeGen/MachineJumpTableInfo.h"
27 #include "llvm/CodeGen/MachineModuleInfo.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/DebugInfo.h"
30 #include "llvm/IR/DerivedTypes.h"
31 #include "llvm/IR/Mangler.h"
32 #include "llvm/MC/MCAsmInfo.h"
33 #include "llvm/MC/MCExpr.h"
34 #include "llvm/MC/MCInst.h"
35 #include "llvm/MC/MCStreamer.h"
36 #include "llvm/MC/TargetRegistry.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include "llvm/Support/raw_ostream.h"
39 #include "llvm/Target/TargetLoweringObjectFile.h"
40 #include <algorithm>
41 #include <cctype>
42 using namespace llvm;
43 
44 #define DEBUG_TYPE "asm-printer"
45 
46 namespace {
47   class XCoreAsmPrinter : public AsmPrinter {
48     XCoreMCInstLower MCInstLowering;
49     XCoreTargetStreamer &getTargetStreamer();
50 
51   public:
52     explicit XCoreAsmPrinter(TargetMachine &TM,
53                              std::unique_ptr<MCStreamer> Streamer)
54         : AsmPrinter(TM, std::move(Streamer)), MCInstLowering(*this) {}
55 
56     StringRef getPassName() const override { return "XCore Assembly Printer"; }
57 
58     void printInlineJT(const MachineInstr *MI, int opNum, raw_ostream &O,
59                        const std::string &directive = ".jmptable");
60     void printInlineJT32(const MachineInstr *MI, int opNum, raw_ostream &O) {
61       printInlineJT(MI, opNum, O, ".jmptable32");
62     }
63     void printOperand(const MachineInstr *MI, int opNum, raw_ostream &O);
64     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
65                          const char *ExtraCode, raw_ostream &O) override;
66     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum,
67                                const char *ExtraCode, raw_ostream &O) override;
68 
69     void emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV);
70     void emitGlobalVariable(const GlobalVariable *GV) override;
71 
72     void emitFunctionEntryLabel() override;
73     void emitInstruction(const MachineInstr *MI) override;
74     void emitFunctionBodyStart() override;
75     void emitFunctionBodyEnd() override;
76   };
77 } // end of anonymous namespace
78 
79 XCoreTargetStreamer &XCoreAsmPrinter::getTargetStreamer() {
80   return static_cast<XCoreTargetStreamer&>(*OutStreamer->getTargetStreamer());
81 }
82 
83 void XCoreAsmPrinter::emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV) {
84   assert( ( GV->hasExternalLinkage() || GV->hasWeakLinkage() ||
85             GV->hasLinkOnceLinkage() || GV->hasCommonLinkage() ) &&
86           "Unexpected linkage");
87   if (ArrayType *ATy = dyn_cast<ArrayType>(GV->getValueType())) {
88 
89     MCSymbol *SymGlob = OutContext.getOrCreateSymbol(
90                           Twine(Sym->getName() + StringRef(".globound")));
91     OutStreamer->emitSymbolAttribute(SymGlob, MCSA_Global);
92     OutStreamer->emitAssignment(SymGlob,
93                                 MCConstantExpr::create(ATy->getNumElements(),
94                                                        OutContext));
95     if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
96         GV->hasCommonLinkage()) {
97       OutStreamer->emitSymbolAttribute(SymGlob, MCSA_Weak);
98     }
99   }
100 }
101 
102 void XCoreAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
103   // Check to see if this is a special global used by LLVM, if so, emit it.
104   if (!GV->hasInitializer() || emitSpecialLLVMGlobal(GV))
105     return;
106 
107   const DataLayout &DL = getDataLayout();
108   OutStreamer->switchSection(getObjFileLowering().SectionForGlobal(GV, TM));
109 
110   MCSymbol *GVSym = getSymbol(GV);
111   const Constant *C = GV->getInitializer();
112   const Align Alignment = DL.getPrefTypeAlign(C->getType());
113 
114   // Mark the start of the global
115   getTargetStreamer().emitCCTopData(GVSym->getName());
116 
117   switch (GV->getLinkage()) {
118   case GlobalValue::AppendingLinkage:
119     report_fatal_error("AppendingLinkage is not supported by this target!");
120   case GlobalValue::LinkOnceAnyLinkage:
121   case GlobalValue::LinkOnceODRLinkage:
122   case GlobalValue::WeakAnyLinkage:
123   case GlobalValue::WeakODRLinkage:
124   case GlobalValue::ExternalLinkage:
125   case GlobalValue::CommonLinkage:
126     emitArrayBound(GVSym, GV);
127     OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
128 
129     if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
130         GV->hasCommonLinkage())
131       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak);
132     [[fallthrough]];
133   case GlobalValue::InternalLinkage:
134   case GlobalValue::PrivateLinkage:
135     break;
136   default:
137     llvm_unreachable("Unknown linkage type!");
138   }
139 
140   emitAlignment(std::max(Alignment, Align(4)), GV);
141 
142   if (GV->isThreadLocal()) {
143     report_fatal_error("TLS is not supported by this target!");
144   }
145   unsigned Size = DL.getTypeAllocSize(C->getType());
146   if (MAI->hasDotTypeDotSizeDirective()) {
147     OutStreamer->emitSymbolAttribute(GVSym, MCSA_ELF_TypeObject);
148     OutStreamer->emitELFSize(GVSym, MCConstantExpr::create(Size, OutContext));
149   }
150   OutStreamer->emitLabel(GVSym);
151 
152   emitGlobalConstant(DL, C);
153   // The ABI requires that unsigned scalar types smaller than 32 bits
154   // are padded to 32 bits.
155   if (Size < 4)
156     OutStreamer->emitZeros(4 - Size);
157 
158   // Mark the end of the global
159   getTargetStreamer().emitCCBottomData(GVSym->getName());
160 }
161 
162 void XCoreAsmPrinter::emitFunctionBodyStart() {
163   MCInstLowering.Initialize(&MF->getContext());
164 }
165 
166 /// EmitFunctionBodyEnd - Targets can override this to emit stuff after
167 /// the last basic block in the function.
168 void XCoreAsmPrinter::emitFunctionBodyEnd() {
169   // Emit function end directives
170   getTargetStreamer().emitCCBottomFunction(CurrentFnSym->getName());
171 }
172 
173 void XCoreAsmPrinter::emitFunctionEntryLabel() {
174   // Mark the start of the function
175   getTargetStreamer().emitCCTopFunction(CurrentFnSym->getName());
176   OutStreamer->emitLabel(CurrentFnSym);
177 }
178 
179 void XCoreAsmPrinter::
180 printInlineJT(const MachineInstr *MI, int opNum, raw_ostream &O,
181               const std::string &directive) {
182   unsigned JTI = MI->getOperand(opNum).getIndex();
183   const MachineFunction *MF = MI->getParent()->getParent();
184   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
185   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
186   const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
187   O << "\t" << directive << " ";
188   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
189     MachineBasicBlock *MBB = JTBBs[i];
190     if (i > 0)
191       O << ",";
192     MBB->getSymbol()->print(O, MAI);
193   }
194 }
195 
196 void XCoreAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
197                                    raw_ostream &O) {
198   const DataLayout &DL = getDataLayout();
199   const MachineOperand &MO = MI->getOperand(opNum);
200   switch (MO.getType()) {
201   case MachineOperand::MO_Register:
202     O << XCoreInstPrinter::getRegisterName(MO.getReg());
203     break;
204   case MachineOperand::MO_Immediate:
205     O << MO.getImm();
206     break;
207   case MachineOperand::MO_MachineBasicBlock:
208     MO.getMBB()->getSymbol()->print(O, MAI);
209     break;
210   case MachineOperand::MO_GlobalAddress:
211     PrintSymbolOperand(MO, O);
212     break;
213   case MachineOperand::MO_ConstantPoolIndex:
214     O << DL.getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
215       << MO.getIndex();
216     break;
217   case MachineOperand::MO_BlockAddress:
218     GetBlockAddressSymbol(MO.getBlockAddress())->print(O, MAI);
219     break;
220   default:
221     llvm_unreachable("not implemented");
222   }
223 }
224 
225 /// PrintAsmOperand - Print out an operand for an inline asm expression.
226 ///
227 bool XCoreAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
228                                       const char *ExtraCode, raw_ostream &O) {
229   // Print the operand if there is no operand modifier.
230   if (!ExtraCode || !ExtraCode[0]) {
231     printOperand(MI, OpNo, O);
232     return false;
233   }
234 
235   // Otherwise fallback on the default implementation.
236   return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, O);
237 }
238 
239 bool XCoreAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
240                                             unsigned OpNum,
241                                             const char *ExtraCode,
242                                             raw_ostream &O) {
243   if (ExtraCode && ExtraCode[0]) {
244     return true; // Unknown modifier.
245   }
246   printOperand(MI, OpNum, O);
247   O << '[';
248   printOperand(MI, OpNum + 1, O);
249   O << ']';
250   return false;
251 }
252 
253 void XCoreAsmPrinter::emitInstruction(const MachineInstr *MI) {
254   XCore_MC::verifyInstructionPredicates(MI->getOpcode(),
255                                         getSubtargetInfo().getFeatureBits());
256 
257   SmallString<128> Str;
258   raw_svector_ostream O(Str);
259 
260   switch (MI->getOpcode()) {
261   case XCore::DBG_VALUE:
262     llvm_unreachable("Should be handled target independently");
263   case XCore::ADD_2rus:
264     if (MI->getOperand(2).getImm() == 0) {
265       O << "\tmov "
266         << XCoreInstPrinter::getRegisterName(MI->getOperand(0).getReg()) << ", "
267         << XCoreInstPrinter::getRegisterName(MI->getOperand(1).getReg());
268       OutStreamer->emitRawText(O.str());
269       return;
270     }
271     break;
272   case XCore::BR_JT:
273   case XCore::BR_JT32:
274     O << "\tbru "
275       << XCoreInstPrinter::getRegisterName(MI->getOperand(1).getReg()) << '\n';
276     if (MI->getOpcode() == XCore::BR_JT)
277       printInlineJT(MI, 0, O);
278     else
279       printInlineJT32(MI, 0, O);
280     O << '\n';
281     OutStreamer->emitRawText(O.str());
282     return;
283   }
284 
285   MCInst TmpInst;
286   MCInstLowering.Lower(MI, TmpInst);
287 
288   EmitToStreamer(*OutStreamer, TmpInst);
289 }
290 
291 // Force static initialization.
292 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeXCoreAsmPrinter() {
293   RegisterAsmPrinter<XCoreAsmPrinter> X(getTheXCoreTarget());
294 }
295