1 //===-- MipsAsmPrinter.cpp - Mips LLVM assembly writer --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains a printer that converts from our internal representation
11 // of machine-dependent LLVM code to GAS-format MIPS assembly language.
13 //===----------------------------------------------------------------------===//
15 #define DEBUG_TYPE "mips-asm-printer"
18 #include "MipsInstrInfo.h"
19 #include "MipsTargetMachine.h"
20 #include "MipsMachineFunction.h"
21 #include "llvm/Constants.h"
22 #include "llvm/DerivedTypes.h"
23 #include "llvm/Module.h"
24 #include "llvm/CodeGen/AsmPrinter.h"
25 #include "llvm/CodeGen/MachineFunctionPass.h"
26 #include "llvm/CodeGen/MachineConstantPool.h"
27 #include "llvm/CodeGen/MachineFrameInfo.h"
28 #include "llvm/CodeGen/MachineInstr.h"
29 #include "llvm/Target/TargetAsmInfo.h"
30 #include "llvm/Target/TargetData.h"
31 #include "llvm/Target/TargetMachine.h"
32 #include "llvm/Target/TargetOptions.h"
33 #include "llvm/Support/Mangler.h"
34 #include "llvm/ADT/Statistic.h"
35 #include "llvm/ADT/StringExtras.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/CommandLine.h"
38 #include "llvm/Support/MathExtras.h"
43 STATISTIC(EmittedInsts, "Number of machine instrs printed");
46 struct VISIBILITY_HIDDEN MipsAsmPrinter : public AsmPrinter {
47 MipsAsmPrinter(std::ostream &O, MipsTargetMachine &TM,
48 const TargetAsmInfo *T):
49 AsmPrinter(O, TM, T) {}
51 virtual const char *getPassName() const {
52 return "Mips Assembly Printer";
55 enum SetDirectiveFlags {
56 REORDER, // enables instruction reordering.
57 NOREORDER, // disables instruction reordering.
58 MACRO, // enables GAS macros.
59 NOMACRO // disables GAS macros.
62 void printOperand(const MachineInstr *MI, int opNum);
63 void printMemOperand(const MachineInstr *MI, int opNum,
64 const char *Modifier = 0);
65 void printFCCOperand(const MachineInstr *MI, int opNum,
66 const char *Modifier = 0);
68 unsigned int getSavedRegsBitmask(bool isFloat, MachineFunction &MF);
69 void printHex32(unsigned int Value);
71 void emitFunctionStart(MachineFunction &MF);
72 void emitFunctionEnd(MachineFunction &MF);
73 void emitFrameDirective(MachineFunction &MF);
74 void emitMaskDirective(MachineFunction &MF);
75 void emitFMaskDirective(MachineFunction &MF);
76 void emitSetDirective(SetDirectiveFlags Flag);
78 bool printInstruction(const MachineInstr *MI); // autogenerated.
79 bool runOnMachineFunction(MachineFunction &F);
80 bool doInitialization(Module &M);
81 bool doFinalization(Module &M);
83 } // end of anonymous namespace
85 #include "MipsGenAsmWriter.inc"
87 /// createMipsCodePrinterPass - Returns a pass that prints the MIPS
88 /// assembly code for a MachineFunction to the given output stream,
89 /// using the given target machine description. This should work
90 /// regardless of whether the function is in SSA form.
91 FunctionPass *llvm::createMipsCodePrinterPass(std::ostream &o,
92 MipsTargetMachine &tm)
94 return new MipsAsmPrinter(o, tm, tm.getTargetAsmInfo());
97 //===----------------------------------------------------------------------===//
99 // Mips Asm Directives
101 // -- Frame directive "frame Stackpointer, Stacksize, RARegister"
102 // Describe the stack frame.
104 // -- Mask directives "(f)mask bitmask, offset"
105 // Tells the assembler which registers are saved and where.
106 // bitmask - contain a little endian bitset indicating which registers are
107 // saved on function prologue (e.g. with a 0x80000000 mask, the
108 // assembler knows the register 31 (RA) is saved at prologue.
109 // offset - the position before stack pointer subtraction indicating where
110 // the first saved register on prologue is located. (e.g. with a
112 // Consider the following function prologue:
115 // .mask 0xc0000000,-8
116 // addiu $sp, $sp, -48
120 // With a 0xc0000000 mask, the assembler knows the register 31 (RA) and
121 // 30 (FP) are saved at prologue. As the save order on prologue is from
122 // left to right, RA is saved first. A -8 offset means that after the
123 // stack pointer subtration, the first register in the mask (RA) will be
124 // saved at address 48-8=40.
126 //===----------------------------------------------------------------------===//
128 /// Mask directive for GPR
129 void MipsAsmPrinter::
130 emitMaskDirective(MachineFunction &MF)
132 MipsFunctionInfo *MipsFI = MF.getInfo<MipsFunctionInfo>();
134 int StackSize = MF.getFrameInfo()->getStackSize();
135 int Offset = (!MipsFI->getTopSavedRegOffset()) ? 0 :
136 (-(StackSize-MipsFI->getTopSavedRegOffset()));
139 DOUT << "--> emitMaskDirective" << "\n";
140 DOUT << "StackSize : " << StackSize << "\n";
141 DOUT << "getTopSavedReg : " << MipsFI->getTopSavedRegOffset() << "\n";
142 DOUT << "Offset : " << Offset << "\n\n";
145 unsigned int Bitmask = getSavedRegsBitmask(false, MF);
148 O << "," << Offset << "\n";
151 /// TODO: Mask Directive for Floating Point
152 void MipsAsmPrinter::
153 emitFMaskDirective(MachineFunction &MF)
155 unsigned int Bitmask = getSavedRegsBitmask(true, MF);
163 void MipsAsmPrinter::
164 emitFrameDirective(MachineFunction &MF)
166 const TargetRegisterInfo &RI = *TM.getRegisterInfo();
168 unsigned stackReg = RI.getFrameRegister(MF);
169 unsigned returnReg = RI.getRARegister();
170 unsigned stackSize = MF.getFrameInfo()->getStackSize();
173 O << "\t.frame\t" << "$" << LowercaseString(RI.get(stackReg).AsmName)
174 << "," << stackSize << ","
175 << "$" << LowercaseString(RI.get(returnReg).AsmName)
179 /// Emit Set directives.
180 void MipsAsmPrinter::
181 emitSetDirective(SetDirectiveFlags Flag)
185 case REORDER: O << "reorder" << "\n"; break;
186 case NOREORDER: O << "noreorder" << "\n"; break;
187 case MACRO: O << "macro" << "\n"; break;
188 case NOMACRO: O << "nomacro" << "\n"; break;
193 // Create a bitmask with all callee saved registers for CPU
194 // or Floating Point registers. For CPU registers consider RA,
195 // GP and FP for saving if necessary.
196 unsigned int MipsAsmPrinter::
197 getSavedRegsBitmask(bool isFloat, MachineFunction &MF)
199 const TargetRegisterInfo &RI = *TM.getRegisterInfo();
201 // Floating Point Registers, TODO
206 unsigned int Bitmask = 0;
208 MachineFrameInfo *MFI = MF.getFrameInfo();
209 const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
210 for (unsigned i = 0, e = CSI.size(); i != e; ++i)
211 Bitmask |= (1 << MipsRegisterInfo::getRegisterNumbering(CSI[i].getReg()));
214 Bitmask |= (1 << MipsRegisterInfo::
215 getRegisterNumbering(RI.getFrameRegister(MF)));
217 if (MF.getFrameInfo()->hasCalls())
218 Bitmask |= (1 << MipsRegisterInfo::
219 getRegisterNumbering(RI.getRARegister()));
224 // Print a 32 bit hex number with all numbers.
225 void MipsAsmPrinter::
226 printHex32(unsigned int Value)
228 O << "0x" << std::hex;
229 for (int i = 7; i >= 0; i--)
230 O << std::hex << ( (Value & (0xF << (i*4))) >> (i*4) );
234 /// Emit the directives used by GAS on the start of functions
235 void MipsAsmPrinter::
236 emitFunctionStart(MachineFunction &MF)
238 // Print out the label for the function.
239 const Function *F = MF.getFunction();
240 SwitchToTextSection(getSectionForFunction(*F).c_str(), F);
245 O << "\t.globl\t" << CurrentFnName << "\n";
246 O << "\t.ent\t" << CurrentFnName << "\n";
247 O << "\t.type\t" << CurrentFnName << ", @function\n";
248 O << CurrentFnName << ":\n";
250 emitFrameDirective(MF);
251 emitMaskDirective(MF);
252 emitFMaskDirective(MF);
254 if (TM.getRelocationModel() == Reloc::Static) {
255 emitSetDirective(NOREORDER);
256 emitSetDirective(NOMACRO);
262 /// Emit the directives used by GAS on the end of functions
263 void MipsAsmPrinter::
264 emitFunctionEnd(MachineFunction &MF)
266 if (TM.getRelocationModel() == Reloc::Static) {
267 emitSetDirective(MACRO);
268 emitSetDirective(REORDER);
271 O << "\t.end\t" << CurrentFnName << "\n";
274 /// runOnMachineFunction - This uses the printMachineInstruction()
275 /// method to print assembly for each instruction.
276 bool MipsAsmPrinter::
277 runOnMachineFunction(MachineFunction &MF)
279 SetupMachineFunction(MF);
281 // Print out constants referenced by the function
282 EmitConstantPool(MF.getConstantPool());
284 // Print out jump tables referenced by the function
285 EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
289 // What's my mangled name?
290 CurrentFnName = Mang->getValueName(MF.getFunction());
292 // Emit the function start directives
293 emitFunctionStart(MF);
295 // Print out code for the function.
296 for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
299 // Print a label for the basic block.
300 if (I != MF.begin()) {
301 printBasicBlockLabel(I, true, true);
305 for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
307 // Print the assembly for the instruction.
308 printInstruction(II);
312 // Each Basic Block is separated by a newline
316 // Emit function end directives
319 // We didn't modify anything.
323 void MipsAsmPrinter::
324 printOperand(const MachineInstr *MI, int opNum)
326 const MachineOperand &MO = MI->getOperand(opNum);
327 const TargetRegisterInfo &RI = *TM.getRegisterInfo();
329 bool isPIC = (TM.getRelocationModel() == Reloc::PIC_);
330 bool isCodeLarge = (TM.getCodeModel() == CodeModel::Large);
332 // %hi and %lo used on mips gas to load global addresses on
333 // static code. %got is used to load global addresses when
334 // using PIC_. %call16 is used to load direct call targets
335 // on PIC_ and small code size. %call_lo and %call_hi load
336 // direct call targets on PIC_ and large code size.
337 if (MI->getOpcode() == Mips::LUi && !MO.isRegister()
338 && !MO.isImmediate()) {
339 if ((isPIC) && (isCodeLarge))
344 } else if ((MI->getOpcode() == Mips::ADDiu) && !MO.isRegister()
345 && !MO.isImmediate()) {
348 } else if ((isPIC) && (MI->getOpcode() == Mips::LW)
349 && (!MO.isRegister()) && (!MO.isImmediate())) {
350 const MachineOperand &firstMO = MI->getOperand(opNum-1);
351 const MachineOperand &lastMO = MI->getOperand(opNum+1);
352 if ((firstMO.isRegister()) && (lastMO.isRegister())) {
353 if ((firstMO.getReg() == Mips::T9) && (lastMO.getReg() == Mips::GP)
356 else if ((firstMO.getReg() != Mips::T9) && (lastMO.getReg() == Mips::GP))
358 else if ((firstMO.getReg() == Mips::T9) && (lastMO.getReg() != Mips::GP)
365 switch (MO.getType())
367 case MachineOperand::MO_Register:
368 if (TargetRegisterInfo::isPhysicalRegister(MO.getReg()))
369 O << "$" << LowercaseString (RI.get(MO.getReg()).AsmName);
371 O << "$" << MO.getReg();
374 case MachineOperand::MO_Immediate:
375 if ((MI->getOpcode() == Mips::SLTiu) || (MI->getOpcode() == Mips::ORi) ||
376 (MI->getOpcode() == Mips::LUi) || (MI->getOpcode() == Mips::ANDi))
377 O << (unsigned short int)MO.getImm();
379 O << (short int)MO.getImm();
382 case MachineOperand::MO_MachineBasicBlock:
383 printBasicBlockLabel(MO.getMBB());
386 case MachineOperand::MO_GlobalAddress:
387 O << Mang->getValueName(MO.getGlobal());
390 case MachineOperand::MO_ExternalSymbol:
391 O << MO.getSymbolName();
394 case MachineOperand::MO_JumpTableIndex:
395 O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
396 << '_' << MO.getIndex();
399 // FIXME: Verify correct
400 case MachineOperand::MO_ConstantPoolIndex:
401 O << TAI->getPrivateGlobalPrefix() << "CPI"
402 << getFunctionNumber() << "_" << MO.getIndex();
406 O << "<unknown operand type>"; abort (); break;
409 if (closeP) O << ")";
412 void MipsAsmPrinter::
413 printMemOperand(const MachineInstr *MI, int opNum, const char *Modifier)
415 // when using stack locations for not load/store instructions
416 // print the same way as all normal 3 operand instructions.
417 if (Modifier && !strcmp(Modifier, "stackloc")) {
418 printOperand(MI, opNum+1);
420 printOperand(MI, opNum);
424 // Load/Store memory operands -- imm($reg)
425 // If PIC target the target is loaded as the
426 // pattern lw $25,%call16($28)
427 printOperand(MI, opNum);
429 printOperand(MI, opNum+1);
433 void MipsAsmPrinter::
434 printFCCOperand(const MachineInstr *MI, int opNum, const char *Modifier)
436 const MachineOperand& MO = MI->getOperand(opNum);
437 O << Mips::MipsFCCToString((Mips::CondCode)MO.getImm());
440 bool MipsAsmPrinter::
441 doInitialization(Module &M)
443 Mang = new Mangler(M);
444 return false; // success
447 bool MipsAsmPrinter::
448 doFinalization(Module &M)
450 const TargetData *TD = TM.getTargetData();
452 // Print out module-level global variables here.
453 for (Module::const_global_iterator I = M.global_begin(),
454 E = M.global_end(); I != E; ++I)
456 // External global require no code
457 if (I->hasInitializer()) {
459 // Check to see if this is a special global
460 // used by LLVM, if so, emit it.
461 if (EmitSpecialLLVMGlobal(I))
465 std::string name = Mang->getValueName(I);
466 Constant *C = I->getInitializer();
467 unsigned Size = TD->getABITypeSize(C->getType());
468 unsigned Align = TD->getPreferredAlignmentLog(I);
471 if (C->isNullValue() && (I->hasLinkOnceLinkage() ||
472 I->hasInternalLinkage() || I->hasWeakLinkage() ||
473 I->hasCommonLinkage()))
475 if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it.
477 if (!NoZerosInBSS && TAI->getBSSSection())
478 SwitchToDataSection(TAI->getBSSSection(), I);
480 SwitchToDataSection(TAI->getDataSection(), I);
482 if (I->hasInternalLinkage()) {
483 if (TAI->getLCOMMDirective())
484 O << TAI->getLCOMMDirective() << name << "," << Size;
486 O << "\t.local\t" << name << "\n";
488 O << TAI->getCOMMDirective() << name << "," << Size;
489 // The .comm alignment in bytes.
490 if (TAI->getCOMMDirectiveTakesAlignment())
491 O << "," << (1 << Align);
496 switch (I->getLinkage())
498 case GlobalValue::LinkOnceLinkage:
499 case GlobalValue::CommonLinkage:
500 case GlobalValue::WeakLinkage:
501 // FIXME: Verify correct for weak.
502 // Nonnull linkonce -> weak
503 O << "\t.weak " << name << "\n";
504 SwitchToDataSection("", I);
505 O << "\t.section\t\".llvm.linkonce.d." << name
506 << "\",\"aw\",@progbits\n";
508 case GlobalValue::AppendingLinkage:
509 // FIXME: appending linkage variables
510 // should go into a section of their name or
511 // something. For now, just emit them as external.
512 case GlobalValue::ExternalLinkage:
513 // If external or appending, declare as a global symbol
514 O << TAI->getGlobalDirective() << name << "\n";
516 case GlobalValue::InternalLinkage:
517 // FIXME: special handling for ".ctors" & ".dtors" sections
518 if (I->hasSection() && (I->getSection() == ".ctors" ||
519 I->getSection() == ".dtors")) {
520 std::string SectionName = ".section " + I->getSection();
521 SectionName += ",\"aw\",%progbits";
522 SwitchToDataSection(SectionName.c_str());
524 if (C->isNullValue() && !NoZerosInBSS && TAI->getBSSSection())
525 SwitchToDataSection(TAI->getBSSSection(), I);
526 else if (!I->isConstant())
527 SwitchToDataSection(TAI->getDataSection(), I);
530 if (TAI->getReadOnlySection())
531 SwitchToDataSection(TAI->getReadOnlySection(), I);
533 SwitchToDataSection(TAI->getDataSection(), I);
537 case GlobalValue::GhostLinkage:
538 cerr << "Should not have any unmaterialized functions!\n";
540 case GlobalValue::DLLImportLinkage:
541 cerr << "DLLImport linkage is not supported by this target!\n";
543 case GlobalValue::DLLExportLinkage:
544 cerr << "DLLExport linkage is not supported by this target!\n";
547 assert(0 && "Unknown linkage type!");
550 O << "\t.align " << Align << "\n";
551 O << "\t.type " << name << ",@object\n";
552 O << "\t.size " << name << "," << Size << "\n";
554 EmitGlobalConstant(C);
560 return AsmPrinter::doFinalization(M);