llvmGen/Llvm/Types.hs

    {-# LANGUAGE CPP, GeneralizedNewtypeDeriving #-}

    --------------------------------------------------------------------------------
    -- | The LLVM Type System.
    --

    module Llvm.Types where

    #include "HsVersions.h"

    import Data.Char
    import Data.Int
    import Numeric

    import DynFlags
    import FastString
    import Outputable
    import Unique

    -- from NCG
    import PprBase

    import GHC.Float

    -- -----------------------------------------------------------------------------
    -- * LLVM Basic Types and Variables
    --

    -- | A global mutable variable. Maybe defined or external
    data LMGlobal = LMGlobal {
      getGlobalVar :: LlvmVar,          -- ^ Returns the variable of the 'LMGlobal'
      getGlobalValue :: Maybe LlvmStatic -- ^ Return the value of the 'LMGlobal'
      }

    -- | A String in LLVM
    type LMString = FastString

    -- | A type alias
    type LlvmAlias = (LMString, LlvmType)

    -- | Llvm Types
    data LlvmType
      = LMInt Int             -- ^ An integer with a given width in bits.
      | LMFloat               -- ^ 32 bit floating point
      | LMDouble              -- ^ 64 bit floating point
      | LMFloat80             -- ^ 80 bit (x86 only) floating point
      | LMFloat128            -- ^ 128 bit floating point
      | LMPointer LlvmType    -- ^ A pointer to a 'LlvmType'
      | LMArray Int LlvmType  -- ^ An array of 'LlvmType'
      | LMVector Int LlvmType -- ^ A vector of 'LlvmType'
      | LMLabel               -- ^ A 'LlvmVar' can represent a label (address)
      | LMVoid                -- ^ Void type
      | LMStruct [LlvmType]   -- ^ Packed structure type
      | LMStructU [LlvmType]  -- ^ Unpacked structure type
      | LMAlias LlvmAlias     -- ^ A type alias
      | LMMetadata            -- ^ LLVM Metadata

      -- | Function type, used to create pointers to functions
      | LMFunction LlvmFunctionDecl
      deriving (Eq)

    instance Outputable LlvmType where
      ppr (LMInt size     ) = char 'i' <> ppr size
      ppr (LMFloat        ) = text "float"
      ppr (LMDouble       ) = text "double"
      ppr (LMFloat80      ) = text "x86_fp80"
      ppr (LMFloat128     ) = text "fp128"
      ppr (LMPointer x    ) = ppr x <> char '*'
      ppr (LMArray nr tp  ) = char '[' <> ppr nr <> text " x " <> ppr tp <> char ']'
      ppr (LMVector nr tp ) = char '<' <> ppr nr <> text " x " <> ppr tp <> char '>'
      ppr (LMLabel        ) = text "label"
      ppr (LMVoid         ) = text "void"
      ppr (LMStruct tys   ) = text "<{" <> ppCommaJoin tys <> text "}>"
      ppr (LMStructU tys  ) = text "{" <> ppCommaJoin tys <> text "}"
      ppr (LMMetadata     ) = text "metadata"

      ppr (LMFunction (LlvmFunctionDecl _ _ _ r varg p _))
        = ppr r <+> lparen <> ppParams varg p <> rparen

      ppr (LMAlias (s,_)) = char '%' <> ftext s

    ppParams :: LlvmParameterListType -> [LlvmParameter] -> SDoc
    ppParams varg p
      = let varg' = case varg of
              VarArgs | null args -> sLit "..."
                      | otherwise -> sLit ", ..."
              _otherwise          -> sLit ""
            -- by default we don't print param attributes
            args = map fst p
        in ppCommaJoin args <> ptext varg'

    -- | An LLVM section definition. If Nothing then let LLVM decide the section
    type LMSection = Maybe LMString
    type LMAlign = Maybe Int

    data LMConst = Global      -- ^ Mutable global variable
                 | Constant    -- ^ Constant global variable
                 | Alias       -- ^ Alias of another variable
                 deriving (Eq)

    -- | LLVM Variables
    data LlvmVar
      -- | Variables with a global scope.
      = LMGlobalVar LMString LlvmType LlvmLinkageType LMSection LMAlign LMConst
      -- | Variables local to a function or parameters.
      | LMLocalVar Unique LlvmType
      -- | Named local variables. Sometimes we need to be able to explicitly name
      -- variables (e.g for function arguments).
      | LMNLocalVar LMString LlvmType
      -- | A constant variable
      | LMLitVar LlvmLit
      deriving (Eq)

    instance Outputable LlvmVar where
      ppr (LMLitVar x)  = ppr x
      ppr (x         )  = ppr (getVarType x) <+> ppName x

    -- | Llvm Literal Data.
    --
    -- These can be used inline in expressions.
    data LlvmLit
      -- | Refers to an integer constant (i64 42).
      = LMIntLit Integer LlvmType
      -- | Floating point literal
      | LMFloatLit Double LlvmType
      -- | Literal NULL, only applicable to pointer types
      | LMNullLit LlvmType
      -- | Vector literal
      | LMVectorLit [LlvmLit]
      -- | Undefined value, random bit pattern. Useful for optimisations.
      | LMUndefLit LlvmType
      deriving (Eq)

    instance Outputable LlvmLit where
      ppr l@(LMVectorLit {}) = ppLit l
      ppr l                  = ppr (getLitType l) <+> ppLit l

    -- | Llvm Static Data.
    --
    -- These represent the possible global level variables and constants.
    data LlvmStatic
      = LMComment LMString                  -- ^ A comment in a static section
      | LMStaticLit LlvmLit                 -- ^ A static variant of a literal value
      | LMUninitType LlvmType               -- ^ For uninitialised data
      | LMStaticStr LMString LlvmType       -- ^ Defines a static 'LMString'
      | LMStaticArray [LlvmStatic] LlvmType -- ^ A static array
      | LMStaticStruc [LlvmStatic] LlvmType -- ^ A static structure type
      | LMStaticPointer LlvmVar             -- ^ A pointer to other data

      -- static expressions, could split out but leave
      -- for moment for ease of use. Not many of them.

      | LMBitc LlvmStatic LlvmType         -- ^ Pointer to Pointer conversion
      | LMPtoI LlvmStatic LlvmType         -- ^ Pointer to Integer conversion
      | LMAdd LlvmStatic LlvmStatic        -- ^ Constant addition operation
      | LMSub LlvmStatic LlvmStatic        -- ^ Constant subtraction operation

    instance Outputable LlvmStatic where
      ppr (LMComment       s) = text "; " <> ftext s
      ppr (LMStaticLit   l  ) = ppr l
      ppr (LMUninitType    t) = ppr t <> text " undef"
      ppr (LMStaticStr   s t) = ppr t <> text " c\"" <> ftext s <> text "\\00\""
      ppr (LMStaticArray d t) = ppr t <> text " [" <> ppCommaJoin d <> char ']'
      ppr (LMStaticStruc d t) = ppr t <> text "<{" <> ppCommaJoin d <> text "}>"
      ppr (LMStaticPointer v) = ppr v
      ppr (LMBitc v t)
          = ppr t <> text " bitcast (" <> ppr v <> text " to " <> ppr t <> char ')'
      ppr (LMPtoI v t)
          = ppr t <> text " ptrtoint (" <> ppr v <> text " to " <> ppr t <> char ')'

      ppr (LMAdd s1 s2)
          = pprStaticArith s1 s2 (sLit "add") (sLit "fadd") "LMAdd"
      ppr (LMSub s1 s2)
          = pprStaticArith s1 s2 (sLit "sub") (sLit "fsub") "LMSub"

    pprSpecialStatic :: LlvmStatic -> SDoc
    pprSpecialStatic (LMBitc v t) =
        ppr (pLower t) <> text ", bitcast (" <> ppr v <> text " to " <> ppr t
            <> char ')'
    pprSpecialStatic stat = ppr stat

    pprStaticArith :: LlvmStatic -> LlvmStatic -> LitString -> LitString -> String -> SDoc
    pprStaticArith s1 s2 int_op float_op op_name =
      let ty1 = getStatType s1
          op  = if isFloat ty1 then float_op else int_op
      in if ty1 == getStatType s2
         then ppr ty1 <+> ptext op <+> lparen <> ppr s1 <> comma <> ppr s2 <> rparen
         else sdocWithDynFlags $ \dflags ->
                error $ op_name ++ " with different types! s1: "
                        ++ showSDoc dflags (ppr s1) ++ ", s2: " ++ showSDoc dflags (ppr s2)

    -- -----------------------------------------------------------------------------
    -- ** Operations on LLVM Basic Types and Variables
    --

    -- | Return the variable name or value of the 'LlvmVar'
    -- in Llvm IR textual representation (e.g. @\@x@, @%y@ or @42@).
    ppName :: LlvmVar -> SDoc
    ppName v@(LMGlobalVar {}) = char '@' <> ppPlainName v
    ppName v@(LMLocalVar  {}) = char '%' <> ppPlainName v
    ppName v@(LMNLocalVar {}) = char '%' <> ppPlainName v
    ppName v@(LMLitVar    {}) =             ppPlainName v

    -- | Return the variable name or value of the 'LlvmVar'
    -- in a plain textual representation (e.g. @x@, @y@ or @42@).
    ppPlainName :: LlvmVar -> SDoc
    ppPlainName (LMGlobalVar x _ _ _ _ _) = ftext x
    ppPlainName (LMLocalVar  x LMLabel  ) = text (show x)
    ppPlainName (LMLocalVar  x _        ) = text ('l' : show x)
    ppPlainName (LMNLocalVar x _        ) = ftext x
    ppPlainName (LMLitVar    x          ) = ppLit x

    -- | Print a literal value. No type.
    ppLit :: LlvmLit -> SDoc
    ppLit (LMIntLit i (LMInt 32))  = ppr (fromInteger i :: Int32)
    ppLit (LMIntLit i (LMInt 64))  = ppr (fromInteger i :: Int64)
    ppLit (LMIntLit   i _       )  = ppr ((fromInteger i)::Int)
    ppLit (LMFloatLit r LMFloat )  = ppFloat $ narrowFp r
    ppLit (LMFloatLit r LMDouble)  = ppDouble r
    ppLit f@(LMFloatLit _ _)       = sdocWithDynFlags (\dflags ->
                                       error $ "Can't print this float literal!" ++ showSDoc dflags (ppr f))
    ppLit (LMVectorLit ls  )       = char '<' <+> ppCommaJoin ls <+> char '>'
    ppLit (LMNullLit _     )       = text "null"
    -- Trac 11487 was an issue where we passed undef for some arguments
    -- that were actually live. By chance the registers holding those
    -- arguments usually happened to have the right values anyways, but
    -- that was not guaranteed. To find such bugs reliably, we set the
    -- flag below when validating, which replaces undef literals (at
    -- common types) with values that are likely to cause a crash or test
    -- failure.
    ppLit (LMUndefLit t    )       = sdocWithDynFlags f
      where f dflags
              | gopt Opt_LlvmFillUndefWithGarbage dflags,
                Just lit <- garbageLit t   = ppLit lit
              | otherwise                  = text "undef"

    garbageLit :: LlvmType -> Maybe LlvmLit
    garbageLit t@(LMInt w)     = Just (LMIntLit (0xbbbbbbbbbbbbbbb0 `mod` (2^w)) t)
      -- Use a value that looks like an untagged pointer, so we are more
      -- likely to try to enter it
    garbageLit t
      | isFloat t              = Just (LMFloatLit 12345678.9 t)
    garbageLit t@(LMPointer _) = Just (LMNullLit t)
      -- Using null isn't totally ideal, since some functions may check for null.
      -- But producing another value is inconvenient since it needs a cast,
      -- and the knowledge for how to format casts is in PpLlvm.
    garbageLit _               = Nothing
      -- More cases could be added, but this should do for now.

    -- | Return the 'LlvmType' of the 'LlvmVar'
    getVarType :: LlvmVar -> LlvmType
    getVarType (LMGlobalVar _ y _ _ _ _) = y
    getVarType (LMLocalVar  _ y        ) = y
    getVarType (LMNLocalVar _ y        ) = y
    getVarType (LMLitVar    l          ) = getLitType l

    -- | Return the 'LlvmType' of a 'LlvmLit'
    getLitType :: LlvmLit -> LlvmType
    getLitType (LMIntLit   _ t) = t
    getLitType (LMFloatLit _ t) = t
    getLitType (LMVectorLit [])  = panic "getLitType"
    getLitType (LMVectorLit ls)  = LMVector (length ls) (getLitType (head ls))
    getLitType (LMNullLit    t) = t
    getLitType (LMUndefLit   t) = t

    -- | Return the 'LlvmType' of the 'LlvmStatic'
    getStatType :: LlvmStatic -> LlvmType
    getStatType (LMStaticLit   l  ) = getLitType l
    getStatType (LMUninitType    t) = t
    getStatType (LMStaticStr   _ t) = t
    getStatType (LMStaticArray _ t) = t
    getStatType (LMStaticStruc _ t) = t
    getStatType (LMStaticPointer v) = getVarType v
    getStatType (LMBitc        _ t) = t
    getStatType (LMPtoI        _ t) = t
    getStatType (LMAdd         t _) = getStatType t
    getStatType (LMSub         t _) = getStatType t
    getStatType (LMComment       _) = error "Can't call getStatType on LMComment!"

    -- | Return the 'LlvmLinkageType' for a 'LlvmVar'
    getLink :: LlvmVar -> LlvmLinkageType
    getLink (LMGlobalVar _ _ l _ _ _) = l
    getLink _                         = Internal

    -- | Add a pointer indirection to the supplied type. 'LMLabel' and 'LMVoid'
    -- cannot be lifted.
    pLift :: LlvmType -> LlvmType
    pLift LMLabel    = error "Labels are unliftable"
    pLift LMVoid     = error "Voids are unliftable"
    pLift LMMetadata = error "Metadatas are unliftable"
    pLift x          = LMPointer x

    -- | Lift a variable to 'LMPointer' type.
    pVarLift :: LlvmVar -> LlvmVar
    pVarLift (LMGlobalVar s t l x a c) = LMGlobalVar s (pLift t) l x a c
    pVarLift (LMLocalVar  s t        ) = LMLocalVar  s (pLift t)
    pVarLift (LMNLocalVar s t        ) = LMNLocalVar s (pLift t)
    pVarLift (LMLitVar    _          ) = error $ "Can't lower a literal type!"

    -- | Remove the pointer indirection of the supplied type. Only 'LMPointer'
    -- constructors can be lowered.
    pLower :: LlvmType -> LlvmType
    pLower (LMPointer x) = x
    pLower x  = pprPanic "llvmGen(pLower)"
                $ ppr x <+> text " is a unlowerable type, need a pointer"

    -- | Lower a variable of 'LMPointer' type.
    pVarLower :: LlvmVar -> LlvmVar
    pVarLower (LMGlobalVar s t l x a c) = LMGlobalVar s (pLower t) l x a c
    pVarLower (LMLocalVar  s t        ) = LMLocalVar  s (pLower t)
    pVarLower (LMNLocalVar s t        ) = LMNLocalVar s (pLower t)
    pVarLower (LMLitVar    _          ) = error $ "Can't lower a literal type!"

    -- | Test if the given 'LlvmType' is an integer
    isInt :: LlvmType -> Bool
    isInt (LMInt _) = True
    isInt _         = False

    -- | Test if the given 'LlvmType' is a floating point type
    isFloat :: LlvmType -> Bool
    isFloat LMFloat    = True
    isFloat LMDouble   = True
    isFloat LMFloat80  = True
    isFloat LMFloat128 = True
    isFloat _          = False

    -- | Test if the given 'LlvmType' is an 'LMPointer' construct
    isPointer :: LlvmType -> Bool
    isPointer (LMPointer _) = True
    isPointer _             = False

    -- | Test if the given 'LlvmType' is an 'LMVector' construct
    isVector :: LlvmType -> Bool
    isVector (LMVector {}) = True
    isVector _             = False

    -- | Test if a 'LlvmVar' is global.
    isGlobal :: LlvmVar -> Bool
    isGlobal (LMGlobalVar _ _ _ _ _ _) = True
    isGlobal _                         = False

    -- | Width in bits of an 'LlvmType', returns 0 if not applicable
    llvmWidthInBits :: DynFlags -> LlvmType -> Int
    llvmWidthInBits _      (LMInt n)       = n
    llvmWidthInBits _      (LMFloat)       = 32
    llvmWidthInBits _      (LMDouble)      = 64
    llvmWidthInBits _      (LMFloat80)     = 80
    llvmWidthInBits _      (LMFloat128)    = 128
    -- Could return either a pointer width here or the width of what
    -- it points to. We will go with the former for now.
    -- PMW: At least judging by the way LLVM outputs constants, pointers
    --      should use the former, but arrays the latter.
    llvmWidthInBits dflags (LMPointer _)   = llvmWidthInBits dflags (llvmWord dflags)
    llvmWidthInBits dflags (LMArray n t)   = n * llvmWidthInBits dflags t
    llvmWidthInBits dflags (LMVector n ty) = n * llvmWidthInBits dflags ty
    llvmWidthInBits _      LMLabel         = 0
    llvmWidthInBits _      LMVoid          = 0
    llvmWidthInBits dflags (LMStruct tys)  = sum $ map (llvmWidthInBits dflags) tys
    llvmWidthInBits _      (LMStructU _)   =
        -- It's not trivial to calculate the bit width of the unpacked structs,
        -- since they will be aligned depending on the specified datalayout (
        -- http://llvm.org/docs/LangRef.html#data-layout ). One way we could support
        -- this could be to make the LlvmCodeGen.Ppr.moduleLayout be a data type
        -- that exposes the alignment information. However, currently the only place
        -- we use unpacked structs is LLVM intrinsics that return them (e.g.,
        -- llvm.sadd.with.overflow.*), so we don't actually need to compute their
        -- bit width.
        panic "llvmWidthInBits: not implemented for LMStructU"
    llvmWidthInBits _      (LMFunction  _) = 0
    llvmWidthInBits dflags (LMAlias (_,t)) = llvmWidthInBits dflags t
    llvmWidthInBits _      LMMetadata      = panic "llvmWidthInBits: Meta-data has no runtime representation!"

    -- -----------------------------------------------------------------------------
    -- ** Shortcut for Common Types
    --

    i128, i64, i32, i16, i8, i1, i8Ptr :: LlvmType
    i128  = LMInt 128
    i64   = LMInt  64
    i32   = LMInt  32
    i16   = LMInt  16
    i8    = LMInt   8
    i1    = LMInt   1
    i8Ptr = pLift i8

    -- | The target architectures word size
    llvmWord, llvmWordPtr :: DynFlags -> LlvmType
    llvmWord    dflags = LMInt (wORD_SIZE dflags * 8)
    llvmWordPtr dflags = pLift (llvmWord dflags)

    -- -----------------------------------------------------------------------------
    -- * LLVM Function Types
    --

    -- | An LLVM Function
    data LlvmFunctionDecl = LlvmFunctionDecl {
            -- | Unique identifier of the function
            decName       :: LMString,
            -- | LinkageType of the function
            funcLinkage   :: LlvmLinkageType,
            -- | The calling convention of the function
            funcCc        :: LlvmCallConvention,
            -- | Type of the returned value
            decReturnType :: LlvmType,
            -- | Indicates if this function uses varargs
            decVarargs    :: LlvmParameterListType,
            -- | Parameter types and attributes
            decParams     :: [LlvmParameter],
            -- | Function align value, must be power of 2
            funcAlign     :: LMAlign
      }
      deriving (Eq)

    instance Outputable LlvmFunctionDecl where
      ppr (LlvmFunctionDecl n l c r varg p a)
        = let align = case a of
                           Just a' -> text " align " <> ppr a'
                           Nothing -> empty
          in ppr l <+> ppr c <+> ppr r <+> char '@' <> ftext n <>
                 lparen <> ppParams varg p <> rparen <> align

    type LlvmFunctionDecls = [LlvmFunctionDecl]

    type LlvmParameter = (LlvmType, [LlvmParamAttr])

    -- | LLVM Parameter Attributes.
    --
    -- Parameter attributes are used to communicate additional information about
    -- the result or parameters of a function
    data LlvmParamAttr
      -- | This indicates to the code generator that the parameter or return value
      -- should be zero-extended to a 32-bit value by the caller (for a parameter)
      -- or the callee (for a return value).
      = ZeroExt
      -- | This indicates to the code generator that the parameter or return value
      -- should be sign-extended to a 32-bit value by the caller (for a parameter)
      -- or the callee (for a return value).
      | SignExt
      -- | This indicates that this parameter or return value should be treated in
      -- a special target-dependent fashion during while emitting code for a
      -- function call or return (usually, by putting it in a register as opposed
      -- to memory).
      | InReg
      -- | This indicates that the pointer parameter should really be passed by
      -- value to the function.
      | ByVal
      -- | This indicates that the pointer parameter specifies the address of a
      -- structure that is the return value of the function in the source program.
      | SRet
      -- | This indicates that the pointer does not alias any global or any other
      -- parameter.
      | NoAlias
      -- | This indicates that the callee does not make any copies of the pointer
      -- that outlive the callee itself
      | NoCapture
      -- | This indicates that the pointer parameter can be excised using the
      -- trampoline intrinsics.
      | Nest
      deriving (Eq)

    instance Outputable LlvmParamAttr where
      ppr ZeroExt   = text "zeroext"
      ppr SignExt   = text "signext"
      ppr InReg     = text "inreg"
      ppr ByVal     = text "byval"
      ppr SRet      = text "sret"
      ppr NoAlias   = text "noalias"
      ppr NoCapture = text "nocapture"
      ppr Nest      = text "nest"

    -- | Llvm Function Attributes.
    --
    -- Function attributes are set to communicate additional information about a
    -- function. Function attributes are considered to be part of the function,
    -- not of the function type, so functions with different parameter attributes
    -- can have the same function type. Functions can have multiple attributes.
    --
    -- Descriptions taken from <http://llvm.org/docs/LangRef.html#fnattrs>
    data LlvmFuncAttr
      -- | This attribute indicates that the inliner should attempt to inline this
      -- function into callers whenever possible, ignoring any active inlining
      -- size threshold for this caller.
      = AlwaysInline
      -- | This attribute indicates that the source code contained a hint that
      -- inlining this function is desirable (such as the \"inline\" keyword in
      -- C/C++). It is just a hint; it imposes no requirements on the inliner.
      | InlineHint
      -- | This attribute indicates that the inliner should never inline this
      -- function in any situation. This attribute may not be used together
      -- with the alwaysinline attribute.
      | NoInline
      -- | This attribute suggests that optimization passes and code generator
      -- passes make choices that keep the code size of this function low, and
      -- otherwise do optimizations specifically to reduce code size.
      | OptSize
      -- | This function attribute indicates that the function never returns
      -- normally. This produces undefined behavior at runtime if the function
      -- ever does dynamically return.
      | NoReturn
      -- | This function attribute indicates that the function never returns with
      -- an unwind or exceptional control flow. If the function does unwind, its
      -- runtime behavior is undefined.
      | NoUnwind
      -- | This attribute indicates that the function computes its result (or
      -- decides to unwind an exception) based strictly on its arguments, without
      -- dereferencing any pointer arguments or otherwise accessing any mutable
      -- state (e.g. memory, control registers, etc) visible to caller functions.
      -- It does not write through any pointer arguments (including byval
      -- arguments) and never changes any state visible to callers. This means
      -- that it cannot unwind exceptions by calling the C++ exception throwing
      -- methods, but could use the unwind instruction.
      | ReadNone
      -- | This attribute indicates that the function does not write through any
      -- pointer arguments (including byval arguments) or otherwise modify any
      -- state (e.g. memory, control registers, etc) visible to caller functions.
      -- It may dereference pointer arguments and read state that may be set in
      -- the caller. A readonly function always returns the same value (or unwinds
      -- an exception identically) when called with the same set of arguments and
      -- global state. It cannot unwind an exception by calling the C++ exception
      -- throwing methods, but may use the unwind instruction.
      | ReadOnly
      -- | This attribute indicates that the function should emit a stack smashing
      -- protector. It is in the form of a \"canary\"—a random value placed on the
      -- stack before the local variables that's checked upon return from the
      -- function to see if it has been overwritten. A heuristic is used to
      -- determine if a function needs stack protectors or not.
      --
      -- If a function that has an ssp attribute is inlined into a function that
      -- doesn't have an ssp attribute, then the resulting function will have an
      -- ssp attribute.
      | Ssp
      -- | This attribute indicates that the function should always emit a stack
      -- smashing protector. This overrides the ssp function attribute.
      --
      -- If a function that has an sspreq attribute is inlined into a function
      -- that doesn't have an sspreq attribute or which has an ssp attribute,
      -- then the resulting function will have an sspreq attribute.
      | SspReq
      -- | This attribute indicates that the code generator should not use a red
      -- zone, even if the target-specific ABI normally permits it.
      | NoRedZone
      -- | This attributes disables implicit floating point instructions.
      | NoImplicitFloat
      -- | This attribute disables prologue / epilogue emission for the function.
      -- This can have very system-specific consequences.
      | Naked
      deriving (Eq)

    instance Outputable LlvmFuncAttr where
      ppr AlwaysInline       = text "alwaysinline"
      ppr InlineHint         = text "inlinehint"
      ppr NoInline           = text "noinline"
      ppr OptSize            = text "optsize"
      ppr NoReturn           = text "noreturn"
      ppr NoUnwind           = text "nounwind"
      ppr ReadNone           = text "readnon"
      ppr ReadOnly           = text "readonly"
      ppr Ssp                = text "ssp"
      ppr SspReq             = text "ssqreq"
      ppr NoRedZone          = text "noredzone"
      ppr NoImplicitFloat    = text "noimplicitfloat"
      ppr Naked              = text "naked"

    -- | Different types to call a function.
    data LlvmCallType
      -- | Normal call, allocate a new stack frame.
      = StdCall
      -- | Tail call, perform the call in the current stack frame.
      | TailCall
      deriving (Eq,Show)

    -- | Different calling conventions a function can use.
    data LlvmCallConvention
      -- | The C calling convention.
      -- This calling convention (the default if no other calling convention is
      -- specified) matches the target C calling conventions. This calling
      -- convention supports varargs function calls and tolerates some mismatch in
      -- the declared prototype and implemented declaration of the function (as
      -- does normal C).
      = CC_Ccc
      -- | This calling convention attempts to make calls as fast as possible
      -- (e.g. by passing things in registers). This calling convention allows
      -- the target to use whatever tricks it wants to produce fast code for the
      -- target, without having to conform to an externally specified ABI
      -- (Application Binary Interface). Implementations of this convention should
      -- allow arbitrary tail call optimization to be supported. This calling
      -- convention does not support varargs and requires the prototype of al
      -- callees to exactly match the prototype of the function definition.
      | CC_Fastcc
      -- | This calling convention attempts to make code in the caller as efficient
      -- as possible under the assumption that the call is not commonly executed.
      -- As such, these calls often preserve all registers so that the call does
      -- not break any live ranges in the caller side. This calling convention
      -- does not support varargs and requires the prototype of all callees to
      -- exactly match the prototype of the function definition.
      | CC_Coldcc
      -- | The GHC-specific 'registerised' calling convention.
      | CC_Ghc
      -- | Any calling convention may be specified by number, allowing
      -- target-specific calling conventions to be used. Target specific calling
      -- conventions start at 64.
      | CC_Ncc Int
      -- | X86 Specific 'StdCall' convention. LLVM includes a specific alias for it
      -- rather than just using CC_Ncc.
      | CC_X86_Stdcc
      deriving (Eq)

    instance Outputable LlvmCallConvention where
      ppr CC_Ccc       = text "ccc"
      ppr CC_Fastcc    = text "fastcc"
      ppr CC_Coldcc    = text "coldcc"
      ppr CC_Ghc       = text "ghccc"
      ppr (CC_Ncc i)   = text "cc " <> ppr i
      ppr CC_X86_Stdcc = text "x86_stdcallcc"

    -- | Functions can have a fixed amount of parameters, or a variable amount.
    data LlvmParameterListType
      -- Fixed amount of arguments.
      = FixedArgs
      -- Variable amount of arguments.
      | VarArgs
      deriving (Eq,Show)

    -- | Linkage type of a symbol.
    --
    -- The description of the constructors is copied from the Llvm Assembly Language
    -- Reference Manual <http://www.llvm.org/docs/LangRef.html#linkage>, because
    -- they correspond to the Llvm linkage types.
    data LlvmLinkageType
      -- | Global values with internal linkage are only directly accessible by
      -- objects in the current module. In particular, linking code into a module
      -- with an internal global value may cause the internal to be renamed as
      -- necessary to avoid collisions. Because the symbol is internal to the
      -- module, all references can be updated. This corresponds to the notion
      -- of the @static@ keyword in C.
      = Internal
      -- | Globals with @linkonce@ linkage are merged with other globals of the
      -- same name when linkage occurs. This is typically used to implement
      -- inline functions, templates, or other code which must be generated
      -- in each translation unit that uses it. Unreferenced linkonce globals are
      -- allowed to be discarded.
      | LinkOnce
      -- | @weak@ linkage is exactly the same as linkonce linkage, except that
      -- unreferenced weak globals may not be discarded. This is used for globals
      -- that may be emitted in multiple translation units, but that are not
      -- guaranteed to be emitted into every translation unit that uses them. One
      -- example of this are common globals in C, such as @int X;@ at global
      -- scope.
      | Weak
      -- | @appending@ linkage may only be applied to global variables of pointer
      -- to array type. When two global variables with appending linkage are
      -- linked together, the two global arrays are appended together. This is
      -- the Llvm, typesafe, equivalent of having the system linker append
      -- together @sections@ with identical names when .o files are linked.
      | Appending
      -- | The semantics of this linkage follow the ELF model: the symbol is weak
      -- until linked, if not linked, the symbol becomes null instead of being an
      -- undefined reference.
      | ExternWeak
      -- | The symbol participates in linkage and can be used to resolve external
      --  symbol references.
      | ExternallyVisible
      -- | Alias for 'ExternallyVisible' but with explicit textual form in LLVM
      --  assembly.
      | External
      -- | Symbol is private to the module and should not appear in the symbol table
      | Private
      deriving (Eq)

    instance Outputable LlvmLinkageType where
      ppr Internal          = text "internal"
      ppr LinkOnce          = text "linkonce"
      ppr Weak              = text "weak"
      ppr Appending         = text "appending"
      ppr ExternWeak        = text "extern_weak"
      -- ExternallyVisible does not have a textual representation, it is
      -- the linkage type a function resolves to if no other is specified
      -- in Llvm.
      ppr ExternallyVisible = empty
      ppr External          = text "external"
      ppr Private           = text "private"

    -- -----------------------------------------------------------------------------
    -- * LLVM Operations
    --

    -- | Llvm binary operators machine operations.
    data LlvmMachOp
      = LM_MO_Add  -- ^ add two integer, floating point or vector values.
      | LM_MO_Sub  -- ^ subtract two ...
      | LM_MO_Mul  -- ^ multiply ..
      | LM_MO_UDiv -- ^ unsigned integer or vector division.
      | LM_MO_SDiv -- ^ signed integer ..
      | LM_MO_URem -- ^ unsigned integer or vector remainder (mod)
      | LM_MO_SRem -- ^ signed ...

      | LM_MO_FAdd -- ^ add two floating point or vector values.
      | LM_MO_FSub -- ^ subtract two ...
      | LM_MO_FMul -- ^ multiply ...
      | LM_MO_FDiv -- ^ divide ...
      | LM_MO_FRem -- ^ remainder ...

      -- | Left shift
      | LM_MO_Shl
      -- | Logical shift right
      -- Shift right, filling with zero
      | LM_MO_LShr
      -- | Arithmetic shift right
      -- The most significant bits of the result will be equal to the sign bit of
      -- the left operand.
      | LM_MO_AShr

      | LM_MO_And -- ^ AND bitwise logical operation.
      | LM_MO_Or  -- ^ OR bitwise logical operation.
      | LM_MO_Xor -- ^ XOR bitwise logical operation.
      deriving (Eq)

    instance Outputable LlvmMachOp where
      ppr LM_MO_Add  = text "add"
      ppr LM_MO_Sub  = text "sub"
      ppr LM_MO_Mul  = text "mul"
      ppr LM_MO_UDiv = text "udiv"
      ppr LM_MO_SDiv = text "sdiv"
      ppr LM_MO_URem = text "urem"
      ppr LM_MO_SRem = text "srem"
      ppr LM_MO_FAdd = text "fadd"
      ppr LM_MO_FSub = text "fsub"
      ppr LM_MO_FMul = text "fmul"
      ppr LM_MO_FDiv = text "fdiv"
      ppr LM_MO_FRem = text "frem"
      ppr LM_MO_Shl  = text "shl"
      ppr LM_MO_LShr = text "lshr"
      ppr LM_MO_AShr = text "ashr"
      ppr LM_MO_And  = text "and"
      ppr LM_MO_Or   = text "or"
      ppr LM_MO_Xor  = text "xor"

    -- | Llvm compare operations.
    data LlvmCmpOp
      = LM_CMP_Eq  -- ^ Equal (Signed and Unsigned)
      | LM_CMP_Ne  -- ^ Not equal (Signed and Unsigned)
      | LM_CMP_Ugt -- ^ Unsigned greater than
      | LM_CMP_Uge -- ^ Unsigned greater than or equal
      | LM_CMP_Ult -- ^ Unsigned less than
      | LM_CMP_Ule -- ^ Unsigned less than or equal
      | LM_CMP_Sgt -- ^ Signed greater than
      | LM_CMP_Sge -- ^ Signed greater than or equal
      | LM_CMP_Slt -- ^ Signed less than
      | LM_CMP_Sle -- ^ Signed less than or equal

      -- Float comparisons. GHC uses a mix of ordered and unordered float
      -- comparisons.
      | LM_CMP_Feq -- ^ Float equal
      | LM_CMP_Fne -- ^ Float not equal
      | LM_CMP_Fgt -- ^ Float greater than
      | LM_CMP_Fge -- ^ Float greater than or equal
      | LM_CMP_Flt -- ^ Float less than
      | LM_CMP_Fle -- ^ Float less than or equal
      deriving (Eq)

    instance Outputable LlvmCmpOp where
      ppr LM_CMP_Eq  = text "eq"
      ppr LM_CMP_Ne  = text "ne"
      ppr LM_CMP_Ugt = text "ugt"
      ppr LM_CMP_Uge = text "uge"
      ppr LM_CMP_Ult = text "ult"
      ppr LM_CMP_Ule = text "ule"
      ppr LM_CMP_Sgt = text "sgt"
      ppr LM_CMP_Sge = text "sge"
      ppr LM_CMP_Slt = text "slt"
      ppr LM_CMP_Sle = text "sle"
      ppr LM_CMP_Feq = text "oeq"
      ppr LM_CMP_Fne = text "une"
      ppr LM_CMP_Fgt = text "ogt"
      ppr LM_CMP_Fge = text "oge"
      ppr LM_CMP_Flt = text "olt"
      ppr LM_CMP_Fle = text "ole"

    -- | Llvm cast operations.
    data LlvmCastOp
      = LM_Trunc    -- ^ Integer truncate
      | LM_Zext     -- ^ Integer extend (zero fill)
      | LM_Sext     -- ^ Integer extend (sign fill)
      | LM_Fptrunc  -- ^ Float truncate
      | LM_Fpext    -- ^ Float extend
      | LM_Fptoui   -- ^ Float to unsigned Integer
      | LM_Fptosi   -- ^ Float to signed Integer
      | LM_Uitofp   -- ^ Unsigned Integer to Float
      | LM_Sitofp   -- ^ Signed Int to Float
      | LM_Ptrtoint -- ^ Pointer to Integer
      | LM_Inttoptr -- ^ Integer to Pointer
      | LM_Bitcast  -- ^ Cast between types where no bit manipulation is needed
      deriving (Eq)

    instance Outputable LlvmCastOp where
      ppr LM_Trunc    = text "trunc"
      ppr LM_Zext     = text "zext"
      ppr LM_Sext     = text "sext"
      ppr LM_Fptrunc  = text "fptrunc"
      ppr LM_Fpext    = text "fpext"
      ppr LM_Fptoui   = text "fptoui"
      ppr LM_Fptosi   = text "fptosi"
      ppr LM_Uitofp   = text "uitofp"
      ppr LM_Sitofp   = text "sitofp"
      ppr LM_Ptrtoint = text "ptrtoint"
      ppr LM_Inttoptr = text "inttoptr"
      ppr LM_Bitcast  = text "bitcast"

    -- -----------------------------------------------------------------------------
    -- * Floating point conversion
    --

    -- | Convert a Haskell Double to an LLVM hex encoded floating point form. In
    -- Llvm float literals can be printed in a big-endian hexadecimal format,
    -- regardless of underlying architecture.
    --
    -- See Note [LLVM Float Types].
    ppDouble :: Double -> SDoc
    ppDouble d
      = let bs     = doubleToBytes d
            hex d' = case showHex d' "" of
                         []    -> error "dToStr: too few hex digits for float"
                         [x]   -> ['0',x]
                         [x,y] -> [x,y]
                         _     -> error "dToStr: too many hex digits for float"

            str  = map toUpper $ concat $ fixEndian $ map hex bs
        in  text "0x" <> text str

    -- Note [LLVM Float Types]
    -- ~~~~~~~~~~~~~~~~~~~~~~~
    -- We use 'ppDouble' for both printing Float and Double floating point types. This is
    -- as LLVM expects all floating point constants (single & double) to be in IEEE
    -- 754 Double precision format. However, for single precision numbers (Float)
    -- they should be *representable* in IEEE 754 Single precision format. So the
    -- easiest way to do this is to narrow and widen again.
    -- (i.e., Double -> Float -> Double). We must be careful doing this that GHC
    -- doesn't optimize that away.

    -- Note [narrowFp & widenFp]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~
    -- NOTE: we use float2Double & co directly as GHC likes to optimize away
    -- successive calls of 'realToFrac', defeating the narrowing. (Bug #7600).
    -- 'realToFrac' has inconsistent behaviour with optimisation as well that can
    -- also cause issues, these methods don't.

    narrowFp :: Double -> Float
    {-# NOINLINE narrowFp #-}
    narrowFp = double2Float

    widenFp :: Float -> Double
    {-# NOINLINE widenFp #-}
    widenFp = float2Double

    ppFloat :: Float -> SDoc
    ppFloat = ppDouble . widenFp

    -- | Reverse or leave byte data alone to fix endianness on this target.
    fixEndian :: [a] -> [a]
    #ifdef WORDS_BIGENDIAN
    fixEndian = id
    #else
    fixEndian = reverse
    #endif

    --------------------------------------------------------------------------------
    -- * Misc functions
    --------------------------------------------------------------------------------

    ppCommaJoin :: (Outputable a) => [a] -> SDoc
    ppCommaJoin strs = hsep $ punctuate comma (map ppr strs)

    ppSpaceJoin :: (Outputable a) => [a] -> SDoc
    ppSpaceJoin strs = hsep (map ppr strs)