Extracting a value from an union - llvm

Question

What is the LLVM way to extract values from an array of unions?
Unions are not directly supported and this seems to complicate things.
Background:
I am calling a function returned by the JIT execution machine
and pass it 1 argument, namely the base address of an array
of unions which contains the arguments.
The data structure is set up from C like:
std::array<union{int,float*}> arguments(5);
The sequence of occurences of int and float* is encoded
in a vector<llvm::Type*>:
i32
i32
float*
float*
float*
Right now I am trying this (this is the jitted function):
define void #main([8 x i8]* %arg_ptr) {
entrypoint:
%0 = getelementptr [8 x i8]* %arg_ptr, i32 0
%1 = getelementptr [8 x i8]* %arg_ptr, i32 1
%2 = getelementptr [8 x i8]* %arg_ptr, i32 2
%3 = getelementptr [8 x i8]* %arg_ptr, i32 3
%4 = getelementptr [8 x i8]* %arg_ptr, i32 4
}
First of all, is the functions' signature correct (assuming
pointer size is 8 bytes)?
How do I get the first i32 out of the [8 x i8] stored in %0?
Do I need to cast the array [8 x i8] first to a pointer i32*,
then create another GEP to its first element?

Answer 1

Note that LLVM IR does not really have unions. What happens in practice is that Clang (which is aware of the target triple, so the details are platform/ABI specific) will create a single-element struct big enough to contain you union and act on that. Here's some C code:
typedef union {
double dnum;
int inum;
float* fptr;
} my_union;
int bar(my_union* mu) {
return mu[4].inum;
}
Converting this to LLVM IR with clang (using the default target on a x86-64 machine, we get this (optimized code, to reduce clutter):
%union.my_union = type { double }
define i32 #bar(%union.my_union* nocapture readonly %mu) #0 {
entry:
%arrayidx = getelementptr inbounds %union.my_union* %mu, i64 4
%inum = bitcast %union.my_union* %arrayidx to i32*
%0 = load i32* %inum, align 4
ret i32 %0
}
A few things to note here, with answers to some of the sub-questions embedded in your question:
The union is replaced by the C type struct {double} because that's large enough to contain all union members, and it also provides the correct alignment constraints. LLVM knows absolutely nothing about unions. From this point on, it acts on a struct aggregate.
Access to array members in LLVM is done with a GEP which gets two numeric indices. For an in-depth explanation of why it works this way, see http://llvm.org/docs/GetElementPtr.html
Once you have the member, you just load the value from it. Clang knows how members are laid out within an enum, so it loads a i32* directly from the member.