format = cmmTypeFormat ty

     CmmUnsafeForeignCall target result_regs args

     CmmBranch id          -> genBranch id

     CmmCondBranch arg true false prediction -> do

   let Reg64 hi lo = localReg64 local_reg

   return (RegCode64 nilOL hi lo)

 iselExpr64 (CmmLit (CmmInt i _)) = do

   Reg64 rhi rlo <- getNewReg64

   let

 -- @get_arg@, which moves the arguments to the correct registers/stack

 -- locations.  Apart from that, the code is easy.

          -> [CmmFormal]        -- where to put the result

          -> [CmmActual]        -- arguments (of mixed type)

          -> NatM InstrBlock

  = return $ unitOL LWSYNC

  = return $ unitOL LWSYNC

  = return $ unitOL HWSYNC

  = return $ nilOL

  = return $ nilOL

  = do let fmt      = intFormat width

           reg_dst  = getLocalRegReg dst

       (instr, n_code) <- case amop of

                           (n_reg, n_code) <- getSomeReg n

                           return  (op dst dst (RIReg n_reg), n_code)

  = do let fmt      = intFormat width

           reg_dst  = getLocalRegReg dst

           form     = if widthInBits width == 64 then DS else D

 -- This is also what gcc does.

     code <- assignMem_IntCode (intFormat width) addr val

     return $ unitOL HWSYNC `appOL` code

   = do

       (old_reg, old_code) <- getSomeReg old

       (new_reg, new_code) <- getSomeReg new

     format = intFormat width

       if target32Bit platform && width == W64

         then do

           RegCode64 code vr_hi vr_lo <- iselExpr64 src

           let cntlz = unitOL (CNTLZ format reg_dst reg)

           return $ s_code `appOL` pre `appOL` cntlz `appOL` post

       if target32Bit platform && width == W64

         then do

           let format = II32

                           , SUBFC dst r' (RIImm (ImmInt (format_bits)))

                           ]

         PrimTarget (MO_S_QuotRem  width) -> divOp1 True  width

                                                    dest_regs argsAndHints

         PrimTarget (MO_U_QuotRem  width) -> divOp1 False width

                                    , sc_hole_ty = coercionLKind co }) }

                                         -- NB!  As the cast goes past, the

                                         -- type of the hole changes (#16312)

         -- (f |> co) e   ===>   (f (e |> co1)) |> co2

         -- where   co :: (s1->s2) ~ (t1->t2)

         --         co1 :: t1 ~ s1

             , not ( isSimplified dup &&  -- See (SR2) in Note [Avoiding simplifying repeatedly]

                     not (exprIsTrivial arg) &&

                     not (isDeadOcc (idOccInfo bndr)) )

                     tick (PreInlineUnconditionally bndr)

                   ; simplLam env' body cont }

 import GHC.Types.Demand

 import GHC.Types.Var.Set

 import GHC.Types.Basic

 import GHC.Data.OrdList ( isNilOL )

 import GHC.Data.FastString ( fsLit )

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 import Data.List        ( sortBy )

 import Data.Graph

 {- *********************************************************************

                 True  -> True;

                 False -> False

 Note [Scrutinee Constant Folding]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 --         See Note [Eliminate Identity Case]

 --------------------------------------------------

   = do { tick (CaseIdentity case_bndr)

   where

     arg_tys = tyConAppArgs (idType case_bndr)

 mkCase1 mode scrut bndr alts_ty alts = mkCase2 mode scrut bndr alts_ty alts

 mkCastMCo :: CoreExpr -> MCoercionR -> CoreExpr

 mkCastMCo e MRefl    = e

   -- We are careful to use (MCo co) only when co is not reflexive

   -- Hence (Cast e co) rather than (mkCast e co)

 -- | Wraps the given expression in the source annotation, dropping the

 -- annotation if possible.

 mkTick :: CoreTickish -> CoreExpr -> CoreExpr

  where

   -- Some ticks (cost-centres) can be split in two, with the

   -- non-counting part having laxer placement properties.

   canSplit = tickishCanSplit t && tickishPlace (mkNoCount t) /= tickishPlace t

   -- mkTick' handles floating of ticks *into* the expression.

           -> CoreExpr

     -- Float ticks into unsafe coerce the same way we would do with a cast.

     Case scrut bndr ty alts@[Alt ac abs _rhs]

       | Just rhs <- isUnsafeEqualityCase scrut bndr alts

     -- Cost centre ticks should never be reordered relative to each

     -- other. Therefore we can stop whenever two collide.

     Tick t2 e

     -- Otherwise we assume that ticks of different placements float

     -- through each other.

     -- For annotations this is where we make sure to not introduce

     -- redundant ticks.

     -- Ticks don't care about types, so we just float all ticks

     -- through them. Note that it's not enough to check for these

     -- expressions below ticks, such constructs can be the result of

     -- unfoldings. We therefore make an effort to put everything into

     -- the right place no matter what we start with.

     Lam x e

       -- Always float through type lambdas. Even for non-type lambdas,

       -- floating is allowed for all but the most strict placement rule.

       | not (isRuntimeVar x) || tickishPlace t /= PlaceRuntime

       -- If it is both counting and scoped, we split the tick into its

       -- two components, often allowing us to keep the counting tick on

       -- floated, and the lambda may then be in a position to be

       -- beta-reduced.

       | canSplit

     App f arg

       -- Always float through type applications.

       | not (isRuntimeArg arg)

       -- We can also float through constructor applications, placement

       -- permitting. Again we can split.

       | isSaturatedConApp expr && (tickishPlace t==PlaceCostCentre || canSplit)

       -> if tickishPlace t == PlaceCostCentre

     Var x

       | notFunction && tickishPlace t == PlaceCostCentre

       | notFunction && canSplit

       where

         -- SCCs can be eliminated on variables provided the variable

         -- is not a function.  In these cases the SCC makes no difference:

     Lit{}

       | tickishPlace t == PlaceCostCentre

     -- Catch-all: Annotate where we stand

 mkTicks :: [CoreTickish] -> CoreExpr -> CoreExpr

 mkTicks ticks expr = foldr mkTick expr ticks

 import GHC.Core.DataCon

 import GHC.Core.TyCon

 import GHC.Core.Class

 import GHC.Core ( Expr(..), mkConApp )

 import GHC.StgToCmm.Closure ( isSmallFamily )

                = mkCoreLams [ runtimeRep1TyVar, openAlphaTyVar, sv, k ] $

                  Var k `App` (evUnaryDictAppE cls dict_args meth_arg)

                where

        ; let mk_ev [c] = evDictApp wd_cls [cls_ty, mty] [evWithDict c]

              mk_ev e   = pprPanic "matchWithDict" (ppr e)

                                (mkReflCo Representational intPrimTy)

      -> do { addUsedDataCons rdr_env repTyCon   -- See wrinkles DTW2 and DTW3

            ; let mk_ev _ = evDictApp dataToTagClass [levity, dty] $

            ; pure (OneInst { cir_new_theta = [] -- (Ignore stupid theta.)

                            , cir_mk_ev     = mk_ev

                            , cir_canonical = EvCanonical

 import GHC.Core

 import GHC.Core.Coercion.Axiom

 import GHC.Core.Coercion

 import GHC.Core.Ppr ()   -- Instance OutputableBndr TyVar

 import GHC.Core.Predicate

 import GHC.Core.Type

   | assertPpr (coercionRole co == Representational)

               (vcat [text "Coercion of wrong role passed to evCastE:", ppr ee, ppr co]) $

     isReflCo co = ee

 evDFunApp :: DFunId -> [Type] -> [EvExpr] -> EvTerm

 -- Dictionary instance application, including when the "dictionary function"

   -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld,

         Int #) = _

 Stopped in Main.foo, T26042b.hs:14:3-18

 13        y = 4

 14    n <- bar (x + y)

       ^^^^^^^^^^^^^^^^

 15    return n

 Stopped in Main.main, T26042b.hs:5:3-26

 4  main = do

 5    a <- foo False undefined

      ^^^^^^^^^^^^^^^^^^^^^^^^

 6    print a

 14

 14

 Breakpoint 0 activated at T26042c.hs:10:15-22

 Stopped in Main.foo, T26042c.hs:10:15-22

 9  foo :: Bool -> Int -> IO Int

 10  foo True  i = return i

                   ^^^^^^^^

 11  foo False _ = do

 Stopped in Main.main, T26042c.hs:5:3-26

 4  main = do

 5    a <- foo False undefined

      ^^^^^^^^^^^^^^^^^^^^^^^^

 Breakpoint 0 activated at T26042d2.hs:11:3-21

 hello1

 Stopped in Main.f, T26042d2.hs:11:3-21

 10  f = do

 11    putStrLn "hello2.1"

       ^^^^^^^^^^^^^^^^^^^

 Breakpoint 0 activated at T26042f.hs:(20,7)-(21,14)

 Stopped in T8.t, T26042f.hs:(20,7)-(21,14)

 x :: Int = 450

 19  t :: Int -> Identity Int

         vv

       ^^^^^^^^^^^^

 15    n <- pure (a+a)

 Stopped in T8.f, T26042f.hs:8:3-14

 x :: Int = 15

 7  f x = do

 8    b <- g (x*x)

      ^^^^^^^^^^^^

 9    y <- pure (b+b)

 x :: Int = 15

 7248