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