module Mate.X86CodeGen where
import Data.Binary
+import Data.BinaryState
import Data.Int
import Data.Maybe
import qualified Data.Map as M
import Mate.Types
import Mate.Utilities
import Mate.ClassPool
+import Mate.Strings
+
foreign import ccall "dynamic"
code_int :: FunPtr (CInt -> CInt -> IO CInt) -> (CInt -> CInt -> IO CInt)
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
+ emitInvoke :: Word16 -> Bool -> CodeGen e s (Maybe (Word32, TrapInfo))
+ emitInvoke cpidx hasThis = do
let l = buildMethodID cls cpidx
calladdr <- getCurrentOffset
newNamedLabel (show l) >>= defineLabel
-- place a nop at the end, therefore the disasm doesn't screw up
emit32 (0xffff9090 :: Word32) >> emit8 (0x90 :: Word8)
-- discard arguments on stack
- let argcnt = (methodGetArgsCount cls cpidx) * 4
+ let argcnt = ((if hasThis then 1 else 0) + (methodGetArgsCount cls cpidx)) * 4
when (argcnt > 0) (add esp argcnt)
-- push result on stack if method has a return value
when (methodHaveReturnValue cls cpidx) (push eax)
return $ Just $ (calladdr, MI l)
+
+ emit' :: J.Instruction -> CodeGen e s (Maybe (Word32, TrapInfo))
+ emit' (INVOKESPECIAL cpidx) = emitInvoke cpidx True
+ emit' (INVOKESTATIC cpidx) = emitInvoke cpidx False
+ emit' (INVOKEVIRTUAL cpidx) = do
+ -- get methodInfo entry
+ let mi@(MethodInfo methodname objname msig@(MethodSignature args _)) = buildMethodID cls cpidx
+ newNamedLabel (show mi) >>= defineLabel
+ -- objref lives somewhere on the argument stack
+ mov eax (Disp ((*4) $ fromIntegral $ length args), esp)
+ -- get method-table-ptr
+ mov eax (Disp 0, eax)
+ -- get method offset
+ let nameAndSig = methodname `B.append` (encode msig)
+ offset <- liftIO $ getMethodOffset objname nameAndSig
+ -- make actual (indirect) call
+ calladdr <- getCurrentOffset
+ call (Disp offset, eax)
+ -- discard arguments on stack (+4 for "this")
+ let argcnt = 4 + ((methodGetArgsCount cls cpidx) * 4)
+ when (argcnt > 0) (add esp argcnt)
+ -- push result on stack if method has a return value
+ when (methodHaveReturnValue cls cpidx) (push eax)
+ -- note, the "mi" has the wrong class reference here.
+ -- we figure that out at run-time, in the methodpool,
+ -- depending on the method-table-ptr
+ return $ Just $ (calladdr, VI mi)
emit' (PUTSTATIC cpidx) = do
pop eax
trapaddr <- getCurrentOffset
let trapaddr = (fromIntegral getaddr :: Word32)
call (trapaddr - w32_calladdr)
add esp (4 :: Word32)
- emit DUP = pop (Disp 0, esp)
+ emit DUP = push (Disp 0, esp)
+ emit ARRAYLENGTH = do
+ pop eax
+ push (Disp 0, eax)
+ emit (NEWARRAY typ) = do
+ let tsize = case decodeS (0 :: Integer) (B.pack [typ]) of
+ T_INT -> 4
+ _ -> error $ "newarray: type not implemented yet"
+ -- get length from stack, but leave it there
+ mov eax (Disp 0, esp)
+ mov ebx (tsize :: Word32)
+ -- multiple amount with native size of one element
+ mul ebx -- result is in eax
+ add eax (4 :: Word32) -- for "length" entry
+ -- push amount of bytes to allocate
+ push eax
+ callMalloc
+ pop eax -- ref to arraymemory
+ pop ebx -- length
+ mov (Disp 0, eax) ebx -- store length at offset 0
+ push eax -- push ref again
emit (NEW objidx) = do
- -- TODO(bernhard): determine right amount...
- let amount = 0x20
+ let objname = buildClassID cls objidx
+ amount <- liftIO $ getMethodSize objname
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
+ callMalloc
-- TODO(bernhard): save reference somewhere for GC
+ -- set method table pointer
+ mtable <- liftIO $ getMethodTable objname
+ mov (Disp 0, eax) mtable
+ emit (CHECKCAST _) = nop -- TODO(bernhard): ...
emit (BIPUSH val) = push ((fromIntegral val) :: Word32)
emit (SIPUSH val) = push ((fromIntegral $ ((fromIntegral val) :: Int16)) :: Word32)
emit (ICONST_0) = push (0 :: Word32)
pop eax
mov (Disp (cArgs x), ebp) eax
+ emit (LDC1 x) = emit (LDC2 $ fromIntegral x)
+ emit (LDC2 x) = do
+ value <- case (constsPool cls) M.! x of
+ (CString s) -> liftIO $ getUniqueStringAddr s
+ _ -> error $ "LDCI... missing impl."
+ push value
emit (GETFIELD x) = do
pop eax -- this pointer
let (cname, fname) = buildFieldOffset cls x
- let offset = unsafePerformIO $ getFieldOffset cname fname
+ offset <- liftIO $ 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
+ offset <- liftIO $ 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 (IINC x imm) = do
add (Disp (cArgs x), ebp) (s8_w32 imm)
+ emit (IF_ACMP cond x) = emit (IF_ICMP cond x)
emit (IF_ICMP cond _) = do
pop eax -- value2
pop ebx -- value1
jmp $ getLabel sid lmap
emit RETURN = do mov esp ebp; pop ebp; ret
+ emit ARETURN = emit IRETURN
emit IRETURN = do
pop eax
mov esp ebp
ret
emit invalid = error $ "insn not implemented yet: " ++ (show invalid)
+ callMalloc :: CodeGen e s ()
+ callMalloc = do
+ calladdr <- getCurrentOffset
+ let w32_calladdr = 5 + calladdr
+ let malloaddr = (fromIntegral getMallocAddr :: Word32)
+ call (malloaddr - w32_calladdr)
+ add esp (4 :: Word32)
+ push eax
+
-- 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 8 + (4 * x')
+ else 4 + (thisMethodArgCnt * 4) - (4 * x')
where x' = fromIntegral x
cArgs_ :: IMM -> Word32
projects / mate.git / blobdiff