Ticket #2917: align.patch

File align.patch, 21.3 KB (added by guest, 6 years ago)

New alignment patch.

Line 
1
2New patches:
3
4[Obey alignment for Storable.
5[email protected]**20090127214504
6 
7 The Storable class contains a method, alignment, to determine what the
8 alignment for the allocated object should be.  This was previously
9 totally ignored.
10 
11 This patch introduces new allocation functions that allocate with a
12 particular alignment, and these functions are used when allocating
13 a Storable or an array of Storable.
14 
15 For GHC we have
16   mallocBytesAligned  uses C malloc() when alignment is smaller or equal to what malloc returns,
17                       otherwise uses posix_memalign().  If the platform does not support
18                       posix_memalign() the allocation will throw an error.
19   allocaBytesAligned  uses the fast heap allocation when alignment is small enough,
20                       otherwise malloc&free.
21   malloc*ForeignPtrBytesAligned uses fast heap allocation with the Addr# stored in the ForeignPtr
22                       rounded up to the alignment boundary.
23 
24 Note that posix_memalign() should never have to be used unless someone
25 asks for an alignment that is bigger than what is needed for the platform.
26 
27] {
28addfile ./Control/Exception/Base.hs-boot
29hunk ./Control/Exception/Base.hs-boot 1
30+module Control.Exception.Base where
31+
32+import GHC.IOBase
33+
34+bracket
35+        :: IO a
36+        -> (a -> IO b)
37+        -> (a -> IO c)
38+        -> IO c
39hunk ./Foreign/ForeignPtr.hs 76
40-import Foreign.Storable ( Storable(sizeOf) )
41+import Foreign.Storable ( Storable(sizeOf, alignment) )
42hunk ./Foreign/ForeignPtr.hs 85
43+import GHC.Ptr(Ptr(..))
44hunk ./Foreign/ForeignPtr.hs 176
45-    doMalloc dummy size  = mallocForeignPtrBytes (size * sizeOf dummy)
46+    doMalloc dummy size  = mallocForeignPtrBytesAligned (alignment dummy) (size * sizeOf dummy)
47hunk ./Foreign/ForeignPtr.hs 185
48+
49hunk ./Foreign/Marshal/Alloc.hs 15
50+#include "HsBaseConfig.h"
51hunk ./Foreign/Marshal/Alloc.hs 20
52-  alloca,       -- :: Storable a =>        (Ptr a -> IO b) -> IO b
53-  allocaBytes,  -- ::               Int -> (Ptr a -> IO b) -> IO b
54+  alloca,              -- :: Storable a =>               (Ptr a -> IO b) -> IO b
55+  allocaBytes,         -- ::                      Int -> (Ptr a -> IO b) -> IO b
56+  allocaBytesAligned,  -- ::               Int -> Int -> (Ptr a -> IO b) -> IO b
57hunk ./Foreign/Marshal/Alloc.hs 25
58-  malloc,       -- :: Storable a =>        IO (Ptr a)
59-  mallocBytes,  -- ::               Int -> IO (Ptr a)
60+  malloc,              -- :: Storable a =>               IO (Ptr a)
61+  mallocBytes,         -- ::                      Int -> IO (Ptr a)
62+  mallocBytesAligned,  -- ::               Int -> Int -> IO (Ptr a)
63hunk ./Foreign/Marshal/Alloc.hs 29
64-  realloc,      -- :: Storable b => Ptr a        -> IO (Ptr b)
65-  reallocBytes, -- ::               Ptr a -> Int -> IO (Ptr a)
66+  realloc,             -- :: Storable b => Ptr a        -> IO (Ptr b)
67+  reallocBytes,        -- ::               Ptr a -> Int -> IO (Ptr a)
68hunk ./Foreign/Marshal/Alloc.hs 32
69-  free,         -- :: Ptr a -> IO ()
70-  finalizerFree -- :: FinalizerPtr a
71+  free,                -- :: Ptr a -> IO ()
72+  finalizerFree        -- :: FinalizerPtr a
73hunk ./Foreign/Marshal/Alloc.hs 37
74-import Foreign.C.Types          ( CSize )
75-import Foreign.Storable         ( Storable(sizeOf) )
76+import Foreign.C.Types          ( CSize, CInt )
77+import Foreign.Storable         ( Storable(sizeOf, alignment, peek, poke) )
78hunk ./Foreign/Marshal/Alloc.hs 52
79+import {-# SOURCE #-} Control.Exception.Base   ( bracket )
80hunk ./Foreign/Marshal/Alloc.hs 66
81+-- The alignment returned by C malloc().
82+-- XXX This should not be hardwired.
83+mallocAlignment :: Int
84+mallocAlignment = 16
85+allocaAlignment :: Int
86+allocaAlignment = 8
87hunk ./Foreign/Marshal/Alloc.hs 87
88-    doMalloc dummy  = mallocBytes (sizeOf dummy)
89+    doMalloc dummy  = mallocBytesAligned (alignment dummy) (sizeOf dummy)
90hunk ./Foreign/Marshal/Alloc.hs 99
91+-- |Allocate a block of memory of the given number of bytes.
92+-- The block of memory is sufficiently aligned according the alignment.
93+-- The alignment must be a power of 2.
94+--
95+-- The memory may be deallocated using 'free' or 'finalizerFree' when
96+-- no longer required.
97+--
98+mallocBytesAligned :: Int   -- ^Alignment
99+                   -> Int   -- ^Size
100+                   -> IO (Ptr a)
101+mallocBytesAligned align size | align <= mallocAlignment = mallocBytes size
102+                             | otherwise                = alloca $ \ pptr -> do
103+    r <- posix_memalign pptr (fromIntegral align) (fromIntegral size)
104+    if r /= 0
105+        then outOfMemoryError "mallocBytesAligned"
106+        else peek pptr
107+
108hunk ./Foreign/Marshal/Alloc.hs 126
109-    doAlloca       :: Storable a' => a' -> (Ptr a' -> IO b') -> IO b'
110-    doAlloca dummy  = allocaBytes (sizeOf dummy)
111+    doAlloca           :: Storable a' => a' -> (Ptr a' -> IO b') -> IO b'
112+    doAlloca dummy act  = allocaBytesAligned (alignment dummy) (sizeOf dummy) act
113hunk ./Foreign/Marshal/Alloc.hs 137
114-#ifdef __GLASGOW_HASKELL__
115hunk ./Foreign/Marshal/Alloc.hs 138
116+#ifdef __GLASGOW_HASKELL__
117hunk ./Foreign/Marshal/Alloc.hs 149
118-allocaBytes      :: Int -> (Ptr a -> IO b) -> IO b
119hunk ./Foreign/Marshal/Alloc.hs 152
120+-- |@'allocaBytesAligned' a n f@ is similar to @'allocaBytes' n f@, but the
121+-- allocated memory is on the specified alignment boundary.
122+allocaBytesAligned      :: Int -> Int -> (Ptr a -> IO b) -> IO b
123+allocaBytesAligned align size | align <= allocaAlignment = allocaBytes size
124+-- XXX Could use the more efficient GHC specific allocation, but
125+-- large alignments are rare.
126+                             | otherwise                = bracket (mallocBytesAligned align size) free
127+
128+-- XXX This does not respect alignment.
129hunk ./Foreign/Marshal/Alloc.hs 216
130+      then outOfMemoryError name
131+      else return addr
132+
133+outOfMemoryError :: String -> IO a
134+outOfMemoryError name =
135hunk ./Foreign/Marshal/Alloc.hs 222
136-      then ioError (IOError Nothing ResourceExhausted name
137-                                        "out of memory" Nothing Nothing)
138+      ioError (IOError Nothing ResourceExhausted name
139+                                   "out of memory" Nothing Nothing)
140hunk ./Foreign/Marshal/Alloc.hs 225
141-      then ioError (IOError Nothing ResourceExhausted name
142-                                        "out of memory" Nothing)
143+      ioError (IOError Nothing ResourceExhausted name
144+                                   "out of memory" Nothing)
145hunk ./Foreign/Marshal/Alloc.hs 228
146-      then ioError (userError (name++": out of memory"))
147+      ioError (userError (name++": out of memory"))
148hunk ./Foreign/Marshal/Alloc.hs 230
149-      else return addr
150hunk ./Foreign/Marshal/Alloc.hs 237
151+#ifdef HAVE_POSIX_MEMALIGN
152+foreign import ccall unsafe "stdlib.h posix_memalign" posix_memalign ::
153+    Ptr (Ptr a) -> CSize -> CSize -> IO CInt
154+#else
155+posix_memalign  :: Ptr (Ptr a) -> CSize -> CSize -> IO CInt
156+posix_memalign pptr _ size = do
157+     -- Just allocate with no regard to alignment.  XXX Should warn the user.
158+     error "posix_memalign called"
159+     ptr <- _malloc size
160+     poke pptr ptr
161+     return (if ptr == nullPtr then 1 else 0)
162+#endif
163+
164hunk ./Foreign/Marshal/Array.hs 66
165-import Foreign.Storable (Storable(sizeOf,peekElemOff,pokeElemOff))
166-import Foreign.Marshal.Alloc (mallocBytes, allocaBytes, reallocBytes)
167+import Foreign.Storable (Storable(sizeOf,peekElemOff,pokeElemOff,alignment))
168+import Foreign.Marshal.Alloc (mallocBytesAligned, allocaBytesAligned, reallocBytes)
169hunk ./Foreign/Marshal/Array.hs 90
170-    doMalloc dummy size  = mallocBytes (size * sizeOf dummy)
171+    doMalloc dummy size  = mallocBytesAligned (alignment dummy) (size * sizeOf dummy)
172hunk ./Foreign/Marshal/Array.hs 104
173-    doAlloca            :: Storable a' => a' -> Int -> (Ptr a' -> IO b') -> IO b'
174-    doAlloca dummy size  = allocaBytes (size * sizeOf dummy)
175+    doAlloca                :: Storable a' => a' -> Int -> (Ptr a' -> IO b') -> IO b'
176+    doAlloca dummy size act  = allocaBytesAligned (alignment dummy) (size * sizeOf dummy) act
177hunk ./Foreign/Marshal/Array.hs 113
178+-- XXX This is wrong.  reallocBytes need to copy to a properly aligned place.
179hunk ./GHC/ForeignPtr.hs 28
180+        mallocForeignPtrBytesAligned,
181+        mallocPlainForeignPtrBytesAligned,
182hunk ./GHC/ForeignPtr.hs 49
183-import GHC.Ptr          ( Ptr(..), FunPtr(..) )
184+import GHC.Ptr          ( Ptr(..), FunPtr(..), alignPtr )
185hunk ./GHC/ForeignPtr.hs 51
186+import GHC.Num
187hunk ./GHC/ForeignPtr.hs 134
188-mallocForeignPtr :: Storable a => IO (ForeignPtr a)
189--- ^ Allocate some memory and return a 'ForeignPtr' to it.  The memory
190--- will be released automatically when the 'ForeignPtr' is discarded.
191---
192--- 'mallocForeignPtr' is equivalent to
193---
194--- >    do { p <- malloc; newForeignPtr finalizerFree p }
195---
196--- although it may be implemented differently internally: you may not
197--- assume that the memory returned by 'mallocForeignPtr' has been
198--- allocated with 'Foreign.Marshal.Alloc.malloc'.
199---
200--- GHC notes: 'mallocForeignPtr' has a heavily optimised
201--- implementation in GHC.  It uses pinned memory in the garbage
202--- collected heap, so the 'ForeignPtr' does not require a finalizer to
203--- free the memory.  Use of 'mallocForeignPtr' and associated
204--- functions is strongly recommended in preference to 'newForeignPtr'
205--- with a finalizer.
206---
207-mallocForeignPtr = doMalloc undefined
208-  where doMalloc :: Storable b => b -> IO (ForeignPtr b)
209-        doMalloc a = do
210-          r <- newIORef (NoFinalizers, [])
211-          IO $ \s ->
212-            case newPinnedByteArray# size s of { (# s', mbarr# #) ->
213-             (# s', ForeignPtr (byteArrayContents# (unsafeCoerce# mbarr#))
214-                               (MallocPtr mbarr# r) #)
215-            }
216-            where (I# size) = sizeOf a
217-
218hunk ./GHC/ForeignPtr.hs 145
219--- | Allocate some memory and return a 'ForeignPtr' to it.  The memory
220--- will be released automatically when the 'ForeignPtr' is discarded.
221---
222--- GHC notes: 'mallocPlainForeignPtr' has a heavily optimised
223--- implementation in GHC.  It uses pinned memory in the garbage
224--- collected heap, as for mallocForeignPtr. Unlike mallocForeignPtr, a
225--- ForeignPtr created with mallocPlainForeignPtr carries no finalizers.
226--- It is not possible to add a finalizer to a ForeignPtr created with
227--- mallocPlainForeignPtr. This is useful for ForeignPtrs that will live
228--- only inside Haskell (such as those created for packed strings).
229--- Attempts to add a finalizer to a ForeignPtr created this way, or to
230--- finalize such a pointer, will throw an exception.
231---
232-mallocPlainForeignPtr :: Storable a => IO (ForeignPtr a)
233-mallocPlainForeignPtr = doMalloc undefined
234-  where doMalloc :: Storable b => b -> IO (ForeignPtr b)
235-        doMalloc a = IO $ \s ->
236-            case newPinnedByteArray# size s of { (# s', mbarr# #) ->
237-             (# s', ForeignPtr (byteArrayContents# (unsafeCoerce# mbarr#))
238-                               (PlainPtr mbarr#) #)
239-            }
240-            where (I# size) = sizeOf a
241-
242hunk ./GHC/ForeignPtr.hs 324
243+----------------------
244+-- Functions defined just in terms of the primitive ones above.
245+
246+-- XXX Where should we get this constant?
247+-- It's the alignment used by GHC's internal allocator.
248+mallocForeignAlignment :: Int
249+mallocForeignAlignment = 8
250+
251+mallocForeignPtr :: Storable a => IO (ForeignPtr a)
252+-- ^ Allocate some memory and return a 'ForeignPtr' to it.  The memory
253+-- will be released automatically when the 'ForeignPtr' is discarded.
254+--
255+-- 'mallocForeignPtr' is equivalent to
256+--
257+-- >    do { p <- malloc; newForeignPtr finalizerFree p }
258+--
259+-- although it may be implemented differently internally: you may not
260+-- assume that the memory returned by 'mallocForeignPtr' has been
261+-- allocated with 'Foreign.Marshal.Alloc.malloc'.
262+--
263+-- GHC notes: 'mallocForeignPtr' has a heavily optimised
264+-- implementation in GHC.  It uses pinned memory in the garbage
265+-- collected heap, so the 'ForeignPtr' does not require a finalizer to
266+-- free the memory.  Use of 'mallocForeignPtr' and associated
267+-- functions is strongly recommended in preference to 'newForeignPtr'
268+-- with a finalizer.
269+--
270+mallocForeignPtr = doMalloc undefined
271+  where doMalloc :: Storable b => b -> IO (ForeignPtr b)
272+        doMalloc a = mallocForeignPtrBytesAligned (alignment a) (sizeOf a)
273+
274+-- | This function is similar to 'mallocForeignPtrBytes', but
275+-- aligns the pointer to the given alignment.
276+mallocForeignPtrBytesAligned :: Int -> Int -> IO (ForeignPtr a)
277+mallocForeignPtrBytesAligned align size | align <= mallocForeignAlignment = mallocForeignPtrBytes size
278+                                       | otherwise = do
279+    -- XXX Adjust the Addr# part of the ForeignPtr.  Is this always OK?
280+    ForeignPtr ptr cnt <- mallocForeignPtrBytes (size + align - 1)
281+    return (ForeignPtr (alignPtr' ptr align) cnt)
282+
283+-- | Allocate some memory and return a 'ForeignPtr' to it.  The memory
284+-- will be released automatically when the 'ForeignPtr' is discarded.
285+--
286+-- GHC notes: 'mallocPlainForeignPtr' has a heavily optimised
287+-- implementation in GHC.  It uses pinned memory in the garbage
288+-- collected heap, as for mallocForeignPtr. Unlike mallocForeignPtr, a
289+-- ForeignPtr created with mallocPlainForeignPtr carries no finalizers.
290+-- It is not possible to add a finalizer to a ForeignPtr created with
291+-- mallocPlainForeignPtr. This is useful for ForeignPtrs that will live
292+-- only inside Haskell (such as those created for packed strings).
293+-- Attempts to add a finalizer to a ForeignPtr created this way, or to
294+-- finalize such a pointer, will throw an exception.
295+--
296+mallocPlainForeignPtr :: Storable a => IO (ForeignPtr a)
297+mallocPlainForeignPtr = doMalloc undefined
298+  where doMalloc :: Storable b => b -> IO (ForeignPtr b)
299+        doMalloc a = mallocPlainForeignPtrBytesAligned (alignment a) (sizeOf a)
300+
301+-- | This function is similar to 'mallocPlainForeignPtr', but
302+-- allocates a pointer on the requested alignment.
303+mallocPlainForeignPtrBytesAligned :: Int -> Int -> IO (ForeignPtr a)
304+mallocPlainForeignPtrBytesAligned align size | align <= mallocForeignAlignment = mallocPlainForeignPtrBytes size
305+                                            | otherwise = do
306+    ForeignPtr ptr cnt <- mallocPlainForeignPtrBytes (size + align - 1)
307+    return (ForeignPtr (alignPtr' ptr align) cnt)
308+
309+alignPtr' :: Addr# -> Int -> Addr#
310+alignPtr' a o = case alignPtr (Ptr a) o of Ptr a' -> a'
311+
312hunk ./configure.ac 37
313+AC_CHECK_FUNCS([posix_memalign])
314}
315
316[Use alignment in the pool allocator too.
317[email protected]**20090127221519] {
318hunk ./Foreign/Marshal/Pool.hs 66
319-import Foreign.Marshal.Alloc ( mallocBytes, reallocBytes, free )
320+import Foreign.Marshal.Alloc ( mallocBytesAligned, reallocBytes, free )
321hunk ./Foreign/Marshal/Pool.hs 70
322-import Foreign.Storable      ( Storable(sizeOf, poke) )
323+import Foreign.Storable      ( Storable(sizeOf, poke, alignment) )
324hunk ./Foreign/Marshal/Pool.hs 121
325-    pm dummy pool = pooledMallocBytes pool (sizeOf dummy)
326+    pm dummy pool = pooledMallocBytesAligned pool (alignment dummy) (sizeOf dummy)
327hunk ./Foreign/Marshal/Pool.hs 126
328-pooledMallocBytes (Pool pool) size = do
329-   ptr <- mallocBytes size
330+pooledMallocBytes pool size = pooledMallocBytesAligned pool 1 size
331+
332+pooledMallocBytesAligned :: Pool -> Int -> Int -> IO (Ptr a)
333+pooledMallocBytesAligned (Pool pool) align size = do
334+   ptr <- mallocBytesAligned align size
335hunk ./Foreign/Marshal/Pool.hs 162
336-    pma dummy pool size = pooledMallocBytes pool (size * sizeOf dummy)
337+    pma dummy pool size = pooledMallocBytesAligned pool (alignment dummy) (size * sizeOf dummy)
338}
339
340Context:
341
342[Require Cabal version >= 1.6
343Ian Lynagh <[email protected]>**20090122011251]
344[Add "bug-reports" and "source-repository" info to the Cabal file
345Ian Lynagh <[email protected]>**20090121182010]
346[Proposal #2875: remove StringRep and StringConstr
347Jose Pedro Magalhaes <[email protected]>**20090116142617]
348[Fix #2759: add mkRealConstr and mkIntegralConstr, deprecate mkFloatConstr and mkIntConstr
349Jose Pedro Magalhaes <[email protected]>**20090116140655]
350[Correct SYB's representation of Char
351Jose Pedro Magalhaes <[email protected]>**20081211144716]
352[avoid `mappend` in monoid laws, because it doesn't work with haddock
353Ross Paterson <[email protected]>**20090118011508]
354[Make Data.Typeable imports and exports more explicit
355Ian Lynagh <[email protected]>**20090114234512]
356[add Monoid laws
357Ross Paterson <[email protected]>**20090116151624]
358[Unbreak an import cycle caused by moving 'catch' definitions around.
359[email protected]**20090116110132
360 The new cycle was introduced for nhc98 only.
361]
362[make the Monoid docs more self-contained
363Ross Paterson <[email protected]>**20090115222441]
364[Move some catch definitions around to avoid an import loop
365Ian Lynagh <[email protected]>**20090114211033
366 As suggested by simonpj in trac #2822.
367]
368[Add NoImplicitPrelude to the extensions used when building with GHC
369Ian Lynagh <[email protected]>**20090114202810]
370[#2699: exit silently for EPIPE on stdout
371Simon Marlow <[email protected]>**20090114134612
372 Ignore-this: 4236560e8e9c1135129e9526355f11b4
373]
374[Fix build when we have HTYPE_TCFLAG_T
375Ian Lynagh <[email protected]>**20090105102020]
376[Fix the build on Windows
377Ian Lynagh <[email protected]>**20090105014625]
378[Add errno to the IOError type
379Ian Lynagh <[email protected]>**20090104173018]
380[Fix typo (reqwests -> requests); trac #2908, spotted by bancroft
381Ian Lynagh <[email protected]>**20090104154405]
382[More compact error messages for record selectors
383[email protected]**20090102145325
384 
385 Make recSelError generate the standard part of the record selector
386 error message (i.e. "No match in record selector") rather than have
387 that string duplicated for every record selector.
388 
389]
390[extra dependencies for the new build system
391Simon Marlow <[email protected]>**20081217104655]
392[warning fix: don't use -XPatternSignatures in GHC >= 6.10
393Simon Marlow <[email protected]>**20081217104637]
394[Rollback INLINE patches
395Simon Marlow <[email protected]>**20081216104143
396 
397 rolling back:
398 
399 Fri Dec  5 17:00:15 GMT 2008  [email protected]
400   * Update INLINE pragmas for new INLINE story
401   
402   - (.) and foldr should inline when applied to only two arguments
403   - Make unpackCString# NOINLINE; it inlines too much (with little gain)
404   
405 
406     M ./GHC/Base.lhs -10 +31
407]
408[FIX #1364: added support for C finalizers that run as soon as the value is no longer reachable.
409Ivan Tomac <[email protected]>**20081210150510
410 
411 Patch amended by Simon Marlow:
412   - mkWeakFinalizer# commoned up with mkWeakFinalizerEnv#
413]
414[Fix #2760: deprecate mkNorepType, add mkNoRepType
415Jose Pedro Magalhaes <[email protected]>**20081121141905]
416[Update INLINE pragmas for new INLINE story
417[email protected]**20081205170015
418 
419 - (.) and foldr should inline when applied to only two arguments
420 - Make unpackCString# NOINLINE; it inlines too much (with little gain)
421 
422]
423[Fix #2750: change Prelude.(,) to Prelude.(,,)
424Jose Pedro Magalhaes <[email protected]>**20081201113411]
425[Fix typo (or out of date reference) in throwTo documentation.
426shelarcy <[email protected]>**20081129024639]
427[Add more description of what "round" does, from the H98 report
428Ian Lynagh <[email protected]>**20081119143131]
429[re-instate the gcd/Integer and lcm/Integer RULES
430Simon Marlow <[email protected]>**20081120101826
431 Fixes a performance regression between 6.8.3 and 6.10.1
432]
433[Change an "undefined" into a more informative error; trac #2782
434Ian Lynagh <[email protected]>**20081116160228]
435[updating Haddock documentation
436[email protected]**20081111095023
437 
438 Fixed the broken link from Data.Generics to Data.Data.
439]
440[add GHC.Conc.runSparks (required by GHC patch "Run sparks in batches")
441Simon Marlow <[email protected]>**20081106095419]
442[FIX #2722: update RULES for the Category/Arrow split
443Ross Paterson <[email protected]>**20081104144515
444 
445 The rule
446 
447        arr id = id
448 
449 interacts unpleasantly with the advice to define
450 
451        id = arr id
452 
453 in instances of Category that are also instances of Arrow (#2722).
454 
455 Also changed a couple of >>>'s to .'s in later rules.
456]
457[Add AnnotationWrapper type so GHC can capture annotation dictionaries during compilation
458Max Bolingbroke <[email protected]>**20081016122608]
459[docs about how exceptions are handled by forkIO'd threads (#2651)
460Simon Marlow <[email protected]>**20081016100410]
461[Import n_capabilities via import symbol when linking dynamically
462Clemens Fruhwirth <[email protected]>**20081013161220]
463[add link to the new syb wiki
464[email protected]**20081013111605]
465[changing haddock links
466[email protected]**20081010095434]
467[add readTVarIO :: TVar a -> IO a
468Simon Marlow <[email protected]>**20081010113835]
469[removed (->) instance from Data.Data
470[email protected]**20081006075254]
471[non-GHC: delete unnecessary imports
472Ross Paterson <[email protected]>**20081007134809]
473[added new module Data.Data
474'Jose Pedro Magalhaes <[email protected]>'**20081002140535
475 
476 The new Data.Data module contains all of Data.Generics.Basics
477 and most of Data.Generics.Instances. The missing instances were
478 deemed dubious and moved to the syb package.
479]
480[add new Data.Data module
481'Jose Pedro Magalhaes <[email protected]>'**20081002082735]
482[restore Complex's derived Data instance
483'Jose Pedro Magalhaes <[email protected]>'**20081002082655]
484[update Data.Generics import
485'Jose Pedro Magalhaes <[email protected]>'**20081002082604]
486[Don't use ^(2::Int) in Data.Complex.magnitude; partially fixes trac #2450
487Ian Lynagh <[email protected]>**20081004142651
488 We still might want to make a RULE for this, so the bug is not fully fixed.
489]
490[Restore the Haskell 98 behaviour of Show Ratio (#1920)
491Simon Marlow <[email protected]>**20080923134949]
492[Pad version number to 4.0.0.0
493Ian Lynagh <[email protected]>**20080920155801]
494[TAG 6.10 branch has been forked
495Ian Lynagh <[email protected]>**20080919123437]
496Patch bundle hash:
49782c9a30f0e37346acf2cb7a30d86fa9936defe3e