lib/Target/ARM/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 "ARMAsmPrinter.h"
  18 #include "ARMAddressingModes.h"
  19 #include "ARMBuildAttrs.h"
  20 #include "ARMBaseRegisterInfo.h"
  21 #include "ARMConstantPoolValue.h"
  22 #include "ARMMachineFunctionInfo.h"
  23 #include "ARMMCExpr.h"
  24 #include "ARMTargetMachine.h"
  25 #include "ARMTargetObjectFile.h"
  26 #include "InstPrinter/ARMInstPrinter.h"
  27 #include "llvm/Analysis/DebugInfo.h"
  28 #include "llvm/Constants.h"
  29 #include "llvm/Module.h"
  30 #include "llvm/Type.h"
  31 #include "llvm/Assembly/Writer.h"
  32 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  33 #include "llvm/CodeGen/MachineFunctionPass.h"
  34 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  35 #include "llvm/MC/MCAsmInfo.h"
  36 #include "llvm/MC/MCAssembler.h"
  37 #include "llvm/MC/MCContext.h"
  38 #include "llvm/MC/MCExpr.h"
  39 #include "llvm/MC/MCInst.h"
  40 #include "llvm/MC/MCSectionMachO.h"
  41 #include "llvm/MC/MCObjectStreamer.h"
  42 #include "llvm/MC/MCStreamer.h"
  43 #include "llvm/MC/MCSymbol.h"
  44 #include "llvm/Target/Mangler.h"
  45 #include "llvm/Target/TargetData.h"
  46 #include "llvm/Target/TargetMachine.h"
  47 #include "llvm/Target/TargetOptions.h"
  48 #include "llvm/Target/TargetRegistry.h"
  49 #include "llvm/ADT/SmallPtrSet.h"
  50 #include "llvm/ADT/SmallString.h"
  51 #include "llvm/ADT/StringExtras.h"
  52 #include "llvm/Support/CommandLine.h"
  53 #include "llvm/Support/Debug.h"
  54 #include "llvm/Support/ErrorHandling.h"
  55 #include "llvm/Support/raw_ostream.h"
  56 #include <cctype>
  57 using namespace llvm;
  58
  59 namespace {
  60
  61   // Per section and per symbol attributes are not supported.
  62   // To implement them we would need the ability to delay this emission
  63   // until the assembly file is fully parsed/generated as only then do we
  64   // know the symbol and section numbers.
  65   class AttributeEmitter {
  66   public:
  67     virtual void MaybeSwitchVendor(StringRef Vendor) = 0;
  68     virtual void EmitAttribute(unsigned Attribute, unsigned Value) = 0;
  69     virtual void Finish() = 0;
  70     virtual ~AttributeEmitter() {}
  71   };
  72
  73   class AsmAttributeEmitter : public AttributeEmitter {
  74     MCStreamer &Streamer;
  75
  76   public:
  77     AsmAttributeEmitter(MCStreamer &Streamer_) : Streamer(Streamer_) {}
  78     void MaybeSwitchVendor(StringRef Vendor) { }
  79
  80     void EmitAttribute(unsigned Attribute, unsigned Value) {
  81       Streamer.EmitRawText("\t.eabi_attribute " +
  82                            Twine(Attribute) + ", " + Twine(Value));
  83     }
  84
  85     void Finish() { }
  86   };
  87
  88   class ObjectAttributeEmitter : public AttributeEmitter {
  89     MCObjectStreamer &Streamer;
  90     StringRef CurrentVendor;
  91     SmallString<64> Contents;
  92
  93   public:
  94     ObjectAttributeEmitter(MCObjectStreamer &Streamer_) :
  95       Streamer(Streamer_), CurrentVendor("") { }
  96
  97     void MaybeSwitchVendor(StringRef Vendor) {
  98       assert(!Vendor.empty() && "Vendor cannot be empty.");
  99
 100       if (CurrentVendor.empty())
 101         CurrentVendor = Vendor;
 102       else if (CurrentVendor == Vendor)
 103         return;
 104       else
 105         Finish();
 106
 107       CurrentVendor = Vendor;
 108
 109       assert(Contents.size() == 0);
 110     }
 111
 112     void EmitAttribute(unsigned Attribute, unsigned Value) {
 113       // FIXME: should be ULEB
 114       Contents += Attribute;
 115       Contents += Value;
 116     }
 117
 118     void Finish() {
 119       const size_t ContentsSize = Contents.size();
 120
 121       // Vendor size + Vendor name + '\0'
 122       const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;
 123
 124       // Tag + Tag Size
 125       const size_t TagHeaderSize = 1 + 4;
 126
 127       Streamer.EmitIntValue(VendorHeaderSize + TagHeaderSize + ContentsSize, 4);
 128       Streamer.EmitBytes(CurrentVendor, 0);
 129       Streamer.EmitIntValue(0, 1); // '\0'
 130
 131       Streamer.EmitIntValue(ARMBuildAttrs::File, 1);
 132       Streamer.EmitIntValue(TagHeaderSize + ContentsSize, 4);
 133
 134       Streamer.EmitBytes(Contents, 0);
 135
 136       Contents.clear();
 137     }
 138   };
 139
 140 } // end of anonymous namespace
 141
 142 MachineLocation ARMAsmPrinter::
 143 getDebugValueLocation(const MachineInstr *MI) const {
 144   MachineLocation Location;
 145   assert(MI->getNumOperands() == 4 && "Invalid no. of machine operands!");
 146   // Frame address.  Currently handles register +- offset only.
 147   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm())
 148     Location.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
 149   else {
 150     DEBUG(dbgs() << "DBG_VALUE instruction ignored! " << *MI << "\n");
 151   }
 152   return Location;
 153 }
 154
 155 void ARMAsmPrinter::EmitFunctionEntryLabel() {
 156   if (AFI->isThumbFunction()) {
 157     OutStreamer.EmitAssemblerFlag(MCAF_Code16);
 158     OutStreamer.EmitThumbFunc(Subtarget->isTargetDarwin()? CurrentFnSym : 0);
 159   }
 160
 161   OutStreamer.EmitLabel(CurrentFnSym);
 162 }
 163
 164 /// runOnMachineFunction - This uses the EmitInstruction()
 165 /// method to print assembly for each instruction.
 166 ///
 167 bool ARMAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 168   AFI = MF.getInfo<ARMFunctionInfo>();
 169   MCP = MF.getConstantPool();
 170
 171   return AsmPrinter::runOnMachineFunction(MF);
 172 }
 173
 174 void ARMAsmPrinter::printOperand(const MachineInstr *MI, int OpNum,
 175                                  raw_ostream &O, const char *Modifier) {
 176   const MachineOperand &MO = MI->getOperand(OpNum);
 177   unsigned TF = MO.getTargetFlags();
 178
 179   switch (MO.getType()) {
 180   default:
 181     assert(0 && "<unknown operand type>");
 182   case MachineOperand::MO_Register: {
 183     unsigned Reg = MO.getReg();
 184     assert(TargetRegisterInfo::isPhysicalRegister(Reg));
 185     assert(!MO.getSubReg() && "Subregs should be eliminated!");
 186     O << ARMInstPrinter::getRegisterName(Reg);
 187     break;
 188   }
 189   case MachineOperand::MO_Immediate: {
 190     int64_t Imm = MO.getImm();
 191     O << '#';
 192     if ((Modifier && strcmp(Modifier, "lo16") == 0) ||
 193         (TF == ARMII::MO_LO16))
 194       O << ":lower16:";
 195     else if ((Modifier && strcmp(Modifier, "hi16") == 0) ||
 196              (TF == ARMII::MO_HI16))
 197       O << ":upper16:";
 198     O << Imm;
 199     break;
 200   }
 201   case MachineOperand::MO_MachineBasicBlock:
 202     O << *MO.getMBB()->getSymbol();
 203     return;
 204   case MachineOperand::MO_GlobalAddress: {
 205     const GlobalValue *GV = MO.getGlobal();
 206     if ((Modifier && strcmp(Modifier, "lo16") == 0) ||
 207         (TF & ARMII::MO_LO16))
 208       O << ":lower16:";
 209     else if ((Modifier && strcmp(Modifier, "hi16") == 0) ||
 210              (TF & ARMII::MO_HI16))
 211       O << ":upper16:";
 212     O << *Mang->getSymbol(GV);
 213
 214     printOffset(MO.getOffset(), O);
 215     if (TF == ARMII::MO_PLT)
 216       O << "(PLT)";
 217     break;
 218   }
 219   case MachineOperand::MO_ExternalSymbol: {
 220     O << *GetExternalSymbolSymbol(MO.getSymbolName());
 221     if (TF == ARMII::MO_PLT)
 222       O << "(PLT)";
 223     break;
 224   }
 225   case MachineOperand::MO_ConstantPoolIndex:
 226     O << *GetCPISymbol(MO.getIndex());
 227     break;
 228   case MachineOperand::MO_JumpTableIndex:
 229     O << *GetJTISymbol(MO.getIndex());
 230     break;
 231   }
 232 }
 233
 234 //===--------------------------------------------------------------------===//
 235
 236 MCSymbol *ARMAsmPrinter::
 237 GetARMSetPICJumpTableLabel2(unsigned uid, unsigned uid2,
 238                             const MachineBasicBlock *MBB) const {
 239   SmallString<60> Name;
 240   raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix()
 241     << getFunctionNumber() << '_' << uid << '_' << uid2
 242     << "_set_" << MBB->getNumber();
 243   return OutContext.GetOrCreateSymbol(Name.str());
 244 }
 245
 246 MCSymbol *ARMAsmPrinter::
 247 GetARMJTIPICJumpTableLabel2(unsigned uid, unsigned uid2) const {
 248   SmallString<60> Name;
 249   raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() << "JTI"
 250     << getFunctionNumber() << '_' << uid << '_' << uid2;
 251   return OutContext.GetOrCreateSymbol(Name.str());
 252 }
 253
 254
 255 MCSymbol *ARMAsmPrinter::GetARMSJLJEHLabel(void) const {
 256   SmallString<60> Name;
 257   raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() << "SJLJEH"
 258     << getFunctionNumber();
 259   return OutContext.GetOrCreateSymbol(Name.str());
 260 }
 261
 262 bool ARMAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
 263                                     unsigned AsmVariant, const char *ExtraCode,
 264                                     raw_ostream &O) {
 265   // Does this asm operand have a single letter operand modifier?
 266   if (ExtraCode && ExtraCode[0]) {
 267     if (ExtraCode[1] != 0) return true; // Unknown modifier.
 268
 269     switch (ExtraCode[0]) {
 270     default: return true;  // Unknown modifier.
 271     case 'a': // Print as a memory address.
 272       if (MI->getOperand(OpNum).isReg()) {
 273         O << "["
 274           << ARMInstPrinter::getRegisterName(MI->getOperand(OpNum).getReg())
 275           << "]";
 276         return false;
 277       }
 278       // Fallthrough
 279     case 'c': // Don't print "#" before an immediate operand.
 280       if (!MI->getOperand(OpNum).isImm())
 281         return true;
 282       O << MI->getOperand(OpNum).getImm();
 283       return false;
 284     case 'P': // Print a VFP double precision register.
 285     case 'q': // Print a NEON quad precision register.
 286       printOperand(MI, OpNum, O);
 287       return false;
 288     case 'Q':
 289     case 'R':
 290     case 'H':
 291       // These modifiers are not yet supported.
 292       return true;
 293     }
 294   }
 295
 296   printOperand(MI, OpNum, O);
 297   return false;
 298 }
 299
 300 bool ARMAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 301                                           unsigned OpNum, unsigned AsmVariant,
 302                                           const char *ExtraCode,
 303                                           raw_ostream &O) {
 304   if (ExtraCode && ExtraCode[0])
 305     return true; // Unknown modifier.
 306
 307   const MachineOperand &MO = MI->getOperand(OpNum);
 308   assert(MO.isReg() && "unexpected inline asm memory operand");
 309   O << "[" << ARMInstPrinter::getRegisterName(MO.getReg()) << "]";
 310   return false;
 311 }
 312
 313 void ARMAsmPrinter::EmitStartOfAsmFile(Module &M) {
 314   if (Subtarget->isTargetDarwin()) {
 315     Reloc::Model RelocM = TM.getRelocationModel();
 316     if (RelocM == Reloc::PIC_ || RelocM == Reloc::DynamicNoPIC) {
 317       // Declare all the text sections up front (before the DWARF sections
 318       // emitted by AsmPrinter::doInitialization) so the assembler will keep
 319       // them together at the beginning of the object file.  This helps
 320       // avoid out-of-range branches that are due a fundamental limitation of
 321       // the way symbol offsets are encoded with the current Darwin ARM
 322       // relocations.
 323       const TargetLoweringObjectFileMachO &TLOFMacho =
 324         static_cast<const TargetLoweringObjectFileMachO &>(
 325           getObjFileLowering());
 326       OutStreamer.SwitchSection(TLOFMacho.getTextSection());
 327       OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection());
 328       OutStreamer.SwitchSection(TLOFMacho.getConstTextCoalSection());
 329       if (RelocM == Reloc::DynamicNoPIC) {
 330         const MCSection *sect =
 331           OutContext.getMachOSection("__TEXT", "__symbol_stub4",
 332                                      MCSectionMachO::S_SYMBOL_STUBS,
 333                                      12, SectionKind::getText());
 334         OutStreamer.SwitchSection(sect);
 335       } else {
 336         const MCSection *sect =
 337           OutContext.getMachOSection("__TEXT", "__picsymbolstub4",
 338                                      MCSectionMachO::S_SYMBOL_STUBS,
 339                                      16, SectionKind::getText());
 340         OutStreamer.SwitchSection(sect);
 341       }
 342       const MCSection *StaticInitSect =
 343         OutContext.getMachOSection("__TEXT", "__StaticInit",
 344                                    MCSectionMachO::S_REGULAR |
 345                                    MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 346                                    SectionKind::getText());
 347       OutStreamer.SwitchSection(StaticInitSect);
 348     }
 349   }
 350
 351   // Use unified assembler syntax.
 352   OutStreamer.EmitAssemblerFlag(MCAF_SyntaxUnified);
 353
 354   // Emit ARM Build Attributes
 355   if (Subtarget->isTargetELF()) {
 356
 357     emitAttributes();
 358   }
 359 }
 360
 361
 362 void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) {
 363   if (Subtarget->isTargetDarwin()) {
 364     // All darwin targets use mach-o.
 365     const TargetLoweringObjectFileMachO &TLOFMacho =
 366       static_cast<const TargetLoweringObjectFileMachO &>(getObjFileLowering());
 367     MachineModuleInfoMachO &MMIMacho =
 368       MMI->getObjFileInfo<MachineModuleInfoMachO>();
 369
 370     // Output non-lazy-pointers for external and common global variables.
 371     MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetGVStubList();
 372
 373     if (!Stubs.empty()) {
 374       // Switch with ".non_lazy_symbol_pointer" directive.
 375       OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
 376       EmitAlignment(2);
 377       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 378         // L_foo$stub:
 379         OutStreamer.EmitLabel(Stubs[i].first);
 380         //   .indirect_symbol _foo
 381         MachineModuleInfoImpl::StubValueTy &MCSym = Stubs[i].second;
 382         OutStreamer.EmitSymbolAttribute(MCSym.getPointer(),MCSA_IndirectSymbol);
 383
 384         if (MCSym.getInt())
 385           // External to current translation unit.
 386           OutStreamer.EmitIntValue(0, 4/*size*/, 0/*addrspace*/);
 387         else
 388           // Internal to current translation unit.
 389           //
 390           // When we place the LSDA into the TEXT section, the type info
 391           // pointers need to be indirect and pc-rel. We accomplish this by
 392           // using NLPs; however, sometimes the types are local to the file.
 393           // We need to fill in the value for the NLP in those cases.
 394           OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),
 395                                                         OutContext),
 396                                 4/*size*/, 0/*addrspace*/);
 397       }
 398
 399       Stubs.clear();
 400       OutStreamer.AddBlankLine();
 401     }
 402
 403     Stubs = MMIMacho.GetHiddenGVStubList();
 404     if (!Stubs.empty()) {
 405       OutStreamer.SwitchSection(getObjFileLowering().getDataSection());
 406       EmitAlignment(2);
 407       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 408         // L_foo$stub:
 409         OutStreamer.EmitLabel(Stubs[i].first);
 410         //   .long _foo
 411         OutStreamer.EmitValue(MCSymbolRefExpr::
 412                               Create(Stubs[i].second.getPointer(),
 413                                      OutContext),
 414                               4/*size*/, 0/*addrspace*/);
 415       }
 416
 417       Stubs.clear();
 418       OutStreamer.AddBlankLine();
 419     }
 420
 421     // Funny Darwin hack: This flag tells the linker that no global symbols
 422     // contain code that falls through to other global symbols (e.g. the obvious
 423     // implementation of multiple entry points).  If this doesn't occur, the
 424     // linker can safely perform dead code stripping.  Since LLVM never
 425     // generates code that does this, it is always safe to set.
 426     OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
 427   }
 428 }
 429
 430 //===----------------------------------------------------------------------===//
 431 // Helper routines for EmitStartOfAsmFile() and EmitEndOfAsmFile()
 432 // FIXME:
 433 // The following seem like one-off assembler flags, but they actually need
 434 // to appear in the .ARM.attributes section in ELF.
 435 // Instead of subclassing the MCELFStreamer, we do the work here.
 436
 437 void ARMAsmPrinter::emitAttributes() {
 438
 439   emitARMAttributeSection();
 440
 441   AttributeEmitter *AttrEmitter;
 442   if (OutStreamer.hasRawTextSupport())
 443     AttrEmitter = new AsmAttributeEmitter(OutStreamer);
 444   else {
 445     MCObjectStreamer &O = static_cast<MCObjectStreamer&>(OutStreamer);
 446     AttrEmitter = new ObjectAttributeEmitter(O);
 447   }
 448
 449   AttrEmitter->MaybeSwitchVendor("aeabi");
 450
 451   std::string CPUString = Subtarget->getCPUString();
 452   if (OutStreamer.hasRawTextSupport()) {
 453     if (CPUString != "generic")
 454       OutStreamer.EmitRawText(StringRef("\t.cpu ") + CPUString);
 455   } else {
 456     assert(CPUString == "generic" && "Unsupported .cpu attribute for ELF/.o");
 457     // FIXME: Why these defaults?
 458     AttrEmitter->EmitAttribute(ARMBuildAttrs::CPU_arch, ARMBuildAttrs::v4T);
 459     AttrEmitter->EmitAttribute(ARMBuildAttrs::ARM_ISA_use, 1);
 460     AttrEmitter->EmitAttribute(ARMBuildAttrs::THUMB_ISA_use, 1);
 461   }
 462
 463   // FIXME: Emit FPU type
 464   if (Subtarget->hasVFP2())
 465     AttrEmitter->EmitAttribute(ARMBuildAttrs::VFP_arch, 2);
 466
 467   // Signal various FP modes.
 468   if (!UnsafeFPMath) {
 469     AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_FP_denormal, 1);
 470     AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_FP_exceptions, 1);
 471   }
 472
 473   if (NoInfsFPMath && NoNaNsFPMath)
 474     AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_FP_number_model, 1);
 475   else
 476     AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_FP_number_model, 3);
 477
 478   // 8-bytes alignment stuff.
 479   AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_align8_needed, 1);
 480   AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_align8_preserved, 1);
 481
 482   // Hard float.  Use both S and D registers and conform to AAPCS-VFP.
 483   if (Subtarget->isAAPCS_ABI() && FloatABIType == FloatABI::Hard) {
 484     AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_HardFP_use, 3);
 485     AttrEmitter->EmitAttribute(ARMBuildAttrs::ABI_VFP_args, 1);
 486   }
 487   // FIXME: Should we signal R9 usage?
 488
 489   AttrEmitter->EmitAttribute(ARMBuildAttrs::DIV_use, 1);
 490
 491   AttrEmitter->Finish();
 492   delete AttrEmitter;
 493 }
 494
 495 void ARMAsmPrinter::emitARMAttributeSection() {
 496   // <format-version>
 497   // [ <section-length> "vendor-name"
 498   // [ <file-tag> <size> <attribute>*
 499   //   | <section-tag> <size> <section-number>* 0 <attribute>*
 500   //   | <symbol-tag> <size> <symbol-number>* 0 <attribute>*
 501   //   ]+
 502   // ]*
 503
 504   if (OutStreamer.hasRawTextSupport())
 505     return;
 506
 507   const ARMElfTargetObjectFile &TLOFELF =
 508     static_cast<const ARMElfTargetObjectFile &>
 509     (getObjFileLowering());
 510
 511   OutStreamer.SwitchSection(TLOFELF.getAttributesSection());
 512
 513   // Format version
 514   OutStreamer.EmitIntValue(0x41, 1);
 515 }
 516
 517 //===----------------------------------------------------------------------===//
 518
 519 static MCSymbol *getPICLabel(const char *Prefix, unsigned FunctionNumber,
 520                              unsigned LabelId, MCContext &Ctx) {
 521
 522   MCSymbol *Label = Ctx.GetOrCreateSymbol(Twine(Prefix)
 523                        + "PC" + Twine(FunctionNumber) + "_" + Twine(LabelId));
 524   return Label;
 525 }
 526
 527 static MCSymbolRefExpr::VariantKind
 528 getModifierVariantKind(ARMCP::ARMCPModifier Modifier) {
 529   switch (Modifier) {
 530   default: llvm_unreachable("Unknown modifier!");
 531   case ARMCP::no_modifier: return MCSymbolRefExpr::VK_None;
 532   case ARMCP::TLSGD:       return MCSymbolRefExpr::VK_ARM_TLSGD;
 533   case ARMCP::TPOFF:       return MCSymbolRefExpr::VK_ARM_TPOFF;
 534   case ARMCP::GOTTPOFF:    return MCSymbolRefExpr::VK_ARM_GOTTPOFF;
 535   case ARMCP::GOT:         return MCSymbolRefExpr::VK_ARM_GOT;
 536   case ARMCP::GOTOFF:      return MCSymbolRefExpr::VK_ARM_GOTOFF;
 537   }
 538   return MCSymbolRefExpr::VK_None;
 539 }
 540
 541 MCSymbol *ARMAsmPrinter::GetARMGVSymbol(const GlobalValue *GV) {
 542   bool isIndirect = Subtarget->isTargetDarwin() &&
 543     Subtarget->GVIsIndirectSymbol(GV, TM.getRelocationModel());
 544   if (!isIndirect)
 545     return Mang->getSymbol(GV);
 546
 547   // FIXME: Remove this when Darwin transition to @GOT like syntax.
 548   MCSymbol *MCSym = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
 549   MachineModuleInfoMachO &MMIMachO =
 550     MMI->getObjFileInfo<MachineModuleInfoMachO>();
 551   MachineModuleInfoImpl::StubValueTy &StubSym =
 552     GV->hasHiddenVisibility() ? MMIMachO.getHiddenGVStubEntry(MCSym) :
 553     MMIMachO.getGVStubEntry(MCSym);
 554   if (StubSym.getPointer() == 0)
 555     StubSym = MachineModuleInfoImpl::
 556       StubValueTy(Mang->getSymbol(GV), !GV->hasInternalLinkage());
 557   return MCSym;
 558 }
 559
 560 void ARMAsmPrinter::
 561 EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {
 562   int Size = TM.getTargetData()->getTypeAllocSize(MCPV->getType());
 563
 564   ARMConstantPoolValue *ACPV = static_cast<ARMConstantPoolValue*>(MCPV);
 565
 566   MCSymbol *MCSym;
 567   if (ACPV->isLSDA()) {
 568     SmallString<128> Str;
 569     raw_svector_ostream OS(Str);
 570     OS << MAI->getPrivateGlobalPrefix() << "_LSDA_" << getFunctionNumber();
 571     MCSym = OutContext.GetOrCreateSymbol(OS.str());
 572   } else if (ACPV->isBlockAddress()) {
 573     MCSym = GetBlockAddressSymbol(ACPV->getBlockAddress());
 574   } else if (ACPV->isGlobalValue()) {
 575     const GlobalValue *GV = ACPV->getGV();
 576     MCSym = GetARMGVSymbol(GV);
 577   } else {
 578     assert(ACPV->isExtSymbol() && "unrecognized constant pool value");
 579     MCSym = GetExternalSymbolSymbol(ACPV->getSymbol());
 580   }
 581
 582   // Create an MCSymbol for the reference.
 583   const MCExpr *Expr =
 584     MCSymbolRefExpr::Create(MCSym, getModifierVariantKind(ACPV->getModifier()),
 585                             OutContext);
 586
 587   if (ACPV->getPCAdjustment()) {
 588     MCSymbol *PCLabel = getPICLabel(MAI->getPrivateGlobalPrefix(),
 589                                     getFunctionNumber(),
 590                                     ACPV->getLabelId(),
 591                                     OutContext);
 592     const MCExpr *PCRelExpr = MCSymbolRefExpr::Create(PCLabel, OutContext);
 593     PCRelExpr =
 594       MCBinaryExpr::CreateAdd(PCRelExpr,
 595                               MCConstantExpr::Create(ACPV->getPCAdjustment(),
 596                                                      OutContext),
 597                               OutContext);
 598     if (ACPV->mustAddCurrentAddress()) {
 599       // We want "(<expr> - .)", but MC doesn't have a concept of the '.'
 600       // label, so just emit a local label end reference that instead.
 601       MCSymbol *DotSym = OutContext.CreateTempSymbol();
 602       OutStreamer.EmitLabel(DotSym);
 603       const MCExpr *DotExpr = MCSymbolRefExpr::Create(DotSym, OutContext);
 604       PCRelExpr = MCBinaryExpr::CreateSub(PCRelExpr, DotExpr, OutContext);
 605     }
 606     Expr = MCBinaryExpr::CreateSub(Expr, PCRelExpr, OutContext);
 607   }
 608   OutStreamer.EmitValue(Expr, Size);
 609 }
 610
 611 void ARMAsmPrinter::EmitJumpTable(const MachineInstr *MI) {
 612   unsigned Opcode = MI->getOpcode();
 613   int OpNum = 1;
 614   if (Opcode == ARM::BR_JTadd)
 615     OpNum = 2;
 616   else if (Opcode == ARM::BR_JTm)
 617     OpNum = 3;
 618
 619   const MachineOperand &MO1 = MI->getOperand(OpNum);
 620   const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id
 621   unsigned JTI = MO1.getIndex();
 622
 623   // Emit a label for the jump table.
 624   MCSymbol *JTISymbol = GetARMJTIPICJumpTableLabel2(JTI, MO2.getImm());
 625   OutStreamer.EmitLabel(JTISymbol);
 626
 627   // Emit each entry of the table.
 628   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
 629   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 630   const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
 631
 632   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
 633     MachineBasicBlock *MBB = JTBBs[i];
 634     // Construct an MCExpr for the entry. We want a value of the form:
 635     // (BasicBlockAddr - TableBeginAddr)
 636     //
 637     // For example, a table with entries jumping to basic blocks BB0 and BB1
 638     // would look like:
 639     // LJTI_0_0:
 640     //    .word (LBB0 - LJTI_0_0)
 641     //    .word (LBB1 - LJTI_0_0)
 642     const MCExpr *Expr = MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext);
 643
 644     if (TM.getRelocationModel() == Reloc::PIC_)
 645       Expr = MCBinaryExpr::CreateSub(Expr, MCSymbolRefExpr::Create(JTISymbol,
 646                                                                    OutContext),
 647                                      OutContext);
 648     OutStreamer.EmitValue(Expr, 4);
 649   }
 650 }
 651
 652 void ARMAsmPrinter::EmitJump2Table(const MachineInstr *MI) {
 653   unsigned Opcode = MI->getOpcode();
 654   int OpNum = (Opcode == ARM::t2BR_JT) ? 2 : 1;
 655   const MachineOperand &MO1 = MI->getOperand(OpNum);
 656   const MachineOperand &MO2 = MI->getOperand(OpNum+1); // Unique Id
 657   unsigned JTI = MO1.getIndex();
 658
 659   // Emit a label for the jump table.
 660   MCSymbol *JTISymbol = GetARMJTIPICJumpTableLabel2(JTI, MO2.getImm());
 661   OutStreamer.EmitLabel(JTISymbol);
 662
 663   // Emit each entry of the table.
 664   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
 665   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 666   const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
 667   unsigned OffsetWidth = 4;
 668   if (MI->getOpcode() == ARM::t2TBB_JT)
 669     OffsetWidth = 1;
 670   else if (MI->getOpcode() == ARM::t2TBH_JT)
 671     OffsetWidth = 2;
 672
 673   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {
 674     MachineBasicBlock *MBB = JTBBs[i];
 675     const MCExpr *MBBSymbolExpr = MCSymbolRefExpr::Create(MBB->getSymbol(),
 676                                                       OutContext);
 677     // If this isn't a TBB or TBH, the entries are direct branch instructions.
 678     if (OffsetWidth == 4) {
 679       MCInst BrInst;
 680       BrInst.setOpcode(ARM::t2B);
 681       BrInst.addOperand(MCOperand::CreateExpr(MBBSymbolExpr));
 682       OutStreamer.EmitInstruction(BrInst);
 683       continue;
 684     }
 685     // Otherwise it's an offset from the dispatch instruction. Construct an
 686     // MCExpr for the entry. We want a value of the form:
 687     // (BasicBlockAddr - TableBeginAddr) / 2
 688     //
 689     // For example, a TBB table with entries jumping to basic blocks BB0 and BB1
 690     // would look like:
 691     // LJTI_0_0:
 692     //    .byte (LBB0 - LJTI_0_0) / 2
 693     //    .byte (LBB1 - LJTI_0_0) / 2
 694     const MCExpr *Expr =
 695       MCBinaryExpr::CreateSub(MBBSymbolExpr,
 696                               MCSymbolRefExpr::Create(JTISymbol, OutContext),
 697                               OutContext);
 698     Expr = MCBinaryExpr::CreateDiv(Expr, MCConstantExpr::Create(2, OutContext),
 699                                    OutContext);
 700     OutStreamer.EmitValue(Expr, OffsetWidth);
 701   }
 702 }
 703
 704 void ARMAsmPrinter::PrintDebugValueComment(const MachineInstr *MI,
 705                                            raw_ostream &OS) {
 706   unsigned NOps = MI->getNumOperands();
 707   assert(NOps==4);
 708   OS << '\t' << MAI->getCommentString() << "DEBUG_VALUE: ";
 709   // cast away const; DIetc do not take const operands for some reason.
 710   DIVariable V(const_cast<MDNode *>(MI->getOperand(NOps-1).getMetadata()));
 711   OS << V.getName();
 712   OS << " <- ";
 713   // Frame address.  Currently handles register +- offset only.
 714   assert(MI->getOperand(0).isReg() && MI->getOperand(1).isImm());
 715   OS << '['; printOperand(MI, 0, OS); OS << '+'; printOperand(MI, 1, OS);
 716   OS << ']';
 717   OS << "+";
 718   printOperand(MI, NOps-2, OS);
 719 }
 720
 721 static void populateADROperands(MCInst &Inst, unsigned Dest,
 722                                 const MCSymbol *Label,
 723                                 unsigned pred, unsigned ccreg,
 724                                 MCContext &Ctx) {
 725   const MCExpr *SymbolExpr = MCSymbolRefExpr::Create(Label, Ctx);
 726   Inst.addOperand(MCOperand::CreateReg(Dest));
 727   Inst.addOperand(MCOperand::CreateExpr(SymbolExpr));
 728   // Add predicate operands.
 729   Inst.addOperand(MCOperand::CreateImm(pred));
 730   Inst.addOperand(MCOperand::CreateReg(ccreg));
 731 }
 732
 733 void ARMAsmPrinter::EmitPatchedInstruction(const MachineInstr *MI,
 734                                            unsigned Opcode) {
 735   MCInst TmpInst;
 736
 737   // Emit the instruction as usual, just patch the opcode.
 738   LowerARMMachineInstrToMCInst(MI, TmpInst, *this);
 739   TmpInst.setOpcode(Opcode);
 740   OutStreamer.EmitInstruction(TmpInst);
 741 }
 742
 743 void ARMAsmPrinter::EmitInstruction(const MachineInstr *MI) {
 744   unsigned Opc = MI->getOpcode();
 745   switch (Opc) {
 746   default: break;
 747   case ARM::t2ADDrSPi:
 748   case ARM::t2ADDrSPi12:
 749   case ARM::t2SUBrSPi:
 750   case ARM::t2SUBrSPi12:
 751     assert ((MI->getOperand(1).getReg() == ARM::SP) &&
 752             "Unexpected source register!");
 753     break;
 754
 755   case ARM::t2MOVi32imm: assert(0 && "Should be lowered by thumb2it pass");
 756   case ARM::DBG_VALUE: {
 757     if (isVerbose() && OutStreamer.hasRawTextSupport()) {
 758       SmallString<128> TmpStr;
 759       raw_svector_ostream OS(TmpStr);
 760       PrintDebugValueComment(MI, OS);
 761       OutStreamer.EmitRawText(StringRef(OS.str()));
 762     }
 763     return;
 764   }
 765   case ARM::tBfar: {
 766     MCInst TmpInst;
 767     TmpInst.setOpcode(ARM::tBL);
 768     TmpInst.addOperand(MCOperand::CreateExpr(MCSymbolRefExpr::Create(
 769           MI->getOperand(0).getMBB()->getSymbol(), OutContext)));
 770     OutStreamer.EmitInstruction(TmpInst);
 771     return;
 772   }
 773   case ARM::LEApcrel:
 774   case ARM::tLEApcrel:
 775   case ARM::t2LEApcrel: {
 776     // FIXME: Need to also handle globals and externals
 777     MCInst TmpInst;
 778     TmpInst.setOpcode(MI->getOpcode() == ARM::t2LEApcrel ? ARM::t2ADR
 779                       : (MI->getOpcode() == ARM::tLEApcrel ? ARM::tADR
 780                          : ARM::ADR));
 781     populateADROperands(TmpInst, MI->getOperand(0).getReg(),
 782                         GetCPISymbol(MI->getOperand(1).getIndex()),
 783                         MI->getOperand(2).getImm(), MI->getOperand(3).getReg(),
 784                         OutContext);
 785     OutStreamer.EmitInstruction(TmpInst);
 786     return;
 787   }
 788   case ARM::LEApcrelJT:
 789   case ARM::tLEApcrelJT:
 790   case ARM::t2LEApcrelJT: {
 791     MCInst TmpInst;
 792     TmpInst.setOpcode(MI->getOpcode() == ARM::t2LEApcrelJT ? ARM::t2ADR
 793                       : (MI->getOpcode() == ARM::tLEApcrelJT ? ARM::tADR
 794                          : ARM::ADR));
 795     populateADROperands(TmpInst, MI->getOperand(0).getReg(),
 796                       GetARMJTIPICJumpTableLabel2(MI->getOperand(1).getIndex(),
 797                                                   MI->getOperand(2).getImm()),
 798                       MI->getOperand(3).getImm(), MI->getOperand(4).getReg(),
 799                       OutContext);
 800     OutStreamer.EmitInstruction(TmpInst);
 801     return;
 802   }
 803   case ARM::MOVPCRX: {
 804     MCInst TmpInst;
 805     TmpInst.setOpcode(ARM::MOVr);
 806     TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
 807     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 808     // Add predicate operands.
 809     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
 810     TmpInst.addOperand(MCOperand::CreateReg(0));
 811     // Add 's' bit operand (always reg0 for this)
 812     TmpInst.addOperand(MCOperand::CreateReg(0));
 813     OutStreamer.EmitInstruction(TmpInst);
 814     return;
 815   }
 816   case ARM::BXr9_CALL:
 817   case ARM::BX_CALL: {
 818     {
 819       MCInst TmpInst;
 820       TmpInst.setOpcode(ARM::MOVr);
 821       TmpInst.addOperand(MCOperand::CreateReg(ARM::LR));
 822       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
 823       // Add predicate operands.
 824       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
 825       TmpInst.addOperand(MCOperand::CreateReg(0));
 826       // Add 's' bit operand (always reg0 for this)
 827       TmpInst.addOperand(MCOperand::CreateReg(0));
 828       OutStreamer.EmitInstruction(TmpInst);
 829     }
 830     {
 831       MCInst TmpInst;
 832       TmpInst.setOpcode(ARM::BX);
 833       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 834       OutStreamer.EmitInstruction(TmpInst);
 835     }
 836     return;
 837   }
 838   case ARM::BMOVPCRXr9_CALL:
 839   case ARM::BMOVPCRX_CALL: {
 840     {
 841       MCInst TmpInst;
 842       TmpInst.setOpcode(ARM::MOVr);
 843       TmpInst.addOperand(MCOperand::CreateReg(ARM::LR));
 844       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
 845       // Add predicate operands.
 846       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
 847       TmpInst.addOperand(MCOperand::CreateReg(0));
 848       // Add 's' bit operand (always reg0 for this)
 849       TmpInst.addOperand(MCOperand::CreateReg(0));
 850       OutStreamer.EmitInstruction(TmpInst);
 851     }
 852     {
 853       MCInst TmpInst;
 854       TmpInst.setOpcode(ARM::MOVr);
 855       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
 856       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 857       // Add predicate operands.
 858       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
 859       TmpInst.addOperand(MCOperand::CreateReg(0));
 860       // Add 's' bit operand (always reg0 for this)
 861       TmpInst.addOperand(MCOperand::CreateReg(0));
 862       OutStreamer.EmitInstruction(TmpInst);
 863     }
 864     return;
 865   }
 866   case ARM::MOVi16_pic_ga:
 867   case ARM::t2MOVi16_pic_ga: {
 868     MCInst TmpInst;
 869     TmpInst.setOpcode(Opc == ARM::MOVi16_pic_ga ? ARM::MOVi16 : ARM::t2MOVi16);
 870     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 871
 872     const GlobalValue *GV = MI->getOperand(1).getGlobal();
 873     MCSymbol *GVSym = GetARMGVSymbol(GV);
 874     const MCExpr *GVSymExpr = MCSymbolRefExpr::Create(GVSym, OutContext);
 875     MCSymbol *LabelSym = getPICLabel(MAI->getPrivateGlobalPrefix(),
 876                                 getFunctionNumber(), MI->getOperand(2).getImm(),
 877                                      OutContext);
 878     const MCExpr *LabelSymExpr = MCSymbolRefExpr::Create(LabelSym, OutContext);
 879     const MCExpr *PCRelExpr =
 880       ARMMCExpr::CreateLower16(MCBinaryExpr::CreateSub(GVSymExpr,
 881                                       MCBinaryExpr::CreateAdd(LabelSymExpr,
 882                                         MCConstantExpr::Create(4, OutContext),
 883                                           OutContext), OutContext), OutContext);
 884     TmpInst.addOperand(MCOperand::CreateExpr(PCRelExpr));
 885     // Add predicate operands.
 886     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
 887     TmpInst.addOperand(MCOperand::CreateReg(0));
 888     // Add 's' bit operand (always reg0 for this)
 889     TmpInst.addOperand(MCOperand::CreateReg(0));
 890     OutStreamer.EmitInstruction(TmpInst);
 891     return;
 892   }
 893   case ARM::MOVTi16_pic_ga:
 894   case ARM::t2MOVTi16_pic_ga: {
 895     MCInst TmpInst;
 896     TmpInst.setOpcode(Opc==ARM::MOVTi16_pic_ga ? ARM::MOVTi16 : ARM::t2MOVTi16);
 897     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 898     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
 899
 900     const GlobalValue *GV = MI->getOperand(2).getGlobal();
 901     MCSymbol *GVSym = GetARMGVSymbol(GV);
 902     const MCExpr *GVSymExpr = MCSymbolRefExpr::Create(GVSym, OutContext);
 903     MCSymbol *LabelSym = getPICLabel(MAI->getPrivateGlobalPrefix(),
 904                                 getFunctionNumber(), MI->getOperand(3).getImm(),
 905                                      OutContext);
 906     const MCExpr *LabelSymExpr = MCSymbolRefExpr::Create(LabelSym, OutContext);
 907     const MCExpr *PCRelExpr =
 908       ARMMCExpr::CreateUpper16(MCBinaryExpr::CreateSub(GVSymExpr,
 909                                       MCBinaryExpr::CreateAdd(LabelSymExpr,
 910                                         MCConstantExpr::Create(4, OutContext),
 911                                           OutContext), OutContext), OutContext);
 912     TmpInst.addOperand(MCOperand::CreateExpr(PCRelExpr));
 913     // Add predicate operands.
 914     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
 915     TmpInst.addOperand(MCOperand::CreateReg(0));
 916     // Add 's' bit operand (always reg0 for this)
 917     TmpInst.addOperand(MCOperand::CreateReg(0));
 918     OutStreamer.EmitInstruction(TmpInst);
 919     return;
 920   }
 921   case ARM::tPICADD: {
 922     // This is a pseudo op for a label + instruction sequence, which looks like:
 923     // LPC0:
 924     //     add r0, pc
 925     // This adds the address of LPC0 to r0.
 926
 927     // Emit the label.
 928     OutStreamer.EmitLabel(getPICLabel(MAI->getPrivateGlobalPrefix(),
 929                           getFunctionNumber(), MI->getOperand(2).getImm(),
 930                           OutContext));
 931
 932     // Form and emit the add.
 933     MCInst AddInst;
 934     AddInst.setOpcode(ARM::tADDhirr);
 935     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 936     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 937     AddInst.addOperand(MCOperand::CreateReg(ARM::PC));
 938     // Add predicate operands.
 939     AddInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
 940     AddInst.addOperand(MCOperand::CreateReg(0));
 941     OutStreamer.EmitInstruction(AddInst);
 942     return;
 943   }
 944   case ARM::PICADD: {
 945     // This is a pseudo op for a label + instruction sequence, which looks like:
 946     // LPC0:
 947     //     add r0, pc, r0
 948     // This adds the address of LPC0 to r0.
 949
 950     // Emit the label.
 951     OutStreamer.EmitLabel(getPICLabel(MAI->getPrivateGlobalPrefix(),
 952                           getFunctionNumber(), MI->getOperand(2).getImm(),
 953                           OutContext));
 954
 955     // Form and emit the add.
 956     MCInst AddInst;
 957     AddInst.setOpcode(ARM::ADDrr);
 958     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 959     AddInst.addOperand(MCOperand::CreateReg(ARM::PC));
 960     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
 961     // Add predicate operands.
 962     AddInst.addOperand(MCOperand::CreateImm(MI->getOperand(3).getImm()));
 963     AddInst.addOperand(MCOperand::CreateReg(MI->getOperand(4).getReg()));
 964     // Add 's' bit operand (always reg0 for this)
 965     AddInst.addOperand(MCOperand::CreateReg(0));
 966     OutStreamer.EmitInstruction(AddInst);
 967     return;
 968   }
 969   case ARM::PICSTR:
 970   case ARM::PICSTRB:
 971   case ARM::PICSTRH:
 972   case ARM::PICLDR:
 973   case ARM::PICLDRB:
 974   case ARM::PICLDRH:
 975   case ARM::PICLDRSB:
 976   case ARM::PICLDRSH: {
 977     // This is a pseudo op for a label + instruction sequence, which looks like:
 978     // LPC0:
 979     //     OP r0, [pc, r0]
 980     // The LCP0 label is referenced by a constant pool entry in order to get
 981     // a PC-relative address at the ldr instruction.
 982
 983     // Emit the label.
 984     OutStreamer.EmitLabel(getPICLabel(MAI->getPrivateGlobalPrefix(),
 985                           getFunctionNumber(), MI->getOperand(2).getImm(),
 986                           OutContext));
 987
 988     // Form and emit the load
 989     unsigned Opcode;
 990     switch (MI->getOpcode()) {
 991     default:
 992       llvm_unreachable("Unexpected opcode!");
 993     case ARM::PICSTR:   Opcode = ARM::STRrs; break;
 994     case ARM::PICSTRB:  Opcode = ARM::STRBrs; break;
 995     case ARM::PICSTRH:  Opcode = ARM::STRH; break;
 996     case ARM::PICLDR:   Opcode = ARM::LDRrs; break;
 997     case ARM::PICLDRB:  Opcode = ARM::LDRBrs; break;
 998     case ARM::PICLDRH:  Opcode = ARM::LDRH; break;
 999     case ARM::PICLDRSB: Opcode = ARM::LDRSB; break;
1000     case ARM::PICLDRSH: Opcode = ARM::LDRSH; break;
1001     }
1002     MCInst LdStInst;
1003     LdStInst.setOpcode(Opcode);
1004     LdStInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1005     LdStInst.addOperand(MCOperand::CreateReg(ARM::PC));
1006     LdStInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
1007     LdStInst.addOperand(MCOperand::CreateImm(0));
1008     // Add predicate operands.
1009     LdStInst.addOperand(MCOperand::CreateImm(MI->getOperand(3).getImm()));
1010     LdStInst.addOperand(MCOperand::CreateReg(MI->getOperand(4).getReg()));
1011     OutStreamer.EmitInstruction(LdStInst);
1012
1013     return;
1014   }
1015   case ARM::CONSTPOOL_ENTRY: {
1016     /// CONSTPOOL_ENTRY - This instruction represents a floating constant pool
1017     /// in the function.  The first operand is the ID# for this instruction, the
1018     /// second is the index into the MachineConstantPool that this is, the third
1019     /// is the size in bytes of this constant pool entry.
1020     unsigned LabelId = (unsigned)MI->getOperand(0).getImm();
1021     unsigned CPIdx   = (unsigned)MI->getOperand(1).getIndex();
1022
1023     EmitAlignment(2);
1024     OutStreamer.EmitLabel(GetCPISymbol(LabelId));
1025
1026     const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPIdx];
1027     if (MCPE.isMachineConstantPoolEntry())
1028       EmitMachineConstantPoolValue(MCPE.Val.MachineCPVal);
1029     else
1030       EmitGlobalConstant(MCPE.Val.ConstVal);
1031
1032     return;
1033   }
1034   case ARM::t2BR_JT: {
1035     // Lower and emit the instruction itself, then the jump table following it.
1036     MCInst TmpInst;
1037     TmpInst.setOpcode(ARM::tMOVgpr2gpr);
1038     TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1039     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1040     // Add predicate operands.
1041     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1042     TmpInst.addOperand(MCOperand::CreateReg(0));
1043     OutStreamer.EmitInstruction(TmpInst);
1044     // Output the data for the jump table itself
1045     EmitJump2Table(MI);
1046     return;
1047   }
1048   case ARM::t2TBB_JT: {
1049     // Lower and emit the instruction itself, then the jump table following it.
1050     MCInst TmpInst;
1051
1052     TmpInst.setOpcode(ARM::t2TBB);
1053     TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1054     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1055     // Add predicate operands.
1056     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1057     TmpInst.addOperand(MCOperand::CreateReg(0));
1058     OutStreamer.EmitInstruction(TmpInst);
1059     // Output the data for the jump table itself
1060     EmitJump2Table(MI);
1061     // Make sure the next instruction is 2-byte aligned.
1062     EmitAlignment(1);
1063     return;
1064   }
1065   case ARM::t2TBH_JT: {
1066     // Lower and emit the instruction itself, then the jump table following it.
1067     MCInst TmpInst;
1068
1069     TmpInst.setOpcode(ARM::t2TBH);
1070     TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1071     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1072     // Add predicate operands.
1073     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1074     TmpInst.addOperand(MCOperand::CreateReg(0));
1075     OutStreamer.EmitInstruction(TmpInst);
1076     // Output the data for the jump table itself
1077     EmitJump2Table(MI);
1078     return;
1079   }
1080   case ARM::tBR_JTr:
1081   case ARM::BR_JTr: {
1082     // Lower and emit the instruction itself, then the jump table following it.
1083     // mov pc, target
1084     MCInst TmpInst;
1085     unsigned Opc = MI->getOpcode() == ARM::BR_JTr ?
1086       ARM::MOVr : ARM::tMOVgpr2gpr;
1087     TmpInst.setOpcode(Opc);
1088     TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1089     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1090     // Add predicate operands.
1091     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1092     TmpInst.addOperand(MCOperand::CreateReg(0));
1093     // Add 's' bit operand (always reg0 for this)
1094     if (Opc == ARM::MOVr)
1095       TmpInst.addOperand(MCOperand::CreateReg(0));
1096     OutStreamer.EmitInstruction(TmpInst);
1097
1098     // Make sure the Thumb jump table is 4-byte aligned.
1099     if (Opc == ARM::tMOVgpr2gpr)
1100       EmitAlignment(2);
1101
1102     // Output the data for the jump table itself
1103     EmitJumpTable(MI);
1104     return;
1105   }
1106   case ARM::BR_JTm: {
1107     // Lower and emit the instruction itself, then the jump table following it.
1108     // ldr pc, target
1109     MCInst TmpInst;
1110     if (MI->getOperand(1).getReg() == 0) {
1111       // literal offset
1112       TmpInst.setOpcode(ARM::LDRi12);
1113       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1114       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1115       TmpInst.addOperand(MCOperand::CreateImm(MI->getOperand(2).getImm()));
1116     } else {
1117       TmpInst.setOpcode(ARM::LDRrs);
1118       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1119       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1120       TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
1121       TmpInst.addOperand(MCOperand::CreateImm(0));
1122     }
1123     // Add predicate operands.
1124     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1125     TmpInst.addOperand(MCOperand::CreateReg(0));
1126     OutStreamer.EmitInstruction(TmpInst);
1127
1128     // Output the data for the jump table itself
1129     EmitJumpTable(MI);
1130     return;
1131   }
1132   case ARM::BR_JTadd: {
1133     // Lower and emit the instruction itself, then the jump table following it.
1134     // add pc, target, idx
1135     MCInst TmpInst;
1136     TmpInst.setOpcode(ARM::ADDrr);
1137     TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1138     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
1139     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
1140     // Add predicate operands.
1141     TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1142     TmpInst.addOperand(MCOperand::CreateReg(0));
1143     // Add 's' bit operand (always reg0 for this)
1144     TmpInst.addOperand(MCOperand::CreateReg(0));
1145     OutStreamer.EmitInstruction(TmpInst);
1146
1147     // Output the data for the jump table itself
1148     EmitJumpTable(MI);
1149     return;
1150   }
1151   case ARM::TRAP: {
1152     // Non-Darwin binutils don't yet support the "trap" mnemonic.
1153     // FIXME: Remove this special case when they do.
1154     if (!Subtarget->isTargetDarwin()) {
1155       //.long 0xe7ffdefe @ trap
1156       uint32_t Val = 0xe7ffdefeUL;
1157       OutStreamer.AddComment("trap");
1158       OutStreamer.EmitIntValue(Val, 4);
1159       return;
1160     }
1161     break;
1162   }
1163   case ARM::tTRAP: {
1164     // Non-Darwin binutils don't yet support the "trap" mnemonic.
1165     // FIXME: Remove this special case when they do.
1166     if (!Subtarget->isTargetDarwin()) {
1167       //.short 57086 @ trap
1168       uint16_t Val = 0xdefe;
1169       OutStreamer.AddComment("trap");
1170       OutStreamer.EmitIntValue(Val, 2);
1171       return;
1172     }
1173     break;
1174   }
1175   case ARM::t2Int_eh_sjlj_setjmp:
1176   case ARM::t2Int_eh_sjlj_setjmp_nofp:
1177   case ARM::tInt_eh_sjlj_setjmp: {
1178     // Two incoming args: GPR:$src, GPR:$val
1179     // mov $val, pc
1180     // adds $val, #7
1181     // str $val, [$src, #4]
1182     // movs r0, #0
1183     // b 1f
1184     // movs r0, #1
1185     // 1:
1186     unsigned SrcReg = MI->getOperand(0).getReg();
1187     unsigned ValReg = MI->getOperand(1).getReg();
1188     MCSymbol *Label = GetARMSJLJEHLabel();
1189     {
1190       MCInst TmpInst;
1191       TmpInst.setOpcode(ARM::tMOVgpr2tgpr);
1192       TmpInst.addOperand(MCOperand::CreateReg(ValReg));
1193       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1194       // 's' bit operand
1195       TmpInst.addOperand(MCOperand::CreateReg(ARM::CPSR));
1196       OutStreamer.AddComment("eh_setjmp begin");
1197       OutStreamer.EmitInstruction(TmpInst);
1198     }
1199     {
1200       MCInst TmpInst;
1201       TmpInst.setOpcode(ARM::tADDi3);
1202       TmpInst.addOperand(MCOperand::CreateReg(ValReg));
1203       // 's' bit operand
1204       TmpInst.addOperand(MCOperand::CreateReg(ARM::CPSR));
1205       TmpInst.addOperand(MCOperand::CreateReg(ValReg));
1206       TmpInst.addOperand(MCOperand::CreateImm(7));
1207       // Predicate.
1208       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1209       TmpInst.addOperand(MCOperand::CreateReg(0));
1210       OutStreamer.EmitInstruction(TmpInst);
1211     }
1212     {
1213       MCInst TmpInst;
1214       TmpInst.setOpcode(ARM::tSTRi);
1215       TmpInst.addOperand(MCOperand::CreateReg(ValReg));
1216       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1217       // The offset immediate is #4. The operand value is scaled by 4 for the
1218       // tSTR instruction.
1219       TmpInst.addOperand(MCOperand::CreateImm(1));
1220       // Predicate.
1221       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1222       TmpInst.addOperand(MCOperand::CreateReg(0));
1223       OutStreamer.EmitInstruction(TmpInst);
1224     }
1225     {
1226       MCInst TmpInst;
1227       TmpInst.setOpcode(ARM::tMOVi8);
1228       TmpInst.addOperand(MCOperand::CreateReg(ARM::R0));
1229       TmpInst.addOperand(MCOperand::CreateReg(ARM::CPSR));
1230       TmpInst.addOperand(MCOperand::CreateImm(0));
1231       // Predicate.
1232       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1233       TmpInst.addOperand(MCOperand::CreateReg(0));
1234       OutStreamer.EmitInstruction(TmpInst);
1235     }
1236     {
1237       const MCExpr *SymbolExpr = MCSymbolRefExpr::Create(Label, OutContext);
1238       MCInst TmpInst;
1239       TmpInst.setOpcode(ARM::tB);
1240       TmpInst.addOperand(MCOperand::CreateExpr(SymbolExpr));
1241       OutStreamer.EmitInstruction(TmpInst);
1242     }
1243     {
1244       MCInst TmpInst;
1245       TmpInst.setOpcode(ARM::tMOVi8);
1246       TmpInst.addOperand(MCOperand::CreateReg(ARM::R0));
1247       TmpInst.addOperand(MCOperand::CreateReg(ARM::CPSR));
1248       TmpInst.addOperand(MCOperand::CreateImm(1));
1249       // Predicate.
1250       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1251       TmpInst.addOperand(MCOperand::CreateReg(0));
1252       OutStreamer.AddComment("eh_setjmp end");
1253       OutStreamer.EmitInstruction(TmpInst);
1254     }
1255     OutStreamer.EmitLabel(Label);
1256     return;
1257   }
1258
1259   case ARM::Int_eh_sjlj_setjmp_nofp:
1260   case ARM::Int_eh_sjlj_setjmp: {
1261     // Two incoming args: GPR:$src, GPR:$val
1262     // add $val, pc, #8
1263     // str $val, [$src, #+4]
1264     // mov r0, #0
1265     // add pc, pc, #0
1266     // mov r0, #1
1267     unsigned SrcReg = MI->getOperand(0).getReg();
1268     unsigned ValReg = MI->getOperand(1).getReg();
1269
1270     {
1271       MCInst TmpInst;
1272       TmpInst.setOpcode(ARM::ADDri);
1273       TmpInst.addOperand(MCOperand::CreateReg(ValReg));
1274       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1275       TmpInst.addOperand(MCOperand::CreateImm(8));
1276       // Predicate.
1277       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1278       TmpInst.addOperand(MCOperand::CreateReg(0));
1279       // 's' bit operand (always reg0 for this).
1280       TmpInst.addOperand(MCOperand::CreateReg(0));
1281       OutStreamer.AddComment("eh_setjmp begin");
1282       OutStreamer.EmitInstruction(TmpInst);
1283     }
1284     {
1285       MCInst TmpInst;
1286       TmpInst.setOpcode(ARM::STRi12);
1287       TmpInst.addOperand(MCOperand::CreateReg(ValReg));
1288       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1289       TmpInst.addOperand(MCOperand::CreateImm(4));
1290       // Predicate.
1291       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1292       TmpInst.addOperand(MCOperand::CreateReg(0));
1293       OutStreamer.EmitInstruction(TmpInst);
1294     }
1295     {
1296       MCInst TmpInst;
1297       TmpInst.setOpcode(ARM::MOVi);
1298       TmpInst.addOperand(MCOperand::CreateReg(ARM::R0));
1299       TmpInst.addOperand(MCOperand::CreateImm(0));
1300       // Predicate.
1301       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1302       TmpInst.addOperand(MCOperand::CreateReg(0));
1303       // 's' bit operand (always reg0 for this).
1304       TmpInst.addOperand(MCOperand::CreateReg(0));
1305       OutStreamer.EmitInstruction(TmpInst);
1306     }
1307     {
1308       MCInst TmpInst;
1309       TmpInst.setOpcode(ARM::ADDri);
1310       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1311       TmpInst.addOperand(MCOperand::CreateReg(ARM::PC));
1312       TmpInst.addOperand(MCOperand::CreateImm(0));
1313       // Predicate.
1314       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1315       TmpInst.addOperand(MCOperand::CreateReg(0));
1316       // 's' bit operand (always reg0 for this).
1317       TmpInst.addOperand(MCOperand::CreateReg(0));
1318       OutStreamer.EmitInstruction(TmpInst);
1319     }
1320     {
1321       MCInst TmpInst;
1322       TmpInst.setOpcode(ARM::MOVi);
1323       TmpInst.addOperand(MCOperand::CreateReg(ARM::R0));
1324       TmpInst.addOperand(MCOperand::CreateImm(1));
1325       // Predicate.
1326       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1327       TmpInst.addOperand(MCOperand::CreateReg(0));
1328       // 's' bit operand (always reg0 for this).
1329       TmpInst.addOperand(MCOperand::CreateReg(0));
1330       OutStreamer.AddComment("eh_setjmp end");
1331       OutStreamer.EmitInstruction(TmpInst);
1332     }
1333     return;
1334   }
1335   case ARM::Int_eh_sjlj_longjmp: {
1336     // ldr sp, [$src, #8]
1337     // ldr $scratch, [$src, #4]
1338     // ldr r7, [$src]
1339     // bx $scratch
1340     unsigned SrcReg = MI->getOperand(0).getReg();
1341     unsigned ScratchReg = MI->getOperand(1).getReg();
1342     {
1343       MCInst TmpInst;
1344       TmpInst.setOpcode(ARM::LDRi12);
1345       TmpInst.addOperand(MCOperand::CreateReg(ARM::SP));
1346       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1347       TmpInst.addOperand(MCOperand::CreateImm(8));
1348       // Predicate.
1349       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1350       TmpInst.addOperand(MCOperand::CreateReg(0));
1351       OutStreamer.EmitInstruction(TmpInst);
1352     }
1353     {
1354       MCInst TmpInst;
1355       TmpInst.setOpcode(ARM::LDRi12);
1356       TmpInst.addOperand(MCOperand::CreateReg(ScratchReg));
1357       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1358       TmpInst.addOperand(MCOperand::CreateImm(4));
1359       // Predicate.
1360       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1361       TmpInst.addOperand(MCOperand::CreateReg(0));
1362       OutStreamer.EmitInstruction(TmpInst);
1363     }
1364     {
1365       MCInst TmpInst;
1366       TmpInst.setOpcode(ARM::LDRi12);
1367       TmpInst.addOperand(MCOperand::CreateReg(ARM::R7));
1368       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1369       TmpInst.addOperand(MCOperand::CreateImm(0));
1370       // Predicate.
1371       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1372       TmpInst.addOperand(MCOperand::CreateReg(0));
1373       OutStreamer.EmitInstruction(TmpInst);
1374     }
1375     {
1376       MCInst TmpInst;
1377       TmpInst.setOpcode(ARM::BX);
1378       TmpInst.addOperand(MCOperand::CreateReg(ScratchReg));
1379       // Predicate.
1380       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1381       TmpInst.addOperand(MCOperand::CreateReg(0));
1382       OutStreamer.EmitInstruction(TmpInst);
1383     }
1384     return;
1385   }
1386   case ARM::tInt_eh_sjlj_longjmp: {
1387     // ldr $scratch, [$src, #8]
1388     // mov sp, $scratch
1389     // ldr $scratch, [$src, #4]
1390     // ldr r7, [$src]
1391     // bx $scratch
1392     unsigned SrcReg = MI->getOperand(0).getReg();
1393     unsigned ScratchReg = MI->getOperand(1).getReg();
1394     {
1395       MCInst TmpInst;
1396       TmpInst.setOpcode(ARM::tLDRi);
1397       TmpInst.addOperand(MCOperand::CreateReg(ScratchReg));
1398       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1399       // The offset immediate is #8. The operand value is scaled by 4 for the
1400       // tLDR instruction.
1401       TmpInst.addOperand(MCOperand::CreateImm(2));
1402       // Predicate.
1403       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1404       TmpInst.addOperand(MCOperand::CreateReg(0));
1405       OutStreamer.EmitInstruction(TmpInst);
1406     }
1407     {
1408       MCInst TmpInst;
1409       TmpInst.setOpcode(ARM::tMOVtgpr2gpr);
1410       TmpInst.addOperand(MCOperand::CreateReg(ARM::SP));
1411       TmpInst.addOperand(MCOperand::CreateReg(ScratchReg));
1412       // Predicate.
1413       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1414       TmpInst.addOperand(MCOperand::CreateReg(0));
1415       OutStreamer.EmitInstruction(TmpInst);
1416     }
1417     {
1418       MCInst TmpInst;
1419       TmpInst.setOpcode(ARM::tLDRi);
1420       TmpInst.addOperand(MCOperand::CreateReg(ScratchReg));
1421       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1422       TmpInst.addOperand(MCOperand::CreateImm(1));
1423       // Predicate.
1424       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1425       TmpInst.addOperand(MCOperand::CreateReg(0));
1426       OutStreamer.EmitInstruction(TmpInst);
1427     }
1428     {
1429       MCInst TmpInst;
1430       TmpInst.setOpcode(ARM::tLDRr);
1431       TmpInst.addOperand(MCOperand::CreateReg(ARM::R7));
1432       TmpInst.addOperand(MCOperand::CreateReg(SrcReg));
1433       TmpInst.addOperand(MCOperand::CreateReg(0));
1434       // Predicate.
1435       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1436       TmpInst.addOperand(MCOperand::CreateReg(0));
1437       OutStreamer.EmitInstruction(TmpInst);
1438     }
1439     {
1440       MCInst TmpInst;
1441       TmpInst.setOpcode(ARM::tBX_RET_vararg);
1442       TmpInst.addOperand(MCOperand::CreateReg(ScratchReg));
1443       // Predicate.
1444       TmpInst.addOperand(MCOperand::CreateImm(ARMCC::AL));
1445       TmpInst.addOperand(MCOperand::CreateReg(0));
1446       OutStreamer.EmitInstruction(TmpInst);
1447     }
1448     return;
1449   }
1450   // These are the pseudos created to comply with stricter operand restrictions
1451   // on ARMv5. Lower them now to "normal" instructions, since all the
1452   // restrictions are already satisfied.
1453   case ARM::MULv5:
1454     EmitPatchedInstruction(MI, ARM::MUL);
1455     return;
1456   case ARM::MLAv5:
1457     EmitPatchedInstruction(MI, ARM::MLA);
1458     return;
1459   case ARM::SMULLv5:
1460     EmitPatchedInstruction(MI, ARM::SMULL);
1461     return;
1462   case ARM::UMULLv5:
1463     EmitPatchedInstruction(MI, ARM::UMULL);
1464     return;
1465   case ARM::SMLALv5:
1466     EmitPatchedInstruction(MI, ARM::SMLAL);
1467     return;
1468   case ARM::UMLALv5:
1469     EmitPatchedInstruction(MI, ARM::UMLAL);
1470     return;
1471   case ARM::UMAALv5:
1472     EmitPatchedInstruction(MI, ARM::UMAAL);
1473     return;
1474   }
1475
1476   MCInst TmpInst;
1477   LowerARMMachineInstrToMCInst(MI, TmpInst, *this);
1478   OutStreamer.EmitInstruction(TmpInst);
1479 }
1480
1481 //===----------------------------------------------------------------------===//
1482 // Target Registry Stuff
1483 //===----------------------------------------------------------------------===//
1484
1485 static MCInstPrinter *createARMMCInstPrinter(const Target &T,
1486                                              unsigned SyntaxVariant,
1487                                              const MCAsmInfo &MAI) {
1488   if (SyntaxVariant == 0)
1489     return new ARMInstPrinter(MAI);
1490   return 0;
1491 }
1492
1493 // Force static initialization.
1494 extern "C" void LLVMInitializeARMAsmPrinter() {
1495   RegisterAsmPrinter<ARMAsmPrinter> X(TheARMTarget);
1496   RegisterAsmPrinter<ARMAsmPrinter> Y(TheThumbTarget);
1497
1498   TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter);
1499   TargetRegistry::RegisterMCInstPrinter(TheThumbTarget, createARMMCInstPrinter);
1500 }
1501