Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 1 | //===-- X86IntelAsmPrinter.cpp - Convert X86 LLVM code to Intel assembly --===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 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'. |
| 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
Chris Lattner | 95b2c7d | 2006-12-19 22:59:26 +0000 | [diff] [blame] | 16 | #define DEBUG_TYPE "asm-printer" |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 17 | #include "X86IntelAsmPrinter.h" |
Cedric Venet | d85f51a | 2008-08-24 12:30:46 +0000 | [diff] [blame] | 18 | #include "X86InstrInfo.h" |
| 19 | #include "X86TargetAsmInfo.h" |
| 20 | #include "X86.h" |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 21 | #include "llvm/CallingConv.h" |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 22 | #include "llvm/Constants.h" |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 23 | #include "llvm/DerivedTypes.h" |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 24 | #include "llvm/Module.h" |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 25 | #include "llvm/ADT/Statistic.h" |
| 26 | #include "llvm/ADT/StringExtras.h" |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 27 | #include "llvm/Assembly/Writer.h" |
Bill Wendling | cb819f1 | 2009-02-18 23:12:06 +0000 | [diff] [blame] | 28 | #include "llvm/CodeGen/DwarfWriter.h" |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 29 | #include "llvm/Support/Mangler.h" |
Jim Laskey | a0f3d17 | 2006-09-07 22:06:40 +0000 | [diff] [blame] | 30 | #include "llvm/Target/TargetAsmInfo.h" |
Evan Cheng | 7ccced6 | 2006-02-18 00:15:05 +0000 | [diff] [blame] | 31 | #include "llvm/Target/TargetOptions.h" |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 32 | using namespace llvm; |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 33 | |
Chris Lattner | 95b2c7d | 2006-12-19 22:59:26 +0000 | [diff] [blame] | 34 | STATISTIC(EmittedInsts, "Number of machine instrs printed"); |
| 35 | |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 36 | static X86MachineFunctionInfo calculateFunctionInfo(const Function *F, |
| 37 | const TargetData *TD) { |
| 38 | X86MachineFunctionInfo Info; |
| 39 | uint64_t Size = 0; |
| 40 | |
| 41 | switch (F->getCallingConv()) { |
| 42 | case CallingConv::X86_StdCall: |
| 43 | Info.setDecorationStyle(StdCall); |
| 44 | break; |
| 45 | case CallingConv::X86_FastCall: |
| 46 | Info.setDecorationStyle(FastCall); |
| 47 | break; |
| 48 | default: |
| 49 | return Info; |
| 50 | } |
| 51 | |
| 52 | unsigned argNum = 1; |
| 53 | for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end(); |
| 54 | AI != AE; ++AI, ++argNum) { |
| 55 | const Type* Ty = AI->getType(); |
| 56 | |
| 57 | // 'Dereference' type in case of byval parameter attribute |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 58 | if (F->paramHasAttr(argNum, Attribute::ByVal)) |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 59 | Ty = cast<PointerType>(Ty)->getElementType(); |
| 60 | |
| 61 | // Size should be aligned to DWORD boundary |
Duncan Sands | ceb4d1a | 2009-01-12 20:38:59 +0000 | [diff] [blame] | 62 | Size += ((TD->getTypePaddedSize(Ty) + 3)/4)*4; |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 63 | } |
| 64 | |
| 65 | // We're not supporting tooooo huge arguments :) |
| 66 | Info.setBytesToPopOnReturn((unsigned int)Size); |
| 67 | return Info; |
| 68 | } |
| 69 | |
| 70 | |
| 71 | /// decorateName - Query FunctionInfoMap and use this information for various |
| 72 | /// name decoration. |
| 73 | void X86IntelAsmPrinter::decorateName(std::string &Name, |
| 74 | const GlobalValue *GV) { |
| 75 | const Function *F = dyn_cast<Function>(GV); |
| 76 | if (!F) return; |
| 77 | |
| 78 | // We don't want to decorate non-stdcall or non-fastcall functions right now |
| 79 | unsigned CC = F->getCallingConv(); |
| 80 | if (CC != CallingConv::X86_StdCall && CC != CallingConv::X86_FastCall) |
| 81 | return; |
| 82 | |
| 83 | FMFInfoMap::const_iterator info_item = FunctionInfoMap.find(F); |
| 84 | |
| 85 | const X86MachineFunctionInfo *Info; |
| 86 | if (info_item == FunctionInfoMap.end()) { |
| 87 | // Calculate apropriate function info and populate map |
| 88 | FunctionInfoMap[F] = calculateFunctionInfo(F, TM.getTargetData()); |
| 89 | Info = &FunctionInfoMap[F]; |
| 90 | } else { |
| 91 | Info = &info_item->second; |
| 92 | } |
| 93 | |
| 94 | const FunctionType *FT = F->getFunctionType(); |
| 95 | switch (Info->getDecorationStyle()) { |
| 96 | case None: |
| 97 | break; |
| 98 | case StdCall: |
| 99 | // "Pure" variadic functions do not receive @0 suffix. |
| 100 | if (!FT->isVarArg() || (FT->getNumParams() == 0) || |
| 101 | (FT->getNumParams() == 1 && F->hasStructRetAttr())) |
| 102 | Name += '@' + utostr_32(Info->getBytesToPopOnReturn()); |
| 103 | break; |
| 104 | case FastCall: |
| 105 | // "Pure" variadic functions do not receive @0 suffix. |
| 106 | if (!FT->isVarArg() || (FT->getNumParams() == 0) || |
| 107 | (FT->getNumParams() == 1 && F->hasStructRetAttr())) |
| 108 | Name += '@' + utostr_32(Info->getBytesToPopOnReturn()); |
| 109 | |
| 110 | if (Name[0] == '_') |
| 111 | Name[0] = '@'; |
| 112 | else |
| 113 | Name = '@' + Name; |
| 114 | |
| 115 | break; |
| 116 | default: |
| 117 | assert(0 && "Unsupported DecorationStyle"); |
| 118 | } |
| 119 | } |
| 120 | |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 121 | /// runOnMachineFunction - This uses the printMachineInstruction() |
| 122 | /// method to print assembly for each instruction. |
| 123 | /// |
| 124 | bool X86IntelAsmPrinter::runOnMachineFunction(MachineFunction &MF) { |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 125 | this->MF = &MF; |
Chris Lattner | 8b8b951 | 2005-11-21 07:51:23 +0000 | [diff] [blame] | 126 | SetupMachineFunction(MF); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 127 | O << "\n\n"; |
| 128 | |
| 129 | // Print out constants referenced by the function |
Chris Lattner | d939f6c | 2005-11-21 08:32:23 +0000 | [diff] [blame] | 130 | EmitConstantPool(MF.getConstantPool()); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 131 | |
| 132 | // Print out labels for the function. |
Chris Lattner | e87e115 | 2006-09-26 03:57:53 +0000 | [diff] [blame] | 133 | const Function *F = MF.getFunction(); |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 134 | unsigned CC = F->getCallingConv(); |
| 135 | |
| 136 | // Populate function information map. Actually, We don't want to populate |
| 137 | // non-stdcall or non-fastcall functions' information right now. |
Chris Lattner | e87e115 | 2006-09-26 03:57:53 +0000 | [diff] [blame] | 138 | if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall) |
Chris Lattner | d15dff2 | 2007-04-17 17:21:52 +0000 | [diff] [blame] | 139 | FunctionInfoMap[F] = *MF.getInfo<X86MachineFunctionInfo>(); |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 140 | |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 141 | decorateName(CurrentFnName, F); |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 142 | |
Anton Korobeynikov | 0c8e806 | 2008-09-24 22:13:07 +0000 | [diff] [blame] | 143 | SwitchToTextSection("_text", F); |
Chris Lattner | afbfded | 2006-10-05 02:43:52 +0000 | [diff] [blame] | 144 | |
Devang Patel | 4ae641f | 2008-10-01 23:18:38 +0000 | [diff] [blame] | 145 | unsigned FnAlign = 4; |
Devang Patel | e4d4b8c | 2008-10-06 17:30:07 +0000 | [diff] [blame] | 146 | if (F->hasFnAttr(Attribute::OptimizeForSize)) |
Devang Patel | db10033 | 2008-09-04 21:03:41 +0000 | [diff] [blame] | 147 | FnAlign = 1; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 148 | switch (F->getLinkage()) { |
| 149 | default: assert(0 && "Unsupported linkage type!"); |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 150 | case Function::PrivateLinkage: |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 151 | case Function::InternalLinkage: |
Evan Cheng | e22e62b | 2008-03-25 22:29:46 +0000 | [diff] [blame] | 152 | EmitAlignment(FnAlign); |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 153 | break; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 154 | case Function::DLLExportLinkage: |
| 155 | DLLExportedFns.insert(CurrentFnName); |
| 156 | //FALLS THROUGH |
| 157 | case Function::ExternalLinkage: |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 158 | O << "\tpublic " << CurrentFnName << "\n"; |
Evan Cheng | e22e62b | 2008-03-25 22:29:46 +0000 | [diff] [blame] | 159 | EmitAlignment(FnAlign); |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 160 | break; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 161 | } |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 162 | |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 163 | O << CurrentFnName << "\tproc near\n"; |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 164 | |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 165 | // Print out code for the function. |
| 166 | for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); |
| 167 | I != E; ++I) { |
| 168 | // Print a label for the basic block if there are any predecessors. |
Dan Gohman | cb406c2 | 2007-10-03 19:26:29 +0000 | [diff] [blame] | 169 | if (!I->pred_empty()) { |
Evan Cheng | fb8075d | 2008-02-28 00:43:03 +0000 | [diff] [blame] | 170 | printBasicBlockLabel(I, true, true); |
Nate Begeman | cdf38c4 | 2006-05-02 05:37:32 +0000 | [diff] [blame] | 171 | O << '\n'; |
| 172 | } |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 173 | for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); |
| 174 | II != E; ++II) { |
| 175 | // Print the assembly for the instruction. |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 176 | printMachineInstruction(II); |
| 177 | } |
| 178 | } |
| 179 | |
Chris Lattner | 1da31ee | 2006-10-05 03:01:21 +0000 | [diff] [blame] | 180 | // Print out jump tables referenced by the function. |
| 181 | EmitJumpTableInfo(MF.getJumpTableInfo(), MF); |
| 182 | |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 183 | O << CurrentFnName << "\tendp\n"; |
| 184 | |
Dan Gohman | e5f4de4 | 2008-11-07 19:49:17 +0000 | [diff] [blame] | 185 | O.flush(); |
| 186 | |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 187 | // We didn't modify anything. |
| 188 | return false; |
| 189 | } |
| 190 | |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 191 | void X86IntelAsmPrinter::printSSECC(const MachineInstr *MI, unsigned Op) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 192 | unsigned char value = MI->getOperand(Op).getImm(); |
Nate Begeman | 6c7cb29 | 2005-07-14 22:52:25 +0000 | [diff] [blame] | 193 | assert(value <= 7 && "Invalid ssecc argument!"); |
| 194 | switch (value) { |
| 195 | case 0: O << "eq"; break; |
| 196 | case 1: O << "lt"; break; |
| 197 | case 2: O << "le"; break; |
| 198 | case 3: O << "unord"; break; |
| 199 | case 4: O << "neq"; break; |
| 200 | case 5: O << "nlt"; break; |
| 201 | case 6: O << "nle"; break; |
| 202 | case 7: O << "ord"; break; |
| 203 | } |
| 204 | } |
| 205 | |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 206 | void X86IntelAsmPrinter::printOp(const MachineOperand &MO, |
Chris Lattner | a3b8c57 | 2006-02-06 23:41:19 +0000 | [diff] [blame] | 207 | const char *Modifier) { |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 208 | switch (MO.getType()) { |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 209 | case MachineOperand::MO_Register: { |
Dan Gohman | 6f0d024 | 2008-02-10 18:45:23 +0000 | [diff] [blame] | 210 | if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) { |
Evan Cheng | 8f7f712 | 2006-05-05 05:40:20 +0000 | [diff] [blame] | 211 | unsigned Reg = MO.getReg(); |
Evan Cheng | cbe70e1 | 2006-05-31 22:34:26 +0000 | [diff] [blame] | 212 | if (Modifier && strncmp(Modifier, "subreg", strlen("subreg")) == 0) { |
Duncan Sands | 83ec4b6 | 2008-06-06 12:08:01 +0000 | [diff] [blame] | 213 | MVT VT = (strcmp(Modifier,"subreg64") == 0) ? |
Evan Cheng | 25ab690 | 2006-09-08 06:48:29 +0000 | [diff] [blame] | 214 | MVT::i64 : ((strcmp(Modifier, "subreg32") == 0) ? MVT::i32 : |
| 215 | ((strcmp(Modifier,"subreg16") == 0) ? MVT::i16 :MVT::i8)); |
Evan Cheng | 8f7f712 | 2006-05-05 05:40:20 +0000 | [diff] [blame] | 216 | Reg = getX86SubSuperRegister(Reg, VT); |
| 217 | } |
Evan Cheng | ae270f6 | 2008-07-07 22:21:06 +0000 | [diff] [blame] | 218 | O << TRI->getName(Reg); |
Evan Cheng | 8f7f712 | 2006-05-05 05:40:20 +0000 | [diff] [blame] | 219 | } else |
Chris Lattner | 99f2632 | 2006-05-01 05:53:50 +0000 | [diff] [blame] | 220 | O << "reg" << MO.getReg(); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 221 | return; |
Anton Korobeynikov | 24287dd | 2006-12-19 21:04:20 +0000 | [diff] [blame] | 222 | } |
Chris Lattner | 63b3d71 | 2006-05-04 17:21:20 +0000 | [diff] [blame] | 223 | case MachineOperand::MO_Immediate: |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 224 | O << MO.getImm(); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 225 | return; |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 226 | case MachineOperand::MO_MachineBasicBlock: |
Chris Lattner | 8aa797a | 2007-12-30 23:10:15 +0000 | [diff] [blame] | 227 | printBasicBlockLabel(MO.getMBB()); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 228 | return; |
Anton Korobeynikov | 24287dd | 2006-12-19 21:04:20 +0000 | [diff] [blame] | 229 | case MachineOperand::MO_JumpTableIndex: { |
| 230 | bool isMemOp = Modifier && !strcmp(Modifier, "mem"); |
| 231 | if (!isMemOp) O << "OFFSET "; |
Evan Cheng | 347d39f | 2007-10-14 05:57:21 +0000 | [diff] [blame] | 232 | O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() |
Chris Lattner | 8aa797a | 2007-12-30 23:10:15 +0000 | [diff] [blame] | 233 | << "_" << MO.getIndex(); |
Anton Korobeynikov | 24287dd | 2006-12-19 21:04:20 +0000 | [diff] [blame] | 234 | return; |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 235 | } |
Evan Cheng | a09bd81 | 2006-02-26 08:28:12 +0000 | [diff] [blame] | 236 | case MachineOperand::MO_ConstantPoolIndex: { |
| 237 | bool isMemOp = Modifier && !strcmp(Modifier, "mem"); |
| 238 | if (!isMemOp) O << "OFFSET "; |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 239 | O << "[" << TAI->getPrivateGlobalPrefix() << "CPI" |
Chris Lattner | 8aa797a | 2007-12-30 23:10:15 +0000 | [diff] [blame] | 240 | << getFunctionNumber() << "_" << MO.getIndex(); |
Anton Korobeynikov | 7751ad9 | 2008-11-22 16:15:34 +0000 | [diff] [blame] | 241 | printOffset(MO.getOffset()); |
Evan Cheng | a09bd81 | 2006-02-26 08:28:12 +0000 | [diff] [blame] | 242 | O << "]"; |
| 243 | return; |
| 244 | } |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 245 | case MachineOperand::MO_GlobalAddress: { |
Evan Cheng | 7ccced6 | 2006-02-18 00:15:05 +0000 | [diff] [blame] | 246 | bool isCallOp = Modifier && !strcmp(Modifier, "call"); |
| 247 | bool isMemOp = Modifier && !strcmp(Modifier, "mem"); |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 248 | GlobalValue *GV = MO.getGlobal(); |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 249 | std::string Name = Mang->getValueName(GV); |
| 250 | |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 251 | decorateName(Name, GV); |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 252 | |
Evan Cheng | 7ccced6 | 2006-02-18 00:15:05 +0000 | [diff] [blame] | 253 | if (!isMemOp && !isCallOp) O << "OFFSET "; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 254 | if (GV->hasDLLImportLinkage()) { |
| 255 | // FIXME: This should be fixed with full support of stdcall & fastcall |
| 256 | // CC's |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 257 | O << "__imp_"; |
| 258 | } |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 259 | O << Name; |
Anton Korobeynikov | 7751ad9 | 2008-11-22 16:15:34 +0000 | [diff] [blame] | 260 | printOffset(MO.getOffset()); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 261 | return; |
| 262 | } |
Evan Cheng | 7ccced6 | 2006-02-18 00:15:05 +0000 | [diff] [blame] | 263 | case MachineOperand::MO_ExternalSymbol: { |
| 264 | bool isCallOp = Modifier && !strcmp(Modifier, "call"); |
Evan Cheng | 4c1aa86 | 2006-02-22 20:19:42 +0000 | [diff] [blame] | 265 | if (!isCallOp) O << "OFFSET "; |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 266 | O << TAI->getGlobalPrefix() << MO.getSymbolName(); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 267 | return; |
Evan Cheng | 7ccced6 | 2006-02-18 00:15:05 +0000 | [diff] [blame] | 268 | } |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 269 | default: |
| 270 | O << "<unknown operand type>"; return; |
| 271 | } |
| 272 | } |
| 273 | |
Evan Cheng | 25ab690 | 2006-09-08 06:48:29 +0000 | [diff] [blame] | 274 | void X86IntelAsmPrinter::printMemReference(const MachineInstr *MI, unsigned Op, |
| 275 | const char *Modifier) { |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 276 | assert(isMem(MI, Op) && "Invalid memory reference!"); |
| 277 | |
| 278 | const MachineOperand &BaseReg = MI->getOperand(Op); |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 279 | int ScaleVal = MI->getOperand(Op+1).getImm(); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 280 | const MachineOperand &IndexReg = MI->getOperand(Op+2); |
| 281 | const MachineOperand &DispSpec = MI->getOperand(Op+3); |
| 282 | |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 283 | O << "["; |
| 284 | bool NeedPlus = false; |
| 285 | if (BaseReg.getReg()) { |
Evan Cheng | 25ab690 | 2006-09-08 06:48:29 +0000 | [diff] [blame] | 286 | printOp(BaseReg, Modifier); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 287 | NeedPlus = true; |
| 288 | } |
| 289 | |
| 290 | if (IndexReg.getReg()) { |
| 291 | if (NeedPlus) O << " + "; |
| 292 | if (ScaleVal != 1) |
| 293 | O << ScaleVal << "*"; |
Evan Cheng | 25ab690 | 2006-09-08 06:48:29 +0000 | [diff] [blame] | 294 | printOp(IndexReg, Modifier); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 295 | NeedPlus = true; |
| 296 | } |
| 297 | |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 298 | if (DispSpec.isGlobal() || DispSpec.isCPI() || |
| 299 | DispSpec.isJTI()) { |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 300 | if (NeedPlus) |
| 301 | O << " + "; |
Evan Cheng | 2338c5c | 2006-02-07 08:38:37 +0000 | [diff] [blame] | 302 | printOp(DispSpec, "mem"); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 303 | } else { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 304 | int DispVal = DispSpec.getImm(); |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 305 | if (DispVal || (!BaseReg.getReg() && !IndexReg.getReg())) { |
Anton Korobeynikov | 7c1c261 | 2008-02-20 11:22:39 +0000 | [diff] [blame] | 306 | if (NeedPlus) { |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 307 | if (DispVal > 0) |
| 308 | O << " + "; |
| 309 | else { |
| 310 | O << " - "; |
| 311 | DispVal = -DispVal; |
| 312 | } |
Anton Korobeynikov | 7c1c261 | 2008-02-20 11:22:39 +0000 | [diff] [blame] | 313 | } |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 314 | O << DispVal; |
| 315 | } |
| 316 | } |
| 317 | O << "]"; |
| 318 | } |
| 319 | |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 320 | void X86IntelAsmPrinter::printPICJumpTableSetLabel(unsigned uid, |
Evan Cheng | cc41586 | 2007-11-09 01:32:10 +0000 | [diff] [blame] | 321 | const MachineBasicBlock *MBB) const { |
| 322 | if (!TAI->getSetDirective()) |
| 323 | return; |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 324 | |
Evan Cheng | cc41586 | 2007-11-09 01:32:10 +0000 | [diff] [blame] | 325 | O << TAI->getSetDirective() << ' ' << TAI->getPrivateGlobalPrefix() |
| 326 | << getFunctionNumber() << '_' << uid << "_set_" << MBB->getNumber() << ','; |
Evan Cheng | fb8075d | 2008-02-28 00:43:03 +0000 | [diff] [blame] | 327 | printBasicBlockLabel(MBB, false, false, false); |
Evan Cheng | cc41586 | 2007-11-09 01:32:10 +0000 | [diff] [blame] | 328 | O << '-' << "\"L" << getFunctionNumber() << "$pb\"'\n"; |
| 329 | } |
| 330 | |
Evan Cheng | 7ccced6 | 2006-02-18 00:15:05 +0000 | [diff] [blame] | 331 | void X86IntelAsmPrinter::printPICLabel(const MachineInstr *MI, unsigned Op) { |
Evan Cheng | 347d39f | 2007-10-14 05:57:21 +0000 | [diff] [blame] | 332 | O << "\"L" << getFunctionNumber() << "$pb\"\n"; |
| 333 | O << "\"L" << getFunctionNumber() << "$pb\":"; |
Evan Cheng | 7ccced6 | 2006-02-18 00:15:05 +0000 | [diff] [blame] | 334 | } |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 335 | |
Evan Cheng | 55c25f2 | 2006-04-28 23:19:39 +0000 | [diff] [blame] | 336 | bool X86IntelAsmPrinter::printAsmMRegister(const MachineOperand &MO, |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 337 | const char Mode) { |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 338 | unsigned Reg = MO.getReg(); |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 339 | switch (Mode) { |
| 340 | default: return true; // Unknown mode. |
| 341 | case 'b': // Print QImode register |
Evan Cheng | 8f7f712 | 2006-05-05 05:40:20 +0000 | [diff] [blame] | 342 | Reg = getX86SubSuperRegister(Reg, MVT::i8); |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 343 | break; |
| 344 | case 'h': // Print QImode high register |
Evan Cheng | 8f7f712 | 2006-05-05 05:40:20 +0000 | [diff] [blame] | 345 | Reg = getX86SubSuperRegister(Reg, MVT::i8, true); |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 346 | break; |
| 347 | case 'w': // Print HImode register |
Evan Cheng | 8f7f712 | 2006-05-05 05:40:20 +0000 | [diff] [blame] | 348 | Reg = getX86SubSuperRegister(Reg, MVT::i16); |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 349 | break; |
| 350 | case 'k': // Print SImode register |
Evan Cheng | 8f7f712 | 2006-05-05 05:40:20 +0000 | [diff] [blame] | 351 | Reg = getX86SubSuperRegister(Reg, MVT::i32); |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 352 | break; |
| 353 | } |
| 354 | |
Evan Cheng | ae270f6 | 2008-07-07 22:21:06 +0000 | [diff] [blame] | 355 | O << '%' << TRI->getName(Reg); |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 356 | return false; |
| 357 | } |
| 358 | |
Evan Cheng | 3d48a90 | 2006-04-28 21:19:05 +0000 | [diff] [blame] | 359 | /// PrintAsmOperand - Print out an operand for an inline asm expression. |
| 360 | /// |
| 361 | bool X86IntelAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 362 | unsigned AsmVariant, |
Evan Cheng | 3d48a90 | 2006-04-28 21:19:05 +0000 | [diff] [blame] | 363 | const char *ExtraCode) { |
| 364 | // Does this asm operand have a single letter operand modifier? |
| 365 | if (ExtraCode && ExtraCode[0]) { |
| 366 | if (ExtraCode[1] != 0) return true; // Unknown modifier. |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 367 | |
Evan Cheng | 3d48a90 | 2006-04-28 21:19:05 +0000 | [diff] [blame] | 368 | switch (ExtraCode[0]) { |
| 369 | default: return true; // Unknown modifier. |
Evan Cheng | 62f2700 | 2006-04-28 23:11:40 +0000 | [diff] [blame] | 370 | case 'b': // Print QImode register |
| 371 | case 'h': // Print QImode high register |
| 372 | case 'w': // Print HImode register |
| 373 | case 'k': // Print SImode register |
Evan Cheng | 55c25f2 | 2006-04-28 23:19:39 +0000 | [diff] [blame] | 374 | return printAsmMRegister(MI->getOperand(OpNo), ExtraCode[0]); |
Evan Cheng | 3d48a90 | 2006-04-28 21:19:05 +0000 | [diff] [blame] | 375 | } |
| 376 | } |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 377 | |
Evan Cheng | 3d48a90 | 2006-04-28 21:19:05 +0000 | [diff] [blame] | 378 | printOperand(MI, OpNo); |
| 379 | return false; |
| 380 | } |
| 381 | |
| 382 | bool X86IntelAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, |
| 383 | unsigned OpNo, |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 384 | unsigned AsmVariant, |
Evan Cheng | 3d48a90 | 2006-04-28 21:19:05 +0000 | [diff] [blame] | 385 | const char *ExtraCode) { |
| 386 | if (ExtraCode && ExtraCode[0]) |
| 387 | return true; // Unknown modifier. |
| 388 | printMemReference(MI, OpNo); |
| 389 | return false; |
| 390 | } |
| 391 | |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 392 | /// printMachineInstruction -- Print out a single X86 LLVM instruction |
| 393 | /// MI in Intel syntax to the current output stream. |
| 394 | /// |
| 395 | void X86IntelAsmPrinter::printMachineInstruction(const MachineInstr *MI) { |
| 396 | ++EmittedInsts; |
| 397 | |
| 398 | // Call the autogenerated instruction printer routines. |
| 399 | printInstruction(MI); |
| 400 | } |
| 401 | |
| 402 | bool X86IntelAsmPrinter::doInitialization(Module &M) { |
Anton Korobeynikov | 271329a | 2008-06-28 11:07:35 +0000 | [diff] [blame] | 403 | bool Result = AsmPrinter::doInitialization(M); |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 404 | |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 405 | Mang->markCharUnacceptable('.'); |
Jeff Cohen | 10efcfa | 2006-05-04 16:20:22 +0000 | [diff] [blame] | 406 | |
Jeff Cohen | 4f1ea1e | 2006-05-02 03:11:50 +0000 | [diff] [blame] | 407 | O << "\t.686\n\t.model flat\n\n"; |
| 408 | |
| 409 | // Emit declarations for external functions. |
| 410 | for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 411 | if (I->isDeclaration()) { |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 412 | std::string Name = Mang->getValueName(I); |
Anton Korobeynikov | 1c4b5ea | 2008-06-28 11:07:54 +0000 | [diff] [blame] | 413 | decorateName(Name, I); |
Jeff Cohen | 4f1ea1e | 2006-05-02 03:11:50 +0000 | [diff] [blame] | 414 | |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 415 | O << "\textern " ; |
| 416 | if (I->hasDLLImportLinkage()) { |
| 417 | O << "__imp_"; |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 418 | } |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 419 | O << Name << ":near\n"; |
| 420 | } |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 421 | |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 422 | // Emit declarations for external globals. Note that VC++ always declares |
| 423 | // external globals to have type byte, and if that's good enough for VC++... |
Jeff Cohen | 4f1ea1e | 2006-05-02 03:11:50 +0000 | [diff] [blame] | 424 | for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); |
| 425 | I != E; ++I) { |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 426 | if (I->isDeclaration()) { |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 427 | std::string Name = Mang->getValueName(I); |
| 428 | |
| 429 | O << "\textern " ; |
| 430 | if (I->hasDLLImportLinkage()) { |
| 431 | O << "__imp_"; |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 432 | } |
Anton Korobeynikov | f824868 | 2006-09-20 22:03:51 +0000 | [diff] [blame] | 433 | O << Name << ":byte\n"; |
| 434 | } |
Jeff Cohen | 4f1ea1e | 2006-05-02 03:11:50 +0000 | [diff] [blame] | 435 | } |
| 436 | |
Dan Gohman | b8275a3 | 2007-07-25 19:33:14 +0000 | [diff] [blame] | 437 | return Result; |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 438 | } |
| 439 | |
Jeff Cohen | 4f1ea1e | 2006-05-02 03:11:50 +0000 | [diff] [blame] | 440 | bool X86IntelAsmPrinter::doFinalization(Module &M) { |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 441 | const TargetData *TD = TM.getTargetData(); |
| 442 | |
| 443 | // Print out module-level global variables here. |
| 444 | for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); |
| 445 | I != E; ++I) { |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 446 | if (I->isDeclaration()) continue; // External global require no code |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 447 | |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 448 | // Check to see if this is a special global used by LLVM, if so, emit it. |
| 449 | if (EmitSpecialLLVMGlobal(I)) |
| 450 | continue; |
Anton Korobeynikov | b131b44 | 2008-06-28 11:07:18 +0000 | [diff] [blame] | 451 | |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 452 | std::string name = Mang->getValueName(I); |
| 453 | Constant *C = I->getInitializer(); |
Devang Patel | f9c197e | 2006-10-24 20:32:14 +0000 | [diff] [blame] | 454 | unsigned Align = TD->getPreferredAlignmentLog(I); |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 455 | bool bCustomSegment = false; |
| 456 | |
| 457 | switch (I->getLinkage()) { |
Duncan Sands | 4dc2b39 | 2009-03-11 20:14:15 +0000 | [diff] [blame] | 458 | case GlobalValue::CommonLinkage: |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 459 | case GlobalValue::LinkOnceAnyLinkage: |
| 460 | case GlobalValue::LinkOnceODRLinkage: |
| 461 | case GlobalValue::WeakAnyLinkage: |
| 462 | case GlobalValue::WeakODRLinkage: |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 463 | SwitchToDataSection(""); |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 464 | O << name << "?\tsegment common 'COMMON'\n"; |
| 465 | bCustomSegment = true; |
| 466 | // FIXME: the default alignment is 16 bytes, but 1, 2, 4, and 256 |
| 467 | // are also available. |
| 468 | break; |
| 469 | case GlobalValue::AppendingLinkage: |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 470 | SwitchToDataSection(""); |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 471 | O << name << "?\tsegment public 'DATA'\n"; |
| 472 | bCustomSegment = true; |
| 473 | // FIXME: the default alignment is 16 bytes, but 1, 2, 4, and 256 |
| 474 | // are also available. |
| 475 | break; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 476 | case GlobalValue::DLLExportLinkage: |
| 477 | DLLExportedGVs.insert(name); |
| 478 | // FALL THROUGH |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 479 | case GlobalValue::ExternalLinkage: |
| 480 | O << "\tpublic " << name << "\n"; |
| 481 | // FALL THROUGH |
| 482 | case GlobalValue::InternalLinkage: |
Anton Korobeynikov | 315690e | 2008-09-24 22:16:16 +0000 | [diff] [blame] | 483 | SwitchToSection(TAI->getDataSection()); |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 484 | break; |
| 485 | default: |
| 486 | assert(0 && "Unknown linkage type!"); |
| 487 | } |
| 488 | |
| 489 | if (!bCustomSegment) |
| 490 | EmitAlignment(Align, I); |
| 491 | |
Evan Cheng | f1c0ae9 | 2009-03-24 00:17:40 +0000 | [diff] [blame] | 492 | O << name << ":"; |
| 493 | if (VerboseAsm) |
Evan Cheng | 7db860d | 2009-03-25 01:08:42 +0000 | [diff] [blame^] | 494 | O << "\t\t\t\t" << TAI->getCommentString() |
Evan Cheng | f1c0ae9 | 2009-03-24 00:17:40 +0000 | [diff] [blame] | 495 | << " " << I->getName(); |
| 496 | O << '\n'; |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 497 | |
| 498 | EmitGlobalConstant(C); |
| 499 | |
| 500 | if (bCustomSegment) |
| 501 | O << name << "?\tends\n"; |
| 502 | } |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 503 | |
| 504 | // Output linker support code for dllexported globals |
Anton Korobeynikov | 271329a | 2008-06-28 11:07:35 +0000 | [diff] [blame] | 505 | if (!DLLExportedGVs.empty() || !DLLExportedFns.empty()) { |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 506 | SwitchToDataSection(""); |
Evan Cheng | 0333920 | 2008-09-20 00:13:08 +0000 | [diff] [blame] | 507 | O << "; WARNING: The following code is valid only with MASM v8.x" |
| 508 | << "and (possible) higher\n" |
| 509 | << "; This version of MASM is usually shipped with Microsoft " |
| 510 | << "Visual Studio 2005\n" |
| 511 | << "; or (possible) further versions. Unfortunately, there is no " |
| 512 | << "way to support\n" |
| 513 | << "; dllexported symbols in the earlier versions of MASM in fully " |
| 514 | << "automatic way\n\n"; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 515 | O << "_drectve\t segment info alias('.drectve')\n"; |
| 516 | } |
| 517 | |
Anton Korobeynikov | 8573986 | 2008-06-27 21:22:49 +0000 | [diff] [blame] | 518 | for (StringSet<>::iterator i = DLLExportedGVs.begin(), |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 519 | e = DLLExportedGVs.end(); |
Anton Korobeynikov | 271329a | 2008-06-28 11:07:35 +0000 | [diff] [blame] | 520 | i != e; ++i) |
Anton Korobeynikov | 8573986 | 2008-06-27 21:22:49 +0000 | [diff] [blame] | 521 | O << "\t db ' /EXPORT:" << i->getKeyData() << ",data'\n"; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 522 | |
Anton Korobeynikov | 8573986 | 2008-06-27 21:22:49 +0000 | [diff] [blame] | 523 | for (StringSet<>::iterator i = DLLExportedFns.begin(), |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 524 | e = DLLExportedFns.end(); |
Anton Korobeynikov | 271329a | 2008-06-28 11:07:35 +0000 | [diff] [blame] | 525 | i != e; ++i) |
Anton Korobeynikov | 8573986 | 2008-06-27 21:22:49 +0000 | [diff] [blame] | 526 | O << "\t db ' /EXPORT:" << i->getKeyData() << "'\n"; |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 527 | |
Anton Korobeynikov | 271329a | 2008-06-28 11:07:35 +0000 | [diff] [blame] | 528 | if (!DLLExportedGVs.empty() || !DLLExportedFns.empty()) |
Anton Korobeynikov | 8573986 | 2008-06-27 21:22:49 +0000 | [diff] [blame] | 529 | O << "_drectve\t ends\n"; |
Anton Korobeynikov | 8573986 | 2008-06-27 21:22:49 +0000 | [diff] [blame] | 530 | |
Jeff Cohen | d43b18d | 2006-05-06 21:27:14 +0000 | [diff] [blame] | 531 | // Bypass X86SharedAsmPrinter::doFinalization(). |
Dan Gohman | b8275a3 | 2007-07-25 19:33:14 +0000 | [diff] [blame] | 532 | bool Result = AsmPrinter::doFinalization(M); |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 533 | SwitchToDataSection(""); |
Jeff Cohen | 4f1ea1e | 2006-05-02 03:11:50 +0000 | [diff] [blame] | 534 | O << "\tend\n"; |
Dan Gohman | b8275a3 | 2007-07-25 19:33:14 +0000 | [diff] [blame] | 535 | return Result; |
Jeff Cohen | 4f1ea1e | 2006-05-02 03:11:50 +0000 | [diff] [blame] | 536 | } |
| 537 | |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 538 | void X86IntelAsmPrinter::EmitString(const ConstantArray *CVA) const { |
| 539 | unsigned NumElts = CVA->getNumOperands(); |
| 540 | if (NumElts) { |
| 541 | // ML does not have escape sequences except '' for '. It also has a maximum |
| 542 | // string length of 255. |
| 543 | unsigned len = 0; |
| 544 | bool inString = false; |
| 545 | for (unsigned i = 0; i < NumElts; i++) { |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 546 | int n = cast<ConstantInt>(CVA->getOperand(i))->getZExtValue() & 255; |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 547 | if (len == 0) |
| 548 | O << "\tdb "; |
| 549 | |
| 550 | if (n >= 32 && n <= 127) { |
| 551 | if (!inString) { |
| 552 | if (len > 0) { |
| 553 | O << ",'"; |
| 554 | len += 2; |
| 555 | } else { |
| 556 | O << "'"; |
| 557 | len++; |
| 558 | } |
| 559 | inString = true; |
| 560 | } |
| 561 | if (n == '\'') { |
| 562 | O << "'"; |
| 563 | len++; |
| 564 | } |
| 565 | O << char(n); |
| 566 | } else { |
| 567 | if (inString) { |
| 568 | O << "'"; |
| 569 | len++; |
| 570 | inString = false; |
| 571 | } |
| 572 | if (len > 0) { |
| 573 | O << ","; |
| 574 | len++; |
| 575 | } |
| 576 | O << n; |
| 577 | len += 1 + (n > 9) + (n > 99); |
| 578 | } |
| 579 | |
| 580 | if (len > 60) { |
| 581 | if (inString) { |
| 582 | O << "'"; |
| 583 | inString = false; |
| 584 | } |
| 585 | O << "\n"; |
| 586 | len = 0; |
| 587 | } |
| 588 | } |
| 589 | |
| 590 | if (len > 0) { |
| 591 | if (inString) |
| 592 | O << "'"; |
| 593 | O << "\n"; |
| 594 | } |
| 595 | } |
| 596 | } |
| 597 | |
Chris Lattner | b36cbd0 | 2005-07-01 22:44:09 +0000 | [diff] [blame] | 598 | // Include the auto-generated portion of the assembly writer. |
| 599 | #include "X86GenAsmWriter1.inc" |