Skip to content

ghc 7.0.1 and 7.1.20101112+ panic building blaze-builder-0.2.0.1

When building blaze-builder-0.2.0.1, ghc 7.0.1 (I've tried ghc 7.1.20101112 and 7.1.20101115 also) spits this:

Building blaze-builder-0.2.0.1...
[1 of 8] Compiling Blaze.ByteString.Builder.Internal ( Blaze\ByteString\Builder\Internal.hs, dist\build\Blaze\ByteString\Builder\Internal.o )
ghc.exe: panic! (the 'impossible' happened)
  (GHC version 7.0.1 for i386-unknown-mingw32):
        dsLet: unlifted
    AbsBinds
    [b{tv aW1} [sk]]
    []
    [pe{v ax5} [lid] <= [b{tv aW1} [sk]] pe{v aW0} [lid]]
      pe{v ax5} [lid]
        :: forall b{tv aW1} [sk]. base:GHC.Ptr.Ptr{tc 33A} b{tv aW1} [sk]
      [LclId]
      { {273:19-54}
        {273:19-54}
        !((pe{v aW0} [lid] :: base:GHC.Ptr.Ptr{tc 33A} b{tv aW1} [sk]))
          = {273:30-54}
            {273:33-41}
            (base:GHC.Ptr.plusPtr{v r4T} [gid]) @ base:GHC.Word.Word8{tc 32U}
            @ b{tv aW1} [sk]
              pf{v ax4} [lid] firstBufSize{v arJ} [lid] }
    EvBinds{{}}
    base:GHC.Base.>>={v 01P} [gid[ClassOp]]
      @ <nt>ghc-prim:GHC.Types.IO{tc 32I}
      $dMonad{v aW2} [lid]
      @ blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildSignal{tc rr6}
      @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
      (step0{v arQ} [lid]
         pf{v ax4} [lid] (pe{v ax5} [lid] @ base:GHC.Word.Word8{tc 32U}))
      (\ (next{v axL} [lid]
            :: blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildSignal{tc rr6}) ->
         let {
           ds_d16v{v} [lid]
             :: blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildSignal{tc rr6}
           [LclId]
           ds_d16v{v} [lid] = next{v axL} [lid] } in
         case ds_d16v{v} [lid] {ghc-prim:GHC.Types.IO{tc 32I}
                                  bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}}
         of (wild_B1{v} [lid]
               :: blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildSignal{tc rr6}) {
           blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.Done{d rrc} (rb_d16F{v} [lid]
                                                                                  :: ghc-prim:GHC.Prim.Addr#{(w) tc 33}) ->
             let {
               pf'{v axM} [lid]
                 :: base:GHC.Ptr.Ptr{tc 33A} base:GHC.Word.Word8{tc 32U}
               [LclId]
               pf'{v axM} [lid] =
                 base:GHC.Ptr.Ptr{v rcL} [gid[DataCon]]
                   @ base:GHC.Word.Word8{tc 32U} rb_d16F{v} [lid] } in
             let {
               fail_d16w{v} [lid]
                 :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                      ghc-prim:GHC.Prim.RealWorld{(w) tc 31E}
                    -> ghc-prim:GHC.Types.IO{tc 32I}
                         bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
               [LclId]
               fail_d16w{v} [lid] =
                 \ (ds_d16x{v} [lid]
                      :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                           ghc-prim:GHC.Prim.RealWorld{(w) tc 31E}) ->
                   base:GHC.Base.${v 019} [gid]
                     @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
                     @ (ghc-prim:GHC.Types.IO{tc 32I}
                          bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                     (base:GHC.Base.return{v 01T} [gid[ClassOp]]
                        @ <nt>ghc-prim:GHC.Types.IO{tc 32I}
                        $dMonad{v aW7} [lid]
                        @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                     (bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.$WChunk{v reB} [gid[DataConWrapper]]
                        (mkbs{v ax6} [lid] @ base:GHC.Word.Word8{tc 32U} pf'{v axM} [lid])
                        k{v arL} [lid]) } in
             case base:GHC.Classes.=={v 01L} [gid[ClassOp]]
                    @ (base:GHC.Ptr.Ptr{tc 33A} base:GHC.Word.Word8{tc 32U})
                    $dEq{v aW4} [lid]
                    pf'{v axM} [lid]
                    pf{v ax4} [lid] {ghc-prim:GHC.Types.IO{tc 32I}
                                       bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}}
             of (wild_B1{v} [lid] :: ghc-prim:GHC.Bool.Bool{(w) tc 3c}) {
               ghc-prim:GHC.Bool.False{(w) d 68} ->
                 fail_d16w{v} [lid] ghc-prim:GHC.Prim.realWorld#{(w) v 0o} [gid];
               ghc-prim:GHC.Bool.True{(w) d 6u} ->
                 base:GHC.Base.return{v 01T} [gid[ClassOp]]
                   @ <nt>ghc-prim:GHC.Types.IO{tc 32I}
                   $dMonad{v aW5} [lid]
                   @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
                   k{v arL} [lid]
             };
           blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BufferFull{d rra} (rb_d16H{v} [lid]
                                                                                        :: ghc-prim:GHC.Prim.Int#{(w) tc 3G})
                                                                                     (rb_d16I{v} [lid]
                                                                                        :: ghc-prim:GHC.Prim.Addr#{(w) tc 33})
                                                                                     (nextStep{v axP} [lid]
                                                                                        :: blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildStep{tc rr4}) ->
             let {
               newSize{v axN} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J}
               [LclId]
               newSize{v axN} [lid] =
                 ghc-prim:GHC.Types.I#{(w) v 6d} [gid[DataCon]]
                   rb_d16H{v} [lid] } in
             let {
               pf'{v axO} [lid]
                 :: base:GHC.Ptr.Ptr{tc 33A} base:GHC.Word.Word8{tc 32U}
               [LclId]
               pf'{v axO} [lid] =
                 base:GHC.Ptr.Ptr{v rcL} [gid[DataCon]]
                   @ base:GHC.Word.Word8{tc 32U} rb_d16I{v} [lid] } in
             let {
               l{v aW9} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J}
               [LclId]
               l{v aW9} [lid] =
                 base:GHC.Ptr.minusPtr{v r4Q} [gid]
                   @ base:GHC.Word.Word8{tc 32U}
                   @ base:GHC.Word.Word8{tc 32U}
                   pf'{v axO} [lid]
                   pf{v ax4} [lid] } in
             case l{v aW9} [lid]
             {ghc-prim:GHC.Types.IO{tc 32I}
                bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}}
             of (l{v aW9} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J})
             { __DEFAULT ->
             let {
               l{v axQ} [lid] :: ghc-prim:GHC.Types.Int{(w) tc 3J}
               [LclId]
               l{v axQ} [lid] = l{v aW9} [lid] } in
             base:GHC.Base.${v 019} [gid]
               @ blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildStep{tc rr4}
               @ (ghc-prim:GHC.Types.IO{tc 32I}
                    bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
               (fillNewBuffer{v arO} [lid]
                  (base:GHC.Classes.max{v rC} [gid[ClassOp]]
                     @ ghc-prim:GHC.Types.Int{(w) tc 3J}
                     $dOrd{v aWa} [lid]
                     (base:GHC.Num.+{v r20} [gid[ClassOp]]
                        @ ghc-prim:GHC.Types.Int{(w) tc 3J}
                        $dNum{v aZq} [lid]
                        l{v axQ} [lid]
                        newSize{v axN} [lid])
                     minBufSize{v arI} [lid]))
               (\ (pfNew{v axR} [lid]
                     :: base:GHC.Ptr.Ptr{tc 33A} base:GHC.Word.Word8{tc 32U})
                  (peNew{v axS} [lid]
                     :: base:GHC.Ptr.Ptr{tc 33A} base:GHC.Word.Word8{tc 32U}) ->
                  base:GHC.Base.>>{v 01Q} [gid[ClassOp]]
                    @ <nt>ghc-prim:GHC.Types.IO{tc 32I}
                    $dMonad{v aZr} [lid]
                    @ ghc-prim:GHC.Unit.(){(w) tc 40}
                    @ blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildSignal{tc rr6}
                    (base:Foreign.Marshal.Utils.copyBytes{v r48} [gid]
                       @ base:GHC.Word.Word8{tc 32U}
                       pfNew{v axR} [lid]
                       pf{v ax4} [lid]
                       l{v axQ} [lid])
                    (nextStep{v axP} [lid]
                       (base:GHC.Ptr.plusPtr{v r4T} [gid]
                          @ base:GHC.Word.Word8{tc 32U}
                          @ base:GHC.Word.Word8{tc 32U}
                          pfNew{v axR} [lid]
                          l{v axQ} [lid])
                       peNew{v axS} [lid]))
             };
           blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.ModifyChunks{d rr8} (rb_d16K{v} [lid]
                                                                                          :: ghc-prim:GHC.Prim.Addr#{(w) tc 33})
                                                                                       (bsk{v axU} [lid]
                                                                                          :: bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
                                                                                             -> bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                                                                                       (nextStep{v axV} [lid]
                                                                                          :: blaze-builder-0.2.0.1:Blaze.ByteString.Builder.Internal.BuildStep{tc rr4}) ->
             let {
               pf'{v axT} [lid]
                 :: base:GHC.Ptr.Ptr{tc 33A} base:GHC.Word.Word8{tc 32U}
               [LclId]
               pf'{v axT} [lid] =
                 base:GHC.Ptr.Ptr{v rcL} [gid[DataCon]]
                   @ base:GHC.Word.Word8{tc 32U} rb_d16K{v} [lid] } in
             let {
               fail_d16A{v} [lid]
                 :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                      ghc-prim:GHC.Prim.RealWorld{(w) tc 31E}
                    -> ghc-prim:GHC.Types.IO{tc 32I}
                         bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
               [LclId]
               fail_d16A{v} [lid] =
                 \ (ds_d16B{v} [lid]
                      :: ghc-prim:GHC.Prim.State#{(w) tc 32q}
                           ghc-prim:GHC.Prim.RealWorld{(w) tc 31E}) ->
                   base:GHC.Base.${v 019} [gid]
                     @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
                     @ (ghc-prim:GHC.Types.IO{tc 32I}
                          bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                     (base:GHC.Base.return{v 01T} [gid[ClassOp]]
                        @ <nt>ghc-prim:GHC.Types.IO{tc 32I}
                        $dMonad{v aZw} [lid]
                        @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                     (bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.$WChunk{v reB} [gid[DataConWrapper]]
                        (mkbs{v ax6} [lid] @ base:GHC.Word.Word8{tc 32U} pf'{v axT} [lid])
                        (bsk{v axU} [lid]
                           (base:GHC.Base.${v 019} [gid]
                              @ (ghc-prim:GHC.Types.IO{tc 32I}
                                   bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                              @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
                              (bytestring-0.9.1.8:Data.ByteString.Internal.inlinePerformIO{v riN} [gid]
                                 @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                              (fillNewBuffer{v arO} [lid]
                                 bufSize{v arH} [lid] nextStep{v axV} [lid])))) } in
             case base:GHC.Classes.=={v 01L} [gid[ClassOp]]
                    @ (base:GHC.Ptr.Ptr{tc 33A} base:GHC.Word.Word8{tc 32U})
                    $dEq{v aZt} [lid]
                    pf'{v axT} [lid]
                    pf{v ax4} [lid] {ghc-prim:GHC.Types.IO{tc 32I}
                                       bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}}
             of (wild_B1{v} [lid] :: ghc-prim:GHC.Bool.Bool{(w) tc 3c}) {
               ghc-prim:GHC.Bool.False{(w) d 68} ->
                 fail_d16A{v} [lid] ghc-prim:GHC.Prim.realWorld#{(w) v 0o} [gid];
               ghc-prim:GHC.Bool.True{(w) d 6u} ->
                 base:GHC.Base.${v 019} [gid]
                   @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
                   @ (ghc-prim:GHC.Types.IO{tc 32I}
                        bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                   (base:GHC.Base.return{v 01T} [gid[ClassOp]]
                      @ <nt>ghc-prim:GHC.Types.IO{tc 32I}
                      $dMonad{v aZu} [lid]
                      @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                   (bsk{v axU} [lid]
                      (base:GHC.Base.${v 019} [gid]
                         @ (ghc-prim:GHC.Types.IO{tc 32I}
                              bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                         @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX}
                         (bytestring-0.9.1.8:Data.ByteString.Internal.inlinePerformIO{v riN} [gid]
                            @ bytestring-0.9.1.8:Data.ByteString.Lazy.Internal.ByteString{tc rfX})
                         (fillNewBuffer{v arO} [lid]
                            bufSize{v arH} [lid] nextStep{v axV} [lid])))
             }
         })

Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug
Trac metadata
Trac field Value
Version 7.0.1
Type Bug
TypeOfFailure OtherFailure
Priority normal
Resolution Unresolved
Component Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture
Edited by awson
To upload designs, you'll need to enable LFS and have an admin enable hashed storage. More information