Strategy to compile for LLVM IR (Chris Lattner)

Message: 3
Date: Fri, 15 Jun 2007 12:24:52 -0700 (PDT)
From: Chris Lattner <sabre@nondot.org>
Subject: Re: [LLVMdev] Strategy to compile for LLVM IR
To: LLVM Developers Mailing List <llvmdev@cs.uiuc.edu>
Message-ID: <Pine.LNX.4.62.0706151218030.7416@nondot.org>
Content-Type: text/plain; charset=“x-unknown”

We have a compiler for the Faust language (faust.grame.fr) that
currently compiles a C++ class which implements a DSP plug-in with
several methods.

ok

Our strategy to compile LLVM IR instead is the following:

  • use the current Faust ==> C++ compiler to compile a “empty” plug-in
    that we use as a template C++ class.

  • compile this template C++ class using "llvm-g++ -emit-llvm -c "
    to get a bytecode file template.bc

Ok.

  • use “llvm2cpp template.bc” to get a template.bc.cpp of C++ code
    the Faust ==> LLVM IR new backend will have to execute to produce
    the correct bytecode.

  • take this template.bc.cpp code as the “constant” part of the Faust
    ==> LLVM IR backend and add everything needed to produce the
    “variable” part (that one corresponding to what the real Faust plug-
    in will do)

Is there any more common and simple method to achieve the same
result? or any other advice?

Here’s a better way. Consider a simple C template like this:

void the_template(int X, int Y) {
if (X == 123)
hole1(Y, X*Y);

int *Ptr;
for (…)
hole2(Ptr);
}

The template can do whatever you want obviously. I assume that there are
various pieces that need to be filled in, e.g. the body of a loop. In you
C template code, just put simple function calls to external functions
(named hole1/hole2 in this example).

At runtime, load the IR for the code above (either from the .bc file, or
statically linked into your app with llvm2cpp). Then do the following:

  1. Create new internal LLVM functions that will be used to fill in the
    holes in the template.
  2. Clone the template code, specializing it based on globals or arguments,
    or whatever else you want.
  3. Iterate through the cloned code looking for calls to hole*. Change the
    callinst to call into the new LLVM function you created with #1.
  4. After you iterate through and update the calls, use the InlineFunction
    routine in llvm/Transforms/Utils/Cloning.h to inline the calls to the
    static functions you built in #1.

The end result is happy specialized code, but in a nice and maintainable
form.

-Chris

Thanks,

I will need also to compile new fields in the result C++ class, thus i need a way to get an access on the class struct field part. I see something like:

std::vector<const Type*>StructTy_struct_mydsp_fields;
StructTy_struct_mydsp_fields.push_back(StructTy_struct_dsp);
StructType* StructTy_struct_mydsp = StructType::get(StructTy_struct_mydsp_fields, /isPacked=/false);
mod->addTypeName(“struct.mydsp”, StructTy_struct_mydsp);

in the generated llvm2cpp code, i guess it is possible then to iterate through the cloned code looking for the object with “struct.mydsp” name and get the associated field struct so that to later do something like : StructTy_struct_mydsp_fields.push_back(Type::FloatTy); to add new fields?

Thanks

Stephane Letz