Question

at the moment, i’m inserting variables into the beginning of block scope using CreateEntryBlockAlloca:

template <typename VariableType>
            static inline llvm::AllocaInst *CreateEntryBlockAlloca(BuilderParameter& buildParameters,
                    const std::string &VarName) {
                HAssertMsg( 1 != 0 , "Not Implemented");
            };

            template <>
              inline llvm::AllocaInst *CreateEntryBlockAlloca<double>(BuilderParameter& buildParameters,
                    const std::string &VarName) {
                llvm::Function* TheFunction = buildParameters.dag.llvmFunction;
                llvm::IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                        TheFunction->getEntryBlock().begin());
                return TmpB.CreateAlloca(llvm::Type::getDoubleTy(buildParameters.getLLVMContext()), 0,
                        VarName.c_str());
            }

Now, i want to add Allocas for non-POD types (that might require a destructor/cleanup function at exit). However, it is not enough to add destructor calls at the end of the exit scope block, since it is not clear how to have them be invoked when a regular DWARF exception is thrown (for the purpose of this argument, lets say that exceptions are thrown from Call points that invoke C++ functions which only throw a POD type, so no, in my case, ignorance is bliss, and i would like to stay away from intrinsic llvm exceptions unless i understand them better).

I was thinking that may be i could have a table with offsets in the stack with the Alloca registers, and have the exception handler (at the bottom of the stack, at the invocation point of the JIT function) walk over those offsets on the table and call destructors appropiately.

The thing i don’t know is how to query the offset of the Alloca’ed registers created with CreateAlloca. How can i do that reliably?

Also, if you think there is a better way to achieve this, please enlighten me on the path of the llvm

• Technical Comment: the JIT code is being called inside a boost::context which only invokes the JIT code inside a try catch, and does nothing on the catch, it just exits from the context and returns to the main execution stack. the idea is that if i handle the unwinding in the main execution stack, any function i call (for say, cleaning up stack variables) will not overwrite those same stack contents from the terminated JIT context, so it will not be corrupted. Hope i’m making enough sense

Answer 1

The thing i don’t know is how to query the offset of the Alloca’ed registers created with CreateAlloca. How can i do that reliably?

You can use the address of an alloca directly… there isn’t any simple way to get its offset into the stack frame, though.

Why exactly do you not want to use the intrinsic LLVM exceptions? They really are not that hard to use, especially in the simple case where your code never actually catches anything. You can basically just take the code clang generates in the simple case, and copy-paste it.

Edit:
To see how to use exceptions in IR in the simple case, try pasting the following C++ code into the demo page at http://llvm.org/demo/:

class X { public: ~X() __attribute((nothrow)); };
void a(X* p);
void b() { X x; a(&x); }

It’s really not that complicated.