GitLab

stat_getElapsedTime(): now visible when RTS_SUPPORTS_THREADS is defined (was: SMP only)

moved {ACQUIRE,RELEASE}_LOCK to OSThreads.h

Also implement MO_32U_to_8U for sparc.  sigh.

Implement missing MachOp, MO_8U_to_32U, for sparc.  (duh!)

Adding section descriptions, for ELF: don't record sections satisfying

   size == 0
   ||
   kind `notElem` [SECTIONKIND_CODE_OR_RODATA, SECTIONKIND_RWDATA]

The latter condition is really an optimisation based on knowledge of
what queries will be made of the table.  Still, seems to work, and
reduces the number of sections in the list by about a factor of 3,
so hopefully will improve GC performance in GHCi.

If you get wierd GC problems in GHCi ... this may be to blame.

wibble

Expand out use of modifyIORef because 4.08.2 doesn't have that.

HC_OPTS is now used in both .c and .hc compilations (again).

GhcRtsHcOpts is included in both .c and .hc compilations (again).

GHC_CC_OPTS should include HC_OPTS

Start to record some stuff about GHCi.

Add a bit of documentation on implicit params

oops, fix HC_OBJS for non-normal ways.

-----------------------------
	Improve type validity checking
	-----------------------------

Two main effects here

a) Type synonyms can be unboxed tuples
	tupe T = (# Int, Int #)

	f :: Int -> T

b) Hoisting works for implicit parameters

	f :: Int -> (?x::Int) => Int

Correct assertion

Document hoisting and implicit quantification

Tighten up syntax w.r.t. Haskell 98; this is disallowed:

	(a `op` b) = ...

since a parenthesised lhs must be followed by at least one parameter.

Clarify explaination about problems with x87 FPU stack invalid exceptions.

Conformed the FFI libraries to meet the FFI Addendum 1.0 specification (except
hs_init() and friends).

Foreign import/export declarations now conform to FFI Addendum Version 1.0

* The old form of foreign declarations is still supported, but generates
  deprecation warnings.

* There are some rather exotic old-style declarations which have become
  invalid as they are interpreted differently under the new scheme and there
  is no (easy) way to determine which style the programmer had in mind (eg,
  importing a C function with the name `wrapper' where the external name is
  explicitly given will not work in some situations - depends on whether an
  `unsafe' was specified and similar things).

* Some "new" old-style forms have been introduced to make parsing a little bit
  easier (ie, avoid shift/reduce conflicts between new-style and old-style
  grammar rules), but they are few, arcane, and don't really hurt (and I won't
  tell what they are, you need to find that out by yourself ;-)

* The FFI Addendum doesn't specify whether a header file that is requested for
  inclusion by multiple foreign declarations should be included only once or
  multiple times.  GHC at the moment includes an header as often as it appears
  in a foreign declaration.  For properly written headers, it doesn't make a
  difference anyway...

* Library object specifications are currently silently ignored.  The feature
  was mainly requested for external calls in .NET (ie, calls which invoke C
  routines when Haskell is compiled to ILX), but those don't seem to be
  supported yet.

* Foreign label declarations are currently broken, but they were already
  broken before I started messing with the stuff.

The code is moderately tested.  All modules in lib/std/ and hslibs/lang/
(using old-style declarations) still compile fine and I have run a couple of
tests on the different forms of new-style declarations.

document the environment variable expansion done in input package specifications

Provide support for authors that want to distribute packages, by
expanding occurrences of "${foo}" in an input package spec with
the value of the 'foo' environment variable. This permits easy
configuration at install-time, e.g.,

  $ libdir=/opt/haskell/packages/lib ghc-pkg -a < NewPackage.pkg

[Clearly, a separate preprocessing pass using some other tool could
 provide identical functionality. However, the benefits to the
 package author of not having to depend on such a tool being present
 on a user's box was considered more important.
]

recognize .ly as a happy extension

pprFCall: avoid/reduce name-capture problem (as was, safe calling
the C function id() would break.)

Add details clarifying the precise treatment of MagicIds in Stix.

Some stuff I forgot.

Finish off the NCG documentation.

Include the patchlevel in the hi version number.

More wibbles on deriving with -fallow-undecidable-instances

Move showHex, showOct, showBin and showIntAtBase from NumExts to
Numeric as per recent changes to Haskell 98.

When distinguishing between code & data pointers, rather than testing
for membership of the text section, test for not membership of one of
the data sections.

The reason for this change is that testing for membership of the text
section was fragile:  we could only test whether a value was smaller
than the end address, because there doesn't appear to be a portable
way to find the beginning of the text section.  Indeed, the test
breaks on very recent Linux kernels which mmap() memory below the
program text.

In fact, the reversed test may be faster because the expected common
case is when the pointer is into the dynamic heap, and we eliminate
these case immediately in the new test.  A quick test shows no
measurable performance difference with the change.

MERGE TO STABLE

Add URLs and other pointers to resources on the PE COFF format.

Win32 implementation, first pass.

Make a quite-large start on native code generator documentation.

Wibbles to yesterdays changes

Update the building guide w.r.t. the enhanced source-file-searching
mechanisms now in fptools/mk/paths.mk.

Also, add a small section on Makefile debugging while I'm here,
mentioning in particular 'make show'.

Add test for GHCi w/ Happy-generated parsers.

Fix a classic bug: copying a Haskell string with one of the C string
functions (in this case strncpy()) is wrong when the string contains
'\0' characters.

The symptom in this case is that Happy parsers created with -ag don't
work in GHCi, because the state tables are encoded as strings
containing lots of '\0' elements.

fix markup bug

First steps towards implementing better interop between
Concurrent Haskell and native threads.

- factored out Capability handling into a separate source file
  (only the SMP build uses multiple capabilities tho).
- factored out OS/native threads handling into a separate
  source file, OSThreads.{c,h}. Currently, just a pthreads-based
  implementation; Win32 version to follow.
- scheduler code now distinguishes between multi-task threaded
  code (SMP) and single-task threaded code ('threaded RTS'),
  but sharing code between these two modes whenever poss.

i.e., just a first snapshot; the bulk of the transitioning code
remains to be implemented.