Don't import FastString in HsVersions.h

[ghc-hetmet.git] / compiler / codeGen / CgForeignCall.hs

diff --git a/compiler/codeGen/CgForeignCall.hs b/compiler/codeGen/CgForeignCall.hs
index 9db66f6..e9a542e 100644 (file)
--- a/compiler/codeGen/CgForeignCall.hs
+++ b/compiler/codeGen/CgForeignCall.hs
@@ -1,3 +1,10 @@
+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
 -----------------------------------------------------------------------------
 --
 -- Code generation for foreign calls.
@@ -36,6 +43,7 @@ import ClosureInfo
 import Constants
 import StaticFlags
 import Outputable
+import FastString
 
 import Control.Monad
 
@@ -43,7 +51,7 @@ import Control.Monad
 -- Code generation for Foreign Calls
 
 cgForeignCall
-       :: CmmHintFormals       -- where to put the results
+       :: CmmFormals   -- where to put the results
        -> ForeignCall          -- the op
        -> [StgArg]             -- arguments
        -> StgLiveVars  -- live vars, in case we need to save them
@@ -57,15 +65,16 @@ cgForeignCall results fcall stg_args live
                    | (stg_arg, (rep,expr)) <- stg_args `zip` reps_n_amodes, 
                       nonVoidArg rep]
 
-       arg_hints = zip arg_exprs (map (typeHint.stgArgType) stg_args)
+       arg_hints = zipWith CmmHinted
+                      arg_exprs (map (typeHint.stgArgType) stg_args)
   -- in
   emitForeignCall results fcall arg_hints live
 
 
 emitForeignCall
-       :: CmmHintFormals       -- where to put the results
+       :: CmmFormals   -- where to put the results
        -> ForeignCall          -- the op
-       -> [(CmmExpr,MachHint)] -- arguments
+       -> [CmmHinted CmmExpr] -- arguments
        -> StgLiveVars  -- live vars, in case we need to save them
        -> Code
 
@@ -79,14 +88,14 @@ emitForeignCall results (CCall (CCallSpec target cconv safety)) args live
        = case target of
           StaticTarget lbl -> (args, CmmLit (CmmLabel 
                                        (mkForeignLabel lbl call_size False)))
-          DynamicTarget    ->  case args of (fn,_):rest -> (rest, fn)
+          DynamicTarget    ->  case args of (CmmHinted fn _):rest -> (rest, fn)
 
        -- in the stdcall calling convention, the symbol needs @size appended
        -- to it, where size is the total number of bytes of arguments.  We
        -- attach this info to the CLabel here, and the CLabel pretty printer
        -- will generate the suffix when the label is printed.
       call_size
-       | StdCallConv <- cconv = Just (sum (map (arg_size.cmmExprRep.fst) args))
+       | StdCallConv <- cconv = Just (sum (map (arg_size.cmmExprRep.hintlessCmm) args))
        | otherwise            = Nothing
 
        -- ToDo: this might not be correct for 64-bit API
@@ -99,9 +108,9 @@ emitForeignCall _ (DNCall _) _ _
 -- alternative entry point, used by CmmParse
 emitForeignCall'
        :: Safety
-       -> CmmHintFormals       -- where to put the results
+       -> CmmFormals   -- where to put the results
        -> CmmCallTarget        -- the op
-       -> [(CmmExpr,MachHint)] -- arguments
+       -> [CmmHinted CmmExpr] -- arguments
        -> Maybe [GlobalReg]    -- live vars, in case we need to save them
         -> C_SRT                -- the SRT of the calls continuation
         -> CmmReturnInfo
@@ -115,7 +124,7 @@ emitForeignCall' safety results target args vols srt ret
     stmtsC caller_load
 
   | otherwise = do
-    -- Both 'id' and 'new_base' are KindNonPtr because they're
+    -- Both 'id' and 'new_base' are GCKindNonPtr because they're
     -- RTS only objects and are not subject to garbage collection
     id <- newNonPtrTemp wordRep
     new_base <- newNonPtrTemp (cmmRegRep (CmmGlobal BaseReg))
@@ -130,13 +139,13 @@ emitForeignCall' safety results target args vols srt ret
     -- and the CPS will will be the one to convert that
     -- to this sequence of three CmmUnsafe calls.
     stmtC (CmmCall (CmmCallee suspendThread CCallConv) 
-                       [ (id,PtrHint) ]
-                       [ (CmmReg (CmmGlobal BaseReg), PtrHint) ] 
+                       [ CmmHinted id PtrHint ]
+                       [ CmmHinted (CmmReg (CmmGlobal BaseReg)) PtrHint ] 
                        CmmUnsafe ret)
     stmtC (CmmCall temp_target results temp_args CmmUnsafe ret)
     stmtC (CmmCall (CmmCallee resumeThread CCallConv) 
-                       [ (new_base, PtrHint) ]
-                       [ (CmmReg (CmmLocal id), PtrHint) ]
+                       [ CmmHinted new_base PtrHint ]
+                       [ CmmHinted (CmmReg (CmmLocal id)) PtrHint ]
                        CmmUnsafe ret)
     -- Assign the result to BaseReg: we
     -- might now have a different Capability!
@@ -156,9 +165,9 @@ resumeThread  = CmmLit (CmmLabel (mkRtsCodeLabel SLIT("resumeThread")))
 -- This is a HACK; really it should be done in the back end, but
 -- it's easier to generate the temporaries here.
 load_args_into_temps = mapM arg_assign_temp
-  where arg_assign_temp (e,hint) = do
+  where arg_assign_temp (CmmHinted e hint) = do
           tmp <- maybe_assign_temp e
-          return (tmp,hint)
+          return (CmmHinted tmp hint)
        
 load_target_into_temp (CmmCallee expr conv) = do 
   tmp <- maybe_assign_temp expr