Text.LLVM

LLVM Monad

data LLVM a

Instances

Monad LLVM

Functor LLVM

MonadFix LLVM

Applicative LLVM

runLLVM :: LLVM a -> (a, Module)

emitTypeDecl :: TypeDecl -> LLVM ()

emitGlobal :: Global -> LLVM ()

emitDeclare :: Declare -> LLVM ()

emitDefine :: Define -> LLVM ()

Alias Introduction

alias :: Ident -> Type -> LLVM ()

Function Definition

freshSymbol :: LLVM Symbol

data a :> b

Constructors

a :> b

Instances

(Show a, Show b) => Show (:> a b)

DefineArgs as k => DefineArgs (:> Type as) (Typed Value -> k)

define :: DefineArgs sig k => FunAttrs -> Type -> Symbol -> sig -> k -> LLVM (Typed Value)

Define a function.

defineFresh :: DefineArgs sig k => FunAttrs -> Type -> sig -> k -> LLVM (Typed Value)

A combination of define and freshSymbol.

class DefineArgs a k | a -> k

Types that can be used to define the body of a function.

Instances

DefineArgs () (BB ())

DefineArgs Type (Typed Value -> BB ())

DefineArgs (Type, Type) (Typed Value -> Typed Value -> BB ())

DefineArgs as k => DefineArgs (:> Type as) (Typed Value -> k)

DefineArgs (Type, Type, Type) (Typed Value -> Typed Value -> Typed Value -> BB ())

define' :: FunAttrs -> Type -> Symbol -> [Type] -> Bool -> ([Typed Value] -> BB ()) -> LLVM (Typed Value)

Function definition when the argument list isn't statically known. This is useful when generating code.

declare :: Type -> Symbol -> [Type] -> Bool -> LLVM ()

Emit a declaration.

global :: Symbol -> Typed Value -> LLVM ()

Emit a global declaration.

Types

iT :: Int32 -> Type

ptrT :: Type -> Type

voidT :: Type

arrayT :: Int32 -> Type -> Type

(=:) :: Type -> a -> Typed a

(-:) :: IsValue a => Type -> a -> Typed Value

Values

class IsValue a where

Methods

toValue :: a -> Value

Instances

IsValue Int

IsValue Int8

IsValue Int16

IsValue Int32

IsValue Int64

IsValue Integer

IsValue Value

IsValue Symbol

IsValue Ident

IsValue a => IsValue (Typed a)

int :: Int -> Value

integer :: Integer -> Value

struct :: Bool -> [Typed Value] -> Typed Value

array :: Type -> [Value] -> Typed Value

string :: Symbol -> String -> LLVM ()

Output a somewhat clunky representation for a string global, that deals well with escaping in the haskell-source string.

Basic Blocks

data BB a

Instances

Monad BB

Functor BB

MonadFix BB

Applicative BB

DefineArgs () (BB ())

DefineArgs Type (Typed Value -> BB ())

IsString (BB a)

DefineArgs (Type, Type) (Typed Value -> Typed Value -> BB ())

DefineArgs (Type, Type, Type) (Typed Value -> Typed Value -> Typed Value -> BB ())

freshLabel :: BB Ident

label :: Ident -> BB ()

Force termination of the current basic block, and start a new one with the given label. If the previous block had no instructions defined, it will just be thrown away.

comment :: String -> BB ()

Terminator Instructions

ret :: IsValue a => Typed a -> BB ()

Emit the `ret' instruction and terminate the current basic block.

retVoid :: BB ()

Emit ``ret void'' and terminate the current basic block.

jump :: Ident -> BB ()

br :: IsValue a => Typed a -> Ident -> Ident -> BB ()

unreachable :: BB ()

unwind :: BB ()

Binary Operations

add :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

fadd :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

sub :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

fsub :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

mul :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

fmul :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

udiv :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

sdiv :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

fdiv :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

urem :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

srem :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

frem :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

Bitwise Binary Operations

shl :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

lshr :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

ashr :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

band :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

bor :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

bxor :: (IsValue a, IsValue b) => Typed a -> b -> BB (Typed Value)

Conversion Operations

trunc :: IsValue a => Typed a -> Type -> BB (Typed Value)

zext :: IsValue a => Typed a -> Type -> BB (Typed Value)

sext :: IsValue a => Typed a -> Type -> BB (Typed Value)

fptrunc :: IsValue a => Typed a -> Type -> BB (Typed Value)

fpext :: IsValue a => Typed a -> Type -> BB (Typed Value)

fptoui :: IsValue a => Typed a -> Type -> BB (Typed Value)

fptosi :: IsValue a => Typed a -> Type -> BB (Typed Value)

uitofp :: IsValue a => Typed a -> Type -> BB (Typed Value)

sitofp :: IsValue a => Typed a -> Type -> BB (Typed Value)

ptrtoint :: IsValue a => Typed a -> Type -> BB (Typed Value)

inttoptr :: IsValue a => Typed a -> Type -> BB (Typed Value)

bitcast :: IsValue a => Typed a -> Type -> BB (Typed Value)

Aggregate Operations

extractValue :: IsValue a => Typed a -> Int32 -> BB (Typed Value)

Returns the value stored in the member field of an aggregate value.

insertValue :: (IsValue a, IsValue b) => Typed a -> Typed b -> Int32 -> BB (Typed Value)

Inserts a value into the member field of an aggregate value, and returns the new value.

Memory Access and Addressing Operations

alloca :: Type -> Maybe (Typed Value) -> Maybe Int -> BB (Typed Value)

load :: IsValue a => Typed a -> Maybe Align -> BB (Typed Value)

store :: (IsValue a, IsValue b) => a -> Typed b -> Maybe Align -> BB ()

getelementptr :: IsValue a => Type -> Typed a -> [Typed Value] -> BB (Typed Value)

nullPtr :: Type -> Typed Value

Other Operations

icmp :: (IsValue a, IsValue b) => ICmpOp -> Typed a -> b -> BB (Typed Value)

fcmp :: (IsValue a, IsValue b) => FCmpOp -> Typed a -> b -> BB (Typed Value)

phi :: Type -> [PhiArg] -> BB (Typed Value)

data PhiArg

from :: IsValue a => a -> BlockLabel -> PhiArg

select :: (IsValue a, IsValue b, IsValue c) => Typed a -> Typed b -> Typed c -> BB (Typed Value)

call :: IsValue a => Typed a -> [Typed Value] -> BB (Typed Value)

Emit a call instruction, and generate a new variable for its result.

call_ :: IsValue a => Typed a -> [Typed Value] -> BB ()

Emit a call instruction, but don't generate a new variable for its result.

invoke :: IsValue a => Type -> a -> [Typed Value] -> Ident -> Ident -> BB (Typed Value)

Emit an invoke instruction, and generate a new variable for its result.

shuffleVector :: (IsValue a, IsValue b, IsValue c) => Typed a -> b -> c -> BB (Typed Value)

Re-exported

module Text.LLVM.AST