\section[ByteCodeGen]{Generate machine-code sequences for foreign import}
\begin{code}
-module ByteCodeFFI ( taggedSizeW, untaggedSizeW, mkMarshalCode ) where
+module ByteCodeFFI ( taggedSizeW, untaggedSizeW, mkMarshalCode, moan64 ) where
#include "HsVersions.h"
import Word ( Word8, Word32 )
import Addr ( Addr(..), writeWord8OffAddr )
import Foreign ( Ptr(..), mallocBytes )
-import IOExts ( trace )
+import IOExts ( trace, unsafePerformIO )
+import IO ( hPutStrLn, stderr )
\end{code}
\begin{code}
+moan64 :: String -> SDoc -> a
+moan64 msg pp_rep
+ = unsafePerformIO (
+ hPutStrLn stderr (
+ "\nGHCi's bytecode generation machinery can't handle 64-bit\n" ++
+ "code properly yet. You can work around this for the time being\n" ++
+ "by compiling this module and all those it imports to object code,\n" ++
+ "and re-starting your GHCi session. The panic below contains information,\n" ++
+ "intended for the GHC implementors, about the exact place where GHC gave up.\n"
+ )
+ )
+ `seq`
+ pprPanic msg pp_rep
+
+
-- For sparc_TARGET_ARCH, i386_TARGET_ARCH, etc.
#include "nativeGen/NCG.h"
= [0x81, 0xC4] ++ lit32 lit
movl_eax_offesimem offB -- movl %eax, offB(%esi)
= [0x89, 0x86] ++ lit32 offB
+ movl_edx_offesimem offB -- movl %edx, offB(%esi)
+ = [0x89, 0x96] ++ lit32 offB
ret -- ret
= [0xC3]
fstpl_offesimem offB -- fstpl offB(%esi)
or
fstps 4(%esi)
-}
- ++ case r_rep of
- CharRep -> movl_eax_offesimem 4
- IntRep -> movl_eax_offesimem 4
- WordRep -> movl_eax_offesimem 4
- AddrRep -> movl_eax_offesimem 4
- DoubleRep -> fstpl_offesimem 4
- FloatRep -> fstps_offesimem 4
+ ++ let i32 = movl_eax_offesimem 4
+ i64 = movl_eax_offesimem 4 ++ movl_edx_offesimem 8
+ f32 = fstps_offesimem 4
+ f64 = fstpl_offesimem 4
+ in
+ case r_rep of
+ CharRep -> i32
+ IntRep -> i32
+ WordRep -> i32
+ AddrRep -> i32
+ DoubleRep -> f64
+ FloatRep -> f32
+ -- Word64Rep -> i64
+ -- Int64Rep -> i64
VoidRep -> []
- other -> pprPanic "ByteCodeFFI.mkMarshalCode_wrk(x86)"
- (ppr r_rep)
+ other -> moan64 "ByteCodeFFI.mkMarshalCode_wrk(x86)"
+ (ppr r_rep)
{- Restore all the pushed regs and go home.
DoubleRep -> f64
FloatRep -> f32
VoidRep -> []
- other -> pprPanic "ByteCodeFFI.mkMarshalCode_wrk(sparc)"
- (ppr r_rep)
+ other -> moan64 "ByteCodeFFI.mkMarshalCode_wrk(sparc)"
+ (ppr r_rep)
++ [mkRET,
mkRESTORE_TRIVIAL] -- this is in the delay slot of the RET
import ByteCodeInstr ( BCInstr(..), ProtoBCO(..), nameOfProtoBCO, bciStackUse )
import ByteCodeItbls ( ItblEnv, mkITbls )
import ByteCodeLink ( UnlinkedBCO, UnlinkedBCOExpr, assembleBCO,
- ClosureEnv, HValue, filterNameMap,
+ ClosureEnv, HValue, filterNameMap, linkFail,
iNTERP_STACK_CHECK_THRESH )
-import ByteCodeFFI ( taggedSizeW, untaggedSizeW, mkMarshalCode )
+import ByteCodeFFI ( taggedSizeW, untaggedSizeW, mkMarshalCode, moan64 )
import Linker ( lookupSymbol )
import List ( intersperse, sortBy, zip4 )
DynamicTarget
-> returnBc (False, panic "ByteCodeGen.generateCCall(dyn)")
StaticTarget target
- -> ioToBc (lookupSymbol (_UNPK_ target)) `thenBc` \res ->
+ -> let sym_to_find = _UNPK_ target in
+ ioToBc (lookupSymbol sym_to_find) `thenBc` \res ->
case res of
Just aa -> case aa of Ptr a# -> returnBc (True, A# a#)
- Nothing -> returnBc invalid
+ Nothing -> ioToBc (linkFail "ByteCodeGen.generateCCall"
+ sym_to_find)
CasmTarget _
- -> returnBc invalid
- where
- invalid = pprPanic ("ByteCodeGen.generateCCall: unfindable "
- ++ "symbol or otherwise invalid target")
- (ppr ccall_spec)
+ -> pprPanic "ByteCodeGen.generateCCall: casm" (ppr ccall_spec)
in
get_target_info `thenBc` \ (is_static, static_target_addr) ->
let
= case pr of
CharRep -> MachChar 0
IntRep -> MachInt 0
+ WordRep -> MachWord 0
DoubleRep -> MachDouble 0
FloatRep -> MachFloat 0
AddrRep | taggedSizeW AddrRep == taggedSizeW WordRep -> MachWord 0
- _ -> pprPanic "mkDummyLiteral" (ppr pr)
+ _ -> moan64 "mkDummyLiteral" (ppr pr)
-- Convert (eg)
| npr `elem` [IntRep, WordRep, FloatRep, DoubleRep, CharRep, AddrRep]
= approved
| otherwise
- = pprPanic "ByteCodeGen.mkUnpackCode" (ppr npr)
+ = moan64 "ByteCodeGen.mkUnpackCode" (ppr npr)
where
approved = UPK_TAG usizeW (off_h-usizeW) off_s `consOL` theRest
theRest = do_nptrs (off_h-usizeW) (off_s + tsizeW) nprs
module ByteCodeLink ( UnlinkedBCO, UnlinkedBCOExpr, assembleBCO,
ClosureEnv, HValue, filterNameMap,
- linkIModules, linkIExpr,
+ linkIModules, linkIExpr, linkFail,
iNTERP_STACK_CHECK_THRESH
) where
import ST ( runST )
import IArray ( array )
import MArray ( castSTUArray,
+ newInt64Array, writeInt64Array,
newFloatArray, writeFloatArray,
newDoubleArray, writeDoubleArray,
newIntArray, writeIntArray,
import PrelGHC ( BCO#, newBCO#, unsafeCoerce#,
ByteArray#, Array#, addrToHValue#, mkApUpd0# )
import IOExts ( fixIO )
+import Exception ( throwDyn )
+import Panic ( GhcException(..) )
import PrelArr ( Array(..) )
import ArrayBase ( UArray(..) )
import PrelIOBase ( IO(..) )
+import Int ( Int64 )
\end{code}
st_l1 <- addListToSS st_l0 ws
return (sizeSS st_l0, (st_i0,st_l1,st_p0,st_I0))
+ int64 (st_i0,st_l0,st_p0,st_I0) i
+ = do let ws = mkLitI64 i
+ st_l1 <- addListToSS st_l0 ws
+ return (sizeSS st_l0, (st_i0,st_l1,st_p0,st_I0))
+
addr (st_i0,st_l0,st_p0,st_I0) a
= do let ws = mkLitA a
st_l1 <- addListToSS st_l0 ws
= do st_I1 <- addToSS st_I0 (getName dcon)
return (sizeSS st_I0, (st_i0,st_l0,st_p0,st_I1))
- literal st (MachWord w) = int st (fromIntegral w)
- literal st (MachInt j) = int st (fromIntegral j)
- literal st (MachFloat r) = float st (fromRational r)
- literal st (MachDouble r) = double st (fromRational r)
- literal st (MachChar c) = int st c
- literal st other = pprPanic "ByteCodeLink.literal" (ppr other)
+ literal st (MachWord w) = int st (fromIntegral w)
+ literal st (MachInt j) = int st (fromIntegral j)
+ literal st (MachFloat r) = float st (fromRational r)
+ literal st (MachDouble r) = double st (fromRational r)
+ literal st (MachChar c) = int st c
+ literal st (MachInt64 ii) = int64 st (fromIntegral ii)
+ literal st (MachWord64 ii) = int64 st (fromIntegral ii)
+ literal st other = pprPanic "ByteCodeLink.literal" (ppr other)
ctoi_itbl st pk
= addr st ret_itbl_addr
= case pk of
CharRep -> stg_gc_unbx_r1_ret_info
IntRep -> stg_gc_unbx_r1_ret_info
+ WordRep -> stg_gc_unbx_r1_ret_info
AddrRep -> stg_gc_unbx_r1_ret_info
FloatRep -> stg_gc_f1_ret_info
DoubleRep -> stg_gc_d1_ret_info
-- Make lists of host-sized words for literals, so that when the
-- words are placed in memory at increasing addresses, the
-- bit pattern is correct for the host's word size and endianness.
-mkLitI :: Int -> [Word]
-mkLitF :: Float -> [Word]
-mkLitD :: Double -> [Word]
-mkLitA :: Addr -> [Word]
+mkLitI :: Int -> [Word]
+mkLitF :: Float -> [Word]
+mkLitD :: Double -> [Word]
+mkLitA :: Addr -> [Word]
+mkLitI64 :: Int64 -> [Word]
mkLitF f
= runST (do
return [w0]
)
+mkLitI64 ii
+ | wORD_SIZE == 4
+ = runST (do
+ arr <- newInt64Array ((0::Int),1)
+ writeInt64Array arr 0 ii
+ d_arr <- castSTUArray arr
+ w0 <- readWordArray d_arr 0
+ w1 <- readWordArray d_arr 1
+ return [w0,w1]
+ )
+ | wORD_SIZE == 8
+ = runST (do
+ arr <- newInt64Array ((0::Int),0)
+ writeInt64Array arr 0 ii
+ d_arr <- castSTUArray arr
+ w0 <- readWordArray d_arr 0
+ return [w0]
+ )
+
mkLitI i
= runST (do
arr <- newIntArray ((0::Int),0)
lookupCE :: ClosureEnv -> Either Name PrimOp -> IO HValue
lookupCE ce (Right primop)
- = do m <- lookupSymbol (primopToCLabel primop "closure")
+ = do let sym_to_find = primopToCLabel primop "closure"
+ m <- lookupSymbol sym_to_find
case m of
Just (Ptr addr) -> case addrToHValue# addr of
(# hval #) -> return hval
- Nothing -> pprPanic "ByteCodeLink.lookupCE(primop)" (ppr primop)
+ Nothing -> linkFail "ByteCodeLink.lookupCE(primop)" sym_to_find
lookupCE ce (Left nm)
= case lookupFM ce nm of
Just aa -> return aa
Nothing
- -> do m <- lookupSymbol (nameToCLabel nm "closure")
+ -> do let sym_to_find = nameToCLabel nm "closure"
+ m <- lookupSymbol sym_to_find
case m of
Just (Ptr addr) -> case addrToHValue# addr of
(# hval #) -> return hval
- Nothing -> pprPanic "ByteCodeLink.lookupCE" (ppr nm)
+ Nothing -> linkFail "ByteCodeLink.lookupCE" sym_to_find
lookupIE :: ItblEnv -> Name -> IO (Ptr a)
lookupIE ie con_nm
Just (Ptr a) -> return (Ptr a)
Nothing
-> do -- try looking up in the object files.
- m <- lookupSymbol (nameToCLabel con_nm "con_info")
+ let sym_to_find1 = nameToCLabel con_nm "con_info"
+ m <- lookupSymbol sym_to_find1
case m of
Just addr -> return addr
Nothing
-> do -- perhaps a nullary constructor?
- n <- lookupSymbol (nameToCLabel con_nm "static_info")
+ let sym_to_find2 = nameToCLabel con_nm "static_info"
+ n <- lookupSymbol sym_to_find2
case n of
Just addr -> return addr
- Nothing -> pprPanic "ByteCodeLink.lookupIE" (ppr con_nm)
+ Nothing -> linkFail "ByteCodeLink.lookupIE"
+ (sym_to_find1 ++ " or " ++ sym_to_find2)
+
+linkFail :: String -> String -> IO a
+linkFail who what
+ = throwDyn (ProgramError (
+ "\nDuring interactive linking, GHCi couldn't find the following symbol:\n" ++
+ " " ++ what ++ "\n" ++
+ "This may be due to you not asking GHCi to load extra object files,\n" ++
+ "archives or DLLs needed by your current session. Restart GHCi, specifying\n" ++
+ "the missing library using the -L/path/to/object/dir and -lmissinglibname\n" ++
+ "flags, or simply by naming the relevant files on the GHCi command line.\n" ++
+ "Alternatively, this link failure might indicate a bug in GHCi.\n" ++
+ "If you suspect the latter, please send a bug report to:\n" ++
+ " glasgow-haskell-bugs@haskell.org\n"
+ ))
-- HACKS!!! ToDo: cleaner
nameToCLabel :: Name -> String{-suffix-} -> String
projects / ghc-hetmet.git / commitdiff