This project is mirrored from Pull mirroring failed .
Repository mirroring has been paused due to too many failed attempts. It can be resumed by a project maintainer.
Last successful update .
  1. 08 Mar, 2001 1 commit
    • simonpj's avatar
      [project @ 2001-03-08 12:07:38 by simonpj] · 51a571c0
      simonpj authored
      	A major hygiene pass
      1. The main change here is to
      	Move what was the "IdFlavour" out of IdInfo,
      	and into the varDetails field of a Var
         It was a mess before, because the flavour was a permanent attribute
         of an Id, whereas the rest of the IdInfo was ephemeral.  It's
         all much tidier now.
         Main places to look:
      	   Var.lhs	Defn of VarDetails
      	   IdInfo.lhs	Defn of GlobalIdDetails
         The main remaining infelicity is that SpecPragmaIds are right down
         in Var.lhs, which seems unduly built-in for such an ephemeral thing.
         But that is no worse than before.
      2. Tidy up the HscMain story a little.  Move mkModDetails from MkIface
         into CoreTidy (where it belongs more nicely)
         This was partly forced by (1) above, because I didn't want to make
         DictFun Ids into a separate kind of Id (which is how it was before).
         Not having them separate means we have to keep a list of them right
         through, rather than pull them out of the bindings at the end.
      3. Add NameEnv as a separate module (to join NameSet).
      4. Remove unnecessary {-# SOURCE #-} imports from FieldLabel.
  2. 06 Mar, 2001 1 commit
  3. 05 Mar, 2001 1 commit
    • simonpj's avatar
      [project @ 2001-03-05 12:45:45 by simonpj] · e6dff21d
      simonpj authored
      Improve SpecConstr
      This commit fixes SpecConstr so that it can see the effect of
      enclosing case expressions properly.  That's what the "cons" field
      in ScEnv is for.
      As a result, consider this function:
        data AccessPath = Cont  AccessPath
      		  | Value Int
        demandAll n ap@(Cont (Value (I# i1)))
          = case n of
      	0     -> i1
      	other -> i1 +# demandAll (n-1) ap
      SpecConstr now successfully compiles it to this:
          = \ i1 :: PrelGHC.Int# sc :: PrelGHC.Int# ->
            case sc of ds {
      	0 -> i1;
      	__DEFAULT -> PrelGHC.+# i1 (Foo.$s$wdemandAll i1 (PrelGHC.-# ds 1))
      with the rule
       "SC:$wdemandAll1" __forall i1 :: PrelGHC.Int# ,
      			    sc :: PrelGHC.Int# .
      	Foo.$wdemandAll sc (Foo.$wCont (Foo.$wValue (PrelBase.$wI# i1)))
      	= Foo.$s$wdemandAll i1 sc ;
  4. 01 Mar, 2001 1 commit
  5. 28 Feb, 2001 1 commit
    • simonpj's avatar
      [project @ 2001-02-28 11:48:34 by simonpj] · 12e6a9a5
      simonpj authored
      Add most of the code for constructor specialisation.  The comment
      below is reproduced from specialise/SpecConstr.lhs.
      It doesn't quite work properly yet, because we need to have 
      rules in scope in a recursive function's own RHS, and that
      entails a bit of fiddling I havn't yet completed.  But SpecConstr
      itself is a nice neat 250 lines of code.
      			Game plan
      	drop n []     = []
      	drop 0 xs     = []
      	drop n (x:xs) = drop (n-1) xs
      After the first time round, we could pass n unboxed.  This happens in
      numerical code too.  Here's what it looks like in Core:
      	drop n xs = case xs of
      		      []     -> []
      		      (y:ys) -> case n of 
      				  I# n# -> case n# of
      					     0 -> []
      					     _ -> drop (I# (n# -# 1#)) xs
      Notice that the recursive call has an explicit constructor as argument.
      Noticing this, we can make a specialised version of drop
      	RULE: drop (I# n#) xs ==> drop' n# xs
      	drop' n# xs = let n = I# n# in ...orig RHS...
      Now the simplifier will apply the specialisation in the rhs of drop', giving
      	drop' n# xs = case xs of
      		      []     -> []
      		      (y:ys) -> case n# of
      				  0 -> []
      				  _ -> drop (n# -# 1#) xs
      Much better!  
      We'd also like to catch cases where a parameter is carried along unchanged,
      but evaluated each time round the loop:
      	f i n = if i>0 || i>n then i else f (i*2) n
      Here f isn't strict in n, but we'd like to avoid evaluating it each iteration.
      In Core, by the time we've w/wd (f is strict in i) we get
      	f i# n = case i# ># 0 of
      		   False -> I# i#
      		   True  -> case n of n' { I# n# ->
      			    case i# ># n# of
      				False -> I# i#
      				True  -> f (i# *# 2#) n'
      At the call to f, we see that the argument, n is know to be (I# n#),
      and n is evaluated elsewhere in the body of f, so we can play the same
      trick as above.  However we don't want to do that if the boxed version
      of n is needed (else we'd avoid the eval but pay more for re-boxing n).
      So in this case we want that the *only* uses of n are in case statements.
      So we look for
      * A self-recursive function.  Ignore mutual recursion for now, 
        because it's less common, and the code is simpler for self-recursion.
      * EITHER
         a) At a recursive call, one or more parameters is an explicit 
            constructor application
            That same parameter is scrutinised by a case somewhere in 
            the RHS of the function
          b) At a recursive call, one or more parameters has an unfolding
             that is an explicit constructor application
            That same parameter is scrutinised by a case somewhere in 
            the RHS of the function
            Those are the only uses of the parameter