GitLab

Some multi-processor hackery, including

  - Don't hang blocked threads off BLACKHOLEs any more, instead keep
    them all on a separate queue which is checked periodically for
    threads to wake up.

    This is good because (a) we don't have to worry about locking the
    closure in SMP mode when we want to block on it, and (b) it means
    the standard update code doesn't need to wake up any threads or
    check for a BLACKHOLE_BQ, simplifying the update code.

    The downside is that if there are lots of threads blocked on
    BLACKHOLEs, we might have to do a lot of repeated list traversal.
    We don't expect this to be common, though.  conc023 goes slower
    with this change, but we expect most programs to benefit from the
    shorter update code.

  - Fixing up the Capability code to handle multiple capabilities (SMP
    mode), and related changes to get the SMP mode at least building.

x86_64: generate 32-bit relative offset plus 32-bit padding instead of
a 64-bit relative offset.  This is probably not the best place to do
it, but it'll do for now.

Also reinstate some changes that accidentally got spammed yesterday.

GHC package: set $(GhcLibHcOpts) to empty; we want $(GhcStage2HcOpts)
to take precedence here.

Main x86_64 hacking: we have a problem on this arch where binutils
can't generate 64-bit relative relocations (R_X86_64_PC64), which many
of our info-table fields are.  So far we've been hacking around it by
putting everything in the text section, but I've decided to adopt
another approach: we'll use explicit 32-bit offset fields on this
platform instead.  This is safe in the default "small" memory model
where all symbols are guaranteed to be in the lower 2Gb of the address
space.

NCG changes coming; mangler changes are probably required too.

print format type fixup

printf format type fixup

type fixups

type fixup

In many places there was a common pattern

when (verbose >= n) $ putMsg "..."

It is now replaced with

debutTraceMsg dflags n "..."

In few places hPutStrLn stderr or putStrLn was used instead of putMsg in
the above pattern. They are replaced too. Now putMsg is used only in places
where the verbosity flag was not checked.

Final wibbles, I hope

One more stage2 wibble

More stage2 wibbles

More wibbles to HsSyn changes

Use the imul instruction natively, rather than the braindead wrapper
around it.  The register allocator has been able to handle the fixed
register usage of imul for a while now.  Also, the wrapper was broken
on x86_64.

wibble

Further HsSyn wibbles

Wibbles arising from HsSyn changes

Big cleanup of the scheduler.

The main idea here was to extract as much stuff as possible from the
scheduler loop into seprate functions, so as to better expose the
control structure of the scheduler.  Now, the scheduler loop is down
to some 300+ lines; there's some more code that could be extracted,
but I think it looks pretty good now.

This work is partly due to an initial cleanup by the GRAN/PAR folks,
heavily re-worked by me.

Update hs-boot file

Wibble: invert sense of test

Documentation for rebindable syntax

This commit combines three overlapping things:

1.  Make rebindable syntax work for do-notation. The idea
    here is that, in particular, (>>=) can have a type that
    has class constraints on its argument types, e.g.
       (>>=) :: (Foo m, Baz a) => m a -> (a -> m b) -> m b
    The consequence is that a BindStmt and ExprStmt must have
    individual evidence attached -- previously it was one
    batch of evidence for the entire Do
    
    Sadly, we can't do this for MDo, because we use bind at
    a polymorphic type (to tie the knot), so we still use one
    blob of evidence (now in the HsStmtContext) for MDo.
    
    For arrow syntax, the evidence is in the HsCmd.
    
    For list comprehensions, it's all built-in anyway.
    
    So the evidence on a BindStmt is only used for ordinary
    do-notation.

2.  Tidy up HsSyn.  In particular:

	- Eliminate a few "Out" forms, which we can manage
	without (e.g. 

	- It ought to be the case that the type checker only
	decorates the syntax tree, but doesn't change one
	construct into another.  That wasn't true for NPat,
	LitPat, NPlusKPat, so I've fixed that.

	- Eliminate ResultStmts from Stmt.  They always had
	to be the last Stmt, which led to awkward pattern
	matching in some places; and the benefits didn't seem
	to outweigh the costs.  Now each construct that uses
	[Stmt] has a result expression too (e.g. GRHS).


3.  Make 'deriving( Ix )' generate a binding for unsafeIndex,
    rather than for index.  This is loads more efficient.

    (This item only affects TcGenDeriv, but some of point (2)
    also affects TcGenDeriv, so it has to be in one commit.)

comment out parts of the Win32 DLLs section, specifically those that
don't apply to current Windows distributions.

Give prototypes for getAllocations and revertCAFs.

x86_64: some small optimisations to instruction selection, taking
advantage of automatic zero-extension of 32-bit results.

regUsage(x86_64): tell the register allocator that argument registers are read
by call instructions.

mkSpillInstr/mkLoadInstr(x86_64): implement FP spills/loads, not sure
if this is quite right yet.

x86_64: fix reg printing

#include "MachDeps.h" to get WORD_SIZE_IN_BITS (fixes profasm breakages)

unconditionally define oFFSET_StgRegTable_rL1

enable x86_64 native codegen

First cut at the x86_64 native code generator.  Lots of code is shared
with i386, but floating point uses SSE2.

This more or less works, the things I know that don't work are:

  - the floating-point primitives (sin, cos etc.) are missing
  - floating-point comparisons involving NaN are wrong
  - there's no PIC support yet

Also, I have a long list of small things to fix up to improve
performance.

I think the small memory model is assumed, for now.

build fix when !GHCI

DriverPipeline.compile: we should be grabbing the OPTIONS from the
StringBuffer, not reading the file again (duh!)

SysTools: some message cleanups

More hacking on the GHC API to get it into shape for VS

 - load now takes a LoadHowMuch argument, which is either
	LoadAllTargets
	LoadUpTo Module
	LoadDependenciesOf Module
   which should be self-explanatory.  LoadDependenciesOf might go
   away in the future, it's necessary at the moment because it is
   used in the implementation of:

 - checkModule :: Session -> Module -> MessageHandler -> IO CheckResult

   which is currently the only way to get at the parsed & typechecked
   abstract syntax for a module.

- fix depends field
- remove Main module

Tweaks to get the GHC sources through Haddock.  Doesn't quite work
yet, because Haddock complains about the recursive modules.  Haddock
needs to understand SOURCE imports (it can probably just ignore them
as a first attempt).

foreign import syntax

commas in export list

remove extra commas in export list

Make getourtimeofday() return lnat instead of nat, and propagate changes.