[project @ 2001-11-26 09:20:25 by simonpj]

[ghc-hetmet.git] / ghc / compiler / typecheck / TcForeign.lhs

diff --git a/ghc/compiler/typecheck/TcForeign.lhs b/ghc/compiler/typecheck/TcForeign.lhs
index 950d8ad..a8e63a3 100644 (file)
--- a/ghc/compiler/typecheck/TcForeign.lhs
+++ b/ghc/compiler/typecheck/TcForeign.lhs
@@ -25,21 +25,22 @@ import HsSyn                ( HsDecl(..), ForeignDecl(..), HsExpr(..),
 import RnHsSyn         ( RenamedHsDecl, RenamedForeignDecl )
 
 import TcMonad
-import TcEnv           ( newLocalId )
+import TcEnv           ( newLocalName )
 import TcMonoType      ( tcHsSigType, UserTypeCtxt(..) )
 import TcHsSyn         ( TcMonoBinds, TypecheckedForeignDecl, TcForeignExportDecl )
-import TcExpr          ( tcPolyExpr )                  
+import TcExpr          ( tcExpr )                      
 import Inst            ( emptyLIE, LIE, plusLIE )
 
 import ErrUtils                ( Message )
 import Id              ( Id, mkLocalId )
 import Name            ( nameOccName )
-import TysWiredIn      ( isFFIArgumentTy, isFFIImportResultTy, 
-                         isFFIExportResultTy,
-                         isFFIExternalTy, isFFIDynArgumentTy, isFFIDynResultTy,
-                         isFFILabelTy
+import PrimRep         ( getPrimRepSize, isFloatingRep )
+import Type            ( typePrimRep )
+import TcType          ( Type, tcSplitFunTys, tcSplitTyConApp_maybe, tcSplitForAllTys,
+                         isFFIArgumentTy, isFFIImportResultTy, 
+                         isFFIExportResultTy, isFFILabelTy,
+                         isFFIExternalTy, isFFIDynArgumentTy, isFFIDynResultTy
                        )
-import TcType          ( Type, tcSplitFunTys, tcSplitTyConApp_maybe, tcSplitForAllTys )
 import ForeignCall     ( CCallSpec(..), CExportSpec(..), CCallTarget(..), isDynamicTarget, isCasmTarget )
 import CStrings                ( CLabelString, isCLabelString )
 import PrelNames       ( hasKey, ioTyConKey )
@@ -105,7 +106,8 @@ tcCheckFIType sig_ty arg_tys res_ty (CDynImport _)
     case arg_tys of
        [arg1_ty] -> checkForeignArgs isFFIExternalTy arg1_tys                  `thenNF_Tc_`
                     checkForeignRes nonIOok  isFFIExportResultTy res1_ty       `thenNF_Tc_`
-                    checkForeignRes mustBeIO isFFIDynResultTy    res_ty
+                    checkForeignRes mustBeIO isFFIDynResultTy    res_ty        `thenNF_Tc_`
+                    checkFEDArgs arg1_tys
                  where
                     (arg1_tys, res1_ty) = tcSplitFunTys arg1_ty
         other -> addErrTc (illegalForeignTyErr empty sig_ty)
@@ -139,6 +141,41 @@ checkCTarget (CasmTarget _)
   = checkCg checkC
 \end{code}
 
+On a SPARC, with foreign export dynamic, due to a giant hack when building
+adjustor thunks, we only allow 16 bytes of arguments!
+
+So for example, args (Int,Double,Int) would be OK (1+2+1)
+as would (Int,Int,Int,Int) (1+1+1+1) but not (Int,Double,Double) (1+2+2).
+
+On an Alpha, due to a similar hack, we only allow 4 integer arguments with
+foreign export dynamic (i.e., 32 bytes of arguments after padding each
+argument to a quadword, excluding floating-point arguments).
+
+The check is needed for both via-C and native-code routes
+
+\begin{code}
+#include "nativeGen/NCG.h"
+#if sparc_TARGET_ARCH
+checkFEDArgs arg_tys
+  = check (words_of_args <= 4) err
+  where
+    words_of_args = sum (map (getPrimRepSize . typePrimRep) arg_tys)
+    err = ptext SLIT("On SPARC, I can only handle 4 words of arguments to foreign export dynamic")
+#else
+#if alpha_TARGET_ARCH
+checkFEDArgs arg_tys
+  = check (integral_args <= 4) err
+  where
+    integral_args = sum (map getPrimRepSize $
+                         filter (not . isFloatingRep) $
+                         map typePrimRep arg_tys)
+    err = ptext SLIT("On Alpha, I can only handle 4 non-floating-point arguments to foreign export dynamic")
+#else
+checkFEDArgs arg_tys = returnNF_Tc ()
+#endif
+#endif
+\end{code}
+
 
 %************************************************************************
 %*                                                                     *
@@ -162,7 +199,7 @@ tcFExport fo@(ForeignExport nm hs_ty spec src_loc) =
    tcAddErrCtxt (foreignDeclCtxt fo)   $
 
    tcHsSigType (ForSigCtxt nm) hs_ty   `thenTc` \ sig_ty ->
-   tcPolyExpr (HsVar nm) sig_ty                `thenTc` \ (rhs, lie, _, _, _) ->
+   tcExpr (HsVar nm) sig_ty            `thenTc` \ (rhs, lie) ->
 
    tcCheckFEType sig_ty spec           `thenTc_`
 
@@ -170,9 +207,10 @@ tcFExport fo@(ForeignExport nm hs_ty spec src_loc) =
          -- than its declared/inferred type. Hence the need
          -- to create a local binding which will call the exported function
          -- at a particular type (and, maybe, overloading).
-   newLocalId (nameOccName nm) sig_ty src_loc  `thenNF_Tc` \ id ->
+   newLocalName nm                     `thenNF_Tc` \ id_name ->
    let
-       bind  = VarMonoBind id rhs
+       id   = mkLocalId id_name sig_ty
+       bind = VarMonoBind id rhs
    in
    returnTc (lie, bind, ForeignExport id undefined spec src_loc)
 \end{code}
@@ -260,9 +298,13 @@ checkCOrAsmOrDotNetOrInterp other
 
 checkCg check
  = getDOptsTc          `thenNF_Tc` \ dflags ->
-   case check (dopt_HscLang dflags) of
-       Nothing  -> returnNF_Tc ()
-       Just err -> addErrTc (text "Illegal foreign declaration:" <+> err)
+   let hscLang = dopt_HscLang dflags in
+   case hscLang of
+        HscNothing -> returnNF_Tc ()
+        otherwise ->
+         case check hscLang of
+              Nothing  -> returnNF_Tc ()
+              Just err -> addErrTc (text "Illegal foreign declaration:" <+> err)
 \end{code} 
                           
 Warnings
@@ -289,3 +331,4 @@ foreignDeclCtxt fo
   = hang (ptext SLIT("When checking declaration:"))
          4 (ppr fo)
 \end{code}
+