Questions after playing around with KaleidoscopeJIT (With source files)

Hello LLVM people,

after finishing Chapter 1 and 2 of the KaleidoscopeJIT tutorial, I started to play around with the code and now, I have even more questions than before. I hope that the people reading this could help me with it, to improve my understanding about the LLVM and the JIT.

I have also the source code and binaries (Windows) available but because I don’t know how the mailing list treats attachments (like .zip) I decided to only attach the source files - hoping it will help >o<

CM_ExternalConstant.cpp (147 Bytes)

CM_Orc.cpp (199 Bytes)

CM_PlanschiValue.cpp (40 Bytes)

PlanschbeckenOrcJIT.cpp (473 Bytes)

PlanschbeckenJIT.cpp (3.78 KB)

PlanschbeckenJIT.h (2.2 KB)

(+Lang, ORC leader)

I don’t know much about most of the questions myself, though for (5) - Clang does map between code and mangled names, but it doesn’t provide a simple entry-point to that. (mostly because it’s not often useful in isolation) - you can compile “const int foo;” to LLVM IR and you’ll see the mangled name there. The narrowest piece of code that gives just the mangled name would accept the Clang AST as input and operate on that, not on a string of source code.

Thank you David!

ORC leader is actually a pretty cool title. Anyway – what is the Clang AST? Maybe I could try converting from a string to that AST myself? Currently I use the way you described, by getting the name from the LLVM IR.

Hi Gaier,

(2) - I'd imagine that this is more or less the expected behavior.
Function redefinition like that isn't legal in regular C++ land. If
you'd like to make the second definition shadow the old one though
that's a more interesting problem.

One idea that Patrick Nappa had is to name each function
"functionName_{count}" then keep a map between the function's name,
and its count. When you add a function, increment the count and add it
to the JIT with that name. To look it up, check the map for its most
recent name and look that up.

(4) - AFIK Clang uses the same optimization passes as you might choose
to add to the JIT. There is a really great sackoverflow question that
covers the optimization passes that Clang uses for various
optimization flags here:

https://stackoverflow.com/questions/15548023/clang-optimization-levels

I'd imagine that you'd want to run those passes in the JIT because
that way you can control when things are optimized and likely speed up
compilation, but I'd be interested to see what you end up deciding on.

Also, as a side question, I'd be interested to know how you're using
clang to compile the C++ code into modules. I've been working on a
similar project and have found getting errors out of the parser
properly to be pretty difficult. If you've managed to solve that
problem, I'd love to hear about how you worked it out. Otherwise I
found Cling's incremental parsing code to be pretty helpful:

https://github.com/root-project/cling/blob/master/lib/Interpreter/IncrementalParser.cpp#L741

Good luck,
Zeke

Hello Zeke Medley,

(2) - In the past I used MCJIT and when such a clash(?) happened, then the JIT automatically renamed one of the functions by adding a number to it, like you suggested. So I was surprised, that this didn't happened again.
I like the idea with the map a lot! Still waiting for an answer to (1) that would help me imagine the implementation for that, because I would tend to do it on the llvm::Module.

(4) - I use Clang-Cl (Windows user here) and simply add to my compiler flags "-Xclang -emit-llvm-bc" or without the -bc. I then use a LLVM function to load and parse the module. I hope that helps a bit? I'm a noob with the LLVM so I might misunderstood the question.

Thank you a lot for your answer and the link! This helped me to go some steps forward.

Kind greetings
Björn