2 {-# LANGUAGE OverloadedStrings #-}
3 {-# LANGUAGE ForeignFunctionInterface #-}
5 module Mate.X86TrapHandling (
10 import qualified Data.Map as M
13 import Foreign.C.Types
16 import {-# SOURCE #-} Mate.MethodPool
19 foreign import ccall "register_signal"
20 register_signal :: IO ()
25 | VirtualMethodCall Bool
26 | InterfaceMethodCall Bool
28 getTrapType :: TrapMap -> CPtrdiff -> CPtrdiff -> TrapType
29 getTrapType tmap signal_from from2 =
30 case M.lookup (fromIntegral signal_from) tmap of
31 (Just (StaticMethod _)) -> StaticMethodCall
32 (Just (StaticField _)) -> StaticFieldAccess
33 (Just _) -> error "getTrapMap: doesn't happen"
34 -- maybe we've a hit on the second `from' value
35 Nothing -> case M.lookup (fromIntegral from2) tmap of
36 (Just (VirtualMethod imm8 _)) -> VirtualMethodCall imm8
37 (Just (InterfaceMethod imm8 _)) -> InterfaceMethodCall imm8
38 (Just _) -> error "getTrapType: abort #1 :-("
39 Nothing -> error $ "getTrapType: abort #2 :-(" ++ show signal_from ++ ", " ++ show from2 ++ ", " ++ show tmap
41 foreign export ccall mateHandler :: CPtrdiff -> CPtrdiff -> CPtrdiff -> CPtrdiff -> IO CPtrdiff
42 mateHandler :: CPtrdiff -> CPtrdiff -> CPtrdiff -> CPtrdiff -> IO CPtrdiff
43 mateHandler eip eax ebx esp = do
44 callerAddr <- callerAddrFromStack esp
46 case getTrapType tmap eip callerAddr of
47 StaticMethodCall -> staticCallHandler eip
48 StaticFieldAccess -> staticFieldHandler eip
49 VirtualMethodCall imm8 -> invokeHandler eax eax esp imm8
50 InterfaceMethodCall imm8 -> invokeHandler eax ebx esp imm8
52 staticCallHandler :: CPtrdiff -> IO CPtrdiff
53 staticCallHandler eip = do
54 -- the actual insn to patch as pointer
55 let insn_ptr = intPtrToPtr (fromIntegral eip) :: Ptr CUChar
56 -- call offset is displaced by one byte (as the first byte is the opcode)
57 let imm_ptr = intPtrToPtr (fromIntegral (eip + 1)) :: Ptr CPtrdiff
58 -- in codegen we set the immediate to some magic value
59 -- in order to produce a SIGILL signal. we also do a safety
60 -- check here, if we're really the "owner" of this signal.
61 checkMe <- peek imm_ptr
62 if checkMe == 0x909090ff then
64 entryAddr <- getMethodEntry eip 0
65 poke insn_ptr 0xe8 -- `call' opcode
66 -- it's a relative call, so we have to calculate the offset. why "+ 5"?
67 -- (1) the whole insn is 5 bytes long
68 -- (2) offset is calculated wrt to the beginning of the next insn
69 poke imm_ptr (entryAddr - (eip + 5))
71 else error "staticCallHandler: something is wrong here. abort\n"
73 staticFieldHandler :: CPtrdiff -> IO CPtrdiff
74 staticFieldHandler eip = do
75 -- patch the offset here, first two bytes are part of the insn (opcode + reg)
76 let imm_ptr = intPtrToPtr (fromIntegral (eip + 2)) :: Ptr CPtrdiff
77 checkMe <- peek imm_ptr
78 if checkMe == 0x00000000 then
80 getStaticFieldAddr eip >>= poke imm_ptr
82 else error "staticFieldHandler: something is wrong here. abort.\n"
84 invokeHandler :: CPtrdiff -> CPtrdiff -> CPtrdiff -> Bool -> IO CPtrdiff
85 invokeHandler method_table table2patch esp imm8 = do
86 -- table2patch: note, that can be a method-table or a interface-table
87 callerAddr <- callerAddrFromStack esp
88 offset <- if imm8 then offsetOfCallInsn8 esp else offsetOfCallInsn32 esp
89 entryAddr <- getMethodEntry callerAddr method_table
90 let call_insn = intPtrToPtr (fromIntegral $ table2patch + fromIntegral offset)
91 poke call_insn entryAddr
95 callerAddrFromStack :: CPtrdiff -> IO CPtrdiff
96 callerAddrFromStack = peek . intPtrToPtr . fromIntegral
98 offsetOfCallInsn8 :: CPtrdiff -> IO CPtrdiff
99 offsetOfCallInsn8 esp = do
100 let ret_ptr = intPtrToPtr (fromIntegral esp) :: Ptr CPtrdiff
102 retval <- peek (intPtrToPtr (fromIntegral (ret - 1)) :: Ptr CUChar)
103 return $ fromIntegral retval
105 offsetOfCallInsn32 :: CPtrdiff -> IO CPtrdiff
106 offsetOfCallInsn32 esp = do
107 let ret_ptr = intPtrToPtr (fromIntegral esp) :: Ptr CPtrdiff
109 peek (intPtrToPtr $ fromIntegral (ret - 4))