Is there something like a VM to wrap tools such as LLVM IRBuilder?

I'm working on a lightweight embedded scripting language for C++ applications. This is intended for modest extensions to the applications themselves, such as adding context-menu options to GUI controls (scripts are handlers for when the option is activated); parsers for loading data in custom serialization formats (scripts might be pairs of regex rules with match callbacks); or statistical analyses for data sets. The language has a VM which aims to be almost trivial, or at least have a minimal working core -- mostly instructions to build up a parameter list and call C++ code via function pointers. One of my goals is to minimize the distinction between calling C++ functions from a host application versus methods that implement basic language elements, like declaring/initializing variables, managing lexical scopes and variable lifetimes, and branching/loop blocks. For instance, instead of "jump" instructions if/else could be implemented as a C++ function whose second argument is an object encapsulating a code block.

My question is as follows: with this setup I am researching the feasibility of transpiling to C++ files rather than executing scripts immediately. For the basic language I seek to minimize heavy dependencies like LLVM (leaning more toward a much smaller infrastructure, like LuaVM). But I would accept external dependencies for optional extensions.

Generating C++ code directly via something like std::stringstream seems pretty awkward. I've read about Jank's IR from which C++ code is produced (and then, I believe, compiled immediately via Clang). Perhaps Gabriel dos Reis's IPR could be used to similar effect. Instead of compiling \*to\* IR, generate IR and decompile to C++ source code.

But since my compiler pipeline is designed to emit VM code, I'm hoping some tools might exist for which IR is more akin to instructions in some special-purpose bytecode format. Functionally, I'm envisioning something like LLVM IRBuilder, where code-generation is decomposed into lots of small actions (add some token to an argument list, open/close some code block, etc.). Even just a wrapper around IRBuilder might work. But what I hope to find is a sort of DSL where various IRBuilder methods (or the equivalent) could be written in sequence, one-line-per-instruction style. One thing confusing me is that online discussions about .ll files "decompiling" to C++ aren't clear as to whether the goal is generating IRBuilder code that would produce the equivalent .ll code, or conversely reconstructing the actual C++ originally written. Substantially though I'm not sure how much it matters. Here's what AI spits out as a simple IRBuilder example:

Type* Int32Ty = Type::getInt32Ty(Context);
std::vector<Type*> ParamTypes = {Int32Ty, Int32Ty};
FunctionType *FuncType = FunctionType::get(Int32Ty, ParamTypes, false);
Function *AddFunc = Function::Create(FuncType, Function::ExternalLinkage, "add", OwnerModule.get());
Function::arg_iterator Args = AddFunc->arg_begin();
Value* ArgA = Args++;
ArgA->setName("a");
Value* ArgB = Args;
ArgB->setName("b");

I could certainly envision an interface like this to produce equivalent C++ code:

int32_t add(int32_t a, int32_t b)

and so forth. But it would be excellent if the IRBuilder code could be replaced by something more VM-like:

init-arg-list
add-param-type @Int32Ty
add-param-type @Int32Ty
add-return-type @Int32Ty
reset-arg-cursor
set-arg-name "a"
inc-arg-cursor
set-arg-name "b"
inc-arg-cursor
set-proc-name "add"
write-function-signature

or something like that (imagining a "@" sigil on type names). The point is that the above lines might be pretty close to VM code intended to call the "add" function at runtime, so you could use the same compiler toolchain for multiple steps before generating one kind of code for runtime scripts and a different VM flavor for producing C++ source files.

I don't think there's any