vendor/llvm/llvm-trunk-r238337

1 files changed, 171 insertions, 211 deletions

diff --git a/include/llvm/MC/MCStreamer.h b/include/llvm/MC/MCStreamer.h
index 18855f9cf03d8..957913e934c4a 100644
--- a/include/llvm/MC/MCStreamer.h
+++ b/include/llvm/MC/MCStreamer.h
@@ -16,12 +16,12 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/SMLoc.h"
 #include <string>
 
 namespace llvm {
@@ -42,7 +42,7 @@ class raw_ostream;
 class formatted_raw_ostream;
 class AssemblerConstantPools;
 
-typedef std::pair<const MCSection *, const MCExpr *> MCSectionSubPair;
+typedef std::pair<MCSection *, const MCExpr *> MCSectionSubPair;
 
 /// Target specific streamer interface. This is used so that targets can
 /// implement support for target specific assembly directives.
@@ -87,35 +87,12 @@ public:
   virtual void finish();
 };
 
-class AArch64TargetStreamer : public MCTargetStreamer {
-public:
-  AArch64TargetStreamer(MCStreamer &S);
-  ~AArch64TargetStreamer();
-
-  void finish() override;
-
-  /// Callback used to implement the ldr= pseudo.
-  /// Add a new entry to the constant pool for the current section and return an
-  /// MCExpr that can be used to refer to the constant pool location.
-  const MCExpr *addConstantPoolEntry(const MCExpr *, unsigned Size);
-
-  /// Callback used to implemnt the .ltorg directive.
-  /// Emit contents of constant pool for the current section.
-  void emitCurrentConstantPool();
-
-  /// Callback used to implement the .inst directive.
-  virtual void emitInst(uint32_t Inst);
-
-private:
-  std::unique_ptr<AssemblerConstantPools> ConstantPools;
-};
-
 // FIXME: declared here because it is used from
 // lib/CodeGen/AsmPrinter/ARMException.cpp.
 class ARMTargetStreamer : public MCTargetStreamer {
 public:
   ARMTargetStreamer(MCStreamer &S);
-  ~ARMTargetStreamer();
+  ~ARMTargetStreamer() override;
 
   virtual void emitFnStart();
   virtual void emitFnEnd();
@@ -139,6 +116,7 @@ public:
                                     StringRef StringValue = "");
   virtual void emitFPU(unsigned FPU);
   virtual void emitArch(unsigned Arch);
+  virtual void emitArchExtension(unsigned ArchExt);
   virtual void emitObjectArch(unsigned Arch);
   virtual void finishAttributeSection();
   virtual void emitInst(uint32_t Inst, char Suffix = '\0');
@@ -162,11 +140,12 @@ private:
   std::unique_ptr<AssemblerConstantPools> ConstantPools;
 };
 
-/// MCStreamer - Streaming machine code generation interface.  This interface
-/// is intended to provide a programatic interface that is very similar to the
-/// level that an assembler .s file provides.  It has callbacks to emit bytes,
-/// handle directives, etc.  The implementation of this interface retains
-/// state to know what the current section is etc.
+/// \brief Streaming machine code generation interface.
+///
+/// This interface is intended to provide a programatic interface that is very
+/// similar to the level that an assembler .s file provides.  It has callbacks
+/// to emit bytes, handle directives, etc.  The implementation of this interface
+/// retains state to know what the current section is etc.
 ///
 /// There are multiple implementations of this interface: one for writing out
 /// a .s file, and implementations that write out .o files of various formats.
@@ -175,8 +154,8 @@ class MCStreamer {
   MCContext &Context;
   std::unique_ptr<MCTargetStreamer> TargetStreamer;
 
-  MCStreamer(const MCStreamer &) LLVM_DELETED_FUNCTION;
-  MCStreamer &operator=(const MCStreamer &) LLVM_DELETED_FUNCTION;
+  MCStreamer(const MCStreamer &) = delete;
+  MCStreamer &operator=(const MCStreamer &) = delete;
 
   std::vector<MCDwarfFrameInfo> DwarfFrameInfos;
   MCDwarfFrameInfo *getCurrentDwarfFrameInfo();
@@ -188,12 +167,12 @@ class MCStreamer {
   WinEH::FrameInfo *CurrentWinFrameInfo;
   void EnsureValidWinFrameInfo();
 
-  // SymbolOrdering - Tracks an index to represent the order
-  // a symbol was emitted in. Zero means we did not emit that symbol.
+  /// \brief Tracks an index to represent the order a symbol was emitted in.
+  /// Zero means we did not emit that symbol.
   DenseMap<const MCSymbol *, unsigned> SymbolOrdering;
 
-  /// SectionStack - This is stack of current and previous section
-  /// values saved by PushSection.
+  /// \brief This is stack of current and previous section values saved by
+  /// PushSection.
   SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;
 
 protected:
@@ -242,22 +221,24 @@ public:
 
   void generateCompactUnwindEncodings(MCAsmBackend *MAB);
 
-  /// @name Assembly File Formatting.
+  /// \name Assembly File Formatting.
   /// @{
 
-  /// isVerboseAsm - Return true if this streamer supports verbose assembly
-  /// and if it is enabled.
+  /// \brief Return true if this streamer supports verbose assembly and if it is
+  /// enabled.
   virtual bool isVerboseAsm() const { return false; }
 
-  /// hasRawTextSupport - Return true if this asm streamer supports emitting
-  /// unformatted text to the .s file with EmitRawText.
+  /// \brief Return true if this asm streamer supports emitting unformatted text
+  /// to the .s file with EmitRawText.
   virtual bool hasRawTextSupport() const { return false; }
 
-  /// Is the integrated assembler required for this streamer to function
+  /// \brief Is the integrated assembler required for this streamer to function
   /// correctly?
   virtual bool isIntegratedAssemblerRequired() const { return false; }
 
-  /// AddComment - Add a comment that can be emitted to the generated .s
+  /// \brief Add a textual command.
+  ///
+  /// Typically for comments that can be emitted to the generated .s
   /// file if applicable as a QoI issue to make the output of the compiler
   /// more readable.  This only affects the MCAsmStreamer, and only when
   /// verbose assembly output is enabled.
@@ -266,14 +247,14 @@ public:
   /// prefix as appropriate.  The added comment should not end with a \n.
   virtual void AddComment(const Twine &T) {}
 
-  /// GetCommentOS - Return a raw_ostream that comments can be written to.
-  /// Unlike AddComment, you are required to terminate comments with \n if you
-  /// use this method.
+  /// \brief Return a raw_ostream that comments can be written to. Unlike
+  /// AddComment, you are required to terminate comments with \n if you use this
+  /// method.
   virtual raw_ostream &GetCommentOS();
 
-  /// Print T and prefix it with the comment string (normally #) and optionally
-  /// a tab. This prints the comment immediately, not at the end of the
-  /// current line. It is basically a safe version of EmitRawText: since it
+  /// \brief Print T and prefix it with the comment string (normally #) and
+  /// optionally a tab. This prints the comment immediately, not at the end of
+  /// the current line. It is basically a safe version of EmitRawText: since it
   /// only prints comments, the object streamer ignores it instead of asserting.
   virtual void emitRawComment(const Twine &T, bool TabPrefix = true);
 
@@ -282,46 +263,43 @@ public:
 
   /// @}
 
-  /// @name Symbol & Section Management
+  /// \name Symbol & Section Management
   /// @{
 
-  /// getCurrentSection - Return the current section that the streamer is
-  /// emitting code to.
+  /// \brief Return the current section that the streamer is emitting code to.
   MCSectionSubPair getCurrentSection() const {
     if (!SectionStack.empty())
       return SectionStack.back().first;
     return MCSectionSubPair();
   }
 
-  /// getPreviousSection - Return the previous section that the streamer is
-  /// emitting code to.
+  /// \brief Return the previous section that the streamer is emitting code to.
   MCSectionSubPair getPreviousSection() const {
     if (!SectionStack.empty())
       return SectionStack.back().second;
     return MCSectionSubPair();
   }
 
-  /// GetSymbolOrder - Returns an index to represent the order
-  /// a symbol was emitted in. (zero if we did not emit that symbol)
+  /// \brief Returns an index to represent the order a symbol was emitted in.
+  /// (zero if we did not emit that symbol)
   unsigned GetSymbolOrder(const MCSymbol *Sym) const {
     return SymbolOrdering.lookup(Sym);
   }
 
-  /// ChangeSection - Update streamer for a new active section.
+  /// \brief Update streamer for a new active section.
   ///
   /// This is called by PopSection and SwitchSection, if the current
   /// section changes.
-  virtual void ChangeSection(const MCSection *, const MCExpr *);
+  virtual void ChangeSection(MCSection *, const MCExpr *);
 
-  /// pushSection - Save the current and previous section on the
-  /// section stack.
+  /// \brief Save the current and previous section on the section stack.
   void PushSection() {
     SectionStack.push_back(
         std::make_pair(getCurrentSection(), getPreviousSection()));
   }
 
-  /// popSection - Restore the current and previous section from
-  /// the section stack.  Calls ChangeSection as needed.
+  /// \brief Restore the current and previous section from the section stack.
+  /// Calls ChangeSection as needed.
   ///
   /// Returns false if the stack was empty.
   bool PopSection() {
@@ -343,25 +321,17 @@ public:
     return true;
   }
 
-  /// SwitchSection - Set the current section where code is being emitted to
-  /// @p Section.  This is required to update CurSection.
+  /// Set the current section where code is being emitted to \p Section.  This
+  /// is required to update CurSection.
   ///
   /// This corresponds to assembler directives like .section, .text, etc.
-  virtual void SwitchSection(const MCSection *Section,
-                             const MCExpr *Subsection = nullptr) {
-    assert(Section && "Cannot switch to a null section!");
-    MCSectionSubPair curSection = SectionStack.back().first;
-    SectionStack.back().second = curSection;
-    if (MCSectionSubPair(Section, Subsection) != curSection) {
-      SectionStack.back().first = MCSectionSubPair(Section, Subsection);
-      ChangeSection(Section, Subsection);
-    }
-  }
+  virtual void SwitchSection(MCSection *Section,
+                             const MCExpr *Subsection = nullptr);
 
-  /// SwitchSectionNoChange - Set the current section where code is being
-  /// emitted to @p Section.  This is required to update CurSection. This
-  /// version does not call ChangeSection.
-  void SwitchSectionNoChange(const MCSection *Section,
+  /// \brief Set the current section where code is being emitted to \p Section.
+  /// This is required to update CurSection. This version does not call
+  /// ChangeSection.
+  void SwitchSectionNoChange(MCSection *Section,
                              const MCExpr *Subsection = nullptr) {
     assert(Section && "Cannot switch to a null section!");
     MCSectionSubPair curSection = SectionStack.back().first;
@@ -370,21 +340,23 @@ public:
       SectionStack.back().first = MCSectionSubPair(Section, Subsection);
   }
 
-  /// Create the default sections and set the initial one.
+  /// \brief Create the default sections and set the initial one.
   virtual void InitSections(bool NoExecStack);
 
-  /// AssignSection - Sets the symbol's section.
+  MCSymbol *endSection(MCSection *Section);
+
+  /// \brief Sets the symbol's section.
   ///
   /// Each emitted symbol will be tracked in the ordering table,
   /// so we can sort on them later.
-  void AssignSection(MCSymbol *Symbol, const MCSection *Section);
+  void AssignSection(MCSymbol *Symbol, MCSection *Section);
 
-  /// EmitLabel - Emit a label for @p Symbol into the current section.
+  /// \brief Emit a label for \p Symbol into the current section.
   ///
   /// This corresponds to an assembler statement such as:
   ///   foo:
   ///
-  /// @param Symbol - The symbol to emit. A given symbol should only be
+  /// \param Symbol - The symbol to emit. A given symbol should only be
   /// emitted as a label once, and symbols emitted as a label should never be
   /// used in an assignment.
   // FIXME: These emission are non-const because we mutate the symbol to
@@ -393,25 +365,25 @@ public:
 
   virtual void EmitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol);
 
-  /// EmitAssemblerFlag - Note in the output the specified @p Flag.
+  /// \brief Note in the output the specified \p Flag.
   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
 
-  /// EmitLinkerOptions - Emit the given list @p Options of strings as linker
+  /// \brief Emit the given list \p Options of strings as linker
   /// options into the output.
   virtual void EmitLinkerOptions(ArrayRef<std::string> Kind) {}
 
-  /// EmitDataRegion - Note in the output the specified region @p Kind.
+  /// \brief Note in the output the specified region \p Kind.
   virtual void EmitDataRegion(MCDataRegionType Kind) {}
 
-  /// EmitVersionMin - Specify the MachO minimum deployment target version.
+  /// \brief Specify the MachO minimum deployment target version.
   virtual void EmitVersionMin(MCVersionMinType, unsigned Major, unsigned Minor,
                               unsigned Update) {}
 
-  /// EmitThumbFunc - Note in the output that the specified @p Func is
-  /// a Thumb mode function (ARM target only).
+  /// \brief Note in the output that the specified \p Func is a Thumb mode
+  /// function (ARM target only).
   virtual void EmitThumbFunc(MCSymbol *Func);
 
-  /// EmitAssignment - Emit an assignment of @p Value to @p Symbol.
+  /// \brief Emit an assignment of \p Value to \p Symbol.
   ///
   /// This corresponds to an assembler statement such as:
   ///  symbol = value
@@ -420,133 +392,131 @@ public:
   /// value in the current context. For the assembly streamer, this prints the
   /// binding into the .s file.
   ///
-  /// @param Symbol - The symbol being assigned to.
-  /// @param Value - The value for the symbol.
+  /// \param Symbol - The symbol being assigned to.
+  /// \param Value - The value for the symbol.
   virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
 
-  /// EmitWeakReference - Emit an weak reference from @p Alias to @p Symbol.
+  /// \brief Emit an weak reference from \p Alias to \p Symbol.
   ///
   /// This corresponds to an assembler statement such as:
   ///  .weakref alias, symbol
   ///
-  /// @param Alias - The alias that is being created.
-  /// @param Symbol - The symbol being aliased.
+  /// \param Alias - The alias that is being created.
+  /// \param Symbol - The symbol being aliased.
   virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
 
-  /// EmitSymbolAttribute - Add the given @p Attribute to @p Symbol.
+  /// \brief Add the given \p Attribute to \p Symbol.
   virtual bool EmitSymbolAttribute(MCSymbol *Symbol,
                                    MCSymbolAttr Attribute) = 0;
 
-  /// EmitSymbolDesc - Set the @p DescValue for the @p Symbol.
+  /// \brief Set the \p DescValue for the \p Symbol.
   ///
-  /// @param Symbol - The symbol to have its n_desc field set.
-  /// @param DescValue - The value to set into the n_desc field.
+  /// \param Symbol - The symbol to have its n_desc field set.
+  /// \param DescValue - The value to set into the n_desc field.
   virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
 
-  /// BeginCOFFSymbolDef - Start emitting COFF symbol definition
+  /// \brief Start emitting COFF symbol definition
   ///
-  /// @param Symbol - The symbol to have its External & Type fields set.
+  /// \param Symbol - The symbol to have its External & Type fields set.
   virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol);
 
-  /// EmitCOFFSymbolStorageClass - Emit the storage class of the symbol.
+  /// \brief Emit the storage class of the symbol.
   ///
-  /// @param StorageClass - The storage class the symbol should have.
+  /// \param StorageClass - The storage class the symbol should have.
   virtual void EmitCOFFSymbolStorageClass(int StorageClass);
 
-  /// EmitCOFFSymbolType - Emit the type of the symbol.
+  /// \brief Emit the type of the symbol.
   ///
-  /// @param Type - A COFF type identifier (see COFF::SymbolType in X86COFF.h)
+  /// \param Type - A COFF type identifier (see COFF::SymbolType in X86COFF.h)
   virtual void EmitCOFFSymbolType(int Type);
 
-  /// EndCOFFSymbolDef - Marks the end of the symbol definition.
+  /// \brief Marks the end of the symbol definition.
   virtual void EndCOFFSymbolDef();
 
-  /// EmitCOFFSectionIndex - Emits a COFF section index.
+  /// \brief Emits a COFF section index.
   ///
-  /// @param Symbol - Symbol the section number relocation should point to.
+  /// \param Symbol - Symbol the section number relocation should point to.
   virtual void EmitCOFFSectionIndex(MCSymbol const *Symbol);
 
-  /// EmitCOFFSecRel32 - Emits a COFF section relative relocation.
+  /// \brief Emits a COFF section relative relocation.
   ///
-  /// @param Symbol - Symbol the section relative relocation should point to.
+  /// \param Symbol - Symbol the section relative relocation should point to.
   virtual void EmitCOFFSecRel32(MCSymbol const *Symbol);
 
-  /// EmitELFSize - Emit an ELF .size directive.
+  /// \brief Emit an ELF .size directive.
   ///
   /// This corresponds to an assembler statement such as:
   ///  .size symbol, expression
-  ///
   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value);
 
   /// \brief Emit a Linker Optimization Hint (LOH) directive.
   /// \param Args - Arguments of the LOH.
   virtual void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}
 
-  /// EmitCommonSymbol - Emit a common symbol.
+  /// \brief Emit a common symbol.
   ///
-  /// @param Symbol - The common symbol to emit.
-  /// @param Size - The size of the common symbol.
-  /// @param ByteAlignment - The alignment of the symbol if
+  /// \param Symbol - The common symbol to emit.
+  /// \param Size - The size of the common symbol.
+  /// \param ByteAlignment - The alignment of the symbol if
   /// non-zero. This must be a power of 2.
   virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                 unsigned ByteAlignment) = 0;
 
-  /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
+  /// \brief Emit a local common (.lcomm) symbol.
   ///
-  /// @param Symbol - The common symbol to emit.
-  /// @param Size - The size of the common symbol.
-  /// @param ByteAlignment - The alignment of the common symbol in bytes.
+  /// \param Symbol - The common symbol to emit.
+  /// \param Size - The size of the common symbol.
+  /// \param ByteAlignment - The alignment of the common symbol in bytes.
   virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                      unsigned ByteAlignment);
 
-  /// EmitZerofill - Emit the zerofill section and an optional symbol.
+  /// \brief Emit the zerofill section and an optional symbol.
   ///
-  /// @param Section - The zerofill section to create and or to put the symbol
-  /// @param Symbol - The zerofill symbol to emit, if non-NULL.
-  /// @param Size - The size of the zerofill symbol.
-  /// @param ByteAlignment - The alignment of the zerofill symbol if
+  /// \param Section - The zerofill section to create and or to put the symbol
+  /// \param Symbol - The zerofill symbol to emit, if non-NULL.
+  /// \param Size - The size of the zerofill symbol.
+  /// \param ByteAlignment - The alignment of the zerofill symbol if
   /// non-zero. This must be a power of 2 on some targets.
-  virtual void EmitZerofill(const MCSection *Section,
-                            MCSymbol *Symbol = nullptr, uint64_t Size = 0,
-                            unsigned ByteAlignment = 0) = 0;
+  virtual void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+                            uint64_t Size = 0, unsigned ByteAlignment = 0) = 0;
 
-  /// EmitTBSSSymbol - Emit a thread local bss (.tbss) symbol.
+  /// \brief Emit a thread local bss (.tbss) symbol.
   ///
-  /// @param Section - The thread local common section.
-  /// @param Symbol - The thread local common symbol to emit.
-  /// @param Size - The size of the symbol.
-  /// @param ByteAlignment - The alignment of the thread local common symbol
+  /// \param Section - The thread local common section.
+  /// \param Symbol - The thread local common symbol to emit.
+  /// \param Size - The size of the symbol.
+  /// \param ByteAlignment - The alignment of the thread local common symbol
   /// if non-zero.  This must be a power of 2 on some targets.
-  virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
+  virtual void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
                               uint64_t Size, unsigned ByteAlignment = 0);
 
   /// @}
-  /// @name Generating Data
+  /// \name Generating Data
   /// @{
 
-  /// EmitBytes - Emit the bytes in \p Data into the output.
+  /// \brief Emit the bytes in \p Data into the output.
   ///
   /// This is used to implement assembler directives such as .byte, .ascii,
   /// etc.
   virtual void EmitBytes(StringRef Data);
 
-  /// EmitValue - Emit the expression @p Value into the output as a native
-  /// integer of the given @p Size bytes.
+  /// \brief Emit the expression \p Value into the output as a native
+  /// integer of the given \p Size bytes.
   ///
   /// This is used to implement assembler directives such as .word, .quad,
   /// etc.
   ///
-  /// @param Value - The value to emit.
-  /// @param Size - The size of the integer (in bytes) to emit. This must
+  /// \param Value - The value to emit.
+  /// \param Size - The size of the integer (in bytes) to emit. This must
   /// match a native machine width.
-  /// @param Loc - The location of the expression for error reporting.
+  /// \param Loc - The location of the expression for error reporting.
   virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
                              const SMLoc &Loc = SMLoc());
 
   void EmitValue(const MCExpr *Value, unsigned Size,
                  const SMLoc &Loc = SMLoc());
 
-  /// EmitIntValue - Special case of EmitValue that avoids the client having
+  /// \brief Special case of EmitValue that avoids the client having
   /// to pass in a MCExpr for constant integers.
   virtual void EmitIntValue(uint64_t Value, unsigned Size);
 
@@ -554,112 +524,119 @@ public:
 
   virtual void EmitSLEB128Value(const MCExpr *Value);
 
-  /// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
-  /// client having to pass in a MCExpr for constant integers.
+  /// \brief Special case of EmitULEB128Value that avoids the client having to
+  /// pass in a MCExpr for constant integers.
   void EmitULEB128IntValue(uint64_t Value, unsigned Padding = 0);
 
-  /// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
-  /// client having to pass in a MCExpr for constant integers.
+  /// \brief Special case of EmitSLEB128Value that avoids the client having to
+  /// pass in a MCExpr for constant integers.
   void EmitSLEB128IntValue(int64_t Value);
 
-  /// EmitSymbolValue - Special case of EmitValue that avoids the client
-  /// having to pass in a MCExpr for MCSymbols.
+  /// \brief Special case of EmitValue that avoids the client having to pass in
+  /// a MCExpr for MCSymbols.
   void EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
                        bool IsSectionRelative = false);
 
-  /// EmitGPRel64Value - Emit the expression @p Value into the output as a
-  /// gprel64 (64-bit GP relative) value.
+  /// \brief Emit the expression \p Value into the output as a gprel64 (64-bit
+  /// GP relative) value.
   ///
   /// This is used to implement assembler directives such as .gpdword on
   /// targets that support them.
   virtual void EmitGPRel64Value(const MCExpr *Value);
 
-  /// EmitGPRel32Value - Emit the expression @p Value into the output as a
-  /// gprel32 (32-bit GP relative) value.
+  /// \brief Emit the expression \p Value into the output as a gprel32 (32-bit
+  /// GP relative) value.
   ///
   /// This is used to implement assembler directives such as .gprel32 on
   /// targets that support them.
   virtual void EmitGPRel32Value(const MCExpr *Value);
 
-  /// EmitFill - Emit NumBytes bytes worth of the value specified by
-  /// FillValue.  This implements directives such as '.space'.
+  /// \brief Emit NumBytes bytes worth of the value specified by FillValue.
+  /// This implements directives such as '.space'.
   virtual void EmitFill(uint64_t NumBytes, uint8_t FillValue);
 
   /// \brief Emit NumBytes worth of zeros.
   /// This function properly handles data in virtual sections.
   virtual void EmitZeros(uint64_t NumBytes);
 
-  /// EmitValueToAlignment - Emit some number of copies of @p Value until
-  /// the byte alignment @p ByteAlignment is reached.
+  /// \brief Emit some number of copies of \p Value until the byte alignment \p
+  /// ByteAlignment is reached.
   ///
   /// If the number of bytes need to emit for the alignment is not a multiple
-  /// of @p ValueSize, then the contents of the emitted fill bytes is
+  /// of \p ValueSize, then the contents of the emitted fill bytes is
   /// undefined.
   ///
   /// This used to implement the .align assembler directive.
   ///
-  /// @param ByteAlignment - The alignment to reach. This must be a power of
+  /// \param ByteAlignment - The alignment to reach. This must be a power of
   /// two on some targets.
-  /// @param Value - The value to use when filling bytes.
-  /// @param ValueSize - The size of the integer (in bytes) to emit for
-  /// @p Value. This must match a native machine width.
-  /// @param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
+  /// \param Value - The value to use when filling bytes.
+  /// \param ValueSize - The size of the integer (in bytes) to emit for
+  /// \p Value. This must match a native machine width.
+  /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
   /// the alignment cannot be reached in this many bytes, no bytes are
   /// emitted.
   virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                                     unsigned ValueSize = 1,
                                     unsigned MaxBytesToEmit = 0);
 
-  /// EmitCodeAlignment - Emit nops until the byte alignment @p ByteAlignment
-  /// is reached.
+  /// \brief Emit nops until the byte alignment \p ByteAlignment is reached.
   ///
   /// This used to align code where the alignment bytes may be executed.  This
   /// can emit different bytes for different sizes to optimize execution.
   ///
-  /// @param ByteAlignment - The alignment to reach. This must be a power of
+  /// \param ByteAlignment - The alignment to reach. This must be a power of
   /// two on some targets.
-  /// @param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
+  /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
   /// the alignment cannot be reached in this many bytes, no bytes are
   /// emitted.
   virtual void EmitCodeAlignment(unsigned ByteAlignment,
                                  unsigned MaxBytesToEmit = 0);
 
-  /// EmitValueToOffset - Emit some number of copies of @p Value until the
-  /// byte offset @p Offset is reached.
+  /// \brief Emit some number of copies of \p Value until the byte offset \p
+  /// Offset is reached.
   ///
   /// This is used to implement assembler directives such as .org.
   ///
-  /// @param Offset - The offset to reach. This may be an expression, but the
+  /// \param Offset - The offset to reach. This may be an expression, but the
   /// expression must be associated with the current section.
-  /// @param Value - The value to use when filling bytes.
-  /// @return false on success, true if the offset was invalid.
+  /// \param Value - The value to use when filling bytes.
+  /// \return false on success, true if the offset was invalid.
   virtual bool EmitValueToOffset(const MCExpr *Offset,
                                  unsigned char Value = 0);
 
   /// @}
 
-  /// EmitFileDirective - Switch to a new logical file.  This is used to
-  /// implement the '.file "foo.c"' assembler directive.
+  /// \brief Switch to a new logical file.  This is used to implement the '.file
+  /// "foo.c"' assembler directive.
   virtual void EmitFileDirective(StringRef Filename);
 
-  /// Emit the "identifiers" directive.  This implements the
+  /// \brief Emit the "identifiers" directive.  This implements the
   /// '.ident "version foo"' assembler directive.
   virtual void EmitIdent(StringRef IdentString) {}
 
-  /// EmitDwarfFileDirective - Associate a filename with a specified logical
-  /// file number.  This implements the DWARF2 '.file 4 "foo.c"' assembler
-  /// directive.
+  /// \brief Associate a filename with a specified logical file number.  This
+  /// implements the DWARF2 '.file 4 "foo.c"' assembler directive.
   virtual unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                           StringRef Filename,
                                           unsigned CUID = 0);
 
-  /// EmitDwarfLocDirective - This implements the DWARF2
-  // '.loc fileno lineno ...' assembler directive.
+  /// \brief This implements the DWARF2 '.loc fileno lineno ...' assembler
+  /// directive.
   virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                      unsigned Column, unsigned Flags,
                                      unsigned Isa, unsigned Discriminator,
                                      StringRef FileName);
 
+  /// Emit the absolute difference between two symbols if possible.
+  ///
+  /// \pre Offset of \c Hi is greater than the offset \c Lo.
+  /// \return true on success.
+  virtual bool emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
+                                      unsigned Size) {
+    return false;
+  }
+
   virtual MCSymbol *getDwarfLineTableSymbol(unsigned CUID);
   virtual void EmitCFISections(bool EH, bool Debug);
   void EmitCFIStartProc(bool IsSimple);
@@ -697,8 +674,7 @@ public:
   virtual void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except);
   virtual void EmitWinEHHandlerData();
 
-  /// EmitInstruction - Emit the given @p Instruction into the current
-  /// section.
+  /// \brief Emit the given \p Instruction into the current section.
   virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 
   /// \brief Set the bundle alignment mode from now on in the section.
@@ -715,29 +691,28 @@ public:
   /// \brief Ends a bundle-locked group.
   virtual void EmitBundleUnlock();
 
-  /// EmitRawText - If this file is backed by a assembly streamer, this dumps
-  /// the specified string in the output .s file.  This capability is
-  /// indicated by the hasRawTextSupport() predicate.  By default this aborts.
+  /// \brief If this file is backed by a assembly streamer, this dumps the
+  /// specified string in the output .s file.  This capability is indicated by
+  /// the hasRawTextSupport() predicate.  By default this aborts.
   void EmitRawText(const Twine &String);
 
-  /// Flush - Causes any cached state to be written out.
+  /// \brief Causes any cached state to be written out.
   virtual void Flush() {}
 
-  /// FinishImpl - Streamer specific finalization.
+  /// \brief Streamer specific finalization.
   virtual void FinishImpl();
-  /// Finish - Finish emission of machine code.
+  /// \brief Finish emission of machine code.
   void Finish();
 
-  virtual bool mayHaveInstructions() const { return true; }
+  virtual bool mayHaveInstructions(MCSection &Sec) const { return true; }
 };
 
-/// createNullStreamer - Create a dummy machine code streamer, which does
-/// nothing. This is useful for timing the assembler front end.
+/// Create a dummy machine code streamer, which does nothing. This is useful for
+/// timing the assembler front end.
 MCStreamer *createNullStreamer(MCContext &Ctx);
 
-/// createAsmStreamer - Create a machine code streamer which will print out
-/// assembly for the native target, suitable for compiling with a native
-/// assembler.
+/// Create a machine code streamer which will print out assembly for the native
+/// target, suitable for compiling with a native assembler.
 ///
 /// \param InstPrint - If given, the instruction printer to use. If not given
 /// the MCInst representation will be printed.  This method takes ownership of
@@ -752,26 +727,11 @@ MCStreamer *createNullStreamer(MCContext &Ctx);
 ///
 /// \param ShowInst - Whether to show the MCInst representation inline with
 /// the assembly.
-MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
+MCStreamer *createAsmStreamer(MCContext &Ctx,
+                              std::unique_ptr<formatted_raw_ostream> OS,
                               bool isVerboseAsm, bool useDwarfDirectory,
                               MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                               MCAsmBackend *TAB, bool ShowInst);
-
-/// createMachOStreamer - Create a machine code streamer which will generate
-/// Mach-O format object files.
-///
-/// Takes ownership of \p TAB and \p CE.
-MCStreamer *createMachOStreamer(MCContext &Ctx, MCAsmBackend &TAB,
-                                raw_ostream &OS, MCCodeEmitter *CE,
-                                bool RelaxAll = false,
-                                bool LabelSections = false);
-
-/// createELFStreamer - Create a machine code streamer which will generate
-/// ELF format object files.
-MCStreamer *createELFStreamer(MCContext &Ctx, MCAsmBackend &TAB,
-                              raw_ostream &OS, MCCodeEmitter *CE,
-                              bool RelaxAll);
-
 } // end namespace llvm
 
 #endif