    {-
    (c) The GRASP/AQUA Project, Glasgow University, 1992-1998

    \section[PrimOp]{Primitive operations (machine-level)}
    -}

    {-# LANGUAGE CPP #-}
    {-# LANGUAGE LambdaCase #-}

    module GHC.Builtin.PrimOps (
            PrimOp(..), PrimOpVecCat(..), allThePrimOps,
            primOpType, primOpSig, primOpResultType,
            primOpTag, maxPrimOpTag, primOpOcc,
            primOpWrapperId,
            pprPrimOp,

            tagToEnumKey,

            primOpOutOfLine, primOpCodeSize,
            primOpOkForSpeculation, primOpOkToDiscard,
            primOpIsWorkFree, primOpIsCheap, primOpFixity, primOpDocs, primOpDeprecations,
            primOpIsDiv, primOpIsReallyInline,

            PrimOpEffect(..), primOpEffect,

            getPrimOpResultInfo,  isComparisonPrimOp, PrimOpResultInfo(..),

            PrimCall(..)
        ) where

    import GHC.Prelude

    import GHC.Builtin.Types.Prim
    import GHC.Builtin.Types
    import GHC.Builtin.Uniques (mkPrimOpIdUnique, mkPrimOpWrapperUnique )
    import GHC.Builtin.Names ( gHC_PRIMOPWRAPPERS )

    import GHC.Core.TyCon    ( isPrimTyCon, isUnboxedTupleTyCon, PrimRep(..) )
    import GHC.Core.Type

    import GHC.Cmm.Type

    import GHC.Types.Demand
    import GHC.Types.Id
    import GHC.Types.Id.Info
    import GHC.Types.Name
    import GHC.Types.RepType ( tyConPrimRep )
    import GHC.Types.Basic
    import GHC.Types.Fixity  ( Fixity(..), FixityDirection(..) )
    import GHC.Types.SrcLoc  ( wiredInSrcSpan )
    import GHC.Types.ForeignCall ( CLabelString )
    import GHC.Types.Unique  ( Unique )

    import GHC.Unit.Types    ( Unit )

    import GHC.Utils.Outputable
    import GHC.Utils.Panic

    import GHC.Data.FastString

    {-
    ************************************************************************
    *                                                                      *
    \subsection[PrimOp-datatype]{Datatype for @PrimOp@ (an enumeration)}
    *                                                                      *
    ************************************************************************

    These are in \tr{state-interface.verb} order.
    -}

    -- supplies:
    -- data PrimOp = ...
    #include "primop-data-decl.hs-incl"

    -- supplies
    -- primOpTag :: PrimOp -> Int
    #include "primop-tag.hs-incl"
    primOpTag PrimOp
    _ = [Char] -> Int
    forall a. HasCallStack => [Char] -> a
    error [Char]
    "primOpTag: unknown primop"

    instance Eq PrimOp where
        PrimOp
    op1 == :: PrimOp -> PrimOp -> Bool
    == PrimOp
    op2 = PrimOp -> Int
    primOpTag PrimOp
    op1 Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == PrimOp -> Int
    primOpTag PrimOp
    op2

    instance Ord PrimOp where
        PrimOp
    op1 < :: PrimOp -> PrimOp -> Bool
    <  PrimOp
    op2 =  PrimOp -> Int
    primOpTag PrimOp
    op1 Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < PrimOp -> Int
    primOpTag PrimOp
    op2
        PrimOp
    op1 <= :: PrimOp -> PrimOp -> Bool
    <= PrimOp
    op2 =  PrimOp -> Int
    primOpTag PrimOp
    op1 Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= PrimOp -> Int
    primOpTag PrimOp
    op2
        PrimOp
    op1 >= :: PrimOp -> PrimOp -> Bool
    >= PrimOp
    op2 =  PrimOp -> Int
    primOpTag PrimOp
    op1 Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= PrimOp -> Int
    primOpTag PrimOp
    op2
        PrimOp
    op1 > :: PrimOp -> PrimOp -> Bool
    >  PrimOp
    op2 =  PrimOp -> Int
    primOpTag PrimOp
    op1 Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > PrimOp -> Int
    primOpTag PrimOp
    op2
        PrimOp
    op1 compare :: PrimOp -> PrimOp -> Ordering
    `compare` PrimOp
    op2 | PrimOp
    op1 PrimOp -> PrimOp -> Bool
    forall a. Ord a => a -> a -> Bool
    < PrimOp
    op2  = Ordering
    LT
                          | PrimOp
    op1 PrimOp -> PrimOp -> Bool
    forall a. Eq a => a -> a -> Bool
    == PrimOp
    op2 = Ordering
    EQ
                          | Bool
    otherwise  = Ordering
    GT

    instance Outputable PrimOp where
        ppr :: PrimOp -> SDoc
    ppr PrimOp
    op = PrimOp -> SDoc
    forall doc. IsLine doc => PrimOp -> doc
    pprPrimOp PrimOp
    op

    data PrimOpVecCat = IntVec
                      | WordVec
                      | FloatVec

    -- An @Enum@-derived list would be better; meanwhile... (ToDo)

    allThePrimOps :: [PrimOp]
    [PrimOp]
    allThePrimOps =
    #include "primop-list.hs-incl"

    tagToEnumKey :: Unique
    tagToEnumKey :: Unique
    tagToEnumKey = Int -> Unique
    mkPrimOpIdUnique (PrimOp -> Int
    primOpTag PrimOp
    TagToEnumOp)

    {-
    ************************************************************************
    *                                                                      *
    \subsection[PrimOp-info]{The essential info about each @PrimOp@}
    *                                                                      *
    ************************************************************************
    -}

    data PrimOpInfo
      = Compare     OccName         -- string :: T -> T -> Int#
                    Type
      | GenPrimOp   OccName         -- string :: \/a1..an . T1 -> .. -> Tk -> T
                    [TyVarBinder]
                    [Type]
                    Type

    mkCompare :: FastString -> Type -> PrimOpInfo
    mkCompare :: FastString -> Type -> PrimOpInfo
    mkCompare FastString
    str Type
    ty = OccName -> Type -> PrimOpInfo
    Compare (FastString -> OccName
    mkVarOccFS FastString
    str) Type
    ty

    mkGenPrimOp :: FastString -> [TyVarBinder] -> [Type] -> Type -> PrimOpInfo
    mkGenPrimOp :: FastString -> [TyVarBinder] -> [Type] -> Type -> PrimOpInfo
    mkGenPrimOp FastString
    str [TyVarBinder]
    tvs [Type]
    tys Type
    ty = OccName -> [TyVarBinder] -> [Type] -> Type -> PrimOpInfo
    GenPrimOp (FastString -> OccName
    mkVarOccFS FastString
    str) [TyVarBinder]
    tvs [Type]
    tys Type
    ty

    {-
    ************************************************************************
    *                                                                      *
    \subsubsection{Strictness}
    *                                                                      *
    ************************************************************************

    Not all primops are strict!
    -}

    primOpStrictness :: PrimOp -> Arity -> DmdSig
            -- See Demand.DmdSig for discussion of what the results
            -- The arity should be the arity of the primop; that's why
            -- this function isn't exported.
    #include "primop-strictness.hs-incl"

    {-
    ************************************************************************
    *                                                                      *
    \subsubsection{Fixity}
    *                                                                      *
    ************************************************************************
    -}

    primOpFixity :: PrimOp -> Maybe Fixity
    #include "primop-fixity.hs-incl"

    {-
    ************************************************************************
    *                                                                      *
    \subsubsection{Docs}
    *                                                                      *
    ************************************************************************

    See Note [GHC.Prim Docs] in GHC.Builtin.Utils
    -}

    primOpDocs :: [(FastString, String)]
    #include "primop-docs.hs-incl"

    primOpDeprecations :: [(OccName, FastString)]
    #include "primop-deprecations.hs-incl"

    {-
    ************************************************************************
    *                                                                      *
    \subsubsection[PrimOp-comparison]{PrimOpInfo basic comparison ops}
    *                                                                      *
    ************************************************************************

    @primOpInfo@ gives all essential information (from which everything
    else, notably a type, can be constructed) for each @PrimOp@.
    -}

    primOpInfo :: PrimOp -> PrimOpInfo
    #include "primop-primop-info.hs-incl"
    primOpInfo PrimOp
    _ = [Char] -> PrimOpInfo
    forall a. HasCallStack => [Char] -> a
    error [Char]
    "primOpInfo: unknown primop"

    {-
    Here are a load of comments from the old primOp info:

    A @Word#@ is an unsigned @Int#@.

    @decodeFloat#@ is given w/ Integer-stuff (it's similar).

    @decodeDouble#@ is given w/ Integer-stuff (it's similar).

    Decoding of floating-point numbers is sorta Integer-related.  Encoding
    is done with plain ccalls now (see PrelNumExtra.hs).

    A @Weak@ Pointer is created by the @mkWeak#@ primitive:

            mkWeak# :: k -> v -> f -> State# RealWorld
                            -> (# State# RealWorld, Weak# v #)

    In practice, you'll use the higher-level

            data Weak v = Weak# v
            mkWeak :: k -> v -> IO () -> IO (Weak v)

    The following operation dereferences a weak pointer.  The weak pointer
    may have been finalized, so the operation returns a result code which
    must be inspected before looking at the dereferenced value.

            deRefWeak# :: Weak# v -> State# RealWorld ->
                            (# State# RealWorld, v, Int# #)

    Only look at v if the Int# returned is /= 0 !!

    The higher-level op is

            deRefWeak :: Weak v -> IO (Maybe v)

    Weak pointers can be finalized early by using the finalize# operation:

            finalizeWeak# :: Weak# v -> State# RealWorld ->
                               (# State# RealWorld, Int#, IO () #)

    The Int# returned is either

            0 if the weak pointer has already been finalized, or it has no
              finalizer (the third component is then invalid).

            1 if the weak pointer is still alive, with the finalizer returned
              as the third component.

    A {\em stable name/pointer} is an index into a table of stable name
    entries.  Since the garbage collector is told about stable pointers,
    it is safe to pass a stable pointer to external systems such as C
    routines.

    \begin{verbatim}
    makeStablePtr#  :: a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)
    freeStablePtr   :: StablePtr# a -> State# RealWorld -> State# RealWorld
    deRefStablePtr# :: StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)
    eqStablePtr#    :: StablePtr# a -> StablePtr# a -> Int#
    \end{verbatim}

    It may seem a bit surprising that @makeStablePtr#@ is a @IO@
    operation since it doesn't (directly) involve IO operations.  The
    reason is that if some optimisation pass decided to duplicate calls to
    @makeStablePtr#@ and we only pass one of the stable pointers over, a
    massive space leak can result.  Putting it into the IO monad
    prevents this.  (Another reason for putting them in a monad is to
    ensure correct sequencing wrt the side-effecting @freeStablePtr@
    operation.)

    An important property of stable pointers is that if you call
    makeStablePtr# twice on the same object you get the same stable
    pointer back.

    Note that we can implement @freeStablePtr#@ using @_ccall_@ (and,
    besides, it's not likely to be used from Haskell) so it's not a
    primop.

    Question: Why @RealWorld@ - won't any instance of @_ST@ do the job? [ADR]

    Stable Names
    ~~~~~~~~~~~~

    A stable name is like a stable pointer, but with three important differences:

            (a) You can't deRef one to get back to the original object.
            (b) You can convert one to an Int.
            (c) You don't need to 'freeStableName'

    The existence of a stable name doesn't guarantee to keep the object it
    points to alive (unlike a stable pointer), hence (a).

    Invariants:

            (a) makeStableName always returns the same value for a given
                object (same as stable pointers).

            (b) if two stable names are equal, it implies that the objects
                from which they were created were the same.

            (c) stableNameToInt always returns the same Int for a given
                stable name.

    These primops are pretty weird.

            tagToEnum# :: Int -> a    (result type must be an enumerated type)

    The constraints aren't currently checked by the front end, but the
    code generator will fall over if they aren't satisfied.

    ************************************************************************
    *                                                                      *
                Which PrimOps are out-of-line
    *                                                                      *
    ************************************************************************

    Some PrimOps need to be called out-of-line because they either need to
    perform a heap check or they block.
    -}

    primOpOutOfLine :: PrimOp -> Bool
    #include "primop-out-of-line.hs-incl"

    {-
    ************************************************************************
    *                                                                      *
                Failure and side effects
    *                                                                      *
    ************************************************************************

    Note [Exceptions: asynchronous, synchronous, and unchecked]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    There are three very different sorts of things in GHC-Haskell that are
    sometimes called exceptions:

    * Haskell exceptions:

      These are ordinary exceptions that users can raise with the likes
      of 'throw' and handle with the likes of 'catch'.  They come in two
      very different flavors:

      * Asynchronous exceptions:
        * These can arise at nearly any time, and may have nothing to do
          with the code being executed.
        * The compiler itself mostly doesn't need to care about them.
        * Examples: a signal from another process, running out of heap or stack
        * Even pure code can receive asynchronous exceptions; in this
          case, executing the same code again may lead to different
          results, because the exception may not happen next time.
        * See rts/RaiseAsync.c for the gory details of how they work.

      * Synchronous exceptions:
        * These are produced by the code being executed, most commonly via
          a call to the `raise#` or `raiseIO#` primops.
        * At run-time, if a piece of pure code raises a synchronous
          exception, it will always raise the same synchronous exception
          if it is run again (and not interrupted by an asynchronous
          exception).
        * In particular, if an updatable thunk does some work and then
          raises a synchronous exception, it is safe to overwrite it with
          a thunk that /immediately/ raises the same exception.
        * Although we are careful not to discard synchronous exceptions, we
          are very liberal about re-ordering them with respect to most other
          operations.  See the paper "A semantics for imprecise exceptions"
          as well as Note [Precise exceptions and strictness analysis] in
          GHC.Types.Demand.

    * Unchecked exceptions:

      * These are nasty failures like seg-faults or primitive Int# division
        by zero.  They differ from Haskell exceptions in that they are
        un-recoverable and typically bring execution to an immediate halt.
      * We generally treat unchecked exceptions as undefined behavior, on
        the assumption that the programmer never intends to crash the
        program in this way.  Thus we have no qualms about replacing a
        division-by-zero with a recoverable Haskell exception or
        discarding an indexArray# operation whose result is unused.

    Note [Classifying primop effects]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Each primop has an associated 'PrimOpEffect', based on what that
    primop can or cannot do at runtime.  This classification is

    * Recorded in the 'effect' field in primops.txt.pp, and
    * Exposed to the compiler via the 'primOpEffect' function in this module.

    See Note [Transformations affected by primop effects] for how we make
    use of this categorisation.

    The meanings of the four constructors of 'PrimOpEffect' are as
    follows, in decreasing order of permissiveness:

    * ReadWriteEffect
        A primop is marked ReadWriteEffect if it can
        - read or write to the world (I/O), or
        - read or write to a mutable data structure (e.g. readMutVar#).

        Every such primop uses State# tokens for sequencing, with a type like:
          Inputs -> State# s -> (# State# s, Outputs #)
        The state token threading expresses ordering, but duplicating even
        a read-only effect would defeat this.  (See "duplication" under
        Note [Transformations affected by primop effects] for details.)

        Note that operations like `indexArray#` that read *immutable*
        data structures do not need such special sequencing-related care,
        and are therefore not marked ReadWriteEffect.

    * ThrowsException
        A primop is marked ThrowsException if
        - it is not marked ReadWriteEffect, and
        - it may diverge or throw a synchronous Haskell exception
          even when used in a "correct" and well-specified way.

        See also Note [Exceptions: asynchronous, synchronous, and unchecked].
        Examples include raise#, raiseIO#, dataToTagLarge#, and seq#.

        Note that whether an exception is considered precise or imprecise
        does not matter for the purposes of the PrimOpEffect flag.

    * CanFail
        A primop is marked CanFail if
        - it is not marked ReadWriteEffect or ThrowsException, and
        - it can trigger a (potentially-unchecked) exception when used incorrectly.

        See Note [Exceptions: asynchronous, synchronous, and unchecked].
        Examples include quotWord# and indexIntArray#, which can fail with
        division-by-zero and a segfault respectively.

        A correct use of a CanFail primop is usually surrounded by a test
        that screens out the bad cases such as a zero divisor or an
        out-of-bounds array index.  We must take care never to move a
        CanFail primop outside the scope of such a test.

    * NoEffect
        A primop is marked NoEffect if it does not belong to any of the
        other three categories.  We can very aggressively shuffle these
        operations around without fear of changing a program's meaning.

        Perhaps surprisingly, this aggressive shuffling imposes another
        restriction: The tricky NoEffect primop uncheckedShiftLWord32# has
        an undefined result when the provided shift amount is not between
        0 and 31.  Thus, a call like `uncheckedShiftLWord32# x 95#` is
        obviously invalid.  But since uncheckedShiftLWord32# is marked
        NoEffect, we may float such an invalid call out of a dead branch
        and speculatively evaluate it.

        In particular, we cannot safely rewrite such an invalid call to a
        runtime error; we must emit code that produces a valid Word32#.
        (If we're lucky, Core Lint may complain that the result of such a
        rewrite violates the let-can-float invariant (#16742), but the
        rewrite is always wrong!)  See also Note [Guarding against silly shifts]
        in GHC.Core.Opt.ConstantFold.

        Marking uncheckedShiftLWord32# as CanFail instead of NoEffect
        would give us the freedom to rewrite such invalid calls to runtime
        errors, but would get in the way of optimization: When speculatively
        executing a bit-shift prevents the allocation of a thunk, that's a
        big win.

    Note [Transformations affected by primop effects]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    The PrimOpEffect properties have the following effect on program
    transformations.  The summary table is followed by details.  See also
    Note [Classifying primop effects] for exactly what each column means.

                        NoEffect    CanFail    ThrowsException    ReadWriteEffect
    Discard                YES        YES            NO                 NO
    Defer (float in)       YES        YES           SAFE               SAFE
    Speculate (float out)  YES        NO             NO                 NO
    Duplicate              YES        YES            YES                NO

    (SAFE means we could perform the transformation but do not.)

    * Discarding:   case (a `op` b) of _ -> rhs  ===>   rhs
        You should not discard a ReadWriteEffect primop; e.g.
           case (writeIntArray# a i v s of (# _, _ #) -> True
        One could argue in favor of discarding this, since the returned
        State# token is not used.  But in practice unsafePerformIO can
        easily produce similar code, and programmers sometimes write this
        kind of stuff by hand (#9390).  So we (conservatively) never discard
        a ReadWriteEffect primop.

          Digression: We could try to track read-only effects separately
          from write effects to allow the former to be discarded.  But in
          fact we want a more general rewrite for read-only operations:
            case readOp# state# of (# newState#, _unused_result #) -> body
            ==> case state# of newState# -> body
          Such a rewrite is not yet implemented, but would have to be done
          in a different place anyway.

        Discarding a ThrowsException primop would also discard any exception
        it might have thrown.  For `raise#` or `raiseIO#` this would defeat
        the whole point of the primop, while for `dataToTagLarge#` or `seq#`
        this would make programs unexpectly lazier.

        However, it's fine to discard a CanFail primop.  For example
           case (indexIntArray# a i) of _ -> True
        We can discard indexIntArray# here; this came up in #5658.  Notice
        that CanFail primops like indexIntArray# can only trigger an
        exception when used incorrectly, i.e. a call that might not succeed
        is undefined behavior anyway.

    * Deferring (float-in):
        See Note [Floating primops] in GHC.Core.Opt.FloatIn.

        In the absence of data dependencies (including state token threading),
        we reserve the right to re-order the following things arbitrarily:
          * Side effects
          * Imprecise exceptions
          * Divergent computations (infinite loops)
        This lets us safely float almost any primop *inwards*, but not
        inside a (multi-shot) lambda.  (See "Duplication" below.)

        However, the main reason to float-in a primop application would be
        to discard it (by floating it into some but not all branches of a
        case), so we actually only float-in NoEffect and CanFail operations.
        See also Note [Floating primops] in GHC.Core.Opt.FloatIn.

        (This automatically side-steps the question of precise exceptions, which
        mustn't be re-ordered arbitrarily but need at least ThrowsException.)

    * Speculation (strict float-out):
        You must not float a CanFail primop *outwards* lest it escape the
        dynamic scope of a run-time validity test.  Example:
          case d ># 0# of
            True  -> case x /# d of r -> r +# 1
            False -> 0
        Here we must not float the case outwards to give
          case x/# d of r ->
          case d ># 0# of
            True  -> r +# 1
            False -> 0
        Otherwise, if this block is reached when d is zero, it will crash.
        Exactly the same reasoning applies to ThrowsException primops.

        Nor can you float out a ReadWriteEffect primop.  For example:
           if blah then case writeMutVar# v True s0 of (# s1 #) -> s1
                   else s0
        Notice that s0 is mentioned in both branches of the 'if', but
        only one of these two will actually be consumed.  But if we
        float out to
          case writeMutVar# v True s0 of (# s1 #) ->
          if blah then s1 else s0
        the writeMutVar will be performed in both branches, which is
        utterly wrong.

        What about a read-only operation that cannot fail, like
        readMutVar#?  In principle we could safely float these out.  But
        there are not very many such operations and it's not clear if
        there are real-world programs that would benefit from this.

    * Duplication:
        You cannot duplicate a ReadWriteEffect primop.  You might wonder
        how this can occur given the state token threading, but just look
        at Control.Monad.ST.Lazy.Imp.strictToLazy!  We get something like this
            p = case readMutVar# s v of
                  (# s', r #) -> (State# s', r)
            s' = case p of (s', r) -> s'
            r  = case p of (s', r) -> r

        (All these bindings are boxed.)  If we inline p at its two call
        sites, we get a catastrophe: because the read is performed once when
        s' is demanded, and once when 'r' is demanded, which may be much
        later.  Utterly wrong.  #3207 is real example of this happening.
        Floating p into a multi-shot lambda would be wrong for the same reason.

        However, it's fine to duplicate a CanFail or ThrowsException primop.

    Note [Implementation: how PrimOpEffect affects transformations]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    How do we ensure that floating/duplication/discarding are done right
    in the simplifier?

    Several predicates on primops test this flag:
      primOpOkToDiscard      <=> effect < ThrowsException
      primOpOkForSpeculation <=> effect == NoEffect && not (out_of_line)
      primOpIsCheap          <=> cheap  -- ...defaults to primOpOkForSpeculation
        [[But note that the raise# family and seq# are also considered cheap in
          GHC.Core.Utils.exprIsCheap by way of being work-free]]

      * The discarding mentioned above happens in
        GHC.Core.Opt.Simplify.Iteration, specifically in rebuildCase,
        where it is guarded by exprOkToDiscard, which in turn checks
        primOpOkToDiscard.

      * The "no-float-out" thing is achieved by ensuring that we never
        let-bind a saturated primop application unless it has NoEffect.
        The RHS of a let-binding (which can float in and out freely)
        satisfies exprOkForSpeculation; this is the let-can-float
        invariant.  And exprOkForSpeculation is false of a saturated
        primop application unless it has NoEffect.

      * So primops that aren't NoEffect will appear only as the
        scrutinees of cases, and that's why the FloatIn pass is capable
        of floating case bindings inwards.

      * Duplication via inlining and float-in of (lifted) let-binders is
        controlled via primOpIsWorkFree and primOpIsCheap, by making
        ReadWriteEffect things (among others) not-cheap!  (The test
        PrimOpEffect_Sanity will complain if any ReadWriteEffect primop
        is considered either work-free or cheap.)  Additionally, a
        case binding is only floated inwards if its scrutinee is ok-to-discard.
    -}

    primOpEffect :: PrimOp -> PrimOpEffect
    #include "primop-effects.hs-incl"

    data PrimOpEffect
      -- See Note [Classifying primop effects]
      = NoEffect
      | CanFail
      | ThrowsException
      | ReadWriteEffect
      deriving (PrimOpEffect -> PrimOpEffect -> Bool
    (PrimOpEffect -> PrimOpEffect -> Bool)
    -> (PrimOpEffect -> PrimOpEffect -> Bool) -> Eq PrimOpEffect
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PrimOpEffect -> PrimOpEffect -> Bool
    == :: PrimOpEffect -> PrimOpEffect -> Bool
    $c/= :: PrimOpEffect -> PrimOpEffect -> Bool
    /= :: PrimOpEffect -> PrimOpEffect -> Bool
    Eq, Eq PrimOpEffect
    Eq PrimOpEffect =>
    (PrimOpEffect -> PrimOpEffect -> Ordering)
    -> (PrimOpEffect -> PrimOpEffect -> Bool)
    -> (PrimOpEffect -> PrimOpEffect -> Bool)
    -> (PrimOpEffect -> PrimOpEffect -> Bool)
    -> (PrimOpEffect -> PrimOpEffect -> Bool)
    -> (PrimOpEffect -> PrimOpEffect -> PrimOpEffect)
    -> (PrimOpEffect -> PrimOpEffect -> PrimOpEffect)
    -> Ord PrimOpEffect
    PrimOpEffect -> PrimOpEffect -> Bool
    PrimOpEffect -> PrimOpEffect -> Ordering
    PrimOpEffect -> PrimOpEffect -> PrimOpEffect
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: PrimOpEffect -> PrimOpEffect -> Ordering
    compare :: PrimOpEffect -> PrimOpEffect -> Ordering
    $c< :: PrimOpEffect -> PrimOpEffect -> Bool
    < :: PrimOpEffect -> PrimOpEffect -> Bool
    $c<= :: PrimOpEffect -> PrimOpEffect -> Bool
    <= :: PrimOpEffect -> PrimOpEffect -> Bool
    $c> :: PrimOpEffect -> PrimOpEffect -> Bool
    > :: PrimOpEffect -> PrimOpEffect -> Bool
    $c>= :: PrimOpEffect -> PrimOpEffect -> Bool
    >= :: PrimOpEffect -> PrimOpEffect -> Bool
    $cmax :: PrimOpEffect -> PrimOpEffect -> PrimOpEffect
    max :: PrimOpEffect -> PrimOpEffect -> PrimOpEffect
    $cmin :: PrimOpEffect -> PrimOpEffect -> PrimOpEffect
    min :: PrimOpEffect -> PrimOpEffect -> PrimOpEffect
    Ord)

    primOpOkForSpeculation :: PrimOp -> Bool
      -- See Note [Classifying primop effects]
      -- See comments with GHC.Core.Utils.exprOkForSpeculation
      -- primOpOkForSpeculation => primOpOkToDiscard
    primOpOkForSpeculation :: PrimOp -> Bool
    primOpOkForSpeculation PrimOp
    op
      = PrimOp -> PrimOpEffect
    primOpEffect PrimOp
    op PrimOpEffect -> PrimOpEffect -> Bool
    forall a. Eq a => a -> a -> Bool
    == PrimOpEffect
    NoEffect Bool -> Bool -> Bool
    && Bool -> Bool
    not (PrimOp -> Bool
    primOpOutOfLine PrimOp
    op)
        -- I think the "out of line" test is because out of line things can
        -- be expensive (eg sine, cosine), and so we may not want to speculate them

    primOpOkToDiscard :: PrimOp -> Bool
    primOpOkToDiscard :: PrimOp -> Bool
    primOpOkToDiscard PrimOp
    op
      = PrimOp -> PrimOpEffect
    primOpEffect PrimOp
    op PrimOpEffect -> PrimOpEffect -> Bool
    forall a. Ord a => a -> a -> Bool
    < PrimOpEffect
    ThrowsException

    primOpIsWorkFree :: PrimOp -> Bool
    #include "primop-is-work-free.hs-incl"

    primOpIsCheap :: PrimOp -> Bool
    -- See Note [Classifying primop effects]
    #include "primop-is-cheap.hs-incl"
    -- In March 2001, we changed this to
    --      primOpIsCheap op = False
    -- thereby making *no* primops seem cheap.  But this killed eta
    -- expansion on case (x ==# y) of True -> \s -> ...
    -- which is bad.  In particular a loop like
    --      doLoop n = loop 0
    --     where
    --         loop i | i == n    = return ()
    --                | otherwise = bar i >> loop (i+1)
    -- allocated a closure every time round because it doesn't eta expand.
    --
    -- The problem that originally gave rise to the change was
    --      let x = a +# b *# c in x +# x
    -- were we don't want to inline x. But primopIsCheap doesn't control
    -- that (it's primOpIsWorkFree that does) so the problem doesn't occur
    -- even if primOpIsCheap sometimes says 'True'.

    -- | True of dyadic operators that can fail only if the second arg is zero!
    --
    -- This function probably belongs in an automagically generated file.. but it's
    -- such a special case I thought I'd leave it here for now.
    primOpIsDiv :: PrimOp -> Bool
    primOpIsDiv :: PrimOp -> Bool
    primOpIsDiv PrimOp
    op = case PrimOp
    op of

      PrimOp
    IntQuotOp       -> Bool
    True
      PrimOp
    Int8QuotOp      -> Bool
    True
      PrimOp
    Int16QuotOp     -> Bool
    True
      PrimOp
    Int32QuotOp     -> Bool
    True
      PrimOp
    Int64QuotOp     -> Bool
    True

      PrimOp
    IntRemOp        -> Bool
    True
      PrimOp
    Int8RemOp       -> Bool
    True
      PrimOp
    Int16RemOp      -> Bool
    True
      PrimOp
    Int32RemOp      -> Bool
    True
      PrimOp
    Int64RemOp      -> Bool
    True

      PrimOp
    IntQuotRemOp    -> Bool
    True
      PrimOp
    Int8QuotRemOp   -> Bool
    True
      PrimOp
    Int16QuotRemOp  -> Bool
    True
      PrimOp
    Int32QuotRemOp  -> Bool
    True
      -- Int64QuotRemOp doesn't exist (yet)

      PrimOp
    WordQuotOp      -> Bool
    True
      PrimOp
    Word8QuotOp     -> Bool
    True
      PrimOp
    Word16QuotOp    -> Bool
    True
      PrimOp
    Word32QuotOp    -> Bool
    True
      PrimOp
    Word64QuotOp    -> Bool
    True

      PrimOp
    WordRemOp       -> Bool
    True
      PrimOp
    Word8RemOp      -> Bool
    True
      PrimOp
    Word16RemOp     -> Bool
    True
      PrimOp
    Word32RemOp     -> Bool
    True
      PrimOp
    Word64RemOp     -> Bool
    True

      PrimOp
    WordQuotRemOp   -> Bool
    True
      PrimOp
    Word8QuotRemOp  -> Bool
    True
      PrimOp
    Word16QuotRemOp -> Bool
    True
      PrimOp
    Word32QuotRemOp -> Bool
    True
      -- Word64QuotRemOp doesn't exist (yet)

      PrimOp
    WordQuotRem2Op  -> Bool
    True

      PrimOp
    FloatDivOp      -> Bool
    True
      PrimOp
    DoubleDivOp     -> Bool
    True
      PrimOp
    _               -> Bool
    False

    {-
    ************************************************************************
    *                                                                      *
                   PrimOp code size
    *                                                                      *
    ************************************************************************

    primOpCodeSize
    ~~~~~~~~~~~~~~
    Gives an indication of the code size of a primop, for the purposes of
    calculating unfolding sizes; see GHC.Core.Unfold.sizeExpr.
    -}

    primOpCodeSize :: PrimOp -> Int
    #include "primop-code-size.hs-incl"

    primOpCodeSizeDefault :: Int
    primOpCodeSizeDefault :: Int
    primOpCodeSizeDefault = Int
    1
      -- GHC.Core.Unfold.primOpSize already takes into account primOpOutOfLine
      -- and adds some further costs for the args in that case.

    primOpCodeSizeForeignCall :: Int
    primOpCodeSizeForeignCall :: Int
    primOpCodeSizeForeignCall = Int
    4

    {-
    ************************************************************************
    *                                                                      *
                   PrimOp types
    *                                                                      *
    ************************************************************************
    -}

    primOpType :: PrimOp -> Type  -- you may want to use primOpSig instead
    primOpType :: PrimOp -> Type
    primOpType PrimOp
    op
      = case PrimOp -> PrimOpInfo
    primOpInfo PrimOp
    op of
        Compare OccName
    _occ Type
    ty -> Type -> Type
    compare_fun_ty Type
    ty

        GenPrimOp OccName
    _occ [TyVarBinder]
    tyvars [Type]
    arg_tys Type
    res_ty ->
            [TyVarBinder] -> Type -> Type
    mkForAllTys [TyVarBinder]
    tyvars ([Type] -> Type -> Type
    mkVisFunTysMany [Type]
    arg_tys Type
    res_ty)

    primOpResultType :: PrimOp -> Type
    primOpResultType :: PrimOp -> Type
    primOpResultType PrimOp
    op
      = case PrimOp -> PrimOpInfo
    primOpInfo PrimOp
    op of
        Compare OccName
    _occ Type
    _ty -> Type
    intPrimTy
        GenPrimOp OccName
    _occ [TyVarBinder]
    _tyvars [Type]
    _arg_tys Type
    res_ty -> Type
    res_ty

    primOpOcc :: PrimOp -> OccName
    primOpOcc :: PrimOp -> OccName
    primOpOcc PrimOp
    op = case PrimOp -> PrimOpInfo
    primOpInfo PrimOp
    op of
                   Compare   OccName
    occ Type
    _     -> OccName
    occ
                   GenPrimOp OccName
    occ [TyVarBinder]
    _ [Type]
    _ Type
    _ -> OccName
    occ

    {- Note [Primop wrappers]
    ~~~~~~~~~~~~~~~~~~~~~~~~~

    To support (limited) use of primops in GHCi genprimopcode generates the
    GHC.PrimopWrappers module. This module contains a "primop wrapper"
    binding for each primop. These are standard Haskell functions mirroring the
    types of the primops they wrap. For instance, in the case of plusInt# we would
    have:

        module GHC.PrimopWrappers where
        import GHC.Prim as P

        plusInt# :: Int# -> Int# -> Int#
        plusInt# a b = P.plusInt# a b

    The Id for the wrapper of a primop can be found using
    'GHC.Builtin.PrimOps.primOpWrapperId'. However, GHCi does not use this mechanism
    to link primops; it rather does a rather hacky symbol lookup (see
    GHC.ByteCode.Linker.primopToCLabel). TODO: Perhaps this should be changed?

    Note that these wrappers aren't *quite* as expressive as their unwrapped
    brethren, in that they may exhibit less representation polymorphism.
    For instance, consider the case of mkWeakNoFinalizer#, which has type:

        mkWeakNoFinalizer# :: forall (r :: RuntimeRep) (k :: TYPE r) (v :: Type).
                              k -> v
                           -> State# RealWorld
                           -> (# State# RealWorld, Weak# v #)

    Naively we could generate a wrapper of the form,

        mkWeakNoFinalizer# k v s = GHC.Prim.mkWeakNoFinalizer# k v s

    However, this would require that 'k' bind the representation-polymorphic key,
    which is disallowed by our representation polymorphism validity checks
    (see Note [Representation polymorphism invariants] in GHC.Core).
    Consequently, we give the wrapper the simpler, less polymorphic type

        mkWeakNoFinalizer# :: forall (k :: Type) (v :: Type).
                              k -> v
                           -> State# RealWorld
                           -> (# State# RealWorld, Weak# v #)

    This simplification tends to be good enough for GHCi uses given that there are
    few representation-polymorphic primops, and we do little simplification
    on interpreted code anyways.

    TODO: This behavior is actually wrong; a program becomes ill-typed upon
    replacing a real primop occurrence with one of its wrapper due to the fact that
    the former has an additional type binder. Hmmm....

    Note [Eta expanding primops]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    STG requires that primop applications be saturated. This makes code generation
    significantly simpler since otherwise we would need to define a calling
    convention for curried applications that can accommodate representation
    polymorphism.

    To ensure saturation, CorePrep eta expands all primop applications as
    described in Note [Eta expansion of hasNoBinding things in CorePrep] in
    GHC.Core.Prep.

    Historical Note:

    For a short period around GHC 8.8 we rewrote unsaturated primop applications to
    rather use the primop's wrapper (see Note [Primop wrappers] in
    GHC.Builtin.PrimOps) instead of eta expansion. This was because at the time
    CoreTidy would try to predict the CAFfyness of bindings that would be produced
    by CorePrep for inclusion in interface files. Eta expanding during CorePrep
    proved to be very difficult to predict, leading to nasty inconsistencies in
    CAFfyness determinations (see #16846).

    Thankfully, we now no longer try to predict CAFfyness but rather compute it on
    GHC STG (see Note [SRTs] in GHC.Cmm.Info.Build) and inject it into the interface
    file after code generation (see TODO: Refer to whatever falls out of #18096).
    This is much simpler and avoids the potential for inconsistency, allowing us to
    return to the somewhat simpler eta expansion approach for unsaturated primops.

    See #18079.
    -}

    -- | Returns the 'Id' of the wrapper associated with the given 'PrimOp'.
    -- See Note [Primop wrappers].
    primOpWrapperId :: PrimOp -> Id
    primOpWrapperId :: PrimOp -> Id
    primOpWrapperId PrimOp
    op = HasDebugCallStack => Name -> Type -> IdInfo -> Id
    Name -> Type -> IdInfo -> Id
    mkVanillaGlobalWithInfo Name
    name Type
    ty IdInfo
    info
      where
        info :: IdInfo
    info = IdInfo -> CafInfo -> IdInfo
    setCafInfo IdInfo
    vanillaIdInfo CafInfo
    NoCafRefs
        name :: Name
    name = Unique -> Module -> OccName -> SrcSpan -> Name
    mkExternalName Unique
    uniq Module
    gHC_PRIMOPWRAPPERS (PrimOp -> OccName
    primOpOcc PrimOp
    op) SrcSpan
    wiredInSrcSpan
        uniq :: Unique
    uniq = Int -> Unique
    mkPrimOpWrapperUnique (PrimOp -> Int
    primOpTag PrimOp
    op)
        ty :: Type
    ty   = PrimOp -> Type
    primOpType PrimOp
    op

    isComparisonPrimOp :: PrimOp -> Bool
    isComparisonPrimOp :: PrimOp -> Bool
    isComparisonPrimOp PrimOp
    op = case PrimOp -> PrimOpInfo
    primOpInfo PrimOp
    op of
                              Compare {}   -> Bool
    True
                              GenPrimOp {} -> Bool
    False

    -- primOpSig is like primOpType but gives the result split apart:
    -- (type variables, argument types, result type)
    -- It also gives arity, strictness info

    primOpSig :: PrimOp -> ([TyVarBinder], [Type], Type, Arity, DmdSig)
    primOpSig :: PrimOp -> ([TyVarBinder], [Type], Type, Int, DmdSig)
    primOpSig PrimOp
    op
      = ([TyVarBinder]
    tyvars, [Type]
    arg_tys, Type
    res_ty, Int
    arity, PrimOp -> Int -> DmdSig
    primOpStrictness PrimOp
    op Int
    arity)
      where
        arity :: Int
    arity = [Type] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [Type]
    arg_tys
        ([TyVarBinder]
    tyvars, [Type]
    arg_tys, Type
    res_ty)
          = case (PrimOp -> PrimOpInfo
    primOpInfo PrimOp
    op) of
            Compare   OccName
    _occ Type
    ty                    -> ([],     [Type
    ty,Type
    ty], Type
    intPrimTy)
            GenPrimOp OccName
    _occ [TyVarBinder]
    tyvars [Type]
    arg_tys Type
    res_ty -> ([TyVarBinder]
    tyvars, [Type]
    arg_tys, Type
    res_ty   )

    data PrimOpResultInfo
      = ReturnsVoid
      | ReturnsPrim     PrimRep
      | ReturnsTuple

    -- Some PrimOps need not return a manifest primitive or algebraic value
    -- (i.e. they might return a polymorphic value).  These PrimOps *must*
    -- be out of line, or the code generator won't work.

    getPrimOpResultInfo :: PrimOp -> PrimOpResultInfo
    getPrimOpResultInfo :: PrimOp -> PrimOpResultInfo
    getPrimOpResultInfo PrimOp
    op
      = case (PrimOp -> PrimOpInfo
    primOpInfo PrimOp
    op) of
          Compare OccName
    _ Type
    _                         -> PrimRep -> PrimOpResultInfo
    ReturnsPrim PrimRep
    IntRep
          GenPrimOp OccName
    _ [TyVarBinder]
    _ [Type]
    _ Type
    ty | TyCon -> Bool
    isPrimTyCon TyCon
    tc -> case HasDebugCallStack => TyCon -> [PrimRep]
    TyCon -> [PrimRep]
    tyConPrimRep TyCon
    tc of
                                                   [] -> PrimOpResultInfo
    ReturnsVoid
                                                   [PrimRep
    rep] -> PrimRep -> PrimOpResultInfo
    ReturnsPrim PrimRep
    rep
                                                   [PrimRep]
    _ -> [Char] -> SDoc -> PrimOpResultInfo
    forall a. HasCallStack => [Char] -> SDoc -> a
    pprPanic [Char]
    "getPrimOpResultInfo" (PrimOp -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr PrimOp
    op)
                             | TyCon -> Bool
    isUnboxedTupleTyCon TyCon
    tc -> PrimOpResultInfo
    ReturnsTuple
                             | Bool
    otherwise      -> [Char] -> SDoc -> PrimOpResultInfo
    forall a. HasCallStack => [Char] -> SDoc -> a
    pprPanic [Char]
    "getPrimOpResultInfo" (PrimOp -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr PrimOp
    op)
                             where
                               tc :: TyCon
    tc = HasDebugCallStack => Type -> TyCon
    Type -> TyCon
    tyConAppTyCon Type
    ty
                            -- All primops return a tycon-app result
                            -- The tycon can be an unboxed tuple or sum, though,
                            -- which gives rise to a ReturnAlg

    {-
    We do not currently make use of whether primops are commutable.

    We used to try to move constants to the right hand side for strength
    reduction.
    -}

    {-
    commutableOp :: PrimOp -> Bool
    #include "primop-commutable.hs-incl"
    -}

    -- Utils:

    compare_fun_ty :: Type -> Type
    compare_fun_ty :: Type -> Type
    compare_fun_ty Type
    ty = [Type] -> Type -> Type
    mkVisFunTysMany [Type
    ty, Type
    ty] Type
    intPrimTy

    -- Output stuff:

    pprPrimOp  :: IsLine doc => PrimOp -> doc
    pprPrimOp :: forall doc. IsLine doc => PrimOp -> doc
    pprPrimOp PrimOp
    other_op = OccName -> doc
    forall doc. IsLine doc => OccName -> doc
    pprOccName (PrimOp -> OccName
    primOpOcc PrimOp
    other_op)
    {-# SPECIALIZE pprPrimOp :: PrimOp -> SDoc #-}
    {-# SPECIALIZE pprPrimOp :: PrimOp -> HLine #-} -- see Note [SPECIALIZE to HDoc] in GHC.Utils.Outputable

    {-
    ************************************************************************
    *                                                                      *
    \subsubsection[PrimCall]{User-imported primitive calls}
    *                                                                      *
    ************************************************************************
    -}

    data PrimCall = PrimCall CLabelString Unit

    instance Outputable PrimCall where
      ppr :: PrimCall -> SDoc
    ppr (PrimCall FastString
    lbl Unit
    pkgId)
            = [Char] -> SDoc
    forall doc. IsLine doc => [Char] -> doc
    text [Char]
    "__primcall" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Unit -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Unit
    pkgId SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> FastString -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr FastString
    lbl

    -- | Indicate if a primop is really inline: that is, it isn't out-of-line and it
    -- isn't DataToTagOp which are two primops that evaluate their argument
    -- hence induce thread/stack/heap changes.
    primOpIsReallyInline :: PrimOp -> Bool
    primOpIsReallyInline :: PrimOp -> Bool
    primOpIsReallyInline = \case
      PrimOp
    DataToTagSmallOp -> Bool
    False
      PrimOp
    DataToTagLargeOp -> Bool
    False
      PrimOp
    p                -> Bool -> Bool
    not (PrimOp -> Bool
    primOpOutOfLine PrimOp
    p)