Cleanup LLVMMC headers

[serge-sans-paille]

Summary

There's a few relevant forward declarations in there that may require downstream
adding explicit includes:

llvm/MC/MCContext.h no longer includes llvm/BinaryFormat/ELF.h, llvm/MC/MCSubtargetInfo.h, llvm/MC/MCTargetOptions.h
llvm/MC/MCObjectStreamer.h no longer include llvm/MC/MCAssembler.h
llvm/MC/MCAssembler.h no longer includes llvm/MC/MCFixup.h, llvm/MC/MCFragment.h

Counting preprocessed lines required to rebuild llvm-project on my setup:
before: 1052436830
after: 1049293745

Which is significant and backs up the change in addition to the usual benefits of
decreasing coupling between headers and compilation units.

Discourse thread: https://discourse.llvm.org/t/include-what-you-use-include-cleanup

[MaskRay]

LGTM.

llvm/include/llvm/MC/MCContext.h

48

The clang-format should be done separately.

llvm/include/llvm/MC/MCDwarf.h

33

move this below

llvm/include/llvm/MC/MCLinkerOptimizationHint.h

27

sort

llvm/include/llvm/MC/MCStreamer.h

41

Sort at least MC* declarations

llvm/lib/MC/MCAssembler.cpp

44

forward declarations are usually after using namespace llvm;

[MaskRay]

llvm/utils/TableGen/FixedLenDecoderEmitter.cpp

2405

sort

Consider committing this change separately

[rastogishubham]

Hi it seems like this change might have been responsible for the lldb incremental bot to have broken

/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/../include/c++/v1/__memory/unique_ptr.h:50:19: error: missing '#include "llvm/MC/MCSubtargetInfo.h"'; 'MCSubtargetInfo' must be defined before it is used

static_assert(sizeof(_Tp) > 0,
              ^

/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/../include/c++/v1/__memory/unique_ptr.h:315:7: note: in instantiation of member function 'std::default_delete<llvm::MCSubtargetInfo>::operator()' requested here

__ptr_.second()(__tmp);
^

/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/../include/c++/v1/__memory/unique_ptr.h:269:19: note: in instantiation of member function 'std::unique_ptr<llvm::MCSubtargetInfo>::reset' requested here

~unique_ptr() { reset(); }
                ^

/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/include/llvm/DWARFLinker/DWARFStreamer.h:46:3: note: in instantiation of member function 'std::unique_ptr<llvm::MCSubtargetInfo>::~unique_ptr' requested here

DwarfStreamer(OutputFileType OutFileType, raw_pwrite_stream &OutFile,
^

/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/include/llvm/MC/MCSubtargetInfo.h:76:7: note: definition here is not reachable
class MCSubtargetInfo {

^

/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/lib/DWARFLinker/DWARFLinkerCompileUnit.cpp:9:10: fatal error: could not build module 'LLVM_DWARFLinker'
#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"

Build is here: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/41179/

Please revert the change or fix it as soon as poosible, thanks

[MaskRay]

In D119244#3309062, @rastogishubham wrote:

Hi it seems like this change might have been responsible for the lldb incremental bot to have broken

/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/../include/c++/v1/__memory/unique_ptr.h:50:19: error: missing '#include "llvm/MC/MCSubtargetInfo.h"'; 'MCSubtargetInfo' must be defined before it is used

static_assert(sizeof(_Tp) > 0,
              ^

/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/../include/c++/v1/__memory/unique_ptr.h:315:7: note: in instantiation of member function 'std::default_delete<llvm::MCSubtargetInfo>::operator()' requested here

__ptr_.second()(__tmp);
^

/Users/buildslave/jenkins/workspace/lldb-cmake/host-compiler/bin/../include/c++/v1/__memory/unique_ptr.h:269:19: note: in instantiation of member function 'std::unique_ptr<llvm::MCSubtargetInfo>::reset' requested here

~unique_ptr() { reset(); }
                ^

/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/include/llvm/DWARFLinker/DWARFStreamer.h:46:3: note: in instantiation of member function 'std::unique_ptr<llvm::MCSubtargetInfo>::~unique_ptr' requested here

DwarfStreamer(OutputFileType OutFileType, raw_pwrite_stream &OutFile,
^

/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/include/llvm/MC/MCSubtargetInfo.h:76:7: note: definition here is not reachable
class MCSubtargetInfo {

^

/Users/buildslave/jenkins/workspace/lldb-cmake/llvm-project/llvm/lib/DWARFLinker/DWARFLinkerCompileUnit.cpp:9:10: fatal error: could not build module 'LLVM_DWARFLinker'
#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"

Build is here: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/41179/

Please revert the change or fix it as soon as poosible, thanks

Is this a LLVM_ENABLE_MODULES=on build? For regular build check-lldb builds.

I added a possibly missing header to llvm/include/llvm/DWARFLinker/DWARFStreamer.h and am building a module build to confirm.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H
 #define LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H
 
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/MC/MCExpr.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 
 class GlobalValue;
 class MachineModuleInfo;
 class MachineFunction;
 class MCContext;

llvm/include/llvm/MC/MCAsmBackend.h

 //===- llvm/MC/MCAsmBackend.h - MC Asm Backend ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCASMBACKEND_H
 #define LLVM_MC_MCASMBACKEND_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCFixup.h"
-#include "llvm/MC/MCFragment.h"
 #include "llvm/Support/Endian.h"
 #include <cstdint>
 
 namespace llvm {
 
+class MCAlignFragment;
+class MCDwarfCallFrameFragment;
+class MCDwarfLineAddrFragment;
+class MCFragment;
+class MCRelaxableFragment;
+class MCSymbol;
 class MCAsmLayout;
 class MCAssembler;
 class MCCFIInstruction;
 struct MCFixupKindInfo;
 class MCInst;
 class MCObjectStreamer;
 class MCObjectTargetWriter;
 class MCObjectWriter;
 class MCSubtargetInfo;
 class MCValue;
 class raw_pwrite_stream;
 class StringRef;
+class raw_ostream;
 
 /// Generic interface to target specific assembler backends.
 class MCAsmBackend {
 protected: // Can only create subclasses.
   MCAsmBackend(support::endianness Endian);
 
 public:
   MCAsmBackend(const MCAsmBackend &) = delete;

llvm/include/llvm/MC/MCAssembler.h

 //===- MCAssembler.h - Object File Generation -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCASSEMBLER_H
 #define LLVM_MC_MCASSEMBLER_H
 
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCDwarf.h"
-#include "llvm/MC/MCFixup.h"
-#include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/SMLoc.h"
 #include "llvm/Support/VersionTuple.h"
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
+class MCBoundaryAlignFragment;
+class MCCVDefRangeFragment;
+class MCCVInlineLineTableFragment;
+class MCDwarfCallFrameFragment;
+class MCDwarfLineAddrFragment;
+class MCEncodedFragment;
+class MCFixup;
+class MCLEBFragment;
+class MCPseudoProbeAddrFragment;
+class MCRelaxableFragment;
+class MCSymbolRefExpr;
+class raw_ostream;
 class MCAsmBackend;
 class MCAsmLayout;
 class MCContext;
 class MCCodeEmitter;
 class MCFragment;
 class MCObjectWriter;
 class MCSection;
 class MCValue;

llvm/include/llvm/MC/MCCodeView.h

 //===- MCCodeView.h - Machine Code CodeView support -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Holds state from .cv_file and .cv_loc directives for later emission.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCCODEVIEW_H
 #define LLVM_MC_MCCODEVIEW_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCFragment.h"
-#include "llvm/MC/MCObjectStreamer.h"
 #include <map>
 #include <vector>
 
 namespace llvm {
+class MCAsmLayout;
+class MCCVDefRangeFragment;
+class MCCVInlineLineTableFragment;
+class MCDataFragment;
+class MCFragment;
+class MCSection;
+class MCSymbol;
 class MCContext;
 class MCObjectStreamer;
 class MCStreamer;
-class CodeViewContext;
 
 /// Instances of this class represent the information from a
 /// .cv_loc directive.
 class MCCVLoc {
   const MCSymbol *Label = nullptr;
   uint32_t FunctionId;
   uint32_t FileNum;
   uint32_t Line;

llvm/include/llvm/MC/MCContext.h

 //===- MCContext.h - Machine Code Context -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCCONTEXT_H
 #define LLVM_MC_MCCONTEXT_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
-#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCAsmMacro.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCPseudoProbe.h"
-#include "llvm/MC/MCSubtargetInfo.h"
-#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/MC/MCSection.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
+class MCInst;
+class MCSubtargetInfo;
+class MCTargetOptions;
+template <typename T> class SmallVectorImpl;
 
-  class CodeViewContext;
-  class MCAsmInfo;
-  class MCLabel;
-  class MCObjectFileInfo;
-  class MCRegisterInfo;
-  class MCSection;
-  class MCSectionCOFF;
-  class MCSectionELF;
-  class MCSectionGOFF;
-  class MCSectionMachO;
-  class MCSectionWasm;
-  class MCSectionXCOFF;
-  class MCStreamer;
-  class MCSymbol;
-  class MCSymbolELF;
-  class MCSymbolWasm;
-  class MCSymbolXCOFF;
-  class MDNode;
-  class SMDiagnostic;
-  class SMLoc;
-  class SourceMgr;
 
-  /// Context object for machine code objects.  This class owns all of the
-  /// sections that it creates.
-  ///
-  class MCContext {
-  public:
-    using SymbolTable = StringMap<MCSymbol *, BumpPtrAllocator &>;
-    using DiagHandlerTy =
-        std::function<void(const SMDiagnostic &, bool, const SourceMgr &,
-                           std::vector<const MDNode *> &)>;
-    enum Environment { IsMachO, IsELF, IsGOFF, IsCOFF, IsWasm, IsXCOFF };
 
-  private:
-    Environment Env;
 
-    /// The name of the Segment where Swift5 Reflection Section data will be
-    /// outputted
-    StringRef Swift5ReflectionSegmentName;
 
-    /// The triple for this object.
-    Triple TT;
 
-    /// The SourceMgr for this object, if any.
-    const SourceMgr *SrcMgr;
 
-    /// The SourceMgr for inline assembly, if any.
-    std::unique_ptr<SourceMgr> InlineSrcMgr;
-    std::vector<const MDNode *> LocInfos;
 
-    DiagHandlerTy DiagHandler;
 
-    /// The MCAsmInfo for this target.
-    const MCAsmInfo *MAI;
 
-    /// The MCRegisterInfo for this target.
-    const MCRegisterInfo *MRI;
 
-    /// The MCObjectFileInfo for this target.
-    const MCObjectFileInfo *MOFI;
 
-    /// The MCSubtargetInfo for this target.
-    const MCSubtargetInfo *MSTI;
 
-    std::unique_ptr<CodeViewContext> CVContext;
 
-    /// Allocator object used for creating machine code objects.
-    ///
-    /// We use a bump pointer allocator to avoid the need to track all allocated
-    /// objects.
-    BumpPtrAllocator Allocator;
 
-    SpecificBumpPtrAllocator<MCSectionCOFF> COFFAllocator;
-    SpecificBumpPtrAllocator<MCSectionELF> ELFAllocator;
-    SpecificBumpPtrAllocator<MCSectionMachO> MachOAllocator;
-    SpecificBumpPtrAllocator<MCSectionGOFF> GOFFAllocator;
-    SpecificBumpPtrAllocator<MCSectionWasm> WasmAllocator;
-    SpecificBumpPtrAllocator<MCSectionXCOFF> XCOFFAllocator;
-    SpecificBumpPtrAllocator<MCInst> MCInstAllocator;
 
-    /// Bindings of names to symbols.
-    SymbolTable Symbols;
 
-    /// A mapping from a local label number and an instance count to a symbol.
-    /// For example, in the assembly
-    ///     1:
-    ///     2:
-    ///     1:
-    /// We have three labels represented by the pairs (1, 0), (2, 0) and (1, 1)
-    DenseMap<std::pair<unsigned, unsigned>, MCSymbol *> LocalSymbols;
 
-    /// Keeps tracks of names that were used both for used declared and
-    /// artificial symbols. The value is "true" if the name has been used for a
-    /// non-section symbol (there can be at most one of those, plus an unlimited
-    /// number of section symbols with the same name).
-    StringMap<bool, BumpPtrAllocator &> UsedNames;
 
-    /// Keeps track of labels that are used in inline assembly.
-    SymbolTable InlineAsmUsedLabelNames;
 
-    /// The next ID to dole out to an unnamed assembler temporary symbol with
-    /// a given prefix.
-    StringMap<unsigned> NextID;
 
-    /// Instances of directional local labels.
-    DenseMap<unsigned, MCLabel *> Instances;
-    /// NextInstance() creates the next instance of the directional local label
-    /// for the LocalLabelVal and adds it to the map if needed.
-    unsigned NextInstance(unsigned LocalLabelVal);
-    /// GetInstance() gets the current instance of the directional local label
-    /// for the LocalLabelVal and adds it to the map if needed.
-    unsigned GetInstance(unsigned LocalLabelVal);
 
-    /// The file name of the log file from the environment variable
-    /// AS_SECURE_LOG_FILE.  Which must be set before the .secure_log_unique
-    /// directive is used or it is an error.
-    char *SecureLogFile;
-    /// The stream that gets written to for the .secure_log_unique directive.
-    std::unique_ptr<raw_fd_ostream> SecureLog;
-    /// Boolean toggled when .secure_log_unique / .secure_log_reset is seen to
-    /// catch errors if .secure_log_unique appears twice without
-    /// .secure_log_reset appearing between them.
-    bool SecureLogUsed = false;
 
-    /// The compilation directory to use for DW_AT_comp_dir.
-    SmallString<128> CompilationDir;
 
-    /// Prefix replacement map for source file information.
-    std::map<const std::string, const std::string> DebugPrefixMap;
 
-    /// The main file name if passed in explicitly.
-    std::string MainFileName;
 
-    /// The dwarf file and directory tables from the dwarf .file directive.
-    /// We now emit a line table for each compile unit. To reduce the prologue
-    /// size of each line table, the files and directories used by each compile
-    /// unit are separated.
-    std::map<unsigned, MCDwarfLineTable> MCDwarfLineTablesCUMap;
 
-    /// The current dwarf line information from the last dwarf .loc directive.
-    MCDwarfLoc CurrentDwarfLoc;
-    bool DwarfLocSeen = false;
 
-    /// Generate dwarf debugging info for assembly source files.
-    bool GenDwarfForAssembly = false;
 
-    /// The current dwarf file number when generate dwarf debugging info for
-    /// assembly source files.
-    unsigned GenDwarfFileNumber = 0;
 
-    /// Sections for generating the .debug_ranges and .debug_aranges sections.
-    SetVector<MCSection *> SectionsForRanges;
 
-    /// The information gathered from labels that will have dwarf label
-    /// entries when generating dwarf assembly source files.
-    std::vector<MCGenDwarfLabelEntry> MCGenDwarfLabelEntries;
 
-    /// The string to embed in the debug information for the compile unit, if
-    /// non-empty.
-    StringRef DwarfDebugFlags;
 
-    /// The string to embed in as the dwarf AT_producer for the compile unit, if
-    /// non-empty.
-    StringRef DwarfDebugProducer;
 
-    /// The maximum version of dwarf that we should emit.
-    uint16_t DwarfVersion = 4;
 
-    /// The format of dwarf that we emit.
-    dwarf::DwarfFormat DwarfFormat = dwarf::DWARF32;
 
-    /// Honor temporary labels, this is useful for debugging semantic
-    /// differences between temporary and non-temporary labels (primarily on
-    /// Darwin).
-    bool AllowTemporaryLabels = true;
-    bool UseNamesOnTempLabels = false;
 
-    /// The Compile Unit ID that we are currently processing.
-    unsigned DwarfCompileUnitID = 0;
 
-    /// A collection of MCPseudoProbe in the current module
-    MCPseudoProbeTable PseudoProbeTable;
 
-    // Sections are differentiated by the quadruple (section_name, group_name,
-    // unique_id, link_to_symbol_name). Sections sharing the same quadruple are
-    // combined into one section.
-    struct ELFSectionKey {
-      std::string SectionName;
-      StringRef GroupName;
-      StringRef LinkedToName;
-      unsigned UniqueID;
 
-      ELFSectionKey(StringRef SectionName, StringRef GroupName,
-                    StringRef LinkedToName, unsigned UniqueID)
-          : SectionName(SectionName), GroupName(GroupName),
-            LinkedToName(LinkedToName), UniqueID(UniqueID) {}
 
-      bool operator<(const ELFSectionKey &Other) const {
-        if (SectionName != Other.SectionName)
-          return SectionName < Other.SectionName;
-        if (GroupName != Other.GroupName)
-          return GroupName < Other.GroupName;
-        if (int O = LinkedToName.compare(Other.LinkedToName))
-          return O < 0;
-        return UniqueID < Other.UniqueID;
-      }
-    };
 
-    struct COFFSectionKey {
-      std::string SectionName;
-      StringRef GroupName;
-      int SelectionKey;
-      unsigned UniqueID;
 
-      COFFSectionKey(StringRef SectionName, StringRef GroupName,
-                     int SelectionKey, unsigned UniqueID)
-          : SectionName(SectionName), GroupName(GroupName),
-            SelectionKey(SelectionKey), UniqueID(UniqueID) {}
+    COFFSectionKey(StringRef SectionName, StringRef GroupName, int SelectionKey,
+                   unsigned UniqueID)
 
-      bool operator<(const COFFSectionKey &Other) const {
-        if (SectionName != Other.SectionName)
-          return SectionName < Other.SectionName;
-        if (GroupName != Other.GroupName)
-          return GroupName < Other.GroupName;
-        if (SelectionKey != Other.SelectionKey)
-          return SelectionKey < Other.SelectionKey;
-        return UniqueID < Other.UniqueID;
-      }
-    };
 
-    struct WasmSectionKey {
-      std::string SectionName;
-      StringRef GroupName;
-      unsigned UniqueID;
 
-      WasmSectionKey(StringRef SectionName, StringRef GroupName,
-                     unsigned UniqueID)
-          : SectionName(SectionName), GroupName(GroupName), UniqueID(UniqueID) {
-      }
+        : SectionName(SectionName), GroupName(GroupName), UniqueID(UniqueID) {}
 
-      bool operator<(const WasmSectionKey &Other) const {
-        if (SectionName != Other.SectionName)
-          return SectionName < Other.SectionName;
-        if (GroupName != Other.GroupName)
-          return GroupName < Other.GroupName;
-        return UniqueID < Other.UniqueID;
-      }
-    };
 
-    struct XCOFFSectionKey {
-      // Section name.
-      std::string SectionName;
-      // Section property.
-      // For csect section, it is storage mapping class.
-      // For debug section, it is section type flags.
-      union {
-        XCOFF::StorageMappingClass MappingClass;
-        XCOFF::DwarfSectionSubtypeFlags DwarfSubtypeFlags;
-      };
-      bool IsCsect;
 
-      XCOFFSectionKey(StringRef SectionName,
-                      XCOFF::StorageMappingClass MappingClass)
-          : SectionName(SectionName), MappingClass(MappingClass),
-            IsCsect(true) {}
+        : SectionName(SectionName), MappingClass(MappingClass), IsCsect(true) {}
 
-      XCOFFSectionKey(StringRef SectionName,
-                      XCOFF::DwarfSectionSubtypeFlags DwarfSubtypeFlags)
-          : SectionName(SectionName), DwarfSubtypeFlags(DwarfSubtypeFlags),
-            IsCsect(false) {}
 
-      bool operator<(const XCOFFSectionKey &Other) const {
-        if (IsCsect && Other.IsCsect)
-          return std::tie(SectionName, MappingClass) <
-                 std::tie(Other.SectionName, Other.MappingClass);
-        if (IsCsect != Other.IsCsect)
-          return IsCsect;
-        return std::tie(SectionName, DwarfSubtypeFlags) <
-               std::tie(Other.SectionName, Other.DwarfSubtypeFlags);
-      }
-    };
 
-    StringMap<MCSectionMachO *> MachOUniquingMap;
-    std::map<ELFSectionKey, MCSectionELF *> ELFUniquingMap;
-    std::map<COFFSectionKey, MCSectionCOFF *> COFFUniquingMap;
-    std::map<std::string, MCSectionGOFF *> GOFFUniquingMap;
-    std::map<WasmSectionKey, MCSectionWasm *> WasmUniquingMap;
-    std::map<XCOFFSectionKey, MCSectionXCOFF *> XCOFFUniquingMap;
-    StringMap<bool> RelSecNames;
 
-    SpecificBumpPtrAllocator<MCSubtargetInfo> MCSubtargetAllocator;
 
-    /// Do automatic reset in destructor
-    bool AutoReset;
 
-    MCTargetOptions const *TargetOptions;
 
-    bool HadError = false;
 
-    void reportCommon(SMLoc Loc,
-                      std::function<void(SMDiagnostic &, const SourceMgr *)>);
 
-    MCSymbol *createSymbolImpl(const StringMapEntry<bool> *Name,
-                               bool CanBeUnnamed);
-    MCSymbol *createSymbol(StringRef Name, bool AlwaysAddSuffix,
-                           bool IsTemporary);
 
-    MCSymbol *getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
-                                                unsigned Instance);
 
-    MCSectionELF *createELFSectionImpl(StringRef Section, unsigned Type,
-                                       unsigned Flags, SectionKind K,
-                                       unsigned EntrySize,
-                                       const MCSymbolELF *Group, bool IsComdat,
-                                       unsigned UniqueID,
-                                       const MCSymbolELF *LinkedToSym);
 
-    MCSymbolXCOFF *createXCOFFSymbolImpl(const StringMapEntry<bool> *Name,
-                                         bool IsTemporary);
 
-    /// Map of currently defined macros.
-    StringMap<MCAsmMacro> MacroMap;
 
-    struct ELFEntrySizeKey {
-      std::string SectionName;
-      unsigned Flags;
-      unsigned EntrySize;
 
-      ELFEntrySizeKey(StringRef SectionName, unsigned Flags, unsigned EntrySize)
-          : SectionName(SectionName), Flags(Flags), EntrySize(EntrySize) {}
 
-      bool operator<(const ELFEntrySizeKey &Other) const {
-        if (SectionName != Other.SectionName)
-          return SectionName < Other.SectionName;
-        if (Flags != Other.Flags)
-          return Flags < Other.Flags;
-        return EntrySize < Other.EntrySize;
-      }
-    };
 
-    // Symbols must be assigned to a section with a compatible entry size and
-    // flags. This map is used to assign unique IDs to sections to distinguish
-    // between sections with identical names but incompatible entry sizes and/or
-    // flags. This can occur when a symbol is explicitly assigned to a section,
-    // e.g. via __attribute__((section("myname"))).
-    std::map<ELFEntrySizeKey, unsigned> ELFEntrySizeMap;
 
-    // This set is used to record the generic mergeable section names seen.
-    // These are sections that are created as mergeable e.g. .debug_str. We need
-    // to avoid assigning non-mergeable symbols to these sections. It is used
-    // to prevent non-mergeable symbols being explicitly assigned  to mergeable
-    // sections (e.g. via _attribute_((section("myname")))).
-    DenseSet<StringRef> ELFSeenGenericMergeableSections;
 
-  public:
-    explicit MCContext(const Triple &TheTriple, const MCAsmInfo *MAI,
-                       const MCRegisterInfo *MRI, const MCSubtargetInfo *MSTI,
-                       const SourceMgr *Mgr = nullptr,
-                       MCTargetOptions const *TargetOpts = nullptr,
-                       bool DoAutoReset = true,
-                       StringRef Swift5ReflSegmentName = {});
-    MCContext(const MCContext &) = delete;
-    MCContext &operator=(const MCContext &) = delete;
-    ~MCContext();
 
-    Environment getObjectFileType() const { return Env; }
 
-    const StringRef &getSwift5ReflectionSegmentName() const {
-      return Swift5ReflectionSegmentName;
-    }
-    const Triple &getTargetTriple() const { return TT; }
-    const SourceMgr *getSourceManager() const { return SrcMgr; }
 
-    void initInlineSourceManager();
-    SourceMgr *getInlineSourceManager() {
-      return InlineSrcMgr.get();
-    }
-    std::vector<const MDNode *> &getLocInfos() { return LocInfos; }
-    void setDiagnosticHandler(DiagHandlerTy DiagHandler) {
-      this->DiagHandler = DiagHandler;
-    }
+  SourceMgr *getInlineSourceManager() { return InlineSrcMgr.get(); }
 
-    void setObjectFileInfo(const MCObjectFileInfo *Mofi) { MOFI = Mofi; }
 
-    const MCAsmInfo *getAsmInfo() const { return MAI; }
 
-    const MCRegisterInfo *getRegisterInfo() const { return MRI; }
 
-    const MCObjectFileInfo *getObjectFileInfo() const { return MOFI; }
 
-    const MCSubtargetInfo *getSubtargetInfo() const { return MSTI; }
 
-    CodeViewContext &getCVContext();
 
-    void setAllowTemporaryLabels(bool Value) { AllowTemporaryLabels = Value; }
-    void setUseNamesOnTempLabels(bool Value) { UseNamesOnTempLabels = Value; }
 
-    /// \name Module Lifetime Management
-    /// @{
 
-    /// reset - return object to right after construction state to prepare
-    /// to process a new module
-    void reset();
 
-    /// @}
 
-    /// \name McInst Management
 
-    /// Create and return a new MC instruction.
-    MCInst *createMCInst();
 
-    /// \name Symbol Management
-    /// @{
 
-    /// Create and return a new linker temporary symbol with a unique but
-    /// unspecified name.
-    MCSymbol *createLinkerPrivateTempSymbol();
 
-    /// Create a temporary symbol with a unique name. The name will be omitted
-    /// in the symbol table if UseNamesOnTempLabels is false (default except
-    /// MCAsmStreamer). The overload without Name uses an unspecified name.
-    MCSymbol *createTempSymbol();
-    MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix = true);
 
-    /// Create a temporary symbol with a unique name whose name cannot be
-    /// omitted in the symbol table. This is rarely used.
-    MCSymbol *createNamedTempSymbol();
-    MCSymbol *createNamedTempSymbol(const Twine &Name);
 
-    /// Create the definition of a directional local symbol for numbered label
-    /// (used for "1:" definitions).
-    MCSymbol *createDirectionalLocalSymbol(unsigned LocalLabelVal);
 
-    /// Create and return a directional local symbol for numbered label (used
-    /// for "1b" or 1f" references).
-    MCSymbol *getDirectionalLocalSymbol(unsigned LocalLabelVal, bool Before);
 
-    /// Lookup the symbol inside with the specified \p Name.  If it exists,
-    /// return it.  If not, create a forward reference and return it.
-    ///
-    /// \param Name - The symbol name, which must be unique across all symbols.
-    MCSymbol *getOrCreateSymbol(const Twine &Name);
 
-    /// Gets a symbol that will be defined to the final stack offset of a local
-    /// variable after codegen.
-    ///
-    /// \param Idx - The index of a local variable passed to \@llvm.localescape.
-    MCSymbol *getOrCreateFrameAllocSymbol(StringRef FuncName, unsigned Idx);
 
-    MCSymbol *getOrCreateParentFrameOffsetSymbol(StringRef FuncName);
 
-    MCSymbol *getOrCreateLSDASymbol(StringRef FuncName);
 
-    /// Get the symbol for \p Name, or null.
-    MCSymbol *lookupSymbol(const Twine &Name) const;
 
-    /// Set value for a symbol.
-    void setSymbolValue(MCStreamer &Streamer, StringRef Sym, uint64_t Val);
 
-    /// getSymbols - Get a reference for the symbol table for clients that
-    /// want to, for example, iterate over all symbols. 'const' because we
-    /// still want any modifications to the table itself to use the MCContext
-    /// APIs.
-    const SymbolTable &getSymbols() const { return Symbols; }
 
-    /// isInlineAsmLabel - Return true if the name is a label referenced in
-    /// inline assembly.
-    MCSymbol *getInlineAsmLabel(StringRef Name) const {
-      return InlineAsmUsedLabelNames.lookup(Name);
-    }
 
-    /// registerInlineAsmLabel - Records that the name is a label referenced in
-    /// inline assembly.
-    void registerInlineAsmLabel(MCSymbol *Sym);
 
-    /// @}
 
-    /// \name Section Management
-    /// @{
 
-    enum : unsigned {
-      /// Pass this value as the UniqueID during section creation to get the
-      /// generic section with the given name and characteristics. The usual
-      /// sections such as .text use this ID.
-      GenericSectionID = ~0U
-    };
 
-    /// Return the MCSection for the specified mach-o section.  This requires
-    /// the operands to be valid.
-    MCSectionMachO *getMachOSection(StringRef Segment, StringRef Section,
-                                    unsigned TypeAndAttributes,
-                                    unsigned Reserved2, SectionKind K,
-                                    const char *BeginSymName = nullptr);
 
-    MCSectionMachO *getMachOSection(StringRef Segment, StringRef Section,
-                                    unsigned TypeAndAttributes, SectionKind K,
-                                    const char *BeginSymName = nullptr) {
-      return getMachOSection(Segment, Section, TypeAndAttributes, 0, K,
-                             BeginSymName);
-    }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags) {
-      return getELFSection(Section, Type, Flags, 0, "", false);
-    }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize) {
-      return getELFSection(Section, Type, Flags, EntrySize, "", false,
-                           MCSection::NonUniqueID, nullptr);
-    }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const Twine &Group, bool IsComdat) {
-      return getELFSection(Section, Type, Flags, EntrySize, Group, IsComdat,
-                           MCSection::NonUniqueID, nullptr);
-    }
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const Twine &Group, bool IsComdat,
-                                unsigned UniqueID,
-                                const MCSymbolELF *LinkedToSym);
 
-    MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
-                                unsigned Flags, unsigned EntrySize,
-                                const MCSymbolELF *Group, bool IsComdat,
-                                unsigned UniqueID,
-                                const MCSymbolELF *LinkedToSym);
 
-    /// Get a section with the provided group identifier. This section is
-    /// named by concatenating \p Prefix with '.' then \p Suffix. The \p Type
-    /// describes the type of the section and \p Flags are used to further
-    /// configure this named section.
-    MCSectionELF *getELFNamedSection(const Twine &Prefix, const Twine &Suffix,
-                                     unsigned Type, unsigned Flags,
-                                     unsigned EntrySize = 0);
 
-    MCSectionELF *createELFRelSection(const Twine &Name, unsigned Type,
-                                      unsigned Flags, unsigned EntrySize,
-                                      const MCSymbolELF *Group,
-                                      const MCSectionELF *RelInfoSection);
 
-    void renameELFSection(MCSectionELF *Section, StringRef Name);
 
-    MCSectionELF *createELFGroupSection(const MCSymbolELF *Group,
-                                        bool IsComdat);
+  MCSectionELF *createELFGroupSection(const MCSymbolELF *Group, bool IsComdat);
 
-    void recordELFMergeableSectionInfo(StringRef SectionName, unsigned Flags,
-                                       unsigned UniqueID, unsigned EntrySize);
 
-    bool isELFImplicitMergeableSectionNamePrefix(StringRef Name);
 
-    bool isELFGenericMergeableSection(StringRef Name);
 
-    /// Return the unique ID of the section with the given name, flags and entry
-    /// size, if it exists.
-    Optional<unsigned> getELFUniqueIDForEntsize(StringRef SectionName,
-                                                unsigned Flags,
-                                                unsigned EntrySize);
 
-    MCSectionGOFF *getGOFFSection(StringRef Section, SectionKind Kind);
 
-    MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
-                                  SectionKind Kind, StringRef COMDATSymName,
-                                  int Selection,
-                                  unsigned UniqueID = GenericSectionID,
-                                  const char *BeginSymName = nullptr);
 
-    MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
-                                  SectionKind Kind,
-                                  const char *BeginSymName = nullptr);
 
-    /// Gets or creates a section equivalent to Sec that is associated with the
-    /// section containing KeySym. For example, to create a debug info section
-    /// associated with an inline function, pass the normal debug info section
-    /// as Sec and the function symbol as KeySym.
-    MCSectionCOFF *
-    getAssociativeCOFFSection(MCSectionCOFF *Sec, const MCSymbol *KeySym,
-                              unsigned UniqueID = GenericSectionID);
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  unsigned Flags = 0) {
-      return getWasmSection(Section, K, Flags, nullptr);
-    }
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  unsigned Flags, const char *BeginSymName) {
-      return getWasmSection(Section, K, Flags, "", ~0, BeginSymName);
-    }
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  unsigned Flags, const Twine &Group,
-                                  unsigned UniqueID) {
-      return getWasmSection(Section, K, Flags, Group, UniqueID, nullptr);
-    }
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  unsigned Flags, const Twine &Group,
-                                  unsigned UniqueID, const char *BeginSymName);
 
-    MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
-                                  unsigned Flags, const MCSymbolWasm *Group,
-                                  unsigned UniqueID, const char *BeginSymName);
 
-    bool hasXCOFFSection(StringRef Section,
-                         XCOFF::CsectProperties CsectProp) const;
 
-    MCSectionXCOFF *getXCOFFSection(
-        StringRef Section, SectionKind K,
-        Optional<XCOFF::CsectProperties> CsectProp = None,
-        bool MultiSymbolsAllowed = false, const char *BeginSymName = nullptr,
-        Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSubtypeFlags = None);
 
-    // Create and save a copy of STI and return a reference to the copy.
-    MCSubtargetInfo &getSubtargetCopy(const MCSubtargetInfo &STI);
 
-    /// @}
 
-    /// \name Dwarf Management
-    /// @{
 
-    /// Get the compilation directory for DW_AT_comp_dir
-    /// The compilation directory should be set with \c setCompilationDir before
-    /// calling this function. If it is unset, an empty string will be returned.
-    StringRef getCompilationDir() const { return CompilationDir; }
 
-    /// Set the compilation directory for DW_AT_comp_dir
-    void setCompilationDir(StringRef S) { CompilationDir = S.str(); }
 
-    /// Add an entry to the debug prefix map.
-    void addDebugPrefixMapEntry(const std::string &From, const std::string &To);
 
-    // Remaps all debug directory paths in-place as per the debug prefix map.
-    void RemapDebugPaths();
 
-    /// Get the main file name for use in error messages and debug
-    /// info. This can be set to ensure we've got the correct file name
-    /// after preprocessing or for -save-temps.
-    const std::string &getMainFileName() const { return MainFileName; }
 
-    /// Set the main file name and override the default.
-    void setMainFileName(StringRef S) { MainFileName = std::string(S); }
 
-    /// Creates an entry in the dwarf file and directory tables.
-    Expected<unsigned> getDwarfFile(StringRef Directory, StringRef FileName,
-                                    unsigned FileNumber,
-                                    Optional<MD5::MD5Result> Checksum,
-                                    Optional<StringRef> Source, unsigned CUID);
 
-    bool isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID = 0);
 
-    const std::map<unsigned, MCDwarfLineTable> &getMCDwarfLineTables() const {
-      return MCDwarfLineTablesCUMap;
-    }
 
-    MCDwarfLineTable &getMCDwarfLineTable(unsigned CUID) {
-      return MCDwarfLineTablesCUMap[CUID];
-    }
 
-    const MCDwarfLineTable &getMCDwarfLineTable(unsigned CUID) const {
-      auto I = MCDwarfLineTablesCUMap.find(CUID);
-      assert(I != MCDwarfLineTablesCUMap.end());
-      return I->second;
-    }
 
-    const SmallVectorImpl<MCDwarfFile> &getMCDwarfFiles(unsigned CUID = 0) {
-      return getMCDwarfLineTable(CUID).getMCDwarfFiles();
-    }
 
-    const SmallVectorImpl<std::string> &getMCDwarfDirs(unsigned CUID = 0) {
-      return getMCDwarfLineTable(CUID).getMCDwarfDirs();
-    }
 
-    unsigned getDwarfCompileUnitID() { return DwarfCompileUnitID; }
 
-    void setDwarfCompileUnitID(unsigned CUIndex) {
-      DwarfCompileUnitID = CUIndex;
-    }
+  void setDwarfCompileUnitID(unsigned CUIndex) { DwarfCompileUnitID = CUIndex; }
 
-    /// Specifies the "root" file and directory of the compilation unit.
-    /// These are "file 0" and "directory 0" in DWARF v5.
-    void setMCLineTableRootFile(unsigned CUID, StringRef CompilationDir,
-                                StringRef Filename,
-                                Optional<MD5::MD5Result> Checksum,
-                                Optional<StringRef> Source) {
-      getMCDwarfLineTable(CUID).setRootFile(CompilationDir, Filename, Checksum,
-                                            Source);
-    }
 
-    /// Reports whether MD5 checksum usage is consistent (all-or-none).
-    bool isDwarfMD5UsageConsistent(unsigned CUID) const {
-      return getMCDwarfLineTable(CUID).isMD5UsageConsistent();
-    }
 
-    /// Saves the information from the currently parsed dwarf .loc directive
-    /// and sets DwarfLocSeen.  When the next instruction is assembled an entry
-    /// in the line number table with this information and the address of the
-    /// instruction will be created.
-    void setCurrentDwarfLoc(unsigned FileNum, unsigned Line, unsigned Column,
-                            unsigned Flags, unsigned Isa,
-                            unsigned Discriminator) {
-      CurrentDwarfLoc.setFileNum(FileNum);
-      CurrentDwarfLoc.setLine(Line);
-      CurrentDwarfLoc.setColumn(Column);
-      CurrentDwarfLoc.setFlags(Flags);
-      CurrentDwarfLoc.setIsa(Isa);
-      CurrentDwarfLoc.setDiscriminator(Discriminator);
-      DwarfLocSeen = true;
-    }
 
-    void clearDwarfLocSeen() { DwarfLocSeen = false; }
 
-    bool getDwarfLocSeen() { return DwarfLocSeen; }
-    const MCDwarfLoc &getCurrentDwarfLoc() { return CurrentDwarfLoc; }
 
-    bool getGenDwarfForAssembly() { return GenDwarfForAssembly; }
-    void setGenDwarfForAssembly(bool Value) { GenDwarfForAssembly = Value; }
-    unsigned getGenDwarfFileNumber() { return GenDwarfFileNumber; }
 
-    void setGenDwarfFileNumber(unsigned FileNumber) {
-      GenDwarfFileNumber = FileNumber;
-    }
 
-    /// Specifies information about the "root file" for assembler clients
-    /// (e.g., llvm-mc). Assumes compilation dir etc. have been set up.
-    void setGenDwarfRootFile(StringRef FileName, StringRef Buffer);
 
-    const SetVector<MCSection *> &getGenDwarfSectionSyms() {
-      return SectionsForRanges;
-    }
 
-    bool addGenDwarfSection(MCSection *Sec) {
-      return SectionsForRanges.insert(Sec);
-    }
 
-    void finalizeDwarfSections(MCStreamer &MCOS);
 
-    const std::vector<MCGenDwarfLabelEntry> &getMCGenDwarfLabelEntries() const {
-      return MCGenDwarfLabelEntries;
-    }
 
-    void addMCGenDwarfLabelEntry(const MCGenDwarfLabelEntry &E) {
-      MCGenDwarfLabelEntries.push_back(E);
-    }
 
-    void setDwarfDebugFlags(StringRef S) { DwarfDebugFlags = S; }
-    StringRef getDwarfDebugFlags() { return DwarfDebugFlags; }
 
-    void setDwarfDebugProducer(StringRef S) { DwarfDebugProducer = S; }
-    StringRef getDwarfDebugProducer() { return DwarfDebugProducer; }
 
-    void setDwarfFormat(dwarf::DwarfFormat f) { DwarfFormat = f; }
-    dwarf::DwarfFormat getDwarfFormat() const { return DwarfFormat; }
 
-    void setDwarfVersion(uint16_t v) { DwarfVersion = v; }
-    uint16_t getDwarfVersion() const { return DwarfVersion; }
 
-    /// @}
 
-    char *getSecureLogFile() { return SecureLogFile; }
-    raw_fd_ostream *getSecureLog() { return SecureLog.get(); }
 
-    void setSecureLog(std::unique_ptr<raw_fd_ostream> Value) {
-      SecureLog = std::move(Value);
-    }
 
-    bool getSecureLogUsed() { return SecureLogUsed; }
-    void setSecureLogUsed(bool Value) { SecureLogUsed = Value; }
 
-    void *allocate(unsigned Size, unsigned Align = 8) {
-      return Allocator.Allocate(Size, Align);
-    }
 
-    void deallocate(void *Ptr) {}
 
-    bool hadError() { return HadError; }
-    void diagnose(const SMDiagnostic &SMD);
-    void reportError(SMLoc L, const Twine &Msg);
-    void reportWarning(SMLoc L, const Twine &Msg);
 
-    const MCAsmMacro *lookupMacro(StringRef Name) {
-      StringMap<MCAsmMacro>::iterator I = MacroMap.find(Name);
-      return (I == MacroMap.end()) ? nullptr : &I->getValue();
-    }
 
-    void defineMacro(StringRef Name, MCAsmMacro Macro) {
-      MacroMap.insert(std::make_pair(Name, std::move(Macro)));
-    }
 
-    void undefineMacro(StringRef Name) { MacroMap.erase(Name); }
 
-    MCPseudoProbeTable &getMCPseudoProbeTable() { return PseudoProbeTable; }
-  };
 
 } // end namespace llvm
 
 // operator new and delete aren't allowed inside namespaces.
 // The throw specifications are mandated by the standard.
 /// Placement new for using the MCContext's allocator.
 ///
 /// This placement form of operator new uses the MCContext's allocator for

llvm/include/llvm/MC/MCDwarf.h

 #ifndef LLVM_MC_MCDWARF_H
 #define LLVM_MC_MCDWARF_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCSection.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MD5.h"
 #include <cassert>
 #include <cstdint>
 #include <string>
-#include <tuple>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
+class MCSection;
+
 template <typename T> class ArrayRef;
 class MCAsmBackend;
 class MCContext;
 class MCObjectStreamer;
 class MCStreamer;
 class MCSymbol;
 class raw_ostream;
 class SMLoc;

llvm/include/llvm/MC/MCELFStreamer.h

 //===- MCELFStreamer.h - MCStreamer ELF Object File Interface ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCELFSTREAMER_H
 #define LLVM_MC_MCELFSTREAMER_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCObjectStreamer.h"
 
 namespace llvm {
 
+class MCContext;
+class MCDataFragment;
+class MCFragment;
+class MCObjectWriter;
+class MCSection;
+class MCSubtargetInfo;
+class MCSymbol;
+class MCSymbolRefExpr;
 class MCAsmBackend;
 class MCCodeEmitter;
 class MCExpr;
 class MCInst;
 
 class MCELFStreamer : public MCObjectStreamer {
 public:
   MCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,

llvm/include/llvm/MC/MCFragment.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/Alignment.h"
-#include "llvm/Support/Casting.h"
 #include "llvm/Support/SMLoc.h"
 #include <cstdint>
 #include <utility>
 
 namespace llvm {
 
 class MCSection;
 class MCSubtargetInfo;

llvm/include/llvm/MC/MCInstrAnalysis.h

 //===- llvm/MC/MCInstrAnalysis.h - InstrDesc target hooks -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the MCInstrAnalysis class which the MCTargetDescs can
 // derive from to give additional information to MC.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCINSTRANALYSIS_H
 #define LLVM_MC_MCINSTRANALYSIS_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include <cstdint>
+#include <vector>
 
 namespace llvm {
 
 class MCRegisterInfo;
 class Triple;
 
 class MCInstrAnalysis {
 protected:

llvm/include/llvm/MC/MCInstrDesc.h

 //===-- llvm/MC/MCInstrDesc.h - Instruction Descriptors -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the MCOperandInfo and MCInstrDesc classes, which
 // are used to describe target instructions and their operands.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCINSTRDESC_H
 #define LLVM_MC_MCINSTRDESC_H
 
-#include "llvm/MC/MCRegisterInfo.h"
-#include "llvm/Support/DataTypes.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/MC/MCRegister.h"
 
 namespace llvm {
+class MCRegisterInfo;
 
 class MCInst;
 
 //===----------------------------------------------------------------------===//
 // Machine Operand Flags and Description
 //===----------------------------------------------------------------------===//
 
 namespace MCOI {

llvm/include/llvm/MC/MCInstrInfo.h

 //===-- llvm/MC/MCInstrInfo.h - Target Instruction Info ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file describes the target machine instruction set.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCINSTRINFO_H
 #define LLVM_MC_MCINSTRINFO_H
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include <cassert>
 
 namespace llvm {
 
 class MCSubtargetInfo;
 
 //---------------------------------------------------------------------------

llvm/include/llvm/MC/MCLinkerOptimizationHint.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCLINKEROPTIMIZATIONHINT_H
 #define LLVM_MC_MCLINKEROPTIMIZATIONHINT_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 
 namespace llvm {
 
+class raw_ostream;
 class MachObjectWriter;
 class MCAsmLayout;
 class MCSymbol;
 
 /// Linker Optimization Hint Type.
 enum MCLOHType {
   MCLOH_AdrpAdrp = 0x1u,      ///< Adrp xY, _v1@PAGE -> Adrp xY, _v2@PAGE.
   MCLOH_AdrpLdr = 0x2u,       ///< Adrp _v@PAGE -> Ldr _v@PAGEOFF.

llvm/include/llvm/MC/MCObjectFileInfo.h

 //===-- llvm/MC/MCObjectFileInfo.h - Object File Info -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file describes common object file formats.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCOBJECTFILEINFO_H
 #define LLVM_MC_MCOBJECTFILEINFO_H
 
-#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/Swift.h"
-#include "llvm/MC/MCSymbol.h"
-#include "llvm/Support/CodeGen.h"
 #include "llvm/Support/VersionTuple.h"
 
+#include <array>
+
 namespace llvm {
 class MCContext;
 class MCSection;
 
 class MCObjectFileInfo {
 protected:
   /// True if .comm supports alignment.  This is a hack for as long as we
   /// support 10.4 Tiger, whose assembler doesn't support alignment on comm.

llvm/include/llvm/MC/MCObjectStreamer.h

 //===- MCObjectStreamer.h - MCStreamer Object File Interface ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCOBJECTSTREAMER_H
 #define LLVM_MC_MCOBJECTSTREAMER_H
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCFixup.h"
+#include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 
 namespace llvm {
+class MCContext;
+class MCInst;
+class MCObjectWriter;
+class MCSymbol;
+struct MCDwarfFrameInfo;
 class MCAssembler;
 class MCCodeEmitter;
 class MCSubtargetInfo;
 class MCExpr;
 class MCFragment;
 class MCDataFragment;
 class MCAsmBackend;
 class raw_ostream;

llvm/include/llvm/MC/MCPseudoProbe.h

struct MCPseudoProbeFuncDesc {
   std::string FuncName;
 
   MCPseudoProbeFuncDesc(uint64_t GUID, uint64_t Hash, StringRef Name)
       : FuncGUID(GUID), FuncHash(Hash), FuncName(Name){};
 
   void print(raw_ostream &OS);
 };
 
-class MCPseudoProbe;
 class MCDecodedPseudoProbe;
 
 // An inline frame has the form <Guid, ProbeID>
 using InlineSite = std::tuple<uint64_t, uint32_t>;
 using MCPseudoProbeInlineStack = SmallVector<InlineSite, 8>;
 // GUID to PseudoProbeFuncDesc map
 using GUIDProbeFunctionMap =
     std::unordered_map<uint64_t, MCPseudoProbeFuncDesc>;
 // Address to pseudo probes map.
 using AddressProbesMap =
     std::unordered_map<uint64_t, std::list<MCDecodedPseudoProbe>>;
 
-class MCPseudoProbeInlineTree;
 class MCDecodedPseudoProbeInlineTree;
 
 class MCPseudoProbeBase {
 protected:
   uint64_t Guid;
   uint64_t Index;
   uint8_t Attributes;
   uint8_t Type;

llvm/include/llvm/MC/MCSectionELF.h

 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/SectionKind.h"
 
 namespace llvm {
 
-class MCSymbol;
-
 /// This represents a section on linux, lots of unix variants and some bare
 /// metal systems.
 class MCSectionELF final : public MCSection {
   /// This is the sh_type field of a section, drawn from the enums below.
   unsigned Type;
 
   /// This is the sh_flags field of a section, drawn from the enums below.
   unsigned Flags;

llvm/include/llvm/MC/MCStreamer.h

 //===- MCStreamer.h - High-level Streaming Machine Code Output --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the MCStreamer class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCSTREAMER_H
 #define LLVM_MC_MCSTREAMER_H
 
-#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
+#include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCPseudoProbe.h"
-#include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWinEH.h"
+#include "llvm/Support/ARMTargetParser.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/SMLoc.h"
-#include "llvm/Support/ARMTargetParser.h"
-#include "llvm/Support/TargetParser.h"
 #include "llvm/Support/VersionTuple.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
+class APInt;
+class MCAssembler;
+class MCFragment;
+class MCSymbol;
+class Triple;
 class AssemblerConstantPools;
 class MCAsmBackend;
 class MCContext;
-struct MCDwarfFrameInfo;
 class MCExpr;
 class MCInst;
 class MCInstPrinter;
 class MCRegister;
 class MCSection;
 class MCStreamer;
 class MCSymbolRefExpr;
 class MCSubtargetInfo;

llvm/include/llvm/MC/MCSubtargetInfo.h

 //===- llvm/MC/MCSubtargetInfo.h - Subtarget Information --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file describes the subtarget options of a Target machine.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCSUBTARGETINFO_H
 #define LLVM_MC_MCSUBTARGETINFO_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCInstrItineraries.h"
 #include "llvm/MC/MCSchedule.h"
 #include "llvm/MC/SubtargetFeature.h"
-#include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <string>
 
 namespace llvm {
 
 class MCInst;
 

llvm/include/llvm/MC/MCSymbol.h

 //===- MCSymbol.h - Machine Code Symbols ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the declaration of the MCSymbol class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCSYMBOL_H
 #define LLVM_MC_MCSYMBOL_H
 
 #include "llvm/ADT/PointerIntPair.h"
-#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringMapEntry.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>

llvm/include/llvm/MC/MCValue.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCVALUE_H
 #define LLVM_MC_MCVALUE_H
 
 #include "llvm/MC/MCExpr.h"
 #include "llvm/Support/DataTypes.h"
-#include <cassert>
 
 namespace llvm {
 class raw_ostream;
 
 /// This represents an "assembler immediate".
 ///
 ///  In its most general form, this can hold ":Kind:(SymbolA - SymbolB +
 ///  imm64)".  Not all targets supports relocations of this general form, but we

llvm/include/llvm/MC/SubtargetFeature.h

 /// as example, gather chip info from the command line, a long with features
 /// that should be used on that chip.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_SUBTARGETFEATURE_H
 #define LLVM_MC_SUBTARGETFEATURE_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MathExtras.h"
 #include <array>
-#include <bitset>
 #include <initializer_list>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 class Triple;

llvm/include/llvm/MC/TargetRegistry.h

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
-#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <iterator>
 #include <memory>
 #include <string>
 
 namespace llvm {
 

 class MCRelocationInfo;
 class MCStreamer;
 class MCSubtargetInfo;
 class MCSymbolizer;
 class MCTargetAsmParser;
 class MCTargetOptions;
 class MCTargetStreamer;
 class raw_ostream;
-class raw_pwrite_stream;
 class TargetMachine;
 class TargetOptions;
 namespace mca {
 class CustomBehaviour;
 class InstrPostProcess;
 class SourceMgr;
 } // namespace mca
 

llvm/include/llvm/Target/TargetLoweringObjectFile.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
 #define LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
 
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegister.h"
+#include "llvm/Support/Alignment.h"
 #include <cstdint>
 
 namespace llvm {
 
 class Constant;
 class DataLayout;
 class Function;
 class GlobalObject;

llvm/lib/CodeGen/LLVMTargetMachine.cpp

 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"

llvm/lib/MC/ELFObjectWriter.cpp

 //===- lib/MC/ELFObjectWriter.cpp - ELF File Writer -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements ELF object file writer information.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/ADT/iterator.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCFragment.h"
-#include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Alignment.h"
-#include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compression.h"
+#include "llvm/Support/Endian.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SMLoc.h"
-#include "llvm/Support/StringSaver.h"
-#include "llvm/Support/SwapByteOrder.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>

llvm/lib/MC/MCAsmBackend.cpp

 //===- MCAsmBackend.cpp - Target MC Assembly Backend ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/ADT/None.h"
-#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/STLArrayExtras.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCMachObjectWriter.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCWasmObjectWriter.h"
 #include "llvm/MC/MCWinCOFFObjectWriter.h"
 #include "llvm/MC/MCXCOFFObjectWriter.h"
 #include <cassert>

llvm/lib/MC/MCAsmStreamer.cpp

 //===- lib/MC/MCAsmStreamer.cpp - Text Assembly Output ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCRegister.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
-#include <cctype>
 
 using namespace llvm;
 
 namespace {
 
 class MCAsmStreamer final : public MCStreamer {
   std::unique_ptr<formatted_raw_ostream> OSOwner;
   formatted_raw_ostream &OS;

llvm/lib/MC/MCAssembler.cpp

 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
-#include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
-#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
-#include <cstring>
 #include <tuple>
 #include <utility>
 
+namespace llvm {
+class MCSubtargetInfo;
+}
+
 using namespace llvm;
 
 #define DEBUG_TYPE "assembler"
 
 namespace {
 namespace stats {
 
 STATISTIC(EmittedFragments, "Number of emitted assembler fragments - total");

llvm/lib/MC/MCCodeView.cpp

 
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/Line.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/MC/MCAsmLayout.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/EndianStream.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 

llvm/lib/MC/MCContext.cpp

 //===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCContext.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
+#include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCLabel.h"
-#include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolCOFF.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCSymbolGOFF.h"
 #include "llvm/MC/MCSymbolMachO.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
+#include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/Signals.h"
+#include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdlib>
 #include <tuple>
 #include <utility>
 
 using namespace llvm;

llvm/lib/MC/MCExpr.cpp

 //===- MCExpr.cpp - Assembly Level Expression Implementation --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCExpr.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectWriter.h"

llvm/lib/MC/MCInstPrinter.cpp

 //===- MCInstPrinter.cpp - Convert an MCInst to target assembly syntax ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdint>
 
 using namespace llvm;

llvm/lib/MC/MCInstrAnalysis.cpp

 //===- MCInstrAnalysis.cpp - InstrDesc target hooks -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCInstrAnalysis.h"
 
 #include "llvm/ADT/APInt.h"
-#include "llvm/MC/MCInst.h"
-#include "llvm/MC/MCInstrDesc.h"
-#include "llvm/MC/MCInstrInfo.h"
 #include <cstdint>
 
+namespace llvm {
+class MCSubtargetInfo;
+}
+
 using namespace llvm;
 
 bool MCInstrAnalysis::clearsSuperRegisters(const MCRegisterInfo &MRI,
                                            const MCInst &Inst,
                                            APInt &Writes) const {
   Writes.clearAllBits();
   return false;
 }

llvm/lib/MC/MCInstrDesc.cpp

 //===------ llvm/MC/MCInstrDesc.cpp- Instruction Descriptors --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines methods on the MCOperandInfo and MCInstrDesc classes, which
 // are used to describe target instructions and their operands.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCRegisterInfo.h"
-#include "llvm/MC/MCSubtargetInfo.h"
 
 using namespace llvm;
 
 bool MCInstrDesc::mayAffectControlFlow(const MCInst &MI,
                                        const MCRegisterInfo &RI) const {
   if (isBranch() || isCall() || isReturn() || isIndirectBranch())
     return true;
   unsigned PC = RI.getProgramCounter();

llvm/lib/MC/MCMachOStreamer.cpp

 //===- MCMachOStreamer.cpp - MachO Streamer -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFragment.h"
-#include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionMachO.h"
-#include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolMachO.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/MC/SectionKind.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <vector>
 
+namespace llvm {
+class MCInst;
+class MCStreamer;
+class MCSubtargetInfo;
+class Triple;
+} // namespace llvm
+
 using namespace llvm;
 
 namespace {
 
 class MCMachOStreamer : public MCObjectStreamer {
 private:
   /// LabelSections - true if each section change should emit a linker local
   /// label for use in relocations for assembler local references. Obviates the

llvm/lib/MC/MCNullStreamer.cpp

 //===- lib/MC/MCNullStreamer.cpp - Dummy Streamer Implementation ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCStreamer.h"
-#include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/SMLoc.h"
+namespace llvm {
+class MCContext;
+class MCExpr;
+class MCSection;
+class MCSymbol;
+} // namespace llvm
 
 using namespace llvm;
 
 namespace {
 
   class MCNullStreamer : public MCStreamer {
   public:
     MCNullStreamer(MCContext &Context) : MCStreamer(Context) {}

llvm/lib/MC/MCObjectFileInfo.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"
+#include "llvm/Support/Casting.h"
 
 using namespace llvm;
 
 static bool useCompactUnwind(const Triple &T) {
   // Only on darwin.
   if (!T.isOSDarwin())
     return false;
 

llvm/lib/MC/MCObjectStreamer.cpp

 //===- lib/MC/MCObjectStreamer.cpp - Object File MCStreamer Interface -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCObjectStreamer.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"

llvm/lib/MC/MCObjectWriter.cpp

 //===- lib/MC/MCObjectWriter.cpp - MCObjectWriter implementation ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCObjectWriter.h"
-#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCSymbol.h"
+namespace llvm {
+class MCSection;
+}
 
 using namespace llvm;
 
 MCObjectWriter::~MCObjectWriter() = default;
 
 bool MCObjectWriter::isSymbolRefDifferenceFullyResolved(
     const MCAssembler &Asm, const MCSymbolRefExpr *A, const MCSymbolRefExpr *B,
     bool InSet) const {

llvm/lib/MC/MCParser/COFFMasmParser.cpp

 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 #include "llvm/MC/MCParser/MCAsmParserUtils.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolCOFF.h"
 #include "llvm/MC/SectionKind.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/SMLoc.h"
 #include <cassert>
 #include <cstdint>
 #include <limits>
 #include <utility>
 
 using namespace llvm;
 

llvm/lib/MC/MCParser/MCAsmParserExtension.cpp

 //===- MCAsmParserExtension.cpp - Asm Parser Hooks ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCStreamer.h"
 
 using namespace llvm;
 
 MCAsmParserExtension::MCAsmParserExtension() = default;
 
 MCAsmParserExtension::~MCAsmParserExtension() = default;
 

llvm/lib/MC/MCParser/MasmParser.cpp

 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 #include "llvm/MC/MCParser/MCAsmParserUtils.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MD5.h"

llvm/lib/MC/MCParser/WasmAsmParser.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/MachineValueType.h"
 
 using namespace llvm;
 
 namespace {
 
 class WasmAsmParser : public MCAsmParserExtension {
   MCAsmParser *Parser = nullptr;

llvm/lib/MC/MCPseudoProbe.cpp

 //===- lib/MC/MCPseudoProbe.cpp - Pseudo probe encoding support ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCPseudoProbe.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
-#include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 #include <limits>
 #include <memory>
 #include <sstream>
 
 #define DEBUG_TYPE "mcpseudoprobe"

llvm/lib/MC/MCSection.cpp

 //===- lib/MC/MCSection.cpp - Machine Code Section Representation ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSection.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
-#include <algorithm>
 #include <utility>
 
 using namespace llvm;
 
 MCSection::MCSection(SectionVariant V, StringRef Name, SectionKind K,
                      MCSymbol *Begin)
     : Begin(Begin), BundleGroupBeforeFirstInst(false), HasInstructions(false),
       IsRegistered(false), DummyFragment(this), Name(Name), Variant(V),

llvm/lib/MC/MCSectionMachO.cpp

 //===- lib/MC/MCSectionMachO.cpp - MachO Code Section Representation ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSectionMachO.h"
-#include "llvm/MC/MCContext.h"
+#include "llvm/MC/SectionKind.h"
 #include "llvm/Support/raw_ostream.h"
-#include <cctype>
+
+namespace llvm {
+class MCAsmInfo;
+class MCExpr;
+class MCSymbol;
+class Triple;
+} // namespace llvm
+
 using namespace llvm;
 
 /// SectionTypeDescriptors - These are strings that describe the various section
 /// types.  This *must* be kept in order with and stay synchronized with the
 /// section type list.
 static constexpr struct {
   StringLiteral AssemblerName, EnumName;
 } SectionTypeDescriptors[MachO::LAST_KNOWN_SECTION_TYPE + 1] = {

llvm/lib/MC/MCSectionWasm.cpp

 //===- lib/MC/MCSectionWasm.cpp - Wasm Code Section Representation --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCExpr.h"
-#include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 // Decides whether a '.section' directive
 // should be printed before the section name.
 bool MCSectionWasm::shouldOmitSectionDirective(StringRef Name,

llvm/lib/MC/MCSectionXCOFF.cpp

 //===- lib/MC/MCSectionXCOFF.cpp - XCOFF Code Section Representation ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCAsmInfo.h"
-#include "llvm/MC/MCExpr.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
+namespace llvm {
+class MCExpr;
+class Triple;
+} // namespace llvm
 
 using namespace llvm;
 
 MCSectionXCOFF::~MCSectionXCOFF() = default;
 
 void MCSectionXCOFF::printCsectDirective(raw_ostream &OS) const {
   OS << "\t.csect " << QualName->getName() << "," << Log2_32(getAlignment())
      << '\n';

llvm/lib/MC/MCStreamer.cpp

 //===- lib/MC/MCStreamer.cpp - Streaming Machine Code Output --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/COFF.h"
+#include "llvm/BinaryFormat/MachO.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"

llvm/lib/MC/MCSymbol.cpp

 //===- lib/MC/MCSymbol.cpp - MCSymbol implementation ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
-#include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstddef>
 

llvm/lib/MC/MCSymbolELF.cpp

 //===- lib/MC/MCSymbolELF.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/BinaryFormat/ELF.h"
-#include "llvm/MC/MCFixupKindInfo.h"
 
 namespace llvm {
 
 namespace {
 enum {
   // Shift value for STT_* flags. 7 possible values. 3 bits.
   ELF_STT_Shift = 0,
 

llvm/lib/MC/MCWasmStreamer.cpp

 //===- lib/MC/MCWasmStreamer.cpp - Wasm Object Output ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file assembles .s files and emits Wasm .o object files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCWasmStreamer.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCAsmBackend.h"
-#include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
-#include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
-#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCFixup.h"
+#include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
-#include "llvm/MC/MCValue.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
+namespace llvm {
+class MCContext;
+class MCStreamer;
+class MCSubtargetInfo;
+} // namespace llvm
+
 using namespace llvm;
 
 MCWasmStreamer::~MCWasmStreamer() = default; // anchor.
 
 void MCWasmStreamer::mergeFragment(MCDataFragment *DF, MCDataFragment *EF) {
   flushPendingLabels(DF, DF->getContents().size());
 
   for (unsigned I = 0, E = EF->getFixups().size(); I != E; ++I) {

llvm/lib/MC/MCWin64EH.cpp

 //===- lib/MC/MCWin64EH.cpp - MCWin64EH implementation --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCWin64EH.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
-#include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
-#include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Win64EH.h"
+namespace llvm {
+class MCSection;
+}
 
 using namespace llvm;
 
 // NOTE: All relocations generated here are 4-byte image-relative.
 
 static uint8_t CountOfUnwindCodes(std::vector<WinEH::Instruction> &Insns) {
   uint8_t Count = 0;
   for (const auto &I : Insns) {

llvm/lib/MC/MCWinCOFFStreamer.cpp

 //===- llvm/MC/MCWinCOFFStreamer.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains an implementation of a Windows COFF object file streamer.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/MC/MCWinCOFFStreamer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSymbolCOFF.h"
-#include "llvm/MC/MCWinCOFFStreamer.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cassert>
 #include <cstdint>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "WinCOFFStreamer"
 
 MCWinCOFFStreamer::MCWinCOFFStreamer(MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> MAB,

llvm/lib/MC/MCWinEH.cpp

 //===- lib/MC/MCWinEH.cpp - Windows EH implementation ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCWinEH.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/BinaryFormat/COFF.h"
-#include "llvm/MC/MCContext.h"
-#include "llvm/MC/MCObjectFileInfo.h"
-#include "llvm/MC/MCSectionCOFF.h"
-#include "llvm/MC/MCStreamer.h"
-#include "llvm/MC/MCSymbol.h"
 
 namespace llvm {
 namespace WinEH {
 
 UnwindEmitter::~UnwindEmitter() = default;
 
 }
 }
 

llvm/lib/MC/MCXCOFFStreamer.cpp

 //===- lib/MC/MCXCOFFStreamer.cpp - XCOFF Object Output -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file assembles .s files and emits XCOFF .o object files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCXCOFFStreamer.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/Casting.h"
 
 using namespace llvm;
 
 MCXCOFFStreamer::MCXCOFFStreamer(MCContext &Context,
                                  std::unique_ptr<MCAsmBackend> MAB,
                                  std::unique_ptr<MCObjectWriter> OW,
                                  std::unique_ptr<MCCodeEmitter> Emitter)
     : MCObjectStreamer(Context, std::move(MAB), std::move(OW),

llvm/lib/MC/SubtargetFeature.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-#include <iterator>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 
 /// Splits a string of comma separated items in to a vector of strings.
 void SubtargetFeatures::Split(std::vector<std::string> &V, StringRef S) {
   SmallVector<StringRef, 3> Tmp;

llvm/lib/MC/WasmObjectWriter.cpp

 //===- lib/MC/WasmObjectWriter.cpp - Wasm File Writer ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements Wasm object file writer information.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/BinaryFormat/WasmTraits.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/MCWasmObjectWriter.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
-#include "llvm/Support/StringSaver.h"
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "mc"
 
 namespace {
 

llvm/lib/MC/WinCOFFObjectWriter.cpp

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
-#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <ctime>
 #include <memory>
 #include <string>
 #include <vector>
 
 using namespace llvm;

llvm/lib/MC/XCOFFObjectWriter.cpp

 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/MCXCOFFObjectWriter.h"
 #include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/EndianStream.h"
-#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 
 #include <deque>
 
 using namespace llvm;
 
 // An XCOFF object file has a limited set of predefined sections. The most
 // important ones for us (right now) are:

llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp

 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 using namespace llvm;
 
 namespace {

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/AArch64AddressingModes.h"
 #include "MCTargetDesc/AArch64FixupKinds.h"
 #include "MCTargetDesc/AArch64MCExpr.h"
 #include "Utils/AArch64BaseInfo.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/Casting.h"

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp

 //===----------------------------------------------------------------------===//
 
 #include "AArch64MCExpr.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "aarch64symbolrefexpr"
 
 const AArch64MCExpr *AArch64MCExpr::create(const MCExpr *Expr, VariantKind Kind,
                                        MCContext &Ctx) {

llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp

 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/MCWinCOFFObjectWriter.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 
 using namespace llvm;
 
 namespace {
 

llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFStreamer.cpp

 //===-- AArch64WinCOFFStreamer.cpp - ARM Target WinCOFF Streamer ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64WinCOFFStreamer.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCWin64EH.h"
 #include "llvm/MC/MCWinCOFFStreamer.h"
 
 using namespace llvm;
 
 namespace {

llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

 #include "AMDKernelCodeT.h"
 #include "GCNSubtarget.h"
 #include "MCTargetDesc/AMDGPUInstPrinter.h"
 #include "MCTargetDesc/AMDGPUTargetStreamer.h"
 #include "R600AsmPrinter.h"
 #include "SIMachineFunctionInfo.h"
 #include "TargetInfo/AMDGPUTargetInfo.h"
 #include "Utils/AMDGPUBaseInfo.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/AMDHSAKernelDescriptor.h"
+#include "llvm/Support/TargetParser.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 // This should get the default rounding mode from the kernel. We just set the
 // default here, but this could change if the OpenCL rounding mode pragmas are

llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp

 #include "TargetInfo/AMDGPUTargetInfo.h"
 #include "Utils/AMDGPUAsmUtils.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "Utils/AMDKernelCodeTUtils.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCSymbol.h"

llvm/lib/Target/AMDGPU/Disassembler/AMDGPUDisassembler.cpp

 
 // ToDo: What to do with instruction suffixes (v_mov_b32 vs v_mov_b32_e32)?
 
 #include "Disassembler/AMDGPUDisassembler.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "TargetInfo/AMDGPUTargetInfo.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm-c/DisassemblerTypes.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixedLenDisassembler.h"
-#include "llvm/MC/TargetRegistry.h"
 #include "llvm/MC/MCInstrDesc.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/AMDHSAKernelDescriptor.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "amdgpu-disassembler"
 
 #define SGPR_MAX                                                               \
   (isGFX10Plus() ? AMDGPU::EncValues::SGPR_MAX_GFX10                           \

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUAsmBackend.cpp

 //===-- AMDGPUAsmBackend.cpp - AMDGPU Assembler Backend -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 /// \file
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/AMDGPUFixupKinds.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "Utils/AMDGPUBaseInfo.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/EndianStream.h"
+#include "llvm/Support/TargetParser.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 namespace {
 
 class AMDGPUAsmBackend : public MCAsmBackend {
 public:

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUMCTargetDesc.cpp

 #include "AMDGPUMCTargetDesc.h"
 #include "AMDGPUELFStreamer.h"
 #include "AMDGPUInstPrinter.h"
 #include "AMDGPUMCAsmInfo.h"
 #include "AMDGPUTargetStreamer.h"
 #include "R600InstPrinter.h"
 #include "R600MCTargetDesc.h"
 #include "TargetInfo/AMDGPUTargetInfo.h"
+#include "llvm/MC/LaneBitmask.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 
 using namespace llvm;
 
 #define GET_INSTRINFO_MC_DESC
 #include "AMDGPUGenInstrInfo.inc"

llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp

 
 #include "AMDGPUTargetStreamer.h"
 #include "AMDGPUPTNote.h"
 #include "AMDKernelCodeT.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "Utils/AMDKernelCodeTUtils.h"
 #include "llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCSectionELF.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/AMDGPUMetadata.h"
 #include "llvm/Support/AMDHSAKernelDescriptor.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/TargetParser.h"
 
 using namespace llvm;
 using namespace llvm::AMDGPU;
 
 //===----------------------------------------------------------------------===//
 // AMDGPUTargetStreamer
 //===----------------------------------------------------------------------===//
 

llvm/lib/Target/AMDGPU/MCTargetDesc/R600MCCodeEmitter.cpp

 
 #include "MCTargetDesc/R600MCTargetDesc.h"
 #include "R600Defines.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Support/EndianStream.h"
 
 using namespace llvm;
 
 namespace {
 
 class R600MCCodeEmitter : public MCCodeEmitter {

llvm/lib/Target/AMDGPU/MCTargetDesc/SIMCCodeEmitter.cpp

 #include "MCTargetDesc/AMDGPUMCCodeEmitter.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "SIDefines.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Support/Casting.h"
 
 using namespace llvm;
 
 namespace {
 
 class SIMCCodeEmitter : public  AMDGPUMCCodeEmitter {
   const MCRegisterInfo &MRI;
 

llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFStreamer.cpp

 //===-- ARMWinCOFFStreamer.cpp - ARM Target WinCOFF Streamer ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ARMMCTargetDesc.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCWinCOFFStreamer.h"
 
 using namespace llvm;
 
 namespace {
 class ARMWinCOFFStreamer : public MCWinCOFFStreamer {

llvm/lib/Target/AVR/MCTargetDesc/AVRELFStreamer.cpp

 #include "AVRELFStreamer.h"
 
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Support/FormattedStream.h"
 
 #include "AVRMCTargetDesc.h"
 
 namespace llvm {
 

llvm/lib/Target/BPF/Disassembler/BPFDisassembler.cpp

 #include "MCTargetDesc/BPFMCTargetDesc.h"
 #include "TargetInfo/BPFTargetInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCFixedLenDisassembler.h"
 #include "llvm/MC/MCInst.h"
+#include "llvm/MC/SubtargetFeature.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstdint>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "bpf-disassembler"
 

llvm/lib/Target/BPF/MCTargetDesc/BPFInstPrinter.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/BPFInstPrinter.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
 // Include the auto-generated portion of the assembly writer.
 #include "BPFGenAsmWriter.inc"

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonAsmBackend.cpp

 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/EndianStream.h"
 
 #include <sstream>
 
 using namespace llvm;
 using namespace Hexagon;

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCChecker.cpp

 #include "MCTargetDesc/HexagonMCShuffler.h"
 #include "MCTargetDesc/HexagonMCTargetDesc.h"
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/SourceMgr.h"
 #include <cassert>
 
 using namespace llvm;
 
 static cl::opt<bool>
     RelaxNVChecks("relax-nv-checks", cl::init(false), cl::ZeroOrMore,

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCExpr.cpp

 //===-- HexagonMCExpr.cpp - Hexagon specific MC expression classes
 //----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "HexagonMCExpr.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "hexagon-mcexpr"
 
 HexagonMCExpr *HexagonMCExpr::create(MCExpr const *Expr, MCContext &Ctx) {
   return new (Ctx) HexagonMCExpr(Expr);

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp

 #include "MCTargetDesc/HexagonMCAsmInfo.h"
 #include "MCTargetDesc/HexagonMCELFStreamer.h"
 #include "MCTargetDesc/HexagonMCInstrInfo.h"
 #include "TargetInfo/HexagonTargetInfo.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCRegisterInfo.h"

llvm/lib/Target/MSP430/MCTargetDesc/MSP430ELFStreamer.cpp

 //===-- MSP430ELFStreamer.cpp - MSP430 ELF Target Streamer Methods --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides MSP430 specific target streamer methods.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MSP430MCTargetDesc.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/MSP430Attributes.h"
 
 using namespace llvm;

llvm/lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp

 //===-- MipsTargetStreamer.cpp - Mips Target Streamer Methods -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides Mips specific target streamer methods.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MipsTargetStreamer.h"
-#include "MipsInstPrinter.h"
 #include "MCTargetDesc/MipsABIInfo.h"
 #include "MipsELFStreamer.h"
+#include "MipsInstPrinter.h"
 #include "MipsMCExpr.h"
 #include "MipsMCTargetDesc.h"
 #include "MipsTargetObjectFile.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 
 using namespace llvm;
 
 namespace {
 static cl::opt<bool> RoundSectionSizes(

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFStreamer.cpp

 // guarantee that the 8 byte instructions do not cross that boundary.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PPCXCOFFStreamer.h"
 #include "PPCMCCodeEmitter.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/TargetRegistry.h"
 
 using namespace llvm;

llvm/lib/Target/PowerPC/PPCTargetStreamer.h

 //===- PPCTargetStreamer.h - PPC Target Streamer ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_POWERPC_PPCTARGETSTREAMER_H
 #define LLVM_LIB_TARGET_POWERPC_PPCTARGETSTREAMER_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCStreamer.h"
 
 namespace llvm {
 
 class MCExpr;
 class MCSymbol;
 class MCSymbolELF;
 

llvm/lib/Target/RISCV/MCTargetDesc/RISCVELFStreamer.cpp

 //===----------------------------------------------------------------------===//
 
 #include "RISCVELFStreamer.h"
 #include "RISCVAsmBackend.h"
 #include "RISCVBaseInfo.h"
 #include "RISCVMCTargetDesc.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/RISCVAttributes.h"
 
 using namespace llvm;
 
 // This part is for ELF object output.
 RISCVTargetELFStreamer::RISCVTargetELFStreamer(MCStreamer &S,
                                                const MCSubtargetInfo &STI)

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp

 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "mccodeemitter"

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCExpr.cpp

 #include "RISCVFixupKinds.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "riscvmcexpr"
 
 const RISCVMCExpr *RISCVMCExpr::create(const MCExpr *Expr, VariantKind Kind,
                                        MCContext &Ctx) {

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCObjectFileInfo.cpp

 //===-- RISCVMCObjectFileInfo.cpp - RISCV object file properties ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the declarations of the RISCVMCObjectFileInfo properties.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RISCVMCObjectFileInfo.h"
 #include "RISCVMCTargetDesc.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 
 using namespace llvm;
 
 unsigned RISCVMCObjectFileInfo::getTextSectionAlignment() const {
   const MCSubtargetInfo *STI = getContext().getSubtargetInfo();
   return STI->hasFeature(RISCV::FeatureStdExtC) ? 2 : 4;
 }

llvm/lib/Target/Sparc/MCTargetDesc/SparcMCExpr.cpp

 //===----------------------------------------------------------------------===//
 
 #include "SparcMCExpr.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/Support/Casting.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "sparcmcexpr"
 
 const SparcMCExpr*
 SparcMCExpr::create(VariantKind Kind, const MCExpr *Expr,
                       MCContext &Ctx) {

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCTargetDesc.cpp

 //===-- SystemZMCTargetDesc.cpp - SystemZ target descriptions -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SystemZMCTargetDesc.h"
 #include "SystemZInstPrinter.h"
 #include "SystemZMCAsmInfo.h"
 #include "SystemZTargetStreamer.h"
 #include "TargetInfo/SystemZTargetInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 
 using namespace llvm;
 

llvm/lib/Target/SystemZ/SystemZTargetStreamer.h

 //=- SystemZTargetStreamer.h - SystemZ Target Streamer ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZTARGETSTREAMER_H
 #define LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZTARGETSTREAMER_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCStreamer.h"
 
 namespace llvm {
 
 class SystemZTargetStreamer : public MCTargetStreamer {
 public:
   SystemZTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
 

llvm/lib/Target/TargetMachine.cpp

 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 using namespace llvm;
 
 //---------------------------------------------------------------------------
 // TargetMachine Class
 //

llvm/lib/Target/VE/MCTargetDesc/VEMCExpr.cpp

 
 #include "VEMCExpr.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/Casting.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "vemcexpr"
 
 const VEMCExpr *VEMCExpr::create(VariantKind Kind, const MCExpr *Expr,
                                  MCContext &Ctx) {
   return new (Ctx) VEMCExpr(Kind, Expr);

llvm/lib/Target/X86/AsmParser/X86Operand.h

 #include "MCTargetDesc/X86IntelInstPrinter.h"
 #include "MCTargetDesc/X86MCTargetDesc.h"
 #include "X86AsmParserCommon.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/SMLoc.h"
 #include <cassert>
 #include <memory>
 
 namespace llvm {
 
 /// X86Operand - Instances of this class represent a parsed X86 machine

llvm/lib/Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp

 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixup.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
 
 using namespace llvm;
 

llvm/lib/Target/X86/MCTargetDesc/X86MCExpr.h

 
 #ifndef LLVM_LIB_TARGET_X86_MCTARGETDESC_X86MCEXPR_H
 #define LLVM_LIB_TARGET_X86_MCTARGETDESC_X86MCEXPR_H
 
 #include "X86ATTInstPrinter.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 
 class X86MCExpr : public MCTargetExpr {
 
 private:
   const int64_t RegNo; // All

llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFStreamer.cpp

 //===-- X86WinCOFFStreamer.cpp - X86 Target WinCOFF Streamer ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86MCTargetDesc.h"
 #include "X86TargetStreamer.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCWin64EH.h"
 #include "llvm/MC/MCWinCOFFStreamer.h"
 
 using namespace llvm;
 
 namespace {

llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp

 //===-- X86WinCOFFTargetStreamer.cpp ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86MCTargetDesc.h"
 #include "X86TargetStreamer.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/FormattedStream.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 
 namespace {
 /// Implements Windows x86-only directives for assembly emission.
 class X86WinCOFFAsmTargetStreamer : public X86TargetStreamer {

llvm/tools/dsymutil/MachOUtils.cpp

 //===-- MachOUtils.cpp - Mach-o specific helpers for dsymutil  ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MachOUtils.h"
 #include "BinaryHolder.h"
 #include "DebugMap.h"
 #include "LinkUtils.h"
 #include "llvm/CodeGen/NonRelocatableStringpool.h"
 #include "llvm/MC/MCAsmLayout.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCMachObjectWriter.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace dsymutil {

llvm/tools/dsymutil/dsymutil.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileCollector.h"
 #include "llvm/Support/FileSystem.h"

llvm/tools/llvm-dwp/llvm-dwp.cpp

 #include "llvm/DWP/DWPError.h"
 #include "llvm/DWP/DWPStringPool.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 

llvm/tools/llvm-ml/llvm-ml.cpp

 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCParser/AsmLexer.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/FormatVariadic.h"

llvm/unittests/CodeGen/AsmPrinterDwarfTest.cpp

 //===- llvm/unittest/CodeGen/AsmPrinterDwarfTest.cpp ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestAsmPrinter.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/Target/TargetMachine.h"

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

 //===- llvm/unittest/DebugInfo/DWARFExpressionCompactPrinterTest.cpp ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfGenerator.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace dwarf;

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp

 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"

llvm/unittests/MC/DwarfLineTableHeaders.cpp

 //===- llvm/unittest/MC/DwarfLineTableHeaders.cpp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "gtest/gtest.h"

llvm/unittests/MC/MCInstPrinter.cpp

 //===- llvm/unittest/MC/MCInstPrinter.cpp ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;

llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp

 //===- llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===--------------------------------------------------------------------===//
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
 
 #include "gtest/gtest.h"
 
 using namespace llvm;

llvm/utils/TableGen/FixedLenDecoderEmitter.cpp

<< "  llvm_unreachable(\"bogosity detected in disassembler state "
         "machine!\");\n"
      << "}\n\n";
 }
 
 // Emits disassembler code for instruction decoding.
 void FixedLenDecoderEmitter::run(raw_ostream &o) {
   formatted_raw_ostream OS(o);
   OS << "#include \"llvm/MC/MCInst.h\"\n";
+  OS << "#include \"llvm/MC/SubtargetFeature.h\"\n";
+  OS << "#include \"llvm/MC/MCSubtargetInfo.h\"\n";
   OS << "#include \"llvm/Support/DataTypes.h\"\n";
   OS << "#include \"llvm/Support/Debug.h\"\n";
   OS << "#include \"llvm/Support/LEB128.h\"\n";
   OS << "#include \"llvm/Support/raw_ostream.h\"\n";
   OS << "#include <assert.h>\n";
   OS << '\n';
   OS << "namespace llvm {\n\n";