import Data.Int
import Data.Maybe
import qualified Data.Map as M
+import qualified Data.Set as S
import qualified Data.ByteString.Lazy as B
import Control.Monad
foreign import ccall "getaddr"
getaddr :: CUInt
+foreign import ccall "getMallocAddr"
+ getMallocAddr :: CUInt
+
foreign import ccall "callertrap"
callertrap :: IO ()
case hmap of
Nothing -> error "sorry, no code generation"
Just hmap' -> do
- let ebb = emitFromBB cls hmap'
+ let ebb = emitFromBB method cls hmap'
(_, Right ((entry, bbstarts, end, _), disasm)) <- runCodeGen ebb () ()
let int_entry = ((fromIntegral $ ptrToIntPtr entry) :: Int)
printf "disasm:\n"
type CompileInfo = (EntryPoint, BBStarts, Int, TMap)
-emitFromBB :: Class Resolved -> MapBB -> CodeGen e s (CompileInfo, [Instruction])
-emitFromBB cls hmap = do
+emitFromBB :: B.ByteString -> Class Resolved -> MapBB -> CodeGen e s (CompileInfo, [Instruction])
+emitFromBB method cls hmap = do
llmap <- sequence [newNamedLabel ("bb_" ++ show x) | (x,_) <- M.toList hmap]
let lmap = zip (Prelude.fst $ unzip $ M.toList hmap) llmap
ep <- getEntryPoint
push ebp
mov ebp esp
+ -- TODO(bernhard): determine a reasonable value.
+ -- e.g. (locals used) * 4
+ sub esp (0x60 :: Word32)
(calls, bbstarts) <- efBB (0,(hmap M.! 0)) M.empty M.empty lmap
d <- disassemble
-- TODO(bernhard): implement `emit' as function which accepts a list of
-- instructions, so we can use patterns for optimizations
where
+ getCurrentOffset :: CodeGen e s (Word32)
+ getCurrentOffset = do
+ ep <- getEntryPoint
+ let w32_ep = (fromIntegral $ ptrToIntPtr ep) :: Word32
+ offset <- getCodeOffset
+ return $ w32_ep + (fromIntegral offset)
+
emit' :: J.Instruction -> CodeGen e s (Maybe (Word32, TrapInfo))
+ emit' (INVOKESPECIAL cpidx) = emit' (INVOKESTATIC cpidx)
emit' (INVOKESTATIC cpidx) = do
- ep <- getEntryPoint
- let w32_ep = (fromIntegral $ ptrToIntPtr ep) :: Word32
let l = buildMethodID cls cpidx
- calladdr <- getCodeOffset
- let w32_calladdr = w32_ep + (fromIntegral calladdr) :: Word32
+ calladdr <- getCurrentOffset
newNamedLabel (show l) >>= defineLabel
-- causes SIGILL. in the signal handler we patch it to the acutal call.
-- place a nop at the end, therefore the disasm doesn't screw up
when (argcnt > 0) (add esp argcnt)
-- push result on stack if method has a return value
when (methodHaveReturnValue cls cpidx) (push eax)
- return $ Just $ (w32_calladdr, MI l)
+ return $ Just $ (calladdr, MI l)
emit' (PUTSTATIC cpidx) = do
pop eax
- ep <- getEntryPoint
- let w32_ep = (fromIntegral $ ptrToIntPtr ep) :: Word32
- trapaddr <- getCodeOffset
- let w32_trapaddr = w32_ep + (fromIntegral trapaddr)
+ trapaddr <- getCurrentOffset
mov (Addr 0x00000000) eax -- it's a trap
- return $ Just $ (w32_trapaddr, SFI $ buildFieldID cls cpidx)
+ return $ Just $ (trapaddr, SFI $ buildStaticFieldID cls cpidx)
emit' (GETSTATIC cpidx) = do
- ep <- getEntryPoint
- let w32_ep = (fromIntegral $ ptrToIntPtr ep) :: Word32
- trapaddr <- getCodeOffset
- let w32_trapaddr = w32_ep + (fromIntegral trapaddr)
+ trapaddr <- getCurrentOffset
mov eax (Addr 0x00000000) -- it's a trap
push eax
- return $ Just $ (w32_trapaddr, SFI $ buildFieldID cls cpidx)
+ return $ Just $ (trapaddr, SFI $ buildStaticFieldID cls cpidx)
emit' insn = emit insn >> return Nothing
emit :: J.Instruction -> CodeGen e s ()
emit POP = do -- print dropped value
- ep <- getEntryPoint
- let w32_ep = (fromIntegral $ ptrToIntPtr ep) :: Word32
+ calladdr <- getCurrentOffset
-- '5' is the size of the `call' instruction ( + immediate)
- calladdr <- getCodeOffset
- let w32_calladdr = 5 + w32_ep + (fromIntegral calladdr) :: Word32
+ let w32_calladdr = 5 + calladdr
let trapaddr = (fromIntegral getaddr :: Word32)
call (trapaddr - w32_calladdr)
add esp (4 :: Word32)
+ emit DUP = pop (Disp 0, esp)
+ emit (NEW objidx) = do
+ -- TODO(bernhard): determine right amount...
+ let amount = 0x20
+ push (amount :: Word32)
+ calladdr <- getCurrentOffset
+ let w32_calladdr = 5 + calladdr
+ let malloaddr = (fromIntegral getMallocAddr :: Word32)
+ call (malloaddr - w32_calladdr)
+ add esp (4 :: Word32)
+ push eax
+ -- TODO(bernhard): save reference somewhere for GC
emit (BIPUSH val) = push ((fromIntegral val) :: Word32)
emit (SIPUSH val) = push ((fromIntegral $ ((fromIntegral val) :: Int16)) :: Word32)
emit (ICONST_0) = push (0 :: Word32)
emit (ICONST_2) = push (2 :: Word32)
emit (ICONST_4) = push (4 :: Word32)
emit (ICONST_5) = push (5 :: Word32)
+ emit (ALOAD_ x) = emit (ILOAD_ x)
emit (ILOAD_ x) = do
push (Disp (cArgs_ x), ebp)
+ emit (ALOAD x) = emit (ILOAD x)
+ emit (ILOAD x) = do
+ push (Disp (cArgs x), ebp)
+ emit (ASTORE_ x) = emit (ISTORE_ x)
emit (ISTORE_ x) = do
pop eax
mov (Disp (cArgs_ x), ebp) eax
+ emit (ASTORE x) = emit (ISTORE x)
+ emit (ISTORE x) = do
+ pop eax
+ mov (Disp (cArgs x), ebp) eax
+
+ emit (GETFIELD x) = do
+ pop eax -- this pointer
+ let (cname, fname) = buildFieldOffset cls x
+ let offset = unsafePerformIO $ getFieldOffset cname fname
+ push (Disp (fromIntegral $ offset * 4), eax) -- get field
+ emit (PUTFIELD x) = do
+ pop ebx -- value to write
+ pop eax -- this pointer
+ let (cname, fname) = buildFieldOffset cls x
+ let offset = unsafePerformIO $ getFieldOffset cname fname
+ mov (Disp (fromIntegral $ offset * 4), eax) ebx -- set field
+
emit IADD = do pop ebx; pop eax; add eax ebx; push eax
emit ISUB = do pop ebx; pop eax; sub eax ebx; push eax
emit IMUL = do pop ebx; pop eax; mul ebx; push eax
ret
emit invalid = error $ "insn not implemented yet: " ++ (show invalid)
- cArgs x = (8 + 4 * (fromIntegral x))
- cArgs_ x = (8 + 4 * case x of I0 -> 0; I1 -> 1; I2 -> 2; I3 -> 3)
+ -- for locals we use a different storage
+ cArgs :: Word8 -> Word32
+ cArgs x = if (x' >= thisMethodArgCnt)
+ -- TODO(bernhard): maybe s/(-4)/(-8)/
+ then fromIntegral $ (-4) * (x' - thisMethodArgCnt + 1)
+ else 4 + (thisMethodArgCnt * 4) - (4 * x')
+ where x' = fromIntegral x
+
+ cArgs_ :: IMM -> Word32
+ cArgs_ x = cArgs $ case x of I0 -> 0; I1 -> 1; I2 -> 2; I3 -> 3
+
+ thisMethodArgCnt :: Word32
+ thisMethodArgCnt = isNonStatic + (fromIntegral $ length args)
+ where
+ (Just m) = lookupMethod method cls
+ (MethodSignature args _) = methodSignature m
+ isNonStatic = if S.member ACC_STATIC (methodAccessFlags m)
+ then 0
+ else 1 -- one argument for the this pointer
+
-- sign extension from w8 to w32 (over s8)
-- unfortunately, hs-java is using Word8 everywhere (while