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     if (MO1.getReg() == ARM::SP) {
 613       bool isFLDM = (MI->getOpcode() == ARM::FLDMD ||
 614                      MI->getOpcode() == ARM::FLDMS);
 615       O << ARM_AM::getAMSubModeAltStr(Mode, isFLDM);
 616     } else
 617       O << ARM_AM::getAMSubModeStr(Mode);
 618     return;
 619   } else if (Modifier && strcmp(Modifier, "base") == 0) {
 620     // Used for FSTM{D|S} and LSTM{D|S} operations.
 621     O << getRegisterName(MO1.getReg());
 622     if (ARM_AM::getAM5WBFlag(MO2.getImm()))
 623       O << "!";
 624     return;
 625   }
 626
 627   O << "[" << getRegisterName(MO1.getReg());
 628
 629   if (unsigned ImmOffs = ARM_AM::getAM5Offset(MO2.getImm())) {
 630     O << ", #"
 631       << (char)ARM_AM::getAM5Op(MO2.getImm())
 632       << ImmOffs*4;
 633   }
 634   O << "]";
 635 }
 636
 637 void ARMAsmPrinter::printAddrMode6Operand(const MachineInstr *MI, int Op) {
 638   const MachineOperand &MO1 = MI->getOperand(Op);
 639   const MachineOperand &MO2 = MI->getOperand(Op+1);
 640   const MachineOperand &MO3 = MI->getOperand(Op+2);
 641   const MachineOperand &MO4 = MI->getOperand(Op+3);
 642
 643   O << "[" << getRegisterName(MO1.getReg());
 644   if (MO4.getImm()) {
 645     if (Subtarget->isTargetDarwin())
 646       O << ", :";
 647     else
 648       O << " @";
 649     O << MO4.getImm();
 650   }
 651   O << "]";
 652
 653   if (ARM_AM::getAM6WBFlag(MO3.getImm())) {
 654     if (MO2.getReg() == 0)
 655       O << "!";
 656     else
 657       O << ", " << getRegisterName(MO2.getReg());
 658   }
 659 }
 660
 661 void ARMAsmPrinter::printAddrModePCOperand(const MachineInstr *MI, int Op,
 662                                            const char *Modifier) {
 663   if (Modifier && strcmp(Modifier, "label") == 0) {
 664     printPCLabel(MI, Op+1);
 665     return;
 666   }
 667
 668   const MachineOperand &MO1 = MI->getOperand(Op);
 669   assert(TargetRegisterInfo::isPhysicalRegister(MO1.getReg()));
 670   O << "[pc, +" << getRegisterName(MO1.getReg()) << "]";
 671 }
 672
 673 void
 674 ARMAsmPrinter::printBitfieldInvMaskImmOperand(const MachineInstr *MI, int Op) {
 675   const MachineOperand &MO = MI->getOperand(Op);
 676   uint32_t v = ~MO.getImm();
 677   int32_t lsb = CountTrailingZeros_32(v);
 678   int32_t width = (32 - CountLeadingZeros_32 (v)) - lsb;
 679   assert(MO.isImm() && "Not a valid bf_inv_mask_imm value!");
 680   O << "#" << lsb << ", #" << width;
 681 }
 682
 683 //===--------------------------------------------------------------------===//
 684
 685 void
 686 ARMAsmPrinter::printThumbITMask(const MachineInstr *MI, int Op) {
 687   // (3 - the number of trailing zeros) is the number of then / else.
 688   unsigned Mask = MI->getOperand(Op).getImm();
 689   unsigned NumTZ = CountTrailingZeros_32(Mask);
 690   assert(NumTZ <= 3 && "Invalid IT mask!");
 691   for (unsigned Pos = 3, e = NumTZ; Pos > e; --Pos) {
 692     bool T = (Mask & (1 << Pos)) == 0;
 693     if (T)
 694       O << 't';
 695     else
 696       O << 'e';
 697   }
 698 }
 699
 700 void
 701 ARMAsmPrinter::printThumbAddrModeRROperand(const MachineInstr *MI, int Op) {
 702   const MachineOperand &MO1 = MI->getOperand(Op);
 703   const MachineOperand &MO2 = MI->getOperand(Op+1);
 704   O << "[" << getRegisterName(MO1.getReg());
 705   O << ", " << getRegisterName(MO2.getReg()) << "]";
 706 }
 707
 708 void
 709 ARMAsmPrinter::printThumbAddrModeRI5Operand(const MachineInstr *MI, int Op,
 710                                             unsigned Scale) {
 711   const MachineOperand &MO1 = MI->getOperand(Op);
 712   const MachineOperand &MO2 = MI->getOperand(Op+1);
 713   const MachineOperand &MO3 = MI->getOperand(Op+2);
 714
 715   if (!MO1.isReg()) {   // FIXME: This is for CP entries, but isn't right.
 716     printOperand(MI, Op);
 717     return;
 718   }
 719
 720   O << "[" << getRegisterName(MO1.getReg());
 721   if (MO3.getReg())
 722     O << ", " << getRegisterName(MO3.getReg());
 723   else if (unsigned ImmOffs = MO2.getImm()) {
 724     O << ", #" << ImmOffs;
 725     if (Scale > 1)
 726       O << " * " << Scale;
 727   }
 728   O << "]";
 729 }
 730
 731 void
 732 ARMAsmPrinter::printThumbAddrModeS1Operand(const MachineInstr *MI, int Op) {
 733   printThumbAddrModeRI5Operand(MI, Op, 1);
 734 }
 735 void
 736 ARMAsmPrinter::printThumbAddrModeS2Operand(const MachineInstr *MI, int Op) {
 737   printThumbAddrModeRI5Operand(MI, Op, 2);
 738 }
 739 void
 740 ARMAsmPrinter::printThumbAddrModeS4Operand(const MachineInstr *MI, int Op) {
 741   printThumbAddrModeRI5Operand(MI, Op, 4);
 742 }
 743
 744 void ARMAsmPrinter::printThumbAddrModeSPOperand(const MachineInstr *MI,int Op) {
 745   const MachineOperand &MO1 = MI->getOperand(Op);
 746   const MachineOperand &MO2 = MI->getOperand(Op+1);
 747   O << "[" << getRegisterName(MO1.getReg());
 748   if (unsigned ImmOffs = MO2.getImm())
 749     O << ", #" << ImmOffs << " * 4";
 750   O << "]";
 751 }
 752
 753 //===--------------------------------------------------------------------===//
 754
 755 // Constant shifts t2_so_reg is a 2-operand unit corresponding to the Thumb2
 756 // register with shift forms.
 757 // REG 0   0           - e.g. R5
 758 // REG IMM, SH_OPC     - e.g. R5, LSL #3
 759 void ARMAsmPrinter::printT2SOOperand(const MachineInstr *MI, int OpNum) {
 760   const MachineOperand &MO1 = MI->getOperand(OpNum);
 761   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 762
 763   unsigned Reg = MO1.getReg();
 764   assert(TargetRegisterInfo::isPhysicalRegister(Reg));
 765   O << getRegisterName(Reg);
 766
 767   // Print the shift opc.
 768   O << ", "
 769     << ARM_AM::getShiftOpcStr(ARM_AM::getSORegShOp(MO2.getImm()))
 770     << " ";
 771
 772   assert(MO2.isImm() && "Not a valid t2_so_reg value!");
 773   O << "#" << ARM_AM::getSORegOffset(MO2.getImm());
 774 }
 775
 776 void ARMAsmPrinter::printT2AddrModeImm12Operand(const MachineInstr *MI,
 777                                                 int OpNum) {
 778   const MachineOperand &MO1 = MI->getOperand(OpNum);
 779   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 780
 781   O << "[" << getRegisterName(MO1.getReg());
 782
 783   unsigned OffImm = MO2.getImm();
 784   if (OffImm)  // Don't print +0.
 785     O << ", #+" << OffImm;
 786   O << "]";
 787 }
 788
 789 void ARMAsmPrinter::printT2AddrModeImm8Operand(const MachineInstr *MI,
 790                                                int OpNum) {
 791   const MachineOperand &MO1 = MI->getOperand(OpNum);
 792   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 793
 794   O << "[" << getRegisterName(MO1.getReg());
 795
 796   int32_t OffImm = (int32_t)MO2.getImm();
 797   // Don't print +0.
 798   if (OffImm < 0)
 799     O << ", #-" << -OffImm;
 800   else if (OffImm > 0)
 801     O << ", #+" << OffImm;
 802   O << "]";
 803 }
 804
 805 void ARMAsmPrinter::printT2AddrModeImm8s4Operand(const MachineInstr *MI,
 806                                                  int OpNum) {
 807   const MachineOperand &MO1 = MI->getOperand(OpNum);
 808   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 809
 810   O << "[" << getRegisterName(MO1.getReg());
 811
 812   int32_t OffImm = (int32_t)MO2.getImm() / 4;
 813   // Don't print +0.
 814   if (OffImm < 0)
 815     O << ", #-" << -OffImm << " * 4";
 816   else if (OffImm > 0)
 817     O << ", #+" << OffImm << " * 4";
 818   O << "]";
 819 }
 820
 821 void ARMAsmPrinter::printT2AddrModeImm8OffsetOperand(const MachineInstr *MI,
 822                                                      int OpNum) {
 823   const MachineOperand &MO1 = MI->getOperand(OpNum);
 824   int32_t OffImm = (int32_t)MO1.getImm();
 825   // Don't print +0.
 826   if (OffImm < 0)
 827     O << "#-" << -OffImm;
 828   else if (OffImm > 0)
 829     O << "#+" << OffImm;
 830 }
 831
 832 void ARMAsmPrinter::printT2AddrModeSoRegOperand(const MachineInstr *MI,
 833                                                 int OpNum) {
 834   const MachineOperand &MO1 = MI->getOperand(OpNum);
 835   const MachineOperand &MO2 = MI->getOperand(OpNum+1);
 836   const MachineOperand &MO3 = MI->getOperand(OpNum+2);
 837
 838   O << "[" << getRegisterName(MO1.getReg());
 839
 840   assert(MO2.getReg() && "Invalid so_reg load / store address!");
 841   O << ", " << getRegisterName(MO2.getReg());
 842
 843   unsigned ShAmt = MO3.getImm();
 844   if (ShAmt) {
 845     assert(ShAmt <= 3 && "Not a valid Thumb2 addressing mode!");
 846     O << ", lsl #" << ShAmt;
 847   }
 848   O << "]";
 849 }
 850
 851
 852 //===--------------------------------------------------------------------===//
 853
 854 void ARMAsmPrinter::printPredicateOperand(const MachineInstr *MI, int OpNum) {
 855   ARMCC::CondCodes CC = (ARMCC::CondCodes)MI->getOperand(OpNum).getImm();
 856   if (CC != ARMCC::AL)
 857     O << ARMCondCodeToString(CC);
 858 }
 859
 860 void ARMAsmPrinter::printSBitModifierOperand(const MachineInstr *MI, int OpNum){
 861   unsigned Reg = MI->getOperand(OpNum).getReg();
 862   if (Reg) {
 863     assert(Reg == ARM::CPSR && "Expect ARM CPSR register!");
 864     O << 's';
 865   }
 866 }
 867
 868 void ARMAsmPrinter::printPCLabel(const MachineInstr *MI, int OpNum) {
 869   int Id = (int)MI->getOperand(OpNum).getImm();
 870   O << MAI->getPrivateGlobalPrefix()
 871     << "PC" << getFunctionNumber() << "_" << Id;
 872 }
 873
 874 void ARMAsmPrinter::printRegisterList(const MachineInstr *MI, int OpNum) {
 875   O << "{";
 876   // Always skip the first operand, it's the optional (and implicit writeback).
 877   for (unsigned i = OpNum+1, e = MI->getNumOperands(); i != e; ++i) {
 878     if (MI->getOperand(i).isImplicit())
 879       continue;
 880     if ((int)i != OpNum+1) O << ", ";
 881     printOperand(MI, i);
 882   }
 883   O << "}";
 884 }
 885
 886 void ARMAsmPrinter::printCPInstOperand(const MachineInstr *MI, int OpNum,
 887                                        const char *Modifier) {
 888   assert(Modifier && "This operand only works with a modifier!");
 889   // There are two aspects to a CONSTANTPOOL_ENTRY operand, the label and the
 890   // data itself.
 891   if (!strcmp(Modifier, "label")) {
 892     unsigned ID = MI->getOperand(OpNum).getImm();
 893     O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber()
 894       << '_' << ID << ":\n";
 895   } else {
 896     assert(!strcmp(Modifier, "cpentry") && "Unknown modifier for CPE");
 897     unsigned CPI = MI->getOperand(OpNum).getIndex();
 898
 899     const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPI];
 900
 901     if (MCPE.isMachineConstantPoolEntry()) {
 902       EmitMachineConstantPoolValue(MCPE.Val.MachineCPVal);
 903     } else {
 904       EmitGlobalConstant(MCPE.Val.ConstVal);
 905     }
 906   }
 907 }
 908
 909 void ARMAsmPrinter::printJTBlockOperand(const MachineInstr *MI, int OpNum) {
 910   assert(!Subtarget->isThumb2() && "Thumb2 should use double-jump jumptables!");
 911
 912   const MachineOperand &MO1 = MI->getOperand(OpNum);
 913   const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id
 914   unsigned JTI = MO1.getIndex();
 915   O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 916     << '_' << JTI << '_' << MO2.getImm() << ":\n";
 917
 918   const char *JTEntryDirective = MAI->getData32bitsDirective();
 919
 920   const MachineFunction *MF = MI->getParent()->getParent();
 921   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
 922   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 923   const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
 924   bool UseSet= MAI->getSetDirective() && TM.getRelocationModel() == Reloc::PIC_;
 925   SmallPtrSet<MachineBasicBlock*, 8> JTSets;
 926   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
 927     MachineBasicBlock *MBB = JTBBs[i];
 928     bool isNew = JTSets.insert(MBB);
 929
 930     if (UseSet && isNew)
 931       printPICJumpTableSetLabel(JTI, MO2.getImm(), MBB);
 932
 933     O << JTEntryDirective << ' ';
 934     if (UseSet)
 935       O << MAI->getPrivateGlobalPrefix() << getFunctionNumber()
 936         << '_' << JTI << '_' << MO2.getImm()
 937         << "_set_" << MBB->getNumber();
 938     else if (TM.getRelocationModel() == Reloc::PIC_) {
 939       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 940       O << '-' << MAI->getPrivateGlobalPrefix() << "JTI"
 941         << getFunctionNumber() << '_' << JTI << '_' << MO2.getImm();
 942     } else {
 943       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 944     }
 945     if (i != e-1)
 946       O << '\n';
 947   }
 948 }
 949
 950 void ARMAsmPrinter::printJT2BlockOperand(const MachineInstr *MI, int OpNum) {
 951   const MachineOperand &MO1 = MI->getOperand(OpNum);
 952   const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id
 953   unsigned JTI = MO1.getIndex();
 954   O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 955     << '_' << JTI << '_' << MO2.getImm() << ":\n";
 956
 957   const MachineFunction *MF = MI->getParent()->getParent();
 958   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
 959   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 960   const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
 961   bool ByteOffset = false, HalfWordOffset = false;
 962   if (MI->getOpcode() == ARM::t2TBB)
 963     ByteOffset = true;
 964   else if (MI->getOpcode() == ARM::t2TBH)
 965     HalfWordOffset = true;
 966
 967   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
 968     MachineBasicBlock *MBB = JTBBs[i];
 969     if (ByteOffset)
 970       O << MAI->getData8bitsDirective();
 971     else if (HalfWordOffset)
 972       O << MAI->getData16bitsDirective();
 973     if (ByteOffset || HalfWordOffset) {
 974       O << '(';
 975       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 976       O << "-" << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 977         << '_' << JTI << '_' << MO2.getImm() << ")/2";
 978     } else {
 979       O << "\tb.w ";
 980       GetMBBSymbol(MBB->getNumber())->print(O, MAI);
 981     }
 982     if (i != e-1)
 983       O << '\n';
 984   }
 985
 986   // Make sure the instruction that follows TBB is 2-byte aligned.
 987   // FIXME: Constant island pass should insert an "ALIGN" instruction instead.
 988   if (ByteOffset && (JTBBs.size() & 1)) {
 989     O << '\n';
 990     EmitAlignment(1);
 991   }
 992 }
 993
 994 void ARMAsmPrinter::printTBAddrMode(const MachineInstr *MI, int OpNum) {
 995   O << "[pc, " << getRegisterName(MI->getOperand(OpNum).getReg());
 996   if (MI->getOpcode() == ARM::t2TBH)
 997     O << ", lsl #1";
 998   O << ']';
 999 }
1000
1001 void ARMAsmPrinter::printNoHashImmediate(const MachineInstr *MI, int OpNum) {
1002   O << MI->getOperand(OpNum).getImm();
1003 }
1004
1005 void ARMAsmPrinter::printVFPf32ImmOperand(const MachineInstr *MI, int OpNum) {
1006   const ConstantFP *FP = MI->getOperand(OpNum).getFPImm();
1007   O << '#' << ARM::getVFPf32Imm(FP->getValueAPF());
1008   if (VerboseAsm) {
1009     O.PadToColumn(MAI->getCommentColumn());
1010     O << MAI->getCommentString() << ' ';
1011     WriteAsOperand(O, FP, /*PrintType=*/false);
1012   }
1013 }
1014
1015 void ARMAsmPrinter::printVFPf64ImmOperand(const MachineInstr *MI, int OpNum) {
1016   const ConstantFP *FP = MI->getOperand(OpNum).getFPImm();
1017   O << '#' << ARM::getVFPf64Imm(FP->getValueAPF());
1018   if (VerboseAsm) {
1019     O.PadToColumn(MAI->getCommentColumn());
1020     O << MAI->getCommentString() << ' ';
1021     WriteAsOperand(O, FP, /*PrintType=*/false);
1022   }
1023 }
1024
1025 bool ARMAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
1026                                     unsigned AsmVariant, const char *ExtraCode){
1027   // Does this asm operand have a single letter operand modifier?
1028   if (ExtraCode && ExtraCode[0]) {
1029     if (ExtraCode[1] != 0) return true; // Unknown modifier.
1030
1031     switch (ExtraCode[0]) {
1032     default: return true;  // Unknown modifier.
1033     case 'a': // Print as a memory address.
1034       if (MI->getOperand(OpNum).isReg()) {
1035         O << "[" << getRegisterName(MI->getOperand(OpNum).getReg()) << "]";
1036         return false;
1037       }
1038       // Fallthrough
1039     case 'c': // Don't print "#" before an immediate operand.
1040       if (!MI->getOperand(OpNum).isImm())
1041         return true;
1042       printNoHashImmediate(MI, OpNum);
1043       return false;
1044     case 'P': // Print a VFP double precision register.
1045       printOperand(MI, OpNum);
1046       return false;
1047     case 'Q':
1048       if (TM.getTargetData()->isLittleEndian())
1049         break;
1050       // Fallthrough
1051     case 'R':
1052       if (TM.getTargetData()->isBigEndian())
1053         break;
1054       // Fallthrough
1055     case 'H': // Write second word of DI / DF reference.
1056       // Verify that this operand has two consecutive registers.
1057       if (!MI->getOperand(OpNum).isReg() ||
1058           OpNum+1 == MI->getNumOperands() ||
1059           !MI->getOperand(OpNum+1).isReg())
1060         return true;
1061       ++OpNum;   // Return the high-part.
1062     }
1063   }
1064
1065   printOperand(MI, OpNum);
1066   return false;
1067 }
1068
1069 bool ARMAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
1070                                           unsigned OpNum, unsigned AsmVariant,
1071                                           const char *ExtraCode) {
1072   if (ExtraCode && ExtraCode[0])
1073     return true; // Unknown modifier.
1074
1075   const MachineOperand &MO = MI->getOperand(OpNum);
1076   assert(MO.isReg() && "unexpected inline asm memory operand");
1077   O << "[" << getRegisterName(MO.getReg()) << "]";
1078   return false;
1079 }
1080
1081 void ARMAsmPrinter::printMachineInstruction(const MachineInstr *MI) {
1082   ++EmittedInsts;
1083
1084   // Call the autogenerated instruction printer routines.
1085   processDebugLoc(MI, true);
1086
1087   if (EnableMCInst) {
1088     printInstructionThroughMCStreamer(MI);
1089   } else {
1090     int Opc = MI->getOpcode();
1091     if (Opc == ARM::CONSTPOOL_ENTRY)
1092       EmitAlignment(2);
1093
1094     printInstruction(MI);
1095   }
1096
1097   if (VerboseAsm && !MI->getDebugLoc().isUnknown())
1098     EmitComments(*MI);
1099   O << '\n';
1100   processDebugLoc(MI, false);
1101 }
1102
1103 void ARMAsmPrinter::EmitStartOfAsmFile(Module &M) {
1104   if (Subtarget->isTargetDarwin()) {
1105     Reloc::Model RelocM = TM.getRelocationModel();
1106     if (RelocM == Reloc::PIC_ || RelocM == Reloc::DynamicNoPIC) {
1107       // Declare all the text sections up front (before the DWARF sections
1108       // emitted by AsmPrinter::doInitialization) so the assembler will keep
1109       // them together at the beginning of the object file.  This helps
1110       // avoid out-of-range branches that are due a fundamental limitation of
1111       // the way symbol offsets are encoded with the current Darwin ARM
1112       // relocations.
1113       TargetLoweringObjectFileMachO &TLOFMacho =
1114         static_cast<TargetLoweringObjectFileMachO &>(getObjFileLowering());
1115       OutStreamer.SwitchSection(TLOFMacho.getTextSection());
1116       OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
1117       OutStreamer.SwitchSection(TLOFMacho.getConstTextCoalSection());
1118       if (RelocM == Reloc::DynamicNoPIC) {
1119         const MCSection *sect =
1120           TLOFMacho.getMachOSection("__TEXT", "__symbol_stub4",
1121                                     MCSectionMachO::S_SYMBOL_STUBS,
1122                                     12, SectionKind::getText());
1123         OutStreamer.SwitchSection(sect);
1124       } else {
1125         const MCSection *sect =
1126           TLOFMacho.getMachOSection("__TEXT", "__picsymbolstub4",
1127                                     MCSectionMachO::S_SYMBOL_STUBS,
1128                                     16, SectionKind::getText());
1129         OutStreamer.SwitchSection(sect);
1130       }
1131     }
1132   }
1133
1134   // Use unified assembler syntax mode for Thumb.
1135   if (Subtarget->isThumb())
1136     O << "\t.syntax unified\n";
1137
1138   // Emit ARM Build Attributes
1139   if (Subtarget->isTargetELF()) {
1140     // CPU Type
1141     std::string CPUString = Subtarget->getCPUString();
1142     if (CPUString != "generic")
1143       O << "\t.cpu " << CPUString << '\n';
1144
1145     // FIXME: Emit FPU type
1146     if (Subtarget->hasVFP2())
1147       O << "\t.eabi_attribute " << ARMBuildAttrs::VFP_arch << ", 2\n";
1148
1149     // Signal various FP modes.
1150     if (!UnsafeFPMath)
1151       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_denormal << ", 1\n"
1152         << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_exceptions << ", 1\n";
1153
1154     if (FiniteOnlyFPMath())
1155       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_number_model << ", 1\n";
1156     else
1157       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_FP_number_model << ", 3\n";
1158
1159     // 8-bytes alignment stuff.
1160     O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_align8_needed << ", 1\n"
1161       << "\t.eabi_attribute " << ARMBuildAttrs::ABI_align8_preserved << ", 1\n";
1162
1163     // Hard float.  Use both S and D registers and conform to AAPCS-VFP.
1164     if (Subtarget->isAAPCS_ABI() && FloatABIType == FloatABI::Hard)
1165       O << "\t.eabi_attribute " << ARMBuildAttrs::ABI_HardFP_use << ", 3\n"
1166         << "\t.eabi_attribute " << ARMBuildAttrs::ABI_VFP_args << ", 1\n";
1167
1168     // FIXME: Should we signal R9 usage?
1169   }
1170 }
1171
1172 void ARMAsmPrinter::PrintGlobalVariable(const GlobalVariable* GVar) {
1173   const TargetData *TD = TM.getTargetData();
1174
1175   if (!GVar->hasInitializer())   // External global require no code
1176     return;
1177
1178   // Check to see if this is a special global used by LLVM, if so, emit it.
1179
1180   if (EmitSpecialLLVMGlobal(GVar)) {
1181     if (Subtarget->isTargetDarwin() &&
1182         TM.getRelocationModel() == Reloc::Static) {
1183       if (GVar->getName() == "llvm.global_ctors")
1184         O << ".reference .constructors_used\n";
1185       else if (GVar->getName() == "llvm.global_dtors")
1186         O << ".reference .destructors_used\n";
1187     }
1188     return;
1189   }
1190
1191   std::string name = Mang->getMangledName(GVar);
1192   Constant *C = GVar->getInitializer();
1193   const Type *Type = C->getType();
1194   unsigned Size = TD->getTypeAllocSize(Type);
1195   unsigned Align = TD->getPreferredAlignmentLog(GVar);
1196   bool isDarwin = Subtarget->isTargetDarwin();
1197
1198   printVisibility(name, GVar->getVisibility());
1199
1200   if (Subtarget->isTargetELF())
1201     O << "\t.type " << name << ",%object\n";
1202
1203   const MCSection *TheSection =
1204     getObjFileLowering().SectionForGlobal(GVar, Mang, TM);
1205   OutStreamer.SwitchSection(TheSection);
1206
1207   // FIXME: get this stuff from section kind flags.
1208   if (C->isNullValue() && !GVar->hasSection() && !GVar->isThreadLocal() &&
1209       // Don't put things that should go in the cstring section into "comm".
1210       !TheSection->getKind().isMergeableCString()) {
1211     if (GVar->hasExternalLinkage()) {
1212       if (const char *Directive = MAI->getZeroFillDirective()) {
1213         O << "\t.globl\t" << name << "\n";
1214         O << Directive << "__DATA, __common, " << name << ", "
1215           << Size << ", " << Align << "\n";
1216         return;
1217       }
1218     }
1219
1220     if (GVar->hasLocalLinkage() || GVar->isWeakForLinker()) {
1221       if (Size == 0) Size = 1;   // .comm Foo, 0 is undefined, avoid it.
1222
1223       if (isDarwin) {
1224         if (GVar->hasLocalLinkage()) {
1225           O << MAI->getLCOMMDirective()  << name << "," << Size
1226             << ',' << Align;
1227         } else if (GVar->hasCommonLinkage()) {
1228           O << MAI->getCOMMDirective()  << name << "," << Size
1229             << ',' << Align;
1230         } else {
1231           OutStreamer.SwitchSection(TheSection);
1232           O << "\t.globl " << name << '\n'
1233             << MAI->getWeakDefDirective() << name << '\n';
1234           EmitAlignment(Align, GVar);
1235           O << name << ":";
1236           if (VerboseAsm) {
1237             O.PadToColumn(MAI->getCommentColumn());
1238             O << MAI->getCommentString() << ' ';
1239             WriteAsOperand(O, GVar, /*PrintType=*/false, GVar->getParent());
1240           }
1241           O << '\n';
1242           EmitGlobalConstant(C);
1243           return;
1244         }
1245       } else if (MAI->getLCOMMDirective() != NULL) {
1246         if (GVar->hasLocalLinkage()) {
1247           O << MAI->getLCOMMDirective() << name << "," << Size;
1248         } else {
1249           O << MAI->getCOMMDirective()  << name << "," << Size;
1250           if (MAI->getCOMMDirectiveTakesAlignment())
1251             O << ',' << (MAI->getAlignmentIsInBytes() ? (1 << Align) : Align);
1252         }
1253       } else {
1254         if (GVar->hasLocalLinkage())
1255           O << "\t.local\t" << name << "\n";
1256         O << MAI->getCOMMDirective()  << name << "," << Size;
1257         if (MAI->getCOMMDirectiveTakesAlignment())
1258           O << "," << (MAI->getAlignmentIsInBytes() ? (1 << Align) : Align);
1259       }
1260       if (VerboseAsm) {
1261         O.PadToColumn(MAI->getCommentColumn());
1262         O << MAI->getCommentString() << ' ';
1263         WriteAsOperand(O, GVar, /*PrintType=*/false, GVar->getParent());
1264       }
1265       O << "\n";
1266       return;
1267     }
1268   }
1269
1270   switch (GVar->getLinkage()) {
1271   case GlobalValue::CommonLinkage:
1272   case GlobalValue::LinkOnceAnyLinkage:
1273   case GlobalValue::LinkOnceODRLinkage:
1274   case GlobalValue::WeakAnyLinkage:
1275   case GlobalValue::WeakODRLinkage:
1276   case GlobalValue::LinkerPrivateLinkage:
1277     if (isDarwin) {
1278       O << "\t.globl " << name << "\n"
1279         << "\t.weak_definition " << name << "\n";
1280     } else {
1281       O << "\t.weak " << name << "\n";
1282     }
1283     break;
1284   case GlobalValue::AppendingLinkage:
1285   // FIXME: appending linkage variables should go into a section of
1286   // their name or something.  For now, just emit them as external.
1287   case GlobalValue::ExternalLinkage:
1288     O << "\t.globl " << name << "\n";
1289     break;
1290   case GlobalValue::PrivateLinkage:
1291   case GlobalValue::InternalLinkage:
1292     break;
1293   default:
1294     llvm_unreachable("Unknown linkage type!");
1295   }
1296
1297   EmitAlignment(Align, GVar);
1298   O << name << ":";
1299   if (VerboseAsm) {
1300     O.PadToColumn(MAI->getCommentColumn());
1301     O << MAI->getCommentString() << ' ';
1302     WriteAsOperand(O, GVar, /*PrintType=*/false, GVar->getParent());
1303   }
1304   O << "\n";
1305   if (MAI->hasDotTypeDotSizeDirective())
1306     O << "\t.size " << name << ", " << Size << "\n";
1307
1308   EmitGlobalConstant(C);
1309   O << '\n';
1310 }
1311
1312
1313 void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) {
1314   if (Subtarget->isTargetDarwin()) {
1315     // All darwin targets use mach-o.
1316     TargetLoweringObjectFileMachO &TLOFMacho =
1317       static_cast<TargetLoweringObjectFileMachO &>(getObjFileLowering());
1318     MachineModuleInfoMachO &MMIMacho =
1319       MMI->getObjFileInfo<MachineModuleInfoMachO>();
1320
1321     O << '\n';
1322
1323     // Output non-lazy-pointers for external and common global variables.
1324     MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetGVStubList();
1325
1326     if (!Stubs.empty()) {
1327       // Switch with ".non_lazy_symbol_pointer" directive.
1328       OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
1329       EmitAlignment(2);
1330       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1331         Stubs[i].first->print(O, MAI);
1332         O << ":\n\t.indirect_symbol ";
1333         Stubs[i].second->print(O, MAI);
1334         O << "\n\t.long\t0\n";
1335       }
1336     }
1337
1338     Stubs = MMIMacho.GetHiddenGVStubList();
1339     if (!Stubs.empty()) {
1340       OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
1341       EmitAlignment(2);
1342       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
1343         Stubs[i].first->print(O, MAI);
1344         O << ":\n\t.long ";
1345         Stubs[i].second->print(O, MAI);
1346         O << "\n";
1347       }
1348     }
1349
1350     // Funny Darwin hack: This flag tells the linker that no global symbols
1351     // contain code that falls through to other global symbols (e.g. the obvious
1352     // implementation of multiple entry points).  If this doesn't occur, the
1353     // linker can safely perform dead code stripping.  Since LLVM never
1354     // generates code that does this, it is always safe to set.
1355     OutStreamer.EmitAssemblerFlag(MCStreamer::SubsectionsViaSymbols);
1356   }
1357 }
1358
1359 //===----------------------------------------------------------------------===//
1360
1361 void ARMAsmPrinter::printInstructionThroughMCStreamer(const MachineInstr *MI) {
1362   ARMMCInstLower MCInstLowering(OutContext, *Mang, *this);
1363   switch (MI->getOpcode()) {
1364   case ARM::t2MOVi32imm:
1365     assert(0 && "Should be lowered by thumb2it pass");
1366   default: break;
1367   case TargetInstrInfo::DBG_LABEL:
1368   case TargetInstrInfo::EH_LABEL:
1369   case TargetInstrInfo::GC_LABEL:
1370     printLabel(MI);
1371     return;
1372   case TargetInstrInfo::KILL:
1373     printKill(MI);
1374     return;
1375   case TargetInstrInfo::INLINEASM:
1376     printInlineAsm(MI);
1377     return;
1378   case TargetInstrInfo::IMPLICIT_DEF:
1379     printImplicitDef(MI);
1380     return;
1381   case ARM::PICADD: { // FIXME: Remove asm string from td file.
1382     // This is a pseudo op for a label + instruction sequence, which looks like:
1383     // LPC0:
1384     //     add r0, pc, r0
1385     // This adds the address of LPC0 to r0.
1386
1387     // Emit the label.
1388     // FIXME: MOVE TO SHARED PLACE.
1389     unsigned Id = (unsigned)MI->getOperand(2).getImm();
1390     const char *Prefix = MAI->getPrivateGlobalPrefix();
1391     MCSymbol *Label =OutContext.GetOrCreateSymbol(Twine(Prefix)
1392                          + "PC" + Twine(getFunctionNumber()) + "_" + Twine(Id));
1393     OutStreamer.EmitLabel(Label);
1394
1395
1396     // Form and emit tha dd.
1397     MCInst AddInst;
1398     AddInst.setOpcode(ARM::ADDrr);
1399     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1400     AddInst.addOperand(MCOperand::CreateReg(ARM::PC));
1401     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
1402     printMCInst(&AddInst);
1403     return;
1404   }
1405   case ARM::CONSTPOOL_ENTRY: { // FIXME: Remove asm string from td file.
1406     /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool
1407     /// in the function.  The first operand is the ID# for this instruction, the
1408     /// second is the index into the MachineConstantPool that this is, the third
1409     /// is the size in bytes of this constant pool entry.
1410     unsigned LabelId = (unsigned)MI->getOperand(0).getImm();
1411     unsigned CPIdx   = (unsigned)MI->getOperand(1).getIndex();
1412
1413     EmitAlignment(2);
1414
1415     const char *Prefix = MAI->getPrivateGlobalPrefix();
1416     MCSymbol *Label = OutContext.GetOrCreateSymbol(Twine(Prefix)+"CPI"+
1417                                                    Twine(getFunctionNumber())+
1418                                                    "_"+ Twine(LabelId));
1419     OutStreamer.EmitLabel(Label);
1420
1421     const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPIdx];
1422     if (MCPE.isMachineConstantPoolEntry())
1423       EmitMachineConstantPoolValue(MCPE.Val.MachineCPVal);
1424     else
1425       EmitGlobalConstant(MCPE.Val.ConstVal);
1426
1427     return;
1428   }
1429   case ARM::MOVi2pieces: { // FIXME: Remove asmstring from td file.
1430     // This is a hack that lowers as a two instruction sequence.
1431     unsigned DstReg = MI->getOperand(0).getReg();
1432     unsigned ImmVal = (unsigned)MI->getOperand(1).getImm();
1433
1434     unsigned SOImmValV1 = ARM_AM::getSOImmTwoPartFirst(ImmVal);
1435     unsigned SOImmValV2 = ARM_AM::getSOImmTwoPartSecond(ImmVal);
1436
1437     {
1438       MCInst TmpInst;
1439       TmpInst.setOpcode(ARM::MOVi);
1440       TmpInst.addOperand(MCOperand::CreateReg(DstReg));
1441       TmpInst.addOperand(MCOperand::CreateImm(SOImmValV1));
1442
1443       // Predicate.
1444       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1445       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1446
1447       TmpInst.addOperand(MCOperand::CreateReg(0));          // cc_out
1448       printMCInst(&TmpInst);
1449       O << '\n';
1450     }
1451
1452     {
1453       MCInst TmpInst;
1454       TmpInst.setOpcode(ARM::ORRri);
1455       TmpInst.addOperand(MCOperand::CreateReg(DstReg));     // dstreg
1456       TmpInst.addOperand(MCOperand::CreateReg(DstReg));     // inreg
1457       TmpInst.addOperand(MCOperand::CreateImm(SOImmValV2)); // so_imm
1458       // Predicate.
1459       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1460       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1461
1462       TmpInst.addOperand(MCOperand::CreateReg(0));          // cc_out
1463       printMCInst(&TmpInst);
1464     }
1465     return;
1466   }
1467   case ARM::MOVi32imm: { // FIXME: Remove asmstring from td file.
1468     // This is a hack that lowers as a two instruction sequence.
1469     unsigned DstReg = MI->getOperand(0).getReg();
1470     unsigned ImmVal = (unsigned)MI->getOperand(1).getImm();
1471
1472     {
1473       MCInst TmpInst;
1474       TmpInst.setOpcode(ARM::MOVi16);
1475       TmpInst.addOperand(MCOperand::CreateReg(DstReg));         // dstreg
1476       TmpInst.addOperand(MCOperand::CreateImm(ImmVal & 65535)); // lower16(imm)
1477
1478       // Predicate.
1479       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1480       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1481
1482       printMCInst(&TmpInst);
1483       O << '\n';
1484     }
1485
1486     {
1487       MCInst TmpInst;
1488       TmpInst.setOpcode(ARM::MOVTi16);
1489       TmpInst.addOperand(MCOperand::CreateReg(DstReg));         // dstreg
1490       TmpInst.addOperand(MCOperand::CreateReg(DstReg));         // srcreg
1491       TmpInst.addOperand(MCOperand::CreateImm(ImmVal >> 16));   // upper16(imm)
1492
1493       // Predicate.
1494       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1495       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(3).getReg()));
1496
1497       printMCInst(&TmpInst);
1498     }
1499
1500     return;
1501   }
1502   }
1503
1504   MCInst TmpInst;
1505   MCInstLowering.Lower(MI, TmpInst);
1506
1507   printMCInst(&TmpInst);
1508 }
1509
1510 //===----------------------------------------------------------------------===//
1511 // Target Registry Stuff
1512 //===----------------------------------------------------------------------===//
1513
1514 static MCInstPrinter *createARMMCInstPrinter(const Target &T,
1515                                              unsigned SyntaxVariant,
1516                                              const MCAsmInfo &MAI,
1517                                              raw_ostream &O) {
1518   if (SyntaxVariant == 0)
1519     return new ARMInstPrinter(O, MAI, false);
1520   return 0;
1521 }
1522
1523 // Force static initialization.
1524 extern "C" void LLVMInitializeARMAsmPrinter() {
1525   RegisterAsmPrinter<ARMAsmPrinter> X(TheARMTarget);
1526   RegisterAsmPrinter<ARMAsmPrinter> Y(TheThumbTarget);
1527
1528   TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter);
1529   TargetRegistry::RegisterMCInstPrinter(TheThumbTarget, createARMMCInstPrinter);
1530 }
1531