1 //===-- SPUAsmPrinter.cpp - Print machine instrs to Cell SPU assembly -------=//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by a team from the Computer Systems Research
6 // Department at The Aerospace Corporation.
8 // See README.txt for details.
10 //===----------------------------------------------------------------------===//
12 // This file contains a printer that converts from our internal representation
13 // of machine-dependent LLVM code to Cell SPU assembly language. This printer
14 // is the output mechanism used by `llc'.
16 // Documentation at http://developer.apple.com/documentation/DeveloperTools/
17 // Reference/Assembler/ASMIntroduction/chapter_1_section_1.html
19 //===----------------------------------------------------------------------===//
21 #define DEBUG_TYPE "asmprinter"
23 #include "SPUTargetMachine.h"
24 #include "llvm/Constants.h"
25 #include "llvm/DerivedTypes.h"
26 #include "llvm/Module.h"
27 #include "llvm/Assembly/Writer.h"
28 #include "llvm/CodeGen/AsmPrinter.h"
29 #include "llvm/CodeGen/DwarfWriter.h"
30 #include "llvm/CodeGen/MachineModuleInfo.h"
31 #include "llvm/CodeGen/MachineFunctionPass.h"
32 #include "llvm/CodeGen/MachineInstr.h"
33 #include "llvm/Support/Mangler.h"
34 #include "llvm/Support/MathExtras.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/Compiler.h"
38 #include "llvm/Target/TargetAsmInfo.h"
39 #include "llvm/Target/MRegisterInfo.h"
40 #include "llvm/Target/TargetInstrInfo.h"
41 #include "llvm/Target/TargetOptions.h"
42 #include "llvm/ADT/Statistic.h"
43 #include "llvm/ADT/StringExtras.h"
48 STATISTIC(EmittedInsts, "Number of machine instrs printed");
50 const std::string bss_section(".bss");
52 struct VISIBILITY_HIDDEN SPUAsmPrinter : public AsmPrinter {
53 std::set<std::string> FnStubs, GVStubs;
55 SPUAsmPrinter(std::ostream &O, TargetMachine &TM, const TargetAsmInfo *T) :
60 virtual const char *getPassName() const {
61 return "STI CBEA SPU Assembly Printer";
64 SPUTargetMachine &getTM() {
65 return static_cast<SPUTargetMachine&>(TM);
68 /// printInstruction - This method is automatically generated by tablegen
69 /// from the instruction set description. This method returns true if the
70 /// machine instruction was sufficiently described to print it, otherwise it
72 bool printInstruction(const MachineInstr *MI);
74 void printMachineInstruction(const MachineInstr *MI);
75 void printOp(const MachineOperand &MO);
77 /// printRegister - Print register according to target requirements.
79 void printRegister(const MachineOperand &MO, bool R0AsZero) {
80 unsigned RegNo = MO.getReg();
81 assert(MRegisterInfo::isPhysicalRegister(RegNo) && "Not physreg??");
82 O << TM.getRegisterInfo()->get(RegNo).Name;
85 void printOperand(const MachineInstr *MI, unsigned OpNo) {
86 const MachineOperand &MO = MI->getOperand(OpNo);
87 if (MO.isRegister()) {
88 assert(MRegisterInfo::isPhysicalRegister(MO.getReg())&&"Not physreg??");
89 O << TM.getRegisterInfo()->get(MO.getReg()).Name;
90 } else if (MO.isImmediate()) {
91 O << MO.getImmedValue();
97 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
98 unsigned AsmVariant, const char *ExtraCode);
99 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
100 unsigned AsmVariant, const char *ExtraCode);
104 printS7ImmOperand(const MachineInstr *MI, unsigned OpNo)
106 int value = MI->getOperand(OpNo).getImmedValue();
107 value = (value << (32 - 7)) >> (32 - 7);
109 assert((value >= -(1 << 8) && value <= (1 << 7) - 1)
110 && "Invalid s7 argument");
115 printU7ImmOperand(const MachineInstr *MI, unsigned OpNo)
117 unsigned int value = MI->getOperand(OpNo).getImmedValue();
118 assert(value < (1 << 8) && "Invalid u7 argument");
123 printMemRegImmS7(const MachineInstr *MI, unsigned OpNo)
125 char value = MI->getOperand(OpNo).getImmedValue();
128 printOperand(MI, OpNo+1);
133 printS16ImmOperand(const MachineInstr *MI, unsigned OpNo)
135 O << (short) MI->getOperand(OpNo).getImmedValue();
139 printU16ImmOperand(const MachineInstr *MI, unsigned OpNo)
141 O << (unsigned short)MI->getOperand(OpNo).getImmedValue();
145 printU32ImmOperand(const MachineInstr *MI, unsigned OpNo)
147 O << (unsigned)MI->getOperand(OpNo).getImmedValue();
151 printMemRegReg(const MachineInstr *MI, unsigned OpNo) {
152 // When used as the base register, r0 reads constant zero rather than
153 // the value contained in the register. For this reason, the darwin
154 // assembler requires that we print r0 as 0 (no r) when used as the base.
155 const MachineOperand &MO = MI->getOperand(OpNo);
156 O << TM.getRegisterInfo()->get(MO.getReg()).Name;
158 printOperand(MI, OpNo+1);
162 printU18ImmOperand(const MachineInstr *MI, unsigned OpNo)
164 unsigned int value = MI->getOperand(OpNo).getImmedValue();
165 assert(value <= (1 << 19) - 1 && "Invalid u18 argument");
170 printS10ImmOperand(const MachineInstr *MI, unsigned OpNo)
172 short value = (short) (((int) MI->getOperand(OpNo).getImmedValue() << 16)
174 assert((value >= -(1 << 9) && value <= (1 << 9) - 1)
175 && "Invalid s10 argument");
180 printU10ImmOperand(const MachineInstr *MI, unsigned OpNo)
182 short value = (short) (((int) MI->getOperand(OpNo).getImmedValue() << 16)
184 assert((value <= (1 << 10) - 1) && "Invalid u10 argument");
189 printMemRegImmS10(const MachineInstr *MI, unsigned OpNo)
191 const MachineOperand &MO = MI->getOperand(OpNo);
192 assert(MO.isImmediate()
193 && "printMemRegImmS10 first operand is not immedate");
194 printS10ImmOperand(MI, OpNo);
196 printOperand(MI, OpNo+1);
201 printAddr256K(const MachineInstr *MI, unsigned OpNo)
203 /* Note: operand 1 is an offset or symbol name. Operand 2 is
205 if (MI->getOperand(OpNo).isImmediate()) {
206 printS16ImmOperand(MI, OpNo);
208 printOp(MI->getOperand(OpNo));
212 void printCallOperand(const MachineInstr *MI, unsigned OpNo) {
213 printOp(MI->getOperand(OpNo));
216 void printPCRelativeOperand(const MachineInstr *MI, unsigned OpNo) {
217 printOp(MI->getOperand(OpNo));
221 void printSymbolHi(const MachineInstr *MI, unsigned OpNo) {
222 if (MI->getOperand(OpNo).isImmediate()) {
223 printS16ImmOperand(MI, OpNo);
225 printOp(MI->getOperand(OpNo));
230 void printSymbolLo(const MachineInstr *MI, unsigned OpNo) {
231 if (MI->getOperand(OpNo).isImmediate()) {
232 printS16ImmOperand(MI, OpNo);
234 printOp(MI->getOperand(OpNo));
239 /// Print local store address
240 void printSymbolLSA(const MachineInstr *MI, unsigned OpNo) {
241 printOp(MI->getOperand(OpNo));
244 void printROTHNeg7Imm(const MachineInstr *MI, unsigned OpNo) {
245 if (MI->getOperand(OpNo).isImmediate()) {
246 int value = (int) MI->getOperand(OpNo).getImmedValue();
247 assert((value >= 0 && value < 16)
248 && "Invalid negated immediate rotate 7-bit argument");
251 assert(0 && "Invalid/non-immediate rotate amount in printRotateNeg7Imm");
255 void printROTNeg7Imm(const MachineInstr *MI, unsigned OpNo) {
256 if (MI->getOperand(OpNo).isImmediate()) {
257 int value = (int) MI->getOperand(OpNo).getImmedValue();
258 assert((value >= 0 && value < 32)
259 && "Invalid negated immediate rotate 7-bit argument");
262 assert(0 && "Invalid/non-immediate rotate amount in printRotateNeg7Imm");
266 virtual bool runOnMachineFunction(MachineFunction &F) = 0;
267 virtual bool doFinalization(Module &M) = 0;
270 /// LinuxAsmPrinter - SPU assembly printer, customized for Linux
271 struct VISIBILITY_HIDDEN LinuxAsmPrinter : public SPUAsmPrinter {
275 LinuxAsmPrinter(std::ostream &O, SPUTargetMachine &TM,
276 const TargetAsmInfo *T) :
277 SPUAsmPrinter(O, TM, T),
281 virtual const char *getPassName() const {
282 return "STI CBEA SPU Assembly Printer";
285 bool runOnMachineFunction(MachineFunction &F);
286 bool doInitialization(Module &M);
287 bool doFinalization(Module &M);
289 void getAnalysisUsage(AnalysisUsage &AU) const {
290 AU.setPreservesAll();
291 AU.addRequired<MachineModuleInfo>();
292 SPUAsmPrinter::getAnalysisUsage(AU);
295 /// getSectionForFunction - Return the section that we should emit the
296 /// specified function body into.
297 virtual std::string getSectionForFunction(const Function &F) const;
299 } // end of anonymous namespace
301 // Include the auto-generated portion of the assembly writer
302 #include "SPUGenAsmWriter.inc"
304 void SPUAsmPrinter::printOp(const MachineOperand &MO) {
305 switch (MO.getType()) {
306 case MachineOperand::MO_Immediate:
307 cerr << "printOp() does not handle immediate values\n";
311 case MachineOperand::MO_MachineBasicBlock:
312 printBasicBlockLabel(MO.getMachineBasicBlock());
314 case MachineOperand::MO_JumpTableIndex:
315 O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
316 << '_' << MO.getJumpTableIndex();
317 // FIXME: PIC relocation model
319 case MachineOperand::MO_ConstantPoolIndex:
320 O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
321 << '_' << MO.getConstantPoolIndex();
323 case MachineOperand::MO_ExternalSymbol:
324 // Computing the address of an external symbol, not calling it.
325 if (TM.getRelocationModel() != Reloc::Static) {
326 std::string Name(TAI->getGlobalPrefix()); Name += MO.getSymbolName();
327 GVStubs.insert(Name);
328 O << "L" << Name << "$non_lazy_ptr";
331 O << TAI->getGlobalPrefix() << MO.getSymbolName();
333 case MachineOperand::MO_GlobalAddress: {
334 // Computing the address of a global symbol, not calling it.
335 GlobalValue *GV = MO.getGlobal();
336 std::string Name = Mang->getValueName(GV);
338 // External or weakly linked global variables need non-lazily-resolved
340 if (TM.getRelocationModel() != Reloc::Static) {
341 if (((GV->isDeclaration() || GV->hasWeakLinkage() ||
342 GV->hasLinkOnceLinkage()))) {
343 GVStubs.insert(Name);
344 O << "L" << Name << "$non_lazy_ptr";
350 if (GV->hasExternalWeakLinkage())
351 ExtWeakSymbols.insert(GV);
356 O << "<unknown operand type: " << MO.getType() << ">";
361 /// PrintAsmOperand - Print out an operand for an inline asm expression.
363 bool SPUAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
365 const char *ExtraCode) {
366 // Does this asm operand have a single letter operand modifier?
367 if (ExtraCode && ExtraCode[0]) {
368 if (ExtraCode[1] != 0) return true; // Unknown modifier.
370 switch (ExtraCode[0]) {
371 default: return true; // Unknown modifier.
372 case 'L': // Write second word of DImode reference.
373 // Verify that this operand has two consecutive registers.
374 if (!MI->getOperand(OpNo).isRegister() ||
375 OpNo+1 == MI->getNumOperands() ||
376 !MI->getOperand(OpNo+1).isRegister())
378 ++OpNo; // Return the high-part.
383 printOperand(MI, OpNo);
387 bool SPUAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
390 const char *ExtraCode) {
391 if (ExtraCode && ExtraCode[0])
392 return true; // Unknown modifier.
393 printMemRegReg(MI, OpNo);
397 /// printMachineInstruction -- Print out a single PowerPC MI in Darwin syntax
398 /// to the current output stream.
400 void SPUAsmPrinter::printMachineInstruction(const MachineInstr *MI) {
402 printInstruction(MI);
407 std::string LinuxAsmPrinter::getSectionForFunction(const Function &F) const {
408 switch (F.getLinkage()) {
409 default: assert(0 && "Unknown linkage type!");
410 case Function::ExternalLinkage:
411 case Function::InternalLinkage: return TAI->getTextSection();
412 case Function::WeakLinkage:
413 case Function::LinkOnceLinkage:
414 return ""; // Print nothing for the time being...
418 /// runOnMachineFunction - This uses the printMachineInstruction()
419 /// method to print assembly for each instruction.
422 LinuxAsmPrinter::runOnMachineFunction(MachineFunction &MF)
424 DW.SetModuleInfo(&getAnalysis<MachineModuleInfo>());
426 SetupMachineFunction(MF);
429 // Print out constants referenced by the function
430 EmitConstantPool(MF.getConstantPool());
432 // Print out labels for the function.
433 const Function *F = MF.getFunction();
435 SwitchToTextSection(getSectionForFunction(*F).c_str(), F);
438 switch (F->getLinkage()) {
439 default: assert(0 && "Unknown linkage type!");
440 case Function::InternalLinkage: // Symbols default to internal.
442 case Function::ExternalLinkage:
443 O << "\t.global\t" << CurrentFnName << "\n"
444 << "\t.type\t" << CurrentFnName << ", @function\n";
446 case Function::WeakLinkage:
447 case Function::LinkOnceLinkage:
448 O << "\t.global\t" << CurrentFnName << "\n";
449 O << "\t.weak_definition\t" << CurrentFnName << "\n";
452 O << CurrentFnName << ":\n";
454 // Emit pre-function debug information.
455 DW.BeginFunction(&MF);
457 // Print out code for the function.
458 for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
460 // Print a label for the basic block.
461 if (I != MF.begin()) {
462 printBasicBlockLabel(I, true);
465 for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
467 // Print the assembly for the instruction.
469 printMachineInstruction(II);
473 O << "\t.size\t" << CurrentFnName << ",.-" << CurrentFnName << "\n";
475 // Print out jump tables referenced by the function.
476 EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
478 // Emit post-function debug information.
481 // We didn't modify anything.
486 bool LinuxAsmPrinter::doInitialization(Module &M) {
487 bool Result = AsmPrinter::doInitialization(M);
488 SwitchToTextSection(TAI->getTextSection());
489 // Emit initial debug information.
494 bool LinuxAsmPrinter::doFinalization(Module &M) {
495 const TargetData *TD = TM.getTargetData();
497 // Print out module-level global variables here.
498 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
500 if (!I->hasInitializer()) continue; // External global require no code
502 // Check to see if this is a special global used by LLVM, if so, emit it.
503 if (EmitSpecialLLVMGlobal(I))
506 std::string name = Mang->getValueName(I);
507 Constant *C = I->getInitializer();
508 unsigned Size = TD->getTypeStoreSize(C->getType());
509 unsigned Align = TD->getPreferredAlignmentLog(I);
511 if (C->isNullValue() && /* FIXME: Verify correct */
512 (I->hasInternalLinkage() || I->hasWeakLinkage() ||
513 I->hasLinkOnceLinkage() ||
514 (I->hasExternalLinkage() && !I->hasSection()))) {
515 if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it.
516 if (I->hasExternalLinkage()) {
517 // External linkage globals -> .bss section
518 // FIXME: Want to set the global variable's section so that
519 // SwitchToDataSection emits the ".section" directive
520 SwitchToDataSection("\t.section\t.bss", I);
521 O << "\t.global\t" << name << '\n';
522 O << "\t.align\t" << Align << '\n';
523 O << "\t.type\t" << name << ", @object\n";
524 O << "\t.size\t" << name << ", " << Size << '\n';
526 O << "\t.zero\t" << Size;
527 } else if (I->hasInternalLinkage()) {
528 SwitchToDataSection("\t.data", I);
529 O << TAI->getLCOMMDirective() << name << "," << Size << "," << Align;
531 SwitchToDataSection("\t.data", I);
532 O << ".comm " << name << "," << Size;
534 O << "\t\t# '" << I->getName() << "'\n";
536 switch (I->getLinkage()) {
537 case GlobalValue::LinkOnceLinkage:
538 case GlobalValue::WeakLinkage:
539 O << "\t.global " << name << '\n'
540 << "\t.weak_definition " << name << '\n';
541 SwitchToDataSection(".section __DATA,__datacoal_nt,coalesced", I);
543 case GlobalValue::AppendingLinkage:
544 // FIXME: appending linkage variables should go into a section of
545 // their name or something. For now, just emit them as external.
546 case GlobalValue::ExternalLinkage:
547 // If external or appending, declare as a global symbol
548 O << "\t.global " << name << "\n";
550 case GlobalValue::InternalLinkage:
551 if (I->isConstant()) {
552 const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
553 if (TAI->getCStringSection() && CVA && CVA->isCString()) {
554 SwitchToDataSection(TAI->getCStringSection(), I);
559 SwitchToDataSection("\t.data", I);
562 cerr << "Unknown linkage type!";
566 EmitAlignment(Align, I);
567 O << name << ":\t\t\t\t# '" << I->getName() << "'\n";
569 // If the initializer is a extern weak symbol, remember to emit the weak
571 if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
572 if (GV->hasExternalWeakLinkage())
573 ExtWeakSymbols.insert(GV);
575 EmitGlobalConstant(C);
580 // Output stubs for dynamically-linked functions
581 if (TM.getRelocationModel() == Reloc::PIC_) {
582 for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
584 SwitchToTextSection(".section __TEXT,__picsymbolstub1,symbol_stubs,"
585 "pure_instructions,32");
587 O << "L" << *i << "$stub:\n";
588 O << "\t.indirect_symbol " << *i << "\n";
590 O << "\tbcl 20,31,L0$" << *i << "\n";
591 O << "L0$" << *i << ":\n";
593 O << "\taddis r11,r11,ha16(L" << *i << "$lazy_ptr-L0$" << *i << ")\n";
595 O << "\tlwzu r12,lo16(L" << *i << "$lazy_ptr-L0$" << *i << ")(r11)\n";
596 O << "\tmtctr r12\n";
598 SwitchToDataSection(".lazy_symbol_pointer");
599 O << "L" << *i << "$lazy_ptr:\n";
600 O << "\t.indirect_symbol " << *i << "\n";
601 O << "\t.long dyld_stub_binding_helper\n";
604 for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
606 SwitchToTextSection(".section __TEXT,__symbol_stub1,symbol_stubs,"
607 "pure_instructions,16");
609 O << "L" << *i << "$stub:\n";
610 O << "\t.indirect_symbol " << *i << "\n";
611 O << "\tlis r11,ha16(L" << *i << "$lazy_ptr)\n";
612 O << "\tlwzu r12,lo16(L" << *i << "$lazy_ptr)(r11)\n";
613 O << "\tmtctr r12\n";
615 SwitchToDataSection(".lazy_symbol_pointer");
616 O << "L" << *i << "$lazy_ptr:\n";
617 O << "\t.indirect_symbol " << *i << "\n";
618 O << "\t.long dyld_stub_binding_helper\n";
624 // Output stubs for external and common global variables.
625 if (GVStubs.begin() != GVStubs.end()) {
626 SwitchToDataSection(".non_lazy_symbol_pointer");
627 for (std::set<std::string>::iterator I = GVStubs.begin(),
628 E = GVStubs.end(); I != E; ++I) {
629 O << "L" << *I << "$non_lazy_ptr:\n";
630 O << "\t.indirect_symbol " << *I << "\n";
635 // Emit initial debug information.
638 // Emit ident information
639 O << "\t.ident\t\"(llvm 1.9+) STI CBEA Cell SPU backend\"\n";
641 return AsmPrinter::doFinalization(M);
646 /// createSPUCodePrinterPass - Returns a pass that prints the Cell SPU
647 /// assembly code for a MachineFunction to the given output stream, in a format
648 /// that the Linux SPU assembler can deal with.
650 FunctionPass *llvm::createSPUAsmPrinterPass(std::ostream &o,
651 SPUTargetMachine &tm) {
652 return new LinuxAsmPrinter(o, tm, tm.getTargetAsmInfo());