projects/ldc: tools/binding/llvm/llvm.d comparison

comparison tools/binding/llvm/llvm.d @ 1274:4ff9ab0d472c

Check in some old changes to the binding, from before I had commit access. - Add bindings for InsertValue and ExtractValue - Updates to use new APIs where they were renamed or removed. - Add generic error messages if LLVM didn't provide one. - Enable typesafe variadic arguments for GetGEP.

author	Frits van Bommel <fvbommel wxs.nl>
date	Mon, 27 Apr 2009 22:34:36 +0200
parents	1ba61de8796b
children

comparison

equal deleted inserted replaced

-:1ba61de8796b
+:4ff9ab0d472c
 /// global registry for 1:1 mapping of ModuleRef's -> Module's
 private static Module[LLVMModuleRef] registry;
 ///
 private LLVMModuleRef mod;
 const char[] name;
+// Make all methods final to enable linking with just needed libs.
+// To make use of this if compiling with GDC: use -ffunction-sections when
+// compiling and --gc-sections when linking.
+// (Final avoids references in the vtable)
+final:
 ///
 this(char[] nam)
 {
 name = nam;
 mod = LLVMModuleCreateWithName(to_stringz(nam));
 char* msg;
 if (LLVMCreateMemoryBufferWithContentsOfFile(to_stringz(bitcodepath), &bref, &msg))
 {
 errmsg = from_stringz(msg).dup;
 LLVMDisposeMessage(msg);
+if (errmsg.length == 0)
+errmsg = "Error reading bitcode file";
 throw new LLVMException(errmsg);
 }
 scope(exit)
 LLVMDisposeMemoryBuffer(bref);
 if (LLVMParseBitcode(bref, &mref, &msg))
 {
 errmsg = from_stringz(msg).dup;
 LLVMDisposeMessage(msg);
+if (errmsg.length == 0)
+errmsg = "Error parsing bitcode";
 LLVMDisposeMemoryBuffer(bref);
 throw new LLVMException(errmsg);
 }
 return new Module(mref);
 }
 ///
 Function getOrInsertFunction(Type t, char[] nam)
 {
 assert(mod !is null);
 auto c = LLVMGetOrInsertFunction(mod, to_stringz(nam), t.ll);
-assert(c !is null);
+auto val = getValueOf(c);
-return cast(Function)getValueOf(c);
+auto fn = cast(Function) val;
+// Can happen if 'nam' names a function of a different type:
+assert(fn !is null, "Not a function of type " ~ t.toString() ~ ": " ~ val.toString());
+return fn;
 }
 /// Performs the same optimizations as `opt -std-compile-opts ...' would on the module.
 /// If inline is true, function inlining will be performed.
 void optimize(bool inline)
 {
 char* msg;
 if (LLVMVerifyModule(mod, LLVMVerifierFailureAction.ReturnStatus, &msg))
 {
 auto errmsg = from_stringz(msg).dup;
 LLVMDisposeMessage(msg);
+if (errmsg.length == 0)
+errmsg = "Module verification failed";
 throw new LLVMException(errmsg);
 }
 }
 }
 char* msg;
 if (LLVMCreateMemoryBufferWithContentsOfFile(to_stringz(filename), &buf, &msg))
 {
 auto errmsg = from_stringz(msg).dup;
 LLVMDisposeMessage(msg);
+if (errmsg.length == 0)
+errmsg = "ModuleProvider: Error reading bitcode file";
 throw new LLVMException(errmsg);
 }
 LLVMModuleProviderRef mp;
 // Takes ownership of buffer ...
 // ... unless it fails, in which case we need to clean it up ourselves
 LLVMDisposeMemoryBuffer(buf);
 auto errmsg = from_stringz(msg).dup;
 LLVMDisposeMessage(msg);
+if (errmsg.length == 0)
+errmsg = "Error creating ModuleProvider for bitcode file";
 throw new LLVMException(errmsg);
 }
 return new ModuleProvider(mp);
 }
 ///
 ///
 mixin(GenericConstCmp!("Int","ICmp"));
 ///
 mixin(GenericConstCmp!("Real","FCmp"));
 ///
-Constant GetGEP(Constant ptr, Constant[] idxs)
+Constant GetGEP(Constant ptr, Constant[] idxs...)
 {
+static if (size_t.max > uint.max) {
+assert(idxs.length <= uint.max, "Ridiculous number of indexes to GEP");
+}
 auto ar = new LLVMValueRef[idxs.length];
 foreach(i,v; idxs) ar[i] = v.value;
 auto c = LLVMConstGEP(ptr.value, ar.ptr, ar.length);
 return cast(Constant)getValueOf(c);
 }
 ///
+Constant GetExtractValue(Constant agg, uint[] idxs...) {
+static if (size_t.max > uint.max) {
+assert(idxs.length <= uint.max, "Ridiculous number of indexes to ExtractValue");
+}
+auto c = LLVMConstExtractValue(agg.value, idxs.ptr, idxs.length);
+return cast(Constant)getValueOf(c);
+}
+///
+Constant GetInsertValue(Constant agg, Constant elt, uint[] idxs...) {
+static if (size_t.max > uint.max) {
+assert(idxs.length <= uint.max, "Ridiculous number of indexes to InsertValue");
+}
+auto c = LLVMConstInsertValue(agg.value, elt.value, idxs.ptr, idxs.length);
+return cast(Constant)getValueOf(c);
+}
+///
 Constant GetSizeOf(Type t)
 {
 return cast(Constant)getValueOf(LLVMSizeOf(t.ll));
 }
 }
 }
 ///
 class GlobalVariable : GlobalValue
 {
-/// TODO:
+/// TODO: void DeleteGlobal(ValueRef GlobalVar);
-/// void DeleteGlobal(ValueRef GlobalVar);
 ///
 private this(LLVMValueRef v, Type t) {
 super(v, t);
 }
 ///
 bool hasInitializer()
 {
-return LLVMHasInitializer(value) != 0;
+return isDeclaration() == 0;
 }
 ///
 Constant initializer()
 {
 auto c = LLVMGetInitializer(value);
 }
 ///
 class Function : GlobalValue
 {
-/// TODO:
+/// TODO: void GetParams(ValueRef Fn, ValueRef *Params);
-/// void GetParams(ValueRef Fn, ValueRef *Params);
+/// TODO: void GetBasicBlocks(ValueRef Fn, BasicBlockRef *BasicBlocks);
-/// void GetBasicBlocks(ValueRef Fn, BasicBlockRef *BasicBlocks);
 ///
 package this(LLVMValueRef v, Type t) {
 super(v, t);
 }
 void callConv(uint cc)
 {
 LLVMSetFunctionCallConv(value, cc);
 }
 ///
-char[] collector()
+char[] gc()
 {
-return from_stringz(LLVMGetCollector(value));
+return from_stringz(LLVMGetGC(value));
 }
 ///
-void collector(char[] col)
+void gc(char[] name)
 {
-LLVMSetCollector(value, to_stringz(col));
+LLVMSetGC(value, to_stringz(name));
 }
 ///
 uint numBasicBlocks()
 {
 return LLVMCountBasicBlocks(value);

Mercurial > projects > ldc

comparison tools/binding/llvm/llvm.d @ 1274:4ff9ab0d472c