1. 23 May, 2000 1 commit
    • simonpj's avatar
      [project @ 2000-05-23 11:35:36 by simonpj] · bb91427f
      simonpj authored
      *** MERGE WITH 4.07 (once I've checked it works) ***
      
      * Fix result type signatures.  Note that a consequential change is that
        an ordinary binding with a variable on the left
      	f = e
        is now treated as a FunMonoBind, not a PatMonoBind.  This makes
        a few things a bit simpler (eg rnMethodBinds)
      
      * Fix warnings for unused imports.  This meant moving where provenances
        are improved in RnNames.  Move mkExportAvails from RnEnv to RnNames.
      
      * Print module names right (small change in Module.lhs and Rename.lhs)
      
      * Remove a few unused bindings
        
      * Add a little hack to let us print info about join points that turn
        out not to be let-no-escaped.  The idea is to call them "$j" and report
        any such variables that are not let-no-escaped.
      
      * Some small things aiming towards -ddump-types (harmless but incomplete)
      bb91427f
  2. 15 May, 2000 1 commit
  3. 21 Apr, 2000 2 commits
    • simonpj's avatar
      [project @ 2000-04-21 14:40:48 by simonpj] · 0666c3bb
      simonpj authored
      Remove a way to make the simplifier go into an
      infinite loop.   This has been there for some weeks;
      and George's UniForm tickled it.  I'm amazed nothing
      else has done so.  I'll add a test.
      
      The bad case happened when you go
      
      	let xs = 1:xs
      	in
      	foldr k z xs
      
      Then we kept firing the foldr/cons rule.
      
      Solution: we don't attach an unfolding *at all* to
      loop breakers (Simplify.completeBinding)
      0666c3bb
    • simonpj's avatar
      [project @ 2000-04-21 12:57:54 by simonpj] · c30bd911
      simonpj authored
      /home/simonpj/tmp/msg
      c30bd911
  4. 14 Apr, 2000 1 commit
  5. 13 Apr, 2000 1 commit
    • simonpj's avatar
      [project @ 2000-04-13 11:56:35 by simonpj] · 9579283c
      simonpj authored
      Add support for 'packages'.
      
      * A package is a group of modules.
      
      * A package has a name (e.g. std)
      
      * A package is built into a single library (Unix; e.g. libHSstd.a)
                             or a single DLL     (Windows; e.g. HSstd.dll)
      
      * The '-package-name foo' flag tells GHC that the module being compiled
        is destined for package foo.
      
      * The '-package foo' flag tells GHC to make available modules
        from package 'foo'.  It replaces '-syslib foo' which is now deprecated.
      
      * Cross-package references cost an extra indirection in Windows,
        but not Unix
      
      * GHC does not maintain detailed cross-package dependency information.
        It does remember which modules in other packages the current module
        depends on, but not which things within those imported things.
      
      
      All of this tidies up the Prelude enormously.  The Prelude and
      Standard Libraries are built into a singl package called 'std'.  (This
      is a change; the library is now called libHSstd.a instead of libHS.a)
      9579283c
  6. 05 Apr, 2000 1 commit
    • simonpj's avatar
      [project @ 2000-04-05 16:25:51 by simonpj] · d4e0a55c
      simonpj authored
      * Add new flag -fddump-minimal-imports, which dumps a file
        M.imports that contains the (allegedly) minimal bunch of
        imports that make the system work.
        It's done by Rename.printMinimalImports
      
      * Extend foreign import/export to handle
      	* Booleans
      	* newtypes
        as requested by the FFI team
      
      * Tidy up DsCCall quite a bit
        Remove maybeBoxedPrimTy from TcHsSyn
      d4e0a55c
  7. 03 Apr, 2000 2 commits
  8. 27 Mar, 2000 1 commit
    • simonpj's avatar
      [project @ 2000-03-27 13:24:12 by simonpj] · a127213c
      simonpj authored
      a) Move Unfolding and UnfoldingGuidance to CoreSyn
         As a result, remove several SOURCE imports
         Shrink CoreSyn.hi-boot considerably
         Delete CoreUnfold.hi-boot altogether
      
      b) Add CoreUtils.exprIsConApp_maybe
         Use in PrelRules to fix a bug in the dataToTag rule
      
      c) Fix boolean polarity error in Simplify.lhs
      a127213c
  9. 24 Mar, 2000 1 commit
    • simonpj's avatar
      [project @ 2000-03-24 17:49:29 by simonpj] · 6c872fff
      simonpj authored
      a) Small wibbles to do with inlining and floating
      
      b) Implement Ralf's request, so that one can write
      
      	type F = forall a. a -> a
      
      	f :: Int -> F
      	f = ...
      
         The for-alls inside F are hoisted out to the top of
         the type signature for f.  This applies uniformly to
         all user-written types
      6c872fff
  10. 23 Mar, 2000 2 commits
    • simonpj's avatar
      [project @ 2000-03-23 17:45:17 by simonpj] · 111cee3f
      simonpj authored
      This utterly gigantic commit is what I've been up to in background
      mode in the last couple of months.  Originally the main goal
      was to get rid of Con (staturated constant applications)
      in the CoreExpr type, but one thing led to another, and I kept
      postponing actually committing.   Sorry.
      
      	Simon, 23 March 2000
      
      
      I've tested it pretty thoroughly, but doubtless things will break.
      
      Here are the highlights
      
      * Con is gone; the CoreExpr type is simpler
      * NoRepLits have gone
      * Better usage info in interface files => less recompilation
      * Result type signatures work
      * CCall primop is tidied up
      * Constant folding now done by Rules
      * Lots of hackery in the simplifier
      * Improvements in CPR and strictness analysis
      
      Many bug fixes including
      
      * Sergey's DoCon compiles OK; no loop in the strictness analyser
      * Volker Wysk's programs don't crash the CPR analyser
      
      I have not done much on measuring compilation times and binary sizes;
      they could have got worse.  I think performance has got significantly
      better, though, in most cases.
      
      
      Removing the Con form of Core expressions
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      The big thing is that
      
        For every constructor C there are now *two* Ids:
      
      	C is the constructor's *wrapper*. It evaluates and unboxes arguments
      	before calling $wC.  It has a perfectly ordinary top-level defn
      	in the module defining the data type.
      
      	$wC is the constructor's *worker*.  It is like a primop that simply
      	allocates and builds the constructor value.  Its arguments are the
      	actual representation arguments of the constructor.
      	Its type may be different to C, because:
      		- useless dict args are dropped
      		- strict args may be flattened
      
        For every primop P there is *one* Id, its (curried) Id
      
        Neither contructor worker Id nor the primop Id have a defminition anywhere.
        Instead they are saturated during the core-to-STG pass, and the code generator
        generates code for them directly. The STG language still has saturated
        primops and constructor applications.
      
      * The Const type disappears, along with Const.lhs.  The literal part
        of Const.lhs reappears as Literal.lhs.  Much tidying up in here,
        to bring all the range checking into this one module.
      
      * I got rid of NoRep literals entirely.  They just seem to be too much trouble.
      
      * Because Con's don't exist any more, the funny C { args } syntax
        disappears from inteface files.
      
      
      Parsing
      ~~~~~~~
      * Result type signatures now work
      	f :: Int -> Int = \x -> x
      	-- The Int->Int is the type of f
      
      	g x y :: Int = x+y
      	-- The Int is the type of the result of (g x y)
      
      
      Recompilation checking and make
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      * The .hi file for a modules is not touched if it doesn't change.  (It used to
        be touched regardless, forcing a chain of recompilations.)  The penalty for this
        is that we record exported things just as if they were mentioned in the body of
        the module.  And the penalty for that is that we may recompile a module when
        the only things that have changed are the things it is passing on without using.
        But it seems like a good trade.
      
      * -recomp is on by default
      
      Foreign declarations
      ~~~~~~~~~~~~~~~~~~~~
      * If you say
      	foreign export zoo :: Int -> IO Int
        then you get a C produre called 'zoo', not 'zzoo' as before.
        I've also added a check that complains if you export (or import) a C
        procedure whose name isn't legal C.
      
      
      Code generation and labels
      ~~~~~~~~~~~~~~~~~~~~~~~~~~
      * Now that constructor workers and wrappers have distinct names, there's
        no need to have a Foo_static_closure and a Foo_closure for constructor Foo.
        I nuked the entire StaticClosure story.  This has effects in some of
        the RTS headers (i.e. s/static_closure/closure/g)
      
      
      Rules, constant folding
      ~~~~~~~~~~~~~~~~~~~~~~~
      * Constant folding becomes just another rewrite rule, attached to the Id for the
        PrimOp.   To achieve this, there's a new form of Rule, a BuiltinRule (see CoreSyn.lhs).
        The prelude rules are in prelude/PrelRules.lhs, while simplCore/ConFold.lhs has gone.
      
      * Appending of constant strings now works, using fold/build fusion, plus
        the rewrite rule
      	unpack "foo" c (unpack "baz" c n)  =  unpack "foobaz" c n
        Implemented in PrelRules.lhs
      
      * The CCall primop is tidied up quite a bit.  There is now a data type CCall,
        defined in PrimOp, that packages up the info needed for a particular CCall.
        There is a new Id for each new ccall, with an big "occurrence name"
      	{__ccall "foo" gc Int# -> Int#}
        In interface files, this is parsed as a single Id, which is what it is, really.
      
      Miscellaneous
      ~~~~~~~~~~~~~
      * There were numerous places where the host compiler's
        minInt/maxInt was being used as the target machine's minInt/maxInt.
        I nuked all of these; everything is localised to inIntRange and inWordRange,
        in Literal.lhs
      
      * Desugaring record updates was broken: it didn't generate correct matches when
        used withe records with fancy unboxing etc.  It now uses matchWrapper.
      
      * Significant tidying up in codeGen/SMRep.lhs
      
      * Add __word, __word64, __int64 terminals to signal the obvious types
        in interface files.  Add the ability to print word values in hex into
        C code.
      
      * PrimOp.lhs is no longer part of a loop.  Remove PrimOp.hi-boot*
      
      
      Types
      ~~~~~
      * isProductTyCon no longer returns False for recursive products, nor
        for unboxed products; you have to test for these separately.
        There's no reason not to do CPR for recursive product types, for example.
        Ditto splitProductType_maybe.
      
      Simplification
      ~~~~~~~~~~~~~~~
      * New -fno-case-of-case flag for the simplifier.  We use this in the first run
        of the simplifier, where it helps to stop messing up expressions that
        the (subsequent) full laziness pass would otherwise find float out.
        It's much more effective than previous half-baked hacks in inlining.
      
        Actually, it turned out that there were three places in Simplify.lhs that
        needed to know use this flag.
      
      * Make the float-in pass push duplicatable bindings into the branches of
        a case expression, in the hope that we never have to allocate them.
        (see FloatIn.sepBindsByDropPoint)
      
      * Arrange that top-level bottoming Ids get a NOINLINE pragma
        This reduced gratuitous inlining of error messages.
        But arrange that such things still get w/w'd.
      
      * Arrange that a strict argument position is regarded as an 'interesting'
        context, so that if we see
      	foldr k z (g x)
        then we'll be inclined to inline g; this can expose a build.
      
      * There was a missing case in CoreUtils.exprEtaExpandArity that meant
        we were missing some obvious cases for eta expansion
        Also improve the code when handling applications.
      
      * Make record selectors (identifiable by their IdFlavour) into "cheap" operations.
      	  [The change is a 2-liner in CoreUtils.exprIsCheap]
        This means that record selection may be inlined into function bodies, which
        greatly improves the arities of overloaded functions.
      
      * Make a cleaner job of inlining "lone variables".  There was some distributed
        cunning, but I've centralised it all now in SimplUtils.analyseCont, which
        analyses the context of a call to decide whether it is "interesting".
      
      * Don't specialise very small functions in Specialise.specDefn
        It's better to inline it.  Rather like the worker/wrapper case.
      
      * Be just a little more aggressive when floating out of let rhss.
        See comments with Simplify.wantToExpose
        A small change with an occasional big effect.
      
      * Make the inline-size computation think that
      	case x of I# x -> ...
        is *free*.
      
      
      CPR analysis
      ~~~~~~~~~~~~
      * Fix what was essentially a bug in CPR analysis.  Consider
      
      	letrec f x = let g y = let ... in f e1
      		     in
      		     if ... then (a,b) else g x
      
        g has the CPR property if f does; so when generating the final annotated
        RHS for f, we must use an envt in which f is bound to its final abstract
        value.  This wasn't happening.  Instead, f was given the CPR tag but g
        wasn't; but of course the w/w pass gives rotten results in that case!!
        (Because f's CPR-ness relied on g's.)
      
        On they way I tidied up the code in CprAnalyse.  It's quite a bit shorter.
      
        The fact that some data constructors return a constructed product shows
        up in their CPR info (MkId.mkDataConId) not in CprAnalyse.lhs
      
      
      
      Strictness analysis and worker/wrapper
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      * BIG THING: pass in the demand to StrictAnal.saExpr.  This affects situations
        like
      	f (let x = e1 in (x,x))
        where f turns out to have strictness u(SS), say.  In this case we can
        mark x as demanded, and use a case expression for it.
      
        The situation before is that we didn't "know" that there is the u(SS)
        demand on the argument, so we simply computed that the body of the let
        expression is lazy in x, and marked x as lazily-demanded.  Then even after
        f was w/w'd we got
      
      	let x = e1 in case (x,x) of (a,b) -> $wf a b
      
        and hence
      
      	let x = e1 in $wf a b
      
        I found a much more complicated situation in spectral/sphere/Main.shade,
        which improved quite a bit with this change.
      
      * Moved the StrictnessInfo type from IdInfo to Demand.  It's the logical
        place for it, and helps avoid module loops
      
      * Do worker/wrapper for coerces even if the arity is zero.  Thus:
      	stdout = coerce Handle (..blurg..)
        ==>
      	wibble = (...blurg...)
      	stdout = coerce Handle wibble
        This is good because I found places where we were saying
      	case coerce t stdout of { MVar a ->
      	...
      	case coerce t stdout of { MVar b ->
      	...
        and the redundant case wasn't getting eliminated because of the coerce.
      111cee3f
    • sewardj's avatar
      [project @ 2000-03-23 12:22:04 by sewardj] · 1e5271f1
      sewardj authored
      In interface files, don't forget to mention the names of modules imported
      via hi-boot files.  This is needed so that Hugs can use the import decls
      in interface files to safely overestimate the dependency sets which it will
      encounter when linking object code.
      1e5271f1
  11. 08 Mar, 2000 1 commit
    • simonmar's avatar
      [project @ 2000-03-08 17:48:24 by simonmar] · de896403
      simonmar authored
      - generalise the per-module initialisation stubs so that we use it
        in normal (non-profiled) code too.  The initialisation stubs are
        now called '__init_<module>' rather than '_reg<module>'.
      
      - Register foreign exported functions as stable pointers in the
        initialisation code for the module.  This fixes the foreign export
        problems reported by several people.
      
      - remove the concept of "module groups" from the profiling subsystem.
      
      - change the profiling semantics slightly; it should be unnecessary
        to use '-caf-all' to get reasonable profiles now.
      de896403
  12. 02 Mar, 2000 1 commit
  13. 25 Feb, 2000 1 commit
    • panne's avatar
      [project @ 2000-02-25 14:55:31 by panne] · f83a5a68
      panne authored
      Deprecations of variables now works, although the source location is
      not yet reported correctly and the code needs some cleanup. Added a
      new flag -fwarn-deprecations to the set of standard warnings. The
      syntax of deprecations has been extended to deprecate types, classes,
      or even constructors, although this does not work yet.
      f83a5a68
  14. 22 Feb, 2000 1 commit
  15. 21 Feb, 2000 1 commit
  16. 20 Feb, 2000 1 commit
  17. 15 Feb, 2000 1 commit
    • panne's avatar
      [project @ 2000-02-15 22:18:16 by panne] · 06619533
      panne authored
      First steps towards DEPRECATED before Rosebank (12yrs) takes its toll.
      Nothing very functional yet, but at least hsc can be compiled and it
      still compiles the Prelude.
      
      Parsing the pragma turned out to be a little bit more complicated than
      expected, here the comment from Parser.y:
      
         The place for module deprecation is really too restrictive, but if it
         was allowed at its natural place just before 'module', we get an ugly
         s/r conflict with the second alternative. Another solution would be the
         introduction of a new pragma DEPRECATED_MODULE, but this is not very nice,
         either, and DEPRECATED is only expected to be used by people who really
         know what they are doing. :-)
      
      Net result: Module deprecation is allowed exactly behind the module's
      name and nowhere else. I probably have to think a little bit more
      about this some day...
      06619533
  18. 09 Feb, 2000 1 commit
  19. 31 Jan, 2000 1 commit
  20. 28 Jan, 2000 1 commit
    • lewie's avatar
      [project @ 2000-01-28 20:52:37 by lewie] · 266fadd9
      lewie authored
      First pass at implicit parameters.  Honest, I didn't really go in *intending*
      to modify every file in the typechecker... ;-)  The breadth of the change
      is partly due to generalizing contexts so that they are not hardwired to
      be (Class, [Type]) pairs.  See types/Type.lhs for details (look for PredType).
      266fadd9
  21. 24 Jan, 2000 1 commit
    • sewardj's avatar
      [project @ 2000-01-24 18:22:07 by sewardj] · 9ac31f7c
      sewardj authored
      ARR_HDR_SIZE --> ARR_WORDS_HDR_SIZE, and derived quantities in
      Constants.h, Constants.lhs et al are similarly renamed.
      
      new constant ARR_PTRS_HDR_SIZE, with corresponding derivatives.
      9ac31f7c
  22. 13 Jan, 2000 3 commits
  23. 04 Jan, 2000 1 commit
    • simonpj's avatar
      [project @ 2000-01-04 17:40:46 by simonpj] · 5ca77490
      simonpj authored
      This commit arranges that literal strings will fuse
      nicely, by expressing them as an application of build.
      
      * NoRepStr is now completely redundant, though I havn't removed it yet.
      
      * The unpackStr stuff moves from PrelPack to PrelBase.
      
      * There's a new form of Rule, a BuiltinRule, for rules that
        can't be expressed in Haskell.  The string-fusion rule is one
        such.  It's defined in prelude/PrelRules.lhs.
      
      * PrelRules.lhs also contains a great deal of code that
        implements constant folding.  In due course this will replace
        ConFold.lhs, but for the moment it simply duplicates it.
      5ca77490
  24. 20 Dec, 1999 1 commit
    • simonpj's avatar
      [project @ 1999-12-20 10:34:27 by simonpj] · e921b2e3
      simonpj authored
      This commit implements a substantial re-organisation of the Prelude
      It also fixes a couple of small renamer bugs that were reported recently
      	(notably, Sven pointed out that we weren't reporting
      	unused imports properly)
      
      My original goal was to get rid of all "orphan" modules (i.e. ones
      with instance decls that don't belong either to a tycon or a class
      defined in the same module).  This should reduce the number of
      interface files that have to be read when compiling small Haskell
      modules.
      
      But like most expeditions into the Prelude Swamp, it spiraled out
      of control.  The result is quite satisfactory, though.
      
      	GONE AWAY:	PrelCCall, PrelNumExtra
      
      	NEW:		PrelReal, PrelFloat, PrelByteArr, PrelNum.hi-boot
      
      (The extra PrelNum.hi-boot is because of a tiresome thin-air Id, addr2Integer,
      which used to be in PrelBase.)
      
      Quite a lot of types have moved from one module to another,
      which entails some changes to part of the compiler (PrelInfo, PrelMods) etc,
      and there are a few places in the RTS includes and even in the driver
      that know about these home modules (alas).
      
      So the rough structure is as follows, in (linearised) dependency order
      	[this list now appears in PrelBase.lhs]
      
      PrelGHC		Has no implementation.  It defines built-in things, and
      		by importing it you bring them into scope.
      		The source file is PrelGHC.hi-boot, which is just
      		copied to make PrelGHC.hi
      
      		Classes: CCallable, CReturnable
      
      PrelBase	Classes: Eq, Ord, Functor, Monad
      		Types:   list, (), Int, Bool, Ordering, Char, String
      
      PrelTup		Types: tuples, plus instances for PrelBase classes
      
      PrelShow	Class: Show, plus instances for PrelBase/PrelTup types
      
      PrelEnum	Class: Enum,  plus instances for PrelBase/PrelTup types
      
      PrelMaybe	Type: Maybe, plus instances for PrelBase classes
      
      PrelNum		Class: Num, plus instances for Int
      		Type:  Integer, plus instances for all classes so far (Eq, Ord, Num, Show)
      
      		Integer is needed here because it is mentioned in the signature
      		of 'fromInteger' in class Num
      
      PrelReal	Classes: Real, Integral, Fractional, RealFrac
      			 plus instances for Int, Integer
      		Types:  Ratio, Rational
      			plus intances for classes so far
      
      		Rational is needed here because it is mentioned in the signature
      		of 'toRational' in class Real
      
      Ix		Classes: Ix, plus instances for Int, Bool, Char, Integer, Ordering, tuples
      
      PrelArr		Types: Array, MutableArray, MutableVar
      
      		Does *not* contain any ByteArray stuff (see PrelByteArr)
      		Arrays are used by a function in PrelFloat
      
      PrelFloat	Classes: Floating, RealFloat
      		Types:   Float, Double, plus instances of all classes so far
      
      		This module contains everything to do with floating point.
      		It is a big module (900 lines)
      		With a bit of luck, many modules can be compiled without ever reading PrelFloat.hi
      
      PrelByteArr	Types: ByteArray, MutableByteArray
      
      		We want this one to be after PrelFloat, because it defines arrays
      		of unboxed floats.
      
      
      Other Prelude modules are much easier with fewer complex dependencies.
      e921b2e3
  25. 09 Dec, 1999 1 commit
    • simonpj's avatar
      [project @ 1999-12-09 12:30:56 by simonpj] · 39262efa
      simonpj authored
      A bunch of small changes in the way that usage information
      is generated to stuff into interface files.  I'm not certain
      anything was really wrong before, but it's tidier now, and
      there are slightly fewer dependencies generated.  Main
      differences are in RnIfaces.getImportVersions
      
      I also made the check for orphan rules a bit cleverer
      (Rename.isOrphanDecl) so that we get fewer spurious orphan modules.
      
      Simon
      39262efa
  26. 30 Nov, 1999 1 commit
    • lewie's avatar
      [project @ 1999-11-30 16:10:07 by lewie] · e1e1d020
      lewie authored
      First bits o' functional dependencies - just the syntax and related
      datatypes, plus started moving some of the static checks from the
      renamer (where we don't know about fundeps) to later in the typechecker.
      e1e1d020
  27. 29 Nov, 1999 1 commit
    • simonpj's avatar
      [project @ 1999-11-29 17:34:14 by simonpj] · e1a4f2a5
      simonpj authored
      Make it so that a class decl generates default method decls
      for every method, not just for the ones that the user supplies
      default-methods for.
      
      GHC will never call these default-default methods, because
      when it finds an instance decl with no defn for a method,
      *and* the class decl doesn't have a user-programmed default
      method, it whips up a new default method for that instance
      decl so that the error message is more informative than
      the default-default method would be.
      
      But Hugs isn't so smart, and wants to call something from
      the class decl.
      
      This change required fiddling with more than I expected.  Sigh.
      
      Simon
      e1a4f2a5
  28. 02 Nov, 1999 1 commit
    • simonmar's avatar
      [project @ 1999-11-02 15:05:38 by simonmar] · f6692611
      simonmar authored
      This commit adds in the current state of our SMP support.  Notably,
      this allows the new way 's' to be built, providing support for running
      multiple Haskell threads simultaneously on top of any pthreads
      implementation, the idea being to take advantage of commodity SMP
      boxes.
      
      Don't expect to get much of a speedup yet; due to the excessive
      locking required to synchronise access to mutable heap objects, you'll
      see a slowdown in most cases, even on a UP machine.  The best I've
      seen is a 1.6-1.7 speedup on an example that did no locking (two
      optimised nfibs in parallel).
      
      	- new RTS -N flag specifies how many pthreads to start.
      
      	- new driver -smp flag, tells the driver to use way 's'.
      
      	- new compiler -fsmp option (not for user comsumption)
      	  tells the compiler not to generate direct jumps to
      	  thunk entry code.
      
      	- largely rewritten scheduler
      
      	- _ccall_GC is now done by handing back a "token" to the
      	  RTS before executing the ccall; it should now be possible
      	  to execute blocking ccalls in the current thread while
      	  allowing the RTS to continue running Haskell threads as
      	  normal.
      
      	- you can only call thread-safe C libraries from a way 's'
      	  build, of course.
      
      Pthread support is still incomplete, and weird things (including
      deadlocks) are likely to happen.
      f6692611
  29. 01 Nov, 1999 1 commit
    • simonpj's avatar
      [project @ 1999-11-01 17:09:54 by simonpj] · 30b5ebe4
      simonpj authored
      A regrettably-gigantic commit that puts in place what Simon PJ
      has been up to for the last month or so, on and off.
      
      The basic idea was to restore unfoldings to *occurrences* of
      variables without introducing a space leak.  I wanted to make
      sure things improved relative to 4.04, and that proved depressingly
      hard.  On the way I discovered several quite serious bugs in the
      simplifier.
      
      Here's a summary of what's gone on.
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      * No commas between for-alls in RULES.  This makes the for-alls have
        the same syntax as in types.
      
      * Arrange that simplConArgs works in one less pass than before.
        This exposed a bug: a bogus call to completeBeta.
      
      * Add a top-level flag in CoreUnfolding, used in callSiteInline
      
      * Extend w/w to use etaExpandArity, so it does eta/coerce expansion
      
      * Implement inline phases.   The meaning of the inline pragmas is
        described in CoreUnfold.lhs.  You can say things like
      	{#- INLINE 2 build #-}
        to mean "inline build in phase 2"
      
      * Don't float anything out of an INLINE.
        Don't float things to top level unless they also escape a value lambda.
      	[see comments with SetLevels.lvlMFE
        Without at least one of these changes, I found that
      	{-# INLINE concat #-}
      	concat = __inline (/\a -> foldr (++) [])
        was getting floated to
      	concat = __inline( /\a -> lvl a )
      	lvl = ...inlined version of foldr...
      
        Subsequently I found that not floating constants out of an INLINE
        gave really bad code like
      	__inline (let x = e in \y -> ...)
        so I now let things float out of INLINE
      
      * Implement the "reverse-mapping" idea for CSE; actually it turned out to be easier
        to implement it in SetLevels, and may benefit full laziness too.
      
      * It's a good idea to inline inRange. Consider
      
      	index (l,h) i = case inRange (l,h) i of
      		  	  True ->  l+i
      			  False -> error
        inRange itself isn't strict in h, but if it't inlined then 'index'
        *does* become strict in h.  Interesting!
      
      * Big change to the way unfoldings and occurrence info is propagated in the simplifier
        The plan is described in Subst.lhs with the Subst type
        Occurrence info is now in a separate IdInfo field than user pragmas
      
      * I found that
      	(coerce T (coerce S (\x.e))) y
        didn't simplify in one round. First we get to
      	(\x.e) y
        and only then do the beta. Solution: cancel the coerces in the continuation
      
      * Amazingly, CoreUnfold wasn't counting the cost of a function an application.
      
      * Disable rules in initial simplifier run.  Otherwise full laziness
        doesn't get a chance to lift out a MFE before a rule (e.g. fusion)
        zaps it.  queens is a case in point
      
      * Improve float-out stuff significantly.  The big change is that if we have
      
      	\x -> ... /\a -> ...let p = ..a.. in let q = ...p...
      
        where p's rhs doesn't x, we abstract a from p, so that we can get p past x.
        (We did that before.)  But we also substitute (p a) for p in q, and then
        we can do the same thing for q.  (We didn't do that, so q got stuck.)
        This is much better.  It involves doing a substitution "as we go" in SetLevels,
        though.
      30b5ebe4
  30. 13 Oct, 1999 1 commit
  31. 26 Sep, 1999 1 commit
    • sof's avatar
      [project @ 1999-09-26 16:01:08 by sof] · 04d9abca
      sof authored
      Increased friendliness re: record construction a little:
      
        * constructions that fail to mention one or more strict
          fields are now flagged as an error, which the Report demands.
        * Optionally warn about other missing fields. -fwarn-missing-fields
          takes you there, and it is in currently in the '-W' set of
          warnings.
      04d9abca
  32. 17 Sep, 1999 1 commit
    • simonpj's avatar
      [project @ 1999-09-17 09:15:22 by simonpj] · 731f53de
      simonpj authored
      This bunch of commits represents work in progress on inlining and
      worker/wrapper stuff.
      
      Currently, I think it makes the compiler slightly worse than 4.04, for
      reasons I don't yet understand.  But it means that Simon and I can
      both peer at what is going on.
      
      * Substantially improve handling of coerces in worker/wrapper
      
      * exprIsDupable for an application (f e1 .. en) wasn't calling exprIsDupable
        on the arguments!!  So applications with few, but large, args were being dupliated.
      
      * sizeExpr on an application wasn't doing a nukeScrutDiscount on the arg of
        an application!!  So bogus discounts could accumulate from arguments!
      
      * Improve handling of INLINE pragmas in calcUnfoldingGuidance.  It was really
        wrong before
      731f53de
  33. 09 Aug, 1999 1 commit
    • sof's avatar
      [project @ 1999-08-09 14:28:49 by sof] · c8a3ddcb
      sof authored
      First step along the way of having GHC understand DOS-style paths
      (hot new feature!) - if ';' occurs in a -i<dirs> list, ';' is used
      to separate entries on the import search path, otherwise its trusty
      old ':'.
      
      [This commit is made simply to unblock some Win32 users, but it
       shouldn't have any untoward effects on others. If it does, please
       back it out as I'm about to take off for a couple of weeks.]
      c8a3ddcb
  34. 27 Jul, 1999 1 commit
    • sof's avatar
      [project @ 1999-07-27 10:50:17 by sof] · be1c09e7
      sof authored
      Improve the UI a little for modules contain 'foreign export' declarations -
      no longer demand that module name == (basename filename)
      be1c09e7
  35. 15 Jul, 1999 1 commit
    • keithw's avatar
      [project @ 1999-07-15 14:08:03 by keithw] · 9d787ef5
      keithw authored
      This commit makes a start at implementing polymorphic usage
      annotations.
      
      * The module Type has now been split into TypeRep, containing the
        representation Type(..) and other information for `friends' only,
        and Type, providing the public interface to Type.  Due to a bug in
        the interface-file slurping prior to ghc-4.04, {-# SOURCE #-}
        dependencies must unfortunately still refer to TypeRep even though
        they are not friends.
      
      * Unfoldings in interface files now print as __U instead of __u.
        UpdateInfo now prints as __UA instead of __U.
      
      * A new sort of variables, UVar, in their own namespace, uvName, has
        been introduced for usage variables.
      
      * Usage binders __fuall uv have been introduced.  Usage annotations
        are now __u - ty (used once), __u ! ty (used possibly many times),
        __u uv ty (used uv times), where uv is a UVar.  __o and __m have
        gone.  All this still lives only in a TyNote, *for now* (but not for
        much longer).
      
      * Variance calculation for TyCons has moved from
        typecheck/TcTyClsDecls to types/Variance.
      
      * Usage annotation and inference are now done together in a single
        pass.  Provision has been made for inferring polymorphic usage
        annotations (with __fuall) but this has not yet been implemented.
        Watch this space!
      9d787ef5