Returning nested unboxed tuples crashes the code generator on x86_64 Linux
Compiling the following program with GHC 7.0.3 running on a 64 bit Linux machine crashes with a GHC panic:
$ uname -a
Linux pandora 2.6.32-5-amd64 #1 SMP Fri Sep 9 20:23:16 UTC 2011 x86_64 GNU/Linux
$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 7.0.3
$ cat unboxed.hs
{-# LANGUAGE MagicHash, UnboxedTuples, BangPatterns #-}
import GHC.Exts
foo :: Double# -> (# (# Double#, Double# #), Double# #)
foo x = (# (# x, x #), x #)
{-# NOINLINE foo #-}
main :: IO ()
main = print $ let !(# !(# y, z #), w #) = foo 10.0##
in D# (y +## z +## w)
$ ghc unboxed.hs
[1 of 1] Compiling Main ( unboxed.hs, unboxed.o )
ghc: panic! (the 'impossible' happened)
(GHC version 7.0.3 for x86_64-unknown-linux):
cgPanic
sat_siH{v} [lid]
static binds for:
local binds for:
x{v siq} [lid]
SRT label foo{v rcY}_srt
Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug
The expected behavior is compiling correctly and outputting 30.0. In fact, this is what happens if we remove the NOINLINE pragma or flatten the tuple.
Compiling this program with -dcore-lint
produces:
$ ghc unboxed.hs -dcore-lint
[1 of 1] Compiling Main ( unboxed.hs, unboxed.o )
*** Core Lint errors : in result of Desugar ***
<no location info>:
In a case alternative: ((#,#) ds_dil :: (# GHC.Prim.Double#,
GHC.Prim.Double# #),
w_ad4 :: GHC.Prim.Double#)
A variable has unboxed tuple type: ds_dil
Binder's type: (# GHC.Prim.Double#, GHC.Prim.Double# #)
*** Offending Program ***
Main.foo [InlPrag=NOINLINE]
:: GHC.Prim.Double#
-> (# (# GHC.Prim.Double#, GHC.Prim.Double# #), GHC.Prim.Double# #)
[LclId]
Main.foo =
\ (x_ad1 :: GHC.Prim.Double#) -> (# (# x_ad1, x_ad1 #), x_ad1 #)
Main.main :: GHC.Types.IO ()
[LclIdX]
Main.main =
GHC.Base.$
@ GHC.Types.Double
@ (GHC.Types.IO ())
(System.IO.print @ GHC.Types.Double GHC.Float.$fShowDouble)
(case Main.foo 10.0 of _ { (# ds_dil, w_ad4 #) ->
case ds_dil of _ { (# y_ad2, z_ad3 #) ->
GHC.Types.D# (GHC.Prim.+## (GHC.Prim.+## y_ad2 z_ad3) w_ad4)
}
})
:Main.main :: GHC.Types.IO ()
[LclIdX]
:Main.main = GHC.TopHandler.runMainIO @ () Main.main
*** End of Offense ***
<no location info>:
Compilation had errors
GHC 6.12.1 running on a 32 Linux machine rejects the program:
$ uname -a
Linux golconda 2.6.32-5-686 #1 SMP Mon Jun 13 04:13:06 UTC 2011 i686 GNU/Linux
$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 6.12.1
$ ghc unboxed.hs
unboxed.hs:6:11:
Couldn't match kind `(#)' against `??'
When matching the kinds of `(# Double#, Double# #) :: (#)' and
`t :: ??'
Expected type: t
Inferred type: (# Double#, Double# #)
In the expression: (# x, x #)
This is also not the expected behavior, as the documentation says that unboxed tuples should be able to contain an object of any type. Also, this error message is less than maximally helpful.
By the way, the reason we are trying to nest unboxed tuples in the first place is because we are experimenting with using GHC as a compilation target, and our code generator wanted to emit a long unboxed tuple. We got a nice error message saying that the length limit on unboxed tuples was 62; would we please nest them? and on trying to nest them we tripped over this.
Trac metadata
Trac field | Value |
---|---|
Version | 7.0.3 |
Type | Bug |
TypeOfFailure | OtherFailure |
Priority | normal |
Resolution | Unresolved |
Component | Compiler |
Test case | |
Differential revisions | |
BlockedBy | |
Related | |
Blocking | |
CC | axch@mit.edu |
Operating system | |
Architecture |