- Glasgow-haskell-users

Lazy IO and asynchronous callbacks?
by J. Garrett Morris 09 Jul '10

09 Jul '10

Hello everyone, I'm currently in the process of wrapping a C API, and I've run across an interesting possibility. Basically, the C API exposes non-blocking versions of some potentially long-running operations, and will invoke a callback to indicate that the long running operation has finished. For instance, I have something like: int longRunningReadOperation(int length, byte * buf, void (*callback)()) When callback is called, then there are length bytes in buf. What I'd like to do is wrap this in Haskell function like: longRunningReadOperation :: Int -> IO [Byte] such that the function returns immediately, and only blocks when someone pulls on the results if the callback hasn't been triggered yet. I figure I'm going to need unsafeInterleaveIO, but I'm not sure what to do in the computation I pass to it. I had a small hope that if the callback put the results into an MVar (say var), and I returned (unsafeInterleaveIO (readMVar var)) that might work, but it seems like if the readMVar blocks then the callback doesn't execute either. This doesn't surprise me, but it does leave me needing another option. I don't see a way to get the callback into a new Haskell thread, so that it can do the putMVar from there... am I missing something obvious? Thanks in advance! /g

4 3

unsafeCoerce# between integral and floating point types
by Daniel Fischer 09 Jul '10

09 Jul '10

The docs for unsafeCoerce# say: "The following uses of unsafeCoerce# are supposed to work (i.e. not lead to spurious compile-time or run-time crashes): # Casting any lifted type to Any # Casting Any back to the real type # Casting an unboxed type to another unboxed type of the same size (but not coercions between floating-point and integral types) ..." My experience so far is consistent with the assumption that e.g. unsafeCoerce# :: Word64 -> Double is like a cast from (uint64_t *) to (double *), i.e. a bit-pattern- preserving transformation (although by the docs, that use is undefined). Would that assumption generally hold for unsafeCoerce :: a -> b where a and b are single constructor data types wrapping unboxed types of the same bit-size and hence the use of unsafeCoerce# between such types would produce reliable results *on the same machine with the same OS (and GHC version?)* ? And what about e.g. unsafeCoerce# :: Word64# -> Double# ? By the docs, that isn't supposed to work. Is it not supposed to work only because it's not value-preserving (unsafeCoerce# 1## /=## 1.0##) or are there more pitfalls? If there are more pitfalls, is there any chance of getting a function which reinterprets the bit-patterns? Thanks, Daniel

4 4

Avoiding O(n^2) instances when using associated data types to unpack values into constructors
by Johan Tibell 06 Jul '10

06 Jul '10

Hi, I'm trying to create a data type for maps where both keys and values are unpacked into the data type constructors (see code at the end of this email). I achieve this using an associated data type of two arguments (`Map` in the code below). The problem I have is that this definition requires O(n^2) instances. I use a CPP macro to make it easier to create these instances but it doesn't address the real problem that the number of instances grows quadratically. Is there a better way to have GHC unpack the keys and values into the data constructors? Cheers, Johan \begin{code} {-# LANGUAGE CPP, MultiParamTypeClasses, TypeFamilies #-} -- | This module defines a type for maps of unboxed keys and values. module Data.AdaptMap (Unbox()) where -- | The size of the map. type Size = Int -- | A map of unboxed keys and values. class Unbox k a where data Map k a :: * -- Constructors/destructors used to implement functions on the map -- in a generic manner. tipCon :: Map k a binCon :: Size -> k -> a -> Map k a -> Map k a -> Map k a unMap :: Map k a -> b -> (Size -> k -> a -> Map k a -> Map k a -> b) -> b #define primMap(map,key,val,tipcon,bincon) \ instance Unbox key val where { \ data Map key val = tipcon \ | bincon {-# UNPACK #-} !Size \ {-# UNPACK #-} !key \ {-# UNPACK #-} !val \ !(Map key val) \ !(Map key val) \ ; tipCon = tipcon \ ; {-# INLINE tipCon #-} \ ; binCon = bincon \ ; {-# INLINE binCon #-} \ ; unMap t tk bk = case t of { \ tipcon -> tk \ ; bincon sz k v l r -> bk sz k v l r } \ ; {-# INLINE unMap #-} \ } -- Example instance with keys and values of type Int. primMap(IntIntMap,Int,Int,IntIntTip,IntIntBin) ------------------------------------------------------------------------ -- Construction empty :: Unbox k a => Map k a empty = tipCon singleton :: Unbox k a => k -> a -> Map k a singleton k x = binCon 1 k x tipCon tipCon \end{code}

2 1

BlockedIndefinitelyOnMVar exception
by Neil Mitchell 05 Jul '10

05 Jul '10

Hi, I have a very big and highly threaded program that generates a BlockedIndefinitelyOnMVar exception when run. I have spent a reasonable amount of time pouring over the source code, as has Max Bolingbroke. Neither of us have the slightest idea why it raises the exception. Some questions: * Does anyone know the exact sequence of actions that causes this exception to be thrown? I couldn't find it written down. * How confident are people that this exception does really mean that it is in a blocked state? Is there any chance the error could be raised incorrectly? * Any debugging tips for this problem? Thanks, Neil

3 10

Casts, and allocation
by Louis Wasserman 02 Jul '10

02 Jul '10

Hey, I was wondering how difficult it would be to improve handling of casts, as follows: when looking at Core, I see things like (\ (ds_dcKZ :: Data.TrieMap.TrieKey.TrieMap (Data.TrieMap.Regular.Base.App f_XcwB k_XcwD) a_acAi) -> f_scPr (ds_dcKZ `cast` (trans (Data.TrieMap.Regular.App.TFCo:R:TrieMapAppa f_XcwB k_XcwD a_acAi) (Data.TrieMap.Regular.App.NTCo:R:TrieMapAppa f_XcwB k_XcwD a_acAi) :: Data.TrieMap.TrieKey.TrieMap (Data.TrieMap.Regular.Base.App f_XcwB k_XcwD) a_acAi ~ Data.TrieMap.Regular.Class.TrieMapT f_XcwB k_XcwD a_acAi))) which is equivalent to a single cast of f. I get that generalized newtype deriving does something like this automatically -- unfortunately, at the moment, I'm using a class with associated types, so I can't do that. How difficult would it be to identify and rewrite these, when they appear in non-recursive lets? (I'm actually experimenting with implementing the change myself, but I've never hacked GHC before, so we'll see how it goes...) Louis Wasserman wasserman.louis(a)gmail.com http://profiles.google.com/wasserman.louis

1 0

RE: [Haskell-cafe] checking types with type families
by Simon Peyton-Jones 01 Jul '10

01 Jul '10

| Here's a concrete case I recently ran into: | | type family SomeOtherTypeFamily a | class SomeClass a where type SomeType a | instance a ~ SomeOtherTypeFamily b => SomeClass a where | type SomeType a = (b,Int) | -- (error) Not in scope: type variable `b' | | The same thing with fundeps: | | class SomeClass a b | a -> b | instance a ~ SomeOtherTypeFamily b => SomeClass a (b,Int) | -- works fine It's not the same thing at all! The code you give certainly should fail. Suppose you use fundeps thus: class C a b | a->b where op :: a -> b -> b The idiomatic way to replace this with type functions is to remove the 'b' parameter, thus: class C a where type B a op :: a -> B a -> B a Sometimes you don't want to do this. For example, you might have a bidirectional fundep. Then you can (or rather will be able to) use a superclass thus: class (B a ~ b) => C a b where type B a The superclass says that you can only instantiate this class with a second argument b that is equal to (B a). Thus you might have an instance instance C Int Bool where type B Int = Bool Meanwhile we are working hard on the new type inference engine, which will allow superclass equalities like these. Simon

1 0

Help with Win64 port
by George Brewster 01 Jul '10

01 Jul '10

Hey, I'd really like to see ghc working on 64-bit Windows, so I've decided to take at least a quick stab at getting it going. Having talked to some of the people on #ghc, it sounds like the first thing to do is get an unregisterised build going, which sounded like it may be managable. So to that end, I've pulled the 6.12 branch, done a 32-bit build, changed the build config to do an unregisterised build and turn off the native code generator, found a version of mingw64 which seems to work for me, stuffed it in in place of the in-tree mingw, and got my build to fail. At this point, I'd like to get a general idea of what my strategy should be. I read the Building/Porting page on the wiki, and used the config file there as an example of how to do an unregisterised build, but have been ignoring anything related to the hc file bootstrapping process, as I have a working ghc on my platform, just of the wrong bitness. In particular, if there are any changes that you know I'll need to make to the source to get this working, please let me know. The more of those I learn about now, the less fumbling around I'll have to do as things break. In particular, is there some place where I indicate that I'm build a 64-bit compiler? I didn't find anything with a quick look. I have very little time to work on it, and no familiarity with ghc internals, so I wouldn't expect much, but I'm hoping I can get it going... -George

2 1

Re: [Haskell-cafe] Space leak with unsafePerformIO
by Yitzchak Gale 01 Jul '10

01 Jul '10

Henning Thielemann wrote on Haskell Cafe: >> Attached is a program with a space leak... >> I have coded a simple 'map' function, once using unsafePerformIO and >> once without. UnsafePerformIO has a space leak in some circumstances. >> In the main program I demonstrate cases with and without space leak. >> Without space leak the program writes a file to the disk until it >> is full. Bertram Felgenhauer wrote: > The program relies on the GC doing short-cut evaluation of record > selectors to avoid a space leak... > Use of suffix: Due to the call of Main.go1 this is *not* a record > selector. It is compiled to an actual case expression, which to the > garbage collector looks just like an ordinary thunk. A reference to > Main.ds is kept around until the suffix is about to be processed > and a memory leak ensues. > The good news is that the problem is completely unrelated to > unsafePerformIO (the presence of unsafePerformIO makes optimisations > more difficult, but any pure function of sufficient complexity would > have the same effect). Is there already a GHC Trac bug for this? Link to Bertram's original email, with detailed analysis of the GHC Core: http://www.haskell.org/pipermail/haskell-cafe/2010-June/079479.html Thanks, Yitz

2 1

heap profiling
by Evan Laforge 01 Jul '10

01 Jul '10

I've been trying to profile my program and having some trouble. I imagine other people have stumbled across these same issues, so hopefully I can benefit from someone else's experience. In return, if I can figure out some of these things, I'll put it up at http://www.haskell.org/haskellwiki/How_to_profile_a_Haskell_program or maybe make make a heap profiling page linked from that. Firstly a few miscellaneous questions: When running '-hc -hblag,drag' it works for a little while and then stops. The app is still hung, but cpu has gone to 0%. The disk is also idle, so I don't think it's swapping. According to -S, all garbage collection has stopped too. It's apparently due to something about this particular profile, since reducing the amount of data it handles just results in a sooner hang. This same combination works with other profiles, so apparently something the code is doing is locking up. Has anyone else seen this? Any tips on how to troubleshoot where it's getting stuck, doing what? If it sounds like a ghc bug I can try to trim down the size and submit a ticket. GHC 6.12.1 on OSX. The image link from http://www.haskell.org/ghc/docs/6.12.2/html/users_guide/profiling.html is broken, which makes it a little harder to understand the documentation. -s stats say GC time is 46%, productivity is 32%. That's pretty bad, right? And where is the remaining 22% going? The ghc manual says lag is "time between creation and first use" and drag is "time between last use and last reference is dropped". I think I understand drag: it means you haven't touched the data for a while before it goes out of scope or its retainer goes out of scope. So for instance: stuff = do st <- get x1 st x2 Does this mean that 'st' will be dragging through 'x2' as it would in an imperative language? I gather the usual haskell use is when combined with laziness: 'Map.insertWith (+) "a" 42' will keep the old value of "a" around until you look "a" up and force it, since the (+) won't be applied until then. Same with foldl. Are there some other classic examples of drag? Searching for "haskell dragging problem" doesn't yield much to do with memory use. Lag I'm not so sure about. How is something created before it's used? And... what's INHERENT_USE? And what about VOID? How can an object be created but never used? What triggered its creation? So, the main question: I have a program that runs some computation in a monad stack before extracting the final result, a list, and passing it on. When run under the heap profiler, there's a huge spike in that phase, which I think should be mostly bogus usage, since the final output is so relatively small. When I run under -hb I see big bands for LAG and DRAG. According to -hd the top 3 users are: <mtl-1.1.0.2:Control.Monad.Writer.Lazy.sat_sltc> (,) D:Monad This is kind of puzzling to me... first of all I've never seen an explanation for sat_* closure descriptors, and second of all, why does it not show up in the .prof file at all? I switched to Writer.Strict and the drag disappeared, which helped, but the lag is still there, and the top -hd is now <mtl-1.1.0.2:Control.Monad.Writer.Strict.sat_soa1> State stg_ap_2_upd_info (the top -hy is "*", which I gather means "don't know"). And what's "stg_ap_2_upd_info"? The top item accounts for 70% of the memory usage. One obvious candidate for the lag is Writer's data (DList Log.Msg) is collecting and only being forced at the end of the computation, but there is no logging in this section and in any case should never be 30M of it! -hc is not helpful since every monadic operation is charged a little bit, -hr is similarly unhelpful (top retainer is MANY... hah). So what exactly is this sat_*? Where is the memory going? I guess it doesn't have an SCC since it doesn't show up in the .prof output. Is there some place I can manually put an SCC? I was able to fix the drag just by guessing at a strict writer, but the lag is still around. Is there another spot in Writer's >>= that could be accumulating? What's *in* that giant mountain of lag?

4 11

Fwd: Segmentation fault in non-dynamically linked binaries?
by austin seipp 30 Jun '10

30 Jun '10

Forwarding this to g-h-u for archival purposes and in case anybody else has ideas (should'a done this earlier.) ---------- Forwarded message ---------- From: austin seipp <as(a)0xff.ath.cx> Date: Wed, Jun 16, 2010 at 11:21 AM Subject: Re: Segmentation fault in non-dynamically linked binaries? To: Simon Marlow <marlowsd(a)gmail.com> Follow up: Both of my machines are running debian x86_64 linux, both with libc6 version 2.11.2-1 (aka eglibc,) from debian sid. My work machine does not exhibit the same segfaulting behavior as my home machine. Debugging with the rts source available and watching setFullProgArgv go by does not help a lot - when stgCallocBytes is called with strlen as a parameter (to determine how much to allocate,) the code immediately crashes upon arrival into the first instruction of strlen, but the strange thing is *which* strlen it is jumping to. >From a simple 'hello world' executable on my work machine, when disassembling setFullProgArgv we get this: ... 0x0000000000432a26 <setFullProgArgv+54>: xor %ebp,%ebp 0x0000000000432a28 <setFullProgArgv+56>: nopl 0x0(%rax,%rax,1) 0x0000000000432a30 <setFullProgArgv+64>: mov (%r14,%rbp,1),%rdi 0x0000000000432a34 <setFullProgArgv+68>: mov %rbp,%rbx 0x0000000000432a37 <setFullProgArgv+71>: add 0x247f5a(%rip),%rbx # 0x67a998 <full_prog_argv> 0x0000000000432a3e <setFullProgArgv+78>: add $0x1,%r12d 0x0000000000432a42 <setFullProgArgv+82>: callq 0x4028b8 <strlen@plt> 0x0000000000432a47 <setFullProgArgv+87>: lea 0x1(%rax),%edi 0x0000000000432a4a <setFullProgArgv+90>: mov $0x4616fe,%esi 0x0000000000432a4f <setFullProgArgv+95>: callq 0x434790 <stgMallocBytes> 0x0000000000432a54 <setFullProgArgv+100>: mov %rax,(%rbx) 0x0000000000432a57 <setFullProgArgv+103>: mov 0x247f3a(%rip),%rax ... Note that it calls strlen@plt which jumps to libc's implementation of strlen. However, when looking at this same program compiled on my home machine, we instead get: ... 0x0000000000432db6 <+54>: xor %ebp,%ebp 0x0000000000432db8 <+56>: nopl 0x0(%rax,%rax,1) 0x0000000000432dc0 <+64>: mov (%r14,%rbp,1),%rdi 0x0000000000432dc4 <+68>: mov %rbp,%rbx 0x0000000000432dc7 <+71>: add 0x24898a(%rip),%rbx # 0x67b758 <full_prog_argv> 0x0000000000432dce <+78>: add $0x1,%r12d 0x0000000000432dd2 <+82>: callq 0x67b3c0 <strlen@@GLIBC_2.2.5> 0x0000000000432dd7 <+87>: lea 0x1(%rax),%edi 0x0000000000432dda <+90>: mov $0x46207e,%esi 0x0000000000432ddf <+95>: callq 0x434cb0 <stgMallocBytes> 0x0000000000432de4 <+100>: mov %rax,(%rbx) 0x0000000000432de7 <+103>: mov 0x24896a(%rip),%rax # 0x67b758 <full_prog_argv> ... Here we call a version of strlen which the dynamic linker enforces come from glibc v2.2.5. If we run objdump -x, we get: ... Version References: required from librt.so.1: 0x09691973 0x00 04 GLIBC_2.3.3 required from libm.so.6: 0x09691a75 0x00 03 GLIBC_2.2.5 required from libc.so.6: 0x0d696913 0x00 05 GLIBC_2.3 0x09691a75 0x00 02 GLIBC_2.2.5 ... So there are some dependencies on older GLIBC versions for certain symbols, but I'm not sure why. I'm at work agaom so I'll follow up again here in a few hours once I get back home after doing some more reading. On Tue, Jun 15, 2010 at 3:43 PM, austin seipp <as(a)0xff.ath.cx> wrote: > Simon, > > Thanks for the reply. > > One interesting thing to note is that on my work machine, also running > x86_64 debian, with with a full update from apt (many updates come > from sid, others are from lenny,) static and dynamic linking both seem > to work fine for the same versions of GHC that affect my home machine. > > On my debian machine here at work I have a libc6 which is installed > from the unstable sid repository. It is libc6 version '2.11-1', which > is actually a version of eglibc, not glibc (although eglibc is > designed for full ABI-level compatibility - debian switched to it a > while ago.) I believe my home machine with x86_64 debian has the exact > same version of libc6 installed out of sid repos but I cannot confirm > that at the moment. > > I do not currently have access to my home machine from here. When I do > I'll get a copy of the 6.12.1 source code and do a debug link and do > some more investigation. > > Thanks, > > On Tue, Jun 15, 2010 at 5:33 AM, Simon Marlow <marlowsd(a)gmail.com> wrote: >> On 13/06/2010 07:26, austin seipp wrote: >>> >>> Hello, >>> >>> I am running GHC on x86_64 debian linux, and recently I have >>> discovered that the executables generated by my GHC segfault when the >>> linking step is not dynamic. >>> I discovered this while attempting to install haskell-src-exts, which >>> requires a linked version of Setup.hs when cabal builds it (and which >>> would fail inexplicably until I did >>> further investigation.) >>> >>> Example: >>> >>> link ~/t » cat hi.hs >>> main :: IO () >>> main = putStrLn "hi" >>> link ~/t » ghc -dynamic hi.hs >>> link ~/t » file ./a.out >>> ./a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), >>> dynamically linked (uses shared libs), for GNU/Linux 2.6.18, not >>> stripped >>> link ~/t » ldd ./a.out >>> linux-vdso.so.1 => (0x00007fffbadff000) >>> libHShaskell98-1.0.1.1-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/haskell98-1.0.1.1/libHShaskell98-1.0.1.1-ghc6.12.3.so >>> (0x00007fab3a4c4000) >>> libHSrandom-1.0.0.2-ghc6.12.3.so => >>> /usr/local/lib/ghc-6.12.3/random-1.0.0.2/libHSrandom-1.0.0.2-ghc6.12.3.so >>> (0x00007fab3a2af000) >>> libHStime-1.1.4-ghc6.12.3.so => >>> /usr/local/lib/ghc-6.12.3/time-1.1.4/libHStime-1.1.4-ghc6.12.3.so >>> (0x00007fab39fad000) >>> libHSprocess-1.0.1.3-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/process-1.0.1.3/libHSprocess-1.0.1.3-ghc6.12.3.so >>> (0x00007fab39d93000) >>> libHSdirectory-1.0.1.1-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/directory-1.0.1.1/libHSdirectory-1.0.1.1-ghc6.12.3.so >>> (0x00007fab39b77000) >>> libHSunix-2.4.0.2-ghc6.12.3.so => >>> /usr/local/lib/ghc-6.12.3/unix-2.4.0.2/libHSunix-2.4.0.2-ghc6.12.3.so >>> (0x00007fab398c6000) >>> librt.so.1 => /lib/librt.so.1 (0x00007fab396a2000) >>> libutil.so.1 => /lib/libutil.so.1 (0x00007fab3949f000) >>> libdl.so.2 => /lib/libdl.so.2 (0x00007fab3929b000) >>> libHSold-time-1.0.0.5-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/old-time-1.0.0.5/libHSold-time-1.0.0.5-ghc6.12.3.so >>> (0x00007fab3903c000) >>> libHSold-locale-1.0.0.2-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/old-locale-1.0.0.2/libHSold-locale-1.0.0.2-ghc6.12.3.so >>> (0x00007fab38e28000) >>> libHSfilepath-1.1.0.4-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/filepath-1.1.0.4/libHSfilepath-1.1.0.4-ghc6.12.3.so >>> (0x00007fab38c07000) >>> libHSarray-0.3.0.1-ghc6.12.3.so => >>> /usr/local/lib/ghc-6.12.3/array-0.3.0.1/libHSarray-0.3.0.1-ghc6.12.3.so >>> (0x00007fab38992000) >>> libHSbase-4.2.0.2-ghc6.12.3.so => >>> /usr/local/lib/ghc-6.12.3/base-4.2.0.2/libHSbase-4.2.0.2-ghc6.12.3.so >>> (0x00007fab381f2000) >>> libHSinteger-gmp-0.2.0.1-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/integer-gmp-0.2.0.1/libHSinteger-gmp-0.2.0.1-ghc6.12.3.so >>> (0x00007fab37fe1000) >>> libgmp.so.3 => /usr/lib/libgmp.so.3 (0x00007fab37da1000) >>> libHSghc-prim-0.2.0.0-ghc6.12.3.so => >>> >>> /usr/local/lib/ghc-6.12.3/ghc-prim-0.2.0.0/libHSghc-prim-0.2.0.0-ghc6.12.3.so >>> (0x00007fab37b1c000) >>> libHSrts-ghc6.12.3.so => >>> /usr/local/lib/ghc-6.12.3/libHSrts-ghc6.12.3.so (0x00007fab378ba000) >>> libm.so.6 => /lib/libm.so.6 (0x00007fab37637000) >>> libHSffi-ghc6.12.3.so => >>> /usr/local/lib/ghc-6.12.3/libHSffi-ghc6.12.3.so (0x00007fab3742a000) >>> libc.so.6 => /lib/libc.so.6 (0x00007fab370c9000) >>> libpthread.so.0 => /lib/libpthread.so.0 (0x00007fab36eac000) >>> /lib64/ld-linux-x86-64.so.2 (0x00007fab3a6cb000) >>> link ~/t » ./a.out >>> hi >>> link ~/t » rm ./a.out *.hi *.o >>> link ~/t » ghc hi.hs >>> link ~/t » file ./a.out >>> ./a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), >>> dynamically linked (uses shared libs), for GNU/Linux 2.6.18, not >>> stripped >>> link ~/t » ldd ./a.out >>> linux-vdso.so.1 => (0x00007fffaafff000) >>> librt.so.1 => /lib/librt.so.1 (0x00007fdf83d77000) >>> libutil.so.1 => /lib/libutil.so.1 (0x00007fdf83b74000) >>> libdl.so.2 => /lib/libdl.so.2 (0x00007fdf8396f000) >>> libgmp.so.3 => /usr/lib/libgmp.so.3 (0x00007fdf83730000) >>> libm.so.6 => /lib/libm.so.6 (0x00007fdf834ae000) >>> libc.so.6 => /lib/libc.so.6 (0x00007fdf8314c000) >>> libpthread.so.0 => /lib/libpthread.so.0 (0x00007fdf82f30000) >>> /lib64/ld-linux-x86-64.so.2 (0x00007fdf83f9c000) >>> link ~/t » ./a.out >>> [1] 7850 segmentation fault ./a.out >>> link ~/t » gdb7.0 ./a.out >>> >>> >>> 139 ↵ >>> GNU gdb (GDB) 7.0 >>> Copyright (C) 2009 Free Software Foundation, Inc. >>> License GPLv3+: GNU GPL version 3 or >>> later<http://gnu.org/licenses/gpl.html> >>> This is free software: you are free to change and redistribute it. >>> There is NO WARRANTY, to the extent permitted by law. Type "show copying" >>> and "show warranty" for details. >>> This GDB was configured as "x86_64-unknown-linux-gnu". >>> For bug reporting instructions, please see: >>> <http://www.gnu.org/software/gdb/bugs/>... >>> Reading symbols from /home/a/t/a.out...done. >>> (gdb) r >>> Starting program: /home/a/t/a.out >>> [Thread debugging using libthread_db enabled] >>> >>> Program received signal SIGSEGV, Segmentation fault. >>> 0x000000000067b3c0 in strlen@@GLIBC_2.2.5 () >>> (gdb) bt >>> #0 0x000000000067b3c0 in strlen@@GLIBC_2.2.5 () >>> #1 0x0000000000432dd7 in setFullProgArgv () >>> #2 0x000000000043464d in hs_init () >>> #3 0x000000000043478d in startupHaskell () >>> #4 0x0000000000433d59 in real_main () >>> #5 0x0000000000433e87 in hs_main () >>> #6 0x00007ffff6fccc4d in __libc_start_main () from /lib/libc.so.6 >>> #7 0x0000000000402d49 in _start () >>> (gdb) >>> >>> >>> What's interesting is that this occurs with all versions of GHC on my >>> machine, which include: >>> * GHC 6.12.1 >>> * GHC 6.12.3 >>> * GHC 6.13.20100426 >>> >>> Executables that were statically linked with GHC before this strange >>> behavior started occurring appear to still work, i.e. xmonad& xmobar. >>> I recently did an update of my machine with aptitude, but I would not >>> think this would interfere with GHC. >> >> Strange - I suspect there is some ABI change in glibc that means the static >> libraries are no longer compatible with the new version. You'll get more >> information out of gdb if you compile with -debug, then try stepping through >> from setFullProgArgv to see what goes wrong. >> >> If there is an ABI change, and it's going to appear in all the major Linux >> distros at some point, this could give us some difficulties with binary >> distributions. >> >> Cheers, >> Simon >> > > > > -- > - Austin > -- - Austin -- - Austin

1 1