X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FabsCSyn%2FCosts.lhs;h=0ce89077bf44c442fe169c3ad356a801cfd57399;hb=967cc47f37cb93a5e2b6df7822c9a646f0428247;hp=7a2d9dca84e57dd3cb6b68ad7849533ecb72e2c0;hpb=6c381e873e222417d9a67aeec77b9555eca7b7a8;p=ghc-hetmet.git

diff --git a/ghc/compiler/absCSyn/Costs.lhs b/ghc/compiler/absCSyn/Costs.lhs
index 7a2d9dc..0ce8907 100644
--- a/ghc/compiler/absCSyn/Costs.lhs
+++ b/ghc/compiler/absCSyn/Costs.lhs
@@ -1,5 +1,5 @@
 %
-% (c) The GRASP/AQUA Project, Glasgow University, 1994-1995
+% (c) The GRASP/AQUA Project, Glasgow University, 1994-1996
 %     Hans Wolfgang Loidl
 %
 % ---------------------------------------------------------------------------
@@ -44,8 +44,6 @@ These are first suggestions for scaling the costs. But, this scaling should be d
 \end{pseudocode}
 
 \begin{code}
-#include "HsVersions.h"
-
 #define ACCUM_COSTS(i,b,l,s,f)	(i+b+l+s+f)
 
 #define NUM_REGS		10 {- PprAbsCSyn.lhs -}	      {- runtime/c-as-asm/CallWrap_C.lc -}
@@ -57,35 +55,14 @@ module Costs( costs,
 	      addrModeCosts, CostRes(Cost), nullCosts, Side(..)
     ) where
 
-import AbsCUtils
+#include "HsVersions.h"
+
 import AbsCSyn
-import PrelInfo
-import PrimOp
-import TyCon
-import Util
+import PrimOp		( primOpNeedsWrapper, PrimOp(..) )
+import Util		( trace )
 
 -- --------------------------------------------------------------------------
-#ifndef GRAN
--- a module of "stubs" that don't do anything
-data CostRes = Cost (Int, Int, Int, Int, Int)
-data Side = Lhs | Rhs
-
-nullCosts    = Cost (0, 0, 0, 0, 0) :: CostRes
-
-costs :: AbstractC -> CostRes
-addrModeCosts :: CAddrMode -> Side -> CostRes
-costs _ = nullCosts
-addrModeCosts _ _ = nullCosts
-
-instance Eq CostRes; instance Text CostRes
-
-instance Num CostRes where
-    x + y = nullCosts
-
-#else {-GRAN-}
--- the real thing
-
-data CostRes = Cost (Int, Int, Int, Int, Int)
+newtype CostRes = Cost (Int, Int, Int, Int, Int)
 	       deriving (Text)
 
 nullCosts    = Cost (0, 0, 0, 0, 0) :: CostRes
@@ -385,13 +362,13 @@ stmtMacroCosts macro modes =
     UPD_BH_SINGLE_ENTRY	  ->  Cost (3, 0, 0, 1, 0)	 {- SMupdate.lh	 -}
     PUSH_STD_UPD_FRAME	  ->  Cost (3, 0, 0, 4, 0)	 {- SMupdate.lh	 -}
     POP_STD_UPD_FRAME	  ->  Cost (1, 0, 3, 0, 0)	 {- SMupdate.lh	 -}
-    SET_ARITY		  ->  nullCosts		    {- StgMacros.lh  -}
-    CHK_ARITY		  ->  nullCosts		    {- StgMacros.lh  -}
     SET_TAG		  ->  nullCosts		    {- COptRegs.lh -}
     GRAN_FETCH			->  nullCosts	  {- GrAnSim bookkeeping -}
     GRAN_RESCHEDULE		->  nullCosts	  {- GrAnSim bookkeeping -}
     GRAN_FETCH_AND_RESCHEDULE	->  nullCosts	  {- GrAnSim bookkeeping -}
+    GRAN_YIELD		        ->  nullCosts	  {- GrAnSim bookkeeping -- added SOF -}
     THREAD_CONTEXT_SWITCH	->  nullCosts	  {- GrAnSim bookkeeping -}
+    _ -> trace ("Costs.stmtMacroCosts: "++show macro) nullCosts
 
 -- ---------------------------------------------------------------------------
 
@@ -428,10 +405,7 @@ gmpOps	=
   ]
 
 
--- Haven't found the .umul .div .rem macros yet
--- If they are not Haskell cde, they are not costed, yet
-
-abs_costs = nullCosts  -- NB:  This is normal STG code with costs already
+abs_costs = nullCosts   -- NB:  This is normal STG code with costs already 
 			--	included; no need to add costs again.
 
 umul_costs = Cost (21,4,0,0,0)	   -- due to spy counts
@@ -442,8 +416,10 @@ primOpCosts :: PrimOp -> CostRes
 
 -- Special cases
 
-primOpCosts (CCallOp _ _ _ _ _) = SAVE_COSTS + CCALL_COSTS_GUESS +
-				  RESTORE_COSTS		-- GUESS; check it
+primOpCosts (CCallOp _ _ _ _ _ _) = SAVE_COSTS + RESTORE_COSTS  	
+	                          -- don't guess costs of ccall proper
+                                  -- for exact costing use a GRAN_EXEC
+                                  -- in the C code
 
 -- Usually 3 mov instructions are needed to get args and res in right place.
 
@@ -487,7 +463,7 @@ primOpCosts FloatPowerOp  = Cost (2, 1, 4, 4, 3)
 
 primOpCosts primOp
   | primOp `elem` floatOps = Cost (0, 0, 0, 0, 1)  :: CostRes
-  | primOp `elem` gmpOps   = Cost (50, 5, 10, 10, 0) :: CostRes	 -- GUESS; check it
+  | primOp `elem` gmpOps   = Cost (30, 5, 10, 10, 0) :: CostRes  -- GUESS; check it
   | otherwise		   = Cost (1, 0, 0, 0, 0)
 
 -- ---------------------------------------------------------------------------
@@ -505,8 +481,6 @@ costsByKind FloatRep	_ = nullCosts
 costsByKind DoubleRep	_ = nullCosts
 -}
 -- ---------------------------------------------------------------------------
-
-#endif {-GRAN-}
 \end{code}
 
 This is the data structure of {\tt PrimOp} copied from prelude/PrimOp.lhs.
@@ -543,7 +517,7 @@ data PrimOp
     -- Rest is unchecked so far -- HWL
 
     -- Word#-related ops:
-    | AndOp   | OrOp  | NotOp | ShiftLOp | ShiftROp
+    | AndOp   | OrOp  | NotOp | XorOp | ShiftLOp | ShiftROp
     | Int2WordOp | Word2IntOp -- casts
 
     -- Addr#-related ops:
@@ -604,8 +578,8 @@ data PrimOp
     | IndexOffAddrOp	PrimRep
 	-- PrimRep can be one of {Char,Int,Addr,Float,Double}Kind.
 	-- This is just a cheesy encoding of a bunch of ops.
-	-- Note that MallocPtrRep is not included -- the only way of
-	-- creating a MallocPtr is with a ccall or casm.
+	-- Note that ForeignObjRep is not included -- the only way of
+	-- creating a ForeignObj is with a ccall or casm.
 
     | UnsafeFreezeArrayOp | UnsafeFreezeByteArrayOp
 
@@ -613,7 +587,11 @@ data PrimOp
 \end{pseudocode}
 
 A special ``trap-door'' to use in making calls direct to C functions:
-Note: From GrAn point of view, CCall is probably very expensive -- HWL
+Note: From GrAn point of view, CCall is probably very expensive 
+      The programmer can specify the costs of the Ccall by inserting
+      a GRAN_EXEC(a,b,l,s,f) at the end of the C- code, specifing the
+      number or arithm., branch, load, store and floating point instructions
+      -- HWL
 
 \begin{pseudocode}
     | CCallOp	String	-- An "unboxed" ccall# to this named function