diff --git a/INSTALL.md b/INSTALL.md deleted file mode 100644 --- a/INSTALL.md +++ /dev/null @@ -1,61 +0,0 @@ -Build and installation instructions ------------------------------------ - -Please don't think of these as canonical build instructions yet, as -this work is rather early along. Let me tell you what's working for -*me*, and hopefully this information will be enough to get you going. - - -Prerequisites -------------- - -Firstly, you'll need to have LLVM. I recommend installing LLVM -version 2.9 (from [llvm.org](http://llvm.org/releases/)), which is -what this package has mostly been tested with. - -We try to work with both the current and one previous release of LLVM. - -It's easy to install LLVM itself from source: - - cd llvm - ./configure --prefix=$SOMEWHERE - make - make install - -It's a good idea to have `$SOMEWHERE/bin` in your path. - -Installing from source on Windows requires MinGW. - - -Building --------- - -(*Note*: If you're building from a clone of the `git` repository -rather than a release, you *must* run `autoreconf` before you can -build!) - -This is a normal Haskell package, but needs a `configure` script to -configure some system-specific details of LLVM. - -If you have LLVM installed in a fairly normal location (`/usr` or -`/usr/local`), the usual install command should just work: - - cabal install - -On the other hand, if you've installed LLVM in an unusual place, -you'll need some `--configure-option` magic to tell the build where to -find it: - - cabal install --configure-option --with-llvm-prefix=$SOMEWHERE - - -Building examples ------------------ - -In the `examples` directory are a few example programs. There's a GNU -Makefile in there, so running `make` in that directory will build the -examples, as will `make examples` in the top-level directory. Doing -`make run` will build and run the examples. - -Note: On older versions of MacOS X you may see a lot of "atom sorting -error" warnings. They seem to be harmless. diff --git a/LLVM/Core/Data.hs b/LLVM/Core/Data.hs --- a/LLVM/Core/Data.hs +++ b/LLVM/Core/Data.hs @@ -3,7 +3,6 @@ Array(..), Vector(..), Ptr, Label, Struct(..), PackedStruct(..)) where import Data.Typeable import Foreign.Ptr(Ptr) -import Data.TypeLevel -- TODO: -- Make instances IntN, WordN to actually do the right thing. @@ -12,12 +11,12 @@ -- |Variable sized signed integer. -- The /n/ parameter should belong to @PosI@. -newtype (Pos n) => IntN n = IntN Integer +newtype IntN n = IntN Integer deriving (Show, Typeable) -- |Variable sized unsigned integer. -- The /n/ parameter should belong to @PosI@. -newtype (Pos n) => WordN n = WordN Integer +newtype WordN n = WordN Integer deriving (Show, Typeable) -- |128 bit floating point. @@ -25,7 +24,7 @@ deriving (Show, Typeable) -- |Fixed sized arrays, the array size is encoded in the /n/ parameter. -newtype (Nat n) => Array n a = Array [a] +newtype Array n a = Array [a] deriving (Show, Typeable) -- |Fixed sized vector, the array size is encoded in the /n/ parameter. @@ -41,4 +40,3 @@ deriving (Show, Typeable) newtype PackedStruct a = PackedStruct a deriving (Show, Typeable) - diff --git a/LLVM/Core/Type.hs b/LLVM/Core/Type.hs --- a/LLVM/Core/Type.hs +++ b/LLVM/Core/Type.hs @@ -72,6 +72,7 @@ code (TDFunction va as b) = functionType va (code b) (map code as) code TDLabel = FFI.labelType code (TDStruct ts packed) = structType (map code ts) packed + code TDInvalidType = error "typeRef TDInvalidType" typeName :: (IsType a) => a -> String typeName = code . typeDesc @@ -88,6 +89,7 @@ code (TDStruct as packed) = (if packed then "<{" else "{") ++ intercalate "," (map code as) ++ (if packed then "}>" else "}") + code TDInvalidType = error "typeName TDInvalidType" typeDesc2 :: FFI.TypeRef -> IO TypeDesc typeDesc2 t = do diff --git a/LLVM/FFI/Analysis.hsc b/LLVM/FFI/Analysis.hsc deleted file mode 100644 --- a/LLVM/FFI/Analysis.hsc +++ /dev/null @@ -1,19 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-} - -module LLVM.FFI.Analysis where -import Foreign.C.String(CString) -import Foreign.C.Types(CInt) -import Foreign.Ptr(Ptr) - -import LLVM.FFI.Core - -type VerifierFailureAction = CInt - -foreign import ccall unsafe "LLVMVerifyFunction" verifyFunction - :: ValueRef -> VerifierFailureAction -> IO CInt -foreign import ccall unsafe "LLVMVerifyModule" verifyModule - :: ModuleRef -> VerifierFailureAction -> (Ptr CString) -> IO CInt -foreign import ccall unsafe "LLVMViewFunctionCFG" viewFunctionCFG - :: ValueRef -> IO () -foreign import ccall unsafe "LLVMViewFunctionCFGOnly" viewFunctionCFGOnly - :: ValueRef -> IO () diff --git a/LLVM/FFI/BitReader.hsc b/LLVM/FFI/BitReader.hsc deleted file mode 100644 --- a/LLVM/FFI/BitReader.hsc +++ /dev/null @@ -1,21 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-} - -module LLVM.FFI.BitReader where -import Foreign.C.String(CString) -import Foreign.C.Types(CInt) -import Foreign.Ptr(Ptr) - -import LLVM.FFI.Core - -foreign import ccall unsafe "LLVMGetBitcodeModuleProvider" getBitcodeModuleProvider - :: MemoryBufferRef -> (Ptr ModuleProviderRef) -> (Ptr CString) -> IO CInt -foreign import ccall unsafe "LLVMParseBitcode" parseBitcode - :: MemoryBufferRef -> (Ptr ModuleRef) -> (Ptr CString) -> IO CInt -foreign import ccall unsafe "LLVMGetBitcodeModuleProviderInContext" getBitcodeModuleProviderInContext - :: ContextRef -> MemoryBufferRef -> (Ptr ModuleProviderRef) -> (Ptr CString) -> IO CInt -foreign import ccall unsafe "LLVMParseBitcodeInContext" parseBitcodeInContext - :: ContextRef -> MemoryBufferRef -> (Ptr ModuleRef) -> (Ptr CString) -> IO CInt -foreign import ccall unsafe "LLVMGetBitcodeModule" getBitcodeModule - :: MemoryBufferRef -> (Ptr ModuleRef) -> (Ptr CString) -> IO Bool -foreign import ccall unsafe "LLVMGetBitcodeModuleInContext" getBitcodeModuleInContext - :: ContextRef -> MemoryBufferRef -> (Ptr ModuleRef) -> (Ptr CString) -> IO Bool diff --git a/LLVM/FFI/BitWriter.hsc b/LLVM/FFI/BitWriter.hsc deleted file mode 100644 --- a/LLVM/FFI/BitWriter.hsc +++ /dev/null @@ -1,14 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-} - -module LLVM.FFI.BitWriter where -import Foreign.C.String(CString) -import Foreign.C.Types(CInt) - -import LLVM.FFI.Core - -foreign import ccall unsafe "LLVMWriteBitcodeToFile" writeBitcodeToFile - :: ModuleRef -> CString -> IO CInt -foreign import ccall unsafe "LLVMWriteBitcodeToFileHandle" writeBitcodeToFileHandle - :: ModuleRef -> CInt -> IO CInt -foreign import ccall unsafe "LLVMWriteBitcodeToFD" writeBitcodeToFD - :: ModuleRef -> CInt -> CInt -> CInt -> IO CInt diff --git a/LLVM/FFI/Core.hsc b/LLVM/FFI/Core.hsc deleted file mode 100644 --- a/LLVM/FFI/Core.hsc +++ /dev/null @@ -1,1716 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls, DeriveDataTypeable #-} - --- | --- Module: LLVM.FFI.Core --- Copyright: Bryan O'Sullivan 2007, 2008 --- License: BSD-style (see the file LICENSE) --- --- Maintainer: bos@serpentine.com --- Stability: experimental --- Portability: requires GHC 6.8, LLVM --- --- This module provides direct access to the LLVM C bindings. - -module LLVM.FFI.Core - ( - -- * Modules - Module - , ModuleRef - , moduleCreateWithName - , disposeModule - , ptrDisposeModule - - , getDataLayout - , setDataLayout - - , getTarget - , setTarget - - -- * Module providers - , ModuleProvider - , ModuleProviderRef - , createModuleProviderForExistingModule - , ptrDisposeModuleProvider - - -- * Types - , Type - , TypeRef - , addTypeName - , deleteTypeName - - , getTypeKind - , TypeKind(..) - - -- ** Integer types - , int1Type - , int8Type - , int16Type - , int32Type - , int64Type - , integerType - , getIntTypeWidth - - -- ** Real types - , floatType - , doubleType - , x86FP80Type - , fp128Type - , ppcFP128Type - - -- ** Function types - , functionType - , isFunctionVarArg - , getReturnType - , countParamTypes - , getParamTypes - - -- ** Other types - , voidType - , labelType - , opaqueType - - -- ** Array, pointer, and vector types - , arrayType - , pointerType - , vectorType - , getElementType - , getArrayLength - , getPointerAddressSpace - , getVectorSize - - -- ** Struct types - , structType - , countStructElementTypes - , getStructElementTypes - , isPackedStruct - - -- * Type handles - , TypeHandleRef - , createTypeHandle - , refineType - , resolveTypeHandle - , disposeTypeHandle - - -- * Values - , Value - , ValueRef - , typeOf - , getValueName - , setValueName - , dumpValue - - -- ** Constants - , constNull - , constAllOnes - , getUndef - , isConstant - , isNull - , isUndef - - -- ** Global variables, functions, and aliases (globals) - , Linkage(..) - , fromLinkage - , toLinkage - , getLinkage - , setLinkage - - , Visibility(..) - , fromVisibility - , toVisibility - , getVisibility - , setVisibility - - , isDeclaration - , getSection - , setSection - , getAlignment - , setAlignment - - -- ** Global variables - , addGlobal - , getNamedGlobal - , deleteGlobal - , getInitializer - , setInitializer - , isThreadLocal - , setThreadLocal - , isGlobalConstant - , setGlobalConstant - , getFirstGlobal - , getNextGlobal - , getPreviousGlobal - , getLastGlobal - , getGlobalParent - - -- ** Functions - , addFunction - , getNamedFunction - , deleteFunction - , countParams - , getParams - , getParam - , getIntrinsicID - , getGC - , setGC - , getFirstFunction - , getNextFunction - , getPreviousFunction - , getLastFunction - , getFirstParam - , getNextParam - , getPreviousParam - , getLastParam - , getParamParent - , isTailCall - , setTailCall - - -- ** Phi nodes - , addIncoming - , countIncoming - , getIncomingValue - , getIncomingBlock - - -- ** Calling conventions - , CallingConvention(..) - , fromCallingConvention - , toCallingConvention - , getFunctionCallConv - , setFunctionCallConv - , getInstructionCallConv - , setInstructionCallConv - - -- * Constants - - -- ** Scalar constants - , constInt - , constReal - - -- ** Composite constants - , constArray - , constString - , constStruct - , constVector - - -- ** Constant expressions - , sizeOf - , constNeg - , constNot - , constAdd - , constSub - , constMul - , constExactSDiv - , constFAdd - , constFMul - , constFNeg - , constFPCast - , constFSub - , constUDiv - , constSDiv - , constFDiv - , constURem - , constSRem - , constFRem - , constAnd - , constOr - , constXor - , constICmp - , constFCmp - , constShl - , constLShr - , constAShr - , constGEP - , constTrunc - , constSExt - , constZExt - , constFPTrunc - , constFPExt - , constUIToFP - , constSIToFP - , constFPToUI - , constFPToSI - , constPtrToInt - , constIntToPtr - , constBitCast - , constSelect - , constExtractElement - , constInsertElement - , constShuffleVector - , constRealOfString - , constNSWMul - , constNSWNeg - , constNSWSub - , constNUWAdd - , constNUWMul - , constNUWNeg - , constNUWSub - - -- * Basic blocks - , BasicBlock - , BasicBlockRef - , basicBlockAsValue - , valueIsBasicBlock - , valueAsBasicBlock - , countBasicBlocks - , getBasicBlocks - , getEntryBasicBlock - , appendBasicBlock - , insertBasicBlock - , deleteBasicBlock - , getFirstBasicBlock - , getNextBasicBlock - , getPreviousBasicBlock - , getLastBasicBlock - , getInsertBlock - , getBasicBlockParent - - -- * Instruction field accessors - , instGetOpcode, cmpInstGetPredicate - - -- * Instruction building - , Builder - , BuilderRef - , createBuilder - , ptrDisposeBuilder - , positionBuilder - , positionBefore - , positionAtEnd - , getFirstInstruction - , getNextInstruction - , getPreviousInstruction - , getLastInstruction - , getInstructionParent - - -- ** Terminators - , buildRetVoid - , buildRet - , buildBr - , buildIndirectBr - , buildCondBr - , buildSwitch - , buildInvoke - , buildUnwind - , buildUnreachable - - -- ** Arithmetic - , buildAdd - , buildSub - , buildMul - , buildFAdd - , buildFMul - , buildFPCast - , buildFSub - , buildUDiv - , buildSDiv - , buildExactSDiv - , buildFDiv - , buildURem - , buildSRem - , buildFRem - , buildShl - , buildLShr - , buildAShr - , buildAnd - , buildOr - , buildXor - , buildNeg - , buildFNeg - , buildNot - , buildNSWMul - , buildNSWNeg - , buildNSWSub - , buildNUWAdd - , buildNUWMul - , buildNUWNeg - , buildNUWSub - - -- ** Memory - , buildMalloc - , buildArrayMalloc - , buildAlloca - , buildArrayAlloca - , buildFree - , buildLoad - , buildStore - , buildGEP - - -- ** Casts - , buildTrunc - , buildZExt - , buildSExt - , buildFPToUI - , buildFPToSI - , buildUIToFP - , buildSIToFP - , buildFPTrunc - , buildFPExt - , buildPtrToInt - , buildIntToPtr - , buildBitCast - , buildPointerCast - , buildTruncOrBitCast - , buildZExtOrBitCast - , buildSExtOrBitCast - - , buildPtrDiff - - -- * Misc - , buildAggregateRet - , buildGlobalString - , buildGlobalStringPtr - , buildInBoundsGEP - , buildIsNotNull - , buildIsNull - , buildNSWAdd - , buildStructGEP - - -- ** Comparisons - , buildICmp - , buildFCmp - - -- ** Miscellaneous instructions - , buildPhi - , buildCall - , buildSelect - , buildVAArg - , buildExtractElement - , buildInsertElement - , buildShuffleVector - - -- ** Other helpers - , addCase - - -- * Memory buffers - , MemoryBuffer - , MemoryBufferRef - , createMemoryBufferWithContentsOfFile - , createMemoryBufferWithSTDIN - , disposeMemoryBuffer - - -- * Error handling - , disposeMessage - - -- * Parameter passing - , addAttribute - , setInstrParamAlignment - , setParamAlignment - , Attribute(..) - , fromAttribute - , toAttribute - , addInstrAttribute - , removeFunctionAttr - , removeAttribute - , removeInstrAttribute - , addFunctionAttr - - -- * Pass manager - , PassManager - , PassManagerRef - , createFunctionPassManager - , createPassManager - , disposePassManager - , ptrDisposePassManager - , finalizeFunctionPassManager - , initializeFunctionPassManager - , runFunctionPassManager - , runPassManager - - -- * Context functions - , Context - , ContextRef - - -- * Debug - , dumpModule - - - -- * Misc - , alignOf - , constInBoundsGEP - , constIntCast - , constIntOfString - , constIntOfStringAndSize - , constNSWAdd - , constPointerCast - , constPointerNull - , constRealOfStringAndSize - , constSExtOrBitCast - - , getTypeByName - , insertIntoBuilderWithName - - -- * Context functions - , moduleCreateWithNameInContext - , appendBasicBlockInContext - , insertBasicBlockInContext - , createBuilderInContext - - , contextDispose - - , constStringInContext - , constStructInContext - , constTruncOrBitCast - , constZExtOrBitCast - - , doubleTypeInContext - , fP128TypeInContext - , floatTypeInContext - , int16TypeInContext - , int1TypeInContext - , int32TypeInContext - , int64TypeInContext - , int8TypeInContext - , intTypeInContext - , labelTypeInContext - , opaqueTypeInContext - , pPCFP128TypeInContext - , structTypeInContext - , voidTypeInContext - , x86FP80TypeInContext - , getTypeContext - - , addAlias - , addDestination - , addGlobalInAddressSpace - , blockAddress - , clearInsertionPosition - , constExtractValue - , constInlineAsm - , constInsertValue - , constIntGetSExtValue - , constIntGetZExtValue - --- , constUnion - , contextCreate --- , countUnionElementTypes - , createFunctionPassManagerForModule - , getAttribute - , getCurrentDebugLocation - , getFunctionAttr - , getGlobalContext - , getMDKindID - , getMDKindIDInContext - , getMetadata - , getOperand - , getNumOperands --- , getUnionElementTypes - , hasMetadata - , insertIntoBuilder - , mDNode - , mDNodeInContext - , mDString - , mDStringInContext - , replaceAllUsesWith - , setCurrentDebugLocation - , setInstDebugLocation - , setMetadata --- , unionType --- , unionTypeInContext - - -- ** Build instruction from opcode - , buildBinOp - , getConstOpcode - - , buildCast - , buildExtractValue - , buildInsertValue - - -- ** Use - , OpaqueUse - , UseRef - , getFirstUse - , getNextUse - , getNumUses - , getUsedValue - , getUser - , isUsedInBasicBlock - - ) where -import Data.Typeable(Typeable) -import Foreign.C.String (CString) -import Foreign.C.Types (CDouble, CInt, CUInt, CLLong, CULLong) -import Foreign.Ptr (Ptr, FunPtr) - -#include - -data Module - deriving (Typeable) -type ModuleRef = Ptr Module - -foreign import ccall unsafe "LLVMModuleCreateWithName" moduleCreateWithName - :: CString -> IO ModuleRef - -foreign import ccall unsafe "LLVMDisposeModule" disposeModule - :: ModuleRef -> IO () - -foreign import ccall unsafe "&LLVMDisposeModule" ptrDisposeModule - :: FunPtr (ModuleRef -> IO ()) - -foreign import ccall unsafe "LLVMGetDataLayout" getDataLayout - :: ModuleRef -> IO CString - -foreign import ccall unsafe "LLVMSetDataLayout" setDataLayout - :: ModuleRef -> CString -> IO () - - -data ModuleProvider - deriving (Typeable) -type ModuleProviderRef = Ptr ModuleProvider - -foreign import ccall unsafe "LLVMCreateModuleProviderForExistingModule" - createModuleProviderForExistingModule - :: ModuleRef -> IO ModuleProviderRef - -foreign import ccall unsafe "&LLVMDisposeModuleProvider" ptrDisposeModuleProvider - :: FunPtr (ModuleProviderRef -> IO ()) - - -data Type - deriving (Typeable) -type TypeRef = Ptr Type - -foreign import ccall unsafe "LLVMInt1Type" int1Type :: TypeRef - -foreign import ccall unsafe "LLVMInt8Type" int8Type :: TypeRef - -foreign import ccall unsafe "LLVMInt16Type" int16Type :: TypeRef - -foreign import ccall unsafe "LLVMInt32Type" int32Type :: TypeRef - -foreign import ccall unsafe "LLVMInt64Type" int64Type :: TypeRef - --- | An integer type of the given width. -foreign import ccall unsafe "LLVMIntType" integerType - :: CUInt -- ^ width in bits - -> TypeRef - -foreign import ccall unsafe "LLVMFloatType" floatType :: TypeRef - -foreign import ccall unsafe "LLVMDoubleType" doubleType :: TypeRef - -foreign import ccall unsafe "LLVMX86FP80Type" x86FP80Type :: TypeRef - -foreign import ccall unsafe "LLVMFP128Type" fp128Type :: TypeRef - -foreign import ccall unsafe "LLVMPPCFP128Type" ppcFP128Type :: TypeRef - -foreign import ccall unsafe "LLVMVoidType" voidType :: TypeRef - --- | Create a function type. -foreign import ccall unsafe "LLVMFunctionType" functionType - :: TypeRef -- ^ return type - -> Ptr TypeRef -- ^ array of argument types - -> CUInt -- ^ number of elements in array - -> CInt -- ^ non-zero if function is varargs - -> TypeRef - --- | Indicate whether a function takes varargs. -foreign import ccall unsafe "LLVMIsFunctionVarArg" isFunctionVarArg - :: TypeRef -> IO CInt - --- | Give a function's return type. -foreign import ccall unsafe "LLVMGetReturnType" getReturnType - :: TypeRef -> IO TypeRef - --- | Give the number of fixed parameters that a function takes. -foreign import ccall unsafe "LLVMCountParamTypes" countParamTypes - :: TypeRef -> IO CUInt - --- | Fill out an array with the types of a function's fixed --- parameters. -foreign import ccall unsafe "LLVMGetParamTypes" getParamTypes - :: TypeRef -> Ptr TypeRef -> IO () - -foreign import ccall unsafe "LLVMArrayType" arrayType - :: TypeRef -- ^ element type - -> CUInt -- ^ element count - -> TypeRef - -foreign import ccall unsafe "LLVMPointerType" pointerType - :: TypeRef -- ^ pointed-to type - -> CUInt -- ^ address space - -> TypeRef - -foreign import ccall unsafe "LLVMVectorType" vectorType - :: TypeRef -- ^ element type - -> CUInt -- ^ element count - -> TypeRef - -foreign import ccall unsafe "LLVMAddTypeName" addTypeName - :: ModuleRef -> CString -> TypeRef -> IO CInt - -foreign import ccall unsafe "LLVMDeleteTypeName" deleteTypeName - :: ModuleRef -> CString -> IO () - --- | Get the type of a sequential type's elements. -foreign import ccall unsafe "LLVMGetElementType" getElementType - :: TypeRef -> IO TypeRef - - -data Value - deriving (Typeable) -type ValueRef = Ptr Value - -foreign import ccall unsafe "LLVMAddGlobal" addGlobal - :: ModuleRef -> TypeRef -> CString -> IO ValueRef - -foreign import ccall unsafe "LLVMDeleteGlobal" deleteGlobal - :: ValueRef -> IO () - -foreign import ccall unsafe "LLVMSetInitializer" setInitializer - :: ValueRef -> ValueRef -> IO () - -foreign import ccall unsafe "LLVMGetNamedGlobal" getNamedGlobal - :: ModuleRef -> CString -> IO ValueRef - -foreign import ccall unsafe "LLVMGetInitializer" getInitializer - :: ValueRef -> IO ValueRef - -foreign import ccall unsafe "LLVMIsThreadLocal" isThreadLocal - :: ValueRef -> IO CInt - -foreign import ccall unsafe "LLVMSetThreadLocal" setThreadLocal - :: ValueRef -> CInt -> IO () - -foreign import ccall unsafe "LLVMIsGlobalConstant" isGlobalConstant - :: ValueRef -> IO CInt - -foreign import ccall unsafe "LLVMSetGlobalConstant" setGlobalConstant - :: ValueRef -> CInt -> IO () - -foreign import ccall unsafe "LLVMTypeOf" typeOf - :: ValueRef -> IO TypeRef - -foreign import ccall unsafe "LLVMGetValueName" getValueName - :: ValueRef -> IO CString - -foreign import ccall unsafe "LLVMSetValueName" setValueName - :: ValueRef -> CString -> IO () - -foreign import ccall unsafe "LLVMDumpValue" dumpValue - :: ValueRef -> IO () - -foreign import ccall unsafe "LLVMConstAllOnes" constAllOnes - :: TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstArray" constArray - :: TypeRef -> Ptr ValueRef -> CUInt -> ValueRef - -foreign import ccall unsafe "LLVMConstNull" constNull - :: TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMIsConstant" isConstant - :: ValueRef -> IO CInt - -foreign import ccall unsafe "LLVMGetUndef" getUndef - :: TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMIsNull" isNull - :: ValueRef -> IO CInt - -foreign import ccall unsafe "LLVMIsUndef" isUndef - :: ValueRef -> IO CInt - -foreign import ccall unsafe "LLVMGetNamedFunction" getNamedFunction - :: ModuleRef -- ^ module - -> CString -- ^ name - -> IO ValueRef -- ^ function (@nullPtr@ if not found) - -foreign import ccall unsafe "LLVMAddFunction" addFunction - :: ModuleRef -- ^ module - -> CString -- ^ name - -> TypeRef -- ^ type - -> IO ValueRef - -foreign import ccall unsafe "LLVMDeleteFunction" deleteFunction - :: ValueRef -- ^ function - -> IO () - -foreign import ccall unsafe "LLVMCountParams" countParams - :: ValueRef -- ^ function - -> CUInt - -foreign import ccall unsafe "LLVMGetParam" getParam - :: ValueRef -- ^ function - -> CUInt -- ^ offset into array - -> ValueRef - -foreign import ccall unsafe "LLVMGetParams" getParams - :: ValueRef -- ^ function - -> Ptr ValueRef -- ^ array to fill out - -> IO () - -foreign import ccall unsafe "LLVMGetIntrinsicID" getIntrinsicID - :: ValueRef -- ^ function - -> CUInt - -data CallingConvention = C - | Fast - | Cold - | X86StdCall - | X86FastCall - | GHC - deriving (Show, Eq, Ord, Enum, Bounded, Typeable) - -fromCallingConvention :: CallingConvention -> CUInt -fromCallingConvention C = (#const LLVMCCallConv) -fromCallingConvention Fast = (#const LLVMFastCallConv) -fromCallingConvention Cold = (#const LLVMColdCallConv) -fromCallingConvention X86StdCall = (#const LLVMX86FastcallCallConv) -fromCallingConvention X86FastCall = (#const LLVMX86StdcallCallConv) -fromCallingConvention GHC = 10 - -toCallingConvention :: CUInt -> CallingConvention -toCallingConvention c | c == (#const LLVMCCallConv) = C -toCallingConvention c | c == (#const LLVMFastCallConv) = Fast -toCallingConvention c | c == (#const LLVMColdCallConv) = Cold -toCallingConvention c | c == (#const LLVMX86StdcallCallConv) = X86StdCall -toCallingConvention c | c == (#const LLVMX86FastcallCallConv) = X86FastCall -toCallingConvention c | c == 10 = GHC -toCallingConvention c = error $ "LLVM.Core.FFI.toCallingConvention: " ++ - "unsupported calling convention" ++ show c - -foreign import ccall unsafe "LLVMGetFunctionCallConv" getFunctionCallConv - :: ValueRef -- ^ function - -> IO CUInt - -foreign import ccall unsafe "LLVMSetFunctionCallConv" setFunctionCallConv - :: ValueRef -- ^ function - -> CUInt - -> IO () - -foreign import ccall unsafe "LLVMGetGC" getGC - :: ValueRef -> IO CString - -foreign import ccall unsafe "LLVMSetGC" setGC - :: ValueRef -> CString -> IO () - -foreign import ccall unsafe "LLVMIsDeclaration" isDeclaration - :: ValueRef -> IO CInt - --- |An enumeration for the kinds of linkage for global values. -data Linkage - = ExternalLinkage -- ^Externally visible function - | AvailableExternallyLinkage - | LinkOnceAnyLinkage -- ^Keep one copy of function when linking (inline) - | LinkOnceODRLinkage -- ^Same, but only replaced by something equivalent. - | WeakAnyLinkage -- ^Keep one copy of named function when linking (weak) - | WeakODRLinkage -- ^Same, but only replaced by something equivalent. - | AppendingLinkage -- ^Special purpose, only applies to global arrays - | InternalLinkage -- ^Rename collisions when linking (static functions) - | PrivateLinkage -- ^Like Internal, but omit from symbol table - | DLLImportLinkage -- ^Function to be imported from DLL - | DLLExportLinkage -- ^Function to be accessible from DLL - | ExternalWeakLinkage -- ^ExternalWeak linkage description - | GhostLinkage -- ^Stand-in functions for streaming fns from BC files - | CommonLinkage -- ^Tentative definitions - | LinkerPrivateLinkage -- ^Like Private, but linker removes. - deriving (Show, Eq, Ord, Enum, Typeable) - -fromLinkage :: Linkage -> CUInt -fromLinkage ExternalLinkage = (#const LLVMExternalLinkage) -fromLinkage AvailableExternallyLinkage = (#const LLVMAvailableExternallyLinkage ) -fromLinkage LinkOnceAnyLinkage = (#const LLVMLinkOnceAnyLinkage) -fromLinkage LinkOnceODRLinkage = (#const LLVMLinkOnceODRLinkage) -fromLinkage WeakAnyLinkage = (#const LLVMWeakAnyLinkage) -fromLinkage WeakODRLinkage = (#const LLVMWeakODRLinkage) -fromLinkage AppendingLinkage = (#const LLVMAppendingLinkage) -fromLinkage InternalLinkage = (#const LLVMInternalLinkage) -fromLinkage PrivateLinkage = (#const LLVMPrivateLinkage) -fromLinkage DLLImportLinkage = (#const LLVMDLLImportLinkage) -fromLinkage DLLExportLinkage = (#const LLVMDLLExportLinkage) -fromLinkage ExternalWeakLinkage = (#const LLVMExternalWeakLinkage) -fromLinkage GhostLinkage = (#const LLVMGhostLinkage) -fromLinkage CommonLinkage = (#const LLVMCommonLinkage) -fromLinkage LinkerPrivateLinkage = (#const LLVMLinkerPrivateLinkage) - -toLinkage :: CUInt -> Linkage -toLinkage c | c == (#const LLVMExternalLinkage) = ExternalLinkage -toLinkage c | c == (#const LLVMAvailableExternallyLinkage) = AvailableExternallyLinkage -toLinkage c | c == (#const LLVMLinkOnceAnyLinkage) = LinkOnceAnyLinkage -toLinkage c | c == (#const LLVMLinkOnceODRLinkage) = LinkOnceODRLinkage -toLinkage c | c == (#const LLVMWeakAnyLinkage) = WeakAnyLinkage -toLinkage c | c == (#const LLVMWeakODRLinkage) = WeakODRLinkage -toLinkage c | c == (#const LLVMAppendingLinkage) = AppendingLinkage -toLinkage c | c == (#const LLVMInternalLinkage) = InternalLinkage -toLinkage c | c == (#const LLVMPrivateLinkage) = PrivateLinkage -toLinkage c | c == (#const LLVMDLLImportLinkage) = DLLImportLinkage -toLinkage c | c == (#const LLVMDLLExportLinkage) = DLLExportLinkage -toLinkage c | c == (#const LLVMExternalWeakLinkage) = ExternalWeakLinkage -toLinkage c | c == (#const LLVMGhostLinkage) = GhostLinkage -toLinkage c | c == (#const LLVMCommonLinkage) = CommonLinkage -toLinkage c | c == (#const LLVMLinkerPrivateLinkage) = LinkerPrivateLinkage -toLinkage _ = error "toLinkage: bad value" - -foreign import ccall unsafe "LLVMGetLinkage" getLinkage - :: ValueRef -> IO CUInt - -foreign import ccall unsafe "LLVMSetLinkage" setLinkage - :: ValueRef -> CUInt -> IO () - -foreign import ccall unsafe "LLVMGetSection" getSection - :: ValueRef -> IO CString - -foreign import ccall unsafe "LLVMSetSection" setSection - :: ValueRef -> CString -> IO () - --- |An enumeration for the kinds of visibility of global values. -data Visibility - = DefaultVisibility -- ^The GV is visible - | HiddenVisibility -- ^The GV is hidden - | ProtectedVisibility -- ^The GV is protected - deriving (Show, Eq, Ord, Enum) - -fromVisibility :: Visibility -> CUInt -fromVisibility DefaultVisibility = (#const LLVMDefaultVisibility) -fromVisibility HiddenVisibility = (#const LLVMHiddenVisibility) -fromVisibility ProtectedVisibility = (#const LLVMProtectedVisibility) - -toVisibility :: CUInt -> Visibility -toVisibility c | c == (#const LLVMDefaultVisibility) = DefaultVisibility -toVisibility c | c == (#const LLVMHiddenVisibility) = HiddenVisibility -toVisibility c | c == (#const LLVMProtectedVisibility) = ProtectedVisibility -toVisibility _ = error "toVisibility: bad value" - -foreign import ccall unsafe "LLVMGetVisibility" getVisibility - :: ValueRef -> IO CUInt - -foreign import ccall unsafe "LLVMSetVisibility" setVisibility - :: ValueRef -> CUInt -> IO () - -foreign import ccall unsafe "LLVMGetAlignment" getAlignment - :: ValueRef -> IO CUInt - -foreign import ccall unsafe "LLVMSetAlignment" setAlignment - :: ValueRef -> CUInt -> IO () - - -foreign import ccall unsafe "LLVMConstInt" constInt - :: TypeRef -> CULLong -> CInt -> ValueRef - -foreign import ccall unsafe "LLVMConstReal" constReal - :: TypeRef -> CDouble -> ValueRef - -foreign import ccall unsafe "LLVMConstString" constString - :: CString -> CUInt -> CInt -> ValueRef - -foreign import ccall unsafe "LLVMConstStruct" constStruct - :: Ptr ValueRef -> CUInt -> CInt -> ValueRef - -foreign import ccall unsafe "LLVMConstVector" constVector - :: Ptr ValueRef -> CUInt -> ValueRef - -foreign import ccall unsafe "LLVMConstNeg" constNeg - :: ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstNot" constNot - :: ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstAdd" constAdd - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstSub" constSub - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstMul" constMul - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstUDiv" constUDiv - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstSDiv" constSDiv - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstFDiv" constFDiv - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstURem" constURem - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstSRem" constSRem - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstFRem" constFRem - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstAnd" constAnd - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstOr" constOr - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstXor" constXor - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstICmp" constICmp - :: CInt -> ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstFCmp" constFCmp - :: CInt -> ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstShl" constShl - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstLShr" constLShr - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstAShr" constAShr - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstGEP" constGEP - :: ValueRef -> Ptr ValueRef -> CUInt -> ValueRef - -foreign import ccall unsafe "LLVMConstTrunc" constTrunc - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstSExt" constSExt - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstZExt" constZExt - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstFPTrunc" constFPTrunc - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstFPExt" constFPExt - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstUIToFP" constUIToFP - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstSIToFP" constSIToFP - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstFPToUI" constFPToUI - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstFPToSI" constFPToSI - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstPtrToInt" constPtrToInt - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstIntToPtr" constIntToPtr - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstBitCast" constBitCast - :: ValueRef -> TypeRef -> ValueRef - -foreign import ccall unsafe "LLVMConstSelect" constSelect - :: ValueRef -> ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstExtractElement" constExtractElement - :: ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstInsertElement" constInsertElement - :: ValueRef -> ValueRef -> ValueRef -> ValueRef - -foreign import ccall unsafe "LLVMConstShuffleVector" constShuffleVector - :: ValueRef -> ValueRef -> ValueRef -> ValueRef - -type BasicBlock = Value -type BasicBlockRef = Ptr BasicBlock - -foreign import ccall unsafe "LLVMBasicBlockAsValue" basicBlockAsValue - :: BasicBlockRef -> ValueRef - -foreign import ccall unsafe "LLVMValueIsBasicBlock" valueIsBasicBlock - :: ValueRef -> Bool - -foreign import ccall unsafe "LLVMValueAsBasicBlock" valueAsBasicBlock - :: ValueRef -- ^ basic block - -> BasicBlockRef - -foreign import ccall unsafe "LLVMCountBasicBlocks" countBasicBlocks - :: ValueRef -- ^ function - -> IO CUInt - -foreign import ccall unsafe "LLVMGetBasicBlocks" getBasicBlocks - :: ValueRef -- ^ function - -> Ptr BasicBlockRef -- ^ array to fill out - -> IO () - -foreign import ccall unsafe "LLVMGetEntryBasicBlock" getEntryBasicBlock - :: ValueRef -- ^ function - -> IO BasicBlockRef - -foreign import ccall unsafe "LLVMAppendBasicBlock" appendBasicBlock - :: ValueRef -- ^ function - -> CString -- ^ name for label - -> IO BasicBlockRef - -foreign import ccall unsafe "LLVMInsertBasicBlock" insertBasicBlock - :: BasicBlockRef -- ^ insert before this one - -> CString -- ^ name for label - -> IO BasicBlockRef - -foreign import ccall unsafe "LLVMDeleteBasicBlock" deleteBasicBlock - :: BasicBlockRef -> IO () - -foreign import ccall unsafe "LLVMInstGetOpcode" instGetOpcode - :: ValueRef -> IO Int - -foreign import ccall unsafe "LLVMCmpInstGetPredicate" cmpInstGetPredicate - :: ValueRef -> IO Int - -data Builder - deriving (Typeable) -type BuilderRef = Ptr Builder - -foreign import ccall unsafe "LLVMCreateBuilder" createBuilder - :: IO BuilderRef - -foreign import ccall unsafe "&LLVMDisposeBuilder" ptrDisposeBuilder - :: FunPtr (BuilderRef -> IO ()) - -foreign import ccall unsafe "LLVMPositionBuilderBefore" positionBefore - :: BuilderRef -> ValueRef -> IO () - -foreign import ccall unsafe "LLVMPositionBuilderAtEnd" positionAtEnd - :: BuilderRef -> BasicBlockRef -> IO () - -foreign import ccall unsafe "LLVMBuildRetVoid" buildRetVoid - :: BuilderRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildRet" buildRet - :: BuilderRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildBr" buildBr - :: BuilderRef -> BasicBlockRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildCondBr" buildCondBr - :: BuilderRef -> ValueRef -> BasicBlockRef -> BasicBlockRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSwitch" buildSwitch - :: BuilderRef -> ValueRef -> BasicBlockRef -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMBuildInvoke" buildInvoke - :: BuilderRef -> ValueRef -> Ptr ValueRef -> CUInt - -> BasicBlockRef -> BasicBlockRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildUnwind" buildUnwind - :: BuilderRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildUnreachable" buildUnreachable - :: BuilderRef -> IO ValueRef - -foreign import ccall unsafe "LLVMBuildAdd" buildAdd - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSub" buildSub - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildMul" buildMul - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildUDiv" buildUDiv - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSDiv" buildSDiv - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFDiv" buildFDiv - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildURem" buildURem - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSRem" buildSRem - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFRem" buildFRem - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildShl" buildShl - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildLShr" buildLShr - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildAShr" buildAShr - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildAnd" buildAnd - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildOr" buildOr - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildXor" buildXor - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNeg" buildNeg - :: BuilderRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNot" buildNot - :: BuilderRef -> ValueRef -> CString -> IO ValueRef - --- Memory -foreign import ccall unsafe "LLVMBuildMalloc" buildMalloc - :: BuilderRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildArrayMalloc" buildArrayMalloc - :: BuilderRef -> TypeRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildAlloca" buildAlloca - :: BuilderRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildArrayAlloca" buildArrayAlloca - :: BuilderRef -> TypeRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFree" buildFree - :: BuilderRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildLoad" buildLoad - :: BuilderRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildStore" buildStore - :: BuilderRef -> ValueRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildGEP" buildGEP - :: BuilderRef -> ValueRef -> Ptr ValueRef -> CUInt -> CString - -> IO ValueRef - --- Casts -foreign import ccall unsafe "LLVMBuildTrunc" buildTrunc - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildZExt" buildZExt - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSExt" buildSExt - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFPToUI" buildFPToUI - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFPToSI" buildFPToSI - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildUIToFP" buildUIToFP - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSIToFP" buildSIToFP - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFPTrunc" buildFPTrunc - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFPExt" buildFPExt - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildPtrToInt" buildPtrToInt - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildIntToPtr" buildIntToPtr - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildBitCast" buildBitCast - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef - --- Comparisons -foreign import ccall unsafe "LLVMBuildICmp" buildICmp - :: BuilderRef -> CInt -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFCmp" buildFCmp - :: BuilderRef -> CInt -> ValueRef -> ValueRef -> CString -> IO ValueRef - --- Miscellaneous instructions -foreign import ccall unsafe "LLVMBuildPhi" buildPhi - :: BuilderRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildCall" buildCall - :: BuilderRef -> ValueRef -> Ptr ValueRef -> CUInt -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSelect" buildSelect - :: BuilderRef -> ValueRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildVAArg" buildVAArg - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildExtractElement" buildExtractElement - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildInsertElement" buildInsertElement - :: BuilderRef -> ValueRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildShuffleVector" buildShuffleVector - :: BuilderRef -> ValueRef -> ValueRef -> ValueRef -> CString -> IO ValueRef - -foreign import ccall unsafe "LLVMAddCase" addCase - :: ValueRef -> ValueRef -> BasicBlockRef -> IO () - -foreign import ccall unsafe "LLVMCountIncoming" countIncoming - :: ValueRef -> IO CUInt -foreign import ccall unsafe "LLVMAddIncoming" addIncoming - :: ValueRef -> Ptr ValueRef -> Ptr ValueRef -> CUInt -> IO () -foreign import ccall unsafe "LLVMGetIncomingValue" getIncomingValue - :: ValueRef -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMGetIncomingBlock" getIncomingBlock - :: ValueRef -> CUInt -> IO BasicBlockRef - -foreign import ccall unsafe "LLVMGetInstructionCallConv" getInstructionCallConv - :: ValueRef -> IO CUInt -foreign import ccall unsafe "LLVMSetInstructionCallConv" setInstructionCallConv - :: ValueRef -> CUInt -> IO () - -foreign import ccall unsafe "LLVMStructType" structType - :: Ptr TypeRef -> CUInt -> CInt -> TypeRef -foreign import ccall unsafe "LLVMCountStructElementTypes" - countStructElementTypes :: TypeRef -> CUInt -foreign import ccall unsafe "LLVMGetStructElementTypes" getStructElementTypes - :: TypeRef -> Ptr TypeRef -> IO () -foreign import ccall unsafe "LLVMIsPackedStruct" isPackedStruct - :: TypeRef -> CInt - -data MemoryBuffer - deriving (Typeable) -type MemoryBufferRef = Ptr MemoryBuffer - -data TypeHandle - deriving (Typeable) -type TypeHandleRef = Ptr TypeHandle - -data TypeKind - = VoidTypeKind - | FloatTypeKind - | DoubleTypeKind - | X86_FP80TypeKind - | FP128TypeKind - | PPC_FP128TypeKind - | LabelTypeKind - | IntegerTypeKind - | FunctionTypeKind - | StructTypeKind - | ArrayTypeKind - | PointerTypeKind - | OpaqueTypeKind - | VectorTypeKind - deriving (Eq, Ord, Enum, Bounded, Show, Read, Typeable) - -getTypeKind :: TypeRef -> IO TypeKind -getTypeKind = fmap (toEnum . fromIntegral) . getTypeKindCUInt - -foreign import ccall unsafe "LLVMCreateMemoryBufferWithContentsOfFile" createMemoryBufferWithContentsOfFile - :: CString -> Ptr MemoryBufferRef -> Ptr CString -> IO CInt -foreign import ccall unsafe "LLVMCreateMemoryBufferWithSTDIN" createMemoryBufferWithSTDIN - :: Ptr MemoryBufferRef -> Ptr CString -> IO CInt -foreign import ccall unsafe "LLVMCreateTypeHandle" createTypeHandle - :: TypeRef -> IO TypeHandleRef -foreign import ccall unsafe "LLVMDisposeMemoryBuffer" disposeMemoryBuffer - :: MemoryBufferRef -> IO () -foreign import ccall unsafe "LLVMDisposeMessage" disposeMessage - :: CString -> IO () -foreign import ccall unsafe "LLVMDisposeTypeHandle" disposeTypeHandle - :: TypeHandleRef -> IO () -foreign import ccall unsafe "LLVMGetArrayLength" getArrayLength - :: TypeRef -> IO CUInt -foreign import ccall unsafe "LLVMGetIntTypeWidth" getIntTypeWidth - :: TypeRef -> IO CUInt -foreign import ccall unsafe "LLVMGetPointerAddressSpace" getPointerAddressSpace - :: TypeRef -> IO CUInt -foreign import ccall unsafe "LLVMGetTarget" getTarget - :: ModuleRef -> IO CString -foreign import ccall unsafe "LLVMGetTypeKind" getTypeKindCUInt - :: TypeRef -> IO CUInt -foreign import ccall unsafe "LLVMGetVectorSize" getVectorSize - :: TypeRef -> IO CUInt -foreign import ccall unsafe "LLVMRefineType" refineType - :: TypeRef -> TypeRef -> IO () -foreign import ccall unsafe "LLVMResolveTypeHandle" resolveTypeHandle - :: TypeHandleRef -> IO TypeRef -foreign import ccall unsafe "LLVMSetTarget" setTarget - :: ModuleRef -> CString -> IO () -foreign import ccall unsafe "LLVMSizeOf" sizeOf - :: TypeRef -> IO ValueRef - -data Attribute - = ZExtAttribute - | SExtAttribute - | NoReturnAttribute - | InRegAttribute - | StructRetAttribute - | NoUnwindAttribute - | NoAliasAttribute - | ByValAttribute - | NestAttribute - | ReadNoneAttribute - | ReadOnlyAttribute - | NoInlineAttribute - | AlwaysInlineAttribute - | OptimizeForSizeAttribute - | StackProtectAttribute - | StackProtectReqAttribute - | NoCaptureAttribute - | NoRedZoneAttribute - | NoImplicitFloatAttribute - | NakedAttribute - deriving (Show, Eq, Ord, Enum, Bounded, Typeable) - -fromAttribute :: Attribute -> CAttribute -fromAttribute ZExtAttribute = (#const LLVMZExtAttribute) -fromAttribute SExtAttribute = (#const LLVMSExtAttribute) -fromAttribute NoReturnAttribute = (#const LLVMNoReturnAttribute) -fromAttribute InRegAttribute = (#const LLVMInRegAttribute) -fromAttribute StructRetAttribute = (#const LLVMStructRetAttribute) -fromAttribute NoUnwindAttribute = (#const LLVMNoUnwindAttribute) -fromAttribute NoAliasAttribute = (#const LLVMNoAliasAttribute) -fromAttribute ByValAttribute = (#const LLVMByValAttribute) -fromAttribute NestAttribute = (#const LLVMNestAttribute) -fromAttribute ReadNoneAttribute = (#const LLVMReadNoneAttribute) -fromAttribute ReadOnlyAttribute = (#const LLVMReadOnlyAttribute) -fromAttribute NoInlineAttribute = (#const LLVMNoInlineAttribute) -fromAttribute AlwaysInlineAttribute = (#const LLVMAlwaysInlineAttribute) -fromAttribute OptimizeForSizeAttribute = (#const LLVMOptimizeForSizeAttribute) -fromAttribute StackProtectAttribute = (#const LLVMStackProtectAttribute) -fromAttribute StackProtectReqAttribute = (#const LLVMStackProtectReqAttribute) -fromAttribute NoCaptureAttribute = (#const LLVMNoCaptureAttribute) -fromAttribute NoRedZoneAttribute = (#const LLVMNoRedZoneAttribute) -fromAttribute NoImplicitFloatAttribute = (#const LLVMNoImplicitFloatAttribute) -fromAttribute NakedAttribute = (#const LLVMNakedAttribute) - -toAttribute :: CAttribute -> Attribute -toAttribute c | c == (#const LLVMZExtAttribute) = ZExtAttribute -toAttribute c | c == (#const LLVMSExtAttribute) = SExtAttribute -toAttribute c | c == (#const LLVMNoReturnAttribute) = NoReturnAttribute -toAttribute c | c == (#const LLVMInRegAttribute) = InRegAttribute -toAttribute c | c == (#const LLVMStructRetAttribute) = StructRetAttribute -toAttribute c | c == (#const LLVMNoUnwindAttribute) = NoUnwindAttribute -toAttribute c | c == (#const LLVMNoAliasAttribute) = NoAliasAttribute -toAttribute c | c == (#const LLVMByValAttribute) = ByValAttribute -toAttribute c | c == (#const LLVMNestAttribute) = NestAttribute -toAttribute c | c == (#const LLVMReadNoneAttribute) = ReadNoneAttribute -toAttribute c | c == (#const LLVMReadOnlyAttribute) = ReadOnlyAttribute -toAttribute c | c == (#const LLVMNoInlineAttribute) = NoInlineAttribute -toAttribute c | c == (#const LLVMAlwaysInlineAttribute) = AlwaysInlineAttribute -toAttribute c | c == (#const LLVMOptimizeForSizeAttribute) = OptimizeForSizeAttribute -toAttribute c | c == (#const LLVMStackProtectAttribute) = StackProtectAttribute -toAttribute c | c == (#const LLVMStackProtectReqAttribute) = StackProtectReqAttribute -toAttribute c | c == (#const LLVMNoCaptureAttribute) = NoCaptureAttribute -toAttribute c | c == (#const LLVMNoRedZoneAttribute) = NoRedZoneAttribute -toAttribute c | c == (#const LLVMNoImplicitFloatAttribute) = NoImplicitFloatAttribute -toAttribute c | c == (#const LLVMNakedAttribute) = NakedAttribute -toAttribute _ = error "toAttribute: bad value" - -type CAttribute = CInt - -data PassManager - deriving (Typeable) -type PassManagerRef = Ptr PassManager - -data OpaqueUse - deriving (Typeable) -type UseRef = Ptr OpaqueUse - -foreign import ccall unsafe "LLVMConstRealOfString" constRealOfString - :: TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMCreateFunctionPassManager" createFunctionPassManager - :: ModuleProviderRef -> IO PassManagerRef -foreign import ccall unsafe "LLVMCreatePassManager" createPassManager - :: IO PassManagerRef -foreign import ccall unsafe "LLVMDisposePassManager" disposePassManager - :: PassManagerRef -> IO () -foreign import ccall unsafe "&LLVMDisposePassManager" ptrDisposePassManager - :: FunPtr (PassManagerRef -> IO ()) -foreign import ccall unsafe "LLVMDumpModule" dumpModule - :: ModuleRef -> IO () -foreign import ccall unsafe "LLVMFinalizeFunctionPassManager" finalizeFunctionPassManager - :: PassManagerRef -> IO CInt -foreign import ccall unsafe "LLVMGetBasicBlockParent" getBasicBlockParent - :: BasicBlockRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetFirstBasicBlock" getFirstBasicBlock - :: ValueRef -> IO BasicBlockRef -foreign import ccall unsafe "LLVMGetFirstFunction" getFirstFunction - :: ModuleRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetFirstGlobal" getFirstGlobal - :: ModuleRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetFirstInstruction" getFirstInstruction - :: BasicBlockRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetFirstParam" getFirstParam - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetGlobalParent" getGlobalParent - :: ValueRef -> IO ModuleRef -foreign import ccall unsafe "LLVMGetInsertBlock" getInsertBlock - :: BuilderRef -> IO BasicBlockRef -foreign import ccall unsafe "LLVMGetInstructionParent" getInstructionParent - :: ValueRef -> IO BasicBlockRef -foreign import ccall unsafe "LLVMGetLastBasicBlock" getLastBasicBlock - :: ValueRef -> IO BasicBlockRef -foreign import ccall unsafe "LLVMGetLastFunction" getLastFunction - :: ModuleRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetLastGlobal" getLastGlobal - :: ModuleRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetLastInstruction" getLastInstruction - :: BasicBlockRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetLastParam" getLastParam - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetNextBasicBlock" getNextBasicBlock - :: BasicBlockRef -> IO BasicBlockRef -foreign import ccall unsafe "LLVMGetNextFunction" getNextFunction - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetNextGlobal" getNextGlobal - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetNextInstruction" getNextInstruction - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetNextParam" getNextParam - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetParamParent" getParamParent - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetPreviousBasicBlock" getPreviousBasicBlock - :: BasicBlockRef -> IO BasicBlockRef -foreign import ccall unsafe "LLVMGetPreviousFunction" getPreviousFunction - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetPreviousGlobal" getPreviousGlobal - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetPreviousInstruction" getPreviousInstruction - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetPreviousParam" getPreviousParam - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMInitializeFunctionPassManager" initializeFunctionPassManager - :: PassManagerRef -> IO CInt -foreign import ccall unsafe "LLVMLabelType" labelType - :: TypeRef -foreign import ccall unsafe "LLVMOpaqueType" opaqueType - :: TypeRef -foreign import ccall unsafe "LLVMPositionBuilder" positionBuilder - :: BuilderRef -> BasicBlockRef -> ValueRef -> IO () -foreign import ccall unsafe "LLVMRunFunctionPassManager" runFunctionPassManager - :: PassManagerRef -> ValueRef -> IO CInt -foreign import ccall unsafe "LLVMRunPassManager" runPassManager - :: PassManagerRef -> ModuleRef -> IO CInt -foreign import ccall unsafe "LLVMSetInstrParamAlignment" setInstrParamAlignment - :: ValueRef -> CUInt -> CUInt -> IO () -foreign import ccall unsafe "LLVMSetParamAlignment" setParamAlignment - :: ValueRef -> CUInt -> IO () - - -data Context - deriving (Typeable) -type ContextRef = Ptr Context - -foreign import ccall unsafe "LLVMAddAttribute" addAttribute - :: ValueRef -> CAttribute -> IO () -foreign import ccall unsafe "LLVMAddInstrAttribute" addInstrAttribute - :: ValueRef -> CUInt -> CAttribute -> IO () -foreign import ccall unsafe "LLVMIsTailCall" isTailCall - :: ValueRef -> IO CInt -foreign import ccall unsafe "LLVMRemoveAttribute" removeAttribute - :: ValueRef -> CAttribute -> IO () -foreign import ccall unsafe "LLVMRemoveInstrAttribute" removeInstrAttribute - :: ValueRef -> CUInt -> CAttribute -> IO () -foreign import ccall unsafe "LLVMSetTailCall" setTailCall - :: ValueRef -> CInt -> IO () -foreign import ccall unsafe "LLVMAddFunctionAttr" addFunctionAttr - :: ValueRef -> CAttribute -> IO () -foreign import ccall unsafe "LLVMAlignOf" alignOf - :: TypeRef -> IO ValueRef -foreign import ccall unsafe "LLVMAppendBasicBlockInContext" appendBasicBlockInContext - :: ContextRef -> ValueRef -> CString -> IO BasicBlockRef -foreign import ccall unsafe "LLVMBuildAggregateRet" buildAggregateRet - :: BuilderRef -> (Ptr ValueRef) -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMBuildExactSDiv" buildExactSDiv - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFAdd" buildFAdd - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFMul" buildFMul - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFPCast" buildFPCast - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFSub" buildFSub - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildFNeg" buildFNeg - :: BuilderRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildGlobalString" buildGlobalString - :: BuilderRef -> CString -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildGlobalStringPtr" buildGlobalStringPtr - :: BuilderRef -> CString -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildInBoundsGEP" buildInBoundsGEP - :: BuilderRef -> ValueRef -> (Ptr ValueRef) -> CUInt -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildIsNotNull" buildIsNotNull - :: BuilderRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildIsNull" buildIsNull - :: BuilderRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNSWAdd" buildNSWAdd - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildPointerCast" buildPointerCast - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildPtrDiff" buildPtrDiff - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildSExtOrBitCast" buildSExtOrBitCast - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildStructGEP" buildStructGEP - :: BuilderRef -> ValueRef -> CUInt -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildTruncOrBitCast" buildTruncOrBitCast - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildZExtOrBitCast" buildZExtOrBitCast - :: BuilderRef -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMConstExactSDiv" constExactSDiv - :: ValueRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstFAdd" constFAdd - :: ValueRef -> ValueRef -> ValueRef -foreign import ccall unsafe "LLVMConstFMul" constFMul - :: ValueRef -> ValueRef -> ValueRef -foreign import ccall unsafe "LLVMConstFNeg" constFNeg - :: ValueRef -> ValueRef -foreign import ccall unsafe "LLVMConstFPCast" constFPCast - :: ValueRef -> TypeRef -> ValueRef -foreign import ccall unsafe "LLVMConstFSub" constFSub - :: ValueRef -> ValueRef -> ValueRef -foreign import ccall unsafe "LLVMConstInBoundsGEP" constInBoundsGEP - :: ValueRef -> (Ptr ValueRef) -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstIntCast" constIntCast - :: ValueRef -> TypeRef -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstIntOfString" constIntOfString - :: TypeRef -> CString -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstIntOfStringAndSize" constIntOfStringAndSize - :: TypeRef -> CString -> CUInt -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstNSWAdd" constNSWAdd - :: ValueRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstPointerCast" constPointerCast - :: ValueRef -> TypeRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstPointerNull" constPointerNull - :: TypeRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstRealOfStringAndSize" constRealOfStringAndSize - :: TypeRef -> CString -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstSExtOrBitCast" constSExtOrBitCast - :: ValueRef -> TypeRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstStringInContext" constStringInContext - :: ContextRef -> CString -> CUInt -> CInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstStructInContext" constStructInContext - :: ContextRef -> (Ptr ValueRef) -> CUInt -> CInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstTruncOrBitCast" constTruncOrBitCast - :: ValueRef -> TypeRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstZExtOrBitCast" constZExtOrBitCast - :: ValueRef -> TypeRef -> IO ValueRef -foreign import ccall unsafe "LLVMContextDispose" contextDispose - :: ContextRef -> IO () -foreign import ccall unsafe "LLVMCreateBuilderInContext" createBuilderInContext - :: ContextRef -> IO BuilderRef -foreign import ccall unsafe "LLVMDoubleTypeInContext" doubleTypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMFP128TypeInContext" fP128TypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMFloatTypeInContext" floatTypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMGetTypeByName" getTypeByName - :: ModuleRef -> CString -> IO TypeRef -foreign import ccall unsafe "LLVMGetTypeContext" getTypeContext - :: TypeRef -> IO ContextRef -foreign import ccall unsafe "LLVMInsertBasicBlockInContext" insertBasicBlockInContext - :: ContextRef -> BasicBlockRef -> CString -> IO BasicBlockRef -foreign import ccall unsafe "LLVMInsertIntoBuilderWithName" insertIntoBuilderWithName - :: BuilderRef -> ValueRef -> CString -> IO () -foreign import ccall unsafe "LLVMInt16TypeInContext" int16TypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMInt1TypeInContext" int1TypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMInt32TypeInContext" int32TypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMInt64TypeInContext" int64TypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMInt8TypeInContext" int8TypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMIntTypeInContext" intTypeInContext - :: ContextRef -> CUInt -> IO TypeRef -foreign import ccall unsafe "LLVMLabelTypeInContext" labelTypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMModuleCreateWithNameInContext" moduleCreateWithNameInContext - :: CString -> ContextRef -> IO ModuleRef -foreign import ccall unsafe "LLVMOpaqueTypeInContext" opaqueTypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMPPCFP128TypeInContext" pPCFP128TypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMRemoveFunctionAttr" removeFunctionAttr - :: ValueRef -> CAttribute -> IO () -foreign import ccall unsafe "LLVMStructTypeInContext" structTypeInContext - :: ContextRef -> (Ptr TypeRef) -> CUInt -> CInt -> IO TypeRef -foreign import ccall unsafe "LLVMVoidTypeInContext" voidTypeInContext - :: ContextRef -> IO TypeRef -foreign import ccall unsafe "LLVMX86FP80TypeInContext" x86FP80TypeInContext - :: ContextRef -> IO TypeRef - - - - -foreign import ccall unsafe "LLVMAddAlias" addAlias - :: ModuleRef -> TypeRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMAddDestination" addDestination - :: ValueRef -> BasicBlockRef -> IO () -foreign import ccall unsafe "LLVMAddGlobalInAddressSpace" addGlobalInAddressSpace - :: ModuleRef -> TypeRef -> CString -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMBlockAddress" blockAddress - :: ValueRef -> BasicBlockRef -> IO ValueRef -foreign import ccall unsafe "LLVMBuildBinOp" buildBinOp - :: BuilderRef -> CUInt{-Opcode-} -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildCast" buildCast - :: BuilderRef -> CUInt{-Opcode-} -> ValueRef -> TypeRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildExtractValue" buildExtractValue - :: BuilderRef -> ValueRef -> CUInt -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildIndirectBr" buildIndirectBr - :: BuilderRef -> ValueRef -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMBuildInsertValue" buildInsertValue - :: BuilderRef -> ValueRef -> ValueRef -> CUInt -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNSWMul" buildNSWMul - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNSWNeg" buildNSWNeg - :: BuilderRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNSWSub" buildNSWSub - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNUWAdd" buildNUWAdd - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNUWMul" buildNUWMul - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNUWNeg" buildNUWNeg - :: BuilderRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMBuildNUWSub" buildNUWSub - :: BuilderRef -> ValueRef -> ValueRef -> CString -> IO ValueRef -foreign import ccall unsafe "LLVMClearInsertionPosition" clearInsertionPosition - :: BuilderRef -> IO () -foreign import ccall unsafe "LLVMConstExtractValue" constExtractValue - :: ValueRef -> Ptr CUInt -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstInlineAsm" constInlineAsm - :: TypeRef -> CString -> CString -> Bool -> Bool -> IO ValueRef -foreign import ccall unsafe "LLVMConstInsertValue" constInsertValue - :: ValueRef -> ValueRef -> Ptr CUInt -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMConstIntGetSExtValue" constIntGetSExtValue - :: ValueRef -> IO CLLong -foreign import ccall unsafe "LLVMConstIntGetZExtValue" constIntGetZExtValue - :: ValueRef -> IO CULLong -foreign import ccall unsafe "LLVMConstNSWMul" constNSWMul - :: ValueRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstNSWNeg" constNSWNeg - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstNSWSub" constNSWSub - :: ValueRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstNUWAdd" constNUWAdd - :: ValueRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstNUWMul" constNUWMul - :: ValueRef -> ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstNUWNeg" constNUWNeg - :: ValueRef -> IO ValueRef -foreign import ccall unsafe "LLVMConstNUWSub" constNUWSub - :: ValueRef -> ValueRef -> IO ValueRef -{- -foreign import ccall unsafe "LLVMConstUnion" constUnion - :: TypeRef -> ValueRef -> IO ValueRef --} -foreign import ccall unsafe "LLVMContextCreate" contextCreate - :: IO ContextRef -{- -foreign import ccall unsafe "LLVMCountUnionElementTypes" countUnionElementTypes - :: TypeRef -> IO CUInt --} -foreign import ccall unsafe "LLVMCreateFunctionPassManagerForModule" createFunctionPassManagerForModule - :: ModuleRef -> IO PassManagerRef -foreign import ccall unsafe "LLVMGetAttribute" getAttribute - :: ValueRef -> IO CUInt{-Attribute-} -foreign import ccall unsafe "LLVMGetConstOpcode" getConstOpcode - :: ValueRef -> IO CUInt {-Opcode-} -foreign import ccall unsafe "LLVMGetCurrentDebugLocation" getCurrentDebugLocation - :: BuilderRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetFirstUse" getFirstUse - :: ValueRef -> IO UseRef -foreign import ccall unsafe "LLVMGetFunctionAttr" getFunctionAttr - :: ValueRef -> IO CUInt {-Attribute-} -foreign import ccall unsafe "LLVMGetGlobalContext" getGlobalContext - :: IO ContextRef -foreign import ccall unsafe "LLVMGetMDKindID" getMDKindID - :: CString -> CUInt -> IO CUInt -foreign import ccall unsafe "LLVMGetMDKindIDInContext" getMDKindIDInContext - :: ContextRef -> CString -> CUInt -> IO CUInt -foreign import ccall unsafe "LLVMGetMetadata" getMetadata - :: ValueRef -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMGetNextUse" getNextUse - :: UseRef -> IO UseRef -foreign import ccall unsafe "LLVMGetOperand" getOperand - :: ValueRef -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMGetNumOperands" getNumOperands - :: ValueRef -> IO CUInt -{- -foreign import ccall unsafe "LLVMGetUnionElementTypes" getUnionElementTypes - :: TypeRef -> (Ptr TypeRef) -> IO () --} -foreign import ccall unsafe "LLVMValueIsUsedInBasicBlock" isUsedInBasicBlock - :: BasicBlockRef -> ValueRef -> IO CInt -foreign import ccall unsafe "LLVMValueGetNumUses" getNumUses - :: ValueRef -> IO CUInt -foreign import ccall unsafe "LLVMGetUsedValue" getUsedValue - :: UseRef -> IO ValueRef -foreign import ccall unsafe "LLVMGetUser" getUser - :: UseRef -> IO ValueRef -foreign import ccall unsafe "LLVMHasMetadata" hasMetadata - :: ValueRef -> IO CInt -foreign import ccall unsafe "LLVMInsertIntoBuilder" insertIntoBuilder - :: BuilderRef -> ValueRef -> IO () -foreign import ccall unsafe "LLVMMDNode" mDNode - :: (Ptr ValueRef) -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMMDNodeInContext" mDNodeInContext - :: ContextRef -> (Ptr ValueRef) -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMMDString" mDString - :: CString -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMMDStringInContext" mDStringInContext - :: ContextRef -> CString -> CUInt -> IO ValueRef -foreign import ccall unsafe "LLVMReplaceAllUsesWith" replaceAllUsesWith - :: ValueRef -> ValueRef -> IO () -foreign import ccall unsafe "LLVMSetCurrentDebugLocation" setCurrentDebugLocation - :: BuilderRef -> ValueRef -> IO () -foreign import ccall unsafe "LLVMSetInstDebugLocation" setInstDebugLocation - :: BuilderRef -> ValueRef -> IO () -foreign import ccall unsafe "LLVMSetMetadata" setMetadata - :: ValueRef -> CUInt -> ValueRef -> IO () -{- -foreign import ccall unsafe "LLVMUnionType" unionType - :: (Ptr TypeRef) -> CUInt -> IO TypeRef -foreign import ccall unsafe "LLVMUnionTypeInContext" unionTypeInContext - :: ContextRef -> (Ptr TypeRef) -> CUInt -> IO TypeRef --} diff --git a/LLVM/FFI/ExecutionEngine.hsc b/LLVM/FFI/ExecutionEngine.hsc deleted file mode 100644 --- a/LLVM/FFI/ExecutionEngine.hsc +++ /dev/null @@ -1,162 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls, DeriveDataTypeable #-} - -module LLVM.FFI.ExecutionEngine - ( - -- * Execution engines - ExecutionEngine - , createExecutionEngine - , ptrDisposeExecutionEngine - , createInterpreter - , createJITCompiler - , addModuleProvider - , removeModuleProvider - , findFunction - , freeMachineCodeForFunction - , runStaticConstructors - , runStaticDestructors - , runFunction - , runFunctionAsMain - , getExecutionEngineTargetData - , addGlobalMapping - , getPointerToGlobal - - , addModule - , createExecutionEngineForModule - , createInterpreterForModule - , createJITCompilerForModule - , disposeExecutionEngine - , removeModule - - -- * Generic values - , GenericValue - , GenericValueRef - , createGenericValueOfInt - , genericValueToInt - , genericValueIntWidth - , createGenericValueOfFloat - , genericValueToFloat - , createGenericValueOfPointer - , genericValueToPointer - , ptrDisposeGenericValue - - -- * Linking --- , linkInInterpreter - , linkInJIT - ) where -import Data.Typeable -import Foreign.C.String (CString) -import Foreign.C.Types (CDouble, CInt, CUInt, CULLong) -import Foreign.Ptr (Ptr, FunPtr) - -import LLVM.FFI.Core (ModuleRef, ModuleProviderRef, TypeRef, ValueRef) -import LLVM.FFI.Target(TargetDataRef) - -data ExecutionEngine - deriving (Typeable) -type ExecutionEngineRef = Ptr ExecutionEngine - -foreign import ccall unsafe "LLVMCreateExecutionEngine" createExecutionEngine - :: Ptr ExecutionEngineRef -> ModuleProviderRef -> Ptr CString - -> IO CInt - -foreign import ccall unsafe "&LLVMDisposeExecutionEngine" ptrDisposeExecutionEngine - :: FunPtr (ExecutionEngineRef -> IO ()) - -foreign import ccall unsafe "LLVMRunStaticConstructors" runStaticConstructors - :: ExecutionEngineRef -> IO () - -foreign import ccall unsafe "LLVMRunStaticDestructors" runStaticDestructors - :: ExecutionEngineRef -> IO () - - -data GenericValue - deriving (Typeable) -type GenericValueRef = Ptr GenericValue - -foreign import ccall unsafe "LLVMCreateGenericValueOfInt" - createGenericValueOfInt :: TypeRef -> CULLong -> CInt - -> IO GenericValueRef - -foreign import ccall unsafe "LLVMGenericValueToInt" genericValueToInt - :: GenericValueRef -> CInt -> CULLong - -foreign import ccall unsafe "LLVMCreateGenericValueOfFloat" - createGenericValueOfFloat :: TypeRef -> CDouble -> IO GenericValueRef - -foreign import ccall unsafe "LLVMGenericValueToFloat" genericValueToFloat - :: TypeRef -> GenericValueRef -> CDouble - -foreign import ccall unsafe "&LLVMDisposeGenericValue" ptrDisposeGenericValue - :: FunPtr (GenericValueRef -> IO ()) - -{- -safe call is important, since the running LLVM code may call back into Haskell code - -See -http://www.cse.unsw.edu.au/~chak/haskell/ffi/ffi/ffise3.html#x6-130003.3 says: - -"Optionally, an import declaration can specify, -after the calling convention, -the safety level that should be used when invoking an external entity. -..." --} -foreign import ccall safe "LLVMRunFunction" runFunction - :: ExecutionEngineRef -> ValueRef -> CUInt - -> Ptr GenericValueRef -> IO GenericValueRef - -foreign import ccall unsafe "LLVMAddModuleProvider" addModuleProvider - :: ExecutionEngineRef -> ModuleProviderRef -> IO () -foreign import ccall unsafe "LLVMCreateGenericValueOfPointer" - createGenericValueOfPointer :: Ptr a -> IO GenericValueRef -foreign import ccall unsafe "LLVMCreateInterpreter" createInterpreter - :: Ptr ExecutionEngineRef -> ModuleProviderRef -> Ptr CString -> IO CInt -foreign import ccall unsafe "LLVMCreateJITCompiler" createJITCompiler - :: Ptr ExecutionEngineRef -> ModuleProviderRef -> CUInt -> Ptr CString -> IO CInt -foreign import ccall unsafe "LLVMFindFunction" findFunction - :: ExecutionEngineRef -> CString -> Ptr ValueRef -> IO CInt -foreign import ccall unsafe "LLVMFreeMachineCodeForFunction" - freeMachineCodeForFunction :: ExecutionEngineRef -> ValueRef -> IO () -foreign import ccall unsafe "LLVMGenericValueIntWidth" genericValueIntWidth - :: GenericValueRef -> IO CUInt -foreign import ccall unsafe "LLVMGenericValueToPointer" genericValueToPointer - :: GenericValueRef -> IO (Ptr a) -foreign import ccall unsafe "LLVMRemoveModuleProvider" removeModuleProvider - :: ExecutionEngineRef -> ModuleProviderRef -> Ptr ModuleRef -> Ptr CString - -> IO CInt -foreign import ccall safe "LLVMRunFunctionAsMain" runFunctionAsMain - :: ExecutionEngineRef -> ValueRef -> CUInt - -> Ptr CString -- ^ argv - -> Ptr CString -- ^ envp - -> IO CInt - -foreign import ccall unsafe "LLVMGetExecutionEngineTargetData" getExecutionEngineTargetData - :: ExecutionEngineRef -> IO TargetDataRef -foreign import ccall unsafe "LLVMAddGlobalMapping" addGlobalMapping - :: ExecutionEngineRef -> ValueRef -> Ptr () -> IO () - -foreign import ccall unsafe "LLVMGetPointerToGlobal" getPointerToGlobal - :: ExecutionEngineRef -> ValueRef -> IO (FunPtr a) - -{- -foreign import ccall unsafe "LLVMLinkInInterpreter" linkInInterpreter - :: IO () --} -foreign import ccall unsafe "LLVMLinkInJIT" linkInJIT - :: IO () - -foreign import ccall unsafe "LLVMAddModule" addModule - :: ExecutionEngineRef -> ModuleRef -> IO () -foreign import ccall unsafe "LLVMCreateExecutionEngineForModule" createExecutionEngineForModule - :: (Ptr ExecutionEngineRef) -> ModuleRef -> (Ptr CString) -> IO Bool -foreign import ccall unsafe "LLVMCreateInterpreterForModule" createInterpreterForModule - :: (Ptr ExecutionEngineRef) -> ModuleRef -> (Ptr CString) -> IO Bool -foreign import ccall unsafe "LLVMCreateJITCompilerForModule" createJITCompilerForModule - :: (Ptr ExecutionEngineRef) -> ModuleRef -> CUInt -> (Ptr CString) -> IO Bool -foreign import ccall unsafe "LLVMDisposeExecutionEngine" disposeExecutionEngine - :: ExecutionEngineRef -> IO () -{- -foreign import ccall unsafe "LLVMDisposeGenericValue" disposeGenericValue - :: GenericValueRef -> IO () --} -foreign import ccall unsafe "LLVMRemoveModule" removeModule - :: ExecutionEngineRef -> ModuleRef -> (Ptr ModuleRef) -> (Ptr CString) -> IO Bool diff --git a/LLVM/FFI/Support.hsc b/LLVM/FFI/Support.hsc deleted file mode 100644 --- a/LLVM/FFI/Support.hsc +++ /dev/null @@ -1,16 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} - -module LLVM.FFI.Support - ( - createStandardModulePasses - , createStandardFunctionPasses - ) where - -import Foreign.C.Types (CInt, CUInt) -import LLVM.FFI.Core (PassManagerRef) - -foreign import ccall unsafe "LLVMCreateStandardFunctionPasses" createStandardFunctionPasses - :: PassManagerRef -> CUInt -> IO () - -foreign import ccall unsafe "LLVMCreateStandardModulePasses" createStandardModulePasses - :: PassManagerRef -> CUInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO () diff --git a/LLVM/FFI/Target.hsc b/LLVM/FFI/Target.hsc deleted file mode 100644 --- a/LLVM/FFI/Target.hsc +++ /dev/null @@ -1,52 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls, DeriveDataTypeable #-} - -module LLVM.FFI.Target where -import Data.Typeable -import Foreign.C.String (CString) -import Foreign.C.Types (CInt, CUInt, CULLong) -import Foreign.Ptr (Ptr) - -import LLVM.FFI.Core - --- enum { LLVMBigEndian, LLVMLittleEndian }; -type ByteOrdering = CInt - -data TargetData - deriving (Typeable) -type TargetDataRef = Ptr TargetData - -foreign import ccall unsafe "LLVMABIAlignmentOfType" aBIAlignmentOfType - :: TargetDataRef -> TypeRef -> CUInt -foreign import ccall unsafe "LLVMABISizeOfType" aBISizeOfType - :: TargetDataRef -> TypeRef -> CULLong -foreign import ccall unsafe "LLVMAddTargetData" addTargetData - :: TargetDataRef -> PassManagerRef -> IO () -foreign import ccall unsafe "LLVMByteOrder" byteOrder - :: TargetDataRef -> ByteOrdering -foreign import ccall unsafe "LLVMCallFrameAlignmentOfType" callFrameAlignmentOfType - :: TargetDataRef -> TypeRef -> CUInt -foreign import ccall unsafe "LLVMCopyStringRepOfTargetData" copyStringRepOfTargetData - :: TargetDataRef -> IO CString -foreign import ccall unsafe "LLVMCreateTargetData" createTargetData - :: CString -> IO TargetDataRef -foreign import ccall unsafe "LLVMDisposeTargetData" disposeTargetData - :: TargetDataRef -> IO () -foreign import ccall unsafe "LLVMElementAtOffset" elementAtOffset - :: TargetDataRef -> TypeRef -> CULLong -> CUInt -foreign import ccall unsafe "LLVMIntPtrType" intPtrType - :: TargetDataRef -> TypeRef -foreign import ccall unsafe "LLVMInvalidateStructLayout" invalidateStructLayout - :: TargetDataRef -> TypeRef -> IO () -foreign import ccall unsafe "LLVMOffsetOfElement" offsetOfElement - :: TargetDataRef -> TypeRef -> CUInt -> CULLong -foreign import ccall unsafe "LLVMPointerSize" pointerSize - :: TargetDataRef -> CUInt -foreign import ccall unsafe "LLVMPreferredAlignmentOfGlobal" preferredAlignmentOfGlobal - :: TargetDataRef -> ValueRef -> CUInt -foreign import ccall unsafe "LLVMPreferredAlignmentOfType" preferredAlignmentOfType - :: TargetDataRef -> TypeRef -> CUInt -foreign import ccall unsafe "LLVMSizeOfTypeInBits" sizeOfTypeInBits - :: TargetDataRef -> TypeRef -> CULLong -foreign import ccall unsafe "LLVMStoreSizeOfType" storeSizeOfType - :: TargetDataRef -> TypeRef -> CULLong - diff --git a/LLVM/FFI/Transforms/IPO.hsc b/LLVM/FFI/Transforms/IPO.hsc deleted file mode 100644 --- a/LLVM/FFI/Transforms/IPO.hsc +++ /dev/null @@ -1,36 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-} - -module LLVM.FFI.Transforms.IPO where - -import LLVM.FFI.Core - -foreign import ccall unsafe "LLVMAddArgumentPromotionPass" addArgumentPromotionPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddConstantMergePass" addConstantMergePass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddDeadArgEliminationPass" addDeadArgEliminationPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddDeadTypeEliminationPass" addDeadTypeEliminationPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddFunctionAttrsPass" addFunctionAttrsPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddFunctionInliningPass" addFunctionInliningPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddGlobalDCEPass" addGlobalDCEPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddGlobalOptimizerPass" addGlobalOptimizerPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddIPConstantPropagationPass" addIPConstantPropagationPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddLowerSetJmpPass" addLowerSetJmpPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddPruneEHPass" addPruneEHPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddIPSCCPPass" addIPSCCPPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddRaiseAllocationsPass" addRaiseAllocationsPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddStripDeadPrototypesPass" addStripDeadPrototypesPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddStripSymbolsPass" addStripSymbolsPass - :: PassManagerRef -> IO () diff --git a/LLVM/FFI/Transforms/Scalar.hsc b/LLVM/FFI/Transforms/Scalar.hsc deleted file mode 100644 --- a/LLVM/FFI/Transforms/Scalar.hsc +++ /dev/null @@ -1,50 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-} - -module LLVM.FFI.Transforms.Scalar where - -import LLVM.FFI.Core - -foreign import ccall unsafe "LLVMAddCFGSimplificationPass" addCFGSimplificationPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddConstantPropagationPass" addConstantPropagationPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddDemoteMemoryToRegisterPass" addDemoteMemoryToRegisterPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddGVNPass" addGVNPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddInstructionCombiningPass" addInstructionCombiningPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddPromoteMemoryToRegisterPass" addPromoteMemoryToRegisterPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddReassociatePass" addReassociatePass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddAggressiveDCEPass" addAggressiveDCEPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddDeadStoreEliminationPass" addDeadStoreEliminationPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddIndVarSimplifyPass" addIndVarSimplifyPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddJumpThreadingPass" addJumpThreadingPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddLICMPass" addLICMPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddLoopDeletionPass" addLoopDeletionPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddLoopRotatePass" addLoopRotatePass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddLoopUnrollPass" addLoopUnrollPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddLoopUnswitchPass" addLoopUnswitchPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddMemCpyOptPass" addMemCpyOptPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddSCCPPass" addSCCPPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddScalarReplAggregatesPass" addScalarReplAggregatesPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddSimplifyLibCallsPass" addSimplifyLibCallsPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddTailCallEliminationPass" addTailCallEliminationPass - :: PassManagerRef -> IO () -foreign import ccall unsafe "LLVMAddVerifierPass" addVerifierPass - :: PassManagerRef -> IO () diff --git a/LLVM/Target/ARM.hs b/LLVM/Target/ARM.hs deleted file mode 100644 --- a/LLVM/Target/ARM.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.ARM(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeARMTargetInfo - initializeARMTarget - -foreign import ccall unsafe "LLVMInitializeARMTargetInfo" initializeARMTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeARMTarget" initializeARMTarget :: IO () diff --git a/LLVM/Target/Alpha.hs b/LLVM/Target/Alpha.hs deleted file mode 100644 --- a/LLVM/Target/Alpha.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.Alpha(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeAlphaTargetInfo - initializeAlphaTarget - -foreign import ccall unsafe "LLVMInitializeAlphaTargetInfo" initializeAlphaTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeAlphaTarget" initializeAlphaTarget :: IO () diff --git a/LLVM/Target/Blackfin.hs b/LLVM/Target/Blackfin.hs deleted file mode 100644 --- a/LLVM/Target/Blackfin.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.Blackfin(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeBlackfinTargetInfo - initializeBlackfinTarget - -foreign import ccall unsafe "LLVMInitializeBlackfinTargetInfo" initializeBlackfinTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeBlackfinTarget" initializeBlackfinTarget :: IO () diff --git a/LLVM/Target/CBackend.hs b/LLVM/Target/CBackend.hs deleted file mode 100644 --- a/LLVM/Target/CBackend.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.CBackend(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeCBackendTargetInfo - initializeCBackendTarget - -foreign import ccall unsafe "LLVMInitializeCBackendTargetInfo" initializeCBackendTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeCBackendTarget" initializeCBackendTarget :: IO () diff --git a/LLVM/Target/CellSPU.hs b/LLVM/Target/CellSPU.hs deleted file mode 100644 --- a/LLVM/Target/CellSPU.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.CellSPU(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeCellSPUTargetInfo - initializeCellSPUTarget - -foreign import ccall unsafe "LLVMInitializeCellSPUTargetInfo" initializeCellSPUTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeCellSPUTarget" initializeCellSPUTarget :: IO () diff --git a/LLVM/Target/CppBackend.hs b/LLVM/Target/CppBackend.hs deleted file mode 100644 --- a/LLVM/Target/CppBackend.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.CppBackend(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeCppBackendTargetInfo - initializeCppBackendTarget - -foreign import ccall unsafe "LLVMInitializeCppBackendTargetInfo" initializeCppBackendTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeCppBackendTarget" initializeCppBackendTarget :: IO () diff --git a/LLVM/Target/MSP430.hs b/LLVM/Target/MSP430.hs deleted file mode 100644 --- a/LLVM/Target/MSP430.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.MSP430(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeMSP430TargetInfo - initializeMSP430Target - -foreign import ccall unsafe "LLVMInitializeMSP430TargetInfo" initializeMSP430TargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeMSP430Target" initializeMSP430Target :: IO () diff --git a/LLVM/Target/Mips.hs b/LLVM/Target/Mips.hs deleted file mode 100644 --- a/LLVM/Target/Mips.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.Mips(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeMipsTargetInfo - initializeMipsTarget - -foreign import ccall unsafe "LLVMInitializeMipsTargetInfo" initializeMipsTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeMipsTarget" initializeMipsTarget :: IO () diff --git a/LLVM/Target/Native.hs b/LLVM/Target/Native.hs deleted file mode 100644 --- a/LLVM/Target/Native.hs +++ /dev/null @@ -1,20 +0,0 @@ -{-# LANGUAGE CPP #-} -module LLVM.Target.Native(initializeNativeTarget) where -import Control.Monad -import Control.Concurrent.MVar -import System.IO.Unsafe - --- TARGET is expanded by CPP to the native target architecture. -import LLVM.Target.TARGET - --- | Initialize jitter to the native target. --- The operation is idempotent. -initializeNativeTarget :: IO () -initializeNativeTarget = do - done <- takeMVar refDone - when (not done) initializeTarget - putMVar refDone True - --- UNSAFE: global variable to keep track of initialization state. -refDone :: MVar Bool -refDone = unsafePerformIO $ newMVar False diff --git a/LLVM/Target/PIC16.hs b/LLVM/Target/PIC16.hs deleted file mode 100644 --- a/LLVM/Target/PIC16.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.PIC16(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializePIC16TargetInfo - initializePIC16Target - -foreign import ccall unsafe "LLVMInitializePIC16TargetInfo" initializePIC16TargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializePIC16Target" initializePIC16Target :: IO () diff --git a/LLVM/Target/PowerPC.hs b/LLVM/Target/PowerPC.hs deleted file mode 100644 --- a/LLVM/Target/PowerPC.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.PowerPC(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializePowerPCTargetInfo - initializePowerPCTarget - -foreign import ccall unsafe "LLVMInitializePowerPCTargetInfo" initializePowerPCTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializePowerPCTarget" initializePowerPCTarget :: IO () diff --git a/LLVM/Target/Sparc.hs b/LLVM/Target/Sparc.hs deleted file mode 100644 --- a/LLVM/Target/Sparc.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.Sparc(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeSparcTargetInfo - initializeSparcTarget - -foreign import ccall unsafe "LLVMInitializeSparcTargetInfo" initializeSparcTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeSparcTarget" initializeSparcTarget :: IO () diff --git a/LLVM/Target/SystemZ.hs b/LLVM/Target/SystemZ.hs deleted file mode 100644 --- a/LLVM/Target/SystemZ.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.SystemZ(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeSystemZTargetInfo - initializeSystemZTarget - -foreign import ccall unsafe "LLVMInitializeSystemZTargetInfo" initializeSystemZTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeSystemZTarget" initializeSystemZTarget :: IO () diff --git a/LLVM/Target/X86.hs b/LLVM/Target/X86.hs deleted file mode 100644 --- a/LLVM/Target/X86.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.X86(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeX86TargetInfo - initializeX86Target - -foreign import ccall unsafe "LLVMInitializeX86TargetInfo" initializeX86TargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeX86Target" initializeX86Target :: IO () diff --git a/LLVM/Target/XCore.hs b/LLVM/Target/XCore.hs deleted file mode 100644 --- a/LLVM/Target/XCore.hs +++ /dev/null @@ -1,10 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface #-} -module LLVM.Target.XCore(initializeTarget) where - -initializeTarget :: IO () -initializeTarget = do - initializeXCoreTargetInfo - initializeXCoreTarget - -foreign import ccall unsafe "LLVMInitializeXCoreTargetInfo" initializeXCoreTargetInfo :: IO () -foreign import ccall unsafe "LLVMInitializeXCoreTarget" initializeXCoreTarget :: IO () diff --git a/LLVM/Util/Arithmetic.hs b/LLVM/Util/Arithmetic.hs --- a/LLVM/Util/Arithmetic.hs +++ b/LLVM/Util/Arithmetic.hs @@ -1,4 +1,4 @@ -{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# OPTIONS_GHC -fno-warn-orphans -fno-warn-warnings-deprecations #-} {-# LANGUAGE CPP, FlexibleInstances, ScopedTypeVariables, FlexibleContexts, UndecidableInstances, TypeSynonymInstances, MultiParamTypeClasses, FunctionalDependencies #-} module LLVM.Util.Arithmetic( TValue, diff --git a/LLVM/Util/Optimize.hs b/LLVM/Util/Optimize.hs --- a/LLVM/Util/Optimize.hs +++ b/LLVM/Util/Optimize.hs @@ -13,10 +13,8 @@ import LLVM.Core.Util(Module, withModule) import qualified LLVM.FFI.Core as FFI import qualified LLVM.FFI.Support as FFI --- import LLVM.FFI.Target(addTargetData, createTargetData) -import LLVM.FFI.Transforms.IPO import LLVM.FFI.Transforms.Scalar -import Control.Exception (bracket, ) +import Control.Exception (bracket) {- | @@ -66,7 +64,6 @@ -- tools/opt/opt.cpp: AddStandardCompilePasses addVerifierPass passes - addLowerSetJmpPass passes addOptimizationPasses passes fPasses optLevel {- if we wanted to do so, we could loop through all functions and optimize them. @@ -120,7 +117,6 @@ -licm addLICMPass -loop-deletion addLoopDeletionPass -loop-rotate addLoopRotatePass --lowersetjmp addLowerSetJmpPass -memcpyopt addMemCpyOptPass -prune-eh addPruneEHPass -reassociate addReassociatePass diff --git a/Makefile b/Makefile deleted file mode 100644 --- a/Makefile +++ /dev/null @@ -1,66 +0,0 @@ -ghc := ghc -ghcflags := -Wall -Werror - -LLVMLIB=/usr/local -llvm_prefix ?= $(LLVMLIB) -prefix ?= $(LLVMLIB) -_lib := $(shell test -d /usr/lib64 && echo lib64 || echo lib) - -ifeq ($(prefix),$(HOME)) -user_flag := --user -endif - -all: configure build - -configure: configure.ac - autoreconf - -.PHONY: build -build: dist/setup-config - ./setup build - -dist/setup-config: setup configure llvm.cabal llvm.buildinfo.in - ./setup configure --user --prefix=$(prefix) --libdir=$(prefix)/$(_lib) \ - --configure-option --with-llvm-prefix=$(llvm_prefix) $(user_flag) - -setup: Setup.hs - $(ghc) --make -O -o $@ $< - -configure: configure.ac - autoreconf - -.PHONY: examples -examples: - $(MAKE) -C examples - -.PHONY: tests -tests: - $(MAKE) -C tests - -html: INSTALL.html PROBLEMS.html README.html - -%.html: %.md - pandoc -s -o $@ $< - -doc haddock: dist/setup-config - ./setup haddock - -sdist: dist/setup-config - ./setup sdist - -.PHONY: install -install: setup - ./setup install - -clean: - -$(MAKE) -C examples clean - -$(MAKE) -C tests clean - -$(MAKE) -C tools clean - -rm -f Setup.hi Setup.o - -./setup clean - -rm -f setup setup.exe setup.exe.manifest - -rm -f *~ - -rm -rf dist - -distclean: clean - -rm -f setup configure diff --git a/Setup.hs b/Setup.hs deleted file mode 100644 --- a/Setup.hs +++ /dev/null @@ -1,122 +0,0 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE PatternGuards #-} -import System.Directory -import System.Environment -import System.FilePath -import System.Info -import Control.Monad -import Data.List -import Data.Maybe -import Distribution.Simple -import Distribution.Simple.Setup -import Distribution.InstalledPackageInfo -import Distribution.PackageDescription -import Distribution.Simple.LocalBuildInfo -import Distribution.Simple.Install -import Distribution.Simple.Register -import Distribution.Simple.Utils -import Distribution.Text ( display ) - -main = do - let hooks = autoconfUserHooks { postConf = if os == "mingw32" - then generateBuildInfo - else postConf autoconfUserHooks - , instHook = installHookWithExtraGhciLibraries - , regHook = regHookWithExtraGhciLibraries - } - defaultMainWithHooks hooks - --- On Windows we can't count on the configure script, so generate the --- llvm.buildinfo from a template. -generateBuildInfo _ conf _ _ = do - let args = configConfigureArgs conf - let pref = "--with-llvm-prefix=" - let path = case [ p | arg <- args, Just p <- [stripPrefix pref arg] ] of - [p] -> p - _ -> error $ "Use '--configure-option " ++ pref ++ "PATH' to give LLVM installation path" - info <- readFile "llvm.buildinfo.windows.in" - writeFile "llvm.buildinfo" $ subst "@llvm_path@" path info - -subst from to [] = [] -subst from to xs | Just r <- stripPrefix from xs = to ++ subst from to r -subst from to (x:xs) = x : subst from to xs - -{- -To compensate for Cabal's current design, -we need to replicate the default registration hook code here, -to inject a value for extra-ghci-libraries into the package registration info. -(Inspired by 'Gtk2HsSetup.hs'.) -This only works for Cabal 1.10, -thus we added an according constraint to llvm.cabal. - -We define an extension field 'x-extra-ghci-libraries' in the .buildinfo file -in order to communicate the version information of the LLVM dynamic library -from the configure script to the registration code. --} -installHookWithExtraGhciLibraries :: PackageDescription -> LocalBuildInfo - -> UserHooks -> InstallFlags -> IO () -installHookWithExtraGhciLibraries pkg_descr localbuildinfo _ flags = do - let copyFlags = defaultCopyFlags { - copyDistPref = installDistPref flags, - copyDest = toFlag NoCopyDest, - copyVerbosity = installVerbosity flags - } - install pkg_descr localbuildinfo copyFlags - let registerFlags = defaultRegisterFlags { - regDistPref = installDistPref flags, - regInPlace = installInPlace flags, - regPackageDB = installPackageDB flags, - regVerbosity = installVerbosity flags - } - when (hasLibs pkg_descr) $ register' pkg_descr localbuildinfo registerFlags - -regHookWithExtraGhciLibraries :: PackageDescription -> LocalBuildInfo - -> UserHooks -> RegisterFlags -> IO () -regHookWithExtraGhciLibraries pkg_descr localbuildinfo _ flags = - if hasLibs pkg_descr - then register' pkg_descr localbuildinfo flags - else setupMessage verbosity - "Package contains no library to register:" (packageId pkg_descr) - where verbosity = fromFlag (regVerbosity flags) - -register' :: PackageDescription -> LocalBuildInfo - -> RegisterFlags -- ^Install in the user's database?; verbose - -> IO () -register' pkg@PackageDescription { library = Just lib } - lbi@LocalBuildInfo { libraryConfig = Just clbi } regFlags - = do - - installedPkgInfoRaw <- generateRegistrationInfo - verbosity pkg lib lbi clbi inplace distPref - - let ghciLibraries = case lookup "x-extra-ghci-libraries" (customFieldsBI (libBuildInfo lib)) of - Nothing -> [] - Just s -> [s] - installedPkgInfo = installedPkgInfoRaw { - extraGHCiLibraries = ghciLibraries } - - -- Three different modes: - case () of - _ | modeGenerateRegFile -> writeRegistrationFile installedPkgInfo - | modeGenerateRegScript -> die "Generate Reg Script not supported" - | otherwise -> registerPackage verbosity - installedPkgInfo pkg lbi inplace - (withPackageDB lbi) - - where - modeGenerateRegFile = isJust (flagToMaybe (regGenPkgConf regFlags)) - modeGenerateRegScript = fromFlag (regGenScript regFlags) - inplace = fromFlag (regInPlace regFlags) - packageDb = nub $ withPackageDB lbi ++ - maybeToList (flagToMaybe (regPackageDB regFlags)) - distPref = fromFlag (regDistPref regFlags) - verbosity = fromFlag (regVerbosity regFlags) - regFile = fromMaybe (display (packageId pkg) <.> "conf") - (fromFlag (regGenPkgConf regFlags)) - writeRegistrationFile installedPkgInfo = do - notice verbosity ("Creating package registration file: " ++ regFile) - writeUTF8File regFile (showInstalledPackageInfo installedPkgInfo) - -register' _ _ regFlags = notice verbosity "No package to register" - where - verbosity = fromFlag (regVerbosity regFlags) diff --git a/Setup.lhs b/Setup.lhs new file mode 100644 --- /dev/null +++ b/Setup.lhs @@ -0,0 +1,3 @@ +#!/usr/bin/env runhaskell +> import Distribution.Simple +> main = defaultMain diff --git a/cbits/extra.cpp b/cbits/extra.cpp deleted file mode 100644 --- a/cbits/extra.cpp +++ /dev/null @@ -1,544 +0,0 @@ -/* - * Copyright (c) 2008-10, Mahadevan R All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * * Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. - * - * * Neither the name of this software, nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * These are some "extra" functions not available in the standard LLVM-C - * bindings, but are required / good-to-have inorder to implement the - * Python bindings. - */ - -#include "hs_llvm_config.h" - -// standard includes -#include -#include -#include -#include - -#define __STDC_LIMIT_MACROS -#define __STDC_CONSTANT_MACROS - -// LLVM includes -#include "llvm/LLVMContext.h" -#include "llvm/Bitcode/ReaderWriter.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/Casting.h" -#include "llvm/Constants.h" -#include "llvm/DerivedTypes.h" -#include "llvm/GlobalVariable.h" -#include "llvm/TypeSymbolTable.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/CallSite.h" -#include "llvm/IntrinsicInst.h" -#include "llvm/Analysis/Verifier.h" -#include "llvm/Assembly/Parser.h" -#ifdef HAVE_LLVM_SUPPORT_DYNAMICLIBRARY_H -# include "llvm/Support/DynamicLibrary.h" -#else -# include "llvm/System/DynamicLibrary.h" -#endif -#include "llvm/PassManager.h" -#include "llvm/ExecutionEngine/ExecutionEngine.h" -#include "llvm/Analysis/LoopPass.h" -#include "llvm/Analysis/Passes.h" -#include "llvm/Analysis/DomPrinter.h" -#include "llvm/Transforms/Scalar.h" -#include "llvm/Transforms/IPO.h" -#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h" -#include "llvm/Transforms/Instrumentation.h" -#include "llvm/Transforms/Utils/Cloning.h" -#include "llvm/Linker.h" -#include "llvm/Support/SourceMgr.h" - -// LLVM-C includes -#include "llvm-c/Core.h" -#include "llvm-c/ExecutionEngine.h" - -// our includes -#include "extra.h" - -//using namespace llvm; - -char *LLVMDumpModuleToString(LLVMModuleRef module) -{ - std::string s; - llvm::raw_string_ostream buf(s); - llvm::Module *p = llvm::unwrap(module); - assert(p); - p->print(buf, NULL); - return strdup(buf.str().c_str()); -} - -char *LLVMDumpTypeToString(LLVMTypeRef type) -{ - std::string s; - llvm::raw_string_ostream buf(s); - llvm::Type *p = llvm::unwrap(type); - assert(p); - p->print(buf); - return strdup(buf.str().c_str()); -} - -char *LLVMDumpValueToString(LLVMValueRef value) -{ - std::string s; - llvm::raw_string_ostream buf(s); - llvm::Value *p = llvm::unwrap(value); - assert(p); - p->print(buf); - return strdup(buf.str().c_str()); -} - -unsigned LLVMModuleGetPointerSize(LLVMModuleRef module) -{ - llvm::Module *modulep = llvm::unwrap(module); - assert(modulep); - - llvm::Module::PointerSize p = modulep->getPointerSize(); - if (p == llvm::Module::Pointer32) - return 32; - else if (p == llvm::Module::Pointer64) - return 64; - return 0; -} - -LLVMValueRef LLVMModuleGetOrInsertFunction(LLVMModuleRef module, - const char *name, LLVMTypeRef function_type) -{ - assert(name); - - llvm::Module *modulep = llvm::unwrap(module); - assert(modulep); - - llvm::FunctionType *ftp = llvm::unwrap(function_type); - assert(ftp); - - llvm::Constant *f = modulep->getOrInsertFunction(name, ftp); - return wrap(f); -} - -int LLVMHasInitializer(LLVMValueRef global_var) -{ - llvm::GlobalVariable *gvp = llvm::unwrap(global_var); - assert(gvp); - - return gvp->hasInitializer(); -} - -#define inst_checkfn(ourfn, llvmfn) \ -unsigned ourfn (LLVMValueRef v) { \ - llvm::Instruction *ip = llvm::unwrap(v); \ - assert(ip); \ - return ip-> llvmfn () ? 1 : 0; \ -} - -inst_checkfn(LLVMInstIsTerminator, isTerminator) -inst_checkfn(LLVMInstIsBinaryOp, isBinaryOp) -inst_checkfn(LLVMInstIsShift, isShift) -inst_checkfn(LLVMInstIsCast, isCast) -inst_checkfn(LLVMInstIsLogicalShift, isLogicalShift) -inst_checkfn(LLVMInstIsArithmeticShift, isArithmeticShift) -inst_checkfn(LLVMInstIsAssociative, isAssociative) -inst_checkfn(LLVMInstIsCommutative, isCommutative) - -unsigned LLVMInstIsVolatile(LLVMValueRef v) -{ - using namespace llvm; - Instruction *ip = unwrap(v); - assert(ip); - return ((isa(*ip) && cast(*ip).isVolatile()) || - (isa(*ip) && cast(*ip).isVolatile()) ); -} - -const char *LLVMInstGetOpcodeName(LLVMValueRef inst) -{ - llvm::Instruction *instp = llvm::unwrap(inst); - assert(instp); - return instp->getOpcodeName(); -} - -unsigned LLVMInstGetOpcode(LLVMValueRef inst) -{ - llvm::Instruction *instp = llvm::unwrap(inst); - assert(instp); - return instp->getOpcode(); -} - -unsigned LLVMCmpInstGetPredicate(LLVMValueRef cmpinst) -{ - llvm::CmpInst *instp = llvm::unwrap(cmpinst); - assert(instp); - return instp->getPredicate(); -} - -/* llvm::unwrap a set of `n' wrapped objects starting at `values', - * into a vector of pointers to llvm::unwrapped objects `out'. */ -template -void unwrap_vec(W *values, unsigned n, std::vector& out) -{ - out.clear(); - - while (n--) { - UW *p = llvm::unwrap(*values); - assert(p); - out.push_back(p); - ++values; - } -} - -/* Same as llvm::unwrap_vec, but use a vector of const pointers. */ -template -void unwrap_cvec(W *values, unsigned n, std::vector& out) -{ - out.clear(); - - while (n--) { - UW *p = llvm::unwrap(*values); - assert(p); - out.push_back(p); - ++values; - } -} - -LLVMValueRef LLVMBuildRetMultiple(LLVMBuilderRef builder, - LLVMValueRef *values, unsigned n_values) -{ - assert(values); - - std::vector values_vec; - unwrap_vec(values, n_values, values_vec); - - llvm::IRBuilder<> *builderp = llvm::unwrap(builder); - assert(builderp); - - return llvm::wrap(builderp->CreateAggregateRet(&values_vec[0], values_vec.size())); -} - -LLVMValueRef LLVMBuildGetResult(LLVMBuilderRef builder, - LLVMValueRef value, unsigned index, const char *name) -{ - assert(name); - - llvm::IRBuilder<> *builderp = llvm::unwrap(builder); - assert(builderp); - - return llvm::wrap(builderp->CreateExtractValue(llvm::unwrap(value), index, name)); -} - -unsigned LLVMValueGetID(LLVMValueRef value) -{ - llvm::Value *valuep = llvm::unwrap(value); - assert(valuep); - - return valuep->getValueID(); -} - - -unsigned LLVMValueGetNumUses(LLVMValueRef value) -{ - llvm::Value *valuep = llvm::unwrap(value); - assert(valuep); - - return valuep->getNumUses(); -} - - -unsigned LLVMValueGetUses(LLVMValueRef value, LLVMValueRef **refs) -{ - llvm::Value *valuep = llvm::unwrap(value); - assert(valuep); - - unsigned n = valuep->getNumUses(); - if (n == 0) - return 0; - - assert(refs); - LLVMValueRef *out = (LLVMValueRef *)malloc(sizeof(LLVMValueRef) * n); - if (!out) - return 0; - *refs = out; - - memset(out, 0, sizeof(LLVMValueRef) * n); - llvm::Value::use_iterator it = valuep->use_begin(); - while (it != valuep->use_end()) { - *out++ = llvm::wrap(*it); - ++it; - } - - return n; -} - -unsigned LLVMValueIsUsedInBasicBlock(LLVMValueRef value, LLVMBasicBlockRef bb) -{ - llvm::Value *valuep = llvm::unwrap(value); - assert(valuep); - llvm::BasicBlock *bbp = llvm::unwrap(bb); - assert(bbp); - return valuep->isUsedInBasicBlock(bbp); -} - -void LLVMDisposeValueRefArray(LLVMValueRef *refs) -{ - assert(refs); - free(refs); -} - -unsigned LLVMUserGetNumOperands(LLVMValueRef user) -{ - llvm::User *userp = llvm::unwrap(user); - assert(userp); - return userp->getNumOperands(); -} - -LLVMValueRef LLVMUserGetOperand(LLVMValueRef user, unsigned idx) -{ - llvm::User *userp = llvm::unwrap(user); - assert(userp); - llvm::Value *operand = userp->getOperand(idx); - return llvm::wrap(operand); -} - -unsigned LLVMGetDoesNotThrow(LLVMValueRef fn) -{ - llvm::Function *fnp = llvm::unwrap(fn); - assert(fnp); - - return fnp->doesNotThrow(); -} - -void LLVMSetDoesNotThrow(LLVMValueRef fn, int DoesNotThrow) -{ - llvm::Function *fnp = llvm::unwrap(fn); - assert(fnp); - - return fnp->setDoesNotThrow((bool)DoesNotThrow); -} - -LLVMValueRef LLVMGetIntrinsic(LLVMModuleRef module, int id, - LLVMTypeRef *types, unsigned n_types) -{ - assert(types); - - std::vector types_vec; - unwrap_cvec(types, n_types, types_vec); - - llvm::Module *modulep = llvm::unwrap(module); - assert(modulep); - - llvm::Function *intfunc = llvm::Intrinsic::getDeclaration(modulep, - llvm::Intrinsic::ID(id), &types_vec[0], types_vec.size()); - - return wrap(intfunc); -} - -LLVMModuleRef LLVMGetModuleFromAssembly(const char *asmtext, unsigned txtlen, - char **out) -{ - assert(asmtext); - assert(out); - - llvm::Module *modulep; - llvm::SMDiagnostic error; - if (!(modulep = llvm::ParseAssemblyString(asmtext, NULL, error, - llvm::getGlobalContext()))) { - std::string s; - llvm::raw_string_ostream buf(s); - error.Print("llvm-py", buf); - *out = strdup(buf.str().c_str()); - return NULL; - } - - return wrap(modulep); -} - -LLVMModuleRef LLVMGetModuleFromBitcode(const char *bitcode, unsigned bclen, - char **out) -{ - assert(bitcode); - assert(out); - - llvm::StringRef as_str(bitcode, bclen); - - llvm::MemoryBuffer *mbp; - if (!(mbp = llvm::MemoryBuffer::getMemBufferCopy(as_str))) - return NULL; - - std::string msg; - llvm::Module *modulep; - if (!(modulep = llvm::ParseBitcodeFile(mbp, llvm::getGlobalContext(), - &msg))) - *out = strdup(msg.c_str()); - - delete mbp; - return wrap(modulep); -} - -unsigned LLVMLinkModules(LLVMModuleRef dest, LLVMModuleRef src, char **out) -{ - llvm::Module *sourcep = llvm::unwrap(src); - assert(sourcep); - llvm::Module *destinationp = llvm::unwrap(dest); - assert(destinationp); - - std::string msg; - if (llvm::Linker::LinkModules(destinationp, sourcep, &msg)) { - *out = strdup(msg.c_str()); - return 0; - } - - return 1; -} - -unsigned char *LLVMGetBitcodeFromModule(LLVMModuleRef module, unsigned *lenp) -{ - assert(lenp); - - llvm::Module *modulep = llvm::unwrap(module); - assert(modulep); - - /* get bc into a string */ - std::string s; - llvm::raw_string_ostream buf(s); - llvm::WriteBitcodeToFile(modulep, buf); - const std::string& bc = buf.str(); - - /* and then into a malloc()-ed block */ - size_t bclen = bc.size(); - unsigned char *bytes = (unsigned char *)malloc(bclen); - if (!bytes) - return NULL; - memcpy(bytes, bc.data(), bclen); - - /* return */ - *lenp = bclen; - return bytes; -} - -/* Return 0 on failure (with errmsg filled in), 1 on success. */ -unsigned LLVMLoadLibraryPermanently(const char* filename, char **errmsg) -{ - assert(filename); - assert(errmsg); - - /* Note: the LLVM API returns true on failure. Don't ask why. */ - std::string msg; - if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(filename, &msg)) { - *errmsg = strdup(msg.c_str()); - return 0; - } - - return 1; -} - -void *LLVMGetPointerToFunction(LLVMExecutionEngineRef ee, LLVMValueRef fn) -{ - llvm::ExecutionEngine *eep = llvm::unwrap(ee); - assert(eep); - - llvm::Function *fnp = llvm::unwrap(fn); - assert(fnp); - - return eep->getPointerToFunction(fnp); -} - -int LLVMInlineFunction(LLVMValueRef call) -{ - llvm::Value *callp = llvm::unwrap(call); - assert(callp); - - llvm::CallSite cs = llvm::CallSite(callp); - - llvm::InlineFunctionInfo unused; - return llvm::InlineFunction(cs, unused); -} - - -/* Passes. A few passes (listed below) are used directly from LLVM-C, - * rest are defined here. - */ - -#define define_pass(P) \ -void LLVMAdd ## P ## Pass (LLVMPassManagerRef passmgr) { \ - using namespace llvm; \ - llvm::PassManagerBase *pmp = llvm::unwrap(passmgr); \ - assert(pmp); \ - pmp->add( create ## P ## Pass ()); \ -} - -define_pass( AAEval ) -define_pass( AliasAnalysisCounter ) -define_pass( AlwaysInliner ) -define_pass( BasicAliasAnalysis ) -define_pass( BlockPlacement ) -define_pass( BreakCriticalEdges ) -define_pass( CodeGenPrepare ) -define_pass( DbgInfoPrinter ) -define_pass( DeadCodeElimination ) -define_pass( DeadInstElimination ) -define_pass( DemoteRegisterToMemory ) -define_pass( DomOnlyPrinter ) -define_pass( DomOnlyViewer ) -define_pass( DomPrinter ) -define_pass( DomViewer ) -define_pass( EdgeProfiler ) -define_pass( GlobalsModRef ) -define_pass( InstCount ) -define_pass( InstructionNamer ) -define_pass( LazyValueInfo ) -define_pass( LCSSA ) -define_pass( LoopDependenceAnalysis ) -define_pass( LoopExtractor ) -define_pass( LoopSimplify ) -define_pass( LoopStrengthReduce ) -define_pass( LowerInvoke ) -define_pass( LowerSwitch ) -define_pass( MergeFunctions ) -define_pass( NoAA ) -define_pass( NoProfileInfo ) -define_pass( OptimalEdgeProfiler ) -define_pass( PartialInlining ) -define_pass( PostDomOnlyPrinter ) -define_pass( PostDomOnlyViewer ) -define_pass( PostDomPrinter ) -define_pass( PostDomViewer ) -define_pass( ProfileEstimator ) -define_pass( ProfileLoader ) -define_pass( ProfileVerifier ) -define_pass( ScalarEvolutionAliasAnalysis ) -define_pass( SingleLoopExtractor ) -define_pass( StripNonDebugSymbols ) -define_pass( StructRetPromotion ) -define_pass( TailDuplication ) -define_pass( UnifyFunctionExitNodes ) - -/* we support only internalize(true) */ -llvm::ModulePass *createInternalize2Pass() { return llvm::createInternalizePass(true); } -define_pass( Internalize2 ) - diff --git a/cbits/free.c b/cbits/free.c deleted file mode 100644 --- a/cbits/free.c +++ /dev/null @@ -1,17 +0,0 @@ -#define __STDC_LIMIT_MACROS -#define __STDC_CONSTANT_MACROS -#include -#include - -/* C function to free function object resources. Can be called from a finalizer. */ -void -c_freeFunctionObject(LLVMExecutionEngineRef execEngine, - LLVMModuleProviderRef moduleProvider, - LLVMValueRef f) -{ - LLVMModuleRef mod; - LLVMFreeMachineCodeForFunction(execEngine, f); - if (!LLVMRemoveModuleProvider(execEngine, moduleProvider, &mod, 0)) { - LLVMDisposeModule(mod); - } -} diff --git a/cbits/malloc.c b/cbits/malloc.c deleted file mode 100644 --- a/cbits/malloc.c +++ /dev/null @@ -1,190 +0,0 @@ -#include -#include - -#ifdef DEBUG -#include -#endif - -#ifdef TEST -#include -#endif - - -size_t gcd(size_t x, size_t y) { - while (x!=0) { - size_t tmp = y%x; - y = x; - x = tmp; - } - return y; -}; - -__inline__ -size_t lcm(size_t x, size_t y) { - return x*(y/gcd(x,y)); -}; - -__inline__ -size_t round_down_multiple(size_t x, size_t y) { - return x - (x%y); -}; - -/* -This is the alignment that malloc always warrants. -If smaller alignments are requested, then we do not need to pad. - -FIXME: -This was only tested on ix86-linux. -How to get the right number for every platform? -*/ -const size_t default_align = 8; - -/* -We have to waste a lot of memory, -since we need an aligned address -and before that space for a pointer. -Less memory can be wasted if 'free' also gets size and align information. -In this case we could omit padding in some cases -and in the other cases we could put the pointer after the memory chunk, -which allows us to use less padding. -*/ -void *aligned_malloc(size_t size, size_t requested_align) { - const size_t ptrsize = sizeof(void *); - /* - Ensure that alignment always allows to store a pointer - (to the whole allocated block). - */ - const size_t align = lcm(requested_align, ptrsize); - const size_t pad = align; - void *ptr = malloc(pad+ptrsize+size); - if (ptr) { - void **alignedptr = (void **) round_down_multiple((size_t)(ptr+pad+ptrsize), align); - *(alignedptr-1) = ptr; -#ifdef DEBUG - printf("allocated size %x with alignment %x at %08x %08x \n", - size, align, (size_t) ptr, (size_t) alignedptr); -#endif - return alignedptr; - } else { - return NULL; - } -}; - -/* align must be a power of two */ -void *power2_aligned_malloc(size_t size, size_t align) { - const size_t ptrsize = sizeof(void *); - size_t pad = align>=default_align ? align-default_align : 0; - void *ptr = malloc(pad+ptrsize+size); - if (ptr) { - void **alignedptr = (void **)((size_t)(ptr+pad+ptrsize) & (-align)); - *(alignedptr-1) = ptr; -#ifdef DEBUG - printf("allocated size 0x%x with alignment 0x%x at %08x %08x \n", - size, align, (size_t) ptr, (size_t) alignedptr); -#endif - return alignedptr; - } else { - return NULL; - } -}; - -void aligned_free(void *alignedptr) { - if (alignedptr) { - void **sptr = (void **) alignedptr; - void *ptr = *(sptr - 1); -#ifdef DEBUG - printf("freed %08x %08x \n", (size_t) ptr, (size_t) alignedptr); -#endif - free(ptr); - } else { - /* - What shall we do about NULL pointers? - Crash immediately? Make an official crash by 'free'? - */ - free(alignedptr); - } -}; - - -/* -Abuse a pointer type as a size_t compatible type -and choose a name that will hopefully not clash -with names an llvm user already uses (such as 'malloc'). -*/ -void *aligned_malloc_sizeptr(void *size, void *align) { - return aligned_malloc((size_t) size, (size_t) align); -} - - -const int - prepadsize = 1024, - postpadsize = 1024; - -void *padded_aligned_malloc(size_t size, size_t align) { - void *ptr = aligned_malloc(prepadsize+size+postpadsize, align); - return ptr ? ptr+prepadsize : NULL; -}; - -void padded_aligned_free(void *ptr) { - aligned_free(ptr ? ptr-prepadsize : NULL); -}; - - -#ifdef TEST -void test_gcd (size_t x, size_t y) { - printf("gcd(%d,%d) = %d\n", x, y, gcd (x,y)); -} - -void test_malloc (size_t size, size_t align) { - uint8_t *ptr = aligned_malloc (size, align); - if (ptr) { - if (((size_t) ptr) % align) { - printf ("ptr %08x not correctly aligned\n", (size_t) ptr); - } - size_t k; - for (k = 0; k 2) - Threshold = 275; - InliningPass = createFunctionInliningPass(Threshold); - } else { - InliningPass = createAlwaysInlinerPass(); - } - - createStandardModulePasses(unwrap(PM), OptLevel, OptimizeSize, - UnitAtATime, UnrollLoops, SimplifyLibCalls, - HaveExceptions, InliningPass); -} diff --git a/configure b/configure deleted file mode 100644 --- a/configure +++ /dev/null @@ -1,4643 +0,0 @@ -#! /bin/sh -# Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.61 for Haskell LLVM bindings 0.9.1.2. -# -# Report bugs to . -# -# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. -# This configure script is free software; the Free Software Foundation -# gives unlimited permission to copy, distribute and modify it. -## --------------------- ## -## M4sh Initialization. ## -## --------------------- ## - -# Be more Bourne compatible -DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - - - -# PATH needs CR -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - echo "#! /bin/sh" >conf$$.sh - echo "exit 0" >>conf$$.sh - chmod +x conf$$.sh - if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then - PATH_SEPARATOR=';' - else - PATH_SEPARATOR=: - fi - rm -f conf$$.sh -fi - -# Support unset when possible. -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then - as_unset=unset -else - as_unset=false -fi - - -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -as_nl=' -' -IFS=" "" $as_nl" - -# Find who we are. Look in the path if we contain no directory separator. -case $0 in - *[\\/]* ) as_myself=$0 ;; - *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break -done -IFS=$as_save_IFS - - ;; -esac -# We did not find ourselves, most probably we were run as `sh COMMAND' -# in which case we are not to be found in the path. -if test "x$as_myself" = x; then - as_myself=$0 -fi -if test ! -f "$as_myself"; then - echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - { (exit 1); exit 1; } -fi - -# Work around bugs in pre-3.0 UWIN ksh. -for as_var in ENV MAIL MAILPATH -do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -for as_var in \ - LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ - LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ - LC_TELEPHONE LC_TIME -do - if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then - eval $as_var=C; export $as_var - else - ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - fi -done - -# Required to use basename. -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then - as_basename=basename -else - as_basename=false -fi - - -# Name of the executable. -as_me=`$as_basename -- "$0" || -$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X/"$0" | - sed '/^.*\/\([^/][^/]*\)\/*$/{ - s//\1/ - q - } - /^X\/\(\/\/\)$/{ - s//\1/ - q - } - /^X\/\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - -# CDPATH. -$as_unset CDPATH - - -if test "x$CONFIG_SHELL" = x; then - if (eval ":") 2>/dev/null; then - as_have_required=yes -else - as_have_required=no -fi - - if test $as_have_required = yes && (eval ": -(as_func_return () { - (exit \$1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} - -exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi - -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi - -if as_func_ret_success; then - : -else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = \"\$1\" ); then - : -else - exitcode=1 - echo positional parameters were not saved. -fi - -test \$exitcode = 0) || { (exit 1); exit 1; } - -( - as_lineno_1=\$LINENO - as_lineno_2=\$LINENO - test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" && - test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; } -") 2> /dev/null; then - : -else - as_candidate_shells= - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - case $as_dir in - /*) - for as_base in sh bash ksh sh5; do - as_candidate_shells="$as_candidate_shells $as_dir/$as_base" - done;; - esac -done -IFS=$as_save_IFS - - - for as_shell in $as_candidate_shells $SHELL; do - # Try only shells that exist, to save several forks. - if { test -f "$as_shell" || test -f "$as_shell.exe"; } && - { ("$as_shell") 2> /dev/null <<\_ASEOF -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - -: -_ASEOF -}; then - CONFIG_SHELL=$as_shell - as_have_required=yes - if { "$as_shell" 2> /dev/null <<\_ASEOF -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - -: -(as_func_return () { - (exit $1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} - -exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi - -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi - -if as_func_ret_success; then - : -else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = "$1" ); then - : -else - exitcode=1 - echo positional parameters were not saved. -fi - -test $exitcode = 0) || { (exit 1); exit 1; } - -( - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; } - -_ASEOF -}; then - break -fi - -fi - - done - - if test "x$CONFIG_SHELL" != x; then - for as_var in BASH_ENV ENV - do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - done - export CONFIG_SHELL - exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} -fi - - - if test $as_have_required = no; then - echo This script requires a shell more modern than all the - echo shells that I found on your system. Please install a - echo modern shell, or manually run the script under such a - echo shell if you do have one. - { (exit 1); exit 1; } -fi - - -fi - -fi - - - -(eval "as_func_return () { - (exit \$1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} - -exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi - -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi - -if as_func_ret_success; then - : -else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = \"\$1\" ); then - : -else - exitcode=1 - echo positional parameters were not saved. -fi - -test \$exitcode = 0") || { - echo No shell found that supports shell functions. - echo Please tell autoconf@gnu.org about your system, - echo including any error possibly output before this - echo message -} - - - - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { - - # Create $as_me.lineno as a copy of $as_myself, but with $LINENO - # uniformly replaced by the line number. The first 'sed' inserts a - # line-number line after each line using $LINENO; the second 'sed' - # does the real work. The second script uses 'N' to pair each - # line-number line with the line containing $LINENO, and appends - # trailing '-' during substitution so that $LINENO is not a special - # case at line end. - # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the - # scripts with optimization help from Paolo Bonzini. Blame Lee - # E. McMahon (1931-1989) for sed's syntax. :-) - sed -n ' - p - /[$]LINENO/= - ' <$as_myself | - sed ' - s/[$]LINENO.*/&-/ - t lineno - b - :lineno - N - :loop - s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ - t loop - s/-\n.*// - ' >$as_me.lineno && - chmod +x "$as_me.lineno" || - { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 - { (exit 1); exit 1; }; } - - # Don't try to exec as it changes $[0], causing all sort of problems - # (the dirname of $[0] is not the place where we might find the - # original and so on. Autoconf is especially sensitive to this). - . "./$as_me.lineno" - # Exit status is that of the last command. - exit -} - - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi - -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in --n*) - case `echo 'x\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - *) ECHO_C='\c';; - esac;; -*) - ECHO_N='-n';; -esac - -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -rm -f conf$$ conf$$.exe conf$$.file -if test -d conf$$.dir; then - rm -f conf$$.dir/conf$$.file -else - rm -f conf$$.dir - mkdir conf$$.dir -fi -echo >conf$$.file -if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' -elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln -else - as_ln_s='cp -p' -fi -rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file -rmdir conf$$.dir 2>/dev/null - -if mkdir -p . 2>/dev/null; then - as_mkdir_p=: -else - test -d ./-p && rmdir ./-p - as_mkdir_p=false -fi - -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x - -# Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" - -# Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" - - - -exec 7<&0 &1 - -# Name of the host. -# hostname on some systems (SVR3.2, Linux) returns a bogus exit status, -# so uname gets run too. -ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` - -# -# Initializations. -# -ac_default_prefix=/usr/local -ac_clean_files= -ac_config_libobj_dir=. -LIBOBJS= -cross_compiling=no -subdirs= -MFLAGS= -MAKEFLAGS= -SHELL=${CONFIG_SHELL-/bin/sh} - -# Identity of this package. -PACKAGE_NAME='Haskell LLVM bindings' -PACKAGE_TARNAME='llvm' -PACKAGE_VERSION='0.9.1.2' -PACKAGE_STRING='Haskell LLVM bindings 0.9.1.2' -PACKAGE_BUGREPORT='bos@serpentine.com' - -ac_unique_file="LLVM/ExecutionEngine.hs" -# Factoring default headers for most tests. -ac_includes_default="\ -#include -#ifdef HAVE_SYS_TYPES_H -# include -#endif -#ifdef HAVE_SYS_STAT_H -# include -#endif -#ifdef STDC_HEADERS -# include -# include -#else -# ifdef HAVE_STDLIB_H -# include -# endif -#endif -#ifdef HAVE_STRING_H -# if !defined STDC_HEADERS && defined HAVE_MEMORY_H -# include -# endif -# include -#endif -#ifdef HAVE_STRINGS_H -# include -#endif -#ifdef HAVE_INTTYPES_H -# include -#endif -#ifdef HAVE_STDINT_H -# include -#endif -#ifdef HAVE_UNISTD_H -# include -#endif" - -ac_subst_vars='SHELL -PATH_SEPARATOR -PACKAGE_NAME -PACKAGE_TARNAME -PACKAGE_VERSION -PACKAGE_STRING -PACKAGE_BUGREPORT -exec_prefix -prefix -program_transform_name -bindir -sbindir -libexecdir -datarootdir -datadir -sysconfdir -sharedstatedir -localstatedir -includedir -oldincludedir -docdir -infodir -htmldir -dvidir -pdfdir -psdir -libdir -localedir -mandir -DEFS -ECHO_C -ECHO_N -ECHO_T -LIBS -build_alias -host_alias -target_alias -CXX -CXXFLAGS -LDFLAGS -CPPFLAGS -ac_ct_CXX -EXEEXT -OBJEXT -llvm_config -CXXCPP -GREP -EGREP -llvm_version -llvm_cppflags -llvm_extra_libs -llvm_extra_libdirs -llvm_extra_ghci_libs -llvm_target -llvm_includedir -llvm_ldoptions -LIBOBJS -LTLIBOBJS' -ac_subst_files='' - ac_precious_vars='build_alias -host_alias -target_alias -CXX -CXXFLAGS -LDFLAGS -LIBS -CPPFLAGS -CCC -CXXCPP' - - -# Initialize some variables set by options. -ac_init_help= -ac_init_version=false -# The variables have the same names as the options, with -# dashes changed to underlines. -cache_file=/dev/null -exec_prefix=NONE -no_create= -no_recursion= -prefix=NONE -program_prefix=NONE -program_suffix=NONE -program_transform_name=s,x,x, -silent= -site= -srcdir= -verbose= -x_includes=NONE -x_libraries=NONE - -# Installation directory options. -# These are left unexpanded so users can "make install exec_prefix=/foo" -# and all the variables that are supposed to be based on exec_prefix -# by default will actually change. -# Use braces instead of parens because sh, perl, etc. also accept them. -# (The list follows the same order as the GNU Coding Standards.) -bindir='${exec_prefix}/bin' -sbindir='${exec_prefix}/sbin' -libexecdir='${exec_prefix}/libexec' -datarootdir='${prefix}/share' -datadir='${datarootdir}' -sysconfdir='${prefix}/etc' -sharedstatedir='${prefix}/com' -localstatedir='${prefix}/var' -includedir='${prefix}/include' -oldincludedir='/usr/include' -docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' -infodir='${datarootdir}/info' -htmldir='${docdir}' -dvidir='${docdir}' -pdfdir='${docdir}' -psdir='${docdir}' -libdir='${exec_prefix}/lib' -localedir='${datarootdir}/locale' -mandir='${datarootdir}/man' - -ac_prev= -ac_dashdash= -for ac_option -do - # If the previous option needs an argument, assign it. - if test -n "$ac_prev"; then - eval $ac_prev=\$ac_option - ac_prev= - continue - fi - - case $ac_option in - *=*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; - *) ac_optarg=yes ;; - esac - - # Accept the important Cygnus configure options, so we can diagnose typos. - - case $ac_dashdash$ac_option in - --) - ac_dashdash=yes ;; - - -bindir | --bindir | --bindi | --bind | --bin | --bi) - ac_prev=bindir ;; - -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) - bindir=$ac_optarg ;; - - -build | --build | --buil | --bui | --bu) - ac_prev=build_alias ;; - -build=* | --build=* | --buil=* | --bui=* | --bu=*) - build_alias=$ac_optarg ;; - - -cache-file | --cache-file | --cache-fil | --cache-fi \ - | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) - ac_prev=cache_file ;; - -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ - | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) - cache_file=$ac_optarg ;; - - --config-cache | -C) - cache_file=config.cache ;; - - -datadir | --datadir | --datadi | --datad) - ac_prev=datadir ;; - -datadir=* | --datadir=* | --datadi=* | --datad=*) - datadir=$ac_optarg ;; - - -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ - | --dataroo | --dataro | --datar) - ac_prev=datarootdir ;; - -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ - | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) - datarootdir=$ac_optarg ;; - - -disable-* | --disable-*) - ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid feature name: $ac_feature" >&2 - { (exit 1); exit 1; }; } - ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'` - eval enable_$ac_feature=no ;; - - -docdir | --docdir | --docdi | --doc | --do) - ac_prev=docdir ;; - -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) - docdir=$ac_optarg ;; - - -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) - ac_prev=dvidir ;; - -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) - dvidir=$ac_optarg ;; - - -enable-* | --enable-*) - ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid feature name: $ac_feature" >&2 - { (exit 1); exit 1; }; } - ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'` - eval enable_$ac_feature=\$ac_optarg ;; - - -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ - | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ - | --exec | --exe | --ex) - ac_prev=exec_prefix ;; - -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ - | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ - | --exec=* | --exe=* | --ex=*) - exec_prefix=$ac_optarg ;; - - -gas | --gas | --ga | --g) - # Obsolete; use --with-gas. - with_gas=yes ;; - - -help | --help | --hel | --he | -h) - ac_init_help=long ;; - -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) - ac_init_help=recursive ;; - -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) - ac_init_help=short ;; - - -host | --host | --hos | --ho) - ac_prev=host_alias ;; - -host=* | --host=* | --hos=* | --ho=*) - host_alias=$ac_optarg ;; - - -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) - ac_prev=htmldir ;; - -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ - | --ht=*) - htmldir=$ac_optarg ;; - - -includedir | --includedir | --includedi | --included | --include \ - | --includ | --inclu | --incl | --inc) - ac_prev=includedir ;; - -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ - | --includ=* | --inclu=* | --incl=* | --inc=*) - includedir=$ac_optarg ;; - - -infodir | --infodir | --infodi | --infod | --info | --inf) - ac_prev=infodir ;; - -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) - infodir=$ac_optarg ;; - - -libdir | --libdir | --libdi | --libd) - ac_prev=libdir ;; - -libdir=* | --libdir=* | --libdi=* | --libd=*) - libdir=$ac_optarg ;; - - -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ - | --libexe | --libex | --libe) - ac_prev=libexecdir ;; - -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ - | --libexe=* | --libex=* | --libe=*) - libexecdir=$ac_optarg ;; - - -localedir | --localedir | --localedi | --localed | --locale) - ac_prev=localedir ;; - -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) - localedir=$ac_optarg ;; - - -localstatedir | --localstatedir | --localstatedi | --localstated \ - | --localstate | --localstat | --localsta | --localst | --locals) - ac_prev=localstatedir ;; - -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ - | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) - localstatedir=$ac_optarg ;; - - -mandir | --mandir | --mandi | --mand | --man | --ma | --m) - ac_prev=mandir ;; - -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) - mandir=$ac_optarg ;; - - -nfp | --nfp | --nf) - # Obsolete; use --without-fp. - with_fp=no ;; - - -no-create | --no-create | --no-creat | --no-crea | --no-cre \ - | --no-cr | --no-c | -n) - no_create=yes ;; - - -no-recursion | --no-recursion | --no-recursio | --no-recursi \ - | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) - no_recursion=yes ;; - - -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ - | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ - | --oldin | --oldi | --old | --ol | --o) - ac_prev=oldincludedir ;; - -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ - | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ - | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) - oldincludedir=$ac_optarg ;; - - -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) - ac_prev=prefix ;; - -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) - prefix=$ac_optarg ;; - - -program-prefix | --program-prefix | --program-prefi | --program-pref \ - | --program-pre | --program-pr | --program-p) - ac_prev=program_prefix ;; - -program-prefix=* | --program-prefix=* | --program-prefi=* \ - | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) - program_prefix=$ac_optarg ;; - - -program-suffix | --program-suffix | --program-suffi | --program-suff \ - | --program-suf | --program-su | --program-s) - ac_prev=program_suffix ;; - -program-suffix=* | --program-suffix=* | --program-suffi=* \ - | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) - program_suffix=$ac_optarg ;; - - -program-transform-name | --program-transform-name \ - | --program-transform-nam | --program-transform-na \ - | --program-transform-n | --program-transform- \ - | --program-transform | --program-transfor \ - | --program-transfo | --program-transf \ - | --program-trans | --program-tran \ - | --progr-tra | --program-tr | --program-t) - ac_prev=program_transform_name ;; - -program-transform-name=* | --program-transform-name=* \ - | --program-transform-nam=* | --program-transform-na=* \ - | --program-transform-n=* | --program-transform-=* \ - | --program-transform=* | --program-transfor=* \ - | --program-transfo=* | --program-transf=* \ - | --program-trans=* | --program-tran=* \ - | --progr-tra=* | --program-tr=* | --program-t=*) - program_transform_name=$ac_optarg ;; - - -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) - ac_prev=pdfdir ;; - -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) - pdfdir=$ac_optarg ;; - - -psdir | --psdir | --psdi | --psd | --ps) - ac_prev=psdir ;; - -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) - psdir=$ac_optarg ;; - - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil) - silent=yes ;; - - -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) - ac_prev=sbindir ;; - -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ - | --sbi=* | --sb=*) - sbindir=$ac_optarg ;; - - -sharedstatedir | --sharedstatedir | --sharedstatedi \ - | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ - | --sharedst | --shareds | --shared | --share | --shar \ - | --sha | --sh) - ac_prev=sharedstatedir ;; - -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ - | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ - | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ - | --sha=* | --sh=*) - sharedstatedir=$ac_optarg ;; - - -site | --site | --sit) - ac_prev=site ;; - -site=* | --site=* | --sit=*) - site=$ac_optarg ;; - - -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) - ac_prev=srcdir ;; - -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) - srcdir=$ac_optarg ;; - - -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ - | --syscon | --sysco | --sysc | --sys | --sy) - ac_prev=sysconfdir ;; - -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ - | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) - sysconfdir=$ac_optarg ;; - - -target | --target | --targe | --targ | --tar | --ta | --t) - ac_prev=target_alias ;; - -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) - target_alias=$ac_optarg ;; - - -v | -verbose | --verbose | --verbos | --verbo | --verb) - verbose=yes ;; - - -version | --version | --versio | --versi | --vers | -V) - ac_init_version=: ;; - - -with-* | --with-*) - ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid package name: $ac_package" >&2 - { (exit 1); exit 1; }; } - ac_package=`echo $ac_package | sed 's/[-.]/_/g'` - eval with_$ac_package=\$ac_optarg ;; - - -without-* | --without-*) - ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid package name: $ac_package" >&2 - { (exit 1); exit 1; }; } - ac_package=`echo $ac_package | sed 's/[-.]/_/g'` - eval with_$ac_package=no ;; - - --x) - # Obsolete; use --with-x. - with_x=yes ;; - - -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ - | --x-incl | --x-inc | --x-in | --x-i) - ac_prev=x_includes ;; - -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ - | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) - x_includes=$ac_optarg ;; - - -x-libraries | --x-libraries | --x-librarie | --x-librari \ - | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) - ac_prev=x_libraries ;; - -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ - | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) - x_libraries=$ac_optarg ;; - - -*) { echo "$as_me: error: unrecognized option: $ac_option -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; } - ;; - - *=*) - ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` - # Reject names that are not valid shell variable names. - expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 - { (exit 1); exit 1; }; } - eval $ac_envvar=\$ac_optarg - export $ac_envvar ;; - - *) - # FIXME: should be removed in autoconf 3.0. - echo "$as_me: WARNING: you should use --build, --host, --target" >&2 - expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && - echo "$as_me: WARNING: invalid host type: $ac_option" >&2 - : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} - ;; - - esac -done - -if test -n "$ac_prev"; then - ac_option=--`echo $ac_prev | sed 's/_/-/g'` - { echo "$as_me: error: missing argument to $ac_option" >&2 - { (exit 1); exit 1; }; } -fi - -# Be sure to have absolute directory names. -for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ - datadir sysconfdir sharedstatedir localstatedir includedir \ - oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ - libdir localedir mandir -do - eval ac_val=\$$ac_var - case $ac_val in - [\\/$]* | ?:[\\/]* ) continue;; - NONE | '' ) case $ac_var in *prefix ) continue;; esac;; - esac - { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 - { (exit 1); exit 1; }; } -done - -# There might be people who depend on the old broken behavior: `$host' -# used to hold the argument of --host etc. -# FIXME: To remove some day. -build=$build_alias -host=$host_alias -target=$target_alias - -# FIXME: To remove some day. -if test "x$host_alias" != x; then - if test "x$build_alias" = x; then - cross_compiling=maybe - echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. - If a cross compiler is detected then cross compile mode will be used." >&2 - elif test "x$build_alias" != "x$host_alias"; then - cross_compiling=yes - fi -fi - -ac_tool_prefix= -test -n "$host_alias" && ac_tool_prefix=$host_alias- - -test "$silent" = yes && exec 6>/dev/null - - -ac_pwd=`pwd` && test -n "$ac_pwd" && -ac_ls_di=`ls -di .` && -ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || - { echo "$as_me: error: Working directory cannot be determined" >&2 - { (exit 1); exit 1; }; } -test "X$ac_ls_di" = "X$ac_pwd_ls_di" || - { echo "$as_me: error: pwd does not report name of working directory" >&2 - { (exit 1); exit 1; }; } - - -# Find the source files, if location was not specified. -if test -z "$srcdir"; then - ac_srcdir_defaulted=yes - # Try the directory containing this script, then the parent directory. - ac_confdir=`$as_dirname -- "$0" || -$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$0" : 'X\(//\)[^/]' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X"$0" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - srcdir=$ac_confdir - if test ! -r "$srcdir/$ac_unique_file"; then - srcdir=.. - fi -else - ac_srcdir_defaulted=no -fi -if test ! -r "$srcdir/$ac_unique_file"; then - test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." - { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 - { (exit 1); exit 1; }; } -fi -ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" -ac_abs_confdir=`( - cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2 - { (exit 1); exit 1; }; } - pwd)` -# When building in place, set srcdir=. -if test "$ac_abs_confdir" = "$ac_pwd"; then - srcdir=. -fi -# Remove unnecessary trailing slashes from srcdir. -# Double slashes in file names in object file debugging info -# mess up M-x gdb in Emacs. -case $srcdir in -*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; -esac -for ac_var in $ac_precious_vars; do - eval ac_env_${ac_var}_set=\${${ac_var}+set} - eval ac_env_${ac_var}_value=\$${ac_var} - eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} - eval ac_cv_env_${ac_var}_value=\$${ac_var} -done - -# -# Report the --help message. -# -if test "$ac_init_help" = "long"; then - # Omit some internal or obsolete options to make the list less imposing. - # This message is too long to be a string in the A/UX 3.1 sh. - cat <<_ACEOF -\`configure' configures Haskell LLVM bindings 0.9.1.2 to adapt to many kinds of systems. - -Usage: $0 [OPTION]... [VAR=VALUE]... - -To assign environment variables (e.g., CC, CFLAGS...), specify them as -VAR=VALUE. See below for descriptions of some of the useful variables. - -Defaults for the options are specified in brackets. - -Configuration: - -h, --help display this help and exit - --help=short display options specific to this package - --help=recursive display the short help of all the included packages - -V, --version display version information and exit - -q, --quiet, --silent do not print \`checking...' messages - --cache-file=FILE cache test results in FILE [disabled] - -C, --config-cache alias for \`--cache-file=config.cache' - -n, --no-create do not create output files - --srcdir=DIR find the sources in DIR [configure dir or \`..'] - -Installation directories: - --prefix=PREFIX install architecture-independent files in PREFIX - [$ac_default_prefix] - --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX - [PREFIX] - -By default, \`make install' will install all the files in -\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify -an installation prefix other than \`$ac_default_prefix' using \`--prefix', -for instance \`--prefix=\$HOME'. - -For better control, use the options below. - -Fine tuning of the installation directories: - --bindir=DIR user executables [EPREFIX/bin] - --sbindir=DIR system admin executables [EPREFIX/sbin] - --libexecdir=DIR program executables [EPREFIX/libexec] - --sysconfdir=DIR read-only single-machine data [PREFIX/etc] - --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] - --localstatedir=DIR modifiable single-machine data [PREFIX/var] - --libdir=DIR object code libraries [EPREFIX/lib] - --includedir=DIR C header files [PREFIX/include] - --oldincludedir=DIR C header files for non-gcc [/usr/include] - --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] - --datadir=DIR read-only architecture-independent data [DATAROOTDIR] - --infodir=DIR info documentation [DATAROOTDIR/info] - --localedir=DIR locale-dependent data [DATAROOTDIR/locale] - --mandir=DIR man documentation [DATAROOTDIR/man] - --docdir=DIR documentation root [DATAROOTDIR/doc/llvm] - --htmldir=DIR html documentation [DOCDIR] - --dvidir=DIR dvi documentation [DOCDIR] - --pdfdir=DIR pdf documentation [DOCDIR] - --psdir=DIR ps documentation [DOCDIR] -_ACEOF - - cat <<\_ACEOF - -System types: - --target=TARGET configure for building compilers for TARGET [guessed] -_ACEOF -fi - -if test -n "$ac_init_help"; then - case $ac_init_help in - short | recursive ) echo "Configuration of Haskell LLVM bindings 0.9.1.2:";; - esac - cat <<\_ACEOF - -Optional Packages: - --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] - --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) - --with-compiler use the given Haskell compiler - --with-llvm-prefix use the version of LLVM at the given location - --with-llvm-bindir use LLVM binaries at the given location - -Some influential environment variables: - CXX C++ compiler command - CXXFLAGS C++ compiler flags - LDFLAGS linker flags, e.g. -L if you have libraries in a - nonstandard directory - LIBS libraries to pass to the linker, e.g. -l - CPPFLAGS C/C++/Objective C preprocessor flags, e.g. -I if - you have headers in a nonstandard directory - CXXCPP C++ preprocessor - -Use these variables to override the choices made by `configure' or to help -it to find libraries and programs with nonstandard names/locations. - -Report bugs to . -_ACEOF -ac_status=$? -fi - -if test "$ac_init_help" = "recursive"; then - # If there are subdirs, report their specific --help. - for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue - test -d "$ac_dir" || continue - ac_builddir=. - -case "$ac_dir" in -.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; -*) - ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` - # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'` - case $ac_top_builddir_sub in - "") ac_top_builddir_sub=. ac_top_build_prefix= ;; - *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; - esac ;; -esac -ac_abs_top_builddir=$ac_pwd -ac_abs_builddir=$ac_pwd$ac_dir_suffix -# for backward compatibility: -ac_top_builddir=$ac_top_build_prefix - -case $srcdir in - .) # We are building in place. - ac_srcdir=. - ac_top_srcdir=$ac_top_builddir_sub - ac_abs_top_srcdir=$ac_pwd ;; - [\\/]* | ?:[\\/]* ) # Absolute name. - ac_srcdir=$srcdir$ac_dir_suffix; - ac_top_srcdir=$srcdir - ac_abs_top_srcdir=$srcdir ;; - *) # Relative name. - ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix - ac_top_srcdir=$ac_top_build_prefix$srcdir - ac_abs_top_srcdir=$ac_pwd/$srcdir ;; -esac -ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix - - cd "$ac_dir" || { ac_status=$?; continue; } - # Check for guested configure. - if test -f "$ac_srcdir/configure.gnu"; then - echo && - $SHELL "$ac_srcdir/configure.gnu" --help=recursive - elif test -f "$ac_srcdir/configure"; then - echo && - $SHELL "$ac_srcdir/configure" --help=recursive - else - echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 - fi || ac_status=$? - cd "$ac_pwd" || { ac_status=$?; break; } - done -fi - -test -n "$ac_init_help" && exit $ac_status -if $ac_init_version; then - cat <<\_ACEOF -Haskell LLVM bindings configure 0.9.1.2 -generated by GNU Autoconf 2.61 - -Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. -This configure script is free software; the Free Software Foundation -gives unlimited permission to copy, distribute and modify it. -_ACEOF - exit -fi -cat >config.log <<_ACEOF -This file contains any messages produced by compilers while -running configure, to aid debugging if configure makes a mistake. - -It was created by Haskell LLVM bindings $as_me 0.9.1.2, which was -generated by GNU Autoconf 2.61. Invocation command line was - - $ $0 $@ - -_ACEOF -exec 5>>config.log -{ -cat <<_ASUNAME -## --------- ## -## Platform. ## -## --------- ## - -hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` -uname -m = `(uname -m) 2>/dev/null || echo unknown` -uname -r = `(uname -r) 2>/dev/null || echo unknown` -uname -s = `(uname -s) 2>/dev/null || echo unknown` -uname -v = `(uname -v) 2>/dev/null || echo unknown` - -/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` -/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` - -/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` -/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` -/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` -/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` -/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` -/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` -/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` - -_ASUNAME - -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - echo "PATH: $as_dir" -done -IFS=$as_save_IFS - -} >&5 - -cat >&5 <<_ACEOF - - -## ----------- ## -## Core tests. ## -## ----------- ## - -_ACEOF - - -# Keep a trace of the command line. -# Strip out --no-create and --no-recursion so they do not pile up. -# Strip out --silent because we don't want to record it for future runs. -# Also quote any args containing shell meta-characters. -# Make two passes to allow for proper duplicate-argument suppression. -ac_configure_args= -ac_configure_args0= -ac_configure_args1= -ac_must_keep_next=false -for ac_pass in 1 2 -do - for ac_arg - do - case $ac_arg in - -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil) - continue ;; - *\'*) - ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; - esac - case $ac_pass in - 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;; - 2) - ac_configure_args1="$ac_configure_args1 '$ac_arg'" - if test $ac_must_keep_next = true; then - ac_must_keep_next=false # Got value, back to normal. - else - case $ac_arg in - *=* | --config-cache | -C | -disable-* | --disable-* \ - | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ - | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ - | -with-* | --with-* | -without-* | --without-* | --x) - case "$ac_configure_args0 " in - "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; - esac - ;; - -* ) ac_must_keep_next=true ;; - esac - fi - ac_configure_args="$ac_configure_args '$ac_arg'" - ;; - esac - done -done -$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; } -$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; } - -# When interrupted or exit'd, cleanup temporary files, and complete -# config.log. We remove comments because anyway the quotes in there -# would cause problems or look ugly. -# WARNING: Use '\'' to represent an apostrophe within the trap. -# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. -trap 'exit_status=$? - # Save into config.log some information that might help in debugging. - { - echo - - cat <<\_ASBOX -## ---------------- ## -## Cache variables. ## -## ---------------- ## -_ASBOX - echo - # The following way of writing the cache mishandles newlines in values, -( - for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5 -echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - *) $as_unset $ac_var ;; - esac ;; - esac - done - (set) 2>&1 | - case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - sed -n \ - "s/'\''/'\''\\\\'\'''\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" - ;; #( - *) - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) - echo - - cat <<\_ASBOX -## ----------------- ## -## Output variables. ## -## ----------------- ## -_ASBOX - echo - for ac_var in $ac_subst_vars - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - echo "$ac_var='\''$ac_val'\''" - done | sort - echo - - if test -n "$ac_subst_files"; then - cat <<\_ASBOX -## ------------------- ## -## File substitutions. ## -## ------------------- ## -_ASBOX - echo - for ac_var in $ac_subst_files - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - echo "$ac_var='\''$ac_val'\''" - done | sort - echo - fi - - if test -s confdefs.h; then - cat <<\_ASBOX -## ----------- ## -## confdefs.h. ## -## ----------- ## -_ASBOX - echo - cat confdefs.h - echo - fi - test "$ac_signal" != 0 && - echo "$as_me: caught signal $ac_signal" - echo "$as_me: exit $exit_status" - } >&5 - rm -f core *.core core.conftest.* && - rm -f -r conftest* confdefs* conf$$* $ac_clean_files && - exit $exit_status -' 0 -for ac_signal in 1 2 13 15; do - trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal -done -ac_signal=0 - -# confdefs.h avoids OS command line length limits that DEFS can exceed. -rm -f -r conftest* confdefs.h - -# Predefined preprocessor variables. - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_NAME "$PACKAGE_NAME" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_TARNAME "$PACKAGE_TARNAME" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_VERSION "$PACKAGE_VERSION" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_STRING "$PACKAGE_STRING" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" -_ACEOF - - -# Let the site file select an alternate cache file if it wants to. -# Prefer explicitly selected file to automatically selected ones. -if test -n "$CONFIG_SITE"; then - set x "$CONFIG_SITE" -elif test "x$prefix" != xNONE; then - set x "$prefix/share/config.site" "$prefix/etc/config.site" -else - set x "$ac_default_prefix/share/config.site" \ - "$ac_default_prefix/etc/config.site" -fi -shift -for ac_site_file -do - if test -r "$ac_site_file"; then - { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 -echo "$as_me: loading site script $ac_site_file" >&6;} - sed 's/^/| /' "$ac_site_file" >&5 - . "$ac_site_file" - fi -done - -if test -r "$cache_file"; then - # Some versions of bash will fail to source /dev/null (special - # files actually), so we avoid doing that. - if test -f "$cache_file"; then - { echo "$as_me:$LINENO: loading cache $cache_file" >&5 -echo "$as_me: loading cache $cache_file" >&6;} - case $cache_file in - [\\/]* | ?:[\\/]* ) . "$cache_file";; - *) . "./$cache_file";; - esac - fi -else - { echo "$as_me:$LINENO: creating cache $cache_file" >&5 -echo "$as_me: creating cache $cache_file" >&6;} - >$cache_file -fi - -# Check that the precious variables saved in the cache have kept the same -# value. -ac_cache_corrupted=false -for ac_var in $ac_precious_vars; do - eval ac_old_set=\$ac_cv_env_${ac_var}_set - eval ac_new_set=\$ac_env_${ac_var}_set - eval ac_old_val=\$ac_cv_env_${ac_var}_value - eval ac_new_val=\$ac_env_${ac_var}_value - case $ac_old_set,$ac_new_set in - set,) - { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 -echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,set) - { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 -echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,);; - *) - if test "x$ac_old_val" != "x$ac_new_val"; then - { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 -echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} - { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 -echo "$as_me: former value: $ac_old_val" >&2;} - { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 -echo "$as_me: current value: $ac_new_val" >&2;} - ac_cache_corrupted=: - fi;; - esac - # Pass precious variables to config.status. - if test "$ac_new_set" = set; then - case $ac_new_val in - *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; - *) ac_arg=$ac_var=$ac_new_val ;; - esac - case " $ac_configure_args " in - *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. - *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; - esac - fi -done -if $ac_cache_corrupted; then - { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 -echo "$as_me: error: changes in the environment can compromise the build" >&2;} - { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 -echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} - { (exit 1); exit 1; }; } -fi - - - - - - - - - - - - - - - - - - - - - - - - - -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - - - - -ac_config_files="$ac_config_files llvm.buildinfo" - - -ac_config_headers="$ac_config_headers include/hs_llvm_config.h" - - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -if test -z "$CXX"; then - if test -n "$CCC"; then - CXX=$CCC - else - if test -n "$ac_tool_prefix"; then - for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC - do - # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. -set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_CXX+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - if test -n "$CXX"; then - ac_cv_prog_CXX="$CXX" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - -fi -fi -CXX=$ac_cv_prog_CXX -if test -n "$CXX"; then - { echo "$as_me:$LINENO: result: $CXX" >&5 -echo "${ECHO_T}$CXX" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - - test -n "$CXX" && break - done -fi -if test -z "$CXX"; then - ac_ct_CXX=$CXX - for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - if test -n "$ac_ct_CXX"; then - ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_prog_ac_ct_CXX="$ac_prog" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - -fi -fi -ac_ct_CXX=$ac_cv_prog_ac_ct_CXX -if test -n "$ac_ct_CXX"; then - { echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5 -echo "${ECHO_T}$ac_ct_CXX" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - - test -n "$ac_ct_CXX" && break -done - - if test "x$ac_ct_CXX" = x; then - CXX="g++" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools -whose name does not start with the host triplet. If you think this -configuration is useful to you, please write to autoconf@gnu.org." >&5 -echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools -whose name does not start with the host triplet. If you think this -configuration is useful to you, please write to autoconf@gnu.org." >&2;} -ac_tool_warned=yes ;; -esac - CXX=$ac_ct_CXX - fi -fi - - fi -fi -# Provide some information about the compiler. -echo "$as_me:$LINENO: checking for C++ compiler version" >&5 -ac_compiler=`set X $ac_compile; echo $2` -{ (ac_try="$ac_compiler --version >&5" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compiler --version >&5") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } -{ (ac_try="$ac_compiler -v >&5" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compiler -v >&5") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } -{ (ac_try="$ac_compiler -V >&5" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compiler -V >&5") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } - -cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files a.out a.exe b.out" -# Try to create an executable without -o first, disregard a.out. -# It will help us diagnose broken compilers, and finding out an intuition -# of exeext. -{ echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5 -echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6; } -ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` -# -# List of possible output files, starting from the most likely. -# The algorithm is not robust to junk in `.', hence go to wildcards (a.*) -# only as a last resort. b.out is created by i960 compilers. -ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out' -# -# The IRIX 6 linker writes into existing files which may not be -# executable, retaining their permissions. Remove them first so a -# subsequent execution test works. -ac_rmfiles= -for ac_file in $ac_files -do - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;; - * ) ac_rmfiles="$ac_rmfiles $ac_file";; - esac -done -rm -f $ac_rmfiles - -if { (ac_try="$ac_link_default" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_link_default") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; then - # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. -# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' -# in a Makefile. We should not override ac_cv_exeext if it was cached, -# so that the user can short-circuit this test for compilers unknown to -# Autoconf. -for ac_file in $ac_files '' -do - test -f "$ac_file" || continue - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) - ;; - [ab].out ) - # We found the default executable, but exeext='' is most - # certainly right. - break;; - *.* ) - if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; - then :; else - ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` - fi - # We set ac_cv_exeext here because the later test for it is not - # safe: cross compilers may not add the suffix if given an `-o' - # argument, so we may need to know it at that point already. - # Even if this section looks crufty: it has the advantage of - # actually working. - break;; - * ) - break;; - esac -done -test "$ac_cv_exeext" = no && ac_cv_exeext= - -else - ac_file='' -fi - -{ echo "$as_me:$LINENO: result: $ac_file" >&5 -echo "${ECHO_T}$ac_file" >&6; } -if test -z "$ac_file"; then - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - -{ { echo "$as_me:$LINENO: error: C++ compiler cannot create executables -See \`config.log' for more details." >&5 -echo "$as_me: error: C++ compiler cannot create executables -See \`config.log' for more details." >&2;} - { (exit 77); exit 77; }; } -fi - -ac_exeext=$ac_cv_exeext - -# Check that the compiler produces executables we can run. If not, either -# the compiler is broken, or we cross compile. -{ echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5 -echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6; } -# FIXME: These cross compiler hacks should be removed for Autoconf 3.0 -# If not cross compiling, check that we can run a simple program. -if test "$cross_compiling" != yes; then - if { ac_try='./$ac_file' - { (case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; }; then - cross_compiling=no - else - if test "$cross_compiling" = maybe; then - cross_compiling=yes - else - { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs. -If you meant to cross compile, use \`--host'. -See \`config.log' for more details." >&5 -echo "$as_me: error: cannot run C++ compiled programs. -If you meant to cross compile, use \`--host'. -See \`config.log' for more details." >&2;} - { (exit 1); exit 1; }; } - fi - fi -fi -{ echo "$as_me:$LINENO: result: yes" >&5 -echo "${ECHO_T}yes" >&6; } - -rm -f a.out a.exe conftest$ac_cv_exeext b.out -ac_clean_files=$ac_clean_files_save -# Check that the compiler produces executables we can run. If not, either -# the compiler is broken, or we cross compile. -{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5 -echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; } -{ echo "$as_me:$LINENO: result: $cross_compiling" >&5 -echo "${ECHO_T}$cross_compiling" >&6; } - -{ echo "$as_me:$LINENO: checking for suffix of executables" >&5 -echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; } -if { (ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; then - # If both `conftest.exe' and `conftest' are `present' (well, observable) -# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will -# work properly (i.e., refer to `conftest.exe'), while it won't with -# `rm'. -for ac_file in conftest.exe conftest conftest.*; do - test -f "$ac_file" || continue - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;; - *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` - break;; - * ) break;; - esac -done -else - { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link -See \`config.log' for more details." >&5 -echo "$as_me: error: cannot compute suffix of executables: cannot compile and link -See \`config.log' for more details." >&2;} - { (exit 1); exit 1; }; } -fi - -rm -f conftest$ac_cv_exeext -{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5 -echo "${ECHO_T}$ac_cv_exeext" >&6; } - -rm -f conftest.$ac_ext -EXEEXT=$ac_cv_exeext -ac_exeext=$EXEEXT -{ echo "$as_me:$LINENO: checking for suffix of object files" >&5 -echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; } -if test "${ac_cv_objext+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -rm -f conftest.o conftest.obj -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; then - for ac_file in conftest.o conftest.obj conftest.*; do - test -f "$ac_file" || continue; - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;; - *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` - break;; - esac -done -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - -{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile -See \`config.log' for more details." >&5 -echo "$as_me: error: cannot compute suffix of object files: cannot compile -See \`config.log' for more details." >&2;} - { (exit 1); exit 1; }; } -fi - -rm -f conftest.$ac_cv_objext conftest.$ac_ext -fi -{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5 -echo "${ECHO_T}$ac_cv_objext" >&6; } -OBJEXT=$ac_cv_objext -ac_objext=$OBJEXT -{ echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5 -echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6; } -if test "${ac_cv_cxx_compiler_gnu+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -int -main () -{ -#ifndef __GNUC__ - choke me -#endif - - ; - return 0; -} -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - ac_compiler_gnu=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_compiler_gnu=no -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_cxx_compiler_gnu=$ac_compiler_gnu - -fi -{ echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5 -echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6; } -GXX=`test $ac_compiler_gnu = yes && echo yes` -ac_test_CXXFLAGS=${CXXFLAGS+set} -ac_save_CXXFLAGS=$CXXFLAGS -{ echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5 -echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6; } -if test "${ac_cv_prog_cxx_g+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - ac_save_cxx_werror_flag=$ac_cxx_werror_flag - ac_cxx_werror_flag=yes - ac_cv_prog_cxx_g=no - CXXFLAGS="-g" - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - ac_cv_prog_cxx_g=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - CXXFLAGS="" - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - : -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_cxx_werror_flag=$ac_save_cxx_werror_flag - CXXFLAGS="-g" - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - ac_cv_prog_cxx_g=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_cxx_werror_flag=$ac_save_cxx_werror_flag -fi -{ echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5 -echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6; } -if test "$ac_test_CXXFLAGS" = set; then - CXXFLAGS=$ac_save_CXXFLAGS -elif test $ac_cv_prog_cxx_g = yes; then - if test "$GXX" = yes; then - CXXFLAGS="-g -O2" - else - CXXFLAGS="-g" - fi -else - if test "$GXX" = yes; then - CXXFLAGS="-O2" - else - CXXFLAGS= - fi -fi -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - - -# Check whether --with-compiler was given. -if test "${with_compiler+set}" = set; then - withval=$with_compiler; compiler="$withval" -else - compiler=ghc -fi - - -# Check whether --with-llvm_prefix was given. -if test "${with_llvm_prefix+set}" = set; then - withval=$with_llvm_prefix; llvm_prefix="$withval" -else - llvm_prefix="$prefix" -fi - - -# Check whether --with-llvm_bindir was given. -if test "${with_llvm_bindir+set}" = set; then - withval=$with_llvm_bindir; llvm_bindir="$withval" -else - llvm_bindir="$llvm_prefix/bin" -fi - -for ac_prog in llvm-config -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_path_llvm_config+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - case $llvm_config in - [\\/]* | ?:[\\/]*) - ac_cv_path_llvm_config="$llvm_config" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -as_dummy=""$llvm_bindir:$PATH"" -for as_dir in $as_dummy -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_llvm_config="$as_dir/$ac_word$ac_exec_ext" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - - ;; -esac -fi -llvm_config=$ac_cv_path_llvm_config -if test -n "$llvm_config"; then - { echo "$as_me:$LINENO: result: $llvm_config" >&5 -echo "${ECHO_T}$llvm_config" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - - test -n "$llvm_config" && break -done -test -n "$llvm_config" || llvm_config="{ { echo "$as_me:$LINENO: error: could not find llvm-config in $llvm_bindir" >&5 -echo "$as_me: error: could not find llvm-config in $llvm_bindir" >&2;} - { (exit 1); exit 1; }; }" - - - - -if test "$target" = "" -then - if test "${compiler}" != "" - then - target=`${compiler} +RTS --info | grep '^ ,("Target platform"' | sed -e 's/.*, "//' -e 's/")//' | tr -d '\r'` - echo "Target platform inferred as: $target" - else - echo "Can't work out target platform" - exit 1 - fi -fi - -case $target in -i386-apple-darwin) - TARGET_CPPFLAGS="-m32" - TAGRET_LDFLAGS="-m32" - ;; -x86_64-apple-darwin) - TARGET_CPPFLAGS="-m64" - TAGRET_LDFLAGS="-m64" - ;; -esac - -llvm_version="`$llvm_config --version`" -llvm_cppflags="`$llvm_config --cppflags`" -llvm_includedir="`$llvm_config --includedir`" -llvm_ldflags="`$llvm_config --ldflags`" - -llvm_all_libs="`$llvm_config --libs all`" -llvm_target="`$llvm_config --libs engine | sed 's/.*LLVM\(.[^ ]*\)CodeGen.*/\1/'`" - -llvm_extra_libs="" -llvm_extra_libdirs="" -llvm_extra_ghci_libs="" -llvm_ldoptions="" -for opt in $llvm_all_libs $llvm_ldflags; do - case $opt in - -l*) llvm_extra_libs="$llvm_extra_libs `echo $opt | sed 's/^-l//'`";; - -L*) llvm_extra_libdirs="$llvm_extra_libdirs `echo $opt | sed 's/^-L//'`";; - */lib*.so|*/lib*.dylib) - llvm_extra_ghci_libs="$llvm_extra_ghci_libs `echo $opt | sed -e 's,^.*/lib\(^/*\),\1,' -e 's/\.so$//' -e 's/\.dylib$//'`";; - *) llvm_ldoptions="$llvm_ldoptions $opt";; - esac -done - -CPPFLAGS="$llvm_cppflags $CPPFLAGS $TARGET_CPPFLAGS" -LDFLAGS="$llvm_ldflags $LDFLAGS $TARGET_LDFLAGS" - - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -{ echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5 -echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6; } -if test -z "$CXXCPP"; then - if test "${ac_cv_prog_CXXCPP+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - # Double quotes because CXXCPP needs to be expanded - for CXXCPP in "$CXX -E" "/lib/cpp" - do - ac_preproc_ok=false -for ac_cxx_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if { (ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } >/dev/null && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - }; then - : -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - # Broken: fails on valid input. -continue -fi - -rm -f conftest.err conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include -_ACEOF -if { (ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } >/dev/null && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - }; then - # Broken: success on invalid input. -continue -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - # Passes both tests. -ac_preproc_ok=: -break -fi - -rm -f conftest.err conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.err conftest.$ac_ext -if $ac_preproc_ok; then - break -fi - - done - ac_cv_prog_CXXCPP=$CXXCPP - -fi - CXXCPP=$ac_cv_prog_CXXCPP -else - ac_cv_prog_CXXCPP=$CXXCPP -fi -{ echo "$as_me:$LINENO: result: $CXXCPP" >&5 -echo "${ECHO_T}$CXXCPP" >&6; } -ac_preproc_ok=false -for ac_cxx_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if { (ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } >/dev/null && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - }; then - : -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - # Broken: fails on valid input. -continue -fi - -rm -f conftest.err conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include -_ACEOF -if { (ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } >/dev/null && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - }; then - # Broken: success on invalid input. -continue -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - # Passes both tests. -ac_preproc_ok=: -break -fi - -rm -f conftest.err conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.err conftest.$ac_ext -if $ac_preproc_ok; then - : -else - { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check -See \`config.log' for more details." >&5 -echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check -See \`config.log' for more details." >&2;} - { (exit 1); exit 1; }; } -fi - -ac_ext=cpp -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - - -{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5 -echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; } -if test "${ac_cv_path_GREP+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - # Extract the first word of "grep ggrep" to use in msg output -if test -z "$GREP"; then -set dummy grep ggrep; ac_prog_name=$2 -if test "${ac_cv_path_GREP+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - ac_path_GREP_found=false -# Loop through the user's path and test for each of PROGNAME-LIST -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in grep ggrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue - # Check for GNU ac_path_GREP and select it if it is found. - # Check for GNU $ac_path_GREP -case `"$ac_path_GREP" --version 2>&1` in -*GNU*) - ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; -*) - ac_count=0 - echo $ECHO_N "0123456789$ECHO_C" >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - echo 'GREP' >> "conftest.nl" - "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - ac_count=`expr $ac_count + 1` - if test $ac_count -gt ${ac_path_GREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_GREP="$ac_path_GREP" - ac_path_GREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - - $ac_path_GREP_found && break 3 - done -done - -done -IFS=$as_save_IFS - - -fi - -GREP="$ac_cv_path_GREP" -if test -z "$GREP"; then - { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5 -echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;} - { (exit 1); exit 1; }; } -fi - -else - ac_cv_path_GREP=$GREP -fi - - -fi -{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5 -echo "${ECHO_T}$ac_cv_path_GREP" >&6; } - GREP="$ac_cv_path_GREP" - - -{ echo "$as_me:$LINENO: checking for egrep" >&5 -echo $ECHO_N "checking for egrep... $ECHO_C" >&6; } -if test "${ac_cv_path_EGREP+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 - then ac_cv_path_EGREP="$GREP -E" - else - # Extract the first word of "egrep" to use in msg output -if test -z "$EGREP"; then -set dummy egrep; ac_prog_name=$2 -if test "${ac_cv_path_EGREP+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - ac_path_EGREP_found=false -# Loop through the user's path and test for each of PROGNAME-LIST -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in egrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" - { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue - # Check for GNU ac_path_EGREP and select it if it is found. - # Check for GNU $ac_path_EGREP -case `"$ac_path_EGREP" --version 2>&1` in -*GNU*) - ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; -*) - ac_count=0 - echo $ECHO_N "0123456789$ECHO_C" >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - echo 'EGREP' >> "conftest.nl" - "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - ac_count=`expr $ac_count + 1` - if test $ac_count -gt ${ac_path_EGREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_EGREP="$ac_path_EGREP" - ac_path_EGREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - - $ac_path_EGREP_found && break 3 - done -done - -done -IFS=$as_save_IFS - - -fi - -EGREP="$ac_cv_path_EGREP" -if test -z "$EGREP"; then - { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5 -echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;} - { (exit 1); exit 1; }; } -fi - -else - ac_cv_path_EGREP=$EGREP -fi - - - fi -fi -{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5 -echo "${ECHO_T}$ac_cv_path_EGREP" >&6; } - EGREP="$ac_cv_path_EGREP" - - -{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5 -echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; } -if test "${ac_cv_header_stdc+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include -#include -#include -#include - -int -main () -{ - - ; - return 0; -} -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - ac_cv_header_stdc=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_cv_header_stdc=no -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - -if test $ac_cv_header_stdc = yes; then - # SunOS 4.x string.h does not declare mem*, contrary to ANSI. - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include - -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "memchr" >/dev/null 2>&1; then - : -else - ac_cv_header_stdc=no -fi -rm -f -r conftest* - -fi - -if test $ac_cv_header_stdc = yes; then - # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include - -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "free" >/dev/null 2>&1; then - : -else - ac_cv_header_stdc=no -fi -rm -f -r conftest* - -fi - -if test $ac_cv_header_stdc = yes; then - # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. - if test "$cross_compiling" = yes; then - : -else - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include -#include -#if ((' ' & 0x0FF) == 0x020) -# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') -# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) -#else -# define ISLOWER(c) \ - (('a' <= (c) && (c) <= 'i') \ - || ('j' <= (c) && (c) <= 'r') \ - || ('s' <= (c) && (c) <= 'z')) -# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) -#endif - -#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) -int -main () -{ - int i; - for (i = 0; i < 256; i++) - if (XOR (islower (i), ISLOWER (i)) - || toupper (i) != TOUPPER (i)) - return 2; - return 0; -} -_ACEOF -rm -f conftest$ac_exeext -if { (ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { ac_try='./conftest$ac_exeext' - { (case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; }; then - : -else - echo "$as_me: program exited with status $ac_status" >&5 -echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - -( exit $ac_status ) -ac_cv_header_stdc=no -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext -fi - - -fi -fi -{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5 -echo "${ECHO_T}$ac_cv_header_stdc" >&6; } -if test $ac_cv_header_stdc = yes; then - -cat >>confdefs.h <<\_ACEOF -#define STDC_HEADERS 1 -_ACEOF - -fi - -# On IRIX 5.3, sys/types and inttypes.h are conflicting. - - - - - - - - - -for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ - inttypes.h stdint.h unistd.h -do -as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` -{ echo "$as_me:$LINENO: checking for $ac_header" >&5 -echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } -if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -$ac_includes_default - -#include <$ac_header> -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - eval "$as_ac_Header=yes" -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - eval "$as_ac_Header=no" -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -ac_res=`eval echo '${'$as_ac_Header'}'` - { echo "$as_me:$LINENO: result: $ac_res" >&5 -echo "${ECHO_T}$ac_res" >&6; } -if test `eval echo '${'$as_ac_Header'}'` = yes; then - cat >>confdefs.h <<_ACEOF -#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF - -fi - -done - - - -for ac_header in llvm-c/Core.h -do -as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` -if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then - { echo "$as_me:$LINENO: checking for $ac_header" >&5 -echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } -if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -fi -ac_res=`eval echo '${'$as_ac_Header'}'` - { echo "$as_me:$LINENO: result: $ac_res" >&5 -echo "${ECHO_T}$ac_res" >&6; } -else - # Is the header compilable? -{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 -echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } -cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -$ac_includes_default -#include <$ac_header> -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - ac_header_compiler=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_header_compiler=no -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 -echo "${ECHO_T}$ac_header_compiler" >&6; } - -# Is the header present? -{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 -echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } -cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include <$ac_header> -_ACEOF -if { (ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } >/dev/null && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - }; then - ac_header_preproc=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_header_preproc=no -fi - -rm -f conftest.err conftest.$ac_ext -{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 -echo "${ECHO_T}$ac_header_preproc" >&6; } - -# So? What about this header? -case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in - yes:no: ) - { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 -echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 -echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} - ac_header_preproc=yes - ;; - no:yes:* ) - { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 -echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 -echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 -echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 -echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 -echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 -echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} - ( cat <<\_ASBOX -## --------------------------------- ## -## Report this to bos@serpentine.com ## -## --------------------------------- ## -_ASBOX - ) | sed "s/^/$as_me: WARNING: /" >&2 - ;; -esac -{ echo "$as_me:$LINENO: checking for $ac_header" >&5 -echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } -if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - eval "$as_ac_Header=\$ac_header_preproc" -fi -ac_res=`eval echo '${'$as_ac_Header'}'` - { echo "$as_me:$LINENO: result: $ac_res" >&5 -echo "${ECHO_T}$ac_res" >&6; } - -fi -if test `eval echo '${'$as_ac_Header'}'` = yes; then - cat >>confdefs.h <<_ACEOF -#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF - -else - { { echo "$as_me:$LINENO: error: could not find LLVM C bindings" >&5 -echo "$as_me: error: could not find LLVM C bindings" >&2;} - { (exit 1); exit 1; }; } -fi - -done - - - -for ac_header in llvm/Support/DynamicLibrary.h -do -as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` -if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then - { echo "$as_me:$LINENO: checking for $ac_header" >&5 -echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } -if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -fi -ac_res=`eval echo '${'$as_ac_Header'}'` - { echo "$as_me:$LINENO: result: $ac_res" >&5 -echo "${ECHO_T}$ac_res" >&6; } -else - # Is the header compilable? -{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 -echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } -cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -$ac_includes_default -#include <$ac_header> -_ACEOF -rm -f conftest.$ac_objext -if { (ac_try="$ac_compile" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_compile") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest.$ac_objext; then - ac_header_compiler=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_header_compiler=no -fi - -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 -echo "${ECHO_T}$ac_header_compiler" >&6; } - -# Is the header present? -{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 -echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } -cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ -#include <$ac_header> -_ACEOF -if { (ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } >/dev/null && { - test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || - test ! -s conftest.err - }; then - ac_header_preproc=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_header_preproc=no -fi - -rm -f conftest.err conftest.$ac_ext -{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 -echo "${ECHO_T}$ac_header_preproc" >&6; } - -# So? What about this header? -case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in - yes:no: ) - { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 -echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 -echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} - ac_header_preproc=yes - ;; - no:yes:* ) - { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 -echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 -echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 -echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 -echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 -echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} - { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 -echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} - ( cat <<\_ASBOX -## --------------------------------- ## -## Report this to bos@serpentine.com ## -## --------------------------------- ## -_ASBOX - ) | sed "s/^/$as_me: WARNING: /" >&2 - ;; -esac -{ echo "$as_me:$LINENO: checking for $ac_header" >&5 -echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } -if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - eval "$as_ac_Header=\$ac_header_preproc" -fi -ac_res=`eval echo '${'$as_ac_Header'}'` - { echo "$as_me:$LINENO: result: $ac_res" >&5 -echo "${ECHO_T}$ac_res" >&6; } - -fi -if test `eval echo '${'$as_ac_Header'}'` = yes; then - cat >>confdefs.h <<_ACEOF -#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF - -fi - -done - - -save_LIBS="$LIBS" -LIBS="-lLLVMSupport -lLLVMSystem -lpthread -ldl $LIBS" - - -{ echo "$as_me:$LINENO: checking for LLVMModuleCreateWithName in -lLLVMCore" >&5 -echo $ECHO_N "checking for LLVMModuleCreateWithName in -lLLVMCore... $ECHO_C" >&6; } -if test "${ac_cv_lib_LLVMCore_LLVMModuleCreateWithName+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lLLVMCore $LIBS" -cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char LLVMModuleCreateWithName (); -int -main () -{ -return LLVMModuleCreateWithName (); - ; - return 0; -} -_ACEOF -rm -f conftest.$ac_objext conftest$ac_exeext -if { (ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_link") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest$ac_exeext && - $as_test_x conftest$ac_exeext; then - ac_cv_lib_LLVMCore_LLVMModuleCreateWithName=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_cv_lib_LLVMCore_LLVMModuleCreateWithName=no -fi - -rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ echo "$as_me:$LINENO: result: $ac_cv_lib_LLVMCore_LLVMModuleCreateWithName" >&5 -echo "${ECHO_T}$ac_cv_lib_LLVMCore_LLVMModuleCreateWithName" >&6; } -if test $ac_cv_lib_LLVMCore_LLVMModuleCreateWithName = yes; then - cat >>confdefs.h <<_ACEOF -#define HAVE_LIBLLVMCORE 1 -_ACEOF - - LIBS="-lLLVMCore $LIBS" - -fi - -if test "$ac_cv_lib_LLVMCore_LLVMModuleCreateWithName" = "no"; then - unset ac_cv_lib_LLVMCore_LLVMModuleCreateWithName - LIBS="-lLLVMSupport $save_LIBS" - -{ echo "$as_me:$LINENO: checking for LLVMModuleCreateWithName in -lLLVMCore" >&5 -echo $ECHO_N "checking for LLVMModuleCreateWithName in -lLLVMCore... $ECHO_C" >&6; } -if test "${ac_cv_lib_LLVMCore_LLVMModuleCreateWithName+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lLLVMCore $LIBS" -cat >conftest.$ac_ext <<_ACEOF -/* confdefs.h. */ -_ACEOF -cat confdefs.h >>conftest.$ac_ext -cat >>conftest.$ac_ext <<_ACEOF -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char LLVMModuleCreateWithName (); -int -main () -{ -return LLVMModuleCreateWithName (); - ; - return 0; -} -_ACEOF -rm -f conftest.$ac_objext conftest$ac_exeext -if { (ac_try="$ac_link" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 - (eval "$ac_link") 2>conftest.er1 - ac_status=$? - grep -v '^ *+' conftest.er1 >conftest.err - rm -f conftest.er1 - cat conftest.err >&5 - echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); } && { - test -z "$ac_cxx_werror_flag" || - test ! -s conftest.err - } && test -s conftest$ac_exeext && - $as_test_x conftest$ac_exeext; then - ac_cv_lib_LLVMCore_LLVMModuleCreateWithName=yes -else - echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_cv_lib_LLVMCore_LLVMModuleCreateWithName=no -fi - -rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ echo "$as_me:$LINENO: result: $ac_cv_lib_LLVMCore_LLVMModuleCreateWithName" >&5 -echo "${ECHO_T}$ac_cv_lib_LLVMCore_LLVMModuleCreateWithName" >&6; } -if test $ac_cv_lib_LLVMCore_LLVMModuleCreateWithName = yes; then - cat >>confdefs.h <<_ACEOF -#define HAVE_LIBLLVMCORE 1 -_ACEOF - - LIBS="-lLLVMCore $LIBS" - -else - { { echo "$as_me:$LINENO: error: could not find LLVM C bindings" >&5 -echo "$as_me: error: could not find LLVM C bindings" >&2;} - { (exit 1); exit 1; }; } -fi - -fi - - - - - - - - - - -cat >confcache <<\_ACEOF -# This file is a shell script that caches the results of configure -# tests run on this system so they can be shared between configure -# scripts and configure runs, see configure's option --config-cache. -# It is not useful on other systems. If it contains results you don't -# want to keep, you may remove or edit it. -# -# config.status only pays attention to the cache file if you give it -# the --recheck option to rerun configure. -# -# `ac_cv_env_foo' variables (set or unset) will be overridden when -# loading this file, other *unset* `ac_cv_foo' will be assigned the -# following values. - -_ACEOF - -# The following way of writing the cache mishandles newlines in values, -# but we know of no workaround that is simple, portable, and efficient. -# So, we kill variables containing newlines. -# Ultrix sh set writes to stderr and can't be redirected directly, -# and sets the high bit in the cache file unless we assign to the vars. -( - for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5 -echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - *) $as_unset $ac_var ;; - esac ;; - esac - done - - (set) 2>&1 | - case $as_nl`(ac_space=' '; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - # `set' does not quote correctly, so add quotes (double-quote - # substitution turns \\\\ into \\, and sed turns \\ into \). - sed -n \ - "s/'/'\\\\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" - ;; #( - *) - # `set' quotes correctly as required by POSIX, so do not add quotes. - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) | - sed ' - /^ac_cv_env_/b end - t clear - :clear - s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ - t end - s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ - :end' >>confcache -if diff "$cache_file" confcache >/dev/null 2>&1; then :; else - if test -w "$cache_file"; then - test "x$cache_file" != "x/dev/null" && - { echo "$as_me:$LINENO: updating cache $cache_file" >&5 -echo "$as_me: updating cache $cache_file" >&6;} - cat confcache >$cache_file - else - { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5 -echo "$as_me: not updating unwritable cache $cache_file" >&6;} - fi -fi -rm -f confcache - -test "x$prefix" = xNONE && prefix=$ac_default_prefix -# Let make expand exec_prefix. -test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' - -DEFS=-DHAVE_CONFIG_H - -ac_libobjs= -ac_ltlibobjs= -for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue - # 1. Remove the extension, and $U if already installed. - ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' - ac_i=`echo "$ac_i" | sed "$ac_script"` - # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR - # will be set to the directory where LIBOBJS objects are built. - ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext" - ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo' -done -LIBOBJS=$ac_libobjs - -LTLIBOBJS=$ac_ltlibobjs - - - -: ${CONFIG_STATUS=./config.status} -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 -echo "$as_me: creating $CONFIG_STATUS" >&6;} -cat >$CONFIG_STATUS <<_ACEOF -#! $SHELL -# Generated by $as_me. -# Run this file to recreate the current configuration. -# Compiler output produced by configure, useful for debugging -# configure, is in config.log if it exists. - -debug=false -ac_cs_recheck=false -ac_cs_silent=false -SHELL=\${CONFIG_SHELL-$SHELL} -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -## --------------------- ## -## M4sh Initialization. ## -## --------------------- ## - -# Be more Bourne compatible -DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - - - -# PATH needs CR -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - echo "#! /bin/sh" >conf$$.sh - echo "exit 0" >>conf$$.sh - chmod +x conf$$.sh - if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then - PATH_SEPARATOR=';' - else - PATH_SEPARATOR=: - fi - rm -f conf$$.sh -fi - -# Support unset when possible. -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then - as_unset=unset -else - as_unset=false -fi - - -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -as_nl=' -' -IFS=" "" $as_nl" - -# Find who we are. Look in the path if we contain no directory separator. -case $0 in - *[\\/]* ) as_myself=$0 ;; - *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break -done -IFS=$as_save_IFS - - ;; -esac -# We did not find ourselves, most probably we were run as `sh COMMAND' -# in which case we are not to be found in the path. -if test "x$as_myself" = x; then - as_myself=$0 -fi -if test ! -f "$as_myself"; then - echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - { (exit 1); exit 1; } -fi - -# Work around bugs in pre-3.0 UWIN ksh. -for as_var in ENV MAIL MAILPATH -do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -for as_var in \ - LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ - LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ - LC_TELEPHONE LC_TIME -do - if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then - eval $as_var=C; export $as_var - else - ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - fi -done - -# Required to use basename. -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then - as_basename=basename -else - as_basename=false -fi - - -# Name of the executable. -as_me=`$as_basename -- "$0" || -$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X/"$0" | - sed '/^.*\/\([^/][^/]*\)\/*$/{ - s//\1/ - q - } - /^X\/\(\/\/\)$/{ - s//\1/ - q - } - /^X\/\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - -# CDPATH. -$as_unset CDPATH - - - - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { - - # Create $as_me.lineno as a copy of $as_myself, but with $LINENO - # uniformly replaced by the line number. The first 'sed' inserts a - # line-number line after each line using $LINENO; the second 'sed' - # does the real work. The second script uses 'N' to pair each - # line-number line with the line containing $LINENO, and appends - # trailing '-' during substitution so that $LINENO is not a special - # case at line end. - # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the - # scripts with optimization help from Paolo Bonzini. Blame Lee - # E. McMahon (1931-1989) for sed's syntax. :-) - sed -n ' - p - /[$]LINENO/= - ' <$as_myself | - sed ' - s/[$]LINENO.*/&-/ - t lineno - b - :lineno - N - :loop - s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ - t loop - s/-\n.*// - ' >$as_me.lineno && - chmod +x "$as_me.lineno" || - { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 - { (exit 1); exit 1; }; } - - # Don't try to exec as it changes $[0], causing all sort of problems - # (the dirname of $[0] is not the place where we might find the - # original and so on. Autoconf is especially sensitive to this). - . "./$as_me.lineno" - # Exit status is that of the last command. - exit -} - - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi - -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in --n*) - case `echo 'x\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - *) ECHO_C='\c';; - esac;; -*) - ECHO_N='-n';; -esac - -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -rm -f conf$$ conf$$.exe conf$$.file -if test -d conf$$.dir; then - rm -f conf$$.dir/conf$$.file -else - rm -f conf$$.dir - mkdir conf$$.dir -fi -echo >conf$$.file -if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' -elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln -else - as_ln_s='cp -p' -fi -rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file -rmdir conf$$.dir 2>/dev/null - -if mkdir -p . 2>/dev/null; then - as_mkdir_p=: -else - test -d ./-p && rmdir ./-p - as_mkdir_p=false -fi - -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x - -# Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" - -# Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" - - -exec 6>&1 - -# Save the log message, to keep $[0] and so on meaningful, and to -# report actual input values of CONFIG_FILES etc. instead of their -# values after options handling. -ac_log=" -This file was extended by Haskell LLVM bindings $as_me 0.9.1.2, which was -generated by GNU Autoconf 2.61. Invocation command line was - - CONFIG_FILES = $CONFIG_FILES - CONFIG_HEADERS = $CONFIG_HEADERS - CONFIG_LINKS = $CONFIG_LINKS - CONFIG_COMMANDS = $CONFIG_COMMANDS - $ $0 $@ - -on `(hostname || uname -n) 2>/dev/null | sed 1q` -" - -_ACEOF - -cat >>$CONFIG_STATUS <<_ACEOF -# Files that config.status was made for. -config_files="$ac_config_files" -config_headers="$ac_config_headers" - -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -ac_cs_usage="\ -\`$as_me' instantiates files from templates according to the -current configuration. - -Usage: $0 [OPTIONS] [FILE]... - - -h, --help print this help, then exit - -V, --version print version number and configuration settings, then exit - -q, --quiet do not print progress messages - -d, --debug don't remove temporary files - --recheck update $as_me by reconfiguring in the same conditions - --file=FILE[:TEMPLATE] - instantiate the configuration file FILE - --header=FILE[:TEMPLATE] - instantiate the configuration header FILE - -Configuration files: -$config_files - -Configuration headers: -$config_headers - -Report bugs to ." - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF -ac_cs_version="\\ -Haskell LLVM bindings config.status 0.9.1.2 -configured by $0, generated by GNU Autoconf 2.61, - with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\" - -Copyright (C) 2006 Free Software Foundation, Inc. -This config.status script is free software; the Free Software Foundation -gives unlimited permission to copy, distribute and modify it." - -ac_pwd='$ac_pwd' -srcdir='$srcdir' -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -# If no file are specified by the user, then we need to provide default -# value. By we need to know if files were specified by the user. -ac_need_defaults=: -while test $# != 0 -do - case $1 in - --*=*) - ac_option=`expr "X$1" : 'X\([^=]*\)='` - ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` - ac_shift=: - ;; - *) - ac_option=$1 - ac_optarg=$2 - ac_shift=shift - ;; - esac - - case $ac_option in - # Handling of the options. - -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) - ac_cs_recheck=: ;; - --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - echo "$ac_cs_version"; exit ;; - --debug | --debu | --deb | --de | --d | -d ) - debug=: ;; - --file | --fil | --fi | --f ) - $ac_shift - CONFIG_FILES="$CONFIG_FILES $ac_optarg" - ac_need_defaults=false;; - --header | --heade | --head | --hea ) - $ac_shift - CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg" - ac_need_defaults=false;; - --he | --h) - # Conflict between --help and --header - { echo "$as_me: error: ambiguous option: $1 -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; };; - --help | --hel | -h ) - echo "$ac_cs_usage"; exit ;; - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil | --si | --s) - ac_cs_silent=: ;; - - # This is an error. - -*) { echo "$as_me: error: unrecognized option: $1 -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; } ;; - - *) ac_config_targets="$ac_config_targets $1" - ac_need_defaults=false ;; - - esac - shift -done - -ac_configure_extra_args= - -if $ac_cs_silent; then - exec 6>/dev/null - ac_configure_extra_args="$ac_configure_extra_args --silent" -fi - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF -if \$ac_cs_recheck; then - echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6 - CONFIG_SHELL=$SHELL - export CONFIG_SHELL - exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion -fi - -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF -exec 5>>config.log -{ - echo - sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX -## Running $as_me. ## -_ASBOX - echo "$ac_log" -} >&5 - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF - -# Handling of arguments. -for ac_config_target in $ac_config_targets -do - case $ac_config_target in - "llvm.buildinfo") CONFIG_FILES="$CONFIG_FILES llvm.buildinfo" ;; - "include/hs_llvm_config.h") CONFIG_HEADERS="$CONFIG_HEADERS include/hs_llvm_config.h" ;; - - *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 -echo "$as_me: error: invalid argument: $ac_config_target" >&2;} - { (exit 1); exit 1; }; };; - esac -done - - -# If the user did not use the arguments to specify the items to instantiate, -# then the envvar interface is used. Set only those that are not. -# We use the long form for the default assignment because of an extremely -# bizarre bug on SunOS 4.1.3. -if $ac_need_defaults; then - test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files - test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers -fi - -# Have a temporary directory for convenience. Make it in the build tree -# simply because there is no reason against having it here, and in addition, -# creating and moving files from /tmp can sometimes cause problems. -# Hook for its removal unless debugging. -# Note that there is a small window in which the directory will not be cleaned: -# after its creation but before its name has been assigned to `$tmp'. -$debug || -{ - tmp= - trap 'exit_status=$? - { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status -' 0 - trap '{ (exit 1); exit 1; }' 1 2 13 15 -} -# Create a (secure) tmp directory for tmp files. - -{ - tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && - test -n "$tmp" && test -d "$tmp" -} || -{ - tmp=./conf$$-$RANDOM - (umask 077 && mkdir "$tmp") -} || -{ - echo "$me: cannot create a temporary directory in ." >&2 - { (exit 1); exit 1; } -} - -# -# Set up the sed scripts for CONFIG_FILES section. -# - -# No need to generate the scripts if there are no CONFIG_FILES. -# This happens for instance when ./config.status config.h -if test -n "$CONFIG_FILES"; then - -_ACEOF - - - -ac_delim='%!_!# ' -for ac_last_try in false false false false false :; do - cat >conf$$subs.sed <<_ACEOF -SHELL!$SHELL$ac_delim -PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim -PACKAGE_NAME!$PACKAGE_NAME$ac_delim -PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim -PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim -PACKAGE_STRING!$PACKAGE_STRING$ac_delim -PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim -exec_prefix!$exec_prefix$ac_delim -prefix!$prefix$ac_delim -program_transform_name!$program_transform_name$ac_delim -bindir!$bindir$ac_delim -sbindir!$sbindir$ac_delim -libexecdir!$libexecdir$ac_delim -datarootdir!$datarootdir$ac_delim -datadir!$datadir$ac_delim -sysconfdir!$sysconfdir$ac_delim -sharedstatedir!$sharedstatedir$ac_delim -localstatedir!$localstatedir$ac_delim -includedir!$includedir$ac_delim -oldincludedir!$oldincludedir$ac_delim -docdir!$docdir$ac_delim -infodir!$infodir$ac_delim -htmldir!$htmldir$ac_delim -dvidir!$dvidir$ac_delim -pdfdir!$pdfdir$ac_delim -psdir!$psdir$ac_delim -libdir!$libdir$ac_delim -localedir!$localedir$ac_delim -mandir!$mandir$ac_delim -DEFS!$DEFS$ac_delim -ECHO_C!$ECHO_C$ac_delim -ECHO_N!$ECHO_N$ac_delim -ECHO_T!$ECHO_T$ac_delim -LIBS!$LIBS$ac_delim -build_alias!$build_alias$ac_delim -host_alias!$host_alias$ac_delim -target_alias!$target_alias$ac_delim -CXX!$CXX$ac_delim -CXXFLAGS!$CXXFLAGS$ac_delim -LDFLAGS!$LDFLAGS$ac_delim -CPPFLAGS!$CPPFLAGS$ac_delim -ac_ct_CXX!$ac_ct_CXX$ac_delim -EXEEXT!$EXEEXT$ac_delim -OBJEXT!$OBJEXT$ac_delim -llvm_config!$llvm_config$ac_delim -CXXCPP!$CXXCPP$ac_delim -GREP!$GREP$ac_delim -EGREP!$EGREP$ac_delim -llvm_version!$llvm_version$ac_delim -llvm_cppflags!$llvm_cppflags$ac_delim -llvm_extra_libs!$llvm_extra_libs$ac_delim -llvm_extra_libdirs!$llvm_extra_libdirs$ac_delim -llvm_extra_ghci_libs!$llvm_extra_ghci_libs$ac_delim -llvm_target!$llvm_target$ac_delim -llvm_includedir!$llvm_includedir$ac_delim -llvm_ldoptions!$llvm_ldoptions$ac_delim -LIBOBJS!$LIBOBJS$ac_delim -LTLIBOBJS!$LTLIBOBJS$ac_delim -_ACEOF - - if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 58; then - break - elif $ac_last_try; then - { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 -echo "$as_me: error: could not make $CONFIG_STATUS" >&2;} - { (exit 1); exit 1; }; } - else - ac_delim="$ac_delim!$ac_delim _$ac_delim!! " - fi -done - -ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed` -if test -n "$ac_eof"; then - ac_eof=`echo "$ac_eof" | sort -nru | sed 1q` - ac_eof=`expr $ac_eof + 1` -fi - -cat >>$CONFIG_STATUS <<_ACEOF -cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof -/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end -_ACEOF -sed ' -s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g -s/^/s,@/; s/!/@,|#_!!_#|/ -:n -t n -s/'"$ac_delim"'$/,g/; t -s/$/\\/; p -N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n -' >>$CONFIG_STATUS >$CONFIG_STATUS <<_ACEOF -:end -s/|#_!!_#|//g -CEOF$ac_eof -_ACEOF - - -# VPATH may cause trouble with some makes, so we remove $(srcdir), -# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and -# trailing colons and then remove the whole line if VPATH becomes empty -# (actually we leave an empty line to preserve line numbers). -if test "x$srcdir" = x.; then - ac_vpsub='/^[ ]*VPATH[ ]*=/{ -s/:*\$(srcdir):*/:/ -s/:*\${srcdir}:*/:/ -s/:*@srcdir@:*/:/ -s/^\([^=]*=[ ]*\):*/\1/ -s/:*$// -s/^[^=]*=[ ]*$// -}' -fi - -cat >>$CONFIG_STATUS <<\_ACEOF -fi # test -n "$CONFIG_FILES" - - -for ac_tag in :F $CONFIG_FILES :H $CONFIG_HEADERS -do - case $ac_tag in - :[FHLC]) ac_mode=$ac_tag; continue;; - esac - case $ac_mode$ac_tag in - :[FHL]*:*);; - :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5 -echo "$as_me: error: Invalid tag $ac_tag." >&2;} - { (exit 1); exit 1; }; };; - :[FH]-) ac_tag=-:-;; - :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; - esac - ac_save_IFS=$IFS - IFS=: - set x $ac_tag - IFS=$ac_save_IFS - shift - ac_file=$1 - shift - - case $ac_mode in - :L) ac_source=$1;; - :[FH]) - ac_file_inputs= - for ac_f - do - case $ac_f in - -) ac_f="$tmp/stdin";; - *) # Look for the file first in the build tree, then in the source tree - # (if the path is not absolute). The absolute path cannot be DOS-style, - # because $ac_f cannot contain `:'. - test -f "$ac_f" || - case $ac_f in - [\\/$]*) false;; - *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; - esac || - { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5 -echo "$as_me: error: cannot find input file: $ac_f" >&2;} - { (exit 1); exit 1; }; };; - esac - ac_file_inputs="$ac_file_inputs $ac_f" - done - - # Let's still pretend it is `configure' which instantiates (i.e., don't - # use $as_me), people would be surprised to read: - # /* config.h. Generated by config.status. */ - configure_input="Generated from "`IFS=: - echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure." - if test x"$ac_file" != x-; then - configure_input="$ac_file. $configure_input" - { echo "$as_me:$LINENO: creating $ac_file" >&5 -echo "$as_me: creating $ac_file" >&6;} - fi - - case $ac_tag in - *:-:* | *:-) cat >"$tmp/stdin";; - esac - ;; - esac - - ac_dir=`$as_dirname -- "$ac_file" || -$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$ac_file" : 'X\(//\)[^/]' \| \ - X"$ac_file" : 'X\(//\)$' \| \ - X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -echo X"$ac_file" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - { as_dir="$ac_dir" - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -echo X"$as_dir" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5 -echo "$as_me: error: cannot create directory $as_dir" >&2;} - { (exit 1); exit 1; }; }; } - ac_builddir=. - -case "$ac_dir" in -.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; -*) - ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` - # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'` - case $ac_top_builddir_sub in - "") ac_top_builddir_sub=. ac_top_build_prefix= ;; - *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; - esac ;; -esac -ac_abs_top_builddir=$ac_pwd -ac_abs_builddir=$ac_pwd$ac_dir_suffix -# for backward compatibility: -ac_top_builddir=$ac_top_build_prefix - -case $srcdir in - .) # We are building in place. - ac_srcdir=. - ac_top_srcdir=$ac_top_builddir_sub - ac_abs_top_srcdir=$ac_pwd ;; - [\\/]* | ?:[\\/]* ) # Absolute name. - ac_srcdir=$srcdir$ac_dir_suffix; - ac_top_srcdir=$srcdir - ac_abs_top_srcdir=$srcdir ;; - *) # Relative name. - ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix - ac_top_srcdir=$ac_top_build_prefix$srcdir - ac_abs_top_srcdir=$ac_pwd/$srcdir ;; -esac -ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix - - - case $ac_mode in - :F) - # - # CONFIG_FILE - # - -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -# If the template does not know about datarootdir, expand it. -# FIXME: This hack should be removed a few years after 2.60. -ac_datarootdir_hack=; ac_datarootdir_seen= - -case `sed -n '/datarootdir/ { - p - q -} -/@datadir@/p -/@docdir@/p -/@infodir@/p -/@localedir@/p -/@mandir@/p -' $ac_file_inputs` in -*datarootdir*) ac_datarootdir_seen=yes;; -*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF - ac_datarootdir_hack=' - s&@datadir@&$datadir&g - s&@docdir@&$docdir&g - s&@infodir@&$infodir&g - s&@localedir@&$localedir&g - s&@mandir@&$mandir&g - s&\\\${datarootdir}&$datarootdir&g' ;; -esac -_ACEOF - -# Neutralize VPATH when `$srcdir' = `.'. -# Shell code in configure.ac might set extrasub. -# FIXME: do we really want to maintain this feature? -cat >>$CONFIG_STATUS <<_ACEOF - sed "$ac_vpsub -$extrasub -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF -:t -/@[a-zA-Z_][a-zA-Z_0-9]*@/!b -s&@configure_input@&$configure_input&;t t -s&@top_builddir@&$ac_top_builddir_sub&;t t -s&@srcdir@&$ac_srcdir&;t t -s&@abs_srcdir@&$ac_abs_srcdir&;t t -s&@top_srcdir@&$ac_top_srcdir&;t t -s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t -s&@builddir@&$ac_builddir&;t t -s&@abs_builddir@&$ac_abs_builddir&;t t -s&@abs_top_builddir@&$ac_abs_top_builddir&;t t -$ac_datarootdir_hack -" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out - -test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && - { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && - { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && - { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir' -which seems to be undefined. Please make sure it is defined." >&5 -echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' -which seems to be undefined. Please make sure it is defined." >&2;} - - rm -f "$tmp/stdin" - case $ac_file in - -) cat "$tmp/out"; rm -f "$tmp/out";; - *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;; - esac - ;; - :H) - # - # CONFIG_HEADER - # -_ACEOF - -# Transform confdefs.h into a sed script `conftest.defines', that -# substitutes the proper values into config.h.in to produce config.h. -rm -f conftest.defines conftest.tail -# First, append a space to every undef/define line, to ease matching. -echo 's/$/ /' >conftest.defines -# Then, protect against being on the right side of a sed subst, or in -# an unquoted here document, in config.status. If some macros were -# called several times there might be several #defines for the same -# symbol, which is useless. But do not sort them, since the last -# AC_DEFINE must be honored. -ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* -# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where -# NAME is the cpp macro being defined, VALUE is the value it is being given. -# PARAMS is the parameter list in the macro definition--in most cases, it's -# just an empty string. -ac_dA='s,^\\([ #]*\\)[^ ]*\\([ ]*' -ac_dB='\\)[ (].*,\\1define\\2' -ac_dC=' ' -ac_dD=' ,' - -uniq confdefs.h | - sed -n ' - t rset - :rset - s/^[ ]*#[ ]*define[ ][ ]*// - t ok - d - :ok - s/[\\&,]/\\&/g - s/^\('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p - s/^\('"$ac_word_re"'\)[ ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p - ' >>conftest.defines - -# Remove the space that was appended to ease matching. -# Then replace #undef with comments. This is necessary, for -# example, in the case of _POSIX_SOURCE, which is predefined and required -# on some systems where configure will not decide to define it. -# (The regexp can be short, since the line contains either #define or #undef.) -echo 's/ $// -s,^[ #]*u.*,/* & */,' >>conftest.defines - -# Break up conftest.defines: -ac_max_sed_lines=50 - -# First sed command is: sed -f defines.sed $ac_file_inputs >"$tmp/out1" -# Second one is: sed -f defines.sed "$tmp/out1" >"$tmp/out2" -# Third one will be: sed -f defines.sed "$tmp/out2" >"$tmp/out1" -# et cetera. -ac_in='$ac_file_inputs' -ac_out='"$tmp/out1"' -ac_nxt='"$tmp/out2"' - -while : -do - # Write a here document: - cat >>$CONFIG_STATUS <<_ACEOF - # First, check the format of the line: - cat >"\$tmp/defines.sed" <<\\CEOF -/^[ ]*#[ ]*undef[ ][ ]*$ac_word_re[ ]*\$/b def -/^[ ]*#[ ]*define[ ][ ]*$ac_word_re[( ]/b def -b -:def -_ACEOF - sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS - echo 'CEOF - sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS - ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in - sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail - grep . conftest.tail >/dev/null || break - rm -f conftest.defines - mv conftest.tail conftest.defines -done -rm -f conftest.defines conftest.tail - -echo "ac_result=$ac_in" >>$CONFIG_STATUS -cat >>$CONFIG_STATUS <<\_ACEOF - if test x"$ac_file" != x-; then - echo "/* $configure_input */" >"$tmp/config.h" - cat "$ac_result" >>"$tmp/config.h" - if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then - { echo "$as_me:$LINENO: $ac_file is unchanged" >&5 -echo "$as_me: $ac_file is unchanged" >&6;} - else - rm -f $ac_file - mv "$tmp/config.h" $ac_file - fi - else - echo "/* $configure_input */" - cat "$ac_result" - fi - rm -f "$tmp/out12" - ;; - - - esac - -done # for ac_tag - - -{ (exit 0); exit 0; } -_ACEOF -chmod +x $CONFIG_STATUS -ac_clean_files=$ac_clean_files_save - - -# configure is writing to config.log, and then calls config.status. -# config.status does its own redirection, appending to config.log. -# Unfortunately, on DOS this fails, as config.log is still kept open -# by configure, so config.status won't be able to write to it; its -# output is simply discarded. So we exec the FD to /dev/null, -# effectively closing config.log, so it can be properly (re)opened and -# appended to by config.status. When coming back to configure, we -# need to make the FD available again. -if test "$no_create" != yes; then - ac_cs_success=: - ac_config_status_args= - test "$silent" = yes && - ac_config_status_args="$ac_config_status_args --quiet" - exec 5>/dev/null - $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false - exec 5>>config.log - # Use ||, not &&, to avoid exiting from the if with $? = 1, which - # would make configure fail if this is the last instruction. - $ac_cs_success || { (exit 1); exit 1; } -fi - diff --git a/configure.ac b/configure.ac deleted file mode 100644 --- a/configure.ac +++ /dev/null @@ -1,126 +0,0 @@ -AC_INIT([Haskell LLVM bindings], [0.9.1.2], [bos@serpentine.com], [llvm]) - -AC_CONFIG_SRCDIR([LLVM/ExecutionEngine.hs]) - -AC_CONFIG_FILES([llvm.buildinfo]) - -AC_CONFIG_HEADERS([include/hs_llvm_config.h]) - -AC_PROG_CXX - -AC_LANG(C++) - -AC_ARG_WITH(compiler, - [AS_HELP_STRING([--with-compiler], - [use the given Haskell compiler])], - compiler="$withval", - compiler=ghc)dnl - -AC_ARG_WITH(llvm_prefix, - [AS_HELP_STRING([--with-llvm-prefix], - [use the version of LLVM at the given location])], - llvm_prefix="$withval", - llvm_prefix="$prefix")dnl - -AC_ARG_WITH(llvm_bindir, - [AS_HELP_STRING([--with-llvm-bindir], - [use LLVM binaries at the given location])], - llvm_bindir="$withval", - llvm_bindir="$llvm_prefix/bin")dnl - -AC_PATH_PROGS(llvm_config, [llvm-config], - [AC_MSG_ERROR(could not find llvm-config in $llvm_bindir)], - ["$llvm_bindir:$PATH"]) - -dnl * Choose target platform -dnl -dnl We don't use the standard autoconf macros for this, but instead -dnl ask GHC what platform it is for. Why? We need to generate a library -dnl matching the compiler. -dnl NB: This code is from GHC's configure (where the corresponding code for -dnl guessing host and build variables can be found, too) - -dnl Guess target platform if necessary. -m4_divert_once([HELP_CANON], -[[ -System types: - --target=TARGET configure for building compilers for TARGET [guessed]]])dnl - -if test "$target" = "" -then - if test "${compiler}" != "" - then - target=`${compiler} +RTS --info | grep '^ ,("Target platform"' | sed -e 's/.*, "//' -e 's/")//' | tr -d '\r'` - echo "Target platform inferred as: $target" - else - echo "Can't work out target platform" - exit 1 - fi -fi - -dnl Determine target-specific options -dnl This is important as Snow Leopard (Mac OS X 10.6) defaults to generating -dnl 64-bit code. -case $target in -i386-apple-darwin) - TARGET_CPPFLAGS="-m32" - TAGRET_LDFLAGS="-m32" - ;; -x86_64-apple-darwin) - TARGET_CPPFLAGS="-m64" - TAGRET_LDFLAGS="-m64" - ;; -esac - -llvm_version="`$llvm_config --version`" -llvm_cppflags="`$llvm_config --cppflags`" -llvm_includedir="`$llvm_config --includedir`" -llvm_ldflags="`$llvm_config --ldflags`" - -llvm_all_libs="`$llvm_config --libs all`" -llvm_target="`$llvm_config --libs engine | sed 's/.*LLVM\(.[[^ ]]*\)CodeGen.*/\1/'`" - -dnl We need to separate libraries that need to be linked from other linker options. -llvm_extra_libs="" -llvm_extra_libdirs="" -llvm_extra_ghci_libs="" -llvm_ldoptions="" -for opt in $llvm_all_libs $llvm_ldflags; do - case $opt in - -l*) llvm_extra_libs="$llvm_extra_libs `echo $opt | sed 's/^-l//'`";; - -L*) llvm_extra_libdirs="$llvm_extra_libdirs `echo $opt | sed 's/^-L//'`";; - */lib*.so|*/lib*.dylib) - llvm_extra_ghci_libs="$llvm_extra_ghci_libs `echo $opt | sed -e 's,^.*/lib\([^/]*\),\1,' -e 's/\.so$//' -e 's/\.dylib$//'`";; - *) llvm_ldoptions="$llvm_ldoptions $opt";; - esac -done - -CPPFLAGS="$llvm_cppflags $CPPFLAGS $TARGET_CPPFLAGS" -LDFLAGS="$llvm_ldflags $LDFLAGS $TARGET_LDFLAGS" - -AC_CHECK_HEADERS([llvm-c/Core.h], [], - [AC_MSG_ERROR(could not find LLVM C bindings)]) - -AC_CHECK_HEADERS([llvm/Support/DynamicLibrary.h]) - -save_LIBS="$LIBS" -LIBS="-lLLVMSupport -lLLVMSystem -lpthread -ldl $LIBS" - -AC_CHECK_LIB(LLVMCore, LLVMModuleCreateWithName, [], []) -if test "$ac_cv_lib_LLVMCore_LLVMModuleCreateWithName" = "no"; then - unset ac_cv_lib_LLVMCore_LLVMModuleCreateWithName - LIBS="-lLLVMSupport $save_LIBS" - AC_CHECK_LIB(LLVMCore, LLVMModuleCreateWithName, [], - [AC_MSG_ERROR(could not find LLVM C bindings)]) -fi - -AC_SUBST([llvm_version]) -AC_SUBST([llvm_cppflags]) -AC_SUBST([llvm_extra_libs]) -AC_SUBST([llvm_extra_libdirs]) -AC_SUBST([llvm_extra_ghci_libs]) -AC_SUBST([llvm_target]) -AC_SUBST([llvm_includedir]) -AC_SUBST([llvm_ldoptions]) - -AC_OUTPUT diff --git a/include/extra.h b/include/extra.h deleted file mode 100644 --- a/include/extra.h +++ /dev/null @@ -1,247 +0,0 @@ -/* - * Copyright (c) 2008-10, Mahadevan R All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * - * * Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. - * - * * Neither the name of this software, nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * These are some "extra" functions not available in the standard LLVM-C - * bindings, but are required / good-to-have inorder to implement the - * Python bindings. - */ - -#ifndef LLVM_PY_EXTRA_H -#define LLVM_PY_EXTRA_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Notes: - * - Some returned strings must be disposed of by LLVMDisposeMessage. These are - * indicated in the comments. Where it is not indicated, DO NOT call dispose. - */ - -/* Wraps llvm::Module::print(). Dispose the returned string after use, via - * LLVMDisposeMessage(). */ -char *LLVMDumpModuleToString(LLVMModuleRef module); - -/* Wraps llvm::Type::print(). Dispose the returned string after use, via - * LLVMDisposeMessage(). */ -char *LLVMDumpTypeToString(LLVMTypeRef type); - -/* Wraps llvm::Value::print(). Dispose the returned string after use, via - * LLVMDisposeMessage(). */ -char *LLVMDumpValueToString(LLVMValueRef Val); - -/* Wraps llvm::IRBuilder::CreateRet(). */ -LLVMValueRef LLVMBuildRetMultiple(LLVMBuilderRef bulder, LLVMValueRef *values, - unsigned n_values); - -/* Wraps llvm::IRBuilder::CreateGetResult(). */ -LLVMValueRef LLVMBuildGetResult(LLVMBuilderRef builder, LLVMValueRef value, - unsigned index, const char *name); - -/* Wraps llvm::Value::getValueID(). */ -unsigned LLVMValueGetID(LLVMValueRef value); - -/* Wraps llvm::Value::getNumUses(). */ -unsigned LLVMValueGetNumUses(LLVMValueRef value); - -/* Wraps llvm::Value::use_{begin,end}. Allocates LLVMValueRef's as - * required. Number of objects are returned as return value. If that is - * greater than zero, the pointer given out must be freed by a - * subsequent call to LLVMDisposeValueRefArray(). */ -unsigned LLVMValueGetUses(LLVMValueRef value, LLVMValueRef **refs); - -/* Wraps llvm::Value::isUsedInBasicBlock(). */ -unsigned LLVMValueIsUsedInBasicBlock(LLVMValueRef value, LLVMBasicBlockRef bb); -/* See above. */ -void LLVMDisposeValueRefArray(LLVMValueRef *refs); - -/* Wraps llvm:User::getNumOperands(). */ -unsigned LLVMUserGetNumOperands(LLVMValueRef user); - -/* Wraps llvm:User::getOperand(). */ -LLVMValueRef LLVMUserGetOperand(LLVMValueRef user, unsigned idx); - -/* Wraps llvm::ConstantExpr::getVICmp(). */ -LLVMValueRef LLVMConstVICmp(LLVMIntPredicate predicate, LLVMValueRef lhs, - LLVMValueRef rhs); - -/* Wraps llvm::ConstantExpr::getVFCmp(). */ -LLVMValueRef LLVMConstVFCmp(LLVMRealPredicate predicate, LLVMValueRef lhs, - LLVMValueRef rhs); - -/* Wraps llvm::IRBuilder::CreateVICmp(). */ -LLVMValueRef LLVMBuildVICmp(LLVMBuilderRef builder, LLVMIntPredicate predicate, - LLVMValueRef lhs, LLVMValueRef rhs, const char *name); - -/* Wraps llvm::IRBuilder::CreateVFCmp(). */ -LLVMValueRef LLVMBuildVFCmp(LLVMBuilderRef builder, LLVMRealPredicate predicate, - LLVMValueRef lhs, LLVMValueRef rhs, const char *name); - -/* Wraps llvm::Intrinsic::getDeclaration(). */ -LLVMValueRef LLVMGetIntrinsic(LLVMModuleRef builder, int id, - LLVMTypeRef *types, unsigned n_types); - -/* Wraps llvm::Function::doesNotThrow(). */ -unsigned LLVMGetDoesNotThrow(LLVMValueRef fn); - -/* Wraps llvm::Function::setDoesNotThrow(). */ -void LLVMSetDoesNotThrow(LLVMValueRef fn, int DoesNotThrow); - -/* Wraps llvm::Module::getPointerSize(). */ -unsigned LLVMModuleGetPointerSize(LLVMModuleRef module); - -/* Wraps llvm::Module::getOrInsertFunction(). */ -LLVMValueRef LLVMModuleGetOrInsertFunction(LLVMModuleRef module, - const char *name, LLVMTypeRef function_type); - -/* Wraps llvm::GlobalVariable::hasInitializer(). */ -int LLVMHasInitializer(LLVMValueRef global_var); - -/* The following functions wrap various llvm::Instruction::isXXX() functions. - * All of them take an instruction and return 0 (isXXX returned false) or 1 - * (isXXX returned false). */ -unsigned LLVMInstIsTerminator (LLVMValueRef inst); -unsigned LLVMInstIsBinaryOp (LLVMValueRef inst); -unsigned LLVMInstIsShift (LLVMValueRef inst); -unsigned LLVMInstIsCast (LLVMValueRef inst); -unsigned LLVMInstIsLogicalShift (LLVMValueRef inst); -unsigned LLVMInstIsArithmeticShift (LLVMValueRef inst); -unsigned LLVMInstIsAssociative (LLVMValueRef inst); -unsigned LLVMInstIsCommutative (LLVMValueRef inst); -unsigned LLVMInstIsTrapping (LLVMValueRef inst); - -/* As above, but these are wrap methods from subclasses of Instruction. */ -unsigned LLVMInstIsVolatile (LLVMValueRef inst); - -/* Wraps llvm::Instruction::getOpcodeName(). */ -const char *LLVMInstGetOpcodeName(LLVMValueRef inst); - -/* Wraps llvm::Instruction::getOpcode(). */ -unsigned LLVMInstGetOpcode(LLVMValueRef inst); - -/* Wraps llvm::CmpInst::getPredicate(). */ -unsigned LLVMCmpInstGetPredicate(LLVMValueRef cmpinst); - -/* Wraps llvm::ParseAssemblyString(). Returns a module reference or NULL (with - * `out' pointing to an error message). Dispose error message after use, via - * LLVMDisposeMessage(). */ -LLVMModuleRef LLVMGetModuleFromAssembly(const char *asmtxt, unsigned txten, - char **out); - -/* Wraps llvm::ParseBitcodeFile(). Returns a module reference or NULL (with - * `out' pointing to an error message). Dispose error message after use, via - * LLVMDisposeMessage(). */ -LLVMModuleRef LLVMGetModuleFromBitcode(const char *bc, unsigned bclen, - char **out); - -/* Wraps llvm::Linker::LinkModules(). Returns 0 on failure (with errmsg - * filled in) and 1 on success. Dispose error message after use with - * LLVMDisposeMessage(). */ -unsigned LLVMLinkModules(LLVMModuleRef dest, LLVMModuleRef src, char **errmsg); - -/* Returns pointer to a heap-allocated block of `*len' bytes containing bit code - * for the given module. NULL on error. */ -unsigned char *LLVMGetBitcodeFromModule(LLVMModuleRef module, unsigned *len); - -/* Wraps llvm::sys::DynamicLibrary::LoadLibraryPermanently(). Returns 0 on - * failure (with errmsg filled in) and 1 on success. Dispose error message after - * use, via LLVMDisposeMessage(). */ -unsigned LLVMLoadLibraryPermanently(const char* filename, char **errmsg); - -/* Wraps llvm::ExecutionEngine::getPointerToFunction(). Returns a pointer - * to the JITted function. */ -void *LLVMGetPointerToFunction(LLVMExecutionEngineRef ee, LLVMValueRef fn); - -/* Wraps llvm::InlineFunction(). Inlines a function. C is the call - * instruction, created by LLVMBuildCall. Even if it fails, the Function - * containing the call is still in a proper state (not changed). */ -int LLVMInlineFunction(LLVMValueRef call); - -/* Passes. Some passes are used directly from LLVM-C, rest are declared - * here. */ - -#define declare_pass(P) \ - void LLVMAdd ## P ## Pass (LLVMPassManagerRef PM); - -declare_pass( AAEval ) -declare_pass( AliasAnalysisCounter ) -declare_pass( AlwaysInliner ) -declare_pass( BasicAliasAnalysis ) -declare_pass( BlockPlacement ) -declare_pass( BreakCriticalEdges ) -declare_pass( CodeGenPrepare ) -declare_pass( DbgInfoPrinter ) -declare_pass( DeadCodeElimination ) -declare_pass( DeadInstElimination ) -declare_pass( DemoteRegisterToMemory ) -declare_pass( DomOnlyPrinter ) -declare_pass( DomOnlyViewer ) -declare_pass( DomPrinter ) -declare_pass( DomViewer ) -declare_pass( EdgeProfiler ) -declare_pass( GlobalsModRef ) -declare_pass( InstCount ) -declare_pass( InstructionNamer ) -declare_pass( LazyValueInfo ) -declare_pass( LCSSA ) -declare_pass( LoopDependenceAnalysis ) -declare_pass( LoopExtractor ) -declare_pass( LoopSimplify ) -declare_pass( LoopStrengthReduce ) -declare_pass( LowerInvoke ) -declare_pass( LowerSwitch ) -declare_pass( MergeFunctions ) -declare_pass( NoAA ) -declare_pass( NoProfileInfo ) -declare_pass( OptimalEdgeProfiler ) -declare_pass( PartialInlining ) -declare_pass( PostDomOnlyPrinter ) -declare_pass( PostDomOnlyViewer ) -declare_pass( PostDomPrinter ) -declare_pass( PostDomViewer ) -declare_pass( ProfileEstimator ) -declare_pass( ProfileLoader ) -declare_pass( ProfileVerifier ) -declare_pass( ScalarEvolutionAliasAnalysis ) -declare_pass( SingleLoopExtractor ) -declare_pass( StripNonDebugSymbols ) -declare_pass( StructRetPromotion ) -declare_pass( TailDuplication ) -declare_pass( UnifyFunctionExitNodes ) - -declare_pass( Internalize2 ) - -#ifdef __cplusplus -} /* extern "C" */ -#endif - -#endif /* LLVM_PY_EXTRA_H */ - diff --git a/include/hs_llvm_config.h.in b/include/hs_llvm_config.h.in deleted file mode 100644 --- a/include/hs_llvm_config.h.in +++ /dev/null @@ -1,55 +0,0 @@ -/* include/hs_llvm_config.h.in. Generated from configure.ac by autoheader. */ - -/* Define to 1 if you have the header file. */ -#undef HAVE_INTTYPES_H - -/* Define to 1 if you have the `LLVMCore' library (-lLLVMCore). */ -#undef HAVE_LIBLLVMCORE - -/* Define to 1 if you have the header file. */ -#undef HAVE_LLVM_C_CORE_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_LLVM_SUPPORT_DYNAMICLIBRARY_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_MEMORY_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_STDINT_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_STDLIB_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_STRINGS_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_STRING_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_SYS_STAT_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_SYS_TYPES_H - -/* Define to 1 if you have the header file. */ -#undef HAVE_UNISTD_H - -/* Define to the address where bug reports for this package should be sent. */ -#undef PACKAGE_BUGREPORT - -/* Define to the full name of this package. */ -#undef PACKAGE_NAME - -/* Define to the full name and version of this package. */ -#undef PACKAGE_STRING - -/* Define to the one symbol short name of this package. */ -#undef PACKAGE_TARNAME - -/* Define to the version of this package. */ -#undef PACKAGE_VERSION - -/* Define to 1 if you have the ANSI C header files. */ -#undef STDC_HEADERS diff --git a/include/support.h b/include/support.h deleted file mode 100644 --- a/include/support.h +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef LLVM_HS_SUPPORT_H -#define LLVM_HS_SUPPORT_H - -#ifdef __cplusplus -extern "C" { -#endif - -void LLVMCreateStandardFunctionPasses(LLVMPassManagerRef PM, - unsigned OptimizationLevel); - -void LLVMCreateStandardModulePasses(LLVMPassManagerRef PM, - unsigned OptimizationLevel, - int OptimizeSize, - int UnitAtATime, - int UnrollLoops, - int SimplifyLibCalls, - int HaveExceptions, - int DisableInlining); - -#ifdef __cplusplus -} /* extern "C" */ -#endif - -#endif /* LLVM_HS_SUPPORT_H */ diff --git a/llvm.buildinfo.in b/llvm.buildinfo.in deleted file mode 100644 --- a/llvm.buildinfo.in +++ /dev/null @@ -1,7 +0,0 @@ -cpp-options: @llvm_cppflags@ -DTARGET=@llvm_target@ -ghc-options: -pgml @CXX@ -extra-libraries: @llvm_extra_libs@ stdc++ -extra-lib-dirs: @llvm_extra_libdirs@ -x-extra-ghci-libraries: @llvm_extra_ghci_libs@ -ld-options: @llvm_ldoptions@ -include-dirs: @llvm_includedir@ diff --git a/llvm.buildinfo.windows.in b/llvm.buildinfo.windows.in deleted file mode 100644 --- a/llvm.buildinfo.windows.in +++ /dev/null @@ -1,4 +0,0 @@ -cpp-options: -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -DTARGET=X86 -ghc-options: -I@llvm_path@/include -pgml g++ -ld-options: -L@llvm_path@/lib -lLLVMXCoreAsmPrinter -lLLVMXCoreCodeGen -lLLVMXCoreInfo -lLLVMSystemZAsmPrinter -lLLVMSystemZCodeGen -lLLVMSystemZInfo -lLLVMSparcAsmPrinter -lLLVMSparcCodeGen -lLLVMSparcInfo -lLLVMPowerPCAsmPrinter -lLLVMPowerPCCodeGen -lLLVMPowerPCInfo -lLLVMPIC16AsmPrinter -lLLVMPIC16CodeGen -lLLVMPIC16Info -lLLVMMSP430AsmPrinter -lLLVMMSP430CodeGen -lLLVMMSP430Info -lLLVMMSIL -lLLVMMSILInfo -lLLVMMipsAsmPrinter -lLLVMMipsCodeGen -lLLVMMipsInfo -lLLVMLinker -lLLVMipo -lLLVMInterpreter -lLLVMInstrumentation -lLLVMJIT -lLLVMExecutionEngine -lLLVMDebugger -lLLVMCppBackend -lLLVMCppBackendInfo -lLLVMCellSPUAsmPrinter -lLLVMCellSPUCodeGen -lLLVMCellSPUInfo -lLLVMCBackend -lLLVMCBackendInfo -lLLVMBlackfinAsmPrinter -lLLVMBlackfinCodeGen -lLLVMBlackfinInfo -lLLVMBitWriter -lLLVMX86AsmParser -lLLVMX86AsmPrinter -lLLVMX86CodeGen -lLLVMX86Info -lLLVMAsmParser -lLLVMARMAsmPrinter -lLLVMARMCodeGen -lLLVMARMInfo -lLLVMArchive -lLLVMBitReader -lLLVMAlphaAsmPrinter -lLLVMAlphaCodeGen -lLLVMSelectionDAG -lLLVMAsmPrinter -lLLVMCodeGen -lLLVMScalarOpts -lLLVMTransformUtils -lLLVMipa -lLLVMAnalysis -lLLVMTarget -lLLVMMC -lLLVMCore -lLLVMAlphaInfo -lLLVMSupport -lLLVMSystem -lpsapi -limagehlp -lstdc++ -lmingwex -include-dirs: @llvm_path@/include diff --git a/llvm.cabal b/llvm.cabal --- a/llvm.cabal +++ b/llvm.cabal @@ -1,16 +1,13 @@ name: llvm -version: 0.10.0.1 +version: 3.0.0.0 license: BSD3 license-file: LICENSE synopsis: Bindings to the LLVM compiler toolkit. description: - Bindings to the LLVM compiler toolkit. + High-level bindings to the LLVM compiler toolkit. . - We try to stay up to date with LLVM releases. The current version - of this package is compatible with LLVM 2.9 and 2.8. Please - understand that the package may or may not work against older LLVM - releases; we don't have the time or resources to test across - multiple releases. + * New in 3.0.0.0: The low-level bindings have been split into the + llvm-base package. . * New in 0.9.1.1: Builds against LLVM 2.9. . @@ -18,39 +15,26 @@ . * New in 0.9.0.0: Adapted to LLVM 2.8 (removed support for Union types). author: Bryan O'Sullivan, Lennart Augustsson -maintainer: Bryan O'Sullivan , Lennart Augustsson +maintainer: Bryan O'Sullivan , + Lennart Augustsson homepage: https://github.com/bos/llvm bug-reports: https://github.com/bos/llvm/issues stability: experimental category: Compilers/Interpreters, Code Generation -tested-with: GHC == 6.10.4, GHC == 6.12.3, GHC == 7.0.3 +tested-with: GHC == 6.12.3, GHC == 7.0.4, GHC == 7.2.2 cabal-version: >= 1.10 -build-type: Custom +build-type: Simple extra-source-files: *.md - Makefile - configure.ac - configure examples/*.c examples/*.hs - include/extra.h - include/hs_llvm_config.h.in - include/support.h - llvm.buildinfo.in - llvm.buildinfo.windows.in tests/*.hs tests/Makefile - tools/*.hs - tools/Makefile -extra-tmp-files: - autom4te.cache - config.log - config.status - configure - include/hs_llvm_config.h - llvm.buildinfo +flag developer + description: operate in developer mode + default: False library default-language: Haskell98 @@ -58,6 +42,7 @@ base >= 3 && < 5, bytestring >= 0.9, directory, + llvm-base == 3.0.*, mtl, process, type-level, @@ -65,6 +50,9 @@ ghc-options: -Wall + if flag(developer) + ghc-options: -Werror + if os(darwin) ld-options: -w frameworks: vecLib @@ -73,15 +61,6 @@ exposed-modules: LLVM.Core LLVM.ExecutionEngine - LLVM.FFI.Analysis - LLVM.FFI.BitReader - LLVM.FFI.BitWriter - LLVM.FFI.Core - LLVM.FFI.ExecutionEngine - LLVM.FFI.Support - LLVM.FFI.Target - LLVM.FFI.Transforms.IPO - LLVM.FFI.Transforms.Scalar LLVM.Util.Arithmetic LLVM.Util.File LLVM.Util.Foreign @@ -99,32 +78,10 @@ LLVM.Core.Vector LLVM.ExecutionEngine.Engine LLVM.ExecutionEngine.Target - LLVM.Target.ARM - LLVM.Target.Alpha - LLVM.Target.Blackfin - LLVM.Target.CBackend - LLVM.Target.CellSPU - LLVM.Target.CppBackend - LLVM.Target.MSP430 - LLVM.Target.Mips - LLVM.Target.Native - LLVM.Target.PIC16 - LLVM.Target.PowerPC - LLVM.Target.Sparc - LLVM.Target.SystemZ - LLVM.Target.X86 - LLVM.Target.XCore - include-dirs: include - C-Sources: - cbits/extra.cpp - cbits/free.c - cbits/malloc.c - cbits/support.cpp - source-repository head type: git - location: https://github.com/bos/llvm/ + location: git://github.com/bos/llvm.git source-repository head type: mercurial diff --git a/tools/DiffFFI.hs b/tools/DiffFFI.hs deleted file mode 100644 --- a/tools/DiffFFI.hs +++ /dev/null @@ -1,39 +0,0 @@ -module DiffFFI (main) where - -import Control.Monad (forM_) -import Data.List (foldl') -import qualified Data.Map as M -import System.Environment (getArgs) -import System.Exit (exitFailure) -import System.IO (hPutStrLn, stderr) -import Text.Regex.Posix ((=~)) - -import FunctionMangulation (pattern, rewriteFunction) - -cFunctions :: String -> M.Map String String -cFunctions s = foldl' go M.empty (s =~ pattern) - where go m (_:ret:name:params:_) = - M.insert ("LLVM" ++ name) (rewriteFunction ret name params) m - go m _ = m - -hsFunctions :: String -> M.Map String String -hsFunctions s = foldl' go M.empty (s =~ pat) - where pat = "\"([a-zA-Z0-9_]+)\"[ \t\n]+([a-zA-Z0-9_']+)" - go m (_:cname:hsname:_) = M.insert cname hsname m - go m _ = m - -main :: IO () -main = do - args <- getArgs - case args of - [cFile, hsFile] -> do - c <- cFunctions `fmap` readFile cFile - hs <- hsFunctions `fmap` readFile hsFile - putStrLn "In C, not Haskell:" - forM_ (M.toAscList $ M.difference c hs) $ \(_, hsfunc) -> - putStrLn hsfunc - putStrLn "In Haskell, not C:" - forM_ (M.keys $ M.difference hs c) $ putStrLn . (" "++) - _ -> do - hPutStrLn stderr "Usage: DiffFFI cFile hsFile" - exitFailure diff --git a/tools/FunctionMangler.hs b/tools/FunctionMangler.hs deleted file mode 100644 --- a/tools/FunctionMangler.hs +++ /dev/null @@ -1,8 +0,0 @@ -module FunctionMangler (main) where - -import Data.List (intercalate) - -import FunctionMangulation (rewrite) - -main :: IO () -main = interact (intercalate "\n\n" . concat . rewrite) >> putStr "\n" diff --git a/tools/FunctionMangulation.hs b/tools/FunctionMangulation.hs deleted file mode 100644 --- a/tools/FunctionMangulation.hs +++ /dev/null @@ -1,65 +0,0 @@ -module FunctionMangulation - ( - pattern - , rewrite - , rewriteFunction - ) where - -import Control.Monad (forM) -import Data.Char (isSpace, toLower) -import Data.List (intercalate, isPrefixOf, isSuffixOf) -import Text.Regex.Posix ((=~), (=~~)) - -pattern :: String -pattern = "^([A-Za-z0-9_ ]+ ?\\*?)[ \t\n]*" ++ - "LLVM([A-Za-z0-9_]+)\\(([a-zA-Z0-9_*, \t\n]+)\\);" - -dropSpace :: String -> String -dropSpace = dropWhile isSpace - -renameType :: String -> String -renameType t | "LLVM" `isPrefixOf` t = rename' (drop 4 t) - | otherwise = rename' t - where rename' "int" = "CInt" - rename' "unsigned" = "CUInt" - rename' "long long" = "CLLong" - rename' "unsigned long long" = "CULLong" - rename' "void" = "()" - rename' "const char *" = "CString" - rename' "char *" = "CString" - rename' s | "*" `isSuffixOf` s = pointer s - | otherwise = strip s - pointer p = case reverse p of - ('*':ps) -> "(Ptr " ++ rename' (reverse ps) ++ ")" - _ -> p - -split :: (a -> Bool) -> [a] -> [[a]] -split p xs = case break p xs of - (h,(_:t)) -> h : split p t - (s,_) -> [s] - -strip :: String -> String -strip = reverse . dropWhile isSpace . reverse . dropSpace - -dropName :: String -> String -dropName s = - case s =~ "^((const )?[A-Za-z0-9_]+( \\*+)?) ?[A-Za-z0-9]*$" of - ((_:typ:_):_) -> typ - _ -> "{- oops! -} " ++ s - -rewriteFunction :: String -> String -> String -> String -rewriteFunction cret cname cparams = - let ret = "IO " ++ renameType (strip cret) - params = map renameParam . split (==',') $ cparams - params' = if params == ["()"] then [] else params - name = let (n:ame) = cname in toLower n : ame - in foreign ++ "\"LLVM" ++ cname ++ "\" " ++ name ++ - "\n :: " ++ intercalate " -> " (params' ++ [ret]) - where renameParam = renameType . dropName . strip - foreign = "foreign import ccall unsafe " - -rewrite :: Monad m => String -> m [String] -rewrite s = do - matches <- s =~~ pattern - forM matches $ \(_:cret:cname:cparams:_) -> - return (rewriteFunction cret cname cparams) diff --git a/tools/IntrinsicMangler.hs b/tools/IntrinsicMangler.hs deleted file mode 100644 --- a/tools/IntrinsicMangler.hs +++ /dev/null @@ -1,22 +0,0 @@ -module IntrinsicMangler (main) where - -import Control.Monad (forM_) -import qualified Data.ByteString.Char8 as C -import Data.Maybe (catMaybes) -import Text.Regex.Posix ((=~~)) - -maybeName :: C.ByteString -> Maybe C.ByteString -maybeName line = do - ((_:name:_):_) <- line =~~ "^[ \t]*([a-z0-9_]+),[ \t]*//[ \t]*llvm\\." - return name - -main :: IO () -main = do - input <- (catMaybes . map maybeName . C.lines) `fmap` C.getContents - - putStrLn "-- automatically generated file - do not edit!" - putStrLn "module LLVM.Core.Intrinsics (Intrinsic(..)) where" - putStrLn "data Intrinsic =" - putStrLn " NotIntrinsic" - forM_ input $ C.putStrLn . (C.append (C.pack " | I_")) - putStrLn " deriving (Eq, Ord, Enum, Show)" diff --git a/tools/Makefile b/tools/Makefile deleted file mode 100644 --- a/tools/Makefile +++ /dev/null @@ -1,11 +0,0 @@ -ghc := ghc -ghcflags := -O -Wall -Werror -tools := DiffFFI FunctionMangler IntrinsicMangler - -all: $(tools) - -%: %.hs - $(ghc) $(ghcflags) --make -o $@ -main-is $(basename $<).main $< - -clean: - -rm -f *.o *.hi $(tools) *.exe