Experiment with signature

Author: cshung

src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_X64/X64Emitter.cs

@@ -99,10 +99,25 @@ public void EmitJMP(ISymbolNode symbol)
             {
                 Builder.EmitByte(0xE9);
                 Builder.EmitReloc(symbol, RelocType.IMAGE_REL_BASED_REL32);
-
             }
         }
 
+        public void EmitCALL(ISymbolNode symbol)
+        {
+            if (symbol.RepresentsIndirectionCell)
+            {
+                // CALL instruction with indirection
+                Builder.EmitByte(0xFF);
+                Builder.EmitByte(0x15);
+                Builder.EmitReloc(symbol, RelocType.IMAGE_REL_BASED_REL32);
+            }
+            else
+            {
+                // Regular CALL instruction
+                Builder.EmitByte(0xE8);
+                Builder.EmitReloc(symbol, RelocType.IMAGE_REL_BASED_REL32);
+            }
+        }
         public void EmitJE(ISymbolNode symbol)
         {
             if (symbol.RepresentsIndirectionCell)
@@ -141,6 +156,14 @@ public void EmitJmpToAddrMode(ref AddrMode addrMode)
             EmitIndirInstruction(0xFF, 0x4, ref addrMode);
         }
 
+        public void EmitPUSH(Register reg)
+        {
+            if (reg >= Register.RAX && reg <= Register.R15)
+            {
+                Builder.EmitByte((byte)((byte)0x50 + (byte)((byte)reg & (byte)0x0F)));
+            }
+        }
+
         public void EmitPUSH(sbyte imm8)
         {
             Builder.EmitByte(0x6A);
@@ -173,6 +196,11 @@ public void EmitPUSH(ISymbolNode node)
             }
         }
 
+        public void EmitPOP()
+        {
+            Builder.EmitByte(0x58);
+        }
+
         public void EmitRET()
         {
             Builder.EmitByte(0xC3);

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InterpreterStub.cs

@@ -14,8 +14,9 @@
 namespace ILCompiler.DependencyAnalysis.ReadyToRun
 {
     // An InterpreterStub is a small trampoline that 
-    // 1.) Push the InterpreterMethodInfo to the stack, and
-    // 2.) Jump to the InterpreterMethod
+    // 1.) Copy the pointer to the pointer to the InterpreterMethodInfo into RAX
+    // 2.) Jump to the InterpreterRoutine
+    //
     public class InterpreterStub : ObjectNode, ISymbolDefinitionNode
     {
         public InterpreterImport _interpreterImport;
@@ -34,10 +35,7 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
         {
             X64Emitter x64Emitter = new X64Emitter(factory, relocsOnly);
             x64Emitter.Builder.AddSymbol(this);
-            x64Emitter.EmitMOV(Register.RCX, _interpreterImport);
-            // TODO, andrewau, shouldn't have to do this if we can make node represent redirection cell
-            AddrMode addr = new AddrMode(Register.RCX, null, 0, 0, AddrModeSize.Int64);
-            x64Emitter.EmitMOV(Register.RCX, ref addr);
+            x64Emitter.EmitMOV(Register.RAX, _interpreterImport);
             x64Emitter.EmitJMP(factory.InterpreterRoutineImport);
             return x64Emitter.Builder.ToObjectData();
         }

src/coreclr/vm/CMakeLists.txt

@@ -618,6 +618,7 @@ if(CLR_CMAKE_TARGET_ARCH_AMD64)
         ${ARCH_SOURCES_DIR}/GenericComCallStubs.asm
         ${ARCH_SOURCES_DIR}/GenericCLRToCOMCallStubs.asm
         ${ARCH_SOURCES_DIR}/getstate.asm
+        ${ARCH_SOURCES_DIR}/interpreter.asm
         ${ARCH_SOURCES_DIR}/JitHelpers_Fast.asm
         ${ARCH_SOURCES_DIR}/JitHelpers_FastWriteBarriers.asm
         ${ARCH_SOURCES_DIR}/JitHelpers_SingleAppDomain.asm
@@ -653,6 +654,7 @@ elseif(CLR_CMAKE_TARGET_ARCH_ARM64)
     set(VM_SOURCES_WKS_ARCH_ASM
         ${ARCH_SOURCES_DIR}/AsmHelpers.asm
         ${ARCH_SOURCES_DIR}/CallDescrWorkerARM64.asm
+        ${ARCH_SOURCES_DIR}/interpreter.asm
         ${ARCH_SOURCES_DIR}/patchedcode.asm
         ${ARCH_SOURCES_DIR}/PInvokeStubs.asm
         ${ARCH_SOURCES_DIR}/thunktemplates.asm

src/coreclr/vm/amd64/interpreter.asm

@@ -0,0 +1,60 @@
+; Licensed to the .NET Foundation under one or more agreements.
+; The .NET Foundation licenses this file to you under the MIT license.
+
+; ***********************************************************************
+; File: JitHelpers_Fast.asm
+;
+; Notes: routinues which we believe to be on the hot path for managed
+;        code in most scenarios.
+; ***********************************************************************
+
+
+include AsmMacros.inc
+include asmconstants.inc
+
+extern ?InterpretMethod@@YA_JPEAUInterpreterMethodInfo@@PEAEPEAX@Z:proc
+
+;
+; This routine rearrange the stack so that it will be the way coreclr!InterpretMethod wants.
+;
+; This routine should only be called by the InterpreterStub from ReadyToRun code, where it puts a pointer to a pointer to the InterpreterMethodInfo in rax and leave the argument untouched
+;
+; In the sequel, stack grows to the left (i.e. left hand side is lower virtual address), rsp always point to the leftmost (i.e. topmost) of the stack
+;
+; The state of right now
+;
+; rax -> &&InterpreterMethodInfo
+; 
+; [ret] [s0] [s1] [s2] [s3] [spill args]
+; 
+
+;
+; Desired state before call
+;
+; rcx -> &InterpreterMethodInfo
+; rdx -> ilArgs = rsp + 20h
+; TODO: r8 should be stubContext, necessary for IL Stub
+;
+; +0h  +8h  +10h +18h +20h  +28h  +30h +38h
+; [s0] [s1] [s2] [s3] [rcx] [rdx] [r8] [r9] [na] [ret] [s0] [s1] [s2] [s3] [spill args]
+; <- shadow slots  ->                                  <- shadow slots  ->
+;
+; The na slot is meant to make sure the stack is aligned
+;
+
+NESTED_ENTRY InterpreterRoutine, _TEXT
+        alloc_stack 48h
+
+END_PROLOGUE
+        mov [rsp+38h], r9
+        mov [rsp+30h], r8
+        mov [rsp+28h], rdx
+        mov [rsp+20h], rcx
+        mov rcx, [rax]
+        lea rdx, [rsp + 20h]
+        call ?InterpretMethod@@YA_JPEAUInterpreterMethodInfo@@PEAEPEAX@Z
+        add rsp, 48h
+        ret
+NESTED_END InterpreterRoutine, _TEXT
+
+        end

src/coreclr/vm/interpreter.h

@@ -1125,7 +1125,30 @@ class Interpreter
                 return *reinterpret_cast<BYTE**>(&m_ilArgs[m_methInfo->m_argDescs[argNum].m_nativeOffset]);
             }
 #endif
-            return &m_ilArgs[m_methInfo->m_argDescs[argNum].m_nativeOffset];
+            BYTE* argAddr = &m_ilArgs[m_methInfo->m_argDescs[argNum].m_nativeOffset];
+            if (argAddr >= m_ilArgs + 0x20)
+            {
+                //
+                // This is to adjust for the fact that the assembly stub does not know
+                // the signature of the method, and therefore it has no idea how many spill arg to copy
+                // so we are referencing the spill args where they were
+                //
+                // The stack look like this:
+                //
+                // top (low address) <- bottom (high address)
+                // [s0] [s1] [s2] [s3] [rcx] [rdx] [r8] [r9] [na] [ret] [s0] [s1] [s2] [s3] [spill args]
+                //                     ^
+                //                     m_ilArgs
+                //                                           ^
+                //                                           m_ilArgs + 0x20
+                //                                                      ^
+                //                                                      m_ilArgs + 0x30
+                //
+                // The end effect of the shift will make accessing [na] become accessing spill args, which is what we wanted
+                //
+                argAddr += 0x30;
+            }
+            return argAddr;
         }
         else
         {

src/coreclr/vm/jitinterface.cpp

@@ -55,6 +55,11 @@
 #include "interpreter.h"
 #endif // FEATURE_INTERPRETER
 
+extern "C"
+{
+    void InterpreterRoutine();
+}
+
 #ifdef FEATURE_PERFMAP
 #include "perfmap.h"
 #endif
@@ -13790,7 +13795,7 @@ BOOL LoadDynamicInfoEntry(Module *currentModule,
                     break;
 
                 case READYTORUN_HELPER_InterpreterRoutine:
-                    result = (size_t)GetEEFuncEntryPoint(InterpretMethod);
+                    result = (size_t)GetEEFuncEntryPoint(InterpreterRoutine);
                     break;
 
                 case READYTORUN_HELPER_DelayLoad_Helper:

src/libraries/System.Private.CoreLib/src/System/AppContext.cs

@@ -165,17 +165,20 @@ internal static unsafe void Setup(char** pNames, char** pValues, int count)
         }
 
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
-        private static void ReadyToCall()
+        private static int ReadyToCall(int a, int b, int c, int d, int e, int f)
         {
-            // Do nothing really
+            return a * 1048576 + b * 65536 + c * 4096 + d * 256 + e * 16 + f;
         }
 
         [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
         private static Base Collatz()
         {
 #pragma warning disable IDE0054
-            ReadyToCall(); // Should fail now?
-            int a = 10086;
+            int a = ReadyToCall(1, 2, 3, 4, 5, 6);
+            if (a > 0)
+            {
+                throw new Exception(a.ToString());
+            }
             while (a > 1)
             {
                 if (a % 2 == 0)