Codegen for invoke-super, invoke-interface
Completed fast & slow paths for invoke-super and the single path for invoke-interface. Added test
for invoke-super, but invoke-interface is untested (needs runtime-support routines to be fleshed
out).
Some trickiness in the invoke-interface code-generation. Because they are going to be
glacially slow anyway, inline code has been minimized and all interesting work pushed
off to TODO runtime support routines. However, we can't simultaneously pass the arguments
needed by the final destination and the arguments needed by the runtime lookup helpers. So,
I've added a trampoline to save the target args, load the args needed by the helpers, call
the lookup routines, restore the final target arguments and continue on the journey.
More detailed comments in the code.
Change-Id: Ice2343798a91a37da982811fd1c6384f584a3c0b
diff --git a/src/runtime_support.S b/src/runtime_support.S
index 46c2dd3..fe40cf2 100644
--- a/src/runtime_support.S
+++ b/src/runtime_support.S
@@ -1,6 +1,44 @@
#if defined(__arm__)
.balign 4
+
+ .global art_invoke_interface_trampoline
+ .extern artFindInterfaceMethodInCache
+ .extern artFailedInvokeInterface
+art_invoke_interface_trampoline:
+ /*
+ * All generated callsites for interface invokes will load arguments
+ * as usual - except instead of loading arg0/r0 with the target
+ * Method*, arg0/r0 will contain the method_idx. This wrapper will
+ * save arg1-arg3, load the caller's Method*, align the stack and
+ * call the helper artFindInterfaceMethodInCache(idx, this, method);
+ * NOTE: "this" is first visable argument of the target, and so can be
+ * found in arg1/r1.
+ *
+ * artFindInterfaceMethodInCache will attempt to locate the target
+ * and return a 64-bit result in r0/r1 consisting of the target
+ * Method* in r0 and method->code_ in r1.
+ *
+ * If unsuccessful, artFindInterfaceMethodInCache will return
+ * NULL/NULL. This is somewhat different than the usual
+ * mechanism of helper routines performing the unwind & throw.
+ * The reason is that this trampoline is not unwindable. In the
+ * event artFindInterfaceMethodInCache fails to resolve, the wrapper
+ * will prepare an unwindable environment and jump to another helper
+ * to do unwind/throw.
+ *
+ * On success this wrapper will restore arguments and *jump* to the
+ * target, leaving the lr pointing back to the original caller.
+ */
+ stmdb sp!, {r1, r2, r3, lr}
+ ldr r2, [sp, #16] @ load caller's Method*
+ bl artFindInterfaceMethodInCache @ (method_idx, this, callerMethod)
+ mov r12, r1 @ save r0->code_
+ ldmia sp!, {r1, r2, r3, lr} @ restore arguments
+ cmp r0, #0 @ did we find the target?
+ bxne r12 @ tail call to target if so
+ b artFailedInvokeInterface @ Will appear as if called directly
+
.global art_shl_long
art_shl_long:
/*