LLVM code generation bug: decode . encode != id

[well-typed]

LLVM code generation bug: decode . encode != id

[Shimuuar]

I couldn't reproduce issue. But here is observation fromIntegral (53169::Word16) == -12367::Int16.

[thoughtpolice]

I've written a tiny bit of code to put this bug in the regression suite, but can't reproduce this either. Can you specifically list what GHC version you're using and what platform you're running on? (e.g. GHC 7.10.3 on i386/Linux or amd64/OSX, etc).

I'll push the test addition to a branch and report back here so you can test the reduced case and see if it triggers.

[Mathnerd314]

I was using NixOS / amd64:

• ghc 7.10.3 from NixOS/nixpkgs@1aff127, h1i19vw3ihg4qm143ypd92y2vqchy2c0-stack-1.1.0
• stack nightly-2016-05-08 resolver
• the LLVM backend with --nix-packages llvm35 --ghc-options "-fllvm"

After I rebuild it without LLVM, it wasn't there; similarly for testing it in GHCi. So maybe it's a GHC codegen bug?

Currently I'm rebuilding everything with LLVM again, to see if it's still there. Edit: yep, still there

[dcoutts]

Thanks for investigating. Yes, not good. Should get to the bottom of it.

[thoughtpolice]

Confirmed with GHC 7.10.3/LLVM 3.5 and GHC 8.0.1-rc4/LLVM 3.7 - the bug from a small reproducer trips this perfectly.

[thoughtpolice]

This can now be tripped by simply compiling the tests with -fllvm enabled (by adding it to a package binary-serialise-cbor in cabal.project, fixing stack.yaml or Nix expressions or whatever). Several tests fail, actually. I'll investigate a little and see if I can dig up anything.

[thoughtpolice]

I've minimized this quite far (thanks to -fhpc):

{-# LANGUAGE MagicHash #-}
module Main
  ( main -- :: IO ()
  ) where

import           Foreign.ForeignPtr       (withForeignPtr)
import           Foreign.Ptr
import           GHC.Exts

import           Data.ByteString          (ByteString)
import qualified Data.ByteString          as B
import qualified Data.ByteString.Internal as BS
import qualified Data.ByteString.Unsafe   as BU (unsafeTail)

withBsPtr :: (Ptr b -> a) -> ByteString -> a
withBsPtr f (BS.PS x off _) =
    BS.accursedUnutterablePerformIO $ withForeignPtr x $
        \(Ptr addr#) -> return $! (f (Ptr addr# `plusPtr` off))
{-# INLINE withBsPtr #-}

grabWord16 :: Ptr () -> Word
grabWord16 (Ptr ip#) = W# (byteSwap16# (indexWord16OffAddr# ip# 0#))
{-# INLINE grabWord16 #-}

trip :: ByteString -> Int
trip bs = fromIntegral (withBsPtr grabWord16 (BU.unsafeTail bs))
{-# INLINE trip #-}

main :: IO ()
main = print (trip $ B.pack [0x19, 0xcf, 0xb1])

Testing:

$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 7.10.3
$ llc -version | head -2
LLVM (http://llvm.org/):
  LLVM version 3.5.2
$
$ ghc -fforce-recomp -O2 Issue67.hs && ./Issue67
[1 of 1] Compiling Main             ( Issue67.hs, Issue67.o )
Linking Issue67 ...
53169
$ ghc -fforce-recomp -O2 Issue67.hs -fllvm && ./Issue67
[1 of 1] Compiling Main             ( Issue67.hs, Issue67.o )
Linking Issue67 ...
-12367

[thoughtpolice]

Even smaller:

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE MagicHash    #-}

module Main
  ( main -- :: IO ()
  ) where
import           GHC.Prim
import           GHC.Word

data T = T !Addr#

t :: T
t = T "\xcf\xb1"#

grabWord16 :: T -> Word
grabWord16 (T addr#) = W# (byteSwap16# (indexWord16OffAddr# addr# 0#))

trip :: Int
trip = fromIntegral (grabWord16 t)

main :: IO ()
main = print trip

[thoughtpolice]

Reported as GHC bug #12095.

[thoughtpolice]

Not actually a GHC bug, this is our bug! Commit incoming with a fix...

[dcoutts]

@thoughtpolice nice work tracking it down!