diff options
Diffstat (limited to 'src/jit/smcommon.cpp')
| -rw-r--r-- | src/jit/smcommon.cpp | 166 |
1 files changed, 166 insertions, 0 deletions
diff --git a/src/jit/smcommon.cpp b/src/jit/smcommon.cpp new file mode 100644 index 0000000000..d17e21b874 --- /dev/null +++ b/src/jit/smcommon.cpp @@ -0,0 +1,166 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +#if defined(DEBUG) || defined(SMGEN_COMPILE) + +// +// The array of state-machine-opcode names +// +const char* const smOpcodeNames[] = { +#define SMOPDEF(smname, string) string, +#include "smopcode.def" +#undef SMOPDEF +}; + +// +// The code sequences the state machine will look for. +// + +const SM_OPCODE s_CodeSeqs[][MAX_CODE_SEQUENCE_LENGTH] = { + +#define SMOPDEF(smname, string) {smname, CODE_SEQUENCE_END}, +// ==== Single opcode states ==== +#include "smopcode.def" +#undef SMOPDEF + + // ==== Legel prefixed opcode sequences ==== + {SM_CONSTRAINED, SM_CALLVIRT, CODE_SEQUENCE_END}, + + // ==== Interesting patterns ==== + + // Fetching of object field + {SM_LDARG_0, SM_LDFLD, CODE_SEQUENCE_END}, + {SM_LDARG_1, SM_LDFLD, CODE_SEQUENCE_END}, + {SM_LDARG_2, SM_LDFLD, CODE_SEQUENCE_END}, + {SM_LDARG_3, SM_LDFLD, CODE_SEQUENCE_END}, + + // Fetching of struct field + {SM_LDARGA_S, SM_LDFLD, CODE_SEQUENCE_END}, + {SM_LDLOCA_S, SM_LDFLD, CODE_SEQUENCE_END}, + + // Fetching of struct field from a normed struct + {SM_LDARGA_S_NORMED, SM_LDFLD, CODE_SEQUENCE_END}, + {SM_LDLOCA_S_NORMED, SM_LDFLD, CODE_SEQUENCE_END}, + + // stloc/ldloc --> dup + {SM_STLOC_0, SM_LDLOC_0, CODE_SEQUENCE_END}, + {SM_STLOC_1, SM_LDLOC_1, CODE_SEQUENCE_END}, + {SM_STLOC_2, SM_LDLOC_2, CODE_SEQUENCE_END}, + {SM_STLOC_3, SM_LDLOC_3, CODE_SEQUENCE_END}, + + // FPU operations + {SM_LDC_R4, SM_ADD, CODE_SEQUENCE_END}, + {SM_LDC_R4, SM_SUB, CODE_SEQUENCE_END}, + {SM_LDC_R4, SM_MUL, CODE_SEQUENCE_END}, + {SM_LDC_R4, SM_DIV, CODE_SEQUENCE_END}, + + {SM_LDC_R8, SM_ADD, CODE_SEQUENCE_END}, + {SM_LDC_R8, SM_SUB, CODE_SEQUENCE_END}, + {SM_LDC_R8, SM_MUL, CODE_SEQUENCE_END}, + {SM_LDC_R8, SM_DIV, CODE_SEQUENCE_END}, + + {SM_CONV_R4, SM_ADD, CODE_SEQUENCE_END}, + {SM_CONV_R4, SM_SUB, CODE_SEQUENCE_END}, + {SM_CONV_R4, SM_MUL, CODE_SEQUENCE_END}, + {SM_CONV_R4, SM_DIV, CODE_SEQUENCE_END}, + + // {SM_CONV_R8, SM_ADD, CODE_SEQUENCE_END}, // Removed since it collides with ldelem.r8 in + // Math.InternalRound + // {SM_CONV_R8, SM_SUB, CODE_SEQUENCE_END}, // Just remove the SM_SUB as well. + {SM_CONV_R8, SM_MUL, CODE_SEQUENCE_END}, + {SM_CONV_R8, SM_DIV, CODE_SEQUENCE_END}, + + /* Constant init constructor: + L_0006: ldarg.0 + L_0007: ldc.r8 0 + L_0010: stfld float64 raytracer.Vec::x + */ + + {SM_LDARG_0, SM_LDC_I4_0, SM_STFLD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_LDC_R4, SM_STFLD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_LDC_R8, SM_STFLD, CODE_SEQUENCE_END}, + + /* Copy constructor: + L_0006: ldarg.0 + L_0007: ldarg.1 + L_0008: ldfld float64 raytracer.Vec::x + L_000d: stfld float64 raytracer.Vec::x + */ + + {SM_LDARG_0, SM_LDARG_1, SM_LDFLD, SM_STFLD, CODE_SEQUENCE_END}, + + /* Field setter: + + [DebuggerNonUserCode] + private void CtorClosed(object target, IntPtr methodPtr) + { + if (target == null) + { + this.ThrowNullThisInDelegateToInstance(); + } + base._target = target; + base._methodPtr = methodPtr; + } + + + .method private hidebysig instance void CtorClosed(object target, native int methodPtr) cil managed + { + .custom instance void System.Diagnostics.DebuggerNonUserCodeAttribute::.ctor() + .maxstack 8 + L_0000: ldarg.1 + L_0001: brtrue.s L_0009 + L_0003: ldarg.0 + L_0004: call instance void System.MulticastDelegate::ThrowNullThisInDelegateToInstance() + + L_0009: ldarg.0 + L_000a: ldarg.1 + L_000b: stfld object System.Delegate::_target + + L_0010: ldarg.0 + L_0011: ldarg.2 + L_0012: stfld native int System.Delegate::_methodPtr + + L_0017: ret + } + */ + + {SM_LDARG_0, SM_LDARG_1, SM_STFLD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_LDARG_2, SM_STFLD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_LDARG_3, SM_STFLD, CODE_SEQUENCE_END}, + + /* Scale operator: + + L_0000: ldarg.0 + L_0001: dup + L_0002: ldfld float64 raytracer.Vec::x + L_0007: ldarg.1 + L_0008: mul + L_0009: stfld float64 raytracer.Vec::x + */ + + {SM_LDARG_0, SM_DUP, SM_LDFLD, SM_LDARG_1, SM_ADD, SM_STFLD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_DUP, SM_LDFLD, SM_LDARG_1, SM_SUB, SM_STFLD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_DUP, SM_LDFLD, SM_LDARG_1, SM_MUL, SM_STFLD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_DUP, SM_LDFLD, SM_LDARG_1, SM_DIV, SM_STFLD, CODE_SEQUENCE_END}, + + /* Add operator + L_0000: ldarg.0 + L_0001: ldfld float64 raytracer.Vec::x + L_0006: ldarg.1 + L_0007: ldfld float64 raytracer.Vec::x + L_000c: add + */ + + {SM_LDARG_0, SM_LDFLD, SM_LDARG_1, SM_LDFLD, SM_ADD, CODE_SEQUENCE_END}, + {SM_LDARG_0, SM_LDFLD, SM_LDARG_1, SM_LDFLD, SM_SUB, CODE_SEQUENCE_END}, + // No need for mul and div since there is no mathemetical meaning of it. + + {SM_LDARGA_S, SM_LDFLD, SM_LDARGA_S, SM_LDFLD, SM_ADD, CODE_SEQUENCE_END}, + {SM_LDARGA_S, SM_LDFLD, SM_LDARGA_S, SM_LDFLD, SM_SUB, CODE_SEQUENCE_END}, + // No need for mul and div since there is no mathemetical meaning of it. + + // The end: + {CODE_SEQUENCE_END}}; + +#endif // defined(DEBUG) || defined(SMGEN_COMPILE) |