Decided run a specific method, called 'RunMe' that has a polymorphic …

…return type and capture and display its result. Currently the return type kind of has to be coerce to an integer, but overall still really good! I can get the return type and validate that now control flow is 100% working and LLVM is a god-send!

LLVMFrontend/MkGraph.hs

@@ -10,6 +10,8 @@ module LLVMFrontend.MkGraph
   , mkBlocks
   , mkMethod
   , pipeline
+  , jvm2llvmType
+  , returnType
   ) where
 
   import qualified Data.List as L
@@ -121,6 +123,7 @@ module LLVMFrontend.MkGraph
       hstarts :: S.Set Int32
       hstarts = S.fromList $ map (fromIntegral . eHandlerPC)
                            $ codeExceptions decoded
+
       initstate :: ParseState'
       initstate = ParseState' {
         -- We begin with only a single entry block
@@ -140,6 +143,24 @@ module LLVMFrontend.MkGraph
       }
       runAll prog = execStateT prog initstate
 
+  jvm2llvmType :: FieldType -> LT.Type
+  jvm2llvmType typ = case typ of
+    SignedByte -> LT.i8
+    CharByte -> LT.i8
+    DoubleType -> LT.double
+    FloatType -> LT.float
+    IntType -> LT.i32
+    LongInt -> LT.i64
+    ShortInt -> LT.i16
+    BoolType -> LT.i1
+    (ObjectType _) -> LT.i64
+    (Array dim typ) -> LT.ArrayType (maybe 0 fromIntegral dim) (jvm2llvmType typ)
+
+
+  returnType :: MethodSignature -> LT.Type
+  returnType (MethodSignature _ (Returns typ)) = jvm2llvmType typ
+  returnType (MethodSignature _ ReturnsVoid) = LT.void
+
   prettyHeader :: String -> IO ()
   prettyHeader str = do
     let len = length str + 6
@@ -381,7 +402,7 @@ module LLVMFrontend.MkGraph
                                           J.C_LT -> LIP.SLT
                                           J.C_NE -> LIP.NE
 
-              appendInstruction $ cmpName LI.:= LI.ICmp cmpInstr op1 op2 []
+              appendInstruction $ cmpName LI.:= LI.ICmp cmpInstr op2 op1 []
 
               -- branch conditionally based on result
               setTerminator $ cbr cmp truejmp falsejmp
@@ -426,7 +447,8 @@ module LLVMFrontend.MkGraph
           -- Return the top operand (after performing type-checking)
           returnSomething t = do
             r <- apop
-            error $ "Processing Type: " ++ show t ++ ", " ++ show r
+            setTerminator $ ret r
+            -- error $ "Processing Type: " ++ show t ++ ", " ++ show r
             -- unless (varType r == t) $ error "toLast return: type mismatch"
             -- return ([], IRReturn $ Just r)
 

Main.hs

@@ -27,6 +27,9 @@ module Main where
 
   import Misc.Logger
 
+  bootstrapMethod :: String
+  bootstrapMethod = "RunMe"
+
   main ::  IO ()
   main = do
     time "main" $ do
@@ -71,11 +74,11 @@ module Main where
     --required on some platforms, initializes boehmgc. [todo bernhard: maybe this should be moved somewhere else - maybe at a global place where vm initialization takes place]
     unless usePreciseGC initGC
 
-    case find ((==) (C8.pack "main") . methodName) (classMethods cls) of
+    case find ((==) (C8.pack bootstrapMethod) . methodName) (classMethods cls) of
       Just m -> do
-        let mi = MethodInfo (C8.pack "main") bclspath $ methodSignature m
+        let mi = MethodInfo (C8.pack bootstrapMethod) bclspath $ methodSignature m
         entry <- lookupMethodEntry mi
-        printfInfo "executing `main' now:\n"
+        printfInfo $ "executing '" ++ bootstrapMethod ++ "' now:\n"
         executeFuncPtr (fromIntegral entry)
         printfInfo "Well, goodbye Sir!\n"
-      Nothing -> error "main not found"
+      Nothing -> error $ bootstrapMethod ++ " not found"

MateVMRuntime/MethodPool.hs

@@ -41,6 +41,8 @@ import LLVM.Transforms
 foreign import ccall "dynamic"
    code_void :: FunPtr (IO ()) -> IO ()
 
+foreign import ccall "dynamic"
+ code_int :: FunPtr (IO Int) -> IO Int
 
 lookupMethodEntry:: MethodInfo -> IO CPtrdiff
 lookupMethodEntry mi@(MethodInfo method cm sig) = do
@@ -103,7 +105,7 @@ compileMethod name sig cls = do
 
   cfg <- pipeline cls meth (codeInstructions . decodeMethod $ code)
   -- cfg <- parseCFG (decodeMethod code)
-  let mod = AST.defaultModule { AST.moduleDefinitions = [defineFn AST.VoidType "main" (M.elems $ basicBlocks cfg)], AST.moduleName = "Dummy" }
+  let mod = AST.defaultModule { AST.moduleDefinitions = [defineFn (returnType sig) "main" (M.elems $ basicBlocks cfg)], AST.moduleName = "Dummy" }
   ast <- compileMethod' mod
   error . show $ ast
 
@@ -132,7 +134,7 @@ compileMethod' mod =
             mainfn <- EE.getFunction ee' "main"
             case mainfn of
               Just fn -> do
-                result <- code_void (castFunPtr fn :: FunPtr (IO ()))
+                result <- code_int (castFunPtr fn :: FunPtr (IO Int))
                 printfJit $ "Evaluated to: " ++ show result
               Nothing -> return ()
 

Unit/Basic/Addition.java

@@ -1,5 +1,6 @@
 class Addition {
-  public static void main(String[] args) {
+
+  public static int RunMe() {
     int x = 0x1000;
     int y = 0x2000;
     int z = 0x3000;
@@ -15,5 +16,11 @@ public static void main(String[] args) {
     } else {
       result = x;
     }
+
+    return result;
+  }
+
+  public static void main(String[] args) {
+
   }
 }