llvm-hs (empty) → 4.0.0.0

raw patch · 162 files changed

+14931/−0 lines, 162 filesdep +QuickCheckdep +arraydep +basebuild-type:Customsetup-changed

Dependencies added: QuickCheck, array, base, bytestring, containers, llvm-hs, llvm-hs-pure, mtl, parsec, pretty-show, semigroups, tasty, tasty-hunit, tasty-quickcheck, template-haskell, temporary, transformers, transformers-compat, utf8-string

Files

• LICENSE +30/−0
• Setup.hs +189/−0
• llvm-hs.cabal +273/−0
• src/Control/Monad/AnyCont.hs +30/−0
• src/Control/Monad/AnyCont/Class.hs +54/−0
• src/Control/Monad/Trans/AnyCont.hs +40/−0
• src/LLVM.hs +7/−0
• src/LLVM/Analysis.hs +8/−0
• src/LLVM/CodeGenOpt.hs +12/−0
• src/LLVM/CodeModel.hs +14/−0
• src/LLVM/CommandLine.hs +8/−0
• src/LLVM/Context.hs +7/−0
• src/LLVM/Diagnostic.hs +33/−0
• src/LLVM/ExecutionEngine.hs +8/−0
• src/LLVM/Internal/Analysis.hs +24/−0
• src/LLVM/Internal/Atomicity.hs +49/−0
• src/LLVM/Internal/Attribute.hs +279/−0
• src/LLVM/Internal/BasicBlock.hs +27/−0
• src/LLVM/Internal/CallingConvention.hs +71/−0
• src/LLVM/Internal/Coding.hs +140/−0
• src/LLVM/Internal/CommandLine.hs +23/−0
• src/LLVM/Internal/Constant.hs +248/−0
• src/LLVM/Internal/Context.hs +20/−0
• src/LLVM/Internal/DataLayout.hs +23/−0
• src/LLVM/Internal/DecodeAST.hs +172/−0
• src/LLVM/Internal/Diagnostic.hs +40/−0
• src/LLVM/Internal/EncodeAST.hs +159/−0
• src/LLVM/Internal/ExecutionEngine.hs +134/−0
• src/LLVM/Internal/FFI/Analysis.h +11/−0
• src/LLVM/Internal/FFI/Analysis.hs +15/−0
• src/LLVM/Internal/FFI/Assembly.hs +29/−0
• src/LLVM/Internal/FFI/AssemblyC.cpp +28/−0
• src/LLVM/Internal/FFI/Attribute.h +69/−0
• src/LLVM/Internal/FFI/Attribute.hs +143/−0
• src/LLVM/Internal/FFI/AttributeC.cpp +145/−0
• src/LLVM/Internal/FFI/AttributeC.hpp +24/−0
• src/LLVM/Internal/FFI/BasicBlock.hs +34/−0
• src/LLVM/Internal/FFI/BinaryOperator.h +16/−0
• src/LLVM/Internal/FFI/BinaryOperator.hs +30/−0
• src/LLVM/Internal/FFI/Bitcode.hs +26/−0
• src/LLVM/Internal/FFI/BitcodeC.cpp +34/−0
• src/LLVM/Internal/FFI/Builder.hs +184/−0
• src/LLVM/Internal/FFI/BuilderC.cpp +223/−0
• src/LLVM/Internal/FFI/ByteRangeCallback.hs +14/−0
• src/LLVM/Internal/FFI/CallingConvention.h +35/−0
• src/LLVM/Internal/FFI/CallingConventionC.cpp +10/−0
• src/LLVM/Internal/FFI/Cleanup.hs +83/−0
• src/LLVM/Internal/FFI/CommandLine.hs +15/−0
• src/LLVM/Internal/FFI/CommandLineC.cpp +12/−0
• src/LLVM/Internal/FFI/Constant.h +20/−0
• src/LLVM/Internal/FFI/Constant.hs +145/−0
• src/LLVM/Internal/FFI/ConstantC.cpp +114/−0
• src/LLVM/Internal/FFI/Context.hs +28/−0
• src/LLVM/Internal/FFI/DataLayout.hs +26/−0
• src/LLVM/Internal/FFI/ExecutionEngine.hs +71/−0
• src/LLVM/Internal/FFI/ExecutionEngineC.cpp +30/−0
• src/LLVM/Internal/FFI/Function.hs +72/−0
• src/LLVM/Internal/FFI/FunctionC.cpp +41/−0
• src/LLVM/Internal/FFI/GlobalAlias.hs +26/−0
• src/LLVM/Internal/FFI/GlobalAliasC.cpp +22/−0
• src/LLVM/Internal/FFI/GlobalValue.h +58/−0
• src/LLVM/Internal/FFI/GlobalValue.hs +79/−0
• src/LLVM/Internal/FFI/GlobalValueC.cpp +87/−0
• src/LLVM/Internal/FFI/GlobalVariable.hs +31/−0
• src/LLVM/Internal/FFI/InlineAssembly.h +14/−0
• src/LLVM/Internal/FFI/InlineAssembly.hs +35/−0
• src/LLVM/Internal/FFI/InlineAssemblyC.cpp +73/−0
• src/LLVM/Internal/FFI/Instruction.h +67/−0
• src/LLVM/Internal/FFI/Instruction.hs +181/−0
• src/LLVM/Internal/FFI/InstructionC.cpp +323/−0
• src/LLVM/Internal/FFI/InstructionDefs.hsc +61/−0
• src/LLVM/Internal/FFI/Iterate.hs +13/−0
• src/LLVM/Internal/FFI/LLVMCTypes.hsc +266/−0
• src/LLVM/Internal/FFI/LibFunc.h +332/−0
• src/LLVM/Internal/FFI/MemoryBuffer.hs +28/−0
• src/LLVM/Internal/FFI/Metadata.hpp +11/−0
• src/LLVM/Internal/FFI/Metadata.hs +93/−0
• src/LLVM/Internal/FFI/MetadataC.cpp +151/−0
• src/LLVM/Internal/FFI/Module.hs +103/−0
• src/LLVM/Internal/FFI/ModuleC.cpp +70/−0
• src/LLVM/Internal/FFI/OrcJIT.h +15/−0
• src/LLVM/Internal/FFI/OrcJIT.hs +51/−0
• src/LLVM/Internal/FFI/OrcJIT/CompileOnDemandLayer.hs +74/−0
• src/LLVM/Internal/FFI/OrcJIT/IRCompileLayer.hs +36/−0
• src/LLVM/Internal/FFI/OrcJITC.cpp +256/−0
• src/LLVM/Internal/FFI/PassManager.hs +134/−0
• src/LLVM/Internal/FFI/PassManagerC.cpp +248/−0
• src/LLVM/Internal/FFI/PtrHierarchy.hs +134/−0
• src/LLVM/Internal/FFI/RawOStream.hs +35/−0
• src/LLVM/Internal/FFI/RawOStreamC.cpp +36/−0
• src/LLVM/Internal/FFI/SMDiagnostic.h +15/−0
• src/LLVM/Internal/FFI/SMDiagnostic.hs +40/−0
• src/LLVM/Internal/FFI/SMDiagnosticC.cpp +42/−0
• src/LLVM/Internal/FFI/Target.h +71/−0
• src/LLVM/Internal/FFI/Target.hpp +11/−0
• src/LLVM/Internal/FFI/Target.hs +141/−0
• src/LLVM/Internal/FFI/TargetC.cpp +319/−0
• src/LLVM/Internal/FFI/Threading.hs +13/−0
• src/LLVM/Internal/FFI/Transforms.hs +76/−0
• src/LLVM/Internal/FFI/Type.h +23/−0
• src/LLVM/Internal/FFI/Type.hs +152/−0
• src/LLVM/Internal/FFI/TypeC.cpp +42/−0
• src/LLVM/Internal/FFI/User.hs +38/−0
• src/LLVM/Internal/FFI/Value.h +32/−0
• src/LLVM/Internal/FFI/Value.hs +41/−0
• src/LLVM/Internal/FFI/ValueC.cpp +30/−0
• src/LLVM/Internal/FastMathFlags.hs +51/−0
• src/LLVM/Internal/FloatingPointPredicate.hs +29/−0
• src/LLVM/Internal/Function.hs +70/−0
• src/LLVM/Internal/Global.hs +146/−0
• src/LLVM/Internal/Inject.hs +11/−0
• src/LLVM/Internal/InlineAssembly.hs +68/−0
• src/LLVM/Internal/Instruction.hs +607/−0
• src/LLVM/Internal/InstructionDefs.hs +71/−0
• src/LLVM/Internal/IntegerPredicate.hs +23/−0
• src/LLVM/Internal/LibraryFunction.hsc +37/−0
• src/LLVM/Internal/MemoryBuffer.hs +57/−0
• src/LLVM/Internal/Metadata.hs +56/−0
• src/LLVM/Internal/Module.hs +526/−0
• src/LLVM/Internal/Operand.hs +131/−0
• src/LLVM/Internal/OrcJIT.hs +107/−0
• src/LLVM/Internal/OrcJIT/CompileOnDemandLayer.hs +146/−0
• src/LLVM/Internal/OrcJIT/IRCompileLayer.hs +74/−0
• src/LLVM/Internal/PassManager.hs +147/−0
• src/LLVM/Internal/RMWOperation.hs +25/−0
• src/LLVM/Internal/RawOStream.hs +79/−0
• src/LLVM/Internal/String.hs +61/−0
• src/LLVM/Internal/TailCallKind.hs +18/−0
• src/LLVM/Internal/Target.hs +314/−0
• src/LLVM/Internal/Threading.hs +13/−0
• src/LLVM/Internal/Type.hs +164/−0
• src/LLVM/Internal/Value.hs +24/−0
• src/LLVM/Module.hs +27/−0
• src/LLVM/OrcJIT.hs +11/−0
• src/LLVM/OrcJIT/CompileOnDemandLayer.hs +14/−0
• src/LLVM/OrcJIT/IRCompileLayer.hs +10/−0
• src/LLVM/PassManager.hs +14/−0
• src/LLVM/Relocation.hs +12/−0
• src/LLVM/Target.hs +22/−0
• src/LLVM/Target/LibraryFunction.hs +7/−0
• src/LLVM/Target/Options.hs +41/−0
• src/LLVM/Threading.hs +24/−0
• src/LLVM/Transforms.hs +197/−0
• test/LLVM/Test/Analysis.hs +113/−0
• test/LLVM/Test/CallingConvention.hs +57/−0
• test/LLVM/Test/Constants.hs +184/−0
• test/LLVM/Test/DataLayout.hs +86/−0
• test/LLVM/Test/ExecutionEngine.hs +59/−0
• test/LLVM/Test/Global.hs +42/−0
• test/LLVM/Test/InlineAssembly.hs +81/−0
• test/LLVM/Test/Instructions.hs +1235/−0
• test/LLVM/Test/Instrumentation.hs +159/−0
• test/LLVM/Test/Linking.hs +66/−0
• test/LLVM/Test/Metadata.hs +157/−0
• test/LLVM/Test/Module.hs +574/−0
• test/LLVM/Test/ObjectCode.hs +35/−0
• test/LLVM/Test/Optimization.hs +306/−0
• test/LLVM/Test/OrcJIT.hs +103/−0
• test/LLVM/Test/Support.hs +42/−0
• test/LLVM/Test/Target.hs +71/−0
• test/LLVM/Test/Tests.hs +39/−0
• test/Test.hs +10/−0

@@ -0,0 +1,30 @@+Copyright (c) 2013, Benjamin S. Scarlet and Google Inc.+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 Benjamin S. Scarlet nor the names of other+      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+HOLDER 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.

@@ -0,0 +1,189 @@+{-# LANGUAGE FlexibleInstances #-}+import Control.Exception (SomeException, try)+import Control.Monad+import Data.Functor+import Data.Maybe+import Data.List (isPrefixOf, (\\), intercalate, stripPrefix, find)+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Monoid+import Data.Char+import Distribution.Simple+import Distribution.Simple.PreProcess+import Distribution.Simple.Program+import Distribution.Simple.Setup hiding (Flag)+import Distribution.Simple.LocalBuildInfo+import Distribution.PackageDescription+import Distribution.Version+import System.Environment+import Distribution.System++-- define these selectively in C files (we are _not_ using HsFFI.h),+-- rather than universally in the ccOptions, because HsFFI.h currently defines them+-- without checking they're already defined and so causes warnings.+uncheckedHsFFIDefines = ["__STDC_LIMIT_MACROS"]++llvmVersion = Version [4,0] []++llvmConfigNames = [+  "llvm-config-" ++ (intercalate "." . map show . versionBranch $ llvmVersion),+  "llvm-config"+ ]++findJustBy :: Monad m => (a -> m (Maybe b)) -> [a] -> m (Maybe b)+findJustBy f (x:xs) = do+  x' <- f x+  case x' of+    Nothing -> findJustBy f xs+    j -> return j+findJustBy _ [] = return Nothing++class ProgramSearch a where+  programSearch :: (String -> a) -> a++-- this instance is used before Cabal-1.18.0, when programFindLocation took one argument+instance Monad m => ProgramSearch (v -> m (Maybe b)) where+  programSearch checkName = \v -> findJustBy (\n -> checkName n v) llvmConfigNames++-- this instance is used for and after Cabal-1.18.0, when programFindLocation took two arguments+instance Monad m => ProgramSearch (v -> p -> m (Maybe b)) where+  programSearch checkName = \v p -> findJustBy (\n -> checkName n v p) llvmConfigNames++class OldHookable hook where+  preHookOld :: (PackageDescription -> LocalBuildInfo -> UserHooks -> TestFlags -> IO ()) -> hook -> hook++-- this instance is used before Cabal-1.22.0.0, when testHook took four arguments+instance OldHookable (PackageDescription -> LocalBuildInfo -> UserHooks -> TestFlags -> IO ()) where+  preHookOld f hook = \packageDescription localBuildInfo userHooks testFlags -> do+    f packageDescription localBuildInfo userHooks testFlags+    hook packageDescription localBuildInfo userHooks testFlags++-- this instance is used for and after Cabal-1.22.0.0, when testHook took four five arguments+instance OldHookable (Args -> PackageDescription -> LocalBuildInfo -> UserHooks -> TestFlags -> IO ()) where+  preHookOld f hook = \args packageDescription localBuildInfo userHooks testFlags -> do+    f packageDescription localBuildInfo userHooks testFlags+    hook args packageDescription localBuildInfo userHooks testFlags++llvmProgram :: Program+llvmProgram = (simpleProgram "llvm-config") {+  programFindLocation = programSearch (programFindLocation . simpleProgram),+  programFindVersion =+    let+      stripSuffix suf str = let r = reverse in liftM r (stripPrefix (r suf) (r str))+      svnToTag v = maybe v (++"-svn") (stripSuffix "svn" v)+      trim = dropWhile isSpace . reverse . dropWhile isSpace . reverse+    in+      \v p -> findProgramVersion "--version" (svnToTag . trim) v p+ }++getLLVMConfig :: ConfigFlags -> IO ([String] -> IO String)+getLLVMConfig configFlags = do+  let verbosity = fromFlag $ configVerbosity configFlags+  (program, _, _) <- requireProgramVersion verbosity llvmProgram+                     (withinVersion llvmVersion)+                     (configPrograms configFlags)+  return $ getProgramOutput verbosity program++addToLdLibraryPath :: String -> IO ()+addToLdLibraryPath path = do+  let (ldLibraryPathVar, ldLibraryPathSep) =+        case buildOS of+          OSX -> ("DYLD_LIBRARY_PATH",":")+          _ -> ("LD_LIBRARY_PATH",":")+  v <- try $ getEnv ldLibraryPathVar :: IO (Either SomeException String)+  setEnv ldLibraryPathVar (path ++ either (const "") (ldLibraryPathSep ++) v)++addLLVMToLdLibraryPath :: ConfigFlags -> IO ()+addLLVMToLdLibraryPath configFlags = do+  llvmConfig <- getLLVMConfig configFlags+  [libDir] <- liftM lines $ llvmConfig ["--libdir"]+  addToLdLibraryPath libDir++-- | These flags are not relevant for us and dropping them allows+-- linking against LLVM build with Clang using GCC+ignoredCxxFlags :: [String]+ignoredCxxFlags =+  ["-Wcovered-switch-default", "-fcolor-diagnostics"] ++ map ("-D" ++) uncheckedHsFFIDefines++ignoredCFlags :: [String]+ignoredCFlags = ["-Wcovered-switch-default", "-Wdelete-non-virtual-dtor", "-fcolor-diagnostics"]++-- | Header directories are added separately to configExtraIncludeDirs+isIncludeFlag :: String -> Bool+isIncludeFlag flag = "-I" `isPrefixOf` flag++isIgnoredCFlag :: String -> Bool+isIgnoredCFlag flag = flag `elem` ignoredCFlags || isIncludeFlag flag++isIgnoredCxxFlag :: String -> Bool+isIgnoredCxxFlag flag = flag `elem` ignoredCxxFlags || isIncludeFlag flag++main = do+  let origUserHooks = simpleUserHooks++  defaultMainWithHooks origUserHooks {+    hookedPrograms = [ llvmProgram ],++    confHook = \(genericPackageDescription, hookedBuildInfo) configFlags -> do+      llvmConfig <- getLLVMConfig configFlags+      llvmCxxFlags <- do+        rawLlvmCxxFlags <- llvmConfig ["--cxxflags"]+        return . filter (not . isIgnoredCxxFlag) $ words rawLlvmCxxFlags+      let stdLib = maybe "stdc++"+                         (drop (length stdlibPrefix))+                         (find (isPrefixOf stdlibPrefix) llvmCxxFlags)+            where stdlibPrefix = "-stdlib=lib"+      includeDirs <- liftM lines $ llvmConfig ["--includedir"]+      libDirs@[libDir] <- liftM lines $ llvmConfig ["--libdir"]+      [llvmVersion] <- liftM lines $ llvmConfig ["--version"]+      let getLibs = liftM (map (fromJust . stripPrefix "-l") . words) . llvmConfig+          flags    = configConfigurationsFlags configFlags+          linkFlag = case lookup (FlagName "shared-llvm") flags of+                       Nothing     -> "--link-static"+                       Just shared -> if shared then "--link-shared" else "--link-static"+      libs       <- getLibs ["--libs", linkFlag]+      systemLibs <- getLibs ["--system-libs"]++      let genericPackageDescription' = genericPackageDescription {+            condLibrary = do+              libraryCondTree <- condLibrary genericPackageDescription+              return libraryCondTree {+                condTreeData = condTreeData libraryCondTree <> mempty {+                    libBuildInfo =+                      mempty {+                        ccOptions = llvmCxxFlags,+                        extraLibs = stdLib : libs ++ systemLibs+                      }+                  }+              }+           }+          configFlags' = configFlags {+            configExtraLibDirs = libDirs ++ configExtraLibDirs configFlags,+            configExtraIncludeDirs = includeDirs ++ configExtraIncludeDirs configFlags+           }+      addLLVMToLdLibraryPath configFlags'+      confHook simpleUserHooks (genericPackageDescription', hookedBuildInfo) configFlags',++    hookedPreProcessors =+      let origHookedPreprocessors = hookedPreProcessors origUserHooks+          newHsc buildInfo localBuildInfo =+              PreProcessor {+                  platformIndependent = platformIndependent (origHsc buildInfo localBuildInfo),+                  runPreProcessor = \inFiles outFiles verbosity -> do+                      llvmConfig <- getLLVMConfig (configFlags localBuildInfo)+                      llvmCFlags <- do+                          rawLlvmCFlags <- llvmConfig ["--cflags"]+                          return . filter (not . isIgnoredCFlag) $ words rawLlvmCFlags+                      let buildInfo' = buildInfo { ccOptions = "-Wno-variadic-macros" : llvmCFlags }+                      runPreProcessor (origHsc buildInfo' localBuildInfo) inFiles outFiles verbosity+              }+              where origHsc = fromMaybe ppHsc2hs (lookup "hsc" origHookedPreprocessors)+      in [("hsc", newHsc)] ++ origHookedPreprocessors,++    buildHook = \packageDescription localBuildInfo userHooks buildFlags -> do+          addLLVMToLdLibraryPath (configFlags localBuildInfo)+          buildHook origUserHooks packageDescription localBuildInfo userHooks buildFlags,++    testHook = preHookOld (\_ localBuildInfo _ _ -> addLLVMToLdLibraryPath (configFlags localBuildInfo))+               (testHook origUserHooks)+   }

@@ -0,0 +1,273 @@+name: llvm-hs+version: 4.0.0.0+license: BSD3+license-file: LICENSE+author: Anthony Cowley, Stephen Diehl, Moritz Kiefer <moritz.kiefer@purelyfunctional.org>, Benjamin S. Scarlet+maintainer: Anthony Cowley, Stephen Diehl, Moritz Kiefer <moritz.kiefer@purelyfunctional.org>+copyright: (c) 2013 Benjamin S. Scarlet and Google Inc.+homepage: http://github.com/llvm-hs/llvm-hs/+bug-reports: http://github.com/llvm-hs/llvm-hs/issues+build-type: Custom+stability: experimental+cabal-version: >= 1.8+category: Compilers/Interpreters, Code Generation+synopsis: General purpose LLVM bindings+description:+  llvm-hs is a set of Haskell bindings for LLVM <http://llvm.org/>. Unlike other current Haskell bindings,+  it uses an ADT to represent LLVM IR (<http://llvm.org/docs/LangRef.html>), and so offers two advantages: it+  handles almost all of the stateful complexities of using the LLVM API to build IR; and it supports moving IR not+  only from Haskell into LLVM C++ objects, but the other direction - from LLVM C++ into Haskell.+extra-source-files:+  src/LLVM/Internal/FFI/Analysis.h+  src/LLVM/Internal/FFI/Attribute.h+  src/LLVM/Internal/FFI/AttributeC.hpp+  src/LLVM/Internal/FFI/BinaryOperator.h+  src/LLVM/Internal/FFI/CallingConvention.h+  src/LLVM/Internal/FFI/Constant.h+  src/LLVM/Internal/FFI/GlobalValue.h+  src/LLVM/Internal/FFI/InlineAssembly.h+  src/LLVM/Internal/FFI/Instruction.h+  src/LLVM/Internal/FFI/LibFunc.h+  src/LLVM/Internal/FFI/Metadata.hpp+  src/LLVM/Internal/FFI/OrcJIT.h+  src/LLVM/Internal/FFI/SMDiagnostic.h+  src/LLVM/Internal/FFI/Target.h+  src/LLVM/Internal/FFI/Target.hpp+  src/LLVM/Internal/FFI/Type.h+  src/LLVM/Internal/FFI/Value.h+tested-with: GHC == 7.8.4, GHC == 7.10.3, GHC == 8.0.2++source-repository head+  type: git+  location: git://github.com/llvm-hs/llvm-hs.git+  branch: llvm-4++flag shared-llvm+  description: link against llvm shared rather than static library+  default: True++flag debug+  description: compile C(++) shims with debug info for ease of troubleshooting+  default: False++flag semigroups+  description: Add semigroups to build-depends for Data.List.NonEmpty. This will be selected automatically by cabal.+  default: False++custom-setup+  setup-depends: base+               , Cabal+               , containers++library+  build-tools: llvm-config+  ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-orphans -fno-warn-incomplete-patterns -fno-warn-missing-signatures -fno-warn-unused-matches -fno-warn-unused-do-bind -fno-warn-type-defaults+  if flag(semigroups)+    build-depends:+      base >= 4.7 && < 4.9,+      semigroups >= 0.18 && < 0.19+  else+    build-depends:+      base >= 4.9 && < 5+  build-depends:+    utf8-string >= 0.3.7,+    bytestring >= 0.9.1.10,+    transformers >= 0.3 && < 0.6,+    transformers-compat >= 0.4,+    mtl >= 2.1.3,+    template-haskell >= 2.5.0.0,+    containers >= 0.4.2.1,+    parsec >= 3.1.3,+    array >= 0.4.0.0,+    llvm-hs-pure == 4.0.0.0+  hs-source-dirs: src+  extensions:+    NoImplicitPrelude+    TupleSections+    DeriveDataTypeable+    EmptyDataDecls+    FlexibleContexts+    FlexibleInstances+    StandaloneDeriving+    ConstraintKinds+  exposed-modules:+    LLVM+    LLVM.Analysis+    LLVM.CodeGenOpt+    LLVM.CodeModel+    LLVM.CommandLine+    LLVM.Context+    LLVM.Diagnostic+    LLVM.ExecutionEngine+    LLVM.Internal.Analysis+    LLVM.Internal.Atomicity+    LLVM.Internal.Attribute+    LLVM.Internal.BasicBlock+    LLVM.Internal.CallingConvention+    LLVM.Internal.Coding+    LLVM.Internal.CommandLine+    LLVM.Internal.Constant+    LLVM.Internal.Context+    LLVM.Internal.DataLayout+    LLVM.Internal.DecodeAST+    LLVM.Internal.Diagnostic+    LLVM.Internal.EncodeAST+    LLVM.Internal.ExecutionEngine+    LLVM.Internal.FastMathFlags+    LLVM.Internal.FloatingPointPredicate+    LLVM.Internal.Function+    LLVM.Internal.Global+    LLVM.Internal.Inject+    LLVM.Internal.InlineAssembly+    LLVM.Internal.Instruction+    LLVM.Internal.InstructionDefs+    LLVM.Internal.IntegerPredicate+    LLVM.Internal.LibraryFunction+    LLVM.Internal.MemoryBuffer+    LLVM.Internal.Metadata+    LLVM.Internal.Module+    LLVM.Internal.OrcJIT+    LLVM.Internal.OrcJIT.CompileOnDemandLayer+    LLVM.Internal.OrcJIT.IRCompileLayer+    LLVM.Internal.Operand+    LLVM.Internal.PassManager+    LLVM.Internal.RawOStream+    LLVM.Internal.RMWOperation+    LLVM.Internal.String+    LLVM.Internal.TailCallKind+    LLVM.Internal.Target+    LLVM.Internal.Threading+    LLVM.Internal.Type+    LLVM.Internal.Value+    LLVM.Internal.FFI.Analysis+    LLVM.Internal.FFI.Attribute+    LLVM.Internal.FFI.Assembly+    LLVM.Internal.FFI.BasicBlock+    LLVM.Internal.FFI.BinaryOperator+    LLVM.Internal.FFI.Bitcode+    LLVM.Internal.FFI.Builder+    LLVM.Internal.FFI.ByteRangeCallback+    LLVM.Internal.FFI.Cleanup+    LLVM.Internal.FFI.CommandLine+    LLVM.Internal.FFI.Constant+    LLVM.Internal.FFI.Context+    LLVM.Internal.FFI.DataLayout+    LLVM.Internal.FFI.ExecutionEngine+    LLVM.Internal.FFI.Function+    LLVM.Internal.FFI.GlobalAlias+    LLVM.Internal.FFI.GlobalValue+    LLVM.Internal.FFI.GlobalVariable+    LLVM.Internal.FFI.InlineAssembly+    LLVM.Internal.FFI.Instruction+    LLVM.Internal.FFI.InstructionDefs+    LLVM.Internal.FFI.Iterate+    LLVM.Internal.FFI.LLVMCTypes+    LLVM.Internal.FFI.MemoryBuffer+    LLVM.Internal.FFI.Metadata+    LLVM.Internal.FFI.Module+    LLVM.Internal.FFI.OrcJIT+    LLVM.Internal.FFI.OrcJIT.CompileOnDemandLayer+    LLVM.Internal.FFI.OrcJIT.IRCompileLayer+    LLVM.Internal.FFI.PassManager+    LLVM.Internal.FFI.PtrHierarchy+    LLVM.Internal.FFI.RawOStream+    LLVM.Internal.FFI.SMDiagnostic+    LLVM.Internal.FFI.Target+    LLVM.Internal.FFI.Threading+    LLVM.Internal.FFI.Transforms+    LLVM.Internal.FFI.Type+    LLVM.Internal.FFI.User+    LLVM.Internal.FFI.Value+    LLVM.Module+    LLVM.OrcJIT+    LLVM.OrcJIT.CompileOnDemandLayer+    LLVM.OrcJIT.IRCompileLayer+    LLVM.PassManager+    LLVM.Relocation+    LLVM.Target+    LLVM.Target.LibraryFunction+    LLVM.Target.Options+    LLVM.Threading+    LLVM.Transforms++  other-modules:+    Control.Monad.AnyCont+    Control.Monad.AnyCont.Class+    Control.Monad.Trans.AnyCont++  include-dirs: src+  c-sources:+    src/LLVM/Internal/FFI/AssemblyC.cpp+    src/LLVM/Internal/FFI/AttributeC.cpp+    src/LLVM/Internal/FFI/BitcodeC.cpp+    src/LLVM/Internal/FFI/BuilderC.cpp+    src/LLVM/Internal/FFI/CallingConventionC.cpp+    src/LLVM/Internal/FFI/ConstantC.cpp+    src/LLVM/Internal/FFI/CommandLineC.cpp+    src/LLVM/Internal/FFI/ExecutionEngineC.cpp+    src/LLVM/Internal/FFI/FunctionC.cpp+    src/LLVM/Internal/FFI/GlobalAliasC.cpp+    src/LLVM/Internal/FFI/GlobalValueC.cpp+    src/LLVM/Internal/FFI/InlineAssemblyC.cpp+    src/LLVM/Internal/FFI/InstructionC.cpp+    src/LLVM/Internal/FFI/MetadataC.cpp+    src/LLVM/Internal/FFI/ModuleC.cpp+    src/LLVM/Internal/FFI/OrcJITC.cpp+    src/LLVM/Internal/FFI/RawOStreamC.cpp+    src/LLVM/Internal/FFI/PassManagerC.cpp+    src/LLVM/Internal/FFI/SMDiagnosticC.cpp+    src/LLVM/Internal/FFI/TargetC.cpp+    src/LLVM/Internal/FFI/TypeC.cpp+    src/LLVM/Internal/FFI/ValueC.cpp++  if flag(debug)+    cc-options: -g++test-suite test+  type: exitcode-stdio-1.0+  if flag(semigroups)+    build-depends:+      base >= 4.7 && < 4.9,+      semigroups >= 0.18 && < 0.19+  else+    build-depends:+      base >= 4.9 && < 5+  build-depends:+    bytestring >= 0.10 && < 0.11,+    tasty >= 0.11,+    tasty-hunit >= 0.9,+    tasty-quickcheck >= 0.8,+    QuickCheck >= 2.5.1.1,+    llvm-hs,+    llvm-hs-pure == 4.0.0.0,+    containers >= 0.4.2.1,+    mtl >= 2.1,+    transformers >= 0.3.0.0,+    transformers-compat,+    temporary >= 1.2 && < 1.3,+    pretty-show >= 1.6 && < 1.7+  hs-source-dirs: test+  extensions:+    TupleSections+    FlexibleInstances+    FlexibleContexts+  main-is: Test.hs+  other-modules:+    LLVM.Test.Analysis+    LLVM.Test.CallingConvention+    LLVM.Test.Constants+    LLVM.Test.DataLayout+    LLVM.Test.ExecutionEngine+    LLVM.Test.Global+    LLVM.Test.InlineAssembly+    LLVM.Test.Instructions+    LLVM.Test.Instrumentation+    LLVM.Test.Linking+    LLVM.Test.Metadata+    LLVM.Test.Module+    LLVM.Test.ObjectCode+    LLVM.Test.OrcJIT+    LLVM.Test.Optimization+    LLVM.Test.Support+    LLVM.Test.Target+    LLVM.Test.Tests

@@ -0,0 +1,30 @@+{-# LANGUAGE+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+module Control.Monad.AnyCont (+    MonadAnyCont(..),+    ScopeAnyCont(..),+    AnyContT(..),+    MonadTransAnyCont(..),+    runAnyContT,+    withAnyContT,+    mapAnyContT+  ) where++import Prelude++import Control.Monad.Trans.AnyCont+import Control.Monad.AnyCont.Class+import Control.Monad.Trans.Class+import Control.Monad.State.Class+import Control.Monad.Error.Class++instance MonadState s m => MonadState s (AnyContT m) where+  get = lift get+  put = lift . put+  state = lift . state++instance MonadError e m => MonadError e (AnyContT m) where+  throwError = lift . throwError+  x `catchError` h = anyContT $ \f -> (runAnyContT x f) `catchError` (\e -> runAnyContT (h e) f)

@@ -0,0 +1,54 @@+{-# LANGUAGE+  RankNTypes,+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+module Control.Monad.AnyCont.Class where++import Prelude++import Control.Monad.Trans.Class+import Control.Monad.Trans.AnyCont (AnyContT)+import qualified Control.Monad.Trans.AnyCont as AnyCont+import Control.Monad.Trans.Except as Except+import Control.Monad.Trans.State as State++class ScopeAnyCont m where+  scopeAnyCont :: m a -> m a++class MonadAnyCont b m where+  anyContToM :: (forall r . (a -> b r) -> b r) -> m a+++instance MonadTransAnyCont b m => MonadAnyCont b (AnyContT m) where+  anyContToM c = AnyCont.anyContT (liftAnyCont c)++instance Monad m => ScopeAnyCont (AnyContT m) where+  scopeAnyCont = lift . flip AnyCont.runAnyContT return+++instance (Monad m, MonadAnyCont b m) => MonadAnyCont b (StateT s m) where+  anyContToM x = lift $ anyContToM x++instance ScopeAnyCont m => ScopeAnyCont (StateT s m) where+  scopeAnyCont = StateT . (scopeAnyCont .) . runStateT+++instance (Monad m, MonadAnyCont b m) => MonadAnyCont b (ExceptT e m) where+  anyContToM x = lift $ anyContToM x+++instance ScopeAnyCont m => ScopeAnyCont (ExceptT e m) where+  scopeAnyCont = mapExceptT scopeAnyCont++class MonadTransAnyCont b m where+  liftAnyCont :: (forall r . (a -> b r) -> b r) -> (forall r . (a -> m r) -> m r)++instance MonadTransAnyCont b b where+  liftAnyCont c = c++instance MonadTransAnyCont b m => MonadTransAnyCont b (StateT s m) where+  liftAnyCont c = (\c q -> StateT $ \s -> c $ ($ s) . runStateT . q) (liftAnyCont c)++instance MonadTransAnyCont b m => MonadTransAnyCont b (ExceptT e m) where+  liftAnyCont c = (\c q -> ExceptT . c $ runExceptT . q) (liftAnyCont c)

@@ -0,0 +1,40 @@+{-# LANGUAGE+  RankNTypes+  #-}+module Control.Monad.Trans.AnyCont where++import LLVM.Prelude++import Control.Monad.Cont++newtype AnyContT m a = AnyContT { unAnyContT :: forall r . ContT r m a }++instance Functor (AnyContT m) where+  fmap f p = AnyContT $ fmap f . unAnyContT $ p++instance Applicative (AnyContT m) where+  pure a = AnyContT $ pure a+  f <*> v = AnyContT $ unAnyContT f <*> unAnyContT v++instance Monad m => Monad (AnyContT m) where+  AnyContT f >>= k = AnyContT $ f >>= unAnyContT . k+  return a = AnyContT $ return a+  fail s = AnyContT (ContT (\_ -> fail s))+  +instance MonadIO m => MonadIO (AnyContT m) where+  liftIO = lift . liftIO++instance MonadTrans AnyContT where+  lift ma = AnyContT (lift ma)++runAnyContT :: AnyContT m a -> (forall r . (a -> m r) -> m r)+runAnyContT = runContT . unAnyContT+anyContT :: (forall r . (a -> m r) -> m r) -> AnyContT m a+anyContT f = AnyContT (ContT f)++withAnyContT :: (forall r . (b -> m r) -> (a -> m r)) -> AnyContT m a -> AnyContT m b+withAnyContT f m = anyContT $ runAnyContT m . f++mapAnyContT :: (forall r . m r -> m r) -> AnyContT m a -> AnyContT m a+mapAnyContT f m = anyContT $ f . runAnyContT m+

@@ -0,0 +1,7 @@+-- | An interface to use LLVM in all capacities+module LLVM (+  module LLVM.Module+  ) where++import LLVM.Module+

@@ -0,0 +1,8 @@+-- | functionality for analyzing 'LLVM.Module.Module's.  Much of the analysis+-- possible with LLVM is managed internally, as needed by 'Transforms', and so is not+-- yet exposed here.+module LLVM.Analysis (+  verify+  ) where++import LLVM.Internal.Analysis

@@ -0,0 +1,12 @@+-- | Code generation options, used in specifying TargetMachine+module LLVM.CodeGenOpt where++import LLVM.Prelude++-- | <http://llvm.org/doxygen/namespacellvm_1_1CodeGenOpt.html>+data Level+    = None+    | Less+    | Default+    | Aggressive+    deriving (Eq, Ord, Read, Show, Typeable, Data)

@@ -0,0 +1,14 @@+-- | Relocations, used in specifying TargetMachine+module LLVM.CodeModel where++import LLVM.Prelude++-- | <http://llvm.org/doxygen/namespacellvm_1_1CodeModel.html>+data Model+    = Default+    | JITDefault+    | Small+    | Kernel+    | Medium+    | Large+    deriving (Eq, Read, Show, Typeable, Data)

@@ -0,0 +1,8 @@+-- | Tools for processing command line arguments, for command line tools build+-- with llvm (or for other uses forced into pretending to be such to get at (ack)+-- global state).+module LLVM.CommandLine (+  parseCommandLineOptions+) where++import LLVM.Internal.CommandLine

@@ -0,0 +1,7 @@+-- | functions for the LLVM Context object which holds thread-scope state+module LLVM.Context (+  Context,+  withContext+  ) where++import LLVM.Internal.Context

@@ -0,0 +1,33 @@+-- | Diagnostics describe parse errors+module LLVM.Diagnostic (+  DiagnosticKind(..),+  Diagnostic(..),+  diagnosticDisplay+ ) where++import LLVM.Prelude++-- | What kind of problem does a diagnostic describe?+data DiagnosticKind +  = ErrorKind+  | WarningKind+  | NoteKind+  deriving (Eq, Ord, Read, Show, Typeable, Data)++-- | A 'Diagnostic' described a problem during parsing of LLVM IR+data Diagnostic = Diagnostic {+    lineNumber :: Int,+    columnNumber :: Int,+    diagnosticKind :: DiagnosticKind,+    filename :: String,+    message :: String,+    lineContents :: String+  }+  deriving (Eq, Ord, Read, Show)++-- | Convert a 'Diagnostic' to a printable form.+diagnosticDisplay :: Diagnostic -> String+diagnosticDisplay d = +  (filename d) ++ ":" ++ show (lineNumber d) ++ ":" ++ show (columnNumber d)+  ++ ":\n" ++ show (diagnosticKind d) ++ ": " ++ (message d) ++ "\n"+  ++ (lineContents d) ++ "\n"

@@ -0,0 +1,8 @@+-- | Tools for JIT execution+module LLVM.ExecutionEngine (+  ExecutionEngine(..),+  ExecutableModule,+  MCJIT, withMCJIT+  ) where++import LLVM.Internal.ExecutionEngine

@@ -0,0 +1,24 @@+module LLVM.Internal.Analysis where++import LLVM.Prelude++import Control.Monad.AnyCont+import Control.Monad.Error.Class+import Control.Monad.IO.Class+import Control.Monad.Trans.Except++import qualified LLVM.Internal.FFI.Analysis as FFI+import qualified LLVM.Internal.FFI.LLVMCTypes as FFI++import LLVM.Internal.Module+import LLVM.Internal.Coding++-- | Run basic sanity checks on a 'Module'. Note that the same checks will trigger assertions+-- within LLVM if LLVM was built with them turned on, before this function can be is called.+verify :: Module -> ExceptT String IO ()+verify m = flip runAnyContT return $ do+  errorPtr <- alloca+  m' <- readModule m+  result <- decodeM =<< (liftIO $ FFI.verifyModule m' FFI.verifierFailureActionReturnStatus errorPtr)+  when result $ throwError =<< decodeM errorPtr+

@@ -0,0 +1,49 @@+{-# LANGUAGE+  TemplateHaskell,+  MultiParamTypeClasses+  #-}+module LLVM.Internal.Atomicity where++import LLVM.Prelude++import Data.Maybe++import qualified LLVM.Internal.FFI.LLVMCTypes as FFI++import LLVM.Internal.Coding+import qualified LLVM.AST as A++genCodingInstance [t| Maybe A.MemoryOrdering |] ''FFI.MemoryOrdering [+  (FFI.memoryOrderingNotAtomic, Nothing),+  (FFI.memoryOrderingUnordered, Just A.Unordered),+  (FFI.memoryOrderingMonotonic, Just A.Monotonic),+  (FFI.memoryOrderingAcquire, Just A.Acquire),+  (FFI.memoryOrderingRelease, Just A.Release),+  (FFI.memoryOrderingAcquireRelease, Just A.AcquireRelease),+  (FFI.memoryOrderingSequentiallyConsistent, Just A.SequentiallyConsistent)+ ]++genCodingInstance [t| A.SynchronizationScope |] ''FFI.SynchronizationScope [+  (FFI.synchronizationScopeSingleThread, A.SingleThread),+  (FFI.synchronizationScopeCrossThread, A.CrossThread)+ ]++instance Monad m => EncodeM m (Maybe A.Atomicity) (FFI.SynchronizationScope, FFI.MemoryOrdering) where+  encodeM a =+    return (,) `ap` encodeM (maybe A.SingleThread fst a) `ap` encodeM (liftM snd a)++instance Monad m => DecodeM m (Maybe A.Atomicity) (FFI.SynchronizationScope, FFI.MemoryOrdering) where+  decodeM (ss, ao) = return (liftM . (,)) `ap` decodeM ss `ap` decodeM ao++instance Monad m => EncodeM m A.Atomicity (FFI.SynchronizationScope, FFI.MemoryOrdering) where+  encodeM = encodeM . Just++instance Monad m => DecodeM m A.Atomicity (FFI.SynchronizationScope, FFI.MemoryOrdering) where+  decodeM = liftM fromJust . decodeM++instance Monad m => EncodeM m A.MemoryOrdering FFI.MemoryOrdering where+  encodeM = encodeM . Just++instance Monad m => DecodeM m A.MemoryOrdering FFI.MemoryOrdering where+  decodeM = liftM fromJust . decodeM+

@@ -0,0 +1,279 @@+{-# LANGUAGE+  MultiParamTypeClasses,+  ConstraintKinds,+  QuasiQuotes,+  UndecidableInstances,+  RankNTypes+  #-}+module LLVM.Internal.Attribute where++import LLVM.Prelude++import Control.Monad.AnyCont+import Control.Monad.IO.Class+import Control.Monad.State (gets)++import Foreign.C (CUInt)+import Foreign.Ptr+import Data.Either+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Maybe++import qualified LLVM.Internal.FFI.Attribute as FFI+import qualified LLVM.Internal.FFI.LLVMCTypes as FFI+import LLVM.Internal.FFI.LLVMCTypes (parameterAttributeKindP, functionAttributeKindP)  ++import qualified LLVM.AST.ParameterAttribute as A.PA  +import qualified LLVM.AST.FunctionAttribute as A.FA  ++import LLVM.Internal.Coding+import LLVM.Internal.Context  +import LLVM.Internal.EncodeAST+import LLVM.Internal.DecodeAST++inconsistentCases :: Show a => String -> a -> b+inconsistentCases name attr =+  error $ "llvm-hs internal error: cases inconstistent in " ++ name ++ " encoding for " ++ show attr++instance Monad m => EncodeM m A.PA.ParameterAttribute (Ptr FFI.ParameterAttrBuilder -> EncodeAST ()) where+  encodeM a = return $ \b -> liftIO $ case a of+    A.PA.Alignment v -> FFI.attrBuilderAddAlignment b v+    A.PA.Dereferenceable v -> FFI.attrBuilderAddDereferenceable b v+    A.PA.DereferenceableOrNull v -> FFI.attrBuilderAddDereferenceableOrNull b v+    _ -> FFI.attrBuilderAddParameterAttributeKind b $ case a of+      A.PA.ZeroExt -> FFI.parameterAttributeKindZExt+      A.PA.SignExt -> FFI.parameterAttributeKindSExt+      A.PA.InReg -> FFI.parameterAttributeKindInReg+      A.PA.SRet -> FFI.parameterAttributeKindStructRet+      A.PA.NoAlias -> FFI.parameterAttributeKindNoAlias+      A.PA.ByVal -> FFI.parameterAttributeKindByVal+      A.PA.NoCapture -> FFI.parameterAttributeKindNoCapture+      A.PA.Nest -> FFI.parameterAttributeKindNest+      A.PA.ReadOnly -> FFI.parameterAttributeKindReadOnly+      A.PA.ReadNone -> FFI.parameterAttributeKindReadNone+      A.PA.InAlloca -> FFI.parameterAttributeKindInAlloca+      A.PA.NonNull -> FFI.parameterAttributeKindNonNull+      A.PA.Returned -> FFI.parameterAttributeKindReturned+      A.PA.SwiftSelf -> FFI.parameterAttributeKindSwiftSelf+      A.PA.SwiftError -> FFI.parameterAttributeKindSwiftError+      A.PA.WriteOnly -> FFI.parameterAttributeKindWriteOnly+      A.PA.Alignment _ -> inconsistentCases "ParameterAttribute" a+      A.PA.Dereferenceable _ -> inconsistentCases "ParameterAttribute" a+      A.PA.DereferenceableOrNull _ -> inconsistentCases "ParameterAttribute" a++instance Monad m => EncodeM m A.FA.FunctionAttribute (Ptr FFI.FunctionAttrBuilder -> EncodeAST ()) where+  encodeM (A.FA.StringAttribute kind value) = return $ \b -> do+    (kindP, kindLen) <- encodeM kind+    (valueP, valueLen) <- encodeM value+    liftIO $ FFI.attrBuilderAddStringAttribute b kindP kindLen valueP valueLen+  encodeM a = return $ \b -> case a of+    A.FA.StackAlignment v -> liftIO $ FFI.attrBuilderAddStackAlignment b v+    A.FA.AllocSize x y -> do+      x' <- encodeM x+      y' <- encodeM y+      liftIO $ FFI.attrBuilderAddAllocSize b x' y'+    _ -> liftIO $ FFI.attrBuilderAddFunctionAttributeKind b $ case a of+      A.FA.Convergent -> FFI.functionAttributeKindConvergent+      A.FA.InaccessibleMemOnly -> FFI.functionAttributeKindInaccessibleMemOnly+      A.FA.InaccessibleMemOrArgMemOnly -> FFI.functionAttributeKindInaccessibleMemOrArgMemOnly+      A.FA.NoReturn -> FFI.functionAttributeKindNoReturn+      A.FA.NoUnwind -> FFI.functionAttributeKindNoUnwind+      A.FA.ReadNone -> FFI.functionAttributeKindReadNone+      A.FA.ReadOnly -> FFI.functionAttributeKindReadOnly+      A.FA.NoInline -> FFI.functionAttributeKindNoInline+      A.FA.NoRecurse -> FFI.functionAttributeKindNoRecurse+      A.FA.AlwaysInline -> FFI.functionAttributeKindAlwaysInline+      A.FA.MinimizeSize -> FFI.functionAttributeKindMinSize+      A.FA.OptimizeForSize -> FFI.functionAttributeKindOptimizeForSize+      A.FA.OptimizeNone -> FFI.functionAttributeKindOptimizeForSize+      A.FA.WriteOnly -> FFI.functionAttributeKindWriteOnly+      A.FA.ArgMemOnly -> FFI.functionAttributeKindArgMemOnly+      A.FA.StackProtect -> FFI.functionAttributeKindStackProtect+      A.FA.StackProtectReq -> FFI.functionAttributeKindStackProtectReq+      A.FA.StackProtectStrong -> FFI.functionAttributeKindStackProtectStrong+      A.FA.NoRedZone -> FFI.functionAttributeKindNoRedZone+      A.FA.NoImplicitFloat -> FFI.functionAttributeKindNoImplicitFloat+      A.FA.Naked -> FFI.functionAttributeKindNaked+      A.FA.InlineHint -> FFI.functionAttributeKindInlineHint+      A.FA.ReturnsTwice -> FFI.functionAttributeKindReturnsTwice+      A.FA.UWTable -> FFI.functionAttributeKindUWTable+      A.FA.NonLazyBind -> FFI.functionAttributeKindNonLazyBind+      A.FA.Builtin -> FFI.functionAttributeKindBuiltin+      A.FA.NoBuiltin -> FFI.functionAttributeKindNoBuiltin+      A.FA.Cold -> FFI.functionAttributeKindCold+      A.FA.JumpTable -> FFI.functionAttributeKindJumpTable+      A.FA.NoDuplicate -> FFI.functionAttributeKindNoDuplicate+      A.FA.SanitizeAddress -> FFI.functionAttributeKindSanitizeAddress+      A.FA.SanitizeThread -> FFI.functionAttributeKindSanitizeThread+      A.FA.SanitizeMemory -> FFI.functionAttributeKindSanitizeMemory+      A.FA.SafeStack -> FFI.functionAttributeKindSafeStack+      A.FA.StackAlignment _ -> inconsistentCases "FunctionAttribute" a+      A.FA.AllocSize _ _ -> inconsistentCases "FunctionAttribute" a+      A.FA.StringAttribute _ _ -> inconsistentCases "FunctionAttribute" a++instance DecodeM DecodeAST A.PA.ParameterAttribute FFI.ParameterAttribute where+  decodeM a = do+    enum <- liftIO $ FFI.parameterAttributeKindAsEnum a+    case enum of+      [parameterAttributeKindP|ZExt|] -> return A.PA.ZeroExt+      [parameterAttributeKindP|SExt|] -> return A.PA.SignExt+      [parameterAttributeKindP|InReg|] -> return A.PA.InReg+      [parameterAttributeKindP|StructRet|] -> return A.PA.SRet+      [parameterAttributeKindP|Alignment|] -> return A.PA.Alignment `ap` (liftIO $ FFI.attributeValueAsInt a)+      [parameterAttributeKindP|NoAlias|] -> return A.PA.NoAlias+      [parameterAttributeKindP|ByVal|] -> return A.PA.ByVal+      [parameterAttributeKindP|NoCapture|] -> return A.PA.NoCapture+      [parameterAttributeKindP|Nest|] -> return A.PA.Nest+      [parameterAttributeKindP|ReadOnly|] -> return A.PA.ReadOnly+      [parameterAttributeKindP|ReadNone|] -> return A.PA.ReadNone+      [parameterAttributeKindP|WriteOnly|] -> return A.PA.WriteOnly+      [parameterAttributeKindP|InAlloca|] -> return A.PA.InAlloca+      [parameterAttributeKindP|NonNull|] -> return A.PA.NonNull+      [parameterAttributeKindP|Dereferenceable|] -> return A.PA.Dereferenceable `ap` (liftIO $ FFI.attributeValueAsInt a)+      [parameterAttributeKindP|DereferenceableOrNull|] -> return A.PA.DereferenceableOrNull `ap` (liftIO $ FFI.attributeValueAsInt a)+      [parameterAttributeKindP|Returned|] -> return A.PA.Returned+      [parameterAttributeKindP|SwiftSelf|] -> return A.PA.SwiftSelf+      [parameterAttributeKindP|SwiftError|] -> return A.PA.SwiftError+      _ -> error $ "unhandled parameter attribute enum value: " ++ show enum++instance DecodeM DecodeAST A.FA.FunctionAttribute FFI.FunctionAttribute where+  decodeM a = do+    isString <- decodeM =<< (liftIO $ FFI.isStringAttribute a)+    if isString+       then+         return A.FA.StringAttribute+                  `ap` (decodeM $ FFI.attributeKindAsString a)+                  `ap` (decodeM $ FFI.attributeValueAsString a)                   +       else do+         enum <- liftIO $ FFI.functionAttributeKindAsEnum a+         case enum of+           [functionAttributeKindP|AllocSize|] -> do+             x <- alloca+             y <- alloca+             isJust <- liftIO $ FFI.attributeGetAllocSizeArgs a x y+             x' <- decodeM =<< peek x+             y' <- peek y+             yM <- decodeM (y', isJust)+             return (A.FA.AllocSize x' yM)+           [functionAttributeKindP|NoReturn|] -> return A.FA.NoReturn+           [functionAttributeKindP|NoUnwind|] -> return A.FA.NoUnwind+           [functionAttributeKindP|ReadNone|] -> return A.FA.ReadNone+           [functionAttributeKindP|ReadOnly|] -> return A.FA.ReadOnly+           [functionAttributeKindP|NoInline|] -> return A.FA.NoInline+           [functionAttributeKindP|NoRecurse|] -> return A.FA.NoRecurse+           [functionAttributeKindP|AlwaysInline|] -> return A.FA.AlwaysInline+           [functionAttributeKindP|MinSize|] -> return A.FA.MinimizeSize+           [functionAttributeKindP|OptimizeForSize|] -> return A.FA.OptimizeForSize+           [functionAttributeKindP|OptimizeNone|] -> return A.FA.OptimizeForSize+           [functionAttributeKindP|StackProtect|] -> return A.FA.StackProtect+           [functionAttributeKindP|StackProtectReq|] -> return A.FA.StackProtectReq+           [functionAttributeKindP|StackProtectStrong|] -> return A.FA.StackProtectStrong+           [functionAttributeKindP|NoRedZone|] -> return A.FA.NoRedZone+           [functionAttributeKindP|NoImplicitFloat|] -> return A.FA.NoImplicitFloat+           [functionAttributeKindP|Naked|] -> return A.FA.Naked+           [functionAttributeKindP|InlineHint|] -> return A.FA.InlineHint+           [functionAttributeKindP|StackAlignment|] -> return A.FA.StackAlignment `ap` (liftIO $ FFI.attributeValueAsInt a)+           [functionAttributeKindP|ReturnsTwice|] -> return A.FA.ReturnsTwice+           [functionAttributeKindP|UWTable|] -> return A.FA.UWTable+           [functionAttributeKindP|NonLazyBind|] -> return A.FA.NonLazyBind+           [functionAttributeKindP|Builtin|] -> return A.FA.Builtin+           [functionAttributeKindP|NoBuiltin|] -> return A.FA.NoBuiltin+           [functionAttributeKindP|Cold|] -> return A.FA.Cold+           [functionAttributeKindP|JumpTable|] -> return A.FA.JumpTable+           [functionAttributeKindP|NoDuplicate|] -> return A.FA.NoDuplicate+           [functionAttributeKindP|SanitizeAddress|] -> return A.FA.SanitizeAddress+           [functionAttributeKindP|SanitizeThread|] -> return A.FA.SanitizeThread+           [functionAttributeKindP|SanitizeMemory|] -> return A.FA.SanitizeMemory+           [functionAttributeKindP|ArgMemOnly|] -> return A.FA.ArgMemOnly+           [functionAttributeKindP|Convergent|] -> return A.FA.Convergent+           [functionAttributeKindP|InaccessibleMemOnly|] -> return A.FA.InaccessibleMemOnly+           [functionAttributeKindP|InaccessibleMemOrArgMemOnly|] -> return A.FA.InaccessibleMemOrArgMemOnly+           [functionAttributeKindP|SafeStack|] -> return A.FA.SafeStack+           [functionAttributeKindP|WriteOnly|] -> return A.FA.WriteOnly+           _ -> error $ "unhandled function attribute enum value: " ++ show enum++allocaAttrBuilder :: (Monad m, MonadAnyCont IO m) => m (Ptr (FFI.AttrBuilder a))+allocaAttrBuilder = do+  p <- allocaArray FFI.getAttrBuilderSize+  anyContToM $ \f -> do+    ab <- FFI.constructAttrBuilder p+    r <- f ab+    FFI.destroyAttrBuilder ab+    return r++instance EncodeM EncodeAST a (Ptr (FFI.AttrBuilder b) -> EncodeAST ()) => EncodeM EncodeAST (FFI.Index, [a]) (FFI.AttributeSet b) where+  encodeM (index, as) = scopeAnyCont $ do+    ab <- allocaAttrBuilder+    builds <- mapM encodeM as+    forM builds ($ ab) :: EncodeAST [()]+    Context context <- gets encodeStateContext+    liftIO $ FFI.getAttributeSet context index ab++instance EncodeM EncodeAST [A.FA.FunctionAttribute] FFI.FunctionAttributeSet where+  encodeM fas = encodeM (FFI.functionIndex, fas)++instance DecodeM DecodeAST a (FFI.Attribute b) => DecodeM DecodeAST [a] (FFI.AttributeSet b) where+  decodeM as = do+    np <- alloca+    as <- liftIO $ FFI.attributeSetGetAttributes as 0 np+    n <- peek np+    decodeM (n, as)+            +data MixedAttributeSet = MixedAttributeSet {+    functionAttributes :: [Either A.FA.GroupID A.FA.FunctionAttribute],+    returnAttributes :: [A.PA.ParameterAttribute],+    parameterAttributes :: Map CUInt [A.PA.ParameterAttribute]+  }+  deriving (Eq, Show)++data PreSlot+  = IndirectFunctionAttributes A.FA.GroupID+  | DirectFunctionAttributes [A.FA.FunctionAttribute]+  | ReturnAttributes [A.PA.ParameterAttribute]+  | ParameterAttributes CUInt [A.PA.ParameterAttribute]    ++instance EncodeM EncodeAST PreSlot FFI.MixedAttributeSet where+  encodeM preSlot = do+    let forget = liftM FFI.forgetAttributeType+    case preSlot of+      IndirectFunctionAttributes gid -> forget (referAttributeGroup gid)+      DirectFunctionAttributes fas -> forget (encodeM fas :: EncodeAST FFI.FunctionAttributeSet)+      ReturnAttributes as -> forget (encodeM (FFI.returnIndex, as) :: EncodeAST FFI.ParameterAttributeSet)+      ParameterAttributes i as -> forget (encodeM (fromIntegral (i + 1) :: FFI.Index, as) :: EncodeAST FFI.ParameterAttributeSet)++instance EncodeM EncodeAST MixedAttributeSet FFI.MixedAttributeSet where+  encodeM (MixedAttributeSet fAttrs rAttrs pAttrs) = do+    let directP = DirectFunctionAttributes (rights fAttrs)+        indirectPs = map IndirectFunctionAttributes (lefts fAttrs)+        returnP = ReturnAttributes rAttrs+        paramPs = [ ParameterAttributes x as | (x, as) <- Map.toList pAttrs ]+    (nAttrs, attrs) <- encodeM ([directP, returnP] ++ indirectPs ++ paramPs)+    Context context <- gets encodeStateContext+    liftIO $ FFI.mixAttributeSets context attrs nAttrs++instance DecodeM DecodeAST MixedAttributeSet FFI.MixedAttributeSet where+  decodeM mas = do+    numSlots <- if mas == nullPtr then return 0 else liftIO $ FFI.attributeSetNumSlots mas+    slotIndexes <- forM (take (fromIntegral numSlots) [0..]) $ \s -> do+      i <- liftIO $ FFI.attributeSetSlotIndex mas s+      return (i, s)+    let separate :: Ord k => k -> Map k a -> (Maybe a, Map k a)+        separate = Map.updateLookupWithKey (\_ _ -> Nothing)+        indexedSlots = Map.fromList slotIndexes+    unless (Map.size indexedSlots == length slotIndexes) $+           fail "unexpected slot index collision decoding mixed AttributeSet"+    let (functionSlot, otherSlots) = separate FFI.functionIndex (Map.fromList slotIndexes)+    functionAnnotation <- for (maybeToList functionSlot) $ \slot -> do+      a <- liftIO $ FFI.attributeSetSlotAttributes mas slot+      getAttributeGroupID a+    otherAttributeSets <- for otherSlots $ \slot -> do+      a <- liftIO $ FFI.attributeSetSlotAttributes mas slot+      decodeM (a :: FFI.ParameterAttributeSet)+    let (returnAttributeSet, shiftedParameterAttributeSets) = separate FFI.returnIndex otherAttributeSets+    return $ MixedAttributeSet {+                  functionAttributes = fmap Left functionAnnotation,+                  returnAttributes = join . maybeToList $ returnAttributeSet,+                  parameterAttributes = Map.mapKeysMonotonic (\x -> fromIntegral x - 1) shiftedParameterAttributeSets+                }+

@@ -0,0 +1,27 @@+module LLVM.Internal.BasicBlock where++import LLVM.Prelude++import Control.Monad.Trans+import Foreign.Ptr++import qualified LLVM.Internal.FFI.PtrHierarchy as FFI+import qualified LLVM.Internal.FFI.BasicBlock as FFI+import qualified LLVM.Internal.FFI.Iterate as FFI++import LLVM.Internal.DecodeAST+import LLVM.Internal.Coding+import LLVM.Internal.Instruction ()++import qualified LLVM.AST.Instruction as A++getBasicBlockTerminator :: Ptr FFI.BasicBlock -> DecodeAST (DecodeAST (A.Named A.Terminator))+getBasicBlockTerminator = decodeM <=< (liftIO . FFI.getBasicBlockTerminator)++getNamedInstructions :: Ptr FFI.BasicBlock -> DecodeAST (DecodeAST [A.Named A.Instruction])+getNamedInstructions b = do+  ffiInstructions <- liftIO $ FFI.getXs (FFI.getFirstInstruction b) FFI.getNextInstruction+  let n = length ffiInstructions+  liftM sequence . forM (take (n-1) ffiInstructions) $ decodeM++  

@@ -0,0 +1,71 @@+{-# LANGUAGE+  MultiParamTypeClasses,+  TemplateHaskell,+  QuasiQuotes+  #-}+module LLVM.Internal.CallingConvention where++import LLVM.Prelude++import LLVM.Internal.Coding+import Foreign.C.Types (CUInt(..))++import qualified LLVM.Internal.FFI.LLVMCTypes as FFI+import LLVM.Internal.FFI.LLVMCTypes (callingConventionP)++import qualified LLVM.AST.CallingConvention as A.CC++instance Monad m => EncodeM m A.CC.CallingConvention FFI.CallingConvention where+  encodeM cc = return $ +        case cc of+          A.CC.C -> FFI.callingConventionC+          A.CC.Fast -> FFI.callingConventionFast+          A.CC.Cold -> FFI.callingConventionCold+          A.CC.GHC ->  FFI.callingConventionGHC+          A.CC.HiPE -> FFI.callingConventionHiPE+          A.CC.WebKit_JS -> FFI.callingConventionWebKit_JS+          A.CC.AnyReg -> FFI.callingConventionAnyReg+          A.CC.PreserveMost -> FFI.callingConventionPreserveMost+          A.CC.PreserveAll -> FFI.callingConventionPreserveAll+          A.CC.X86_StdCall -> FFI.callingConventionX86_StdCall+          A.CC.X86_FastCall -> FFI.callingConventionX86_FastCall+          A.CC.ARM_APCS -> FFI.callingConventionARM_APCS+          A.CC.ARM_AAPCS -> FFI.callingConventionARM_AAPCS+          A.CC.ARM_AAPCS_VFP -> FFI.callingConventionARM_AAPCS_VFP+          A.CC.MSP430_INTR -> FFI.callingConventionMSP430_INTR+          A.CC.X86_ThisCall -> FFI.callingConventionX86_ThisCall+          A.CC.PTX_Kernel -> FFI.callingConventionPTX_Kernel+          A.CC.PTX_Device -> FFI.callingConventionPTX_Device+          A.CC.SPIR_FUNC -> FFI.callingConventionSPIR_FUNC+          A.CC.SPIR_KERNEL -> FFI.callingConventionSPIR_KERNEL+          A.CC.Intel_OCL_BI -> FFI.callingConventionIntel_OCL_BI+          A.CC.X86_64_SysV -> FFI.callingConventionX86_64_SysV+          A.CC.X86_64_Win64 -> FFI.callingConventionX86_64_Win64+          A.CC.Numbered cc' -> FFI.CallingConvention (fromIntegral cc')++instance Monad m => DecodeM m A.CC.CallingConvention FFI.CallingConvention where+  decodeM cc = return $ case cc of+    [callingConventionP|C|] -> A.CC.C+    [callingConventionP|Fast|] -> A.CC.Fast+    [callingConventionP|Cold|] -> A.CC.Cold+    [callingConventionP|GHC|] -> A.CC.GHC+    [callingConventionP|HiPE|] -> A.CC.HiPE+    [callingConventionP|WebKit_JS|] -> A.CC.WebKit_JS+    [callingConventionP|AnyReg|] -> A.CC.AnyReg+    [callingConventionP|PreserveMost|] -> A.CC.PreserveMost+    [callingConventionP|PreserveAll|] -> A.CC.PreserveAll+    [callingConventionP|X86_StdCall|] -> A.CC.X86_StdCall+    [callingConventionP|X86_FastCall|] -> A.CC.X86_FastCall+    [callingConventionP|ARM_APCS|] -> A.CC.ARM_APCS+    [callingConventionP|ARM_AAPCS|] -> A.CC.ARM_AAPCS+    [callingConventionP|ARM_AAPCS_VFP|] -> A.CC.ARM_AAPCS_VFP+    [callingConventionP|MSP430_INTR|] -> A.CC.MSP430_INTR+    [callingConventionP|X86_ThisCall|] -> A.CC.X86_ThisCall+    [callingConventionP|PTX_Kernel|] -> A.CC.PTX_Kernel+    [callingConventionP|PTX_Device|] -> A.CC.PTX_Device+    [callingConventionP|SPIR_FUNC|] -> A.CC.SPIR_FUNC+    [callingConventionP|SPIR_KERNEL|] -> A.CC.SPIR_KERNEL+    [callingConventionP|Intel_OCL_BI|] -> A.CC.Intel_OCL_BI+    [callingConventionP|X86_64_SysV|] -> A.CC.X86_64_SysV+    [callingConventionP|X86_64_Win64|] -> A.CC.X86_64_Win64+    FFI.CallingConvention (CUInt ci) | ci >= 64 -> A.CC.Numbered (fromIntegral ci)

@@ -0,0 +1,140 @@+{-# LANGUAGE+  TemplateHaskell,+  MultiParamTypeClasses,+  FunctionalDependencies,+  UndecidableInstances+  #-}+module LLVM.Internal.Coding where++import LLVM.Prelude++import Language.Haskell.TH+import Language.Haskell.TH.Quote++import Control.Monad.AnyCont+import Control.Monad.IO.Class++import Foreign.C+import Foreign.Ptr+import Foreign.Storable+import Foreign.Marshal.Alloc+import Foreign.Marshal.Array++import qualified LLVM.Internal.FFI.LLVMCTypes as FFI++class EncodeM e h c where+  encodeM :: h -> e c++class DecodeM d h c where+  decodeM :: c -> d h++genCodingInstance :: (Data c, Data h) => TypeQ -> Name -> [(c, h)] -> Q [Dec]+genCodingInstance ht ctn chs = do+  let n = const Nothing+  [d| +    instance Monad m => EncodeM m $(ht) $(conT ctn) where+      encodeM h = return $ $(+        caseE [| h |] [ match (dataToPatQ n h) (normalB (dataToExpQ n c)) [] | (c,h) <- chs ] +       )++    instance Monad m => DecodeM m $(ht) $(conT ctn) where+      decodeM c = return $ $(+        caseE [| c |] [ match (dataToPatQ n c) (normalB (dataToExpQ n h)) [] | (c,h) <- chs ]+       )+   |]++allocaArray :: (Integral i, Storable a, MonadAnyCont IO m) => i -> m (Ptr a)+allocaArray p = anyContToM $ Foreign.Marshal.Array.allocaArray (fromIntegral p)++alloca :: (Storable a, MonadAnyCont IO m) => m (Ptr a)+alloca = anyContToM Foreign.Marshal.Alloc.alloca++peek :: (Storable a, MonadIO m) => Ptr a -> m a+peek p = liftIO $ Foreign.Storable.peek p++peekByteOff :: (Storable a, MonadIO m) => Ptr a -> Int -> m a+peekByteOff p i = liftIO $ Foreign.Storable.peekByteOff p i++poke :: (Storable a, MonadIO m) => Ptr a -> a -> m ()+poke p a = liftIO $ Foreign.Storable.poke p a++pokeByteOff :: (Storable a, MonadIO m) => Ptr a -> Int -> a -> m ()+pokeByteOff p i a = liftIO $ Foreign.Storable.pokeByteOff p i a++peekArray :: (Integral i, Storable a, MonadIO m) => i -> Ptr a -> m [a]+peekArray n p = liftIO $ Foreign.Marshal.Array.peekArray (fromIntegral n) p++instance (Monad m, EncodeM m h c, Storable c, MonadAnyCont IO m) => EncodeM m [h] (CUInt, Ptr c) where+  encodeM hs = do+    hs <- mapM encodeM hs+    (anyContToM $ \x -> Foreign.Marshal.Array.withArrayLen hs $ \n hs -> x (fromIntegral n, hs))++instance (Monad m, DecodeM m h c, Storable c, MonadIO m) => DecodeM m [h] (CUInt, Ptr c) where+  decodeM (n, ca) = do+    cs <- liftIO $ Foreign.Marshal.Array.peekArray (fromIntegral n) ca+    mapM decodeM cs++instance Monad m => EncodeM m Bool FFI.LLVMBool where+  encodeM False = return $ FFI.LLVMBool 0+  encodeM True = return $ FFI.LLVMBool 1++instance Monad m => DecodeM m Bool FFI.LLVMBool where+  decodeM (FFI.LLVMBool 0) = return $ False+  decodeM (FFI.LLVMBool _) = return $ True++instance (Monad m, EncodeM m h (Ptr c)) => EncodeM m (Maybe h) (Ptr c) where+  encodeM = maybe (return nullPtr) encodeM++instance (Monad m, DecodeM m h (Ptr c)) => DecodeM m (Maybe h) (Ptr c) where+  decodeM p | p == nullPtr = return Nothing+            | otherwise = liftM Just $ decodeM p++instance Monad m => EncodeM m (Maybe Bool) (FFI.NothingAsMinusOne Bool) where+  encodeM = return . FFI.NothingAsMinusOne . maybe (-1) (fromIntegral . fromEnum)++instance Monad m => EncodeM m (Maybe Word) (FFI.NothingAsMinusOne Word) where+  encodeM = return . FFI.NothingAsMinusOne . maybe (-1) fromIntegral++instance Monad m => EncodeM m (Maybe Word) (CUInt, FFI.LLVMBool) where+  encodeM (Just a) = liftM2 (,) (encodeM a) (encodeM True)+  encodeM Nothing = return (0,) `ap` (encodeM False)++instance Monad m => DecodeM m (Maybe Word) (CUInt, FFI.LLVMBool) where+  decodeM (a, isJust) = do+    isJust' <- decodeM isJust+    if isJust'+       then liftM Just (decodeM a)+       else return Nothing++instance Monad m => EncodeM m Word CUInt where+  encodeM = return . fromIntegral++instance Monad m => EncodeM m Word32 CUInt where+  encodeM = return . fromIntegral++instance Monad m => EncodeM m Word64 CULong where+  encodeM = return . fromIntegral++instance Monad m => DecodeM m Word CUInt where+  decodeM = return . fromIntegral++instance Monad m => DecodeM m Word32 CUInt where+  decodeM = return . fromIntegral++instance Monad m => DecodeM m Word64 CULong where+  decodeM = return . fromIntegral++instance Monad m => EncodeM m Int32 CInt where+  encodeM = return . fromIntegral++instance Monad m => DecodeM m Int32 CInt where+  decodeM = return . fromIntegral++instance Monad m => DecodeM m Int CInt where+  decodeM = return . fromIntegral++instance Monad m => EncodeM m Word64 Word64 where+  encodeM = return++instance Monad m => DecodeM m Word64 Word64 where+  decodeM = return

@@ -0,0 +1,23 @@+module LLVM.Internal.CommandLine where++import LLVM.Prelude++import Control.Monad.AnyCont+import Control.Monad.IO.Class++import Foreign.Ptr++import qualified LLVM.Internal.FFI.CommandLine as FFI++import LLVM.Internal.Coding+import LLVM.Internal.String ()++-- | <http://llvm.org/doxygen/namespacellvm_1_1cl.html#a992a39dae9eb8d4e54ffee5467902803>+-- Sadly, there is occasionally some configuration one would like to control+-- in LLVM which are accessible only as command line flags setting global state,+-- as if the command line tools were the only use of LLVM. Very sad.+parseCommandLineOptions :: [String] -> Maybe String -> IO ()+parseCommandLineOptions args overview = flip runAnyContT return $ do+  args <- encodeM args+  overview <- maybe (return nullPtr) encodeM overview+  liftIO $ FFI.parseCommandLineOptions args overview

@@ -0,0 +1,248 @@+{-# LANGUAGE+  TemplateHaskell,+  QuasiQuotes,+  MultiParamTypeClasses,+  ScopedTypeVariables+  #-}+module LLVM.Internal.Constant where++import LLVM.Prelude++import qualified Language.Haskell.TH as TH+import qualified Language.Haskell.TH.Quote as TH+import qualified LLVM.Internal.InstructionDefs as ID++import Data.Bits+import Control.Monad.State (get, gets, modify, evalState)+import Control.Monad.AnyCont+import Control.Monad.IO.Class++import qualified Data.Map as Map+import Foreign.Ptr+import Foreign.Storable (Storable, sizeOf)++import qualified LLVM.Internal.FFI.Constant as FFI+import qualified LLVM.Internal.FFI.GlobalValue as FFI+import qualified LLVM.Internal.FFI.Instruction as FFI+import qualified LLVM.Internal.FFI.LLVMCTypes as FFI+import LLVM.Internal.FFI.LLVMCTypes (valueSubclassIdP)+import qualified LLVM.Internal.FFI.PtrHierarchy as FFI+import qualified LLVM.Internal.FFI.Type as FFI+import qualified LLVM.Internal.FFI.User as FFI+import qualified LLVM.Internal.FFI.Value as FFI+import qualified LLVM.Internal.FFI.BinaryOperator as FFI++import qualified LLVM.AST.Constant as A (Constant)+import qualified LLVM.AST.Constant as A.C hiding (Constant)+import qualified LLVM.AST.Type as A+import qualified LLVM.AST.IntegerPredicate as A (IntegerPredicate)+import qualified LLVM.AST.FloatingPointPredicate as A (FloatingPointPredicate)+import qualified LLVM.AST.Float as A.F++import LLVM.Internal.Coding+import LLVM.Internal.DecodeAST+import LLVM.Internal.EncodeAST+import LLVM.Internal.Context+import LLVM.Internal.Type ()+import LLVM.Internal.IntegerPredicate ()+import LLVM.Internal.FloatingPointPredicate ()++allocaWords :: forall a m . (Storable a, MonadAnyCont IO m, Monad m, MonadIO m) => Word32 -> m (Ptr a)+allocaWords nBits = do+  allocaArray (((nBits-1) `div` (8*(fromIntegral (sizeOf (undefined :: a))))) + 1)++instance EncodeM EncodeAST A.Constant (Ptr FFI.Constant) where+  encodeM c = scopeAnyCont $ case c of+    A.C.Int { A.C.integerBits = bits, A.C.integerValue = v } -> do+      t <- encodeM (A.IntegerType bits)+      words <- encodeM [+        fromIntegral ((v `shiftR` (w*64)) .&. 0xffffffffffffffff) :: Word64+        | w <- [0 .. ((fromIntegral bits-1) `div` 64)] +       ]+      liftIO $ FFI.constantIntOfArbitraryPrecision t words+    A.C.Float { A.C.floatValue = v } -> do+      Context context <- gets encodeStateContext+      let poke1 f = do+            let nBits = fromIntegral $ 8*(sizeOf f)+            words <- allocaWords nBits+            poke (castPtr words) f+            return (nBits, words)+          poke2 fh fl = do+             let nBits = fromIntegral $ 8*(sizeOf fh) + 8*(sizeOf fl)+             words <- allocaWords nBits+             pokeByteOff (castPtr words) 0 fl+             pokeByteOff (castPtr words) (sizeOf fl) fh+             return (nBits, words)+      (nBits, words) <- case v of+        A.F.Half f -> poke1 f+        A.F.Single f -> poke1 f+        A.F.Double f -> poke1 f+        A.F.X86_FP80 high low -> poke2 high low+        A.F.Quadruple high low -> poke2 high low+        A.F.PPC_FP128 high low -> poke2 high low+      let fpSem = case v of+                    A.F.Half _ -> FFI.floatSemanticsIEEEhalf+                    A.F.Single _ -> FFI.floatSemanticsIEEEsingle+                    A.F.Double _ -> FFI.floatSemanticsIEEEdouble+                    A.F.Quadruple _ _ -> FFI.floatSemanticsIEEEquad+                    A.F.X86_FP80 _ _ -> FFI.floatSemanticsx87DoubleExtended+                    A.F.PPC_FP128 _ _ -> FFI.floatSemanticsPPCDoubleDouble+      nBits <- encodeM nBits+      liftIO $ FFI.constantFloatOfArbitraryPrecision context nBits words fpSem+    A.C.GlobalReference _ n -> FFI.upCast <$> referGlobal n+    A.C.BlockAddress f b -> do+      f' <- referGlobal f+      b' <- getBlockForAddress f b+      liftIO $ FFI.blockAddress (FFI.upCast f') b'+    A.C.Struct nm p ms -> do+      p <- encodeM p+      ms <- encodeM ms+      case nm of+        Nothing -> do+          Context context <- gets encodeStateContext+          liftIO $ FFI.constStructInContext context ms p+        Just nm -> do+          t <- lookupNamedType nm+          liftIO $ FFI.constNamedStruct t ms+    A.C.TokenNone -> do+      Context context <- gets encodeStateContext+      liftIO $ FFI.getConstTokenNone context+    o -> $(do+      let constExprInfo =  ID.outerJoin ID.astConstantRecs (ID.innerJoin ID.astInstructionRecs ID.instructionDefs)+      TH.caseE [| o |] $ do+        (name, (Just (TH.RecC n fs), instrInfo)) <- Map.toList constExprInfo+        let fns = [ TH.mkName . TH.nameBase $ fn | (fn, _, _) <- fs ]+            coreCall n = TH.dyn $ "FFI.constant" ++ n+            buildBody c = [ TH.bindS (TH.varP fn) [| encodeM $(TH.varE fn) |] | fn <- fns ]+                          ++ [ TH.noBindS [| liftIO $(foldl TH.appE c (map TH.varE fns)) |] ]+            hasFlags = any (== ''Bool) [ h | (_, _, TH.ConT h) <- fs ]+        core <- case instrInfo of+          Just (_, iDef) -> do+            let opcode = TH.dataToExpQ (const Nothing) (ID.cppOpcode iDef)+            case ID.instructionKind iDef of+              ID.Binary | hasFlags -> return $ coreCall name+                        | True -> return [| $(coreCall "BinaryOperator") $(opcode) |]+              ID.Cast -> return [| $(coreCall "Cast") $(opcode) |]+              _ -> return $ coreCall name+          Nothing -> if (name `elem` ["Vector", "Null", "Array", "Undef"])+                      then return $ coreCall name+                      else []+        return $ TH.match+          (TH.recP n [(fn,) <$> (TH.varP . TH.mkName . TH.nameBase $ fn) | (fn, _, _) <- fs])+          (TH.normalB (TH.doE (buildBody core)))+          []+      )++instance DecodeM DecodeAST A.Constant (Ptr FFI.Constant) where+  decodeM c = scopeAnyCont $ do+    let v = FFI.upCast c :: Ptr FFI.Value+        u = FFI.upCast c :: Ptr FFI.User+    ft <- liftIO (FFI.typeOf v)+    t <- decodeM ft+    valueSubclassId <- liftIO $ FFI.getValueSubclassId v+    nOps <- liftIO $ FFI.getNumOperands u+    let globalRef = return A.C.GlobalReference +                    `ap` (return t)+                    `ap` (getGlobalName =<< liftIO (FFI.isAGlobalValue v))+        op = decodeM <=< liftIO . FFI.getConstantOperand c+        getConstantOperands = mapM op [0..nOps-1] +        getConstantData = do+          let nElements = case t of+                            A.VectorType n _ -> n+                            A.ArrayType n _ | n <= (fromIntegral (maxBound :: Word32)) -> fromIntegral n+          forM [0..nElements-1] $ do+             decodeM <=< liftIO . FFI.getConstantDataSequentialElementAsConstant c . fromIntegral++    case valueSubclassId of+      [valueSubclassIdP|Function|] -> globalRef+      [valueSubclassIdP|GlobalAlias|] -> globalRef+      [valueSubclassIdP|GlobalVariable|] -> globalRef+      [valueSubclassIdP|ConstantInt|] -> do+        np <- alloca+        wsp <- liftIO $ FFI.getConstantIntWords c np+        n <- peek np+        words <- decodeM (n, wsp)+        return $ A.C.Int (A.typeBits t) (foldr (\b a -> (a `shiftL` 64) .|. fromIntegral b) 0 (words :: [Word64]))+      [valueSubclassIdP|ConstantFP|] -> do+        let A.FloatingPointType nBits fmt = t+        ws <- allocaWords nBits+        liftIO $ FFI.getConstantFloatWords c ws+        A.C.Float <$> (+          case (nBits, fmt) of+            (16, A.IEEE) -> A.F.Half <$> peek (castPtr ws)+            (32, A.IEEE) -> A.F.Single <$> peek (castPtr ws)+            (64, A.IEEE) -> A.F.Double <$> peek (castPtr ws)+            (128, A.IEEE) -> A.F.Quadruple <$> peekByteOff (castPtr ws) 8 <*> peekByteOff (castPtr ws) 0+            (80, A.DoubleExtended) -> A.F.X86_FP80 <$> peekByteOff (castPtr ws) 8 <*> peekByteOff (castPtr ws) 0+            (128, A.PairOfFloats) -> A.F.PPC_FP128 <$> peekByteOff (castPtr ws) 8 <*> peekByteOff (castPtr ws) 0+            _ -> error $ "don't know how to decode floating point constant of type: " ++ show t+          )+      [valueSubclassIdP|ConstantPointerNull|] -> return $ A.C.Null t+      [valueSubclassIdP|ConstantAggregateZero|] -> return $ A.C.Null t+      [valueSubclassIdP|UndefValue|] -> return $ A.C.Undef t+      [valueSubclassIdP|BlockAddress|] -> +            return A.C.BlockAddress +               `ap` (getGlobalName =<< do liftIO $ FFI.isAGlobalValue =<< FFI.getBlockAddressFunction c)+               `ap` (getLocalName =<< do liftIO $ FFI.getBlockAddressBlock c)+      [valueSubclassIdP|ConstantStruct|] -> do+            return A.C.Struct+               `ap` (return $ case t of A.NamedTypeReference n -> Just n; _ -> Nothing)+               `ap` (decodeM =<< liftIO (FFI.isPackedStruct ft))+               `ap` getConstantOperands+      [valueSubclassIdP|ConstantDataArray|] -> +            return A.C.Array `ap` (return $ A.elementType t) `ap` getConstantData+      [valueSubclassIdP|ConstantArray|] -> +            return A.C.Array `ap` (return $ A.elementType t) `ap` getConstantOperands+      [valueSubclassIdP|ConstantDataVector|] -> +            return A.C.Vector `ap` getConstantData+      [valueSubclassIdP|ConstantExpr|] -> do+            cppOpcode <- liftIO $ FFI.getConstantCPPOpcode c+            $(+              TH.caseE [| cppOpcode |] $ do+                (name, ((TH.RecC n fs, _), iDef)) <- Map.toList $+                      ID.innerJoin (ID.innerJoin ID.astConstantRecs ID.astInstructionRecs) ID.instructionDefs+                let apWrapper o (fn, _, ct) = do+                      a <- case ct of+                             TH.ConT h+                               | h == ''A.Constant -> do+                                               operandNumber <- get+                                               modify (+1)+                                               return [| op $(TH.litE . TH.integerL $ operandNumber) |]+                               | h == ''A.Type -> return [| pure t |]+                               | h == ''A.IntegerPredicate -> +                                 return [| liftIO $ decodeM =<< FFI.getConstantICmpPredicate c |]+                               | h == ''A.FloatingPointPredicate -> +                                 return [| liftIO $ decodeM =<< FFI.getConstantFCmpPredicate c |]+                               | h == ''Bool -> case TH.nameBase fn of+                                                  "inBounds" -> return [| liftIO $ decodeM =<< FFI.getInBounds v |]+                                                  "exact" -> return [| liftIO $ decodeM =<< FFI.isExact v |]+                                                  "nsw" -> return [| liftIO $ decodeM =<< FFI.hasNoSignedWrap v |]+                                                  "nuw" -> return [| liftIO $ decodeM =<< FFI.hasNoUnsignedWrap v |]+                                                  x -> error $ "constant bool field " ++ show x ++ " not handled yet"+                             TH.AppT TH.ListT (TH.ConT h) +                               | h == ''Word32 -> +                                  return [|+                                        do+                                          np <- alloca+                                          isp <- liftIO $ FFI.getConstantIndices c np+                                          n <- peek np+                                          decodeM (n, isp)+                                        |]+                               | h == ''A.Constant -> +                                  case TH.nameBase fn of+                                    "indices" -> do+                                      operandNumber <- get+                                      return [| mapM op [$(TH.litE . TH.integerL $ operandNumber)..nOps-1] |]+                             _ -> error $ "unhandled constant expr field type: " ++ show fn ++ " - " ++ show ct+                      return [| $(o) `ap` $(a) |]+                return $ TH.match +                          (TH.dataToPatQ (const Nothing) (ID.cppOpcode iDef))+                          (TH.normalB (evalState (foldM apWrapper [| return $(TH.conE n) |] fs) 0))+                          []+             )+      [valueSubclassIdP|ConstantTokenNone|] -> return A.C.TokenNone+      _ -> error $ "unhandled constant valueSubclassId: " ++ show valueSubclassId+++  +  

@@ -0,0 +1,20 @@+module LLVM.Internal.Context where++import LLVM.Prelude++import Control.Exception+import Control.Concurrent++import Foreign.Ptr++import qualified LLVM.Internal.FFI.Context as FFI++-- | a Context object holds the state the of LLVM system needs for one thread of+-- | LLVM compilation. Once upon a time, in early versions of LLVM, this state was global.+-- | Then it got packed up in this object to allow multiple threads to compile at once.+data Context = Context (Ptr FFI.Context)++-- | Create a Context, run an action (to which it is provided), then destroy the Context.+withContext :: (Context -> IO a) -> IO a+withContext = runBound . bracket FFI.contextCreate FFI.contextDispose . (. Context)+  where runBound = if rtsSupportsBoundThreads then runInBoundThread else id

@@ -0,0 +1,23 @@+module LLVM.Internal.DataLayout where++import LLVM.Prelude++import Control.Exception+import Control.Monad.AnyCont+import Control.Monad.IO.Class++import Foreign.Ptr++import qualified LLVM.Internal.FFI.DataLayout as FFI++import LLVM.AST.DataLayout+import LLVM.DataLayout++import LLVM.Internal.Coding+import LLVM.Internal.String ()++withFFIDataLayout :: DataLayout -> (Ptr FFI.DataLayout -> IO a) -> IO a+withFFIDataLayout dl f = flip runAnyContT return $ do+  dls <- encodeM (dataLayoutToString dl)+  liftIO $ bracket (FFI.createDataLayout dls) FFI.disposeDataLayout f+

@@ -0,0 +1,172 @@+{-# LANGUAGE+  GeneralizedNewtypeDeriving,+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+module LLVM.Internal.DecodeAST where++import LLVM.Prelude++import Control.Monad.State+import Control.Monad.AnyCont++import Foreign.Ptr+import Foreign.C++import Data.Sequence (Seq)+import qualified Data.Sequence as Seq+import Data.Map (Map)+import qualified Data.Map as Map+import Data.Array (Array)+import qualified Data.Array as Array++import qualified LLVM.Internal.FFI.Attribute as FFI+import qualified LLVM.Internal.FFI.GlobalValue as FFI+import qualified LLVM.Internal.FFI.PtrHierarchy as FFI+import qualified LLVM.Internal.FFI.Value as FFI+import qualified LLVM.Internal.FFI.Type as FFI++import qualified LLVM.AST.Name as A+import qualified LLVM.AST.Operand as A (MetadataNodeID(..))+import qualified LLVM.AST.Attribute as A.A+import qualified LLVM.AST.COMDAT as A.COMDAT++import LLVM.Internal.Coding+import LLVM.Internal.String ()++type NameMap a = Map (Ptr a) Word++data DecodeState = DecodeState {+    globalVarNum :: NameMap FFI.GlobalValue,+    localVarNum :: NameMap FFI.Value,+    localNameCounter :: Maybe Word,+    namedTypeNum :: NameMap FFI.Type,+    typesToDefine :: Seq (Ptr FFI.Type),+    metadataNodesToDefine :: Seq (A.MetadataNodeID, Ptr FFI.MDNode),+    metadataNodes :: Map (Ptr FFI.MDNode) A.MetadataNodeID,+    metadataKinds :: Array Word String,+    parameterAttributeSets :: Map FFI.ParameterAttributeSet [A.A.ParameterAttribute],+    functionAttributeSetIDs :: Map FFI.FunctionAttributeSet A.A.GroupID,+    comdats :: Map (Ptr FFI.COMDAT) (String, A.COMDAT.SelectionKind)+  }+initialDecode = DecodeState {+    globalVarNum = Map.empty,+    localVarNum = Map.empty,+    localNameCounter = Nothing,+    namedTypeNum = Map.empty,+    typesToDefine = Seq.empty,+    metadataNodesToDefine = Seq.empty,+    metadataNodes = Map.empty,+    metadataKinds = Array.listArray (1,0) [],+    parameterAttributeSets = Map.empty,+    functionAttributeSetIDs = Map.empty,+    comdats = Map.empty+  }+newtype DecodeAST a = DecodeAST { unDecodeAST :: AnyContT (StateT DecodeState IO) a }+  deriving (+    Applicative,+    Functor,+    Monad,+    MonadIO,+    MonadState DecodeState,+    MonadAnyCont IO,+    ScopeAnyCont+  )++runDecodeAST :: DecodeAST a -> IO a+runDecodeAST d = flip evalStateT initialDecode . flip runAnyContT return . unDecodeAST $ d++localScope :: DecodeAST a -> DecodeAST a+localScope (DecodeAST x) = DecodeAST (tweak x)+  where tweak x = do+          modify (\s@DecodeState { localNameCounter = Nothing } -> s { localNameCounter = Just 0 })+          r <- x+          modify (\s@DecodeState { localNameCounter = Just _ } -> s { localNameCounter = Nothing })+          return r++getName :: (Ptr a -> IO CString)+           -> Ptr a+           -> (DecodeState -> NameMap a)+           -> DecodeAST Word+           -> DecodeAST A.Name+getName getCString v getNameMap generate = do+  name <- liftIO $ do+            n <- getCString v+            if n == nullPtr then return "" else decodeM n+  if name /= "" +     then+       return $ A.Name name+     else+       A.UnName <$> do+         nm <- gets getNameMap+         maybe generate return $ Map.lookup v nm++getValueName :: FFI.DescendentOf FFI.Value v => Ptr v -> (DecodeState -> NameMap v) -> DecodeAST Word -> DecodeAST A.Name+getValueName = getName (FFI.getValueName . FFI.upCast)++getLocalName :: FFI.DescendentOf FFI.Value v => Ptr v -> DecodeAST A.Name+getLocalName v' = do+  let v = FFI.upCast v'+  getValueName v localVarNum $ do+                    nm <- gets localVarNum+                    Just n <- gets localNameCounter+                    modify $ \s -> s { localNameCounter = Just (1 + n), localVarNum = Map.insert v n nm }+                    return n++getGlobalName :: FFI.DescendentOf FFI.GlobalValue v => Ptr v -> DecodeAST A.Name+getGlobalName v' = do+  let v = FFI.upCast v'+  getValueName v globalVarNum $ do+                     nm <- gets globalVarNum+                     let n = fromIntegral $ Map.size nm+                     modify $ \s -> s { globalVarNum = Map.insert v n nm }+                     return n+++getTypeName :: Ptr FFI.Type -> DecodeAST A.Name+getTypeName t = do+  getName FFI.getStructName t namedTypeNum $ do+                  nm <- gets namedTypeNum+                  let n = fromIntegral $ Map.size nm+                  modify $ \s -> s { namedTypeNum = Map.insert t n nm }+                  return n++saveNamedType :: Ptr FFI.Type -> DecodeAST ()+saveNamedType t = do+  modify $ \s -> s { typesToDefine = t Seq.<| typesToDefine s }++getMetadataNodeID :: Ptr FFI.MDNode -> DecodeAST A.MetadataNodeID+getMetadataNodeID p = do+  mdns <- gets metadataNodes+  case Map.lookup p mdns of+    Just r -> return r+    Nothing -> do+      let r = A.MetadataNodeID (fromIntegral (Map.size mdns))+      modify $ \s -> s { +        metadataNodesToDefine = (r, p) Seq.<| metadataNodesToDefine s,+        metadataNodes = Map.insert p r (metadataNodes s)+      }+      return r++takeTypeToDefine :: DecodeAST (Maybe (Ptr FFI.Type))+takeTypeToDefine = state $ \s -> case Seq.viewr (typesToDefine s) of+  remaining Seq.:> t -> (Just t, s { typesToDefine = remaining })+  _ -> (Nothing, s)++takeMetadataNodeToDefine :: DecodeAST (Maybe (A.MetadataNodeID, Ptr FFI.MDNode))+takeMetadataNodeToDefine = state $ \s -> case Seq.viewr (metadataNodesToDefine s) of+  remaining Seq.:> md -> (Just md, s { metadataNodesToDefine = remaining })+  _ -> (Nothing, s)                              ++instance DecodeM DecodeAST A.Name (Ptr FFI.BasicBlock) where+  decodeM = getLocalName++getAttributeGroupID :: FFI.FunctionAttributeSet -> DecodeAST A.A.GroupID+getAttributeGroupID p = do+  ids <- gets functionAttributeSetIDs+  case Map.lookup p ids of+    Just r -> return r+    Nothing -> do+      let r = A.A.GroupID (fromIntegral (Map.size ids))+      modify $ \s -> s { functionAttributeSetIDs = Map.insert p r (functionAttributeSetIDs s) }+      return r

@@ -0,0 +1,40 @@+{-# LANGUAGE+  TemplateHaskell,+  MultiParamTypeClasses+  #-}  +module LLVM.Internal.Diagnostic where++import LLVM.Prelude++import qualified LLVM.Internal.FFI.LLVMCTypes as FFI+import qualified LLVM.Internal.FFI.SMDiagnostic as FFI++import Control.Exception++import Foreign.Ptr++import LLVM.Diagnostic+import LLVM.Internal.Coding+import LLVM.Internal.String ()++genCodingInstance [t| DiagnosticKind |] ''FFI.DiagnosticKind [+    (FFI.diagnosticKindError, ErrorKind),+    (FFI.diagnosticKindWarning, WarningKind),+    (FFI.diagnosticKindNote, NoteKind)+  ]++withSMDiagnostic :: (Ptr FFI.SMDiagnostic -> IO a) -> IO a+withSMDiagnostic = bracket FFI.createSMDiagnostic FFI.disposeSMDiagnostic++getDiagnostic :: Ptr FFI.SMDiagnostic -> IO Diagnostic+getDiagnostic p = do+  l <- decodeM =<< FFI.getSMDiagnosticLineNo p+  c <- decodeM =<< FFI.getSMDiagnosticColumnNo p+  k <- decodeM =<< FFI.getSMDiagnosticKind p+  f <- decodeM $ FFI.getSMDiagnosticFilename p+  m <- decodeM $ FFI.getSMDiagnosticMessage p+  lc <- decodeM $ FFI.getSMDiagnosticLineContents p+  return $ Diagnostic { +    lineNumber = l, columnNumber = c, diagnosticKind = k, filename = f, message = m, lineContents = lc+   }+

@@ -0,0 +1,159 @@+{-# LANGUAGE+  GeneralizedNewtypeDeriving,+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+module LLVM.Internal.EncodeAST where++import LLVM.Prelude++import Control.Exception+import Control.Monad.AnyCont+import Control.Monad.Error.Class+import Control.Monad.State+import Control.Monad.Trans.Except++import Foreign.Ptr+import Foreign.C++import Data.Map (Map)+import qualified Data.Map as Map++import qualified LLVM.Internal.FFI.Attribute as FFI  +import qualified LLVM.Internal.FFI.Builder as FFI+import qualified LLVM.Internal.FFI.GlobalValue as FFI+import qualified LLVM.Internal.FFI.PtrHierarchy as FFI+import qualified LLVM.Internal.FFI.Value as FFI++import qualified LLVM.AST as A+import qualified LLVM.AST.Attribute as A.A++import LLVM.Internal.Context+import LLVM.Internal.Coding+import LLVM.Internal.String ()++data LocalValue+  = ForwardValue (Ptr FFI.Value)+  | DefinedValue (Ptr FFI.Value)++data EncodeState = EncodeState {+      encodeStateBuilder :: Ptr FFI.Builder,+      encodeStateContext :: Context,+      encodeStateLocals :: Map A.Name LocalValue,+      encodeStateGlobals :: Map A.Name (Ptr FFI.GlobalValue),+      encodeStateAllBlocks :: Map (A.Name, A.Name) (Ptr FFI.BasicBlock),+      encodeStateBlocks :: Map A.Name (Ptr FFI.BasicBlock),+      encodeStateMDNodes :: Map A.MetadataNodeID (Ptr FFI.MDNode),+      encodeStateNamedTypes :: Map A.Name (Ptr FFI.Type),+      encodeStateAttributeGroups :: Map A.A.GroupID FFI.FunctionAttributeSet,+      encodeStateCOMDATs :: Map String (Ptr FFI.COMDAT)+    }++newtype EncodeAST a = EncodeAST { unEncodeAST :: AnyContT (ExceptT String (StateT EncodeState IO)) a }+    deriving (+       Functor,+       Applicative,+       Monad,+       MonadIO,+       MonadState EncodeState,+       MonadError String,+       MonadAnyCont IO,+       ScopeAnyCont+     )++lookupNamedType :: A.Name -> EncodeAST (Ptr FFI.Type)+lookupNamedType n = do+  t <- gets $ Map.lookup n . encodeStateNamedTypes+  maybe (throwError $ "reference to undefined type: " ++ show n) return t++defineType :: A.Name -> Ptr FFI.Type -> EncodeAST ()+defineType n t = modify $ \s -> s { encodeStateNamedTypes = Map.insert n t (encodeStateNamedTypes s) }++runEncodeAST :: Context -> EncodeAST a -> ExceptT String IO a+runEncodeAST context@(Context ctx) (EncodeAST a) = ExceptT $+    bracket (FFI.createBuilderInContext ctx) FFI.disposeBuilder $ \builder -> do+      let initEncodeState = EncodeState {+              encodeStateBuilder = builder,+              encodeStateContext = context,+              encodeStateLocals = Map.empty,+              encodeStateGlobals = Map.empty,+              encodeStateAllBlocks = Map.empty,+              encodeStateBlocks = Map.empty,+              encodeStateMDNodes = Map.empty,+              encodeStateNamedTypes = Map.empty,+              encodeStateAttributeGroups = Map.empty,+              encodeStateCOMDATs = Map.empty+            }+      flip evalStateT initEncodeState . runExceptT . flip runAnyContT return $ a++withName :: A.Name -> (CString -> IO a) -> IO a+withName (A.Name n) = withCString n+withName (A.UnName _) = withCString ""++instance MonadAnyCont IO m => EncodeM m A.Name CString where+  encodeM (A.Name n) = encodeM n+  encodeM _ = encodeM ""++phase :: EncodeAST a -> EncodeAST (EncodeAST a)+phase p = do+  let s0 `withLocalsFrom` s1 = s0 {+         encodeStateLocals = encodeStateLocals s1,+         encodeStateBlocks = encodeStateBlocks s1+        }+  s <- get+  return $ do+    s' <- get+    put $ s' `withLocalsFrom` s+    r <- p+    modify (`withLocalsFrom` s')+    return r++defineLocal :: FFI.DescendentOf FFI.Value v => A.Name -> Ptr v -> EncodeAST ()+defineLocal n v' = do+  let v = FFI.upCast v'+  def <- gets $ Map.lookup n . encodeStateLocals+  case def of+    Just (ForwardValue dummy) -> liftIO $ FFI.replaceAllUsesWith dummy v+    _ -> return ()+  modify $ \b -> b { encodeStateLocals = Map.insert n (DefinedValue v) (encodeStateLocals b) }++defineGlobal :: FFI.DescendentOf FFI.GlobalValue v => A.Name -> Ptr v -> EncodeAST ()+defineGlobal n v = modify $ \b -> b { encodeStateGlobals =  Map.insert n (FFI.upCast v) (encodeStateGlobals b) }++defineMDNode :: A.MetadataNodeID -> Ptr FFI.MDNode -> EncodeAST ()+defineMDNode n v = modify $ \b -> b { encodeStateMDNodes = Map.insert n (FFI.upCast v) (encodeStateMDNodes b) }++defineAttributeGroup :: A.A.GroupID -> FFI.FunctionAttributeSet -> EncodeAST ()+defineAttributeGroup gid attrs = modify $ \b -> b { encodeStateAttributeGroups = Map.insert gid attrs (encodeStateAttributeGroups b) }++defineCOMDAT :: String -> Ptr FFI.COMDAT -> EncodeAST ()+defineCOMDAT name cd = modify $ \b -> b { encodeStateCOMDATs = Map.insert name cd (encodeStateCOMDATs b) }++refer :: (Show n, Ord n) => (EncodeState -> Map n v) -> n -> EncodeAST v -> EncodeAST v+refer r n f = do+  mop <- gets $ Map.lookup n . r+  maybe f return mop++undefinedReference :: Show n => String -> n -> EncodeAST a+undefinedReference m n = throwError $ "reference to undefined " ++ m ++ ": " ++ show n++referOrThrow :: (Show n, Ord n) => (EncodeState -> Map n v) -> String -> n -> EncodeAST v+referOrThrow r m n = refer r n $ undefinedReference m n++referGlobal = referOrThrow encodeStateGlobals "global"+referMDNode = referOrThrow encodeStateMDNodes "metadata node"+referAttributeGroup = referOrThrow encodeStateAttributeGroups "attribute group"+referCOMDAT = referOrThrow encodeStateCOMDATs "COMDAT"++defineBasicBlock :: A.Name -> A.Name -> Ptr FFI.BasicBlock -> EncodeAST ()+defineBasicBlock fn n b = modify $ \s -> s {+  encodeStateBlocks = Map.insert n b (encodeStateBlocks s),+  encodeStateAllBlocks = Map.insert (fn, n) b (encodeStateAllBlocks s)+}++instance EncodeM EncodeAST A.Name (Ptr FFI.BasicBlock) where+  encodeM = referOrThrow encodeStateBlocks "block"++getBlockForAddress :: A.Name -> A.Name -> EncodeAST (Ptr FFI.BasicBlock)+getBlockForAddress fn n = referOrThrow encodeStateAllBlocks "blockaddress" (fn, n)+

@@ -0,0 +1,134 @@+{-# LANGUAGE+  MultiParamTypeClasses,+  FunctionalDependencies,+  RankNTypes+  #-}+module LLVM.Internal.ExecutionEngine where++import LLVM.Prelude++import Control.Exception+import Control.Monad.IO.Class+import Control.Monad.AnyCont+import Control.Monad.Trans.Except++import Data.IORef+import Foreign.Ptr+import Foreign.C (CUInt, CString)+import Foreign.Marshal.Alloc (allocaBytes)++import qualified LLVM.Internal.FFI.PtrHierarchy as FFI+import qualified LLVM.Internal.FFI.ExecutionEngine as FFI+import qualified LLVM.Internal.FFI.Module as FFI+import qualified LLVM.Internal.FFI.LLVMCTypes as FFI++import LLVM.Internal.Module+import LLVM.Internal.Context+import LLVM.Internal.Coding+import qualified LLVM.CodeModel as CodeModel+import LLVM.Internal.Target+import qualified LLVM.AST as A++removeModule :: Ptr FFI.ExecutionEngine -> Ptr FFI.Module -> IO ()+removeModule e m = flip runAnyContT return $ do+  d0 <- alloca+  d1 <- alloca+  r <- liftIO $ FFI.removeModule e m d0 d1+  when (r /= 0) $ fail "FFI.removeModule failure"++-- | a 'ExecutableModule' e represents a 'Module' which is currently "in" an+-- 'ExecutionEngine', and so the functions of which may be executed.+data ExecutableModule e = ExecutableModule e (Ptr FFI.Module)++-- | <http://llvm.org/doxygen/classllvm_1_1ExecutionEngine.html>+class ExecutionEngine e f | e -> f where+  withModuleInEngine :: e -> Module -> (ExecutableModule e -> IO a) -> IO a+  getFunction :: ExecutableModule e -> A.Name -> IO (Maybe f)++instance ExecutionEngine (Ptr FFI.ExecutionEngine) (FunPtr ()) where+  withModuleInEngine e m f = do+    m' <- readModule m+    bracket_ (FFI.addModule e m') (removeModule e m') (f (ExecutableModule e m'))+  getFunction (ExecutableModule e m) (A.Name name) = flip runAnyContT return $ do+    name <- encodeM name+    f <- liftIO $ FFI.getNamedFunction m name+    if f == nullPtr +      then +        return Nothing+      else+        do+          p <- liftIO $ FFI.getPointerToGlobal e (FFI.upCast f)+          return $ if p == nullPtr then Nothing else Just (castPtrToFunPtr p)++withExecutionEngine :: +  Context ->+  Maybe (Ptr FFI.Module) -> +  (Ptr (Ptr FFI.ExecutionEngine) -> Ptr FFI.Module -> Ptr (FFI.OwnerTransfered CString) -> IO CUInt) ->+  (Ptr FFI.ExecutionEngine -> IO a) ->+  IO a+withExecutionEngine c m createEngine f = flip runAnyContT return $ do+  liftIO initializeNativeTarget+  outExecutionEngine <- alloca+  outErrorCStringPtr <- alloca+  dummyModule <- maybe (anyContToM $ liftM (either undefined id) . runExceptT+                            . withModuleFromAST c (A.Module "" "" Nothing Nothing []))+                 (liftIO . newModule) m+  dummyModule' <- readModule dummyModule+  r <- liftIO $ createEngine outExecutionEngine dummyModule' outErrorCStringPtr+  when (r /= 0) $ fail =<< decodeM outErrorCStringPtr+  executionEngine <- anyContToM $ bracket (peek outExecutionEngine) FFI.disposeExecutionEngine+  liftIO $ removeModule executionEngine dummyModule'+  liftIO $ f executionEngine++data MCJITState+  = Deferred (forall a . Module -> (Ptr FFI.ExecutionEngine -> IO a) -> IO a)+  | Constructed (Ptr FFI.ExecutionEngine)++-- | <http://llvm.org/doxygen/classllvm_1_1MCJIT.html>+-- <http://blog.llvm.org/2010/04/intro-to-llvm-mc-project.html>+-- N.B. - the LLVM MCJIT does not current support adding multiple+-- modules to any one instance of the MCJIT.+newtype MCJIT = MCJIT (IORef MCJITState)++-- | bracket the creation and destruction of an 'MCJIT'+withMCJIT :: +  Context+  -> Maybe Word -- ^ optimization level+  -> Maybe CodeModel.Model+  -> Maybe Bool -- ^ True to disable frame pointer elimination+  -> Maybe Bool -- ^ True to enable fast instruction selection+--  -> Maybe MemoryManager -- llvm-hs doesn't support this yet+  -> (MCJIT -> IO a)+  -> IO a+withMCJIT c opt cm fpe fisel f = do+  FFI.linkInMCJIT+  let createMCJITCompilerForModule e m s = do+        size <- FFI.getMCJITCompilerOptionsSize+        allocaBytes (fromIntegral size) $ \p -> do+          FFI.initializeMCJITCompilerOptions p size+          maybe (return ()) (FFI.setMCJITCompilerOptionsOptLevel p <=< encodeM) opt+          maybe (return ()) (FFI.setMCJITCompilerOptionsCodeModel p <=< encodeM) cm+          maybe (return ()) (FFI.setMCJITCompilerOptionsNoFramePointerElim p <=< encodeM) fpe+          maybe (return ()) (FFI.setMCJITCompilerOptionsEnableFastISel p <=< encodeM) fisel+          FFI.createMCJITCompilerForModule e m p size s+  t <- newIORef (Deferred $ \mod f -> do m' <- readModule mod+                                         withExecutionEngine c (Just m') createMCJITCompilerForModule f)+  f (MCJIT t)++instance ExecutionEngine MCJIT (FunPtr ()) where+  withModuleInEngine (MCJIT s) m f = do+    jitState <- readIORef s+    let f' (ExecutableModule _ m) = f (ExecutableModule (MCJIT s) m)+    case jitState of+      Deferred c -> c m $ \e -> +        bracket_ +         (writeIORef s (Constructed e))+         (writeIORef s jitState)+         (withModuleInEngine e m f')+      Constructed e -> withModuleInEngine e m f'++  getFunction (ExecutableModule (MCJIT r) m) n = do+    s <- liftIO $ readIORef r+    case s of+      Deferred _ -> return Nothing+      Constructed e -> getFunction (ExecutableModule e m) n

@@ -0,0 +1,11 @@+#ifndef __LLVM_INTERNAL_FFI__ANALYSIS__H__+#define __LLVM_INTERNAL_FFI__ANALYSIS__H__++#include "llvm-c/Analysis.h"++#define LLVM_HS_FOR_EACH_VERIFIER_FAILURE_ACTION(macro) \+	macro(AbortProcess) \+	macro(PrintMessage) \+	macro(ReturnStatus)++#endif

@@ -0,0 +1,15 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+module LLVM.Internal.FFI.Analysis where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.Module++foreign import ccall unsafe "LLVMVerifyModule" verifyModule ::+  Ptr Module -> VerifierFailureAction -> Ptr (OwnerTransfered CString) -> IO LLVMBool

@@ -0,0 +1,29 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}++-- | Functions to read and write textual LLVM assembly+module LLVM.Internal.FFI.Assembly where++import LLVM.Prelude++import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.MemoryBuffer+import LLVM.Internal.FFI.Module+import LLVM.Internal.FFI.PtrHierarchy++import Foreign.C+import Foreign.Ptr++-- | Use LLVM's parser to parse a string of llvm assembly in a memory buffer to get a module+foreign import ccall unsafe "LLVM_Hs_ParseLLVMAssembly" parseLLVMAssembly ::+  Ptr Context -> OwnerTransfered (Ptr MemoryBuffer) -> Ptr (OwnerTransfered CString) -> IO (Ptr Module)+++-- | LLVM's serializer to generate a string of llvm assembly from a module+foreign import ccall unsafe "LLVM_Hs_WriteLLVMAssembly" writeLLVMAssembly ::+  Ptr Module -> Ptr RawOStream -> IO ()+++

@@ -0,0 +1,28 @@+#define __STDC_LIMIT_MACROS+#include "llvm/AsmParser/Parser.h"+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/Module.h"+#include "llvm/Pass.h"+#include "llvm/Support/MemoryBuffer.h"+#include "llvm/Support/SourceMgr.h"+#include "llvm/Support/raw_ostream.h"++#include "llvm-c/Core.h"+#include "llvm-c/IRReader.h"++using namespace llvm;++extern "C" {++LLVMModuleRef LLVM_Hs_ParseLLVMAssembly(LLVMContextRef context,+                                             LLVMMemoryBufferRef memoryBuffer,+                                             char **error) {+  LLVMModuleRef M;+  LLVMParseIRInContext(context, memoryBuffer, &M, error);+  return M;+}++void LLVM_Hs_WriteLLVMAssembly(LLVMModuleRef module, raw_ostream &os) {+  os << *unwrap(module);+}+}

@@ -0,0 +1,69 @@+#ifndef __LLVM_INTERNAL_FFI__ATTRIBUTES__H__+#define __LLVM_INTERNAL_FFI__ATTRIBUTES__H__+++// The last three arguments are flags indicating if this is a+// parameter attribute, function result attribute or function attribute.+#define LLVM_HS_FOR_EACH_ATTRIBUTE_KIND(macro)	\+	macro(None,F,F,F)                                 \+	macro(Alignment,T,T,F)                            \+	macro(AllocSize,F,F,T)                            \+	macro(AlwaysInline,F,F,T)                         \+	macro(ArgMemOnly,F,F,T)                           \+	macro(Builtin,F,F,T)                              \+	macro(ByVal,T,F,F)                                \+	macro(Cold,F,F,T)                                 \+	macro(Convergent,F,F,T)                           \+	macro(Dereferenceable,T,T,F)                      \+	macro(DereferenceableOrNull,T,T,F)                \+	macro(InAlloca,T,F,F)                             \+	macro(InReg,T,T,F)                                \+	macro(InaccessibleMemOnly,F,F,T) \+	macro(InaccessibleMemOrArgMemOnly,F,F,T) \+	macro(InlineHint,F,F,T)                           \+	macro(JumpTable,F,F,T)                            \+	macro(MinSize,F,F,T)                              \+	macro(Naked,F,F,T)                                \+	macro(Nest,T,F,F)                                 \+	macro(NoAlias,T,T,F)                              \+	macro(NoBuiltin,F,F,T)                            \+	macro(NoCapture,T,F,F)                            \+	macro(NoDuplicate,F,F,T)                          \+	macro(NoImplicitFloat,F,F,T)                      \+	macro(NoInline,F,F,T)                             \+	macro(NoRecurse,F,F,T)                            \+	macro(NoRedZone,F,F,T)                            \+	macro(NoReturn,F,F,T)                             \+	macro(NoUnwind,F,F,T)                             \+	macro(NonLazyBind,F,F,T)                          \+	macro(NonNull,T,T,F)                              \+	macro(OptimizeForSize,F,F,T)                      \+	macro(OptimizeNone,F,F,T)                         \+	macro(ReadNone,T,F,T)                             \+	macro(ReadOnly,T,F,T)                             \+	macro(Returned,T,F,F)                             \+	macro(ReturnsTwice,F,F,T)                         \+	macro(SExt,T,T,F)                                 \+	macro(SafeStack,F,F,T)                            \+	macro(SanitizeAddress,F,F,T)                      \+	macro(SanitizeMemory,F,F,T)                       \+	macro(SanitizeThread,F,F,T)                       \+	macro(StackAlignment,F,F,T)                       \+	macro(StackProtect,F,F,T)                         \+	macro(StackProtectReq,F,F,T)                      \+	macro(StackProtectStrong,F,F,T)                   \+	macro(StructRet,T,F,F)                            \+	macro(SwiftError,T,F,F)                           \+	macro(SwiftSelf,T,F,F)                            \+	macro(UWTable,F,F,T)                              \+	macro(WriteOnly,T,F,T)                            \+	macro(ZExt,T,T,F)                                 \+	macro(EndAttrKinds,F,F,F)++typedef enum {+#define ENUM_CASE(x,p,r,f) LLVM_Hs_AttributeKind_ ## x,+LLVM_HS_FOR_EACH_ATTRIBUTE_KIND(ENUM_CASE)+#undef ENUM_CASE+} LLVM_Hs_AttributeKind;++#endif

@@ -0,0 +1,143 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+module LLVM.Internal.FFI.Attribute where++import LLVM.Prelude++import Foreign.C+import Foreign.Ptr++import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.LLVMCTypes++type Index = CInt+type Slot = CUInt+type IntValue = Word64++{-+Data model:+llvm::Attribute is one function or parameter attribute++llvm::AttributeSet is a mess.+It's used to represent, at different times:+a) the set of parameter attributes on a parameter+b) the set of parameter attributes for a functions return value+c) the set of function attributes for a function+d) All of the above++It is only possible to enumerate the attributes in an attribute set+given a "slot".++Encode path:+Use AttrBuilder on the C++ side only, to implement [Attribute] -> AttributeSet+AttributeSets -> whole AttributeSet++Decode strategy:+Store maps of AttributeSetImpl (Mess | Parameter | Function),+keyed by raw pointer. Expect Parameter and Function AttributeSetImpls+to have only one slot. Use the per-slot iterators to decode them+-}++data MixedAttributeType+data FunctionAttributeType+data ParameterAttributeType+data AttributeImpl a+data AttributeSetImpl a++type Attribute a = Ptr (AttributeImpl a)+type FunctionAttribute = Attribute FunctionAttributeType+type ParameterAttribute = Attribute ParameterAttributeType++type AttributeSet a = Ptr (AttributeSetImpl a)+type MixedAttributeSet = AttributeSet MixedAttributeType+type FunctionAttributeSet = AttributeSet FunctionAttributeType+type ParameterAttributeSet = AttributeSet ParameterAttributeType++forgetAttributeType :: AttributeSet a -> AttributeSet MixedAttributeType+forgetAttributeType = castPtr++functionIndex :: Index+functionIndex = -1+returnIndex :: Index+returnIndex = 0++foreign import ccall unsafe "LLVM_Hs_AttributeKindAsEnum" parameterAttributeKindAsEnum ::+  ParameterAttribute -> IO ParameterAttributeKind++foreign import ccall unsafe "LLVM_Hs_AttributeKindAsEnum" functionAttributeKindAsEnum ::+  FunctionAttribute -> IO FunctionAttributeKind++foreign import ccall unsafe "LLVM_Hs_IsStringAttribute" isStringAttribute ::+  Attribute a -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_AttributeKindAsString" attributeKindAsString ::+  Attribute a -> Ptr CSize -> IO (Ptr CChar)++foreign import ccall unsafe "LLVM_Hs_AttributeValueAsString" attributeValueAsString ::+  Attribute a -> Ptr CSize -> IO (Ptr CChar)++foreign import ccall unsafe "LLVM_Hs_AttributeValueAsInt" attributeValueAsInt ::+  Attribute a -> IO Word64++foreign import ccall unsafe "LLVM_Hs_AttributeSetNumSlots" attributeSetNumSlots ::+  AttributeSet a -> IO Slot++foreign import ccall unsafe "LLVM_Hs_AttributeSetSlotIndex" attributeSetSlotIndex ::+  AttributeSet a -> Slot -> IO Index++foreign import ccall unsafe "LLVM_Hs_AttributeSetSlotAttributes" attributeSetSlotAttributes ::+  MixedAttributeSet -> Slot -> IO (AttributeSet a)++foreign import ccall unsafe "LLVM_Hs_AttributeSetGetAttributes" attributeSetGetAttributes ::+  AttributeSet a -> Slot -> Ptr CUInt -> IO (Ptr (Attribute a))++foreign import ccall unsafe "LLVM_Hs_GetAttributeSet" getAttributeSet ::+  Ptr Context -> Index -> Ptr (AttrBuilder a) -> IO (AttributeSet a)++foreign import ccall unsafe "LLVM_Hs_MixAttributeSets" mixAttributeSets ::+  Ptr Context -> Ptr MixedAttributeSet -> CUInt -> IO MixedAttributeSet++data AttrBuilder a+type FunctionAttrBuilder = AttrBuilder FunctionAttributeType+type ParameterAttrBuilder = AttrBuilder ParameterAttributeType++foreign import ccall unsafe "LLVM_Hs_GetAttrBuilderSize" getAttrBuilderSize ::+  CSize++foreign import ccall unsafe "LLVM_Hs_ConstructAttrBuilder" constructAttrBuilder ::+  Ptr Word8 -> IO (Ptr (AttrBuilder a))++foreign import ccall unsafe "LLVM_Hs_DestroyAttrBuilder" destroyAttrBuilder ::+  Ptr (AttrBuilder a) -> IO ()++foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddAttributeKind" attrBuilderAddFunctionAttributeKind ::+  Ptr FunctionAttrBuilder -> FunctionAttributeKind -> IO ()++foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddAttributeKind" attrBuilderAddParameterAttributeKind ::+  Ptr ParameterAttrBuilder -> ParameterAttributeKind -> IO ()++foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddStringAttribute" attrBuilderAddStringAttribute ::+  Ptr FunctionAttrBuilder -> Ptr CChar -> CSize -> Ptr CChar -> CSize -> IO ()++foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddAlignment" attrBuilderAddAlignment ::+  Ptr ParameterAttrBuilder -> Word64 -> IO ()++foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddStackAlignment" attrBuilderAddStackAlignment ::+  Ptr FunctionAttrBuilder -> Word64 -> IO ()++-- The CInt is 0 if the last value is null and 1 otherwise+foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddAllocSize" attrBuilderAddAllocSize' ::+  Ptr FunctionAttrBuilder -> CUInt -> CUInt -> LLVMBool -> IO ()++attrBuilderAddAllocSize :: Ptr FunctionAttrBuilder -> CUInt -> (CUInt, LLVMBool) -> IO ()+attrBuilderAddAllocSize b i (y, isJust) = attrBuilderAddAllocSize' b i y isJust++foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddDereferenceableAttr" attrBuilderAddDereferenceable ::+  Ptr ParameterAttrBuilder -> Word64 -> IO ()++foreign import ccall unsafe "LLVM_Hs_AttrBuilderAddDereferenceableOrNullAttr" attrBuilderAddDereferenceableOrNull ::+  Ptr ParameterAttrBuilder -> Word64 -> IO ()++foreign import ccall unsafe "LLVM_Hs_AttributeGetAllocSizeArgs" attributeGetAllocSizeArgs ::+  FunctionAttribute -> Ptr CUInt -> Ptr CUInt -> IO LLVMBool

@@ -0,0 +1,145 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "LLVM/Internal/FFI/AttributeC.hpp"++extern "C" {++static_assert(sizeof(AttributeSet) == sizeof(AttributeSetImpl *),+              "AttributeSet implementation has changed");++static_assert(sizeof(Attribute) == sizeof(AttributeImpl *),+              "Attribute implementation has changed");++unsigned LLVM_Hs_AttributeSetNumSlots(const AttributeSetImpl *a) {+	return unwrap(a).getNumSlots();+}++int LLVM_Hs_AttributeSetSlotIndex(const AttributeSetImpl *a, unsigned slot) {+	return unwrap(a).getSlotIndex(slot);+}++const AttributeSetImpl *LLVM_Hs_AttributeSetSlotAttributes(const AttributeSetImpl *a, unsigned slot) {+	return wrap(unwrap(a).getSlotAttributes(slot));+}++const AttributeSetImpl *LLVM_Hs_GetSlotAttributeSet(+	LLVMContextRef context,+	unsigned index,+	const AttributeImpl **attributes,+	unsigned length+) {+	AttrBuilder builder;+	for (unsigned i = 0; i < length; i++) builder.addAttribute(unwrap(attributes[i]));+	return wrap(AttributeSet::get(*unwrap(context), index, builder));+}++const AttributeImpl *const *LLVM_Hs_AttributeSetGetAttributes(AttributeSetImpl *asi, unsigned slot, unsigned *length) {+	AttributeSet as = unwrap(asi);+	ArrayRef<Attribute>::iterator b = as.begin(slot), e = as.end(slot);+	*length = e - b;+	return reinterpret_cast<const AttributeImpl *const *>(b);+}++#define CHECK(name,p,r,f)																								\+	static_assert(																												\+		unsigned(llvm::Attribute::name) == unsigned(LLVM_Hs_AttributeKind_ ## name), \+		"LLVM_Hs_AttributeKind enum out of sync w/ llvm::Attribute::AttrKind for " #name	\+	);+	LLVM_HS_FOR_EACH_ATTRIBUTE_KIND(CHECK)+#undef CHECK++unsigned LLVM_Hs_AttributeKindAsEnum(const AttributeImpl *a) {+    return unwrap(a).getKindAsEnum();+}++uint64_t LLVM_Hs_AttributeValueAsInt(const AttributeImpl *a) {+	return unwrap(a).getValueAsInt();+}++LLVMBool LLVM_Hs_IsStringAttribute(const AttributeImpl *a) {+	return unwrap(a).isStringAttribute();+}++const char *LLVM_Hs_AttributeKindAsString(const AttributeImpl *a, size_t &l) {+	const StringRef s = unwrap(a).getKindAsString();+	l = s.size();+	return s.data();+}++const char *LLVM_Hs_AttributeValueAsString(const AttributeImpl *a, size_t &l) {+	const StringRef s = unwrap(a).getValueAsString();+	l = s.size();+	return s.data();+}++const AttributeSetImpl *LLVM_Hs_GetAttributeSet(LLVMContextRef context, unsigned index, const AttrBuilder &ab) {+	return wrap(AttributeSet::get(*unwrap(context), index, ab));+}++const AttributeSetImpl *LLVM_Hs_MixAttributeSets(+	LLVMContextRef context, const AttributeSetImpl **as, unsigned n+) {+	return wrap(+		AttributeSet::get(+			*unwrap(context),+			ArrayRef<AttributeSet>(reinterpret_cast<const AttributeSet *>(as), n)+		)+	);+}++size_t LLVM_Hs_GetAttrBuilderSize() { return sizeof(AttrBuilder); }++AttrBuilder *LLVM_Hs_ConstructAttrBuilder(char *p) {+	return new(p) AttrBuilder();+}++void LLVM_Hs_DestroyAttrBuilder(AttrBuilder *a) {+	a->~AttrBuilder();+}++void LLVM_Hs_AttrBuilderAddAttributeKind(AttrBuilder &ab, unsigned kind) {+    ab.addAttribute(Attribute::AttrKind(kind));+}++void LLVM_Hs_AttrBuilderAddStringAttribute(+	AttrBuilder &ab, const char *kind, size_t kind_len, const char *value, size_t value_len+) {+	ab.addAttribute(StringRef(kind, kind_len), StringRef(value, value_len));+}++void LLVM_Hs_AttrBuilderAddAlignment(AttrBuilder &ab, uint64_t v) {+	ab.addAlignmentAttr(v);+}++void LLVM_Hs_AttrBuilderAddStackAlignment(AttrBuilder &ab, uint64_t v) {+	ab.addStackAlignmentAttr(v);+}++void LLVM_Hs_AttrBuilderAddAllocSize(AttrBuilder &ab, unsigned x, LLVMBool optionalIsThere, unsigned y) {+    if (optionalIsThere) {+        ab.addAllocSizeAttr(x, y);+    } else {+        ab.addAllocSizeAttr(x, Optional<unsigned>());+    }+}++void LLVM_Hs_AttrBuilderAddDereferenceableAttr(AttrBuilder &ab, uint64_t v) {+	ab.addDereferenceableAttr(v);+}++void LLVM_Hs_AttrBuilderAddDereferenceableOrNullAttr(AttrBuilder &ab, uint64_t v) {+    ab.addDereferenceableOrNullAttr(v);+}++LLVMBool LLVM_Hs_AttributeGetAllocSizeArgs(const AttributeImpl* a, unsigned* x, unsigned* y) {+    auto pair = unwrap(a).getAllocSizeArgs();+    *x = pair.first;+    if (pair.second.hasValue()) {+        *y = pair.second.getValue();+        return 1;+    } else {+        return 0;+    }+}++}

@@ -0,0 +1,24 @@+#ifndef __LLVM_ATTRIBUTE_C_HPP__+#define __LLVM_ATTRIBUTE_C_HPP__+#define __STDC_LIMIT_MACROS+#include "llvm/IR/Attributes.h"+#include "LLVM/Internal/FFI/Attribute.h"+using namespace llvm;++inline AttributeSet unwrap(const AttributeSetImpl *asi) {+    return *reinterpret_cast<const AttributeSet *>(&asi);+}++inline const AttributeSetImpl *wrap(AttributeSet as) {+    return *reinterpret_cast<const AttributeSetImpl **>(&as);+}++inline Attribute unwrap(const AttributeImpl *ai) {+    return *reinterpret_cast<const Attribute *>(&ai);+}++inline const AttributeImpl *wrap(Attribute a) {+    return *reinterpret_cast<const AttributeImpl **>(&a);+}++#endif

@@ -0,0 +1,34 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses+  #-}++-- | <http://llvm.org/doxygen/classllvm_1_1BasicBlock.html>+module LLVM.Internal.FFI.BasicBlock where++import LLVM.Prelude++import Foreign.Ptr++import LLVM.Internal.FFI.PtrHierarchy++-- | <http://llvm.org/doxygen/group__LLVMCCoreValueBasicBlock.html#gab57c996ff697ef40966432055ae47a4e>+foreign import ccall unsafe "LLVMIsABasicBlock" isABasicBlock ::+    Ptr Value -> IO (Ptr BasicBlock)++-- | <http://llvm.org/doxygen/group__LLVMCCoreValueBasicBlock.html#ga754e45f69f4b784b658d9e379943f354>+foreign import ccall unsafe "LLVMGetBasicBlockTerminator" getBasicBlockTerminator ::+    Ptr BasicBlock -> IO (Ptr Instruction)++-- | <http://llvm.org/doxygen/group__LLVMCCoreValueBasicBlock.html#ga9baf824cd325ad211027b23fce8a7494>+foreign import ccall unsafe "LLVMGetFirstInstruction" getFirstInstruction ::+    Ptr BasicBlock -> IO (Ptr Instruction)++-- | <http://llvm.org/doxygen/group__LLVMCCoreValueBasicBlock.html#gaa0bb2c95802d06bf94f4c55e61fc3477>+foreign import ccall unsafe "LLVMGetLastInstruction" getLastInstruction ::+    Ptr BasicBlock -> IO (Ptr Instruction)++-- | <http://llvm.org/doxygen/group__LLVMCCoreValueInstruction.html#ga1b4c3bd197e86e8bffdda247ddf8ec5e>+foreign import ccall unsafe "LLVMGetNextInstruction" getNextInstruction ::+    Ptr Instruction -> IO (Ptr Instruction)+

@@ -0,0 +1,16 @@+#ifndef __LLVM_INTERNAL_FFI__BINARY_OPERATOR__H__+#define __LLVM_INTERNAL_FFI__BINARY_OPERATOR__H__++#define LLVM_HS_FOR_EACH_POSSIBLY_EXACT_BINARY_OPERATOR(macro) \+	macro(UDiv) \+	macro(SDiv) \+	macro(LShr) \+	macro(AShr)++#define LLVM_HS_FOR_EACH_OVERFLOWING_BINARY_OPERATOR(macro) \+	macro(Add) \+	macro(Mul) \+	macro(Shl) \+	macro(Sub) \++#endif

@@ -0,0 +1,30 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+-- | FFI functions for handling the LLVM BinaryOperator class+module LLVM.Internal.FFI.BinaryOperator where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.LLVMCTypes++foreign import ccall unsafe "LLVMIsABinaryOperator" isABinaryOperator ::+    Ptr Value -> IO (Ptr BinaryOperator)++foreign import ccall unsafe "LLVM_Hs_HasNoSignedWrap" hasNoSignedWrap ::+    Ptr Value -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_HasNoUnsignedWrap" hasNoUnsignedWrap ::+    Ptr Value -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_IsExact" isExact ::+    Ptr Value -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_GetFastMathFlags" getFastMathFlags ::+    Ptr Value -> IO FastMathFlags

@@ -0,0 +1,26 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}++-- | Functions to read and write LLVM bitcode+module LLVM.Internal.FFI.Bitcode where++import LLVM.Prelude++import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.MemoryBuffer+import LLVM.Internal.FFI.Module+import LLVM.Internal.FFI.PtrHierarchy++import Foreign.C+import Foreign.Ptr++foreign import ccall unsafe "LLVM_Hs_ParseBitcode" parseBitcode ::+  Ptr Context -> Ptr MemoryBuffer -> Ptr (OwnerTransfered CString) -> IO (Ptr Module)++foreign import ccall unsafe "LLVM_Hs_WriteBitcode" writeBitcode ::+  Ptr Module -> Ptr RawOStream -> IO ()++                               +

@@ -0,0 +1,34 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/Module.h"+#include "llvm-c/Core.h"+#include "llvm/Support/raw_ostream.h"+#include "llvm/Support/MemoryBuffer.h"+#include "llvm/Bitcode/BitcodeReader.h"+#include "llvm/Bitcode/BitcodeWriter.h"++using namespace llvm;++extern "C" {++LLVMModuleRef LLVM_Hs_ParseBitcode(+	LLVMContextRef c,+	LLVMMemoryBufferRef mb, +	char **error+) {+    Expected<std::unique_ptr<Module>> moduleOrErr = parseBitcodeFile(unwrap(mb)->getMemBufferRef(), *unwrap(c));+    if (Error err = moduleOrErr.takeError()) {+        handleAllErrors(std::move(err), [&](ErrorInfoBase &eib) {+                *error = strdup(eib.message().c_str());+            });+        return nullptr;+    }+    return wrap(moduleOrErr.get().release());+}++void LLVM_Hs_WriteBitcode(LLVMModuleRef m, raw_ostream &os) {+	WriteBitcodeToFile(unwrap(m), os);+}++}+

@@ -0,0 +1,184 @@+{-#+  LANGUAGE+  ForeignFunctionInterface,+  TemplateHaskell,+  ViewPatterns+  #-}+-- | FFI glue for llvm::IRBuilder - llvm's IR construction state object+module LLVM.Internal.FFI.Builder where++import LLVM.Prelude++import qualified Language.Haskell.TH as TH++import Foreign.Ptr+import Foreign.C++import qualified Data.List as List+import qualified Data.Map as Map++import qualified LLVM.AST.Instruction as A+import LLVM.Internal.InstructionDefs as ID++import LLVM.Internal.FFI.Cleanup+import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.PtrHierarchy++data Builder++foreign import ccall unsafe "LLVMCreateBuilderInContext" createBuilderInContext ::+  Ptr Context -> IO (Ptr Builder)++foreign import ccall unsafe "LLVMDisposeBuilder" disposeBuilder ::+  Ptr Builder -> IO ()++foreign import ccall unsafe "LLVMPositionBuilderAtEnd" positionBuilderAtEnd ::+  Ptr Builder -> Ptr BasicBlock -> IO ()+++foreign import ccall unsafe "LLVMBuildRet" buildRet ::+  Ptr Builder -> Ptr Value -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildBr" buildBr ::+  Ptr Builder -> Ptr BasicBlock -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildCondBr" buildCondBr ::+  Ptr Builder -> Ptr Value -> Ptr BasicBlock -> Ptr BasicBlock -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildSwitch" buildSwitch ::+  Ptr Builder -> Ptr Value -> Ptr BasicBlock -> CUInt -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildIndirectBr" buildIndirectBr ::+  Ptr Builder -> Ptr Value -> CUInt -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildInvoke" buildInvoke ::+  Ptr Builder -> Ptr Value -> Ptr (Ptr Value) -> CUInt+              -> Ptr BasicBlock -> Ptr BasicBlock -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildResume" buildResume ::+  Ptr Builder -> Ptr Value -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildUnreachable" buildUnreachable ::+  Ptr Builder -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_BuildCleanupRet" buildCleanupRet ::+  Ptr Builder -> Ptr Value -> Ptr BasicBlock -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_BuildCatchRet" buildCatchRet ::+  Ptr Builder -> Ptr Value -> Ptr BasicBlock -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_BuildCatchSwitch" buildCatchSwitch ::+  Ptr Builder -> Ptr Value -> Ptr BasicBlock -> CUInt -> IO (Ptr Instruction)++$(do+  liftM concat $ sequence $ do+    let instrInfo = ID.outerJoin ID.astInstructionRecs ID.instructionDefs+    (lrn, ii) <- Map.toList instrInfo+    (TH.RecC _ (unzip3 -> (_, _, fieldTypes)), ID.InstructionDef { ID.cAPIName = a, ID.instructionKind = k }) <- case ii of+      (Just r, Just d) -> return (r,d)+      (Just _, Nothing) -> error $ "An AST instruction was not found in the LLVM instruction defs"+      (Nothing, Just ID.InstructionDef { ID.instructionKind = k }) | k /= ID.Terminator ->+        error $ "LLVM instruction def " ++ lrn ++ " not found in the AST"+      _ -> []++    let ats = map typeMapping (fieldTypes List.\\ [TH.ConT ''A.InstructionMetadata, TH.ConT ''A.FastMathFlags])+        cName = (if hasFlags fieldTypes then "LLVM_Hs_" else "LLVM") ++ "Build" ++ a+    rt <- case k of+            ID.Binary -> [[t| BinaryOperator |]]+            ID.Cast -> [[t| Instruction |]]+            _ -> []+    return $ foreignDecl cName ("build" ++ a) ([[t| Ptr Builder |]] ++ ats ++ [[t| CString |]]) [t| Ptr $(rt) |]+ )++foreign import ccall unsafe "LLVMBuildArrayAlloca" buildAlloca ::+  Ptr Builder -> Ptr Type -> Ptr Value -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_BuildLoad" buildLoad' ::+  Ptr Builder -> LLVMBool -> Ptr Value -> MemoryOrdering -> SynchronizationScope -> CUInt -> CString -> IO (Ptr Instruction)++buildLoad :: Ptr Builder -> LLVMBool -> Ptr Value -> (SynchronizationScope, MemoryOrdering) -> CUInt -> CString -> IO (Ptr Instruction)+buildLoad builder vol a' (ss, mo) al s = buildLoad' builder vol a' mo ss al s++foreign import ccall unsafe "LLVM_Hs_BuildStore" buildStore' ::+  Ptr Builder -> LLVMBool -> Ptr Value -> Ptr Value -> MemoryOrdering -> SynchronizationScope -> CUInt -> CString -> IO (Ptr Instruction)++buildStore :: Ptr Builder -> LLVMBool -> Ptr Value -> Ptr Value -> (SynchronizationScope, MemoryOrdering) -> CUInt -> CString -> IO (Ptr Instruction)+buildStore builder vol a' v' (ss, mo) al s = buildStore' builder vol a' v' mo ss al s++foreign import ccall unsafe "LLVMBuildGEP" buildGetElementPtr' ::+  Ptr Builder -> Ptr Value -> Ptr (Ptr Value) -> CUInt -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildInBoundsGEP" buildInBoundsGetElementPtr' ::+  Ptr Builder -> Ptr Value -> Ptr (Ptr Value) -> CUInt -> CString -> IO (Ptr Instruction)++buildGetElementPtr :: Ptr Builder -> LLVMBool -> Ptr Value -> (CUInt, Ptr (Ptr Value)) -> CString -> IO (Ptr Instruction)+buildGetElementPtr builder (LLVMBool 1) a (n, is) s = buildInBoundsGetElementPtr' builder a is n s+buildGetElementPtr builder (LLVMBool 0) a (n, is) s = buildGetElementPtr' builder a is n s++foreign import ccall unsafe "LLVM_Hs_BuildFence" buildFence' ::+  Ptr Builder -> MemoryOrdering -> SynchronizationScope -> CString -> IO (Ptr Instruction)++buildFence :: Ptr Builder -> (SynchronizationScope, MemoryOrdering) -> CString -> IO (Ptr Instruction)+buildFence builder (ss, mo) s = buildFence' builder mo ss s++foreign import ccall unsafe "LLVM_Hs_BuildAtomicCmpXchg" buildCmpXchg' ::+  Ptr Builder -> LLVMBool -> Ptr Value -> Ptr Value -> Ptr Value -> MemoryOrdering -> MemoryOrdering -> SynchronizationScope -> CString -> IO (Ptr Instruction)++buildCmpXchg :: Ptr Builder -> LLVMBool -> Ptr Value -> Ptr Value -> Ptr Value -> (SynchronizationScope, MemoryOrdering) -> MemoryOrdering -> CString -> IO (Ptr Instruction)+buildCmpXchg builder vol a e r (ss, smo) fmo s =  buildCmpXchg' builder vol a e r smo fmo ss s++foreign import ccall unsafe "LLVM_Hs_BuildAtomicRMW" buildAtomicRMW' ::+  Ptr Builder -> LLVMBool -> RMWOperation -> Ptr Value -> Ptr Value -> MemoryOrdering -> SynchronizationScope -> CString -> IO (Ptr Instruction)++buildAtomicRMW :: Ptr Builder -> LLVMBool -> RMWOperation -> Ptr Value -> Ptr Value -> (SynchronizationScope, MemoryOrdering) -> CString -> IO (Ptr Instruction)+buildAtomicRMW builder vol rmwOp a v (ss, mo) s = buildAtomicRMW' builder vol rmwOp a v mo ss s++foreign import ccall unsafe "LLVMBuildICmp" buildICmp ::+  Ptr Builder -> ICmpPredicate -> Ptr Value -> Ptr Value -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildFCmp" buildFCmp ::+  Ptr Builder -> FCmpPredicate -> Ptr Value -> Ptr Value -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildPhi" buildPhi ::+  Ptr Builder -> Ptr Type -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildCall" buildCall ::+  Ptr Builder -> Ptr Value -> Ptr (Ptr Value) -> CUInt -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildSelect" buildSelect ::+  Ptr Builder -> Ptr Value -> Ptr Value -> Ptr Value -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildVAArg" buildVAArg ::+  Ptr Builder -> Ptr Value -> Ptr Type -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildExtractElement" buildExtractElement ::+  Ptr Builder -> Ptr Value -> Ptr Value -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildInsertElement" buildInsertElement ::+  Ptr Builder -> Ptr Value -> Ptr Value -> Ptr Value -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildShuffleVector" buildShuffleVector ::+  Ptr Builder -> Ptr Value -> Ptr Value -> Ptr Constant -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_BuildExtractValue" buildExtractValue ::+  Ptr Builder -> Ptr Value -> Ptr CUInt -> CUInt -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_BuildInsertValue" buildInsertValue ::+  Ptr Builder -> Ptr Value -> Ptr Value -> Ptr CUInt -> CUInt -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVMBuildLandingPad" buildLandingPad' ::+  Ptr Builder -> Ptr Type -> Ptr Value -> CUInt -> CString -> IO (Ptr Instruction)++-- | The personality should be set via the function+buildLandingPad :: Ptr Builder -> Ptr Type -> CUInt -> CString -> IO (Ptr Instruction)+buildLandingPad builder ty numClauses name = buildLandingPad' builder ty nullPtr numClauses name++foreign import ccall unsafe "LLVM_Hs_BuildCleanupPad" buildCleanupPad ::+  Ptr Builder -> Ptr Value -> Ptr (Ptr Value) -> CUInt -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_BuildCatchPad" buildCatchPad ::+  Ptr Builder -> Ptr Value -> Ptr (Ptr Value) -> CUInt -> CString -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_SetFastMathFlags" setFastMathFlags ::+  Ptr Builder -> FastMathFlags -> IO ()

@@ -0,0 +1,223 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/IRBuilder.h"++#include "llvm-c/Core.h"++#include "LLVM/Internal/FFI/Instruction.h"+#include "LLVM/Internal/FFI/BinaryOperator.h"++using namespace llvm;++namespace llvm {+static AtomicOrdering unwrap(LLVMAtomicOrdering l) {+	switch(l) {+#define ENUM_CASE(x) case LLVMAtomicOrdering ## x: return AtomicOrdering::x;+LLVM_HS_FOR_EACH_ATOMIC_ORDERING(ENUM_CASE)+#undef ENUM_CASE+	default: return AtomicOrdering(0);+	}+}++static SynchronizationScope unwrap(LLVMSynchronizationScope l) {+	switch(l) {+#define ENUM_CASE(x) case LLVM ## x ## SynchronizationScope: return x;+LLVM_HS_FOR_EACH_SYNCRONIZATION_SCOPE(ENUM_CASE)+#undef ENUM_CASE+	default: return SynchronizationScope(0);+	}+}+++static AtomicRMWInst::BinOp unwrap(LLVMAtomicRMWBinOp l) {+	switch(l) {+#define ENUM_CASE(x) case LLVMAtomicRMWBinOp ## x: return AtomicRMWInst::x;+LLVM_HS_FOR_EACH_RMW_OPERATION(ENUM_CASE)+#undef ENUM_CASE+	default: return AtomicRMWInst::BinOp(0);+	}+}++static FastMathFlags unwrap(LLVMFastMathFlags f) {+	FastMathFlags r = FastMathFlags();+#define ENUM_CASE(x,l) if (f & LLVM ## x) r.set ## x();+LLVM_HS_FOR_EACH_FAST_MATH_FLAG(ENUM_CASE)+#undef ENUM_CASE+	return r;+}++}++extern "C" {++#define ENUM_CASE(Op)																										\+LLVMValueRef LLVM_Hs_Build ## Op(																	\+	LLVMBuilderRef b,																											\+	LLVMBool nsw,																													\+	LLVMBool nuw,																													\+	LLVMValueRef o0,																											\+	LLVMValueRef o1,																											\+	const char *s																													\+) {																																			\+	return wrap(unwrap(b)->Create ## Op(unwrap(o0), unwrap(o1), s, nuw, nsw)); \+}+LLVM_HS_FOR_EACH_OVERFLOWING_BINARY_OPERATOR(ENUM_CASE)+#undef ENUM_CASE++#define ENUM_CASE(Op)																										\+LLVMValueRef LLVM_Hs_Build ## Op(																	\+	LLVMBuilderRef b,																											\+	LLVMBool exact,																												\+	LLVMValueRef o0,																											\+	LLVMValueRef o1,																											\+	const char *s																													\+) {																																			\+	return wrap(unwrap(b)->Create ## Op(unwrap(o0), unwrap(o1), s, exact)); \+}+LLVM_HS_FOR_EACH_POSSIBLY_EXACT_BINARY_OPERATOR(ENUM_CASE)+#undef ENUM_CASE++void LLVM_Hs_SetFastMathFlags(LLVMBuilderRef b, LLVMFastMathFlags f) {+	unwrap(b)->setFastMathFlags(unwrap(f));+}++LLVMValueRef LLVM_Hs_BuildLoad(+	LLVMBuilderRef b,+	LLVMBool isVolatile,+	LLVMValueRef p,+	LLVMAtomicOrdering atomicOrdering,+	LLVMSynchronizationScope synchScope,+	unsigned align,+	const char *name+) {+	LoadInst *i = unwrap(b)->CreateAlignedLoad(unwrap(p), align, isVolatile, name);+	i->setOrdering(unwrap(atomicOrdering));+	if (atomicOrdering != LLVMAtomicOrderingNotAtomic) i->setSynchScope(unwrap(synchScope));+	return wrap(i);+}++LLVMValueRef LLVM_Hs_BuildStore(+	LLVMBuilderRef b,+	LLVMBool isVolatile,+	LLVMValueRef p,+	LLVMValueRef v,+	LLVMAtomicOrdering atomicOrdering,+	LLVMSynchronizationScope synchScope,+	unsigned align,+	const char *name+) {+	StoreInst *i = unwrap(b)->CreateAlignedStore(unwrap(v), unwrap(p), align, isVolatile);+	i->setName(name);+	i->setOrdering(unwrap(atomicOrdering));+	if (atomicOrdering != LLVMAtomicOrderingNotAtomic) i->setSynchScope(unwrap(synchScope));+	return wrap(i);+}++LLVMValueRef LLVM_Hs_BuildFence(+	LLVMBuilderRef b, LLVMAtomicOrdering lao, LLVMSynchronizationScope lss, const char *name+) {+	FenceInst *i = unwrap(b)->CreateFence(unwrap(lao), unwrap(lss));+	i->setName(name);+	return wrap(i);+}++LLVMValueRef LLVM_Hs_BuildAtomicCmpXchg(+	LLVMBuilderRef b,+	LLVMBool v,+	LLVMValueRef ptr, +	LLVMValueRef cmp, +	LLVMValueRef n, +	LLVMAtomicOrdering successOrdering,+	LLVMAtomicOrdering failureOrdering,+	LLVMSynchronizationScope lss,+	const char *name+) {+	AtomicCmpXchgInst *a = unwrap(b)->CreateAtomicCmpXchg(+		unwrap(ptr), unwrap(cmp), unwrap(n), unwrap(successOrdering), unwrap(failureOrdering), unwrap(lss)+	);+	a->setVolatile(v);+	a->setName(name);+	return wrap(a);+}++LLVMValueRef LLVM_Hs_BuildAtomicRMW(+	LLVMBuilderRef b,+	LLVMBool v,+	LLVMAtomicRMWBinOp rmwOp,+	LLVMValueRef ptr, +	LLVMValueRef val, +	LLVMAtomicOrdering lao,+	LLVMSynchronizationScope lss,+	const char *name+) {+	AtomicRMWInst *a = unwrap(b)->CreateAtomicRMW(+		unwrap(rmwOp), unwrap(ptr), unwrap(val), unwrap(lao), unwrap(lss)+	);+	a->setVolatile(v);+	a->setName(name);+	return wrap(a);+}++LLVMValueRef LLVM_Hs_BuildExtractValue(+	LLVMBuilderRef b,+	LLVMValueRef a,+	unsigned *idxs,+	unsigned n,+	const char *name+) {+	return wrap(unwrap(b)->CreateExtractValue(unwrap(a), ArrayRef<unsigned>(idxs, n), name));+}++LLVMValueRef LLVM_Hs_BuildInsertValue(+	LLVMBuilderRef b,+	LLVMValueRef a,+	LLVMValueRef v,+	unsigned *idxs,+	unsigned n,+	const char *name+) {+	return wrap(unwrap(b)->CreateInsertValue(unwrap(a), unwrap(v), ArrayRef<unsigned>(idxs, n), name));+}++LLVMValueRef LLVM_Hs_BuildCleanupPad(LLVMBuilderRef b, LLVMValueRef parentPad,+                                     LLVMValueRef *args, unsigned numArgs,+                                     const char *name) {+  return wrap(unwrap(b)->CreateCleanupPad(unwrap(parentPad),+                                          makeArrayRef(unwrap(args), numArgs),+                                          name));+}++LLVMValueRef LLVM_Hs_BuildCatchPad(LLVMBuilderRef b, LLVMValueRef catchSwitch,+                                   LLVMValueRef *args, unsigned numArgs,+                                   const char *name) {+    return wrap(unwrap(b)->CreateCatchPad(unwrap(catchSwitch),+                                          makeArrayRef(unwrap(args), numArgs),+                                          name));+}++LLVMValueRef LLVM_Hs_BuildCleanupRet(LLVMBuilderRef b, LLVMValueRef cleanupPad,+                                     LLVMBasicBlockRef unwindDest) {+    // Due to the way name resolution works in llvm-hs, cleanupPad might not+    // actually be a CleanupPadInst. However, it will later be replaced by one.+    // Pretending that we have one is thus ok here.+    auto cleanupPad_ = static_cast<CleanupPadInst*>(unwrap<Value>(cleanupPad));+    return wrap(unwrap(b)->CreateCleanupRet(cleanupPad_,+                                            unwrap(unwindDest)));+}++LLVMValueRef LLVM_Hs_BuildCatchRet(LLVMBuilderRef b, LLVMValueRef catchPad,+                                   LLVMBasicBlockRef successor) {+    // Due to the way name resolution works in llvm-hs, catchPad might not+    // actually be a CatchPadInst. However, it will later be replaced by one.+    // Pretending that we have one is thus ok here.+    auto catchPad_ = static_cast<CatchPadInst *>(unwrap<Value>(catchPad));+    return wrap(unwrap(b)->CreateCatchRet(catchPad_, unwrap(successor)));+}++LLVMValueRef LLVM_Hs_BuildCatchSwitch(LLVMBuilderRef b, LLVMValueRef parentPad,+                                      LLVMBasicBlockRef unwindDest,+                                      unsigned numHandlers) {+    return wrap(unwrap(b)->CreateCatchSwitch(unwrap(parentPad),+                                             unwrap(unwindDest), numHandlers));+}+}

@@ -0,0 +1,14 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+module LLVM.Internal.FFI.ByteRangeCallback where++import LLVM.Prelude++import Foreign.C+import Foreign.Ptr++type ByteRangeCallback = Ptr CChar -> CSize -> IO ()+foreign import ccall "wrapper" wrapByteRangeCallback :: +  ByteRangeCallback -> IO (FunPtr ByteRangeCallback)+

@@ -0,0 +1,35 @@+#ifndef __LLVM_INTERNAL_FFI__CALLING_CONVENTION__H__+#define __LLVM_INTERNAL_FFI__CALLING_CONVENTION__H__++#define LLVM_HS_FOR_EACH_CALLING_CONVENTION(macro) \+  macro(C, 0)                                           \+  macro(Fast, 8)                                        \+  macro(Cold, 9)                                        \+  macro(GHC, 10)                                        \+  macro(HiPE, 11)                                       \+  macro(WebKit_JS, 12)                                  \+  macro(AnyReg, 13)                                     \+  macro(PreserveMost, 14)                               \+  macro(PreserveAll, 15)                                \+  macro(X86_StdCall, 64)                                \+  macro(X86_FastCall, 65)                               \+  macro(ARM_APCS, 66)                                   \+  macro(ARM_AAPCS, 67)                                  \+  macro(ARM_AAPCS_VFP, 68)                              \+  macro(MSP430_INTR, 69)                                \+  macro(X86_ThisCall, 70)                               \+  macro(PTX_Kernel, 71)                                 \+  macro(PTX_Device, 72)                                 \+  macro(SPIR_FUNC, 75)                                  \+  macro(SPIR_KERNEL, 76)                                \+  macro(Intel_OCL_BI, 77)                               \+  macro(X86_64_SysV, 78)                                \+  macro(X86_64_Win64, 79)++typedef enum {+#define ENUM_CASE(l,n) LLVM_Hs_CallingConvention_ ## l = n,+  LLVM_HS_FOR_EACH_CALLING_CONVENTION(ENUM_CASE)+#undef ENUM_CASE+} LLVM_Hs_CallingConvention;++#endif

@@ -0,0 +1,10 @@+#include "LLVM/Internal/FFI/CallingConvention.h"+#include "llvm/IR/CallingConv.h"++#define CHECK(l, n)                                                            \+    static_assert(unsigned(llvm::CallingConv::l) ==                            \+                      unsigned(LLVM_Hs_CallingConvention_##l),            \+                  "LLVM_Hs_CallingConvention enum out of sync w/ "        \+                  "llvm::CallingConv::ID for " #l);+LLVM_HS_FOR_EACH_CALLING_CONVENTION(CHECK)+#undef CHECK

@@ -0,0 +1,83 @@+{-# LANGUAGE+  TemplateHaskell+  #-}+module LLVM.Internal.FFI.Cleanup where++import LLVM.Prelude++import Language.Haskell.TH+import Data.Sequence as Seq++import Foreign.C+import Foreign.Ptr++import LLVM.Internal.FFI.LLVMCTypes+import qualified LLVM.Internal.FFI.PtrHierarchy as FFI++import qualified LLVM.AST.IntegerPredicate as A (IntegerPredicate) +import qualified LLVM.AST.FloatingPointPredicate as A (FloatingPointPredicate) +import qualified LLVM.AST.Constant as A.C (Constant)+import qualified LLVM.AST.Operand as A (Operand)+import qualified LLVM.AST.Type as A (Type)+import qualified LLVM.AST.Instruction as A (FastMathFlags)++foreignDecl :: String -> String -> [TypeQ] -> TypeQ -> DecsQ+foreignDecl cName hName argTypeQs returnTypeQ = do+  let foreignDecl' hName argTypeQs = +        forImpD cCall unsafe cName (mkName hName) +                  (foldr (\a b -> appT (appT arrowT a) b) (appT (conT ''IO) returnTypeQ) argTypeQs)+      splitTuples :: [Type] -> Q ([Type], [Pat], [Exp])+      splitTuples ts = do+        let f :: Type -> Q (Seq Type, Pat, Seq Exp)+            f x@(AppT _ _) = maybe (d x) (\q -> q >>= \(ts, ps, es) -> return (ts, TupP (toList ps), es)) (g 0 x)+            f x = d x+            g :: Int -> Type -> Maybe (Q (Seq Type, Seq Pat, Seq Exp))+            g n (TupleT m) | m == n = return (return (Seq.empty, Seq.empty, Seq.empty))+            g n (AppT a b) = do+              k <- g (n+1) a+              return $ do+                (ts, ps, es) <- k+                (ts', p', es') <- f b+                return (ts >< ts', ps |> p', es >< es')+            g _ _ = Nothing+            d :: Type -> Q (Seq Type, Pat, Seq Exp)+            d x = do+              n <- newName "v"+              return (Seq.singleton x, VarP n, Seq.singleton (VarE n))+            seqsToList :: [Seq a] -> [a]+            seqsToList = toList . foldr (><) Seq.empty+                +        (tss, ps, ess) <- liftM unzip3 . mapM f $ ts+        return (seqsToList tss, ps, seqsToList ess)++                                +  argTypes <- sequence argTypeQs+  (ts, ps, es) <- splitTuples argTypes+  let phName = hName ++ "'"+  sequence [+    foreignDecl' phName (map return ts),+    funD (mkName hName) [+     clause (map return ps) (normalB (foldl appE (varE (mkName phName)) (map return es))) []+    ]+   ]++-- | The LLVM C-API for instructions with boolean flags (e.g. nsw) and is weak, so they get+-- separated out for different handling. This check is an accurate but crude test for whether+-- an instruction needs such handling.+hasFlags :: [Type] -> Bool+hasFlags = any (== ConT ''Bool)++typeMapping :: Type -> TypeQ+typeMapping t = case t of+  ConT h | h == ''Bool -> [t| LLVMBool |]+         | h == ''Int32 -> [t| CInt |]+         | h == ''Word32 -> [t| CUInt |]+         | h == ''String -> [t| CString |]+         | h == ''A.Operand -> [t| Ptr FFI.Value |]+         | h == ''A.Type -> [t| Ptr FFI.Type |]+         | h == ''A.C.Constant -> [t| Ptr FFI.Constant |]+         | h == ''A.FloatingPointPredicate -> [t| FCmpPredicate |]+         | h == ''A.IntegerPredicate -> [t| ICmpPredicate |]+         | h == ''A.FastMathFlags -> [t| FastMathFlags |]+  AppT ListT x -> foldl1 appT [tupleT 2, [t| CUInt |], appT [t| Ptr |] (typeMapping x)]+  x -> error $ "type not handled in Cleanup typeMapping: " ++ show x

@@ -0,0 +1,15 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+module LLVM.Internal.FFI.CommandLine where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++foreign import ccall unsafe "LLVM_Hs_ParseCommandLineOptions" parseCommandLineOptions' ::+  CUInt -> Ptr (Ptr CChar) -> Ptr CChar -> IO ()++parseCommandLineOptions :: (CUInt, Ptr (Ptr CChar)) -> Ptr CChar -> IO ()+parseCommandLineOptions = uncurry parseCommandLineOptions'

@@ -0,0 +1,12 @@+#define __STDC_LIMIT_MACROS+#include "llvm/Support/CommandLine.h"++using namespace llvm;++extern "C" {++void LLVM_Hs_ParseCommandLineOptions(unsigned argc, const char * const *argv, const char *overview) {+	cl::ParseCommandLineOptions(argc, argv, overview);+}++}

@@ -0,0 +1,20 @@+#ifndef __LLVM_INTERNAL_FFI__CONSTANT__H__+#define __LLVM_INTERNAL_FFI__CONSTANT__H__++#define LLVM_HS_FOR_EACH_FLOAT_SEMANTICS(macro) \+	macro(IEEEhalf) \+	macro(IEEEsingle) \+	macro(IEEEdouble) \+	macro(IEEEquad) \+	macro(PPCDoubleDouble) \+	macro(x87DoubleExtended) \+	macro(Bogus)++typedef enum {+#define ENUM_CASE(x) LLVMFloatSemantics ## x,+LLVM_HS_FOR_EACH_FLOAT_SEMANTICS(ENUM_CASE)+#undef ENUM_CASE+} LLVMFloatSemantics;+++#endif

@@ -0,0 +1,145 @@+{-# LANGUAGE+  TemplateHaskell,+  ForeignFunctionInterface,+  MultiParamTypeClasses,+  UndecidableInstances,+  ViewPatterns+  #-}+-- | FFI functions for handling the LLVM Constant class+module LLVM.Internal.FFI.Constant where++import LLVM.Prelude++import qualified Language.Haskell.TH as TH+import qualified LLVM.Internal.InstructionDefs as ID++import qualified Data.Map as Map++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.Cleanup+import LLVM.Internal.FFI.LLVMCTypes++foreign import ccall unsafe "LLVMIsConstant" isConstant ::+  Ptr Value -> IO (CUInt)++foreign import ccall unsafe "LLVMIsAConstant" isAConstant ::+  Ptr Value -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMIsAConstantInt" isAConstantInt ::+  Ptr Value -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMGetOperand" getConstantOperand ::+  Ptr Constant -> CUInt -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMIsAConstantPointerNull" isAConstantPointerNull ::+  Ptr Value -> IO (Ptr Constant)++foreign import ccall unsafe "LLVM_Hs_GetConstantIntWords" getConstantIntWords ::+  Ptr Constant -> Ptr CUInt -> IO (Ptr Word64)++foreign import ccall unsafe "LLVM_Hs_ConstFloatDoubleValue" constFloatDoubleValue ::+  Ptr Constant -> IO CDouble++foreign import ccall unsafe "LLVM_Hs_ConstFloatFloatValue" constFloatFloatValue ::+  Ptr Constant -> IO CFloat++foreign import ccall unsafe "LLVMConstStructInContext" constStructInContext' ::+  Ptr Context -> Ptr (Ptr Constant) -> CUInt -> LLVMBool -> IO (Ptr Constant)++constStructInContext :: Ptr Context -> (CUInt, Ptr (Ptr Constant)) -> LLVMBool -> IO (Ptr Constant)+constStructInContext ctx (n, cs) p = constStructInContext' ctx cs n p++foreign import ccall unsafe "LLVMConstNamedStruct" constNamedStruct' ::+  Ptr Type -> Ptr (Ptr Constant) -> CUInt -> IO (Ptr Constant)++constNamedStruct :: Ptr Type -> (CUInt, Ptr (Ptr Constant)) -> IO (Ptr Constant)+constNamedStruct ty (n, cs) = constNamedStruct' ty cs n++foreign import ccall unsafe "LLVM_Hs_GetConstantDataSequentialElementAsConstant" getConstantDataSequentialElementAsConstant ::+  Ptr Constant -> CUInt -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMConstIntOfArbitraryPrecision" constantIntOfArbitraryPrecision' ::+  Ptr Type -> CUInt -> Ptr Word64 -> IO (Ptr Constant)++constantIntOfArbitraryPrecision :: Ptr Type -> (CUInt, Ptr Word64) -> IO (Ptr Constant)+constantIntOfArbitraryPrecision t = uncurry (constantIntOfArbitraryPrecision' t)++foreign import ccall unsafe "LLVM_Hs_ConstFloatOfArbitraryPrecision" constantFloatOfArbitraryPrecision ::+  Ptr Context -> CUInt -> Ptr Word64 -> FloatSemantics -> IO (Ptr Constant)++foreign import ccall unsafe "LLVM_Hs_GetConstantFloatWords" getConstantFloatWords ::+  Ptr Constant -> Ptr Word64 -> IO ()++foreign import ccall unsafe "LLVMConstVector" constantVector' ::+  Ptr (Ptr Constant) -> CUInt -> IO (Ptr Constant)++constantVector :: (CUInt, Ptr (Ptr Constant)) -> IO (Ptr Constant)+constantVector (n, cs) = constantVector' cs n++foreign import ccall unsafe "LLVMConstNull" constantNull ::+  Ptr Type -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMConstArray" constantArray' ::+  Ptr Type -> Ptr (Ptr Constant) -> CUInt -> IO (Ptr Constant)++constantArray :: Ptr Type -> (CUInt, Ptr (Ptr Constant)) -> IO (Ptr Constant)+constantArray t (n, cs) = constantArray' t cs n++foreign import ccall unsafe "LLVM_Hs_ConstCast" constantCast ::+  CPPOpcode -> Ptr Constant -> Ptr Type -> IO (Ptr Constant)++foreign import ccall unsafe "LLVM_Hs_ConstBinaryOperator" constantBinaryOperator ::+  CPPOpcode -> Ptr Constant -> Ptr Constant -> IO (Ptr Constant)++$(do+   let constExprInfo = ID.innerJoin (ID.innerJoin ID.astConstantRecs ID.astInstructionRecs) ID.instructionDefs+   liftM concat $ sequence $ do+     (name, ((TH.RecC _ (unzip3 -> (_, _, fieldTypes)),_), ID.InstructionDef { ID.instructionKind = ik })) <- Map.toList constExprInfo+     prefix <- case ik of+                 ID.Other -> return "LLVM"+                 ID.Binary | hasFlags fieldTypes -> return "LLVM_Hs_"+                 _ -> []+     return $+       foreignDecl (prefix ++ "Const" ++ name) ("constant" ++ name) (map typeMapping fieldTypes) [t| Ptr Constant |]+  )++foreign import ccall unsafe "LLVMConstGEP" constantGetElementPtr' ::+  Ptr Constant -> Ptr (Ptr Constant) -> CUInt -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMConstInBoundsGEP" constantInBoundsGetElementPtr' ::+  Ptr Constant -> Ptr (Ptr Constant) -> CUInt -> IO (Ptr Constant)++constantGetElementPtr :: LLVMBool -> Ptr Constant -> (CUInt, Ptr (Ptr Constant)) -> IO (Ptr Constant)+constantGetElementPtr (LLVMBool ib) a (n, is) =+  (case ib of { 0 -> constantGetElementPtr'; 1 -> constantInBoundsGetElementPtr' }) a is n++foreign import ccall unsafe "LLVM_Hs_GetConstCPPOpcode" getConstantCPPOpcode ::+  Ptr Constant -> IO CPPOpcode++foreign import ccall unsafe "LLVM_Hs_GetConstPredicate" getConstantICmpPredicate ::+  Ptr Constant -> IO ICmpPredicate++foreign import ccall unsafe "LLVM_Hs_GetConstPredicate" getConstantFCmpPredicate ::+  Ptr Constant -> IO FCmpPredicate++foreign import ccall unsafe "LLVM_Hs_GetConstIndices" getConstantIndices ::+  Ptr Constant -> Ptr CUInt -> IO (Ptr CUInt)++foreign import ccall unsafe "LLVMGetUndef" constantUndef ::+  Ptr Type -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMBlockAddress" blockAddress ::+  Ptr Value -> Ptr BasicBlock -> IO (Ptr Constant)++foreign import ccall unsafe "LLVM_Hs_GetBlockAddressFunction" getBlockAddressFunction ::+  Ptr Constant -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_GetBlockAddressBlock" getBlockAddressBlock ::+  Ptr Constant -> IO (Ptr BasicBlock)++foreign import ccall unsafe "LLVM_Hs_GetConstTokenNone" getConstTokenNone ::+  Ptr Context -> IO (Ptr Constant)

@@ -0,0 +1,114 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/Constants.h"+#include "llvm/IR/Function.h"++#include "llvm-c/Core.h"+#include "LLVM/Internal/FFI/Value.h"+#include "LLVM/Internal/FFI/Constant.h"+#include "LLVM/Internal/FFI/BinaryOperator.h"++using namespace llvm;++namespace llvm {++static const struct fltSemantics &unwrap(LLVMFloatSemantics s) {+	switch(s) {+#define ENUM_CASE(x) case LLVMFloatSemantics ## x: return APFloat::x();+LLVM_HS_FOR_EACH_FLOAT_SEMANTICS(ENUM_CASE)+#undef ENUM_CASE+    default: return APFloat::Bogus();+	}+}++}++extern "C" {++LLVMValueRef LLVM_Hs_GetConstantDataSequentialElementAsConstant(LLVMValueRef v, unsigned i) {+	return wrap(unwrap<ConstantDataSequential>(v)->getElementAsConstant(i));+}++LLVMValueRef LLVM_Hs_GetBlockAddressFunction(LLVMValueRef v) {+	return wrap(unwrap<BlockAddress>(v)->getFunction());+}++LLVMBasicBlockRef LLVM_Hs_GetBlockAddressBlock(LLVMValueRef v) {+	return wrap(unwrap<BlockAddress>(v)->getBasicBlock());+}++double LLVM_Hs_ConstFloatDoubleValue(LLVMValueRef v) {+	return unwrap<ConstantFP>(v)->getValueAPF().convertToDouble();+}++float LLVM_Hs_ConstFloatFloatValue(LLVMValueRef v) {+	return unwrap<ConstantFP>(v)->getValueAPF().convertToFloat();+}++LLVMValueRef LLVM_Hs_ConstCast(unsigned opcode, LLVMValueRef v, LLVMTypeRef t) {+	return wrap(ConstantExpr::getCast(opcode, unwrap<Constant>(v), unwrap(t)));+}++LLVMValueRef LLVM_Hs_ConstBinaryOperator(unsigned opcode, LLVMValueRef o0, LLVMValueRef o1) {+	return wrap(ConstantExpr::get(opcode, unwrap<Constant>(o0), unwrap<Constant>(o1)));+}++#define CASE_CODE(op)																										\+LLVMValueRef LLVM_Hs_Const ## op(unsigned nsw, unsigned nuw, LLVMValueRef o0, LLVMValueRef o1) { \+	return wrap(ConstantExpr::get ## op(unwrap<Constant>(o0), unwrap<Constant>(o1), nuw != 0, nsw != 0)); \+}+LLVM_HS_FOR_EACH_OVERFLOWING_BINARY_OPERATOR(CASE_CODE)+#undef CASE_CODE++#define CASE_CODE(op)																										\+LLVMValueRef LLVM_Hs_Const ## op(unsigned isExact, LLVMValueRef o0, LLVMValueRef o1) {	\+	return wrap(ConstantExpr::get ## op(unwrap<Constant>(o0), unwrap<Constant>(o1), isExact != 0));	\+}+LLVM_HS_FOR_EACH_POSSIBLY_EXACT_BINARY_OPERATOR(CASE_CODE)+#undef CASE_CODE++unsigned LLVM_Hs_GetConstCPPOpcode(LLVMValueRef v) {+	return unwrap<ConstantExpr>(v)->getOpcode();+}++unsigned LLVM_Hs_GetConstPredicate(LLVMValueRef v) {+	return unwrap<ConstantExpr>(v)->getPredicate();+}++const unsigned *LLVM_Hs_GetConstIndices(LLVMValueRef v, unsigned *n) {+	ArrayRef<unsigned> r = unwrap<ConstantExpr>(v)->getIndices();+	*n = r.size();+	return r.data();+}++const uint64_t *LLVM_Hs_GetConstantIntWords(LLVMValueRef v, unsigned *n) {+	const APInt &i = unwrap<ConstantInt>(v)->getValue();+	*n = i.getNumWords();+	return i.getRawData();+}++LLVMValueRef LLVM_Hs_ConstFloatOfArbitraryPrecision(+	LLVMContextRef c,+	unsigned bits,+	const uint64_t *words,+	LLVMFloatSemantics semantics+) {+	return wrap(+		ConstantFP::get(+			*unwrap(c),+			APFloat(unwrap(semantics), APInt(bits, ArrayRef<uint64_t>(words, (bits-1)/64 + 1)))+		)+	);+}++void LLVM_Hs_GetConstantFloatWords(LLVMValueRef v, uint64_t *bits) {+	APInt a = unwrap<ConstantFP>(v)->getValueAPF().bitcastToAPInt();+	for(unsigned i=0; i != a.getNumWords(); ++i) bits[i] = a.getRawData()[i];+}++LLVMValueRef LLVM_Hs_GetConstTokenNone(LLVMContextRef context) {+	return wrap(ConstantTokenNone::get(*unwrap(context)));+}+++}

@@ -0,0 +1,28 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}++-- | Functions for handling the LLVMContext class. In all other LLVM interfaces,+-- | prefer the newer explicitly thread-aware variants which use contexts+-- | over corresponding older variants which implicitly reference a global context.+-- | This choice allows multiple threads to do independent work with LLVM safely.+module LLVM.Internal.FFI.Context where++import LLVM.Prelude++import Foreign.Ptr++-- | a blind type to correspond to LLVMContext+data Context++-- | <http://llvm.org/doxygen/group__LLVMCCoreContext.html#gaac4f39a2d0b9735e64ac7681ab543b4c>+foreign import ccall unsafe "LLVMContextCreate" contextCreate ::+    IO (Ptr Context)++-- | <http://llvm.org/doxygen/group__LLVMCCoreContext.html#ga0055cde9a9b2497b332d639d8844a810>+foreign import ccall unsafe "LLVMGetGlobalContext" getGlobalContext ::+    IO (Ptr Context)++-- | <http://llvm.org/doxygen/group__LLVMCCoreContext.html#ga9cf8b0fb4a546d4cdb6f64b8055f5f57>+foreign import ccall unsafe "LLVMContextDispose" contextDispose ::+    Ptr Context -> IO ()

@@ -0,0 +1,26 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}++module LLVM.Internal.FFI.DataLayout where++import LLVM.Prelude++import Foreign.C.String+import Foreign.Ptr++import LLVM.Internal.FFI.LLVMCTypes++data DataLayout++-- Oooh those wacky LLVM C-API coders: C API called DataLayout TargetData.+-- Great. Just great.++foreign import ccall unsafe "LLVMCreateTargetData" createDataLayout :: +  CString -> IO (Ptr DataLayout)++foreign import ccall unsafe "LLVMDisposeTargetData" disposeDataLayout :: +  Ptr DataLayout -> IO ()++foreign import ccall unsafe "LLVMCopyStringRepOfTargetData" dataLayoutToString ::+  Ptr DataLayout -> IO (OwnerTransfered CString)

@@ -0,0 +1,71 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}++module LLVM.Internal.FFI.ExecutionEngine where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.Module+import LLVM.Internal.FFI.LLVMCTypes++data ExecutionEngine++foreign import ccall unsafe "LLVMCreateExecutionEngineForModule" createExecutionEngineForModule ::+  Ptr (Ptr ExecutionEngine) -> Ptr Module -> Ptr (OwnerTransfered CString) -> IO CUInt++foreign import ccall unsafe "LLVMCreateInterpreterForModule" createInterpreterForModule ::+  Ptr (Ptr ExecutionEngine) -> Ptr Module -> Ptr (OwnerTransfered CString) -> IO CUInt++foreign import ccall unsafe "LLVMCreateJITCompilerForModule" createJITCompilerForModule ::+  Ptr (Ptr ExecutionEngine) -> Ptr Module -> CUInt -> Ptr (OwnerTransfered CString) -> IO CUInt++foreign import ccall unsafe "LLVMCreateMCJITCompilerForModule" createMCJITCompilerForModule ::+  Ptr (Ptr ExecutionEngine) -> Ptr Module -> Ptr MCJITCompilerOptions -> CSize -> Ptr (OwnerTransfered CString) -> IO CUInt++foreign import ccall unsafe "LLVMDisposeExecutionEngine" disposeExecutionEngine ::+  Ptr ExecutionEngine -> IO ()++foreign import ccall unsafe "LLVMAddModule" addModule ::+  Ptr ExecutionEngine -> Ptr Module -> IO ()++foreign import ccall unsafe "LLVMRemoveModule" removeModule ::+  Ptr ExecutionEngine -> Ptr Module -> Ptr (Ptr Module) -> Ptr CString -> IO CUInt++foreign import ccall unsafe "LLVMFindFunction" findFunction ::+  Ptr ExecutionEngine -> CString -> Ptr (Ptr Function) -> IO CUInt++foreign import ccall unsafe "LLVMGetPointerToGlobal" getPointerToGlobal ::+  Ptr ExecutionEngine -> Ptr GlobalValue -> IO (Ptr ())++foreign import ccall unsafe "LLVMLinkInInterpreter" linkInInterpreter :: +  IO ()++foreign import ccall unsafe "LLVMLinkInMCJIT" linkInMCJIT :: +  IO ()++data MCJITCompilerOptions++foreign import ccall unsafe "LLVM_Hs_GetMCJITCompilerOptionsSize" getMCJITCompilerOptionsSize ::+  IO CSize++foreign import ccall unsafe "LLVMInitializeMCJITCompilerOptions" initializeMCJITCompilerOptions ::+  Ptr MCJITCompilerOptions -> CSize -> IO ()++foreign import ccall unsafe "LLVM_Hs_SetMCJITCompilerOptionsOptLevel" setMCJITCompilerOptionsOptLevel ::+  Ptr MCJITCompilerOptions -> CUInt -> IO ()++foreign import ccall unsafe "LLVM_Hs_SetMCJITCompilerOptionsCodeModel" setMCJITCompilerOptionsCodeModel ::+  Ptr MCJITCompilerOptions -> CodeModel -> IO ()++foreign import ccall unsafe "LLVM_Hs_SetMCJITCompilerOptionsNoFramePointerElim" setMCJITCompilerOptionsNoFramePointerElim ::+  Ptr MCJITCompilerOptions -> LLVMBool -> IO ()++foreign import ccall unsafe "LLVM_Hs_SetMCJITCompilerOptionsEnableFastISel" setMCJITCompilerOptionsEnableFastISel ::+  Ptr MCJITCompilerOptions -> LLVMBool -> IO ()++

@@ -0,0 +1,30 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "llvm-c/ExecutionEngine.h"++using namespace llvm;++extern "C" {++size_t LLVM_Hs_GetMCJITCompilerOptionsSize() {+  return sizeof(struct LLVMMCJITCompilerOptions);+}++void LLVM_Hs_SetMCJITCompilerOptionsOptLevel(struct LLVMMCJITCompilerOptions *o, unsigned x) {+  o->OptLevel = x;+}++void LLVM_Hs_SetMCJITCompilerOptionsCodeModel(struct LLVMMCJITCompilerOptions *o, LLVMCodeModel x) {+  o->CodeModel = x;+}++void LLVM_Hs_SetMCJITCompilerOptionsNoFramePointerElim(struct LLVMMCJITCompilerOptions *o, LLVMBool x) {+  o->NoFramePointerElim = x;+}++void LLVM_Hs_SetMCJITCompilerOptionsEnableFastISel(struct LLVMMCJITCompilerOptions *o, LLVMBool x) {+  o->EnableFastISel = x;+}++}+

@@ -0,0 +1,72 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses+  #-}++module LLVM.Internal.FFI.Function where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.Attribute+import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.PtrHierarchy++foreign import ccall unsafe "LLVMGetFunctionCallConv" getFunctionCallingConvention ::+  Ptr Function -> IO CallingConvention++foreign import ccall unsafe "LLVMSetFunctionCallConv" setFunctionCallingConvention ::+  Ptr Function -> CallingConvention -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetFunctionMixedAttributeSet" getMixedAttributeSet ::+  Ptr Function -> IO MixedAttributeSet++foreign import ccall unsafe "LLVM_Hs_SetFunctionMixedAttributeSet" setMixedAttributeSet ::+  Ptr Function -> MixedAttributeSet -> IO ()++foreign import ccall unsafe "LLVMGetFirstBasicBlock" getFirstBasicBlock ::+  Ptr Function -> IO (Ptr BasicBlock)++foreign import ccall unsafe "LLVMGetLastBasicBlock" getLastBasicBlock ::+  Ptr Function -> IO (Ptr BasicBlock)++foreign import ccall unsafe "LLVMGetNextBasicBlock" getNextBasicBlock ::+  Ptr BasicBlock -> IO (Ptr BasicBlock)++foreign import ccall unsafe "LLVMAppendBasicBlockInContext" appendBasicBlockInContext ::+  Ptr Context -> Ptr Function -> CString -> IO (Ptr BasicBlock)+++foreign import ccall unsafe "LLVMCountParams" countParams ::+  Ptr Function -> IO CUInt++foreign import ccall unsafe "LLVMGetParams" getParams ::+  Ptr Function -> Ptr (Ptr Parameter) -> IO ()++foreign import ccall unsafe "LLVMGetGC" getGC ::+  Ptr Function -> IO CString++foreign import ccall unsafe "LLVMSetGC" setGC ::+  Ptr Function -> CString -> IO ()+++foreign import ccall unsafe "LLVM_Hs_HasFunctionPrefixData" hasPrefixData ::+  Ptr Function -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_GetFunctionPrefixData" getPrefixData ::+  Ptr Function -> IO (Ptr Constant)++foreign import ccall unsafe "LLVM_Hs_SetFunctionPrefixData" setPrefixData ::+  Ptr Function -> Ptr Constant -> IO ()++foreign import ccall unsafe "LLVMHasPersonalityFn" hasPersonalityFn ::+  Ptr Function -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_SetPersonalityFn" setPersonalityFn ::+  Ptr Function -> Ptr Constant -> IO ()++foreign import ccall unsafe "LLVMGetPersonalityFn" getPersonalityFn ::+  Ptr Function -> IO (Ptr Constant)

@@ -0,0 +1,41 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/Attributes.h"+#include "llvm/IR/Function.h"+#include "llvm/IR/Value.h"++#include "llvm-c/Core.h"+#include "LLVM/Internal/FFI/AttributeC.hpp"++using namespace llvm;++extern "C" {++const AttributeSetImpl *LLVM_Hs_GetFunctionMixedAttributeSet(LLVMValueRef f) {+	return wrap(unwrap<Function>(f)->getAttributes());+}++void LLVM_Hs_SetFunctionMixedAttributeSet(LLVMValueRef f, AttributeSetImpl *asi) {+	unwrap<Function>(f)->setAttributes(unwrap(asi));+}++LLVMBool LLVM_Hs_HasFunctionPrefixData(LLVMValueRef f) {+  return unwrap<Function>(f)->hasPrefixData();+}++LLVMValueRef LLVM_Hs_GetFunctionPrefixData(LLVMValueRef f) {+  return wrap(unwrap<Function>(f)->getPrefixData());+}++void LLVM_Hs_SetFunctionPrefixData(LLVMValueRef f, LLVMValueRef p) {+  unwrap<Function>(f)->setPrefixData(unwrap<Constant>(p));+}++// This wrapper is necessary because LLVMSetPersonalityFn fails if+// personalityFn is a nullptr even though the C++ API allows that.+void LLVM_Hs_SetPersonalityFn(LLVMValueRef fn, LLVMValueRef personalityFn) {+    unwrap<Function>(fn)->setPersonalityFn(personalityFn == nullptr ?+                                           nullptr : unwrap<Constant>(personalityFn));+}++}

@@ -0,0 +1,26 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+-- | FFI functions for handling the LLVM GlobalAlias class+module LLVM.Internal.FFI.GlobalAlias where++import LLVM.Prelude++import Foreign.Ptr++import LLVM.Internal.FFI.PtrHierarchy++-- | test if a 'Value' is a 'GlobalAlias'+foreign import ccall unsafe "LLVMIsAGlobalAlias" isAGlobalAlias ::+    Ptr Value -> IO (Ptr GlobalAlias)++-- | get the constant aliased by this alias+foreign import ccall unsafe "LLVM_Hs_GetAliasee" getAliasee ::+    Ptr GlobalAlias -> IO (Ptr Constant)++-- | set the constant aliased by this alias+foreign import ccall unsafe "LLVM_Hs_SetAliasee" setAliasee ::+    Ptr GlobalAlias -> Ptr Constant -> IO ()+

@@ -0,0 +1,22 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/GlobalAlias.h"+#include "llvm/IR/GlobalObject.h"++#include "llvm-c/Core.h"++#include <iostream>++using namespace llvm;++extern "C" {++LLVMValueRef LLVM_Hs_GetAliasee(LLVMValueRef g) {+	return wrap(unwrap<GlobalAlias>(g)->getAliasee());+}++void LLVM_Hs_SetAliasee(LLVMValueRef g, LLVMValueRef c) {+	unwrap<GlobalAlias>(g)->setAliasee(unwrap<Constant>(c));+}++}

@@ -0,0 +1,58 @@+#ifndef __LLVM_INTERNAL_FFI__GLOBAL_VALUE__H__+#define __LLVM_INTERNAL_FFI__GLOBAL_VALUE__H__++#define LLVM_HS_FOR_EACH_LINKAGE(macro)		\+	macro(External)																\+	macro(AvailableExternally)										\+	macro(LinkOnceAny)														\+	macro(LinkOnceODR)														\+	macro(WeakAny)																\+	macro(WeakODR)																\+	macro(Appending)															\+	macro(Internal)																\+	macro(Private)																\+	macro(ExternalWeak)														\+	macro(Common)++#define LLVM_HS_FOR_EACH_VISIBILITY(macro)	\+	macro(Default)																\+	macro(Hidden)																	\+	macro(Protected)															\++#define LLVM_HS_FOR_EACH_COMDAT_SELECTION_KIND(macro)	\+	macro(Any)                                                \+	macro(ExactMatch)                                         \+	macro(Largest)                                            \+	macro(NoDuplicates)                                       \+	macro(SameSize)++typedef enum {+#define ENUM_CASE(n) LLVM_Hs_COMDAT_Selection_Kind_ ## n,+LLVM_HS_FOR_EACH_COMDAT_SELECTION_KIND(ENUM_CASE)+#undef ENUM_CASE+} LLVM_Hs_COMDAT_Selection_Kind;++#define LLVM_HS_FOR_EACH_DLL_STORAGE_CLASS(macro)	\+	macro(Default)                                        \+	macro(DLLImport)                                      \+	macro(DLLExport)++#define LLVM_HS_FOR_EACH_THREAD_LOCAL_MODE(macro)  \+	macro(NotThreadLocal)                                 \+	macro(GeneralDynamicTLSModel)                         \+	macro(LocalDynamicTLSModel)                           \+	macro(InitialExecTLSModel)                            \+	macro(LocalExecTLSModel)++#define LLVM_HS_FOR_EACH_UNNAMED_ADDR(macro) \+	macro(None)                                   \+	macro(Local)                                  \+	macro(Global)++typedef enum {+#define ENUM_CASE(x) LLVMUnnamedAddr ## x,+LLVM_HS_FOR_EACH_UNNAMED_ADDR(ENUM_CASE)+#undef ENUM_CASE+} LLVMUnnamedAddr;++#endif

@@ -0,0 +1,79 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+-- | FFI functions for handling the LLVM GlobalValue class+module LLVM.Internal.FFI.GlobalValue where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.LLVMCTypes++data COMDAT++foreign import ccall unsafe "LLVMIsAGlobalValue" isAGlobalValue ::+  Ptr Value -> IO (Ptr GlobalValue)++foreign import ccall unsafe "LLVMGetLinkage" getLinkage ::+  Ptr GlobalValue -> IO Linkage++foreign import ccall unsafe "LLVMSetLinkage" setLinkage ::+  Ptr GlobalValue -> Linkage -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetSection" getSection ::+  Ptr GlobalValue -> Ptr CSize -> IO CString++foreign import ccall unsafe "LLVMSetSection" setSection ::+  Ptr GlobalValue -> CString -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetCOMDAT" getCOMDAT ::+  Ptr GlobalValue -> IO (Ptr COMDAT)++foreign import ccall unsafe "LLVM_Hs_SetCOMDAT" setCOMDAT ::+  Ptr GlobalObject -> Ptr COMDAT -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetCOMDATName" getCOMDATName ::+  Ptr COMDAT -> Ptr CSize -> IO (Ptr CChar)++foreign import ccall unsafe "LLVM_Hs_GetCOMDATSelectionKind" getCOMDATSelectionKind ::+  Ptr COMDAT -> IO COMDATSelectionKind++foreign import ccall unsafe "LLVM_Hs_SetCOMDATSelectionKind" setCOMDATSelectionKind ::+  Ptr COMDAT -> COMDATSelectionKind -> IO ()++foreign import ccall unsafe "LLVMGetVisibility" getVisibility ::+  Ptr GlobalValue -> IO Visibility++foreign import ccall unsafe "LLVMSetVisibility" setVisibility ::+  Ptr GlobalValue -> Visibility -> IO ()++foreign import ccall unsafe "LLVMGetDLLStorageClass" getDLLStorageClass ::+  Ptr GlobalValue -> IO DLLStorageClass++foreign import ccall unsafe "LLVMSetDLLStorageClass" setDLLStorageClass ::+  Ptr GlobalValue -> DLLStorageClass -> IO ()++foreign import ccall unsafe "LLVMGetAlignment" getAlignment ::+  Ptr GlobalValue -> IO CUInt++foreign import ccall unsafe "LLVMSetAlignment" setAlignment ::+  Ptr GlobalValue -> CUInt -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetUnnamedAddr" getUnnamedAddr ::+  Ptr GlobalValue -> IO UnnamedAddr++foreign import ccall unsafe "LLVM_Hs_SetUnnamedAddr" setUnnamedAddr ::+  Ptr GlobalValue -> UnnamedAddr -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetThreadLocalMode" getThreadLocalMode ::+  Ptr GlobalValue -> IO ThreadLocalMode++foreign import ccall unsafe "LLVM_Hs_SetThreadLocalMode" setThreadLocalMode ::+  Ptr GlobalValue -> ThreadLocalMode -> IO ()++

@@ -0,0 +1,87 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/Comdat.h"+#include "llvm/IR/GlobalValue.h"+#include "llvm/IR/GlobalObject.h"+#include "llvm-c/Core.h"+#include "LLVM/Internal/FFI/GlobalValue.h"++using namespace llvm;++extern "C" {++const Comdat *LLVM_Hs_GetCOMDAT(LLVMValueRef globalVal) {+  return unwrap<GlobalValue>(globalVal)->getComdat();+}++void LLVM_Hs_SetCOMDAT(LLVMValueRef globalObj, Comdat *comdat) {+  return unwrap<GlobalObject>(globalObj)->setComdat(comdat);+}++const char *LLVM_Hs_GetCOMDATName(const Comdat &comdat, size_t &size) {+  StringRef ref = comdat.getName();+  size = ref.size();+  return ref.data();+}++#define ENUM_CASE(n)                                                           \+    static_assert(unsigned(Comdat::n) ==                                       \+                      unsigned(LLVM_Hs_COMDAT_Selection_Kind_##n),        \+                  "COMDAT SelectionKind Enum mismatch");+LLVM_HS_FOR_EACH_COMDAT_SELECTION_KIND(ENUM_CASE)+#undef ENUM_CASE++const char* LLVM_Hs_GetSection(LLVMValueRef globalVal, size_t* strLength) {+    const auto& section = unwrap<GlobalValue>(globalVal)->getSection();+    *strLength = section.size();+    return section.data();+}++unsigned LLVM_Hs_GetCOMDATSelectionKind(const Comdat &comdat) {+  return unsigned(comdat.getSelectionKind());+}++void LLVM_Hs_SetCOMDATSelectionKind(Comdat &comdat, unsigned csk) {+  comdat.setSelectionKind(Comdat::SelectionKind(csk));+}++static LLVMUnnamedAddr unwrap(GlobalValue::UnnamedAddr a) {+    switch (a) {+#define ENUM_CASE(x) case GlobalValue::UnnamedAddr::x: return LLVMUnnamedAddr ## x;+LLVM_HS_FOR_EACH_UNNAMED_ADDR(ENUM_CASE)+#undef ENUM_CASE+    default: return LLVMUnnamedAddrNone;+    }+}++static GlobalValue::UnnamedAddr wrap(LLVMUnnamedAddr a) {+    switch (a) {+#define ENUM_CASE(x) case LLVMUnnamedAddr ## x: return GlobalValue::UnnamedAddr::x;+LLVM_HS_FOR_EACH_UNNAMED_ADDR(ENUM_CASE)+#undef ENUM_CASE+    default: return GlobalValue::UnnamedAddr::None;+    }+}++LLVMUnnamedAddr LLVM_Hs_GetUnnamedAddr(LLVMValueRef globalVal) {+    return unwrap(unwrap<GlobalValue>(globalVal)->getUnnamedAddr());+}++void LLVM_Hs_SetUnnamedAddr(LLVMValueRef globalVal, LLVMUnnamedAddr attr) {+    unwrap<GlobalValue>(globalVal)->setUnnamedAddr(wrap(attr));+}++#define ENUM_CASE(n)                                                           \+    static_assert(unsigned(GlobalValue::n) == unsigned(LLVM##n),               \+                  "TLS Model Enum mismatch");+LLVM_HS_FOR_EACH_THREAD_LOCAL_MODE(ENUM_CASE)+#undef ENUM_CASE++LLVMThreadLocalMode LLVM_Hs_GetThreadLocalMode(LLVMValueRef globalVal) {+    return LLVMThreadLocalMode(unwrap<GlobalValue>(globalVal)->getThreadLocalMode());+}++void LLVM_Hs_SetThreadLocalMode(LLVMValueRef globalVal, LLVMThreadLocalMode mode) {+    unwrap<GlobalValue>(globalVal)->setThreadLocalMode(GlobalValue::ThreadLocalMode(mode));+}++}

@@ -0,0 +1,31 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses,+  UndecidableInstances+  #-}+-- | FFI functions for handling the LLVM GlobalVariable class+module LLVM.Internal.FFI.GlobalVariable where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.LLVMCTypes++foreign import ccall unsafe "LLVMIsAGlobalVariable" isAGlobalVariable ::+    Ptr Value -> IO (Ptr GlobalVariable)++foreign import ccall unsafe "LLVMIsGlobalConstant" isGlobalConstant ::+    Ptr GlobalVariable -> IO LLVMBool++foreign import ccall unsafe "LLVMSetGlobalConstant" setGlobalConstant ::+    Ptr GlobalVariable -> LLVMBool -> IO ()++foreign import ccall unsafe "LLVMGetInitializer" getInitializer ::+    Ptr GlobalVariable -> IO (Ptr Constant)++foreign import ccall unsafe "LLVMSetInitializer" setInitializer ::+    Ptr GlobalVariable -> Ptr Constant -> IO ()+

@@ -0,0 +1,14 @@+#ifndef __LLVM_INTERNAL_FFI__INLINE_ASSEMBLY__H__+#define __LLVM_INTERNAL_FFI__INLINE_ASSEMBLY__H__++#define LLVM_HS_FOR_EACH_ASM_DIALECT(macro) \+	macro(ATT) \+	macro(Intel) \++typedef enum {+#define ENUM_CASE(d) LLVMAsmDialect_ ## d,+	LLVM_HS_FOR_EACH_ASM_DIALECT(ENUM_CASE)+#undef ENUM_CASE+} LLVMAsmDialect;++#endif

@@ -0,0 +1,35 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}++module LLVM.Internal.FFI.InlineAssembly where++import LLVM.Prelude++import Foreign.C+import Foreign.Ptr++import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.PtrHierarchy++foreign import ccall unsafe "LLVMIsAInlineAsm" isAInlineAsm ::+  Ptr Value -> IO (Ptr InlineAsm)++foreign import ccall unsafe "LLVM_Hs_CreateInlineAsm" createInlineAsm ::+  Ptr Type -> CString -> CString -> LLVMBool -> LLVMBool -> AsmDialect -> IO (Ptr InlineAsm)++foreign import ccall unsafe "LLVM_Hs_GetInlineAsmAsmString" getInlineAsmAssemblyString ::+  Ptr InlineAsm -> IO CString++foreign import ccall unsafe "LLVM_Hs_GetInlineAsmConstraintString" getInlineAsmConstraintString ::+  Ptr InlineAsm -> IO CString++foreign import ccall unsafe "LLVM_Hs_InlineAsmHasSideEffects" inlineAsmHasSideEffects ::+  Ptr InlineAsm -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_InlineAsmIsAlignStack" inlineAsmIsAlignStack ::+  Ptr InlineAsm -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_GetInlineAsmDialect" getInlineAsmDialect ::+  Ptr InlineAsm -> IO AsmDialect+

@@ -0,0 +1,73 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/InlineAsm.h"+#include "llvm/IR/Function.h"+#include "llvm-c/Core.h"++#include "LLVM/Internal/FFI/InlineAssembly.h"++using namespace llvm;++namespace llvm {+static LLVMAsmDialect wrap(InlineAsm::AsmDialect d) {+	switch(d) {+#define ENUM_CASE(x) case InlineAsm::AD_ ## x: return LLVMAsmDialect_ ## x;+LLVM_HS_FOR_EACH_ASM_DIALECT(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMAsmDialect(0);+	}+}++static InlineAsm::AsmDialect unwrap(LLVMAsmDialect d) {+	switch(d) {+#define ENUM_CASE(x) case LLVMAsmDialect_ ## x: return InlineAsm::AD_ ## x;+LLVM_HS_FOR_EACH_ASM_DIALECT(ENUM_CASE)+#undef ENUM_CASE+	default: return InlineAsm::AsmDialect(0);+	}+}+}++extern "C" {++LLVMValueRef LLVM_Hs_CreateInlineAsm(+	LLVMTypeRef t,+	const char *asmStr,+	const char *constraintsStr,+	LLVMBool hasSideEffects,+	LLVMBool isAlignStack,+	LLVMAsmDialect dialect+) {+	return wrap(+		InlineAsm::get(+			unwrap<FunctionType>(t), +			asmStr,+			constraintsStr,+			hasSideEffects,+			isAlignStack,+			unwrap(dialect)+		)+	);+}++const char *LLVM_Hs_GetInlineAsmAsmString(LLVMValueRef v) {+	return unwrap<InlineAsm>(v)->getAsmString().c_str();+}++const char *LLVM_Hs_GetInlineAsmConstraintString(LLVMValueRef v) {+	return unwrap<InlineAsm>(v)->getConstraintString().c_str();+}++LLVMBool LLVM_Hs_InlineAsmHasSideEffects(LLVMValueRef v) {+	return unwrap<InlineAsm>(v)->hasSideEffects();+}++LLVMBool LLVM_Hs_InlineAsmIsAlignStack(LLVMValueRef v) {+	return unwrap<InlineAsm>(v)->isAlignStack();+}++LLVMAsmDialect LLVM_Hs_GetInlineAsmDialect(LLVMValueRef v) {+	return wrap(unwrap<InlineAsm>(v)->getDialect());+}++}+

@@ -0,0 +1,67 @@+#ifndef __LLVM_INTERNAL_FFI__INSTRUCTION__H__+#define __LLVM_INTERNAL_FFI__INSTRUCTION__H__++#include "llvm/Config/llvm-config.h"++#define LLVM_HS_FOR_EACH_ATOMIC_ORDERING(macro) \+	macro(NotAtomic) \+	macro(Unordered) \+	macro(Monotonic) \+	macro(Acquire) \+	macro(Release) \+	macro(AcquireRelease) \+	macro(SequentiallyConsistent)++#define LLVM_HS_FOR_EACH_RMW_OPERATION(macro) \+	macro(Xchg) \+	macro(Add) \+	macro(Sub) \+	macro(And) \+	macro(Nand) \+	macro(Or) \+	macro(Xor) \+	macro(Max) \+	macro(Min) \+	macro(UMax) \+	macro(UMin)++#define LLVM_HS_FOR_EACH_SYNCRONIZATION_SCOPE(macro) \+	macro(SingleThread) \+	macro(CrossThread)++typedef enum {+#define ENUM_CASE(x) LLVM ## x ## SynchronizationScope,+LLVM_HS_FOR_EACH_SYNCRONIZATION_SCOPE(ENUM_CASE)+#undef ENUM_CASE+} LLVMSynchronizationScope;++#define LLVM_HS_FOR_EACH_FAST_MATH_FLAG(macro) \+	macro(UnsafeAlgebra, unsafeAlgebra)								\+	macro(NoNaNs, noNaNs)															\+	macro(NoInfs, noInfs)															\+	macro(NoSignedZeros, noSignedZeros)								\+	macro(AllowReciprocal, allowReciprocal)++typedef enum {+#define ENUM_CASE(x,l) LLVM ## x ## Bit,+LLVM_HS_FOR_EACH_FAST_MATH_FLAG(ENUM_CASE)+#undef ENUM_CASE+} LLVMFastMathFlagBit;++typedef enum {+#define ENUM_CASE(x,l) LLVM ## x = (1 << LLVM ## x ## Bit),+LLVM_HS_FOR_EACH_FAST_MATH_FLAG(ENUM_CASE)+#undef ENUM_CASE+} LLVMFastMathFlags;++#define LLVM_HS_FOR_EACH_TAIL_CALL_KIND(macro) \+	macro(None)                                       \+	macro(Tail)                                       \+	macro(MustTail)++typedef enum {+#define ENUM_CASE(x) LLVM_Hs_TailCallKind_ ## x,+LLVM_HS_FOR_EACH_TAIL_CALL_KIND(ENUM_CASE)+#undef ENUM_CASE+} LLVM_Hs_TailCallKind;+#endif

@@ -0,0 +1,181 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses,+  UndecidableInstances,+  TemplateHaskell+  #-}+module LLVM.Internal.FFI.Instruction where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.Attribute+import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.LLVMCTypes++foreign import ccall unsafe "LLVMIsAInstruction" isAInstruction ::+  Ptr Value -> IO (Ptr Instruction)++newtype COpcode = COpcode CUInt++-- get the C API opcode+foreign import ccall unsafe "LLVMGetInstructionOpcode" getInstructionOpcode :: +  Ptr Instruction -> IO COpcode++-- get the C++ API opcode (one less level of mapping than for that from the C API)+foreign import ccall unsafe "LLVM_Hs_GetInstructionDefOpcode" getInstructionDefOpcode :: +  Ptr Instruction -> IO CPPOpcode++foreign import ccall unsafe "LLVMGetICmpPredicate" getICmpPredicate ::+  Ptr Instruction -> IO ICmpPredicate++foreign import ccall unsafe "LLVM_Hs_GetFCmpPredicate" getFCmpPredicate ::+  Ptr Instruction -> IO FCmpPredicate++foreign import ccall unsafe "LLVM_Hs_GetCallSiteCallingConvention" getCallSiteCallingConvention ::+  Ptr Instruction -> IO CallingConvention++foreign import ccall unsafe "LLVM_Hs_SetCallSiteCallingConvention" setCallSiteCallingConvention ::+  Ptr Instruction -> CallingConvention -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetTailCallKind" getTailCallKind ::+  Ptr Instruction -> IO TailCallKind++foreign import ccall unsafe "LLVM_Hs_SetTailCallKind" setTailCallKind ::+  Ptr Instruction -> TailCallKind -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetCallSiteCalledValue" getCallSiteCalledValue ::+  Ptr Instruction -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_GetCallSiteAttributeSet" getCallSiteAttributeSet ::+  Ptr Instruction -> IO MixedAttributeSet++foreign import ccall unsafe "LLVM_Hs_SetCallSiteAttributeSet" setCallSiteAttributeSet ::+  Ptr Instruction -> MixedAttributeSet -> IO ()+                     +foreign import ccall unsafe "LLVMAddIncoming" addIncoming' ::+  Ptr Instruction -> Ptr (Ptr Value) -> Ptr (Ptr BasicBlock) -> CUInt -> IO ()++addIncoming :: Ptr Instruction -> (CUInt, Ptr (Ptr Value)) -> (CUInt, Ptr (Ptr BasicBlock)) -> IO ()+addIncoming i (nvs, vs) (nbs, bs) | nbs == nvs = addIncoming' i vs bs nbs++foreign import ccall unsafe "LLVMCountIncoming" countIncoming ::+  Ptr Instruction -> IO CUInt++foreign import ccall unsafe "LLVMGetIncomingValue" getIncomingValue ::+  Ptr Instruction -> CUInt -> IO (Ptr Value)++foreign import ccall unsafe "LLVMGetIncomingBlock" getIncomingBlock ::+  Ptr Instruction -> CUInt -> IO (Ptr BasicBlock)+++foreign import ccall unsafe "LLVMAddCase" addCase ::+  Ptr Instruction -> Ptr Constant -> Ptr BasicBlock -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetSwitchCases" getSwitchCases ::+  Ptr Instruction -> Ptr (Ptr Constant) -> Ptr (Ptr BasicBlock) -> IO ()++foreign import ccall unsafe "LLVMAddDestination" addDestination ::+  Ptr Instruction -> Ptr BasicBlock -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetIndirectBrDests" getIndirectBrDests ::+  Ptr Instruction -> Ptr (Ptr BasicBlock) -> IO ()+++foreign import ccall unsafe "LLVM_Hs_GetInstrAlignment" getInstrAlignment ::+  Ptr Instruction -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_SetInstrAlignment" setInstrAlignment ::+  Ptr Instruction -> CUInt -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetAllocaNumElements" getAllocaNumElements ::+  Ptr Instruction -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_GetAllocatedType" getAllocatedType ::+  Ptr Instruction -> IO (Ptr Type)++foreign import ccall unsafe "LLVM_Hs_GetAtomicOrdering" getAtomicOrdering ::+  Ptr Instruction -> IO MemoryOrdering++foreign import ccall unsafe "LLVM_Hs_GetFailureAtomicOrdering" getFailureAtomicOrdering ::+  Ptr Instruction -> IO MemoryOrdering++foreign import ccall unsafe "LLVM_Hs_GetSynchronizationScope" getSynchronizationScope ::+  Ptr Instruction -> IO SynchronizationScope++getAtomicity :: Ptr Instruction -> IO (SynchronizationScope, MemoryOrdering)+getAtomicity i = return (,) `ap` getSynchronizationScope i `ap` getAtomicOrdering i++foreign import ccall unsafe "LLVM_Hs_GetVolatile" getVolatile ::+  Ptr Instruction -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_GetInBounds" getInBounds ::+  Ptr Value -> IO LLVMBool++foreign import ccall unsafe "LLVM_Hs_GetAtomicRMWBinOp" getAtomicRMWBinOp ::+  Ptr Instruction -> IO RMWOperation++foreign import ccall unsafe "LLVM_Hs_CountInstStructureIndices" countInstStructureIndices ::+  Ptr Instruction -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_GetInstStructureIndices" getInstStructureIndices ::+  Ptr Instruction -> Ptr CUInt -> IO ()++foreign import ccall unsafe "LLVMAddClause" addClause ::+  Ptr Instruction -> Ptr Constant -> IO ()++foreign import ccall unsafe "LLVMSetCleanup" setCleanup ::+  Ptr Instruction -> LLVMBool -> IO ()++foreign import ccall unsafe "LLVMIsCleanup" isCleanup ::+  Ptr Instruction -> IO LLVMBool++foreign import ccall unsafe "LLVMGetNumClauses" getNumClauses ::+  Ptr Instruction -> IO CUInt++foreign import ccall unsafe "LLVMGetClause" getClause ::+  Ptr Instruction -> CUInt -> IO (Ptr Constant)++foreign import ccall unsafe "LLVM_Hs_SetMetadata" setMetadata ::+  Ptr Instruction -> MDKindID -> Ptr MDNode -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetMetadata" getMetadata ::+  Ptr Instruction -> Ptr MDKindID -> Ptr (Ptr MDNode) -> CUInt -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_GetCleanupPad" getCleanupPad ::+  Ptr Instruction -> IO (Ptr Instruction)++foreign import ccall unsafe "LLVM_Hs_GetUnwindDest" getUnwindDest ::+  Ptr Instruction -> IO (Ptr BasicBlock)++foreign import ccall unsafe "LLVM_Hs_GetParentPad" getParentPad ::+  Ptr Instruction -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_GetNumArgOperands" getNumArgOperands ::+  Ptr Instruction -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_GetArgOperand" getArgOperand ::+  Ptr Instruction -> CUInt -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_CatchSwitch_GetParentPad" catchSwitchGetParentPad ::+  Ptr Instruction -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_CatchSwitch_GetUnwindDest" catchSwitchGetUnwindDest ::+  Ptr Instruction -> IO (Ptr BasicBlock)++foreign import ccall unsafe "LLVM_Hs_CatchSwitch_GetNumHandlers" catchSwitchGetNumHandlers ::+  Ptr Instruction -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_CatchSwitch_GetHandler" catchSwitchGetHandler ::+  Ptr Instruction -> CUInt -> IO (Ptr BasicBlock)++foreign import ccall unsafe "LLVM_Hs_CatchSwitch_AddHandler" catchSwitchAddHandler ::+  Ptr Instruction -> Ptr BasicBlock -> IO ()++foreign import ccall unsafe "LLVM_Hs_CatchRet_GetCatchPad" catchRetGetCatchPad ::+  Ptr Instruction -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_CatchRet_GetSuccessor" catchRetGetSuccessor ::+  Ptr Instruction -> IO (Ptr BasicBlock)

@@ -0,0 +1,323 @@+#define __STDC_LIMIT_MACROS+#include "llvm/Config/llvm-config.h"+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/InstrTypes.h"+#include "llvm/IR/Attributes.h"+#include "llvm/IR/Operator.h"+#include "llvm/IR/BasicBlock.h"+#include "llvm/IR/Metadata.h"+#include "llvm/IR/CallSite.h"++#include "llvm-c/Core.h"++#include "LLVM/Internal/FFI/Metadata.hpp"+#include "LLVM/Internal/FFI/AttributeC.hpp"+#include "LLVM/Internal/FFI/Instruction.h"++using namespace llvm;++namespace llvm {++static LLVMAtomicOrdering wrap(AtomicOrdering l) {+	switch(l) {+#define ENUM_CASE(x) case AtomicOrdering::x: return LLVMAtomicOrdering ## x;+LLVM_HS_FOR_EACH_ATOMIC_ORDERING(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMAtomicOrdering(0);+	}+}++static LLVMSynchronizationScope wrap(SynchronizationScope l) {+	switch(l) {+#define ENUM_CASE(x) case x: return LLVM ## x ## SynchronizationScope;+LLVM_HS_FOR_EACH_SYNCRONIZATION_SCOPE(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMSynchronizationScope(0);+	}+}++static LLVMAtomicRMWBinOp wrap(AtomicRMWInst::BinOp l) {+	switch(l) {+#define ENUM_CASE(x) case AtomicRMWInst::x: return LLVMAtomicRMWBinOp ## x;+LLVM_HS_FOR_EACH_RMW_OPERATION(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMAtomicRMWBinOp(0);+	}+}++LLVMFastMathFlags wrap(FastMathFlags f) {+	unsigned r = 0;+#define ENUM_CASE(u,l) if (f.l()) r |= unsigned(LLVM ## u);+LLVM_HS_FOR_EACH_FAST_MATH_FLAG(ENUM_CASE)+#undef ENUM_CASE+	return LLVMFastMathFlags(r);+}++}++extern "C" {++unsigned LLVM_Hs_GetInstructionDefOpcode(LLVMValueRef val) {+	return unwrap<Instruction>(val)->getOpcode();+}++unsigned LLVM_Hs_HasNoSignedWrap(LLVMValueRef val) {+	return unwrap<OverflowingBinaryOperator>(val)->hasNoSignedWrap();+}++unsigned LLVM_Hs_HasNoUnsignedWrap(LLVMValueRef val) {+	return unwrap<OverflowingBinaryOperator>(val)->hasNoUnsignedWrap();+}++int LLVM_Hs_IsExact(LLVMValueRef val) {+	return unwrap<PossiblyExactOperator>(val)->isExact();+}++LLVMFastMathFlags LLVM_Hs_GetFastMathFlags(LLVMValueRef val) {+	return wrap(unwrap<Instruction>(val)->getFastMathFlags());+}++LLVMValueRef LLVM_Hs_GetCallSiteCalledValue(LLVMValueRef i) {+	return wrap(CallSite(unwrap<Instruction>(i)).getCalledValue());+}++const AttributeSetImpl *LLVM_Hs_GetCallSiteAttributeSet(LLVMValueRef i) {+	return wrap(CallSite(unwrap<Instruction>(i)).getAttributes());+}++void LLVM_Hs_SetCallSiteAttributeSet(LLVMValueRef i, const AttributeSetImpl *asi) {+	CallSite(unwrap<Instruction>(i)).setAttributes(unwrap(asi));+}++unsigned LLVM_Hs_GetCallSiteCallingConvention(LLVMValueRef i) {+  return unsigned(CallSite(unwrap<Instruction>(i)).getCallingConv());+}++void LLVM_Hs_SetCallSiteCallingConvention(LLVMValueRef i, unsigned cc) {+  CallSite(unwrap<Instruction>(i)).setCallingConv(llvm::CallingConv::ID(cc));+}++#define CHECK(name)                                                            \+    static_assert(unsigned(llvm::CallInst::TCK_##name) ==                      \+                      unsigned(LLVM_Hs_TailCallKind_##name),              \+                  "LLVM_Hs_TailCallKind enum out of sync w/ "             \+                  "llvm::CallInst::TailCallKind for " #name);+LLVM_HS_FOR_EACH_TAIL_CALL_KIND(CHECK)+#undef CHECK++unsigned LLVM_Hs_GetTailCallKind(LLVMValueRef i) {+    return unwrap<CallInst>(i)->getTailCallKind();+}++void LLVM_Hs_SetTailCallKind(LLVMValueRef i, unsigned kind) {+    return unwrap<CallInst>(i)->setTailCallKind(llvm::CallInst::TailCallKind(kind));+}++LLVMValueRef LLVM_Hs_GetAllocaNumElements(LLVMValueRef a) {+	return wrap(unwrap<AllocaInst>(a)->getArraySize());+}++LLVMTypeRef LLVM_Hs_GetAllocatedType(LLVMValueRef a) {+	return wrap(unwrap<AllocaInst>(a)->getAllocatedType());+}++// ------------------------------------------------------------++#define LLVM_HS_FOR_EACH_ALIGNMENT_INST(macro) \+	macro(Alloca) \+	macro(Load) \+	macro(Store)++unsigned LLVM_Hs_GetInstrAlignment(LLVMValueRef l) {+	switch(unwrap<Instruction>(l)->getOpcode()) {+#define ENUM_CASE(n) case Instruction::n: return unwrap<n ## Inst>(l)->getAlignment();+		LLVM_HS_FOR_EACH_ALIGNMENT_INST(ENUM_CASE)+#undef ENUM_CASE+	default: return 0;+	}+}++void LLVM_Hs_SetInstrAlignment(LLVMValueRef l, unsigned a) {+	switch(unwrap<Instruction>(l)->getOpcode()) {+#define ENUM_CASE(n) case Instruction::n: unwrap<n ## Inst>(l)->setAlignment(a); break;+		LLVM_HS_FOR_EACH_ALIGNMENT_INST(ENUM_CASE)+#undef ENUM_CASE+	}+}++// ------------------------------------------------------------++#define LLVM_HS_FOR_EACH_ATOMIC_INST(macro)	\+	macro(Load,)																		\+	macro(Store,)																		\+	macro(Fence,)																		\+	macro(AtomicCmpXchg,Success)										\+	macro(AtomicRMW,)++LLVMAtomicOrdering LLVM_Hs_GetAtomicOrdering(LLVMValueRef i) {+	switch(unwrap<Instruction>(i)->getOpcode()) {+#define ENUM_CASE(n,s) case Instruction::n: return wrap(unwrap<n ## Inst>(i)->get ## s ## Ordering());+		LLVM_HS_FOR_EACH_ATOMIC_INST(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMAtomicOrdering(0);+	}+}++LLVMAtomicOrdering LLVM_Hs_GetFailureAtomicOrdering(LLVMValueRef i) {+	switch(unwrap<Instruction>(i)->getOpcode()) {+	case Instruction::AtomicCmpXchg: return wrap(unwrap<AtomicCmpXchgInst>(i)->getFailureOrdering());+	default: return LLVMAtomicOrdering(0);+	}+}++LLVMSynchronizationScope LLVM_Hs_GetSynchronizationScope(LLVMValueRef i) {+	switch(unwrap<Instruction>(i)->getOpcode()) {+#define ENUM_CASE(n,s) case Instruction::n: return wrap(unwrap<n ## Inst>(i)->getSynchScope());+		LLVM_HS_FOR_EACH_ATOMIC_INST(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMSynchronizationScope(0);+	}+}++#define LLVM_HS_FOR_EACH_VOLATILITY_INST(macro) \+	macro(Load) \+	macro(Store) \+	macro(AtomicCmpXchg) \+	macro(AtomicRMW)++LLVMBool LLVM_Hs_GetVolatile(LLVMValueRef i) {+	switch(unwrap<Instruction>(i)->getOpcode()) {+#define ENUM_CASE(n) case Instruction::n: return unwrap<n ## Inst>(i)->isVolatile();+		LLVM_HS_FOR_EACH_VOLATILITY_INST(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMBool(0);+	}+}++// ------------------------------------------------------------++LLVMBool LLVM_Hs_GetInBounds(LLVMValueRef i) {+	return unwrap<GEPOperator>(i)->isInBounds();+}++LLVMAtomicRMWBinOp LLVM_Hs_GetAtomicRMWBinOp(LLVMValueRef i) {+	return wrap(unwrap<AtomicRMWInst>(i)->getOperation());+}++LLVMRealPredicate LLVM_Hs_GetFCmpPredicate(LLVMValueRef Inst) {+	if (FCmpInst *I = dyn_cast<FCmpInst>(unwrap(Inst)))+		return (LLVMRealPredicate)I->getPredicate();+	if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))+		if (CE->getOpcode() == Instruction::FCmp)+			return (LLVMRealPredicate)CE->getPredicate();+	return (LLVMRealPredicate)0;+}++unsigned LLVM_Hs_CountInstStructureIndices(LLVMValueRef v) {+	if (ExtractValueInst *i = dyn_cast<ExtractValueInst>(unwrap(v))) return i->getNumIndices();+	if (InsertValueInst *i = dyn_cast<InsertValueInst>(unwrap(v))) return i->getNumIndices();+	return 0;+}++void LLVM_Hs_GetInstStructureIndices(LLVMValueRef v, unsigned *is) {+	ArrayRef<unsigned> a;+	if (ExtractValueInst *i = dyn_cast<ExtractValueInst>(unwrap(v))) a = i->getIndices();+	if (InsertValueInst *i = dyn_cast<InsertValueInst>(unwrap(v))) a = i->getIndices();+	std::copy(a.begin(), a.end(), is);+}++void LLVM_Hs_GetSwitchCases(+	LLVMValueRef v,+	LLVMValueRef *values,+	LLVMBasicBlockRef *dests+) {+	SwitchInst *s = unwrap<SwitchInst>(v);+	for(SwitchInst::CaseIt i = s->case_begin(); i != s->case_end(); ++i, ++values, ++dests) {+		*values = wrap(i.getCaseValue());+		*dests = wrap(i.getCaseSuccessor());+	}+}++void LLVM_Hs_GetIndirectBrDests(+	LLVMValueRef v,+	LLVMBasicBlockRef *dests+) {+	IndirectBrInst *ib = unwrap<IndirectBrInst>(v);+	for(unsigned i=0; i != ib->getNumDestinations(); ++i, ++dests)+		*dests = wrap(ib->getDestination(i));+}++inline Metadata **unwrap(LLVMMetadataRef *vals) {+    return reinterpret_cast<Metadata**>(vals);+}++void LLVM_Hs_SetMetadata(LLVMValueRef inst, unsigned kindID, LLVMMetadataRef md) {+    MDNode *N = md ? unwrap<MDNode>(md) : nullptr;+    unwrap<Instruction>(inst)->setMetadata(kindID, N);+}++unsigned LLVM_Hs_GetMetadata(+	LLVMValueRef i,+	unsigned *kinds,+	LLVMMetadataRef *nodes,+	unsigned nKinds+) {+	SmallVector<std::pair<unsigned, MDNode *>, 4> mds;+	unwrap<Instruction>(i)->getAllMetadata(mds);+	if (mds.size() <= nKinds) {+		for(unsigned i=0; i<mds.size(); ++i) {+			kinds[i] = mds[i].first;+			nodes[i] = wrap(mds[i].second);+		}+	}+	return mds.size();+}++LLVMValueRef LLVM_Hs_GetCleanupPad(LLVMValueRef i) {+    return wrap(unwrap<CleanupReturnInst>(i)->getCleanupPad());+}++LLVMBasicBlockRef LLVM_Hs_GetUnwindDest(LLVMValueRef i) {+    return wrap(unwrap<CleanupReturnInst>(i)->getUnwindDest());+}++LLVMValueRef LLVM_Hs_GetParentPad(LLVMValueRef i) {+    return wrap(unwrap<FuncletPadInst>(i)->getParentPad());+}++unsigned LLVM_Hs_GetNumArgOperands(LLVMValueRef i) {+    return unwrap<FuncletPadInst>(i)->getNumArgOperands();+}++LLVMValueRef LLVM_Hs_GetArgOperand(LLVMValueRef i, unsigned op) {+    return wrap(unwrap<FuncletPadInst>(i)->getArgOperand(op));+}++LLVMValueRef LLVM_Hs_CatchSwitch_GetParentPad(LLVMValueRef i) {+    return wrap(unwrap<CatchSwitchInst>(i)->getParentPad());+}++LLVMBasicBlockRef LLVM_Hs_CatchSwitch_GetUnwindDest(LLVMValueRef i) {+    return wrap(unwrap<CatchSwitchInst>(i)->getUnwindDest());+}++unsigned LLVM_Hs_CatchSwitch_GetNumHandlers(LLVMValueRef i) {+    return unwrap<CatchSwitchInst>(i)->getNumHandlers();+}++LLVMBasicBlockRef LLVM_Hs_CatchSwitch_GetHandler(LLVMValueRef instr, unsigned i) {+    return wrap(*(unwrap<CatchSwitchInst>(instr)->handler_begin() + i));+}++void LLVM_Hs_CatchSwitch_AddHandler(LLVMValueRef instr, LLVMBasicBlockRef bb) {+    unwrap<CatchSwitchInst>(instr)->addHandler(unwrap(bb));+}++LLVMValueRef LLVM_Hs_CatchRet_GetCatchPad(LLVMValueRef i) {+    return wrap(unwrap<CatchReturnInst>(i)->getCatchPad());+}++LLVMBasicBlockRef LLVM_Hs_CatchRet_GetSuccessor(LLVMValueRef i) {+    return wrap(unwrap<CatchReturnInst>(i)->getSuccessor());+}+}

@@ -0,0 +1,61 @@+-- This module translates the instruction data in "llvm/Instruction.def" into a Haskell data structure,+-- so it may be accessed conveniently with Template Haskell code+module LLVM.Internal.FFI.InstructionDefs where++import LLVM.Prelude++import LLVM.Internal.FFI.LLVMCTypes++#define FIRST_TERM_INST(num) struct inst { const char *kind; int opcode; const char *name; const char *clas; } insts[] = { { "Terminator", },++#define FIRST_BINARY_INST(num) { "Binary" },+#define FIRST_MEMORY_INST(num) { "Memory" },+#define FIRST_CAST_INST(num) { "Cast" },+#define FIRST_OTHER_INST(num) { "Other" },+#define FIRST_FUNCLETPAD_INST(num) { "FuncletPad" },++#define HANDLE_INST(num,opcode,class) { 0, num, #opcode, #class, },++#define LAST_OTHER_INST(num) { 0, 0, 0, 0, } };++#include "llvm/Config/llvm-config.h"++#include "llvm/IR/Instruction.def"++#{+define hsc_inject() {                                       \+  hsc_printf("[");                                       \+  struct inst *i;                                           \+  const char *kind;                                         \+  int first = 1;                                            \+  for(i = insts; i->kind || i->opcode; ++i) {               \+    if (i->kind) { kind = i->kind; continue; }              \+    if (!first) { hsc_printf("\n   ,"); } else { first = 0; }  \+    hsc_printf(                                             \+        " (CPPOpcode %d,\"%s\",\"%s\", %s)",               \+        i->opcode, i->name, i->clas, kind                   \+      );                                                    \+  }                                                         \+  hsc_printf(" ] ");                                       \+}+}++data InstructionKind = Terminator | Binary | Memory | Cast | FuncletPad | Other+  deriving (Eq, Ord, Show)++data InstructionDef = InstructionDef {+    cppOpcode :: CPPOpcode,+    cAPIName :: String,+    cAPIClassName :: String,+    instructionKind :: InstructionKind+  }+  deriving (Eq, Ord, Show)++instructionDefs :: [InstructionDef]+instructionDefs = [ + InstructionDef o an acn k+ | (o, an, acn, k) <-+   #{inject},+ an /= "UserOp1" && an /= "UserOp2"+ ]+

@@ -0,0 +1,13 @@+-- | Functions to help handle LLVM iteration patterns+module LLVM.Internal.FFI.Iterate where++import LLVM.Prelude++import Foreign.Ptr++-- | retrieve a sequence of objects which form a linked list, given an action to+-- | retrieve the first member and an action to proceed through the list+getXs :: IO (Ptr a) -> (Ptr a -> IO (Ptr a)) -> IO [Ptr a]+getXs firstX nextX = walk =<< firstX+    where walk x | x == nullPtr = return []+          walk x = (x:) <$> (walk <=< nextX) x

@@ -0,0 +1,266 @@+{-# LANGUAGE+  GeneralizedNewtypeDeriving+  #-}+-- | Define types which correspond cleanly with some simple types on the C/C++ side.+-- Encapsulate hsc macro weirdness here, supporting higher-level tricks elsewhere.+module LLVM.Internal.FFI.LLVMCTypes where++import LLVM.Prelude++#define __STDC_LIMIT_MACROS+#include "llvm-c/Core.h"+#include "llvm-c/Linker.h"+#include "llvm-c/OrcBindings.h"+#include "llvm-c/Target.h"+#include "llvm-c/TargetMachine.h"+#include "LLVM/Internal/FFI/Attribute.h"+#include "LLVM/Internal/FFI/Instruction.h"+#include "LLVM/Internal/FFI/Value.h"+#include "LLVM/Internal/FFI/SMDiagnostic.h"+#include "LLVM/Internal/FFI/InlineAssembly.h"+#include "LLVM/Internal/FFI/Target.h"+#include "LLVM/Internal/FFI/CallingConvention.h"+#include "LLVM/Internal/FFI/GlobalValue.h"+#include "LLVM/Internal/FFI/Type.h"+#include "LLVM/Internal/FFI/Constant.h"+#include "LLVM/Internal/FFI/Analysis.h"+#include "LLVM/Internal/FFI/LibFunc.h"+#include "LLVM/Internal/FFI/OrcJIT.h"++import Language.Haskell.TH.Quote++import Data.Bits+import Foreign.C+import Foreign.Storable++#{+define hsc_inject(l, typ, cons, hprefix, recmac) { \+  struct { const char *s; unsigned n; } *p, list[] = { LLVM_HS_FOR_EACH_ ## l(recmac) }; \+  for(p = list; p < list + sizeof(list)/sizeof(list[0]); ++p) { \+    hsc_printf(#hprefix "%s :: " #typ "\n", p->s); \+    hsc_printf(#hprefix "%s = " #cons " %u\n", p->s, p->n); \+  } \+  hsc_printf(#hprefix "P :: QuasiQuoter\n" \+             #hprefix "P = QuasiQuoter {\n" \+             "  quoteExp = undefined,\n" \+             "  quotePat = \\s -> dataToPatQ (const Nothing) $ case s of"); \+  for(p = list; p < list + sizeof(list)/sizeof(list[0]); ++p) { \+    hsc_printf("\n    \"%s\" -> " #hprefix "%s", p->s, p->s); \+  } \+  hsc_printf("\n    x -> error $ \"bad quasiquoted FFI constant for " #hprefix ": \" ++ x"); \+  hsc_printf(",\n" \+             "  quoteType = undefined,\n" \+             "  quoteDec = undefined\n" \+             " }\n"); \+}+}++deriving instance Data CUInt++newtype LLVMBool = LLVMBool CUInt++newtype OwnerTransfered a = OwnerTransfered a+  deriving (Storable)++newtype NothingAsMinusOne h = NothingAsMinusOne CInt+  deriving (Storable)++newtype NothingAsEmptyString c = NothingAsEmptyString c+  deriving (Storable)++newtype CPPOpcode = CPPOpcode CUInt+  deriving (Eq, Ord, Show, Typeable, Data)++newtype ICmpPredicate = ICmpPredicate CUInt+  deriving (Eq, Ord, Show, Typeable, Data)+#{enum ICmpPredicate, ICmpPredicate,+ iCmpPredEQ = LLVMIntEQ,+ iCmpPredNE = LLVMIntNE,+ iCmpPredUGT = LLVMIntUGT,+ iCmpPredUGE = LLVMIntUGE,+ iCmpPredULT = LLVMIntULT,+ iCmpPredULE = LLVMIntULE,+ iCmpPredSGT = LLVMIntSGT,+ iCmpPredSGE = LLVMIntSGE,+ iCmpPredSLT = LLVMIntSLT,+ iCmpPredSLE = LLVMIntSLE+}++newtype FCmpPredicate = FCmpPredicate CUInt+  deriving (Eq, Ord, Show, Typeable, Data)+#{enum FCmpPredicate, FCmpPredicate,+ fCmpPredFalse = LLVMRealPredicateFalse,+ fCmpPredOEQ = LLVMRealOEQ,+ fCmpPredOGT = LLVMRealOGT,+ fCmpPredOGE = LLVMRealOGE,+ fCmpPredOLT = LLVMRealOLT,+ fCmpPredOLE = LLVMRealOLE,+ fCmpPredONE = LLVMRealONE,+ fCmpPredORD = LLVMRealORD,+ fCmpPredUNO = LLVMRealUNO,+ fCmpPredUEQ = LLVMRealUEQ,+ fCmpPredUGT = LLVMRealUGT,+ fCmpPredUGE = LLVMRealUGE,+ fCmpPredULT = LLVMRealULT,+ fCmpPredULE = LLVMRealULE,+ fCmpPredUNE = LLVMRealUNE,+ fcmpPredTrue = LLVMRealPredicateTrue+}++newtype MDKindID = MDKindID CUInt+  deriving (Storable)++newtype FastMathFlags = FastMathFlags CUInt+  deriving (Eq, Ord, Show, Typeable, Data, Num, Bits)+#define FMF_Rec(n,l) { #n, LLVM ## n, },+#{inject FAST_MATH_FLAG, FastMathFlags, FastMathFlags, fastMathFlags, FMF_Rec}++newtype MemoryOrdering = MemoryOrdering CUInt+  deriving (Eq, Typeable, Data)+#define MO_Rec(n) { #n, LLVMAtomicOrdering ## n },+#{inject ATOMIC_ORDERING, MemoryOrdering, MemoryOrdering, memoryOrdering, MO_Rec}++newtype UnnamedAddr = UnnamedAddr CUInt+  deriving (Eq, Typeable, Data)+#define UA_Rec(n) { #n, LLVMUnnamedAddr ## n },+#{inject UNNAMED_ADDR, UnnamedAddr, UnnamedAddr, unnamedAddr, UA_Rec}++newtype SynchronizationScope = SynchronizationScope CUInt+  deriving (Eq, Typeable, Data)+#define SS_Rec(n) { #n, LLVM ## n ## SynchronizationScope },+#{inject SYNCRONIZATION_SCOPE, SynchronizationScope, SynchronizationScope, synchronizationScope, SS_Rec}++newtype TailCallKind = TailCallKind CUInt+  deriving (Eq, Typeable, Data)+#define TCK_Rec(n) { #n, LLVM_Hs_TailCallKind_ ## n },+#{inject TAIL_CALL_KIND, TailCallKind, TailCallKind, tailCallKind, TCK_Rec}++newtype Linkage = Linkage CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define LK_Rec(n) { #n, LLVM ## n ## Linkage },+#{inject LINKAGE, Linkage, Linkage, linkage, LK_Rec}++newtype Visibility = Visibility CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define VIS_Rec(n) { #n, LLVM ## n ## Visibility },+#{inject VISIBILITY, Visibility, Visibility, visibility, VIS_Rec}++newtype COMDATSelectionKind = COMDATSelectionKind CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define CSK(n) { #n, LLVM_Hs_COMDAT_Selection_Kind_ ## n },+#{inject COMDAT_SELECTION_KIND, COMDATSelectionKind, COMDATSelectionKind, comdatSelectionKind, CSK}++newtype DLLStorageClass = DLLStorageClass CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define DLLSC_Rec(n) { #n, LLVM ## n ## StorageClass },+#{inject DLL_STORAGE_CLASS, DLLStorageClass, DLLStorageClass, dllStorageClass, DLLSC_Rec}++newtype CallingConvention = CallingConvention CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define CC_Rec(l, n) { #l, LLVM_Hs_CallingConvention_ ## l },+#{inject CALLING_CONVENTION, CallingConvention, CallingConvention, callingConvention, CC_Rec}++newtype ThreadLocalMode = ThreadLocalMode CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define TLS_Rec(n) { #n, LLVM ## n },+#{inject THREAD_LOCAL_MODE, ThreadLocalMode, ThreadLocalMode, threadLocalMode, TLS_Rec}++newtype ValueSubclassId = ValueSubclassId CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define VSID_Rec(n) { #n, LLVM ## n ## SubclassId },+#{inject VALUE_SUBCLASS, ValueSubclassId, ValueSubclassId, valueSubclassId, VSID_Rec}++newtype DiagnosticKind = DiagnosticKind CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define DK_Rec(n) { #n, LLVMDiagnosticKind ## n },+#{inject DIAGNOSTIC_KIND, DiagnosticKind, DiagnosticKind, diagnosticKind, DK_Rec}++newtype AsmDialect = AsmDialect CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define ASM_Rec(n) { #n, LLVMAsmDialect_ ## n },+#{inject ASM_DIALECT, AsmDialect, AsmDialect, asmDialect, ASM_Rec}++newtype RMWOperation = RMWOperation CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define RMWOp_Rec(n) { #n, LLVMAtomicRMWBinOp ## n },+#{inject RMW_OPERATION, RMWOperation, RMWOperation, rmwOperation, RMWOp_Rec}++newtype RelocModel = RelocModel CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define RM_Rec(n,m) { #n, LLVMReloc ## n },+#{inject RELOC_MODEL, RelocModel, RelocModel, relocModel, RM_Rec}++newtype CodeModel = CodeModel CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define CM_Rec(n) { #n, LLVMCodeModel ## n },+#{inject CODE_MODEL, CodeModel, CodeModel, codeModel, CM_Rec}++newtype CodeGenOptLevel = CodeGenOptLevel CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define CGOL_Rec(n) { #n, LLVMCodeGenLevel ## n },+#{inject CODE_GEN_OPT_LEVEL, CodeGenOptLevel, CodeGenOptLevel, codeGenOptLevel, CGOL_Rec}++newtype CodeGenFileType = CodeGenFileType CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define CGFT_Rec(n) { #n, LLVM ## n ## File },+#{inject CODE_GEN_FILE_TYPE, CodeGenFileType, CodeGenFileType, codeGenFileType, CGFT_Rec}++newtype FloatABIType = FloatABIType CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define FAT_Rec(n) { #n, LLVM_Hs_FloatABI_ ## n },+#{inject FLOAT_ABI, FloatABIType, FloatABIType, floatABI, FAT_Rec}++newtype FPOpFusionMode = FPOpFusionMode CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define FPOFM_Rec(n) { #n, LLVM_Hs_FPOpFusionMode_ ## n },+#{inject FP_OP_FUSION_MODE, FPOpFusionMode, FPOpFusionMode, fpOpFusionMode, FPOFM_Rec}++newtype TargetOptionFlag = TargetOptionFlag CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define TOF_Rec(n) { #n, LLVM_Hs_TargetOptionFlag_ ## n },+#{inject TARGET_OPTION_FLAG, TargetOptionFlag, TargetOptionFlag, targetOptionFlag, TOF_Rec}++newtype TypeKind = TypeKind CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define TK_Rec(n) { #n, LLVM ## n ## TypeKind },+#{inject TYPE_KIND, TypeKind, TypeKind, typeKind, TK_Rec}++#define COMMA ,+#define IF_T(z) z+#define IF_F(z)+#define IF2(x) IF_ ## x+#define IF(x) IF2(x)+#define OR_TT T+#define OR_TF T+#define OR_FT T+#define OR_FF F+#define OR(x,y) OR_ ## x ## y+newtype ParameterAttributeKind = ParameterAttributeKind CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define PAK_Rec(n,p,r,f) IF(OR(p,r))({ #n COMMA LLVM_Hs_AttributeKind_ ## n} COMMA)+#{inject ATTRIBUTE_KIND, ParameterAttributeKind, ParameterAttributeKind, parameterAttributeKind, PAK_Rec}++newtype FunctionAttributeKind = FunctionAttributeKind CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define FAK_Rec(n,p,r,f) IF(f)({ #n COMMA LLVM_Hs_AttributeKind_ ## n} COMMA)+#{inject ATTRIBUTE_KIND, FunctionAttributeKind, FunctionAttributeKind, functionAttributeKind, FAK_Rec}++newtype FloatSemantics = FloatSemantics CUInt+  deriving (Eq, Read, Show, Typeable, Data)+#define FS_Rec(n) { #n, LLVMFloatSemantics ## n },+#{inject FLOAT_SEMANTICS, FloatSemantics, FloatSemantics, floatSemantics, FS_Rec}++newtype VerifierFailureAction = VerifierFailureAction CUInt+  deriving (Eq, Read, Show, Bits, Typeable, Data, Num)+#define VFA_Rec(n) { #n, LLVM ## n ## Action },+#{inject VERIFIER_FAILURE_ACTION, VerifierFailureAction, VerifierFailureAction, verifierFailureAction, VFA_Rec}++newtype LibFunc = LibFunc CUInt+  deriving (Eq, Read, Show, Bits, Typeable, Data, Num, Storable)+#define LF_Rec(n) { #n, LLVMLibFunc__ ## n },+#{inject LIB_FUNC, LibFunc, LibFunc, libFunc__, LF_Rec}++newtype JITSymbolFlags = JITSymbolFlags CUInt+  deriving (Eq, Read, Show, Bits, Typeable, Data, Num, Storable)+#define SF_Rec(n) { #n, LLVMJITSymbolFlag ## n },+#{inject JIT_SYMBOL_FLAG, JITSymbolFlags, JITSymbolFlags, jitSymbolFlags, SF_Rec}

@@ -0,0 +1,332 @@+#ifndef __LLVM_INTERNAL_FFI__LIB_FUNC__H__+#define __LLVM_INTERNAL_FFI__LIB_FUNC__H__++#define LLVM_HS_FOR_EACH_LIB_FUNC(macro)		\+	macro(under_IO_getc)													\+	macro(under_IO_putc)													\+	macro(ZdaPv)																	\+	macro(ZdaPvRKSt9nothrow_t)										\+	macro(ZdlPv)																	\+	macro(ZdlPvRKSt9nothrow_t)										\+	macro(Znaj)																		\+	macro(ZnajRKSt9nothrow_t)											\+	macro(Znam)																		\+	macro(ZnamRKSt9nothrow_t)											\+	macro(Znwj)																		\+	macro(ZnwjRKSt9nothrow_t)											\+	macro(Znwm)																		\+	macro(ZnwmRKSt9nothrow_t)											\+	macro(cospi)																	\+	macro(cospif)																	\+	macro(cxa_atexit)															\+	macro(cxa_guard_abort)												\+	macro(cxa_guard_acquire)											\+	macro(cxa_guard_release)											\+	macro(dunder_isoc99_scanf)										\+	macro(dunder_isoc99_sscanf)										\+	macro(memcpy_chk)															\+	macro(sincospi_stret)													\+	macro(sincospif_stret)												\+	macro(sinpi)																	\+	macro(sinpif)																	\+	macro(sqrt_finite)														\+	macro(sqrtf_finite)														\+	macro(sqrtl_finite)														\+	macro(dunder_strdup)													\+	macro(dunder_strndup)													\+	macro(dunder_strtok_r)												\+	macro(abs)																		\+	macro(access)																	\+	macro(acos)																		\+	macro(acosf)																	\+	macro(acosh)																	\+	macro(acoshf)																	\+	macro(acoshl)																	\+	macro(acosl)																	\+	macro(asin)																		\+	macro(asinf)																	\+	macro(asinh)																	\+	macro(asinhf)																	\+	macro(asinhl)																	\+	macro(asinl)																	\+	macro(atan)																		\+	macro(atan2)																	\+	macro(atan2f)																	\+	macro(atan2l)																	\+	macro(atanf)																	\+	macro(atanh)																	\+	macro(atanhf)																	\+	macro(atanhl)																	\+	macro(atanl)																	\+	macro(atof)																		\+	macro(atoi)																		\+	macro(atol)																		\+	macro(atoll)																	\+	macro(bcmp)																		\+	macro(bcopy)																	\+	macro(bzero)																	\+	macro(calloc)																	\+	macro(cbrt)																		\+	macro(cbrtf)																	\+	macro(cbrtl)																	\+	macro(ceil)																		\+	macro(ceilf)																	\+	macro(ceill)																	\+	macro(chmod)																	\+	macro(chown)																	\+	macro(clearerr)																\+	macro(closedir)																\+	macro(copysign)																\+	macro(copysignf)															\+	macro(copysignl)															\+	macro(cos)																		\+	macro(cosf)																		\+	macro(cosh)																		\+	macro(coshf)																	\+	macro(coshl)																	\+	macro(cosl)																		\+	macro(ctermid)																\+	macro(exp)																		\+	macro(exp10)																	\+	macro(exp10f)																	\+	macro(exp10l)																	\+	macro(exp2)																		\+	macro(exp2f)																	\+	macro(exp2l)																	\+	macro(expf)																		\+	macro(expl)																		\+	macro(expm1)																	\+	macro(expm1f)																	\+	macro(expm1l)																	\+	macro(fabs)																		\+	macro(fabsf)																	\+	macro(fabsl)																	\+	macro(fclose)																	\+	macro(fdopen)																	\+	macro(feof)																		\+	macro(ferror)																	\+	macro(fflush)																	\+	macro(ffs)																		\+	macro(ffsl)																		\+	macro(ffsll)																	\+	macro(fgetc)																	\+	macro(fgetpos)																\+	macro(fgets)																	\+	macro(fileno)																	\+	macro(fiprintf)																\+	macro(flockfile)															\+	macro(floor)																	\+	macro(floorf)																	\+	macro(floorl)																	\+	macro(fmax)																		\+	macro(fmaxf)																	\+	macro(fmaxl)																	\+	macro(fmin)																		\+	macro(fminf)																	\+	macro(fminl)																	\+	macro(fmod)																		\+	macro(fmodf)																	\+	macro(fmodl)																	\+	macro(fopen)																	\+	macro(fopen64)																\+	macro(fprintf)																\+	macro(fputc)																	\+	macro(fputs)																	\+	macro(fread)																	\+	macro(free)																		\+	macro(frexp)																	\+	macro(frexpf)																	\+	macro(frexpl)																	\+	macro(fscanf)																	\+	macro(fseek)																	\+	macro(fseeko)																	\+	macro(fseeko64)																\+	macro(fsetpos)																\+	macro(fstat)																	\+	macro(fstat64)																\+	macro(fstatvfs)																\+	macro(fstatvfs64)															\+	macro(ftell)																	\+	macro(ftello)																	\+	macro(ftello64)																\+	macro(ftrylockfile)														\+	macro(funlockfile)														\+	macro(fwrite)																	\+	macro(getc)																		\+	macro(getc_unlocked)													\+	macro(getchar)																\+	macro(getenv)																	\+	macro(getitimer)															\+	macro(getlogin_r)															\+	macro(getpwnam)																\+	macro(gets)																		\+	macro(gettimeofday)														\+	macro(htonl)																	\+	macro(htons)																	\+	macro(iprintf)																\+	macro(isascii)																\+	macro(isdigit)																\+	macro(labs)																		\+	macro(lchown)																	\+	macro(ldexp)																	\+	macro(ldexpf)																	\+	macro(ldexpl)																	\+	macro(llabs)																	\+	macro(log)																		\+	macro(log10)																	\+	macro(log10f)																	\+	macro(log10l)																	\+	macro(log1p)																	\+	macro(log1pf)																	\+	macro(log1pl)																	\+	macro(log2)																		\+	macro(log2f)																	\+	macro(log2l)																	\+	macro(logb)																		\+	macro(logbf)																	\+	macro(logbl)																	\+	macro(logf)																		\+	macro(logl)																		\+	macro(lstat)																	\+	macro(lstat64)																\+	macro(malloc)																	\+	macro(memalign)																\+	macro(memccpy)																\+	macro(memchr)																	\+	macro(memcmp)																	\+	macro(memcpy)																	\+	macro(memmove)																\+	macro(memrchr)																\+	macro(memset)																	\+	macro(memset_pattern16)												\+	macro(mkdir)																	\+	macro(mktime)																	\+	macro(modf)																		\+	macro(modff)																	\+	macro(modfl)																	\+	macro(nearbyint)															\+	macro(nearbyintf)															\+	macro(nearbyintl)															\+	macro(ntohl)																	\+	macro(ntohs)																	\+	macro(open)																		\+	macro(open64)																	\+	macro(opendir)																\+	macro(pclose)																	\+	macro(perror)																	\+	macro(popen)																	\+	macro(posix_memalign)													\+	macro(pow)																		\+	macro(powf)																		\+	macro(powl)																		\+	macro(pread)																	\+	macro(printf)																	\+	macro(putc)																		\+	macro(putchar)																\+	macro(puts)																		\+	macro(pwrite)																	\+	macro(qsort)																	\+	macro(read)																		\+	macro(readlink)																\+	macro(realloc)																\+	macro(reallocf)																\+	macro(realpath)																\+	macro(remove)																	\+	macro(rename)																	\+	macro(rewind)																	\+	macro(rint)																		\+	macro(rintf)																	\+	macro(rintl)																	\+	macro(rmdir)																	\+	macro(round)																	\+	macro(roundf)																	\+	macro(roundl)																	\+	macro(scanf)																	\+	macro(setbuf)																	\+	macro(setitimer)															\+	macro(setvbuf)																\+	macro(sin)																		\+	macro(sinf)																		\+	macro(sinh)																		\+	macro(sinhf)																	\+	macro(sinhl)																	\+	macro(sinl)																		\+	macro(siprintf)																\+	macro(snprintf)																\+	macro(sprintf)																\+	macro(sqrt)																		\+	macro(sqrtf)																	\+	macro(sqrtl)																	\+	macro(sscanf)																	\+	macro(stat)																		\+	macro(stat64)																	\+	macro(statvfs)																\+	macro(statvfs64)															\+	macro(stpcpy)																	\+	macro(stpncpy)																\+	macro(strcasecmp)															\+	macro(strcat)																	\+	macro(strchr)																	\+	macro(strcmp)																	\+	macro(strcoll)																\+	macro(strcpy)																	\+	macro(strcspn)																\+	macro(strdup)																	\+	macro(strlen)																	\+	macro(strncasecmp)														\+	macro(strncat)																\+	macro(strncmp)																\+	macro(strncpy)																\+	macro(strndup)																\+	macro(strnlen)																\+	macro(strpbrk)																\+	macro(strrchr)																\+	macro(strspn)																	\+	macro(strstr)																	\+	macro(strtod)																	\+	macro(strtof)																	\+	macro(strtok)																	\+	macro(strtok_r)																\+	macro(strtol)																	\+	macro(strtold)																\+	macro(strtoll)																\+	macro(strtoul)																\+	macro(strtoull)																\+	macro(strxfrm)																\+	macro(system)																	\+	macro(tan)																		\+	macro(tanf)																		\+	macro(tanh)																		\+	macro(tanhf)																	\+	macro(tanhl)																	\+	macro(tanl)																		\+	macro(times)																	\+	macro(tmpfile)																\+	macro(tmpfile64)															\+	macro(toascii)																\+	macro(trunc)																	\+	macro(truncf)																	\+	macro(truncl)																	\+	macro(uname)																	\+	macro(ungetc)																	\+	macro(unlink)																	\+	macro(unsetenv)																\+	macro(utime)																	\+	macro(utimes)																	\+	macro(valloc)																	\+	macro(vfprintf)																\+	macro(vfscanf)																\+	macro(vprintf)																\+	macro(vscanf)																	\+	macro(vsnprintf)															\+	macro(vsprintf)																\+	macro(vsscanf)																\+	macro(write)++typedef enum {+#define ENUM_CASE(x) LLVMLibFunc__ ## x,+LLVM_HS_FOR_EACH_LIB_FUNC(ENUM_CASE)+#undef ENUM_CASE+} LLVMLibFunc;++#endif

@@ -0,0 +1,28 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+module LLVM.Internal.FFI.MemoryBuffer where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.LLVMCTypes++data MemoryBuffer++foreign import ccall unsafe "LLVMCreateMemoryBufferWithContentsOfFile" createMemoryBufferWithContentsOfFile ::+  Ptr CChar -> Ptr (Ptr MemoryBuffer) -> Ptr (OwnerTransfered CString) -> IO LLVMBool++foreign import ccall unsafe "LLVMCreateMemoryBufferWithMemoryRange" createMemoryBufferWithMemoryRange ::+  Ptr CChar -> CSize -> CString -> LLVMBool -> IO (Ptr MemoryBuffer)++foreign import ccall unsafe "LLVMGetBufferStart" getBufferStart ::+  Ptr MemoryBuffer -> IO (Ptr CChar)++foreign import ccall unsafe "LLVMGetBufferSize" getBufferSize ::+  Ptr MemoryBuffer -> IO CSize++foreign import ccall unsafe "LLVMDisposeMemoryBuffer" disposeMemoryBuffer ::+  Ptr MemoryBuffer -> IO ()

@@ -0,0 +1,11 @@+#include "llvm/IR/Metadata.h"+#include "llvm-c/Core.h"++namespace llvm {+typedef struct LLVMOpaqueMetadata *LLVMMetadataRef;+DEFINE_ISA_CONVERSION_FUNCTIONS(Metadata, LLVMMetadataRef)++inline Metadata **unwrap(LLVMMetadataRef *Vals) {+  return reinterpret_cast<Metadata**>(Vals);+}+}

@@ -0,0 +1,93 @@+{-#+  LANGUAGE+  ForeignFunctionInterface+  #-}++module LLVM.Internal.FFI.Metadata where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.LLVMCTypes++foreign import ccall unsafe "LLVM_Hs_IsAMDString" isAMDString ::+  Ptr Metadata -> IO (Ptr MDString)++foreign import ccall unsafe "LLVM_Hs_IsAMDNode" isAMDNode ::+  Ptr Metadata -> IO (Ptr MDNode)++foreign import ccall unsafe "LLVM_Hs_IsAMDValue" isAMDValue ::+  Ptr Metadata -> IO (Ptr MDValue)++foreign import ccall unsafe "LLVM_Hs_IsAMetadataOperand" isAMetadataOperand ::+  Ptr Value -> IO (Ptr MetadataAsVal)++foreign import ccall unsafe "LLVM_Hs_GetMDValue" getMDValue ::+  Ptr MDValue -> IO (Ptr Value)++foreign import ccall unsafe "LLVM_Hs_GetMetadataOperand" getMetadataOperand ::+  Ptr MetadataAsVal -> IO (Ptr Metadata)++foreign import ccall unsafe "LLVMGetMDKindIDInContext" getMDKindIDInContext' ::+  Ptr Context -> Ptr CChar -> CUInt -> IO MDKindID++getMDKindIDInContext :: Ptr Context -> (Ptr CChar, CUInt) -> IO MDKindID+getMDKindIDInContext ctx (c, n) = getMDKindIDInContext' ctx c n++foreign import ccall unsafe "LLVM_Hs_GetMDKindNames" getMDKindNames ::+  Ptr Context -> Ptr (Ptr CChar) -> Ptr CUInt -> CUInt -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_MDStringInContext" mdStringInContext' ::+  Ptr Context -> CString -> CUInt -> IO (Ptr MDString)++foreign import ccall unsafe "LLVM_Hs_MDValue" mdValue ::+  Ptr Value -> IO (Ptr MDValue)++foreign import ccall unsafe "LLVM_Hs_MetadataOperand" metadataOperand ::+  Ptr Context -> Ptr Metadata -> IO (Ptr Value)++mdStringInContext :: Ptr Context -> (CString, CUInt) -> IO (Ptr MDString)+mdStringInContext ctx (p, n) = mdStringInContext' ctx p n++foreign import ccall unsafe "LLVM_Hs_GetMDString" getMDString ::+  Ptr MDString -> Ptr CUInt -> IO CString++foreign import ccall unsafe "LLVM_Hs_MDNodeInContext" createMDNodeInContext' ::+  Ptr Context -> Ptr (Ptr Metadata) -> CUInt -> IO (Ptr MDNode)++createMDNodeInContext :: Ptr Context -> (CUInt, Ptr (Ptr Metadata)) -> IO (Ptr MDNode)+createMDNodeInContext ctx (n, vs) = createMDNodeInContext' ctx vs n++foreign import ccall unsafe "LLVM_Hs_CreateTemporaryMDNodeInContext" createTemporaryMDNodeInContext ::+  Ptr Context -> IO (Ptr MDNode)++foreign import ccall unsafe "LLVM_Hs_DestroyTemporaryMDNode" destroyTemporaryMDNode ::+  Ptr MDNode -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetMDNodeNumOperands" getMDNodeNumOperands ::+  Ptr MDNode -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_GetMDNodeOperands" getMDNodeOperands ::+  Ptr MDNode -> Ptr (Ptr Metadata) -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetNamedMetadataName" getNamedMetadataName ::+  Ptr NamedMetadata -> Ptr CUInt -> IO (Ptr CChar)++foreign import ccall unsafe "LLVM_Hs_GetNamedMetadataNumOperands" getNamedMetadataNumOperands ::+  Ptr NamedMetadata -> IO CUInt++foreign import ccall unsafe "LLVM_Hs_GetNamedMetadataOperands" getNamedMetadataOperands ::+  Ptr NamedMetadata -> Ptr (Ptr MDNode) -> IO ()++foreign import ccall unsafe "LLVM_Hs_NamedMetadataAddOperands" namedMetadataAddOperands' ::+  Ptr NamedMetadata -> Ptr (Ptr MDNode) -> CUInt -> IO ()++foreign import ccall unsafe "LLVM_Hs_MetadataReplaceAllUsesWith" metadataReplaceAllUsesWith ::+  Ptr MDNode -> Ptr Metadata -> IO ()++namedMetadataAddOperands :: Ptr NamedMetadata -> (CUInt, Ptr (Ptr MDNode)) -> IO ()+namedMetadataAddOperands nm (n, vs) = namedMetadataAddOperands' nm vs n

@@ -0,0 +1,151 @@+#define __STDC_LIMIT_MACROS++#include <iostream>+#include "LLVM/Internal/FFI/Metadata.hpp"+#include "llvm/Support/FormattedStream.h"++#include "llvm/Config/llvm-config.h"+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/Metadata.h"+#include "llvm-c/Core.h"++using namespace llvm;++extern "C" {++LLVMMetadataRef LLVM_Hs_IsAMDString(LLVMMetadataRef md) {+    if (isa<MDString>(unwrap(md))) {+        return md;+    }+    return nullptr;+}++LLVMMetadataRef LLVM_Hs_MDStringInContext(LLVMContextRef c,+                                               const char *str, unsigned slen) {+    return wrap(MDString::get(*unwrap(c), StringRef(str, slen)));+}++const char *LLVM_Hs_GetMDString(LLVMMetadataRef md, unsigned* len) {+    if (const MDString *S = dyn_cast<MDString>(unwrap(md))) {+      *len = S->getString().size();+      return S->getString().data();+    }+    *len = 0;+    return nullptr;+}++LLVMMetadataRef LLVM_Hs_MDValue(LLVMValueRef v) {+    return wrap(ValueAsMetadata::get(unwrap(v)));+}++LLVMValueRef LLVM_Hs_MetadataOperand(LLVMContextRef c, LLVMMetadataRef md) {+    return wrap(MetadataAsValue::get(*unwrap(c), unwrap(md)));+}++LLVMMetadataRef LLVM_Hs_IsAMDNode(LLVMMetadataRef md) {+    if (isa<MDNode>(unwrap(md))) {+        return md;+    }+    return nullptr;+}++LLVMValueRef LLVM_Hs_GetMDValue(LLVMMetadataRef md) {+    return wrap(unwrap<ValueAsMetadata>(md)->getValue());+}++LLVMMetadataRef LLVM_Hs_GetMetadataOperand(LLVMValueRef val) {+    return wrap(unwrap<MetadataAsValue>(val)->getMetadata());+}++LLVMMetadataRef LLVM_Hs_MDNodeInContext(LLVMContextRef c,+                                             LLVMMetadataRef *mds,+                                             unsigned count) {+    return wrap(MDNode::get(*unwrap(c), ArrayRef<Metadata *>(unwrap(mds), count)));+}++LLVMMetadataRef LLVM_Hs_IsAMDValue(LLVMMetadataRef md) {+    if (isa<ValueAsMetadata>(unwrap(md))) {+        return md;+    }+    return nullptr;+}+++LLVMValueRef LLVM_Hs_IsAMetadataOperand(LLVMValueRef val) {+    if (isa<MetadataAsValue>(unwrap(val))) {+        return val;+    }+    return nullptr;+}+++unsigned LLVM_Hs_GetMDKindNames(+	LLVMContextRef c,+	const char **s,+	unsigned *l,+	unsigned n+) {+	SmallVector<StringRef, 8> ns;+	unwrap(c)->getMDKindNames(ns);+	if (ns.size() <= n) {+		for(unsigned i=0; i < ns.size(); ++i) {+			s[i] = ns[i].data();+			l[i] = ns[i].size();+		}+	}+	return ns.size();+}++unsigned LLVM_Hs_GetMDNodeNumOperands(LLVMMetadataRef v) {+	return unwrap<MDNode>(v)->getNumOperands();+}++void LLVM_Hs_NamedMetadataAddOperands(+	NamedMDNode *n,+	LLVMMetadataRef *ops,+	unsigned nOps+) {+	for(unsigned i = 0; i != nOps; ++i) n->addOperand(unwrap<MDNode>(ops[i]));+}++const char *LLVM_Hs_GetNamedMetadataName(+	NamedMDNode *n,+	unsigned *len+) {+	StringRef s = n->getName();+	*len = s.size();+	return s.data();+}++unsigned LLVM_Hs_GetNamedMetadataNumOperands(NamedMDNode *n) {+	return n->getNumOperands();+}++void LLVM_Hs_GetNamedMetadataOperands(NamedMDNode *n, LLVMMetadataRef *dest) {+	for(unsigned i = 0; i != n->getNumOperands(); ++i)+		dest[i] = wrap(n->getOperand(i));+}++LLVMMetadataRef LLVM_Hs_CreateTemporaryMDNodeInContext(LLVMContextRef c) {+	return wrap(MDNode::getTemporary(*unwrap(c), ArrayRef<Metadata *>()).release());+}++void LLVM_Hs_DestroyTemporaryMDNode(LLVMMetadataRef v) {+    MDNode::deleteTemporary(unwrap<MDNode>(v));+}++void LLVM_Hs_GetMDNodeOperands(LLVMMetadataRef md, LLVMMetadataRef *dest) {+    const auto *N = cast<MDNode>(unwrap(md));+    const unsigned numOperands = N->getNumOperands();+    for (unsigned i = 0; i < numOperands; i++)+        dest[i] = wrap(N->getOperand(i));+}++void LLVM_Hs_MetadataReplaceAllUsesWith(LLVMMetadataRef md, LLVMMetadataRef replacement) {+    auto *Node = unwrap<MDNode>(md);+    Node->replaceAllUsesWith(unwrap<Metadata>(replacement));+    MDNode::deleteTemporary(Node);+}++}+

@@ -0,0 +1,103 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+module LLVM.Internal.FFI.Module where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.Context+import LLVM.Internal.FFI.GlobalValue (COMDAT)+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.Type++data Module++foreign import ccall unsafe "LLVMModuleCreateWithNameInContext" moduleCreateWithNameInContext ::+  CString -> Ptr Context -> IO (Ptr Module)++foreign import ccall unsafe "LLVMGetModuleContext" getModuleContext ::+  Ptr Module -> IO (Ptr Context)++foreign import ccall unsafe "LLVMDisposeModule" disposeModule ::+  Ptr Module -> IO ()++foreign import ccall unsafe "LLVMGetDataLayout" getDataLayout ::+  Ptr Module -> IO CString++foreign import ccall unsafe "LLVMSetDataLayout" setDataLayout ::+  Ptr Module -> CString -> IO ()++foreign import ccall unsafe "LLVMGetTarget" getTargetTriple ::+  Ptr Module -> IO CString++foreign import ccall unsafe "LLVMSetTarget" setTargetTriple ::+  Ptr Module -> CString -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetModuleIdentifier" getModuleIdentifier ::+  Ptr Module -> IO (OwnerTransfered CString)++foreign import ccall unsafe "LLVM_Hs_GetSourceFileName" getSourceFileName ::+  Ptr Module -> IO (OwnerTransfered CString)++foreign import ccall unsafe "LLVM_Hs_SetSourceFileName" setSourceFileName ::+  Ptr Module -> Ptr CChar -> IO ()++foreign import ccall unsafe "LLVMGetFirstGlobal" getFirstGlobal ::+  Ptr Module -> IO (Ptr GlobalVariable)++foreign import ccall unsafe "LLVMGetNextGlobal" getNextGlobal ::+  Ptr GlobalVariable -> IO (Ptr GlobalVariable)++foreign import ccall unsafe "LLVM_Hs_GetFirstAlias" getFirstAlias ::+  Ptr Module -> IO (Ptr GlobalAlias)++foreign import ccall unsafe "LLVM_Hs_GetNextAlias" getNextAlias ::+  Ptr GlobalAlias -> IO (Ptr GlobalAlias)++foreign import ccall unsafe "LLVM_Hs_GetOrInsertCOMDAT" getOrInsertCOMDAT ::+  Ptr Module -> CString -> IO (Ptr COMDAT)++foreign import ccall unsafe "LLVMGetFirstFunction" getFirstFunction ::+  Ptr Module -> IO (Ptr Function)++foreign import ccall unsafe "LLVMGetNextFunction" getNextFunction ::+  Ptr Function -> IO (Ptr Function)++foreign import ccall unsafe "LLVM_Hs_GetFirstNamedMetadata" getFirstNamedMetadata ::+  Ptr Module -> IO (Ptr NamedMetadata)++foreign import ccall unsafe "LLVM_Hs_GetNextNamedMetadata" getNextNamedMetadata ::+  Ptr NamedMetadata -> IO (Ptr NamedMetadata)++foreign import ccall unsafe "LLVMAddGlobalInAddressSpace" addGlobalInAddressSpace ::+  Ptr Module -> Ptr Type -> CString -> CUInt -> IO (Ptr GlobalVariable)++foreign import ccall unsafe "LLVM_Hs_JustAddAlias" justAddAlias ::+  Ptr Module -> Ptr Type -> AddrSpace -> CString -> IO (Ptr GlobalAlias)++foreign import ccall unsafe "LLVMAddFunction" addFunction ::+  Ptr Module -> CString -> Ptr Type -> IO (Ptr Function)++foreign import ccall unsafe "LLVMGetNamedFunction" getNamedFunction ::+  Ptr Module -> CString -> IO (Ptr Function)++foreign import ccall unsafe "LLVM_Hs_GetOrAddNamedMetadata" getOrAddNamedMetadata ::+  Ptr Module -> CString -> IO (Ptr NamedMetadata)++foreign import ccall unsafe "LLVM_Hs_ModuleAppendInlineAsm" moduleAppendInlineAsm' ::+  Ptr Module -> Ptr CChar -> CUInt -> IO ()++newtype ModuleAsm a = ModuleAsm a++moduleAppendInlineAsm :: Ptr Module -> ModuleAsm (Ptr CChar, CUInt) -> IO ()+moduleAppendInlineAsm m (ModuleAsm (c, n)) = moduleAppendInlineAsm' m c n++foreign import ccall unsafe "LLVM_Hs_ModuleGetInlineAsm" moduleGetInlineAsm ::+  Ptr Module -> IO (ModuleAsm CString)++foreign import ccall unsafe "LLVMLinkModules2" linkModules ::+  Ptr Module -> Ptr Module -> IO LLVMBool

@@ -0,0 +1,70 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/Module.h"+#include "llvm-c/Core.h"++using namespace llvm;++extern "C" {++char *LLVM_Hs_GetModuleIdentifier(LLVMModuleRef val) {+	return strdup(unwrap(val)->getModuleIdentifier().c_str());+}++char *LLVM_Hs_GetSourceFileName(LLVMModuleRef val) {+	return strdup(unwrap(val)->getSourceFileName().c_str());+}++void LLVM_Hs_SetSourceFileName(LLVMModuleRef val, const char* sourceFileName) {+	return unwrap(val)->setSourceFileName(sourceFileName);+}++LLVMValueRef LLVM_Hs_GetFirstAlias(LLVMModuleRef m) {+	Module *mod = unwrap(m);+	Module::alias_iterator i = mod->alias_begin();+    if (i == mod->alias_end()) {+        return 0;+    }+    return wrap(&*i);+}++LLVMValueRef LLVM_Hs_GetNextAlias(LLVMValueRef a) {+	GlobalAlias *alias = unwrap<GlobalAlias>(a);+	Module::alias_iterator i(alias);+	if (++i == alias->getParent()->alias_end()) return 0;+	return wrap(&*i);+}++Comdat *LLVM_Hs_GetOrInsertCOMDAT(LLVMModuleRef m, const char *name) {+  return unwrap(m)->getOrInsertComdat(name);+}++// TODO (cocreature): Figure out if we can just change the linkage here+LLVMValueRef LLVM_Hs_JustAddAlias(LLVMModuleRef m, LLVMTypeRef ty, unsigned addrspace, const char *name) {+	return wrap(GlobalAlias::create(unwrap(ty), addrspace, GlobalValue::ExternalLinkage, name, 0, unwrap(m)));+}++NamedMDNode *LLVM_Hs_GetOrAddNamedMetadata(LLVMModuleRef m, const char *name) {+	return unwrap(m)->getOrInsertNamedMetadata(name);+}++NamedMDNode *LLVM_Hs_GetFirstNamedMetadata(LLVMModuleRef m) {+	Module *mod = unwrap(m);+	Module::named_metadata_iterator i = mod->named_metadata_begin();+	return i == mod->named_metadata_end() ? 0 : &*i;+}++NamedMDNode *LLVM_Hs_GetNextNamedMetadata(NamedMDNode *a) {+	Module::named_metadata_iterator i(a);+	if (++i == a->getParent()->named_metadata_end()) return 0;+	return &*i;+}++void LLVM_Hs_ModuleAppendInlineAsm(LLVMModuleRef m, const char *s, unsigned l) {+	unwrap(m)->appendModuleInlineAsm(StringRef(s,l));+}++const char *LLVM_Hs_ModuleGetInlineAsm(LLVMModuleRef m) {+	return unwrap(m)->getModuleInlineAsm().c_str();+}++}

@@ -0,0 +1,15 @@+#ifndef __LLVM_INTERNAL_FFI__ORC_JIT__H__+#define __LLVM_INTERNAL_FFI__ORC_JIT__H__++#define LLVM_HS_FOR_EACH_JIT_SYMBOL_FLAG(macro) \+	macro(None)                                      \+	macro(Weak)                                      \+	macro(Exported)                                  \++typedef enum {+#define ENUM_CASE(x) LLVMJITSymbolFlag ## x,+LLVM_HS_FOR_EACH_JIT_SYMBOL_FLAG(ENUM_CASE)+#undef ENUM_CASE+} LLVMJITSymbolFlags;++#endif

@@ -0,0 +1,51 @@+{-# LANGUAGE ForeignFunctionInterface #-}++module LLVM.Internal.FFI.OrcJIT where++import LLVM.Prelude++import Foreign.C+import Foreign.Ptr++import LLVM.Internal.FFI.DataLayout+import LLVM.Internal.FFI.LLVMCTypes++data JITSymbol+data LambdaResolver+data ObjectLinkingLayer++newtype TargetAddress = TargetAddress Word64++type SymbolResolverFn = CString -> Ptr JITSymbol -> IO ()++foreign import ccall "wrapper" wrapSymbolResolverFn ::+  SymbolResolverFn -> IO (FunPtr SymbolResolverFn)++foreign import ccall safe "LLVM_Hs_disposeJITSymbol" disposeSymbol ::+  Ptr JITSymbol -> IO ()++foreign import ccall safe "LLVM_Hs_createLambdaResolver" createLambdaResolver ::+  FunPtr SymbolResolverFn ->+  FunPtr SymbolResolverFn ->+  IO (Ptr LambdaResolver)++foreign import ccall safe "LLVM_Hs_createObjectLinkingLayer" createObjectLinkingLayer ::+  IO (Ptr ObjectLinkingLayer)++foreign import ccall safe "LLVM_Hs_disposeObjectLinkingLayer" disposeObjectLinkingLayer ::+  Ptr ObjectLinkingLayer -> IO ()++foreign import ccall safe "LLVM_Hs_JITSymbol_getAddress" getAddress ::+  Ptr JITSymbol -> IO TargetAddress++foreign import ccall safe "LLVM_Hs_JITSymbol_getFlags" getFlags ::+  Ptr JITSymbol -> IO JITSymbolFlags++foreign import ccall safe "LLVM_Hs_setJITSymbol" setJITSymbol ::+  Ptr JITSymbol -> TargetAddress -> JITSymbolFlags -> IO ()++foreign import ccall safe "LLVM_Hs_getMangledSymbol" getMangledSymbol ::+  Ptr CString -> CString -> Ptr DataLayout -> IO ()++foreign import ccall safe "LLVM_Hs_disposeMangledSymbol" disposeMangledSymbol ::+  CString -> IO ()

@@ -0,0 +1,74 @@+{-# LANGUAGE ForeignFunctionInterface #-}+module LLVM.Internal.FFI.OrcJIT.CompileOnDemandLayer where++import LLVM.Prelude++import Foreign.C+import Foreign.Ptr++import LLVM.Internal.FFI.DataLayout+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.Module+import LLVM.Internal.FFI.OrcJIT+import LLVM.Internal.FFI.OrcJIT.IRCompileLayer (IRCompileLayer)+import LLVM.Internal.FFI.PtrHierarchy++data IndirectStubsManagerBuilder+data JITCompileCallbackManager+data CompileOnDemandLayer+data Set a+data ModuleSetHandle++type PartitioningFn = Ptr Function -> Ptr (Set (Ptr Function)) -> IO ()++foreign import ccall "wrapper" wrapPartitioningFn ::+  PartitioningFn -> IO (FunPtr PartitioningFn)++foreign import ccall "wrapper" wrapErrorHandler ::+  IO () -> IO (FunPtr (IO ()))++foreign import ccall safe "LLVM_Hs_createLocalCompileCallbackManager" createLocalCompileCallbackManager ::+  CString -> TargetAddress -> IO (Ptr JITCompileCallbackManager)++foreign import ccall safe "LLVM_Hs_disposeCallbackManager" disposeCallbackManager ::+  Ptr JITCompileCallbackManager -> IO ()++foreign import ccall safe "LLVM_Hs_createLocalIndirectStubsManagerBuilder" createLocalIndirectStubsManagerBuilder ::+  CString -> IO (Ptr IndirectStubsManagerBuilder)++foreign import ccall safe "LLVM_Hs_disposeIndirectStubsManagerBuilder" disposeIndirectStubsManagerBuilder ::+  Ptr IndirectStubsManagerBuilder -> IO ()++foreign import ccall safe "LLVM_Hs_insertFun" insertFun ::+  Ptr (Set (Ptr Function)) -> Ptr Function -> IO ()++foreign import ccall safe "LLVM_Hs_createCompileOnDemandLayer" createCompileOnDemandLayer ::+  Ptr IRCompileLayer ->+  FunPtr PartitioningFn ->+  Ptr JITCompileCallbackManager ->+  Ptr IndirectStubsManagerBuilder ->+  LLVMBool ->+  IO (Ptr CompileOnDemandLayer)++foreign import ccall safe "LLVM_Hs_disposeCompileOnDemandLayer" disposeCompileOnDemandLayer ::+  Ptr CompileOnDemandLayer ->+  IO ()++foreign import ccall safe "LLVM_Hs_CompileOnDemandLayer_addModuleSet" addModuleSet ::+  Ptr CompileOnDemandLayer ->+  Ptr DataLayout ->+  Ptr (Ptr Module) ->+  CUInt ->+  Ptr LambdaResolver ->+  IO (Ptr ModuleSetHandle)++foreign import ccall safe "LLVM_Hs_CompileOnDemandLayer_removeModuleSet" removeModuleSet ::+  Ptr CompileOnDemandLayer ->+  Ptr ModuleSetHandle ->+  IO ()++foreign import ccall safe "LLVM_Hs_CompileOnDemandLayer_findSymbol" findSymbol ::+  Ptr CompileOnDemandLayer ->+  CString ->+  LLVMBool ->+  IO (Ptr JITSymbol)

@@ -0,0 +1,36 @@+{-# LANGUAGE ForeignFunctionInterface #-}+module LLVM.Internal.FFI.OrcJIT.IRCompileLayer where++import LLVM.Prelude++import LLVM.Internal.FFI.DataLayout+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.Module+import LLVM.Internal.FFI.OrcJIT+import LLVM.Internal.FFI.Target++import Foreign.Ptr+import Foreign.C++data IRCompileLayer+data ModuleSetHandle++foreign import ccall safe "LLVM_Hs_createIRCompileLayer" createIRCompileLayer ::+  Ptr ObjectLinkingLayer -> Ptr TargetMachine -> IO (Ptr IRCompileLayer)++foreign import ccall safe "LLVM_Hs_disposeIRCompileLayer" disposeIRCompileLayer ::+  Ptr IRCompileLayer -> IO ()++foreign import ccall safe "LLVM_Hs_IRCompileLayer_addModuleSet" addModuleSet ::+  Ptr IRCompileLayer ->+  Ptr DataLayout ->+  Ptr (Ptr Module) ->+  CUInt ->+  Ptr LambdaResolver ->+  IO (Ptr ModuleSetHandle)++foreign import ccall safe "LLVM_Hs_IRCompileLayer_removeModuleSet" removeModuleSet ::+  Ptr IRCompileLayer -> Ptr ModuleSetHandle -> IO ()++foreign import ccall safe "LLVM_Hs_IRCompileLayer_findSymbol" findSymbol ::+  Ptr IRCompileLayer -> CString -> LLVMBool -> IO (Ptr JITSymbol)

@@ -0,0 +1,256 @@+#include "LLVM/Internal/FFI/OrcJIT.h"+#include "LLVM/Internal/FFI/Target.hpp"+#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"+#include "llvm/ExecutionEngine/Orc/CompileUtils.h"+#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"+#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"+#include "llvm/ExecutionEngine/JITSymbol.h"+#include "llvm/ExecutionEngine/Orc/LambdaResolver.h"+#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"+#include "llvm/IR/Mangler.h"++#include <type_traits>++using namespace llvm;+using namespace orc;++typedef llvm::orc::ObjectLinkingLayer<> *LLVMObjectLinkingLayerRef;+typedef llvm::orc::IRCompileLayer<llvm::orc::ObjectLinkingLayer<>>+    LLVMIRCompileLayer;+typedef LLVMIRCompileLayer *LLVMIRCompileLayerRef;+typedef llvm::orc::CompileOnDemandLayer<LLVMIRCompileLayer>+    LLVMCompileOnDemandLayer;+typedef LLVMCompileOnDemandLayer *LLVMCompileOnDemandLayerRef;+typedef llvm::orc::JITCompileCallbackManager *LLVMJITCompileCallbackManagerRef;+typedef llvm::JITSymbol *LLVMJITSymbolRef;+typedef LLVMIRCompileLayer::ModuleSetHandleT *LLVMModuleSetHandleRef;+typedef LLVMCompileOnDemandLayer::ModuleSetHandleT *LLVMCODModuleSetHandleRef;+typedef llvm::orc::LambdaResolver<+    std::function<JITSymbol(const std::string &name)>,+    std::function<JITSymbol(const std::string &name)>>+    LLVMLambdaResolver;+typedef LLVMLambdaResolver *LLVMLambdaResolverRef;+typedef llvm::orc::IndirectStubsManager *LLVMIndirectStubsManagerRef;+typedef std::function<std::unique_ptr<llvm::orc::IndirectStubsManager>()>+    *LLVMIndirectStubsManagerBuilderRef;++static std::string mangle(StringRef name, LLVMTargetDataRef dataLayout) {+    std::string mangledName;+    {+        raw_string_ostream mangledNameStream(mangledName);+        Mangler::getNameWithPrefix(mangledNameStream, name,+                                   *unwrap(dataLayout));+    }+    return mangledName;+}++static std::vector<Module *> getModules(LLVMModuleRef *modules,+                                        unsigned moduleCount,+                                        LLVMTargetDataRef dataLayout) {+    std::vector<Module *> moduleVec(moduleCount);+    for (unsigned i = 0; i < moduleCount; ++i) {+        moduleVec.at(i) = unwrap(modules[i]);+        if (moduleVec.at(i)->getDataLayout().isDefault()) {+            moduleVec.at(i)->setDataLayout(*unwrap(dataLayout));+        }+    }+    return moduleVec;+}++extern "C" {+LLVMIRCompileLayerRef+LLVM_Hs_createIRCompileLayer(LLVMObjectLinkingLayerRef objectLayer,+                                  LLVMTargetMachineRef tm) {+    TargetMachine *tmm = unwrap(tm);+    return new IRCompileLayer<ObjectLinkingLayer<>>(*objectLayer,+                                                    SimpleCompiler(*tmm));+}++void LLVM_Hs_disposeIRCompileLayer(LLVMIRCompileLayerRef compileLayer) {+    delete compileLayer;+}++LLVMJITSymbolRef+LLVM_Hs_IRCompileLayer_findSymbol(LLVMIRCompileLayerRef compileLayer,+                                       const char *name,+                                       LLVMBool exportedSymbolsOnly) {+    JITSymbol symbol = compileLayer->findSymbol(name, exportedSymbolsOnly);+    return new JITSymbol(symbol);+}++void LLVM_Hs_disposeJITSymbol(LLVMJITSymbolRef symbol) { delete symbol; }++LLVMLambdaResolverRef LLVM_Hs_createLambdaResolver(+    void (*dylibResolver)(const char *, LLVMJITSymbolRef),+    void (*externalResolver)(const char *, LLVMJITSymbolRef)) {+    std::function<JITSymbol(const std::string &name)>+        dylibResolverFun = [dylibResolver](+            const std::string &name) -> JITSymbol {+        JITSymbol symbol(nullptr);+        dylibResolver(name.c_str(), &symbol);+        return symbol;+    };+    std::function<JITSymbol(const std::string &name)>+        externalResolverFun = [externalResolver](+            const std::string &name) -> JITSymbol {+        JITSymbol symbol(nullptr);+        externalResolver(name.c_str(), &symbol);+        return symbol;+    };+    auto lambdaResolver =+        createLambdaResolver(dylibResolverFun, externalResolverFun);+    return lambdaResolver.release();+}++LLVMModuleSetHandleRef LLVM_Hs_IRCompileLayer_addModuleSet(+    LLVMIRCompileLayerRef compileLayer, LLVMTargetDataRef dataLayout,+    LLVMModuleRef *modules, unsigned moduleCount,+    LLVMLambdaResolverRef resolver) {+    std::vector<Module *> moduleVec =+        getModules(modules, moduleCount, dataLayout);+    return new IRCompileLayer<ObjectLinkingLayer<>>::ModuleSetHandleT(+        compileLayer->addModuleSet(+            moduleVec, make_unique<SectionMemoryManager>(), resolver));+}++void LLVM_Hs_IRCompileLayer_removeModuleSet(+    LLVMIRCompileLayerRef compileLayer,+    LLVMModuleSetHandleRef moduleSetHandle) {+    compileLayer->removeModuleSet(*moduleSetHandle);+    delete moduleSetHandle;+}++LLVMObjectLinkingLayerRef LLVM_Hs_createObjectLinkingLayer() {+    return new ObjectLinkingLayer<>();+}++void LLVM_Hs_disposeObjectLinkingLayer(+    LLVMObjectLinkingLayerRef objectLayer) {+    delete objectLayer;+}++static JITSymbolFlags unwrap(LLVMJITSymbolFlags f) {+    JITSymbolFlags flags = JITSymbolFlags::None;+#define ENUM_CASE(x)                                                           \+    if (f & LLVMJITSymbolFlag##x)                                              \+        flags |= JITSymbolFlags::x;+    LLVM_HS_FOR_EACH_JIT_SYMBOL_FLAG(ENUM_CASE)+#undef ENUM_CASE+    return flags;+}++static LLVMJITSymbolFlags wrap(JITSymbolFlags f) {+    unsigned r = 0;+#define ENUM_CASE(x)                                                           \+    if ((char)(f & JITSymbolFlags::x))                                         \+        r |= (unsigned)LLVMJITSymbolFlag##x;+    LLVM_HS_FOR_EACH_JIT_SYMBOL_FLAG(ENUM_CASE)+#undef ENUM_CASE+    return LLVMJITSymbolFlags(r);+}++JITTargetAddress+LLVM_Hs_JITSymbol_getAddress(LLVMJITSymbolRef symbol) {+    return symbol->getAddress();+}++LLVMJITSymbolFlags LLVM_Hs_JITSymbol_getFlags(LLVMJITSymbolRef symbol) {+    return wrap(symbol->getFlags());+}++void LLVM_Hs_setJITSymbol(LLVMJITSymbolRef symbol,+                               JITTargetAddress addr,+                               LLVMJITSymbolFlags flags) {+    *symbol = JITSymbol(addr, unwrap(flags));+}++void LLVM_Hs_getMangledSymbol(char **mangledSymbol, const char *symbol,+                                   LLVMTargetDataRef dataLayout) {+    std::string mangled = mangle(symbol, dataLayout);+    *mangledSymbol = new char[mangled.size() + 1];+    strcpy(*mangledSymbol, mangled.c_str());+}++void LLVM_Hs_disposeMangledSymbol(char *mangledSymbol) {+    delete[] mangledSymbol;+}++LLVMJITCompileCallbackManagerRef LLVM_Hs_createLocalCompileCallbackManager(+    const char *triple, JITTargetAddress errorHandler) {+    return llvm::orc::createLocalCompileCallbackManager(Triple(triple),+                                                        errorHandler)+        .release();+}++void LLVM_Hs_disposeCallbackManager(+    LLVMJITCompileCallbackManagerRef callbackManager) {+    delete callbackManager;+}++LLVMIndirectStubsManagerBuilderRef+LLVM_Hs_createLocalIndirectStubsManagerBuilder(const char *triple) {+    return new std::function<std::unique_ptr<IndirectStubsManager>()>(+        llvm::orc::createLocalIndirectStubsManagerBuilder(Triple(triple)));+}++void LLVM_Hs_disposeIndirectStubsManagerBuilder(+    LLVMIndirectStubsManagerBuilderRef stubsManager) {+    delete stubsManager;+}++void LLVM_Hs_insertFun(std::set<llvm::Function *> *set,+                            llvm::Function *f) {+    set->insert(f);+}++LLVMCompileOnDemandLayerRef LLVM_Hs_createCompileOnDemandLayer(+    LLVMIRCompileLayerRef compileLayer,+    void (*partitioningFtor)(llvm::Function *, std::set<llvm::Function *> *set),+    LLVMJITCompileCallbackManagerRef callbackManager,+    LLVMIndirectStubsManagerBuilderRef stubsManager,+    LLVMBool cloneStubsIntoPartitions) {+    return new LLVMCompileOnDemandLayer(+        *compileLayer,+        [partitioningFtor](llvm::Function &f) -> std::set<llvm::Function *> {+            std::set<llvm::Function *> result;+            partitioningFtor(&f, &result);+            return result;+        },+        *callbackManager, *stubsManager, cloneStubsIntoPartitions);+}++void LLVM_Hs_disposeCompileOnDemandLayer(+    LLVMCompileOnDemandLayerRef codLayer) {+    delete codLayer;+}++LLVMCODModuleSetHandleRef LLVM_Hs_CompileOnDemandLayer_addModuleSet(+    LLVMCompileOnDemandLayerRef compileLayer, LLVMTargetDataRef dataLayout,+    LLVMModuleRef *modules, unsigned moduleCount,+    LLVMLambdaResolverRef resolver) {+    std::vector<Module *> moduleVec =+        getModules(modules, moduleCount, dataLayout);+    // We need to copy the resolver to make the use of unique_ptr (required by+    // the LLVM API) safe+    std::unique_ptr<LLVMLambdaResolver> uniqueResolver(+        new LLVMLambdaResolver(*resolver));+    return new LLVMCompileOnDemandLayer::ModuleSetHandleT(+        compileLayer->addModuleSet(moduleVec,+                                   make_unique<SectionMemoryManager>(),+                                   std::move(uniqueResolver)));+}++void LLVM_Hs_CompileOnDemandLayer_removeModuleSet(+    LLVMCompileOnDemandLayerRef compileLayer,+    LLVMCODModuleSetHandleRef moduleSetHandle) {+    compileLayer->removeModuleSet(*moduleSetHandle);+    delete moduleSetHandle;+}++LLVMJITSymbolRef LLVM_Hs_CompileOnDemandLayer_findSymbol(+    LLVMCompileOnDemandLayerRef compileLayer, const char *name,+    LLVMBool exportedSymbolsOnly) {+    JITSymbol symbol = compileLayer->findSymbol(name, exportedSymbolsOnly);+    return new JITSymbol(symbol);+}+}

@@ -0,0 +1,134 @@+{-# LANGUAGE+  TemplateHaskell,+  ForeignFunctionInterface,+  CPP+  #-}++module LLVM.Internal.FFI.PassManager where++import LLVM.Prelude++import qualified Language.Haskell.TH as TH++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.PtrHierarchy+import LLVM.Internal.FFI.Cleanup+import LLVM.Internal.FFI.Module+import LLVM.Internal.FFI.Target+import LLVM.Internal.FFI.Transforms++import qualified LLVM.Transforms as G++data PassManager++foreign import ccall unsafe "LLVMCreatePassManager" createPassManager ::+  IO (Ptr PassManager)++foreign import ccall unsafe "LLVMDisposePassManager" disposePassManager ::+  Ptr PassManager -> IO ()++foreign import ccall unsafe "LLVMRunPassManager" runPassManager ::+  Ptr PassManager -> Ptr Module -> IO CUInt++foreign import ccall unsafe "LLVMCreateFunctionPassManagerForModule" createFunctionPassManagerForModule ::+  Ptr Module -> IO (Ptr PassManager)++foreign import ccall unsafe "LLVMInitializeFunctionPassManager" initializeFunctionPassManager ::+  Ptr PassManager -> IO CUInt++foreign import ccall unsafe "LLVMRunFunctionPassManager" runFunctionPassManager ::+  Ptr PassManager -> Ptr Value -> IO CUInt++foreign import ccall unsafe "LLVMFinalizeFunctionPassManager" finalizeFunctionPassManager ::+  Ptr PassManager -> IO CUInt++foreign import ccall unsafe "LLVMAddAnalysisPasses" addAnalysisPasses ::+  Ptr TargetMachine -> Ptr PassManager -> IO ()++foreign import ccall unsafe "LLVMAddTargetLibraryInfo" addTargetLibraryInfoPass' ::+  Ptr TargetLibraryInfo -> Ptr PassManager -> IO ()++addTargetLibraryInfoPass :: Ptr PassManager -> Ptr TargetLibraryInfo -> IO ()+addTargetLibraryInfoPass = flip addTargetLibraryInfoPass'++$(do+  let declareForeign :: TH.Name -> [TH.Type] -> TH.DecsQ+      declareForeign hName extraParams = do+        let n = TH.nameBase hName+            passTypeMapping :: TH.Type -> TH.TypeQ+            passTypeMapping t = case t of+              TH.ConT h | h == ''Word -> [t| CUInt |]+                        | h == ''G.GCOVVersion -> [t| CString |]+              -- some of the LLVM methods for making passes use "-1" as a special value+              -- handle those here+              TH.AppT (TH.ConT mby) t' | mby == ''Maybe ->+                case t' of+                  TH.ConT h | h == ''Bool -> [t| NothingAsMinusOne Bool |]+                            | h == ''Word -> [t| NothingAsMinusOne Word |]+                            | h == ''FilePath -> [t| NothingAsEmptyString CString |]+                  _ -> typeMapping t+              _ -> typeMapping t+        foreignDecl+          (cName n)+          ("add" ++ n ++ "Pass")+          ([[t| Ptr PassManager |]]+           ++ [[t| Ptr TargetMachine |] | needsTargetMachine n]+           ++ map passTypeMapping extraParams)+          (TH.tupleT 0)+#if __GLASGOW_HASKELL__ < 800+  TH.TyConI (TH.DataD _ _ _ cons _) <- TH.reify ''G.Pass+#else+  TH.TyConI (TH.DataD _ _ _ _ cons _) <- TH.reify ''G.Pass+#endif+  liftM concat $ forM cons $ \con -> case con of+    TH.RecC n l -> declareForeign n [ t | (_,_,t) <- l ]+    TH.NormalC n [] -> declareForeign n []+    TH.NormalC n _ -> error "pass descriptor constructors with fields need to be records"+ )++data PassManagerBuilder++foreign import ccall unsafe "LLVMPassManagerBuilderCreate" passManagerBuilderCreate ::+    IO (Ptr PassManagerBuilder)++foreign import ccall unsafe "LLVMPassManagerBuilderDispose" passManagerBuilderDispose ::+    Ptr PassManagerBuilder -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderSetOptLevel" passManagerBuilderSetOptLevel ::+    Ptr PassManagerBuilder -> CUInt -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderSetSizeLevel" passManagerBuilderSetSizeLevel ::+    Ptr PassManagerBuilder -> CUInt -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderSetDisableUnitAtATime" passManagerBuilderSetDisableUnitAtATime ::+    Ptr PassManagerBuilder -> LLVMBool -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderSetDisableUnrollLoops" passManagerBuilderSetDisableUnrollLoops ::+    Ptr PassManagerBuilder -> CUInt -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderSetDisableSimplifyLibCalls" passManagerBuilderSetDisableSimplifyLibCalls ::+    Ptr PassManagerBuilder -> LLVMBool -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderUseInlinerWithThreshold" passManagerBuilderUseInlinerWithThreshold ::+    Ptr PassManagerBuilder -> CUInt -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderPopulateFunctionPassManager" passManagerBuilderPopulateFunctionPassManager ::+    Ptr PassManagerBuilder -> Ptr PassManager -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderPopulateModulePassManager" passManagerBuilderPopulateModulePassManager ::+    Ptr PassManagerBuilder -> Ptr PassManager -> IO ()++foreign import ccall unsafe "LLVMPassManagerBuilderPopulateLTOPassManager" passManagerBuilderPopulateLTOPassManager ::+    Ptr PassManagerBuilder -> Ptr PassManager -> CUChar -> CUChar -> IO ()++foreign import ccall unsafe "LLVM_Hs_PassManagerBuilderSetLibraryInfo" passManagerBuilderSetLibraryInfo ::+    Ptr PassManagerBuilder -> Ptr TargetLibraryInfo -> IO ()++foreign import ccall unsafe "LLVM_Hs_PassManagerBuilderSetLoopVectorize" passManagerBuilderSetLoopVectorize ::+    Ptr PassManagerBuilder -> LLVMBool -> IO ()++foreign import ccall unsafe "LLVM_Hs_PassManagerBuilderSetSuperwordLevelParallelismVectorize" passManagerBuilderSetSuperwordLevelParallelismVectorize ::+    Ptr PassManagerBuilder -> LLVMBool -> IO ()

@@ -0,0 +1,248 @@+#define __STDC_LIMIT_MACROS+#include "llvm/IR/LLVMContext.h"+#include "llvm/IR/DataLayout.h"+#include "llvm/IR/LegacyPassManager.h"+#include "llvm/Transforms/Scalar.h"+#include "llvm/Transforms/Scalar/GVN.h"+#include "llvm/Transforms/IPO.h"+#include "llvm/Transforms/IPO/Internalize.h"+#include "llvm/Transforms/IPO/PassManagerBuilder.h"+#include "llvm/Transforms/Vectorize.h"+#include "llvm/Transforms/Instrumentation.h"+#include "llvm/CodeGen/Passes.h"+#include "llvm-c/Target.h"+#include "llvm-c/Transforms/PassManagerBuilder.h"+#include "llvm/Analysis/TargetLibraryInfo.h"+#include "llvm/Target/TargetMachine.h"++#include "llvm-c/Core.h"++using namespace llvm;++extern "C" {+typedef struct LLVMOpaqueVectorizationConfig *LLVMVectorizationConfigRef;+typedef struct LLVMOpaqueTargetLowering *LLVMTargetLoweringRef;+typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef;+}++namespace llvm {+inline TargetLowering *unwrap(LLVMTargetLoweringRef P) { +	return reinterpret_cast<TargetLowering *>(P);+}++inline LLVMTargetLoweringRef wrap(const TargetLowering *P) { +	return reinterpret_cast<LLVMTargetLoweringRef>(const_cast<TargetLowering *>(P));+}++inline TargetMachine *unwrap(LLVMTargetMachineRef P) {+	return reinterpret_cast<TargetMachine*>(P);+}++inline LLVMTargetMachineRef wrap(const TargetMachine *P) {+	return reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine *>(P));+}++// Taken from llvm/lib/Transforms/IPO/PassManagerBuilder.cpp+inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {+    return reinterpret_cast<PassManagerBuilder*>(P);+}++inline TargetLibraryInfoImpl *unwrap(LLVMTargetLibraryInfoRef P) {+  return reinterpret_cast<TargetLibraryInfoImpl*>(P);+}++}++extern "C" {++#define LLVM_HS_FOR_EACH_PASS_WITHOUT_LLVM_C_BINDING(macro) \+	macro(BreakCriticalEdges) \+	macro(DeadCodeElimination) \+	macro(DeadInstElimination) \+	macro(DemoteRegisterToMemory) \+	macro(LCSSA) \+	macro(LoopInstSimplify) \+	macro(LowerAtomic) \+	macro(LowerSwitch) \+	macro(MergeFunctions) \+	macro(PartialInlining) \+	macro(Sinking) \+	macro(StripDeadDebugInfo) \+	macro(StripDebugDeclare) \+	macro(StripNonDebugSymbols) \++#define ENUM_CASE(p)								\+void LLVM_Hs_Add ## p ## Pass(LLVMPassManagerRef PM) {	\+	unwrap(PM)->add(create ## p ## Pass());			\+}+LLVM_HS_FOR_EACH_PASS_WITHOUT_LLVM_C_BINDING(ENUM_CASE)+#undef ENUM_CASE++void LLVM_Hs_AddCodeGenPreparePass(LLVMPassManagerRef PM, LLVMTargetMachineRef T) {+	unwrap(PM)->add(createCodeGenPreparePass(unwrap(T)));+}+	+void LLVM_Hs_AddGlobalValueNumberingPass(LLVMPassManagerRef PM, LLVMBool noLoads) {+	unwrap(PM)->add(createGVNPass(noLoads));+}++void LLVM_Hs_AddInternalizePass(LLVMPassManagerRef PM, unsigned nExports, const char **exports) {+    std::vector<std::string> exportList(nExports);+    for (unsigned i = 0; i < nExports; ++i) {+        exportList.at(i) = exports[i];+    }+    std::function<bool(const GlobalValue &)> mustPreserveGV = [exportList](const GlobalValue & gv) {+        for (const auto& exp : exportList) {+            if (gv.getName().equals(exp)) {+                return true;+            }+        }+        return false;+    };+    unwrap(PM)->add(createInternalizePass(std::move(mustPreserveGV)));+}++void LLVM_Hs_AddLoopStrengthReducePass(LLVMPassManagerRef PM) {+	unwrap(PM)->add(createLoopStrengthReducePass());+}++void LLVM_Hs_AddLowerInvokePass(LLVMPassManagerRef PM) {+	unwrap(PM)->add(createLowerInvokePass());+}+	+void LLVM_Hs_AddSROAPass(LLVMPassManagerRef PM) {+	unwrap(PM)->add(createSROAPass());+}++void LLVM_Hs_AddBasicBlockVectorizePass(+	LLVMPassManagerRef PM,+	unsigned vectorBits,+	LLVMBool vectorizeBools,+	LLVMBool vectorizeInts,+	LLVMBool vectorizeFloats,+	LLVMBool vectorizePointers,+	LLVMBool vectorizeCasts,+	LLVMBool vectorizeMath,+	LLVMBool vectorizeFusedMultiplyAdd,+	LLVMBool vectorizeSelect,+	LLVMBool vectorizeCmp,+	LLVMBool vectorizeGetElementPtr,+	LLVMBool vectorizeMemoryOperations,+	LLVMBool alignedOnly,+	unsigned reqChainDepth,+	unsigned searchLimit,+	unsigned maxCandidatePairsForCycleCheck,+	LLVMBool splatBreaksChain,+	unsigned maxInstructions,+	unsigned maxIterations,+	LLVMBool powerOfTwoLengthsOnly,+	LLVMBool noMemoryOperationBoost,+	LLVMBool fastDependencyAnalysis+) {+	VectorizeConfig vectorizeConfig;+	vectorizeConfig.VectorBits = vectorBits;+	vectorizeConfig.VectorizeBools = vectorizeBools;+	vectorizeConfig.VectorizeInts = vectorizeInts;+	vectorizeConfig.VectorizeFloats = vectorizeFloats;+	vectorizeConfig.VectorizePointers = vectorizePointers;+	vectorizeConfig.VectorizeCasts = vectorizeCasts;+	vectorizeConfig.VectorizeMath = vectorizeMath;+	vectorizeConfig.VectorizeFMA = vectorizeFusedMultiplyAdd;+	vectorizeConfig.VectorizeSelect = vectorizeSelect;+	vectorizeConfig.VectorizeCmp = vectorizeCmp;+	vectorizeConfig.VectorizeGEP = vectorizeGetElementPtr;+	vectorizeConfig.VectorizeMemOps = vectorizeMemoryOperations;+	vectorizeConfig.AlignedOnly = alignedOnly;+	vectorizeConfig.ReqChainDepth = reqChainDepth;+	vectorizeConfig.SearchLimit = searchLimit;+	vectorizeConfig.MaxCandPairsForCycleCheck = maxCandidatePairsForCycleCheck;+	vectorizeConfig.SplatBreaksChain = splatBreaksChain;+	vectorizeConfig.MaxInsts = maxInstructions;+	vectorizeConfig.MaxIter = maxIterations;+	vectorizeConfig.Pow2LenOnly = powerOfTwoLengthsOnly;+	vectorizeConfig.NoMemOpBoost = noMemoryOperationBoost;+	vectorizeConfig.FastDep = fastDependencyAnalysis;	++	unwrap(PM)->add(createBBVectorizePass(vectorizeConfig));+}++void LLVM_Hs_AddGCOVProfilerPass(+	LLVMPassManagerRef PM,+	LLVMBool emitNotes,+	LLVMBool emitData,+	const char *version,+	LLVMBool useCfgChecksum,+	LLVMBool noRedZone,+	LLVMBool functionNamesInData+) {+	struct GCOVOptions options;+	options.EmitNotes = emitNotes;+	options.EmitData = emitData;+	std::copy(version, version+4, options.Version);+	options.UseCfgChecksum = useCfgChecksum;+	options.NoRedZone = noRedZone;+	options.FunctionNamesInData = functionNamesInData;+	unwrap(PM)->add(createGCOVProfilerPass(options));+}++void LLVM_Hs_AddAddressSanitizerFunctionPass(+	LLVMPassManagerRef PM+) {+	unwrap(PM)->add(createAddressSanitizerFunctionPass());+}++void LLVM_Hs_AddAddressSanitizerModulePass(+	LLVMPassManagerRef PM+) {+	unwrap(PM)->add(createAddressSanitizerModulePass());+}++void LLVM_Hs_AddMemorySanitizerPass(+	LLVMPassManagerRef PM,+	LLVMBool trackOrigins+) {+	unwrap(PM)->add(createMemorySanitizerPass(trackOrigins));+}++void LLVM_Hs_AddThreadSanitizerPass(+	LLVMPassManagerRef PM+) {+	unwrap(PM)->add(createThreadSanitizerPass());+}++void LLVM_Hs_AddBoundsCheckingPass(LLVMPassManagerRef PM) {+	unwrap(PM)->add(createBoundsCheckingPass());+}++void LLVM_Hs_AddLoopVectorizePass(+	LLVMPassManagerRef PM,+	LLVMBool noUnrolling,+	LLVMBool alwaysVectorize+) {+	unwrap(PM)->add(createLoopVectorizePass(noUnrolling, alwaysVectorize));+}++void LLVM_Hs_PassManagerBuilderSetLibraryInfo(+	LLVMPassManagerBuilderRef PMB,+	LLVMTargetLibraryInfoRef l+) {+	// The PassManager frees the TargetLibraryInfo when done,+	// but we also free our ref, so give it a new copy.+	unwrap(PMB)->LibraryInfo = new TargetLibraryInfoImpl(*unwrap(l));+}++void LLVM_Hs_PassManagerBuilderSetLoopVectorize(+	LLVMPassManagerBuilderRef PMB,+	LLVMBool runLoopVectorization+) {+	unwrap(PMB)->LoopVectorize = runLoopVectorization;+}++void LLVM_Hs_PassManagerBuilderSetSuperwordLevelParallelismVectorize(+	LLVMPassManagerBuilderRef PMB,+	LLVMBool runSLPVectorization+) {+	unwrap(PMB)->SLPVectorize = runSLPVectorization;+}++}

@@ -0,0 +1,134 @@+{-# LANGUAGE+  ForeignFunctionInterface,+  MultiParamTypeClasses,+  FunctionalDependencies,+  UndecidableInstances,+  CPP+  #-}+#if __GLASGOW_HASKELL__ < 710+{-# LANGUAGE OverlappingInstances #-}+#define CPP_OVERLAPPING+#else+#define CPP_OVERLAPPING {-# OVERLAPPING #-}+#endif+-- | This module defines typeclasses to represent the relationships of an object-oriented inheritance hierarchy+module LLVM.Internal.FFI.PtrHierarchy where++import LLVM.Prelude++import Foreign.Ptr++-- | a class to represent safe casting of pointers to objects of descendant-classes to ancestor-classes.+class DescendentOf a b where+    upCast :: Ptr b -> Ptr a+    upCast = castPtr++-- | trivial casts+instance CPP_OVERLAPPING DescendentOf a a where+    upCast = id++-- | a class to represent direct parent-child relationships+class ChildOf b c | c -> b++-- | ancestor-descentant relationships are build out of parent-child relationships+instance (DescendentOf a b, ChildOf b c) => DescendentOf a c++-- | <http://llvm.org/doxygen/classllvm_1_1Value.html>+data Value++-- | <http://llvm.org/doxygen/classllvm_1_1Constant.html>+data Constant++instance ChildOf User Constant++-- | <http://llvm.org/doxygen/classllvm_1_1GlobalValue.html>+data GlobalValue++instance ChildOf Constant GlobalValue++-- | <http://llvm.org/doxygen/classllvm_1_1GlobalObject.html>+data GlobalObject++instance ChildOf GlobalValue GlobalObject++-- | <http://llvm.org/doxygen/classllvm_1_1GlobalVariable.html>+data GlobalVariable++instance ChildOf GlobalObject GlobalVariable++-- | <http://llvm.org/doxygen/classllvm_1_1GlobalAlias.html>+data GlobalAlias++instance ChildOf GlobalValue GlobalAlias++-- | <http://llvm.org/doxygen/classllvm_1_1Function.html>+data Function++instance ChildOf GlobalObject Function++-- | <http://llvm.org/doxygen/classllvm_1_1BasicBlock.html>+data BasicBlock++instance ChildOf Value BasicBlock++-- | <http://llvm.org/doxygen/classllvm_1_1Argument.html>+data Parameter++instance ChildOf Value Parameter++-- | <http://llvm.org/doxygen/classllvm_1_1Instruction.html>+data Instruction++instance ChildOf User Instruction++-- | <http://llvm.org/doxygen/classllvm_1_1BinaryOperator.html>+data BinaryOperator++instance ChildOf Instruction BinaryOperator++-- | <http://llvm.org/doxygen/classllvm_1_1User.html>+data User++instance ChildOf Value User++-- | <http://llvm.org/doxygen/classllvm_1_1MDNode.html>+data MDNode++instance ChildOf Metadata MDNode++-- | <http://llvm.org/doxygen/classllvm_1_1MDString.html>+data MDString++instance ChildOf Metadata MDString++-- | http://llvm.org/doxygen/classllvm_1_1ValueAsMetadata.html+data MDValue++instance ChildOf Metadata MDValue++-- | <http://llvm.org/doxygen/classllvm_1_1NamedMDNode.html>+data NamedMetadata++-- | <http://llvm.org/doxygen/classllvm_1_1InlineAsm.html>+data InlineAsm++instance ChildOf Value InlineAsm++-- | <http://llvm.org/doxygen/classllvm_1_1Type.html>+data Type++-- | <http://llvm.org/doxygen/classllvm_1_1Metadata.html>+data Metadata++-- | <http://www.llvm.org/docs/doxygen/html/classllvm_1_1MetadataAsValue.html>+data MetadataAsVal++instance ChildOf Value MetadataAsVal++-- | <http://llvm.org/docs/doxygen/html/classllvm_1_1raw__ostream.html>+data RawOStream++-- | <http://llvm.org/docs/doxygen/html/classllvm_1_1raw__pwrite__stream.html>+data RawPWriteStream++instance ChildOf RawOStream RawPWriteStream

@@ -0,0 +1,35 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+module LLVM.Internal.FFI.RawOStream where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C+import Control.Exception (bracket)++import LLVM.Internal.FFI.ByteRangeCallback+import LLVM.Internal.FFI.LLVMCTypes+import LLVM.Internal.FFI.PtrHierarchy++type RawPWriteStreamCallback = Ptr RawPWriteStream -> IO ()++foreign import ccall "wrapper" wrapRawPWriteStreamCallback ::+  RawPWriteStreamCallback -> IO (FunPtr RawPWriteStreamCallback)++foreign import ccall safe "LLVM_Hs_WithFileRawPWriteStream" withFileRawPWriteStream' ::+  CString -> LLVMBool -> LLVMBool -> Ptr (OwnerTransfered CString) -> FunPtr RawPWriteStreamCallback -> IO LLVMBool++withFileRawPWriteStream :: CString -> LLVMBool -> LLVMBool -> Ptr (OwnerTransfered CString) -> RawPWriteStreamCallback -> IO LLVMBool+withFileRawPWriteStream p ex bin err c =+  bracket (wrapRawPWriteStreamCallback c) freeHaskellFunPtr (withFileRawPWriteStream' p ex bin err)++foreign import ccall safe "LLVM_Hs_WithBufferRawPWriteStream" withBufferRawPWriteStream' ::+  FunPtr ByteRangeCallback -> FunPtr RawPWriteStreamCallback -> IO ()++withBufferRawPWriteStream :: ByteRangeCallback -> RawPWriteStreamCallback -> IO ()+withBufferRawPWriteStream oc c =+  bracket (wrapRawPWriteStreamCallback c) freeHaskellFunPtr $ \c ->+  bracket (wrapByteRangeCallback oc) freeHaskellFunPtr $ \oc ->+    withBufferRawPWriteStream' oc c

@@ -0,0 +1,36 @@+#define __STDC_LIMIT_MACROS+#include "llvm-c/Core.h"+#include "llvm/Support/FileSystem.h"+#include "llvm/Support/raw_ostream.h"++using namespace llvm;+using sys::fs::F_None;+using sys::fs::F_Excl;+using sys::fs::F_Text;++extern "C" {++LLVMBool+LLVM_Hs_WithFileRawPWriteStream(const char *filename, LLVMBool excl,+                                LLVMBool text, char **error,+                                void (&callback)(raw_pwrite_stream &ostream)) {+    std::error_code e;+    raw_fd_ostream os(filename, e,+                      (excl ? F_Excl : F_None) | (text ? F_Text : F_None));+    if (e) {+        *error = strdup(e.message().c_str());+        return false;+    }+    callback(os);+    return true;+}++void LLVM_Hs_WithBufferRawPWriteStream(+    void (&outputCallback)(const char *start, size_t length),+    void (&streamCallback)(raw_pwrite_stream &ostream)) {+    SmallString<0> s;+    raw_svector_ostream os(s);+    streamCallback(os);+    outputCallback(os.str().data(), s.size());+}+}

@@ -0,0 +1,15 @@+#ifndef __LLVM_INTERNAL_FFI__SMDIAGNOSTIC__+#define __LLVM_INTERNAL_FFI__SMDIAGNOSTIC__++#define LLVM_HS_FOR_EACH_DIAGNOSTIC_KIND(macro) \+	macro(Error) \+	macro(Warning) \+	macro(Note)++typedef enum {+#define ENUM_CASE(k) LLVMDiagnosticKind ## k,+LLVM_HS_FOR_EACH_DIAGNOSTIC_KIND(ENUM_CASE)+#undef ENUM_CASE+} LLVMDiagnosticKind;++#endif

@@ -0,0 +1,40 @@+{-# LANGUAGE+  ForeignFunctionInterface+  #-}+-- | FFI functions for handling the LLVM SMDiagnostic class+module LLVM.Internal.FFI.SMDiagnostic where++import LLVM.Prelude++import Foreign.Ptr+import Foreign.C++import LLVM.Internal.FFI.LLVMCTypes++data SMDiagnostic++-- | allocate an SMDiagnostic object+foreign import ccall unsafe "LLVM_Hs_CreateSMDiagnostic" createSMDiagnostic ::+  IO (Ptr SMDiagnostic)++foreign import ccall unsafe "LLVM_Hs_DisposeSMDiagnostic" disposeSMDiagnostic ::+  Ptr SMDiagnostic -> IO ()++foreign import ccall unsafe "LLVM_Hs_GetSMDiagnosticKind" getSMDiagnosticKind ::+  Ptr SMDiagnostic -> IO DiagnosticKind++foreign import ccall unsafe "LLVM_Hs_GetSMDiagnosticLineNo" getSMDiagnosticLineNo ::+  Ptr SMDiagnostic -> IO CInt ++foreign import ccall unsafe "LLVM_Hs_GetSMDiagnosticColumnNo" getSMDiagnosticColumnNo ::+  Ptr SMDiagnostic -> IO CInt ++foreign import ccall unsafe "LLVM_Hs_GetSMDiagnosticFilename" getSMDiagnosticFilename ::+  Ptr SMDiagnostic -> Ptr CUInt -> IO CString ++foreign import ccall unsafe "LLVM_Hs_GetSMDiagnosticMessage" getSMDiagnosticMessage ::+  Ptr SMDiagnostic -> Ptr CUInt -> IO CString ++foreign import ccall unsafe "LLVM_Hs_GetSMDiagnosticLineContents" getSMDiagnosticLineContents ::+  Ptr SMDiagnostic -> Ptr CUInt -> IO CString +

@@ -0,0 +1,42 @@+#define __STDC_LIMIT_MACROS+#include "llvm/Config/llvm-config.h"+#include "llvm/IR/LLVMContext.h"++#include "llvm/Support/SourceMgr.h"+#include "llvm-c/Core.h"++#include "LLVM/Internal/FFI/SMDiagnostic.h"++using namespace llvm;++extern "C" {++SMDiagnostic *LLVM_Hs_CreateSMDiagnostic() { return new SMDiagnostic(); }+void LLVM_Hs_DisposeSMDiagnostic(SMDiagnostic *p) { delete p; }++LLVMDiagnosticKind LLVM_Hs_GetSMDiagnosticKind(SMDiagnostic *p) {+	switch(p->getKind()) {+#define ENUM_CASE(k) case SourceMgr::DK_ ## k: return LLVMDiagnosticKind ## k;+		LLVM_HS_FOR_EACH_DIAGNOSTIC_KIND(ENUM_CASE)+#undef ENUM_CASE+	default: return LLVMDiagnosticKind(0);+	}+}++int LLVM_Hs_GetSMDiagnosticLineNo(SMDiagnostic *p) { return p->getLineNo(); }+int LLVM_Hs_GetSMDiagnosticColumnNo(SMDiagnostic *p) { return p->getColumnNo(); }++const char *LLVM_Hs_GetSMDiagnosticFilename(SMDiagnostic *p, unsigned *len) { +	*len = p->getFilename().size();+	return p->getFilename().data();+}+const char *LLVM_Hs_GetSMDiagnosticMessage(SMDiagnostic *p, unsigned *len) {+	*len = p->getMessage().size();+	return p->getMessage().data();+}+const char *LLVM_Hs_GetSMDiagnosticLineContents(SMDiagnostic *p, unsigned *len) {+	*len = p->getLineContents().size();+	return p->getLineContents().data();+}++}

@@ -0,0 +1,71 @@+#ifndef __LLVM_INTERNAL_FFI__TARGET__H__+#define __LLVM_INTERNAL_FFI__TARGET__H__++#define LLVM_HS_FOR_EACH_RELOC_MODEL(macro)	\+	macro(Default, Default)													\+	macro(Static, Static)														\+	macro(PIC, PIC_)																\+	macro(DynamicNoPic, DynamicNoPIC)++#define LLVM_HS_FOR_EACH_CODE_MODEL(macro) \+	macro(Default)																\+	macro(JITDefault)															\+	macro(Small)																	\+	macro(Kernel)																	\+	macro(Medium)																	\+	macro(Large)++#define LLVM_HS_FOR_EACH_CODE_GEN_OPT_LEVEL(macro) \+	macro(None)																						\+	macro(Less)																						\+	macro(Default)																				\+	macro(Aggressive)++#define LLVM_HS_FOR_EACH_CODE_GEN_FILE_TYPE(macro)	\+	macro(Assembly)                                       \+	macro(Object)++#define LLVM_HS_FOR_EACH_TARGET_OPTION_FLAG(macro)	\+	macro(PrintMachineCode)																\+	macro(LessPreciseFPMADOption)													\+	macro(UnsafeFPMath)																		\+	macro(NoInfsFPMath)																		\+	macro(NoNaNsFPMath)																		\+	macro(HonorSignDependentRoundingFPMathOption)					\+	macro(NoZerosInBSS)																		\+	macro(GuaranteedTailCallOpt)													\+	macro(EnableFastISel)																	\+	macro(UseInitArray)																		\+	macro(DisableIntegratedAS)														\+	macro(CompressDebugSections)													\+	macro(TrapUnreachable)++typedef enum {+#define ENUM_CASE(n) LLVM_Hs_TargetOptionFlag_ ## n,+	LLVM_HS_FOR_EACH_TARGET_OPTION_FLAG(ENUM_CASE)+#undef ENUM_CASE+} LLVM_Hs_TargetOptionFlag;++#define LLVM_HS_FOR_EACH_FLOAT_ABI(macro)	\+	macro(Default)																\+	macro(Soft)																		\+	macro(Hard)++typedef enum {+#define ENUM_CASE(n) LLVM_Hs_FloatABI_ ## n,+	LLVM_HS_FOR_EACH_FLOAT_ABI(ENUM_CASE)+#undef ENUM_CASE+} LLVM_Hs_FloatABI;++#define LLVM_HS_FOR_EACH_FP_OP_FUSION_MODE(macro)	\+	macro(Fast)																						\+	macro(Standard)																				\+	macro(Strict)++typedef enum {+#define ENUM_CASE(n) LLVM_Hs_FPOpFusionMode_ ## n,+	LLVM_HS_FOR_EACH_FP_OP_FUSION_MODE(ENUM_CASE)+#undef ENUM_CASE+} LLVM_Hs_FPOpFusionMode;++#endif