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