[GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
16 messages Options
Reply | Threaded
Open this post in threaded view
|

[GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
           Reporter:  bgamari        |             Owner:  (none)
               Type:  bug            |            Status:  new
           Priority:  high           |         Milestone:  8.4.1
          Component:  Compiler       |           Version:  8.2.1
  (CodeGen)                          |
           Keywords:                 |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 In #14222 it was noted that something appears to be broken in
 `CmmCommonBlockElim`. Consider the program from that ticket,
 {{{#!hs
 module T14221 where

 import Data.Text as T

 isNumeric :: Text -> Bool
 isNumeric t =
     T.all isNumeric' t && T.any isNumber t
   where
     isNumber c = '0' <= c && c <= '9'
     isNumeric' c = isNumber c
                 || c == 'e'
                 || c == 'E'
                 || c == '.'
                 || c == '-'
                 || c == '+'
 }}}
 This program produces six copies of a block of the form,
 {{{#!c
       c6JT:
           R2 = I64[R1 + 7];
           R1 = P64[Sp + 8];
           Sp = Sp + 16;
           call $wloop_all_s6CQ_info(R2, R1) args: 8, res: 0, upd: 8;
 }}}
 in the `-ddump-opt-cmm` output, which are manifest in the assembler as,
 {{{#!asm
 block_c6JT_info:
 _c6JT:
         movq 7(%rbx),%r14
         movq 8(%rbp),%rbx
         addq $16,%rbp
         jmp $wloop_all_s6CQ_info
 }}}

 CBE really ought to be catching these.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Old description:

> In #14222 it was noted that something appears to be broken in
> `CmmCommonBlockElim`. Consider the program from that ticket,
> {{{#!hs
> module T14221 where
>
> import Data.Text as T
>
> isNumeric :: Text -> Bool
> isNumeric t =
>     T.all isNumeric' t && T.any isNumber t
>   where
>     isNumber c = '0' <= c && c <= '9'
>     isNumeric' c = isNumber c
>                 || c == 'e'
>                 || c == 'E'
>                 || c == '.'
>                 || c == '-'
>                 || c == '+'
> }}}
> This program produces six copies of a block of the form,
> {{{#!c
>       c6JT:
>           R2 = I64[R1 + 7];
>           R1 = P64[Sp + 8];
>           Sp = Sp + 16;
>           call $wloop_all_s6CQ_info(R2, R1) args: 8, res: 0, upd: 8;
> }}}
> in the `-ddump-opt-cmm` output, which are manifest in the assembler as,
> {{{#!asm
> block_c6JT_info:
> _c6JT:
>         movq 7(%rbx),%r14
>         movq 8(%rbp),%rbx
>         addq $16,%rbp
>         jmp $wloop_all_s6CQ_info
> }}}
>
> CBE really ought to be catching these.
New description:

 In #14222 it was noted that something appears to be broken in
 `CmmCommonBlockElim`. Consider the program from that ticket,
 {{{#!hs
 module T14221 where

 import Data.Text as T

 isNumeric :: Text -> Bool
 isNumeric t =
     T.all isNumeric' t && T.any isNumber t
   where
     isNumber c = '0' <= c && c <= '9'
     isNumeric' c = isNumber c
                 || c == 'e'
                 || c == 'E'
                 || c == '.'
                 || c == '-'
                 || c == '+'
 }}}
 This program produces six copies of a block of the form,
 {{{
       c6JT:
           R2 = I64[R1 + 7];
           R1 = P64[Sp + 8];
           Sp = Sp + 16;
           call $wloop_all_s6CQ_info(R2, R1) args: 8, res: 0, upd: 8;
 }}}
 in the `-ddump-opt-cmm` output, which are manifest in the assembler as,
 {{{#!asm
 block_c6JT_info:
 _c6JT:
         movq 7(%rbx),%r14
         movq 8(%rbp),%rbx
         addq $16,%rbp
         jmp $wloop_all_s6CQ_info
 }}}

 CBE really ought to be catching these.

--

Comment (by bgamari):

 I had a quick look at this; it turns out that the reason that CBE doesn't
 work is 73f836f5d57a3106029b573c42f83d2039d21d89, which modifies the hash
 function to include local registers. This may sound familiar to you,
 nomeata, as you wrote it to address #10397.

 Sadly this means that our ability to CBE is quite limited. It seems like
 we should likely revisit this decision.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:1>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by bgamari):

 Oh, actually, never mind. On further reflection I suppose CBE actually
 must look at local registers since they may be live across blocks. Indeed
 nomeata's patch was merely a change in the hash, which is an optimization,
 not a change in the behavior of the pass.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:2>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 OK, so now we are back to: why doesn't CBE eliminate the common blocks?

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:3>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by bgamari):

 Well, because we have an extremely narrow definition of "common". Namely,
 to be the same two blocks must be syntactically identical, including local
 register names. I don't know how often this happens in practice, but I'd
 imagine not terribly often.

 I think the criterion that you would ideally want is equivalence up to
 alpha renaming of local registers; unfortunately this would likely be
 considerably more costly to check for. This makes me wonder whether we
 shouldn't just try to avoid duplicating the blocks to begin with (e.g.
 addressing #14222 earlier in the compilation pipeline).

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:4>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by bgamari):

 One option would be to run CBE **after** register allocation; this would
 make it significantly more likely that two structurally similar blocks
 would look similar to CBE.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:5>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by bgamari):

 To make my objection in comment:4 more concrete, consider that you have
 the following two blocks (from the example in #14226),
 {{{
   c2VZ: // global
       _c2Yd::I64 = _s2Se::I64 + 1;
       _s2Sx::I64 = _c2Yd::I64;
       _s2Se::I64 = _s2Sx::I64;
       goto c2TE;
   c2VY: // global
       _c2Yb::I64 = _s2Se::I64 + 1;
       _s2Sw::I64 = _c2Yb::I64;
       _s2Se::I64 = _s2Sw::I64;
       goto c2TE;
 }}}
 They differ in only two local register names, both of which are dead
 outside of their respective blocks. Ignoring the fact that the sinking
 pass should eliminate both intermediate locals, it seems to me like CBE
 should really consider these blocks to be duplicates.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:6>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  new
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 OK, got it.  Yes, totally.  CBE should be insensitive to alpha-renaming of
 local register.

 One way to do this would be for the hashing function to be sensitive to
 binding sites.  Concretely, suppose that we had
 {{{
 hashInstrs :: HashEnv -> [Instruction] -> HashCode
 type HashEnv = (Map LocalReg HashCode, Int)
 }}}
 Now we could have
 {{{
 hashInstrs (env, next) (Load reg expr : instrs)
   = hashInstrs (extendEnv env reg next, next+1) instrs
     `hashPlus` hashExpr env expr

 ...

 hashExpr env (LocalReg r)
   | Just hc <- lookupEnv env r = hc
   | otherwise = hashLocalReg r  -- as now
 }}}
 The mapping tells what hashcode to use for a local register. We deBruijn-
 number all binding sites as we come across them, mapping them to 1, 2, 3,
 etc. Now we'll be insensitive to what name is chosen.

 I think we already have a function that, for an instruction, says what
 local regs it assigns to.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:7>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  patch
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):  Phab:D3973
       Wiki Page:                    |
-------------------------------------+-------------------------------------
Changes (by bgamari):

 * status:  new => patch
 * differential:   => Phab:D3973


Comment:

 Phab:D3973 implements the equivalence-up-to-alpha-renaming idea described
 above.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:8>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  patch
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #9157             |  Differential Rev(s):  Phab:D3973
       Wiki Page:                    |
-------------------------------------+-------------------------------------
Changes (by bgamari):

 * related:   => #9157


Comment:

 It turns out this was also previously reported as #9157.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:9>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  patch
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #9157             |  Differential Rev(s):  Phab:D3973
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by Ben Gamari <ben@…>):

 In [changeset:"7920a7d9c53083b234e060a3e72f00b601a46808/ghc" 7920a7d/ghc]:
 {{{
 #!CommitTicketReference repository="ghc"
 revision="7920a7d9c53083b234e060a3e72f00b601a46808"
 cmm/CBE: Collapse blocks equivalent up to alpha renaming of local
 registers

 As noted in #14226, the common block elimination pass currently
 implements an extremely strict equivalence relation, demanding that two
 blocks are equivalent including the names of their local registers. This
 is quite restrictive and severely hampers the effectiveness of the pass.

 Here we allow the CBE pass to collapse blocks which are equivalent up to
 alpha renaming of locally-bound local registers. This is completely safe
 and catches many more duplicate blocks.

 Test Plan: Validate

 Reviewers: austin, simonmar, michalt

 Reviewed By: michalt

 Subscribers: rwbarton, thomie

 GHC Trac Issues: #14226

 Differential Revision: https://phabricator.haskell.org/D3973
 }}}

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:10>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  patch
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #9157             |  Differential Rev(s):  Phab:D3973
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by simonpj):

 Ben I forgot to mention this. In `CmmExpr` you'll find
 `foldLocalRegsDefd`, which is, I think, precisely what you need to answer
 the question "which local regs does this node define".  It would be much
 better to use it than to duplicate the logic into `hash_node` and
 `eqMiddleWith`.

 Might you look at doing that?

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:11>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  patch
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #9157             |  Differential Rev(s):  Phab:D3973,
       Wiki Page:                    |  Phab:D3999
-------------------------------------+-------------------------------------
Changes (by bgamari):

 * differential:  Phab:D3973 => Phab:D3973, Phab:D3999


Comment:

 Suggestion in comment:11 done in Phab:D3999.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:12>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  patch
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #9157             |  Differential Rev(s):  Phab:D3973,
       Wiki Page:                    |  Phab:D3999
-------------------------------------+-------------------------------------

Comment (by Ben Gamari <ben@…>):

 In [changeset:"9aa73892e10e90a1799b9277da593e816a827364/ghc"
 9aa73892/ghc]:
 {{{
 #!CommitTicketReference repository="ghc"
 revision="9aa73892e10e90a1799b9277da593e816a827364"
 cmm/CBE: Use foldLocalRegsDefd

 Simonpj suggested this as a follow-on to #14226 to avoid code
 duplication. This also gives us the ability to CBE cases involving
 foreign calls for free.

 Test Plan: Validate

 Reviewers: austin, simonmar, simonpj

 Reviewed By: simonpj

 Subscribers: michalt, simonpj, rwbarton, thomie

 GHC Trac Issues: #14226

 Differential Revision: https://phabricator.haskell.org/D3999
 }}}

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:13>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  closed
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:  fixed             |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #9157             |  Differential Rev(s):  Phab:D3973,
       Wiki Page:                    |  Phab:D3999
-------------------------------------+-------------------------------------
Changes (by bgamari):

 * status:  patch => closed
 * resolution:   => fixed


Comment:

 This should now be resolved.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:14>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets
Reply | Threaded
Open this post in threaded view
|

Re: [GHC] #14226: Common Block Elimination pass doesn't eliminate common blocks

GHC - devs mailing list
In reply to this post by GHC - devs mailing list
#14226: Common Block Elimination pass doesn't eliminate common blocks
-------------------------------------+-------------------------------------
        Reporter:  bgamari           |                Owner:  (none)
            Type:  bug               |               Status:  closed
        Priority:  high              |            Milestone:  8.4.1
       Component:  Compiler          |              Version:  8.2.1
  (CodeGen)                          |
      Resolution:  fixed             |             Keywords:  newcomer
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:  #9157             |  Differential Rev(s):  Phab:D3973,
       Wiki Page:                    |  Phab:D3999
-------------------------------------+-------------------------------------
Changes (by bgamari):

 * keywords:   => newcomer


--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14226#comment:15>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler

_______________________________________________
ghc-tickets mailing list
[hidden email]
http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-tickets