/
Opcode.cs
125 lines (91 loc) · 4.55 KB
/
Opcode.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Threading;
using System.Diagnostics.CodeAnalysis;
namespace System.Reflection.Emit
{
public readonly struct OpCode : IEquatable<OpCode>
{
//
// Use packed bitfield for flags to avoid code bloat
//
internal const int OperandTypeMask = 0x1F; // 000000000000000000000000000XXXXX
internal const int FlowControlShift = 5; // 00000000000000000000000XXXX00000
internal const int FlowControlMask = 0x0F;
internal const int OpCodeTypeShift = 9; // 00000000000000000000XXX000000000
internal const int OpCodeTypeMask = 0x07;
internal const int StackBehaviourPopShift = 12; // 000000000000000XXXXX000000000000
internal const int StackBehaviourPushShift = 17; // 0000000000XXXXX00000000000000000
internal const int StackBehaviourMask = 0x1F;
internal const int SizeShift = 22; // 00000000XX0000000000000000000000
internal const int SizeMask = 0x03;
internal const int EndsUncondJmpBlkFlag = 0x01000000; // 0000000X000000000000000000000000
// unused // 0000XXX0000000000000000000000000
internal const int StackChangeShift = 28; // XXXX0000000000000000000000000000
private readonly OpCodeValues m_value;
private readonly int m_flags;
internal OpCode(OpCodeValues value, int flags)
{
m_value = value;
m_flags = flags;
}
internal bool EndsUncondJmpBlk() =>
(m_flags & EndsUncondJmpBlkFlag) != 0;
internal int StackChange() =>
m_flags >> StackChangeShift;
public OperandType OperandType => (OperandType)(m_flags & OperandTypeMask);
public FlowControl FlowControl => (FlowControl)((m_flags >> FlowControlShift) & FlowControlMask);
public OpCodeType OpCodeType => (OpCodeType)((m_flags >> OpCodeTypeShift) & OpCodeTypeMask);
public StackBehaviour StackBehaviourPop => (StackBehaviour)((m_flags >> StackBehaviourPopShift) & StackBehaviourMask);
public StackBehaviour StackBehaviourPush => (StackBehaviour)((m_flags >> StackBehaviourPushShift) & StackBehaviourMask);
public int Size => (m_flags >> SizeShift) & SizeMask;
public short Value => (short)m_value;
private static volatile string[]? g_nameCache;
public string? Name
{
get
{
if (Size == 0)
return null;
// Create and cache the opcode names lazily. They should be rarely used (only for logging, etc.)
// Note that we do not any locks here because of we always get the same names. The last one wins.
string[]? nameCache = g_nameCache;
if (nameCache == null)
{
nameCache = new string[0x11f];
g_nameCache = nameCache;
}
OpCodeValues opCodeValue = (OpCodeValues)(ushort)Value;
int idx = (int)opCodeValue;
if (idx > 0xFF)
{
if (idx >= 0xfe00 && idx <= 0xfe1e)
{
// Transform two byte opcode value to lower range that's suitable
// for array index
idx = 0x100 + (idx - 0xfe00);
}
else
{
// Unknown opcode
return null;
}
}
string name = Volatile.Read(ref nameCache[idx]);
if (name != null)
return name;
// Create ilasm style name from the enum value name.
name = Enum.GetName(opCodeValue)!.ToLowerInvariant().Replace('_', '.');
Volatile.Write(ref nameCache[idx], name);
return name;
}
}
public override bool Equals([NotNullWhen(true)] object? obj) =>
obj is OpCode other && Equals(other);
public bool Equals(OpCode obj) => obj.Value == Value;
public static bool operator ==(OpCode a, OpCode b) => a.Equals(b);
public static bool operator !=(OpCode a, OpCode b) => !(a == b);
public override int GetHashCode() => Value;
public override string? ToString() => Name;
}
}