[MC] Untangle MCContext and MCObjectFileInfo

[flip1995]

Summary

This untangles the MCContext and the MCObjectFileInfo. There is a circular
dependency between MCContext and MCObjectFileInfo. Currently this dependency
also exists during construction: You can't contruct a MOFI without a MCContext
without constructing the MCContext with a dummy version of that MOFI first.
This removes this dependency during construction. In a perfect world,
MCObjectFileInfo wouldn't depend on MCContext at all, but only be stored in the
MCContext, like other MC information. This is future work.

This also shifts/adds more information to the MCContext making it more
available to the different targets. Namely:

• TargetTriple
• ObjectFileType
• SubtargetInfo

[jrtc27]

What's the benefit of less-aligned functions? Is that not more likely to get poor performance due to cache line straddling of the first instruction? Regardless, the functional change should be separated out from the refactoring.

[MaskRay]

The refactoring part seems useful on its own. The controversial 4-byte alignment part should be split.

[flip1995]

Thanks for the review! I already thought that I will have to split this up, so I made the commits self contained so I'll do that. One question before I start:

Where should I split this? Should I only split out the RISC-V patch and leave the changes that targets can define their own MCObjectFileInfo in (commit a1b3a604a410), or should I also split out that part? Personally I would keep this change in the refactor PR and only split out the RISC-V changes.

---

About the alignment change: I guess we can discuss this then specifically for RISC-V in the split out review. But the short answer is: The main motivation is improving code size a bit, since less padding has to be added between functions. If function alignment is important -align-all-functions=X could be used.

[MaskRay]

The InitMCObjectFileInfo refactoring is good, but I'll suggest initMCObjectFileInfo(MCContext &ctx, bool PIC, bool LargeCodeModel) (change the function name to lowerCase, and reorder MCContext before bool arguments): if you are changing the signature and all the call sites, you can just fix the function naming.

The refactoring adding Triple to MCContext::MCContext and adding setObjectFileInfo should be separate. We sill want to see whether that is good.

The RISC-V functionality change should be separate as well.

[shafik]

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

909 ↗

(On Diff #341207)

Please add comments with the names of parameters for constants as documented here: https://llvm.org/docs/CodingStandards.html#comment-formatting

new llvm::MCContext(llvm::Triple(triple), asm_info_up.get(),
                    reg_info_up.get(), /*MOFI=*/nullptr, subtarget_info_up.get()));

This applies to a bunch of places, thank you!

[shafik]

clang/lib/Parse/ParseStmtAsm.cpp

590

/*PIC=*/false

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

384

/*PIC=*/ false

see clang-tidy rule that checks for this format: https://clang.llvm.org/extra/clang-tidy/checks/bugprone-argument-comment.html

[flip1995]

The refactoring adding Triple to MCContext::MCContext [...] should be separate.

In order to make the MCContext construction independent from the MCObjectFileInfo, passing the Triple to the MCContext is necessary anyway. Moving it completely to the MCContext was just the logical next step for me. It also simplifies calls across the code base since it removes an indirection over MOFI when accessing the triple.

I'll update this on Monday 👍

[flip1995]

[MC] Untangle MCContext and MCObjectFileInfo

This untangles the MCContext and the MCObjectFileInfo. There is a circular
dependency between MCContext and MCObjectFileInfo. Currently this dependency
also exists during construction: You can't contruct a MOFI without a MCContext
without constructing the MCContext with a dummy version of that MOFI first.
This removes this dependency during construction. In a perfect world,
MCObjectFileInfo wouldn't depend on MCContext at all, but only be stored in the
MCContext, like other MC information. This is future work.

This also shifts/adds more information to the MCContext making it more
available to the different targets. Namely:

• TargetTriple
• ObjectFileType
• SubtargetInfo

Included Commits:

• [MC] Add MCSubtargetInfo to MCContext
• [MC] Untangle MCContext and MCObjectFileInfo
• [MC] Move TargetTriple information from MCObjectFileInfo to MCContext

[flip1995]

Rename InitMCObjectFileInfo and reorder arguments

[flip1995]

Fix arc mistake...

[MaskRay]

Looks great!

[flip1995]

Not sure how the process from here on out is. I think it is important to note, that I don't have push rights and someone else will have to land this for me (I guess?).

[MaskRay]

In D101462#2733691, @flip1995 wrote:

Not sure how the process from here on out is. I think it is important to note, that I don't have push rights and someone else will have to land this for me (I guess?).

I'll keep this open for a few days as it touches too many things.
I can push it on your behalf afterwards but you'll need to provide your name and email https://llvm.org/docs/Phabricator.html#committing-someone-s-change-from-phabricator
(If you uploaded the diff with with git format-patch -1 instead of git diff the information would have been available)

[flip1995]

I'll keep this open for a few days as it touches too many things.

Sounds good 👍

but you'll need to provide your name and email

I used arc diff. The commits I made with git have my name and email attached. But it seems like arc doesn't use them? I'll figure it out tomorrow, can't be that hard, I hope.

Ah you just need that to commit it. In that case: "Philipp Krones <[e-mail]>"

[anirudhp]

Hi @flip1995
My apologies, but you might have to rebase this on the latest main. I introduced a MCSubtargetInfo field in https://reviews.llvm.org/D100975. Some of the existing changes to the file may not be needed anymore.

[flip1995]

rebased

[MaskRay]

In D101462#2733726, @flip1995 wrote:

I'll keep this open for a few days as it touches too many things.

Sounds good 👍

but you'll need to provide your name and email

I used arc diff. The commits I made with git have my name and email attached. But it seems like arc doesn't use them? I'll figure it out tomorrow, can't be that hard, I hope.

Ah you just need that to commit it. In that case: "Philipp Krones <[e-mail]>"

Pushed:) You are right. A diff applied with arc diff can be fetched locally with arc patch D101462 with the author information.
(Sometimes arc patch fail refuse to apply and then I'll have no idea how to get the author information.)

[jrtc27]

In D101462#2739404, @MaskRay wrote:

In D101462#2733726, @flip1995 wrote:

I'll keep this open for a few days as it touches too many things.

Sounds good 👍

but you'll need to provide your name and email

I used arc diff. The commits I made with git have my name and email attached. But it seems like arc doesn't use them? I'll figure it out tomorrow, can't be that hard, I hope.

Ah you just need that to commit it. In that case: "Philipp Krones <[e-mail]>"

Pushed:) You are right. A diff applied with arc diff can be fetched locally with arc patch D101462 with the author information.
(Sometimes arc patch fail refuse to apply and then I'll have no idea how to get the author information.)

arc amend lets you replace the metadata with the same thing arc patch adds.

clang/lib/Parse/ParseStmtAsm.cpp

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) {
     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(/*PIC=*/false, Ctx);
+  MOFI->initMCObjectFileInfo(Ctx, /*PIC=*/false);
   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 ExecuteAssembler(AssemblerInvocation &Opts,
   } else if (Opts.RelocationModel == "pic") {
     PIC = true;
   } else {
     assert(Opts.RelocationModel == "dynamic-no-pic" &&
            "Invalid PIC model!");
     PIC = false;
   }
 
-  MOFI->InitMCObjectFileInfo(PIC, Ctx);
+  MOFI->initMCObjectFileInfo(Ctx, PIC);
   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));

llvm/include/llvm/MC/MCObjectFileInfo.h

protected:
   MCSection *GFIDsSection = nullptr;
   MCSection *GIATsSection = nullptr;
   MCSection *GLJMPSection = nullptr;
 
   // XCOFF specific sections
   MCSection *TOCBaseSection = nullptr;
 
 public:
-  void InitMCObjectFileInfo(bool PIC, MCContext &ctx,
+  void initMCObjectFileInfo(MCContext &MCCtx, bool PIC,
                             bool LargeCodeModel = false);
   MCContext &getContext() const { return *Ctx; }
 
   bool getSupportsWeakOmittedEHFrame() const {
     return SupportsWeakOmittedEHFrame;
   }
   bool getSupportsCompactUnwindWithoutEHFrame() const {
     return SupportsCompactUnwindWithoutEHFrame;

llvm/lib/DWARFLinker/DWARFStreamer.cpp

bool DwarfStreamer::init(Triple TheTriple) {
 
   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(/*PIC=*/false, *MC);
+  MOFI->initMCObjectFileInfo(*MC, /*PIC=*/false);
 
   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/MCObjectFileInfo.cpp

DwarfRangesSection = Ctx->getXCOFFSection(
       ".dwrnges", SectionKind::getMetadata(), /* CsectProperties */ None,
       /* MultiSymbolsAllowed */ true, ".dwrnges", XCOFF::SSUBTYP_DWRNGES);
 
   DwarfMacinfoSection = Ctx->getXCOFFSection(
       ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ None,
       /* MultiSymbolsAllowed */ true, ".dwmac", XCOFF::SSUBTYP_DWMAC);
 }
 
-void MCObjectFileInfo::InitMCObjectFileInfo(bool PIC, MCContext &ctx,
+void MCObjectFileInfo::initMCObjectFileInfo(MCContext &MCCtx, bool PIC,
                                             bool LargeCodeModel) {
   PositionIndependent = PIC;
-  Ctx = &ctx;
+  Ctx = &MCCtx;
 
   // Common.
   CommDirectiveSupportsAlignment = true;
   SupportsWeakOmittedEHFrame = true;
   SupportsCompactUnwindWithoutEHFrame = false;
   OmitDwarfIfHaveCompactUnwind = false;
 
   FDECFIEncoding = dwarf::DW_EH_PE_absptr;

llvm/lib/Object/ModuleSymbolTable.cpp

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(/*PIC=*/false, MCCtx);
+  MOFI.initMCObjectFileInfo(MCCtx, /*PIC=*/false);
   MOFI.setSDKVersion(M.getSDKVersion());
   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(

llvm/lib/Target/TargetLoweringObjectFile.cpp

 /// Initialize - this method must be called before any actual lowering is
 /// done.  This specifies the current context for codegen, and gives the
 /// lowering implementations a chance to set up their default sections.
 void TargetLoweringObjectFile::Initialize(MCContext &ctx,
                                           const TargetMachine &TM) {
   // `Initialize` can be called more than once.
   delete Mang;
   Mang = new Mangler();
-  InitMCObjectFileInfo(TM.isPositionIndependent(), ctx,
+  initMCObjectFileInfo(ctx, TM.isPositionIndependent(),
                        TM.getCodeModel() == CodeModel::Large);
 
   // Reset various EH DWARF encodings.
   PersonalityEncoding = LSDAEncoding = TTypeEncoding = dwarf::DW_EH_PE_absptr;
   CallSiteEncoding = dwarf::DW_EH_PE_uleb128;
 
   this->TM = &TM;
 }

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

int main(int argc, char **argv) {
 
   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(/*PIC=*/false, MC);
+  MOFI.initMCObjectFileInfo(MC, /*PIC=*/false);
 
   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/SnippetFile.cpp

Expected<std::vector<BenchmarkCode>> readSnippets(const LLVMState &State,
   BenchmarkCode Result;
 
   MCObjectFileInfo ObjectFileInfo;
   const TargetMachine &TM = State.getTargetMachine();
   MCContext Context(TM.getTargetTriple(), TM.getMCAsmInfo(),
                     TM.getMCRegisterInfo(), &ObjectFileInfo,
                     TM.getMCSubtargetInfo());
   Context.initInlineSourceManager();
-  ObjectFileInfo.InitMCObjectFileInfo(/*PIC=*/false, Context);
+  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-mc-assemble-fuzzer/llvm-mc-assemble-fuzzer.cpp

int AssembleOneInput(const uint8_t *Data, size_t Size) {
   }
 
   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(UsePIC, Ctx);
+  MOFI.initMCObjectFileInfo(Ctx, UsePIC);
 
   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

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,
                 &MCOptions);
-  MOFI.InitMCObjectFileInfo(PIC, Ctx, LargeCodeModel);
+  MOFI.initMCObjectFileInfo(Ctx, PIC, LargeCodeModel);
 
   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) {
   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(/*PIC=*/false, Ctx);
+  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false);
 
   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()));
 
   // Parse the input and create CodeRegions that llvm-mca can analyze.

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

int main(int Argc, char **Argv) {
   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(/*PIC=*/false, Ctx,
+  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false,
                             /*LargeCodeModel=*/true);
 
   if (InputArgs.hasArg(OPT_save_temp_labels))
     Ctx.setAllowTemporaryLabels(false);
 
   // Set compilation information.
   SmallString<128> CWD;
   if (!sys::fs::current_path(CWD))

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

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());
   // FIXME: for now initialize MCObjectFileInfo with default values
-  MOFI.InitMCObjectFileInfo(/*PIC=*/false, Ctx);
+  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false);
 
   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

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(/*PIC=*/false, Ctx);
+  MOFI.initMCObjectFileInfo(Ctx, /*PIC=*/false);
   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/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp

protected:
 
   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, MSTI.get(),
                             &SrcMgr, &MCOptions));
-    MOFI.InitMCObjectFileInfo(/*PIC=*/false, *Ctx, /*LargeCodeModel=*/false);
+    MOFI.initMCObjectFileInfo(*Ctx, /*PIC=*/false, /*LargeCodeModel=*/false);
 
     Str.reset(TheTarget->createNullStreamer(*Ctx));
 
     Parser.reset(createMCAsmParser(SrcMgr, *Ctx, *Str, *MUPMAI));
   }
 
   void lexAndCheckTokens(StringRef AsmStr,
                          SmallVector<AsmToken::TokenKind> ExpectedTokens) {

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(mai.get(), mri.get(), &mofi, &srcMgr, &mcOptions);
-  mofi.InitMCObjectFileInfo(triple, false, ctx, false);
+  llvm::MCContext ctx(triple, mai.get(), mri.get(), &mofi, &srcMgr, &mcOptions);
+  mofi.initMCObjectFileInfo(ctx, /*PIC=*/false, /*LargeCodeModel=*/false);
 
   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(