#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.11 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 RyanGlScott): This doesn't appear to be specific to generics. Rather, it's an issue with `eqAddr#` and how it's affected by optimization levels. Here's a simplified example that takes away the complexity of `GEq1`: {{{#!hs {-# LANGUAGE MagicHash #-} module Main (main) where import GHC.Exts (Addr#, isTrue#) import GHC.Prim (eqAddr#) data A = A { runA :: Addr# } a :: A a = A "a"# main :: IO () main = print (isTrue# (eqAddr# (runA a) (runA a))) }}} Compiling this with `-O0` makes the program return `True`, but compiling with `-O1` or higher returns `False`. Is pointer equality unpredictable enough that it can fail the reflexive property if optimized enough? If so, I can just modify `GEq1` so as not to include `Addr#`. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: patch Priority: normal | Milestone: Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11312 | Differential Rev(s): Phab:D1714 Wiki Page: | -------------------------------------+------------------------------------- Changes (by RyanGlScott): * status: new => patch * differential: => Phab:D1714 * related: => #11312 Comment: Adding `{-# NOINLINE #-}` pragmas does indeed do the trick. I've opened Phab:D1714 for that workaround. I've also opened #11312 regarding the inlining issue. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11312 | Differential Rev(s): Phab:D1714 Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * status: patch => new Comment: RyanGlScott, did you mean to add a `T11292` test in this diff? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:5 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: normal | Milestone: Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11312 | Differential Rev(s): Phab:D1714 Wiki Page: | -------------------------------------+------------------------------------- Changes (by thomie): * status: new => closed * resolution: => fixed Comment: Replying to [comment:6 RyanGlScott]:

I should probably add a standalone test for this behavior

I don't know, but this issue is fixed. `TEST=GEq1 WAY=optasm` is passing again. Thanks. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:7 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: normal | Milestone: Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11312 | Differential Rev(s): Phab:D1714 Wiki Page: | -------------------------------------+------------------------------------- Comment (by RyanGlScott): Replying to [comment:8 simonpj]:

Where is this `eqAddr#` test coming from?? It's utterly bogus to compare two strings by address. This is functional programming!

I'm very uncomfortable about "fixing" this by some new delicate stuff

We have to test `eqAddr#` here because that's how `deriving Eq` deals with `Addr#`. `Addr#` is [http://git.haskell.org/ghc.git/blob/2f923ce2ab8bad6d01645c735c81bbf1b9ff1e05... one of six] privileged unlifted types which a datatype can have and still have a derived `Eq`/`Ord` instance. Internally, the `deriving` machinery compares `Addr#` fields in a datatype with `eqAddr#`/`ltAddr#`/etc., so this test just checks to see if GHC generics is equally as expressive. like NOINLINE pragmas, especially as they are entirely un-explained. I'm inclined to agree, but if we do fix this, we'd probably need to change the way `Addr#` is dealt with in datatypes as well for the sake of consistency. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:9 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: normal | Milestone: Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11312 | Differential Rev(s): Phab:D1714 Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj):

I'm inclined to agree, but if we do fix this, we'd probably need to change the way `Addr#` is dealt with in datatypes as well for the sake of consistency.

No... an `Addr#` might be returned from C-land by `malloc`, and might be perfectly stable. It's just that primitive strings should not be compared with `eqAddr#`. The bug is that primitive strings have type `Addr#`; they should have type `String#`. And to compare `String#` you should use `strcmp`. I suppose that means a new primitive type and family of operations over it... but that looks to me like the Right Thing to do. This NOINLINE stuff looks desperately fragile.... a bug waiting to happen. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:11 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: normal | Milestone: Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11312 | Differential Rev(s): Phab:D1714 Wiki Page: | -------------------------------------+------------------------------------- Comment (by RyanGlScott): I suppose I could just replace the primitive string literals with `nullAddr#`, no? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#11292: Generics unboxed types: TEST=GEq1 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: normal | Milestone: Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #11312 | Differential Rev(s): Phab:D1714 Wiki Page: | -------------------------------------+------------------------------------- Comment (by RyanGlScott): At the moment I'm only testing if something with unlifted types can be equal to itself, so one `Addr#` suffices. I could conceivably add a test for two things that aren't equal, in which the two unequal fields are something like `nullAddr#` and `plusAddr# 1# nullAddr#` (disclaimer: I don't know how safe that would be in general). -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/11292#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler