[MC] Make it possible for targets to define their own MCObjectFileInfo

[flip1995]

Summary

This MCObjectFileInfo is then used to determine things like section
alignment.

For example, this commit removes the hard-coded 4-byte alignment for
text sections and uses the alignment defined by the target specific
MCObjectFileInfo.

This is a follow up to https://reviews.llvm.org/D101462 and prepares for the
RISCV backend defining the text section alignment depending on the enabled
extensions.

[flip1995]

rebased

[MaskRay]

Can you post the RISCV patch depending on this one?

llvm/include/llvm/Support/TargetRegistry.h

1027

https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments
"Don’t duplicate function or class name at the beginning of the comment."

Just ignore existing comments which do not abide by the standard.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

57–59

The argument is almost always /*MOFI=*/nullptr. Doesn't this regress a bit?

[flip1995]

This comment was removed by flip1995.

llvm/include/llvm/Support/TargetRegistry.h

1027

https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments
"Don’t duplicate function or class name at the beginning of the comment."

Just ignore existing comments which do not abide by the standard.

[flip1995]

llvm/lib/DWARFLinker/DWARFStreamer.cpp

57–59

I agree. I think the best thing to do here would be to just remove this argument?

[flip1995]

In D101921#2743735, @MaskRay wrote:

Can you post the RISCV patch depending on this one?

Yes, sure. See https://reviews.llvm.org/D102052.

[flip1995]

Remove redundant item names in doc comments

[MaskRay]

llvm/include/llvm/MC/MCObjectFileInfo.h

255 ↗

(On Diff #343605)

This should be moved to D102052

llvm/lib/DWARFLinker/DWARFStreamer.cpp

57–59

I think so. Since MOFI is guaranteed to be constructed after MCContext now.

[MaskRay]

clang/tools/driver/cc1as_main.cpp

407–412

Can we fix the FIXME now?

[flip1995]

clang/tools/driver/cc1as_main.cpp

407–412

Not quite. The construction is still in the order MCContext -> MOFI -> "continue construction of MCContext by setting the MOFI". The order just changed from "dummy MOFI" -> MCContext -> "init dummy MOFI".

llvm/include/llvm/MC/MCObjectFileInfo.h

255 ↗

(On Diff #343605)

Will do.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

57–59

Will do.

[flip1995]

rebased and addressed review comments:

• [MC] Remove MOFI argument from MCContext constructor
• [MC] Remove getTextSectionAlignment function from MCObjectFileInfo

[MaskRay]

Can createMCObjectFileInfo return MCObjectFileInfo instead of std::unique_ptr<MCObjectFileInfo>?

clang/lib/Parse/ParseStmtAsm.cpp

583–584

Can MOFI be null? (i.e. can createMCObjectFileInfo guarantee no-null return value?)

Consider moving the construction below the checks.

[flip1995]

In D101921#2754426, @MaskRay wrote:

Can createMCObjectFileInfo return MCObjectFileInfo instead of std::unique_ptr<MCObjectFileInfo>?

createMCObjectfileInfo returns a MCObjectFileInfo * similar to every other create* function in TargetRegistry.h.

clang/lib/Parse/ParseStmtAsm.cpp

583–584

You're right. The createMCObjectFileInfo always returns a no-null value. I'll move the construction and remove the check for MOFI.

[flip1995]

• [MC] Don't check if constructed MOFI is a nullptr

[MaskRay]

LGTM. This looks like an improvement because it avoids a temporary MCObjectFileInfo MOFI; (which appeared to be initialized in two subsequent calls) in numerous places.

[MaskRay]

llvm/include/llvm/Support/TargetRegistry.h

26

include/llvm/Support/TargetRegistry.h now has cyclic dependency on include/MC/*.h.

The previous style isn't good as well: include/llvm/Support/TargetRegistry.h has forward declarations of a number of MC* classes.

I think this header probably should be moved to lib/Target.

[flip1995]

llvm/include/llvm/Support/TargetRegistry.h

26

include/llvm/Support/TargetRegistry.h now has cyclic dependency on include/MC/*.h

I'll submit a quick fix changing this to a forward decl.

I think this header probably should be moved to lib/Target.

The whole TargetRegistry.h header?

[flip1995]

llvm/include/llvm/Support/TargetRegistry.h

26

I'll submit a quick fix changing this to a forward decl.

I just noticed, that this isn't as easy, as I would've thought, since the MOFI is constructed if no createMCObjectFileInfo callback function is defined by the target.

[MaskRay]

Because of new MCObjectFileInfo, we cannot use a forward declaration (incomplete class) to replace #include "llvm/MC/MCObjectFileInfo.h" in TargetRegistry.h.

I thought about moving TargetRegistry.{h,cpp} from Support to Target. However, it doesn't work because Bitcode/Object call TargetRegistry::lookupTarget and Bitcode/Object are lower than Target.

@compnerd @dblaikie @mehdi_amini Do you have suggestions on fixing the layering?

[dblaikie]

In D101921#2786245, @MaskRay wrote:

Because of new MCObjectFileInfo, we cannot use a forward declaration (incomplete class) to replace #include "llvm/MC/MCObjectFileInfo.h" in TargetRegistry.h.

I thought about moving TargetRegistry.{h,cpp} from Support to Target. However, it doesn't work because Bitcode/Object call TargetRegistry::lookupTarget and Bitcode/Object are lower than Target.

@compnerd @dblaikie @mehdi_amini Do you have suggestions on fixing the layering?

Looks like a big patch and a bit hard for me to page in all the context. Could you summarize the layering constraints/what headers/types/functions are in which libraries and why they are there/what constrains them?

clang/lib/Parse/ParseStmtAsm.cpp

if (!MRI) {
     return EmptyStmt();
   }
   // FIXME: init MCOptions from sanitizer flags here.
   llvm::MCTargetOptions MCOptions;
   std::unique_ptr<llvm::MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, TT, MCOptions));
   // Get the instruction descriptor.
   std::unique_ptr<llvm::MCInstrInfo> MII(TheTarget->createMCInstrInfo());
-  std::unique_ptr<llvm::MCObjectFileInfo> MOFI(new llvm::MCObjectFileInfo());
   std::unique_ptr<llvm::MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TT, TO.CPU, FeaturesStr));
   // Target MCTargetDesc may not be linked in clang-based tools.
-  if (!MAI || !MII || !MOFI || !STI) {
+
+  if (!MAI || !MII || !STI) {
     Diag(AsmLoc, diag::err_msasm_unable_to_create_target)
         << "target MC unavailable";
     return EmptyStmt();
   }
 
   llvm::SourceMgr TempSrcMgr;
-  llvm::MCContext Ctx(TheTriple, MAI.get(), MRI.get(), MOFI.get(), STI.get(),
-                      &TempSrcMgr);
-  MOFI->initMCObjectFileInfo(Ctx, /*PIC=*/false);
+  llvm::MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &TempSrcMgr);
+  std::unique_ptr<llvm::MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
+  Ctx.setObjectFileInfo(MOFI.get());
+
   std::unique_ptr<llvm::MemoryBuffer> Buffer =
       llvm::MemoryBuffer::getMemBuffer(AsmString, "<MS inline asm>");
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   TempSrcMgr.AddNewSourceBuffer(std::move(Buffer), llvm::SMLoc());
 
   std::unique_ptr<llvm::MCStreamer> Str(createNullStreamer(Ctx));
   std::unique_ptr<llvm::MCAsmParser> Parser(

clang/tools/driver/cc1as_main.cpp

static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   std::unique_ptr<raw_fd_ostream> FDOS =
       getOutputStream(Opts.OutputPath, Diags, IsBinary);
   if (!FDOS)
     return true;
   std::unique_ptr<raw_fd_ostream> DwoOS;
   if (!Opts.SplitDwarfOutput.empty())
     DwoOS = getOutputStream(Opts.SplitDwarfOutput, Diags, IsBinary);
 
-  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
-  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
-  std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
-
   // Build up the feature string from the target feature list.
   std::string FS = llvm::join(Opts.Features, ",");
 
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
   assert(STI && "Unable to create subtarget info!");
 
-  MCContext Ctx(Triple(Opts.Triple), MAI.get(), MRI.get(), MOFI.get(),
-                STI.get(), &SrcMgr, &MCOptions);
+  MCContext Ctx(Triple(Opts.Triple), MAI.get(), MRI.get(), STI.get(), &SrcMgr,
+                &MCOptions);
 
   bool PIC = false;
   if (Opts.RelocationModel == "static") {
     PIC = false;
   } else if (Opts.RelocationModel == "pic") {
     PIC = true;
   } else {
     assert(Opts.RelocationModel == "dynamic-no-pic" &&
            "Invalid PIC model!");
     PIC = false;
   }
 
-  MOFI->initMCObjectFileInfo(Ctx, PIC);
+  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
+  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, PIC));
+  Ctx.setObjectFileInfo(MOFI.get());
+
   if (Opts.SaveTemporaryLabels)
     Ctx.setAllowTemporaryLabels(false);
   if (Opts.GenDwarfForAssembly)
     Ctx.setGenDwarfForAssembly(true);
   if (!Opts.DwarfDebugFlags.empty())
     Ctx.setDwarfDebugFlags(StringRef(Opts.DwarfDebugFlags));
   if (!Opts.DwarfDebugProducer.empty())
     Ctx.setDwarfDebugProducer(StringRef(Opts.DwarfDebugProducer));

lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.cpp

if (!subtarget_info_up)
     return Instance();
 
   llvm::MCTargetOptions MCOptions;
   std::unique_ptr<llvm::MCAsmInfo> asm_info_up(
       curr_target->createMCAsmInfo(*reg_info_up, triple, MCOptions));
   if (!asm_info_up)
     return Instance();
 
-  std::unique_ptr<llvm::MCContext> context_up(new llvm::MCContext(
-      llvm::Triple(triple), asm_info_up.get(), reg_info_up.get(),
-      /*MOFI=*/nullptr, subtarget_info_up.get()));
+  std::unique_ptr<llvm::MCContext> context_up(
+      new llvm::MCContext(llvm::Triple(triple), asm_info_up.get(),
+                          reg_info_up.get(), subtarget_info_up.get()));
   if (!context_up)
     return Instance();
 
   std::unique_ptr<llvm::MCDisassembler> disasm_up(
       curr_target->createMCDisassembler(*subtarget_info_up, *context_up));
   if (!disasm_up)
     return Instance();
 

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

#endif
   llvm::MCTargetOptions MCOptions;
   m_asm_info.reset(
       target->createMCAsmInfo(*m_reg_info, triple.getTriple(), MCOptions));
   m_subtype_info.reset(
       target->createMCSubtargetInfo(triple.getTriple(), cpu, features));
   assert(m_asm_info.get() && m_subtype_info.get());
 
   m_context = std::make_unique<llvm::MCContext>(
-      triple, m_asm_info.get(), m_reg_info.get(), /*MOFI=*/nullptr,
-      m_subtype_info.get());
+      triple, m_asm_info.get(), m_reg_info.get(), m_subtype_info.get());
   assert(m_context.get());
 
   m_disasm.reset(target->createMCDisassembler(*m_subtype_info, *m_context));
   assert(m_disasm.get());
 
   /* Create alternate disassembler for microMIPS */
   if (arch_flags & ArchSpec::eMIPSAse_mips16)
     features += "+mips16,";

lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp

#endif
   llvm::MCTargetOptions MCOptions;
   m_asm_info.reset(
       target->createMCAsmInfo(*m_reg_info, triple.getTriple(), MCOptions));
   m_subtype_info.reset(
       target->createMCSubtargetInfo(triple.getTriple(), cpu, features));
   assert(m_asm_info.get() && m_subtype_info.get());
 
   m_context = std::make_unique<llvm::MCContext>(
-      triple, m_asm_info.get(), m_reg_info.get(), /*MOFI=*/nullptr,
-      m_subtype_info.get());
+      triple, m_asm_info.get(), m_reg_info.get(), m_subtype_info.get());
   assert(m_context.get());
 
   m_disasm.reset(target->createMCDisassembler(*m_subtype_info, *m_context));
   assert(m_disasm.get());
 }
 
 void EmulateInstructionMIPS64::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),

llvm/include/llvm/MC/MCContext.h

private:
     // 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 MCObjectFileInfo *MOFI,
-                       const MCSubtargetInfo *MSTI,
+                       const MCRegisterInfo *MRI, const MCSubtargetInfo *MSTI,
                        const SourceMgr *Mgr = nullptr,
                        MCTargetOptions const *TargetOpts = nullptr,
                        bool DoAutoReset = true);
     MCContext(const MCContext &) = delete;
     MCContext &operator=(const MCContext &) = delete;
     ~MCContext();
 
     Environment getObjectFileType() const { return Env; }
 
     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;
     }
 
+    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; }
 

llvm/include/llvm/Support/TargetRegistry.h

 #ifndef LLVM_SUPPORT_TARGETREGISTRY_H
 #define LLVM_SUPPORT_TARGETREGISTRY_H
 
 #include "llvm-c/DisassemblerTypes.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>

 public:
   friend struct TargetRegistry;
 
   using ArchMatchFnTy = bool (*)(Triple::ArchType Arch);
 
   using MCAsmInfoCtorFnTy = MCAsmInfo *(*)(const MCRegisterInfo &MRI,
                                            const Triple &TT,
                                            const MCTargetOptions &Options);
+  using MCObjectFileInfoCtorFnTy = MCObjectFileInfo *(*)(MCContext &Ctx,
+                                                         bool PIC,
+                                                         bool LargeCodeModel);
   using MCInstrInfoCtorFnTy = MCInstrInfo *(*)();
   using MCInstrAnalysisCtorFnTy = MCInstrAnalysis *(*)(const MCInstrInfo *Info);
   using MCRegInfoCtorFnTy = MCRegisterInfo *(*)(const Triple &TT);
   using MCSubtargetInfoCtorFnTy = MCSubtargetInfo *(*)(const Triple &TT,
                                                        StringRef CPU,
                                                        StringRef Features);
   using TargetMachineCtorTy = TargetMachine
       *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features,
private:
 
   /// HasJIT - Whether this target supports the JIT.
   bool HasJIT;
 
   /// MCAsmInfoCtorFn - Constructor function for this target's MCAsmInfo, if
   /// registered.
   MCAsmInfoCtorFnTy MCAsmInfoCtorFn;
 
+  /// Constructor function for this target's MCObjectFileInfo, if registered.
+  MCObjectFileInfoCtorFnTy MCObjectFileInfoCtorFn;
+
   /// MCInstrInfoCtorFn - Constructor function for this target's MCInstrInfo,
   /// if registered.
   MCInstrInfoCtorFnTy MCInstrInfoCtorFn;
 
   /// MCInstrAnalysisCtorFn - Constructor function for this target's
   /// MCInstrAnalysis, if registered.
   MCInstrAnalysisCtorFnTy MCInstrAnalysisCtorFn;
 
public:
   /// host if that does not exist.
   MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI, StringRef TheTriple,
                              const MCTargetOptions &Options) const {
     if (!MCAsmInfoCtorFn)
       return nullptr;
     return MCAsmInfoCtorFn(MRI, Triple(TheTriple), Options);
   }
 
+  /// Create a MCObjectFileInfo implementation for the specified target
+  /// triple.
+  ///
+  MCObjectFileInfo *createMCObjectFileInfo(MCContext &Ctx, bool PIC,
+                                           bool LargeCodeModel = false) const {
+    if (!MCObjectFileInfoCtorFn) {
+      MCObjectFileInfo *MOFI = new MCObjectFileInfo();
+      MOFI->initMCObjectFileInfo(Ctx, PIC, LargeCodeModel);
+      return MOFI;
+    }
+    return MCObjectFileInfoCtorFn(Ctx, PIC, LargeCodeModel);
+  }
+
   /// createMCInstrInfo - Create a MCInstrInfo implementation.
   ///
   MCInstrInfo *createMCInstrInfo() const {
     if (!MCInstrInfoCtorFn)
       return nullptr;
     return MCInstrInfoCtorFn();
   }
 
struct TargetRegistry {
   /// this is done by initializing all targets at program startup.
   ///
   /// @param T - The target being registered.
   /// @param Fn - A function to construct a MCAsmInfo for the target.
   static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
     T.MCAsmInfoCtorFn = Fn;
   }
 
+  /// Register a MCObjectFileInfo implementation for the given target.
+  ///
+  /// Clients are responsible for ensuring that registration doesn't occur
+  /// while another thread is attempting to access the registry. Typically
+  /// this is done by initializing all targets at program startup.
+  ///
+  /// @param T - The target being registered.
+  /// @param Fn - A function to construct a MCObjectFileInfo for the target.
+  static void RegisterMCObjectFileInfo(Target &T,
+                                       Target::MCObjectFileInfoCtorFnTy Fn) {
+    T.MCObjectFileInfoCtorFn = Fn;
+  }
+
   /// RegisterMCInstrInfo - Register a MCInstrInfo implementation for the
   /// given target.
   ///
   /// Clients are responsible for ensuring that registration doesn't occur
   /// while another thread is attempting to access the registry. Typically
   /// this is done by initializing all targets at program startup.
   ///
   /// @param T - The target being registered.

 ///   RegisterMCAsmInfoFn X(TheFooTarget, TheFunction);
 /// }
 struct RegisterMCAsmInfoFn {
   RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
     TargetRegistry::RegisterMCAsmInfo(T, Fn);
   }
 };
 
+/// Helper template for registering a target object file info implementation.
+/// This invokes the static "Create" method on the class to actually do the
+/// construction.  Usage:
+///
+/// extern "C" void LLVMInitializeFooTarget() {
+///   extern Target TheFooTarget;
+///   RegisterMCObjectFileInfo<FooMCObjectFileInfo> X(TheFooTarget);
+/// }
+template <class MCObjectFileInfoImpl> struct RegisterMCObjectFileInfo {
+  RegisterMCObjectFileInfo(Target &T) {
+    TargetRegistry::RegisterMCObjectFileInfo(T, &Allocator);
+  }
+
+private:
+  static MCObjectFileInfo *Allocator(MCContext &Ctx, bool PIC,
+                                     bool LargeCodeModel = false) {
+    return new MCObjectFileInfoImpl(Ctx, PIC, LargeCodeModel);
+  }
+};
+
+/// Helper template for registering a target object file info implementation.
+/// This invokes the specified function to do the construction.  Usage:
+///
+/// extern "C" void LLVMInitializeFooTarget() {
+///   extern Target TheFooTarget;
+///   RegisterMCObjectFileInfoFn X(TheFooTarget, TheFunction);
+/// }
+struct RegisterMCObjectFileInfoFn {
+  RegisterMCObjectFileInfoFn(Target &T, Target::MCObjectFileInfoCtorFnTy Fn) {
+    TargetRegistry::RegisterMCObjectFileInfo(T, Fn);
+  }
+};
+
 /// RegisterMCInstrInfo - Helper template for registering a target instruction
 /// info implementation.  This invokes the static "Create" method on the class
 /// to actually do the construction.  Usage:
 ///
 /// extern "C" void LLVMInitializeFooTarget() {
 ///   extern Target TheFooTarget;
 ///   RegisterMCInstrInfo<FooMCInstrInfo> X(TheFooTarget);
 /// }

llvm/lib/CodeGen/MachineModuleInfo.cpp

void MachineModuleInfo::finalize() {
 
   delete ObjFileMMI;
   ObjFileMMI = nullptr;
 }
 
 MachineModuleInfo::MachineModuleInfo(MachineModuleInfo &&MMI)
     : TM(std::move(MMI.TM)),
       Context(MMI.TM.getTargetTriple(), MMI.TM.getMCAsmInfo(),
-              MMI.TM.getMCRegisterInfo(), MMI.TM.getObjFileLowering(),
-              MMI.TM.getMCSubtargetInfo(), nullptr, nullptr, false),
+              MMI.TM.getMCRegisterInfo(), MMI.TM.getMCSubtargetInfo(), nullptr,
+              nullptr, false),
       MachineFunctions(std::move(MMI.MachineFunctions)) {
+  Context.setObjectFileInfo(MMI.TM.getObjFileLowering());
   ObjFileMMI = MMI.ObjFileMMI;
   CurCallSite = MMI.CurCallSite;
   UsesMSVCFloatingPoint = MMI.UsesMSVCFloatingPoint;
   UsesMorestackAddr = MMI.UsesMorestackAddr;
   HasSplitStack = MMI.HasSplitStack;
   HasNosplitStack = MMI.HasNosplitStack;
   AddrLabelSymbols = MMI.AddrLabelSymbols;
   ExternalContext = MMI.ExternalContext;
   TheModule = MMI.TheModule;
 }
 
 MachineModuleInfo::MachineModuleInfo(const LLVMTargetMachine *TM)
     : TM(*TM), Context(TM->getTargetTriple(), TM->getMCAsmInfo(),
-                       TM->getMCRegisterInfo(), TM->getObjFileLowering(),
-                       TM->getMCSubtargetInfo(), nullptr, nullptr, false) {
+                       TM->getMCRegisterInfo(), TM->getMCSubtargetInfo(),
+                       nullptr, nullptr, false) {
+  Context.setObjectFileInfo(TM->getObjFileLowering());
   initialize();
 }
 
 MachineModuleInfo::MachineModuleInfo(const LLVMTargetMachine *TM,
                                      MCContext *ExtContext)
     : TM(*TM), Context(TM->getTargetTriple(), TM->getMCAsmInfo(),
-                       TM->getMCRegisterInfo(), TM->getObjFileLowering(),
-                       TM->getMCSubtargetInfo(), nullptr, nullptr, false),
+                       TM->getMCRegisterInfo(), TM->getMCSubtargetInfo(),
+                       nullptr, nullptr, false),
       ExternalContext(ExtContext) {
+  Context.setObjectFileInfo(TM->getObjFileLowering());
   initialize();
 }
 
 MachineModuleInfo::~MachineModuleInfo() { finalize(); }
 
 //===- Address of Block Management ----------------------------------------===//
 
 ArrayRef<MCSymbol *>

llvm/lib/DWARFLinker/DWARFStreamer.cpp

bool DwarfStreamer::init(Triple TheTriple) {
   MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   if (!MAI)
     return error("no asm info for target " + TripleName, Context), false;
 
   MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
   if (!MSTI)
     return error("no subtarget info for target " + TripleName, Context), false;
 
-  MOFI.reset(new MCObjectFileInfo);
-  MC.reset(
-      new MCContext(TheTriple, MAI.get(), MRI.get(), MOFI.get(), MSTI.get()));
-  MOFI->initMCObjectFileInfo(*MC, /*PIC=*/false);
+  MC.reset(new MCContext(TheTriple, MAI.get(), MRI.get(), MSTI.get()));
+  MOFI.reset(TheTarget->createMCObjectFileInfo(*MC, /*PIC=*/false));
+  MC->setObjectFileInfo(MOFI.get());
 
   MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, MCOptions);
   if (!MAB)
     return error("no asm backend for target " + TripleName, Context), false;
 
   MII.reset(TheTarget->createMCInstrInfo());
   if (!MII)
     return error("no instr info info for target " + TripleName, Context), false;

llvm/lib/MC/MCContext.cpp

AsSecureLogFileName("as-secure-log-file-name",
         cl::init(getenv("AS_SECURE_LOG_FILE")), cl::Hidden);
 
 static void defaultDiagHandler(const SMDiagnostic &SMD, bool, const SourceMgr &,
                                std::vector<const MDNode *> &) {
   SMD.print(nullptr, errs());
 }
 
 MCContext::MCContext(const Triple &TheTriple, const MCAsmInfo *mai,
-                     const MCRegisterInfo *mri, const MCObjectFileInfo *mofi,
-                     const MCSubtargetInfo *msti, const SourceMgr *mgr,
-                     MCTargetOptions const *TargetOpts, bool DoAutoReset)
+                     const MCRegisterInfo *mri, const MCSubtargetInfo *msti,
+                     const SourceMgr *mgr, MCTargetOptions const *TargetOpts,
+                     bool DoAutoReset)
     : TT(TheTriple), SrcMgr(mgr), InlineSrcMgr(nullptr),
-      DiagHandler(defaultDiagHandler), MAI(mai), MRI(mri), MOFI(mofi),
-      MSTI(msti), Symbols(Allocator), UsedNames(Allocator),
+      DiagHandler(defaultDiagHandler), MAI(mai), MRI(mri), MSTI(msti),
+      Symbols(Allocator), UsedNames(Allocator),
       InlineAsmUsedLabelNames(Allocator),
       CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0),
       AutoReset(DoAutoReset), TargetOptions(TargetOpts) {
   SecureLogFile = AsSecureLogFileName;
 
   if (SrcMgr && SrcMgr->getNumBuffers())
     MainFileName = std::string(SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())
                                    ->getBufferIdentifier());

llvm/lib/MC/MCDisassembler/Disassembler.cpp

if (!MII)
     return nullptr;
 
   std::unique_ptr<const MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TT, CPU, Features));
   if (!STI)
     return nullptr;
 
   // Set up the MCContext for creating symbols and MCExpr's.
-  std::unique_ptr<MCContext> Ctx(new MCContext(Triple(TT), MAI.get(), MRI.get(),
-                                               /*MOFI=*/nullptr, STI.get()));
+  std::unique_ptr<MCContext> Ctx(
+      new MCContext(Triple(TT), MAI.get(), MRI.get(), STI.get()));
   if (!Ctx)
     return nullptr;
 
   // Set up disassembler.
   std::unique_ptr<MCDisassembler> DisAsm(
       TheTarget->createMCDisassembler(*STI, *Ctx));
   if (!DisAsm)
     return nullptr;

llvm/lib/Object/ModuleSymbolTable.cpp

std::unique_ptr<MCSubtargetInfo> STI(
       T->createMCSubtargetInfo(TT.str(), "", ""));
   if (!STI)
     return;
 
   std::unique_ptr<MCInstrInfo> MCII(T->createMCInstrInfo());
   if (!MCII)
     return;
 
-  MCObjectFileInfo MOFI;
-  MCContext MCCtx(TT, MAI.get(), MRI.get(), &MOFI, STI.get());
-  MOFI.initMCObjectFileInfo(MCCtx, /*PIC=*/false);
-  MOFI.setSDKVersion(M.getSDKVersion());
+  MCContext MCCtx(TT, MAI.get(), MRI.get(), STI.get());
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      T->createMCObjectFileInfo(MCCtx, /*PIC=*/false));
+  MOFI->setSDKVersion(M.getSDKVersion());
+  MCCtx.setObjectFileInfo(MOFI.get());
   RecordStreamer Streamer(MCCtx, M);
   T->createNullTargetStreamer(Streamer);
 
   std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(InlineAsm));
   SourceMgr SrcMgr;
   SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
   std::unique_ptr<MCAsmParser> Parser(
       createMCAsmParser(SrcMgr, MCCtx, Streamer, *MAI));

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.h

private:
   const Target *ObjectTarget = nullptr;
   SubtargetFeatures Features;
 
   // Members required for disassembly.
   std::unique_ptr<const MCRegisterInfo> RegisterInfo;
   std::unique_ptr<const MCAsmInfo> AsmInfo;
   std::unique_ptr<MCSubtargetInfo> SubtargetInfo;
   std::unique_ptr<const MCInstrInfo> MII;
-  MCObjectFileInfo MOFI;
   std::unique_ptr<MCContext> Context;
   std::unique_ptr<const MCDisassembler> Disassembler;
   std::unique_ptr<const MCInstrAnalysis> MIA;
   std::unique_ptr<MCInstPrinter> Printer;
 
   // Symbolizer used for debug information parsing.
   std::unique_ptr<symbolize::LLVMSymbolizer> Symbolizer;
 

llvm/tools/llvm-cfi-verify/lib/FileAnalysis.cpp

if (!SubtargetInfo)
     return make_error<UnsupportedDisassembly>(
         "Failed to initialise SubtargetInfo.");
 
   MII.reset(ObjectTarget->createMCInstrInfo());
   if (!MII)
     return make_error<UnsupportedDisassembly>("Failed to initialise MII.");
 
   Context.reset(new MCContext(Triple(TripleName), AsmInfo.get(),
-                              RegisterInfo.get(), &MOFI, SubtargetInfo.get()));
+                              RegisterInfo.get(), SubtargetInfo.get()));
 
   Disassembler.reset(
       ObjectTarget->createMCDisassembler(*SubtargetInfo, *Context));
 
   if (!Disassembler)
     return make_error<UnsupportedDisassembly>(
         "No disassembler available for target");
 

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

int main(int argc, char **argv) {
   if (!MAI)
     return error("no asm info for target " + TripleName, Context);
 
   std::unique_ptr<MCSubtargetInfo> MSTI(
       TheTarget->createMCSubtargetInfo(TripleName, "", ""));
   if (!MSTI)
     return error("no subtarget info for target " + TripleName, Context);
 
-  MCObjectFileInfo MOFI;
-  MCContext MC(*ErrOrTriple, MAI.get(), MRI.get(), &MOFI, MSTI.get());
-  MOFI.initMCObjectFileInfo(MC, /*PIC=*/false);
+  MCContext MC(*ErrOrTriple, MAI.get(), MRI.get(), MSTI.get());
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(MC, /*PIC=*/false));
+  MC.setObjectFileInfo(MOFI.get());
 
   MCTargetOptions Options;
   auto MAB = TheTarget->createMCAsmBackend(*MSTI, *MRI, Options);
   if (!MAB)
     return error("no asm backend for target " + TripleName, Context);
 
   std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo());
   if (!MII)

llvm/tools/llvm-exegesis/lib/Analysis.h

private:
   // Builds a list of ResolvedSchedClassAndPoints.
   std::vector<ResolvedSchedClassAndPoints> makePointsPerSchedClass() const;
 
   template <typename EscapeTag, EscapeTag Tag>
   void writeSnippet(raw_ostream &OS, ArrayRef<uint8_t> Bytes,
                     const char *Separator) const;
 
   const InstructionBenchmarkClustering &Clustering_;
-  MCObjectFileInfo ObjectFileInfo_;
   std::unique_ptr<MCContext> Context_;
   std::unique_ptr<MCSubtargetInfo> SubtargetInfo_;
   std::unique_ptr<MCInstrInfo> InstrInfo_;
   std::unique_ptr<MCRegisterInfo> RegInfo_;
   std::unique_ptr<MCAsmInfo> AsmInfo_;
   std::unique_ptr<MCInstPrinter> InstPrinter_;
   std::unique_ptr<MCDisassembler> Disasm_;
   const double AnalysisInconsistencyEpsilonSquared_;
   const bool AnalysisDisplayUnstableOpcodes_;
 };
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_CLUSTERING_H

llvm/tools/llvm-exegesis/lib/Analysis.cpp

Analysis::Analysis(const Target &Target, std::unique_ptr<MCInstrInfo> InstrInfo,
   AsmInfo_.reset(
       Target.createMCAsmInfo(*RegInfo_, FirstPoint.LLVMTriple, MCOptions));
   SubtargetInfo_.reset(
       Target.createMCSubtargetInfo(FirstPoint.LLVMTriple, CpuName, ""));
   InstPrinter_.reset(Target.createMCInstPrinter(
       Triple(FirstPoint.LLVMTriple), 0 /*default variant*/, *AsmInfo_,
       *InstrInfo_, *RegInfo_));
 
-  Context_ = std::make_unique<MCContext>(
-      Triple(FirstPoint.LLVMTriple), AsmInfo_.get(), RegInfo_.get(),
-      &ObjectFileInfo_, SubtargetInfo_.get());
+  Context_ =
+      std::make_unique<MCContext>(Triple(FirstPoint.LLVMTriple), AsmInfo_.get(),
+                                  RegInfo_.get(), SubtargetInfo_.get());
   Disasm_.reset(Target.createMCDisassembler(*SubtargetInfo_, *Context_));
   assert(Disasm_ && "cannot create MCDisassembler. missing call to "
                     "InitializeXXXTargetDisassembler ?");
 }
 
 template <>
 Error Analysis::run<Analysis::PrintClusters>(raw_ostream &OS) const {
   if (Clustering_.getPoints().empty())

llvm/tools/llvm-exegesis/lib/LlvmState.cpp

return std::unique_ptr<LLVMTargetMachine>(static_cast<LLVMTargetMachine *>(
       TheTargetMachine->getTarget().createTargetMachine(
           TheTargetMachine->getTargetTriple().normalize(),
           TheTargetMachine->getTargetCPU(),
           TheTargetMachine->getTargetFeatureString(), TheTargetMachine->Options,
           Reloc::Model::Static)));
 }
 
 bool LLVMState::canAssemble(const MCInst &Inst) const {
-  MCObjectFileInfo ObjectFileInfo;
   MCContext Context(TheTargetMachine->getTargetTriple(),
                     TheTargetMachine->getMCAsmInfo(),
-                    TheTargetMachine->getMCRegisterInfo(), &ObjectFileInfo,
+                    TheTargetMachine->getMCRegisterInfo(),
                     TheTargetMachine->getMCSubtargetInfo());
   std::unique_ptr<const MCCodeEmitter> CodeEmitter(
       TheTargetMachine->getTarget().createMCCodeEmitter(
           *TheTargetMachine->getMCInstrInfo(), *TheTargetMachine->getMCRegisterInfo(),
           Context));
   assert(CodeEmitter && "unable to create code emitter");
   SmallVector<char, 16> Tmp;
   raw_svector_ostream OS(Tmp);
   SmallVector<MCFixup, 4> Fixups;
   CodeEmitter->encodeInstruction(Inst, OS, Fixups,
                                  *TheTargetMachine->getMCSubtargetInfo());
   return Tmp.size() > 0;
 }
 
 } // namespace exegesis
 } // namespace llvm

llvm/tools/llvm-exegesis/lib/SnippetFile.cpp

if (std::error_code EC = BufferPtr.getError()) {
     return make_error<Failure>("cannot read snippet: " + Filename + ": " +
                                EC.message());
   }
   SourceMgr SM;
   SM.AddNewSourceBuffer(std::move(BufferPtr.get()), SMLoc());
 
   BenchmarkCode Result;
 
-  MCObjectFileInfo ObjectFileInfo;
   const TargetMachine &TM = State.getTargetMachine();
   MCContext Context(TM.getTargetTriple(), TM.getMCAsmInfo(),
-                    TM.getMCRegisterInfo(), &ObjectFileInfo,
-                    TM.getMCSubtargetInfo());
+                    TM.getMCRegisterInfo(), TM.getMCSubtargetInfo());
+  std::unique_ptr<MCObjectFileInfo> ObjectFileInfo(
+      TM.getTarget().createMCObjectFileInfo(Context, /*PIC=*/false));
+  Context.setObjectFileInfo(ObjectFileInfo.get());
   Context.initInlineSourceManager();
-  ObjectFileInfo.initMCObjectFileInfo(Context, /*PIC=*/false);
   BenchmarkCodeStreamer Streamer(&Context, TM.getMCRegisterInfo(), &Result);
 
   std::string Error;
   raw_string_ostream ErrorStream(Error);
   formatted_raw_ostream InstPrinterOStream(ErrorStream);
   const std::unique_ptr<MCInstPrinter> InstPrinter(
       TM.getTarget().createMCInstPrinter(
           TM.getTargetTriple(), TM.getMCAsmInfo()->getAssemblerDialect(),

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

static Error runChecks(Session &S) {
   MCTargetOptions MCOptions;
   std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   if (!MAI)
     ExitOnErr(make_error<StringError>("Unable to create target asm info " +
                                           TripleName,
                                       inconvertibleErrorCode()));
 
-  MCContext Ctx(Triple(TripleName), MAI.get(), MRI.get(), /*MOFI=*/nullptr,
-                STI.get());
+  MCContext Ctx(Triple(TripleName), MAI.get(), MRI.get(), STI.get());
 
   std::unique_ptr<MCDisassembler> Disassembler(
       TheTarget->createMCDisassembler(*STI, Ctx));
   if (!Disassembler)
     ExitOnErr(make_error<StringError>("Unable to create disassembler for " +
                                           TripleName,
                                       inconvertibleErrorCode()));
 

llvm/tools/llvm-mc-assemble-fuzzer/llvm-mc-assemble-fuzzer.cpp

int AssembleOneInput(const uint8_t *Data, size_t Size) {
   if (!MAI) {
     errs() << "Unable to create target asm info!";
     abort();
   }
 
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
 
-  MCObjectFileInfo MOFI;
-  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), &MOFI, STI.get(), &SrcMgr);
-  static const bool UsePIC = false;
-  MOFI.initMCObjectFileInfo(Ctx, UsePIC);
+  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
+  Ctx.setObjectFileInfo(MOFI.get());
 
   const unsigned OutputAsmVariant = 0;
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   MCInstPrinter *IP = TheTarget->createMCInstPrinter(Triple(TripleName), OutputAsmVariant,
       *MAI, *MCII, *MRI);
   if (!IP) {
     errs()
       << "error: unable to create instruction printer for target triple '"

llvm/tools/llvm-mc/llvm-mc.cpp

int main(int argc, char **argv) {
   }
 
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
   assert(STI && "Unable to create subtarget info!");
 
   // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
-  MCObjectFileInfo MOFI;
-  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), &MOFI, STI.get(), &SrcMgr,
+  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr,
                 &MCOptions);
-  MOFI.initMCObjectFileInfo(Ctx, PIC, LargeCodeModel);
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, PIC, LargeCodeModel));
+  Ctx.setObjectFileInfo(MOFI.get());
 
   if (SaveTempLabels)
     Ctx.setAllowTemporaryLabels(false);
 
   Ctx.setGenDwarfForAssembly(GenDwarfForAssembly);
   // Default to 4 for dwarf version.
   unsigned DwarfVersion = MCOptions.DwarfVersion ? MCOptions.DwarfVersion : 4;
   if (DwarfVersion < 2 || DwarfVersion > 5) {

llvm/tools/llvm-mca/llvm-mca.cpp

int main(int argc, char **argv) {
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
   assert(MRI && "Unable to create target register info!");
 
   MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
   std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   assert(MAI && "Unable to create target asm info!");
 
-  MCObjectFileInfo MOFI;
   SourceMgr SrcMgr;
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*BufferPtr), SMLoc());
 
-  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), &MOFI, STI.get(), &SrcMgr);
-
-  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false);
+  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
+  Ctx.setObjectFileInfo(MOFI.get());
 
   std::unique_ptr<buffer_ostream> BOS;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   assert(MCII && "Unable to create instruction info!");
 
   std::unique_ptr<MCInstrAnalysis> MCIA(
       TheTarget->createMCInstrAnalysis(MCII.get()));

llvm/tools/llvm-ml/Disassembler.cpp

int Disassembler::disassemble(const Target &T, const std::string &TripleName,
   std::unique_ptr<const MCAsmInfo> MAI(
       T.createMCAsmInfo(*MRI, TripleName, MCOptions));
   if (!MAI) {
     errs() << "error: no assembly info for target " << TripleName << "\n";
     return -1;
   }
 
   // Set up the MCContext for creating symbols and MCExpr's.
-  MCContext Ctx(Triple(TripleName), MAI.get(), MRI.get(), /*MOFI=*/nullptr,
-                &STI);
+  MCContext Ctx(Triple(TripleName), MAI.get(), MRI.get(), &STI);
 
   std::unique_ptr<const MCDisassembler> DisAsm(
       T.createMCDisassembler(STI, Ctx));
   if (!DisAsm) {
     errs() << "error: no disassembler for target " << TripleName << "\n";
     return -1;
   }
 

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

int main(int Argc, char **Argv) {
   MAI->setPreserveAsmComments(InputArgs.hasArg(OPT_preserve_comments));
 
   std::unique_ptr<MCSubtargetInfo> STI(TheTarget->createMCSubtargetInfo(
       TripleName, /*CPU=*/"", /*Features=*/""));
   assert(STI && "Unable to create subtarget info!");
 
   // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
-  MCObjectFileInfo MOFI;
-  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), &MOFI, STI.get(), &SrcMgr);
-  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false,
-                            /*LargeCodeModel=*/true);
+  MCContext Ctx(TheTriple, MAI.get(), MRI.get(), STI.get(), &SrcMgr);
+  std::unique_ptr<MCObjectFileInfo> MOFI(TheTarget->createMCObjectFileInfo(
+      Ctx, /*PIC=*/false, /*LargeCodeModel=*/true));
+  Ctx.setObjectFileInfo(MOFI.get());
 
   if (InputArgs.hasArg(OPT_save_temp_labels))
     Ctx.setAllowTemporaryLabels(false);
 
   // Set compilation information.
   SmallString<128> CWD;
   if (!sys::fs::current_path(CWD))
     Ctx.setCompilationDir(CWD);

llvm/tools/llvm-objdump/MachODump.cpp

std::unique_ptr<const MCRegisterInfo> MRI(
       TheTarget->createMCRegInfo(TripleName));
   CHECK_TARGET_INFO_CREATION(MRI);
   std::unique_ptr<const MCAsmInfo> AsmInfo(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   CHECK_TARGET_INFO_CREATION(AsmInfo);
   std::unique_ptr<const MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MachOMCPU, FeaturesStr));
   CHECK_TARGET_INFO_CREATION(STI);
-  MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), /*MOFI=*/nullptr,
-                STI.get());
+  MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get());
   std::unique_ptr<MCDisassembler> DisAsm(
       TheTarget->createMCDisassembler(*STI, Ctx));
   CHECK_TARGET_INFO_CREATION(DisAsm);
   std::unique_ptr<MCSymbolizer> Symbolizer;
   struct DisassembleInfo SymbolizerInfo(nullptr, nullptr, nullptr, false);
   std::unique_ptr<MCRelocationInfo> RelInfo(
       TheTarget->createMCRelocationInfo(TripleName, Ctx));
   if (RelInfo) {
if (ThumbTarget) {
     ThumbAsmInfo.reset(
         ThumbTarget->createMCAsmInfo(*ThumbMRI, ThumbTripleName, MCOptions));
     CHECK_THUMB_TARGET_INFO_CREATION(ThumbAsmInfo);
     ThumbSTI.reset(
         ThumbTarget->createMCSubtargetInfo(ThumbTripleName, MachOMCPU,
                                            FeaturesStr));
     CHECK_THUMB_TARGET_INFO_CREATION(ThumbSTI);
     ThumbCtx.reset(new MCContext(Triple(ThumbTripleName), ThumbAsmInfo.get(),
-                                 ThumbMRI.get(), /*MOFI=*/nullptr,
-                                 ThumbSTI.get()));
+                                 ThumbMRI.get(), ThumbSTI.get()));
     ThumbDisAsm.reset(ThumbTarget->createMCDisassembler(*ThumbSTI, *ThumbCtx));
     CHECK_THUMB_TARGET_INFO_CREATION(ThumbDisAsm);
     MCContext *PtrThumbCtx = ThumbCtx.get();
     ThumbRelInfo.reset(
         ThumbTarget->createMCRelocationInfo(ThumbTripleName, *PtrThumbCtx));
     if (ThumbRelInfo) {
       ThumbSymbolizer.reset(ThumbTarget->createMCSymbolizer(
           ThumbTripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,

llvm/tools/llvm-objdump/llvm-objdump.cpp

std::unique_ptr<const MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
   if (!STI)
     reportError(Obj->getFileName(),
                 "no subtarget info for target " + TripleName);
   std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
   if (!MII)
     reportError(Obj->getFileName(),
                 "no instruction info for target " + TripleName);
-  MCObjectFileInfo MOFI;
-  MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), &MOFI, STI.get());
+  MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get());
   // FIXME: for now initialize MCObjectFileInfo with default values
-  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false);
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
+  Ctx.setObjectFileInfo(MOFI.get());
 
   std::unique_ptr<MCDisassembler> DisAsm(
       TheTarget->createMCDisassembler(*STI, Ctx));
   if (!DisAsm)
     reportError(Obj->getFileName(), "no disassembler for target " + TripleName);
 
   // If we have an ARM object file, we need a second disassembler, because
   // ARM CPUs have two different instruction sets: ARM mode, and Thumb mode.

llvm/tools/llvm-profgen/ProfiledBinary.cpp

STI.reset(
       TheTarget->createMCSubtargetInfo(TripleName, "", Features.getString()));
   if (!STI)
     exitWithError("no subtarget info for target " + TripleName, FileName);
 
   MII.reset(TheTarget->createMCInstrInfo());
   if (!MII)
     exitWithError("no instruction info for target " + TripleName, FileName);
 
-  MCObjectFileInfo MOFI;
-  MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), &MOFI, STI.get());
-  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false);
+  MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get());
+  std::unique_ptr<MCObjectFileInfo> MOFI(
+      TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
+  Ctx.setObjectFileInfo(MOFI.get());
   DisAsm.reset(TheTarget->createMCDisassembler(*STI, Ctx));
   if (!DisAsm)
     exitWithError("no disassembler for target " + TripleName, FileName);
 
   MIA.reset(TheTarget->createMCInstrAnalysis(MII.get()));
 
   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
   IPrinter.reset(TheTarget->createMCInstPrinter(

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

if (!MRI)
     ErrorAndExit("Unable to create target register info!");
 
   MCTargetOptions MCOptions;
   std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   if (!MAI)
     ErrorAndExit("Unable to create target asm info!");
 
-  MCContext Ctx(Triple(TripleName), MAI.get(), MRI.get(), /*MOFI=*/nullptr,
-                STI.get());
+  MCContext Ctx(Triple(TripleName), MAI.get(), MRI.get(), STI.get());
 
   std::unique_ptr<MCDisassembler> Disassembler(
     TheTarget->createMCDisassembler(*STI, Ctx));
   if (!Disassembler)
     ErrorAndExit("Unable to create disassembler!");
 
   std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo());
   if (!MII)

llvm/tools/sancov/sancov.cpp

std::unique_ptr<const MCRegisterInfo> MRI(
       TheTarget->createMCRegInfo(TripleName));
   failIfEmpty(MRI, "no register info for target " + TripleName);
 
   MCTargetOptions MCOptions;
   std::unique_ptr<const MCAsmInfo> AsmInfo(
       TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   failIfEmpty(AsmInfo, "no asm info for target " + TripleName);
 
-  std::unique_ptr<const MCObjectFileInfo> MOFI(new MCObjectFileInfo);
-  MCContext Ctx(TheTriple, AsmInfo.get(), MRI.get(), MOFI.get(), STI.get());
+  MCContext Ctx(TheTriple, AsmInfo.get(), MRI.get(), STI.get());
   std::unique_ptr<MCDisassembler> DisAsm(
       TheTarget->createMCDisassembler(*STI, Ctx));
   failIfEmpty(DisAsm, "no disassembler info for target " + TripleName);
 
   std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
   failIfEmpty(MII, "no instruction info for target " + TripleName);
 
   std::unique_ptr<const MCInstrAnalysis> MIA(

llvm/unittests/CodeGen/MachineInstrTest.cpp

 namespace {
 // Include helper functions to ease the manipulation of MachineFunctions.
 #include "MFCommon.inc"
 
 std::unique_ptr<MCContext> createMCContext(MCAsmInfo *AsmInfo) {
   Triple TheTriple(/*ArchStr=*/"", /*VendorStr=*/"", /*OSStr=*/"",
                    /*EnvironmentStr=*/"elf");
   return std::make_unique<MCContext>(TheTriple, AsmInfo, nullptr, nullptr,
-                                     nullptr, nullptr, nullptr, false);
+                                     nullptr, nullptr, false);
 }
 
 // This test makes sure that MachineInstr::isIdenticalTo handles Defs correctly
 // for various combinations of IgnoreDefs, and also that it is symmetrical.
 TEST(IsIdenticalToTest, DifferentDefs) {
   LLVMContext Ctx;
   Module Mod("Module", Ctx);
   auto MF = createMachineFunction(Ctx, Mod);

llvm/unittests/CodeGen/MachineOperandTest.cpp

MO.print(OS, MST, LLT{}, /*OpIdx*/~0U, /*PrintDef=*/false, /*IsStandalone=*/false,
            /*ShouldPrintRegisterTies=*/false, 0, /*TRI=*/nullptr,
            /*IntrinsicInfo=*/nullptr);
   ASSERT_TRUE(OS.str() == "!0");
 }
 
 TEST(MachineOperandTest, PrintMCSymbol) {
   MCAsmInfo MAI;
   Triple T = Triple("unknown-unknown-unknown");
-  MCContext Ctx(T, &MAI, /*MRI=*/nullptr, /*MOFI=*/nullptr, /*MSTI=*/nullptr);
+  MCContext Ctx(T, &MAI, /*MRI=*/nullptr, /*MSTI=*/nullptr);
   MCSymbol *Sym = Ctx.getOrCreateSymbol("foo");
 
   // Create a MachineOperand with a metadata and print it.
   MachineOperand MO = MachineOperand::CreateMCSymbol(Sym);
 
   // Checking some preconditions on the newly created
   // MachineOperand.
   ASSERT_TRUE(MO.isMCSymbol());

llvm/unittests/CodeGen/TestAsmPrinter.cpp

llvm::Error TestAsmPrinter::init(const Target *TheTarget, StringRef TripleName,
   TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
                                           None));
   if (!TM)
     return make_error<StringError>("no target machine for target " + TripleName,
                                    inconvertibleErrorCode());
 
   Triple TheTriple(TripleName);
   MC.reset(new MCContext(TheTriple, TM->getMCAsmInfo(), TM->getMCRegisterInfo(),
-                         TM->getObjFileLowering(), TM->getMCSubtargetInfo()));
+                         TM->getMCSubtargetInfo()));
   TM->getObjFileLowering()->Initialize(*MC, *TM);
+  MC->setObjectFileInfo(TM->getObjFileLowering());
 
   MS = new StrictMock<MockMCStreamer>(MC.get());
 
   Asm.reset(
       TheTarget->createAsmPrinter(*TM, std::unique_ptr<MockMCStreamer>(MS)));
   if (!Asm)
     return make_error<StringError>("no asm printer for target " + TripleName,
                                    inconvertibleErrorCode());

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp

return make_error<StringError>("no instr info info for target " +
                                    inconvertibleErrorCode());
 
   TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
                                           None));
   if (!TM)
     return make_error<StringError>("no target machine for target " + TripleName,
                                    inconvertibleErrorCode());
 
+  MC.reset(new MCContext(TheTriple, MAI.get(), MRI.get(), MSTI.get()));
   TLOF = TM->getObjFileLowering();
-  MC.reset(new MCContext(TheTriple, MAI.get(), MRI.get(), TLOF, MSTI.get()));
   TLOF->Initialize(*MC, *TM);
+  MC->setObjectFileInfo(TLOF);
 
   MCE = TheTarget->createMCCodeEmitter(*MII, *MRI, *MC);
   if (!MCE)
     return make_error<StringError>("no code emitter for target " + TripleName,
                                    inconvertibleErrorCode());
 
   Stream = std::make_unique<raw_svector_ostream>(FileBytes);
 

llvm/unittests/MC/DwarfLineTables.cpp

Context() {
     const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
     if (!TheTarget)
       return;
 
     MRI.reset(TheTarget->createMCRegInfo(TripleName));
     MCTargetOptions MCOptions;
     MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
     Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(), MRI.get(),
-                                      /*MOFI=*/nullptr, /*MSTI=*/nullptr);
+                                      /*MSTI=*/nullptr);
   }
 
   operator bool() { return Ctx.get(); }
   operator MCContext &() { return *Ctx; };
 };
 
 Context &getContext() {
   static Context Ctxt;

llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp

static void SetUpTestCase() {
     LLVMInitializeSystemZTargetInfo();
     LLVMInitializeSystemZTargetMC();
     LLVMInitializeSystemZAsmParser();
   }
 
   std::unique_ptr<MCRegisterInfo> MRI;
   std::unique_ptr<MockedUpMCAsmInfo> MUPMAI;
   std::unique_ptr<const MCInstrInfo> MII;
+  std::unique_ptr<MCObjectFileInfo> MOFI;
   std::unique_ptr<MCStreamer> Str;
   std::unique_ptr<MCAsmParser> Parser;
   std::unique_ptr<MCContext> Ctx;
   std::unique_ptr<MCSubtargetInfo> STI;
   std::unique_ptr<MCTargetAsmParser> TargetAsmParser;
 
   SourceMgr SrcMgr;
   std::string TripleName;
   llvm::Triple Triple;
   const Target *TheTarget;
 
   const MCTargetOptions MCOptions;
-  MCObjectFileInfo MOFI;
 
   SystemZAsmLexerTest() {
     // We will use the SystemZ triple, because of missing
     // Object File and Streamer support for the z/OS target.
     TripleName = "s390x-ibm-linux";
     Triple = llvm::Triple(TripleName);
 
     std::string Error;
SystemZAsmLexerTest() {
     EXPECT_EQ(MAI, nullptr);
   }
 
   void setupCallToAsmParser(StringRef AsmStr) {
     std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(AsmStr));
     SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
     EXPECT_EQ(Buffer, nullptr);
 
-    Ctx.reset(new MCContext(Triple, MUPMAI.get(), MRI.get(), &MOFI, STI.get(),
-                            &SrcMgr, &MCOptions));
-    MOFI.initMCObjectFileInfo(*Ctx, /*PIC=*/false, /*LargeCodeModel=*/false);
+    Ctx.reset(new MCContext(Triple, MUPMAI.get(), MRI.get(), STI.get(), &SrcMgr,
+                            &MCOptions));
+    MOFI.reset(TheTarget->createMCObjectFileInfo(*Ctx, /*PIC=*/false,
+                                                 /*LargeCodeModel=*/false));
+    Ctx->setObjectFileInfo(MOFI.get());
 
     Str.reset(TheTarget->createNullStreamer(*Ctx));
 
     Parser.reset(createMCAsmParser(SrcMgr, *Ctx, *Str, *MUPMAI));
 
     TargetAsmParser.reset(
         TheTarget->createMCAsmParser(*STI, *Parser, *MII, MCOptions));
     Parser->setTargetParser(*TargetAsmParser);

mlir/lib/Dialect/GPU/Transforms/SerializeToHsaco.cpp

SerializeToHsacoPass::assembleIsa(const std::string &isa) {
 
   const llvm::MCTargetOptions mcOptions;
   std::unique_ptr<llvm::MCRegisterInfo> mri(
       target->createMCRegInfo(this->triple));
   std::unique_ptr<llvm::MCAsmInfo> mai(
       target->createMCAsmInfo(*mri, this->triple, mcOptions));
   mai->setRelaxELFRelocations(true);
 
-  llvm::MCObjectFileInfo mofi;
-  llvm::MCContext ctx(triple, mai.get(), mri.get(), &mofi, &srcMgr, &mcOptions);
-  mofi.initMCObjectFileInfo(ctx, /*PIC=*/false, /*LargeCodeModel=*/false);
+  llvm::MCContext ctx(triple, mai.get(), mri.get(), &srcMgr, &mcOptions);
+  std::unique_ptr<llvm::MCObjectFileInfo> mofi(target->createMCObjectFileInfo(
+      ctx, /*PIC=*/false, /*LargeCodeModel=*/false));
+  ctx.setObjectFileInfo(mofi.get());
 
   SmallString<128> cwd;
   if (!llvm::sys::fs::current_path(cwd))
     ctx.setCompilationDir(cwd);
 
   std::unique_ptr<llvm::MCStreamer> mcStreamer;
   std::unique_ptr<llvm::MCInstrInfo> mcii(target->createMCInstrInfo());
   std::unique_ptr<llvm::MCSubtargetInfo> sti(