How to generate an executable from an llvm::Module?

Question

I want to write a C++ function that takes an llvm::Module, which is already linked, and output it to an executable file. It should use the llvm/clang API rather than forking a process and invoking the command-line clang.

After looking through the llvm/clang source code, the closest thing I've found is to output a Module to a .o file. For example, the llc tool (tools/llc/llc.cpp) accomplishes this by calling TargetMachine::addPassesToEmitFile(...).

An alternative would be to write the Module to a .bc file, then create a CompilerInstance and call ExecuteCompilerInvocation (as in tools/clang/tools/driver/cc1_main.cpp). But then there's the overhead of file I/O.

So, am I asking for something possible, or must I fall back on the alternative?

Edit: (Of course this is possible. It happens somewhere in the clang source code, I just can't find it.)

I don't think so. `llc` can generate a .o file but not an executable. — jlstrecker, Jul 26 '12 at 15:27

jlstrecker · Accepted Answer · 2012-08-15T23:29:53.727

17

Not possible! clang does not create the executable itself. It invokes ld.

Found it in tools/clang/lib/Driver/Tools.cpp. In the ConstructJob functions for the various platforms (darwin::Link::ConstructJob, solaris::Link::ConstructJob, etc.), it does this:

const char *Exec =
    Args.MakeArgString(getToolChain().GetProgramPath("ld"));
  C.addCommand(new Command(JA, *this, Exec, CmdArgs));

(For visualstudio::Link::ConstructJob, it instead invokes link.exe.)

Edit: In retrospect, it would have been faster to find this out by tracing clang's system calls with dtruss (Mac) or strace (Linux).

Edit: I ended up using the Clang driver API for building and linking. I wrote up some example code.

edited Aug 15 '12 at 23:29

answered Jul 27 '12 at 17:11

jlstrecker

4,953
3
46
60

clang invokes ld on... what? An object file? How do you generate the object file? – andrewrk Nov 24 '15 at 11:10
@andrewrk Maybe a bit late but LLVM can create an object file. – Rakete1111 Sep 19 '18 at 08:09

score 2 · Answer 2 · answered May 16 '22 at 18:01

Here's my compile function, which compiles the Module to an object file and then invokes the Clang++ compilation API to generate an executable.

I don't know if it correctly answers your question, as the object file exists momentarily and is just deleted afterwards (last line) An optimization is of course to do it all in-memory. The constructor of clang::driver::Driver does have a "Virtual File System" optional argument, which can probably be used.

#include "clang/Driver/Driver.h"
#include "clang/Driver/Compilation.h"
#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "llvm/IR/Module.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Support/Host.h"
#include "llvm/Target/TargetMachine.h"

using namespace llvm;
using namespace llvm::sys;


void writeModuleToFile(Module *module)
{
    auto TargetTriple = getDefaultTargetTriple();
    InitializeAllTargetInfos();
    InitializeAllTargets();
    InitializeAllTargetMCs();
    InitializeAllAsmParsers();
    InitializeAllAsmPrinters();

    std::string Error;
    auto Target = TargetRegistry::lookupTarget(TargetTriple, Error);
    auto CPU = "generic";
    auto Features = "";

    TargetOptions opt;
    auto RM = Optional<Reloc::Model>();
    auto TargetMachine = Target->createTargetMachine(TargetTriple, CPU, Features, opt, RM);

    module->setDataLayout(TargetMachine->createDataLayout());
    module->setTargetTriple(TargetTriple);

    auto Filename = "output.o";
    std::error_code EC;
    raw_fd_ostream dest(Filename, EC, sys::fs::OF_None);

    legacy::PassManager pass;
    auto FileType = CGFT_ObjectFile;

    if (TargetMachine->addPassesToEmitFile(pass, dest, nullptr, FileType))
    {
        errs() << "TargetMachine can't emit a file of this type";
        return;
    }
    pass.run(*module);
    dest.flush();

    IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts = new clang::DiagnosticOptions;
    clang::TextDiagnosticPrinter *DiagClient = new clang::TextDiagnosticPrinter(errs(), &*DiagOpts);
    IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagID(new clang::DiagnosticIDs());
    clang::DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
    clang::driver::Driver TheDriver("/usr/bin/clang++-12", TargetTriple, Diags);

    auto args = ArrayRef<const char *>{"-g", "output.o", "-o", "main"};

    std::unique_ptr<clang::driver::Compilation> C(TheDriver.BuildCompilation(args));

    if (C && !C->containsError())
    {
        SmallVector<std::pair<int, const clang::driver::Command *>, 4> FailingCommands;
        TheDriver.ExecuteCompilation(*C, FailingCommands);
    }

    remove(Filename);
}

CAFxX · Answer 3 · 2012-07-27T08:53:47.523

0

~~llvm-ld does what you need when passed the -native flag.~~

llvm-ld has been removed in LLVM 3.1, but the clang driver should be able to replace its function. You may start there.

edited Jul 27 '12 at 08:53

answered Jul 26 '12 at 15:44

CAFxX

28,060
6
41
66

True, but unfortunately `llvm-ld` accomplishes this by invoking `gcc`. – jlstrecker Jul 26 '12 at 22:44
llvm-ld has been removed in LLVM 3.1, and they suggest to use clang directly instead to codegen/link bitcode files into an executable (see http://llvm.org/releases/3.1/docs/ReleaseNotes.html#tools_changes) – CAFxX Jul 27 '12 at 08:51
Re: your edit -- As I said in my question, I searched the clang driver code. I found code to turn a .bc file into an executable, but I'm looking for something that can turn an in-memory Module into an executable. – jlstrecker Jul 27 '12 at 15:42

How to generate an executable from an llvm::Module?

3 Answers3

Linked