llvm 0.10.0.1 → 3.0.0.0

raw patch · 49 files changed

+26/−8610 lines, 49 filesdep +llvm-basesetup-changedPVP ok

version bump matches the API change (PVP)

Dependencies added: llvm-base

API changes (from Hackage documentation)

Files

• INSTALL.md +0/−61
• LLVM/Core/Data.hs +3/−5
• LLVM/Core/Type.hs +2/−0
• LLVM/FFI/Analysis.hsc +0/−19
• LLVM/FFI/BitReader.hsc +0/−21
• LLVM/FFI/BitWriter.hsc +0/−14
• LLVM/FFI/Core.hsc +0/−1716
• LLVM/FFI/ExecutionEngine.hsc +0/−162
• LLVM/FFI/Support.hsc +0/−16
• LLVM/FFI/Target.hsc +0/−52
• LLVM/FFI/Transforms/IPO.hsc +0/−36
• LLVM/FFI/Transforms/Scalar.hsc +0/−50
• LLVM/Target/ARM.hs +0/−10
• LLVM/Target/Alpha.hs +0/−10
• LLVM/Target/Blackfin.hs +0/−10
• LLVM/Target/CBackend.hs +0/−10
• LLVM/Target/CellSPU.hs +0/−10
• LLVM/Target/CppBackend.hs +0/−10
• LLVM/Target/MSP430.hs +0/−10
• LLVM/Target/Mips.hs +0/−10
• LLVM/Target/Native.hs +0/−20
• LLVM/Target/PIC16.hs +0/−10
• LLVM/Target/PowerPC.hs +0/−10
• LLVM/Target/Sparc.hs +0/−10
• LLVM/Target/SystemZ.hs +0/−10
• LLVM/Target/X86.hs +0/−10
• LLVM/Target/XCore.hs +0/−10
• LLVM/Util/Arithmetic.hs +1/−1
• LLVM/Util/Optimize.hs +1/−5
• Makefile +0/−66
• Setup.hs +0/−122
• Setup.lhs +3/−0
• cbits/extra.cpp +0/−544
• cbits/free.c +0/−17
• cbits/malloc.c +0/−190
• cbits/support.cpp +0/−43
• configure +0/−4643
• configure.ac +0/−126
• include/extra.h +0/−247
• include/hs_llvm_config.h.in +0/−55
• include/support.h +0/−24
• llvm.buildinfo.in +0/−7
• llvm.buildinfo.windows.in +0/−4
• llvm.cabal +16/−59
• tools/DiffFFI.hs +0/−39
• tools/FunctionMangler.hs +0/−8
• tools/FunctionMangulation.hs +0/−65
• tools/IntrinsicMangler.hs +0/−22
• tools/Makefile +0/−11

@@ -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.

@@ -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)-

@@ -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

@@ -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 ()

@@ -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

@@ -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

@@ -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 <llvm-c/Core.h>--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--}

@@ -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

@@ -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 ()

@@ -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-

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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 ()

@@ -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,

@@ -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

@@ -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

@@ -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)

@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+> import Distribution.Simple+> main = defaultMain

@@ -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 <cassert>-#include <cstdlib>-#include <cstring>-#include <sstream>--#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<llvm::FunctionType>(function_type);-    assert(ftp);--    llvm::Constant *f = modulep->getOrInsertFunction(name, ftp);-    return wrap(f);-}--int LLVMHasInitializer(LLVMValueRef global_var)-{-    llvm::GlobalVariable *gvp = llvm::unwrap<llvm::GlobalVariable>(global_var);-    assert(gvp);--    return gvp->hasInitializer();-}--#define inst_checkfn(ourfn, llvmfn)                 \-unsigned ourfn (LLVMValueRef v) {                   \-    llvm::Instruction *ip = llvm::unwrap<llvm::Instruction>(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<Instruction>(v);-    assert(ip);-    return ((isa<LoadInst>(*ip)  && cast<LoadInst>(*ip).isVolatile()) ||-            (isa<StoreInst>(*ip) && cast<StoreInst>(*ip).isVolatile()) );-}--const char *LLVMInstGetOpcodeName(LLVMValueRef inst)-{-    llvm::Instruction *instp = llvm::unwrap<llvm::Instruction>(inst);-    assert(instp);-    return instp->getOpcodeName();-}--unsigned LLVMInstGetOpcode(LLVMValueRef inst)-{-    llvm::Instruction *instp = llvm::unwrap<llvm::Instruction>(inst);-    assert(instp);-    return instp->getOpcode();-}--unsigned LLVMCmpInstGetPredicate(LLVMValueRef cmpinst)-{-    llvm::CmpInst *instp = llvm::unwrap<llvm::CmpInst>(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 <typename W, typename UW>-void unwrap_vec(W *values, unsigned n, std::vector<UW *>& 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 <typename W, typename UW>-void unwrap_cvec(W *values, unsigned n, std::vector<const UW *>& 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<llvm::Value *> 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<llvm::User>(user);-    assert(userp);-    return userp->getNumOperands();-}--LLVMValueRef LLVMUserGetOperand(LLVMValueRef user, unsigned idx)-{-    llvm::User *userp = llvm::unwrap<llvm::User>(user);-    assert(userp);-    llvm::Value *operand = userp->getOperand(idx);-    return llvm::wrap(operand);-}--unsigned LLVMGetDoesNotThrow(LLVMValueRef fn)-{-    llvm::Function *fnp = llvm::unwrap<llvm::Function>(fn);-    assert(fnp);--    return fnp->doesNotThrow();-}--void LLVMSetDoesNotThrow(LLVMValueRef fn, int DoesNotThrow)-{-    llvm::Function *fnp = llvm::unwrap<llvm::Function>(fn);-    assert(fnp);--    return fnp->setDoesNotThrow((bool)DoesNotThrow);-}--LLVMValueRef LLVMGetIntrinsic(LLVMModuleRef module, int id,-    LLVMTypeRef *types, unsigned n_types)-{-    assert(types);--    std::vector<const llvm::Type*> 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<llvm::Function>(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 )-

@@ -1,17 +0,0 @@-#define __STDC_LIMIT_MACROS-#define __STDC_CONSTANT_MACROS-#include <llvm-c/Core.h>-#include <llvm-c/ExecutionEngine.h>--/* 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);-  }-}

@@ -1,190 +0,0 @@-#include <stdlib.h>-#include <stdint.h>--#ifdef DEBUG-#include <stdio.h>-#endif--#ifdef TEST-#include <stdio.h>-#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<size; k++) {-      ptr[k] = 0;-    }-    aligned_free (ptr);-  }-}--int main () {-  test_gcd (0,0);-  test_gcd (0,1);-  test_gcd (0,2);-  test_gcd (1,0);-  test_gcd (2,0);-  test_gcd (1,2);-  test_gcd (2,1);-  test_gcd (2,2);-  test_gcd (2,3);-  test_gcd (2,4);-  test_gcd (16,64);-  test_gcd (15,10);-  test_gcd (96,81);--  test_malloc (128, 1);-  test_malloc (128, 2);-  test_malloc (128, 3);-  test_malloc (128, 4);-  test_malloc (128, 5);-  test_malloc (128, 6);-  test_malloc (128, 8);-  test_malloc (128, 16);-  test_malloc (128, 32);-  test_malloc (128, 64);-  test_malloc (111, 1);-  test_malloc (111, 2);-  test_malloc (111, 3);-  test_malloc (111, 4);-  test_malloc (111, 5);-  test_malloc (111, 6);-  test_malloc (111, 8);-  test_malloc (111, 16);-  test_malloc (111, 32);-  test_malloc (111, 64);--  return 0;-}-#endif

@@ -1,43 +0,0 @@-#define __STDC_LIMIT_MACROS-#define __STDC_CONSTANT_MACROS--#include "llvm-c/Core.h"-#include "llvm/PassManager.h"-#include "llvm/Support/StandardPasses.h"--#include "support.h"--using namespace llvm;--void LLVMCreateStandardFunctionPasses(LLVMPassManagerRef PM,-				      unsigned OptimizationLevel)-{-  createStandardFunctionPasses(unwrap(PM), OptimizationLevel);-}--void LLVMCreateStandardModulePasses(LLVMPassManagerRef PM,-				    unsigned OptLevel,-				    int OptimizeSize,-				    int UnitAtATime,-				    int UnrollLoops,-				    int SimplifyLibCalls,-				    int HaveExceptions,-				    int DisableInline)-{-  Pass *InliningPass = 0;--  if (DisableInline) {-    // No inlining pass-  } else if (OptLevel) {-    unsigned Threshold = 225;-    if (OptLevel > 2)-      Threshold = 275;-    InliningPass = createFunctionInliningPass(Threshold);-  } else {-    InliningPass = createAlwaysInlinerPass();-  }--  createStandardModulePasses(unwrap(PM), OptLevel, OptimizeSize,-			     UnitAtATime, UnrollLoops, SimplifyLibCalls,-			     HaveExceptions, InliningPass);-}

@@ -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 <bos@serpentine.com>.-#-# 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 </dev/null 6>&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 <stdio.h>-#ifdef HAVE_SYS_TYPES_H-# include <sys/types.h>-#endif-#ifdef HAVE_SYS_STAT_H-# include <sys/stat.h>-#endif-#ifdef STDC_HEADERS-# include <stdlib.h>-# include <stddef.h>-#else-# ifdef HAVE_STDLIB_H-#  include <stdlib.h>-# endif-#endif-#ifdef HAVE_STRING_H-# if !defined STDC_HEADERS && defined HAVE_MEMORY_H-#  include <memory.h>-# endif-# include <string.h>-#endif-#ifdef HAVE_STRINGS_H-# include <strings.h>-#endif-#ifdef HAVE_INTTYPES_H-# include <inttypes.h>-#endif-#ifdef HAVE_STDINT_H-# include <stdint.h>-#endif-#ifdef HAVE_UNISTD_H-# include <unistd.h>-#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<lib dir> if you have libraries in a-              nonstandard directory <lib dir>-  LIBS        libraries to pass to the linker, e.g. -l<library>-  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if-              you have headers in a nonstandard directory <include dir>-  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 <bos@serpentine.com>.-_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 <limits.h> to <assert.h> if __STDC__ is defined, since-  # <limits.h> 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 <limits.h>-#else-# include <assert.h>-#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 <ac_nonexistent.h>-_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 <limits.h> to <assert.h> if __STDC__ is defined, since-  # <limits.h> 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 <limits.h>-#else-# include <assert.h>-#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 <ac_nonexistent.h>-_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 <stdlib.h>-#include <stdarg.h>-#include <string.h>-#include <float.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_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 <string.h>--_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 <stdlib.h>--_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 <ctype.h>-#include <stdlib.h>-#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 <bug-autoconf@gnu.org>."--_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 <conf$$subs.sed-rm -f conf$$subs.sed-cat >>$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-