#5359: GHC 7.2.1-rc1 panics on `cgLookupPanic`
-------------------------------+--------------------------------------------
Reporter: hvr | Owner: simonpj
Type: bug | Status: new
Priority: highest | Milestone: 7.2.1
Component: Compiler | Version: 7.1
Keywords: | Testcase:
Blockedby: | Difficulty:
Os: Linux | Blocking:
Architecture: x86_64 (amd64) | Failure: Compile-time crash
-------------------------------+--------------------------------------------
Changes (by igloo):
* owner: => simonpj
* priority: normal => highest
* milestone: => 7.2.1
Comment:
Thanks for the report. Here's a single-module testcase:
{{{
{-# LANGUAGE BangPatterns, Rank2Types, MagicHash, UnboxedTuples #-}
module Foo (linesT) where
import GHC.Base
import GHC.Word
import GHC.ST (ST(..), runST)
nullT :: Text -> Bool
nullT (Text _ _ len) = len <= 0
{-# INLINE [1] nullT #-}
spanT :: (Char -> Bool) -> Text -> (Text, Text)
spanT p t@(Text arr off len) = (textP arr off k, textP arr (off+k)
(len-k))
where k = loop 0
loop !i | i >= len || not (p c) = i
| otherwise = loop (i+d)
where Iter c d = iter t i
{-# INLINE spanT #-}
linesT :: Text -> [Text]
linesT ps | nullT ps = []
| otherwise = h : if nullT t
then []
else linesT (unsafeTail t)
where (h,t) = spanT (/= '\n') ps
{-# INLINE linesT #-}
unsafeTail :: Text -> Text
unsafeTail t@(Text arr off len) = Text arr (off+d) (len-d)
where d = iter_ t 0
{-# INLINE unsafeTail #-}
data Iter = Iter {-# UNPACK #-} !Char {-# UNPACK #-} !Int
iter :: Text -> Int -> Iter
iter (Text arr _ _) i = Iter (unsafeChrT m) 1
where m = unsafeIndex arr i
{-# INLINE iter #-}
iter_ :: Text -> Int -> Int
iter_ (Text arr off _) i | m < 0xD800 || m > 0xDBFF = 1
| otherwise = 2
where m = unsafeIndex arr (off+i)
{-# INLINE iter_ #-}
data Text = Text {-# UNPACK #-}!Array {-# UNPACK #-}!Int {-# UNPACK
#-}!Int
text :: Array -> Int -> Int -> Text
text arr off len = Text arr off len
{-# INLINE text #-}
emptyT :: Text
emptyT = Text empty 0 0
{-# INLINE [1] emptyT #-}
textP :: Array -> Int -> Int -> Text
textP arr off len | len == 0 = emptyT
| otherwise = text arr off len
{-# INLINE textP #-}
unsafeChrT :: Word16 -> Char
unsafeChrT (W16# w#) = C# (chr# (word2Int# w#))
{-# INLINE unsafeChrT #-}
data Array = Array ByteArray#
data MArray s = MArray (MutableByteArray# s)
new :: forall s. Int -> ST s (MArray s)
new n@(I# len#)
| n < 0 || n /= 0 = error $ "Data.Text.Array.new: size overflow"
| otherwise = ST $ \s1# ->
case newByteArray# len# s1# of
(# s2#, marr# #) -> (# s2#, MArray marr# #)
{-# INLINE new #-}
unsafeFreeze :: MArray s -> ST s Array
unsafeFreeze (MArray maBA) = ST $ \s# -> (# s#, Array (unsafeCoerce# maBA)
#)
{-# INLINE unsafeFreeze #-}
unsafeIndex :: Array -> Int -> Word16
unsafeIndex (Array aBA) (I# i#) =
case indexWord16Array# aBA i# of r# -> (W16# r#)
{-# INLINE unsafeIndex #-}
empty :: Array
empty = runST (new 0 >>= unsafeFreeze)
}}}
{{{
ghc -dcore-lint -c Foo.hs -O2
}}}
{{{
*** Core Lint warnings : in result of Specialise ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Float out(FOS {Lam = Just 0,
Consts = True,
PAPs = False}) ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Float inwards ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Demand analysis ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Worker Wrapper binds ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Simplifier ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Float out(FOS {Lam = Just 0,
Consts = True,
PAPs = True}) ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Common sub-expression ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Float inwards ***
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint warnings : in result of Liberate case ***
{-# LINE 22 "Foo.hs #-}:
[RHS of linesT_rki :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: linesT_rki
{-# LINE 22 "Foo.hs #-}:
[RHS of Foo.linesT :: Foo.Text -> [Foo.Text]]
INLINE binder is (non-rule) loop breaker: Foo.linesT
*** Core Lint errors : in result of Simplifier ***
<no location info>:
In a case alternative: (GHC.Types.I# y_aEB :: GHC.Prim.Int#)
$w$j_sHK is out of scope
*** Offending Program ***
lvl_sHL
:: forall s_aA6.
GHC.Prim.State# s_aA6 -> (# GHC.Prim.State# s_aA6, Foo.Array #)
[LclId,
Arity=1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=1, Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=IF_ARGS [0] 23 30}]
lvl_sHL =
\ (@ s_aA6)
(s_aDy [Dmd=Just L, Lbv=OneShot] :: GHC.Prim.State# s_aA6) ->
case GHC.Prim.newByteArray# @ s_aA6 0 s_aDy
of _ { (# s2#_atc [Dmd=Just A], marr#_atd [Dmd=Just L] #) ->
(# s2#_atc,
Foo.Array
(marr#_atd
`cast` (UnsafeCo
(GHC.Prim.MutableByteArray# s_aA6) GHC.Prim.ByteArray#
:: GHC.Prim.MutableByteArray# s_aA6 ~
GHC.Prim.ByteArray#)) #)
}
Foo.empty :: Foo.Array
[LclId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=0, Value=False,
ConLike=False, Cheap=False, Expandable=False,
Guidance=IF_ARGS [] 20 0}]
Foo.empty = GHC.ST.runSTRep @ Foo.Array lvl_sHL
Foo.emptyT [InlPrag=INLINE[1] (sat-args=0)] :: Foo.Text
[LclId,
Str=DmdType,
Unf=Unf{Src=InlineStable, TopLvl=True, Arity=0, Value=False,
ConLike=False, Cheap=True, Expandable=True,
Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
Tmpl= case Foo.empty of _ { Foo.Array tpl_B5 [Occ=Once] ->
Foo.Text tpl_B5 0 0
}}]
Foo.emptyT =
case Foo.empty of _ { Foo.Array tpl_B5 [Dmd=Just L] ->
Foo.Text tpl_B5 0 0
}
Foo.nullT [InlPrag=INLINE[1] (sat-args=1)]
:: Foo.Text -> GHC.Types.Bool
[LclId,
Arity=1,
Str=DmdType U(AAL),
Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
Tmpl= \ (ds_dBb [Occ=Once!] :: Foo.Text) ->
case ds_dBb of _ { Foo.Text _ _ rb_dBp [Occ=Once] ->
GHC.Prim.<=# rb_dBp 0
}}]
Foo.nullT =
\ (ds_dBb :: Foo.Text) ->
case ds_dBb
of _
{ Foo.Text rb_dBn [Dmd=Just A]
rb_dBo [Dmd=Just A]
rb_dBp [Dmd=Just L] ->
GHC.Prim.<=# rb_dBp 0
}
Foo.unsafeTail [InlPrag=INLINE (sat-args=1)]
:: Foo.Text -> Foo.Text
[LclId,
Arity=1,
Str=DmdType U(LLL)m,
Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
Tmpl= \ (t_asQ [Occ=Once!] :: Foo.Text) ->
case t_asQ of _ { Foo.Text rb_dBB rb_dBC rb_dBD
[Occ=Once*] ->
let {
a_sEG :: GHC.Prim.Word#
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=False,
ConLike=False, Cheap=True, Expandable=True,
Guidance=IF_ARGS [] 1 0}]
a_sEG = GHC.Prim.indexWord16Array# rb_dBB rb_dBC } in
let {
m_at1 :: GHC.Word.Word16
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=IF_ARGS [] 10 110}]
m_at1 = GHC.Word.W16# a_sEG } in
case GHC.Classes.||
(GHC.Word.$fOrdWord16_$c<
m_at1
(GHC.Word.$fBitsWord16_$cfromInteger
(GHC.Integer.smallInteger 55296)))
(GHC.Word.$fOrdWord16_$c>
m_at1
(GHC.Word.$fBitsWord16_$cfromInteger
(GHC.Integer.smallInteger 56319)))
of _ {
GHC.Types.False ->
Foo.Text rb_dBB (GHC.Prim.+# rb_dBC 2) (GHC.Prim.-#
rb_dBD 2);
GHC.Types.True ->
Foo.Text rb_dBB (GHC.Prim.+# rb_dBC 1) (GHC.Prim.-#
rb_dBD 1)
}
}}]
Foo.unsafeTail =
\ (t_asQ :: Foo.Text) ->
case t_asQ
of _
{ Foo.Text rb_dBB [Dmd=Just L]
rb_dBC [Dmd=Just L]
rb_dBD [Dmd=Just L] ->
let {
a_sGQ [Dmd=Just L] :: GHC.Prim.Word#
[LclId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0, Value=False,
ConLike=False, Cheap=True, Expandable=True,
Guidance=IF_ARGS [] 1 0}]
a_sGQ = GHC.Prim.indexWord16Array# rb_dBB rb_dBC } in
case GHC.Prim.ltWord# a_sGQ __word 55296 of _ {
GHC.Types.False ->
case GHC.Prim.gtWord# a_sGQ __word 56319 of _ {
GHC.Types.False ->
Foo.Text rb_dBB (GHC.Prim.+# rb_dBC 2) (GHC.Prim.-# rb_dBD 2);
GHC.Types.True ->
Foo.Text rb_dBB (GHC.Prim.+# rb_dBC 1) (GHC.Prim.-# rb_dBD 1)
};
GHC.Types.True ->
Foo.Text rb_dBB (GHC.Prim.+# rb_dBC 1) (GHC.Prim.-# rb_dBD 1)
}
}
Rec {
Foo.linesT [InlPrag=INLINE (sat-args=1), Occ=LoopBreaker]
:: Foo.Text -> [Foo.Text]
[LclIdX,
Arity=1,
Str=DmdType U(LLL),
Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
Tmpl= \ (ps_aqA :: Foo.Text) ->
let {
ds_dBj :: (Foo.Text, Foo.Text)
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=False,
ConLike=False, Cheap=False, Expandable=False,
Guidance=IF_ARGS [] 335 120}]
ds_dBj =
let {
ds_dBi [Occ=OnceL] :: GHC.Types.Char
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=IF_ARGS [] 10 110}]
ds_dBi = GHC.Types.C# '\n' } in
case ps_aqA of _ { Foo.Text rb_dBr rb_dBs rb_dBt ->
let {
k_aqv :: GHC.Types.Int
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=False,
ConLike=False, Cheap=False,
Expandable=False,
Guidance=IF_ARGS [] 203 0}]
k_aqv =
letrec {
loop_aAr [Occ=LoopBreaker] :: GHC.Types.Int ->
GHC.Types.Int
[LclId,
Arity=1,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=1,
Value=True,
ConLike=True, Cheap=True,
Expandable=True,
Guidance=IF_ARGS [20] 153 0}]
loop_aAr =
\ (i_aqx [Occ=Once!] :: GHC.Types.Int) ->
case i_aqx of i_XqJ { GHC.Types.I# ipv_sFe
->
case GHC.Classes.||
(GHC.Prim.>=# ipv_sFe rb_dBt)
(GHC.Classes.not
(GHC.Classes.$fEqChar_$c/=
(GHC.Types.C#
(GHC.Prim.chr#
(GHC.Prim.word2Int#
(GHC.Prim.indexWord16Array# rb_dBr ipv_sFe))))
ds_dBi))
of _ {
GHC.Types.False -> loop_aAr (GHC.Types.I#
(GHC.Prim.+# ipv_sFe 1));
GHC.Types.True -> i_XqJ
}
}; } in
loop_aAr (GHC.Types.I# 0) } in
(case k_aqv of _ { GHC.Types.I# x_aEN [Occ=Once!] ->
case x_aEN of wild_Xy {
__DEFAULT -> Foo.Text rb_dBr rb_dBs wild_Xy;
0 -> Foo.emptyT
}
},
case k_aqv of _ { GHC.Types.I# y_aEB ->
case GHC.Prim.-# rb_dBt y_aEB of wild_Xy {
__DEFAULT -> Foo.Text rb_dBr (GHC.Prim.+# rb_dBs
y_aEB) wild_Xy;
0 -> Foo.emptyT
}
})
} } in
let {
t_aqC :: Foo.Text
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=False,
ConLike=False, Cheap=True, Expandable=True,
Guidance=IF_ARGS [] 10 0}]
t_aqC = case ds_dBj of _ { (_, t_Xra [Occ=Once]) ->
t_Xra } } in
case Foo.nullT ps_aqA of _ {
GHC.Types.False ->
GHC.Types.:
@ Foo.Text
(case ds_dBj of _ { (h_aqB [Occ=Once], _) -> h_aqB
})
(case Foo.nullT t_aqC of _ {
GHC.Types.False -> Foo.linesT (Foo.unsafeTail
t_aqC);
GHC.Types.True -> GHC.Types.[] @ Foo.Text
});
GHC.Types.True -> GHC.Types.[] @ Foo.Text
}}]
Foo.linesT =
\ (ps_aqA :: Foo.Text) ->
case ps_aqA
of _
{ Foo.Text rb_dBn [Dmd=Just L]
rb_dBo [Dmd=Just L]
rb_dBp [Dmd=Just L] ->
case GHC.Prim.<=# rb_dBp 0 of _ {
GHC.Types.False ->
let {
k_aqv [Dmd=Just D(L)] :: GHC.Types.Int
[LclId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0, Value=False,
ConLike=False, Cheap=False, Expandable=False,
Guidance=IF_ARGS [] 123 110}]
k_aqv =
letrec {
$wloop_sHE [Occ=LoopBreaker] :: GHC.Prim.Int# ->
GHC.Prim.Int#
[LclId,
Arity=1,
Str=DmdType L,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=1, Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=IF_ARGS [0] 63 0}]
$wloop_sHE =
\ (ww_sHp :: GHC.Prim.Int#) ->
case GHC.Prim.>=# ww_sHp rb_dBp of _ {
GHC.Types.False ->
case GHC.Prim.chr#
(GHC.Prim.word2Int#
(GHC.Prim.indexWord16Array# rb_dBn ww_sHp))
of _ {
__DEFAULT -> $wloop_sHE (GHC.Prim.+# ww_sHp 1);
'\n' -> ww_sHp
};
GHC.Types.True -> ww_sHp
}; } in
case $wloop_sHE 0 of ww_sHt { __DEFAULT ->
GHC.Types.I# ww_sHt
} } in
GHC.Types.:
@ Foo.Text
(case k_aqv of _ { GHC.Types.I# x_aEN [Dmd=Just L] ->
case x_aEN of wild_Xy [Dmd=Just L] {
__DEFAULT -> Foo.Text rb_dBn rb_dBo wild_Xy;
0 -> Foo.emptyT
}
})
(case k_aqv of _ { GHC.Types.I# y_aEB [Dmd=Just L] ->
case GHC.Prim.-# rb_dBp y_aEB of wild_Xy [Dmd=Just L] {
__DEFAULT -> $w$j_sHK rb_dBn (GHC.Prim.+# rb_dBo y_aEB)
wild_Xy;
0 ->
case Foo.emptyT
of wild_XR [Dmd=Just A]
{ Foo.Text rb_XBR [Dmd=Just L]
rb_XBT [Dmd=Just L]
rb_XBV [Dmd=Just L] ->
letrec {
linesT_XkT [InlPrag=INLINE (sat-args=1), Occ=LoopBreaker]
:: Foo.Text -> [Foo.Text]
[LclId,
Arity=1,
Str=DmdType U(LLL),
Unf=Unf{Src=InlineStable, TopLvl=False, Arity=1,
Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=ALWAYS_IF(unsat_ok=False,boring_ok=False)
Tmpl= \ (ps_Xrd :: Foo.Text) ->
let {
ds_dBj :: (Foo.Text, Foo.Text)
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False,
Arity=0, Value=False,
ConLike=False, Cheap=False,
Expandable=False,
Guidance=IF_ARGS [] 335 120}]
ds_dBj =
let {
ds_dBi [Occ=OnceL] ::
GHC.Types.Char
[LclId,
Unf=Unf{Src=<vanilla>,
TopLvl=False, Arity=0, Value=True,
ConLike=True, Cheap=True,
Expandable=True,
Guidance=IF_ARGS [] 10
110}]
ds_dBi = GHC.Types.C# '\n' } in
case ps_Xrd of _ { Foo.Text rb_dBr
rb_dBs rb_dBt ->
let {
k_Xri :: GHC.Types.Int
[LclId,
Unf=Unf{Src=<vanilla>,
TopLvl=False, Arity=0, Value=False,
ConLike=False,
Cheap=False, Expandable=False,
Guidance=IF_ARGS [] 203
0}]
k_Xri =
letrec {
loop_aAr [Occ=LoopBreaker]
:: GHC.Types.Int ->
GHC.Types.Int
[LclId,
Arity=1,
Unf=Unf{Src=<vanilla>,
TopLvl=False, Arity=1,
Value=True,
ConLike=True, Cheap=True,
Expandable=True,
Guidance=IF_ARGS [20] 153 0}]
loop_aAr =
\ (i_aqx [Occ=Once!] ::
GHC.Types.Int) ->
case i_aqx of i_XqJ {
GHC.Types.I# ipv_sFe ->
case GHC.Classes.||
(GHC.Prim.>=#
ipv_sFe rb_dBt)
(GHC.Classes.not
(GHC.Classes.$fEqChar_$c/=
(GHC.Types.C#
(GHC.Prim.chr#
(GHC.Prim.word2Int#
(GHC.Prim.indexWord16Array#
rb_dBr ipv_sFe))))
ds_dBi))
of _ {
GHC.Types.False ->
loop_aAr (GHC.Types.I#
(GHC.Prim.+# ipv_sFe 1));
GHC.Types.True -> i_XqJ
}
}; } in
loop_aAr (GHC.Types.I# 0) } in
(case k_Xri of _ { GHC.Types.I#
x_aEN [Occ=Once!] ->
case x_aEN of wild_X1r {
__DEFAULT -> Foo.Text rb_dBr
rb_dBs wild_X1r;
0 -> wild_XR
}
},
case k_Xri of _ { GHC.Types.I#
y_XFr ->
case GHC.Prim.-# rb_dBt y_XFr of
wild_X1r {
__DEFAULT ->
Foo.Text rb_dBr (GHC.Prim.+#
rb_dBs y_XFr) wild_X1r;
0 -> wild_XR
}
})
} } in
let {
t_aqC :: Foo.Text
[LclId,
Unf=Unf{Src=<vanilla>, TopLvl=False,
Arity=0, Value=False,
ConLike=False, Cheap=True,
Expandable=True,
Guidance=IF_ARGS [] 10 0}]
t_aqC = case ds_dBj of _ { (_, t_Xra
[Occ=Once]) -> t_Xra } } in
case Foo.nullT ps_Xrd of _ {
GHC.Types.False ->
GHC.Types.:
@ Foo.Text
(case ds_dBj of _ { (h_aqB
[Occ=Once], _) -> h_aqB })
(case Foo.nullT t_aqC of _ {
GHC.Types.False -> linesT_XkT
(Foo.unsafeTail t_aqC);
GHC.Types.True -> GHC.Types.[]
@ Foo.Text
});
GHC.Types.True -> GHC.Types.[] @
Foo.Text
}}]
linesT_XkT =
\ (ps_Xrd :: Foo.Text) ->
case ps_Xrd
of _
{ Foo.Text rb_XC2 [Dmd=Just L]
rb_XC4 [Dmd=Just L]
rb_XC6 [Dmd=Just L] ->
case GHC.Prim.<=# rb_XC6 0 of _ {
GHC.Types.False ->
let {
k_Xrh [Dmd=Just D(L)] :: GHC.Types.Int
[LclId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=False,
ConLike=False, Cheap=False,
Expandable=False,
Guidance=IF_ARGS [] 123 110}]
k_Xrh =
letrec {
$wloop_sHE [Occ=LoopBreaker] ::
GHC.Prim.Int# -> GHC.Prim.Int#
[LclId,
Arity=1,
Str=DmdType L,
Unf=Unf{Src=<vanilla>, TopLvl=False,
Arity=1, Value=True,
ConLike=True, Cheap=True,
Expandable=True,
Guidance=IF_ARGS [0] 63 0}]
$wloop_sHE =
\ (ww_sHp :: GHC.Prim.Int#) ->
case GHC.Prim.>=# ww_sHp rb_XC6 of _ {
GHC.Types.False ->
case GHC.Prim.chr#
(GHC.Prim.word2Int#
(GHC.Prim.indexWord16Array# rb_XC2 ww_sHp))
of _ {
__DEFAULT -> $wloop_sHE
(GHC.Prim.+# ww_sHp 1);
'\n' -> ww_sHp
};
GHC.Types.True -> ww_sHp
}; } in
case $wloop_sHE 0 of ww_sHt { __DEFAULT ->
GHC.Types.I# ww_sHt
} } in
GHC.Types.:
@ Foo.Text
(case k_Xrh of _ { GHC.Types.I# x_aEN [Dmd=Just
L] ->
case x_aEN of wild_X1q [Dmd=Just L] {
__DEFAULT -> Foo.Text rb_XC2 rb_XC4
wild_X1q;
0 -> wild_XR
}
})
(case k_Xrh of _ { GHC.Types.I# y_XFq [Dmd=Just
L] ->
case GHC.Prim.-# rb_XC6 y_XFq of wild_X1q
[Dmd=Just L] {
__DEFAULT -> $w$j_XIm rb_XC2 (GHC.Prim.+#
rb_XC4 y_XFq) wild_X1q;
0 -> $w$j_XIm rb_XBR rb_XBT rb_XBV
}
});
GHC.Types.True -> GHC.Types.[] @ Foo.Text
}
};
$w$j_XIm
:: GHC.Prim.ByteArray#
-> GHC.Prim.Int# -> GHC.Prim.Int# -> [Foo.Text]
[LclId,
Arity=3,
Str=DmdType LLL,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=3,
Value=True,
ConLike=True, Cheap=True, Expandable=True,
Guidance=IF_ARGS [0 0 0] 160 10}]
$w$j_XIm =
\ (w_sHz [Dmd=Just L, Lbv=OneShot] ::
GHC.Prim.ByteArray#)
(w_sHA [Dmd=Just L, Lbv=OneShot] :: GHC.Prim.Int#)
(w_sHB [Dmd=Just L, Lbv=OneShot] :: GHC.Prim.Int#) ->
case GHC.Prim.<=# w_sHB 0 of _ {
GHC.Types.False ->
let {
a_sEG [Dmd=Just L] :: GHC.Prim.Word#
[LclId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=False, Arity=0,
Value=False,
ConLike=False, Cheap=True,
Expandable=True,
Guidance=IF_ARGS [] 1 0}]
a_sEG = GHC.Prim.indexWord16Array# w_sHz w_sHA
} in
case GHC.Prim.ltWord# a_sEG __word 55296 of _ {
GHC.Types.False ->
case GHC.Prim.gtWord# a_sEG __word 56319 of _
{
GHC.Types.False ->
linesT_XkT
(Foo.Text w_sHz (GHC.Prim.+# w_sHA 2)
(GHC.Prim.-# w_sHB 2));
GHC.Types.True ->
linesT_XkT
(Foo.Text w_sHz (GHC.Prim.+# w_sHA 1)
(GHC.Prim.-# w_sHB 1))
};
GHC.Types.True ->
linesT_XkT
(Foo.Text w_sHz (GHC.Prim.+# w_sHA 1)
(GHC.Prim.-# w_sHB 1))
};
GHC.Types.True -> GHC.Types.[] @ Foo.Text
}; } in
$w$j_XIm rb_XBR rb_XBT rb_XBV
}
}
});
GHC.Types.True -> GHC.Types.[] @ Foo.Text
}
}
end Rec }
*** End of Offense ***
}}}
--
Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/5359#comment:1>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler
_______________________________________________
Glasgow-haskell-bugs mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs
