{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ForeignFunctionInterface #-}
#include "debug.h"
-module Mate.X86TrapHandling where
+module Mate.X86TrapHandling (
+ mateHandler,
+ register_signal
+ ) where
+import Numeric
import qualified Data.Map as M
+import qualified Data.ByteString.Lazy as B
import Foreign
import Foreign.C.Types
+import Harpy
+
import Mate.Types
-import Mate.MethodPool
+import Mate.NativeSizes
+import {-# SOURCE #-} Mate.MethodPool
import Mate.ClassPool
+import Mate.X86CodeGen
+
+#ifdef DBG_JIT
+import Text.Printf
+#endif
+import Mate.Debug
+import Harpy.X86Disassembler
foreign import ccall "register_signal"
register_signal :: IO ()
-
-getTrapType :: CUInt -> CUInt -> IO CUInt
-getTrapType signal_from from2 = do
+foreign export ccall mateHandler :: CPtrdiff -> CPtrdiff -> CPtrdiff -> CPtrdiff -> IO CPtrdiff
+mateHandler :: CPtrdiff -> CPtrdiff -> CPtrdiff -> CPtrdiff -> IO CPtrdiff
+mateHandler reip reax rebx resi = do
tmap <- getTrapMap
- case M.lookup (fromIntegral signal_from) tmap of
- (Just (MI _)) -> return 0
- (Just (SFI _)) -> return 2
- (Just _) -> error "getTrapMap: doesn't happen"
- -- maybe we've a hit on the second `from' value
- Nothing -> case M.lookup (fromIntegral from2) tmap of
- (Just (VI True _)) -> return 1
- (Just (VI False _)) -> return 5
- (Just (II True _)) -> return 4
- (Just (II False _)) -> return 8
- (Just _) -> error "getTrapType: abort #1 :-("
- Nothing -> error $ "getTrapType: abort #2 :-(" ++ show signal_from ++ ", " ++ show from2 ++ ", " ++ show tmap
+ case M.lookup (fromIntegral reip) tmap of
+ (Just (StaticMethod _)) -> patchWithHarpy patchStaticCall reip
+ (Just (StaticField _)) -> staticFieldHandler reip
+ (Just (InstanceOf cn)) -> patchWithHarpy (`patchInstanceOf` cn) reip
+ (Just (NewObject cn)) -> patchWithHarpy (`patchNewObject` cn) reip
+ (Just (VirtualCall False _ io_offset)) ->
+ patchWithHarpy (patchInvoke reax reax io_offset) reip
+ (Just (VirtualCall True _ io_offset)) ->
+ patchWithHarpy (patchInvoke rebx reax io_offset) reip
+ Nothing -> case resi of
+ 0x13371234 -> return (-1)
+ _ -> error $ "getTrapType: abort :-( " ++ (showHex reip ". ")
+ ++ (concatMap (`showHex` ", ") (M.keys tmap))
-foreign export ccall mateHandler :: CUInt -> CUInt -> CUInt -> CUInt -> IO CUInt
-mateHandler :: CUInt -> CUInt -> CUInt -> CUInt -> IO CUInt
-mateHandler eip eax ebx esp = do
- callerAddr <- callerAddrFromStack esp
- blah <- getTrapType eip callerAddr
- case blah of
- 0 -> staticCallHandler eip
- 1 -> invokeHandler eax eax esp True
- 5 -> invokeHandler eax eax esp False
- 4 -> invokeHandler eax ebx esp True
- 8 -> invokeHandler eax ebx esp False
- 2 -> staticFieldHandler eip
- x -> error $ "wtf: " ++ (show x)
+patchWithHarpy :: (CPtrdiff -> CodeGen () () CPtrdiff) -> CPtrdiff -> IO CPtrdiff
+patchWithHarpy patcher reip = do
+ -- this is just an upperbound. if the value is to low, patching fails. find
+ -- something better?
+ let fixme = 1024
+ let entry = Just (intPtrToPtr (fromIntegral reip), fixme)
+ let cgconfig = defaultCodeGenConfig { customCodeBuffer = entry }
+ (_, Right right) <- runCodeGenWithConfig (withDisasm $ patcher reip) () () cgconfig
+ mapM_ (printfJit "patched: %s\n" . showAtt) $ snd right
+ return reip
-staticCallHandler :: CUInt -> IO CUInt
-staticCallHandler eip = do
- -- the actual insn to patch is displaced by two bytes
- let insn_ptr = intPtrToPtr (fromIntegral (eip - 2)) :: Ptr CUChar
- -- call offset is displaced by one byte
- let imm_ptr = intPtrToPtr (fromIntegral (eip - 1)) :: Ptr CUInt
- -- in codegen we set the immediate to some magic value
- -- in order to produce a SIGILL signal. we also do a safety
- -- check here, if we're really the "owner" of this signal.
- checkMe <- peek imm_ptr
- case checkMe == 0x90ffff90 of
- True -> do
- entryAddr <- getMethodEntry eip 0
- poke insn_ptr 0xe8 -- call opcode
- -- it's a relative call, so we have to calculate the offset. why "+ 3"?
- -- (1) the whole insn is 5 bytes long
- -- (2) begin of insn is displaced by 2 bytes
- -- (3) offset is calculated wrt to the beginning of the next insn
- poke imm_ptr (entryAddr - (eip + 3))
- return (eip - 2)
- False -> error "staticCallHandler: something is wrong here. abort\n"
+withDisasm :: CodeGen e s CPtrdiff -> CodeGen e s (CPtrdiff, [Instruction])
+withDisasm patcher = do
+ reip <- patcher
+ d <- disassemble
+ return (reip, d)
-staticFieldHandler :: CUInt -> IO CUInt
-staticFieldHandler eip = do
- -- patch the offset here, first two bytes are part of the insn (opcode + reg)
- let imm_ptr = intPtrToPtr (fromIntegral (eip + 2)) :: Ptr CUInt
- checkMe <- peek imm_ptr
- case checkMe == 0x00000000 of
- True -> do
- getStaticFieldAddr eip >>= poke imm_ptr
- return eip
- False -> error "staticFieldHandler: something is wrong here. abort.\n"
+patchStaticCall :: CPtrdiff -> CodeGen e s CPtrdiff
+patchStaticCall reip = do
+ entryAddr <- liftIO $ getMethodEntry reip 0
+ call (fromIntegral (entryAddr - (reip + 5)) :: NativeWord)
+ return reip
-invokeHandler :: CUInt -> CUInt -> CUInt -> Bool -> IO CUInt
-invokeHandler method_table table2patch esp imm8 = do
- -- table2patch: note, that can be a method-table or a interface-table
- callerAddr <- callerAddrFromStack esp
- offset <- if imm8 then offsetOfCallInsn8 esp else offsetOfCallInsn32 esp
- entryAddr <- getMethodEntry callerAddr method_table
- let call_insn = intPtrToPtr (fromIntegral $ table2patch + (fromIntegral offset))
- poke call_insn entryAddr
- return entryAddr
+staticFieldHandler :: CPtrdiff -> IO CPtrdiff
+staticFieldHandler reip = do
+ -- patch the offset here, first two bytes are part of the insn (opcode + reg)
+ let imm_ptr = intPtrToPtr (fromIntegral (reip + 2)) :: Ptr CPtrdiff
+ checkMe <- peek imm_ptr
+ if checkMe == 0x00000000 then
+ do
+ getStaticFieldAddr reip >>= poke imm_ptr
+ return reip
+ else error "staticFieldHandler: something is wrong here. abort.\n"
-callerAddrFromStack :: CUInt -> IO CUInt
-callerAddrFromStack = peek . intPtrToPtr . fromIntegral
+patchInstanceOf :: CPtrdiff -> B.ByteString -> CodeGen e s CPtrdiff
+patchInstanceOf reip classname = do
+ mtable <- liftIO $ getMethodTable classname
+ mov edx mtable
+ return reip
-offsetOfCallInsn8 :: CUInt -> IO CUInt
-offsetOfCallInsn8 esp = do
- let ret_ptr = intPtrToPtr (fromIntegral esp) :: Ptr CUInt
- ret <- peek ret_ptr
- retval <- peek (intPtrToPtr (fromIntegral (ret - 1)) :: Ptr CUChar)
- return $ fromIntegral retval
+patchNewObject :: CPtrdiff -> B.ByteString -> CodeGen e s CPtrdiff
+patchNewObject reip classname = do
+ objsize <- liftIO $ getObjectSize classname
+ push32 objsize
+ callMalloc
+ mtable <- liftIO $ getMethodTable classname
+ mov (Disp 0, eax) mtable
+ return reip
-offsetOfCallInsn32 :: CUInt -> IO CUInt
-offsetOfCallInsn32 esp = do
- let ret_ptr = intPtrToPtr (fromIntegral esp) :: Ptr CUInt
- ret <- peek ret_ptr
- retval <- peek (intPtrToPtr $ fromIntegral (ret - 4))
- return retval
+patchInvoke :: CPtrdiff -> CPtrdiff -> IO NativeWord -> CPtrdiff -> CodeGen e s CPtrdiff
+patchInvoke method_table table2patch io_offset reip = do
+ offset <- liftIO io_offset
+ entryAddr <- liftIO $ getMethodEntry reip method_table
+ call32_eax (Disp offset)
+ -- patch entry in table
+ let call_insn = intPtrToPtr . fromIntegral $ table2patch + fromIntegral offset
+ liftIO $ poke call_insn entryAddr
+ return reip
projects / mate.git / blobdiff