1 //===-- X86IntelAsmPrinter.cpp - Convert X86 LLVM code to Intel 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 Intel format assembly language.
12 // This printer is the output mechanism used by `llc'.
14 //===----------------------------------------------------------------------===//
16 #include "X86IntelAsmPrinter.h"
18 #include "llvm/Constants.h"
19 #include "llvm/Module.h"
20 #include "llvm/Assembly/Writer.h"
21 #include "llvm/Support/Mangler.h"
22 #include "llvm/Target/TargetOptions.h"
25 X86IntelAsmPrinter::X86IntelAsmPrinter(std::ostream &O, X86TargetMachine &TM)
26 : X86SharedAsmPrinter(O, TM) {
29 PrivateGlobalPrefix = "$";
30 AlignDirective = "\talign\t";
32 ZeroDirective = "\tdb\t";
33 ZeroDirectiveSuffix = " dup(0)";
34 AsciiDirective = "\tdb\t";
36 Data8bitsDirective = "\t.db\t";
37 Data16bitsDirective = "\t.dw\t";
38 Data32bitsDirective = "\t.dd\t";
39 Data64bitsDirective = "\t.dq\t";
40 HasDotTypeDotSizeDirective = false;
43 /// runOnMachineFunction - This uses the printMachineInstruction()
44 /// method to print assembly for each instruction.
46 bool X86IntelAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
48 // Let PassManager know we need debug information and relay
49 // the MachineDebugInfo address on to DwarfWriter.
50 DW.SetDebugInfo(&getAnalysis<MachineDebugInfo>());
53 SetupMachineFunction(MF);
56 // Print out constants referenced by the function
57 EmitConstantPool(MF.getConstantPool());
59 // Print out labels for the function.
60 SwitchSection(".code", MF.getFunction());
62 if (MF.getFunction()->getLinkage() == GlobalValue::ExternalLinkage)
63 O << "\tpublic " << CurrentFnName << "\n";
64 O << CurrentFnName << "\tproc near\n";
67 // Emit pre-function debug information.
68 DW.BeginFunction(&MF);
71 // Print out code for the function.
72 for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
74 // Print a label for the basic block if there are any predecessors.
75 if (I->pred_begin() != I->pred_end()) {
76 printBasicBlockLabel(I, true);
79 for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
81 // Print the assembly for the instruction.
83 printMachineInstruction(II);
88 // Emit post-function debug information.
92 O << CurrentFnName << "\tendp\n";
94 // We didn't modify anything.
98 void X86IntelAsmPrinter::printSSECC(const MachineInstr *MI, unsigned Op) {
99 unsigned char value = MI->getOperand(Op).getImmedValue();
100 assert(value <= 7 && "Invalid ssecc argument!");
102 case 0: O << "eq"; break;
103 case 1: O << "lt"; break;
104 case 2: O << "le"; break;
105 case 3: O << "unord"; break;
106 case 4: O << "neq"; break;
107 case 5: O << "nlt"; break;
108 case 6: O << "nle"; break;
109 case 7: O << "ord"; break;
113 void X86IntelAsmPrinter::printOp(const MachineOperand &MO,
114 const char *Modifier) {
115 const MRegisterInfo &RI = *TM.getRegisterInfo();
116 switch (MO.getType()) {
117 case MachineOperand::MO_VirtualRegister:
118 if (MRegisterInfo::isPhysicalRegister(MO.getReg()))
119 O << RI.get(MO.getReg()).Name;
121 O << "reg" << MO.getReg();
124 case MachineOperand::MO_SignExtendedImmed:
125 case MachineOperand::MO_UnextendedImmed:
126 O << (int)MO.getImmedValue();
128 case MachineOperand::MO_MachineBasicBlock:
129 printBasicBlockLabel(MO.getMachineBasicBlock());
131 case MachineOperand::MO_ConstantPoolIndex: {
132 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
133 if (!isMemOp) O << "OFFSET ";
134 O << "[" << PrivateGlobalPrefix << "CPI" << getFunctionNumber() << "_"
135 << MO.getConstantPoolIndex();
136 if (forDarwin && TM.getRelocationModel() == Reloc::PIC)
137 O << "-\"L" << getFunctionNumber() << "$pb\"";
138 int Offset = MO.getOffset();
140 O << " + " << Offset;
146 case MachineOperand::MO_GlobalAddress: {
147 bool isCallOp = Modifier && !strcmp(Modifier, "call");
148 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
149 if (!isMemOp && !isCallOp) O << "OFFSET ";
150 if (forDarwin && TM.getRelocationModel() != Reloc::Static) {
151 GlobalValue *GV = MO.getGlobal();
152 std::string Name = Mang->getValueName(GV);
153 if (!isMemOp && !isCallOp) O << '$';
154 // Link-once, External, or Weakly-linked global variables need
155 // non-lazily-resolved stubs
156 if (GV->isExternal() || GV->hasWeakLinkage() ||
157 GV->hasLinkOnceLinkage()) {
158 // Dynamically-resolved functions need a stub for the function.
159 if (isCallOp && isa<Function>(GV) && cast<Function>(GV)->isExternal()) {
160 FnStubs.insert(Name);
161 O << "L" << Name << "$stub";
163 GVStubs.insert(Name);
164 O << "L" << Name << "$non_lazy_ptr";
167 O << Mang->getValueName(GV);
169 if (!isCallOp && TM.getRelocationModel() == Reloc::PIC)
170 O << "-\"L" << getFunctionNumber() << "$pb\"";
172 O << Mang->getValueName(MO.getGlobal());
173 int Offset = MO.getOffset();
175 O << " + " << Offset;
180 case MachineOperand::MO_ExternalSymbol: {
181 bool isCallOp = Modifier && !strcmp(Modifier, "call");
182 if (isCallOp && forDarwin && TM.getRelocationModel() != Reloc::Static) {
183 std::string Name(GlobalPrefix);
184 Name += MO.getSymbolName();
185 FnStubs.insert(Name);
186 O << "L" << Name << "$stub";
189 if (!isCallOp) O << "OFFSET ";
190 O << GlobalPrefix << MO.getSymbolName();
194 O << "<unknown operand type>"; return;
198 void X86IntelAsmPrinter::printMemReference(const MachineInstr *MI, unsigned Op){
199 assert(isMem(MI, Op) && "Invalid memory reference!");
201 const MachineOperand &BaseReg = MI->getOperand(Op);
202 int ScaleVal = MI->getOperand(Op+1).getImmedValue();
203 const MachineOperand &IndexReg = MI->getOperand(Op+2);
204 const MachineOperand &DispSpec = MI->getOperand(Op+3);
206 if (BaseReg.isFrameIndex()) {
207 O << "[frame slot #" << BaseReg.getFrameIndex();
208 if (DispSpec.getImmedValue())
209 O << " + " << DispSpec.getImmedValue();
215 bool NeedPlus = false;
216 if (BaseReg.getReg()) {
217 printOp(BaseReg, "mem");
221 if (IndexReg.getReg()) {
222 if (NeedPlus) O << " + ";
224 O << ScaleVal << "*";
229 if (DispSpec.isGlobalAddress() || DispSpec.isConstantPoolIndex()) {
232 printOp(DispSpec, "mem");
234 int DispVal = DispSpec.getImmedValue();
235 if (DispVal || (!BaseReg.getReg() && !IndexReg.getReg())) {
249 void X86IntelAsmPrinter::printPICLabel(const MachineInstr *MI, unsigned Op) {
250 O << "\"L" << getFunctionNumber() << "$pb\"\n";
251 O << "\"L" << getFunctionNumber() << "$pb\":";
254 bool X86IntelAsmPrinter::printAsmMRegister(const MachineOperand &MO,
256 const MRegisterInfo &RI = *TM.getRegisterInfo();
257 unsigned Reg = MO.getReg();
258 const char *Name = RI.get(Reg).Name;
260 default: return true; // Unknown mode.
261 case 'b': // Print QImode register
263 default: return true;
264 case X86::AH: case X86::AL: case X86::AX: case X86::EAX:
267 case X86::DH: case X86::DL: case X86::DX: case X86::EDX:
270 case X86::CH: case X86::CL: case X86::CX: case X86::ECX:
273 case X86::BH: case X86::BL: case X86::BX: case X86::EBX:
290 case 'h': // Print QImode high register
292 default: return true;
293 case X86::AH: case X86::AL: case X86::AX: case X86::EAX:
296 case X86::DH: case X86::DL: case X86::DX: case X86::EDX:
299 case X86::CH: case X86::CL: case X86::CX: case X86::ECX:
302 case X86::BH: case X86::BL: case X86::BX: case X86::EBX:
307 case 'w': // Print HImode register
309 default: return true;
310 case X86::AH: case X86::AL: case X86::AX: case X86::EAX:
313 case X86::DH: case X86::DL: case X86::DX: case X86::EDX:
316 case X86::CH: case X86::CL: case X86::CX: case X86::ECX:
319 case X86::BH: case X86::BL: case X86::BX: case X86::EBX:
336 case 'k': // Print SImode register
338 default: return true;
339 case X86::AH: case X86::AL: case X86::AX: case X86::EAX:
342 case X86::DH: case X86::DL: case X86::DX: case X86::EDX:
345 case X86::CH: case X86::CL: case X86::CX: case X86::ECX:
348 case X86::BH: case X86::BL: case X86::BX: case X86::EBX:
371 /// PrintAsmOperand - Print out an operand for an inline asm expression.
373 bool X86IntelAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
375 const char *ExtraCode) {
376 // Does this asm operand have a single letter operand modifier?
377 if (ExtraCode && ExtraCode[0]) {
378 if (ExtraCode[1] != 0) return true; // Unknown modifier.
380 switch (ExtraCode[0]) {
381 default: return true; // Unknown modifier.
382 case 'b': // Print QImode register
383 case 'h': // Print QImode high register
384 case 'w': // Print HImode register
385 case 'k': // Print SImode register
386 return printAsmMRegister(MI->getOperand(OpNo), ExtraCode[0]);
390 printOperand(MI, OpNo);
394 bool X86IntelAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
397 const char *ExtraCode) {
398 if (ExtraCode && ExtraCode[0])
399 return true; // Unknown modifier.
400 printMemReference(MI, OpNo);
404 /// printMachineInstruction -- Print out a single X86 LLVM instruction
405 /// MI in Intel syntax to the current output stream.
407 void X86IntelAsmPrinter::printMachineInstruction(const MachineInstr *MI) {
410 // Call the autogenerated instruction printer routines.
411 printInstruction(MI);
414 bool X86IntelAsmPrinter::doInitialization(Module &M) {
415 X86SharedAsmPrinter::doInitialization(M);
416 Mang->markCharUnacceptable('.');
417 PrivateGlobalPrefix = "$"; // need this here too :(
418 O << "\t.686\n\t.model flat\n\n";
420 // Emit declarations for external functions.
421 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
423 O << "\textern " << Mang->getValueName(I) << ":near\n";
425 // Emit declarations for external globals.
426 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
429 O << "\textern " << Mang->getValueName(I) << ":byte\n";
435 bool X86IntelAsmPrinter::doFinalization(Module &M) {
436 X86SharedAsmPrinter::doFinalization(M);
437 SwitchSection("", 0);
442 void X86IntelAsmPrinter::EmitString(const ConstantArray *CVA) const {
443 unsigned NumElts = CVA->getNumOperands();
445 // ML does not have escape sequences except '' for '. It also has a maximum
446 // string length of 255.
448 bool inString = false;
449 for (unsigned i = 0; i < NumElts; i++) {
450 int n = cast<ConstantInt>(CVA->getOperand(i))->getRawValue() & 255;
454 if (n >= 32 && n <= 127) {
481 len += 1 + (n > 9) + (n > 99);
502 // Include the auto-generated portion of the assembly writer.
503 #include "X86GenAsmWriter1.inc"