lib/MC/MCAsmStreamer.cpp

   1 //===- lib/MC/MCAsmStreamer.cpp - Text Assembly Output --------------------===//
   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 #include "llvm/MC/MCStreamer.h"
  11 #include "llvm/MC/MCAsmInfo.h"
  12 #include "llvm/MC/MCCodeEmitter.h"
  13 #include "llvm/MC/MCContext.h"
  14 #include "llvm/MC/MCExpr.h"
  15 #include "llvm/MC/MCFixupKindInfo.h"
  16 #include "llvm/MC/MCInst.h"
  17 #include "llvm/MC/MCInstPrinter.h"
  18 #include "llvm/MC/MCSectionMachO.h"
  19 #include "llvm/MC/MCSymbol.h"
  20 #include "llvm/ADT/OwningPtr.h"
  21 #include "llvm/ADT/SmallString.h"
  22 #include "llvm/ADT/Twine.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Support/MathExtras.h"
  25 #include "llvm/Support/Format.h"
  26 #include "llvm/Support/FormattedStream.h"
  27 #include "llvm/Target/TargetAsmBackend.h"
  28 #include "llvm/Target/TargetAsmInfo.h"
  29 #include "llvm/Target/TargetLoweringObjectFile.h"
  30 #include <cctype>
  31 using namespace llvm;
  32
  33 namespace {
  34
  35 class MCAsmStreamer : public MCStreamer {
  36   formatted_raw_ostream &OS;
  37   const MCAsmInfo &MAI;
  38   OwningPtr<MCInstPrinter> InstPrinter;
  39   OwningPtr<MCCodeEmitter> Emitter;
  40   OwningPtr<TargetAsmBackend> AsmBackend;
  41
  42   SmallString<128> CommentToEmit;
  43   raw_svector_ostream CommentStream;
  44
  45   unsigned IsVerboseAsm : 1;
  46   unsigned ShowInst : 1;
  47   unsigned UseLoc : 1;
  48
  49   bool needsSet(const MCExpr *Value);
  50
  51 public:
  52   MCAsmStreamer(MCContext &Context, formatted_raw_ostream &os,
  53                 bool isVerboseAsm,
  54                 bool useLoc,
  55                 MCInstPrinter *printer, MCCodeEmitter *emitter,
  56                 TargetAsmBackend *asmbackend,
  57                 bool showInst)
  58     : MCStreamer(Context), OS(os), MAI(Context.getAsmInfo()),
  59       InstPrinter(printer), Emitter(emitter), AsmBackend(asmbackend),
  60       CommentStream(CommentToEmit), IsVerboseAsm(isVerboseAsm),
  61       ShowInst(showInst), UseLoc(useLoc) {
  62     if (InstPrinter && IsVerboseAsm)
  63       InstPrinter->setCommentStream(CommentStream);
  64   }
  65   ~MCAsmStreamer() {}
  66
  67   inline void EmitEOL() {
  68     // If we don't have any comments, just emit a \n.
  69     if (!IsVerboseAsm) {
  70       OS << '\n';
  71       return;
  72     }
  73     EmitCommentsAndEOL();
  74   }
  75   void EmitCommentsAndEOL();
  76
  77   /// isVerboseAsm - Return true if this streamer supports verbose assembly at
  78   /// all.
  79   virtual bool isVerboseAsm() const { return IsVerboseAsm; }
  80
  81   /// hasRawTextSupport - We support EmitRawText.
  82   virtual bool hasRawTextSupport() const { return true; }
  83
  84   /// AddComment - Add a comment that can be emitted to the generated .s
  85   /// file if applicable as a QoI issue to make the output of the compiler
  86   /// more readable.  This only affects the MCAsmStreamer, and only when
  87   /// verbose assembly output is enabled.
  88   virtual void AddComment(const Twine &T);
  89
  90   /// AddEncodingComment - Add a comment showing the encoding of an instruction.
  91   virtual void AddEncodingComment(const MCInst &Inst);
  92
  93   /// GetCommentOS - Return a raw_ostream that comments can be written to.
  94   /// Unlike AddComment, you are required to terminate comments with \n if you
  95   /// use this method.
  96   virtual raw_ostream &GetCommentOS() {
  97     if (!IsVerboseAsm)
  98       return nulls();  // Discard comments unless in verbose asm mode.
  99     return CommentStream;
 100   }
 101
 102   /// AddBlankLine - Emit a blank line to a .s file to pretty it up.
 103   virtual void AddBlankLine() {
 104     EmitEOL();
 105   }
 106
 107   /// @name MCStreamer Interface
 108   /// @{
 109
 110   virtual void ChangeSection(const MCSection *Section);
 111
 112   virtual void InitSections() {
 113     // FIXME, this is MachO specific, but the testsuite
 114     // expects this.
 115     SwitchSection(getContext().getMachOSection("__TEXT", "__text",
 116                          MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
 117                          0, SectionKind::getText()));
 118   }
 119
 120   virtual void EmitLabel(MCSymbol *Symbol);
 121
 122   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
 123   virtual void EmitThumbFunc(MCSymbol *Func);
 124
 125   virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
 126   virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
 127   virtual void EmitDwarfAdvanceLineAddr(int64_t LineDelta,
 128                                         const MCSymbol *LastLabel,
 129                                         const MCSymbol *Label);
 130
 131   virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute);
 132
 133   virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
 134   virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol);
 135   virtual void EmitCOFFSymbolStorageClass(int StorageClass);
 136   virtual void EmitCOFFSymbolType(int Type);
 137   virtual void EndCOFFSymbolDef();
 138   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value);
 139   virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
 140                                 unsigned ByteAlignment);
 141
 142   /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
 143   ///
 144   /// @param Symbol - The common symbol to emit.
 145   /// @param Size - The size of the common symbol.
 146   virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size);
 147
 148   virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0,
 149                             unsigned Size = 0, unsigned ByteAlignment = 0);
 150
 151   virtual void EmitTBSSSymbol (const MCSection *Section, MCSymbol *Symbol,
 152                                uint64_t Size, unsigned ByteAlignment = 0);
 153
 154   virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
 155
 156   virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
 157                              bool isPCRel, unsigned AddrSpace);
 158   virtual void EmitIntValue(uint64_t Value, unsigned Size,
 159                             unsigned AddrSpace = 0);
 160
 161   virtual void EmitULEB128Value(const MCExpr *Value, unsigned AddrSpace = 0);
 162
 163   virtual void EmitSLEB128Value(const MCExpr *Value, unsigned AddrSpace = 0);
 164
 165   virtual void EmitGPRel32Value(const MCExpr *Value);
 166
 167
 168   virtual void EmitFill(uint64_t NumBytes, uint8_t FillValue,
 169                         unsigned AddrSpace);
 170
 171   virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
 172                                     unsigned ValueSize = 1,
 173                                     unsigned MaxBytesToEmit = 0);
 174
 175   virtual void EmitCodeAlignment(unsigned ByteAlignment,
 176                                  unsigned MaxBytesToEmit = 0);
 177
 178   virtual void EmitValueToOffset(const MCExpr *Offset,
 179                                  unsigned char Value = 0);
 180
 181   virtual void EmitFileDirective(StringRef Filename);
 182   virtual bool EmitDwarfFileDirective(unsigned FileNo, StringRef Filename);
 183   virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
 184                                      unsigned Column, unsigned Flags,
 185                                      unsigned Isa, unsigned Discriminator);
 186
 187   virtual void EmitCFIStartProc();
 188   virtual void EmitCFIEndProc();
 189   virtual void EmitCFIDefCfa(int64_t Register, int64_t Offset);
 190   virtual void EmitCFIDefCfaOffset(int64_t Offset);
 191   virtual void EmitCFIDefCfaRegister(int64_t Register);
 192   virtual void EmitCFIOffset(int64_t Register, int64_t Offset);
 193   virtual void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
 194   virtual void EmitCFILsda(const MCSymbol *Sym, unsigned Encoding);
 195   virtual void EmitCFIRememberState();
 196   virtual void EmitCFIRestoreState();
 197   virtual void EmitCFISameValue(int64_t Register);
 198   virtual void EmitCFIRelOffset(int64_t Register, int64_t Offset);
 199   virtual void EmitCFIAdjustCfaOffset(int64_t Adjustment);
 200
 201   virtual void EmitFnStart();
 202   virtual void EmitFnEnd();
 203   virtual void EmitCantUnwind();
 204   virtual void EmitPersonality(const MCSymbol *Personality);
 205   virtual void EmitHandlerData();
 206   virtual void EmitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0);
 207   virtual void EmitPad(int64_t Offset);
 208   virtual void EmitRegSave(const SmallVectorImpl<unsigned> &RegList, bool);
 209
 210
 211   virtual void EmitInstruction(const MCInst &Inst);
 212
 213   /// EmitRawText - If this file is backed by an assembly streamer, this dumps
 214   /// the specified string in the output .s file.  This capability is
 215   /// indicated by the hasRawTextSupport() predicate.
 216   virtual void EmitRawText(StringRef String);
 217
 218   virtual void Finish();
 219
 220   /// @}
 221 };
 222
 223 } // end anonymous namespace.
 224
 225 /// AddComment - Add a comment that can be emitted to the generated .s
 226 /// file if applicable as a QoI issue to make the output of the compiler
 227 /// more readable.  This only affects the MCAsmStreamer, and only when
 228 /// verbose assembly output is enabled.
 229 void MCAsmStreamer::AddComment(const Twine &T) {
 230   if (!IsVerboseAsm) return;
 231
 232   // Make sure that CommentStream is flushed.
 233   CommentStream.flush();
 234
 235   T.toVector(CommentToEmit);
 236   // Each comment goes on its own line.
 237   CommentToEmit.push_back('\n');
 238
 239   // Tell the comment stream that the vector changed underneath it.
 240   CommentStream.resync();
 241 }
 242
 243 void MCAsmStreamer::EmitCommentsAndEOL() {
 244   if (CommentToEmit.empty() && CommentStream.GetNumBytesInBuffer() == 0) {
 245     OS << '\n';
 246     return;
 247   }
 248
 249   CommentStream.flush();
 250   StringRef Comments = CommentToEmit.str();
 251
 252   assert(Comments.back() == '\n' &&
 253          "Comment array not newline terminated");
 254   do {
 255     // Emit a line of comments.
 256     OS.PadToColumn(MAI.getCommentColumn());
 257     size_t Position = Comments.find('\n');
 258     OS << MAI.getCommentString() << ' ' << Comments.substr(0, Position) << '\n';
 259
 260     Comments = Comments.substr(Position+1);
 261   } while (!Comments.empty());
 262
 263   CommentToEmit.clear();
 264   // Tell the comment stream that the vector changed underneath it.
 265   CommentStream.resync();
 266 }
 267
 268 static inline int64_t truncateToSize(int64_t Value, unsigned Bytes) {
 269   assert(Bytes && "Invalid size!");
 270   return Value & ((uint64_t) (int64_t) -1 >> (64 - Bytes * 8));
 271 }
 272
 273 void MCAsmStreamer::ChangeSection(const MCSection *Section) {
 274   assert(Section && "Cannot switch to a null section!");
 275   Section->PrintSwitchToSection(MAI, OS);
 276 }
 277
 278 void MCAsmStreamer::EmitLabel(MCSymbol *Symbol) {
 279   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
 280   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
 281   assert(getCurrentSection() && "Cannot emit before setting section!");
 282
 283   OS << *Symbol << MAI.getLabelSuffix();
 284   EmitEOL();
 285   Symbol->setSection(*getCurrentSection());
 286 }
 287
 288 void MCAsmStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
 289   switch (Flag) {
 290   default: assert(0 && "Invalid flag!");
 291   case MCAF_SyntaxUnified:         OS << "\t.syntax unified"; break;
 292   case MCAF_SubsectionsViaSymbols: OS << ".subsections_via_symbols"; break;
 293   case MCAF_Code16:                OS << "\t.code\t16"; break;
 294   case MCAF_Code32:                OS << "\t.code\t32"; break;
 295   }
 296   EmitEOL();
 297 }
 298
 299 void MCAsmStreamer::EmitThumbFunc(MCSymbol *Func) {
 300   // This needs to emit to a temporary string to get properly quoted
 301   // MCSymbols when they have spaces in them.
 302   OS << "\t.thumb_func";
 303   if (Func)
 304     OS << '\t' << *Func;
 305   EmitEOL();
 306 }
 307
 308 void MCAsmStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
 309   OS << *Symbol << " = " << *Value;
 310   EmitEOL();
 311
 312   // FIXME: Lift context changes into super class.
 313   Symbol->setVariableValue(Value);
 314 }
 315
 316 void MCAsmStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
 317   OS << ".weakref " << *Alias << ", " << *Symbol;
 318   EmitEOL();
 319 }
 320
 321 void MCAsmStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
 322                                              const MCSymbol *LastLabel,
 323                                              const MCSymbol *Label) {
 324   EmitDwarfSetLineAddr(LineDelta, Label,
 325                        getContext().getTargetAsmInfo().getPointerSize());
 326 }
 327
 328 void MCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
 329                                         MCSymbolAttr Attribute) {
 330   switch (Attribute) {
 331   case MCSA_Invalid: assert(0 && "Invalid symbol attribute");
 332   case MCSA_ELF_TypeFunction:    /// .type _foo, STT_FUNC  # aka @function
 333   case MCSA_ELF_TypeIndFunction: /// .type _foo, STT_GNU_IFUNC
 334   case MCSA_ELF_TypeObject:      /// .type _foo, STT_OBJECT  # aka @object
 335   case MCSA_ELF_TypeTLS:         /// .type _foo, STT_TLS     # aka @tls_object
 336   case MCSA_ELF_TypeCommon:      /// .type _foo, STT_COMMON  # aka @common
 337   case MCSA_ELF_TypeNoType:      /// .type _foo, STT_NOTYPE  # aka @notype
 338   case MCSA_ELF_TypeGnuUniqueObject:  /// .type _foo, @gnu_unique_object
 339     assert(MAI.hasDotTypeDotSizeDirective() && "Symbol Attr not supported");
 340     OS << "\t.type\t" << *Symbol << ','
 341        << ((MAI.getCommentString()[0] != '@') ? '@' : '%');
 342     switch (Attribute) {
 343     default: assert(0 && "Unknown ELF .type");
 344     case MCSA_ELF_TypeFunction:    OS << "function"; break;
 345     case MCSA_ELF_TypeIndFunction: OS << "gnu_indirect_function"; break;
 346     case MCSA_ELF_TypeObject:      OS << "object"; break;
 347     case MCSA_ELF_TypeTLS:         OS << "tls_object"; break;
 348     case MCSA_ELF_TypeCommon:      OS << "common"; break;
 349     case MCSA_ELF_TypeNoType:      OS << "no_type"; break;
 350     case MCSA_ELF_TypeGnuUniqueObject: OS << "gnu_unique_object"; break;
 351     }
 352     EmitEOL();
 353     return;
 354   case MCSA_Global: // .globl/.global
 355     OS << MAI.getGlobalDirective();
 356     break;
 357   case MCSA_Hidden:         OS << "\t.hidden\t";          break;
 358   case MCSA_IndirectSymbol: OS << "\t.indirect_symbol\t"; break;
 359   case MCSA_Internal:       OS << "\t.internal\t";        break;
 360   case MCSA_LazyReference:  OS << "\t.lazy_reference\t";  break;
 361   case MCSA_Local:          OS << "\t.local\t";           break;
 362   case MCSA_NoDeadStrip:    OS << "\t.no_dead_strip\t";   break;
 363   case MCSA_SymbolResolver: OS << "\t.symbol_resolver\t"; break;
 364   case MCSA_PrivateExtern:  OS << "\t.private_extern\t";  break;
 365   case MCSA_Protected:      OS << "\t.protected\t";       break;
 366   case MCSA_Reference:      OS << "\t.reference\t";       break;
 367   case MCSA_Weak:           OS << "\t.weak\t";            break;
 368   case MCSA_WeakDefinition: OS << "\t.weak_definition\t"; break;
 369       // .weak_reference
 370   case MCSA_WeakReference:  OS << MAI.getWeakRefDirective(); break;
 371   case MCSA_WeakDefAutoPrivate: OS << "\t.weak_def_can_be_hidden\t"; break;
 372   }
 373
 374   OS << *Symbol;
 375   EmitEOL();
 376 }
 377
 378 void MCAsmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
 379   OS << ".desc" << ' ' << *Symbol << ',' << DescValue;
 380   EmitEOL();
 381 }
 382
 383 void MCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
 384   OS << "\t.def\t " << *Symbol << ';';
 385   EmitEOL();
 386 }
 387
 388 void MCAsmStreamer::EmitCOFFSymbolStorageClass (int StorageClass) {
 389   OS << "\t.scl\t" << StorageClass << ';';
 390   EmitEOL();
 391 }
 392
 393 void MCAsmStreamer::EmitCOFFSymbolType (int Type) {
 394   OS << "\t.type\t" << Type << ';';
 395   EmitEOL();
 396 }
 397
 398 void MCAsmStreamer::EndCOFFSymbolDef() {
 399   OS << "\t.endef";
 400   EmitEOL();
 401 }
 402
 403 void MCAsmStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
 404   assert(MAI.hasDotTypeDotSizeDirective());
 405   OS << "\t.size\t" << *Symbol << ", " << *Value << '\n';
 406 }
 407
 408 void MCAsmStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
 409                                      unsigned ByteAlignment) {
 410   OS << "\t.comm\t" << *Symbol << ',' << Size;
 411   if (ByteAlignment != 0) {
 412     if (MAI.getCOMMDirectiveAlignmentIsInBytes())
 413       OS << ',' << ByteAlignment;
 414     else
 415       OS << ',' << Log2_32(ByteAlignment);
 416   }
 417   EmitEOL();
 418 }
 419
 420 /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
 421 ///
 422 /// @param Symbol - The common symbol to emit.
 423 /// @param Size - The size of the common symbol.
 424 void MCAsmStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) {
 425   assert(MAI.hasLCOMMDirective() && "Doesn't have .lcomm, can't emit it!");
 426   OS << "\t.lcomm\t" << *Symbol << ',' << Size;
 427   EmitEOL();
 428 }
 429
 430 void MCAsmStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
 431                                  unsigned Size, unsigned ByteAlignment) {
 432   // Note: a .zerofill directive does not switch sections.
 433   OS << ".zerofill ";
 434
 435   // This is a mach-o specific directive.
 436   const MCSectionMachO *MOSection = ((const MCSectionMachO*)Section);
 437   OS << MOSection->getSegmentName() << "," << MOSection->getSectionName();
 438
 439   if (Symbol != NULL) {
 440     OS << ',' << *Symbol << ',' << Size;
 441     if (ByteAlignment != 0)
 442       OS << ',' << Log2_32(ByteAlignment);
 443   }
 444   EmitEOL();
 445 }
 446
 447 // .tbss sym, size, align
 448 // This depends that the symbol has already been mangled from the original,
 449 // e.g. _a.
 450 void MCAsmStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
 451                                    uint64_t Size, unsigned ByteAlignment) {
 452   assert(Symbol != NULL && "Symbol shouldn't be NULL!");
 453   // Instead of using the Section we'll just use the shortcut.
 454   // This is a mach-o specific directive and section.
 455   OS << ".tbss " << *Symbol << ", " << Size;
 456
 457   // Output align if we have it.  We default to 1 so don't bother printing
 458   // that.
 459   if (ByteAlignment > 1) OS << ", " << Log2_32(ByteAlignment);
 460
 461   EmitEOL();
 462 }
 463
 464 static inline char toOctal(int X) { return (X&7)+'0'; }
 465
 466 static void PrintQuotedString(StringRef Data, raw_ostream &OS) {
 467   OS << '"';
 468
 469   for (unsigned i = 0, e = Data.size(); i != e; ++i) {
 470     unsigned char C = Data[i];
 471     if (C == '"' || C == '\\') {
 472       OS << '\\' << (char)C;
 473       continue;
 474     }
 475
 476     if (isprint((unsigned char)C)) {
 477       OS << (char)C;
 478       continue;
 479     }
 480
 481     switch (C) {
 482       case '\b': OS << "\\b"; break;
 483       case '\f': OS << "\\f"; break;
 484       case '\n': OS << "\\n"; break;
 485       case '\r': OS << "\\r"; break;
 486       case '\t': OS << "\\t"; break;
 487       default:
 488         OS << '\\';
 489         OS << toOctal(C >> 6);
 490         OS << toOctal(C >> 3);
 491         OS << toOctal(C >> 0);
 492         break;
 493     }
 494   }
 495
 496   OS << '"';
 497 }
 498
 499
 500 void MCAsmStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
 501   assert(getCurrentSection() && "Cannot emit contents before setting section!");
 502   if (Data.empty()) return;
 503
 504   if (Data.size() == 1) {
 505     OS << MAI.getData8bitsDirective(AddrSpace);
 506     OS << (unsigned)(unsigned char)Data[0];
 507     EmitEOL();
 508     return;
 509   }
 510
 511   // If the data ends with 0 and the target supports .asciz, use it, otherwise
 512   // use .ascii
 513   if (MAI.getAscizDirective() && Data.back() == 0) {
 514     OS << MAI.getAscizDirective();
 515     Data = Data.substr(0, Data.size()-1);
 516   } else {
 517     OS << MAI.getAsciiDirective();
 518   }
 519
 520   OS << ' ';
 521   PrintQuotedString(Data, OS);
 522   EmitEOL();
 523 }
 524
 525 void MCAsmStreamer::EmitIntValue(uint64_t Value, unsigned Size,
 526                                  unsigned AddrSpace) {
 527   EmitValue(MCConstantExpr::Create(Value, getContext()), Size, AddrSpace);
 528 }
 529
 530 void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
 531                                   bool isPCRel, unsigned AddrSpace) {
 532   assert(getCurrentSection() && "Cannot emit contents before setting section!");
 533   assert(!isPCRel && "Cannot emit pc relative relocations!");
 534   const char *Directive = 0;
 535   switch (Size) {
 536   default: break;
 537   case 1: Directive = MAI.getData8bitsDirective(AddrSpace); break;
 538   case 2: Directive = MAI.getData16bitsDirective(AddrSpace); break;
 539   case 4: Directive = MAI.getData32bitsDirective(AddrSpace); break;
 540   case 8:
 541     Directive = MAI.getData64bitsDirective(AddrSpace);
 542     // If the target doesn't support 64-bit data, emit as two 32-bit halves.
 543     if (Directive) break;
 544     int64_t IntValue;
 545     if (!Value->EvaluateAsAbsolute(IntValue))
 546       report_fatal_error("Don't know how to emit this value.");
 547     if (getContext().getTargetAsmInfo().isLittleEndian()) {
 548       EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
 549       EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
 550     } else {
 551       EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
 552       EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
 553     }
 554     return;
 555   }
 556
 557   assert(Directive && "Invalid size for machine code value!");
 558   OS << Directive << *Value;
 559   EmitEOL();
 560 }
 561
 562 void MCAsmStreamer::EmitULEB128Value(const MCExpr *Value, unsigned AddrSpace) {
 563   int64_t IntValue;
 564   if (Value->EvaluateAsAbsolute(IntValue)) {
 565     EmitULEB128IntValue(IntValue, AddrSpace);
 566     return;
 567   }
 568   assert(MAI.hasLEB128() && "Cannot print a .uleb");
 569   OS << ".uleb128 " << *Value;
 570   EmitEOL();
 571 }
 572
 573 void MCAsmStreamer::EmitSLEB128Value(const MCExpr *Value, unsigned AddrSpace) {
 574   int64_t IntValue;
 575   if (Value->EvaluateAsAbsolute(IntValue)) {
 576     EmitSLEB128IntValue(IntValue, AddrSpace);
 577     return;
 578   }
 579   assert(MAI.hasLEB128() && "Cannot print a .sleb");
 580   OS << ".sleb128 " << *Value;
 581   EmitEOL();
 582 }
 583
 584 void MCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) {
 585   assert(MAI.getGPRel32Directive() != 0);
 586   OS << MAI.getGPRel32Directive() << *Value;
 587   EmitEOL();
 588 }
 589
 590
 591 /// EmitFill - Emit NumBytes bytes worth of the value specified by
 592 /// FillValue.  This implements directives such as '.space'.
 593 void MCAsmStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue,
 594                              unsigned AddrSpace) {
 595   if (NumBytes == 0) return;
 596
 597   if (AddrSpace == 0)
 598     if (const char *ZeroDirective = MAI.getZeroDirective()) {
 599       OS << ZeroDirective << NumBytes;
 600       if (FillValue != 0)
 601         OS << ',' << (int)FillValue;
 602       EmitEOL();
 603       return;
 604     }
 605
 606   // Emit a byte at a time.
 607   MCStreamer::EmitFill(NumBytes, FillValue, AddrSpace);
 608 }
 609
 610 void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
 611                                          unsigned ValueSize,
 612                                          unsigned MaxBytesToEmit) {
 613   // Some assemblers don't support non-power of two alignments, so we always
 614   // emit alignments as a power of two if possible.
 615   if (isPowerOf2_32(ByteAlignment)) {
 616     switch (ValueSize) {
 617     default: llvm_unreachable("Invalid size for machine code value!");
 618     case 1: OS << MAI.getAlignDirective(); break;
 619     // FIXME: use MAI for this!
 620     case 2: OS << ".p2alignw "; break;
 621     case 4: OS << ".p2alignl "; break;
 622     case 8: llvm_unreachable("Unsupported alignment size!");
 623     }
 624
 625     if (MAI.getAlignmentIsInBytes())
 626       OS << ByteAlignment;
 627     else
 628       OS << Log2_32(ByteAlignment);
 629
 630     if (Value || MaxBytesToEmit) {
 631       OS << ", 0x";
 632       OS.write_hex(truncateToSize(Value, ValueSize));
 633
 634       if (MaxBytesToEmit)
 635         OS << ", " << MaxBytesToEmit;
 636     }
 637     EmitEOL();
 638     return;
 639   }
 640
 641   // Non-power of two alignment.  This is not widely supported by assemblers.
 642   // FIXME: Parameterize this based on MAI.
 643   switch (ValueSize) {
 644   default: llvm_unreachable("Invalid size for machine code value!");
 645   case 1: OS << ".balign";  break;
 646   case 2: OS << ".balignw"; break;
 647   case 4: OS << ".balignl"; break;
 648   case 8: llvm_unreachable("Unsupported alignment size!");
 649   }
 650
 651   OS << ' ' << ByteAlignment;
 652   OS << ", " << truncateToSize(Value, ValueSize);
 653   if (MaxBytesToEmit)
 654     OS << ", " << MaxBytesToEmit;
 655   EmitEOL();
 656 }
 657
 658 void MCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment,
 659                                       unsigned MaxBytesToEmit) {
 660   // Emit with a text fill value.
 661   EmitValueToAlignment(ByteAlignment, MAI.getTextAlignFillValue(),
 662                        1, MaxBytesToEmit);
 663 }
 664
 665 void MCAsmStreamer::EmitValueToOffset(const MCExpr *Offset,
 666                                       unsigned char Value) {
 667   // FIXME: Verify that Offset is associated with the current section.
 668   OS << ".org " << *Offset << ", " << (unsigned) Value;
 669   EmitEOL();
 670 }
 671
 672
 673 void MCAsmStreamer::EmitFileDirective(StringRef Filename) {
 674   assert(MAI.hasSingleParameterDotFile());
 675   OS << "\t.file\t";
 676   PrintQuotedString(Filename, OS);
 677   EmitEOL();
 678 }
 679
 680 bool MCAsmStreamer::EmitDwarfFileDirective(unsigned FileNo, StringRef Filename){
 681   if (UseLoc) {
 682     OS << "\t.file\t" << FileNo << ' ';
 683     PrintQuotedString(Filename, OS);
 684     EmitEOL();
 685   }
 686   return this->MCStreamer::EmitDwarfFileDirective(FileNo, Filename);
 687 }
 688
 689 void MCAsmStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
 690                                           unsigned Column, unsigned Flags,
 691                                           unsigned Isa,
 692                                           unsigned Discriminator) {
 693   this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
 694                                           Isa, Discriminator);
 695   if (!UseLoc)
 696     return;
 697
 698   OS << "\t.loc\t" << FileNo << " " << Line << " " << Column;
 699   if (Flags & DWARF2_FLAG_BASIC_BLOCK)
 700     OS << " basic_block";
 701   if (Flags & DWARF2_FLAG_PROLOGUE_END)
 702     OS << " prologue_end";
 703   if (Flags & DWARF2_FLAG_EPILOGUE_BEGIN)
 704     OS << " epilogue_begin";
 705
 706   unsigned OldFlags = getContext().getCurrentDwarfLoc().getFlags();
 707   if ((Flags & DWARF2_FLAG_IS_STMT) != (OldFlags & DWARF2_FLAG_IS_STMT)) {
 708     OS << " is_stmt ";
 709
 710     if (Flags & DWARF2_FLAG_IS_STMT)
 711       OS << "1";
 712     else
 713       OS << "0";
 714   }
 715
 716   if (Isa)
 717     OS << "isa " << Isa;
 718   if (Discriminator)
 719     OS << "discriminator " << Discriminator;
 720   EmitEOL();
 721 }
 722
 723 void MCAsmStreamer::EmitCFIStartProc() {
 724   MCStreamer::EmitCFIStartProc();
 725
 726   OS << "\t.cfi_startproc";
 727   EmitEOL();
 728 }
 729
 730 void MCAsmStreamer::EmitCFIEndProc() {
 731   MCStreamer::EmitCFIEndProc();
 732
 733   OS << "\t.cfi_endproc";
 734   EmitEOL();
 735 }
 736
 737 void MCAsmStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
 738   abort();
 739 }
 740
 741 void MCAsmStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
 742   MCStreamer::EmitCFIDefCfaOffset(Offset);
 743
 744   OS << "\t.cfi_def_cfa_offset " << Offset;
 745   EmitEOL();
 746 }
 747
 748 void MCAsmStreamer::EmitCFIDefCfaRegister(int64_t Register) {
 749   MCStreamer::EmitCFIDefCfaRegister(Register);
 750
 751   OS << "\t.cfi_def_cfa_register " << Register;
 752   EmitEOL();
 753 }
 754
 755 void MCAsmStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
 756   this->MCStreamer::EmitCFIOffset(Register, Offset);
 757
 758   OS << "\t.cfi_offset " << Register << ", " << Offset;
 759   EmitEOL();
 760 }
 761
 762 void MCAsmStreamer::EmitCFIPersonality(const MCSymbol *Sym,
 763                                        unsigned Encoding) {
 764   MCStreamer::EmitCFIPersonality(Sym, Encoding);
 765
 766   OS << "\t.cfi_personality " << Encoding << ", " << *Sym;
 767   EmitEOL();
 768 }
 769
 770 void MCAsmStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
 771   MCStreamer::EmitCFILsda(Sym, Encoding);
 772
 773   OS << "\t.cfi_lsda " << Encoding << ", " << *Sym;
 774   EmitEOL();
 775 }
 776
 777 void MCAsmStreamer::EmitCFIRememberState() {
 778   MCStreamer::EmitCFIRememberState();
 779
 780   OS << "\t.cfi_remember_state";
 781   EmitEOL();
 782 }
 783
 784 void MCAsmStreamer::EmitCFIRestoreState() {
 785   MCStreamer::EmitCFIRestoreState();
 786
 787   OS << "\t.cfi_restore_state";
 788   EmitEOL();
 789 }
 790
 791 void MCAsmStreamer::EmitCFISameValue(int64_t Register) {
 792   MCStreamer::EmitCFISameValue(Register);
 793
 794   OS << "\t.cfi_same_value " << Register;
 795   EmitEOL();
 796 }
 797
 798 void MCAsmStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
 799   MCStreamer::EmitCFIRelOffset(Register, Offset);
 800
 801   OS << "\t.cfi_rel_offset " << Register << ", " << Offset;
 802   EmitEOL();
 803 }
 804
 805 void MCAsmStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
 806   MCStreamer::EmitCFIAdjustCfaOffset(Adjustment);
 807
 808   OS << "\t.cfi_adjust_cfa_offset " << Adjustment;
 809   EmitEOL();
 810 }
 811
 812 void MCAsmStreamer::AddEncodingComment(const MCInst &Inst) {
 813   raw_ostream &OS = GetCommentOS();
 814   SmallString<256> Code;
 815   SmallVector<MCFixup, 4> Fixups;
 816   raw_svector_ostream VecOS(Code);
 817   Emitter->EncodeInstruction(Inst, VecOS, Fixups);
 818   VecOS.flush();
 819
 820   // If we are showing fixups, create symbolic markers in the encoded
 821   // representation. We do this by making a per-bit map to the fixup item index,
 822   // then trying to display it as nicely as possible.
 823   SmallVector<uint8_t, 64> FixupMap;
 824   FixupMap.resize(Code.size() * 8);
 825   for (unsigned i = 0, e = Code.size() * 8; i != e; ++i)
 826     FixupMap[i] = 0;
 827
 828   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
 829     MCFixup &F = Fixups[i];
 830     const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind());
 831     for (unsigned j = 0; j != Info.TargetSize; ++j) {
 832       unsigned Index = F.getOffset() * 8 + Info.TargetOffset + j;
 833       assert(Index < Code.size() * 8 && "Invalid offset in fixup!");
 834       FixupMap[Index] = 1 + i;
 835     }
 836   }
 837
 838   // FIXME: Node the fixup comments for Thumb2 are completely bogus since the
 839   // high order halfword of a 32-bit Thumb2 instruction is emitted first.
 840   OS << "encoding: [";
 841   for (unsigned i = 0, e = Code.size(); i != e; ++i) {
 842     if (i)
 843       OS << ',';
 844
 845     // See if all bits are the same map entry.
 846     uint8_t MapEntry = FixupMap[i * 8 + 0];
 847     for (unsigned j = 1; j != 8; ++j) {
 848       if (FixupMap[i * 8 + j] == MapEntry)
 849         continue;
 850
 851       MapEntry = uint8_t(~0U);
 852       break;
 853     }
 854
 855     if (MapEntry != uint8_t(~0U)) {
 856       if (MapEntry == 0) {
 857         OS << format("0x%02x", uint8_t(Code[i]));
 858       } else {
 859         if (Code[i]) {
 860           // FIXME: Some of the 8 bits require fix up.
 861           OS << format("0x%02x", uint8_t(Code[i])) << '\''
 862              << char('A' + MapEntry - 1) << '\'';
 863         } else
 864           OS << char('A' + MapEntry - 1);
 865       }
 866     } else {
 867       // Otherwise, write out in binary.
 868       OS << "0b";
 869       for (unsigned j = 8; j--;) {
 870         unsigned Bit = (Code[i] >> j) & 1;
 871
 872         unsigned FixupBit;
 873         if (getContext().getTargetAsmInfo().isLittleEndian())
 874           FixupBit = i * 8 + j;
 875         else
 876           FixupBit = i * 8 + (7-j);
 877
 878         if (uint8_t MapEntry = FixupMap[FixupBit]) {
 879           assert(Bit == 0 && "Encoder wrote into fixed up bit!");
 880           OS << char('A' + MapEntry - 1);
 881         } else
 882           OS << Bit;
 883       }
 884     }
 885   }
 886   OS << "]\n";
 887
 888   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
 889     MCFixup &F = Fixups[i];
 890     const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind());
 891     OS << "  fixup " << char('A' + i) << " - " << "offset: " << F.getOffset()
 892        << ", value: " << *F.getValue() << ", kind: " << Info.Name << "\n";
 893   }
 894 }
 895
 896 void MCAsmStreamer::EmitFnStart() {
 897   OS << "\t.fnstart";
 898   EmitEOL();
 899 }
 900
 901 void MCAsmStreamer::EmitFnEnd() {
 902   OS << "\t.fnend";
 903   EmitEOL();
 904 }
 905
 906 void MCAsmStreamer::EmitCantUnwind() {
 907   OS << "\t.cantunwind";
 908   EmitEOL();
 909 }
 910
 911 void MCAsmStreamer::EmitHandlerData() {
 912   OS << "\t.handlerdata";
 913   EmitEOL();
 914 }
 915
 916 void MCAsmStreamer::EmitPersonality(const MCSymbol *Personality) {
 917   OS << "\t.personality " << Personality->getName();
 918   EmitEOL();
 919 }
 920
 921 void MCAsmStreamer::EmitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset) {
 922   OS << "\t.setfp\t" << InstPrinter->getRegName(FpReg)
 923      << ", "        << InstPrinter->getRegName(SpReg);
 924   if (Offset)
 925     OS << ", #" << Offset;
 926   EmitEOL();
 927 }
 928
 929 void MCAsmStreamer::EmitPad(int64_t Offset) {
 930   OS << "\t.pad\t#" << Offset;
 931   EmitEOL();
 932 }
 933
 934 void MCAsmStreamer::EmitRegSave(const SmallVectorImpl<unsigned> &RegList,
 935                                 bool isVector) {
 936   assert(RegList.size() && "RegList should not be empty");
 937   if (isVector)
 938     OS << "\t.vsave\t{";
 939   else
 940     OS << "\t.save\t{";
 941
 942   OS << InstPrinter->getRegName(RegList[0]);
 943
 944   for (unsigned i = 1, e = RegList.size(); i != e; ++i)
 945     OS << ", " << InstPrinter->getRegName(RegList[i]);
 946
 947   OS << "}";
 948   EmitEOL();
 949 }
 950
 951 void MCAsmStreamer::EmitInstruction(const MCInst &Inst) {
 952   assert(getCurrentSection() && "Cannot emit contents before setting section!");
 953
 954   if (!UseLoc)
 955     MCLineEntry::Make(this, getCurrentSection());
 956
 957   // Show the encoding in a comment if we have a code emitter.
 958   if (Emitter)
 959     AddEncodingComment(Inst);
 960
 961   // Show the MCInst if enabled.
 962   if (ShowInst) {
 963     Inst.dump_pretty(GetCommentOS(), &MAI, InstPrinter.get(), "\n ");
 964     GetCommentOS() << "\n";
 965   }
 966
 967   // If we have an AsmPrinter, use that to print, otherwise print the MCInst.
 968   if (InstPrinter)
 969     InstPrinter->printInst(&Inst, OS);
 970   else
 971     Inst.print(OS, &MAI);
 972   EmitEOL();
 973 }
 974
 975 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
 976 /// the specified string in the output .s file.  This capability is
 977 /// indicated by the hasRawTextSupport() predicate.
 978 void MCAsmStreamer::EmitRawText(StringRef String) {
 979   if (!String.empty() && String.back() == '\n')
 980     String = String.substr(0, String.size()-1);
 981   OS << String;
 982   EmitEOL();
 983 }
 984
 985 void MCAsmStreamer::Finish() {
 986   // Dump out the dwarf file & directory tables and line tables.
 987   if (getContext().hasDwarfFiles() && !UseLoc)
 988     MCDwarfFileTable::Emit(this);
 989 }
 990
 991 MCStreamer *llvm::createAsmStreamer(MCContext &Context,
 992                                     formatted_raw_ostream &OS,
 993                                     bool isVerboseAsm, bool useLoc,
 994                                     MCInstPrinter *IP, MCCodeEmitter *CE,
 995                                     TargetAsmBackend *TAB, bool ShowInst) {
 996   return new MCAsmStreamer(Context, OS, isVerboseAsm, useLoc,
 997                            IP, CE, TAB, ShowInst);
 998 }