Update RyuJIT

- Update RyuJIT package to latest CoreCLR (includes the .NET 4.6.1 integration)
- Update and fix JIT-EE interface to keep "Hello world" working
- Update documentation as necessary

4 files changed, 170 insertions, 122 deletions

diff --git a/src/JitInterface/src/CorInfoImpl.cs b/src/JitInterface/src/CorInfoImpl.cs
index 520e634a5..1580cbd7c 100644
--- a/src/JitInterface/src/CorInfoImpl.cs
+++ b/src/JitInterface/src/CorInfoImpl.cs
@@ -61,16 +61,16 @@ namespace Internal.JitInterface
             public int LineNumber;
         }
 
-        private MethodDesc _methodBeingCompiled;
+        private MethodCodeNode _methodCodeNode;
 
         public void CompileMethod(MethodCodeNode methodCodeNodeNeedingCode)
         {
             try
             {
-                _methodBeingCompiled = methodCodeNodeNeedingCode.Method;
+                _methodCodeNode = methodCodeNodeNeedingCode;
 
                 CORINFO_METHOD_INFO methodInfo;
-                Get_CORINFO_METHOD_INFO(_methodBeingCompiled, out methodInfo);
+                Get_CORINFO_METHOD_INFO(MethodBeingCompiled, out methodInfo);
 
                 uint flags = (uint)(
                     CorJitFlag.CORJIT_FLG_SKIP_VERIFICATION |
@@ -82,7 +82,7 @@ namespace Internal.JitInterface
                 if (!_compilation.Options.NoLineNumbers)
                 {
                     CompilerTypeSystemContext typeSystemContext = _compilation.TypeSystemContext;
-                    IEnumerable<ILSequencePoint> ilSequencePoints = typeSystemContext.GetSequencePointsForMethod(_methodBeingCompiled);
+                    IEnumerable<ILSequencePoint> ilSequencePoints = typeSystemContext.GetSequencePointsForMethod(MethodBeingCompiled);
                     if (ilSequencePoints != null)
                     {
                         Dictionary<int, SequencePoint> sequencePoints = new Dictionary<int, SequencePoint>();
@@ -98,7 +98,7 @@ namespace Internal.JitInterface
                 uint codeSize;
                 _compile(_jit, _comp, ref methodInfo, flags, out nativeEntry, out codeSize);
 
-                PublishCode(methodCodeNodeNeedingCode);
+                PublishCode();
             }
             finally
             {
@@ -106,7 +106,7 @@ namespace Internal.JitInterface
             }
         }
 
-        private void PublishCode(MethodCodeNode methodCodeNodeNeedingCode)
+        private void PublishCode()
         {
             var relocs = _relocs.ToArray();
             Array.Sort(relocs, (x, y) => (x.Offset - y.Offset));
@@ -114,12 +114,20 @@ namespace Internal.JitInterface
             var objectData = new ObjectNode.ObjectData(_code,
                                                        relocs,
                                                        _compilation.NodeFactory.Target.MinimumFunctionAlignment,
-                                                       new ISymbolNode[] { methodCodeNodeNeedingCode });
+                                                       new ISymbolNode[] { _methodCodeNode });
 
-            methodCodeNodeNeedingCode.SetCode(objectData);
+            _methodCodeNode.SetCode(objectData);
 
-            methodCodeNodeNeedingCode.InitializeFrameInfos(_frameInfos);
-            methodCodeNodeNeedingCode.InitializeDebugLocInfos(_debugLocInfos);
+            _methodCodeNode.InitializeFrameInfos(_frameInfos);
+            _methodCodeNode.InitializeDebugLocInfos(_debugLocInfos);
+        }
+
+        private MethodDesc MethodBeingCompiled
+        {
+            get
+            {
+                return _methodCodeNode.Method;
+            }
         }
 
         private int PointerSize
@@ -130,7 +138,6 @@ namespace Internal.JitInterface
             }
         }
 
-        // TODO: Free pins at the end of the compilation
         private Dictionary<Object, GCHandle> _pins = new Dictionary<object, GCHandle>();
 
         private IntPtr GetPin(Object obj)
@@ -149,7 +156,7 @@ namespace Internal.JitInterface
                 pin.Value.Free();
             _pins.Clear();
 
-            _methodBeingCompiled = null;
+            _methodCodeNode = null;
 
             _code = null;
             _coldCode = null;
@@ -1955,7 +1962,7 @@ namespace Internal.JitInterface
                 _roData = new byte[roDataSize];
 
                 _roDataBlob = _compilation.NodeFactory.ReadOnlyDataBlob(
-                    "__readonlydata_" + _compilation.NameMangler.GetMangledMethodName(_methodBeingCompiled),
+                    "__readonlydata_" + _compilation.NameMangler.GetMangledMethodName(MethodBeingCompiled),
                     _roData, alignment);
 
                 roDataBlock = (void*)GetPin(_roData);
@@ -2107,8 +2114,8 @@ namespace Internal.JitInterface
             switch (targetBlock)
             {
                 case BlockType.Code:
-                    // TODO: Arbitrary relocs
-                    throw new NotImplementedException("Arbitrary relocs");
+                    reloc.Target = _methodCodeNode;
+                    break;
 
                 case BlockType.ColdCode:
                     // TODO: Arbitrary relocs
diff --git a/src/JitInterface/src/CorInfoTypes.cs b/src/JitInterface/src/CorInfoTypes.cs
index 59de652d8..1cfc88e1e 100644
--- a/src/JitInterface/src/CorInfoTypes.cs
+++ b/src/JitInterface/src/CorInfoTypes.cs
@@ -421,6 +421,19 @@ namespace Internal.JitInterface
         CORINFO_INTRINSIC_Sqrt,
         CORINFO_INTRINSIC_Abs,
         CORINFO_INTRINSIC_Round,
+        CORINFO_INTRINSIC_Cosh,
+        CORINFO_INTRINSIC_Sinh,
+        CORINFO_INTRINSIC_Tan,
+        CORINFO_INTRINSIC_Tanh,
+        CORINFO_INTRINSIC_Asin,
+        CORINFO_INTRINSIC_Acos,
+        CORINFO_INTRINSIC_Atan,
+        CORINFO_INTRINSIC_Atan2,
+        CORINFO_INTRINSIC_Log10,
+        CORINFO_INTRINSIC_Pow,
+        CORINFO_INTRINSIC_Exp,
+        CORINFO_INTRINSIC_Ceiling,
+        CORINFO_INTRINSIC_Floor,
         CORINFO_INTRINSIC_GetChar,              // fetch character out of string
         CORINFO_INTRINSIC_Array_GetDimLength,   // Get number of elements in a given dimension of an array
         CORINFO_INTRINSIC_Array_Get,            // Get the value of an element in an array
diff --git a/src/JitInterface/src/ThunkGenerator/corinfo.h b/src/JitInterface/src/ThunkGenerator/corinfo.h
index e0004a594..fef412678 100644
--- a/src/JitInterface/src/ThunkGenerator/corinfo.h
+++ b/src/JitInterface/src/ThunkGenerator/corinfo.h
@@ -189,10 +189,82 @@ TODO: Talk about initializing strutures before use
 #include <corhdr.h>
 #include <specstrings.h>
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
+//
+// #JITEEVersionIdentifier
+//
+// This GUID represents the version of the JIT/EE interface. Any time the interface between the JIT and
+// the EE changes (by adding or removing methods to any interface shared between them), this GUID should
+// be changed. This is the identifier verified by ICorJitCompiler::getVersionIdentifier().
+//
+// You can use "uuidgen.exe -s" to generate this value.
+//
+// **** NOTE TO INTEGRATORS:
+//
+// If there is a merge conflict here, because the version changed in two different places, you must
+// create a **NEW** GUID, not simply choose one or the other!
+//
+// NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(SELECTANY)
+    #define SELECTANY extern __declspec(selectany)
+#endif
+
+// COR_JIT_EE_VERSION is a #define that specifies a JIT-EE version, but on a less granular basis than the GUID.
+// The #define is intended to be used on a per-product basis. That is, for each release that we support a JIT
+// CTP build, we'll update the COR_JIT_EE_VERSION. The GUID must change any time any part of the interface changes.
+//
+// COR_JIT_EE_VERSION is set, by convention, to a number related to the the product number. So, 460 is .NET 4.60.
+// 461 would indicate .NET 4.6.1. Etc.
+//
+// Note that the EE should always build with the most current (highest numbered) version. Only the JIT will
+// potentially build with a lower version number. In that case, the COR_JIT_EE_VERSION will be specified in the
+// CTP JIT build project, such as ctpjit.nativeproj.
+
+#if !defined(COR_JIT_EE_VERSION)
+#define COR_JIT_EE_VERSION 999999999    // This means we'll take everything in the interface
+#endif
+
+#if COR_JIT_EE_VERSION > 460
+
+// Update this one
+SELECTANY const GUID JITEEVersionIdentifier = { /* f7be09f3-9ca7-42fd-b0ca-f97c0499f5a3 */
+    0xf7be09f3,
+    0x9ca7,
+    0x42fd,
+    {0xb0, 0xca, 0xf9, 0x7c, 0x04, 0x99, 0xf5, 0xa3}
+};
+
+#else
+
+// ************ Leave this one alone ***************
+// We need it to build a .NET 4.6 compatible JIT for the RyuJIT CTP releases
+SELECTANY const GUID JITEEVersionIdentifier = { /* 9110edd8-8fc3-4e3d-8ac9-12555ff9be9c */
+    0x9110edd8,
+    0x8fc3,
+    0x4e3d,
+    { 0x8a, 0xc9, 0x12, 0x55, 0x5f, 0xf9, 0xbe, 0x9c }
+};
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// END JITEEVersionIdentifier
+//
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#if COR_JIT_EE_VERSION > 460
+
 // For System V on the CLR type system number of registers to pass in and return a struct is the same.
-#define SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS   2
-#define SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_RETURN_IN_REGISTERS SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS
-#define SYSTEMV_MAX_STRUCT_BYTES_TO_PASS_IN_REGISTERS       16
+// The CLR type system allows only up to 2 eightbytes to be passed in registers. There is no SSEUP classification types.
+#define CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS   2 
+#define CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_RETURN_IN_REGISTERS 2
+#define CLR_SYSTEMV_MAX_STRUCT_BYTES_TO_PASS_IN_REGISTERS       16
 
 // System V struct passing
 // The Classification types are described in the ABI spec at http://www.x86-64.org/documentation/abi.pdf
@@ -212,7 +284,7 @@ enum SystemVClassificationType : unsigned __int8
     SystemVClassificationTypeMAX = 7,
 };
 
-
+// Represents classification information for a struct.
 struct SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR
 {
     SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR()
@@ -220,19 +292,40 @@ struct SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR
         Initialize();
     }
 
-    bool                        canPassInRegisters;
-    unsigned int                eightByteCount;
-    SystemVClassificationType   eightByteClassifications[SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS];
-    unsigned int                eightByteSizes[SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS];
-    unsigned int                eightByteOffsets[SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS];
+    bool                        passedInRegisters; // Whether the struct is passable/passed (this includes struct returning) in registers.
+    unsigned __int8             eightByteCount;    // Number of eightbytes for this struct.
+    SystemVClassificationType   eightByteClassifications[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS]; // The eightbytes type classification.
+    unsigned __int8             eightByteSizes[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS];           // The size of the eightbytes (an eightbyte could include padding. This represents the no padding size of the eightbyte).
+    unsigned __int8             eightByteOffsets[CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS];         // The start offset of the eightbytes (in bytes).
+
+
+    //------------------------------------------------------------------------
+    // CopyFrom: Copies a struct classification into this one.
+    //
+    // Arguments:
+    //    'copyFrom' the struct classification to copy from.
+    //
+    void CopyFrom(const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR& copyFrom)
+    {
+        passedInRegisters = copyFrom.passedInRegisters;
+        eightByteCount = copyFrom.eightByteCount;
+
+        for (int i = 0; i < CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS; i++)
+        {
+            eightByteClassifications[i] = copyFrom.eightByteClassifications[i];
+            eightByteSizes[i] = copyFrom.eightByteSizes[i];
+            eightByteOffsets[i] = copyFrom.eightByteOffsets[i];
+        }
+    }
 
     // Members
+private:
     void Initialize()
     {
-        canPassInRegisters = false;
+        passedInRegisters = false;
         eightByteCount = 0;
 
-        for (int i = 0; i < SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS; i++)
+        for (int i = 0; i < CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS; i++)
         {
             eightByteClassifications[i] = SystemVClassificationTypeUnknown;
             eightByteSizes[i] = 0;
@@ -241,6 +334,8 @@ struct SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR
     }
 };
 
+#endif // COR_JIT_EE_VERSION
+
 // CorInfoHelpFunc defines the set of helpers (accessed via the ICorDynamicInfo::getHelperFtn())
 // These helpers can be called by native code which executes in the runtime.
 // Compilers can emit calls to these helpers.
@@ -307,9 +402,8 @@ enum CorInfoHelpFunc
     CORINFO_HELP_NEWARR_1_ALIGN8,   // like VC, but aligns the array start
 
     CORINFO_HELP_STRCNS,            // create a new string literal
-#if !defined(RYUJIT_CTPBUILD)
     CORINFO_HELP_STRCNS_CURRENT_MODULE, // create a new string literal from the current module (used by NGen code)
-#endif
+
     /* Object model */
 
     CORINFO_HELP_INITCLASS,         // Initialize class if not already initialized
@@ -347,9 +441,9 @@ enum CorInfoHelpFunc
     CORINFO_HELP_RNGCHKFAIL,        // array bounds check failed
     CORINFO_HELP_OVERFLOW,          // throw an overflow exception
     CORINFO_HELP_THROWDIVZERO,      // throw a divide by zero exception
-#ifndef RYUJIT_CTPBUILD
+#if COR_JIT_EE_VERSION > 460
     CORINFO_HELP_THROWNULLREF,      // throw a null reference exception
-#endif
+#endif // COR_JIT_EE_VERSION
 
     CORINFO_HELP_INTERNALTHROW,     // Support for really fast jit
     CORINFO_HELP_VERIFICATION,      // Throw a VerificationException
@@ -487,9 +581,6 @@ enum CorInfoHelpFunc
 
     // These helpers are required for MDIL backward compatibility only. They are not used by current JITed code.
     CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPEHANDLE_OBSOLETE, // Convert from a TypeHandle (native structure pointer) to RuntimeTypeHandle at run-time
-#if defined(RYUJIT_CTPBUILD)
-    CORINFO_HELP_METHODDESC_TO_RUNTIMEMETHODHANDLE_MAYBENULL_OBSOLETE, // Convert from a MethodDesc (native structure pointer) to RuntimeMethodHandle at run-time
-#endif
     CORINFO_HELP_METHODDESC_TO_RUNTIMEMETHODHANDLE_OBSOLETE, // Convert from a MethodDesc (native structure pointer) to RuntimeMethodHandle at run-time
     CORINFO_HELP_FIELDDESC_TO_RUNTIMEFIELDHANDLE_OBSOLETE, // Convert from a FieldDesc (native structure pointer) to RuntimeFieldHandle at run-time
 
@@ -501,7 +592,6 @@ enum CorInfoHelpFunc
     CORINFO_HELP_VIRTUAL_FUNC_PTR,      // look up a virtual method at run-time
     //CORINFO_HELP_VIRTUAL_FUNC_PTR_LOG,  // look up a virtual method at run-time, with IBC logging
 
-#ifndef RYUJIT_CTPBUILD
     // Not a real helpers. Instead of taking handle arguments, these helpers point to a small stub that loads the handle argument and calls the static helper.
     CORINFO_HELP_READYTORUN_NEW,
     CORINFO_HELP_READYTORUN_NEWARR_1,
@@ -509,8 +599,12 @@ enum CorInfoHelpFunc
     CORINFO_HELP_READYTORUN_CHKCAST,
     CORINFO_HELP_READYTORUN_STATIC_BASE,
     CORINFO_HELP_READYTORUN_VIRTUAL_FUNC_PTR,
+
+#if COR_JIT_EE_VERSION > 460
     CORINFO_HELP_READYTORUN_DELEGATE_CTOR,
-#endif
+#else
+    #define CORINFO_HELP_READYTORUN_DELEGATE_CTOR CORINFO_HELP_EE_PRESTUB
+#endif // COR_JIT_EE_VERSION
 
 #ifdef REDHAWK
     // these helpers are arbitrary since we don't have any relation to the actual CLR corinfo.h.
@@ -596,7 +690,7 @@ enum CorInfoHelpFunc
     CORINFO_HELP_LOOP_CLONE_CHOICE_ADDR, // Return the reference to a counter to decide to take cloned path in debug stress.
     CORINFO_HELP_DEBUG_LOG_LOOP_CLONING, // Print a message that a loop cloning optimization has occurred in debug mode.
 
-#ifndef RYUJIT_CTPBUILD
+#if COR_JIT_EE_VERSION > 460
     CORINFO_HELP_THROW_ARGUMENTEXCEPTION,           // throw ArgumentException
     CORINFO_HELP_THROW_ARGUMENTOUTOFRANGEEXCEPTION, // throw ArgumentOutOfRangeException
 #endif
@@ -1162,6 +1256,19 @@ enum CorInfoIntrinsics
     CORINFO_INTRINSIC_Sqrt,
     CORINFO_INTRINSIC_Abs,
     CORINFO_INTRINSIC_Round,
+    CORINFO_INTRINSIC_Cosh,
+    CORINFO_INTRINSIC_Sinh,
+    CORINFO_INTRINSIC_Tan,
+    CORINFO_INTRINSIC_Tanh,
+    CORINFO_INTRINSIC_Asin,
+    CORINFO_INTRINSIC_Acos,
+    CORINFO_INTRINSIC_Atan,
+    CORINFO_INTRINSIC_Atan2,
+    CORINFO_INTRINSIC_Log10,
+    CORINFO_INTRINSIC_Pow,
+    CORINFO_INTRINSIC_Exp,
+    CORINFO_INTRINSIC_Ceiling,
+    CORINFO_INTRINSIC_Floor,
     CORINFO_INTRINSIC_GetChar,              // fetch character out of string
     CORINFO_INTRINSIC_Array_GetDimLength,   // Get number of elements in a given dimension of an array
     CORINFO_INTRINSIC_Array_Get,            // Get the value of an element in an array
@@ -1876,9 +1983,7 @@ struct CORINFO_CALL_INFO
         CORINFO_LOOKUP      codePointerLookup;
     };
 
-#ifndef RYUJIT_CTPBUILD
     CORINFO_CONST_LOOKUP    instParamLookup;    // Used by Ready-to-Run
-#endif
 };
 
 //----------------------------------------------------------------------------
@@ -1887,9 +1992,7 @@ struct CORINFO_CALL_INFO
 enum CORINFO_FIELD_ACCESSOR
 {
     CORINFO_FIELD_INSTANCE,                 // regular instance field at given offset from this-ptr
-#ifndef RYUJIT_CTPBUILD
     CORINFO_FIELD_INSTANCE_WITH_BASE,       // instance field with base offset (used by Ready-to-Run)
-#endif
     CORINFO_FIELD_INSTANCE_HELPER,          // instance field accessed using helper (arguments are this, FieldDesc * and the value)
     CORINFO_FIELD_INSTANCE_ADDR_HELPER,     // instance field accessed using address-of helper (arguments are this and FieldDesc *)
 
@@ -1934,9 +2037,7 @@ struct CORINFO_FIELD_INFO
     CorInfoIsAccessAllowedResult accessAllowed;
     CORINFO_HELPER_DESC     accessCalloutHelper;
 
-#ifndef RYUJIT_CTPBUILD
     CORINFO_CONST_LOOKUP    fieldLookup;        // Used by Ready-to-Run
-#endif
 };
 
 //----------------------------------------------------------------------------
@@ -2005,10 +2106,8 @@ struct CORINFO_EE_INFO
     unsigned    offsetOfTransparentProxyRP;
     unsigned    offsetOfRealProxyServer;
 
-#ifndef RYUJIT_CTPBUILD
     // Array offsets
     unsigned    offsetOfObjArrayData;
-#endif
 
     CORINFO_OS  osType;
     unsigned    osMajor;
@@ -2046,7 +2145,7 @@ struct CORINFO_Object
 struct CORINFO_String : public CORINFO_Object
 {
     unsigned                stringLen;
-    const wchar_t           chars[1];       // actually of variable size
+    wchar_t                 chars[1];       // actually of variable size
 };
 
 struct CORINFO_Array : public CORINFO_Object
@@ -2098,9 +2197,6 @@ struct CORINFO_RefArray : public CORINFO_Object
 #ifdef _WIN64
     unsigned                alignpad;
 #endif // _WIN64
-#if defined(RYUJIT_CTPBUILD)
-    CORINFO_CLASS_HANDLE    cls;
-#endif
 
 #if 0
     /* Multi-dimensional arrays have the lengths and bounds here */
@@ -2606,13 +2702,11 @@ public:
             CORINFO_METHOD_HANDLE       method
             ) = 0;
 
-#ifndef RYUJIT_CTPBUILD
     // Is the given module the System.Numerics.Vectors module?
     // This defaults to false.
     virtual bool isInSIMDModule(
             CORINFO_CLASS_HANDLE        classHnd
             ) { return false; }
-#endif // RYUJIT_CTPBUILD
 
     // return the unmanaged calling convention for a PInvoke
     virtual CorInfoUnmanagedCallConv getUnmanagedCallConv(
@@ -3007,13 +3101,11 @@ public:
             CORINFO_CLASS_HANDLE        cls
             ) = 0;
 
-#ifndef RYUJIT_CTPBUILD
     virtual void getReadyToRunHelper(
             CORINFO_RESOLVED_TOKEN * pResolvedToken,
             CorInfoHelpFunc          id,
             CORINFO_CONST_LOOKUP *   pLookup
             ) = 0;
-#endif
 
     virtual const char* getHelperName(
             CorInfoHelpFunc
@@ -3349,12 +3441,6 @@ public:
     // Returns name of the JIT timer log
     virtual LPCWSTR getJitTimeLogFilename() = 0;
 
-#ifdef RYUJIT_CTPBUILD
-    // Logs a SQM event for a JITting a very large method.
-    virtual void logSQMLongJitEvent(unsigned mcycles, unsigned msec, unsigned ilSize, unsigned numBasicBlocks, bool minOpts, 
-                                    CORINFO_METHOD_HANDLE methodHnd) = 0;
-#endif // RYUJIT_CTPBUILD
-
     /*********************************************************************************/
     //
     // Diagnostic methods
@@ -3390,13 +3476,14 @@ public:
             size_t FQNameCapacity  /* IN */
             ) = 0;
 
+#if COR_JIT_EE_VERSION > 460
+
     // returns whether the struct is enregisterable. Only valid on a System V VM. Returns true on success, false on failure.
     virtual bool getSystemVAmd64PassStructInRegisterDescriptor(
         /* IN */    CORINFO_CLASS_HANDLE        structHnd,
         /* OUT */   SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr
         ) = 0;
 
-#if !defined(RYUJIT_CTPBUILD)
     /*************************************************************************/
     //
     // Configuration values - Allows querying of the CLR configuration.
@@ -3423,7 +3510,9 @@ public:
     virtual void freeStringConfigValue(
         __in_z wchar_t *value
         ) = 0;
-#endif // !RYUJIT_CTPBUILD
+
+#endif // COR_JIT_EE_VERSION
+
 };
 
 /*****************************************************************************
@@ -3499,23 +3588,12 @@ public:
                     void                  **ppIndirection = NULL
                     ) = 0;
 
-#if defined(RYUJIT_CTPBUILD)
-    // These entry points must be called if a handle is being embedded in
-    // the code to be passed to a JIT helper function. (as opposed to just
-    // being passed back into the ICorInfo interface.)
-
-    // a module handle may not always be available. A call to embedModuleHandle should always
-    // be preceeded by a call to canEmbedModuleHandleForHelper. A dynamicMethod does not have a module
-    virtual bool canEmbedModuleHandleForHelper(
-        CORINFO_MODULE_HANDLE   handle
-        ) = 0;
-#else
     // get slow lazy string literal helper to use (CORINFO_HELP_STRCNS*). 
     // Returns CORINFO_HELP_UNDEF if lazy string literal helper cannot be used.
     virtual CorInfoHelpFunc getLazyStringLiteralHelper(
                     CORINFO_MODULE_HANDLE   handle
                     ) = 0;
-#endif
+
     virtual CORINFO_MODULE_HANDLE embedModuleHandle(
                     CORINFO_MODULE_HANDLE   handle,
                     void                  **ppIndirection = NULL
diff --git a/src/JitInterface/src/ThunkGenerator/corjit.h b/src/JitInterface/src/ThunkGenerator/corjit.h
index a470d5bff..8612d954d 100644
--- a/src/JitInterface/src/ThunkGenerator/corjit.h
+++ b/src/JitInterface/src/ThunkGenerator/corjit.h
@@ -334,52 +334,6 @@ struct IEEMemoryManager;
 
 extern "C" ICorJitCompiler* __stdcall getJit();
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
-//
-// #JITEEVersionIdentifier
-//
-// This GUID represents the version of the JIT/EE interface. Any time the interface between the JIT and
-// the EE changes (by adding or removing methods to any interface shared between them), this GUID should
-// be changed. This is the identifier verified by ICorJitCompiler::getVersionIdentifier().
-//
-// You can use "uuidgen.exe -s" to generate this value.
-//
-// **** NOTE TO INTEGRATORS:
-//
-// If there is a merge conflict here, because the version changed in two different places, you must
-// create a **NEW** GUID, not simply choose one or the other!
-//
-// NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
-//
-//////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if !defined(SELECTANY)
-    #define SELECTANY extern __declspec(selectany)
-#endif
-
-#if !defined(RYUJIT_CTPBUILD)
-
-// Update this one
-SELECTANY const GUID JITEEVersionIdentifier = { /* f7be09f3-9ca7-42fd-b0ca-f97c0499f5a3 */
-    0xf7be09f3,
-    0x9ca7,
-    0x42fd,
-    {0xb0, 0xca, 0xf9, 0x7c, 0x04, 0x99, 0xf5, 0xa3}
-};
-
-#else
-// Leave this one alone
-// We need it to build a .NET 4.5.1 compatible JIT for the RyuJIT CTP releases
-SELECTANY const GUID JITEEVersionIdentifier = { /* 72d8f09d-1052-4466-94e9-d095b370bdae */
-    0x72d8f09d,
-    0x1052,
-    0x4466,
-    {0x94, 0xe9, 0xd0, 0x95, 0xb3, 0x70, 0xbd, 0xae}
-};
-#endif
-
 // #EEToJitInterface
 // ICorJitCompiler is the interface that the EE uses to get IL bytecode converted to native code. Note that
 // to accomplish this the JIT has to call back to the EE to get symbolic information.  The code:ICorJitInfo
@@ -428,7 +382,6 @@ public:
             GUID*   versionIdentifier   /* OUT */
             ) = 0;
 
-#ifndef RYUJIT_CTPBUILD
     // When the EE loads the System.Numerics.Vectors assembly, it asks the JIT what length (in bytes) of
     // SIMD vector it supports as an intrinsic type.  Zero means that the JIT does not support SIMD
     // intrinsics, so the EE should use the default size (i.e. the size of the IL implementation).
@@ -441,7 +394,6 @@ public:
     // ICorJitCompiler implementation. If 'realJitCompiler' is nullptr, then the JIT should resume
     // executing all the functions itself.
     virtual void setRealJit(ICorJitCompiler* realJitCompiler) { }
-#endif // !RYUJIT_CTPBUILD
 
 };
 
@@ -579,7 +531,6 @@ public:
             ULONG *               numRuns
             ) = 0;
 
-#if !defined(RYUJIT_CTPBUILD)
     // Associates a native call site, identified by its offset in the native code stream, with
     // the signature information and method handle the JIT used to lay out the call site. If
     // the call site has no signature information (e.g. a helper call) or has no method handle
@@ -589,7 +540,6 @@ public:
             CORINFO_SIG_INFO *    callSig,      /* IN */
             CORINFO_METHOD_HANDLE methodHandle  /* IN */
             ) = 0;
-#endif // !defined(RYUJIT_CTPBUILD)
 
     // A relocation is recorded if we are pre-jitting.
     // A jump thunk may be inserted if we are jitting