Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 1 | //===-- ARMAsmPrinter.cpp - Print machine code to an ARM .s file ----------===// |
| 2 | // |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 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 |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 6 | // 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 GAS-format ARM assembly language. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
Chris Lattner | 95b2c7d | 2006-12-19 22:59:26 +0000 | [diff] [blame] | 15 | #define DEBUG_TYPE "asm-printer" |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 16 | #include "ARM.h" |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 17 | #include "ARMBuildAttrs.h" |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 18 | #include "ARMAddressingModes.h" |
| 19 | #include "ARMConstantPoolValue.h" |
Chris Lattner | f447a5f | 2010-07-19 23:44:46 +0000 | [diff] [blame] | 20 | #include "AsmPrinter/ARMInstPrinter.h" |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 21 | #include "ARMMachineFunctionInfo.h" |
| 22 | #include "ARMMCInstLower.h" |
| 23 | #include "ARMTargetMachine.h" |
Dale Johannesen | 3f282aa | 2010-04-26 20:07:31 +0000 | [diff] [blame] | 24 | #include "llvm/Analysis/DebugInfo.h" |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 25 | #include "llvm/Constants.h" |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 26 | #include "llvm/Module.h" |
Benjamin Kramer | e55b15f | 2009-12-28 12:27:56 +0000 | [diff] [blame] | 27 | #include "llvm/Type.h" |
Dan Gohman | cf20ac4 | 2009-08-13 01:36:44 +0000 | [diff] [blame] | 28 | #include "llvm/Assembly/Writer.h" |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 29 | #include "llvm/CodeGen/AsmPrinter.h" |
Chris Lattner | b0f294c | 2009-10-19 18:38:33 +0000 | [diff] [blame] | 30 | #include "llvm/CodeGen/MachineModuleInfoImpls.h" |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 31 | #include "llvm/CodeGen/MachineFunctionPass.h" |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 32 | #include "llvm/CodeGen/MachineJumpTableInfo.h" |
Anton Korobeynikov | 362dd0b | 2010-02-15 22:37:53 +0000 | [diff] [blame] | 33 | #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" |
Chris Lattner | b0f294c | 2009-10-19 18:38:33 +0000 | [diff] [blame] | 34 | #include "llvm/MC/MCAsmInfo.h" |
| 35 | #include "llvm/MC/MCContext.h" |
Bill Wendling | becd83e | 2010-03-09 00:40:17 +0000 | [diff] [blame] | 36 | #include "llvm/MC/MCExpr.h" |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 37 | #include "llvm/MC/MCInst.h" |
Chris Lattner | f9bdedd | 2009-08-10 18:15:01 +0000 | [diff] [blame] | 38 | #include "llvm/MC/MCSectionMachO.h" |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 39 | #include "llvm/MC/MCStreamer.h" |
Chris Lattner | 325d3dc | 2009-09-13 17:14:04 +0000 | [diff] [blame] | 40 | #include "llvm/MC/MCSymbol.h" |
Chris Lattner | d62f1b4 | 2010-03-12 21:19:23 +0000 | [diff] [blame] | 41 | #include "llvm/Target/Mangler.h" |
Rafael Espindola | b01c4bb | 2006-07-27 11:38:51 +0000 | [diff] [blame] | 42 | #include "llvm/Target/TargetData.h" |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 43 | #include "llvm/Target/TargetMachine.h" |
Evan Cheng | 5be54b0 | 2007-01-19 19:25:36 +0000 | [diff] [blame] | 44 | #include "llvm/Target/TargetOptions.h" |
Daniel Dunbar | 51b198a | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 45 | #include "llvm/Target/TargetRegistry.h" |
Evan Cheng | c324ecb | 2009-07-24 18:19:46 +0000 | [diff] [blame] | 46 | #include "llvm/ADT/SmallPtrSet.h" |
Jim Grosbach | c40d9f9 | 2009-09-01 18:49:12 +0000 | [diff] [blame] | 47 | #include "llvm/ADT/SmallString.h" |
Bob Wilson | 54c78ef | 2009-11-06 23:33:28 +0000 | [diff] [blame] | 48 | #include "llvm/ADT/StringExtras.h" |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 49 | #include "llvm/Support/CommandLine.h" |
Devang Patel | 59135f4 | 2010-08-04 22:39:39 +0000 | [diff] [blame] | 50 | #include "llvm/Support/Debug.h" |
Torok Edwin | 3046470 | 2009-07-08 20:55:50 +0000 | [diff] [blame] | 51 | #include "llvm/Support/ErrorHandling.h" |
Chris Lattner | b23569a | 2010-04-04 08:18:47 +0000 | [diff] [blame] | 52 | #include "llvm/Support/raw_ostream.h" |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 53 | #include <cctype> |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 54 | using namespace llvm; |
| 55 | |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 56 | static cl::opt<bool> |
| 57 | EnableMCInst("enable-arm-mcinst-printer", cl::Hidden, |
| 58 | cl::desc("enable experimental asmprinter gunk in the arm backend")); |
| 59 | |
Jim Grosbach | 9172900 | 2010-07-21 23:03:52 +0000 | [diff] [blame] | 60 | namespace llvm { |
| 61 | namespace ARM { |
| 62 | enum DW_ISA { |
| 63 | DW_ISA_ARM_thumb = 1, |
| 64 | DW_ISA_ARM_arm = 2 |
| 65 | }; |
| 66 | } |
| 67 | } |
| 68 | |
Chris Lattner | 95b2c7d | 2006-12-19 22:59:26 +0000 | [diff] [blame] | 69 | namespace { |
Chris Lattner | 4a071d6 | 2009-10-19 17:59:19 +0000 | [diff] [blame] | 70 | class ARMAsmPrinter : public AsmPrinter { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 71 | |
| 72 | /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can |
| 73 | /// make the right decision when printing asm code for different targets. |
| 74 | const ARMSubtarget *Subtarget; |
| 75 | |
| 76 | /// AFI - Keep a pointer to ARMFunctionInfo for the current |
Evan Cheng | 6d63a72 | 2008-09-18 07:27:23 +0000 | [diff] [blame] | 77 | /// MachineFunction. |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 78 | ARMFunctionInfo *AFI; |
| 79 | |
Evan Cheng | 6d63a72 | 2008-09-18 07:27:23 +0000 | [diff] [blame] | 80 | /// MCP - Keep a pointer to constantpool entries of the current |
| 81 | /// MachineFunction. |
| 82 | const MachineConstantPool *MCP; |
| 83 | |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 84 | public: |
Chris Lattner | b23569a | 2010-04-04 08:18:47 +0000 | [diff] [blame] | 85 | explicit ARMAsmPrinter(TargetMachine &TM, MCStreamer &Streamer) |
| 86 | : AsmPrinter(TM, Streamer), AFI(NULL), MCP(NULL) { |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 87 | Subtarget = &TM.getSubtarget<ARMSubtarget>(); |
| 88 | } |
| 89 | |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 90 | virtual const char *getPassName() const { |
| 91 | return "ARM Assembly Printer"; |
| 92 | } |
Chris Lattner | 6a71afa | 2009-10-19 19:59:05 +0000 | [diff] [blame] | 93 | |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 94 | void printInstructionThroughMCStreamer(const MachineInstr *MI); |
| 95 | |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 96 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 97 | void printOperand(const MachineInstr *MI, int OpNum, raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 98 | const char *Modifier = 0); |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 99 | void printSOImmOperand(const MachineInstr *MI, int OpNum, raw_ostream &O); |
| 100 | void printSOImm2PartOperand(const MachineInstr *MI, int OpNum, |
| 101 | raw_ostream &O); |
| 102 | void printSORegOperand(const MachineInstr *MI, int OpNum, |
| 103 | raw_ostream &O); |
| 104 | void printAddrMode2Operand(const MachineInstr *MI, int OpNum, |
| 105 | raw_ostream &O); |
| 106 | void printAddrMode2OffsetOperand(const MachineInstr *MI, int OpNum, |
| 107 | raw_ostream &O); |
| 108 | void printAddrMode3Operand(const MachineInstr *MI, int OpNum, |
| 109 | raw_ostream &O); |
| 110 | void printAddrMode3OffsetOperand(const MachineInstr *MI, int OpNum, |
| 111 | raw_ostream &O); |
| 112 | void printAddrMode4Operand(const MachineInstr *MI, int OpNum,raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 113 | const char *Modifier = 0); |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 114 | void printAddrMode5Operand(const MachineInstr *MI, int OpNum,raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 115 | const char *Modifier = 0); |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 116 | void printAddrMode6Operand(const MachineInstr *MI, int OpNum, |
| 117 | raw_ostream &O); |
| 118 | void printAddrMode6OffsetOperand(const MachineInstr *MI, int OpNum, |
| 119 | raw_ostream &O); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 120 | void printAddrModePCOperand(const MachineInstr *MI, int OpNum, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 121 | raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 122 | const char *Modifier = 0); |
Bob Wilson | eaf1c98 | 2010-08-11 23:10:46 +0000 | [diff] [blame] | 123 | void printBitfieldInvMaskImmOperand(const MachineInstr *MI, int OpNum, |
| 124 | raw_ostream &O); |
Johnny Chen | 1adc40c | 2010-08-12 20:46:17 +0000 | [diff] [blame^] | 125 | void printMemBOption(const MachineInstr *MI, int OpNum, |
| 126 | raw_ostream &O); |
Bob Wilson | eaf1c98 | 2010-08-11 23:10:46 +0000 | [diff] [blame] | 127 | void printSatShiftOperand(const MachineInstr *MI, int OpNum, |
| 128 | raw_ostream &O); |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 129 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 130 | void printThumbS4ImmOperand(const MachineInstr *MI, int OpNum, |
| 131 | raw_ostream &O); |
| 132 | void printThumbITMask(const MachineInstr *MI, int OpNum, raw_ostream &O); |
| 133 | void printThumbAddrModeRROperand(const MachineInstr *MI, int OpNum, |
| 134 | raw_ostream &O); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 135 | void printThumbAddrModeRI5Operand(const MachineInstr *MI, int OpNum, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 136 | raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 137 | unsigned Scale); |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 138 | void printThumbAddrModeS1Operand(const MachineInstr *MI, int OpNum, |
| 139 | raw_ostream &O); |
| 140 | void printThumbAddrModeS2Operand(const MachineInstr *MI, int OpNum, |
| 141 | raw_ostream &O); |
| 142 | void printThumbAddrModeS4Operand(const MachineInstr *MI, int OpNum, |
| 143 | raw_ostream &O); |
| 144 | void printThumbAddrModeSPOperand(const MachineInstr *MI, int OpNum, |
| 145 | raw_ostream &O); |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 146 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 147 | void printT2SOOperand(const MachineInstr *MI, int OpNum, raw_ostream &O); |
| 148 | void printT2AddrModeImm12Operand(const MachineInstr *MI, int OpNum, |
| 149 | raw_ostream &O); |
| 150 | void printT2AddrModeImm8Operand(const MachineInstr *MI, int OpNum, |
| 151 | raw_ostream &O); |
| 152 | void printT2AddrModeImm8s4Operand(const MachineInstr *MI, int OpNum, |
| 153 | raw_ostream &O); |
| 154 | void printT2AddrModeImm8OffsetOperand(const MachineInstr *MI, int OpNum, |
| 155 | raw_ostream &O); |
| 156 | void printT2AddrModeImm8s4OffsetOperand(const MachineInstr *MI, int OpNum, |
| 157 | raw_ostream &O) {} |
| 158 | void printT2AddrModeSoRegOperand(const MachineInstr *MI, int OpNum, |
| 159 | raw_ostream &O); |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 160 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 161 | void printCPSOptionOperand(const MachineInstr *MI, int OpNum, |
| 162 | raw_ostream &O) {} |
| 163 | void printMSRMaskOperand(const MachineInstr *MI, int OpNum, |
| 164 | raw_ostream &O) {} |
| 165 | void printNegZeroOperand(const MachineInstr *MI, int OpNum, |
| 166 | raw_ostream &O) {} |
| 167 | void printPredicateOperand(const MachineInstr *MI, int OpNum, |
| 168 | raw_ostream &O); |
| 169 | void printMandatoryPredicateOperand(const MachineInstr *MI, int OpNum, |
| 170 | raw_ostream &O); |
| 171 | void printSBitModifierOperand(const MachineInstr *MI, int OpNum, |
| 172 | raw_ostream &O); |
| 173 | void printPCLabel(const MachineInstr *MI, int OpNum, |
| 174 | raw_ostream &O); |
| 175 | void printRegisterList(const MachineInstr *MI, int OpNum, |
| 176 | raw_ostream &O); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 177 | void printCPInstOperand(const MachineInstr *MI, int OpNum, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 178 | raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 179 | const char *Modifier); |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 180 | void printJTBlockOperand(const MachineInstr *MI, int OpNum, |
| 181 | raw_ostream &O); |
| 182 | void printJT2BlockOperand(const MachineInstr *MI, int OpNum, |
| 183 | raw_ostream &O); |
| 184 | void printTBAddrMode(const MachineInstr *MI, int OpNum, |
| 185 | raw_ostream &O); |
| 186 | void printNoHashImmediate(const MachineInstr *MI, int OpNum, |
| 187 | raw_ostream &O); |
| 188 | void printVFPf32ImmOperand(const MachineInstr *MI, int OpNum, |
| 189 | raw_ostream &O); |
| 190 | void printVFPf64ImmOperand(const MachineInstr *MI, int OpNum, |
| 191 | raw_ostream &O); |
Bob Wilson | 1a913ed | 2010-06-11 21:34:50 +0000 | [diff] [blame] | 192 | void printNEONModImmOperand(const MachineInstr *MI, int OpNum, |
| 193 | raw_ostream &O); |
Bob Wilson | 54c78ef | 2009-11-06 23:33:28 +0000 | [diff] [blame] | 194 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 195 | virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNum, |
Chris Lattner | c75c028 | 2010-04-04 05:29:35 +0000 | [diff] [blame] | 196 | unsigned AsmVariant, const char *ExtraCode, |
| 197 | raw_ostream &O); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 198 | virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum, |
Bob Wilson | 224c244 | 2009-05-19 05:53:42 +0000 | [diff] [blame] | 199 | unsigned AsmVariant, |
Chris Lattner | c75c028 | 2010-04-04 05:29:35 +0000 | [diff] [blame] | 200 | const char *ExtraCode, raw_ostream &O); |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 201 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 202 | void printInstruction(const MachineInstr *MI, raw_ostream &O); // autogen |
Chris Lattner | d95148f | 2009-09-13 20:19:22 +0000 | [diff] [blame] | 203 | static const char *getRegisterName(unsigned RegNo); |
Chris Lattner | 05af261 | 2009-09-13 20:08:00 +0000 | [diff] [blame] | 204 | |
Chris Lattner | a786cea | 2010-01-28 01:10:34 +0000 | [diff] [blame] | 205 | virtual void EmitInstruction(const MachineInstr *MI); |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 206 | bool runOnMachineFunction(MachineFunction &F); |
Chris Lattner | a240619 | 2010-01-28 00:19:24 +0000 | [diff] [blame] | 207 | |
| 208 | virtual void EmitConstantPool() {} // we emit constant pools customly! |
Chris Lattner | 953ebb7 | 2010-01-27 23:58:11 +0000 | [diff] [blame] | 209 | virtual void EmitFunctionEntryLabel(); |
Bob Wilson | 812209a | 2009-09-30 22:06:26 +0000 | [diff] [blame] | 210 | void EmitStartOfAsmFile(Module &M); |
Chris Lattner | 4a071d6 | 2009-10-19 17:59:19 +0000 | [diff] [blame] | 211 | void EmitEndOfAsmFile(Module &M); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 212 | |
Devang Patel | 59135f4 | 2010-08-04 22:39:39 +0000 | [diff] [blame] | 213 | MachineLocation getDebugValueLocation(const MachineInstr *MI) const { |
| 214 | MachineLocation Location; |
| 215 | assert (MI->getNumOperands() == 4 && "Invalid no. of machine operands!"); |
| 216 | // Frame address. Currently handles register +- offset only. |
| 217 | if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) |
| 218 | Location.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm()); |
| 219 | else { |
| 220 | DEBUG(dbgs() << "DBG_VALUE instruction ignored! " << *MI << "\n"); |
| 221 | } |
| 222 | return Location; |
| 223 | } |
| 224 | |
Jim Grosbach | 9172900 | 2010-07-21 23:03:52 +0000 | [diff] [blame] | 225 | virtual unsigned getISAEncoding() { |
| 226 | // ARM/Darwin adds ISA to the DWARF info for each function. |
| 227 | if (!Subtarget->isTargetDarwin()) |
| 228 | return 0; |
| 229 | return Subtarget->isThumb() ? |
| 230 | llvm::ARM::DW_ISA_ARM_thumb : llvm::ARM::DW_ISA_ARM_arm; |
| 231 | } |
| 232 | |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 233 | MCSymbol *GetARMSetPICJumpTableLabel2(unsigned uid, unsigned uid2, |
| 234 | const MachineBasicBlock *MBB) const; |
| 235 | MCSymbol *GetARMJTIPICJumpTableLabel2(unsigned uid, unsigned uid2) const; |
Chris Lattner | bfcb096 | 2010-01-25 19:39:52 +0000 | [diff] [blame] | 236 | |
Evan Cheng | 711b6dc | 2008-08-08 06:56:16 +0000 | [diff] [blame] | 237 | /// EmitMachineConstantPoolValue - Print a machine constantpool value to |
| 238 | /// the .s file. |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 239 | virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 240 | SmallString<128> Str; |
| 241 | raw_svector_ostream OS(Str); |
| 242 | EmitMachineConstantPoolValue(MCPV, OS); |
| 243 | OutStreamer.EmitRawText(OS.str()); |
| 244 | } |
| 245 | |
| 246 | void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV, |
| 247 | raw_ostream &O) { |
Chris Lattner | ea3cb40 | 2010-01-20 07:33:29 +0000 | [diff] [blame] | 248 | switch (TM.getTargetData()->getTypeAllocSize(MCPV->getType())) { |
| 249 | case 1: O << MAI->getData8bitsDirective(0); break; |
| 250 | case 2: O << MAI->getData16bitsDirective(0); break; |
| 251 | case 4: O << MAI->getData32bitsDirective(0); break; |
| 252 | default: assert(0 && "Unknown CPV size"); |
| 253 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 254 | |
Evan Cheng | 711b6dc | 2008-08-08 06:56:16 +0000 | [diff] [blame] | 255 | ARMConstantPoolValue *ACPV = static_cast<ARMConstantPoolValue*>(MCPV); |
Jim Grosbach | 3fb2b1e | 2009-09-01 01:57:56 +0000 | [diff] [blame] | 256 | |
| 257 | if (ACPV->isLSDA()) { |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 258 | O << MAI->getPrivateGlobalPrefix() << "_LSDA_" << getFunctionNumber(); |
Bob Wilson | 28989a8 | 2009-11-02 16:59:06 +0000 | [diff] [blame] | 259 | } else if (ACPV->isBlockAddress()) { |
Chris Lattner | 0752cda | 2010-04-05 16:32:14 +0000 | [diff] [blame] | 260 | O << *GetBlockAddressSymbol(ACPV->getBlockAddress()); |
Bob Wilson | 28989a8 | 2009-11-02 16:59:06 +0000 | [diff] [blame] | 261 | } else if (ACPV->isGlobalValue()) { |
Dan Gohman | 46510a7 | 2010-04-15 01:51:59 +0000 | [diff] [blame] | 262 | const GlobalValue *GV = ACPV->getGV(); |
Evan Cheng | e4e4ed3 | 2009-08-28 23:18:09 +0000 | [diff] [blame] | 263 | bool isIndirect = Subtarget->isTargetDarwin() && |
Evan Cheng | 63476a8 | 2009-09-03 07:04:02 +0000 | [diff] [blame] | 264 | Subtarget->GVIsIndirectSymbol(GV, TM.getRelocationModel()); |
Evan Cheng | e4e4ed3 | 2009-08-28 23:18:09 +0000 | [diff] [blame] | 265 | if (!isIndirect) |
Chris Lattner | d62f1b4 | 2010-03-12 21:19:23 +0000 | [diff] [blame] | 266 | O << *Mang->getSymbol(GV); |
Evan Cheng | e4e4ed3 | 2009-08-28 23:18:09 +0000 | [diff] [blame] | 267 | else { |
| 268 | // FIXME: Remove this when Darwin transition to @GOT like syntax. |
Chris Lattner | 7a2ba94 | 2010-01-16 18:37:32 +0000 | [diff] [blame] | 269 | MCSymbol *Sym = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 270 | O << *Sym; |
Chris Lattner | b8f64a7 | 2009-10-19 18:49:14 +0000 | [diff] [blame] | 271 | |
| 272 | MachineModuleInfoMachO &MMIMachO = |
| 273 | MMI->getObjFileInfo<MachineModuleInfoMachO>(); |
Bill Wendling | cebae36 | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 274 | MachineModuleInfoImpl::StubValueTy &StubSym = |
Chris Lattner | b8f64a7 | 2009-10-19 18:49:14 +0000 | [diff] [blame] | 275 | GV->hasHiddenVisibility() ? MMIMachO.getHiddenGVStubEntry(Sym) : |
| 276 | MMIMachO.getGVStubEntry(Sym); |
Bill Wendling | cebae36 | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 277 | if (StubSym.getPointer() == 0) |
| 278 | StubSym = MachineModuleInfoImpl:: |
Chris Lattner | d62f1b4 | 2010-03-12 21:19:23 +0000 | [diff] [blame] | 279 | StubValueTy(Mang->getSymbol(GV), !GV->hasInternalLinkage()); |
Evan Cheng | e4e4ed3 | 2009-08-28 23:18:09 +0000 | [diff] [blame] | 280 | } |
Bob Wilson | 28989a8 | 2009-11-02 16:59:06 +0000 | [diff] [blame] | 281 | } else { |
| 282 | assert(ACPV->isExtSymbol() && "unrecognized constant pool value"); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 283 | O << *GetExternalSymbolSymbol(ACPV->getSymbol()); |
Bob Wilson | 28989a8 | 2009-11-02 16:59:06 +0000 | [diff] [blame] | 284 | } |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 285 | |
Lauro Ramos Venancio | 0ae4a33 | 2007-04-22 00:04:12 +0000 | [diff] [blame] | 286 | if (ACPV->hasModifier()) O << "(" << ACPV->getModifier() << ")"; |
Lauro Ramos Venancio | 64f4fa5 | 2007-04-27 13:54:47 +0000 | [diff] [blame] | 287 | if (ACPV->getPCAdjustment() != 0) { |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 288 | O << "-(" << MAI->getPrivateGlobalPrefix() << "PC" |
Evan Cheng | e7e0d62 | 2009-11-06 22:24:13 +0000 | [diff] [blame] | 289 | << getFunctionNumber() << "_" << ACPV->getLabelId() |
Lauro Ramos Venancio | 64f4fa5 | 2007-04-27 13:54:47 +0000 | [diff] [blame] | 290 | << "+" << (unsigned)ACPV->getPCAdjustment(); |
| 291 | if (ACPV->mustAddCurrentAddress()) |
| 292 | O << "-."; |
Chris Lattner | 8b37875 | 2010-01-15 23:26:49 +0000 | [diff] [blame] | 293 | O << ')'; |
Lauro Ramos Venancio | 64f4fa5 | 2007-04-27 13:54:47 +0000 | [diff] [blame] | 294 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 295 | } |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 296 | }; |
| 297 | } // end of anonymous namespace |
| 298 | |
| 299 | #include "ARMGenAsmWriter.inc" |
| 300 | |
Chris Lattner | 953ebb7 | 2010-01-27 23:58:11 +0000 | [diff] [blame] | 301 | void ARMAsmPrinter::EmitFunctionEntryLabel() { |
| 302 | if (AFI->isThumbFunction()) { |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 303 | OutStreamer.EmitRawText(StringRef("\t.code\t16")); |
Chris Lattner | 0752cda | 2010-04-05 16:32:14 +0000 | [diff] [blame] | 304 | if (!Subtarget->isTargetDarwin()) |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 305 | OutStreamer.EmitRawText(StringRef("\t.thumb_func")); |
Chris Lattner | 0752cda | 2010-04-05 16:32:14 +0000 | [diff] [blame] | 306 | else { |
| 307 | // This needs to emit to a temporary string to get properly quoted |
| 308 | // MCSymbols when they have spaces in them. |
| 309 | SmallString<128> Tmp; |
| 310 | raw_svector_ostream OS(Tmp); |
| 311 | OS << "\t.thumb_func\t" << *CurrentFnSym; |
| 312 | OutStreamer.EmitRawText(OS.str()); |
| 313 | } |
Chris Lattner | 953ebb7 | 2010-01-27 23:58:11 +0000 | [diff] [blame] | 314 | } |
| 315 | |
| 316 | OutStreamer.EmitLabel(CurrentFnSym); |
| 317 | } |
| 318 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 319 | /// runOnMachineFunction - This uses the printInstruction() |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 320 | /// method to print assembly for each instruction. |
| 321 | /// |
| 322 | bool ARMAsmPrinter::runOnMachineFunction(MachineFunction &MF) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 323 | AFI = MF.getInfo<ARMFunctionInfo>(); |
Evan Cheng | 6d63a72 | 2008-09-18 07:27:23 +0000 | [diff] [blame] | 324 | MCP = MF.getConstantPool(); |
Rafael Espindola | 4b442b5 | 2006-05-23 02:48:20 +0000 | [diff] [blame] | 325 | |
Chris Lattner | d49fe1b | 2010-01-28 01:28:58 +0000 | [diff] [blame] | 326 | return AsmPrinter::runOnMachineFunction(MF); |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 327 | } |
| 328 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 329 | void ARMAsmPrinter::printOperand(const MachineInstr *MI, int OpNum, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 330 | raw_ostream &O, const char *Modifier) { |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 331 | const MachineOperand &MO = MI->getOperand(OpNum); |
Anton Korobeynikov | 5cdc3a9 | 2009-11-24 00:44:37 +0000 | [diff] [blame] | 332 | unsigned TF = MO.getTargetFlags(); |
| 333 | |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 334 | switch (MO.getType()) { |
Chris Lattner | 8bc86cb | 2009-10-19 20:59:55 +0000 | [diff] [blame] | 335 | default: |
| 336 | assert(0 && "<unknown operand type>"); |
Bob Wilson | 5bafff3 | 2009-06-22 23:27:02 +0000 | [diff] [blame] | 337 | case MachineOperand::MO_Register: { |
| 338 | unsigned Reg = MO.getReg(); |
Chris Lattner | 8bc86cb | 2009-10-19 20:59:55 +0000 | [diff] [blame] | 339 | assert(TargetRegisterInfo::isPhysicalRegister(Reg)); |
| 340 | if (Modifier && strcmp(Modifier, "dregpair") == 0) { |
Jakob Stoklund Olesen | 558661d | 2010-05-24 16:54:32 +0000 | [diff] [blame] | 341 | unsigned DRegLo = TM.getRegisterInfo()->getSubReg(Reg, ARM::dsub_0); |
| 342 | unsigned DRegHi = TM.getRegisterInfo()->getSubReg(Reg, ARM::dsub_1); |
Chris Lattner | 8bc86cb | 2009-10-19 20:59:55 +0000 | [diff] [blame] | 343 | O << '{' |
Bob Wilson | a0148c3 | 2010-07-09 00:47:20 +0000 | [diff] [blame] | 344 | << getRegisterName(DRegLo) << ", " << getRegisterName(DRegHi) |
Chris Lattner | 8bc86cb | 2009-10-19 20:59:55 +0000 | [diff] [blame] | 345 | << '}'; |
| 346 | } else if (Modifier && strcmp(Modifier, "lane") == 0) { |
| 347 | unsigned RegNum = ARMRegisterInfo::getRegisterNumbering(Reg); |
Chris Lattner | 9d1c1ad | 2010-04-04 18:06:11 +0000 | [diff] [blame] | 348 | unsigned DReg = |
Jakob Stoklund Olesen | e00fa64 | 2010-05-25 00:15:15 +0000 | [diff] [blame] | 349 | TM.getRegisterInfo()->getMatchingSuperReg(Reg, |
| 350 | RegNum & 1 ? ARM::ssub_1 : ARM::ssub_0, &ARM::DPR_VFP2RegClass); |
Chris Lattner | 8bc86cb | 2009-10-19 20:59:55 +0000 | [diff] [blame] | 351 | O << getRegisterName(DReg) << '[' << (RegNum & 1) << ']'; |
| 352 | } else { |
Anton Korobeynikov | e8ea011 | 2009-11-07 15:20:32 +0000 | [diff] [blame] | 353 | assert(!MO.getSubReg() && "Subregs should be eliminated!"); |
Chris Lattner | 8bc86cb | 2009-10-19 20:59:55 +0000 | [diff] [blame] | 354 | O << getRegisterName(Reg); |
| 355 | } |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 356 | break; |
Bob Wilson | 5bafff3 | 2009-06-22 23:27:02 +0000 | [diff] [blame] | 357 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 358 | case MachineOperand::MO_Immediate: { |
Evan Cheng | 5adb66a | 2009-09-28 09:14:39 +0000 | [diff] [blame] | 359 | int64_t Imm = MO.getImm(); |
Anton Korobeynikov | 632606c | 2009-10-08 20:43:22 +0000 | [diff] [blame] | 360 | O << '#'; |
Anton Korobeynikov | 5cdc3a9 | 2009-11-24 00:44:37 +0000 | [diff] [blame] | 361 | if ((Modifier && strcmp(Modifier, "lo16") == 0) || |
| 362 | (TF & ARMII::MO_LO16)) |
| 363 | O << ":lower16:"; |
| 364 | else if ((Modifier && strcmp(Modifier, "hi16") == 0) || |
| 365 | (TF & ARMII::MO_HI16)) |
| 366 | O << ":upper16:"; |
Anton Korobeynikov | 632606c | 2009-10-08 20:43:22 +0000 | [diff] [blame] | 367 | O << Imm; |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 368 | break; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 369 | } |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 370 | case MachineOperand::MO_MachineBasicBlock: |
Chris Lattner | 1b2eb0e | 2010-03-13 21:04:28 +0000 | [diff] [blame] | 371 | O << *MO.getMBB()->getSymbol(); |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 372 | return; |
Rafael Espindola | 84b19be | 2006-07-16 01:02:57 +0000 | [diff] [blame] | 373 | case MachineOperand::MO_GlobalAddress: { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 374 | bool isCallOp = Modifier && !strcmp(Modifier, "call"); |
Dan Gohman | 46510a7 | 2010-04-15 01:51:59 +0000 | [diff] [blame] | 375 | const GlobalValue *GV = MO.getGlobal(); |
Anton Korobeynikov | 5cdc3a9 | 2009-11-24 00:44:37 +0000 | [diff] [blame] | 376 | |
| 377 | if ((Modifier && strcmp(Modifier, "lo16") == 0) || |
| 378 | (TF & ARMII::MO_LO16)) |
| 379 | O << ":lower16:"; |
| 380 | else if ((Modifier && strcmp(Modifier, "hi16") == 0) || |
| 381 | (TF & ARMII::MO_HI16)) |
| 382 | O << ":upper16:"; |
Chris Lattner | d62f1b4 | 2010-03-12 21:19:23 +0000 | [diff] [blame] | 383 | O << *Mang->getSymbol(GV); |
Anton Korobeynikov | 7751ad9 | 2008-11-22 16:15:34 +0000 | [diff] [blame] | 384 | |
Chris Lattner | 0c08d09 | 2010-04-03 22:28:33 +0000 | [diff] [blame] | 385 | printOffset(MO.getOffset(), O); |
Anton Korobeynikov | 7751ad9 | 2008-11-22 16:15:34 +0000 | [diff] [blame] | 386 | |
Lauro Ramos Venancio | 0ae4a33 | 2007-04-22 00:04:12 +0000 | [diff] [blame] | 387 | if (isCallOp && Subtarget->isTargetELF() && |
| 388 | TM.getRelocationModel() == Reloc::PIC_) |
| 389 | O << "(PLT)"; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 390 | break; |
Rafael Espindola | 84b19be | 2006-07-16 01:02:57 +0000 | [diff] [blame] | 391 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 392 | case MachineOperand::MO_ExternalSymbol: { |
| 393 | bool isCallOp = Modifier && !strcmp(Modifier, "call"); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 394 | O << *GetExternalSymbolSymbol(MO.getSymbolName()); |
Chris Lattner | 09533a4 | 2010-01-13 08:08:33 +0000 | [diff] [blame] | 395 | |
Lauro Ramos Venancio | 0ae4a33 | 2007-04-22 00:04:12 +0000 | [diff] [blame] | 396 | if (isCallOp && Subtarget->isTargetELF() && |
| 397 | TM.getRelocationModel() == Reloc::PIC_) |
| 398 | O << "(PLT)"; |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 399 | break; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 400 | } |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 401 | case MachineOperand::MO_ConstantPoolIndex: |
Chris Lattner | 1b46f43 | 2010-01-23 07:00:21 +0000 | [diff] [blame] | 402 | O << *GetCPISymbol(MO.getIndex()); |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 403 | break; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 404 | case MachineOperand::MO_JumpTableIndex: |
Chris Lattner | 1b46f43 | 2010-01-23 07:00:21 +0000 | [diff] [blame] | 405 | O << *GetJTISymbol(MO.getIndex()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 406 | break; |
Rafael Espindola | 2f99b6b | 2006-05-25 12:57:06 +0000 | [diff] [blame] | 407 | } |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 408 | } |
| 409 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 410 | static void printSOImm(raw_ostream &O, int64_t V, bool VerboseAsm, |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 411 | const MCAsmInfo *MAI) { |
Evan Cheng | e7cbe41 | 2009-07-08 21:03:57 +0000 | [diff] [blame] | 412 | // Break it up into two parts that make up a shifter immediate. |
| 413 | V = ARM_AM::getSOImmVal(V); |
| 414 | assert(V != -1 && "Not a valid so_imm value!"); |
| 415 | |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 416 | unsigned Imm = ARM_AM::getSOImmValImm(V); |
| 417 | unsigned Rot = ARM_AM::getSOImmValRot(V); |
Anton Korobeynikov | 7751ad9 | 2008-11-22 16:15:34 +0000 | [diff] [blame] | 418 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 419 | // Print low-level immediate formation info, per |
| 420 | // A5.1.3: "Data-processing operands - Immediate". |
| 421 | if (Rot) { |
| 422 | O << "#" << Imm << ", " << Rot; |
| 423 | // Pretty printed version. |
Evan Cheng | 3938242 | 2009-10-28 01:44:26 +0000 | [diff] [blame] | 424 | if (VerboseAsm) { |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 425 | O << "\t" << MAI->getCommentString() << ' '; |
Evan Cheng | 3938242 | 2009-10-28 01:44:26 +0000 | [diff] [blame] | 426 | O << (int)ARM_AM::rotr32(Imm, Rot); |
| 427 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 428 | } else { |
| 429 | O << "#" << Imm; |
| 430 | } |
| 431 | } |
| 432 | |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 433 | /// printSOImmOperand - SOImm is 4-bit rotate amount in bits 8-11 with 8-bit |
| 434 | /// immediate in bits 0-7. |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 435 | void ARMAsmPrinter::printSOImmOperand(const MachineInstr *MI, int OpNum, |
| 436 | raw_ostream &O) { |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 437 | const MachineOperand &MO = MI->getOperand(OpNum); |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 438 | assert(MO.isImm() && "Not a valid so_imm value!"); |
Chris Lattner | 3f53c83 | 2010-04-04 18:52:31 +0000 | [diff] [blame] | 439 | printSOImm(O, MO.getImm(), isVerbose(), MAI); |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 440 | } |
| 441 | |
Evan Cheng | 9092213 | 2008-11-06 02:25:39 +0000 | [diff] [blame] | 442 | /// printSOImm2PartOperand - SOImm is broken into two pieces using a 'mov' |
| 443 | /// followed by an 'orr' to materialize. |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 444 | void ARMAsmPrinter::printSOImm2PartOperand(const MachineInstr *MI, int OpNum, |
| 445 | raw_ostream &O) { |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 446 | const MachineOperand &MO = MI->getOperand(OpNum); |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 447 | assert(MO.isImm() && "Not a valid so_imm value!"); |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 448 | unsigned V1 = ARM_AM::getSOImmTwoPartFirst(MO.getImm()); |
| 449 | unsigned V2 = ARM_AM::getSOImmTwoPartSecond(MO.getImm()); |
Chris Lattner | 3f53c83 | 2010-04-04 18:52:31 +0000 | [diff] [blame] | 450 | printSOImm(O, V1, isVerbose(), MAI); |
Evan Cheng | 5e148a3 | 2007-06-05 18:55:18 +0000 | [diff] [blame] | 451 | O << "\n\torr"; |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 452 | printPredicateOperand(MI, 2, O); |
Evan Cheng | 162e309 | 2009-10-26 23:45:59 +0000 | [diff] [blame] | 453 | O << "\t"; |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 454 | printOperand(MI, 0, O); |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 455 | O << ", "; |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 456 | printOperand(MI, 0, O); |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 457 | O << ", "; |
Chris Lattner | 3f53c83 | 2010-04-04 18:52:31 +0000 | [diff] [blame] | 458 | printSOImm(O, V2, isVerbose(), MAI); |
Evan Cheng | c70d184 | 2007-03-20 08:11:30 +0000 | [diff] [blame] | 459 | } |
| 460 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 461 | // so_reg is a 4-operand unit corresponding to register forms of the A5.1 |
| 462 | // "Addressing Mode 1 - Data-processing operands" forms. This includes: |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 463 | // REG 0 0 - e.g. R5 |
| 464 | // REG REG 0,SH_OPC - e.g. R5, ROR R3 |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 465 | // REG 0 IMM,SH_OPC - e.g. R5, LSL #3 |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 466 | void ARMAsmPrinter::printSORegOperand(const MachineInstr *MI, int Op, |
| 467 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 468 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 469 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 470 | const MachineOperand &MO3 = MI->getOperand(Op+2); |
| 471 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 472 | O << getRegisterName(MO1.getReg()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 473 | |
| 474 | // Print the shift opc. |
Bob Wilson | 1d9125a | 2010-08-05 00:34:42 +0000 | [diff] [blame] | 475 | ARM_AM::ShiftOpc ShOpc = ARM_AM::getSORegShOp(MO3.getImm()); |
| 476 | O << ", " << ARM_AM::getShiftOpcStr(ShOpc); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 477 | if (MO2.getReg()) { |
Bob Wilson | 1d9125a | 2010-08-05 00:34:42 +0000 | [diff] [blame] | 478 | O << ' ' << getRegisterName(MO2.getReg()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 479 | assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0); |
Bob Wilson | 1d9125a | 2010-08-05 00:34:42 +0000 | [diff] [blame] | 480 | } else if (ShOpc != ARM_AM::rrx) { |
| 481 | O << " #" << ARM_AM::getSORegOffset(MO3.getImm()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 482 | } |
| 483 | } |
| 484 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 485 | void ARMAsmPrinter::printAddrMode2Operand(const MachineInstr *MI, int Op, |
| 486 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 487 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 488 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 489 | const MachineOperand &MO3 = MI->getOperand(Op+2); |
| 490 | |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 491 | if (!MO1.isReg()) { // FIXME: This is for CP entries, but isn't right. |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 492 | printOperand(MI, Op, O); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 493 | return; |
| 494 | } |
| 495 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 496 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 497 | |
| 498 | if (!MO2.getReg()) { |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 499 | if (ARM_AM::getAM2Offset(MO3.getImm())) // Don't print +0. |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 500 | O << ", #" |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 501 | << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm())) |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 502 | << ARM_AM::getAM2Offset(MO3.getImm()); |
| 503 | O << "]"; |
| 504 | return; |
| 505 | } |
| 506 | |
| 507 | O << ", " |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 508 | << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO3.getImm())) |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 509 | << getRegisterName(MO2.getReg()); |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 510 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 511 | if (unsigned ShImm = ARM_AM::getAM2Offset(MO3.getImm())) |
| 512 | O << ", " |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 513 | << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO3.getImm())) |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 514 | << " #" << ShImm; |
| 515 | O << "]"; |
| 516 | } |
| 517 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 518 | void ARMAsmPrinter::printAddrMode2OffsetOperand(const MachineInstr *MI, int Op, |
| 519 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 520 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 521 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 522 | |
| 523 | if (!MO1.getReg()) { |
Evan Cheng | bdc9869 | 2007-05-03 23:30:36 +0000 | [diff] [blame] | 524 | unsigned ImmOffs = ARM_AM::getAM2Offset(MO2.getImm()); |
Evan Cheng | bdc9869 | 2007-05-03 23:30:36 +0000 | [diff] [blame] | 525 | O << "#" |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 526 | << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm())) |
Evan Cheng | bdc9869 | 2007-05-03 23:30:36 +0000 | [diff] [blame] | 527 | << ImmOffs; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 528 | return; |
| 529 | } |
| 530 | |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 531 | O << ARM_AM::getAddrOpcStr(ARM_AM::getAM2Op(MO2.getImm())) |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 532 | << getRegisterName(MO1.getReg()); |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 533 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 534 | if (unsigned ShImm = ARM_AM::getAM2Offset(MO2.getImm())) |
| 535 | O << ", " |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 536 | << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO2.getImm())) |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 537 | << " #" << ShImm; |
| 538 | } |
| 539 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 540 | void ARMAsmPrinter::printAddrMode3Operand(const MachineInstr *MI, int Op, |
| 541 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 542 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 543 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 544 | const MachineOperand &MO3 = MI->getOperand(Op+2); |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 545 | |
Dan Gohman | 6f0d024 | 2008-02-10 18:45:23 +0000 | [diff] [blame] | 546 | assert(TargetRegisterInfo::isPhysicalRegister(MO1.getReg())); |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 547 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 548 | |
| 549 | if (MO2.getReg()) { |
| 550 | O << ", " |
| 551 | << (char)ARM_AM::getAM3Op(MO3.getImm()) |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 552 | << getRegisterName(MO2.getReg()) |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 553 | << "]"; |
| 554 | return; |
| 555 | } |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 556 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 557 | if (unsigned ImmOffs = ARM_AM::getAM3Offset(MO3.getImm())) |
| 558 | O << ", #" |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 559 | << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO3.getImm())) |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 560 | << ImmOffs; |
| 561 | O << "]"; |
| 562 | } |
| 563 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 564 | void ARMAsmPrinter::printAddrMode3OffsetOperand(const MachineInstr *MI, int Op, |
| 565 | raw_ostream &O){ |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 566 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 567 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 568 | |
| 569 | if (MO1.getReg()) { |
| 570 | O << (char)ARM_AM::getAM3Op(MO2.getImm()) |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 571 | << getRegisterName(MO1.getReg()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 572 | return; |
| 573 | } |
| 574 | |
| 575 | unsigned ImmOffs = ARM_AM::getAM3Offset(MO2.getImm()); |
| 576 | O << "#" |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 577 | << ARM_AM::getAddrOpcStr(ARM_AM::getAM3Op(MO2.getImm())) |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 578 | << ImmOffs; |
| 579 | } |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 580 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 581 | void ARMAsmPrinter::printAddrMode4Operand(const MachineInstr *MI, int Op, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 582 | raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 583 | const char *Modifier) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 584 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 585 | ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MO2.getImm()); |
| 586 | if (Modifier && strcmp(Modifier, "submode") == 0) { |
Bob Wilson | ea7f22c | 2010-03-16 16:19:07 +0000 | [diff] [blame] | 587 | O << ARM_AM::getAMSubModeStr(Mode); |
Evan Cheng | d77c7ab | 2009-08-07 21:19:10 +0000 | [diff] [blame] | 588 | } else if (Modifier && strcmp(Modifier, "wide") == 0) { |
| 589 | ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MO2.getImm()); |
| 590 | if (Mode == ARM_AM::ia) |
| 591 | O << ".w"; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 592 | } else { |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 593 | printOperand(MI, Op, O); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 594 | } |
| 595 | } |
| 596 | |
| 597 | void ARMAsmPrinter::printAddrMode5Operand(const MachineInstr *MI, int Op, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 598 | raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 599 | const char *Modifier) { |
| 600 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 601 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 602 | |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 603 | if (!MO1.isReg()) { // FIXME: This is for CP entries, but isn't right. |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 604 | printOperand(MI, Op, O); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 605 | return; |
| 606 | } |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 607 | |
Dan Gohman | 6f0d024 | 2008-02-10 18:45:23 +0000 | [diff] [blame] | 608 | assert(TargetRegisterInfo::isPhysicalRegister(MO1.getReg())); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 609 | |
| 610 | if (Modifier && strcmp(Modifier, "submode") == 0) { |
| 611 | ARM_AM::AMSubMode Mode = ARM_AM::getAM5SubMode(MO2.getImm()); |
Jim Grosbach | e516549 | 2009-11-09 00:11:35 +0000 | [diff] [blame] | 612 | O << ARM_AM::getAMSubModeStr(Mode); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 613 | return; |
| 614 | } else if (Modifier && strcmp(Modifier, "base") == 0) { |
| 615 | // Used for FSTM{D|S} and LSTM{D|S} operations. |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 616 | O << getRegisterName(MO1.getReg()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 617 | return; |
| 618 | } |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 619 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 620 | O << "[" << getRegisterName(MO1.getReg()); |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 621 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 622 | if (unsigned ImmOffs = ARM_AM::getAM5Offset(MO2.getImm())) { |
| 623 | O << ", #" |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 624 | << ARM_AM::getAddrOpcStr(ARM_AM::getAM5Op(MO2.getImm())) |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 625 | << ImmOffs*4; |
| 626 | } |
| 627 | O << "]"; |
| 628 | } |
| 629 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 630 | void ARMAsmPrinter::printAddrMode6Operand(const MachineInstr *MI, int Op, |
| 631 | raw_ostream &O) { |
Bob Wilson | 8b024a5 | 2009-07-01 23:16:05 +0000 | [diff] [blame] | 632 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 633 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
Bob Wilson | 8b024a5 | 2009-07-01 23:16:05 +0000 | [diff] [blame] | 634 | |
Jim Grosbach | 8a5ec86 | 2009-11-07 21:25:39 +0000 | [diff] [blame] | 635 | O << "[" << getRegisterName(MO1.getReg()); |
Bob Wilson | 226036e | 2010-03-20 22:13:40 +0000 | [diff] [blame] | 636 | if (MO2.getImm()) { |
Anton Korobeynikov | bce3dbd | 2009-11-17 20:04:59 +0000 | [diff] [blame] | 637 | // FIXME: Both darwin as and GNU as violate ARM docs here. |
Bob Wilson | 273ff31 | 2010-07-14 23:54:43 +0000 | [diff] [blame] | 638 | O << ", :" << (MO2.getImm() << 3); |
Jim Grosbach | 8a5ec86 | 2009-11-07 21:25:39 +0000 | [diff] [blame] | 639 | } |
| 640 | O << "]"; |
Bob Wilson | 226036e | 2010-03-20 22:13:40 +0000 | [diff] [blame] | 641 | } |
Bob Wilson | a43e6bf | 2010-03-16 23:01:13 +0000 | [diff] [blame] | 642 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 643 | void ARMAsmPrinter::printAddrMode6OffsetOperand(const MachineInstr *MI, int Op, |
| 644 | raw_ostream &O){ |
Bob Wilson | 226036e | 2010-03-20 22:13:40 +0000 | [diff] [blame] | 645 | const MachineOperand &MO = MI->getOperand(Op); |
| 646 | if (MO.getReg() == 0) |
| 647 | O << "!"; |
| 648 | else |
| 649 | O << ", " << getRegisterName(MO.getReg()); |
Bob Wilson | 8b024a5 | 2009-07-01 23:16:05 +0000 | [diff] [blame] | 650 | } |
| 651 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 652 | void ARMAsmPrinter::printAddrModePCOperand(const MachineInstr *MI, int Op, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 653 | raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 654 | const char *Modifier) { |
| 655 | if (Modifier && strcmp(Modifier, "label") == 0) { |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 656 | printPCLabel(MI, Op+1, O); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 657 | return; |
| 658 | } |
| 659 | |
| 660 | const MachineOperand &MO1 = MI->getOperand(Op); |
Dan Gohman | 6f0d024 | 2008-02-10 18:45:23 +0000 | [diff] [blame] | 661 | assert(TargetRegisterInfo::isPhysicalRegister(MO1.getReg())); |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 662 | O << "[pc, " << getRegisterName(MO1.getReg()) << "]"; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 663 | } |
| 664 | |
| 665 | void |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 666 | ARMAsmPrinter::printBitfieldInvMaskImmOperand(const MachineInstr *MI, int Op, |
| 667 | raw_ostream &O) { |
Evan Cheng | f49810c | 2009-06-23 17:48:47 +0000 | [diff] [blame] | 668 | const MachineOperand &MO = MI->getOperand(Op); |
| 669 | uint32_t v = ~MO.getImm(); |
Evan Cheng | 9e03cbe | 2009-06-25 22:04:44 +0000 | [diff] [blame] | 670 | int32_t lsb = CountTrailingZeros_32(v); |
Nick Lewycky | b825aaa | 2009-06-24 01:08:42 +0000 | [diff] [blame] | 671 | int32_t width = (32 - CountLeadingZeros_32 (v)) - lsb; |
Evan Cheng | f49810c | 2009-06-23 17:48:47 +0000 | [diff] [blame] | 672 | assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!"); |
| 673 | O << "#" << lsb << ", #" << width; |
| 674 | } |
| 675 | |
Johnny Chen | 1adc40c | 2010-08-12 20:46:17 +0000 | [diff] [blame^] | 676 | void |
| 677 | ARMAsmPrinter::printMemBOption(const MachineInstr *MI, int OpNum, |
| 678 | raw_ostream &O) { |
| 679 | unsigned val = MI->getOperand(OpNum).getImm(); |
| 680 | O << ARM_MB::MemBOptToString(val); |
| 681 | } |
| 682 | |
Bob Wilson | eaf1c98 | 2010-08-11 23:10:46 +0000 | [diff] [blame] | 683 | void ARMAsmPrinter::printSatShiftOperand(const MachineInstr *MI, int OpNum, |
| 684 | raw_ostream &O) { |
| 685 | unsigned ShiftOp = MI->getOperand(OpNum).getImm(); |
| 686 | ARM_AM::ShiftOpc Opc = ARM_AM::getSORegShOp(ShiftOp); |
| 687 | switch (Opc) { |
| 688 | case ARM_AM::no_shift: |
| 689 | return; |
| 690 | case ARM_AM::lsl: |
| 691 | O << ", lsl #"; |
| 692 | break; |
| 693 | case ARM_AM::asr: |
| 694 | O << ", asr #"; |
| 695 | break; |
| 696 | default: |
| 697 | assert(0 && "unexpected shift opcode for saturate shift operand"); |
| 698 | } |
| 699 | O << ARM_AM::getSORegOffset(ShiftOp); |
| 700 | } |
| 701 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 702 | //===--------------------------------------------------------------------===// |
| 703 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 704 | void ARMAsmPrinter::printThumbS4ImmOperand(const MachineInstr *MI, int Op, |
| 705 | raw_ostream &O) { |
Evan Cheng | 2ef9c8a | 2009-11-19 06:57:41 +0000 | [diff] [blame] | 706 | O << "#" << MI->getOperand(Op).getImm() * 4; |
| 707 | } |
| 708 | |
Evan Cheng | f49810c | 2009-06-23 17:48:47 +0000 | [diff] [blame] | 709 | void |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 710 | ARMAsmPrinter::printThumbITMask(const MachineInstr *MI, int Op, |
| 711 | raw_ostream &O) { |
Evan Cheng | e556474 | 2009-07-09 23:43:36 +0000 | [diff] [blame] | 712 | // (3 - the number of trailing zeros) is the number of then / else. |
| 713 | unsigned Mask = MI->getOperand(Op).getImm(); |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 714 | unsigned CondBit0 = Mask >> 4 & 1; |
Evan Cheng | e556474 | 2009-07-09 23:43:36 +0000 | [diff] [blame] | 715 | unsigned NumTZ = CountTrailingZeros_32(Mask); |
| 716 | assert(NumTZ <= 3 && "Invalid IT mask!"); |
Evan Cheng | 06e1658 | 2009-07-10 01:54:42 +0000 | [diff] [blame] | 717 | for (unsigned Pos = 3, e = NumTZ; Pos > e; --Pos) { |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 718 | bool T = ((Mask >> Pos) & 1) == CondBit0; |
Evan Cheng | e556474 | 2009-07-09 23:43:36 +0000 | [diff] [blame] | 719 | if (T) |
| 720 | O << 't'; |
| 721 | else |
| 722 | O << 'e'; |
| 723 | } |
| 724 | } |
| 725 | |
| 726 | void |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 727 | ARMAsmPrinter::printThumbAddrModeRROperand(const MachineInstr *MI, int Op, |
| 728 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 729 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 730 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 731 | O << "[" << getRegisterName(MO1.getReg()); |
| 732 | O << ", " << getRegisterName(MO2.getReg()) << "]"; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 733 | } |
| 734 | |
| 735 | void |
| 736 | ARMAsmPrinter::printThumbAddrModeRI5Operand(const MachineInstr *MI, int Op, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 737 | raw_ostream &O, |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 738 | unsigned Scale) { |
| 739 | const MachineOperand &MO1 = MI->getOperand(Op); |
Evan Cheng | cea117d | 2007-01-30 02:35:32 +0000 | [diff] [blame] | 740 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
| 741 | const MachineOperand &MO3 = MI->getOperand(Op+2); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 742 | |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 743 | if (!MO1.isReg()) { // FIXME: This is for CP entries, but isn't right. |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 744 | printOperand(MI, Op, O); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 745 | return; |
| 746 | } |
| 747 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 748 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | cea117d | 2007-01-30 02:35:32 +0000 | [diff] [blame] | 749 | if (MO3.getReg()) |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 750 | O << ", " << getRegisterName(MO3.getReg()); |
Evan Cheng | 4b6bbe1 | 2009-11-10 19:48:13 +0000 | [diff] [blame] | 751 | else if (unsigned ImmOffs = MO2.getImm()) |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 752 | O << ", #" << ImmOffs * Scale; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 753 | O << "]"; |
| 754 | } |
| 755 | |
| 756 | void |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 757 | ARMAsmPrinter::printThumbAddrModeS1Operand(const MachineInstr *MI, int Op, |
| 758 | raw_ostream &O) { |
| 759 | printThumbAddrModeRI5Operand(MI, Op, O, 1); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 760 | } |
| 761 | void |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 762 | ARMAsmPrinter::printThumbAddrModeS2Operand(const MachineInstr *MI, int Op, |
| 763 | raw_ostream &O) { |
| 764 | printThumbAddrModeRI5Operand(MI, Op, O, 2); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 765 | } |
| 766 | void |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 767 | ARMAsmPrinter::printThumbAddrModeS4Operand(const MachineInstr *MI, int Op, |
| 768 | raw_ostream &O) { |
| 769 | printThumbAddrModeRI5Operand(MI, Op, O, 4); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 770 | } |
| 771 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 772 | void ARMAsmPrinter::printThumbAddrModeSPOperand(const MachineInstr *MI,int Op, |
| 773 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 774 | const MachineOperand &MO1 = MI->getOperand(Op); |
| 775 | const MachineOperand &MO2 = MI->getOperand(Op+1); |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 776 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 777 | if (unsigned ImmOffs = MO2.getImm()) |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 778 | O << ", #" << ImmOffs*4; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 779 | O << "]"; |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 780 | } |
| 781 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 782 | //===--------------------------------------------------------------------===// |
| 783 | |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 784 | // Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2 |
| 785 | // register with shift forms. |
| 786 | // REG 0 0 - e.g. R5 |
| 787 | // REG IMM, SH_OPC - e.g. R5, LSL #3 |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 788 | void ARMAsmPrinter::printT2SOOperand(const MachineInstr *MI, int OpNum, |
| 789 | raw_ostream &O) { |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 790 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 791 | const MachineOperand &MO2 = MI->getOperand(OpNum+1); |
| 792 | |
| 793 | unsigned Reg = MO1.getReg(); |
| 794 | assert(TargetRegisterInfo::isPhysicalRegister(Reg)); |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 795 | O << getRegisterName(Reg); |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 796 | |
| 797 | // Print the shift opc. |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 798 | assert(MO2.isImm() && "Not a valid t2_so_reg value!"); |
Bob Wilson | 1d9125a | 2010-08-05 00:34:42 +0000 | [diff] [blame] | 799 | ARM_AM::ShiftOpc ShOpc = ARM_AM::getSORegShOp(MO2.getImm()); |
| 800 | O << ", " << ARM_AM::getShiftOpcStr(ShOpc); |
| 801 | if (ShOpc != ARM_AM::rrx) |
| 802 | O << " #" << ARM_AM::getSORegOffset(MO2.getImm()); |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 803 | } |
| 804 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 805 | void ARMAsmPrinter::printT2AddrModeImm12Operand(const MachineInstr *MI, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 806 | int OpNum, |
| 807 | raw_ostream &O) { |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 808 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 809 | const MachineOperand &MO2 = MI->getOperand(OpNum+1); |
Evan Cheng | 9cb9e67 | 2009-06-27 02:26:13 +0000 | [diff] [blame] | 810 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 811 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 812 | |
| 813 | unsigned OffImm = MO2.getImm(); |
| 814 | if (OffImm) // Don't print +0. |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 815 | O << ", #" << OffImm; |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 816 | O << "]"; |
| 817 | } |
| 818 | |
| 819 | void ARMAsmPrinter::printT2AddrModeImm8Operand(const MachineInstr *MI, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 820 | int OpNum, |
| 821 | raw_ostream &O) { |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 822 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 823 | const MachineOperand &MO2 = MI->getOperand(OpNum+1); |
| 824 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 825 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 826 | |
| 827 | int32_t OffImm = (int32_t)MO2.getImm(); |
| 828 | // Don't print +0. |
| 829 | if (OffImm < 0) |
| 830 | O << ", #-" << -OffImm; |
| 831 | else if (OffImm > 0) |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 832 | O << ", #" << OffImm; |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 833 | O << "]"; |
| 834 | } |
| 835 | |
Evan Cheng | 5c87417 | 2009-07-09 22:21:59 +0000 | [diff] [blame] | 836 | void ARMAsmPrinter::printT2AddrModeImm8s4Operand(const MachineInstr *MI, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 837 | int OpNum, |
| 838 | raw_ostream &O) { |
Evan Cheng | 5c87417 | 2009-07-09 22:21:59 +0000 | [diff] [blame] | 839 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 840 | const MachineOperand &MO2 = MI->getOperand(OpNum+1); |
| 841 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 842 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | 5c87417 | 2009-07-09 22:21:59 +0000 | [diff] [blame] | 843 | |
| 844 | int32_t OffImm = (int32_t)MO2.getImm() / 4; |
| 845 | // Don't print +0. |
| 846 | if (OffImm < 0) |
Evan Cheng | a64ce45 | 2009-11-19 06:31:26 +0000 | [diff] [blame] | 847 | O << ", #-" << -OffImm * 4; |
Evan Cheng | 5c87417 | 2009-07-09 22:21:59 +0000 | [diff] [blame] | 848 | else if (OffImm > 0) |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 849 | O << ", #" << OffImm * 4; |
Evan Cheng | 5c87417 | 2009-07-09 22:21:59 +0000 | [diff] [blame] | 850 | O << "]"; |
| 851 | } |
| 852 | |
Evan Cheng | e88d5ce | 2009-07-02 07:28:31 +0000 | [diff] [blame] | 853 | void ARMAsmPrinter::printT2AddrModeImm8OffsetOperand(const MachineInstr *MI, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 854 | int OpNum, |
| 855 | raw_ostream &O) { |
Evan Cheng | e88d5ce | 2009-07-02 07:28:31 +0000 | [diff] [blame] | 856 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 857 | int32_t OffImm = (int32_t)MO1.getImm(); |
| 858 | // Don't print +0. |
| 859 | if (OffImm < 0) |
| 860 | O << "#-" << -OffImm; |
| 861 | else if (OffImm > 0) |
Johnny Chen | 9e08876 | 2010-03-17 17:52:21 +0000 | [diff] [blame] | 862 | O << "#" << OffImm; |
| 863 | } |
| 864 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 865 | void ARMAsmPrinter::printT2AddrModeSoRegOperand(const MachineInstr *MI, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 866 | int OpNum, |
| 867 | raw_ostream &O) { |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 868 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 869 | const MachineOperand &MO2 = MI->getOperand(OpNum+1); |
| 870 | const MachineOperand &MO3 = MI->getOperand(OpNum+2); |
| 871 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 872 | O << "[" << getRegisterName(MO1.getReg()); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 873 | |
Evan Cheng | 3a21425 | 2009-08-11 08:52:18 +0000 | [diff] [blame] | 874 | assert(MO2.getReg() && "Invalid so_reg load / store address!"); |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 875 | O << ", " << getRegisterName(MO2.getReg()); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 876 | |
Evan Cheng | 3a21425 | 2009-08-11 08:52:18 +0000 | [diff] [blame] | 877 | unsigned ShAmt = MO3.getImm(); |
| 878 | if (ShAmt) { |
| 879 | assert(ShAmt <= 3 && "Not a valid Thumb2 addressing mode!"); |
| 880 | O << ", lsl #" << ShAmt; |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 881 | } |
| 882 | O << "]"; |
| 883 | } |
| 884 | |
| 885 | |
| 886 | //===--------------------------------------------------------------------===// |
| 887 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 888 | void ARMAsmPrinter::printPredicateOperand(const MachineInstr *MI, int OpNum, |
| 889 | raw_ostream &O) { |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 890 | ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm(); |
Evan Cheng | 44bec52 | 2007-05-15 01:29:07 +0000 | [diff] [blame] | 891 | if (CC != ARMCC::AL) |
| 892 | O << ARMCondCodeToString(CC); |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 893 | } |
| 894 | |
Johnny Chen | 9d3acaa | 2010-03-02 17:57:15 +0000 | [diff] [blame] | 895 | void ARMAsmPrinter::printMandatoryPredicateOperand(const MachineInstr *MI, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 896 | int OpNum, |
| 897 | raw_ostream &O) { |
Johnny Chen | 9d3acaa | 2010-03-02 17:57:15 +0000 | [diff] [blame] | 898 | ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm(); |
| 899 | O << ARMCondCodeToString(CC); |
| 900 | } |
| 901 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 902 | void ARMAsmPrinter::printSBitModifierOperand(const MachineInstr *MI, int OpNum, |
| 903 | raw_ostream &O){ |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 904 | unsigned Reg = MI->getOperand(OpNum).getReg(); |
Evan Cheng | dfb2eba | 2007-07-06 01:01:34 +0000 | [diff] [blame] | 905 | if (Reg) { |
| 906 | assert(Reg == ARM::CPSR && "Expect ARM CPSR register!"); |
| 907 | O << 's'; |
| 908 | } |
| 909 | } |
| 910 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 911 | void ARMAsmPrinter::printPCLabel(const MachineInstr *MI, int OpNum, |
| 912 | raw_ostream &O) { |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 913 | int Id = (int)MI->getOperand(OpNum).getImm(); |
Evan Cheng | e7e0d62 | 2009-11-06 22:24:13 +0000 | [diff] [blame] | 914 | O << MAI->getPrivateGlobalPrefix() |
| 915 | << "PC" << getFunctionNumber() << "_" << Id; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 916 | } |
| 917 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 918 | void ARMAsmPrinter::printRegisterList(const MachineInstr *MI, int OpNum, |
| 919 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 920 | O << "{"; |
Bob Wilson | 815baeb | 2010-03-13 01:08:20 +0000 | [diff] [blame] | 921 | for (unsigned i = OpNum, e = MI->getNumOperands(); i != e; ++i) { |
Evan Cheng | 4b322e5 | 2009-08-11 21:11:32 +0000 | [diff] [blame] | 922 | if (MI->getOperand(i).isImplicit()) |
| 923 | continue; |
Bob Wilson | 815baeb | 2010-03-13 01:08:20 +0000 | [diff] [blame] | 924 | if ((int)i != OpNum) O << ", "; |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 925 | printOperand(MI, i, O); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 926 | } |
| 927 | O << "}"; |
| 928 | } |
| 929 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 930 | void ARMAsmPrinter::printCPInstOperand(const MachineInstr *MI, int OpNum, |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 931 | raw_ostream &O, const char *Modifier) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 932 | assert(Modifier && "This operand only works with a modifier!"); |
| 933 | // There are two aspects to a CONSTANTPOOL_ENTRY operand, the label and the |
| 934 | // data itself. |
| 935 | if (!strcmp(Modifier, "label")) { |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 936 | unsigned ID = MI->getOperand(OpNum).getImm(); |
Chris Lattner | 8e089a9 | 2010-02-10 00:36:00 +0000 | [diff] [blame] | 937 | OutStreamer.EmitLabel(GetCPISymbol(ID)); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 938 | } else { |
| 939 | assert(!strcmp(Modifier, "cpentry") && "Unknown modifier for CPE"); |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 940 | unsigned CPI = MI->getOperand(OpNum).getIndex(); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 941 | |
Evan Cheng | 6d63a72 | 2008-09-18 07:27:23 +0000 | [diff] [blame] | 942 | const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPI]; |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 943 | |
Evan Cheng | 711b6dc | 2008-08-08 06:56:16 +0000 | [diff] [blame] | 944 | if (MCPE.isMachineConstantPoolEntry()) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 945 | EmitMachineConstantPoolValue(MCPE.Val.MachineCPVal); |
Evan Cheng | 711b6dc | 2008-08-08 06:56:16 +0000 | [diff] [blame] | 946 | } else { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 947 | EmitGlobalConstant(MCPE.Val.ConstVal); |
Lauro Ramos Venancio | 305b8a5 | 2007-04-25 14:50:40 +0000 | [diff] [blame] | 948 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 949 | } |
| 950 | } |
| 951 | |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 952 | MCSymbol *ARMAsmPrinter:: |
| 953 | GetARMSetPICJumpTableLabel2(unsigned uid, unsigned uid2, |
| 954 | const MachineBasicBlock *MBB) const { |
| 955 | SmallString<60> Name; |
| 956 | raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() |
Chris Lattner | bfcb096 | 2010-01-25 19:39:52 +0000 | [diff] [blame] | 957 | << getFunctionNumber() << '_' << uid << '_' << uid2 |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 958 | << "_set_" << MBB->getNumber(); |
Chris Lattner | 9b97a73 | 2010-03-30 18:10:53 +0000 | [diff] [blame] | 959 | return OutContext.GetOrCreateSymbol(Name.str()); |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 960 | } |
| 961 | |
| 962 | MCSymbol *ARMAsmPrinter:: |
| 963 | GetARMJTIPICJumpTableLabel2(unsigned uid, unsigned uid2) const { |
| 964 | SmallString<60> Name; |
| 965 | raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() << "JTI" |
Chris Lattner | 281e776 | 2010-01-25 23:28:03 +0000 | [diff] [blame] | 966 | << getFunctionNumber() << '_' << uid << '_' << uid2; |
Chris Lattner | 9b97a73 | 2010-03-30 18:10:53 +0000 | [diff] [blame] | 967 | return OutContext.GetOrCreateSymbol(Name.str()); |
Chris Lattner | bfcb096 | 2010-01-25 19:39:52 +0000 | [diff] [blame] | 968 | } |
| 969 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 970 | void ARMAsmPrinter::printJTBlockOperand(const MachineInstr *MI, int OpNum, |
| 971 | raw_ostream &O) { |
Evan Cheng | 66ac531 | 2009-07-25 00:33:29 +0000 | [diff] [blame] | 972 | assert(!Subtarget->isThumb2() && "Thumb2 should use double-jump jumptables!"); |
| 973 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 974 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 975 | const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id |
Chris Lattner | 1b46f43 | 2010-01-23 07:00:21 +0000 | [diff] [blame] | 976 | |
Chris Lattner | 8aa797a | 2007-12-30 23:10:15 +0000 | [diff] [blame] | 977 | unsigned JTI = MO1.getIndex(); |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 978 | MCSymbol *JTISymbol = GetARMJTIPICJumpTableLabel2(JTI, MO2.getImm()); |
Chris Lattner | 0333535 | 2010-04-05 17:52:31 +0000 | [diff] [blame] | 979 | // Can't use EmitLabel until instprinter happens, label comes out in the wrong |
| 980 | // order. |
Bob Wilson | d4d188e | 2010-07-31 06:28:10 +0000 | [diff] [blame] | 981 | O << "\n" << *JTISymbol << ":\n"; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 982 | |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 983 | const char *JTEntryDirective = MAI->getData32bitsDirective(); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 984 | |
Dan Gohman | 4542611 | 2008-07-07 20:06:06 +0000 | [diff] [blame] | 985 | const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 986 | const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); |
| 987 | const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; |
Chris Lattner | cee6332 | 2010-01-26 20:40:54 +0000 | [diff] [blame] | 988 | bool UseSet= MAI->hasSetDirective() && TM.getRelocationModel() == Reloc::PIC_; |
Evan Cheng | c324ecb | 2009-07-24 18:19:46 +0000 | [diff] [blame] | 989 | SmallPtrSet<MachineBasicBlock*, 8> JTSets; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 990 | for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) { |
| 991 | MachineBasicBlock *MBB = JTBBs[i]; |
Evan Cheng | 66ac531 | 2009-07-25 00:33:29 +0000 | [diff] [blame] | 992 | bool isNew = JTSets.insert(MBB); |
| 993 | |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 994 | if (UseSet && isNew) { |
Chris Lattner | cee6332 | 2010-01-26 20:40:54 +0000 | [diff] [blame] | 995 | O << "\t.set\t" |
Jim Grosbach | 1f9b48a | 2010-01-25 23:50:13 +0000 | [diff] [blame] | 996 | << *GetARMSetPICJumpTableLabel2(JTI, MO2.getImm(), MBB) << ',' |
Chris Lattner | 1b2eb0e | 2010-03-13 21:04:28 +0000 | [diff] [blame] | 997 | << *MBB->getSymbol() << '-' << *JTISymbol << '\n'; |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 998 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 999 | |
| 1000 | O << JTEntryDirective << ' '; |
| 1001 | if (UseSet) |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 1002 | O << *GetARMSetPICJumpTableLabel2(JTI, MO2.getImm(), MBB); |
| 1003 | else if (TM.getRelocationModel() == Reloc::PIC_) |
Chris Lattner | 1b2eb0e | 2010-03-13 21:04:28 +0000 | [diff] [blame] | 1004 | O << *MBB->getSymbol() << '-' << *JTISymbol; |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 1005 | else |
Chris Lattner | 1b2eb0e | 2010-03-13 21:04:28 +0000 | [diff] [blame] | 1006 | O << *MBB->getSymbol(); |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 1007 | |
Evan Cheng | d85ac4d | 2007-01-27 02:29:45 +0000 | [diff] [blame] | 1008 | if (i != e-1) |
| 1009 | O << '\n'; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1010 | } |
| 1011 | } |
| 1012 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1013 | void ARMAsmPrinter::printJT2BlockOperand(const MachineInstr *MI, int OpNum, |
| 1014 | raw_ostream &O) { |
Evan Cheng | 66ac531 | 2009-07-25 00:33:29 +0000 | [diff] [blame] | 1015 | const MachineOperand &MO1 = MI->getOperand(OpNum); |
| 1016 | const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id |
| 1017 | unsigned JTI = MO1.getIndex(); |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 1018 | |
| 1019 | MCSymbol *JTISymbol = GetARMJTIPICJumpTableLabel2(JTI, MO2.getImm()); |
Chris Lattner | 0333535 | 2010-04-05 17:52:31 +0000 | [diff] [blame] | 1020 | |
| 1021 | // Can't use EmitLabel until instprinter happens, label comes out in the wrong |
| 1022 | // order. |
Bob Wilson | d4d188e | 2010-07-31 06:28:10 +0000 | [diff] [blame] | 1023 | O << "\n" << *JTISymbol << ":\n"; |
Evan Cheng | 66ac531 | 2009-07-25 00:33:29 +0000 | [diff] [blame] | 1024 | |
Evan Cheng | 66ac531 | 2009-07-25 00:33:29 +0000 | [diff] [blame] | 1025 | const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); |
| 1026 | const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); |
| 1027 | const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; |
Evan Cheng | 5657c01 | 2009-07-29 02:18:14 +0000 | [diff] [blame] | 1028 | bool ByteOffset = false, HalfWordOffset = false; |
| 1029 | if (MI->getOpcode() == ARM::t2TBB) |
| 1030 | ByteOffset = true; |
| 1031 | else if (MI->getOpcode() == ARM::t2TBH) |
| 1032 | HalfWordOffset = true; |
| 1033 | |
Evan Cheng | 66ac531 | 2009-07-25 00:33:29 +0000 | [diff] [blame] | 1034 | for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) { |
| 1035 | MachineBasicBlock *MBB = JTBBs[i]; |
Evan Cheng | 5657c01 | 2009-07-29 02:18:14 +0000 | [diff] [blame] | 1036 | if (ByteOffset) |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 1037 | O << MAI->getData8bitsDirective(); |
Evan Cheng | 5657c01 | 2009-07-29 02:18:14 +0000 | [diff] [blame] | 1038 | else if (HalfWordOffset) |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 1039 | O << MAI->getData16bitsDirective(); |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 1040 | |
| 1041 | if (ByteOffset || HalfWordOffset) |
Chris Lattner | 1b2eb0e | 2010-03-13 21:04:28 +0000 | [diff] [blame] | 1042 | O << '(' << *MBB->getSymbol() << "-" << *JTISymbol << ")/2"; |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 1043 | else |
Chris Lattner | 1b2eb0e | 2010-03-13 21:04:28 +0000 | [diff] [blame] | 1044 | O << "\tb.w " << *MBB->getSymbol(); |
Chris Lattner | 0890cf1 | 2010-01-25 19:51:38 +0000 | [diff] [blame] | 1045 | |
Evan Cheng | 66ac531 | 2009-07-25 00:33:29 +0000 | [diff] [blame] | 1046 | if (i != e-1) |
| 1047 | O << '\n'; |
| 1048 | } |
| 1049 | } |
| 1050 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1051 | void ARMAsmPrinter::printTBAddrMode(const MachineInstr *MI, int OpNum, |
| 1052 | raw_ostream &O) { |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 1053 | O << "[pc, " << getRegisterName(MI->getOperand(OpNum).getReg()); |
Evan Cheng | 5657c01 | 2009-07-29 02:18:14 +0000 | [diff] [blame] | 1054 | if (MI->getOpcode() == ARM::t2TBH) |
| 1055 | O << ", lsl #1"; |
| 1056 | O << ']'; |
| 1057 | } |
| 1058 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1059 | void ARMAsmPrinter::printNoHashImmediate(const MachineInstr *MI, int OpNum, |
| 1060 | raw_ostream &O) { |
Anton Korobeynikov | 8e9ece7 | 2009-08-08 23:10:41 +0000 | [diff] [blame] | 1061 | O << MI->getOperand(OpNum).getImm(); |
| 1062 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1063 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1064 | void ARMAsmPrinter::printVFPf32ImmOperand(const MachineInstr *MI, int OpNum, |
| 1065 | raw_ostream &O) { |
Evan Cheng | 3938242 | 2009-10-28 01:44:26 +0000 | [diff] [blame] | 1066 | const ConstantFP *FP = MI->getOperand(OpNum).getFPImm(); |
Jim Grosbach | 77b02be | 2009-11-23 21:08:25 +0000 | [diff] [blame] | 1067 | O << '#' << FP->getValueAPF().convertToFloat(); |
Chris Lattner | 3f53c83 | 2010-04-04 18:52:31 +0000 | [diff] [blame] | 1068 | if (isVerbose()) { |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1069 | O << "\t\t" << MAI->getCommentString() << ' '; |
Evan Cheng | 3938242 | 2009-10-28 01:44:26 +0000 | [diff] [blame] | 1070 | WriteAsOperand(O, FP, /*PrintType=*/false); |
| 1071 | } |
| 1072 | } |
| 1073 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1074 | void ARMAsmPrinter::printVFPf64ImmOperand(const MachineInstr *MI, int OpNum, |
| 1075 | raw_ostream &O) { |
Evan Cheng | 3938242 | 2009-10-28 01:44:26 +0000 | [diff] [blame] | 1076 | const ConstantFP *FP = MI->getOperand(OpNum).getFPImm(); |
Jim Grosbach | 77b02be | 2009-11-23 21:08:25 +0000 | [diff] [blame] | 1077 | O << '#' << FP->getValueAPF().convertToDouble(); |
Chris Lattner | 3f53c83 | 2010-04-04 18:52:31 +0000 | [diff] [blame] | 1078 | if (isVerbose()) { |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1079 | O << "\t\t" << MAI->getCommentString() << ' '; |
Evan Cheng | 3938242 | 2009-10-28 01:44:26 +0000 | [diff] [blame] | 1080 | WriteAsOperand(O, FP, /*PrintType=*/false); |
| 1081 | } |
| 1082 | } |
| 1083 | |
Bob Wilson | 1a913ed | 2010-06-11 21:34:50 +0000 | [diff] [blame] | 1084 | void ARMAsmPrinter::printNEONModImmOperand(const MachineInstr *MI, int OpNum, |
| 1085 | raw_ostream &O) { |
Bob Wilson | 6dce00c | 2010-07-13 04:44:34 +0000 | [diff] [blame] | 1086 | unsigned EncodedImm = MI->getOperand(OpNum).getImm(); |
| 1087 | unsigned EltBits; |
| 1088 | uint64_t Val = ARM_AM::decodeNEONModImm(EncodedImm, EltBits); |
Bob Wilson | 1a913ed | 2010-06-11 21:34:50 +0000 | [diff] [blame] | 1089 | O << "#0x" << utohexstr(Val); |
| 1090 | } |
| 1091 | |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 1092 | bool ARMAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNum, |
Chris Lattner | c75c028 | 2010-04-04 05:29:35 +0000 | [diff] [blame] | 1093 | unsigned AsmVariant, const char *ExtraCode, |
| 1094 | raw_ostream &O) { |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1095 | // Does this asm operand have a single letter operand modifier? |
| 1096 | if (ExtraCode && ExtraCode[0]) { |
| 1097 | if (ExtraCode[1] != 0) return true; // Unknown modifier. |
Anton Korobeynikov | 8e9ece7 | 2009-08-08 23:10:41 +0000 | [diff] [blame] | 1098 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1099 | switch (ExtraCode[0]) { |
| 1100 | default: return true; // Unknown modifier. |
Bob Wilson | 9b4b00a | 2009-07-09 23:54:51 +0000 | [diff] [blame] | 1101 | case 'a': // Print as a memory address. |
| 1102 | if (MI->getOperand(OpNum).isReg()) { |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 1103 | O << "[" << getRegisterName(MI->getOperand(OpNum).getReg()) << "]"; |
Bob Wilson | 9b4b00a | 2009-07-09 23:54:51 +0000 | [diff] [blame] | 1104 | return false; |
| 1105 | } |
| 1106 | // Fallthrough |
| 1107 | case 'c': // Don't print "#" before an immediate operand. |
Bob Wilson | 4f38b38 | 2009-08-21 21:58:55 +0000 | [diff] [blame] | 1108 | if (!MI->getOperand(OpNum).isImm()) |
| 1109 | return true; |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1110 | printNoHashImmediate(MI, OpNum, O); |
Bob Wilson | 8f34346 | 2009-04-06 21:46:51 +0000 | [diff] [blame] | 1111 | return false; |
Evan Cheng | e21e396 | 2007-04-04 00:13:29 +0000 | [diff] [blame] | 1112 | case 'P': // Print a VFP double precision register. |
Evan Cheng | d831cda | 2009-12-08 23:06:22 +0000 | [diff] [blame] | 1113 | case 'q': // Print a NEON quad precision register. |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1114 | printOperand(MI, OpNum, O); |
Evan Cheng | 23a9570 | 2007-03-08 22:42:46 +0000 | [diff] [blame] | 1115 | return false; |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1116 | case 'Q': |
Bob Wilson | d984eb6 | 2010-05-27 20:23:42 +0000 | [diff] [blame] | 1117 | case 'R': |
Bob Wilson | d984eb6 | 2010-05-27 20:23:42 +0000 | [diff] [blame] | 1118 | case 'H': |
Evan Cheng | 1261672 | 2010-05-27 23:45:31 +0000 | [diff] [blame] | 1119 | report_fatal_error("llvm does not support 'Q', 'R', and 'H' modifiers!"); |
Bob Wilson | d984eb6 | 2010-05-27 20:23:42 +0000 | [diff] [blame] | 1120 | return true; |
Evan Cheng | 84f60b7 | 2010-05-27 22:08:38 +0000 | [diff] [blame] | 1121 | } |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1122 | } |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 1123 | |
Chris Lattner | 35c33bd | 2010-04-04 04:47:45 +0000 | [diff] [blame] | 1124 | printOperand(MI, OpNum, O); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1125 | return false; |
| 1126 | } |
| 1127 | |
Bob Wilson | 224c244 | 2009-05-19 05:53:42 +0000 | [diff] [blame] | 1128 | bool ARMAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, |
Evan Cheng | 055b031 | 2009-06-29 07:51:04 +0000 | [diff] [blame] | 1129 | unsigned OpNum, unsigned AsmVariant, |
Chris Lattner | c75c028 | 2010-04-04 05:29:35 +0000 | [diff] [blame] | 1130 | const char *ExtraCode, |
| 1131 | raw_ostream &O) { |
Bob Wilson | 224c244 | 2009-05-19 05:53:42 +0000 | [diff] [blame] | 1132 | if (ExtraCode && ExtraCode[0]) |
| 1133 | return true; // Unknown modifier. |
Bob Wilson | 765cc0b | 2009-10-13 20:50:28 +0000 | [diff] [blame] | 1134 | |
| 1135 | const MachineOperand &MO = MI->getOperand(OpNum); |
| 1136 | assert(MO.isReg() && "unexpected inline asm memory operand"); |
| 1137 | O << "[" << getRegisterName(MO.getReg()) << "]"; |
Bob Wilson | 224c244 | 2009-05-19 05:53:42 +0000 | [diff] [blame] | 1138 | return false; |
| 1139 | } |
| 1140 | |
Chris Lattner | a786cea | 2010-01-28 01:10:34 +0000 | [diff] [blame] | 1141 | void ARMAsmPrinter::EmitInstruction(const MachineInstr *MI) { |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 1142 | if (EnableMCInst) { |
| 1143 | printInstructionThroughMCStreamer(MI); |
Chris Lattner | 7ad07c4 | 2010-04-04 06:12:20 +0000 | [diff] [blame] | 1144 | return; |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 1145 | } |
Chris Lattner | 7ad07c4 | 2010-04-04 06:12:20 +0000 | [diff] [blame] | 1146 | |
| 1147 | if (MI->getOpcode() == ARM::CONSTPOOL_ENTRY) |
| 1148 | EmitAlignment(2); |
| 1149 | |
| 1150 | SmallString<128> Str; |
| 1151 | raw_svector_ostream OS(Str); |
Dale Johannesen | 3f282aa | 2010-04-26 20:07:31 +0000 | [diff] [blame] | 1152 | if (MI->getOpcode() == ARM::DBG_VALUE) { |
| 1153 | unsigned NOps = MI->getNumOperands(); |
| 1154 | assert(NOps==4); |
| 1155 | OS << '\t' << MAI->getCommentString() << "DEBUG_VALUE: "; |
| 1156 | // cast away const; DIetc do not take const operands for some reason. |
| 1157 | DIVariable V(const_cast<MDNode *>(MI->getOperand(NOps-1).getMetadata())); |
| 1158 | OS << V.getName(); |
| 1159 | OS << " <- "; |
| 1160 | // Frame address. Currently handles register +- offset only. |
| 1161 | assert(MI->getOperand(0).isReg() && MI->getOperand(1).isImm()); |
| 1162 | OS << '['; printOperand(MI, 0, OS); OS << '+'; printOperand(MI, 1, OS); |
| 1163 | OS << ']'; |
| 1164 | OS << "+"; |
| 1165 | printOperand(MI, NOps-2, OS); |
| 1166 | OutStreamer.EmitRawText(OS.str()); |
| 1167 | return; |
| 1168 | } |
| 1169 | |
Chris Lattner | 7ad07c4 | 2010-04-04 06:12:20 +0000 | [diff] [blame] | 1170 | printInstruction(MI, OS); |
| 1171 | OutStreamer.EmitRawText(OS.str()); |
| 1172 | |
| 1173 | // Make sure the instruction that follows TBB is 2-byte aligned. |
| 1174 | // FIXME: Constant island pass should insert an "ALIGN" instruction instead. |
| 1175 | if (MI->getOpcode() == ARM::t2TBB) |
| 1176 | EmitAlignment(1); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1177 | } |
| 1178 | |
Bob Wilson | 812209a | 2009-09-30 22:06:26 +0000 | [diff] [blame] | 1179 | void ARMAsmPrinter::EmitStartOfAsmFile(Module &M) { |
Bob Wilson | 0fb3468 | 2009-09-30 00:23:42 +0000 | [diff] [blame] | 1180 | if (Subtarget->isTargetDarwin()) { |
| 1181 | Reloc::Model RelocM = TM.getRelocationModel(); |
| 1182 | if (RelocM == Reloc::PIC_ || RelocM == Reloc::DynamicNoPIC) { |
| 1183 | // Declare all the text sections up front (before the DWARF sections |
| 1184 | // emitted by AsmPrinter::doInitialization) so the assembler will keep |
| 1185 | // them together at the beginning of the object file. This helps |
| 1186 | // avoid out-of-range branches that are due a fundamental limitation of |
| 1187 | // the way symbol offsets are encoded with the current Darwin ARM |
| 1188 | // relocations. |
Dan Gohman | 0d805c3 | 2010-04-17 16:44:48 +0000 | [diff] [blame] | 1189 | const TargetLoweringObjectFileMachO &TLOFMacho = |
| 1190 | static_cast<const TargetLoweringObjectFileMachO &>( |
| 1191 | getObjFileLowering()); |
Bob Wilson | 29e0669 | 2009-09-30 22:25:37 +0000 | [diff] [blame] | 1192 | OutStreamer.SwitchSection(TLOFMacho.getTextSection()); |
| 1193 | OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection()); |
| 1194 | OutStreamer.SwitchSection(TLOFMacho.getConstTextCoalSection()); |
| 1195 | if (RelocM == Reloc::DynamicNoPIC) { |
| 1196 | const MCSection *sect = |
Chris Lattner | 2277221 | 2010-04-08 20:40:11 +0000 | [diff] [blame] | 1197 | OutContext.getMachOSection("__TEXT", "__symbol_stub4", |
| 1198 | MCSectionMachO::S_SYMBOL_STUBS, |
| 1199 | 12, SectionKind::getText()); |
Bob Wilson | 29e0669 | 2009-09-30 22:25:37 +0000 | [diff] [blame] | 1200 | OutStreamer.SwitchSection(sect); |
| 1201 | } else { |
| 1202 | const MCSection *sect = |
Chris Lattner | 2277221 | 2010-04-08 20:40:11 +0000 | [diff] [blame] | 1203 | OutContext.getMachOSection("__TEXT", "__picsymbolstub4", |
| 1204 | MCSectionMachO::S_SYMBOL_STUBS, |
| 1205 | 16, SectionKind::getText()); |
Bob Wilson | 29e0669 | 2009-09-30 22:25:37 +0000 | [diff] [blame] | 1206 | OutStreamer.SwitchSection(sect); |
| 1207 | } |
Bob Wilson | 63db594 | 2010-07-30 19:55:47 +0000 | [diff] [blame] | 1208 | const MCSection *StaticInitSect = |
| 1209 | OutContext.getMachOSection("__TEXT", "__StaticInit", |
| 1210 | MCSectionMachO::S_REGULAR | |
| 1211 | MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, |
| 1212 | SectionKind::getText()); |
| 1213 | OutStreamer.SwitchSection(StaticInitSect); |
Bob Wilson | 0fb3468 | 2009-09-30 00:23:42 +0000 | [diff] [blame] | 1214 | } |
| 1215 | } |
| 1216 | |
Jim Grosbach | e516549 | 2009-11-09 00:11:35 +0000 | [diff] [blame] | 1217 | // Use unified assembler syntax. |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1218 | OutStreamer.EmitRawText(StringRef("\t.syntax unified")); |
Anton Korobeynikov | d61eca5 | 2009-06-17 23:43:18 +0000 | [diff] [blame] | 1219 | |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 1220 | // Emit ARM Build Attributes |
| 1221 | if (Subtarget->isTargetELF()) { |
| 1222 | // CPU Type |
Anton Korobeynikov | d260c24 | 2009-06-01 19:03:17 +0000 | [diff] [blame] | 1223 | std::string CPUString = Subtarget->getCPUString(); |
| 1224 | if (CPUString != "generic") |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1225 | OutStreamer.EmitRawText("\t.cpu " + Twine(CPUString)); |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 1226 | |
| 1227 | // FIXME: Emit FPU type |
| 1228 | if (Subtarget->hasVFP2()) |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1229 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1230 | Twine(ARMBuildAttrs::VFP_arch) + ", 2"); |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 1231 | |
| 1232 | // Signal various FP modes. |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1233 | if (!UnsafeFPMath) { |
| 1234 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1235 | Twine(ARMBuildAttrs::ABI_FP_denormal) + ", 1"); |
| 1236 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1237 | Twine(ARMBuildAttrs::ABI_FP_exceptions) + ", 1"); |
| 1238 | } |
| 1239 | |
Evan Cheng | 60108e9 | 2010-07-15 22:07:12 +0000 | [diff] [blame] | 1240 | if (NoInfsFPMath && NoNaNsFPMath) |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1241 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1242 | Twine(ARMBuildAttrs::ABI_FP_number_model)+ ", 1"); |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 1243 | else |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1244 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1245 | Twine(ARMBuildAttrs::ABI_FP_number_model)+ ", 3"); |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 1246 | |
| 1247 | // 8-bytes alignment stuff. |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1248 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1249 | Twine(ARMBuildAttrs::ABI_align8_needed) + ", 1"); |
| 1250 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1251 | Twine(ARMBuildAttrs::ABI_align8_preserved) + ", 1"); |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 1252 | |
Anton Korobeynikov | 567d14f | 2009-08-05 19:04:42 +0000 | [diff] [blame] | 1253 | // Hard float. Use both S and D registers and conform to AAPCS-VFP. |
Chris Lattner | 9d7efd3 | 2010-04-04 07:05:53 +0000 | [diff] [blame] | 1254 | if (Subtarget->isAAPCS_ABI() && FloatABIType == FloatABI::Hard) { |
| 1255 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1256 | Twine(ARMBuildAttrs::ABI_HardFP_use) + ", 3"); |
| 1257 | OutStreamer.EmitRawText("\t.eabi_attribute " + |
| 1258 | Twine(ARMBuildAttrs::ABI_VFP_args) + ", 1"); |
| 1259 | } |
Anton Korobeynikov | 88ce667 | 2009-05-23 19:51:20 +0000 | [diff] [blame] | 1260 | // FIXME: Should we signal R9 usage? |
| 1261 | } |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 1262 | } |
| 1263 | |
Anton Korobeynikov | 0f3cc65 | 2008-08-07 09:54:23 +0000 | [diff] [blame] | 1264 | |
Chris Lattner | 4a071d6 | 2009-10-19 17:59:19 +0000 | [diff] [blame] | 1265 | void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) { |
Evan Cheng | 5be54b0 | 2007-01-19 19:25:36 +0000 | [diff] [blame] | 1266 | if (Subtarget->isTargetDarwin()) { |
Chris Lattner | f61159b | 2009-08-03 22:18:15 +0000 | [diff] [blame] | 1267 | // All darwin targets use mach-o. |
Dan Gohman | 0d805c3 | 2010-04-17 16:44:48 +0000 | [diff] [blame] | 1268 | const TargetLoweringObjectFileMachO &TLOFMacho = |
| 1269 | static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering()); |
Chris Lattner | b0f294c | 2009-10-19 18:38:33 +0000 | [diff] [blame] | 1270 | MachineModuleInfoMachO &MMIMacho = |
| 1271 | MMI->getObjFileInfo<MachineModuleInfoMachO>(); |
Jim Grosbach | e995221 | 2009-09-04 01:38:51 +0000 | [diff] [blame] | 1272 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1273 | // Output non-lazy-pointers for external and common global variables. |
Chris Lattner | b0f294c | 2009-10-19 18:38:33 +0000 | [diff] [blame] | 1274 | MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetGVStubList(); |
Bill Wendling | cebae36 | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 1275 | |
Chris Lattner | b0f294c | 2009-10-19 18:38:33 +0000 | [diff] [blame] | 1276 | if (!Stubs.empty()) { |
Chris Lattner | ff4bc46 | 2009-08-10 01:39:42 +0000 | [diff] [blame] | 1277 | // Switch with ".non_lazy_symbol_pointer" directive. |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 1278 | OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection()); |
Chris Lattner | c076a97 | 2009-08-10 18:01:34 +0000 | [diff] [blame] | 1279 | EmitAlignment(2); |
Chris Lattner | b0f294c | 2009-10-19 18:38:33 +0000 | [diff] [blame] | 1280 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
Bill Wendling | becd83e | 2010-03-09 00:40:17 +0000 | [diff] [blame] | 1281 | // L_foo$stub: |
| 1282 | OutStreamer.EmitLabel(Stubs[i].first); |
| 1283 | // .indirect_symbol _foo |
Bill Wendling | 52a50e5 | 2010-03-11 01:18:13 +0000 | [diff] [blame] | 1284 | MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second; |
| 1285 | OutStreamer.EmitSymbolAttribute(MCSym.getPointer(),MCSA_IndirectSymbol); |
Bill Wendling | cf6f28d | 2010-03-09 00:43:34 +0000 | [diff] [blame] | 1286 | |
Bill Wendling | 52a50e5 | 2010-03-11 01:18:13 +0000 | [diff] [blame] | 1287 | if (MCSym.getInt()) |
Bill Wendling | cf6f28d | 2010-03-09 00:43:34 +0000 | [diff] [blame] | 1288 | // External to current translation unit. |
| 1289 | OutStreamer.EmitIntValue(0, 4/*size*/, 0/*addrspace*/); |
| 1290 | else |
| 1291 | // Internal to current translation unit. |
Bill Wendling | 5e1b55d | 2010-03-31 18:47:10 +0000 | [diff] [blame] | 1292 | // |
| 1293 | // When we place the LSDA into the TEXT section, the type info pointers |
| 1294 | // need to be indirect and pc-rel. We accomplish this by using NLPs. |
| 1295 | // However, sometimes the types are local to the file. So we need to |
| 1296 | // fill in the value for the NLP in those cases. |
Bill Wendling | 52a50e5 | 2010-03-11 01:18:13 +0000 | [diff] [blame] | 1297 | OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(), |
| 1298 | OutContext), |
Bill Wendling | cf6f28d | 2010-03-09 00:43:34 +0000 | [diff] [blame] | 1299 | 4/*size*/, 0/*addrspace*/); |
Evan Cheng | ae94e59 | 2008-12-05 01:06:39 +0000 | [diff] [blame] | 1300 | } |
Bill Wendling | becd83e | 2010-03-09 00:40:17 +0000 | [diff] [blame] | 1301 | |
| 1302 | Stubs.clear(); |
| 1303 | OutStreamer.AddBlankLine(); |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1304 | } |
| 1305 | |
Chris Lattner | e4d9ea8 | 2009-10-19 18:44:38 +0000 | [diff] [blame] | 1306 | Stubs = MMIMacho.GetHiddenGVStubList(); |
| 1307 | if (!Stubs.empty()) { |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 1308 | OutStreamer.SwitchSection(getObjFileLowering().getDataSection()); |
Chris Lattner | f3231de | 2009-08-10 18:02:16 +0000 | [diff] [blame] | 1309 | EmitAlignment(2); |
Bill Wendling | becd83e | 2010-03-09 00:40:17 +0000 | [diff] [blame] | 1310 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
| 1311 | // L_foo$stub: |
| 1312 | OutStreamer.EmitLabel(Stubs[i].first); |
| 1313 | // .long _foo |
Bill Wendling | cebae36 | 2010-03-10 22:34:10 +0000 | [diff] [blame] | 1314 | OutStreamer.EmitValue(MCSymbolRefExpr:: |
| 1315 | Create(Stubs[i].second.getPointer(), |
| 1316 | OutContext), |
Bill Wendling | becd83e | 2010-03-09 00:40:17 +0000 | [diff] [blame] | 1317 | 4/*size*/, 0/*addrspace*/); |
| 1318 | } |
Bill Wendling | cf6f28d | 2010-03-09 00:43:34 +0000 | [diff] [blame] | 1319 | |
| 1320 | Stubs.clear(); |
| 1321 | OutStreamer.AddBlankLine(); |
Evan Cheng | ae94e59 | 2008-12-05 01:06:39 +0000 | [diff] [blame] | 1322 | } |
| 1323 | |
Evan Cheng | a8e2989 | 2007-01-19 07:51:42 +0000 | [diff] [blame] | 1324 | // Funny Darwin hack: This flag tells the linker that no global symbols |
| 1325 | // contain code that falls through to other global symbols (e.g. the obvious |
| 1326 | // implementation of multiple entry points). If this doesn't occur, the |
| 1327 | // linker can safely perform dead code stripping. Since LLVM never |
| 1328 | // generates code that does this, it is always safe to set. |
Chris Lattner | a5ad93a | 2010-01-23 06:39:22 +0000 | [diff] [blame] | 1329 | OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols); |
Rafael Espindola | b01c4bb | 2006-07-27 11:38:51 +0000 | [diff] [blame] | 1330 | } |
Rafael Espindola | 7bc59bc | 2006-05-14 22:18:28 +0000 | [diff] [blame] | 1331 | } |
Anton Korobeynikov | 0bd8971 | 2008-08-17 13:55:10 +0000 | [diff] [blame] | 1332 | |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 1333 | //===----------------------------------------------------------------------===// |
| 1334 | |
| 1335 | void ARMAsmPrinter::printInstructionThroughMCStreamer(const MachineInstr *MI) { |
Chris Lattner | 96bc217 | 2009-10-20 00:52:47 +0000 | [diff] [blame] | 1336 | ARMMCInstLower MCInstLowering(OutContext, *Mang, *this); |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 1337 | switch (MI->getOpcode()) { |
Chris Lattner | c6b8a99 | 2009-10-20 05:58:02 +0000 | [diff] [blame] | 1338 | case ARM::t2MOVi32imm: |
| 1339 | assert(0 && "Should be lowered by thumb2it pass"); |
Chris Lattner | 4d15222 | 2009-10-19 22:23:04 +0000 | [diff] [blame] | 1340 | default: break; |
Chris Lattner | 4d15222 | 2009-10-19 22:23:04 +0000 | [diff] [blame] | 1341 | case ARM::PICADD: { // FIXME: Remove asm string from td file. |
| 1342 | // This is a pseudo op for a label + instruction sequence, which looks like: |
| 1343 | // LPC0: |
| 1344 | // add r0, pc, r0 |
| 1345 | // This adds the address of LPC0 to r0. |
| 1346 | |
| 1347 | // Emit the label. |
| 1348 | // FIXME: MOVE TO SHARED PLACE. |
Chris Lattner | a70e644 | 2009-10-19 22:33:05 +0000 | [diff] [blame] | 1349 | unsigned Id = (unsigned)MI->getOperand(2).getImm(); |
Chris Lattner | 7c5b021 | 2009-10-19 22:49:00 +0000 | [diff] [blame] | 1350 | const char *Prefix = MAI->getPrivateGlobalPrefix(); |
Chris Lattner | 9b97a73 | 2010-03-30 18:10:53 +0000 | [diff] [blame] | 1351 | MCSymbol *Label =OutContext.GetOrCreateSymbol(Twine(Prefix) |
Evan Cheng | e7e0d62 | 2009-11-06 22:24:13 +0000 | [diff] [blame] | 1352 | + "PC" + Twine(getFunctionNumber()) + "_" + Twine(Id)); |
Chris Lattner | 7c5b021 | 2009-10-19 22:49:00 +0000 | [diff] [blame] | 1353 | OutStreamer.EmitLabel(Label); |
Chris Lattner | 4d15222 | 2009-10-19 22:23:04 +0000 | [diff] [blame] | 1354 | |
| 1355 | |
| 1356 | // Form and emit tha dd. |
| 1357 | MCInst AddInst; |
| 1358 | AddInst.setOpcode(ARM::ADDrr); |
| 1359 | AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg())); |
| 1360 | AddInst.addOperand(MCOperand::CreateReg(ARM::PC)); |
| 1361 | AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg())); |
Chris Lattner | 850d2e2 | 2010-02-03 01:16:28 +0000 | [diff] [blame] | 1362 | OutStreamer.EmitInstruction(AddInst); |
Chris Lattner | 4d15222 | 2009-10-19 22:23:04 +0000 | [diff] [blame] | 1363 | return; |
| 1364 | } |
Chris Lattner | a70e644 | 2009-10-19 22:33:05 +0000 | [diff] [blame] | 1365 | case ARM::CONSTPOOL_ENTRY: { // FIXME: Remove asm string from td file. |
| 1366 | /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool |
| 1367 | /// in the function. The first operand is the ID# for this instruction, the |
| 1368 | /// second is the index into the MachineConstantPool that this is, the third |
| 1369 | /// is the size in bytes of this constant pool entry. |
| 1370 | unsigned LabelId = (unsigned)MI->getOperand(0).getImm(); |
| 1371 | unsigned CPIdx = (unsigned)MI->getOperand(1).getIndex(); |
| 1372 | |
| 1373 | EmitAlignment(2); |
Chris Lattner | 1b46f43 | 2010-01-23 07:00:21 +0000 | [diff] [blame] | 1374 | OutStreamer.EmitLabel(GetCPISymbol(LabelId)); |
Chris Lattner | a70e644 | 2009-10-19 22:33:05 +0000 | [diff] [blame] | 1375 | |
| 1376 | const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPIdx]; |
| 1377 | if (MCPE.isMachineConstantPoolEntry()) |
| 1378 | EmitMachineConstantPoolValue(MCPE.Val.MachineCPVal); |
| 1379 | else |
| 1380 | EmitGlobalConstant(MCPE.Val.ConstVal); |
| 1381 | |
| 1382 | return; |
| 1383 | } |
Chris Lattner | 017d947 | 2009-10-20 00:40:56 +0000 | [diff] [blame] | 1384 | case ARM::MOVi2pieces: { // FIXME: Remove asmstring from td file. |
| 1385 | // This is a hack that lowers as a two instruction sequence. |
| 1386 | unsigned DstReg = MI->getOperand(0).getReg(); |
| 1387 | unsigned ImmVal = (unsigned)MI->getOperand(1).getImm(); |
| 1388 | |
| 1389 | unsigned SOImmValV1 = ARM_AM::getSOImmTwoPartFirst(ImmVal); |
| 1390 | unsigned SOImmValV2 = ARM_AM::getSOImmTwoPartSecond(ImmVal); |
| 1391 | |
| 1392 | { |
| 1393 | MCInst TmpInst; |
| 1394 | TmpInst.setOpcode(ARM::MOVi); |
| 1395 | TmpInst.addOperand(MCOperand::CreateReg(DstReg)); |
| 1396 | TmpInst.addOperand(MCOperand::CreateImm(SOImmValV1)); |
| 1397 | |
| 1398 | // Predicate. |
| 1399 | TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm())); |
| 1400 | TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg())); |
Chris Lattner | 233917c | 2009-10-20 00:46:11 +0000 | [diff] [blame] | 1401 | |
| 1402 | TmpInst.addOperand(MCOperand::CreateReg(0)); // cc_out |
Chris Lattner | 850d2e2 | 2010-02-03 01:16:28 +0000 | [diff] [blame] | 1403 | OutStreamer.EmitInstruction(TmpInst); |
Chris Lattner | 017d947 | 2009-10-20 00:40:56 +0000 | [diff] [blame] | 1404 | } |
| 1405 | |
| 1406 | { |
| 1407 | MCInst TmpInst; |
| 1408 | TmpInst.setOpcode(ARM::ORRri); |
| 1409 | TmpInst.addOperand(MCOperand::CreateReg(DstReg)); // dstreg |
| 1410 | TmpInst.addOperand(MCOperand::CreateReg(DstReg)); // inreg |
| 1411 | TmpInst.addOperand(MCOperand::CreateImm(SOImmValV2)); // so_imm |
| 1412 | // Predicate. |
| 1413 | TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm())); |
| 1414 | TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg())); |
| 1415 | |
| 1416 | TmpInst.addOperand(MCOperand::CreateReg(0)); // cc_out |
Chris Lattner | 850d2e2 | 2010-02-03 01:16:28 +0000 | [diff] [blame] | 1417 | OutStreamer.EmitInstruction(TmpInst); |
Chris Lattner | 017d947 | 2009-10-20 00:40:56 +0000 | [diff] [blame] | 1418 | } |
| 1419 | return; |
| 1420 | } |
Chris Lattner | 161dcbf | 2009-10-20 01:11:37 +0000 | [diff] [blame] | 1421 | case ARM::MOVi32imm: { // FIXME: Remove asmstring from td file. |
| 1422 | // This is a hack that lowers as a two instruction sequence. |
| 1423 | unsigned DstReg = MI->getOperand(0).getReg(); |
Rafael Espindola | 18c1021 | 2010-05-12 05:16:34 +0000 | [diff] [blame] | 1424 | const MachineOperand &MO = MI->getOperand(1); |
| 1425 | MCOperand V1, V2; |
| 1426 | if (MO.isImm()) { |
| 1427 | unsigned ImmVal = (unsigned)MI->getOperand(1).getImm(); |
| 1428 | V1 = MCOperand::CreateImm(ImmVal & 65535); |
| 1429 | V2 = MCOperand::CreateImm(ImmVal >> 16); |
| 1430 | } else if (MO.isGlobal()) { |
| 1431 | MCSymbol *Symbol = MCInstLowering.GetGlobalAddressSymbol(MO); |
| 1432 | const MCSymbolRefExpr *SymRef1 = |
Duncan Sands | 3472766 | 2010-07-12 08:16:59 +0000 | [diff] [blame] | 1433 | MCSymbolRefExpr::Create(Symbol, |
| 1434 | MCSymbolRefExpr::VK_ARM_LO16, OutContext); |
Rafael Espindola | 18c1021 | 2010-05-12 05:16:34 +0000 | [diff] [blame] | 1435 | const MCSymbolRefExpr *SymRef2 = |
Duncan Sands | 3472766 | 2010-07-12 08:16:59 +0000 | [diff] [blame] | 1436 | MCSymbolRefExpr::Create(Symbol, |
| 1437 | MCSymbolRefExpr::VK_ARM_HI16, OutContext); |
Rafael Espindola | 18c1021 | 2010-05-12 05:16:34 +0000 | [diff] [blame] | 1438 | V1 = MCOperand::CreateExpr(SymRef1); |
| 1439 | V2 = MCOperand::CreateExpr(SymRef2); |
| 1440 | } else { |
| 1441 | MI->dump(); |
| 1442 | llvm_unreachable("cannot handle this operand"); |
| 1443 | } |
| 1444 | |
Chris Lattner | 161dcbf | 2009-10-20 01:11:37 +0000 | [diff] [blame] | 1445 | { |
| 1446 | MCInst TmpInst; |
| 1447 | TmpInst.setOpcode(ARM::MOVi16); |
| 1448 | TmpInst.addOperand(MCOperand::CreateReg(DstReg)); // dstreg |
Rafael Espindola | 18c1021 | 2010-05-12 05:16:34 +0000 | [diff] [blame] | 1449 | TmpInst.addOperand(V1); // lower16(imm) |
Chris Lattner | 017d947 | 2009-10-20 00:40:56 +0000 | [diff] [blame] | 1450 | |
Chris Lattner | 161dcbf | 2009-10-20 01:11:37 +0000 | [diff] [blame] | 1451 | // Predicate. |
| 1452 | TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm())); |
| 1453 | TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg())); |
| 1454 | |
Chris Lattner | 850d2e2 | 2010-02-03 01:16:28 +0000 | [diff] [blame] | 1455 | OutStreamer.EmitInstruction(TmpInst); |
Chris Lattner | 161dcbf | 2009-10-20 01:11:37 +0000 | [diff] [blame] | 1456 | } |
| 1457 | |
| 1458 | { |
| 1459 | MCInst TmpInst; |
| 1460 | TmpInst.setOpcode(ARM::MOVTi16); |
| 1461 | TmpInst.addOperand(MCOperand::CreateReg(DstReg)); // dstreg |
| 1462 | TmpInst.addOperand(MCOperand::CreateReg(DstReg)); // srcreg |
Rafael Espindola | 18c1021 | 2010-05-12 05:16:34 +0000 | [diff] [blame] | 1463 | TmpInst.addOperand(V2); // upper16(imm) |
Chris Lattner | 161dcbf | 2009-10-20 01:11:37 +0000 | [diff] [blame] | 1464 | |
| 1465 | // Predicate. |
| 1466 | TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm())); |
| 1467 | TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg())); |
| 1468 | |
Chris Lattner | 850d2e2 | 2010-02-03 01:16:28 +0000 | [diff] [blame] | 1469 | OutStreamer.EmitInstruction(TmpInst); |
Chris Lattner | 161dcbf | 2009-10-20 01:11:37 +0000 | [diff] [blame] | 1470 | } |
| 1471 | |
| 1472 | return; |
| 1473 | } |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 1474 | } |
| 1475 | |
| 1476 | MCInst TmpInst; |
| 1477 | MCInstLowering.Lower(MI, TmpInst); |
Chris Lattner | 850d2e2 | 2010-02-03 01:16:28 +0000 | [diff] [blame] | 1478 | OutStreamer.EmitInstruction(TmpInst); |
Chris Lattner | 97f0693 | 2009-10-19 20:20:46 +0000 | [diff] [blame] | 1479 | } |
Daniel Dunbar | 2685a29 | 2009-10-20 05:15:36 +0000 | [diff] [blame] | 1480 | |
| 1481 | //===----------------------------------------------------------------------===// |
| 1482 | // Target Registry Stuff |
| 1483 | //===----------------------------------------------------------------------===// |
| 1484 | |
| 1485 | static MCInstPrinter *createARMMCInstPrinter(const Target &T, |
| 1486 | unsigned SyntaxVariant, |
Chris Lattner | d374087 | 2010-04-04 05:04:31 +0000 | [diff] [blame] | 1487 | const MCAsmInfo &MAI) { |
Daniel Dunbar | 2685a29 | 2009-10-20 05:15:36 +0000 | [diff] [blame] | 1488 | if (SyntaxVariant == 0) |
Chris Lattner | d374087 | 2010-04-04 05:04:31 +0000 | [diff] [blame] | 1489 | return new ARMInstPrinter(MAI, false); |
Daniel Dunbar | 2685a29 | 2009-10-20 05:15:36 +0000 | [diff] [blame] | 1490 | return 0; |
| 1491 | } |
| 1492 | |
| 1493 | // Force static initialization. |
| 1494 | extern "C" void LLVMInitializeARMAsmPrinter() { |
| 1495 | RegisterAsmPrinter<ARMAsmPrinter> X(TheARMTarget); |
| 1496 | RegisterAsmPrinter<ARMAsmPrinter> Y(TheThumbTarget); |
| 1497 | |
| 1498 | TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter); |
| 1499 | TargetRegistry::RegisterMCInstPrinter(TheThumbTarget, createARMMCInstPrinter); |
| 1500 | } |
| 1501 | |