# HG changeset patch # User Moritz Warning # Date 1274378703 -7200 # Node ID cb960b882ca3bf5f934498587cf958b630fdffb6 # Parent 40bd4a0d48709527a9ba1bdf992f2b99c913e2df bindings were moved to dsource.org/projects/bindings/ diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/LICENSE.TXT --- a/tools/binding/LICENSE.TXT Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,72 +0,0 @@ -============================================================================== -LLVM Release License -============================================================================== -University of Illinois/NCSA -Open Source License - -Copyright (c) 2003-2008 University of Illinois at Urbana-Champaign. -All rights reserved. - -Developed by: - - LLVM Team - - University of Illinois at Urbana-Champaign - - http://llvm.org - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal with -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimers. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimers in the - documentation and/or other materials provided with the distribution. - - * Neither the names of the LLVM Team, University of Illinois at - Urbana-Champaign, nor the names of its contributors may be used to - endorse or promote products derived from this Software without specific - prior written permission. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE -SOFTWARE. - -============================================================================== -Copyrights and Licenses for Third Party Software Distributed with LLVM: -============================================================================== -The LLVM software contains code written by third parties. Such software will -have its own individual LICENSE.TXT file in the directory in which it appears. -This file will describe the copyrights, license, and restrictions which apply -to that code. - -The disclaimer of warranty in the University of Illinois Open Source License -applies to all code in the LLVM Distribution, and nothing in any of the -other licenses gives permission to use the names of the LLVM Team or the -University of Illinois to endorse or promote products derived from this -Software. - -The following pieces of software have additional or alternate copyrights, -licenses, and/or restrictions: - -Program Directory -------- --------- -System Library llvm/lib/System -Compiler Driver llvm/tools/llvmc -Autoconf llvm/autoconf - llvm/projects/ModuleMaker/autoconf - llvm/projects/sample/autoconf -Boost C++ Libraries llvm/include : docs/BOOST_LICENSE_1_0.txt -CellSPU backend llvm/lib/Target/CellSPU/README.txt - - diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/dsss.conf --- a/tools/binding/dsss.conf Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,30 +0,0 @@ -defaulttargets= llvm - -[llvm] -type= library -prebuild= sh prebuild.sh -postinstall= install libllvm-c-ext.a $PREFIX/lib - -[llvmsample1.d] -buildflags = libllvm-c-ext.a -llstdc++ \ - -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \ - -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \ - -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl - -[llvmsample2.d] -buildflags = libllvm-c-ext.a -llstdc++ \ - -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \ - -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \ - -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl - -[llvmsample3.d] -buildflags = libllvm-c-ext.a -llstdc++ \ - -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \ - -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \ - -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl - -[llvmsample4.d] -buildflags = libllvm-c-ext.a -llstdc++ \ - -llLLVMCore -llLLVMBitWriter -llLLVMBitReader -llLLVMAnalysis -llLLVMTarget \ - -llLLVMTransformUtils -llLLVMScalarOpts -llLLVMipa -llLLVMipo \ - -llLLVMInstrumentation -llLLVMSystem -llLLVMSupport -lldl diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm-ext.cpp --- a/tools/binding/llvm-ext.cpp Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,87 +0,0 @@ -// Extension of the LLVM C interface for use with D, some things in the -// LLVM 2.2 release are kind sparse or even broken... -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -#ifndef D11_LLVMCEXT_H -#define D11_LLVMCEXT_H - -#include "llvm/Type.h" -#include "llvm/Constants.h" -#include "llvm/Support/CFG.h" -#include "llvm/Target/TargetData.h" -#include "llvm-c/Core.h" - -#include -#include - -using namespace llvm; -using namespace std; - -extern "C" -{ - -// we need to be able to erase an instruction from its parent -void LLVMEraseFromParent(LLVMValueRef I) { - unwrap(I)->eraseFromParent(); -} - -// we need to be able to check if a basic block is terminated -int LLVMIsTerminated(LLVMBasicBlockRef BB) { - return (unwrap(BB)->getTerminator() != NULL); -} - -// we need to be able to check if a basic block has any predecessors -int LLVMHasPredecessors(LLVMBasicBlockRef BB) { - BasicBlock* B = unwrap(BB); - return (pred_begin(B) != pred_end(B)); -} - -// we need to be able to check if a basic block is empty -int LLVMIsBasicBlockEmpty(LLVMBasicBlockRef BB) { - return unwrap(BB)->empty(); -} - -// we need to be able to replace all uses of V with W -void LLVMReplaceAllUsesWith(LLVMValueRef V, LLVMValueRef W) { - unwrap(V)->replaceAllUsesWith(unwrap(W)); -} - -// sometimes it's nice to be able to dump a type, not only values... -void LLVMDumpType(LLVMTypeRef T) { - unwrap(T)->dump(); -} - -LLVMValueRef LLVMGetOrInsertFunction(LLVMModuleRef M, char* Name, LLVMTypeRef Type) { - return wrap(unwrap(M)->getOrInsertFunction(Name, unwrap(Type))); -} - -// being able to determine the "kind" of a value is really useful -unsigned LLVMGetValueKind(LLVMValueRef Value) { - return unwrap(Value)->getValueID(); -} - -char* LLVMValueToString(LLVMValueRef v) { - stringstream ss; - unwrap(v)->print(ss); - return strdup(ss.str().c_str()); -} - -char* LLVMTypeToString(LLVMTypeRef ty) { - stringstream ss; - unwrap(ty)->print(ss); - return strdup(ss.str().c_str()); -} - -LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, char* Name) { - return wrap(unwrap(M)->getTypeByName(Name)); -} - -int LLVMIsTypeAbstract(LLVMTypeRef T) { - return unwrap(T)->isAbstract(); -} - -} // extern "C" - -#endif diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm-opt.cpp --- a/tools/binding/llvm-opt.cpp Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,75 +0,0 @@ -// Optimizer functionality for the LLVM D binding. -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -#include "llvm/PassManager.h" -#include "llvm/LinkAllPasses.h" -#include "llvm/Analysis/LoopPass.h" -#include "llvm/Target/TargetData.h" -#include "llvm-c/Core.h" - -using namespace llvm; - -extern "C" { - -void LLVMOptimizeModule(LLVMModuleRef M, int doinline) -{ - Module* m = unwrap(M); - - PassManager pm; - pm.add(new TargetData(m)); - - //pm.add(createStripDeadPrototypesPass()); - pm.add(createGlobalDCEPass()); - - pm.add(createRaiseAllocationsPass()); - pm.add(createCFGSimplificationPass()); - pm.add(createPromoteMemoryToRegisterPass()); - pm.add(createGlobalOptimizerPass()); - pm.add(createGlobalDCEPass()); - - pm.add(createIPConstantPropagationPass()); - pm.add(createDeadArgEliminationPass()); - pm.add(createInstructionCombiningPass()); - pm.add(createCFGSimplificationPass()); - pm.add(createPruneEHPass()); - - if (doinline) - pm.add(createFunctionInliningPass()); - - pm.add(createArgumentPromotionPass()); - pm.add(createTailDuplicationPass()); - pm.add(createInstructionCombiningPass()); - pm.add(createCFGSimplificationPass()); - pm.add(createScalarReplAggregatesPass()); - pm.add(createInstructionCombiningPass()); - pm.add(createCondPropagationPass()); - - pm.add(createTailCallEliminationPass()); - pm.add(createCFGSimplificationPass()); - pm.add(createReassociatePass()); - pm.add(createLoopRotatePass()); - pm.add(createLICMPass()); - pm.add(createLoopUnswitchPass()); - pm.add(createInstructionCombiningPass()); - pm.add(createIndVarSimplifyPass()); - pm.add(createLoopUnrollPass()); - pm.add(createInstructionCombiningPass()); - pm.add(createGVNPass()); - pm.add(createSCCPPass()); - - pm.add(createInstructionCombiningPass()); - pm.add(createCondPropagationPass()); - - pm.add(createDeadStoreEliminationPass()); - pm.add(createAggressiveDCEPass()); - pm.add(createCFGSimplificationPass()); - pm.add(createSimplifyLibCallsPass()); - pm.add(createDeadTypeEliminationPass()); - pm.add(createConstantMergePass()); - - pm.run(*m); -} - -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm-typemonitor.cpp --- a/tools/binding/llvm-typemonitor.cpp Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,46 +0,0 @@ -/// Support for callbacks when an abstract type becomes more concrete. - -#include "llvm/Support/Streams.h" -#include "llvm/Type.h" -#include "llvm-c/Core.h" - -using namespace llvm; - -extern "C" typedef int (*RefineCallback)(void *handle, LLVMTypeRef newT); - -class TypeMonitor : AbstractTypeUser { - void *handle_; - RefineCallback callback_; - - void onRefineType(const Type* oldT, const Type* newT) { - callback_(handle_, wrap(newT)); - oldT->removeAbstractTypeUser(this); - delete this; - } - - public: - - TypeMonitor(Type* T, void *handle, RefineCallback callback) - : handle_(handle), callback_(callback) { - T->addAbstractTypeUser(this); - } - - virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) { - onRefineType(OldTy, NewTy); - } - - virtual void typeBecameConcrete(const DerivedType *AbsTy) { - onRefineType(AbsTy, AbsTy); - } - - virtual void dump() const { - cerr << ""; - } -}; - -extern "C" void LLVMRegisterAbstractTypeCallback(LLVMTypeRef T, - void *handle, - RefineCallback callback) -{ - new TypeMonitor(unwrap(T), handle, callback); -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/builder.d --- a/tools/binding/llvm/builder.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,202 +0,0 @@ -// Written in the D programming language by Tomas Lindquist Olsen 2008 -// Binding of llvm.c.Core builder for D. -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -module llvm.builder; - -import llvm.c.Core; -import llvm.c.Ext; - -import llvm.llvm; -import llvm.util; - -private -{ - template Build_NoArgs_Mixin(char[] N) { - const Build_NoArgs_Mixin = " - Value build"~N~"() { - return new Value(LLVMBuild"~N~"(builder)); - } - "; - } - - template Build_Mixin(char[] NAME, char[] ARGS, char[] VALUES) { - const Build_Mixin = " - Value build"~NAME~"("~ARGS~") { - return new Value(LLVMBuild"~NAME~"(builder, "~VALUES~")); - } - "; - static assert(ARGS != ""); - static assert(VALUES != ""); - } - - // unnamed - template Build_Value(char[] N) { - const Build_Value = Build_Mixin!(N, "Value v", `v.value`); - } - template Build_Value_Value(char[] N) { - const Build_Value_Value = Build_Mixin!(N, "Value v, Value w", `v.value, w.value`); - } - template Build_BB(char[] N) { - const Build_BB = Build_Mixin!(N, "BasicBlock b", `b.bb`); - } - template Build_Value_BB_BB(char[] N) { - const Build_Value_BB_BB = Build_Mixin!(N, "Value v, BasicBlock b1, BasicBlock b2", `v.value, b1.bb, b2.bb`); - } - template Build_Value_BB_uint(char[] N) { - const Build_Value_BB_uint = Build_Mixin!(N, "Value v, BasicBlock b, uint n", `v.value, b.bb, n`); - } - - // named - template Build_Named_Mixin(char[] NAME, char[] ARGS, char[] VALUES) { - const Build_Named_Mixin = Build_Mixin!(NAME, ARGS~", char[] name", VALUES~`, to_stringz(name)`); - } - - template Build_Type_Name(char[] N) { - const Build_Type_Name = Build_Named_Mixin!(N, "Type t", `t.ll`); - } - template Build_Value_Name(char[] N) { - const Build_Value_Name = Build_Named_Mixin!(N, "Value v", `v.value`); - } - template Build_Type_Value_Name(char[] N) { - const Build_Type_Value_Name = Build_Named_Mixin!(N, "Type t, Value v", `t.ll, v.value`); - } - template Build_Value_Type_Name(char[] N) { - const Build_Value_Type_Name = Build_Named_Mixin!(N, "Value v, Type t", `v.value, t.ll`); - } - template Build_Value_Value_Name(char[] N) { - const Build_Value_Value_Name = Build_Named_Mixin!(N, "Value a, Value b", `a.value, b.value`); - } - template Build_Value_Value_Value_Name(char[] N) { - const Build_Value_Value_Value_Name = Build_Named_Mixin!(N, "Value a, Value b, Value c", `a.value, b.value, c.value`); - } - template Build_Value_uint_Name(char[] N) { - const Build_Value_uint_Name = Build_Named_Mixin!(N, "Value a, uint n", `a.value, n`); - } - template Build_Value_Value_uint_Name(char[] N) { - const Build_Value_Value_uint_Name = Build_Named_Mixin!(N, "Value a, Value b, uint n", `a.value, b.value, n`); - } - template Build_Cmp(char[] PRED, char[] N) { - const Build_Cmp = Build_Named_Mixin!(N, ""~PRED~"Predicate p, Value l, Value r", `p, l.value, r.value`); - } - - template StringDistribute(alias T, U...) - { - static if (!U.length) - const char[] StringDistribute=""; - else - const char[] StringDistribute = T!(U[0]) ~ StringDistribute!(T, U[1..$]); - } -} - -/// -class Builder -{ - /// - private LLVMBuilderRef builder; - /// - this() - { - builder = LLVMCreateBuilder(); - } - /// - void dispose() - { - LLVMDisposeBuilder(builder); - builder = null; - } - /// - ~this() - { - // safe because builder isn't on the GC heap and isn't exposed. - dispose(); - } - /// - void positionBefore(Value v) - { - assert(builder !is null); - LLVMPositionBuilderBefore(builder, v.value); - } - /// - void positionAtEnd(BasicBlock bb) - { - assert(builder !is null); - LLVMPositionBuilderAtEnd(builder, bb.bb); - } - /// - void positionAtStart(BasicBlock bb) - { - assert(builder !is null); - LLVMPositionBuilderBefore(builder, LLVMGetFirstInstruction(bb.bb)); - } - /// - BasicBlock getInsertBlock() - { - return new BasicBlock(LLVMGetInsertBlock(builder)); - } - - /// - mixin(StringDistribute!(Build_NoArgs_Mixin, "RetVoid", "Unwind", "Unreachable")); - mixin(Build_BB!("Br")); - mixin(Build_Value_BB_BB!("CondBr")); - mixin(Build_Value_BB_uint!("Switch")); - /// - mixin(StringDistribute!(Build_Value, "Ret", "Free")); - /// - mixin(Build_Value_Value!("Store")); - /// - mixin(StringDistribute!(Build_Value_Value_Name, - "Add","Sub","Mul","UDiv","SDiv","FDiv","URem","SRem","FRem", - "Shl","LShr","AShr","And","Or","Xor", - "ExtractElement" - )); - /// - mixin(StringDistribute!(Build_Value_Name, "Neg","Not", "Load")); - /// - mixin(StringDistribute!(Build_Value_Type_Name, - "Trunc","SExt","ZExt","FPTrunc","FPExt", - "UIToFP","SIToFP","FPToUI","FPToSI", - "PtrToInt","IntToPtr","BitCast", - "VAArg" - )); - /// - mixin(Build_Cmp!("Int","ICmp")); - /// - mixin(Build_Cmp!("Real","FCmp")); - /// - mixin(StringDistribute!(Build_Type_Name, - "Phi", "Malloc", "Alloca" - )); - /// - mixin(StringDistribute!(Build_Type_Value_Name, - "ArrayMalloc", "ArrayAlloca" - )); - /// - mixin(StringDistribute!(Build_Value_Value_Value_Name, - "Select", "InsertElement", "ShuffleVector" - )); - /// - mixin(Build_Value_uint_Name!("ExtractValue")); - /// - mixin(Build_Value_Value_uint_Name!("InsertValue")); - /// - Value buildCall(Value fn, Value[] args, char[] name) { - auto llargs = new LLVMValueRef[args.length]; - foreach(i,a; args) llargs[i] = a.value; - return new Value(LLVMBuildCall(builder, fn.value, llargs.ptr, llargs.length, to_stringz(name))); - } - /// - Value buildGEP(Value ptr, Value[] indices, char[] name) { - auto llindices = new LLVMValueRef[indices.length]; - foreach(i,idx; indices) llindices[i] = idx.value; - return new Value(LLVMBuildGEP(builder, ptr.value, llindices.ptr, llindices.length, to_stringz(name))); - } - /// - Value buildInvoke(Value fn, Value[] args, BasicBlock thenbb, BasicBlock catchbb, char[] name) { - auto llargs = new LLVMValueRef[args.length]; - foreach(i,a; args) llargs[i] = a.value; - return new Value(LLVMBuildInvoke(builder, fn.value, llargs.ptr, llargs.length, thenbb.bb, catchbb.bb, to_stringz(name))); - } -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/Analysis.d --- a/tools/binding/llvm/c/Analysis.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,42 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2008 -// Original file header: -/*===-- llvm-c/Analysis.h - Analysis Library C Interface --------*- C++ -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMAnalysis.a, which *| -|* implements various analyses of the LLVM IR. *| -|* *| -|* Many exotic languages can interoperate with C code but have a harder time *| -|* with C++ due to name mangling. So in addition to C, this interface enables *| -|* tools written in such languages. *| -|* *| -\*===----------------------------------------------------------------------===*/ - -module llvm.c.Analysis; - -import llvm.c.Core; - -extern(C): - -enum LLVMVerifierFailureAction { - AbortProcess, /* verifier will print to stderr and abort() */ - PrintMessage, /* verifier will print to stderr and return 1 */ - ReturnStatus /* verifier will just return 1 */ -} - - -/* Verifies that a module is valid, taking the specified action if not. - Optionally returns a human-readable description of any invalid constructs. - OutMessage must be disposed with LLVMDisposeMessage. */ -int LLVMVerifyModule(LLVMModuleRef M, LLVMVerifierFailureAction Action, - char **OutMessage); - -/* Verifies that a single function is valid, taking the specified action. Useful - for debugging. */ -int LLVMVerifyFunction(LLVMValueRef Fn, LLVMVerifierFailureAction Action); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/BitReader.d --- a/tools/binding/llvm/c/BitReader.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,38 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2008 -// Original file header: -/*===-- llvm-c/BitReader.h - BitReader Library C Interface ------*- C++ -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMBitReader.a, which *| -|* implements input of the LLVM bitcode format. *| -|* *| -|* Many exotic languages can interoperate with C code but have a harder time *| -|* with C++ due to name mangling. So in addition to C, this interface enables *| -|* tools written in such languages. *| -|* *| -\*===----------------------------------------------------------------------===*/ - -module llvm.c.BitReader; - -import llvm.c.Core; - -extern(C): - -/* Builds a module from the bitcode in the specified memory buffer, returning a - reference to the module via the OutModule parameter. Returns 0 on success. - Optionally returns a human-readable error message via OutMessage. */ -int LLVMParseBitcode(LLVMMemoryBufferRef MemBuf, - LLVMModuleRef *OutModule, char **OutMessage); - -/* Reads a module from the specified path, returning via the OutMP parameter - a module provider which performs lazy deserialization. Returns 0 on success. - Optionally returns a human-readable error message via OutMessage. */ -int LLVMGetBitcodeModuleProvider(LLVMMemoryBufferRef MemBuf, - LLVMModuleProviderRef *OutMP, - char **OutMessage); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/BitWriter.d --- a/tools/binding/llvm/c/BitWriter.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,33 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2008 -// Original file header: -/*===-- llvm-c/BitWriter.h - BitWriter Library C Interface ------*- C++ -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMBitWriter.a, which *| -|* implements output of the LLVM bitcode format. *| -|* *| -|* Many exotic languages can interoperate with C code but have a harder time *| -|* with C++ due to name mangling. So in addition to C, this interface enables *| -|* tools written in such languages. *| -|* *| -\*===----------------------------------------------------------------------===*/ - -module llvm.c.BitWriter; - -import llvm.c.Core; - -extern(C): - -/*===-- Operations on modules ---------------------------------------------===*/ - -/** Writes a module to an open file descriptor. Returns 0 on success. */ -int LLVMWriteBitcodeToFileHandle(LLVMModuleRef M, int Handle); - -/** Writes a module to the specified path. Returns 0 on success. */ -int LLVMWriteBitcodeToFile(LLVMModuleRef M, /*const*/ char *Path); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/Core.d --- a/tools/binding/llvm/c/Core.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,696 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2008 -// and Frits van Bommel 2008 -// Original file header: -/*===-- llvm-c/Core.h - Core Library C Interface ------------------*- C -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMCore.a, which implements *| -|* the LLVM intermediate representation. *| -|* *| -|* LLVM uses a polymorphic type hierarchy which C cannot represent, therefore *| -|* parameters must be passed as base types. Despite the declared types, most *| -|* of the functions provided operate only on branches of the type hierarchy. *| -|* The declared parameter names are descriptive and specify which type is *| -|* required. Additionally, each type hierarchy is documented along with the *| -|* functions that operate upon it. For more detail, refer to LLVM's C++ code. *| -|* If in doubt, refer to Core.cpp, which performs paramter downcasts in the *| -|* form unwrap(Param). *| -|* *| -|* Many exotic languages can interoperate with C code but have a harder time *| -|* with C++ due to name mangling. So in addition to C, this interface enables *| -|* tools written in such languages. *| -|* *| -|* When included into a C++ source file, also declares 'wrap' and 'unwrap' *| -|* helpers to perform opaque reference<-->pointer conversions. These helpers *| -|* are shorter and more tightly typed than writing the casts by hand when *| -|* authoring bindings. In assert builds, they will do runtime type checking. *| -|* *| -\*===----------------------------------------------------------------------===*/ -module llvm.c.Core; - -extern(C): - -/** - * The top-level container for all other LLVM Intermediate Representation (IR) - * objects. See the llvm::Module class. - */ -typedef void* LLVMModuleRef; - -/** - * Each value in the LLVM IR has a type, an instance of [lltype]. See the - * llvm::Type class. - */ -typedef void* LLVMTypeRef; - -/** - * When building recursive types using [refine_type], [lltype] values may become - * invalid; use [lltypehandle] to resolve this problem. See the - * llvm::AbstractTypeHolder] class. - */ -typedef void* LLVMTypeHandleRef; - -typedef void* LLVMValueRef; -typedef void* LLVMBasicBlockRef; -typedef void* LLVMBuilderRef; - -/* Used to provide a module to JIT or interpreter. - * See the llvm::ModuleProvider class. - */ -typedef void* LLVMModuleProviderRef; - -/* Used to provide a module to JIT or interpreter. - * See the llvm::MemoryBuffer class. - */ -typedef void* LLVMMemoryBufferRef; - -/** See the llvm::PassManagerBase class. */ -typedef void* LLVMPassManagerRef; - -enum LLVMAttribute { - ZExt = 1<<0, - SExt = 1<<1, - NoReturn = 1<<2, - InReg = 1<<3, - StructRet = 1<<4, - NoUnwind = 1<<5, - NoAlias = 1<<6, - ByVal = 1<<7, - Nest = 1<<8, - ReadNone = 1<<9, - ReadOnly = 1<<10, - NoInline = 1<<11, - AlwaysInline = 1<<12, - OptimizeForSize = 1<<13, - StackProtect = 1<<14, - StackProtectReq = 1<<15, - NoCapture = 1<<21, - NoRedZone = 1<<22, - NoImplicitFloat = 1<<23, - Naked = 1<<24 -} - -enum LLVMTypeKind { - Void, /**< type with no size */ - Float, /**< 32 bit floating point type */ - Double, /**< 64 bit floating point type */ - X86_FP80, /**< 80 bit floating point type (X87) */ - FP128, /**< 128 bit floating point type (112-bit mantissa)*/ - PPC_FP128, /**< 128 bit floating point type (two 64-bits) */ - Label, /**< Labels */ - Integer, /**< Arbitrary bit width integers */ - Function, /**< Functions */ - Struct, /**< Structures */ - Array, /**< Arrays */ - Pointer, /**< Pointers */ - Opaque, /**< Opaque: type with unknown structure */ - Vector, /**< SIMD 'packed' format, or other vector type */ - Metadata /**< Metadata */ -} - -enum LLVMLinkage { - External, /**< Externally visible function */ - AvailableExternally, - LinkOnceAny, /**< Keep one copy of function when linking (inline)*/ - LinkOnceODR, /**< Same, but only replaced by something - equivalent. */ - WeakAny, /**< Keep one copy of function when linking (weak) */ - WeakODR, /**< Same, but only replaced by something - equivalent. */ - Appending, /**< Special purpose, only applies to global arrays */ - Internal, /**< Rename collisions when linking (static - functions) */ - Private, /**< Like Internal, but omit from symbol table */ - DLLImport, /**< Function to be imported from DLL */ - DLLExport, /**< Function to be accessible from DLL */ - ExternalWeak,/**< ExternalWeak linkage description */ - Ghost, /**< Stand-in functions for streaming fns from - bitcode */ - Common, /**< Tentative definitions */ - LinkerPrivate /**< Like Private, but linker removes. */ -} - -enum LLVMVisibility { - Default, /**< The GV is visible */ - Hidden, /**< The GV is hidden */ - Protected/**< The GV is protected */ -} - -enum LLVMCallConv { - C = 0, - Fast = 8, - Cold = 9, - X86Stdcall = 64, - X86Fastcall= 65 -} - -enum LLVMIntPredicate { - EQ = 32, /**< equal */ - NE, /**< not equal */ - UGT, /**< uint greater than */ - UGE, /**< uint greater or equal */ - ULT, /**< uint less than */ - ULE, /**< uint less or equal */ - SGT, /**< signed greater than */ - SGE, /**< signed greater or equal */ - SLT, /**< signed less than */ - SLE /**< signed less or equal */ -} - -enum LLVMRealPredicate { - False, /**< Always false (always folded) */ - OEQ, /**< True if ordered and equal */ - OGT, /**< True if ordered and greater than */ - OGE, /**< True if ordered and greater than or equal */ - OLT, /**< True if ordered and less than */ - OLE, /**< True if ordered and less than or equal */ - ONE, /**< True if ordered and operands are unequal */ - ORD, /**< True if ordered (no nans) */ - UNO, /**< True if unordered: isnan(X) | isnan(Y) */ - UEQ, /**< True if unordered or equal */ - UGT, /**< True if unordered or greater than */ - UGE, /**< True if unordered, greater than, or equal */ - ULT, /**< True if unordered or less than */ - ULE, /**< True if unordered, less than, or equal */ - UNE, /**< True if unordered or not equal */ - True /**< Always true (always folded) */ -} - -/*===-- Error handling ----------------------------------------------------===*/ - -void LLVMDisposeMessage(char *Message); - - -/*===-- Modules -----------------------------------------------------------===*/ - -/* Create and destroy modules. */ -/** See llvm::Module::Module. */ -LLVMModuleRef LLVMModuleCreateWithName(/*const*/ char *ModuleID); - -/** See llvm::Module::~Module. */ -void LLVMDisposeModule(LLVMModuleRef M); - -/** Data layout. See Module::getDataLayout. */ -/*const*/ char *LLVMGetDataLayout(LLVMModuleRef M); -void LLVMSetDataLayout(LLVMModuleRef M, /*const*/ char *DataLayout); - -/** Target triple. See Module::getTargetTriple. */ -/*const*/ char *LLVMGetTarget(LLVMModuleRef M); -void LLVMSetTarget(LLVMModuleRef M, /*const*/ char *Triple); - -/** See Module::addTypeName. */ -int LLVMAddTypeName(LLVMModuleRef M, /*const*/ char *Name, LLVMTypeRef Ty); -void LLVMDeleteTypeName(LLVMModuleRef M, /*const*/ char *Name); - -/** See Module::dump. */ -void LLVMDumpModule(LLVMModuleRef M); - -/*===-- Types -------------------------------------------------------------===*/ - -/* LLVM types conform to the following hierarchy: - * - * types: - * integer type - * real type - * function type - * sequence types: - * array type - * pointer type - * vector type - * void type - * label type - * opaque type - */ - -LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty); - -/* Operations on integer types */ -LLVMTypeRef LLVMInt1Type(); -LLVMTypeRef LLVMInt8Type(); -LLVMTypeRef LLVMInt16Type(); -LLVMTypeRef LLVMInt32Type(); -LLVMTypeRef LLVMInt64Type(); -LLVMTypeRef LLVMIntType(uint NumBits); -uint LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy); - -/* Operations on real types */ -LLVMTypeRef LLVMFloatType(); -LLVMTypeRef LLVMDoubleType(); -LLVMTypeRef LLVMX86FP80Type(); -LLVMTypeRef LLVMFP128Type(); -LLVMTypeRef LLVMPPCFP128Type(); - -/* Operations on function types */ -LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, - LLVMTypeRef *ParamTypes, uint ParamCount, - int IsVarArg); -int LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy); -LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy); -uint LLVMCountParamTypes(LLVMTypeRef FunctionTy); -void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest); - -/* Operations on struct types */ -LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, uint ElementCount, - int Packed); -uint LLVMCountStructElementTypes(LLVMTypeRef StructTy); -void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest); -int LLVMIsPackedStruct(LLVMTypeRef StructTy); - -/* Operations on array, pointer, and vector types (sequence types) */ -LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, uint ElementCount); -LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, uint AddressSpace); -LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, uint ElementCount); - -LLVMTypeRef LLVMGetElementType(LLVMTypeRef Ty); -uint LLVMGetArrayLength(LLVMTypeRef ArrayTy); -uint LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy); -uint LLVMGetVectorSize(LLVMTypeRef VectorTy); - -/* Operations on other types */ -LLVMTypeRef LLVMVoidType(); -LLVMTypeRef LLVMLabelType(); -LLVMTypeRef LLVMOpaqueType(); - -/* Operations on type handles */ -LLVMTypeHandleRef LLVMCreateTypeHandle(LLVMTypeRef PotentiallyAbstractTy); -void LLVMRefineType(LLVMTypeRef AbstractTy, LLVMTypeRef ConcreteTy); -LLVMTypeRef LLVMResolveTypeHandle(LLVMTypeHandleRef TypeHandle); -void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle); - - -/*===-- Values ------------------------------------------------------------===*/ - -/* The bulk of LLVM's object model consists of values, which comprise a very - * rich type hierarchy. - * - * values: - * constants: - * scalar constants - * composite contants - * globals: - * global variable - * function - * alias - * basic blocks - */ - -/* Operations on all values */ -LLVMTypeRef LLVMTypeOf(LLVMValueRef Val); -/*const*/ char *LLVMGetValueName(LLVMValueRef Val); -void LLVMSetValueName(LLVMValueRef Val, /*const*/ char *Name); -void LLVMDumpValue(LLVMValueRef Val); - -/* Operations on constants of any type */ -LLVMValueRef LLVMConstNull(LLVMTypeRef Ty); /* all zeroes */ -LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty); /* only for int/vector */ -LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty); -int LLVMIsConstant(LLVMValueRef Val); -int LLVMIsNull(LLVMValueRef Val); -int LLVMIsUndef(LLVMValueRef Val); - -/* Operations on scalar constants */ -LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, ulong N, - int SignExtend); -LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, /*const*/ char *Text, - ubyte Radix); -LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, /*const*/ char *Text, - uint SLen, ubyte Radix); -LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N); -LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, /*const*/ char *Text); -LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, /*const*/ char *Text, - uint SLen); - -/* Operations on composite constants */ -LLVMValueRef LLVMConstString(/*const*/ char *Str, uint Length, - int DontNullTerminate); -LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, - LLVMValueRef *ConstantVals, uint Length); -LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, uint Count, - int packed); -LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, uint Size); - -/* Constant expressions */ -LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty); -LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal); -LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal); -LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, - LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, - LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant); -LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, - LLVMValueRef *ConstantIndices, uint NumIndices); -LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType); -LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, - LLVMValueRef ConstantIfTrue, - LLVMValueRef ConstantIfFalse); -LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, - LLVMValueRef IndexConstant); -LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, - LLVMValueRef ElementValueConstant, - LLVMValueRef IndexConstant); -LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, - LLVMValueRef VectorBConstant, - LLVMValueRef MaskConstant); -LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, uint *IdxList, - uint NumIdx); -LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, - LLVMValueRef ElementValueConstant, - uint *IdxList, uint NumIdx); - -/* Operations on global variables, functions, and aliases (globals) */ -LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global); -int LLVMIsDeclaration(LLVMValueRef Global); -LLVMLinkage LLVMGetLinkage(LLVMValueRef Global); -void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage); -/*const*/ char *LLVMGetSection(LLVMValueRef Global); -void LLVMSetSection(LLVMValueRef Global, /*const*/ char *Section); -LLVMVisibility LLVMGetVisibility(LLVMValueRef Global); -void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz); -uint LLVMGetAlignment(LLVMValueRef Global); -void LLVMSetAlignment(LLVMValueRef Global, uint Bytes); - -/* Operations on global variables */ -LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, /*const*/ char *Name); -LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, /*const*/ char *Name); -LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M); -LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M); -LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar); -LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar); -void LLVMDeleteGlobal(LLVMValueRef GlobalVar); -LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar); -void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal); -int LLVMIsThreadLocal(LLVMValueRef GlobalVar); -void LLVMSetThreadLocal(LLVMValueRef GlobalVar, int IsThreadLocal); -int LLVMIsGlobalConstant(LLVMValueRef GlobalVar); -void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, int IsConstant); - -/* Operations on functions */ -LLVMValueRef LLVMAddFunction(LLVMModuleRef M, /*const*/ char *Name, - LLVMTypeRef FunctionTy); -LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, /*const*/ char *Name); -LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M); -LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M); -LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn); -LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn); -void LLVMDeleteFunction(LLVMValueRef Fn); -uint LLVMGetIntrinsicID(LLVMValueRef Fn); -uint LLVMGetFunctionCallConv(LLVMValueRef Fn); -void LLVMSetFunctionCallConv(LLVMValueRef Fn, uint CC); -/*const*/ char *LLVMGetGC(LLVMValueRef Fn); -void LLVMSetGC(LLVMValueRef Fn, /*const*/ char *Name); -void LLVMAddFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); -void LLVMRemoveFunctionAttr(LLVMValueRef Fn, LLVMAttribute PA); - -/* Operations on parameters */ -uint LLVMCountParams(LLVMValueRef Fn); -void LLVMGetParams(LLVMValueRef Fn, LLVMValueRef *Params); -LLVMValueRef LLVMGetParam(LLVMValueRef Fn, uint Index); -LLVMValueRef LLVMGetParamParent(LLVMValueRef Inst); -LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn); -LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn); -LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg); -LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg); -void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA); -void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA); -void LLVMSetParamAlignment(LLVMValueRef Arg, uint alignm); - - -/* Operations on basic blocks */ -LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef Bb); -int LLVMValueIsBasicBlock(LLVMValueRef Val); -LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val); -LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB); -uint LLVMCountBasicBlocks(LLVMValueRef Fn); -void LLVMGetBasicBlocks(LLVMValueRef Fn, LLVMBasicBlockRef *BasicBlocks); -LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn); -LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn); -LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB); -LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB); -LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn); -LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef Fn, /*const*/ char *Name); -LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef InsertBeforeBB, - /*const*/ char *Name); -void LLVMDeleteBasicBlock(LLVMBasicBlockRef BB); - -/* Operations on instructions */ -LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst); -LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB); -LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB); -LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst); -LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst); - -/* Operations on call sites */ -void LLVMSetInstructionCallConv(LLVMValueRef Instr, uint CC); -uint LLVMGetInstructionCallConv(LLVMValueRef Instr); -void LLVMAddInstrAttribute(LLVMValueRef Instr, uint index, LLVMAttribute); -void LLVMRemoveInstrAttribute(LLVMValueRef Instr, uint index, LLVMAttribute); -void LLVMSetInstrParamAlignment(LLVMValueRef Instr, uint index, uint alignm); - -/* Operations on call instructions (only) */ -int LLVMIsTailCall(LLVMValueRef CallInst); -void LLVMSetTailCall(LLVMValueRef CallInst, int IsTailCall); - -/* Operations on phi nodes */ -void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, - LLVMBasicBlockRef *IncomingBlocks, uint Count); -uint LLVMCountIncoming(LLVMValueRef PhiNode); -LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, uint Index); -LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, uint Index); - -/*===-- Instruction builders ----------------------------------------------===*/ - -/* An instruction builder represents a point within a basic block, and is the - * exclusive means of building instructions using the C interface. - */ - -LLVMBuilderRef LLVMCreateBuilder(); -void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, - LLVMValueRef Instr); -void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr); -void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block); -LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder); -void LLVMDisposeBuilder(LLVMBuilderRef Builder); - -/* Terminators */ -LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef); -LLVMValueRef LLVMBuildRet(LLVMBuilderRef, LLVMValueRef V); -LLVMValueRef LLVMBuildBr(LLVMBuilderRef, LLVMBasicBlockRef Dest); -LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef, LLVMValueRef If, - LLVMBasicBlockRef Then, LLVMBasicBlockRef Else); -LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef, LLVMValueRef V, - LLVMBasicBlockRef Else, uint NumCases); -LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef, LLVMValueRef Fn, - LLVMValueRef *Args, uint NumArgs, - LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, - /*const*/ char *Name); -LLVMValueRef LLVMBuildUnwind(LLVMBuilderRef); -LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef); - -/* Add a case to the switch instruction */ -void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, - LLVMBasicBlockRef Dest); - -/* Arithmetic */ -LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildSub(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildMul(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildURem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildSRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildFRem(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildShl(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildLShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildAShr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildAnd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildOr(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildXor(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, /*const*/ char *Name); -LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, /*const*/ char *Name); - -/* Memory */ -LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, /*const*/ char *Name); -LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty, - LLVMValueRef Val, /*const*/ char *Name); -LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef, LLVMTypeRef Ty, /*const*/ char *Name); -LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef, LLVMTypeRef Ty, - LLVMValueRef Val, /*const*/ char *Name); -LLVMValueRef LLVMBuildFree(LLVMBuilderRef, LLVMValueRef PointerVal); -LLVMValueRef LLVMBuildLoad(LLVMBuilderRef, LLVMValueRef PointerVal, - /*const*/ char *Name); -LLVMValueRef LLVMBuildStore(LLVMBuilderRef, LLVMValueRef Val, LLVMValueRef Ptr); -LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, - LLVMValueRef *Indices, uint NumIndices, - /*const*/ char *Name); -LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, - LLVMValueRef *Indices, uint NumIndices, - /*const*/ char *Name); - -/* Casts */ -LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildSExt(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); -LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef, LLVMValueRef Val, - LLVMTypeRef DestTy, /*const*/ char *Name); - -/* Comparisons */ -LLVMValueRef LLVMBuildICmp(LLVMBuilderRef, LLVMIntPredicate Op, - LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); -LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef, LLVMRealPredicate Op, - LLVMValueRef LHS, LLVMValueRef RHS, - /*const*/ char *Name); - -/* Miscellaneous instructions */ -LLVMValueRef LLVMBuildPhi(LLVMBuilderRef, LLVMTypeRef Ty, /*const*/ char *Name); -LLVMValueRef LLVMBuildCall(LLVMBuilderRef, LLVMValueRef Fn, - LLVMValueRef *Args, uint NumArgs, - /*const*/ char *Name); -LLVMValueRef LLVMBuildSelect(LLVMBuilderRef, LLVMValueRef If, - LLVMValueRef Then, LLVMValueRef Else, - /*const*/ char *Name); -LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef, LLVMValueRef List, LLVMTypeRef Ty, - /*const*/ char *Name); -LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef, LLVMValueRef VecVal, - LLVMValueRef Index, /*const*/ char *Name); -LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef, LLVMValueRef VecVal, - LLVMValueRef EltVal, LLVMValueRef Index, - /*const*/ char *Name); -LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef, LLVMValueRef V1, - LLVMValueRef V2, LLVMValueRef Mask, - /*const*/ char *Name); -LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef, LLVMValueRef AggVal, - uint Index, /*const*/ char *Name); -LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef, LLVMValueRef AggVal, - LLVMValueRef EltVal, uint Index, - /*const*/ char *Name); - - -/*===-- Module providers --------------------------------------------------===*/ - -/* Encapsulates the module M in a module provider, taking ownership of the - * module. - * See the constructor llvm::ExistingModuleProvider::ExistingModuleProvider. - */ -LLVMModuleProviderRef -LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M); - -/* Destroys the module provider MP as well as the contained module. - * See the destructor llvm::ModuleProvider::~ModuleProvider. - */ -void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP); - - -/*===-- Memory buffers ----------------------------------------------------===*/ - -int LLVMCreateMemoryBufferWithContentsOfFile(/*const*/ char *Path, - LLVMMemoryBufferRef *OutMemBuf, - char **OutMessage); -int LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, - char **OutMessage); -void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf); - -/*===-- Pass Managers -----------------------------------------------------===*/ - -/** Constructs a new whole-module pass pipeline. This type of pipeline is - suitable for link-time optimization and whole-module transformations. - See llvm::PassManager::PassManager. */ -LLVMPassManagerRef LLVMCreatePassManager(); - -/** Constructs a new function-by-function pass pipeline over the module - provider. It does not take ownership of the module provider. This type of - pipeline is suitable for code generation and JIT compilation tasks. - See llvm::FunctionPassManager::FunctionPassManager. */ -LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP); - -/** Initializes, executes on the provided module, and finalizes all of the - passes scheduled in the pass manager. Returns 1 if any of the passes - modified the module, 0 otherwise. See llvm::PassManager::run(Module&). */ -int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M); - -/** Initializes all of the function passes scheduled in the function pass - manager. Returns 1 if any of the passes modified the module, 0 otherwise. - See llvm::FunctionPassManager::doInitialization. */ -int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM); - -/** Executes all of the function passes scheduled in the function pass manager - on the provided function. Returns 1 if any of the passes modified the - function, false otherwise. - See llvm::FunctionPassManager::run(Function&). */ -int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F); - -/** Finalizes all of the function passes scheduled in in the function pass - manager. Returns 1 if any of the passes modified the module, 0 otherwise. - See llvm::FunctionPassManager::doFinalization. */ -int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM); - -/** Frees the memory of a pass pipeline. For function pipelines, does not free - the module provider. - See llvm::PassManagerBase::~PassManagerBase. */ -void LLVMDisposePassManager(LLVMPassManagerRef PM); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/ExecutionEngine.d --- a/tools/binding/llvm/c/ExecutionEngine.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,94 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2008 -// Original file header: -/*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMExecutionEngine.o, which *| -|* implements various analyses of the LLVM IR. *| -|* *| -|* Many exotic languages can interoperate with C code but have a harder time *| -|* with C++ due to name mangling. So in addition to C, this interface enables *| -|* tools written in such languages. *| -|* *| -\*===----------------------------------------------------------------------===*/ - -module llvm.c.ExecutionEngine; - -import llvm.c.Core; - -extern(C): - -private -{ - struct LLVM_OpaqueGenericValue {} - struct LLVM_OpaqueExecutionEngine {} -} - -typedef LLVM_OpaqueGenericValue* LLVMGenericValueRef; -typedef LLVM_OpaqueExecutionEngine* LLVMExecutionEngineRef; - -/*===-- Operations on generic values --------------------------------------===*/ - -LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty, - ulong N, - int IsSigned); - -LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P); - -LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N); - -uint LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef); - -ulong LLVMGenericValueToInt(LLVMGenericValueRef GenVal, - int IsSigned); - -void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal); - -double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal); - -void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal); - -/*===-- Operations on execution engines -----------------------------------===*/ - -int LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE, - LLVMModuleProviderRef MP, - char **OutError); - -int LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp, - LLVMModuleProviderRef MP, - char **OutError); - -int LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT, - LLVMModuleProviderRef MP, - char **OutError); - -void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE); - -void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE); - -void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE); - -int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F, - uint ArgC, /*const*/ char * /*const*/ *ArgV, - /*const*/ char * /*const*/ *EnvP); - -LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F, - uint NumArgs, - LLVMGenericValueRef *Args); - -void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F); - -void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP); - -int LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE, - LLVMModuleProviderRef MP, - LLVMModuleRef *OutMod, char **OutError); - -int LLVMFindFunction(LLVMExecutionEngineRef EE, /*const*/ char *Name, - LLVMValueRef *OutFn); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/Ext.d --- a/tools/binding/llvm/c/Ext.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +0,0 @@ -// Written in the D programming language by Tomas Lindquist Olsen 2008 -// Extensions to the LLVM C interface for the D binding. -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -module llvm.c.Ext; - -import llvm.c.Core; - -// taken from llvm/Value.h -/// An enumeration for keeping track of the concrete subclass of Value that -/// is actually instantiated. Values of this enumeration are kept in the -/// Value classes SubclassID field. They are used for concrete type -/// identification. -enum LLVMValueKind : uint -{ - Argument, /// This is an instance of Argument - BasicBlock, /// This is an instance of BasicBlock - Function, /// This is an instance of Function - GlobalAlias, /// This is an instance of GlobalAlias - GlobalVariable, /// This is an instance of GlobalVariable - UndefValue, /// This is an instance of UndefValue - ConstantExpr, /// This is an instance of ConstantExpr - ConstantAggregateZero, /// This is an instance of ConstantAggregateNull - ConstantInt, /// This is an instance of ConstantInt - ConstantFP, /// This is an instance of ConstantFP - ConstantArray, /// This is an instance of ConstantArray - ConstantStruct, /// This is an instance of ConstantStruct - ConstantVector, /// This is an instance of ConstantVector - ConstantPointerNull, /// This is an instance of ConstantPointerNull - InlineAsm, /// This is an instance of InlineAsm - Instruction /// This is an instance of Instruction -} - -extern(C) -{ - void LLVMEraseFromParent(LLVMValueRef I); - int LLVMIsTerminated(LLVMBasicBlockRef BB); - int LLVMHasPredecessors(LLVMBasicBlockRef BB); - int LLVMIsBasicBlockEmpty(LLVMBasicBlockRef BB); - void LLVMReplaceAllUsesWith(LLVMValueRef V, LLVMValueRef W); - - void LLVMOptimizeModule(LLVMModuleRef M, int doinline); - void LLVMDumpType(LLVMTypeRef T); - - LLVMValueRef LLVMGetOrInsertFunction(LLVMModuleRef M, char* Name, LLVMTypeRef Type); - - /// Return a strdup()ed string which must be free()ed - char* LLVMValueToString(LLVMValueRef v); - char* LLVMTypeToString(LLVMTypeRef ty); /// ditto - - LLVMValueKind LLVMGetValueKind(LLVMValueRef Value); - - LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, char* Name); - int LLVMIsTypeAbstract(LLVMTypeRef T); - - alias void function(void* handle, LLVMTypeRef newT) RefineCallback; - void LLVMRegisterAbstractTypeCallback(LLVMTypeRef T, - void* handle, - RefineCallback callback); -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/Target.d --- a/tools/binding/llvm/c/Target.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,110 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2008 -// Original file header: -/*===-- llvm-c/Target.h - Target Lib C Iface --------------------*- C++ -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMTarget.a, which *| -|* implements target information. *| -|* *| -|* Many exotic languages can interoperate with C code but have a harder time *| -|* with C++ due to name mangling. So in addition to C, this interface enables *| -|* tools written in such languages. *| -|* *| -\*===----------------------------------------------------------------------===*/ - -module llvm.c.Target; - -import llvm.c.Core; - -extern(C): - -enum { LLVMBigEndian, LLVMLittleEndian }; -alias int LLVMByteOrdering; - -typedef void* LLVMTargetDataRef; -typedef void* LLVMStructLayoutRef; - - -/*===-- Target Data -------------------------------------------------------===*/ - -/** Creates target data from a target layout string. - See the constructor llvm::TargetData::TargetData. */ -LLVMTargetDataRef LLVMCreateTargetData( /*const*/ char *StringRep); - -/** Adds target data information to a pass manager. This does not take ownership - of the target data. - See the method llvm::PassManagerBase::add. */ -void LLVMAddTargetData(LLVMTargetDataRef, LLVMPassManagerRef); - -/** Converts target data to a target layout string. The string must be disposed - with LLVMDisposeMessage. - See the constructor llvm::TargetData::TargetData. */ -char *LLVMCopyStringRepOfTargetData(LLVMTargetDataRef); - -/** Returns the byte order of a target, either LLVMBigEndian or - LLVMLittleEndian. - See the method llvm::TargetData::isLittleEndian. */ -LLVMByteOrdering LLVMByteOrder(LLVMTargetDataRef); - -/** Returns the pointer size in bytes for a target. - See the method llvm::TargetData::getPointerSize. */ -uint LLVMPointerSize(LLVMTargetDataRef); - -/** Returns the integer type that is the same size as a pointer on a target. - See the method llvm::TargetData::getIntPtrType. */ -LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef); - -/** Computes the size of a type in bytes for a target. - See the method llvm::TargetData::getTypeSizeInBits. */ -ulong LLVMSizeOfTypeInBits(LLVMTargetDataRef, LLVMTypeRef); - -/** Computes the storage size of a type in bytes for a target. - See the method llvm::TargetData::getTypeStoreSize. */ -ulong LLVMStoreSizeOfType(LLVMTargetDataRef, LLVMTypeRef); - -/** Computes the ABI size of a type in bytes for a target. - See the method llvm::TargetData::getABITypeSize. */ -ulong LLVMABISizeOfType(LLVMTargetDataRef, LLVMTypeRef); - -/** Computes the ABI alignment of a type in bytes for a target. - See the method llvm::TargetData::getTypeABISize. */ -uint LLVMABIAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef); - -/** Computes the call frame alignment of a type in bytes for a target. - See the method llvm::TargetData::getTypeABISize. */ -uint LLVMCallFrameAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef); - -/** Computes the preferred alignment of a type in bytes for a target. - See the method llvm::TargetData::getTypeABISize. */ -uint LLVMPreferredAlignmentOfType(LLVMTargetDataRef, LLVMTypeRef); - -/** Computes the preferred alignment of a global variable in bytes for a target. - See the method llvm::TargetData::getPreferredAlignment. */ -uint LLVMPreferredAlignmentOfGlobal(LLVMTargetDataRef, - LLVMValueRef GlobalVar); - -/** Computes the structure element that contains the byte offset for a target. - See the method llvm::StructLayout::getElementContainingOffset. */ -uint LLVMElementAtOffset(LLVMTargetDataRef, LLVMTypeRef StructTy, - ulong Offset); - -/** Computes the byte offset of the indexed struct element for a target. - See the method llvm::StructLayout::getElementContainingOffset. */ -ulong LLVMOffsetOfElement(LLVMTargetDataRef, LLVMTypeRef StructTy, - uint Element); - -/** Struct layouts are speculatively cached. If a TargetDataRef is alive when - types are being refined and removed, this method must be called whenever a - struct type is removed to avoid a dangling pointer in this cache. - See the method llvm::TargetData::InvalidateStructLayoutInfo. */ -void LLVMInvalidateStructLayout(LLVMTargetDataRef, LLVMTypeRef StructTy); - -/** Deallocates a TargetData. - See the destructor llvm::TargetData::~TargetData. */ -void LLVMDisposeTargetData(LLVMTargetDataRef); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/transforms/IPO.d --- a/tools/binding/llvm/c/transforms/IPO.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,62 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2009 - -/*===-- IPO.h - Interprocedural Transformations C Interface -----*- C++ -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMIPO.a, which implements *| -|* various interprocedural transformations of the LLVM IR. *| -|* *| -\*===----------------------------------------------------------------------===*/ -module llvm.c.transforms.IPO; - -import llvm.c.Core; - -extern(C): - -/** See llvm::createArgumentPromotionPass function. */ -void LLVMAddArgumentPromotionPass(LLVMPassManagerRef PM); - -/** See llvm::createConstantMergePass function. */ -void LLVMAddConstantMergePass(LLVMPassManagerRef PM); - -/** See llvm::createDeadArgEliminationPass function. */ -void LLVMAddDeadArgEliminationPass(LLVMPassManagerRef PM); - -/** See llvm::createDeadTypeEliminationPass function. */ -void LLVMAddDeadTypeEliminationPass(LLVMPassManagerRef PM); - -/** See llvm::createFunctionAttrsPass function. */ -void LLVMAddFunctionAttrsPass(LLVMPassManagerRef PM); - -/** See llvm::createFunctionInliningPass function. */ -void LLVMAddFunctionInliningPass(LLVMPassManagerRef PM); - -/** See llvm::createGlobalDCEPass function. */ -void LLVMAddGlobalDCEPass(LLVMPassManagerRef PM); - -/** See llvm::createGlobalOptimizerPass function. */ -void LLVMAddGlobalOptimizerPass(LLVMPassManagerRef PM); - -/** See llvm::createIPConstantPropagationPass function. */ -void LLVMAddIPConstantPropagationPass(LLVMPassManagerRef PM); - -/** See llvm::createLowerSetJmpPass function. */ -void LLVMAddLowerSetJmpPass(LLVMPassManagerRef PM); - -/** See llvm::createPruneEHPass function. */ -void LLVMAddPruneEHPass(LLVMPassManagerRef PM); - -/** See llvm::createRaiseAllocationsPass function. */ -void LLVMAddRaiseAllocationsPass(LLVMPassManagerRef PM); - -/** See llvm::createStripDeadPrototypesPass function. */ -void LLVMAddStripDeadPrototypesPass(LLVMPassManagerRef PM); - -/** See llvm::createStripSymbolsPass function. */ -void LLVMAddStripSymbolsPass(LLVMPassManagerRef PM); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/c/transforms/Scalar.d --- a/tools/binding/llvm/c/transforms/Scalar.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,93 +0,0 @@ -// Converted to the D programming language by Tomas Lindquist Olsen 2009 - -/*===-- Scalar.h - Scalar Transformation Library C Interface ----*- C++ -*-===*\ -|* *| -|* The LLVM Compiler Infrastructure *| -|* *| -|* This file is distributed under the University of Illinois Open Source *| -|* License. See LICENSE.TXT for details. *| -|* *| -|*===----------------------------------------------------------------------===*| -|* *| -|* This header declares the C interface to libLLVMScalarOpts.a, which *| -|* implements various scalar transformations of the LLVM IR. *| -|* *| -|* Many exotic languages can interoperate with C code but have a harder time *| -|* with C++ due to name mangling. So in addition to C, this interface enables *| -|* tools written in such languages. *| -|* *| -\*===----------------------------------------------------------------------===*/ -module llvm.c.transforms.Scalar; - -import llvm.c.Core; - -extern(C): - -/** See llvm::createAggressiveDCEPass function. */ -void LLVMAddAggressiveDCEPass(LLVMPassManagerRef PM); - -/** See llvm::createCFGSimplificationPass function. */ -void LLVMAddCFGSimplificationPass(LLVMPassManagerRef PM); - -/** See llvm::createCondPropagationPass function. */ -void LLVMAddCondPropagationPass(LLVMPassManagerRef PM); - -/** See llvm::createDeadStoreEliminationPass function. */ -void LLVMAddDeadStoreEliminationPass(LLVMPassManagerRef PM); - -/** See llvm::createGVNPass function. */ -void LLVMAddGVNPass(LLVMPassManagerRef PM); - -/** See llvm::createIndVarSimplifyPass function. */ -void LLVMAddIndVarSimplifyPass(LLVMPassManagerRef PM); - -/** See llvm::createInstructionCombiningPass function. */ -void LLVMAddInstructionCombiningPass(LLVMPassManagerRef PM); - -/** See llvm::createJumpThreadingPass function. */ -void LLVMAddJumpThreadingPass(LLVMPassManagerRef PM); - -/** See llvm::createLICMPass function. */ -void LLVMAddLICMPass(LLVMPassManagerRef PM); - -/** See llvm::createLoopDeletionPass function. */ -void LLVMAddLoopDeletionPass(LLVMPassManagerRef PM); - -/** See llvm::createLoopIndexSplitPass function. */ -void LLVMAddLoopIndexSplitPass(LLVMPassManagerRef PM); - -/** See llvm::createLoopRotatePass function. */ -void LLVMAddLoopRotatePass(LLVMPassManagerRef PM); - -/** See llvm::createLoopUnrollPass function. */ -void LLVMAddLoopUnrollPass(LLVMPassManagerRef PM); - -/** See llvm::createLoopUnswitchPass function. */ -void LLVMAddLoopUnswitchPass(LLVMPassManagerRef PM); - -/** See llvm::createMemCpyOptPass function. */ -void LLVMAddMemCpyOptPass(LLVMPassManagerRef PM); - -/** See llvm::createPromoteMemoryToRegisterPass function. */ -void LLVMAddPromoteMemoryToRegisterPass(LLVMPassManagerRef PM); - -/** See llvm::createReassociatePass function. */ -void LLVMAddReassociatePass(LLVMPassManagerRef PM); - -/** See llvm::createSCCPPass function. */ -void LLVMAddSCCPPass(LLVMPassManagerRef PM); - -/** See llvm::createScalarReplAggregatesPass function. */ -void LLVMAddScalarReplAggregatesPass(LLVMPassManagerRef PM); - -/** See llvm::createSimplifyLibCallsPass function. */ -void LLVMAddSimplifyLibCallsPass(LLVMPassManagerRef PM); - -/** See llvm::createTailCallEliminationPass function. */ -void LLVMAddTailCallEliminationPass(LLVMPassManagerRef PM); - -/** See llvm::createConstantPropagationPass function. */ -void LLVMAddConstantPropagationPass(LLVMPassManagerRef PM); - -/** See llvm::demotePromoteMemoryToRegisterPass function. */ -void LLVMAddDemoteMemoryToRegisterPass(LLVMPassManagerRef PM); diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/executionengine.d --- a/tools/binding/llvm/executionengine.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,224 +0,0 @@ -// Written in the D programming language by Frits van Bommel 2008 -// Binding of llvm.c.ExecutionEngine for D. -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -module llvm.executionengine; - -import llvm.c.Core; -import llvm.c.ExecutionEngine; - -import llvm.llvm; -import llvm.util; - -/// -class GenericValue -{ - /// - private LLVMGenericValueRef value; - /// - private this(LLVMGenericValueRef v) - { - value = v; - } - /// - void dispose() - { - LLVMDisposeGenericValue(value); - value = null; - } - /// - ~this() - { - dispose(); // safe because value isn't on the GC heap and isn't exposed. - } - /// - static GenericValue GetS(IntegerType ty, long N) - { - return new GenericValue(LLVMCreateGenericValueOfInt(ty.ll, N, true)); - } - /// - static GenericValue GetU(IntegerType ty, ulong N) - { - return new GenericValue(LLVMCreateGenericValueOfInt(ty.ll, N, false)); - } - /// - static GenericValue GetP(void* P) - { - return new GenericValue(LLVMCreateGenericValueOfPointer(P)); - } - /// - static GenericValue GetF(RealType ty, double N) - { - return new GenericValue(LLVMCreateGenericValueOfFloat(ty.ll, N)); - } - /// - uint intWidth() - { - return LLVMGenericValueIntWidth(value); - } - /// - ulong toUInt() - { - return LLVMGenericValueToInt(value, false); - } - /// - long toSInt() - { - return LLVMGenericValueToInt(value, true); - } - /// - void* toPointer() - { - return LLVMGenericValueToPointer(value); - } - /// - double toFloat(RealType ty) - { - return LLVMGenericValueToFloat(ty.ll, value); - } -} - - -/// -class ExecutionEngine -{ - /// - private LLVMExecutionEngineRef ee; - /// - private this(LLVMExecutionEngineRef ee) - { - this.ee = ee; - } - /// - static ExecutionEngine Create(ModuleProvider mp) - { - LLVMExecutionEngineRef ee; - char* err; - if (LLVMCreateExecutionEngine(&ee, mp.ll, &err)) - { - auto errmsg = from_stringz(err).dup; - LLVMDisposeMessage(err); - if (errmsg.length == 0) - errmsg = "Error creating execution engine"; - throw new LLVMException(errmsg); - } - return new ExecutionEngine(ee); - } - /// - static ExecutionEngine CreateInterpreter(ModuleProvider mp) - { - LLVMExecutionEngineRef ee; - char* err; - if (LLVMCreateInterpreter(&ee, mp.ll, &err)) - { - auto errmsg = from_stringz(err).dup; - LLVMDisposeMessage(err); - if (errmsg.length == 0) - errmsg = "Error creating interpreter"; - throw new LLVMException(errmsg); - } - return new ExecutionEngine(ee); - } - /// - static ExecutionEngine CreateJIT(ModuleProvider mp) - { - LLVMExecutionEngineRef ee; - char* err; - if (LLVMCreateJITCompiler(&ee, mp.ll, &err)) - { - auto errmsg = from_stringz(err).dup; - LLVMDisposeMessage(err); - if (errmsg.length == 0) - errmsg = "Error creating JIT"; - throw new LLVMException(errmsg); - } - return new ExecutionEngine(ee); - } - /// - void dispose() - { - LLVMDisposeExecutionEngine(ee); - ee = null; - } - /// - ~this() - { - dispose(); // safe because ee isn't on the GC heap and isn't exposed. - } - /// - void runStaticConstructors() - { - LLVMRunStaticConstructors(ee); - } - /// - void runStaticDestructors() - { - LLVMRunStaticDestructors(ee); - } - /// - int runAsMain(Function f, char[][] args = null, char[][] env = null) { - auto argv = new char*[args.length]; - foreach (size_t idx, ref arg; args) - { - argv[idx] = to_stringz(arg); - } - - auto envp = new char*[env.length + 1]; - foreach (size_t idx, ref envvar ; env) - { - envp[idx] = to_stringz(envvar); - } - envp[$-1] = null; - - return LLVMRunFunctionAsMain(ee, f.value, argv.length, argv.ptr, envp.ptr); - } - /// - GenericValue run(Function f, GenericValue[] args = null) - { - auto cargs = new LLVMGenericValueRef[args.length]; - foreach (size_t idx, ref arg ; args) - { - cargs[idx] = arg.value; - } - - auto result = LLVMRunFunction(ee, f.value, cargs.length, cargs.ptr); - return new GenericValue(result); - } - /// - void freeMachineCodeForFunction(Function f) - { - LLVMFreeMachineCodeForFunction(ee, f.value); - } - /// - void addModuleProvider(ModuleProvider mp) - { - LLVMAddModuleProvider(ee, mp.ll); - } - /// - Module removeModuleProvider(ModuleProvider mp) - { - LLVMModuleRef mod; - char* err; - if (LLVMRemoveModuleProvider(ee, mp.ll, &mod, &err)) - { - auto errmsg = from_stringz(err).dup; - LLVMDisposeMessage(err); - if (errmsg.length == 0) - errmsg = "Error removing ModuleProvider from ExecutionEngine"; - throw new LLVMException(errmsg); - } - return Module.GetExisting(mod); - } - /// - Function findFunction(char[] name) - { - LLVMValueRef fn; - if (LLVMFindFunction(ee, to_stringz(name), &fn)) - { - return null; - } - return new Function(fn, getTypeOf(fn)); - } -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/llvm.d --- a/tools/binding/llvm/llvm.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1033 +0,0 @@ -// Written in the D programming language by Tomas Lindquist Olsen 2008 -// Binding of llvm.c.Core values for D. -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -module llvm.llvm; - -import llvm.c.Core; -import llvm.c.Ext; -import llvm.c.BitWriter; -import llvm.c.BitReader; -import llvm.c.Analysis; -import llvm.c.Target; - -public import llvm.type; -public import llvm.builder; - -import llvm.util; - -/// -class LLVMException : Exception -{ - this(char[] msg) { - super(msg); - } -} - -version(Tango) { - import tango.stdc.stdlib; -} -else { - import std.c.stdlib; -} -/// -alias LLVMLinkage Linkage; -/// -alias LLVMIntPredicate IntPredicate; -/// -alias LLVMRealPredicate RealPredicate; -/// -alias LLVMCallConv CallConv; -/// -alias LLVMVisibility Visibility; -/// -alias LLVMValueKind ValueKind; - -/// -class Module -{ - /// 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)); - registry[mod] = this; - } - /// - private this(LLVMModuleRef m) - { - name = null; - mod = m; - registry[m] = this; - } - /// - static package Module GetExisting(LLVMModuleRef m) - { - if (auto p = m in registry) - { - return *p; - } - return new Module(m); - } - /// Create a module from bitcode. Returns the Module on success, null on failure. - static Module GetFromBitcode(char[] bitcodepath, ref char[] errmsg) - { - LLVMModuleRef mref; - LLVMMemoryBufferRef bref; - 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); - } - /// important to call this when done - void dispose() - { - if (mod) - { - registry.remove(mod); - LLVMDisposeModule(mod); - mod = null; - } - } - /// - char[] dataLayout() - { - assert(mod !is null); - return from_stringz(LLVMGetDataLayout(mod)); - } - /// - void dataLayout(char[] dl) - { - assert(mod !is null); - LLVMSetDataLayout(mod, to_stringz(dl)); - } - /// - char[] target() - { - assert(mod !is null); - return from_stringz(LLVMGetTarget(mod)); - } - /// - void target(char[] dl) - { - assert(mod !is null); - LLVMSetTarget(mod, to_stringz(dl)); - } - /// - bool addTypeName(char[] nam, Type t) - { - assert(mod !is null); - return LLVMAddTypeName(mod, to_stringz(nam), t.ll) != 0; - } - /// - Type getTypeByName(char[] name) { - return getTypeOf(LLVMGetTypeByName(mod, to_stringz(name))); - } - /// - void deleteTypeName(char[] nam) - { - assert(mod !is null); - LLVMDeleteTypeName(mod, to_stringz(nam)); - } - /// - GlobalVariable addGlobal(Type t, char[] nam) - { - assert(mod !is null); - auto c = LLVMAddGlobal(mod, t.ll, to_stringz(nam)); - assert(c !is null); - return new GlobalVariable(c, getTypeOf(c)); - } - /// Convenience method, type is taken to be that of the initializer - GlobalVariable addGlobal(Constant initializer, char[] name) - { - auto global = addGlobal(initializer.type, name); - global.initializer = initializer; - return global; - } - /// - GlobalValue getNamedGlobal(char[] nam) - { - assert(mod !is null); - auto c = LLVMGetNamedGlobal(mod, to_stringz(nam)); - if (c is null) return null; - return cast(GlobalValue)getValueOf(c); - } - /// - Function addFunction(Type t, char[] nam) - { - assert(mod !is null); - auto c = LLVMAddFunction(mod, to_stringz(nam), t.ll); - assert(c !is null); - return new Function(c, getTypeOf(c)); - } - /// - Function getNamedFunction(char[] nam) - { - assert(mod !is null); - auto c = LLVMGetNamedFunction(mod, to_stringz(nam)); - if (c is null) return null; - return cast(Function)getValueOf(c); - } - /// - Function getOrInsertFunction(Type t, char[] nam) - { - assert(mod !is null); - auto c = LLVMGetOrInsertFunction(mod, to_stringz(nam), t.ll); - auto val = 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) - { - LLVMOptimizeModule(mod, inline); - } - /// Writes the module to an open file descriptor. Returns true on success. - bool writeBitcodeToFileHandle(int handle) - { - return (LLVMWriteBitcodeToFileHandle(mod, handle) == 0); - } - /// Writes the module to the specified path. Returns 0 on success. - bool writeBitcodeToFile(char[] path) - { - return (LLVMWriteBitcodeToFile(mod, to_stringz(path)) == 0); - } - /// Throws an exception if the module doesn't pass the LLVM verifier. - void verify() - { - 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); - } - } -} - -class ModuleProvider -{ - /// - private LLVMModuleProviderRef mp; - /// - private this(LLVMModuleProviderRef mp) - { - this.mp = mp; - } - /// Takes ownership of module, returns a ModuleProvider for it. - static ModuleProvider GetForModule(Module m) - { - auto mp = LLVMCreateModuleProviderForExistingModule(m.mod); - return new ModuleProvider(mp); - } - /// Destroys the provided module, unless this MP was passed to an ExecutionEngine. - void dispose() - { - LLVMDisposeModuleProvider(mp); - mp = null; - } - /// Returns a lazily-deserializing ModuleProvider - static ModuleProvider GetFromBitcode(char[] filename) - { - LLVMMemoryBufferRef buf; - 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 ... - if (LLVMGetBitcodeModuleProvider(buf, &mp, &msg)) - { - // ... 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); - } - /// - package LLVMModuleProviderRef ll() - { - return mp; - } -} - -/// -class Value -{ - /// - const LLVMValueRef value; - /// - const Type type; - /// - this(LLVMValueRef v, Type t=null) { - value = v; - if (t is null) t = getTypeOf(v); - type = t; - } - /// - char[] toString() { - auto cstr = LLVMValueToString(value); - auto result = from_stringz(cstr).dup; - free(cstr); - return result; - } - /// - ValueKind kind() - { - return LLVMGetValueKind(value); - } - /// - char[] name() - { - return from_stringz(LLVMGetValueName(value)); - } - /// - void name(char[] s) - { - LLVMSetValueName(value, to_stringz(s)); - } - /// - void dump() { - LLVMDumpValue(value); - } - /// - bool isConstant() - { - return LLVMIsConstant(value) != 0; - } - /// - int opEquals(Object o) - { - auto v = cast(Value)o; - if (v is null) return 0; - if (value is v.value) - return 1; - return 0; - } - /// invalidates object - void eraseFromParent() - { - LLVMEraseFromParent(value); - } - /// ditto - void replaceAllUsesWith(Value newval) - { - LLVMReplaceAllUsesWith(value, newval.value); - } - - /// only for call's - void callConv(uint CC) - { - LLVMSetInstructionCallConv(value, CC); - } - /// ditto - uint callConv() - { - return LLVMGetInstructionCallConv(value); - } - - /// only for phi's - void addIncoming(Value[] inValues, BasicBlock[] inBlocks) - { - auto n = inValues.length; - assert(n == inBlocks.length); - auto v = new LLVMValueRef[n]; - auto b = new LLVMBasicBlockRef[n]; - for (size_t i=0; i 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)); - } - } -} - -/// -abstract class ScalarConstant : Constant -{ - /// - protected this(LLVMValueRef v, Type t) - { - super(v, t); - } -} - -/// -class ConstantInt : ScalarConstant -{ - /// - private this(LLVMValueRef v, Type t) - { - super(v, t); - } - /// - static ConstantInt Get(Type t, ulong N, bool signExt) - { - auto c = LLVMConstInt(t.ll, N, signExt); - return new ConstantInt(c, t); - } - /// - static ConstantInt GetS(Type t, long N) - { - return Get(t, cast(ulong)N, true); - } - /// - static ConstantInt GetU(Type t, ulong N) - { - return Get(t, N, false); - } -} - -/// -class ConstantReal : ScalarConstant -{ - /// - private this(LLVMValueRef v, Type t) - { - super(v, t); - } - /// - static ConstantReal Get(Type t, real N) - { - auto c = LLVMConstReal(t.ll, N); - return new ConstantReal(c, t); - } -} - -/// -abstract class CompositeConstant : Constant -{ - /// - protected this(LLVMValueRef v, Type t) - { - super(v, t); - } -} - -/// -class ConstantArray : CompositeConstant -{ - /// - private this(LLVMValueRef v, Type t) - { - super(v, t); - } - /// - static ConstantArray Get(Type eltty, Constant[] vals) - { - auto p = new LLVMValueRef[vals.length]; - foreach(i,v; vals) p[i] = v.value; - auto c = LLVMConstArray(eltty.ll, p.ptr, p.length); - return new ConstantArray(c, getTypeOf(c)); - } - /// - static ConstantArray GetString(char[] str, bool nullterm) - { - auto len = str.length + nullterm; - auto c = LLVMConstString(str.ptr, str.length, !nullterm); - return new ConstantArray(c, getTypeOf(c)); - } -} - -/// -class ConstantStruct : CompositeConstant -{ - /// - private this(LLVMValueRef v, Type t) - { - super(v, t); - } - /// - static ConstantStruct Get(Constant[] vals, bool packed=false) - { - auto p = new LLVMValueRef[vals.length]; - foreach(i,v; vals) p[i] = v.value; - auto c = LLVMConstStruct(p.ptr, p.length, packed); - return new ConstantStruct(c, getTypeOf(c)); - } -} - -/// -class ConstantVector : CompositeConstant -{ - /// - private this(LLVMValueRef v, Type t) - { - super(v, t); - } - /// - static ConstantVector Get(ScalarConstant[] vals) - { - auto p = new LLVMValueRef[vals.length]; - foreach(i,v; vals) p[i] = v.value; - auto c = LLVMConstVector(p.ptr, p.length); - return new ConstantVector(c, getTypeOf(c)); - } -} - -/// -abstract class GlobalValue : Constant -{ - /// - private this(LLVMValueRef v, Type t) { - super(v, t); - } - /// - bool isDeclaration() - { - return LLVMIsDeclaration(value) != 0; - } - /// - Linkage linkage() - { - return LLVMGetLinkage(value); - } - /// - void linkage(Linkage l) - { - LLVMSetLinkage(value, l); - } - /// - char[] section() - { - return from_stringz(LLVMGetSection(value)); - } - /// - void section(char[] s) - { - LLVMSetSection(value, to_stringz(s)); - } - /// - Visibility visibility() - { - return LLVMGetVisibility(value); - } - /// - void visibility(Visibility v) - { - LLVMSetVisibility(value, v); - } - /// - uint alignment() - { - return LLVMGetAlignment(value); - } - /// - void alignment(uint bytes) - { - LLVMSetAlignment(value, bytes); - } -} - -/// -class GlobalVariable : GlobalValue -{ - /// TODO: void DeleteGlobal(ValueRef GlobalVar); - - /// - private this(LLVMValueRef v, Type t) { - super(v, t); - } - /// - bool hasInitializer() - { - return isDeclaration() == 0; - } - /// - Constant initializer() - { - auto c = LLVMGetInitializer(value); - if (c is null) return null; - return cast(Constant)getValueOf(c); - } - /// - void initializer(Constant c) - { - LLVMSetInitializer(value, c.value); - } - /// - bool threadLocal() - { - return LLVMIsThreadLocal(value) != 0; - } - /// - void threadLocal(bool b) - { - LLVMSetThreadLocal(value, b); - } - /// - bool globalConstant() - { - return LLVMIsGlobalConstant(value) != 0; - } - /// - void globalConstant(bool b) - { - LLVMSetGlobalConstant(value, b); - } -} - -/// -class Function : GlobalValue -{ - /// TODO: void GetParams(ValueRef Fn, ValueRef *Params); - /// TODO: void GetBasicBlocks(ValueRef Fn, BasicBlockRef *BasicBlocks); - - /// - package this(LLVMValueRef v, Type t) { - super(v, t); - } - /// - void eraseFromParent() - { - LLVMDeleteFunction(value); - } - /// - uint numParams() - { - return LLVMCountParams(value); - } - /// - Value getParam(uint idx) - { - auto v = LLVMGetParam(value, idx); - assert(v !is null); - return getValueOf(v); - } - /// - uint intrinsicID() - { - return LLVMGetIntrinsicID(value); - } - /// - uint callConv() - { - return LLVMGetFunctionCallConv(value); - } - /// - void callConv(uint cc) - { - LLVMSetFunctionCallConv(value, cc); - } - /// - char[] gc() - { - return from_stringz(LLVMGetGC(value)); - } - /// - void gc(char[] name) - { - LLVMSetGC(value, to_stringz(name)); - } - /// - uint numBasicBlocks() - { - return LLVMCountBasicBlocks(value); - } - /// - static BasicBlock InsertBasicBlock(BasicBlock bb, char[] name) - { - auto b = LLVMInsertBasicBlock(bb.bb, to_stringz(name)); - assert(b !is null); - return new BasicBlock(b); - } - /// - BasicBlock appendBasicBlock(char[] name) - { - auto b = LLVMAppendBasicBlock(value, to_stringz(name)); - assert(b !is null); - return new BasicBlock(b); - } - /// - BasicBlock getEntryBasicBlock() - { - auto b = LLVMGetEntryBasicBlock(value); - if (b is null) return null; - return new BasicBlock(b); - } - /// Throws an exception if the function doesn't pass the LLVM verifier. - void verify() - { - if (LLVMVerifyFunction(value, LLVMVerifierFailureAction.ReturnStatus)) - { - auto exceptionmsg = "Function failed to verify (" ~ name ~ ")"; - throw new LLVMException(exceptionmsg); - } - } -} - -/// -class BasicBlock -{ - /// - LLVMBasicBlockRef bb; - /// - this(LLVMBasicBlockRef b) - { - assert(b !is null); - bb = b; - } - /// - this(Value v) - { - assert(LLVMValueIsBasicBlock(v.value)); - bb = LLVMValueAsBasicBlock(v.value); - } - /// - override int opEquals(Object o) { - auto block = cast(BasicBlock) o; - if (!block) - return false; - return bb == block.bb; - } - /// - void dispose() - { - LLVMDeleteBasicBlock(bb); - bb = null; - } - /// - Function getParent() { - assert(bb !is null); - auto func = LLVMGetBasicBlockParent(bb); - if (!func) return null; - return new Function(func, getTypeOf(func)); - } - /// - Value asValue() - { - assert(bb !is null); - auto v = LLVMBasicBlockAsValue(bb); - return new Value(v, Type.Label); - } - /// - bool terminated() - { - assert(bb !is null); - return (LLVMIsTerminated(bb) != 0); - } - /// - bool hasPredecessors() - { - assert(bb !is null); - return (LLVMHasPredecessors(bb) != 0); - } - /// - bool empty() - { - assert(bb !is null); - return (LLVMIsBasicBlockEmpty(bb) != 0); - } -} - -/// -class TargetData -{ - /// - private LLVMTargetDataRef target; - /// - private this(LLVMTargetDataRef td) - { - target = td; - } - /// - static TargetData Get(char[] str) - { - return new TargetData(LLVMCreateTargetData(to_stringz(str))); - } - /// - static TargetData Get(Module M) - { - return new TargetData(LLVMCreateTargetData(to_stringz(M.dataLayout))); - } - /// invalidates object - void dispose() - { - LLVMDisposeTargetData(target); - target = null; - } - /// - size_t getABITypeSize(Type T) - { - return LLVMABISizeOfType(target, T.ll); - } -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvm/type.d --- a/tools/binding/llvm/type.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,587 +0,0 @@ -// Written in the D programming language by Tomas Lindquist Olsen 2008 -// Binding of llvm.c.Core types for D. -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -module llvm.type; - -import llvm.c.Core; -import llvm.c.Ext; - -import llvm.util; - -// we need free -version(Tango) { - import tango.stdc.stdlib; -} -else { - import std.c.stdlib; -} - - -/** - * Each value in the IR has a type, an instance of [lltype]. See the - * llvm::Type class. - */ -class Type -{ - /// global registry for 1:1 mapping of LLVMTypeRef's -> Type's - private static Type[LLVMTypeRef] registry; - /// - alias LLVMTypeKind Kind; - /// - private LLVMTypeRef type; - // used to detect if the kind of type has changed after refinement - private const Kind cached_kind; - /// - private this(LLVMTypeRef t) { - assert(t !is null); - type = t; - cached_kind = kind; - assert((t in registry) is null, "Duplicate type"); - registry[t] = this; - if (isAbstract()) - registerAbstractType(); - } - /// - void registerAbstractType() { - static extern(C) void onTypeRefine(void* old, LLVMTypeRef newTypeRef) { - Type T = cast(Type) old; - registry.remove(T.type); - - if (LLVMGetTypeKind(newTypeRef) == T.cached_kind) { - // The kind of type didn't change, so try to update and - // recycle the Type by updating the LLVMTypeRef. - T.type = newTypeRef; - if (newTypeRef in registry) { - // We can't update the Type if it already exists - // but is abstract since doing so requires we pass - // a pointer to an object that will be stored where - // the GC can't see it. (If it's not in the registry - // it's safe because we'll put a reference in there - // for the GC to find, and if it's not abstract - // there's no need for the pointer to get out) - if (T.isAbstract()) - T.type = null; - } else { - registry[newTypeRef] = T; - // This callback only gets called once per type. If - // we recycle the old Type object for another - // abstract type we need to re-register it with the - // new LLVMTypeRef. - if (T.isAbstract()) - T.registerAbstractType(); - } - } else { - // Kind of type has changed, invalidate the old object. - T.type = null; - // The new Type will get entered into the registry when - // it's first needed. - } - } - - // Make sure we there's a reference to the passed object that - // the GC can see in the registry. - auto p = this.type in registry; - assert((p !is null) && (*p is this), "Can't safely register an abstract type that isn't in the registry"); - - LLVMRegisterAbstractTypeCallback(this.type, - cast(void*) *p, - &onTypeRefine); - } - /// - char[] toString() { - auto cstr = LLVMTypeToString(type); - auto result = from_stringz(cstr).dup; - free(cstr); - return result; - } - /// - Kind kind() { - return LLVMGetTypeKind(type); - } - /// - bool isAbstract() { - return LLVMIsTypeAbstract(type) != 0; - } - /** Note: may invalidate the current object. Returns the refined Type - * if it can, or null otherwise. - */ - Type refineAbstractType(Type to) { - assert(isAbstract()); - - LLVMRefineType(type, to.type); - - // Either type will do. Go through the registry to try to use the - // "canonical" Type object for the type. - if (type != null && to.type != null) { - assert(type == to.type, "After refinement they should be equal, right?"); - return registry[type]; - } else if (type != null) { - return registry[type]; - } else if (to.type != null) { - return registry[to.type]; - } - // Both types were invalidated. Is this even possible? - return null; - } - /// - static IntegerType IntType(uint bits) { - return IntegerType.Get(bits); - } - /// - static const Type Void,Label; - /// - static const IntegerType Int1, Int8, Int16, Int32, Int64, Size_t; - /// - static const RealType Float,Double,X86_FP80, FP128, PPC_FP128; - /// - static this() - { - Void = new Type(LLVMVoidType()); - Label = new Type(LLVMLabelType()); - - Int1 = new IntegerType(LLVMInt1Type()); - Int8 = new IntegerType(LLVMInt8Type()); - Int16 = new IntegerType(LLVMInt16Type()); - Int32 = new IntegerType(LLVMInt32Type()); - Int64 = new IntegerType(LLVMInt64Type()); - if (size_t.sizeof == 4) - Size_t = Int32; - else - Size_t = Int64; - - Float = new RealType(LLVMFloatType()); - Double = new RealType(LLVMDoubleType()); - X86_FP80 = new RealType(LLVMX86FP80Type()); - FP128 = new RealType(LLVMFP128Type()); - PPC_FP128 = new RealType(LLVMPPCFP128Type()); - } - /// - LLVMTypeRef ll() - { - return type; - } - /// - void dump() - { - LLVMDumpType(type); - } - /// - bool isBasic() - { - auto k = kind; - if (k == Kind.Struct || k == Kind.Array || k == Kind.Function) - return false; - return true; - } -} - -/// -class IntegerType : Type -{ - /// - private this(LLVMTypeRef t) - { - super(t); - } - /// - static IntegerType Get(uint nbits) - { - if (nbits == 1) - return Type.Int1; - else if (nbits == 8) - return Type.Int8; - else if (nbits == 16) - return Type.Int16; - else if (nbits == 32) - return Type.Int32; - else if (nbits == 64) - return Type.Int64; - else - { - auto t = LLVMIntType(nbits); - auto ptr = t in registry; - if (ptr !is null) - return cast(IntegerType)*ptr; - auto it = new IntegerType(t); - return it; - } - } - /// - uint numBits() - { - return LLVMGetIntTypeWidth(type); - } -} - -/// -class RealType : Type -{ - /// - private this(LLVMTypeRef t) - { - super(t); - } -} - -/// -class FunctionType : Type -{ - /// - private Type ret; - private const Type[] params; - /// - protected this(LLVMTypeRef t, Type r, Type[] pars) - { - super(t); - ret = r; - params = pars; - } - /// - static FunctionType Get(Type r, Type[] pars, bool vararg=false) - { - auto p = new LLVMTypeRef[pars.length]; - foreach(i,v; pars) p[i] = v.ll; - auto t = LLVMFunctionType(r.ll, p.ptr, p.length, vararg); - auto ptr = t in registry; - if (ptr !is null) - return cast(FunctionType)*ptr; - auto ft = new FunctionType(t, r, pars); - return ft; - } - /// - bool isVarArg() - { - return (LLVMIsFunctionVarArg(type) != 0); - } - /// - Type returnType() - { - if (!ret.type) - ret = getTypeOf(LLVMGetReturnType(type)); - - return ret; - } - /// - Type[] paramTypes() - { - foreach (par ; params) { - if (!par.type) { - updateParams(); - } - } - return params; - } - /// - Type getParamType(uint idx) - { - auto par = params[idx]; - if (!par.type) { - updateParams(); - par = params[idx]; - } - return params[idx]; - } - /// - uint numParams() - { - return params.length; - } - /** Called when one or more of the parameter types have been - * invalidated. - */ - private void updateParams() { - assert (LLVMCountParamTypes(type) == params.length); - auto llparams = new LLVMTypeRef[params.length]; - LLVMGetParamTypes(type, llparams.ptr); - foreach (idx, llpar ; llparams) { - params[idx] = getTypeOf(llpar); - } - } -} - -/// -class StructType : Type -{ - /// - private this(LLVMTypeRef t) - { - super(t); - } - /// - static StructType Get(Type[] elems, bool packed=false) - { - auto tys = new LLVMTypeRef[elems.length]; - foreach(i,e; elems) tys[i] = e.ll; - auto t = LLVMStructType(tys.ptr, tys.length, packed); - auto ptr = t in registry; - if (ptr !is null) - return cast(StructType)*ptr; - auto st = new StructType(t); - return st; - } - /// - bool packed() - { - return (LLVMIsPackedStruct(type) != 0); - } - /// - uint numElements() - { - return LLVMCountStructElementTypes(type); - } - /// - Type[] elementTypes() - { - auto n = numElements(); - auto dst = new LLVMTypeRef[n]; - LLVMGetStructElementTypes(type, dst.ptr); - auto e = new Type[n]; - for(auto i=0; i -version(Tango) { - import tango.stdc.string; -} -else { - import std.c.string; -} - -/// -char[] from_stringz(char* p) -{ - if (p is null) - return ""; - return p[0..strlen(p)]; -} - -/// -char* to_stringz(char[] s) -{ - return (s~\0).ptr; -} - diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvmsample1.d --- a/tools/binding/llvmsample1.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,47 +0,0 @@ -// simple hello world sample of D LLVM -module llvmsample1; - -import llvm.llvm; - -void main() -{ - // create module - auto m = new Module("sample1"); - scope(exit) m.dispose(); - - // declare string - auto chello = ConstantArray.GetString("Hello World!\n", true); - auto hello = m.addGlobal(chello.type, "hellostring"); - hello.initializer = chello; - hello.linkage = Linkage.Internal; - hello.globalConstant = true; - - // declare printf - auto printfType = FunctionType.Get(Type.Int32, [ PointerType.Get(Type.Int8) ], true); - auto llprintf = m.addFunction(printfType, "printf"); - - // declare main - auto mainType = FunctionType.Get(Type.Int32, null); - auto llmain = m.addFunction(mainType, "main"); - - // create builder - auto b = new Builder; - scope(exit) b.dispose(); - - // create main body block - auto bb = llmain.appendBasicBlock("entry"); - b.positionAtEnd(bb); - - // call printf - auto zero = ConstantInt.GetU(Type.Int32, 0); - auto helloptr = b.buildGEP(hello, [ zero, zero ], "str"); - helloptr.dump(); - auto args = [ helloptr ]; - auto call = b.buildCall(llprintf, args, ""); - - // return 0 - b.buildRet(ConstantInt.GetS(Type.Int32, 0)); - - // write bitcode - m.writeBitcodeToFile("sample1.bc"); -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvmsample2.d --- a/tools/binding/llvmsample2.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,18 +0,0 @@ -// simple test of recursive types. -module llvmsample2; - -import llvm.llvm; - -void main() -{ - auto th = new TypeHandle(); - auto s = StructType.Get([ PointerType.Get(th.resolve) ], false); - th.refine(s); - s.dump(); - th.dispose(); - - auto t = getTypeOf(s.ll); - t.dump(); - - assert(s is t); -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/llvmsample3.d --- a/tools/binding/llvmsample3.d Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,35 +0,0 @@ -// simple example that shows off getting D wrappers from C values. -module llvmsample3; - -import llvm.c.Core; -import llvm.llvm; - -void main() -{ - auto m = new Module("sample3"); - - // global int32 - auto gi = m.addGlobal(Type.Int32, "myint"); - gi.initializer = ConstantInt.GetU(Type.Int32, 42); - - // this is not a cached value, it's recreated dynamically - auto _i = gi.initializer; - auto ci = cast(ConstantInt)_i; - assert(ci !is null); - ci.dump; - - // global struct - auto st = StructType.Get([Type.Double,Type.Double,Type.Double]); - auto gs = m.addGlobal(st, "mystruct"); - auto elems = new Constant[3]; - foreach(i,ref e; elems) - e = ConstantReal.Get(Type.Double, i+1); - gs.initializer = ConstantStruct.Get(elems); - - // again this is not a cached value. - auto s = gs.initializer; - auto cs = cast(ConstantStruct)s; - assert(cs !is null); - - cs.dump; -} diff -r 40bd4a0d4870 -r cb960b882ca3 tools/binding/prebuild.sh --- a/tools/binding/prebuild.sh Wed May 19 12:42:32 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,9 +0,0 @@ -#!/bin/sh - -g++ llvm-ext.cpp -c `llvm-config --cxxflags` -g++ llvm-opt.cpp -c `llvm-config --cxxflags` -g++ llvm-typemonitor.cpp -c `llvm-config --cxxflags` - -rm -f libllvm-c-ext.a -ar rc libllvm-c-ext.a llvm-ext.o llvm-opt.o llvm-typemonitor.o -ranlib libllvm-c-ext.a