Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Commits on Apr 12, 2011
  1. @simonmar

    Change the way module initialisation is done (#3252, #4417)

    simonmar authored
    Previously the code generator generated small code fragments labelled
    with __stginit_M for each module M, and these performed whatever
    initialisation was necessary for that module and recursively invoked
    the initialisation functions for imported modules.  This appraoch had
    drawbacks:
    
     - FFI users had to call hs_add_root() to ensure the correct
       initialisation routines were called.  This is a non-standard,
       and ugly, API.
    
     - unless we were using -split-objs, the __stginit dependencies would
       entail linking the whole transitive closure of modules imported,
       whether they were actually used or not.  In an extreme case (#4387,
       #4417), a module from GHC might be imported for use in Template
       Haskell or an annotation, and that would force the whole of GHC to
       be needlessly linked into the final executable.
    
    So now instead we do our initialisation with C functions marked with
    __attribute__((constructor)), which are automatically invoked at
    program startup time (or DSO load-time).  The C initialisers are
    emitted into the stub.c file.  This means that every time we compile
    with -prof or -hpc, we now get a stub file, but thanks to #3687 that
    is now invisible to the user.
    
    There are some refactorings in the RTS (particularly for HPC) to
    handle the fact that initialisers now get run earlier than they did
    before.
    
    The __stginit symbols are still generated, and the hs_add_root()
    function still exists (but does nothing), for backwards compatibility.
Commits on Aug 2, 2009
  1. @simonmar

    RTS tidyup sweep, first phase

    simonmar authored
    The first phase of this tidyup is focussed on the header files, and in
    particular making sure we are exposinng publicly exactly what we need
    to, and no more.
    
     - Rts.h now includes everything that the RTS exposes publicly,
       rather than a random subset of it.
    
     - Most of the public header files have moved into subdirectories, and
       many of them have been renamed.  But clients should not need to
       include any of the other headers directly, just #include the main
       public headers: Rts.h, HsFFI.h, RtsAPI.h.
    
     - All the headers needed for via-C compilation have moved into the
       stg subdirectory, which is self-contained.  Most of the headers for
       the rest of the RTS APIs have moved into the rts subdirectory.
    
     - I left MachDeps.h where it is, because it is so widely used in
       Haskell code.
     
     - I left a deprecated stub for RtsFlags.h in place.  The flag
       structures are now exposed by Rts.h.
    
     - Various internal APIs are no longer exposed by public header files.
    
     - Various bits of dead code and declarations have been removed
    
     - More gcc warnings are turned on, and the RTS code is more
       warning-clean.
    
     - More source files #include "PosixSource.h", and hence only use
       standard POSIX (1003.1c-1995) interfaces.
    
    There is a lot more tidying up still to do, this is just the first
    pass.  I also intend to standardise the names for external RTS APIs
    (e.g use the rts_ prefix consistently), and declare the internal APIs
    as hidden for shared libraries.
Commits on May 15, 2009
  1. @dcoutts

    Keep C main separate from rts lib and link it in for standalone progs

    dcoutts authored
    Previously the object code for the C main function lived in the rts
    lib, however this is a problem when the rts is built as a shared lib.
    With Windows DLLs it always causes problems while on ELF systems it's a
    problem when the user decides to use their own C main function rather
    than a Haskell Main.main. So instead we now put main in it's own tiny
    little static lib libHSrtsmain.a which we install next to the rts libs.
    Whenever ghc links a program (without -no-hs-main) then it also links
    in -lHSrtsmain. For consistency we always do it this way now rather
    than trying to do it differently for static vs shared libraries.
Commits on Dec 9, 2008
  1. @simonmar

    Fix #2592: do an orderly shutdown when the heap is exhausted

    simonmar authored
    Really we should be raising an exception in this case, but that's
    tricky (see comments).  At least now we shut down the runtime
    correctly rather than just exiting.
Commits on Aug 24, 2007
  1. @igfoo
Commits on Aug 3, 2007
  1. @igfoo

    Catch exceptions on Windows, to stop it popping up dialog boxes

    igfoo authored
    Adaptated from code from Sigbjorn Finne
Commits on Dec 15, 2006
  1. @igfoo
Commits on Oct 24, 2006
  1. Split GC.c, and move storage manager into sm/ directory

    Simon Marlow authored
    In preparation for parallel GC, split up the monolithic GC.c file into
    smaller parts.  Also in this patch (and difficult to separate,
    unfortunatley):
      
      - Don't include Stable.h in Rts.h, instead just include it where
        necessary.
      
      - consistently use STATIC_INLINE in source files, and INLINE_HEADER
        in header files.  STATIC_INLINE is now turned off when DEBUG is on,
        to make debugging easier.
      
      - The GC no longer takes the get_roots function as an argument.
        We weren't making use of this generalisation.
Commits on Jun 7, 2006
  1. Gather timing stats for a Task when it completes.

    Simon Marlow authored
    Previously we did this just for workers, now we do it for the main
    thread and for forkOS threads too.
Commits on Apr 7, 2006
  1. Reorganisation of the source tree

    Simon Marlow authored
    Most of the other users of the fptools build system have migrated to
    Cabal, and with the move to darcs we can now flatten the source tree
    without losing history, so here goes.
    
    The main change is that the ghc/ subdir is gone, and most of what it
    contained is now at the top level.  The build system now makes no
    pretense at being multi-project, it is just the GHC build system.
    
    No doubt this will break many things, and there will be a period of
    instability while we fix the dependencies.  A straightforward build
    should work, but I haven't yet fixed binary/source distributions.
    Changes to the Building Guide will follow, too.
Something went wrong with that request. Please try again.