LCOV - code coverage report
Current view: top level - lib/MC - MCAsmStreamer.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 918 976 94.1 %
Date: 2018-09-23 13:06:45 Functions: 120 126 95.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- lib/MC/MCAsmStreamer.cpp - Text Assembly Output ----------*- C++ -*-===//
       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/ADT/Optional.h"
      11             : #include "llvm/ADT/STLExtras.h"
      12             : #include "llvm/ADT/SmallString.h"
      13             : #include "llvm/ADT/StringExtras.h"
      14             : #include "llvm/ADT/Twine.h"
      15             : #include "llvm/MC/MCAsmBackend.h"
      16             : #include "llvm/MC/MCAsmInfo.h"
      17             : #include "llvm/MC/MCAssembler.h"
      18             : #include "llvm/MC/MCCodeEmitter.h"
      19             : #include "llvm/MC/MCCodeView.h"
      20             : #include "llvm/MC/MCContext.h"
      21             : #include "llvm/MC/MCExpr.h"
      22             : #include "llvm/MC/MCFixupKindInfo.h"
      23             : #include "llvm/MC/MCInst.h"
      24             : #include "llvm/MC/MCInstPrinter.h"
      25             : #include "llvm/MC/MCObjectFileInfo.h"
      26             : #include "llvm/MC/MCObjectWriter.h"
      27             : #include "llvm/MC/MCRegisterInfo.h"
      28             : #include "llvm/MC/MCSectionMachO.h"
      29             : #include "llvm/MC/MCStreamer.h"
      30             : #include "llvm/Support/ErrorHandling.h"
      31             : #include "llvm/Support/Format.h"
      32             : #include "llvm/Support/FormattedStream.h"
      33             : #include "llvm/Support/LEB128.h"
      34             : #include "llvm/Support/MathExtras.h"
      35             : #include "llvm/Support/Path.h"
      36             : #include "llvm/Support/TargetRegistry.h"
      37             : #include <cctype>
      38             : 
      39             : using namespace llvm;
      40             : 
      41             : namespace {
      42             : 
      43             : class MCAsmStreamer final : public MCStreamer {
      44             :   std::unique_ptr<formatted_raw_ostream> OSOwner;
      45             :   formatted_raw_ostream &OS;
      46             :   const MCAsmInfo *MAI;
      47             :   std::unique_ptr<MCInstPrinter> InstPrinter;
      48             :   std::unique_ptr<MCAssembler> Assembler;
      49             : 
      50             :   SmallString<128> ExplicitCommentToEmit;
      51             :   SmallString<128> CommentToEmit;
      52             :   raw_svector_ostream CommentStream;
      53             :   raw_null_ostream NullStream;
      54             : 
      55             :   unsigned IsVerboseAsm : 1;
      56             :   unsigned ShowInst : 1;
      57             :   unsigned UseDwarfDirectory : 1;
      58             : 
      59             :   void EmitRegisterName(int64_t Register);
      60             :   void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
      61             :   void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
      62             : 
      63             : public:
      64       22812 :   MCAsmStreamer(MCContext &Context, std::unique_ptr<formatted_raw_ostream> os,
      65             :                 bool isVerboseAsm, bool useDwarfDirectory,
      66             :                 MCInstPrinter *printer, std::unique_ptr<MCCodeEmitter> emitter,
      67             :                 std::unique_ptr<MCAsmBackend> asmbackend, bool showInst)
      68       22812 :       : MCStreamer(Context), OSOwner(std::move(os)), OS(*OSOwner),
      69       22812 :         MAI(Context.getAsmInfo()), InstPrinter(printer),
      70             :         Assembler(llvm::make_unique<MCAssembler>(
      71             :             Context, std::move(asmbackend), std::move(emitter),
      72       45624 :             (asmbackend) ? asmbackend->createObjectWriter(NullStream)
      73             :                          : nullptr)),
      74             :         CommentStream(CommentToEmit), IsVerboseAsm(isVerboseAsm),
      75       68436 :         ShowInst(showInst), UseDwarfDirectory(useDwarfDirectory) {
      76             :     assert(InstPrinter);
      77       22812 :     if (IsVerboseAsm)
      78             :         InstPrinter->setCommentStream(CommentStream);
      79       22812 :   }
      80             : 
      81             :   MCAssembler &getAssembler() { return *Assembler; }
      82      332735 :   MCAssembler *getAssemblerPtr() override { return nullptr; }
      83             : 
      84     5412107 :   inline void EmitEOL() {
      85             :     // Dump Explicit Comments here.
      86             :     emitExplicitComments();
      87             :     // If we don't have any comments, just emit a \n.
      88     5412107 :     if (!IsVerboseAsm) {
      89       89096 :       OS << '\n';
      90       89096 :       return;
      91             :     }
      92     5323011 :     EmitCommentsAndEOL();
      93             :   }
      94             : 
      95             :   void EmitSyntaxDirective() override;
      96             : 
      97             :   void EmitCommentsAndEOL();
      98             : 
      99             :   /// Return true if this streamer supports verbose assembly at all.
     100       61592 :   bool isVerboseAsm() const override { return IsVerboseAsm; }
     101             : 
     102             :   /// Do we support EmitRawText?
     103        4033 :   bool hasRawTextSupport() const override { return true; }
     104             : 
     105             :   /// Add a comment that can be emitted to the generated .s file to make the
     106             :   /// output of the compiler more readable. This only affects the MCAsmStreamer
     107             :   /// and only when verbose assembly output is enabled.
     108             :   void AddComment(const Twine &T, bool EOL = true) override;
     109             : 
     110             :   /// Add a comment showing the encoding of an instruction.
     111             :   /// If PrintSchedInfo is true, then the comment sched:[x:y] will be added to
     112             :   /// the output if supported by the target.
     113             :   void AddEncodingComment(const MCInst &Inst, const MCSubtargetInfo &,
     114             :                           bool PrintSchedInfo);
     115             : 
     116             :   /// Return a raw_ostream that comments can be written to.
     117             :   /// Unlike AddComment, you are required to terminate comments with \n if you
     118             :   /// use this method.
     119     2756364 :   raw_ostream &GetCommentOS() override {
     120     2946732 :     if (!IsVerboseAsm)
     121       41864 :       return nulls();  // Discard comments unless in verbose asm mode.
     122     4954674 :     return CommentStream;
     123             :   }
     124             : 
     125             :   void emitRawComment(const Twine &T, bool TabPrefix = true) override;
     126             : 
     127             :   void addExplicitComment(const Twine &T) override;
     128             :   void emitExplicitComments() override;
     129             : 
     130             :   /// Emit a blank line to a .s file to pretty it up.
     131      694080 :   void AddBlankLine() override {
     132      694080 :     EmitEOL();
     133      694080 :   }
     134             : 
     135             :   /// @name MCStreamer Interface
     136             :   /// @{
     137             : 
     138             :   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
     139             : 
     140             :   void emitELFSymverDirective(StringRef AliasName,
     141             :                               const MCSymbol *Aliasee) override;
     142             : 
     143             :   void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override;
     144             :   void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
     145             : 
     146             :   void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
     147             :   void EmitLinkerOptions(ArrayRef<std::string> Options) override;
     148             :   void EmitDataRegion(MCDataRegionType Kind) override;
     149             :   void EmitVersionMin(MCVersionMinType Kind, unsigned Major, unsigned Minor,
     150             :                       unsigned Update) override;
     151             :   void EmitBuildVersion(unsigned Platform, unsigned Major, unsigned Minor,
     152             :                         unsigned Update) override;
     153             :   void EmitThumbFunc(MCSymbol *Func) override;
     154             : 
     155             :   void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
     156             :   void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
     157             :   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
     158             : 
     159             :   void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
     160             :   void BeginCOFFSymbolDef(const MCSymbol *Symbol) override;
     161             :   void EmitCOFFSymbolStorageClass(int StorageClass) override;
     162             :   void EmitCOFFSymbolType(int Type) override;
     163             :   void EndCOFFSymbolDef() override;
     164             :   void EmitCOFFSafeSEH(MCSymbol const *Symbol) override;
     165             :   void EmitCOFFSymbolIndex(MCSymbol const *Symbol) override;
     166             :   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
     167             :   void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override;
     168             :   void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) override;
     169             :   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
     170             :   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
     171             :                         unsigned ByteAlignment) override;
     172             : 
     173             :   /// Emit a local common (.lcomm) symbol.
     174             :   ///
     175             :   /// @param Symbol - The common symbol to emit.
     176             :   /// @param Size - The size of the common symbol.
     177             :   /// @param ByteAlignment - The alignment of the common symbol in bytes.
     178             :   void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
     179             :                              unsigned ByteAlignment) override;
     180             : 
     181             :   void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
     182             :                     uint64_t Size = 0, unsigned ByteAlignment = 0,
     183             :                     SMLoc Loc = SMLoc()) override;
     184             : 
     185             :   void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
     186             :                       unsigned ByteAlignment = 0) override;
     187             : 
     188             :   void EmitBinaryData(StringRef Data) override;
     189             : 
     190             :   void EmitBytes(StringRef Data) override;
     191             : 
     192             :   void EmitValueImpl(const MCExpr *Value, unsigned Size,
     193             :                      SMLoc Loc = SMLoc()) override;
     194             :   void EmitIntValue(uint64_t Value, unsigned Size) override;
     195             : 
     196             :   void EmitULEB128Value(const MCExpr *Value) override;
     197             : 
     198             :   void EmitSLEB128Value(const MCExpr *Value) override;
     199             : 
     200             :   void EmitDTPRel32Value(const MCExpr *Value) override;
     201             :   void EmitDTPRel64Value(const MCExpr *Value) override;
     202             :   void EmitTPRel32Value(const MCExpr *Value) override;
     203             :   void EmitTPRel64Value(const MCExpr *Value) override;
     204             : 
     205             :   void EmitGPRel64Value(const MCExpr *Value) override;
     206             : 
     207             :   void EmitGPRel32Value(const MCExpr *Value) override;
     208             : 
     209             :   void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
     210             :                 SMLoc Loc = SMLoc()) override;
     211             : 
     212             :   void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
     213             :                 SMLoc Loc = SMLoc()) override;
     214             : 
     215             :   void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
     216             :                             unsigned ValueSize = 1,
     217             :                             unsigned MaxBytesToEmit = 0) override;
     218             : 
     219             :   void EmitCodeAlignment(unsigned ByteAlignment,
     220             :                          unsigned MaxBytesToEmit = 0) override;
     221             : 
     222             :   void emitValueToOffset(const MCExpr *Offset,
     223             :                          unsigned char Value,
     224             :                          SMLoc Loc) override;
     225             : 
     226             :   void EmitFileDirective(StringRef Filename) override;
     227             :   Expected<unsigned> tryEmitDwarfFileDirective(unsigned FileNo,
     228             :                                                StringRef Directory,
     229             :                                                StringRef Filename,
     230             :                                                MD5::MD5Result *Checksum = 0,
     231             :                                                Optional<StringRef> Source = None,
     232             :                                                unsigned CUID = 0) override;
     233             :   void emitDwarfFile0Directive(StringRef Directory, StringRef Filename,
     234             :                                MD5::MD5Result *Checksum,
     235             :                                Optional<StringRef> Source,
     236             :                                unsigned CUID = 0) override;
     237             :   void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
     238             :                              unsigned Column, unsigned Flags,
     239             :                              unsigned Isa, unsigned Discriminator,
     240             :                              StringRef FileName) override;
     241             :   MCSymbol *getDwarfLineTableSymbol(unsigned CUID) override;
     242             : 
     243             :   bool EmitCVFileDirective(unsigned FileNo, StringRef Filename,
     244             :                            ArrayRef<uint8_t> Checksum,
     245             :                            unsigned ChecksumKind) override;
     246             :   bool EmitCVFuncIdDirective(unsigned FuncId) override;
     247             :   bool EmitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc,
     248             :                                    unsigned IAFile, unsigned IALine,
     249             :                                    unsigned IACol, SMLoc Loc) override;
     250             :   void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
     251             :                           unsigned Column, bool PrologueEnd, bool IsStmt,
     252             :                           StringRef FileName, SMLoc Loc) override;
     253             :   void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart,
     254             :                                 const MCSymbol *FnEnd) override;
     255             :   void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
     256             :                                       unsigned SourceFileId,
     257             :                                       unsigned SourceLineNum,
     258             :                                       const MCSymbol *FnStartSym,
     259             :                                       const MCSymbol *FnEndSym) override;
     260             :   void EmitCVDefRangeDirective(
     261             :       ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
     262             :       StringRef FixedSizePortion) override;
     263             :   void EmitCVStringTableDirective() override;
     264             :   void EmitCVFileChecksumsDirective() override;
     265             :   void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override;
     266             :   void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc L) override;
     267             : 
     268             :   void EmitIdent(StringRef IdentString) override;
     269             :   void EmitCFISections(bool EH, bool Debug) override;
     270             :   void EmitCFIDefCfa(int64_t Register, int64_t Offset) override;
     271             :   void EmitCFIDefCfaOffset(int64_t Offset) override;
     272             :   void EmitCFIDefCfaRegister(int64_t Register) override;
     273             :   void EmitCFIOffset(int64_t Register, int64_t Offset) override;
     274             :   void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding) override;
     275             :   void EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) override;
     276             :   void EmitCFIRememberState() override;
     277             :   void EmitCFIRestoreState() override;
     278             :   void EmitCFIRestore(int64_t Register) override;
     279             :   void EmitCFISameValue(int64_t Register) override;
     280             :   void EmitCFIRelOffset(int64_t Register, int64_t Offset) override;
     281             :   void EmitCFIAdjustCfaOffset(int64_t Adjustment) override;
     282             :   void EmitCFIEscape(StringRef Values) override;
     283             :   void EmitCFIGnuArgsSize(int64_t Size) override;
     284             :   void EmitCFISignalFrame() override;
     285             :   void EmitCFIUndefined(int64_t Register) override;
     286             :   void EmitCFIRegister(int64_t Register1, int64_t Register2) override;
     287             :   void EmitCFIWindowSave() override;
     288             :   void EmitCFIReturnColumn(int64_t Register) override;
     289             : 
     290             :   void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) override;
     291             :   void EmitWinCFIEndProc(SMLoc Loc) override;
     292             :   void EmitWinCFIStartChained(SMLoc Loc) override;
     293             :   void EmitWinCFIEndChained(SMLoc Loc) override;
     294             :   void EmitWinCFIPushReg(unsigned Register, SMLoc Loc) override;
     295             :   void EmitWinCFISetFrame(unsigned Register, unsigned Offset,
     296             :                           SMLoc Loc) override;
     297             :   void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) override;
     298             :   void EmitWinCFISaveReg(unsigned Register, unsigned Offset,
     299             :                          SMLoc Loc) override;
     300             :   void EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
     301             :                          SMLoc Loc) override;
     302             :   void EmitWinCFIPushFrame(bool Code, SMLoc Loc) override;
     303             :   void EmitWinCFIEndProlog(SMLoc Loc) override;
     304             : 
     305             :   void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
     306             :                         SMLoc Loc) override;
     307             :   void EmitWinEHHandlerData(SMLoc Loc) override;
     308             : 
     309             :   void emitCGProfileEntry(const MCSymbolRefExpr *From,
     310             :                           const MCSymbolRefExpr *To, uint64_t Count) override;
     311             : 
     312             :   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
     313             :                        bool PrintSchedInfo) override;
     314             : 
     315             :   void EmitBundleAlignMode(unsigned AlignPow2) override;
     316             :   void EmitBundleLock(bool AlignToEnd) override;
     317             :   void EmitBundleUnlock() override;
     318             : 
     319             :   bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
     320             :                           const MCExpr *Expr, SMLoc Loc,
     321             :                           const MCSubtargetInfo &STI) override;
     322             : 
     323             :   void EmitAddrsig() override;
     324             :   void EmitAddrsigSym(const MCSymbol *Sym) override;
     325             : 
     326             :   /// If this file is backed by an assembly streamer, this dumps the specified
     327             :   /// string in the output .s file. This capability is indicated by the
     328             :   /// hasRawTextSupport() predicate.
     329             :   void EmitRawTextImpl(StringRef String) override;
     330             : 
     331             :   void FinishImpl() override;
     332             : };
     333             : 
     334             : } // end anonymous namespace.
     335             : 
     336      106285 : void MCAsmStreamer::AddComment(const Twine &T, bool EOL) {
     337      106285 :   if (!IsVerboseAsm) return;
     338             : 
     339      105312 :   T.toVector(CommentToEmit);
     340             : 
     341      105312 :   if (EOL)
     342       98632 :     CommentToEmit.push_back('\n'); // Place comment in a new line.
     343             : }
     344             : 
     345     5323011 : void MCAsmStreamer::EmitCommentsAndEOL() {
     346     5323011 :   if (CommentToEmit.empty() && CommentStream.GetNumBytesInBuffer() == 0) {
     347     3762870 :     OS << '\n';
     348     3762870 :     return;
     349             :   }
     350             : 
     351     1560141 :   StringRef Comments = CommentToEmit;
     352             : 
     353             :   assert(Comments.back() == '\n' &&
     354             :          "Comment array not newline terminated");
     355             :   do {
     356             :     // Emit a line of comments.
     357     1624138 :     OS.PadToColumn(MAI->getCommentColumn());
     358     1624138 :     size_t Position = Comments.find('\n');
     359     3248276 :     OS << MAI->getCommentString() << ' ' << Comments.substr(0, Position) <<'\n';
     360             : 
     361     1624138 :     Comments = Comments.substr(Position+1);
     362     1624138 :   } while (!Comments.empty());
     363             : 
     364             :   CommentToEmit.clear();
     365             : }
     366             : 
     367             : static inline int64_t truncateToSize(int64_t Value, unsigned Bytes) {
     368             :   assert(Bytes > 0 && Bytes <= 8 && "Invalid size!");
     369       98505 :   return Value & ((uint64_t) (int64_t) -1 >> (64 - Bytes * 8));
     370             : }
     371             : 
     372      596412 : void MCAsmStreamer::emitRawComment(const Twine &T, bool TabPrefix) {
     373      596412 :   if (TabPrefix)
     374       37755 :     OS << '\t';
     375      596412 :   OS << MAI->getCommentString() << T;
     376      596412 :   EmitEOL();
     377      596412 : }
     378             : 
     379         204 : void MCAsmStreamer::addExplicitComment(const Twine &T) {
     380         204 :   StringRef c = T.getSingleStringRef();
     381         204 :   if (c.equals(StringRef(MAI->getSeparatorString())))
     382          48 :     return;
     383             :   if (c.startswith(StringRef("//"))) {
     384             :     ExplicitCommentToEmit.append("\t");
     385          19 :     ExplicitCommentToEmit.append(MAI->getCommentString());
     386             :     // drop //
     387          38 :     ExplicitCommentToEmit.append(c.slice(2, c.size()).str());
     388             :   } else if (c.startswith(StringRef("/*"))) {
     389          12 :     size_t p = 2, len = c.size() - 2;
     390             :     // emit each line in comment as separate newline.
     391             :     do {
     392          14 :       size_t newp = std::min(len, c.find_first_of("\r\n", p));
     393             :       ExplicitCommentToEmit.append("\t");
     394          13 :       ExplicitCommentToEmit.append(MAI->getCommentString());
     395          13 :       ExplicitCommentToEmit.append(c.slice(p, newp).str());
     396             :       // If we have another line in this comment add line
     397          13 :       if (newp < len)
     398             :         ExplicitCommentToEmit.append("\n");
     399          13 :       p = newp + 1;
     400          13 :     } while (p < len);
     401             :   } else if (c.startswith(StringRef(MAI->getCommentString()))) {
     402             :     ExplicitCommentToEmit.append("\t");
     403         218 :     ExplicitCommentToEmit.append(c.str());
     404          32 :   } else if (c.front() == '#') {
     405             : 
     406             :     ExplicitCommentToEmit.append("\t");
     407          16 :     ExplicitCommentToEmit.append(MAI->getCommentString());
     408          32 :     ExplicitCommentToEmit.append(c.slice(1, c.size()).str());
     409             :   } else
     410             :     assert(false && "Unexpected Assembly Comment");
     411             :   // full line comments immediately output
     412         312 :   if (c.back() == '\n')
     413             :     emitExplicitComments();
     414             : }
     415             : 
     416           0 : void MCAsmStreamer::emitExplicitComments() {
     417     5412236 :   StringRef Comments = ExplicitCommentToEmit;
     418     5412236 :   if (!Comments.empty())
     419         152 :     OS << Comments;
     420             :   ExplicitCommentToEmit.clear();
     421           0 : }
     422             : 
     423      158542 : void MCAsmStreamer::ChangeSection(MCSection *Section,
     424             :                                   const MCExpr *Subsection) {
     425             :   assert(Section && "Cannot switch to a null section!");
     426      158542 :   if (MCTargetStreamer *TS = getTargetStreamer()) {
     427      297224 :     TS->changeSection(getCurrentSectionOnly(), Section, Subsection, OS);
     428             :   } else {
     429       29790 :     Section->PrintSwitchToSection(
     430        9930 :         *MAI, getContext().getObjectFileInfo()->getTargetTriple(), OS,
     431        9930 :         Subsection);
     432             :   }
     433      158541 : }
     434             : 
     435           6 : void MCAsmStreamer::emitELFSymverDirective(StringRef AliasName,
     436             :                                            const MCSymbol *Aliasee) {
     437           6 :   OS << ".symver ";
     438           6 :   Aliasee->print(OS, MAI);
     439           6 :   OS << ", " << AliasName;
     440           6 :   EmitEOL();
     441           6 : }
     442             : 
     443      446570 : void MCAsmStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
     444      446570 :   MCStreamer::EmitLabel(Symbol, Loc);
     445             : 
     446      446569 :   Symbol->print(OS, MAI);
     447      446569 :   OS << MAI->getLabelSuffix();
     448             : 
     449      446569 :   EmitEOL();
     450      446569 : }
     451             : 
     452         237 : void MCAsmStreamer::EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {
     453         237 :   StringRef str = MCLOHIdToName(Kind);
     454             : 
     455             : #ifndef NDEBUG
     456             :   int NbArgs = MCLOHIdToNbArgs(Kind);
     457             :   assert(NbArgs != -1 && ((size_t)NbArgs) == Args.size() && "Malformed LOH!");
     458             :   assert(str != "" && "Invalid LOH name");
     459             : #endif
     460             : 
     461         237 :   OS << "\t" << MCLOHDirectiveName() << " " << str << "\t";
     462             :   bool IsFirst = true;
     463         774 :   for (const MCSymbol *Arg : Args) {
     464         537 :     if (!IsFirst)
     465         300 :       OS << ", ";
     466             :     IsFirst = false;
     467         537 :     Arg->print(OS, MAI);
     468             :   }
     469         237 :   EmitEOL();
     470         237 : }
     471             : 
     472       19080 : void MCAsmStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
     473       19080 :   switch (Flag) {
     474        2668 :   case MCAF_SyntaxUnified:         OS << "\t.syntax unified"; break;
     475        2174 :   case MCAF_SubsectionsViaSymbols: OS << ".subsections_via_symbols"; break;
     476       11750 :   case MCAF_Code16:                OS << '\t'<< MAI->getCode16Directive();break;
     477       16722 :   case MCAF_Code32:                OS << '\t'<< MAI->getCode32Directive();break;
     478           4 :   case MCAF_Code64:                OS << '\t'<< MAI->getCode64Directive();break;
     479             :   }
     480       19080 :   EmitEOL();
     481       19080 : }
     482             : 
     483           5 : void MCAsmStreamer::EmitLinkerOptions(ArrayRef<std::string> Options) {
     484             :   assert(!Options.empty() && "At least one option is required!");
     485           5 :   OS << "\t.linker_option \"" << Options[0] << '"';
     486           2 :   for (ArrayRef<std::string>::iterator it = Options.begin() + 1,
     487           7 :          ie = Options.end(); it != ie; ++it) {
     488           2 :     OS << ", " << '"' << *it << '"';
     489             :   }
     490           5 :   EmitEOL();
     491           5 : }
     492             : 
     493        3324 : void MCAsmStreamer::EmitDataRegion(MCDataRegionType Kind) {
     494        3324 :   if (!MAI->doesSupportDataRegionDirectives())
     495             :     return;
     496         850 :   switch (Kind) {
     497         375 :   case MCDR_DataRegion:            OS << "\t.data_region"; break;
     498          17 :   case MCDR_DataRegionJT8:         OS << "\t.data_region jt8"; break;
     499           0 :   case MCDR_DataRegionJT16:        OS << "\t.data_region jt16"; break;
     500          33 :   case MCDR_DataRegionJT32:        OS << "\t.data_region jt32"; break;
     501         425 :   case MCDR_DataRegionEnd:         OS << "\t.end_data_region"; break;
     502             :   }
     503         850 :   EmitEOL();
     504             : }
     505             : 
     506             : static const char *getVersionMinDirective(MCVersionMinType Type) {
     507         787 :   switch (Type) {
     508             :   case MCVM_WatchOSVersionMin: return ".watchos_version_min";
     509          18 :   case MCVM_TvOSVersionMin:    return ".tvos_version_min";
     510         186 :   case MCVM_IOSVersionMin:     return ".ios_version_min";
     511         557 :   case MCVM_OSXVersionMin:     return ".macosx_version_min";
     512             :   }
     513           0 :   llvm_unreachable("Invalid MC version min type");
     514             : }
     515             : 
     516         787 : void MCAsmStreamer::EmitVersionMin(MCVersionMinType Type, unsigned Major,
     517             :                                    unsigned Minor, unsigned Update) {
     518        2361 :   OS << '\t' << getVersionMinDirective(Type) << ' ' << Major << ", " << Minor;
     519         787 :   if (Update)
     520          43 :     OS << ", " << Update;
     521         787 :   EmitEOL();
     522         787 : }
     523             : 
     524             : static const char *getPlatformName(MachO::PlatformType Type) {
     525           8 :   switch (Type) {
     526             :   case MachO::PLATFORM_MACOS:    return "macos";
     527           1 :   case MachO::PLATFORM_IOS:      return "ios";
     528           2 :   case MachO::PLATFORM_TVOS:     return "tvos";
     529           1 :   case MachO::PLATFORM_WATCHOS:  return "watchos";
     530           0 :   case MachO::PLATFORM_BRIDGEOS: return "bridgeos";
     531             :   }
     532           0 :   llvm_unreachable("Invalid Mach-O platform type");
     533             : }
     534             : 
     535           8 : void MCAsmStreamer::EmitBuildVersion(unsigned Platform, unsigned Major,
     536             :                                      unsigned Minor, unsigned Update) {
     537             :   const char *PlatformName = getPlatformName((MachO::PlatformType)Platform);
     538          16 :   OS << "\t.build_version " << PlatformName << ", " << Major << ", " << Minor;
     539           8 :   if (Update)
     540           3 :     OS << ", " << Update;
     541           8 :   EmitEOL();
     542           8 : }
     543             : 
     544        5710 : void MCAsmStreamer::EmitThumbFunc(MCSymbol *Func) {
     545             :   // This needs to emit to a temporary string to get properly quoted
     546             :   // MCSymbols when they have spaces in them.
     547        5710 :   OS << "\t.thumb_func";
     548             :   // Only Mach-O hasSubsectionsViaSymbols()
     549        5710 :   if (MAI->hasSubsectionsViaSymbols()) {
     550        1301 :     OS << '\t';
     551        1301 :     Func->print(OS, MAI);
     552             :   }
     553        5710 :   EmitEOL();
     554        5710 : }
     555             : 
     556        2094 : void MCAsmStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
     557             :   // Do not emit a .set on inlined target assignments.
     558             :   bool EmitSet = true;
     559           1 :   if (auto *E = dyn_cast<MCTargetExpr>(Value))
     560           1 :     if (E->inlineAssignedExpr())
     561             :       EmitSet = false;
     562             :   if (EmitSet) {
     563        2093 :     OS << ".set ";
     564        2093 :     Symbol->print(OS, MAI);
     565        2093 :     OS << ", ";
     566        2093 :     Value->print(OS, MAI);
     567             : 
     568        2093 :     EmitEOL();
     569             :   }
     570             : 
     571        2094 :   MCStreamer::EmitAssignment(Symbol, Value);
     572        2094 : }
     573             : 
     574           0 : void MCAsmStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
     575           0 :   OS << ".weakref ";
     576           0 :   Alias->print(OS, MAI);
     577           0 :   OS << ", ";
     578           0 :   Symbol->print(OS, MAI);
     579           0 :   EmitEOL();
     580           0 : }
     581             : 
     582      381435 : bool MCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
     583             :                                         MCSymbolAttr Attribute) {
     584      381435 :   switch (Attribute) {
     585             :   case MCSA_Invalid: llvm_unreachable("Invalid symbol attribute");
     586      179827 :   case MCSA_ELF_TypeFunction:    /// .type _foo, STT_FUNC  # aka @function
     587             :   case MCSA_ELF_TypeIndFunction: /// .type _foo, STT_GNU_IFUNC
     588             :   case MCSA_ELF_TypeObject:      /// .type _foo, STT_OBJECT  # aka @object
     589             :   case MCSA_ELF_TypeTLS:         /// .type _foo, STT_TLS     # aka @tls_object
     590             :   case MCSA_ELF_TypeCommon:      /// .type _foo, STT_COMMON  # aka @common
     591             :   case MCSA_ELF_TypeNoType:      /// .type _foo, STT_NOTYPE  # aka @notype
     592             :   case MCSA_ELF_TypeGnuUniqueObject:  /// .type _foo, @gnu_unique_object
     593      179827 :     if (!MAI->hasDotTypeDotSizeDirective())
     594             :       return false; // Symbol attribute not supported
     595      179759 :     OS << "\t.type\t";
     596      179759 :     Symbol->print(OS, MAI);
     597      539277 :     OS << ',' << ((MAI->getCommentString()[0] != '@') ? '@' : '%');
     598             :     switch (Attribute) {
     599             :     default: return false;
     600      168908 :     case MCSA_ELF_TypeFunction:    OS << "function"; break;
     601           6 :     case MCSA_ELF_TypeIndFunction: OS << "gnu_indirect_function"; break;
     602       10839 :     case MCSA_ELF_TypeObject:      OS << "object"; break;
     603           1 :     case MCSA_ELF_TypeTLS:         OS << "tls_object"; break;
     604           1 :     case MCSA_ELF_TypeCommon:      OS << "common"; break;
     605           1 :     case MCSA_ELF_TypeNoType:      OS << "notype"; break;
     606           3 :     case MCSA_ELF_TypeGnuUniqueObject: OS << "gnu_unique_object"; break;
     607             :     }
     608      179759 :     EmitEOL();
     609      179759 :     return true;
     610      199229 :   case MCSA_Global: // .globl/.global
     611      199229 :     OS << MAI->getGlobalDirective();
     612      199229 :     break;
     613         519 :   case MCSA_Hidden:         OS << "\t.hidden\t";          break;
     614         583 :   case MCSA_IndirectSymbol: OS << "\t.indirect_symbol\t"; break;
     615           0 :   case MCSA_Internal:       OS << "\t.internal\t";        break;
     616           9 :   case MCSA_LazyReference:  OS << "\t.lazy_reference\t";  break;
     617         243 :   case MCSA_Local:          OS << "\t.local\t";           break;
     618         107 :   case MCSA_NoDeadStrip:
     619         107 :     if (!MAI->hasNoDeadStrip())
     620             :       return false;
     621          59 :     OS << "\t.no_dead_strip\t";
     622          59 :     break;
     623           4 :   case MCSA_SymbolResolver: OS << "\t.symbol_resolver\t"; break;
     624           8 :   case MCSA_AltEntry:       OS << "\t.alt_entry\t";       break;
     625          69 :   case MCSA_PrivateExtern:
     626          69 :     OS << "\t.private_extern\t";
     627          69 :     break;
     628          45 :   case MCSA_Protected:      OS << "\t.protected\t";       break;
     629           4 :   case MCSA_Reference:      OS << "\t.reference\t";       break;
     630         459 :   case MCSA_Weak:           OS << MAI->getWeakDirective(); break;
     631         164 :   case MCSA_WeakDefinition:
     632         164 :     OS << "\t.weak_definition\t";
     633         164 :     break;
     634             :       // .weak_reference
     635         150 :   case MCSA_WeakReference:  OS << MAI->getWeakRefDirective(); break;
     636          15 :   case MCSA_WeakDefAutoPrivate: OS << "\t.weak_def_can_be_hidden\t"; break;
     637             :   }
     638             : 
     639      201560 :   Symbol->print(OS, MAI);
     640      201560 :   EmitEOL();
     641             : 
     642      201560 :   return true;
     643             : }
     644             : 
     645           3 : void MCAsmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
     646           3 :   OS << ".desc" << ' ';
     647           3 :   Symbol->print(OS, MAI);
     648           3 :   OS << ',' << DescValue;
     649           3 :   EmitEOL();
     650           3 : }
     651             : 
     652        7102 : void MCAsmStreamer::EmitSyntaxDirective() {
     653        7102 :   if (MAI->getAssemblerDialect() == 1) {
     654          23 :     OS << "\t.intel_syntax noprefix";
     655          23 :     EmitEOL();
     656             :   }
     657             :   // FIXME: Currently emit unprefix'ed registers.
     658             :   // The intel_syntax directive has one optional argument
     659             :   // with may have a value of prefix or noprefix.
     660        7102 : }
     661             : 
     662        3169 : void MCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
     663        3169 :   OS << "\t.def\t ";
     664        3169 :   Symbol->print(OS, MAI);
     665        3169 :   OS << ';';
     666        3169 :   EmitEOL();
     667        3169 : }
     668             : 
     669        3169 : void MCAsmStreamer::EmitCOFFSymbolStorageClass (int StorageClass) {
     670        3169 :   OS << "\t.scl\t" << StorageClass << ';';
     671        3169 :   EmitEOL();
     672        3169 : }
     673             : 
     674        3169 : void MCAsmStreamer::EmitCOFFSymbolType (int Type) {
     675        3169 :   OS << "\t.type\t" << Type << ';';
     676        3169 :   EmitEOL();
     677        3169 : }
     678             : 
     679        3169 : void MCAsmStreamer::EndCOFFSymbolDef() {
     680        3169 :   OS << "\t.endef";
     681        3169 :   EmitEOL();
     682        3169 : }
     683             : 
     684          30 : void MCAsmStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
     685          30 :   OS << "\t.safeseh\t";
     686          30 :   Symbol->print(OS, MAI);
     687          30 :   EmitEOL();
     688          30 : }
     689             : 
     690           4 : void MCAsmStreamer::EmitCOFFSymbolIndex(MCSymbol const *Symbol) {
     691           4 :   OS << "\t.symidx\t";
     692           4 :   Symbol->print(OS, MAI);
     693           4 :   EmitEOL();
     694           4 : }
     695             : 
     696         117 : void MCAsmStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
     697         117 :   OS << "\t.secidx\t";
     698         117 :   Symbol->print(OS, MAI);
     699         117 :   EmitEOL();
     700         117 : }
     701             : 
     702         310 : void MCAsmStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) {
     703         310 :   OS << "\t.secrel32\t";
     704         310 :   Symbol->print(OS, MAI);
     705         310 :   if (Offset != 0)
     706           4 :     OS << '+' << Offset;
     707         310 :   EmitEOL();
     708         310 : }
     709             : 
     710           0 : void MCAsmStreamer::EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) {
     711           0 :   OS << "\t.rva\t";
     712           0 :   Symbol->print(OS, MAI);
     713           0 :   if (Offset > 0)
     714           0 :     OS << '+' << Offset;
     715           0 :   else if (Offset < 0)
     716           0 :     OS << '-' << -Offset;
     717           0 :   EmitEOL();
     718           0 : }
     719             : 
     720      177112 : void MCAsmStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
     721             :   assert(MAI->hasDotTypeDotSizeDirective());
     722      177112 :   OS << "\t.size\t";
     723      177112 :   Symbol->print(OS, MAI);
     724      177112 :   OS << ", ";
     725      177112 :   Value->print(OS, MAI);
     726      177112 :   EmitEOL();
     727      177112 : }
     728             : 
     729        2674 : void MCAsmStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
     730             :                                      unsigned ByteAlignment) {
     731        2674 :   OS << "\t.comm\t";
     732        2674 :   Symbol->print(OS, MAI);
     733        5348 :   OS << ',' << Size;
     734             : 
     735        2674 :   if (ByteAlignment != 0) {
     736        2564 :     if (MAI->getCOMMDirectiveAlignmentIsInBytes())
     737        2352 :       OS << ',' << ByteAlignment;
     738             :     else
     739         212 :       OS << ',' << Log2_32(ByteAlignment);
     740             :   }
     741        2674 :   EmitEOL();
     742        2674 : }
     743             : 
     744          42 : void MCAsmStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
     745             :                                           unsigned ByteAlign) {
     746          42 :   OS << "\t.lcomm\t";
     747          42 :   Symbol->print(OS, MAI);
     748          84 :   OS << ',' << Size;
     749             : 
     750          42 :   if (ByteAlign > 1) {
     751          32 :     switch (MAI->getLCOMMDirectiveAlignmentType()) {
     752             :     case LCOMM::NoAlignment:
     753             :       llvm_unreachable("alignment not supported on .lcomm!");
     754          31 :     case LCOMM::ByteAlignment:
     755          31 :       OS << ',' << ByteAlign;
     756             :       break;
     757           1 :     case LCOMM::Log2Alignment:
     758             :       assert(isPowerOf2_32(ByteAlign) && "alignment must be a power of 2");
     759           1 :       OS << ',' << Log2_32(ByteAlign);
     760             :       break;
     761             :     }
     762             :   }
     763          42 :   EmitEOL();
     764          42 : }
     765             : 
     766         279 : void MCAsmStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
     767             :                                  uint64_t Size, unsigned ByteAlignment,
     768             :                                  SMLoc Loc) {
     769         279 :   if (Symbol)
     770         556 :     AssignFragment(Symbol, &Section->getDummyFragment());
     771             : 
     772             :   // Note: a .zerofill directive does not switch sections.
     773         279 :   OS << ".zerofill ";
     774             : 
     775             :   assert(Section->getVariant() == MCSection::SV_MachO &&
     776             :          ".zerofill is a Mach-O specific directive");
     777             :   // This is a mach-o specific directive.
     778             : 
     779             :   const MCSectionMachO *MOSection = ((const MCSectionMachO*)Section);
     780         837 :   OS << MOSection->getSegmentName() << "," << MOSection->getSectionName();
     781             : 
     782         279 :   if (Symbol) {
     783         278 :     OS << ',';
     784         278 :     Symbol->print(OS, MAI);
     785         556 :     OS << ',' << Size;
     786         278 :     if (ByteAlignment != 0)
     787         278 :       OS << ',' << Log2_32(ByteAlignment);
     788             :   }
     789         279 :   EmitEOL();
     790         279 : }
     791             : 
     792             : // .tbss sym, size, align
     793             : // This depends that the symbol has already been mangled from the original,
     794             : // e.g. _a.
     795          73 : void MCAsmStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
     796             :                                    uint64_t Size, unsigned ByteAlignment) {
     797         146 :   AssignFragment(Symbol, &Section->getDummyFragment());
     798             : 
     799             :   assert(Symbol && "Symbol shouldn't be NULL!");
     800             :   // Instead of using the Section we'll just use the shortcut.
     801             : 
     802             :   assert(Section->getVariant() == MCSection::SV_MachO &&
     803             :          ".zerofill is a Mach-O specific directive");
     804             :   // This is a mach-o specific directive and section.
     805             : 
     806          73 :   OS << ".tbss ";
     807          73 :   Symbol->print(OS, MAI);
     808          73 :   OS << ", " << Size;
     809             : 
     810             :   // Output align if we have it.  We default to 1 so don't bother printing
     811             :   // that.
     812          73 :   if (ByteAlignment > 1) OS << ", " << Log2_32(ByteAlignment);
     813             : 
     814          73 :   EmitEOL();
     815          73 : }
     816             : 
     817        3196 : static inline char toOctal(int X) { return (X&7)+'0'; }
     818             : 
     819       20976 : static void PrintQuotedString(StringRef Data, raw_ostream &OS) {
     820             :   OS << '"';
     821             : 
     822      232971 :   for (unsigned i = 0, e = Data.size(); i != e; ++i) {
     823      211995 :     unsigned char C = Data[i];
     824      211995 :     if (C == '"' || C == '\\') {
     825             :       OS << '\\' << (char)C;
     826         261 :       continue;
     827             :     }
     828             : 
     829      211734 :     if (isPrint((unsigned char)C)) {
     830             :       OS << (char)C;
     831      207992 :       continue;
     832             :     }
     833             : 
     834        3742 :     switch (C) {
     835          41 :       case '\b': OS << "\\b"; break;
     836          11 :       case '\f': OS << "\\f"; break;
     837         421 :       case '\n': OS << "\\n"; break;
     838           5 :       case '\r': OS << "\\r"; break;
     839          68 :       case '\t': OS << "\\t"; break;
     840             :       default:
     841             :         OS << '\\';
     842        3196 :         OS << toOctal(C >> 6);
     843        3196 :         OS << toOctal(C >> 3);
     844             :         OS << toOctal(C >> 0);
     845             :         break;
     846             :     }
     847             :   }
     848             : 
     849             :   OS << '"';
     850       20976 : }
     851             : 
     852       40520 : void MCAsmStreamer::EmitBytes(StringRef Data) {
     853             :   assert(getCurrentSectionOnly() &&
     854             :          "Cannot emit contents before setting section!");
     855       40520 :   if (Data.empty()) return;
     856             : 
     857             :   // If only single byte is provided or no ascii or asciz directives is
     858             :   // supported, emit as vector of 8bits data.
     859       40519 :   if (Data.size() == 1 ||
     860        6030 :       !(MAI->getAscizDirective() || MAI->getAsciiDirective())) {
     861       34502 :     const char *Directive = MAI->getData8bitsDirective();
     862       69017 :     for (const unsigned char C : Data.bytes()) {
     863       34515 :       OS << Directive << (unsigned)C;
     864       34515 :       EmitEOL();
     865             :     }
     866             :     return;
     867             :   }
     868             : 
     869             :   // If the data ends with 0 and the target supports .asciz, use it, otherwise
     870             :   // use .ascii
     871        6017 :   if (MAI->getAscizDirective() && Data.back() == 0) {
     872        4933 :     OS << MAI->getAscizDirective();
     873        4933 :     Data = Data.substr(0, Data.size()-1);
     874             :   } else {
     875        1084 :     OS << MAI->getAsciiDirective();
     876             :   }
     877             : 
     878        6017 :   PrintQuotedString(Data, OS);
     879        6017 :   EmitEOL();
     880             : }
     881             : 
     882         778 : void MCAsmStreamer::EmitBinaryData(StringRef Data) {
     883             :   // This is binary data. Print it in a grid of hex bytes for readability.
     884             :   const size_t Cols = 4;
     885        3015 :   for (size_t I = 0, EI = alignTo(Data.size(), Cols); I < EI; I += Cols) {
     886        2237 :     size_t J = I, EJ = std::min(I + Cols, Data.size());
     887             :     assert(EJ > 0);
     888        2237 :     OS << MAI->getData8bitsDirective();
     889        7761 :     for (; J < EJ - 1; ++J)
     890       16572 :       OS << format("0x%02x", uint8_t(Data[J])) << ", ";
     891        6711 :     OS << format("0x%02x", uint8_t(Data[J]));
     892        2237 :     EmitEOL();
     893             :   }
     894         778 : }
     895             : 
     896      441017 : void MCAsmStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
     897      441017 :   EmitValue(MCConstantExpr::create(Value, getContext()), Size);
     898      441017 : }
     899             : 
     900      465456 : void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
     901             :                                   SMLoc Loc) {
     902             :   assert(Size <= 8 && "Invalid size");
     903             :   assert(getCurrentSectionOnly() &&
     904             :          "Cannot emit contents before setting section!");
     905             :   const char *Directive = nullptr;
     906      465456 :   switch (Size) {
     907             :   default: break;
     908      129272 :   case 1: Directive = MAI->getData8bitsDirective();  break;
     909       43212 :   case 2: Directive = MAI->getData16bitsDirective(); break;
     910      253531 :   case 4: Directive = MAI->getData32bitsDirective(); break;
     911       39441 :   case 8: Directive = MAI->getData64bitsDirective(); break;
     912             :   }
     913             : 
     914      465456 :   if (!Directive) {
     915             :     int64_t IntValue;
     916         754 :     if (!Value->evaluateAsAbsolute(IntValue))
     917           0 :       report_fatal_error("Don't know how to emit this value.");
     918             : 
     919             :     // We couldn't handle the requested integer size so we fallback by breaking
     920             :     // the request down into several, smaller, integers.
     921             :     // Since sizes greater or equal to "Size" are invalid, we use the greatest
     922             :     // power of 2 that is less than "Size" as our largest piece of granularity.
     923         754 :     bool IsLittleEndian = MAI->isLittleEndian();
     924        2262 :     for (unsigned Emitted = 0; Emitted != Size;) {
     925        1508 :       unsigned Remaining = Size - Emitted;
     926             :       // The size of our partial emission must be a power of two less than
     927             :       // Size.
     928        2262 :       unsigned EmissionSize = PowerOf2Floor(std::min(Remaining, Size - 1));
     929             :       // Calculate the byte offset of our partial emission taking into account
     930             :       // the endianness of the target.
     931             :       unsigned ByteOffset =
     932        1508 :           IsLittleEndian ? Emitted : (Remaining - EmissionSize);
     933        1508 :       uint64_t ValueToEmit = IntValue >> (ByteOffset * 8);
     934             :       // We truncate our partial emission to fit within the bounds of the
     935             :       // emission domain.  This produces nicer output and silences potential
     936             :       // truncation warnings when round tripping through another assembler.
     937        1508 :       uint64_t Shift = 64 - EmissionSize * 8;
     938             :       assert(Shift < static_cast<uint64_t>(
     939             :                          std::numeric_limits<unsigned long long>::digits) &&
     940             :              "undefined behavior");
     941        1508 :       ValueToEmit &= ~0ULL >> Shift;
     942        1508 :       EmitIntValue(ValueToEmit, EmissionSize);
     943        1508 :       Emitted += EmissionSize;
     944             :     }
     945             :     return;
     946             :   }
     947             : 
     948             :   assert(Directive && "Invalid size for machine code value!");
     949      464702 :   OS << Directive;
     950      464702 :   if (MCTargetStreamer *TS = getTargetStreamer()) {
     951      448420 :     TS->emitValue(Value);
     952             :   } else {
     953       16282 :     Value->print(OS, MAI);
     954       16282 :     EmitEOL();
     955             :   }
     956             : }
     957             : 
     958        2118 : void MCAsmStreamer::EmitULEB128Value(const MCExpr *Value) {
     959             :   int64_t IntValue;
     960        2118 :   if (Value->evaluateAsAbsolute(IntValue)) {
     961           4 :     EmitULEB128IntValue(IntValue);
     962           4 :     return;
     963             :   }
     964        2114 :   OS << "\t.uleb128 ";
     965        2114 :   Value->print(OS, MAI);
     966        2114 :   EmitEOL();
     967             : }
     968             : 
     969           4 : void MCAsmStreamer::EmitSLEB128Value(const MCExpr *Value) {
     970             :   int64_t IntValue;
     971           4 :   if (Value->evaluateAsAbsolute(IntValue)) {
     972           4 :     EmitSLEB128IntValue(IntValue);
     973           4 :     return;
     974             :   }
     975           0 :   OS << "\t.sleb128 ";
     976           0 :   Value->print(OS, MAI);
     977           0 :   EmitEOL();
     978             : }
     979             : 
     980           3 : void MCAsmStreamer::EmitDTPRel64Value(const MCExpr *Value) {
     981             :   assert(MAI->getDTPRel64Directive() != nullptr);
     982           3 :   OS << MAI->getDTPRel64Directive();
     983           3 :   Value->print(OS, MAI);
     984           3 :   EmitEOL();
     985           3 : }
     986             : 
     987           3 : void MCAsmStreamer::EmitDTPRel32Value(const MCExpr *Value) {
     988             :   assert(MAI->getDTPRel32Directive() != nullptr);
     989           3 :   OS << MAI->getDTPRel32Directive();
     990           3 :   Value->print(OS, MAI);
     991           3 :   EmitEOL();
     992           3 : }
     993             : 
     994           2 : void MCAsmStreamer::EmitTPRel64Value(const MCExpr *Value) {
     995             :   assert(MAI->getTPRel64Directive() != nullptr);
     996           2 :   OS << MAI->getTPRel64Directive();
     997           2 :   Value->print(OS, MAI);
     998           2 :   EmitEOL();
     999           2 : }
    1000             : 
    1001           2 : void MCAsmStreamer::EmitTPRel32Value(const MCExpr *Value) {
    1002             :   assert(MAI->getTPRel32Directive() != nullptr);
    1003           2 :   OS << MAI->getTPRel32Directive();
    1004           2 :   Value->print(OS, MAI);
    1005           2 :   EmitEOL();
    1006           2 : }
    1007             : 
    1008          33 : void MCAsmStreamer::EmitGPRel64Value(const MCExpr *Value) {
    1009             :   assert(MAI->getGPRel64Directive() != nullptr);
    1010          33 :   OS << MAI->getGPRel64Directive();
    1011          33 :   Value->print(OS, MAI);
    1012          33 :   EmitEOL();
    1013          33 : }
    1014             : 
    1015          19 : void MCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) {
    1016             :   assert(MAI->getGPRel32Directive() != nullptr);
    1017          19 :   OS << MAI->getGPRel32Directive();
    1018          19 :   Value->print(OS, MAI);
    1019          19 :   EmitEOL();
    1020          19 : }
    1021             : 
    1022       52942 : void MCAsmStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
    1023             :                              SMLoc Loc) {
    1024             :   int64_t IntNumBytes;
    1025       52942 :   if (NumBytes.evaluateAsAbsolute(IntNumBytes) && IntNumBytes == 0)
    1026       52942 :     return;
    1027             : 
    1028       16648 :   if (const char *ZeroDirective = MAI->getZeroDirective()) {
    1029             :     // FIXME: Emit location directives
    1030       16648 :     OS << ZeroDirective;
    1031       16648 :     NumBytes.print(OS, MAI);
    1032       16648 :     if (FillValue != 0)
    1033        3802 :       OS << ',' << (int)FillValue;
    1034       16648 :     EmitEOL();
    1035       16648 :     return;
    1036             :   }
    1037             : 
    1038           0 :   MCStreamer::emitFill(NumBytes, FillValue);
    1039             : }
    1040             : 
    1041          19 : void MCAsmStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
    1042             :                              int64_t Expr, SMLoc Loc) {
    1043             :   // FIXME: Emit location directives
    1044          19 :   OS << "\t.fill\t";
    1045          19 :   NumValues.print(OS, MAI);
    1046          19 :   OS << ", " << Size << ", 0x";
    1047          19 :   OS.write_hex(truncateToSize(Expr, 4));
    1048          19 :   EmitEOL();
    1049          19 : }
    1050             : 
    1051      217815 : void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
    1052             :                                          unsigned ValueSize,
    1053             :                                          unsigned MaxBytesToEmit) {
    1054             :   // Some assemblers don't support non-power of two alignments, so we always
    1055             :   // emit alignments as a power of two if possible.
    1056             :   if (isPowerOf2_32(ByteAlignment)) {
    1057      217813 :     switch (ValueSize) {
    1058           0 :     default:
    1059           0 :       llvm_unreachable("Invalid size for machine code value!");
    1060      217802 :     case 1:
    1061      217802 :       OS << "\t.p2align\t";
    1062      217802 :       break;
    1063           4 :     case 2:
    1064           4 :       OS << ".p2alignw ";
    1065           4 :       break;
    1066           7 :     case 4:
    1067           7 :       OS << ".p2alignl ";
    1068           7 :       break;
    1069             :     case 8:
    1070             :       llvm_unreachable("Unsupported alignment size!");
    1071             :     }
    1072             : 
    1073      217813 :     OS << Log2_32(ByteAlignment);
    1074             : 
    1075      217813 :     if (Value || MaxBytesToEmit) {
    1076       98484 :       OS << ", 0x";
    1077       98484 :       OS.write_hex(truncateToSize(Value, ValueSize));
    1078             : 
    1079       98484 :       if (MaxBytesToEmit)
    1080           1 :         OS << ", " << MaxBytesToEmit;
    1081             :     }
    1082      217813 :     EmitEOL();
    1083      217813 :     return;
    1084             :   }
    1085             : 
    1086             :   // Non-power of two alignment.  This is not widely supported by assemblers.
    1087             :   // FIXME: Parameterize this based on MAI.
    1088           2 :   switch (ValueSize) {
    1089           0 :   default: llvm_unreachable("Invalid size for machine code value!");
    1090           2 :   case 1: OS << ".balign";  break;
    1091           0 :   case 2: OS << ".balignw"; break;
    1092           0 :   case 4: OS << ".balignl"; break;
    1093             :   case 8: llvm_unreachable("Unsupported alignment size!");
    1094             :   }
    1095             : 
    1096           2 :   OS << ' ' << ByteAlignment;
    1097           2 :   OS << ", " << truncateToSize(Value, ValueSize);
    1098           2 :   if (MaxBytesToEmit)
    1099           0 :     OS << ", " << MaxBytesToEmit;
    1100           2 :   EmitEOL();
    1101             : }
    1102             : 
    1103      187392 : void MCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment,
    1104             :                                       unsigned MaxBytesToEmit) {
    1105             :   // Emit with a text fill value.
    1106      187392 :   EmitValueToAlignment(ByteAlignment, MAI->getTextAlignFillValue(),
    1107             :                        1, MaxBytesToEmit);
    1108      187392 : }
    1109             : 
    1110           9 : void MCAsmStreamer::emitValueToOffset(const MCExpr *Offset,
    1111             :                                       unsigned char Value,
    1112             :                                       SMLoc Loc) {
    1113             :   // FIXME: Verify that Offset is associated with the current section.
    1114           9 :   OS << ".org ";
    1115           9 :   Offset->print(OS, MAI);
    1116           9 :   OS << ", " << (unsigned)Value;
    1117           9 :   EmitEOL();
    1118           9 : }
    1119             : 
    1120       13941 : void MCAsmStreamer::EmitFileDirective(StringRef Filename) {
    1121             :   assert(MAI->hasSingleParameterDotFile());
    1122       13941 :   OS << "\t.file\t";
    1123       13941 :   PrintQuotedString(Filename, OS);
    1124       13941 :   EmitEOL();
    1125       13941 : }
    1126             : 
    1127         388 : static void printDwarfFileDirective(unsigned FileNo, StringRef Directory,
    1128             :                                     StringRef Filename,
    1129             :                                     MD5::MD5Result *Checksum,
    1130             :                                     Optional<StringRef> Source,
    1131             :                                     bool UseDwarfDirectory,
    1132             :                                     raw_svector_ostream &OS) {
    1133             :   SmallString<128> FullPathName;
    1134             : 
    1135         388 :   if (!UseDwarfDirectory && !Directory.empty()) {
    1136         303 :     if (sys::path::is_absolute(Filename))
    1137             :       Directory = "";
    1138             :     else {
    1139             :       FullPathName = Directory;
    1140         256 :       sys::path::append(FullPathName, Filename);
    1141             :       Directory = "";
    1142         256 :       Filename = FullPathName;
    1143             :     }
    1144             :   }
    1145             : 
    1146         388 :   OS << "\t.file\t" << FileNo << ' ';
    1147         388 :   if (!Directory.empty()) {
    1148          43 :     PrintQuotedString(Directory, OS);
    1149             :     OS << ' ';
    1150             :   }
    1151         388 :   PrintQuotedString(Filename, OS);
    1152         388 :   if (Checksum)
    1153          12 :     OS << " md5 0x" << Checksum->digest();
    1154         388 :   if (Source) {
    1155           6 :     OS << " source ";
    1156           6 :     PrintQuotedString(*Source, OS);
    1157             :   }
    1158         388 : }
    1159             : 
    1160        3317 : Expected<unsigned> MCAsmStreamer::tryEmitDwarfFileDirective(
    1161             :     unsigned FileNo, StringRef Directory, StringRef Filename,
    1162             :     MD5::MD5Result *Checksum, Optional<StringRef> Source, unsigned CUID) {
    1163             :   assert(CUID == 0 && "multiple CUs not supported by MCAsmStreamer");
    1164             : 
    1165        3317 :   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
    1166        3317 :   unsigned NumFiles = Table.getMCDwarfFiles().size();
    1167             :   Expected<unsigned> FileNoOrErr =
    1168        3317 :       Table.tryGetFile(Directory, Filename, Checksum, Source, FileNo);
    1169        3317 :   if (!FileNoOrErr)
    1170             :     return FileNoOrErr.takeError();
    1171        3317 :   FileNo = FileNoOrErr.get();
    1172        3317 :   if (NumFiles == Table.getMCDwarfFiles().size())
    1173             :     return FileNo;
    1174             : 
    1175             :   SmallString<128> Str;
    1176             :   raw_svector_ostream OS1(Str);
    1177         382 :   printDwarfFileDirective(FileNo, Directory, Filename, Checksum, Source,
    1178         382 :                           UseDwarfDirectory, OS1);
    1179             : 
    1180         382 :   if (MCTargetStreamer *TS = getTargetStreamer())
    1181         756 :     TS->emitDwarfFileDirective(OS1.str());
    1182             :   else
    1183          12 :     EmitRawText(OS1.str());
    1184             : 
    1185             :   return FileNo;
    1186             : }
    1187             : 
    1188         292 : void MCAsmStreamer::emitDwarfFile0Directive(StringRef Directory,
    1189             :                                             StringRef Filename,
    1190             :                                             MD5::MD5Result *Checksum,
    1191             :                                             Optional<StringRef> Source,
    1192             :                                             unsigned CUID) {
    1193             :   assert(CUID == 0);
    1194             :   // .file 0 is new for DWARF v5.
    1195         292 :   if (getContext().getDwarfVersion() < 5)
    1196         286 :     return;
    1197             :   // Inform MCDwarf about the root file.
    1198           6 :   getContext().setMCLineTableRootFile(CUID, Directory, Filename, Checksum,
    1199             :                                       Source);
    1200             : 
    1201             :   SmallString<128> Str;
    1202             :   raw_svector_ostream OS1(Str);
    1203           6 :   printDwarfFileDirective(0, Directory, Filename, Checksum, Source,
    1204           6 :                           UseDwarfDirectory, OS1);
    1205             : 
    1206           6 :   if (MCTargetStreamer *TS = getTargetStreamer())
    1207          12 :     TS->emitDwarfFileDirective(OS1.str());
    1208             :   else
    1209           0 :     EmitRawText(OS1.str());
    1210             : }
    1211             : 
    1212        1460 : void MCAsmStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
    1213             :                                           unsigned Column, unsigned Flags,
    1214             :                                           unsigned Isa,
    1215             :                                           unsigned Discriminator,
    1216             :                                           StringRef FileName) {
    1217        4380 :   OS << "\t.loc\t" << FileNo << " " << Line << " " << Column;
    1218        1460 :   if (MAI->supportsExtendedDwarfLocDirective()) {
    1219        1423 :     if (Flags & DWARF2_FLAG_BASIC_BLOCK)
    1220           0 :       OS << " basic_block";
    1221        1423 :     if (Flags & DWARF2_FLAG_PROLOGUE_END)
    1222         326 :       OS << " prologue_end";
    1223        1423 :     if (Flags & DWARF2_FLAG_EPILOGUE_BEGIN)
    1224           0 :       OS << " epilogue_begin";
    1225             : 
    1226        1423 :     unsigned OldFlags = getContext().getCurrentDwarfLoc().getFlags();
    1227        1423 :     if ((Flags & DWARF2_FLAG_IS_STMT) != (OldFlags & DWARF2_FLAG_IS_STMT)) {
    1228         321 :       OS << " is_stmt ";
    1229             : 
    1230         321 :       if (Flags & DWARF2_FLAG_IS_STMT)
    1231         137 :         OS << "1";
    1232             :       else
    1233         184 :         OS << "0";
    1234             :     }
    1235             : 
    1236        1423 :     if (Isa)
    1237           1 :       OS << " isa " << Isa;
    1238        1423 :     if (Discriminator)
    1239           6 :       OS << " discriminator " << Discriminator;
    1240             :   }
    1241             : 
    1242        1460 :   if (IsVerboseAsm) {
    1243        1314 :     OS.PadToColumn(MAI->getCommentColumn());
    1244        2628 :     OS << MAI->getCommentString() << ' ' << FileName << ':'
    1245             :        << Line << ':' << Column;
    1246             :   }
    1247        1460 :   EmitEOL();
    1248        1460 :   this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
    1249             :                                           Isa, Discriminator, FileName);
    1250        1460 : }
    1251             : 
    1252         310 : MCSymbol *MCAsmStreamer::getDwarfLineTableSymbol(unsigned CUID) {
    1253             :   // Always use the zeroth line table, since asm syntax only supports one line
    1254             :   // table for now.
    1255         310 :   return MCStreamer::getDwarfLineTableSymbol(0);
    1256             : }
    1257             : 
    1258          66 : bool MCAsmStreamer::EmitCVFileDirective(unsigned FileNo, StringRef Filename,
    1259             :                                         ArrayRef<uint8_t> Checksum,
    1260             :                                         unsigned ChecksumKind) {
    1261          66 :   if (!getContext().getCVContext().addFile(*this, FileNo, Filename, Checksum,
    1262             :                                            ChecksumKind))
    1263             :     return false;
    1264             : 
    1265          66 :   OS << "\t.cv_file\t" << FileNo << ' ';
    1266          66 :   PrintQuotedString(Filename, OS);
    1267             : 
    1268          66 :   if (!ChecksumKind) {
    1269          27 :     EmitEOL();
    1270          27 :     return true;
    1271             :   }
    1272             : 
    1273          39 :   OS << ' ';
    1274          39 :   PrintQuotedString(toHex(Checksum), OS);
    1275          39 :   OS << ' ' << ChecksumKind;
    1276             : 
    1277          39 :   EmitEOL();
    1278          39 :   return true;
    1279             : }
    1280             : 
    1281         104 : bool MCAsmStreamer::EmitCVFuncIdDirective(unsigned FuncId) {
    1282         104 :   OS << "\t.cv_func_id " << FuncId << '\n';
    1283         104 :   return MCStreamer::EmitCVFuncIdDirective(FuncId);
    1284             : }
    1285             : 
    1286           9 : bool MCAsmStreamer::EmitCVInlineSiteIdDirective(unsigned FunctionId,
    1287             :                                                 unsigned IAFunc,
    1288             :                                                 unsigned IAFile,
    1289             :                                                 unsigned IALine, unsigned IACol,
    1290             :                                                 SMLoc Loc) {
    1291          18 :   OS << "\t.cv_inline_site_id " << FunctionId << " within " << IAFunc
    1292           9 :      << " inlined_at " << IAFile << ' ' << IALine << ' ' << IACol << '\n';
    1293           9 :   return MCStreamer::EmitCVInlineSiteIdDirective(FunctionId, IAFunc, IAFile,
    1294           9 :                                                  IALine, IACol, Loc);
    1295             : }
    1296             : 
    1297         421 : void MCAsmStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
    1298             :                                        unsigned Line, unsigned Column,
    1299             :                                        bool PrologueEnd, bool IsStmt,
    1300             :                                        StringRef FileName, SMLoc Loc) {
    1301             :   // Validate the directive.
    1302         421 :   if (!checkCVLocSection(FunctionId, FileNo, Loc))
    1303             :     return;
    1304             : 
    1305        1680 :   OS << "\t.cv_loc\t" << FunctionId << " " << FileNo << " " << Line << " "
    1306             :      << Column;
    1307         420 :   if (PrologueEnd)
    1308           0 :     OS << " prologue_end";
    1309             : 
    1310         420 :   if (IsStmt)
    1311           0 :     OS << " is_stmt 1";
    1312             : 
    1313         420 :   if (IsVerboseAsm) {
    1314         420 :     OS.PadToColumn(MAI->getCommentColumn());
    1315         840 :     OS << MAI->getCommentString() << ' ' << FileName << ':' << Line << ':'
    1316             :        << Column;
    1317             :   }
    1318         420 :   EmitEOL();
    1319             : }
    1320             : 
    1321          98 : void MCAsmStreamer::EmitCVLinetableDirective(unsigned FunctionId,
    1322             :                                              const MCSymbol *FnStart,
    1323             :                                              const MCSymbol *FnEnd) {
    1324         196 :   OS << "\t.cv_linetable\t" << FunctionId << ", ";
    1325          98 :   FnStart->print(OS, MAI);
    1326          98 :   OS << ", ";
    1327          98 :   FnEnd->print(OS, MAI);
    1328          98 :   EmitEOL();
    1329          98 :   this->MCStreamer::EmitCVLinetableDirective(FunctionId, FnStart, FnEnd);
    1330          98 : }
    1331             : 
    1332           7 : void MCAsmStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
    1333             :                                                    unsigned SourceFileId,
    1334             :                                                    unsigned SourceLineNum,
    1335             :                                                    const MCSymbol *FnStartSym,
    1336             :                                                    const MCSymbol *FnEndSym) {
    1337           7 :   OS << "\t.cv_inline_linetable\t" << PrimaryFunctionId << ' ' << SourceFileId
    1338             :      << ' ' << SourceLineNum << ' ';
    1339           7 :   FnStartSym->print(OS, MAI);
    1340           7 :   OS << ' ';
    1341           7 :   FnEndSym->print(OS, MAI);
    1342           7 :   EmitEOL();
    1343           7 :   this->MCStreamer::EmitCVInlineLinetableDirective(
    1344             :       PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
    1345           7 : }
    1346             : 
    1347         113 : void MCAsmStreamer::EmitCVDefRangeDirective(
    1348             :     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
    1349             :     StringRef FixedSizePortion) {
    1350         113 :   OS << "\t.cv_def_range\t";
    1351         228 :   for (std::pair<const MCSymbol *, const MCSymbol *> Range : Ranges) {
    1352         115 :     OS << ' ';
    1353         115 :     Range.first->print(OS, MAI);
    1354         115 :     OS << ' ';
    1355         115 :     Range.second->print(OS, MAI);
    1356             :   }
    1357         113 :   OS << ", ";
    1358         113 :   PrintQuotedString(FixedSizePortion, OS);
    1359         113 :   EmitEOL();
    1360         113 :   this->MCStreamer::EmitCVDefRangeDirective(Ranges, FixedSizePortion);
    1361         113 : }
    1362             : 
    1363          63 : void MCAsmStreamer::EmitCVStringTableDirective() {
    1364          63 :   OS << "\t.cv_stringtable";
    1365          63 :   EmitEOL();
    1366          63 : }
    1367             : 
    1368          61 : void MCAsmStreamer::EmitCVFileChecksumsDirective() {
    1369          61 :   OS << "\t.cv_filechecksums";
    1370          61 :   EmitEOL();
    1371          61 : }
    1372             : 
    1373           6 : void MCAsmStreamer::EmitCVFileChecksumOffsetDirective(unsigned FileNo) {
    1374           6 :   OS << "\t.cv_filechecksumoffset\t" << FileNo;
    1375           6 :   EmitEOL();
    1376           6 : }
    1377             : 
    1378          64 : void MCAsmStreamer::EmitCVFPOData(const MCSymbol *ProcSym, SMLoc L) {
    1379          64 :   OS << "\t.cv_fpo_data\t";
    1380          64 :   ProcSym->print(OS, MAI);
    1381          64 :   EmitEOL();
    1382          64 : }
    1383             : 
    1384         363 : void MCAsmStreamer::EmitIdent(StringRef IdentString) {
    1385             :   assert(MAI->hasIdentDirective() && ".ident directive not supported");
    1386         363 :   OS << "\t.ident\t";
    1387         363 :   PrintQuotedString(IdentString, OS);
    1388         363 :   EmitEOL();
    1389         363 : }
    1390             : 
    1391         127 : void MCAsmStreamer::EmitCFISections(bool EH, bool Debug) {
    1392         127 :   MCStreamer::EmitCFISections(EH, Debug);
    1393         127 :   OS << "\t.cfi_sections ";
    1394         127 :   if (EH) {
    1395           0 :     OS << ".eh_frame";
    1396           0 :     if (Debug)
    1397           0 :       OS << ", .debug_frame";
    1398         127 :   } else if (Debug) {
    1399         127 :     OS << ".debug_frame";
    1400             :   }
    1401             : 
    1402         127 :   EmitEOL();
    1403         127 : }
    1404             : 
    1405      107619 : void MCAsmStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
    1406      107619 :   OS << "\t.cfi_startproc";
    1407      107619 :   if (Frame.IsSimple)
    1408           2 :     OS << " simple";
    1409      107619 :   EmitEOL();
    1410      107619 : }
    1411             : 
    1412      107617 : void MCAsmStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
    1413      107617 :   MCStreamer::EmitCFIEndProcImpl(Frame);
    1414      107617 :   OS << "\t.cfi_endproc";
    1415      107617 :   EmitEOL();
    1416      107617 : }
    1417             : 
    1418       21781 : void MCAsmStreamer::EmitRegisterName(int64_t Register) {
    1419       21781 :   if (!MAI->useDwarfRegNumForCFI()) {
    1420             :     // User .cfi_* directives can use arbitrary DWARF register numbers, not
    1421             :     // just ones that map to LLVM register numbers and have known names.
    1422             :     // Fall back to using the original number directly if no name is known.
    1423       18826 :     const MCRegisterInfo *MRI = getContext().getRegisterInfo();
    1424       18826 :     int LLVMRegister = MRI->getLLVMRegNumFromEH(Register);
    1425       18826 :     if (LLVMRegister != -1) {
    1426       18825 :       InstPrinter->printRegName(OS, LLVMRegister);
    1427       18825 :       return;
    1428             :     }
    1429             :   }
    1430        2956 :   OS << Register;
    1431             : }
    1432             : 
    1433        2241 : void MCAsmStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
    1434        2241 :   MCStreamer::EmitCFIDefCfa(Register, Offset);
    1435        2241 :   OS << "\t.cfi_def_cfa ";
    1436        2241 :   EmitRegisterName(Register);
    1437        2241 :   OS << ", " << Offset;
    1438        2241 :   EmitEOL();
    1439        2241 : }
    1440             : 
    1441       15115 : void MCAsmStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
    1442       15115 :   MCStreamer::EmitCFIDefCfaOffset(Offset);
    1443       15115 :   OS << "\t.cfi_def_cfa_offset " << Offset;
    1444       15115 :   EmitEOL();
    1445       15115 : }
    1446             : 
    1447          22 : static void PrintCFIEscape(llvm::formatted_raw_ostream &OS, StringRef Values) {
    1448          22 :   OS << "\t.cfi_escape ";
    1449          22 :   if (!Values.empty()) {
    1450          22 :     size_t e = Values.size() - 1;
    1451          44 :     for (size_t i = 0; i < e; ++i)
    1452          44 :       OS << format("0x%02x", uint8_t(Values[i])) << ", ";
    1453          44 :     OS << format("0x%02x", uint8_t(Values[e]));
    1454             :   }
    1455          22 : }
    1456             : 
    1457           0 : void MCAsmStreamer::EmitCFIEscape(StringRef Values) {
    1458           0 :   MCStreamer::EmitCFIEscape(Values);
    1459           0 :   PrintCFIEscape(OS, Values);
    1460           0 :   EmitEOL();
    1461           0 : }
    1462             : 
    1463          22 : void MCAsmStreamer::EmitCFIGnuArgsSize(int64_t Size) {
    1464          22 :   MCStreamer::EmitCFIGnuArgsSize(Size);
    1465             : 
    1466          22 :   uint8_t Buffer[16] = { dwarf::DW_CFA_GNU_args_size };
    1467          22 :   unsigned Len = encodeULEB128(Size, Buffer + 1) + 1;
    1468             : 
    1469          44 :   PrintCFIEscape(OS, StringRef((const char *)&Buffer[0], Len));
    1470          22 :   EmitEOL();
    1471          22 : }
    1472             : 
    1473        1441 : void MCAsmStreamer::EmitCFIDefCfaRegister(int64_t Register) {
    1474        1441 :   MCStreamer::EmitCFIDefCfaRegister(Register);
    1475        1441 :   OS << "\t.cfi_def_cfa_register ";
    1476        1441 :   EmitRegisterName(Register);
    1477        1441 :   EmitEOL();
    1478        1441 : }
    1479             : 
    1480       18072 : void MCAsmStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
    1481       18072 :   this->MCStreamer::EmitCFIOffset(Register, Offset);
    1482       18072 :   OS << "\t.cfi_offset ";
    1483       18072 :   EmitRegisterName(Register);
    1484       18072 :   OS << ", " << Offset;
    1485       18072 :   EmitEOL();
    1486       18072 : }
    1487             : 
    1488         208 : void MCAsmStreamer::EmitCFIPersonality(const MCSymbol *Sym,
    1489             :                                        unsigned Encoding) {
    1490         208 :   MCStreamer::EmitCFIPersonality(Sym, Encoding);
    1491         416 :   OS << "\t.cfi_personality " << Encoding << ", ";
    1492         208 :   Sym->print(OS, MAI);
    1493         208 :   EmitEOL();
    1494         208 : }
    1495             : 
    1496         208 : void MCAsmStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
    1497         208 :   MCStreamer::EmitCFILsda(Sym, Encoding);
    1498         416 :   OS << "\t.cfi_lsda " << Encoding << ", ";
    1499         208 :   Sym->print(OS, MAI);
    1500         208 :   EmitEOL();
    1501         208 : }
    1502             : 
    1503          28 : void MCAsmStreamer::EmitCFIRememberState() {
    1504          28 :   MCStreamer::EmitCFIRememberState();
    1505          28 :   OS << "\t.cfi_remember_state";
    1506          28 :   EmitEOL();
    1507          28 : }
    1508             : 
    1509          28 : void MCAsmStreamer::EmitCFIRestoreState() {
    1510          28 :   MCStreamer::EmitCFIRestoreState();
    1511          28 :   OS << "\t.cfi_restore_state";
    1512          28 :   EmitEOL();
    1513          28 : }
    1514             : 
    1515           4 : void MCAsmStreamer::EmitCFIRestore(int64_t Register) {
    1516           4 :   MCStreamer::EmitCFIRestore(Register);
    1517           4 :   OS << "\t.cfi_restore ";
    1518           4 :   EmitRegisterName(Register);
    1519           4 :   EmitEOL();
    1520           4 : }
    1521             : 
    1522           2 : void MCAsmStreamer::EmitCFISameValue(int64_t Register) {
    1523           2 :   MCStreamer::EmitCFISameValue(Register);
    1524           2 :   OS << "\t.cfi_same_value ";
    1525           2 :   EmitRegisterName(Register);
    1526           2 :   EmitEOL();
    1527           2 : }
    1528             : 
    1529          21 : void MCAsmStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
    1530          21 :   MCStreamer::EmitCFIRelOffset(Register, Offset);
    1531          21 :   OS << "\t.cfi_rel_offset ";
    1532          21 :   EmitRegisterName(Register);
    1533          21 :   OS << ", " << Offset;
    1534          21 :   EmitEOL();
    1535          21 : }
    1536             : 
    1537        1693 : void MCAsmStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
    1538        1693 :   MCStreamer::EmitCFIAdjustCfaOffset(Adjustment);
    1539        1693 :   OS << "\t.cfi_adjust_cfa_offset " << Adjustment;
    1540        1693 :   EmitEOL();
    1541        1693 : }
    1542             : 
    1543           0 : void MCAsmStreamer::EmitCFISignalFrame() {
    1544           0 :   MCStreamer::EmitCFISignalFrame();
    1545           0 :   OS << "\t.cfi_signal_frame";
    1546           0 :   EmitEOL();
    1547           0 : }
    1548             : 
    1549           0 : void MCAsmStreamer::EmitCFIUndefined(int64_t Register) {
    1550           0 :   MCStreamer::EmitCFIUndefined(Register);
    1551           0 :   OS << "\t.cfi_undefined " << Register;
    1552           0 :   EmitEOL();
    1553           0 : }
    1554             : 
    1555         394 : void MCAsmStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
    1556         394 :   MCStreamer::EmitCFIRegister(Register1, Register2);
    1557         394 :   OS << "\t.cfi_register " << Register1 << ", " << Register2;
    1558         394 :   EmitEOL();
    1559         394 : }
    1560             : 
    1561         392 : void MCAsmStreamer::EmitCFIWindowSave() {
    1562         392 :   MCStreamer::EmitCFIWindowSave();
    1563         392 :   OS << "\t.cfi_window_save";
    1564         392 :   EmitEOL();
    1565         392 : }
    1566             : 
    1567           3 : void MCAsmStreamer::EmitCFIReturnColumn(int64_t Register) {
    1568           3 :   MCStreamer::EmitCFIReturnColumn(Register);
    1569           3 :   OS << "\t.cfi_return_column " << Register;
    1570           3 :   EmitEOL();
    1571           3 : }
    1572             : 
    1573         466 : void MCAsmStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) {
    1574         466 :   MCStreamer::EmitWinCFIStartProc(Symbol, Loc);
    1575             : 
    1576         466 :   OS << ".seh_proc ";
    1577         466 :   Symbol->print(OS, MAI);
    1578         466 :   EmitEOL();
    1579         466 : }
    1580             : 
    1581         465 : void MCAsmStreamer::EmitWinCFIEndProc(SMLoc Loc) {
    1582         465 :   MCStreamer::EmitWinCFIEndProc(Loc);
    1583             : 
    1584         465 :   OS << "\t.seh_endproc";
    1585         465 :   EmitEOL();
    1586         465 : }
    1587             : 
    1588           1 : void MCAsmStreamer::EmitWinCFIStartChained(SMLoc Loc) {
    1589           1 :   MCStreamer::EmitWinCFIStartChained(Loc);
    1590             : 
    1591           1 :   OS << "\t.seh_startchained";
    1592           1 :   EmitEOL();
    1593           1 : }
    1594             : 
    1595           1 : void MCAsmStreamer::EmitWinCFIEndChained(SMLoc Loc) {
    1596           1 :   MCStreamer::EmitWinCFIEndChained(Loc);
    1597             : 
    1598           1 :   OS << "\t.seh_endchained";
    1599           1 :   EmitEOL();
    1600           1 : }
    1601             : 
    1602         131 : void MCAsmStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
    1603             :                                      bool Except, SMLoc Loc) {
    1604         131 :   MCStreamer::EmitWinEHHandler(Sym, Unwind, Except, Loc);
    1605             : 
    1606         131 :   OS << "\t.seh_handler ";
    1607         131 :   Sym->print(OS, MAI);
    1608         131 :   if (Unwind)
    1609         130 :     OS << ", @unwind";
    1610         131 :   if (Except)
    1611         131 :     OS << ", @except";
    1612         131 :   EmitEOL();
    1613         131 : }
    1614             : 
    1615         465 : void MCAsmStreamer::EmitWinEHHandlerData(SMLoc Loc) {
    1616         465 :   MCStreamer::EmitWinEHHandlerData(Loc);
    1617             : 
    1618             :   // Switch sections. Don't call SwitchSection directly, because that will
    1619             :   // cause the section switch to be visible in the emitted assembly.
    1620             :   // We only do this so the section switch that terminates the handler
    1621             :   // data block is visible.
    1622         465 :   WinEH::FrameInfo *CurFrame = getCurrentWinFrameInfo();
    1623         465 :   MCSection *TextSec = &CurFrame->Function->getSection();
    1624         465 :   MCSection *XData = getAssociatedXDataSection(TextSec);
    1625             :   SwitchSectionNoChange(XData);
    1626             : 
    1627         465 :   OS << "\t.seh_handlerdata";
    1628         465 :   EmitEOL();
    1629         465 : }
    1630             : 
    1631         414 : void MCAsmStreamer::EmitWinCFIPushReg(unsigned Register, SMLoc Loc) {
    1632         414 :   MCStreamer::EmitWinCFIPushReg(Register, Loc);
    1633             : 
    1634         414 :   OS << "\t.seh_pushreg " << Register;
    1635         414 :   EmitEOL();
    1636         414 : }
    1637             : 
    1638          92 : void MCAsmStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset,
    1639             :                                        SMLoc Loc) {
    1640          92 :   MCStreamer::EmitWinCFISetFrame(Register, Offset, Loc);
    1641             : 
    1642         184 :   OS << "\t.seh_setframe " << Register << ", " << Offset;
    1643          92 :   EmitEOL();
    1644          92 : }
    1645             : 
    1646         438 : void MCAsmStreamer::EmitWinCFIAllocStack(unsigned Size, SMLoc Loc) {
    1647         438 :   MCStreamer::EmitWinCFIAllocStack(Size, Loc);
    1648             : 
    1649         438 :   OS << "\t.seh_stackalloc " << Size;
    1650         438 :   EmitEOL();
    1651         438 : }
    1652             : 
    1653           1 : void MCAsmStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset,
    1654             :                                       SMLoc Loc) {
    1655           1 :   MCStreamer::EmitWinCFISaveReg(Register, Offset, Loc);
    1656             : 
    1657           2 :   OS << "\t.seh_savereg " << Register << ", " << Offset;
    1658           1 :   EmitEOL();
    1659           1 : }
    1660             : 
    1661         191 : void MCAsmStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
    1662             :                                       SMLoc Loc) {
    1663         191 :   MCStreamer::EmitWinCFISaveXMM(Register, Offset, Loc);
    1664             : 
    1665         382 :   OS << "\t.seh_savexmm " << Register << ", " << Offset;
    1666         191 :   EmitEOL();
    1667         191 : }
    1668             : 
    1669           1 : void MCAsmStreamer::EmitWinCFIPushFrame(bool Code, SMLoc Loc) {
    1670           1 :   MCStreamer::EmitWinCFIPushFrame(Code, Loc);
    1671             : 
    1672           1 :   OS << "\t.seh_pushframe";
    1673           1 :   if (Code)
    1674           1 :     OS << " @code";
    1675           1 :   EmitEOL();
    1676           1 : }
    1677             : 
    1678         466 : void MCAsmStreamer::EmitWinCFIEndProlog(SMLoc Loc) {
    1679         466 :   MCStreamer::EmitWinCFIEndProlog(Loc);
    1680             : 
    1681         466 :   OS << "\t.seh_endprologue";
    1682         466 :   EmitEOL();
    1683         466 : }
    1684             : 
    1685           6 : void MCAsmStreamer::emitCGProfileEntry(const MCSymbolRefExpr *From,
    1686             :                                        const MCSymbolRefExpr *To,
    1687             :                                        uint64_t Count) {
    1688           6 :   OS << "\t.cg_profile ";
    1689           6 :   From->getSymbol().print(OS, MAI);
    1690           6 :   OS << ", ";
    1691           6 :   To->getSymbol().print(OS, MAI);
    1692           6 :   OS << ", " << Count;
    1693           6 :   EmitEOL();
    1694           6 : }
    1695             : 
    1696     2041189 : void MCAsmStreamer::AddEncodingComment(const MCInst &Inst,
    1697             :                                        const MCSubtargetInfo &STI,
    1698             :                                        bool PrintSchedInfo) {
    1699             :   raw_ostream &OS = GetCommentOS();
    1700             :   SmallString<256> Code;
    1701             :   SmallVector<MCFixup, 4> Fixups;
    1702             :   raw_svector_ostream VecOS(Code);
    1703             : 
    1704             :   // If we have no code emitter, don't emit code.
    1705     2041189 :   if (!getAssembler().getEmitterPtr())
    1706             :     return;
    1707             : 
    1708      450364 :   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
    1709             : 
    1710             :   // If we are showing fixups, create symbolic markers in the encoded
    1711             :   // representation. We do this by making a per-bit map to the fixup item index,
    1712             :   // then trying to display it as nicely as possible.
    1713             :   SmallVector<uint8_t, 64> FixupMap;
    1714      900726 :   FixupMap.resize(Code.size() * 8);
    1715    22637931 :   for (unsigned i = 0, e = Code.size() * 8; i != e; ++i)
    1716    44375136 :     FixupMap[i] = 0;
    1717             : 
    1718      456066 :   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
    1719        5703 :     MCFixup &F = Fixups[i];
    1720             :     const MCFixupKindInfo &Info =
    1721        5703 :         getAssembler().getBackend().getFixupKindInfo(F.getKind());
    1722      108996 :     for (unsigned j = 0; j != Info.TargetSize; ++j) {
    1723      103293 :       unsigned Index = F.getOffset() * 8 + Info.TargetOffset + j;
    1724             :       assert(Index < Code.size() * 8 && "Invalid offset in fixup!");
    1725      206586 :       FixupMap[Index] = 1 + i;
    1726             :     }
    1727             :   }
    1728             : 
    1729             :   // FIXME: Note the fixup comments for Thumb2 are completely bogus since the
    1730             :   // high order halfword of a 32-bit Thumb2 instruction is emitted first.
    1731      450363 :   OS << "encoding: [";
    1732     3223809 :   for (unsigned i = 0, e = Code.size(); i != e; ++i) {
    1733     2773446 :     if (i)
    1734             :       OS << ',';
    1735             : 
    1736             :     // See if all bits are the same map entry.
    1737     5546892 :     uint8_t MapEntry = FixupMap[i * 8 + 0];
    1738    22177945 :     for (unsigned j = 1; j != 8; ++j) {
    1739    38813752 :       if (FixupMap[i * 8 + j] == MapEntry)
    1740             :         continue;
    1741             : 
    1742             :       MapEntry = uint8_t(~0U);
    1743             :       break;
    1744             :     }
    1745             : 
    1746     2773446 :     if (MapEntry != uint8_t(~0U)) {
    1747     2771069 :       if (MapEntry == 0) {
    1748     8278920 :         OS << format("0x%02x", uint8_t(Code[i]));
    1749             :       } else {
    1750       22858 :         if (Code[i]) {
    1751             :           // FIXME: Some of the 8 bits require fix up.
    1752        1377 :           OS << format("0x%02x", uint8_t(Code[i])) << '\''
    1753         459 :              << char('A' + MapEntry - 1) << '\'';
    1754             :         } else
    1755       10970 :           OS << char('A' + MapEntry - 1);
    1756             :       }
    1757             :     } else {
    1758             :       // Otherwise, write out in binary.
    1759        2377 :       OS << "0b";
    1760       21393 :       for (unsigned j = 8; j--;) {
    1761       19016 :         unsigned Bit = (Code[i] >> j) & 1;
    1762             : 
    1763             :         unsigned FixupBit;
    1764       19016 :         if (MAI->isLittleEndian())
    1765       10304 :           FixupBit = i * 8 + j;
    1766             :         else
    1767        8712 :           FixupBit = i * 8 + (7-j);
    1768             : 
    1769       38032 :         if (uint8_t MapEntry = FixupMap[FixupBit]) {
    1770             :           assert(Bit == 0 && "Encoder wrote into fixed up bit!");
    1771       11861 :           OS << char('A' + MapEntry - 1);
    1772             :         } else
    1773             :           OS << Bit;
    1774             :       }
    1775             :     }
    1776             :   }
    1777      450363 :   OS << "]";
    1778             :   // If we are not going to add fixup or schedule comments after this point
    1779             :   // then we have to end the current comment line with "\n".
    1780      450363 :   if (Fixups.size() || !PrintSchedInfo)
    1781      450363 :     OS << "\n";
    1782             : 
    1783      456066 :   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
    1784        5703 :     MCFixup &F = Fixups[i];
    1785             :     const MCFixupKindInfo &Info =
    1786        5703 :         getAssembler().getBackend().getFixupKindInfo(F.getKind());
    1787       11406 :     OS << "  fixup " << char('A' + i) << " - " << "offset: " << F.getOffset()
    1788        5703 :        << ", value: " << *F.getValue() << ", kind: " << Info.Name << "\n";
    1789             :   }
    1790             : }
    1791             : 
    1792     2041189 : void MCAsmStreamer::EmitInstruction(const MCInst &Inst,
    1793             :                                     const MCSubtargetInfo &STI,
    1794             :                                     bool PrintSchedInfo) {
    1795             :   assert(getCurrentSectionOnly() &&
    1796             :          "Cannot emit contents before setting section!");
    1797             : 
    1798             :   // Show the encoding in a comment if we have a code emitter.
    1799     2041189 :   AddEncodingComment(Inst, STI, PrintSchedInfo);
    1800             : 
    1801             :   // Show the MCInst if enabled.
    1802     2041188 :   if (ShowInst) {
    1803        8617 :     if (PrintSchedInfo)
    1804           0 :       GetCommentOS() << "\n";
    1805        8617 :     Inst.dump_pretty(GetCommentOS(), InstPrinter.get(), "\n ");
    1806        8617 :     GetCommentOS() << "\n";
    1807             :   }
    1808             : 
    1809     2041188 :   if(getTargetStreamer())
    1810     3765296 :     getTargetStreamer()->prettyPrintAsm(*InstPrinter, OS, Inst, STI);
    1811             :   else
    1812      317080 :     InstPrinter->printInst(&Inst, OS, "", STI);
    1813             : 
    1814     2041188 :   if (PrintSchedInfo) {
    1815       63511 :     std::string SI = STI.getSchedInfoStr(Inst);
    1816       63511 :     if (!SI.empty())
    1817             :       GetCommentOS() << SI;
    1818             :   }
    1819             : 
    1820             :   StringRef Comments = CommentToEmit;
    1821     2041188 :   if (Comments.size() && Comments.back() != '\n')
    1822      120959 :     GetCommentOS() << "\n";
    1823             : 
    1824     2041188 :   EmitEOL();
    1825     2041188 : }
    1826             : 
    1827           1 : void MCAsmStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
    1828           1 :   OS << "\t.bundle_align_mode " << AlignPow2;
    1829           1 :   EmitEOL();
    1830           1 : }
    1831             : 
    1832           4 : void MCAsmStreamer::EmitBundleLock(bool AlignToEnd) {
    1833           4 :   OS << "\t.bundle_lock";
    1834           4 :   if (AlignToEnd)
    1835           3 :     OS << " align_to_end";
    1836           4 :   EmitEOL();
    1837           4 : }
    1838             : 
    1839           2 : void MCAsmStreamer::EmitBundleUnlock() {
    1840           2 :   OS << "\t.bundle_unlock";
    1841           2 :   EmitEOL();
    1842           2 : }
    1843             : 
    1844         102 : bool MCAsmStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
    1845             :                                        const MCExpr *Expr, SMLoc,
    1846             :                                        const MCSubtargetInfo &STI) {
    1847         102 :   OS << "\t.reloc ";
    1848         102 :   Offset.print(OS, MAI);
    1849         102 :   OS << ", " << Name;
    1850         102 :   if (Expr) {
    1851          99 :     OS << ", ";
    1852          99 :     Expr->print(OS, MAI);
    1853             :   }
    1854         102 :   EmitEOL();
    1855         102 :   return false;
    1856             : }
    1857             : 
    1858          50 : void MCAsmStreamer::EmitAddrsig() {
    1859          50 :   OS << "\t.addrsig";
    1860          50 :   EmitEOL();
    1861          50 : }
    1862             : 
    1863          27 : void MCAsmStreamer::EmitAddrsigSym(const MCSymbol *Sym) {
    1864          27 :   OS << "\t.addrsig_sym ";
    1865          27 :   Sym->print(OS, MAI);
    1866          27 :   EmitEOL();
    1867          27 : }
    1868             : 
    1869             : /// EmitRawText - If this file is backed by an assembly streamer, this dumps
    1870             : /// the specified string in the output .s file.  This capability is
    1871             : /// indicated by the hasRawTextSupport() predicate.
    1872      459481 : void MCAsmStreamer::EmitRawTextImpl(StringRef String) {
    1873      459481 :   if (!String.empty() && String.back() == '\n')
    1874        8896 :     String = String.substr(0, String.size()-1);
    1875      459481 :   OS << String;
    1876      459481 :   EmitEOL();
    1877      459481 : }
    1878             : 
    1879       20517 : void MCAsmStreamer::FinishImpl() {
    1880             :   // If we are generating dwarf for assembly source files dump out the sections.
    1881       20517 :   if (getContext().getGenDwarfForAssembly())
    1882           6 :     MCGenDwarfInfo::Emit(this);
    1883             : 
    1884             :   // Emit the label for the line table, if requested - since the rest of the
    1885             :   // line table will be defined by .loc/.file directives, and not emitted
    1886             :   // directly, the label is the only work required here.
    1887       20517 :   auto &Tables = getContext().getMCDwarfLineTables();
    1888       20517 :   if (!Tables.empty()) {
    1889             :     assert(Tables.size() == 1 && "asm output only supports one line table");
    1890         314 :     if (auto *Label = Tables.begin()->second.getLabel()) {
    1891         299 :       SwitchSection(getContext().getObjectFileInfo()->getDwarfLineSection());
    1892         299 :       EmitLabel(Label);
    1893             :     }
    1894             :   }
    1895       20517 : }
    1896             : 
    1897       22812 : MCStreamer *llvm::createAsmStreamer(MCContext &Context,
    1898             :                                     std::unique_ptr<formatted_raw_ostream> OS,
    1899             :                                     bool isVerboseAsm, bool useDwarfDirectory,
    1900             :                                     MCInstPrinter *IP,
    1901             :                                     std::unique_ptr<MCCodeEmitter> &&CE,
    1902             :                                     std::unique_ptr<MCAsmBackend> &&MAB,
    1903             :                                     bool ShowInst) {
    1904             :   return new MCAsmStreamer(Context, std::move(OS), isVerboseAsm,
    1905             :                            useDwarfDirectory, IP, std::move(CE), std::move(MAB),
    1906       45624 :                            ShowInst);
    1907             : }

Generated by: LCOV version 1.13