unsafeCoerce# causing invalid assembly generation

Discovered by MichaelBurge on IRC:

{-# LANGUAGE MagicHash #-}

import GHC.Prim
import GHC.Types

x = D# ((unsafeCoerce# (5# :: Int#) :: Double#) +## 5.0##)

main = putStrLn $ show x

Compile with GHC 7.8, 8.0.1 or HEAD:

[1 of 1] Compiling Main             ( weird.hs, weird.o )
/tmp/ghc23262_0/ghc_2.s: Assembler messages:

/tmp/ghc23262_0/ghc_2.s:43:0: error:
     Error: junk `naughty x86_64 register' after expression
`gcc' failed in phase `Assembler'. (Exit code: 1)

Trac metadata

Trac field	Value
Version	8.1
Type	Bug
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

mentioned in issue #12161

changed weight to 5

added Tbug Trac import labels

I don't really think this is a bug. You used unsafeCoerce# in an invalid way, and you were lucky enough to get an error message. From the documentation of unsafeCoerce#:

The following uses of {\tt unsafeCoerce\#} are supposed to work (i.e. not lead to spurious compile-time or run-time crashes):

• Casting an unboxed type to another unboxed type of the same size (but not coercions between floating-point and integral types)

you were lucky enough to get an error message

But I did not get an error message! GHC is happily generating an assembly file with naughty x86_64 register in it! I think it should at least panic at that point instead of printing this. But ideally, the code generator would know more about the register set and do something sensible e.g. a proper error message ("unsafeCoerce# between float and int not supported as they live in separate registers" etc.).

Really, I should be getting a panic.

I agree with Omer.

Moreover CoreLint should check for bogus use of unsafeCoerce#.

Is anyone up for doing this?

Simon

added Pnormal label