Text.LLVM

LLVM Monad

data LLVM a

Instances

Monad LLVM

Methods

(>>=) :: LLVM a -> (a -> LLVM b) -> LLVM b

(>>) :: LLVM a -> LLVM b -> LLVM b

return :: a -> LLVM a

fail :: String -> LLVM a

Functor LLVM

Methods

fmap :: (a -> b) -> LLVM a -> LLVM b

(<$) :: a -> LLVM b -> LLVM a

MonadFix LLVM

Methods

mfix :: (a -> LLVM a) -> LLVM a

Applicative LLVM

Methods

pure :: a -> LLVM a

(<*>) :: LLVM (a -> b) -> LLVM a -> LLVM b

(*>) :: LLVM a -> LLVM b -> LLVM b

(<*) :: LLVM a -> LLVM b -> LLVM a

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

emitTypeDecl :: TypeDecl -> LLVM ()

emitGlobal :: Global -> LLVM (Typed Value)

emitDeclare :: Declare -> LLVM (Typed Value)

emitDefine :: Define -> LLVM (Typed Value)

Alias Introduction

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

Function Definition

freshSymbol :: LLVM Symbol

data a :> b infixr 0

Constructors

a :> b infixr 0

Instances

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

Methods

showsPrec :: Int -> (a :> b) -> ShowS

show :: (a :> b) -> String

showList :: [a :> b] -> ShowS

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

Methods

defineBody :: [Typed Ident] -> (Type :> as) -> (Typed Value -> k) -> LLVM ([Typed Ident], [BasicBlock])

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.

Minimal complete definition

defineBody

Instances

DefineArgs () (BB ())

Methods

defineBody :: [Typed Ident] -> () -> BB () -> LLVM ([Typed Ident], [BasicBlock])

DefineArgs Type (Typed Value -> BB ())

Methods

defineBody :: [Typed Ident] -> Type -> (Typed Value -> BB ()) -> LLVM ([Typed Ident], [BasicBlock])

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

Methods

defineBody :: [Typed Ident] -> (Type, Type) -> (Typed Value -> Typed Value -> BB ()) -> LLVM ([Typed Ident], [BasicBlock])

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

Methods

defineBody :: [Typed Ident] -> (Type :> as) -> (Typed Value -> k) -> LLVM ([Typed Ident], [BasicBlock])

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

Methods

defineBody :: [Typed Ident] -> (Type, Type, Type) -> (Typed Value -> Typed Value -> Typed Value -> BB ()) -> LLVM ([Typed Ident], [BasicBlock])

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 (Typed Value)

Emit a declaration.

global :: GlobalAttrs -> Symbol -> Type -> Maybe Value -> LLVM (Typed Value)

Emit a global declaration.

data FunAttrs

Constructors

FunAttrs

Fields

• funLinkage :: Maybe Linkage
• funGC :: Maybe GC

Instances

Show FunAttrs

Methods

showsPrec :: Int -> FunAttrs -> ShowS

show :: FunAttrs -> String

showList :: [FunAttrs] -> ShowS

emptyFunAttrs :: FunAttrs

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

Minimal complete definition

toValue

Methods

toValue :: a -> Value

Instances

IsValue Bool

Methods

toValue :: Bool -> Value

IsValue Double

Methods

toValue :: Double -> Value

IsValue Float

Methods

toValue :: Float -> Value

IsValue Int

Methods

toValue :: Int -> Value

IsValue Int8

Methods

toValue :: Int8 -> Value

IsValue Int16

Methods

toValue :: Int16 -> Value

IsValue Int32

Methods

toValue :: Int32 -> Value

IsValue Int64

Methods

toValue :: Int64 -> Value

IsValue Integer

Methods

toValue :: Integer -> Value

IsValue Value

Methods

toValue :: Value -> Value

IsValue Symbol

Methods

toValue :: Symbol -> Value

IsValue Ident

Methods

toValue :: Ident -> Value

IsValue a => IsValue (Typed a)

Methods

toValue :: Typed a -> Value

int :: Int -> Value

integer :: Integer -> Value

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

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

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

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

Methods

(>>=) :: BB a -> (a -> BB b) -> BB b

(>>) :: BB a -> BB b -> BB b

return :: a -> BB a

fail :: String -> BB a

Functor BB

Methods

fmap :: (a -> b) -> BB a -> BB b

(<$) :: a -> BB b -> BB a

MonadFix BB

Methods

mfix :: (a -> BB a) -> BB a

Applicative BB

Methods

pure :: a -> BB a

(<*>) :: BB (a -> b) -> BB a -> BB b

(*>) :: BB a -> BB b -> BB b

(<*) :: BB a -> BB b -> BB a

DefineArgs () (BB ())

Methods

defineBody :: [Typed Ident] -> () -> BB () -> LLVM ([Typed Ident], [BasicBlock])

DefineArgs Type (Typed Value -> BB ())

Methods

defineBody :: [Typed Ident] -> Type -> (Typed Value -> BB ()) -> LLVM ([Typed Ident], [BasicBlock])

IsString (BB a)

Methods

fromString :: String -> BB a

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

Methods

defineBody :: [Typed Ident] -> (Type, Type) -> (Typed Value -> Typed Value -> BB ()) -> LLVM ([Typed Ident], [BasicBlock])

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

Methods

defineBody :: [Typed Ident] -> (Type, Type, Type) -> (Typed Value -> Typed Value -> Typed Value -> BB ()) -> LLVM ([Typed Ident], [BasicBlock])

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

assign :: IsValue a => Ident -> BB (Typed a) -> BB (Typed Value)

Emit an assignment that uses the given identifier to name the result of the BB operation.

WARNING: this can throw errors.

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.

switch :: IsValue a => Typed a -> Ident -> [(Integer, Ident)] -> BB ()

Emit a call instruction, but don't 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