Merge branch 'master' into atomics
[ghc.git] / testsuite / tests / simplCore / should_compile / spec-inline.stderr
1
2 ==================== Tidy Core ====================
3 Result size of Tidy Core = {terms: 162, types: 61, coercions: 0}
4
5 Roman.foo3 :: GHC.Types.Int
6 [GblId, Str=DmdType b]
7 Roman.foo3 =
8   Control.Exception.Base.patError
9     @ GHC.Types.Int "spec-inline.hs:(19,5)-(29,25)|function go"#
10
11 Rec {
12 Roman.foo_$s$wgo [Occ=LoopBreaker]
13   :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
14 [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType <L,U><L,U>]
15 Roman.foo_$s$wgo =
16   \ (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#) ->
17     let {
18       a :: GHC.Prim.Int#
19       [LclId, Str=DmdType]
20       a =
21         GHC.Prim.+#
22           (GHC.Prim.+#
23              (GHC.Prim.+#
24                 (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# sc1 sc1) sc1) sc1) sc1)
25              sc1)
26           sc1 } in
27     case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=$# sc 0)
28     of _ {
29       GHC.Types.False ->
30         case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# sc 100)
31         of _ {
32           GHC.Types.False ->
33             case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# sc 500)
34             of _ {
35               GHC.Types.False ->
36                 Roman.foo_$s$wgo (GHC.Prim.-# sc 1) (GHC.Prim.+# a a);
37               GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# sc 3) a
38             };
39           GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# sc 2) sc1
40         };
41       GHC.Types.True -> 0
42     }
43 end Rec }
44
45 Roman.$wgo
46   :: Data.Maybe.Maybe GHC.Types.Int
47      -> Data.Maybe.Maybe GHC.Types.Int -> GHC.Prim.Int#
48 [GblId,
49  Arity=2,
50  Str=DmdType <S,1*U><S,1*U>,
51  Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=2, Value=True,
52          ConLike=True, WorkFree=True, Expandable=True,
53          Guidance=IF_ARGS [60 30] 256 0}]
54 Roman.$wgo =
55   \ (w :: Data.Maybe.Maybe GHC.Types.Int)
56     (w1 :: Data.Maybe.Maybe GHC.Types.Int) ->
57     case w1 of _ {
58       Data.Maybe.Nothing -> case Roman.foo3 of wild1 { };
59       Data.Maybe.Just x ->
60         case x of _ { GHC.Types.I# ipv ->
61         let {
62           a :: GHC.Prim.Int#
63           [LclId, Str=DmdType]
64           a =
65             GHC.Prim.+#
66               (GHC.Prim.+#
67                  (GHC.Prim.+#
68                     (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# ipv ipv) ipv) ipv) ipv)
69                  ipv)
70               ipv } in
71         case w of _ {
72           Data.Maybe.Nothing -> Roman.foo_$s$wgo 10 a;
73           Data.Maybe.Just n ->
74             case n of _ { GHC.Types.I# x2 ->
75             case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=$# x2 0)
76             of _ {
77               GHC.Types.False ->
78                 case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# x2 100)
79                 of _ {
80                   GHC.Types.False ->
81                     case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<$# x2 500)
82                     of _ {
83                       GHC.Types.False ->
84                         Roman.foo_$s$wgo (GHC.Prim.-# x2 1) (GHC.Prim.+# a a);
85                       GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# x2 3) a
86                     };
87                   GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# x2 2) ipv
88                 };
89               GHC.Types.True -> 0
90             }
91             }
92         }
93         }
94     }
95
96 Roman.foo_go [InlPrag=INLINE[0]]
97   :: Data.Maybe.Maybe GHC.Types.Int
98      -> Data.Maybe.Maybe GHC.Types.Int -> GHC.Types.Int
99 [GblId,
100  Arity=2,
101  Str=DmdType <S,1*U><S,1*U>m,
102  Unf=Unf{Src=Wrapper, TopLvl=True, Arity=2, Value=True,
103          ConLike=True, WorkFree=True, Expandable=True,
104          Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
105          Tmpl= \ (w [Occ=Once] :: Data.Maybe.Maybe GHC.Types.Int)
106                  (w1 [Occ=Once] :: Data.Maybe.Maybe GHC.Types.Int) ->
107                  case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }}]
108 Roman.foo_go =
109   \ (w :: Data.Maybe.Maybe GHC.Types.Int)
110     (w1 :: Data.Maybe.Maybe GHC.Types.Int) ->
111     case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }
112
113 Roman.foo2 :: GHC.Types.Int
114 [GblId,
115  Caf=NoCafRefs,
116  Str=DmdType m,
117  Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=0, Value=True,
118          ConLike=True, WorkFree=True, Expandable=True,
119          Guidance=IF_ARGS [] 10 20}]
120 Roman.foo2 = GHC.Types.I# 6
121
122 Roman.foo1 :: Data.Maybe.Maybe GHC.Types.Int
123 [GblId,
124  Caf=NoCafRefs,
125  Str=DmdType m2,
126  Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=0, Value=True,
127          ConLike=True, WorkFree=True, Expandable=True,
128          Guidance=IF_ARGS [] 10 20}]
129 Roman.foo1 = Data.Maybe.Just @ GHC.Types.Int Roman.foo2
130
131 Roman.foo :: GHC.Types.Int -> GHC.Types.Int
132 [GblId,
133  Arity=1,
134  Caf=NoCafRefs,
135  Str=DmdType <S,1*U>m,
136  Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
137          ConLike=True, WorkFree=True, Expandable=True,
138          Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
139          Tmpl= \ (n [Occ=Once!] :: GHC.Types.Int) ->
140                  case n of n1 { GHC.Types.I# _ ->
141                  Roman.foo_go (Data.Maybe.Just @ GHC.Types.Int n1) Roman.foo1
142                  }}]
143 Roman.foo =
144   \ (n :: GHC.Types.Int) ->
145     case n of _ { GHC.Types.I# ipv ->
146     case Roman.foo_$s$wgo ipv 6 of ww { __DEFAULT -> GHC.Types.I# ww }
147     }
148
149
150 ------ Local rules for imported ids --------
151 "SC:$wgo0" [ALWAYS]
152     forall (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#).
153       Roman.$wgo (Data.Maybe.Just @ GHC.Types.Int (GHC.Types.I# sc))
154                  (Data.Maybe.Just @ GHC.Types.Int (GHC.Types.I# sc1))
155       = Roman.foo_$s$wgo sc sc1
156
157