1 //===-- X86ATTAsmPrinter.cpp - Convert X86 LLVM code to AT&T assembly -----===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source 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 AT&T format assembly
12 // language. This printer is the output mechanism used by `llc'.
14 //===----------------------------------------------------------------------===//
16 #define DEBUG_TYPE "asm-printer"
17 #include "X86ATTAsmPrinter.h"
20 #include "X86MachineFunctionInfo.h"
21 #include "X86TargetMachine.h"
22 #include "X86TargetAsmInfo.h"
23 #include "llvm/ADT/StringExtras.h"
24 #include "llvm/CallingConv.h"
25 #include "llvm/Module.h"
26 #include "llvm/Support/Mangler.h"
27 #include "llvm/Target/TargetAsmInfo.h"
28 #include "llvm/Target/TargetOptions.h"
29 #include "llvm/ADT/Statistic.h"
32 STATISTIC(EmittedInsts, "Number of machine instrs printed");
34 static std::string computePICLabel(unsigned FnNum,
35 const TargetAsmInfo *TAI,
36 const X86Subtarget* Subtarget) {
38 if (Subtarget->isTargetDarwin())
39 label = "\"L" + utostr_32(FnNum) + "$pb\"";
40 else if (Subtarget->isTargetELF())
41 label = ".Lllvm$" + utostr_32(FnNum) + "$piclabel";
43 assert(0 && "Don't know how to print PIC label!\n");
48 /// getSectionForFunction - Return the section that we should emit the
49 /// specified function body into.
50 std::string X86ATTAsmPrinter::getSectionForFunction(const Function &F) const {
51 switch (F.getLinkage()) {
52 default: assert(0 && "Unknown linkage type!");
53 case Function::InternalLinkage:
54 case Function::DLLExportLinkage:
55 case Function::ExternalLinkage:
56 return TAI->getTextSection();
57 case Function::WeakLinkage:
58 case Function::LinkOnceLinkage:
59 if (Subtarget->isTargetDarwin()) {
60 return ".section __TEXT,__textcoal_nt,coalesced,pure_instructions";
61 } else if (Subtarget->isTargetCygMing()) {
62 return "\t.section\t.text$linkonce." + CurrentFnName + ",\"ax\"";
64 return "\t.section\t.llvm.linkonce.t." + CurrentFnName +
70 /// runOnMachineFunction - This uses the printMachineInstruction()
71 /// method to print assembly for each instruction.
73 bool X86ATTAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
74 if (TAI->doesSupportDebugInformation()) {
75 // Let PassManager know we need debug information and relay
76 // the MachineModuleInfo address on to DwarfWriter.
77 MMI = &getAnalysis<MachineModuleInfo>();
78 DW.SetModuleInfo(MMI);
81 SetupMachineFunction(MF);
84 // Print out constants referenced by the function
85 EmitConstantPool(MF.getConstantPool());
87 // Print out labels for the function.
88 const Function *F = MF.getFunction();
89 unsigned CC = F->getCallingConv();
91 // Populate function information map. Actually, We don't want to populate
92 // non-stdcall or non-fastcall functions' information right now.
93 if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall)
94 FunctionInfoMap[F] = *MF.getInfo<X86MachineFunctionInfo>();
96 X86SharedAsmPrinter::decorateName(CurrentFnName, F);
98 SwitchToTextSection(getSectionForFunction(*F).c_str(), F);
100 switch (F->getLinkage()) {
101 default: assert(0 && "Unknown linkage type!");
102 case Function::InternalLinkage: // Symbols default to internal.
103 if (Subtarget->isTargetDarwin())
104 // FIXME: This should be parameterized somewhere.
105 EmitAlignment(4, F, 0, true, 0x90);
107 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
109 case Function::DLLExportLinkage:
110 DLLExportedFns.insert(Mang->makeNameProper(F->getName(), ""));
112 case Function::ExternalLinkage:
113 if (Subtarget->isTargetDarwin())
114 // FIXME: This should be parameterized somewhere.
115 EmitAlignment(4, F, 0, true, 0x90);
117 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
118 O << "\t.globl\t" << CurrentFnName << "\n";
120 case Function::LinkOnceLinkage:
121 case Function::WeakLinkage:
122 if (Subtarget->isTargetDarwin()) {
123 // FIXME: This should be parameterized somewhere.
124 EmitAlignment(4, F, 0, true, 0x90);
125 O << "\t.globl\t" << CurrentFnName << "\n";
126 O << "\t.weak_definition\t" << CurrentFnName << "\n";
127 } else if (Subtarget->isTargetCygMing()) {
128 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
129 O << "\t.globl\t" << CurrentFnName << "\n";
130 O << "\t.linkonce discard\n";
132 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
133 O << "\t.weak\t" << CurrentFnName << "\n";
137 if (F->hasHiddenVisibility()) {
138 if (const char *Directive = TAI->getHiddenDirective())
139 O << Directive << CurrentFnName << "\n";
140 } else if (F->hasProtectedVisibility()) {
141 if (const char *Directive = TAI->getProtectedDirective())
142 O << Directive << CurrentFnName << "\n";
145 if (Subtarget->isTargetELF())
146 O << "\t.type\t" << CurrentFnName << ",@function\n";
147 else if (Subtarget->isTargetCygMing()) {
148 O << "\t.def\t " << CurrentFnName
150 (F->getLinkage() == Function::InternalLinkage ? COFF::C_STAT : COFF::C_EXT)
151 << ";\t.type\t" << (COFF::DT_FCN << COFF::N_BTSHFT)
155 O << CurrentFnName << ":\n";
156 // Add some workaround for linkonce linkage on Cygwin\MinGW
157 if (Subtarget->isTargetCygMing() &&
158 (F->getLinkage() == Function::LinkOnceLinkage ||
159 F->getLinkage() == Function::WeakLinkage))
160 O << "Lllvm$workaround$fake$stub$" << CurrentFnName << ":\n";
162 if (TAI->doesSupportDebugInformation()) {
163 // Emit pre-function debug information.
164 DW.BeginFunction(&MF);
167 // Print out code for the function.
168 for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
170 // Print a label for the basic block.
171 if (!I->pred_empty()) {
172 printBasicBlockLabel(I, true);
175 for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
177 // Print the assembly for the instruction.
179 printMachineInstruction(II);
183 if (TAI->hasDotTypeDotSizeDirective())
184 O << "\t.size\t" << CurrentFnName << ", .-" << CurrentFnName << "\n";
186 if (TAI->doesSupportDebugInformation()) {
187 // Emit post-function debug information.
191 // Print out jump tables referenced by the function.
192 EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
194 // We didn't modify anything.
198 static inline bool printGOT(TargetMachine &TM, const X86Subtarget* ST) {
199 return ST->isPICStyleGOT() && TM.getRelocationModel() == Reloc::PIC_;
202 static inline bool printStub(TargetMachine &TM, const X86Subtarget* ST) {
203 return ST->isPICStyleStub() && TM.getRelocationModel() != Reloc::Static;
206 void X86ATTAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
207 const char *Modifier, bool NotRIPRel) {
208 const MachineOperand &MO = MI->getOperand(OpNo);
209 const MRegisterInfo &RI = *TM.getRegisterInfo();
210 switch (MO.getType()) {
211 case MachineOperand::MO_Register: {
212 assert(MRegisterInfo::isPhysicalRegister(MO.getReg()) &&
213 "Virtual registers should not make it this far!");
215 unsigned Reg = MO.getReg();
216 if (Modifier && strncmp(Modifier, "subreg", strlen("subreg")) == 0) {
217 MVT::ValueType VT = (strcmp(Modifier+6,"64") == 0) ?
218 MVT::i64 : ((strcmp(Modifier+6, "32") == 0) ? MVT::i32 :
219 ((strcmp(Modifier+6,"16") == 0) ? MVT::i16 : MVT::i8));
220 Reg = getX86SubSuperRegister(Reg, VT);
222 for (const char *Name = RI.get(Reg).Name; *Name; ++Name)
223 O << (char)tolower(*Name);
227 case MachineOperand::MO_Immediate:
229 (strcmp(Modifier, "debug") && strcmp(Modifier, "mem")))
231 O << MO.getImmedValue();
233 case MachineOperand::MO_MachineBasicBlock:
234 printBasicBlockLabel(MO.getMachineBasicBlock());
236 case MachineOperand::MO_JumpTableIndex: {
237 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
238 if (!isMemOp) O << '$';
239 O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() << "_"
240 << MO.getJumpTableIndex();
242 if (TM.getRelocationModel() == Reloc::PIC_) {
243 if (Subtarget->isPICStyleStub())
244 O << "-\"" << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
246 else if (Subtarget->isPICStyleGOT())
250 if (isMemOp && Subtarget->isPICStyleRIPRel() && !NotRIPRel)
254 case MachineOperand::MO_ConstantPoolIndex: {
255 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
256 if (!isMemOp) O << '$';
257 O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_"
258 << MO.getConstantPoolIndex();
260 if (TM.getRelocationModel() == Reloc::PIC_) {
261 if (Subtarget->isPICStyleStub())
262 O << "-\"" << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
264 else if (Subtarget->isPICStyleGOT())
268 int Offset = MO.getOffset();
274 if (isMemOp && Subtarget->isPICStyleRIPRel() && !NotRIPRel)
278 case MachineOperand::MO_GlobalAddress: {
279 bool isCallOp = Modifier && !strcmp(Modifier, "call");
280 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
281 bool needCloseParen = false;
283 GlobalValue *GV = MO.getGlobal();
284 GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
285 bool isThreadLocal = GVar && GVar->isThreadLocal();
287 std::string Name = Mang->getValueName(GV);
288 X86SharedAsmPrinter::decorateName(Name, GV);
290 if (!isMemOp && !isCallOp)
292 else if (Name[0] == '$') {
293 // The name begins with a dollar-sign. In order to avoid having it look
294 // like an integer immediate to the assembler, enclose it in parens.
296 needCloseParen = true;
299 if (printStub(TM, Subtarget)) {
300 // Link-once, declaration, or Weakly-linked global variables need
301 // non-lazily-resolved stubs
302 if (GV->isDeclaration() ||
303 GV->hasWeakLinkage() ||
304 GV->hasLinkOnceLinkage()) {
305 // Dynamically-resolved functions need a stub for the function.
306 if (isCallOp && isa<Function>(GV)) {
307 FnStubs.insert(Name);
308 O << TAI->getPrivateGlobalPrefix() << Name << "$stub";
310 GVStubs.insert(Name);
311 O << TAI->getPrivateGlobalPrefix() << Name << "$non_lazy_ptr";
314 if (GV->hasDLLImportLinkage())
319 if (!isCallOp && TM.getRelocationModel() == Reloc::PIC_)
320 O << "-\"" << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
323 if (GV->hasDLLImportLinkage()) {
328 if (isCallOp && isa<Function>(GV)) {
329 if (printGOT(TM, Subtarget)) {
330 // Assemble call via PLT for non-local symbols
331 if (!(GV->hasHiddenVisibility() || GV->hasProtectedVisibility()) ||
335 if (Subtarget->isTargetCygMing() && GV->isDeclaration())
336 // Save function name for later type emission
337 FnStubs.insert(Name);
341 if (GV->hasExternalWeakLinkage())
342 ExtWeakSymbols.insert(GV);
344 int Offset = MO.getOffset();
351 if (TM.getRelocationModel() == Reloc::PIC_)
352 O << "@TLSGD"; // general dynamic TLS model
354 if (GV->isDeclaration())
355 O << "@INDNTPOFF"; // initial exec TLS model
357 O << "@NTPOFF"; // local exec TLS model
358 } else if (isMemOp) {
359 if (printGOT(TM, Subtarget)) {
360 if (Subtarget->GVRequiresExtraLoad(GV, TM, false))
364 } else if (Subtarget->isPICStyleRIPRel() && !NotRIPRel &&
365 TM.getRelocationModel() != Reloc::Static) {
366 if ((GV->isDeclaration() ||
367 GV->hasWeakLinkage() ||
368 GV->hasLinkOnceLinkage()) &&
369 TM.getRelocationModel() != Reloc::Static)
372 if (needCloseParen) {
373 needCloseParen = false;
377 // Use rip when possible to reduce code size, except when
378 // index or base register are also part of the address. e.g.
379 // foo(%rip)(%rcx,%rax,4) is not legal
389 case MachineOperand::MO_ExternalSymbol: {
390 bool isCallOp = Modifier && !strcmp(Modifier, "call");
391 bool needCloseParen = false;
392 std::string Name(TAI->getGlobalPrefix());
393 Name += MO.getSymbolName();
394 if (isCallOp && printStub(TM, Subtarget)) {
395 FnStubs.insert(Name);
396 O << TAI->getPrivateGlobalPrefix() << Name << "$stub";
401 else if (Name[0] == '$') {
402 // The name begins with a dollar-sign. In order to avoid having it look
403 // like an integer immediate to the assembler, enclose it in parens.
405 needCloseParen = true;
410 if (printGOT(TM, Subtarget)) {
411 std::string GOTName(TAI->getGlobalPrefix());
412 GOTName+="_GLOBAL_OFFSET_TABLE_";
414 // HACK! Emit extra offset to PC during printing GOT offset to
415 // compensate for the size of popl instruction. The resulting code
419 // popl %some_register
420 // addl $_GLOBAL_ADDRESS_TABLE_ + [.-piclabel], %some_register
422 << computePICLabel(getFunctionNumber(), TAI, Subtarget) << "]";
431 if (!isCallOp && Subtarget->isPICStyleRIPRel())
437 O << "<unknown operand type>"; return;
441 void X86ATTAsmPrinter::printSSECC(const MachineInstr *MI, unsigned Op) {
442 unsigned char value = MI->getOperand(Op).getImmedValue();
443 assert(value <= 7 && "Invalid ssecc argument!");
445 case 0: O << "eq"; break;
446 case 1: O << "lt"; break;
447 case 2: O << "le"; break;
448 case 3: O << "unord"; break;
449 case 4: O << "neq"; break;
450 case 5: O << "nlt"; break;
451 case 6: O << "nle"; break;
452 case 7: O << "ord"; break;
456 void X86ATTAsmPrinter::printMemReference(const MachineInstr *MI, unsigned Op,
457 const char *Modifier){
458 assert(isMem(MI, Op) && "Invalid memory reference!");
459 MachineOperand BaseReg = MI->getOperand(Op);
460 MachineOperand IndexReg = MI->getOperand(Op+2);
461 const MachineOperand &DispSpec = MI->getOperand(Op+3);
463 bool NotRIPRel = IndexReg.getReg() || BaseReg.getReg();
464 if (DispSpec.isGlobalAddress() ||
465 DispSpec.isConstantPoolIndex() ||
466 DispSpec.isJumpTableIndex()) {
467 printOperand(MI, Op+3, "mem", NotRIPRel);
469 int DispVal = DispSpec.getImmedValue();
470 if (DispVal || (!IndexReg.getReg() && !BaseReg.getReg()))
474 if (IndexReg.getReg() || BaseReg.getReg()) {
475 unsigned ScaleVal = MI->getOperand(Op+1).getImmedValue();
476 unsigned BaseRegOperand = 0, IndexRegOperand = 2;
478 // There are cases where we can end up with ESP/RSP in the indexreg slot.
479 // If this happens, swap the base/index register to support assemblers that
480 // don't work when the index is *SP.
481 if (IndexReg.getReg() == X86::ESP || IndexReg.getReg() == X86::RSP) {
482 assert(ScaleVal == 1 && "Scale not supported for stack pointer!");
483 std::swap(BaseReg, IndexReg);
484 std::swap(BaseRegOperand, IndexRegOperand);
488 if (BaseReg.getReg())
489 printOperand(MI, Op+BaseRegOperand, Modifier);
491 if (IndexReg.getReg()) {
493 printOperand(MI, Op+IndexRegOperand, Modifier);
495 O << "," << ScaleVal;
501 void X86ATTAsmPrinter::printPICJumpTableSetLabel(unsigned uid,
502 const MachineBasicBlock *MBB) const {
503 if (!TAI->getSetDirective())
506 O << TAI->getSetDirective() << ' ' << TAI->getPrivateGlobalPrefix()
507 << getFunctionNumber() << '_' << uid << "_set_" << MBB->getNumber() << ',';
508 printBasicBlockLabel(MBB, false, false);
509 if (Subtarget->isPICStyleRIPRel())
510 O << '-' << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
511 << '_' << uid << '\n';
513 O << '-' << computePICLabel(getFunctionNumber(), TAI, Subtarget) << '\n';
516 void X86ATTAsmPrinter::printPICLabel(const MachineInstr *MI, unsigned Op) {
517 std::string label = computePICLabel(getFunctionNumber(), TAI, Subtarget);
518 O << label << "\n" << label << ":";
522 bool X86ATTAsmPrinter::printAsmMRegister(const MachineOperand &MO,
524 const MRegisterInfo &RI = *TM.getRegisterInfo();
525 unsigned Reg = MO.getReg();
527 default: return true; // Unknown mode.
528 case 'b': // Print QImode register
529 Reg = getX86SubSuperRegister(Reg, MVT::i8);
531 case 'h': // Print QImode high register
532 Reg = getX86SubSuperRegister(Reg, MVT::i8, true);
534 case 'w': // Print HImode register
535 Reg = getX86SubSuperRegister(Reg, MVT::i16);
537 case 'k': // Print SImode register
538 Reg = getX86SubSuperRegister(Reg, MVT::i32);
540 case 'q': // Print DImode register
541 Reg = getX86SubSuperRegister(Reg, MVT::i64);
546 for (const char *Name = RI.get(Reg).Name; *Name; ++Name)
547 O << (char)tolower(*Name);
551 /// PrintAsmOperand - Print out an operand for an inline asm expression.
553 bool X86ATTAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
555 const char *ExtraCode) {
556 // Does this asm operand have a single letter operand modifier?
557 if (ExtraCode && ExtraCode[0]) {
558 if (ExtraCode[1] != 0) return true; // Unknown modifier.
560 switch (ExtraCode[0]) {
561 default: return true; // Unknown modifier.
562 case 'c': // Don't print "$" before a global var name or constant.
563 printOperand(MI, OpNo, "mem");
565 case 'b': // Print QImode register
566 case 'h': // Print QImode high register
567 case 'w': // Print HImode register
568 case 'k': // Print SImode register
569 case 'q': // Print DImode register
570 if (MI->getOperand(OpNo).isRegister())
571 return printAsmMRegister(MI->getOperand(OpNo), ExtraCode[0]);
572 printOperand(MI, OpNo);
575 case 'P': // Don't print @PLT, but do print as memory.
576 printOperand(MI, OpNo, "mem");
581 printOperand(MI, OpNo);
585 bool X86ATTAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
588 const char *ExtraCode) {
589 if (ExtraCode && ExtraCode[0]) {
590 if (ExtraCode[1] != 0) return true; // Unknown modifier.
592 switch (ExtraCode[0]) {
593 default: return true; // Unknown modifier.
594 case 'b': // Print QImode register
595 case 'h': // Print QImode high register
596 case 'w': // Print HImode register
597 case 'k': // Print SImode register
598 case 'q': // Print SImode register
599 // These only apply to registers, ignore on mem.
603 printMemReference(MI, OpNo);
607 /// printMachineInstruction -- Print out a single X86 LLVM instruction
608 /// MI in AT&T syntax to the current output stream.
610 void X86ATTAsmPrinter::printMachineInstruction(const MachineInstr *MI) {
613 // See if a truncate instruction can be turned into a nop.
614 switch (MI->getOpcode()) {
616 case X86::PsMOVZX64rr32:
617 O << TAI->getCommentString() << " ZERO-EXTEND " << "\n\t";
621 // Call the autogenerated instruction printer routines.
622 printInstruction(MI);
625 // Include the auto-generated portion of the assembly writer.
626 #include "X86GenAsmWriter.inc"