Update Trac ticket URLs to point to GitLab
[ghc.git] / testsuite / tests / simplCore / T9646 / readme.txt
1 This is a test for https://gitlab.haskell.org/ghc/ghc/issues/9646
2
3 The problem addressed in that ticket was that under some circumstances,
4 GHC < 7.10.3 was failing to perform eta reduction deterministically.
5
6 Compiling this code now (2016/03/16) under ghc-7.8.4 and git HEAD shows that
7 ghc-7.8.4 produces more complicated code, with a number of extra lambdas which
8 are completely absent in the fast version.
9
10 Git HEAD current produces:
11
12     letrec {
13       $wpoly_innerLoop2
14       $wpoly_innerLoop2 =
15         \ @ s ww ww1 ww2 ww3 ww4 w ->
16           case tagToEnum# (<# ww1 dt2) of _ {
17             False -> (# w, (W# ww2, W# ww3, W# ww4) #);
18             True ->
19               case indexWordArray# dt1 ww of w#2 { __DEFAULT ->
20               case indexWordArray# dt3 ww1 of w#3 { __DEFAULT ->
21               case timesWord2# w#2 w#3 of _ { (# ovf1, prod1 #) ->
22               case plusWord2# prod1 ww4 of _ { (# c, s1 #) ->
23               case plusWord2# ww3 ovf1 of _ { (# c1, s2 #) ->
24               case plusWord2# s2 c of _ { (# c2, s3 #) ->
25               $wpoly_innerLoop2
26                 (-# ww 1#) (+# ww1 1#) (plusWord# ww2 (plusWord# c1 c2)) s3 s1 w
27               }
28               }
29               }
30               }
31               }
32               }
33           }; } in ....
34
35 whereas ghc-7.8, for the same block produces:
36
37     letrec {
38       $wpoly_innerLoop2
39       $wpoly_innerLoop2 =
40         \ @ s ww ww1 ww2 ww3 ww4 ->
41           case tagToEnum# (<# ww1 dt2) of _ {
42             False ->
43               let {
44                 sum
45                 sum = W# ww4 } in
46               let {
47                 carrylo
48                 carrylo = W# ww3 } in
49               let {
50                 carryhi
51                 carryhi = W# ww2 } in
52               let {
53                 vx
54                 vx = (carryhi, carrylo, sum) } in
55               (\ eta -> (# eta, vx #)) `cast` ...;
56             True ->
57               let {
58                 ds3
59                 ds3 =
60                   case indexWordArray# dt1 ww of w#2 { __DEFAULT ->
61                   let {
62                     x
63                     x = W# w#2 } in
64                   (\ eta -> (# eta, x #)) `cast` ...
65                   } } in
66               let {
67                 lvl
68                 lvl =
69                   case indexWordArray# dt3 ww1 of w#2 { __DEFAULT ->
70                   let {
71                     x
72                     x = W# w#2 } in
73                   (\ eta -> (# eta, x #)) `cast` ...
74                   } } in
75               let {
76                 a
77                 a = -# ww 1 } in
78               let {
79                 a1
80                 a1 = +# ww1 1 } in
81               (\ eta ->
82                  case (ds3 `cast` ...) eta of _ { (# ipv, ipv3 #) ->
83                  case (lvl `cast` ...) ipv of _ { (# ipv4, ipv5 #) ->
84                  case ipv3 of _ { W# a2 ->
85                  case ipv5 of _ { W# b ->
86                  case timesWord2# a2 b of _ { (# ovf1, prod1 #) ->
87                  case plusWord2# prod1 ww4 of _ { (# c, s1 #) ->
88                  case plusWord2# ww3 ovf1 of _ { (# c1, s2 #) ->
89                  case plusWord2# s2 c of _ { (# c2, s3 #) ->
90                  (($wpoly_innerLoop2 a a1 (plusWord# ww2 (plusWord# c1 c2)) s3 s1)
91                   `cast` ...)
92                    ipv4
93                  }
94                  }
95                  }
96                  }
97                  }
98                  }
99                  }
100                  })
101               `cast` ...
102           }; } in ...
103
104 I suspect that in the ghc-7.8.4 case, the lambda:
105
106      (\ eta -> (# eta, x #)) `cast` ...
107
108 is preventing the inlining of the indexWordArray# operations.
109
110 Much of the code for this test was pulled from the primitive package:
111
112         https://hackage.haskell.org/package/primitive