1 //===-- CSKYAsmPrinter.cpp - CSKY 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 CSKY assembly language.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "CSKYAsmPrinter.h"
14 #include "CSKY.h"
15 #include "CSKYConstantPoolValue.h"
16 #include "CSKYTargetMachine.h"
17 #include "MCTargetDesc/CSKYInstPrinter.h"
18 #include "MCTargetDesc/CSKYMCExpr.h"
19 #include "MCTargetDesc/CSKYTargetStreamer.h"
20 #include "TargetInfo/CSKYTargetInfo.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/CodeGen/AsmPrinter.h"
23 #include "llvm/CodeGen/MachineConstantPool.h"
24 #include "llvm/CodeGen/MachineFrameInfo.h"
25 #include "llvm/IR/DataLayout.h"
26 #include "llvm/MC/MCAsmInfo.h"
27 #include "llvm/MC/MCContext.h"
28 #include "llvm/MC/MCInstBuilder.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/MC/TargetRegistry.h"
31
32 using namespace llvm;
33
34 #define DEBUG_TYPE "csky-asm-printer"
35
36 STATISTIC(CSKYNumInstrsCompressed,
37 "Number of C-SKY Compressed instructions emitted");
38
CSKYAsmPrinter(llvm::TargetMachine & TM,std::unique_ptr<llvm::MCStreamer> Streamer)39 CSKYAsmPrinter::CSKYAsmPrinter(llvm::TargetMachine &TM,
40 std::unique_ptr<llvm::MCStreamer> Streamer)
41 : AsmPrinter(TM, std::move(Streamer)), MCInstLowering(OutContext, *this) {}
42
runOnMachineFunction(MachineFunction & MF)43 bool CSKYAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
44 MCP = MF.getConstantPool();
45 TII = MF.getSubtarget().getInstrInfo();
46
47 // Set the current MCSubtargetInfo to a copy which has the correct
48 // feature bits for the current MachineFunction
49 MCSubtargetInfo &NewSTI =
50 OutStreamer->getContext().getSubtargetCopy(*TM.getMCSubtargetInfo());
51 NewSTI.setFeatureBits(MF.getSubtarget().getFeatureBits());
52 Subtarget = &NewSTI;
53
54 return AsmPrinter::runOnMachineFunction(MF);
55 }
56
57 #define GEN_COMPRESS_INSTR
58 #include "CSKYGenCompressInstEmitter.inc"
EmitToStreamer(MCStreamer & S,const MCInst & Inst)59 void CSKYAsmPrinter::EmitToStreamer(MCStreamer &S, const MCInst &Inst) {
60 MCInst CInst;
61 bool Res = compressInst(CInst, Inst, *Subtarget);
62 if (Res)
63 ++CSKYNumInstrsCompressed;
64 AsmPrinter::EmitToStreamer(*OutStreamer, Res ? CInst : Inst);
65 }
66
67 // Simple pseudo-instructions have their lowering (with expansion to real
68 // instructions) auto-generated.
69 #include "CSKYGenMCPseudoLowering.inc"
70
expandTLSLA(const MachineInstr * MI)71 void CSKYAsmPrinter::expandTLSLA(const MachineInstr *MI) {
72 DebugLoc DL = MI->getDebugLoc();
73
74 MCSymbol *PCLabel = OutContext.getOrCreateSymbol(
75 Twine(MAI->getPrivateGlobalPrefix()) + "PC" + Twine(getFunctionNumber()) +
76 "_" + Twine(MI->getOperand(3).getImm()));
77
78 OutStreamer->emitLabel(PCLabel);
79
80 auto Instr = BuildMI(*MF, DL, TII->get(CSKY::LRW32))
81 .add(MI->getOperand(0))
82 .add(MI->getOperand(2));
83 MCInst LRWInst;
84 MCInstLowering.Lower(Instr, LRWInst);
85 EmitToStreamer(*OutStreamer, LRWInst);
86
87 Instr = BuildMI(*MF, DL, TII->get(CSKY::GRS32))
88 .add(MI->getOperand(1))
89 .addSym(PCLabel);
90 MCInst GRSInst;
91 MCInstLowering.Lower(Instr, GRSInst);
92 EmitToStreamer(*OutStreamer, GRSInst);
93 return;
94 }
95
emitCustomConstantPool(const MachineInstr * MI)96 void CSKYAsmPrinter::emitCustomConstantPool(const MachineInstr *MI) {
97
98 // This instruction represents a floating constant pool in the function.
99 // The first operand is the ID# for this instruction, the second is the
100 // index into the MachineConstantPool that this is, the third is the size
101 // in bytes of this constant pool entry.
102 // The required alignment is specified on the basic block holding this MI.
103 unsigned LabelId = (unsigned)MI->getOperand(0).getImm();
104 unsigned CPIdx = (unsigned)MI->getOperand(1).getIndex();
105
106 // If this is the first entry of the pool, mark it.
107 if (!InConstantPool) {
108 OutStreamer->emitValueToAlignment(Align(4));
109 InConstantPool = true;
110 }
111
112 OutStreamer->emitLabel(GetCPISymbol(LabelId));
113
114 const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPIdx];
115 if (MCPE.isMachineConstantPoolEntry())
116 emitMachineConstantPoolValue(MCPE.Val.MachineCPVal);
117 else
118 emitGlobalConstant(MF->getDataLayout(), MCPE.Val.ConstVal);
119 return;
120 }
121
emitFunctionBodyEnd()122 void CSKYAsmPrinter::emitFunctionBodyEnd() {
123 // Make sure to terminate any constant pools that were at the end
124 // of the function.
125 if (!InConstantPool)
126 return;
127 InConstantPool = false;
128 }
129
emitStartOfAsmFile(Module & M)130 void CSKYAsmPrinter::emitStartOfAsmFile(Module &M) {
131 if (TM.getTargetTriple().isOSBinFormatELF())
132 emitAttributes();
133 }
134
emitEndOfAsmFile(Module & M)135 void CSKYAsmPrinter::emitEndOfAsmFile(Module &M) {
136 CSKYTargetStreamer &CTS =
137 static_cast<CSKYTargetStreamer &>(*OutStreamer->getTargetStreamer());
138
139 if (TM.getTargetTriple().isOSBinFormatELF())
140 CTS.finishAttributeSection();
141 }
142
emitInstruction(const MachineInstr * MI)143 void CSKYAsmPrinter::emitInstruction(const MachineInstr *MI) {
144 CSKY_MC::verifyInstructionPredicates(MI->getOpcode(),
145 getSubtargetInfo().getFeatureBits());
146
147 // Do any auto-generated pseudo lowerings.
148 if (emitPseudoExpansionLowering(*OutStreamer, MI))
149 return;
150
151 // If we just ended a constant pool, mark it as such.
152 if (InConstantPool && MI->getOpcode() != CSKY::CONSTPOOL_ENTRY) {
153 InConstantPool = false;
154 }
155
156 if (MI->getOpcode() == CSKY::PseudoTLSLA32)
157 return expandTLSLA(MI);
158
159 if (MI->getOpcode() == CSKY::CONSTPOOL_ENTRY)
160 return emitCustomConstantPool(MI);
161
162 MCInst TmpInst;
163 MCInstLowering.Lower(MI, TmpInst);
164 EmitToStreamer(*OutStreamer, TmpInst);
165 }
166
167 // Convert a CSKY-specific constant pool modifier into the associated
168 // MCSymbolRefExpr variant kind.
169 static CSKYMCExpr::VariantKind
getModifierVariantKind(CSKYCP::CSKYCPModifier Modifier)170 getModifierVariantKind(CSKYCP::CSKYCPModifier Modifier) {
171 switch (Modifier) {
172 case CSKYCP::NO_MOD:
173 return CSKYMCExpr::VK_CSKY_None;
174 case CSKYCP::ADDR:
175 return CSKYMCExpr::VK_CSKY_ADDR;
176 case CSKYCP::GOT:
177 return CSKYMCExpr::VK_CSKY_GOT;
178 case CSKYCP::GOTOFF:
179 return CSKYMCExpr::VK_CSKY_GOTOFF;
180 case CSKYCP::PLT:
181 return CSKYMCExpr::VK_CSKY_PLT;
182 case CSKYCP::TLSGD:
183 return CSKYMCExpr::VK_CSKY_TLSGD;
184 case CSKYCP::TLSLE:
185 return CSKYMCExpr::VK_CSKY_TLSLE;
186 case CSKYCP::TLSIE:
187 return CSKYMCExpr::VK_CSKY_TLSIE;
188 }
189 llvm_unreachable("Invalid CSKYCPModifier!");
190 }
191
emitMachineConstantPoolValue(MachineConstantPoolValue * MCPV)192 void CSKYAsmPrinter::emitMachineConstantPoolValue(
193 MachineConstantPoolValue *MCPV) {
194 int Size = getDataLayout().getTypeAllocSize(MCPV->getType());
195 CSKYConstantPoolValue *CCPV = static_cast<CSKYConstantPoolValue *>(MCPV);
196 MCSymbol *MCSym;
197
198 if (CCPV->isBlockAddress()) {
199 const BlockAddress *BA =
200 cast<CSKYConstantPoolConstant>(CCPV)->getBlockAddress();
201 MCSym = GetBlockAddressSymbol(BA);
202 } else if (CCPV->isGlobalValue()) {
203 const GlobalValue *GV = cast<CSKYConstantPoolConstant>(CCPV)->getGV();
204 MCSym = getSymbol(GV);
205 } else if (CCPV->isMachineBasicBlock()) {
206 const MachineBasicBlock *MBB = cast<CSKYConstantPoolMBB>(CCPV)->getMBB();
207 MCSym = MBB->getSymbol();
208 } else if (CCPV->isJT()) {
209 signed JTI = cast<CSKYConstantPoolJT>(CCPV)->getJTI();
210 MCSym = GetJTISymbol(JTI);
211 } else if (CCPV->isConstPool()) {
212 const Constant *C = cast<CSKYConstantPoolConstant>(CCPV)->getConstantPool();
213 MCSym = GetCPISymbol(MCP->getConstantPoolIndex(C, Align(4)));
214 } else {
215 assert(CCPV->isExtSymbol() && "unrecognized constant pool value");
216 StringRef Sym = cast<CSKYConstantPoolSymbol>(CCPV)->getSymbol();
217 MCSym = GetExternalSymbolSymbol(Sym);
218 }
219 // Create an MCSymbol for the reference.
220 const MCExpr *Expr =
221 MCSymbolRefExpr::create(MCSym, MCSymbolRefExpr::VK_None, OutContext);
222
223 if (CCPV->getPCAdjustment()) {
224
225 MCSymbol *PCLabel = OutContext.getOrCreateSymbol(
226 Twine(MAI->getPrivateGlobalPrefix()) + "PC" +
227 Twine(getFunctionNumber()) + "_" + Twine(CCPV->getLabelID()));
228
229 const MCExpr *PCRelExpr = MCSymbolRefExpr::create(PCLabel, OutContext);
230 if (CCPV->mustAddCurrentAddress()) {
231 // We want "(<expr> - .)", but MC doesn't have a concept of the '.'
232 // label, so just emit a local label end reference that instead.
233 MCSymbol *DotSym = OutContext.createTempSymbol();
234 OutStreamer->emitLabel(DotSym);
235 const MCExpr *DotExpr = MCSymbolRefExpr::create(DotSym, OutContext);
236 PCRelExpr = MCBinaryExpr::createSub(PCRelExpr, DotExpr, OutContext);
237 }
238 Expr = MCBinaryExpr::createSub(Expr, PCRelExpr, OutContext);
239 }
240
241 // Create an MCSymbol for the reference.
242 Expr = CSKYMCExpr::create(Expr, getModifierVariantKind(CCPV->getModifier()),
243 OutContext);
244
245 OutStreamer->emitValue(Expr, Size);
246 }
247
emitAttributes()248 void CSKYAsmPrinter::emitAttributes() {
249 CSKYTargetStreamer &CTS =
250 static_cast<CSKYTargetStreamer &>(*OutStreamer->getTargetStreamer());
251
252 const Triple &TT = TM.getTargetTriple();
253 StringRef CPU = TM.getTargetCPU();
254 StringRef FS = TM.getTargetFeatureString();
255 const CSKYTargetMachine &CTM = static_cast<const CSKYTargetMachine &>(TM);
256 /* TuneCPU doesn't impact emission of ELF attributes, ELF attributes only
257 care about arch related features, so we can set TuneCPU as CPU. */
258 const CSKYSubtarget STI(TT, CPU, /*TuneCPU=*/CPU, FS, CTM);
259
260 CTS.emitTargetAttributes(STI);
261 }
262
PrintAsmOperand(const MachineInstr * MI,unsigned OpNo,const char * ExtraCode,raw_ostream & OS)263 bool CSKYAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
264 const char *ExtraCode, raw_ostream &OS) {
265 // First try the generic code, which knows about modifiers like 'c' and 'n'.
266 if (!AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS))
267 return false;
268
269 const MachineOperand &MO = MI->getOperand(OpNo);
270 if (ExtraCode && ExtraCode[0]) {
271 if (ExtraCode[1] != 0)
272 return true; // Unknown modifier.
273
274 switch (ExtraCode[0]) {
275 default:
276 return true; // Unknown modifier.
277 case 'R':
278 if (MO.getType() == MachineOperand::MO_Register) {
279 OS << CSKYInstPrinter::getRegisterName(MO.getReg() + 1);
280 return false;
281 }
282 }
283 }
284
285 switch (MO.getType()) {
286 case MachineOperand::MO_Immediate:
287 OS << MO.getImm();
288 return false;
289 case MachineOperand::MO_Register:
290 if (MO.getReg() == CSKY::C)
291 return false;
292 OS << CSKYInstPrinter::getRegisterName(MO.getReg());
293 return false;
294 case MachineOperand::MO_GlobalAddress:
295 PrintSymbolOperand(MO, OS);
296 return false;
297 case MachineOperand::MO_BlockAddress: {
298 MCSymbol *Sym = GetBlockAddressSymbol(MO.getBlockAddress());
299 Sym->print(OS, MAI);
300 return false;
301 }
302 default:
303 break;
304 }
305
306 return true;
307 }
308
PrintAsmMemoryOperand(const MachineInstr * MI,unsigned OpNo,const char * ExtraCode,raw_ostream & OS)309 bool CSKYAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
310 unsigned OpNo, const char *ExtraCode,
311 raw_ostream &OS) {
312 if (!ExtraCode) {
313 const MachineOperand &MO = MI->getOperand(OpNo);
314 // For now, we only support register memory operands in registers and
315 // assume there is no addend
316 if (!MO.isReg())
317 return true;
318
319 OS << "(" << CSKYInstPrinter::getRegisterName(MO.getReg()) << ", 0)";
320 return false;
321 }
322
323 return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, ExtraCode, OS);
324 }
325
LLVMInitializeCSKYAsmPrinter()326 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeCSKYAsmPrinter() {
327 RegisterAsmPrinter<CSKYAsmPrinter> X(getTheCSKYTarget());
328 }
329