lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp

   1 //===-- ARMAsmPrinter.cpp - Print machine code to an ARM .s file ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   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
  15 #define DEBUG_TYPE "asm-printer"
  16 #include "ARM.h"
  17 #include "ARMBuildAttrs.h"
  18 #include "ARMAddressingModes.h"
  19 #include "ARMConstantPoolValue.h"
  20 #include "ARMInstPrinter.h"
  21 #include "ARMMachineFunctionInfo.h"
  22 #include "ARMMCInstLower.h"
  23 #include "ARMTargetMachine.h"
  24 #include "llvm/Constants.h"
  25 #include "llvm/Module.h"
  26 #include "llvm/Assembly/Writer.h"
  27 #include "llvm/CodeGen/AsmPrinter.h"
  28 #include "llvm/CodeGen/DwarfWriter.h"
  29 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  30 #include "llvm/CodeGen/MachineFunctionPass.h"
  31 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  32 #include "llvm/MC/MCAsmInfo.h"
  33 #include "llvm/MC/MCContext.h"
  34 #include "llvm/MC/MCInst.h"
  35 #include "llvm/MC/MCSectionMachO.h"
  36 #include "llvm/MC/MCStreamer.h"
  37 #include "llvm/MC/MCSymbol.h"
  38 #include "llvm/Target/TargetData.h"
  39 #include "llvm/Target/TargetLoweringObjectFile.h"
  40 #include "llvm/Target/TargetMachine.h"
  41 #include "llvm/Target/TargetOptions.h"
  42 #include "llvm/Target/TargetRegistry.h"
  43 #include "llvm/ADT/SmallPtrSet.h"
  44 #include "llvm/ADT/SmallString.h"
  45 #include "llvm/ADT/Statistic.h"
  46 #include "llvm/ADT/StringExtras.h"
  47 #include "llvm/ADT/StringSet.h"
  48 #include "llvm/Support/CommandLine.h"
  49 #include "llvm/Support/ErrorHandling.h"
  50 #include "llvm/Support/FormattedStream.h"
  51 #include "llvm/Support/Mangler.h"
  52 #include "llvm/Support/MathExtras.h"
  53 #include <cctype>
  54 using namespace llvm;
  55
  56 STATISTIC(EmittedInsts, "Number of machine instrs printed");
  57
  58 static cl::opt<bool>
  59 EnableMCInst("enable-arm-mcinst-printer", cl::Hidden,
  60             cl::desc("enable experimental asmprinter gunk in the arm backend"));
  61
  62 namespace {
  63   class ARMAsmPrinter : public AsmPrinter {
  64
  65     /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
  66     /// make the right decision when printing asm code for different targets.
  67     const ARMSubtarget *Subtarget;
  68
  69     /// AFI - Keep a pointer to ARMFunctionInfo for the current
  70     /// MachineFunction.
  71     ARMFunctionInfo *AFI;
  72
  73     /// MCP - Keep a pointer to constantpool entries of the current
  74     /// MachineFunction.
  75     const MachineConstantPool *MCP;
  76
  77   public:
  78     explicit ARMAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
  79                            const MCAsmInfo *T, bool V)
  80       : AsmPrinter(O, TM, T, V), AFI(NULL), MCP(NULL) {
  81       Subtarget = &TM.getSubtarget<ARMSubtarget>();
  82     }
  83
  84     virtual const char *getPassName() const {
  85       return "ARM Assembly Printer";
  86     }
  87
  88     void printMCInst(const MCInst *MI) {
  89       ARMInstPrinter(O, *MAI, VerboseAsm).printInstruction(MI);
  90     }
  91
  92     void printInstructionThroughMCStreamer(const MachineInstr *MI);
  93
  94
  95     void printOperand(const MachineInstr *MI, int OpNum,
  96                       const char *Modifier = 0);
  97     void printSOImmOperand(const MachineInstr *MI, int OpNum);
  98     void printSOImm2PartOperand(const MachineInstr *MI, int OpNum);
  99     void printSORegOperand(const MachineInstr *MI, int OpNum);
 100     void printAddrMode2Operand(const MachineInstr *MI, int OpNum);
 101     void printAddrMode2OffsetOperand(const MachineInstr *MI, int OpNum);
 102     void printAddrMode3Operand(const MachineInstr *MI, int OpNum);
 103     void printAddrMode3OffsetOperand(const MachineInstr *MI, int OpNum);
 104     void printAddrMode4Operand(const MachineInstr *MI, int OpNum,
 105                                const char *Modifier = 0);
 106     void printAddrMode5Operand(const MachineInstr *MI, int OpNum,
 107                                const char *Modifier = 0);
 108     void printAddrMode6Operand(const MachineInstr *MI, int OpNum);
 109     void printAddrModePCOperand(const MachineInstr *MI, int OpNum,
 110                                 const char *Modifier = 0);
 111     void printBitfieldInvMaskImmOperand (const MachineInstr *MI, int OpNum);
 112
 113     void printThumbITMask(const MachineInstr *MI, int OpNum);
 114     void printThumbAddrModeRROperand(const MachineInstr *MI, int OpNum);
 115     void printThumbAddrModeRI5Operand(const MachineInstr *MI, int OpNum,
 116                                       unsigned Scale);
 117     void printThumbAddrModeS1Operand(const MachineInstr *MI, int OpNum);
 118     void printThumbAddrModeS2Operand(const MachineInstr *MI, int OpNum);
 119     void printThumbAddrModeS4Operand(const MachineInstr *MI, int OpNum);
 120     void printThumbAddrModeSPOperand(const MachineInstr *MI, int OpNum);
 121
 122     void printT2SOOperand(const MachineInstr *MI, int OpNum);
 123     void printT2AddrModeImm12Operand(const MachineInstr *MI, int OpNum);
 124     void printT2AddrModeImm8Operand(const MachineInstr *MI, int OpNum);
 125     void printT2AddrModeImm8s4Operand(const MachineInstr *MI, int OpNum);
 126     void printT2AddrModeImm8OffsetOperand(const MachineInstr *MI, int OpNum);
 127     void printT2AddrModeSoRegOperand(const MachineInstr *MI, int OpNum);
 128
 129     void printPredicateOperand(const MachineInstr *MI, int OpNum);
 130     void printSBitModifierOperand(const MachineInstr *MI, int OpNum);
 131     void printPCLabel(const MachineInstr *MI, int OpNum);
 132     void printRegisterList(const MachineInstr *MI, int OpNum);
 133     void printCPInstOperand(const MachineInstr *MI, int OpNum,
 134                             const char *Modifier);
 135     void printJTBlockOperand(const MachineInstr *MI, int OpNum);
 136     void printJT2BlockOperand(const MachineInstr *MI, int OpNum);
 137     void printTBAddrMode(const MachineInstr *MI, int OpNum);
 138     void printNoHashImmediate(const MachineInstr *MI, int OpNum);
 139     void printVFPf32ImmOperand(const MachineInstr *MI, int OpNum);
 140     void printVFPf64ImmOperand(const MachineInstr *MI, int OpNum);
 141
 142     void printHex8ImmOperand(const MachineInstr *MI, int OpNum) {
 143       O << "#0x" << utohexstr(MI->getOperand(OpNum).getImm() & 0xff);
 144     }
 145     void printHex16ImmOperand(const MachineInstr *MI, int OpNum) {
 146       O << "#0x" << utohexstr(MI->getOperand(OpNum).getImm() & 0xffff);
 147     }
 148     void printHex32ImmOperand(const MachineInstr *MI, int OpNum) {
 149       O << "#0x" << utohexstr(MI->getOperand(OpNum).getImm() & 0xffffffff);
 150     }
 151     void printHex64ImmOperand(const MachineInstr *MI, int OpNum) {
 152       O << "#0x" << utohexstr(MI->getOperand(OpNum).getImm());
 153     }
 154
 155     virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
 156                                  unsigned AsmVariant, const char *ExtraCode);
 157     virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum,
 158                                        unsigned AsmVariant,
 159                                        const char *ExtraCode);
 160
 161     void PrintGlobalVariable(const GlobalVariable* GVar);
 162     void printInstruction(const MachineInstr *MI);  // autogenerated.
 163     static const char *getRegisterName(unsigned RegNo);
 164
 165     void printMachineInstruction(const MachineInstr *MI);
 166     bool runOnMachineFunction(MachineFunction &F);
 167     void EmitStartOfAsmFile(Module &M);
 168     void EmitEndOfAsmFile(Module &M);
 169
 170     /// EmitMachineConstantPoolValue - Print a machine constantpool value to
 171     /// the .s file.
 172     virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {
 173       printDataDirective(MCPV->getType());
 174
 175       ARMConstantPoolValue *ACPV = static_cast<ARMConstantPoolValue*>(MCPV);
 176       std::string Name;
 177
 178       if (ACPV->isLSDA()) {
 179         SmallString<16> LSDAName;
 180         raw_svector_ostream(LSDAName) << MAI->getPrivateGlobalPrefix() <<
 181           "_LSDA_" << getFunctionNumber();
 182         Name = LSDAName.str();
 183       } else if (ACPV->isBlockAddress()) {
 184         Name = GetBlockAddressSymbol(ACPV->getBlockAddress())->getName();
 185       } else if (ACPV->isGlobalValue()) {
 186         GlobalValue *GV = ACPV->getGV();
 187         bool isIndirect = Subtarget->isTargetDarwin() &&
 188           Subtarget->GVIsIndirectSymbol(GV, TM.getRelocationModel());
 189         if (!isIndirect)
 190           Name = Mang->getMangledName(GV);
 191         else {
 192           // FIXME: Remove this when Darwin transition to @GOT like syntax.
 193           Name = Mang->getMangledName(GV, "$non_lazy_ptr", true);
 194           MCSymbol *Sym = OutContext.GetOrCreateSymbol(StringRef(Name));
 195
 196           MachineModuleInfoMachO &MMIMachO =
 197             MMI->getObjFileInfo<MachineModuleInfoMachO>();
 198           const MCSymbol *&StubSym =
 199             GV->hasHiddenVisibility() ? MMIMachO.getHiddenGVStubEntry(Sym) :
 200                                         MMIMachO.getGVStubEntry(Sym);
 201           if (StubSym == 0) {
 202             SmallString<128> NameStr;
 203             Mang->getNameWithPrefix(NameStr, GV, false);
 204             StubSym = OutContext.GetOrCreateSymbol(NameStr.str());
 205           }
 206         }
 207       } else {
 208         assert(ACPV->isExtSymbol() && "unrecognized constant pool value");
 209         Name = Mang->makeNameProper(ACPV->getSymbol());
 210       }
 211       O << Name;
 212
 213       if (ACPV->hasModifier()) O << "(" << ACPV->getModifier() << ")";
 214       if (ACPV->getPCAdjustment() != 0) {
 215         O << "-(" << MAI->getPrivateGlobalPrefix() << "PC"
 216           << getFunctionNumber() << "_"  << ACPV->getLabelId()
 217           << "+" << (unsigned)ACPV->getPCAdjustment();
 218          if (ACPV->mustAddCurrentAddress())
 219            O << "-.";
 220          O << ")";
 221       }
 222       O << "\n";
 223     }
 224
 225     void getAnalysisUsage(AnalysisUsage &AU) const {
 226       AsmPrinter::getAnalysisUsage(AU);
 227       AU.setPreservesAll();
 228       AU.addRequired<MachineModuleInfo>();
 229       AU.addRequired<DwarfWriter>();
 230     }
 231   };
 232 } // end of anonymous namespace
 233
 234 #include "ARMGenAsmWriter.inc"
 235
 236 /// runOnMachineFunction - This uses the printInstruction()
 237 /// method to print assembly for each instruction.
 238 ///
 239 bool ARMAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 240   this->MF = &MF;
 241
 242   AFI = MF.getInfo<ARMFunctionInfo>();
 243   MCP = MF.getConstantPool();
 244
 245   SetupMachineFunction(MF);
 246   O << "\n";
 247
 248   // NOTE: we don't print out constant pools here, they are handled as
 249   // instructions.
 250
 251   O << '\n';
 252
 253   // Print out labels for the function.
 254   const Function *F = MF.getFunction();
 255   OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM));
 256
 257   switch (F->getLinkage()) {
 258   default: llvm_unreachable("Unknown linkage type!");
 259   case Function::PrivateLinkage:
 260   case Function::InternalLinkage:
 261     break;
 262   case Function::ExternalLinkage:
 263     O << "\t.globl\t" << CurrentFnName << "\n";
 264     break;
 265   case Function::LinkerPrivateLinkage:
 266   case Function::WeakAnyLinkage:
 267   case Function::WeakODRLinkage:
 268   case Function::LinkOnceAnyLinkage:
 269   case Function::LinkOnceODRLinkage:
 270     if (Subtarget->isTargetDarwin()) {
 271       O << "\t.globl\t" << CurrentFnName << "\n";
 272       O << "\t.weak_definition\t" << CurrentFnName << "\n";
 273     } else {
 274       O << MAI->getWeakRefDirective() << CurrentFnName << "\n";
 275     }
 276     break;
 277   }
 278
 279   printVisibility(CurrentFnName, F->getVisibility());
 280
 281   unsigned FnAlign = 1 << MF.getAlignment();  // MF alignment is log2.
 282   if (AFI->isThumbFunction()) {
 283     EmitAlignment(FnAlign, F, AFI->getAlign());
 284     O << "\t.code\t16\n";
 285     O << "\t.thumb_func";
 286     if (Subtarget->isTargetDarwin())
 287       O << "\t" << CurrentFnName;
 288     O << "\n";
 289   } else {
 290     EmitAlignment(FnAlign, F);
 291   }
 292
 293   O << CurrentFnName << ":\n";
 294   // Emit pre-function debug information.
 295   DW->BeginFunction(&MF);
 296
 297   if (Subtarget->isTargetDarwin()) {
 298     // If the function is empty, then we need to emit *something*. Otherwise,
 299     // the function's label might be associated with something that it wasn't
 300     // meant to be associated with. We emit a noop in this situation.
 301     MachineFunction::iterator I = MF.begin();
 302
 303     if (++I == MF.end() && MF.front().empty())
 304       O << "\tnop\n";
 305   }
 306
 307   // Print out code for the function.
 308   for (MachineFunction::const_iterator I = MF.begin(), E = MF.end();
 309        I != E; ++I) {
 310     // Print a label for the basic block.
 311     if (I != MF.begin())
 312       EmitBasicBlockStart(I);
 313
 314     // Print the assembly for the instruction.
 315     for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end();
 316          II != E; ++II)
 317       printMachineInstruction(II);
 318   }
 319
 320   if (MAI->hasDotTypeDotSizeDirective())
 321     O << "\t.size " << CurrentFnName << ", .-" << CurrentFnName << "\n";
 322
 323   // Emit post-function debug information.
 324   DW->EndFunction(&MF);
 325
 326   return false;
 327 }
 328
 329 void ARMAsmPrinter::printOperand(const MachineInstr *MI, int OpNum,
 330                                  const char *Modifier) {
 331   const MachineOperand &MO = MI->getOperand(OpNum);
 332   switch (MO.getType()) {
 333   default:
 334     assert(0 && "<unknown operand type>");
 335   case MachineOperand::MO_Register: {
 336     unsigned Reg = MO.getReg();
 337     assert(TargetRegisterInfo::isPhysicalRegister(Reg));
 338     if (Modifier && strcmp(Modifier, "dregpair") == 0) {
 339       unsigned DRegLo = TRI->getSubReg(Reg, 5); // arm_dsubreg_0
 340       unsigned DRegHi = TRI->getSubReg(Reg, 6); // arm_dsubreg_1
 341       O << '{'
 342         << getRegisterName(DRegLo) << ',' << getRegisterName(DRegHi)
 343         << '}';
 344     } else if (Modifier && strcmp(Modifier, "lane") == 0) {
 345       unsigned RegNum = ARMRegisterInfo::getRegisterNumbering(Reg);
 346       unsigned DReg = TRI->getMatchingSuperReg(Reg, RegNum & 1 ? 2 : 1,
 347                                                &ARM::DPR_VFP2RegClass);
 348       O << getRegisterName(DReg) << '[' << (RegNum & 1) << ']';
 349     } else {
 350       assert(!MO.getSubReg() && "Subregs should be eliminated!");
 351       O << getRegisterName(Reg);
 352     }
 353     break;
 354   }
 355   case MachineOperand::MO_Immediate: {
 356     int64_t Imm = MO.getImm();
 357     O << '#';
 358     if (Modifier) {
 359       if (strcmp(Modifier, "lo16") == 0)
 360         O << ":lower16:";
 361       else if (strcmp(Modifier, "hi16") == 0)
 362         O << ":upper16:";
 363     }
 364     O << Imm;
 365     break;
 366   }
 367   case MachineOperand::MO_MachineBasicBlock:
 368     GetMBBSymbol(MO.getMBB()->getNumber())->print(O, MAI);
 369     return;
 370   case MachineOperand::MO_GlobalAddress: {
 371     bool isCallOp = Modifier && !strcmp(Modifier, "call");
 372     GlobalValue *GV = MO.getGlobal();
 373     O << Mang->getMangledName(GV);
 374
 375     printOffset(MO.getOffset());
 376
 377     if (isCallOp && Subtarget->isTargetELF() &&
 378         TM.getRelocationModel() == Reloc::PIC_)
 379       O << "(PLT)";
 380     break;
 381   }
 382   case MachineOperand::MO_ExternalSymbol: {
 383     bool isCallOp = Modifier && !strcmp(Modifier, "call");
 384     std::string Name = Mang->makeNameProper(MO.getSymbolName());
 385
 386     O << Name;
 387     if (isCallOp && Subtarget->isTargetELF() &&
 388         TM.getRelocationModel() == Reloc::PIC_)
 389       O << "(PLT)";
 390     break;
 391   }
 392   case MachineOperand::MO_ConstantPoolIndex:
 393     O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
 394       << '_' << MO.getIndex();
 395     break;
 396   case MachineOperand::MO_JumpTableIndex:
 397     O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 398       << '_' << MO.getIndex();
 399     break;
 400   }
 401 }
 402
 403 static void printSOImm(formatted_raw_ostream &O, int64_t V, bool VerboseAsm,
 404                        const MCAsmInfo *MAI) {
 405   // Break it up into two parts that make up a shifter immediate.
 406   V = ARM_AM::getSOImmVal(V);
 407   assert(V != -1 && "Not a valid so_imm value!");
 408
 409   unsigned Imm = ARM_AM::getSOImmValImm(V);
 410   unsigned Rot = ARM_AM::getSOImmValRot(V);
 411
 412   // Print low-level immediate formation info, per
 413   // A5.1.3: "Data-processing operands - Immediate".
 414   if (Rot) {
 415     O << "#" << Imm << ", " << Rot;
 416     // Pretty printed version.
 417     if (VerboseAsm) {
 418       O.PadToColumn(MAI->getCommentColumn());
 419       O << MAI->getCommentString() << ' ';
 420       O << (int)ARM_AM::rotr32(Imm, Rot);
 421     }
 422   } else {
 423     O << "#" << Imm;
 424   }
 425 }
 426
 427 /// printSOImmOperand - SOImm is 4-bit rotate amount in bits 8-11 with 8-bit
 428 /// immediate in bits 0-7.
 429 void ARMAsmPrinter::printSOImmOperand(const MachineInstr *MI, int OpNum) {
 430   const MachineOperand &MO = MI->getOperand(OpNum);
 431   assert(MO.isImm() && "Not a valid so_imm value!");
 432   printSOImm(O, MO.getImm(), VerboseAsm, MAI);
 433 }
 434
 435 /// printSOImm2PartOperand - SOImm is broken into two pieces using a 'mov'
 436 /// followed by an 'orr' to materialize.
 437 void ARMAsmPrinter::printSOImm2PartOperand(const MachineInstr *MI, int OpNum) {
 438   const MachineOperand &MO = MI->getOperand(OpNum);
 439   assert(MO.isImm() && "Not a valid so_imm value!");
 440   unsigned V1 = ARM_AM::getSOImmTwoPartFirst(MO.getImm());
 441   unsigned V2 = ARM_AM::getSOImmTwoPartSecond(MO.getImm());
 442   printSOImm(O, V1, VerboseAsm, MAI);
 443   O << "\n\torr";
 444   printPredicateOperand(MI, 2);
 445   O << "\t";
 446   printOperand(MI, 0);
 447   O << ", ";
 448   printOperand(MI, 0);
 449   O << ", ";
 450   printSOImm(O, V2, VerboseAsm, MAI);
 451 }
 452
 453 // so_reg is a 4-operand unit corresponding to register forms of the A5.1
 454 // "Addressing Mode 1 - Data-processing operands" forms.  This includes:
 455 //    REG 0   0           - e.g. R5
 456 //    REG REG 0,SH_OPC    - e.g. R5, ROR R3
 457 //    REG 0   IMM,SH_OPC  - e.g. R5, LSL #3
 458 void ARMAsmPrinter::printSORegOperand(const MachineInstr *MI, int Op) {
 459   const MachineOperand &MO1 = MI->getOperand(Op);
 460   const MachineOperand &MO2 = MI->getOperand(Op+1);
 461   const MachineOperand &MO3 = MI->getOperand(Op+2);
 462
 463   O << getRegisterName(MO1.getReg());
 464
 465   // Print the shift opc.
 466   O << ", "
 467     << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO3.getImm()))
 468     << " ";
 469
 470   if (MO2.getReg()) {
 471     O << getRegisterName(MO2.getReg());
 472     assert(ARM_AM::getSORegOffset(MO3.getImm()) == 0);
 473   } else {
 474     O << "#" << ARM_AM::getSORegOffset(MO3.getImm());
 475   }
 476 }
 477
 478 void ARMAsmPrinter::printAddrMode2Operand(const MachineInstr *MI, int Op) {
 479   const MachineOperand &MO1 = MI->getOperand(Op);
 480   const MachineOperand &MO2 = MI->getOperand(Op+1);
 481   const MachineOperand &MO3 = MI->getOperand(Op+2);
 482
 483   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 484     printOperand(MI, Op);
 485     return;
 486   }
 487
 488   O << "[" << getRegisterName(MO1.getReg());
 489
 490   if (!MO2.getReg()) {
 491     if (ARM_AM::getAM2Offset(MO3.getImm()))  // Don't print +0.
 492       O << ", #"
 493         << (char)ARM_AM::getAM2Op(MO3.getImm())
 494         << ARM_AM::getAM2Offset(MO3.getImm());
 495     O << "]";
 496     return;
 497   }
 498
 499   O << ", "
 500     << (char)ARM_AM::getAM2Op(MO3.getImm())
 501     << getRegisterName(MO2.getReg());
 502
 503   if (unsigned ShImm = ARM_AM::getAM2Offset(MO3.getImm()))
 504     O << ", "
 505       << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO3.getImm()))
 506       << " #" << ShImm;
 507   O << "]";
 508 }
 509
 510 void ARMAsmPrinter::printAddrMode2OffsetOperand(const MachineInstr *MI, int Op){
 511   const MachineOperand &MO1 = MI->getOperand(Op);
 512   const MachineOperand &MO2 = MI->getOperand(Op+1);
 513
 514   if (!MO1.getReg()) {
 515     unsigned ImmOffs = ARM_AM::getAM2Offset(MO2.getImm());
 516     assert(ImmOffs && "Malformed indexed load / store!");
 517     O << "#"
 518       << (char)ARM_AM::getAM2Op(MO2.getImm())
 519       << ImmOffs;
 520     return;
 521   }
 522
 523   O << (char)ARM_AM::getAM2Op(MO2.getImm())
 524     << getRegisterName(MO1.getReg());
 525
 526   if (unsigned ShImm = ARM_AM::getAM2Offset(MO2.getImm()))
 527     O << ", "
 528       << ARM_AM::getShiftOpcStr(ARM_AM::getAM2ShiftOpc(MO2.getImm()))
 529       << " #" << ShImm;
 530 }
 531
 532 void ARMAsmPrinter::printAddrMode3Operand(const MachineInstr *MI, int Op) {
 533   const MachineOperand &MO1 = MI->getOperand(Op);
 534   const MachineOperand &MO2 = MI->getOperand(Op+1);
 535   const MachineOperand &MO3 = MI->getOperand(Op+2);
 536
 537   assert(TargetRegisterInfo::isPhysicalRegister(MO1.getReg()));
 538   O << "[" << getRegisterName(MO1.getReg());
 539
 540   if (MO2.getReg()) {
 541     O << ", "
 542       << (char)ARM_AM::getAM3Op(MO3.getImm())
 543       << getRegisterName(MO2.getReg())
 544       << "]";
 545     return;
 546   }
 547
 548   if (unsigned ImmOffs = ARM_AM::getAM3Offset(MO3.getImm()))
 549     O << ", #"
 550       << (char)ARM_AM::getAM3Op(MO3.getImm())
 551       << ImmOffs;
 552   O << "]";
 553 }
 554
 555 void ARMAsmPrinter::printAddrMode3OffsetOperand(const MachineInstr *MI, int Op){
 556   const MachineOperand &MO1 = MI->getOperand(Op);
 557   const MachineOperand &MO2 = MI->getOperand(Op+1);
 558
 559   if (MO1.getReg()) {
 560     O << (char)ARM_AM::getAM3Op(MO2.getImm())
 561       << getRegisterName(MO1.getReg());
 562     return;
 563   }
 564
 565   unsigned ImmOffs = ARM_AM::getAM3Offset(MO2.getImm());
 566   assert(ImmOffs && "Malformed indexed load / store!");
 567   O << "#"
 568     << (char)ARM_AM::getAM3Op(MO2.getImm())
 569     << ImmOffs;
 570 }
 571
 572 void ARMAsmPrinter::printAddrMode4Operand(const MachineInstr *MI, int Op,
 573                                           const char *Modifier) {
 574   const MachineOperand &MO1 = MI->getOperand(Op);
 575   const MachineOperand &MO2 = MI->getOperand(Op+1);
 576   ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MO2.getImm());
 577   if (Modifier && strcmp(Modifier, "submode") == 0) {
 578     if (MO1.getReg() == ARM::SP) {
 579       // FIXME
 580       bool isLDM = (MI->getOpcode() == ARM::LDM ||
 581                     MI->getOpcode() == ARM::LDM_RET ||
 582                     MI->getOpcode() == ARM::t2LDM ||
 583                     MI->getOpcode() == ARM::t2LDM_RET);
 584       O << ARM_AM::getAMSubModeAltStr(Mode, isLDM);
 585     } else
 586       O << ARM_AM::getAMSubModeStr(Mode);
 587   } else if (Modifier && strcmp(Modifier, "wide") == 0) {
 588     ARM_AM::AMSubMode Mode = ARM_AM::getAM4SubMode(MO2.getImm());
 589     if (Mode == ARM_AM::ia)
 590       O << ".w";
 591   } else {
 592     printOperand(MI, Op);
 593     if (ARM_AM::getAM4WBFlag(MO2.getImm()))
 594       O << "!";
 595   }
 596 }
 597
 598 void ARMAsmPrinter::printAddrMode5Operand(const MachineInstr *MI, int Op,
 599                                           const char *Modifier) {
 600   const MachineOperand &MO1 = MI->getOperand(Op);
 601   const MachineOperand &MO2 = MI->getOperand(Op+1);
 602
 603   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 604     printOperand(MI, Op);
 605     return;
 606   }
 607
 608   assert(TargetRegisterInfo::isPhysicalRegister(MO1.getReg()));
 609
 610   if (Modifier && strcmp(Modifier, "submode") == 0) {
 611     ARM_AM::AMSubMode Mode = ARM_AM::getAM5SubMode(MO2.getImm());
 612     O << ARM_AM::getAMSubModeStr(Mode);
 613     return;
 614   } else if (Modifier && strcmp(Modifier, "base") == 0) {
 615     // Used for FSTM{D|S} and LSTM{D|S} operations.
 616     O << getRegisterName(MO1.getReg());
 617     if (ARM_AM::getAM5WBFlag(MO2.getImm()))
 618       O << "!";
 619     return;
 620   }
 621
 622   O << "[" << getRegisterName(MO1.getReg());
 623
 624   if (unsigned ImmOffs = ARM_AM::getAM5Offset(MO2.getImm())) {
 625     O << ", #"
 626       << (char)ARM_AM::getAM5Op(MO2.getImm())
 627       << ImmOffs*4;
 628   }
 629   O << "]";
 630 }
 631
 632 void ARMAsmPrinter::printAddrMode6Operand(const MachineInstr *MI, int Op) {
 633   const MachineOperand &MO1 = MI->getOperand(Op);
 634   const MachineOperand &MO2 = MI->getOperand(Op+1);
 635   const MachineOperand &MO3 = MI->getOperand(Op+2);
 636   const MachineOperand &MO4 = MI->getOperand(Op+3);
 637
 638   O << "[" << getRegisterName(MO1.getReg());
 639   if (MO4.getImm()) {
 640     if (Subtarget->isTargetDarwin())
 641       O << ", :";
 642     else
 643       O << " @";
 644     O << MO4.getImm();
 645   }
 646   O << "]";
 647
 648   if (ARM_AM::getAM6WBFlag(MO3.getImm())) {
 649     if (MO2.getReg() == 0)
 650       O << "!";
 651     else
 652       O << ", " << getRegisterName(MO2.getReg());
 653   }
 654 }
 655
 656 void ARMAsmPrinter::printAddrModePCOperand(const MachineInstr *MI, int Op,
 657                                            const char *Modifier) {
 658   if (Modifier && strcmp(Modifier, "label") == 0) {
 659     printPCLabel(MI, Op+1);
 660     return;
 661   }
 662
 663   const MachineOperand &MO1 = MI->getOperand(Op);
 664   assert(TargetRegisterInfo::isPhysicalRegister(MO1.getReg()));
 665   O << "[pc, +" << getRegisterName(MO1.getReg()) << "]";
 666 }
 667
 668 void
 669 ARMAsmPrinter::printBitfieldInvMaskImmOperand(const MachineInstr *MI, int Op) {
 670   const MachineOperand &MO = MI->getOperand(Op);
 671   uint32_t v = ~MO.getImm();
 672   int32_t lsb = CountTrailingZeros_32(v);
 673   int32_t width = (32 - CountLeadingZeros_32 (v)) - lsb;
 674   assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!");
 675   O << "#" << lsb << ", #" << width;
 676 }
 677
 678 //===--------------------------------------------------------------------===//
 679
 680 void
 681 ARMAsmPrinter::printThumbITMask(const MachineInstr *MI, int Op) {
 682   // (3 - the number of trailing zeros) is the number of then / else.
 683   unsigned Mask = MI->getOperand(Op).getImm();
 684   unsigned NumTZ = CountTrailingZeros_32(Mask);
 685   assert(NumTZ <= 3 && "Invalid IT mask!");
 686   for (unsigned Pos = 3, e = NumTZ; Pos > e; --Pos) {
 687     bool T = (Mask & (1 << Pos)) == 0;
 688     if (T)
 689       O << 't';
 690     else
 691       O << 'e';
 692   }
 693 }
 694
 695 void
 696 ARMAsmPrinter::printThumbAddrModeRROperand(const MachineInstr *MI, int Op) {
 697   const MachineOperand &MO1 = MI->getOperand(Op);
 698   const MachineOperand &MO2 = MI->getOperand(Op+1);
 699   O << "[" << getRegisterName(MO1.getReg());
 700   O << ", " << getRegisterName(MO2.getReg()) << "]";
 701 }
 702
 703 void
 704 ARMAsmPrinter::printThumbAddrModeRI5Operand(const MachineInstr *MI, int Op,
 705                                             unsigned Scale) {
 706   const MachineOperand &MO1 = MI->getOperand(Op);
 707   const MachineOperand &MO2 = MI->getOperand(Op+1);
 708   const MachineOperand &MO3 = MI->getOperand(Op+2);
 709
 710   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 711     printOperand(MI, Op);
 712     return;
 713   }
 714
 715   O << "[" << getRegisterName(MO1.getReg());
 716   if (MO3.getReg())
 717     O << ", " << getRegisterName(MO3.getReg());
 718   else if (unsigned ImmOffs = MO2.getImm()) {
 719     O << ", #" << ImmOffs;
 720     if (Scale > 1)
 721       O << " * " << Scale;
 722   }
 723   O << "]";
 724 }
 725
 726 void
 727 ARMAsmPrinter::printThumbAddrModeS1Operand(const MachineInstr *MI, int Op) {
 728   printThumbAddrModeRI5Operand(MI, Op, 1);
 729 }
 730 void
 731 ARMAsmPrinter::printThumbAddrModeS2Operand(const MachineInstr *MI, int Op) {
 732   printThumbAddrModeRI5Operand(MI, Op, 2);
 733 }
 734 void
 735 ARMAsmPrinter::printThumbAddrModeS4Operand(const MachineInstr *MI, int Op) {
 736   printThumbAddrModeRI5Operand(MI, Op, 4);
 737 }
 738
 739 void ARMAsmPrinter::printThumbAddrModeSPOperand(const MachineInstr *MI,int Op) {
 740   const MachineOperand &MO1 = MI->getOperand(Op);
 741   const MachineOperand &MO2 = MI->getOperand(Op+1);
 742   O << "[" << getRegisterName(MO1.getReg());
 743   if (unsigned ImmOffs = MO2.getImm())
 744     O << ", #" << ImmOffs << " * 4";
 745   O << "]";
 746 }
 747
 748 //===--------------------------------------------------------------------===//
 749
 750 // Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2
 751 // register with shift forms.
 752 // REG 0   0           - e.g. R5
 753 // REG IMM, SH_OPC     - e.g. R5, LSL #3
 754 void ARMAsmPrinter::printT2SOOperand(const MachineInstr *MI, int OpNum) {
 755   const MachineOperand &MO1 = MI->getOperand(OpNum);
 756   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 757
 758   unsigned Reg = MO1.getReg();
 759   assert(TargetRegisterInfo::isPhysicalRegister(Reg));
 760   O << getRegisterName(Reg);
 761
 762   // Print the shift opc.
 763   O << ", "
 764     << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO2.getImm()))
 765     << " ";
 766
 767   assert(MO2.isImm() && "Not a valid t2_so_reg value!");
 768   O << "#" << ARM_AM::getSORegOffset(MO2.getImm());
 769 }
 770
 771 void ARMAsmPrinter::printT2AddrModeImm12Operand(const MachineInstr *MI,
 772                                                 int OpNum) {
 773   const MachineOperand &MO1 = MI->getOperand(OpNum);
 774   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 775
 776   O << "[" << getRegisterName(MO1.getReg());
 777
 778   unsigned OffImm = MO2.getImm();
 779   if (OffImm)  // Don't print +0.
 780     O << ", #+" << OffImm;
 781   O << "]";
 782 }
 783
 784 void ARMAsmPrinter::printT2AddrModeImm8Operand(const MachineInstr *MI,
 785                                                int OpNum) {
 786   const MachineOperand &MO1 = MI->getOperand(OpNum);
 787   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 788
 789   O << "[" << getRegisterName(MO1.getReg());
 790
 791   int32_t OffImm = (int32_t)MO2.getImm();
 792   // Don't print +0.
 793   if (OffImm < 0)
 794     O << ", #-" << -OffImm;
 795   else if (OffImm > 0)
 796     O << ", #+" << OffImm;
 797   O << "]";
 798 }
 799
 800 void ARMAsmPrinter::printT2AddrModeImm8s4Operand(const MachineInstr *MI,
 801                                                  int OpNum) {
 802   const MachineOperand &MO1 = MI->getOperand(OpNum);
 803   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 804
 805   O << "[" << getRegisterName(MO1.getReg());
 806
 807   int32_t OffImm = (int32_t)MO2.getImm() / 4;
 808   // Don't print +0.
 809   if (OffImm < 0)
 810     O << ", #-" << -OffImm << " * 4";
 811   else if (OffImm > 0)
 812     O << ", #+" << OffImm << " * 4";
 813   O << "]";
 814 }
 815
 816 void ARMAsmPrinter::printT2AddrModeImm8OffsetOperand(const MachineInstr *MI,
 817                                                      int OpNum) {
 818   const MachineOperand &MO1 = MI->getOperand(OpNum);
 819   int32_t OffImm = (int32_t)MO1.getImm();
 820   // Don't print +0.
 821   if (OffImm < 0)
 822     O << "#-" << -OffImm;
 823   else if (OffImm > 0)
 824     O << "#+" << OffImm;
 825 }
 826
 827 void ARMAsmPrinter::printT2AddrModeSoRegOperand(const MachineInstr *MI,
 828                                                 int OpNum) {
 829   const MachineOperand &MO1 = MI->getOperand(OpNum);
 830   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 831   const MachineOperand &MO3 = MI->getOperand(OpNum+2);
 832
 833   O << "[" << getRegisterName(MO1.getReg());
 834
 835   assert(MO2.getReg() && "Invalid so_reg load / store address!");
 836   O << ", " << getRegisterName(MO2.getReg());
 837
 838   unsigned ShAmt = MO3.getImm();
 839   if (ShAmt) {
 840     assert(ShAmt <= 3 && "Not a valid Thumb2 addressing mode!");
 841     O << ", lsl #" << ShAmt;
 842   }
 843   O << "]";
 844 }
 845
 846
 847 //===--------------------------------------------------------------------===//
 848
 849 void ARMAsmPrinter::printPredicateOperand(const MachineInstr *MI, int OpNum) {
 850   ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
 851   if (CC != ARMCC::AL)
 852     O << ARMCondCodeToString(CC);
 853 }
 854
 855 void ARMAsmPrinter::printSBitModifierOperand(const MachineInstr *MI, int OpNum){
 856   unsigned Reg = MI->getOperand(OpNum).getReg();
 857   if (Reg) {
 858     assert(Reg == ARM::CPSR && "Expect ARM CPSR register!");
 859     O << 's';
 860   }
 861 }
 862
 863 void ARMAsmPrinter::printPCLabel(const MachineInstr *MI, int OpNum) {
 864   int Id = (int)MI->getOperand(OpNum).getImm();
 865   O << MAI->getPrivateGlobalPrefix()
 866     << "PC" << getFunctionNumber() << "_" << Id;
 867 }
 868
 869 void ARMAsmPrinter::printRegisterList(const MachineInstr *MI, int OpNum) {
 870   O << "{";
 871   // Always skip the first operand, it's the optional (and implicit writeback).
 872   for (unsigned i = OpNum+1, e = MI->getNumOperands(); i != e; ++i) {
 873     if (MI->getOperand(i).isImplicit())
 874       continue;
 875     if ((int)i != OpNum+1) O << ", ";
 876     printOperand(MI, i);
 877   }
 878   O << "}";
 879 }
 880
 881 void ARMAsmPrinter::printCPInstOperand(const MachineInstr *MI, int OpNum,
 882                                        const char *Modifier) {
 883   assert(Modifier && "This operand only works with a modifier!");
 884   // There are two aspects to a CONSTANTPOOL_ENTRY operand, the label and the
 885   // data itself.
 886   if (!strcmp(Modifier, "label")) {
 887     unsigned ID = MI->getOperand(OpNum).getImm();
 888     O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
 889       << '_' << ID << ":\n";
 890   } else {
 891     assert(!strcmp(Modifier, "cpentry") && "Unknown modifier for CPE");
 892     unsigned CPI = MI->getOperand(OpNum).getIndex();
 893
 894     const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPI];
 895
 896     if (MCPE.isMachineConstantPoolEntry()) {
 897       EmitMachineConstantPoolValue(MCPE.Val.MachineCPVal);
 898     } else {
 899       EmitGlobalConstant(MCPE.Val.ConstVal);
 900     }
 901   }
 902 }
 903
 904 void ARMAsmPrinter::printJTBlockOperand(const MachineInstr *MI, int OpNum) {
 905   assert(!Subtarget->isThumb2() && "Thumb2 should use double-jump jumptables!");
 906
 907   const MachineOperand &MO1 = MI->getOperand(OpNum);
 908   const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id
 909   unsigned JTI = MO1.getIndex();
 910   O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 911     << '_' << JTI << '_' << MO2.getImm() << ":\n";
 912
 913   const char *JTEntryDirective = MAI->getData32bitsDirective();
 914
 915   const MachineFunction *MF = MI->getParent()->getParent();
 916   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
 917   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 918   const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
 919   bool UseSet= MAI->getSetDirective() && TM.getRelocationModel() == Reloc::PIC_;
 920   SmallPtrSet<MachineBasicBlock*, 8> JTSets;
 921   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
 922     MachineBasicBlock *MBB = JTBBs[i];
 923     bool isNew = JTSets.insert(MBB);
 924
 925     if (UseSet && isNew)
 926       printPICJumpTableSetLabel(JTI, MO2.getImm(), MBB);
 927
 928     O << JTEntryDirective << ' ';
 929     if (UseSet)
 930       O << MAI->getPrivateGlobalPrefix() << getFunctionNumber()
 931         << '_' << JTI << '_' << MO2.getImm()
 932         << "_set_" << MBB->getNumber();
 933     else if (TM.getRelocationModel() == Reloc::PIC_) {
 934       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 935       O << '-' << MAI->getPrivateGlobalPrefix() << "JTI"
 936         << getFunctionNumber() << '_' << JTI << '_' << MO2.getImm();
 937     } else {
 938       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 939     }
 940     if (i != e-1)
 941       O << '\n';
 942   }
 943 }
 944
 945 void ARMAsmPrinter::printJT2BlockOperand(const MachineInstr *MI, int OpNum) {
 946   const MachineOperand &MO1 = MI->getOperand(OpNum);
 947   const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id
 948   unsigned JTI = MO1.getIndex();
 949   O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 950     << '_' << JTI << '_' << MO2.getImm() << ":\n";
 951
 952   const MachineFunction *MF = MI->getParent()->getParent();
 953   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
 954   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 955   const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
 956   bool ByteOffset = false, HalfWordOffset = false;
 957   if (MI->getOpcode() == ARM::t2TBB)
 958     ByteOffset = true;
 959   else if (MI->getOpcode() == ARM::t2TBH)
 960     HalfWordOffset = true;
 961
 962   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
 963     MachineBasicBlock *MBB = JTBBs[i];
 964     if (ByteOffset)
 965       O << MAI->getData8bitsDirective();
 966     else if (HalfWordOffset)
 967       O << MAI->getData16bitsDirective();
 968     if (ByteOffset || HalfWordOffset) {
 969       O << '(';
 970       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 971       O << "-" << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 972         << '_' << JTI << '_' << MO2.getImm() << ")/2";
 973     } else {
 974       O << "\tb.w ";
 975       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 976     }
 977     if (i != e-1)
 978       O << '\n';
 979   }
 980
 981   // Make sure the instruction that follows TBB is 2-byte aligned.
 982   // FIXME: Constant island pass should insert an "ALIGN" instruction instead.
 983   if (ByteOffset && (JTBBs.size() & 1)) {
 984     O << '\n';
 985     EmitAlignment(1);
 986   }
 987 }
 988
 989 void ARMAsmPrinter::printTBAddrMode(const MachineInstr *MI, int OpNum) {
 990   O << "[pc, " << getRegisterName(MI->getOperand(OpNum).getReg());
 991   if (MI->getOpcode() == ARM::t2TBH)
 992     O << ", lsl #1";
 993   O << ']';
 994 }
 995
 996 void ARMAsmPrinter::printNoHashImmediate(const MachineInstr *MI, int OpNum) {
 997   O << MI->getOperand(OpNum).getImm();
 998 }
 999
1000 void ARMAsmPrinter::printVFPf32ImmOperand(const MachineInstr *MI, int OpNum) {
1001   const ConstantFP *FP = MI->getOperand(OpNum).getFPImm();
1002   O << '#' << ARM::getVFPf32Imm(FP->getValueAPF());
1003   if (VerboseAsm) {
1004     O.PadToColumn(MAI->getCommentColumn());
1005     O << MAI->getCommentString() << ' ';
1006     WriteAsOperand(O, FP, /*PrintType=*/false);
1007   }
1008 }
1009
1010 void ARMAsmPrinter::printVFPf64ImmOperand(const MachineInstr *MI, int OpNum) {
1011   const ConstantFP *FP = MI->getOperand(OpNum).getFPImm();
1012   O << '#' << ARM::getVFPf64Imm(FP->getValueAPF());
1013   if (VerboseAsm) {
1014     O.PadToColumn(MAI->getCommentColumn());
1015     O << MAI->getCommentString() << ' ';
1016     WriteAsOperand(O, FP, /*PrintType=*/false);
1017   }
1018 }
1019
1020 bool ARMAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
1021                                     unsigned AsmVariant, const char *ExtraCode){
1022   // Does this asm operand have a single letter operand modifier?
1023   if (ExtraCode && ExtraCode[0]) {
1024     if (ExtraCode[1] != 0) return true; // Unknown modifier.
1025
1026     switch (ExtraCode[0]) {
1027     default: return true;  // Unknown modifier.
1028     case 'a': // Print as a memory address.
1029       if (MI->getOperand(OpNum).isReg()) {
1030         O << "[" << getRegisterName(MI->getOperand(OpNum).getReg()) << "]";
1031         return false;
1032       }
1033       // Fallthrough
1034     case 'c': // Don't print "#" before an immediate operand.
1035       if (!MI->getOperand(OpNum).isImm())
1036         return true;
1037       printNoHashImmediate(MI, OpNum);
1038       return false;
1039     case 'P': // Print a VFP double precision register.
1040       printOperand(MI, OpNum);
1041       return false;
1042     case 'Q':
1043       if (TM.getTargetData()->isLittleEndian())
1044         break;
1045       // Fallthrough
1046     case 'R':
1047       if (TM.getTargetData()->isBigEndian())
1048         break;
1049       // Fallthrough
1050     case 'H': // Write second word of DI / DF reference.
1051       // Verify that this operand has two consecutive registers.
1052       if (!MI->getOperand(OpNum).isReg() ||
1053           OpNum+1 == MI->getNumOperands() ||
1054           !MI->getOperand(OpNum+1).isReg())
1055         return true;
1056       ++OpNum;   // Return the high-part.
1057     }
1058   }
1059
1060   printOperand(MI, OpNum);
1061   return false;
1062 }
1063
1064 bool ARMAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
1065                                           unsigned OpNum, unsigned AsmVariant,
1066                                           const char *ExtraCode) {
1067   if (ExtraCode && ExtraCode[0])
1068     return true; // Unknown modifier.
1069
1070   const MachineOperand &MO = MI->getOperand(OpNum);
1071   assert(MO.isReg() && "unexpected inline asm memory operand");
1072   O << "[" << getRegisterName(MO.getReg()) << "]";
1073   return false;
1074 }
1075
1076 void ARMAsmPrinter::printMachineInstruction(const MachineInstr *MI) {
1077   ++EmittedInsts;
1078
1079   // Call the autogenerated instruction printer routines.
1080   processDebugLoc(MI, true);
1081
1082   if (EnableMCInst) {
1083     printInstructionThroughMCStreamer(MI);
1084   } else {
1085     int Opc = MI->getOpcode();
1086     if (Opc == ARM::CONSTPOOL_ENTRY)
1087       EmitAlignment(2);
1088
1089     printInstruction(MI);
1090   }
1091
1092   if (VerboseAsm && !MI->getDebugLoc().isUnknown())
1093     EmitComments(*MI);
1094   O << '\n';
1095   processDebugLoc(MI, false);
1096 }
1097
1098 void ARMAsmPrinter::EmitStartOfAsmFile(Module &M) {
1099   if (Subtarget->isTargetDarwin()) {
1100     Reloc::Model RelocM = TM.getRelocationModel();
1101     if (RelocM == Reloc::PIC_ || RelocM == Reloc::DynamicNoPIC) {
1102       // Declare all the text sections up front (before the DWARF sections
1103       // emitted by AsmPrinter::doInitialization) so the assembler will keep
1104       // them together at the beginning of the object file.  This helps
1105       // avoid out-of-range branches that are due a fundamental limitation of
1106       // the way symbol offsets are encoded with the current Darwin ARM
1107       // relocations.
1108       TargetLoweringObjectFileMachO &TLOFMacho =
1109         static_cast<TargetLoweringObjectFileMachO &>(getObjFileLowering());
1110       OutStreamer.SwitchSection(TLOFMacho.getTextSection());
1111       OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
1112       OutStreamer.SwitchSection(TLOFMacho.getConstTextCoalSection());
1113       if (RelocM == Reloc::DynamicNoPIC) {
1114         const MCSection *sect =
1115           TLOFMacho.getMachOSection("__TEXT", "__symbol_stub4",
1116                                     MCSectionMachO::S_SYMBOL_STUBS,
1117                                     12, SectionKind::getText());
1118         OutStreamer.SwitchSection(sect);
1119       } else {
1120         const MCSection *sect =
1121           TLOFMacho.getMachOSection("__TEXT", "__picsymbolstub4",
1122                                     MCSectionMachO::S_SYMBOL_STUBS,
1123                                     16, SectionKind::getText());
1124         OutStreamer.SwitchSection(sect);
1125       }
1126     }
1127   }
1128
1129   // Use unified assembler syntax.
1130   O << "\t.syntax unified\n";
1131
1132   // Emit ARM Build Attributes
1133   if (Subtarget->isTargetELF()) {
1134     // CPU Type
1135     std::string CPUString = Subtarget->getCPUString();
1136     if (CPUString != "generic")
1137       O << "\t.cpu " << CPUString << '\n';
1138
1139     // FIXME: Emit FPU type
1140     if (Subtarget->hasVFP2())
1141       O << "\t.eabi_attribute " << ARMBuildAttrs::VFP_arch << ", 2\n";
1142
1143     // Signal various FP modes.
1144     if (!UnsafeFPMath)
1145       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_denormal << ", 1\n"
1146         << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_exceptions << ", 1\n";
1147
1148     if (FiniteOnlyFPMath())
1149       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_number_model << ", 1\n";
1150     else
1151       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_number_model << ", 3\n";
1152
1153     // 8-bytes alignment stuff.
1154     O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_align8_needed << ", 1\n"
1155       << "\t.eabi_attribute " << ARMBuildAttrs::ABI_align8_preserved << ", 1\n";
1156
1157     // Hard float.  Use both S and D registers and conform to AAPCS-VFP.
1158     if (Subtarget->isAAPCS_ABI() && FloatABIType == FloatABI::Hard)
1159       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_HardFP_use << ", 3\n"
1160         << "\t.eabi_attribute " << ARMBuildAttrs::ABI_VFP_args << ", 1\n";
1161
1162     // FIXME: Should we signal R9 usage?
1163   }
1164 }
1165
1166 void ARMAsmPrinter::PrintGlobalVariable(const GlobalVariable* GVar) {
1167   const TargetData *TD = TM.getTargetData();
1168
1169   if (!GVar->hasInitializer())   // External global require no code
1170     return;
1171
1172   // Check to see if this is a special global used by LLVM, if so, emit it.
1173
1174   if (EmitSpecialLLVMGlobal(GVar)) {
1175     if (Subtarget->isTargetDarwin() &&
1176         TM.getRelocationModel() == Reloc::Static) {
1177       if (GVar->getName() == "llvm.global_ctors")
1178         O << ".reference .constructors_used\n";
1179       else if (GVar->getName() == "llvm.global_dtors")
1180         O << ".reference .destructors_used\n";
1181     }
1182     return;
1183   }
1184
1185   std::string name = Mang->getMangledName(GVar);
1186   Constant *C = GVar->getInitializer();
1187   const Type *Type = C->getType();
1188   unsigned Size = TD->getTypeAllocSize(Type);
1189   unsigned Align = TD->getPreferredAlignmentLog(GVar);
1190   bool isDarwin = Subtarget->isTargetDarwin();
1191
1192   printVisibility(name, GVar->getVisibility());
1193
1194   if (Subtarget->isTargetELF())
1195     O << "\t.type " << name << ",%object\n";
1196
1197   const MCSection *TheSection =
1198     getObjFileLowering().SectionForGlobal(GVar, Mang, TM);
1199   OutStreamer.SwitchSection(TheSection);
1200
1201   // FIXME: get this stuff from section kind flags.
1202   if (C->isNullValue() && !GVar->hasSection() && !GVar->isThreadLocal() &&
1203       // Don't put things that should go in the cstring section into "comm".
1204       !TheSection->getKind().isMergeableCString()) {
1205     if (GVar->hasExternalLinkage()) {
1206       if (const char *Directive = MAI->getZeroFillDirective()) {
1207         O << "\t.globl\t" << name << "\n";
1208         O << Directive << "__DATA, __common, " << name << ", "
1209           << Size << ", " << Align << "\n";
1210         return;
1211       }
1212     }
1213
1214     if (GVar->hasLocalLinkage() || GVar->isWeakForLinker()) {
1215       if (Size == 0) Size = 1;   // .comm Foo, 0 is undefined, avoid it.
1216
1217       if (isDarwin) {
1218         if (GVar->hasLocalLinkage()) {
1219           O << MAI->getLCOMMDirective()  << name << "," << Size
1220             << ',' << Align;
1221         } else if (GVar->hasCommonLinkage()) {
1222           O << MAI->getCOMMDirective()  << name << "," << Size
1223             << ',' << Align;
1224         } else {
1225           OutStreamer.SwitchSection(TheSection);
1226           O << "\t.globl " << name << '\n'
1227             << MAI->getWeakDefDirective() << name << '\n';
1228           EmitAlignment(Align, GVar);
1229           O << name << ":";
1230           if (VerboseAsm) {
1231             O.PadToColumn(MAI->getCommentColumn());
1232             O << MAI->getCommentString() << ' ';
1233             WriteAsOperand(O, GVar, /*PrintType=*/false, GVar->getParent());
1234           }
1235           O << '\n';
1236           EmitGlobalConstant(C);
1237           return;
1238         }
1239       } else if (MAI->getLCOMMDirective() != NULL) {
1240         if (GVar->hasLocalLinkage()) {
1241           O << MAI->getLCOMMDirective() << name << "," << Size;
1242         } else {
1243           O << MAI->getCOMMDirective()  << name << "," << Size;
1244           if (MAI->getCOMMDirectiveTakesAlignment())
1245             O << ',' << (MAI->getAlignmentIsInBytes() ? (1 << Align) : Align);
1246         }
1247       } else {
1248         if (GVar->hasLocalLinkage())
1249           O << "\t.local\t" << name << "\n";
1250         O << MAI->getCOMMDirective()  << name << "," << Size;
1251         if (MAI->getCOMMDirectiveTakesAlignment())
1252           O << "," << (MAI->getAlignmentIsInBytes() ? (1 << Align) : Align);
1253       }
1254       if (VerboseAsm) {
1255         O.PadToColumn(MAI->getCommentColumn());
1256         O << MAI->getCommentString() << ' ';
1257         WriteAsOperand(O, GVar, /*PrintType=*/false, GVar->getParent());
1258       }
1259       O << "\n";
1260       return;
1261     }
1262   }
1263
1264   switch (GVar->getLinkage()) {
1265   case GlobalValue::CommonLinkage:
1266   case GlobalValue::LinkOnceAnyLinkage:
1267   case GlobalValue::LinkOnceODRLinkage:
1268   case GlobalValue::WeakAnyLinkage:
1269   case GlobalValue::WeakODRLinkage:
1270   case GlobalValue::LinkerPrivateLinkage:
1271     if (isDarwin) {
1272       O << "\t.globl " << name << "\n"
1273         << "\t.weak_definition " << name << "\n";
1274     } else {
1275       O << "\t.weak " << name << "\n";
1276     }
1277     break;
1278   case GlobalValue::AppendingLinkage:
1279   // FIXME: appending linkage variables should go into a section of
1280   // their name or something.  For now, just emit them as external.
1281   case GlobalValue::ExternalLinkage:
1282     O << "\t.globl " << name << "\n";
1283     break;
1284   case GlobalValue::PrivateLinkage:
1285   case GlobalValue::InternalLinkage:
1286     break;
1287   default:
1288     llvm_unreachable("Unknown linkage type!");
1289   }
1290
1291   EmitAlignment(Align, GVar);
1292   O << name << ":";
1293   if (VerboseAsm) {
1294     O.PadToColumn(MAI->getCommentColumn());
1295     O << MAI->getCommentString() << ' ';
1296     WriteAsOperand(O, GVar, /*PrintType=*/false, GVar->getParent());
1297   }
1298   O << "\n";
1299   if (MAI->hasDotTypeDotSizeDirective())
1300     O << "\t.size " << name << ", " << Size << "\n";
1301
1302   EmitGlobalConstant(C);
1303   O << '\n';
1304 }
1305
1306
1307 void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) {
1308   if (Subtarget->isTargetDarwin()) {
1309     // All darwin targets use mach-o.
1310     TargetLoweringObjectFileMachO &TLOFMacho =
1311       static_cast<TargetLoweringObjectFileMachO &>(getObjFileLowering());
1312     MachineModuleInfoMachO &MMIMacho =
1313       MMI->getObjFileInfo<MachineModuleInfoMachO>();
1314
1315     O << '\n';
1316
1317     // Output non-lazy-pointers for external and common global variables.
1318     MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetGVStubList();
1319
1320     if (!Stubs.empty()) {
1321       // Switch with ".non_lazy_symbol_pointer" directive.
1322       OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1323       EmitAlignment(2);
1324       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1325         Stubs[i].first->print(O, MAI);
1326         O << ":\n\t.indirect_symbol ";
1327         Stubs[i].second->print(O, MAI);
1328         O << "\n\t.long\t0\n";
1329       }
1330     }
1331
1332     Stubs = MMIMacho.GetHiddenGVStubList();
1333     if (!Stubs.empty()) {
1334       OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1335       EmitAlignment(2);
1336       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1337         Stubs[i].first->print(O, MAI);
1338         O << ":\n\t.long ";
1339         Stubs[i].second->print(O, MAI);
1340         O << "\n";
1341       }
1342     }
1343
1344     // Funny Darwin hack: This flag tells the linker that no global symbols
1345     // contain code that falls through to other global symbols (e.g. the obvious
1346     // implementation of multiple entry points).  If this doesn't occur, the
1347     // linker can safely perform dead code stripping.  Since LLVM never
1348     // generates code that does this, it is always safe to set.
1349     OutStreamer.EmitAssemblerFlag(MCStreamer::SubsectionsViaSymbols);
1350   }
1351 }
1352
1353 //===----------------------------------------------------------------------===//
1354
1355 void ARMAsmPrinter::printInstructionThroughMCStreamer(const MachineInstr *MI) {
1356   ARMMCInstLower MCInstLowering(OutContext, *Mang, *this);
1357   switch (MI->getOpcode()) {
1358   case ARM::t2MOVi32imm:
1359     assert(0 && "Should be lowered by thumb2it pass");
1360   default: break;
1361   case TargetInstrInfo::DBG_LABEL:
1362   case TargetInstrInfo::EH_LABEL:
1363   case TargetInstrInfo::GC_LABEL:
1364     printLabel(MI);
1365     return;
1366   case TargetInstrInfo::KILL:
1367     printKill(MI);
1368     return;
1369   case TargetInstrInfo::INLINEASM:
1370     printInlineAsm(MI);
1371     return;
1372   case TargetInstrInfo::IMPLICIT_DEF:
1373     printImplicitDef(MI);
1374     return;
1375   case ARM::PICADD: { // FIXME: Remove asm string from td file.
1376     // This is a pseudo op for a label + instruction sequence, which looks like:
1377     // LPC0:
1378     //     add r0, pc, r0
1379     // This adds the address of LPC0 to r0.
1380
1381     // Emit the label.
1382     // FIXME: MOVE TO SHARED PLACE.
1383     unsigned Id = (unsigned)MI->getOperand(2).getImm();
1384     const char *Prefix = MAI->getPrivateGlobalPrefix();
1385     MCSymbol *Label =OutContext.GetOrCreateSymbol(Twine(Prefix)
1386                          + "PC" + Twine(getFunctionNumber()) + "_" + Twine(Id));
1387     OutStreamer.EmitLabel(Label);
1388
1389
1390     // Form and emit tha dd.
1391     MCInst AddInst;
1392     AddInst.setOpcode(ARM::ADDrr);
1393     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1394     AddInst.addOperand(MCOperand::CreateReg(ARM::PC));
1395     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
1396     printMCInst(&AddInst);
1397     return;
1398   }
1399   case ARM::CONSTPOOL_ENTRY: { // FIXME: Remove asm string from td file.
1400     /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool
1401     /// in the function.  The first operand is the ID# for this instruction, the
1402     /// second is the index into the MachineConstantPool that this is, the third
1403     /// is the size in bytes of this constant pool entry.
1404     unsigned LabelId = (unsigned)MI->getOperand(0).getImm();
1405     unsigned CPIdx   = (unsigned)MI->getOperand(1).getIndex();
1406
1407     EmitAlignment(2);
1408
1409     const char *Prefix = MAI->getPrivateGlobalPrefix();
1410     MCSymbol *Label = OutContext.GetOrCreateSymbol(Twine(Prefix)+"CPI"+
1411                                                    Twine(getFunctionNumber())+
1412                                                    "_"+ Twine(LabelId));
1413     OutStreamer.EmitLabel(Label);
1414
1415     const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPIdx];
1416     if (MCPE.isMachineConstantPoolEntry())
1417       EmitMachineConstantPoolValue(MCPE.Val.MachineCPVal);
1418     else
1419       EmitGlobalConstant(MCPE.Val.ConstVal);
1420
1421     return;
1422   }
1423   case ARM::MOVi2pieces: { // FIXME: Remove asmstring from td file.
1424     // This is a hack that lowers as a two instruction sequence.
1425     unsigned DstReg = MI->getOperand(0).getReg();
1426     unsigned ImmVal = (unsigned)MI->getOperand(1).getImm();
1427
1428     unsigned SOImmValV1 = ARM_AM::getSOImmTwoPartFirst(ImmVal);
1429     unsigned SOImmValV2 = ARM_AM::getSOImmTwoPartSecond(ImmVal);
1430
1431     {
1432       MCInst TmpInst;
1433       TmpInst.setOpcode(ARM::MOVi);
1434       TmpInst.addOperand(MCOperand::CreateReg(DstReg));
1435       TmpInst.addOperand(MCOperand::CreateImm(SOImmValV1));
1436
1437       // Predicate.
1438       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1439       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1440
1441       TmpInst.addOperand(MCOperand::CreateReg(0));          // cc_out
1442       printMCInst(&TmpInst);
1443       O << '\n';
1444     }
1445
1446     {
1447       MCInst TmpInst;
1448       TmpInst.setOpcode(ARM::ORRri);
1449       TmpInst.addOperand(MCOperand::CreateReg(DstReg));     // dstreg
1450       TmpInst.addOperand(MCOperand::CreateReg(DstReg));     // inreg
1451       TmpInst.addOperand(MCOperand::CreateImm(SOImmValV2)); // so_imm
1452       // Predicate.
1453       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1454       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1455
1456       TmpInst.addOperand(MCOperand::CreateReg(0));          // cc_out
1457       printMCInst(&TmpInst);
1458     }
1459     return;
1460   }
1461   case ARM::MOVi32imm: { // FIXME: Remove asmstring from td file.
1462     // This is a hack that lowers as a two instruction sequence.
1463     unsigned DstReg = MI->getOperand(0).getReg();
1464     unsigned ImmVal = (unsigned)MI->getOperand(1).getImm();
1465
1466     {
1467       MCInst TmpInst;
1468       TmpInst.setOpcode(ARM::MOVi16);
1469       TmpInst.addOperand(MCOperand::CreateReg(DstReg));         // dstreg
1470       TmpInst.addOperand(MCOperand::CreateImm(ImmVal & 65535)); // lower16(imm)
1471
1472       // Predicate.
1473       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1474       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1475
1476       printMCInst(&TmpInst);
1477       O << '\n';
1478     }
1479
1480     {
1481       MCInst TmpInst;
1482       TmpInst.setOpcode(ARM::MOVTi16);
1483       TmpInst.addOperand(MCOperand::CreateReg(DstReg));         // dstreg
1484       TmpInst.addOperand(MCOperand::CreateReg(DstReg));         // srcreg
1485       TmpInst.addOperand(MCOperand::CreateImm(ImmVal >> 16));   // upper16(imm)
1486
1487       // Predicate.
1488       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1489       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1490
1491       printMCInst(&TmpInst);
1492     }
1493
1494     return;
1495   }
1496   }
1497
1498   MCInst TmpInst;
1499   MCInstLowering.Lower(MI, TmpInst);
1500
1501   printMCInst(&TmpInst);
1502 }
1503
1504 //===----------------------------------------------------------------------===//
1505 // Target Registry Stuff
1506 //===----------------------------------------------------------------------===//
1507
1508 static MCInstPrinter *createARMMCInstPrinter(const Target &T,
1509                                              unsigned SyntaxVariant,
1510                                              const MCAsmInfo &MAI,
1511                                              raw_ostream &O) {
1512   if (SyntaxVariant == 0)
1513     return new ARMInstPrinter(O, MAI, false);
1514   return 0;
1515 }
1516
1517 // Force static initialization.
1518 extern "C" void LLVMInitializeARMAsmPrinter() {
1519   RegisterAsmPrinter<ARMAsmPrinter> X(TheARMTarget);
1520   RegisterAsmPrinter<ARMAsmPrinter> Y(TheThumbTarget);
1521
1522   TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter);
1523   TargetRegistry::RegisterMCInstPrinter(TheThumbTarget, createARMMCInstPrinter);
1524 }
1525