blob: 03a22865e2ce8378a6689229b20ab715f23181cf [file] [log] [blame]
Chris Lattnerb36cbd02005-07-01 22:44:09 +00001//===-- X86ATTAsmPrinter.cpp - Convert X86 LLVM code to Intel assembly ----===//
2//
3// The LLVM Compiler Infrastructure
4//
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.
7//
8//===----------------------------------------------------------------------===//
9//
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'.
13//
14//===----------------------------------------------------------------------===//
15
Chris Lattner95b2c7d2006-12-19 22:59:26 +000016#define DEBUG_TYPE "asm-printer"
Chris Lattnerb36cbd02005-07-01 22:44:09 +000017#include "X86ATTAsmPrinter.h"
18#include "X86.h"
Anton Korobeynikovd05ca652007-01-16 16:41:57 +000019#include "X86COFF.h"
Anton Korobeynikovf8248682006-09-20 22:03:51 +000020#include "X86MachineFunctionInfo.h"
Chris Lattnerb36cbd02005-07-01 22:44:09 +000021#include "X86TargetMachine.h"
Jim Laskeya0f3d172006-09-07 22:06:40 +000022#include "X86TargetAsmInfo.h"
Anton Korobeynikov7f705592007-01-12 19:20:47 +000023#include "llvm/ADT/StringExtras.h"
Anton Korobeynikovf8248682006-09-20 22:03:51 +000024#include "llvm/CallingConv.h"
Chris Lattnerb36cbd02005-07-01 22:44:09 +000025#include "llvm/Module.h"
26#include "llvm/Support/Mangler.h"
Jim Laskeya0f3d172006-09-07 22:06:40 +000027#include "llvm/Target/TargetAsmInfo.h"
Evan Cheng7ccced62006-02-18 00:15:05 +000028#include "llvm/Target/TargetOptions.h"
Chris Lattner95b2c7d2006-12-19 22:59:26 +000029#include "llvm/ADT/Statistic.h"
Chris Lattnerb36cbd02005-07-01 22:44:09 +000030using namespace llvm;
Chris Lattnerb36cbd02005-07-01 22:44:09 +000031
Chris Lattner95b2c7d2006-12-19 22:59:26 +000032STATISTIC(EmittedInsts, "Number of machine instrs printed");
33
Evan Cheng071b9d52007-01-18 01:49:58 +000034static std::string computePICLabel(unsigned FnNum,
35 const TargetAsmInfo *TAI,
36 const X86Subtarget* Subtarget) {
Anton Korobeynikov7f705592007-01-12 19:20:47 +000037 std::string label;
Evan Cheng071b9d52007-01-18 01:49:58 +000038 if (Subtarget->isTargetDarwin())
39 label = "\"L" + utostr_32(FnNum) + "$pb\"";
40 else if (Subtarget->isTargetELF())
41 label = ".Lllvm$" + utostr_32(FnNum) + "$piclabel";
42 else
Anton Korobeynikov7f705592007-01-12 19:20:47 +000043 assert(0 && "Don't know how to print PIC label!\n");
44
45 return label;
46}
47
Chris Lattnerafbfded2006-10-05 02:43:52 +000048/// getSectionForFunction - Return the section that we should emit the
49/// specified function body into.
50std::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";
Anton Korobeynikov317848f2007-01-03 11:43:14 +000061 } else if (Subtarget->isTargetCygMing()) {
Anton Korobeynikovb1c88022006-10-18 09:12:29 +000062 return "\t.section\t.text$linkonce." + CurrentFnName + ",\"ax\"\n";
Chris Lattnerafbfded2006-10-05 02:43:52 +000063 } else {
64 return "\t.section\t.llvm.linkonce.t." + CurrentFnName +
65 ",\"ax\",@progbits\n";
66 }
67 }
68}
69
Chris Lattnerb36cbd02005-07-01 22:44:09 +000070/// runOnMachineFunction - This uses the printMachineInstruction()
71/// method to print assembly for each instruction.
72///
73bool X86ATTAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
Anton Korobeynikovab4022f2006-10-31 08:31:24 +000074 if (Subtarget->isTargetDarwin() ||
75 Subtarget->isTargetELF() ||
Anton Korobeynikov317848f2007-01-03 11:43:14 +000076 Subtarget->isTargetCygMing()) {
Jim Laskeye29c2f52006-07-19 11:54:50 +000077 // Let PassManager know we need debug information and relay
Jim Laskey44c3b9f2007-01-26 21:22:28 +000078 // the MachineModuleInfo address on to DwarfWriter.
79 DW.SetModuleInfo(&getAnalysis<MachineModuleInfo>());
Jim Laskeye29c2f52006-07-19 11:54:50 +000080 }
Evan Cheng3c992d22006-03-07 02:02:57 +000081
Chris Lattner8b8b9512005-11-21 07:51:23 +000082 SetupMachineFunction(MF);
Chris Lattnerb36cbd02005-07-01 22:44:09 +000083 O << "\n\n";
84
85 // Print out constants referenced by the function
Chris Lattnerd939f6c2005-11-21 08:32:23 +000086 EmitConstantPool(MF.getConstantPool());
Chris Lattnerb36cbd02005-07-01 22:44:09 +000087
88 // Print out labels for the function.
Evan Cheng2338c5c2006-02-07 08:38:37 +000089 const Function *F = MF.getFunction();
Anton Korobeynikovf8248682006-09-20 22:03:51 +000090 unsigned CC = F->getCallingConv();
91
92 // Populate function information map. Actually, We don't want to populate
93 // non-stdcall or non-fastcall functions' information right now.
Chris Lattnere87e1152006-09-26 03:57:53 +000094 if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall)
Chris Lattnerd15dff22007-04-17 17:21:52 +000095 FunctionInfoMap[F] = *MF.getInfo<X86MachineFunctionInfo>();
Anton Korobeynikovf8248682006-09-20 22:03:51 +000096
97 X86SharedAsmPrinter::decorateName(CurrentFnName, F);
98
Anton Korobeynikovd5f317d2007-01-07 00:41:20 +000099 SwitchToTextSection(getSectionForFunction(*F).c_str(), F);
Anton Korobeynikovcea9d1d2007-01-06 18:24:26 +0000100
Evan Cheng2338c5c2006-02-07 08:38:37 +0000101 switch (F->getLinkage()) {
102 default: assert(0 && "Unknown linkage type!");
103 case Function::InternalLinkage: // Symbols default to internal.
Evan Cheng2338c5c2006-02-07 08:38:37 +0000104 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
105 break;
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000106 case Function::DLLExportLinkage:
107 DLLExportedFns.insert(Mang->makeNameProper(F->getName(), ""));
108 //FALLS THROUGH
Evan Cheng2338c5c2006-02-07 08:38:37 +0000109 case Function::ExternalLinkage:
Evan Cheng2338c5c2006-02-07 08:38:37 +0000110 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000111 O << "\t.globl\t" << CurrentFnName << "\n";
Evan Cheng2338c5c2006-02-07 08:38:37 +0000112 break;
Evan Cheng2338c5c2006-02-07 08:38:37 +0000113 case Function::LinkOnceLinkage:
Anton Korobeynikovb1c88022006-10-18 09:12:29 +0000114 case Function::WeakLinkage:
Jim Laskeyea348582006-07-27 02:05:13 +0000115 if (Subtarget->isTargetDarwin()) {
Evan Chengf1616da2006-02-22 23:59:57 +0000116 O << "\t.globl\t" << CurrentFnName << "\n";
Evan Cheng2338c5c2006-02-07 08:38:37 +0000117 O << "\t.weak_definition\t" << CurrentFnName << "\n";
Anton Korobeynikov317848f2007-01-03 11:43:14 +0000118 } else if (Subtarget->isTargetCygMing()) {
Evan Cheng932ad512006-05-25 21:59:08 +0000119 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
Anton Korobeynikovb7188b12006-10-17 20:29:49 +0000120 O << "\t.globl " << CurrentFnName << "\n";
Anton Korobeynikov66413092007-02-23 01:58:50 +0000121 O << "\t.linkonce discard\n";
Anton Korobeynikovb7188b12006-10-17 20:29:49 +0000122 } else {
123 EmitAlignment(4, F); // FIXME: This should be parameterized somewhere.
124 O << "\t.weak " << CurrentFnName << "\n";
125 }
126 break;
Evan Cheng2338c5c2006-02-07 08:38:37 +0000127 }
Chris Lattner43bbc5c2007-01-14 06:29:53 +0000128 if (F->hasHiddenVisibility())
129 if (const char *Directive = TAI->getHiddenDirective())
130 O << Directive << CurrentFnName << "\n";
Anton Korobeynikovd05ca652007-01-16 16:41:57 +0000131
132 if (Subtarget->isTargetELF())
133 O << "\t.type " << CurrentFnName << ",@function\n";
134 else if (Subtarget->isTargetCygMing()) {
135 O << "\t.def\t " << CurrentFnName
136 << ";\t.scl\t" <<
137 (F->getLinkage() == Function::InternalLinkage ? COFF::C_STAT : COFF::C_EXT)
138 << ";\t.type\t" << (COFF::DT_FCN << COFF::N_BTSHFT)
139 << ";\t.endef\n";
140 }
141
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000142 O << CurrentFnName << ":\n";
Anton Korobeynikovb1c88022006-10-18 09:12:29 +0000143 // Add some workaround for linkonce linkage on Cygwin\MinGW
Anton Korobeynikov317848f2007-01-03 11:43:14 +0000144 if (Subtarget->isTargetCygMing() &&
Anton Korobeynikovb1c88022006-10-18 09:12:29 +0000145 (F->getLinkage() == Function::LinkOnceLinkage ||
146 F->getLinkage() == Function::WeakLinkage))
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000147 O << "Lllvm$workaround$fake$stub$" << CurrentFnName << ":\n";
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000148
Anton Korobeynikovab4022f2006-10-31 08:31:24 +0000149 if (Subtarget->isTargetDarwin() ||
150 Subtarget->isTargetELF() ||
Anton Korobeynikov317848f2007-01-03 11:43:14 +0000151 Subtarget->isTargetCygMing()) {
Jim Laskey6b92b8e2006-04-07 20:44:42 +0000152 // Emit pre-function debug information.
Jim Laskey89d67fa2006-06-23 12:51:53 +0000153 DW.BeginFunction(&MF);
Jim Laskey6b92b8e2006-04-07 20:44:42 +0000154 }
155
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000156 // Print out code for the function.
157 for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
158 I != E; ++I) {
159 // Print a label for the basic block.
Nate Begemancdf38c42006-05-02 05:37:32 +0000160 if (I->pred_begin() != I->pred_end()) {
161 printBasicBlockLabel(I, true);
162 O << '\n';
163 }
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000164 for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
165 II != E; ++II) {
166 // Print the assembly for the instruction.
167 O << "\t";
168 printMachineInstruction(II);
169 }
170 }
Evan Cheng67afece2006-08-28 22:14:16 +0000171
Chris Lattner1da31ee2006-10-05 03:01:21 +0000172 // Print out jump tables referenced by the function.
173
174 // Mac OS X requires that the jump table follow the function, so that the jump
175 // table is part of the same atom that the function is in.
176 EmitJumpTableInfo(MF.getJumpTableInfo(), MF);
Evan Cheng67afece2006-08-28 22:14:16 +0000177
Jim Laskey563321a2006-09-06 18:34:40 +0000178 if (TAI->hasDotTypeDotSizeDirective())
Nate Begeman73213f62005-07-12 01:37:28 +0000179 O << "\t.size " << CurrentFnName << ", .-" << CurrentFnName << "\n";
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000180
Anton Korobeynikovab4022f2006-10-31 08:31:24 +0000181 if (Subtarget->isTargetDarwin() ||
182 Subtarget->isTargetELF() ||
Anton Korobeynikov317848f2007-01-03 11:43:14 +0000183 Subtarget->isTargetCygMing()) {
Evan Chengd5948812006-03-07 02:23:26 +0000184 // Emit post-function debug information.
Jim Laskey99db0442006-03-23 18:09:44 +0000185 DW.EndFunction();
Evan Chengd5948812006-03-07 02:23:26 +0000186 }
Evan Cheng3c992d22006-03-07 02:02:57 +0000187
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000188 // We didn't modify anything.
189 return false;
190}
191
Evan Chengae19abc2007-01-18 22:27:12 +0000192static inline bool printGOT(TargetMachine &TM, const X86Subtarget* ST) {
193 return ST->isPICStyleGOT() && TM.getRelocationModel() == Reloc::PIC_;
194}
195
196static inline bool printStub(TargetMachine &TM, const X86Subtarget* ST) {
197 return ST->isPICStyleStub() && TM.getRelocationModel() != Reloc::Static;
198}
199
Chris Lattnera3b8c572006-02-06 23:41:19 +0000200void X86ATTAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
Evan Cheng28b514392006-12-05 19:50:18 +0000201 const char *Modifier, bool NotRIPRel) {
Chris Lattnera3b8c572006-02-06 23:41:19 +0000202 const MachineOperand &MO = MI->getOperand(OpNo);
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000203 const MRegisterInfo &RI = *TM.getRegisterInfo();
204 switch (MO.getType()) {
Evan Cheng8f7f7122006-05-05 05:40:20 +0000205 case MachineOperand::MO_Register: {
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000206 assert(MRegisterInfo::isPhysicalRegister(MO.getReg()) &&
207 "Virtual registers should not make it this far!");
208 O << '%';
Evan Cheng8f7f7122006-05-05 05:40:20 +0000209 unsigned Reg = MO.getReg();
Evan Chengcbe70e12006-05-31 22:34:26 +0000210 if (Modifier && strncmp(Modifier, "subreg", strlen("subreg")) == 0) {
Evan Cheng25ab6902006-09-08 06:48:29 +0000211 MVT::ValueType VT = (strcmp(Modifier+6,"64") == 0) ?
212 MVT::i64 : ((strcmp(Modifier+6, "32") == 0) ? MVT::i32 :
213 ((strcmp(Modifier+6,"16") == 0) ? MVT::i16 : MVT::i8));
Evan Cheng8f7f7122006-05-05 05:40:20 +0000214 Reg = getX86SubSuperRegister(Reg, VT);
215 }
216 for (const char *Name = RI.get(Reg).Name; *Name; ++Name)
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000217 O << (char)tolower(*Name);
218 return;
Evan Cheng8f7f7122006-05-05 05:40:20 +0000219 }
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000220
Chris Lattner63b3d712006-05-04 17:21:20 +0000221 case MachineOperand::MO_Immediate:
Chris Lattnerb4828722007-01-25 02:53:24 +0000222 if (!Modifier ||
223 (strcmp(Modifier, "debug") && strcmp(Modifier, "mem")))
Evan Cheng3c992d22006-03-07 02:02:57 +0000224 O << '$';
Evan Cheng138a24e2006-05-26 08:04:31 +0000225 O << MO.getImmedValue();
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000226 return;
Nate Begeman37efe672006-04-22 18:53:45 +0000227 case MachineOperand::MO_MachineBasicBlock:
228 printBasicBlockLabel(MO.getMachineBasicBlock());
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000229 return;
Nate Begeman37efe672006-04-22 18:53:45 +0000230 case MachineOperand::MO_JumpTableIndex: {
231 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
232 if (!isMemOp) O << '$';
Jim Laskey563321a2006-09-06 18:34:40 +0000233 O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() << "_"
Nate Begeman37efe672006-04-22 18:53:45 +0000234 << MO.getJumpTableIndex();
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000235
236 if (TM.getRelocationModel() == Reloc::PIC_) {
237 if (Subtarget->isPICStyleStub())
Evan Cheng071b9d52007-01-18 01:49:58 +0000238 O << "-\"" << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
239 << "$pb\"";
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000240 else if (Subtarget->isPICStyleGOT())
241 O << "@GOTOFF";
242 }
243
Evan Chengae19abc2007-01-18 22:27:12 +0000244 if (isMemOp && Subtarget->isPICStyleRIPRel() && !NotRIPRel)
Evan Cheng25ab6902006-09-08 06:48:29 +0000245 O << "(%rip)";
Nate Begeman37efe672006-04-22 18:53:45 +0000246 return;
247 }
Evan Chenga09bd812006-02-26 08:28:12 +0000248 case MachineOperand::MO_ConstantPoolIndex: {
249 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
250 if (!isMemOp) O << '$';
Jim Laskey563321a2006-09-06 18:34:40 +0000251 O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_"
Evan Chenga09bd812006-02-26 08:28:12 +0000252 << MO.getConstantPoolIndex();
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000253
254 if (TM.getRelocationModel() == Reloc::PIC_) {
255 if (Subtarget->isPICStyleStub())
Evan Cheng071b9d52007-01-18 01:49:58 +0000256 O << "-\"" << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
257 << "$pb\"";
Evan Chengae19abc2007-01-18 22:27:12 +0000258 else if (Subtarget->isPICStyleGOT())
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000259 O << "@GOTOFF";
260 }
261
Evan Chenga09bd812006-02-26 08:28:12 +0000262 int Offset = MO.getOffset();
263 if (Offset > 0)
264 O << "+" << Offset;
265 else if (Offset < 0)
266 O << Offset;
Evan Cheng25ab6902006-09-08 06:48:29 +0000267
Evan Chengae19abc2007-01-18 22:27:12 +0000268 if (isMemOp && Subtarget->isPICStyleRIPRel() && !NotRIPRel)
Evan Cheng25ab6902006-09-08 06:48:29 +0000269 O << "(%rip)";
Evan Chenga09bd812006-02-26 08:28:12 +0000270 return;
271 }
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000272 case MachineOperand::MO_GlobalAddress: {
Chris Lattnera3b8c572006-02-06 23:41:19 +0000273 bool isCallOp = Modifier && !strcmp(Modifier, "call");
Evan Cheng2338c5c2006-02-07 08:38:37 +0000274 bool isMemOp = Modifier && !strcmp(Modifier, "mem");
Dan Gohman2a3250c2007-04-26 21:07:05 +0000275 bool needCloseParen = false;
Evan Cheng25ab6902006-09-08 06:48:29 +0000276
Anton Korobeynikovf8248682006-09-20 22:03:51 +0000277 GlobalValue *GV = MO.getGlobal();
Lauro Ramos Venanciob3a04172007-04-20 21:38:10 +0000278 GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
279 bool isThreadLocal = GVar && GVar->isThreadLocal();
280
Evan Cheng25ab6902006-09-08 06:48:29 +0000281 std::string Name = Mang->getValueName(GV);
Chris Lattnere87e1152006-09-26 03:57:53 +0000282 X86SharedAsmPrinter::decorateName(Name, GV);
Anton Korobeynikovf8248682006-09-20 22:03:51 +0000283
Dan Gohman2a3250c2007-04-26 21:07:05 +0000284 if (!isMemOp && !isCallOp)
285 O << '$';
286 else if (Name[0] == '$') {
287 // The name begins with a dollar-sign. In order to avoid having it look
288 // like an integer immediate to the assembler, enclose it in parens.
289 O << '(';
290 needCloseParen = true;
291 }
292
Evan Chengae19abc2007-01-18 22:27:12 +0000293 if (printStub(TM, Subtarget)) {
Evan Cheng2338c5c2006-02-07 08:38:37 +0000294 // Link-once, External, or Weakly-linked global variables need
295 // non-lazily-resolved stubs
Reid Spencer5cbf9852007-01-30 20:08:39 +0000296 if (GV->isDeclaration() ||
Evan Chengae19abc2007-01-18 22:27:12 +0000297 GV->hasWeakLinkage() ||
298 GV->hasLinkOnceLinkage()) {
Evan Cheng2338c5c2006-02-07 08:38:37 +0000299 // Dynamically-resolved functions need a stub for the function.
Evan Cheng25ab6902006-09-08 06:48:29 +0000300 if (isCallOp && isa<Function>(GV)) {
Evan Cheng2338c5c2006-02-07 08:38:37 +0000301 FnStubs.insert(Name);
Evan Cheng071b9d52007-01-18 01:49:58 +0000302 O << TAI->getPrivateGlobalPrefix() << Name << "$stub";
Evan Cheng2338c5c2006-02-07 08:38:37 +0000303 } else {
304 GVStubs.insert(Name);
Evan Cheng071b9d52007-01-18 01:49:58 +0000305 O << TAI->getPrivateGlobalPrefix() << Name << "$non_lazy_ptr";
Evan Cheng2338c5c2006-02-07 08:38:37 +0000306 }
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000307 } else {
Evan Chengae19abc2007-01-18 22:27:12 +0000308 if (GV->hasDLLImportLinkage())
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000309 O << "__imp_";
Evan Cheng25ab6902006-09-08 06:48:29 +0000310 O << Name;
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000311 }
312
Chris Lattner35d86fe2006-07-26 21:12:04 +0000313 if (!isCallOp && TM.getRelocationModel() == Reloc::PIC_)
Evan Cheng071b9d52007-01-18 01:49:58 +0000314 O << "-\"" << TAI->getPrivateGlobalPrefix() << getFunctionNumber()
315 << "$pb\"";
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000316 } else {
317 if (GV->hasDLLImportLinkage()) {
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000318 O << "__imp_";
319 }
Evan Cheng25ab6902006-09-08 06:48:29 +0000320 O << Name;
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000321
Anton Korobeynikovd05ca652007-01-16 16:41:57 +0000322 if (isCallOp && isa<Function>(GV)) {
Evan Chengae19abc2007-01-18 22:27:12 +0000323 if (printGOT(TM, Subtarget)) {
Anton Korobeynikovd05ca652007-01-16 16:41:57 +0000324 // Assemble call via PLT for non-local symbols
Reid Spencer5cbf9852007-01-30 20:08:39 +0000325 if (!GV->hasHiddenVisibility() || GV->isDeclaration())
Anton Korobeynikovd05ca652007-01-16 16:41:57 +0000326 O << "@PLT";
327 }
Reid Spencer5cbf9852007-01-30 20:08:39 +0000328 if (Subtarget->isTargetCygMing() && GV->isDeclaration())
Anton Korobeynikovd05ca652007-01-16 16:41:57 +0000329 // Save function name for later type emission
330 FnStubs.insert(Name);
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000331 }
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000332 }
Anton Korobeynikov78ee7b72006-12-01 00:25:12 +0000333
Evan Cheng6d7d3102006-12-01 07:38:23 +0000334 if (GV->hasExternalWeakLinkage())
Rafael Espindola15404d02006-12-18 03:37:18 +0000335 ExtWeakSymbols.insert(GV);
Anton Korobeynikovb74ed072006-09-14 18:23:27 +0000336
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000337 int Offset = MO.getOffset();
338 if (Offset > 0)
339 O << "+" << Offset;
340 else if (Offset < 0)
341 O << Offset;
Evan Cheng25ab6902006-09-08 06:48:29 +0000342
Lauro Ramos Venanciob3a04172007-04-20 21:38:10 +0000343 if (isThreadLocal) {
344 if (TM.getRelocationModel() == Reloc::PIC_)
345 O << "@TLSGD"; // general dynamic TLS model
346 else
347 if (GV->isDeclaration())
348 O << "@INDNTPOFF"; // initial exec TLS model
349 else
350 O << "@NTPOFF"; // local exec TLS model
351 } else if (isMemOp) {
Evan Chengae19abc2007-01-18 22:27:12 +0000352 if (printGOT(TM, Subtarget)) {
Anton Korobeynikov5032e5a2007-01-17 10:33:08 +0000353 if (Subtarget->GVRequiresExtraLoad(GV, TM, false))
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000354 O << "@GOT";
Anton Korobeynikov5032e5a2007-01-17 10:33:08 +0000355 else
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000356 O << "@GOTOFF";
Evan Chengae19abc2007-01-18 22:27:12 +0000357 } else if (Subtarget->isPICStyleRIPRel() && !NotRIPRel) {
358 if ((GV->hasExternalLinkage() ||
359 GV->hasWeakLinkage() ||
360 GV->hasLinkOnceLinkage()) &&
361 TM.getRelocationModel() != Reloc::Static)
362 O << "@GOTPCREL";
Dan Gohman2a3250c2007-04-26 21:07:05 +0000363
364 if (needCloseParen) {
365 needCloseParen = false;
366 O << ')';
367 }
368
Evan Chengae19abc2007-01-18 22:27:12 +0000369 // Use rip when possible to reduce code size, except when
370 // index or base register are also part of the address. e.g.
371 // foo(%rip)(%rcx,%rax,4) is not legal
372 O << "(%rip)";
373 }
Evan Cheng25ab6902006-09-08 06:48:29 +0000374 }
375
Dan Gohman2a3250c2007-04-26 21:07:05 +0000376 if (needCloseParen)
377 O << ')';
378
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000379 return;
380 }
Chris Lattnera3b8c572006-02-06 23:41:19 +0000381 case MachineOperand::MO_ExternalSymbol: {
382 bool isCallOp = Modifier && !strcmp(Modifier, "call");
Dan Gohman2a3250c2007-04-26 21:07:05 +0000383 bool needCloseParen = false;
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000384 std::string Name(TAI->getGlobalPrefix());
385 Name += MO.getSymbolName();
Evan Chengae19abc2007-01-18 22:27:12 +0000386 if (isCallOp && printStub(TM, Subtarget)) {
Nate Begeman72b286b2005-07-08 00:23:26 +0000387 FnStubs.insert(Name);
Evan Cheng071b9d52007-01-18 01:49:58 +0000388 O << TAI->getPrivateGlobalPrefix() << Name << "$stub";
Nate Begeman72b286b2005-07-08 00:23:26 +0000389 return;
390 }
Dan Gohman2a3250c2007-04-26 21:07:05 +0000391 if (!isCallOp)
392 O << '$';
393 else if (Name[0] == '$') {
394 // The name begins with a dollar-sign. In order to avoid having it look
395 // like an integer immediate to the assembler, enclose it in parens.
396 O << '(';
397 needCloseParen = true;
398 }
399
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000400 O << Name;
401
Evan Chengae19abc2007-01-18 22:27:12 +0000402 if (printGOT(TM, Subtarget)) {
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000403 std::string GOTName(TAI->getGlobalPrefix());
404 GOTName+="_GLOBAL_OFFSET_TABLE_";
405 if (Name == GOTName)
Evan Chengae19abc2007-01-18 22:27:12 +0000406 // HACK! Emit extra offset to PC during printing GOT offset to
407 // compensate for the size of popl instruction. The resulting code
408 // should look like:
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000409 // call .piclabel
410 // piclabel:
411 // popl %some_register
412 // addl $_GLOBAL_ADDRESS_TABLE_ + [.-piclabel], %some_register
Evan Cheng071b9d52007-01-18 01:49:58 +0000413 O << " + [.-"
414 << computePICLabel(getFunctionNumber(), TAI, Subtarget) << "]";
Evan Chengae19abc2007-01-18 22:27:12 +0000415
416 if (isCallOp)
417 O << "@PLT";
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000418 }
419
Dan Gohman2a3250c2007-04-26 21:07:05 +0000420 if (needCloseParen)
421 O << ')';
422
Evan Chengae19abc2007-01-18 22:27:12 +0000423 if (!isCallOp && Subtarget->isPICStyleRIPRel())
Evan Cheng25ab6902006-09-08 06:48:29 +0000424 O << "(%rip)";
425
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000426 return;
Chris Lattnera3b8c572006-02-06 23:41:19 +0000427 }
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000428 default:
429 O << "<unknown operand type>"; return;
430 }
431}
432
Nate Begeman391c5d22005-11-30 18:54:35 +0000433void X86ATTAsmPrinter::printSSECC(const MachineInstr *MI, unsigned Op) {
Nate Begeman6c7cb292005-07-14 22:52:25 +0000434 unsigned char value = MI->getOperand(Op).getImmedValue();
435 assert(value <= 7 && "Invalid ssecc argument!");
436 switch (value) {
437 case 0: O << "eq"; break;
438 case 1: O << "lt"; break;
439 case 2: O << "le"; break;
440 case 3: O << "unord"; break;
441 case 4: O << "neq"; break;
442 case 5: O << "nlt"; break;
443 case 6: O << "nle"; break;
444 case 7: O << "ord"; break;
445 }
446}
447
Evan Cheng25ab6902006-09-08 06:48:29 +0000448void X86ATTAsmPrinter::printMemReference(const MachineInstr *MI, unsigned Op,
449 const char *Modifier){
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000450 assert(isMem(MI, Op) && "Invalid memory reference!");
Chris Lattner32c9a452007-01-14 00:13:07 +0000451 MachineOperand BaseReg = MI->getOperand(Op);
452 MachineOperand IndexReg = MI->getOperand(Op+2);
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000453 const MachineOperand &DispSpec = MI->getOperand(Op+3);
454
Evan Cheng28b514392006-12-05 19:50:18 +0000455 bool NotRIPRel = IndexReg.getReg() || BaseReg.getReg();
Evan Chengc9676de2006-08-29 22:14:48 +0000456 if (DispSpec.isGlobalAddress() ||
457 DispSpec.isConstantPoolIndex() ||
458 DispSpec.isJumpTableIndex()) {
Evan Cheng28b514392006-12-05 19:50:18 +0000459 printOperand(MI, Op+3, "mem", NotRIPRel);
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000460 } else {
461 int DispVal = DispSpec.getImmedValue();
462 if (DispVal || (!IndexReg.getReg() && !BaseReg.getReg()))
463 O << DispVal;
464 }
465
466 if (IndexReg.getReg() || BaseReg.getReg()) {
Chris Lattner32c9a452007-01-14 00:13:07 +0000467 unsigned ScaleVal = MI->getOperand(Op+1).getImmedValue();
468 unsigned BaseRegOperand = 0, IndexRegOperand = 2;
469
470 // There are cases where we can end up with ESP/RSP in the indexreg slot.
471 // If this happens, swap the base/index register to support assemblers that
472 // don't work when the index is *SP.
473 if (IndexReg.getReg() == X86::ESP || IndexReg.getReg() == X86::RSP) {
474 assert(ScaleVal == 1 && "Scale not supported for stack pointer!");
475 std::swap(BaseReg, IndexReg);
476 std::swap(BaseRegOperand, IndexRegOperand);
Evan Cheng25ab6902006-09-08 06:48:29 +0000477 }
Chris Lattner32c9a452007-01-14 00:13:07 +0000478
479 O << "(";
480 if (BaseReg.getReg())
481 printOperand(MI, Op+BaseRegOperand, Modifier);
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000482
483 if (IndexReg.getReg()) {
484 O << ",";
Chris Lattner32c9a452007-01-14 00:13:07 +0000485 printOperand(MI, Op+IndexRegOperand, Modifier);
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000486 if (ScaleVal != 1)
487 O << "," << ScaleVal;
488 }
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000489 O << ")";
490 }
491}
492
Evan Cheng7ccced62006-02-18 00:15:05 +0000493void X86ATTAsmPrinter::printPICLabel(const MachineInstr *MI, unsigned Op) {
Evan Cheng071b9d52007-01-18 01:49:58 +0000494 std::string label = computePICLabel(getFunctionNumber(), TAI, Subtarget);
Anton Korobeynikov7f705592007-01-12 19:20:47 +0000495 O << label << "\n" << label << ":";
Evan Cheng7ccced62006-02-18 00:15:05 +0000496}
497
Evan Cheng62f27002006-04-28 23:11:40 +0000498
Evan Cheng55c25f22006-04-28 23:19:39 +0000499bool X86ATTAsmPrinter::printAsmMRegister(const MachineOperand &MO,
Evan Cheng62f27002006-04-28 23:11:40 +0000500 const char Mode) {
501 const MRegisterInfo &RI = *TM.getRegisterInfo();
502 unsigned Reg = MO.getReg();
Evan Cheng62f27002006-04-28 23:11:40 +0000503 switch (Mode) {
504 default: return true; // Unknown mode.
505 case 'b': // Print QImode register
Evan Cheng8f7f7122006-05-05 05:40:20 +0000506 Reg = getX86SubSuperRegister(Reg, MVT::i8);
Evan Cheng62f27002006-04-28 23:11:40 +0000507 break;
508 case 'h': // Print QImode high register
Evan Cheng8f7f7122006-05-05 05:40:20 +0000509 Reg = getX86SubSuperRegister(Reg, MVT::i8, true);
Evan Cheng62f27002006-04-28 23:11:40 +0000510 break;
511 case 'w': // Print HImode register
Evan Cheng8f7f7122006-05-05 05:40:20 +0000512 Reg = getX86SubSuperRegister(Reg, MVT::i16);
Evan Cheng62f27002006-04-28 23:11:40 +0000513 break;
514 case 'k': // Print SImode register
Evan Cheng8f7f7122006-05-05 05:40:20 +0000515 Reg = getX86SubSuperRegister(Reg, MVT::i32);
Evan Cheng62f27002006-04-28 23:11:40 +0000516 break;
517 }
518
Evan Cheng8f7f7122006-05-05 05:40:20 +0000519 O << '%';
520 for (const char *Name = RI.get(Reg).Name; *Name; ++Name)
521 O << (char)tolower(*Name);
Evan Cheng62f27002006-04-28 23:11:40 +0000522 return false;
523}
524
Evan Cheng3d48a902006-04-28 21:19:05 +0000525/// PrintAsmOperand - Print out an operand for an inline asm expression.
526///
527bool X86ATTAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
528 unsigned AsmVariant,
529 const char *ExtraCode) {
530 // Does this asm operand have a single letter operand modifier?
531 if (ExtraCode && ExtraCode[0]) {
532 if (ExtraCode[1] != 0) return true; // Unknown modifier.
533
534 switch (ExtraCode[0]) {
535 default: return true; // Unknown modifier.
Chris Lattnerb4828722007-01-25 02:53:24 +0000536 case 'c': // Don't print "$" before a global var name or constant.
Chris Lattner0d924992006-10-31 20:12:30 +0000537 printOperand(MI, OpNo, "mem");
538 return false;
Evan Cheng62f27002006-04-28 23:11:40 +0000539 case 'b': // Print QImode register
540 case 'h': // Print QImode high register
541 case 'w': // Print HImode register
542 case 'k': // Print SImode register
Chris Lattner14393522007-03-25 02:01:03 +0000543 if (MI->getOperand(OpNo).isReg())
544 return printAsmMRegister(MI->getOperand(OpNo), ExtraCode[0]);
545 printOperand(MI, OpNo);
546 return false;
Chris Lattner7cd5e072007-03-25 01:44:57 +0000547
548 case 'P': // Don't print @PLT, but do print as memory.
549 printOperand(MI, OpNo, "mem");
550 return false;
Evan Cheng3d48a902006-04-28 21:19:05 +0000551 }
552 }
553
554 printOperand(MI, OpNo);
555 return false;
556}
557
558bool X86ATTAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
559 unsigned OpNo,
560 unsigned AsmVariant,
561 const char *ExtraCode) {
562 if (ExtraCode && ExtraCode[0])
563 return true; // Unknown modifier.
564 printMemReference(MI, OpNo);
565 return false;
566}
567
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000568/// printMachineInstruction -- Print out a single X86 LLVM instruction
569/// MI in Intel syntax to the current output stream.
570///
571void X86ATTAsmPrinter::printMachineInstruction(const MachineInstr *MI) {
572 ++EmittedInsts;
Evan Cheng67caa392006-01-26 02:27:43 +0000573
Evan Cheng8f7f7122006-05-05 05:40:20 +0000574 // See if a truncate instruction can be turned into a nop.
575 switch (MI->getOpcode()) {
576 default: break;
Evan Cheng25ab6902006-09-08 06:48:29 +0000577 case X86::TRUNC_64to32:
578 case X86::TRUNC_64to16:
579 case X86::TRUNC_32to16:
580 case X86::TRUNC_32to8:
581 case X86::TRUNC_16to8:
582 case X86::TRUNC_32_to8:
583 case X86::TRUNC_16_to8: {
Evan Cheng8f7f7122006-05-05 05:40:20 +0000584 const MachineOperand &MO0 = MI->getOperand(0);
585 const MachineOperand &MO1 = MI->getOperand(1);
586 unsigned Reg0 = MO0.getReg();
587 unsigned Reg1 = MO1.getReg();
Evan Cheng25ab6902006-09-08 06:48:29 +0000588 unsigned Opc = MI->getOpcode();
589 if (Opc == X86::TRUNC_64to32)
590 Reg1 = getX86SubSuperRegister(Reg1, MVT::i32);
591 else if (Opc == X86::TRUNC_32to16 || Opc == X86::TRUNC_64to16)
Evan Cheng403be7e2006-05-08 08:01:26 +0000592 Reg1 = getX86SubSuperRegister(Reg1, MVT::i16);
Evan Cheng8f7f7122006-05-05 05:40:20 +0000593 else
Evan Cheng403be7e2006-05-08 08:01:26 +0000594 Reg1 = getX86SubSuperRegister(Reg1, MVT::i8);
Jim Laskey563321a2006-09-06 18:34:40 +0000595 O << TAI->getCommentString() << " TRUNCATE ";
Evan Cheng403be7e2006-05-08 08:01:26 +0000596 if (Reg0 != Reg1)
597 O << "\n\t";
Evan Cheng8f7f7122006-05-05 05:40:20 +0000598 break;
599 }
Evan Cheng25ab6902006-09-08 06:48:29 +0000600 case X86::PsMOVZX64rr32:
601 O << TAI->getCommentString() << " ZERO-EXTEND " << "\n\t";
602 break;
Evan Cheng8f7f7122006-05-05 05:40:20 +0000603 }
604
Chris Lattnerb36cbd02005-07-01 22:44:09 +0000605 // Call the autogenerated instruction printer routines.
606 printInstruction(MI);
607}
608
609// Include the auto-generated portion of the assembly writer.
610#include "X86GenAsmWriter.inc"
611