- ghc-devs - Haskell.org

Fwd: Changing GHC Error Message Wrapping
by Andrew Gibiansky 10 Jan '14

10 Jan '14

Hello, I'd like to change how the error messages from GHC get wrapped. I am using the following code: flip gcatch handler $ do runStmt "let f (x, y, z, w, e, r, d , ax, b ,c,ex ,g ,h) = (x :: Int) + y + z" RunToCompletion runStmt "f (1, 2, 3)" RunToCompletion return () where handler :: SomeException -> Ghc () handler e = liftIO $ putStrLn $ "Exception:\n" ++ show e The output I am getting looks like this: [image: Inline image 1] I would like the types to not wrap at all, or wrap at some very long length along the lines of 200-300 characters. I have seen the `pprUserLength` and `pprCols` fields in DynFlags, but they don't seem to do anything. What should I do? Thanks! Andrew

5 12

Optimisation flags at -O0
by Chris Heller 09 Jan '14

09 Jan '14

I wanted to understand better what `-fspec-constr` does. So I compiled the User Guide example with `-O0 -fspec-constr` to isolate the effects of call-pattern specialization, and nothing else (I used ghc-core to pretty-print the resulting Core syntax). It appears I get the same output wether I use `-fspec-constr` or not. Does this mean that compiling with `-O0` even explicitly enabled optimizations are turned off? If that is the case, how does one test an isolated optimization? -Chris

3 2

Cannot find normal object file when compiling TH code
by Yorick Laupa 09 Jan '14

09 Jan '14

Hi, Oddly I can't compile code using TH with GHC HEAD. Here's what I get: cannot find normal object file './Tuple.dyn_o' while linking an interpreted expression I'm currently working on a issue so I compile the code with ghc-stage2 for convenience. I found an old ticket related to my problem ( https://ghc.haskell.org/trac/ghc/ticket/8443) but adding -XTemplateHaskell didn't work out. The code compiles with ghc 7.6.3. Here's my setup: Archlinux (3.12.6-1) Any suggestions ? --Yorick

3 6

Tuple predicates in Template Haskell
by Yorick Laupa 08 Jan '14

08 Jan '14

Hi, I try to make my way through #7021 [1]. Unfortunately, there is nothing in the ticket about what should be expected from the code given as example. I came with an implementation and I would like feedback from you guys. So, considering this snippet: -- {-# LANGUAGE ConstraintKinds #-} type IOable a = (Show a, Read a) foo :: IOable a => a foo = undefined -- This is what I got now when pretty-printing TH.Info after reify "foo" call: VarI Tuple.foo (ForallT [PlainTV a_1627398594] [TupleP 2 [AppT (ConT GHC.Show.Show) (VarT a_1627398594),AppT (ConT GHC.Read.Read) (VarT a_1627398594)]] (VarT a_1627398594)) Nothing (Fixity 9 InfixL) Does that sound right to you ? Thanks for your time -- Yorick [1] https://ghc.haskell.org/trac/ghc/ticket/7021

2 2

LLVM and dynamic linking
by Ben Gamari 08 Jan '14

08 Jan '14

# The Problem Dynamic linking is currently broken with the LLVM code generator. This can be easily seen by attempting to compile GHC with, GhcDynamic = YES DYNAMIC_BY_DEFAULT = YES DYNAMIC_GHC_PROGRAMS = YES BuildFlavour = quick-llvm This build will fail with a error along the lines of, dll-split: internal error: invalid closure, info=0x402ec0 (GHC version 7.7.20131212 for x86_64_unknown_linux) Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug After some poking around with the help of Peter Wortmann, it seems clear that this is due to a subtle difference in how LLVM emits function symbols. While the NCG emits these symbols with `.type @object`, LLVM emits `.type @function`. It appears that the `.type` annotation guides the linker in choosing the relocation mechanism to use for the symbol. While `@object` symbols use the Global Offset Table, `@function` symbols are relocated through the Procedure Linking Table, a table of trampoline calls which are fixed up at runtime. This means that static references to functions end up pointing not to the object itself (and its info table) but instead to some linker-generated assembly. When the garbage collector attempts to examine the info table of one of these references, it finds nonsense and fails. # A solution Peter demonstrated that manually modifying the assembler produced by llc, passing this through GHC's mangler, and assembling the result yields a functional binary. As far as I can tell, LLVM's intermediate language doesn't expose any way to force a function to `.type @object`. Unfortunately this means that, at least for now, the only fix is to augment the mangler with logic to perform this transform. I've done this in my `llvm-dynamic` branch[1] (in addition to finding a bug in the `rewriteInstructions` function used by AVX rewriting). This branch compiles on my x86_64 machine to produce what appears to be a functional compiler. Unfortunately installation issues (which I'll describe shortly in a new thread) prevent me from verifying this. I'm currently waiting for a build on my ARM box but assuming this fix works this means that GHC could (finally) have first-class, stable ARM support. Comments? Cheers, - Ben [1] https://github.com/bgamari/ghc/tree/llvm-dynamic

3 6

Re: Pattern synonyms for 7.8?
by Dr. ÉRDI Gergő 08 Jan '14

08 Jan '14

Hi, please don't commit it just yet, I'd like the eventual single commit to also include the user documentation. Thanks, Gergo On Jan 8, 2014 10:46 PM, "Austin Seipp" <aseipp(a)pobox.com> wrote: > Oh, to be honest, I was just going to squash it into a single Big > Commit, with you set as the author, Gergo. This seems to be the > general way we do it for new features. > > If you'd like I can just go ahead and do this for you. > > On Wed, Jan 8, 2014 at 8:33 AM, Dr. ERDI Gergo <gergo(a)erdi.hu> wrote: > > On Wed, 8 Jan 2014, Simon Peyton Jones wrote: > > > >> It'd be good if what we finally commit to HEAD has a sensible history > > > > > > Yes, of course. I'll clean that up next week. I just have to run now. > > > > > > -- > > > > .--= ULLA! =-----------------. > > \ http://gergo.erdi.hu \ > > `---= gergo(a)erdi.hu =-------' > > Ha paranoiásokkal akarsz megismerkedni, kezdd el követni ôket. > > > > -- > Regards, > Austin - PGP: 4096R/0x91384671 >

1 0

Re: Pattern synonyms for 7.8?
by Dr. ERDI Gergo 08 Jan '14

08 Jan '14

On Wed, 8 Jan 2014, Austin Seipp wrote: > Oh, to be honest, I was just going to squash it into a single Big > Commit, with you set as the author, Gergo. This seems to be the > general way we do it for new features. > > If you'd like I can just go ahead and do this for you. Sure, thanks. I'm getting 8 unexpected test failures but I haven't tried them on master yet to see if they are caused by my code: driver T4437 [bad stdout] (normal) generics GenDerivOutput [stderr mismatch] (normal) generics GenDerivOutput1_0 [stderr mismatch] (normal) generics GenDerivOutput1_1 [stderr mismatch] (normal) perf/haddock haddock.Cabal [stat not good enough] (normal) perf/should_run T5237 [stat not good enough] (normal) rename/should_compile T7336 [stderr mismatch] (normal) th T8633 [bad exit code] (normal) I'll look at these next week when I'm back. Bye, Gergo

1 0

Re: Pattern synonyms for 7.8?
by Dr. ERDI Gergo 08 Jan '14

08 Jan '14

On Tue, 7 Jan 2014, Austin Seipp wrote: > Hi Gergo, > > Thanks for rebasing your changes. Unfortunately, they do not compile > cleanly with ./validate, which we really need to have working for all > incoming patches. I've fixed validation (but the commit history is a bit of a mess -- expect another history rewrite shortly. But the code is at the same location on github. Thanks, Gergo -- .--= ULLA! =-----------------. \ http://gergo.erdi.hu \ `---= gergo(a)erdi.hu =-------' Glob thinkally, loc actally

2 2

RE: GHC API: Using runGhc twice or from multiple threads?
by p.k.f.holzenspies＠utwente.nl 08 Jan '14

08 Jan '14

Dear Benno, Simon, > I think that both ought to be ok, but I'd welcome other input. > > GHC.runGHC calls initGhcMonad, which allocates an entirely new session (in > newHscEnv). So the two will work entirely independently. > > Unfortunately that's not 100% true. If you search for GLOBAL_VAR you'll see > a handful of disgusting global state variables, and they *will* be shared > between GHC sessions. > > There really aren't many. I'd love someone to eliminate them! (NB ghc- > devs) There is one open question about what you intend to do with the results of running those GHC-sessions. Correct me if I'm wrong (Simon, or anyone), but methinks you should be very careful with assigned Uniques, i.e. (Rdr/Occ)Name-things from one session shouldn't be used in the other and vice versa. I was wondering about this earlier; it would be nice to have some more explicit combinators for manipulating GHC API states (e.g. combining two HscEnvs, such that any NamedThing defined in either will also exist in the result). I thinks some updated documentation on some of the states (HscEnv, GblEnv, LclEnv, etc.) would help people not well-versed with the GHC-innerts to bend their mind around the API. Regards, Philip

1 0

Re: LLVM and dynamic linking
by Aaron Friel 08 Jan '14

08 Jan '14

Replying to include the email list. You’re right, the llvm backend and the gmp licensing issues are orthogonal - or should be. The problem is I get build errors when trying to build GHC with LLVM and dynamic libraries. The result is that I get a few different choices when producing a platform image for development, with some uncomfortable tradeoffs: 1. LLVM-built GHC, dynamic libs - doesn’t build. 2. LLVM-built GHC, static libs - potential licensing oddities with me shipping a statically linked ghc binary that is now gpled. I am not a lawyer, but the situation makes me uncomfortable. 3. GCC/ASM-built GHC, dynamic libs - this is the *standard* for most platforms shipping ghc binaries, but it means that one of the biggest and most critical users of the LLVM backend is neglecting it. It also bifurcates development resources for GHC. Optimization work is duplicated and already devs are getting into the uncomfortable position of suggesting to users that they should trust GHC to build your programs in a particular way, but not itself. 4. GCC/ASM-built GHC, static libs - worst of all possible worlds. Because of this, the libgmp and llvm-backend issues aren’t entirely orthogonal. Trac ticket #7885 is exactly the issue I get when trying to compile #1. From: Carter Schonwald<mailto:carter.schonwald@gmail.com> Sent: ‎Monday‎, ‎December‎ ‎30‎, ‎2013 ‎1‎:‎05‎ ‎PM To: Aaron Friel<mailto:aaron@frieltek.com> Good question but you forgot to email the mailing list too :-) Using llvm has nothing to do with Gmp. Use the native code gen (it's simper) and integer-simple. That said, standard ghc dylinks to a system copy of Gmp anyways (I think ). Building ghc as a Dylib is orthogonal. -Carter On Dec 30, 2013, at 1:58 PM, Aaron Friel <aaron(a)frieltek.com<mailto:aaron@frieltek.com>> wrote: Excellent research - I’m curious if this is the right thread to inquire about the status of trying to link GHC itself dynamically. I’ve been attempting to do so with various LLVM versions (3.2, 3.3, 3.4) using snapshot builds of GHC (within the past week) from git, and I hit ticket #7885 [https://ghc.haskell.org/trac/ghc/ticket/7885] every time (even the exact same error message). I’m interested in dynamically linking GHC with LLVM to avoid the entanglement with libgmp’s license. If this is the wrong thread or if I should reply instead to the trac item, please let me know. From: Carter Schonwald<mailto:carter.schonwald@gmail.com> Sent: ‎Friday‎, ‎December‎ ‎27‎, ‎2013 ‎2‎:‎41‎ ‎PM To: Ben Gamari<mailto:bgamari.foss@gmail.com> Cc: ghc-devs(a)haskell.org<mailto:ghc-devs@haskell.org> great work! :) On Fri, Dec 27, 2013 at 3:21 PM, Ben Gamari <bgamari.foss(a)gmail.com<mailto:bgamari.foss@gmail.com>> wrote: Simon Marlow <marlowsd(a)gmail.com<mailto:marlowsd@gmail.com>> writes: > This sounds right to me. Did you submit a patch? > > Note that dynamic linking with LLVM is likely to produce significantly > worse code that with the NCG right now, because the LLVM back end uses > dynamic references even for symbols in the same package, whereas the NCG > back-end uses direct static references for these. > Today with the help of Edward Yang I examined the code produced by the LLVM backend in light of this statement. I was surprised to find that LLVM's code appears to be no worse than the NCG with respect to intra-package references. My test case can be found here[2] and can be built with the included `build.sh` script. The test consists of two modules build into a shared library. One module, `LibTest`, exports a few simple members while the other module (`LibTest2`) defines members that consume them. Care is taken to ensure the members are not inlined. The tests were done on x86_64 running LLVM 3.4 and GHC HEAD with the patches[1] I referred to in my last message. Please let me know if I've missed something. # Evaluation ## First example ## The first member is a simple `String` (defined in `LibTest`), helloWorld :: String helloWorld = "Hello World!" The use-site is quite straightforward, testHelloWorld :: IO String testHelloWorld = return helloWorld With `-O1` the code looks reasonable in both cases. Most importantly, both backends use IP relative addressing to find the symbol. ### LLVM ### 0000000000000ef8 <rKw_info>: ef8: 48 8b 45 00 mov 0x0(%rbp),%rax efc: 48 8d 1d cd 11 20 00 lea 0x2011cd(%rip),%rbx # 2020d0 <libtestzm0zi1zi0zi0_LibTest_helloWorld_closure> f03: ff e0 jmpq *%rax 0000000000000f28 <libtestzm0zi1zi0zi0_LibTest2_testHelloWorld_info>: f28: eb ce jmp ef8 <rKw_info> f2a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) ### NCG ### 0000000000000d58 <rH1_info>: d58: 48 8d 1d 71 13 20 00 lea 0x201371(%rip),%rbx # 2020d0 <libtestzm0zi1zi0zi0_LibTest_helloWorld_closure> d5f: ff 65 00 jmpq *0x0(%rbp) 0000000000000d88 <libtestzm0zi1zi0zi0_LibTest2_testHelloWorld_info>: d88: eb ce jmp d58 <rH1_info> With `-O0` the code is substantially longer but the relocation behavior is still correct, as one would expect. Looking at the definition of `helloWorld`[3] itself it becomes clear that the LLVM backend is more likely to use PLT relocations over GOT. In general, `stg_*` primitives are called through the PLT. As far as I can tell, both of these call mechanisms will incur two memory accesses. However, in the case of the PLT the call will consist of two JMPs whereas the GOT will consist of only one. Is this a cause for concern? Could these two jumps interfere with prediction? In general the LLVM backend produces a few more instructions than the NCG although this doesn't appear to be related to handling of relocations. For instance, the inexplicable (to me) `mov` at the beginning of LLVM's `rKw_info`. ## Second example ## The second example demonstrates an actual call, -- Definition (in LibTest) infoRef :: Int -> Int infoRef n = n + 1 -- Call site testInfoRef :: IO Int testInfoRef = return (infoRef 2) With `-O1` this produces the following code, ### LLVM ### 0000000000000fb0 <rLy_info>: fb0: 48 8b 45 00 mov 0x0(%rbp),%rax fb4: 48 8d 1d a5 10 20 00 lea 0x2010a5(%rip),%rbx # 202060 <rLx_closure> fbb: ff e0 jmpq *%rax 0000000000000fe0 <libtestzm0zi1zi0zi0_LibTest2_testInfoRef_info>: fe0: eb ce jmp fb0 <rLy_info> ### NCG ### 0000000000000e10 <rI3_info>: e10: 48 8d 1d 51 12 20 00 lea 0x201251(%rip),%rbx # 202068 <rI2_closure> e17: ff 65 00 jmpq *0x0(%rbp) 0000000000000e40 <libtestzm0zi1zi0zi0_LibTest2_testInfoRef_info>: e40: eb ce jmp e10 <rI3_info> Again, it seems that LLVM is a bit more verbose but seems to handle intra-package calls efficiently. [1] https://github.com/bgamari/ghc/commits/llvm-dynamic [2] https://github.com/bgamari/ghc-linking-tests/tree/master/ghc-test [3] `helloWorld` definitions: LLVM: 00000000000010a8 <libtestzm0zi1zi0zi0_LibTest_helloWorld_info>: 10a8: 50 push %rax 10a9: 4c 8d 75 f0 lea -0x10(%rbp),%r14 10ad: 4d 39 fe cmp %r15,%r14 10b0: 73 07 jae 10b9 <libtestzm0zi1zi0zi0_LibTest_helloWorld_info+0x11> 10b2: 49 8b 45 f0 mov -0x10(%r13),%rax 10b6: 5a pop %rdx 10b7: ff e0 jmpq *%rax 10b9: 4c 89 ef mov %r13,%rdi 10bc: 48 89 de mov %rbx,%rsi 10bf: e8 0c fd ff ff callq dd0 <newCAF@plt> 10c4: 48 85 c0 test %rax,%rax 10c7: 74 22 je 10eb <libtestzm0zi1zi0zi0_LibTest_helloWorld_info+0x43> 10c9: 48 8b 0d 18 0f 20 00 mov 0x200f18(%rip),%rcx # 201fe8 <_DYNAMIC+0x228> 10d0: 48 89 4d f0 mov %rcx,-0x10(%rbp) 10d4: 48 89 45 f8 mov %rax,-0x8(%rbp) 10d8: 48 8d 05 21 00 00 00 lea 0x21(%rip),%rax # 1100 <cJC_str> 10df: 4c 89 f5 mov %r14,%rbp 10e2: 49 89 c6 mov %rax,%r14 10e5: 58 pop %rax 10e6: e9 b5 fc ff ff jmpq da0 <ghczmprim_GHCziCString_unpackCStringzh_info@plt> 10eb: 48 8b 03 mov (%rbx),%rax 10ee: 5a pop %rdx 10ef: ff e0 jmpq *%rax NCG: 0000000000000ef8 <libtestzm0zi1zi0zi0_LibTest_helloWorld_info>: ef8: 48 8d 45 f0 lea -0x10(%rbp),%rax efc: 4c 39 f8 cmp %r15,%rax eff: 72 3f jb f40 <libtestzm0zi1zi0zi0_LibTest_helloWorld_info+0x48> f01: 4c 89 ef mov %r13,%rdi f04: 48 89 de mov %rbx,%rsi f07: 48 83 ec 08 sub $0x8,%rsp f0b: b8 00 00 00 00 mov $0x0,%eax f10: e8 1b fd ff ff callq c30 <newCAF@plt> f15: 48 83 c4 08 add $0x8,%rsp f19: 48 85 c0 test %rax,%rax f1c: 74 20 je f3e <libtestzm0zi1zi0zi0_LibTest_helloWorld_info+0x46> f1e: 48 8b 1d cb 10 20 00 mov 0x2010cb(%rip),%rbx # 201ff0 <_DYNAMIC+0x238> f25: 48 89 5d f0 mov %rbx,-0x10(%rbp) f29: 48 89 45 f8 mov %rax,-0x8(%rbp) f2d: 4c 8d 35 1c 00 00 00 lea 0x1c(%rip),%r14 # f50 <cGG_str> f34: 48 83 c5 f0 add $0xfffffffffffffff0,%rbp f38: ff 25 7a 10 20 00 jmpq *0x20107a(%rip) # 201fb8 <_DYNAMIC+0x200> f3e: ff 23 jmpq *(%rbx) f40: 41 ff 65 f0 jmpq *-0x10(%r13) _______________________________________________ ghc-devs mailing list ghc-devs(a)haskell.org<mailto:ghc-devs@haskell.org> http://www.haskell.org/mailman/listinfo/ghc-devs

5 11