In LLVM, the getelementptr instruction is used to get the address of an element in an aggregate data structure. It only calculates the address and does not access the memory.
The first argument of the getelementptr instruction is a type used as the basis for calculating the address. The second argument is pointer or vector of pointers which act as base of the address - which in our array case will be a. The next arguments are the indices of the element to be accessed.
The Language reference (http://llvm.org/docs/LangRef.html#getelementptr-instruction) mentions important notes on getelementptr instruction as follows:
The first index always indexes the pointer value given as the first argument, the second index indexes a value of the type pointed to (not necessarily the value directly pointed to, since the first index can be non-zero), etc. The first type indexed into must be a pointer value, subsequent types can be arrays, vectors, and structs. Note that subsequent types being indexed into can never be pointers, since that would require loading the pointer before continuing calculation.
This essentially implies two important things:
- Every pointer has an index, and the first index is always an array index. If it's a pointer to a structure, you have to use index 0 to mean (the first such structure), then the index of the element.
- The first type parameter helps GEP identify the sizes of the base structure and its elements, thus easily calculating the address. The resulting type (
%a1) is not necessarily the same.
More elaborated explanation is provided at http://llvm.org/docs/GetElementPtr.html
Let's assume that we have a pointer to a vector of two 32 bit integers <2 x i32>* %a and we want to access second integer from the vector. The address will be calculated as
%a1 = getelementptr i32, <2 x i32>* %a, i32 1
To emit this instruction, LLVM API can be used as follows:
First create an array type which will be passed as argument to the function.
Function *createFunc(IRBuilder<> &Builder, std::string Name) {
Type *u32Ty = Type::getInt32Ty(Context);
Type *vecTy = VectorType::get(u32Ty, 2);
Type *ptrTy = vecTy->getPointerTo(0);
FunctionType *funcType =
FunctionType::get(Builder.getInt32Ty(), ptrTy, false);
Function *fooFunc =
Function::Create(funcType, Function::ExternalLinkage, Name, ModuleOb);
return fooFunc;
}
Value *getGEP(IRBuilder<> &Builder, Value *Base, Value *Offset) {
return Builder.CreateGEP(Builder.getInt32Ty(), Base, Offset, "a1");
}The whole code looks like:
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"
#include <vector>
using namespace llvm;
static LLVMContext &Context = getGlobalContext();
static Module *ModuleOb = new Module("my compiler", Context);
static std::vector<std::string> FunArgs;
Function *createFunc(IRBuilder<> &Builder, std::string Name) {
Type *u32Ty = Type::getInt32Ty(Context);
Type *vecTy = VectorType::get(u32Ty, 2);
Type *ptrTy = vecTy->getPointerTo(0);
FunctionType *funcType =
FunctionType::get(Builder.getInt32Ty(), ptrTy, false);
Function *fooFunc =
Function::Create(funcType, Function::ExternalLinkage, Name, ModuleOb);
return fooFunc;
}
void setFuncArgs(Function *fooFunc, std::vector<std::string> FunArgs) {
unsigned Idx = 0;
Function::arg_iterator AI, AE;
for (AI = fooFunc->arg_begin(), AE = fooFunc->arg_end(); AI != AE;
++AI, ++Idx)
AI->setName(FunArgs[Idx]);
}
BasicBlock *createBB(Function *fooFunc, std::string Name) {
return BasicBlock::Create(Context, Name, fooFunc);
}
Value *getGEP(IRBuilder<> &Builder, Value *Base, Value *Offset) {
return Builder.CreateGEP(Builder.getInt32Ty(), Base, Offset, "a1");
}
int main(int argc, char *argv[]) {
FunArgs.push_back("a");
static IRBuilder<> Builder(Context);
Function *fooFunc = createFunc(Builder, "foo");
setFuncArgs(fooFunc, FunArgs);
Value *Base = fooFunc->arg_begin();
BasicBlock *entry = createBB(fooFunc, "entry");
Builder.SetInsertPoint(entry);
Value *gep = getGEP(Builder, Base, Builder.getInt32(1));
verifyFunction(*fooFunc);
ModuleOb->dump();
return 0;
}Compile the code:
$ clang++ toy.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core` -fno-rtti -o toy $ ./toy
Output:
; ModuleID = 'my compiler'
define i32 @foo(<2 x i32>* %a) {
entry:
%a1 = getelementptr i32, <2 x i32>* %a, i32 1
ret i32 0
}