../dlr/Runtime/Microsoft.Dynamic/Interpreter/RuntimeVariables.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/AddInstruction.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/AndInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/ArrayOperations.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/CallInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/CallInstruction.Generated.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/LabelInfo.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/LessThanInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/LocalAccess.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/ModInstruction.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/MulInstruction.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/NegateInstruction.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/NotInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/NotEqualInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/NumericConvertInstruction.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/OrInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/StackOperations.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/ShlInstruction.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/ShrInstruction.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/SubInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/TypeOperations.cs
+../dlr/Runtime/Microsoft.Dynamic/Interpreter/Instructions/XorInstruction.cs
../dlr/Runtime/Microsoft.Dynamic/Math/BigIntegerV4.cs
../dlr/Runtime/Microsoft.Dynamic/Math/Complex64.cs
--- /dev/null
+//
+// AndbInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class AndInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Boolean;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private AndInstruction() {
+ }
+
+ internal sealed class AndInt32 : AndInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject((Int32)l & (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class AndInt16 : AndInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)((Int16)l & (Int16)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class AndInt64 : AndInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)((Int64)l & (Int64)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class AndUInt16 : AndInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)((UInt16)l & (UInt16)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class AndUInt32 : AndInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)((UInt32)l & (UInt32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class AndUInt64 : AndInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)((UInt64)l & (UInt64)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class AndBoolean : AndInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Boolean)((Boolean)l & (Boolean)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new AndInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new AndInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new AndInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new AndUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new AndUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new AndUInt64());
+ case TypeCode.Boolean: return _Boolean ?? (_Boolean = new AndBoolean());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "And()";
+ }
+ }
+}
}
}
+ public sealed class GetArrayLengthInstruction : Instruction {
+ private static Instruction instance;
+
+ private GetArrayLengthInstruction() { }
+
+ public override int ConsumedStack { get { return 1; } }
+ public override int ProducedStack { get { return 1; } }
+
+ public override int Run(InterpretedFrame frame) {
+ var array = (Array)frame.Pop();
+ frame.Push(array.Length);
+ return +1;
+ }
+
+ public static Instruction Create() {
+ return instance ?? (instance = new GetArrayLengthInstruction());
+ }
+
+ public override string InstructionName {
+ get { return "GetArrayLength"; }
+ }
+ }
+
public sealed class SetArrayItemInstruction<TElement> : Instruction {
internal SetArrayItemInstruction() { }
return null;
}
}
-
- internal sealed class NotInstruction : Instruction {
- public static readonly Instruction Instance = new NotInstruction();
-
- private NotInstruction() { }
- public override int ConsumedStack { get { return 1; } }
- public override int ProducedStack { get { return 1; } }
- public override int Run(InterpretedFrame frame) {
- frame.Push((bool)frame.Pop() ? ScriptingRuntimeHelpers.False : ScriptingRuntimeHelpers.True);
- return +1;
- }
- }
}
}
}
+ public void EmitGetArrayLength(Type arrayType) {
+ Emit(GetArrayLengthInstruction.Create());
+ }
+
public void EmitSetArrayItem(Type arrayType) {
Type elementType = arrayType.GetElementType();
if (elementType.IsClass() || elementType.IsInterface()) {
}
}
- [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters")]
public void EmitSub(Type type, bool @checked) {
- throw new NotSupportedException();
+ if (@checked) {
+ Emit(SubOvfInstruction.Create(type));
+ } else {
+ Emit(SubInstruction.Create(type));
+ }
}
- [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters")]
public void EmitMul(Type type, bool @checked) {
- throw new NotSupportedException();
+ if (@checked) {
+ Emit(MulOvfInstruction.Create(type));
+ } else {
+ Emit(MulInstruction.Create(type));
+ }
}
public void EmitDiv(Type type) {
Emit(DivInstruction.Create(type));
}
+ public void EmitMod(Type type) {
+ Emit(ModInstruction.Create(type));
+ }
+
#endregion
+ public void EmitShl(Type type) {
+ Emit(ShlInstruction.Create(type));
+ }
+
+ public void EmitShr(Type type) {
+ Emit(ShrInstruction.Create(type));
+ }
+
+ public void EmitOr(Type type) {
+ Emit(OrInstruction.Create(type));
+ }
+
+ public void EmitAnd(Type type) {
+ Emit(AndInstruction.Create(type));
+ }
+
+ public void EmitExclusiveOr(Type type) {
+ Emit(XorInstruction.Create(type));
+ }
+
#region Comparisons
public void EmitEqual(Type type) {
#endregion
- #region Boolean Operators
+ #region Unary Operators
+
+ public void EmitNegate(Type type, bool @checked) {
+ if (@checked)
+ Emit(NegateOvfInstruction.Create(type));
+ else
+ Emit(NegateInstruction.Create(type));
+ }
- public void EmitNot() {
- Emit(NotInstruction.Instance);
+ public void EmitNot(Type type) {
+ Emit(NotInstruction.Create(type));
}
#endregion
--- /dev/null
+//
+// ModInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class ModInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Single, _Double;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private ModInstruction() {
+ }
+
+ internal sealed class ModInt32 : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject(unchecked((Int32)l % (Int32)r));
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class ModInt16 : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)unchecked((Int16)l % (Int16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class ModInt64 : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)unchecked((Int64)l % (Int64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class ModUInt16 : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)unchecked((UInt16)l % (UInt16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class ModUInt32 : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)unchecked((UInt32)l % (UInt32)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class ModUInt64 : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)unchecked((UInt64)l % (UInt64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class ModSingle : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Single)((Single)l % (Single)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class ModDouble : ModInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Double)l % (Double)r;
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new ModInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new ModInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new ModInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new ModUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new ModUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new ModUInt64());
+ case TypeCode.Single: return _Single ?? (_Single = new ModSingle());
+ case TypeCode.Double: return _Double ?? (_Double = new ModDouble());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Mod()";
+ }
+ }
+}
--- /dev/null
+//
+// MulInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class MulInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Single, _Double;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private MulInstruction() {
+ }
+
+ internal sealed class MulInt32 : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject(unchecked((Int32)l * (Int32)r));
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulInt16 : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)unchecked((Int16)l * (Int16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulInt64 : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)unchecked((Int64)l * (Int64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulUInt16 : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)unchecked((UInt16)l * (UInt16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulUInt32 : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)unchecked((UInt32)l * (UInt32)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulUInt64 : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)unchecked((UInt64)l * (UInt64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulSingle : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Single)((Single)l * (Single)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulDouble : MulInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Double)l * (Double)r;
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new MulInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new MulInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new MulInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new MulUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new MulUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new MulUInt64());
+ case TypeCode.Single: return _Single ?? (_Single = new MulSingle());
+ case TypeCode.Double: return _Double ?? (_Double = new MulDouble());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Mul()";
+ }
+ }
+
+ internal abstract class MulOvfInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Single, _Double;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private MulOvfInstruction() {
+ }
+
+ internal sealed class MulOvfInt32 : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject(checked((Int32)l * (Int32)r));
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulOvfInt16 : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)checked((Int16)l * (Int16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulOvfInt64 : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)checked((Int64)l * (Int64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulOvfUInt16 : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)checked((UInt16)l * (UInt16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulOvfUInt32 : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)checked((UInt32)l * (UInt32)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulOvfUInt64 : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)checked((UInt64)l * (UInt64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulOvfSingle : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Single)((Single)l * (Single)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class MulOvfDouble : MulOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Double)l * (Double)r;
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new MulOvfInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new MulOvfInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new MulOvfInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new MulOvfUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new MulOvfUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new MulOvfUInt64());
+ case TypeCode.Single: return _Single ?? (_Single = new MulOvfSingle());
+ case TypeCode.Double: return _Double ?? (_Double = new MulOvfDouble());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "MulOvf()";
+ }
+ }
+}
--- /dev/null
+//
+// NegateInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class NegateInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _Single, _Double;
+
+ public override int ConsumedStack { get { return 1; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private NegateInstruction() {
+ }
+
+ internal sealed class NegateInt32 : NegateInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = ScriptingRuntimeHelpers.Int32ToObject(unchecked(-(Int32)v));
+ return 1;
+ }
+ }
+
+ internal sealed class NegateInt16 : NegateInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Int16)unchecked(-(Int16)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NegateInt64 : NegateInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Int64)unchecked(-(Int64)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NegateUInt16 : NegateInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (UInt16)unchecked(-(UInt16)v);
+ return 1;
+
+ }
+ }
+
+ internal sealed class NegateUInt32 : NegateInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (UInt32)unchecked(-(UInt32)v);
+ return 1;
+
+ }
+ }
+
+ internal sealed class NegateSingle : NegateInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Single)unchecked(-(Single)v);
+ return 1;
+
+ }
+ }
+
+ internal sealed class NegateDouble : NegateInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Double)unchecked(-(Double)v);
+ return 1;
+
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new NegateInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new NegateInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new NegateInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new NegateUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new NegateUInt32());
+ case TypeCode.Single: return _Single ?? (_Single = new NegateSingle());
+ case TypeCode.Double: return _Double ?? (_Double = new NegateDouble());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Negate()";
+ }
+ }
+
+ internal abstract class NegateOvfInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _Single, _Double;
+
+ public override int ConsumedStack { get { return 1; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private NegateOvfInstruction() {
+ }
+
+ internal sealed class NegateOvfInt32 : NegateOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = ScriptingRuntimeHelpers.Int32ToObject(checked(-(Int32)v));
+ return 1;
+ }
+ }
+
+ internal sealed class NegateOvfInt16 : NegateOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Int16)checked(-(Int16)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NegateOvfInt64 : NegateOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Int64)checked(-(Int64)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NegateOvfUInt16 : NegateOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (UInt16)checked(-(UInt16)v);
+ return 1;
+
+ }
+ }
+
+ internal sealed class NegateOvfUInt32 : NegateOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (UInt32)checked(-(UInt32)v);
+ return 1;
+
+ }
+ }
+
+ internal sealed class NegateOvfSingle : NegateOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Single)checked(-(Single)v);
+ return 1;
+
+ }
+ }
+
+ internal sealed class NegateOvfDouble : NegateOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Double)checked(-(Double)v);
+ return 1;
+
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new NegateOvfInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new NegateOvfInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new NegateOvfInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new NegateOvfUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new NegateOvfUInt32());
+ case TypeCode.Single: return _Single ?? (_Single = new NegateOvfSingle());
+ case TypeCode.Double: return _Double ?? (_Double = new NegateOvfDouble());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "NegateOvf()";
+ }
+ }
+}
--- /dev/null
+//
+// NotInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class NotInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Boolean;
+
+ public override int ConsumedStack { get { return 1; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private NotInstruction() {
+ }
+
+ internal sealed class NotBoolean : NotInstruction {
+ public override int Run(InterpretedFrame frame) {
+ frame.Push((bool)frame.Pop() ? ScriptingRuntimeHelpers.False : ScriptingRuntimeHelpers.True);
+ return 1;
+ }
+ }
+
+ internal sealed class NotInt32 : NotInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = ScriptingRuntimeHelpers.Int32ToObject(~(Int32)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NotInt16 : NotInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Int16)(~(Int16)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NotInt64 : NotInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (Int64)(~(Int64)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NotUInt16 : NotInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (UInt64)(~(UInt64)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NotUInt32 : NotInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (UInt32)(~(UInt32)v);
+ return 1;
+ }
+ }
+
+ internal sealed class NotUInt64 : NotInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object v = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 1] = (UInt64)(~(UInt64)v);
+ return 1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new NotInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new NotInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new NotInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new NotUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new NotUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new NotUInt64());
+ case TypeCode.Boolean: return _Boolean ?? (_Boolean = new NotBoolean());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Not()";
+ }
+ }
+}
--- /dev/null
+//
+// OrInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class OrInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Boolean;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private OrInstruction() {
+ }
+
+ internal sealed class OrInt32 : OrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject((Int32)l | (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class OrInt16 : OrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)((Int16)l | (Int16)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class OrInt64 : OrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)((Int64)l | (Int64)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class OrUInt16 : OrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)((UInt16)l | (UInt16)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class OrUInt32 : OrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)((UInt32)l | (UInt32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class OrUInt64 : OrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)((UInt64)l | (UInt64)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class OrBoolean : OrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Boolean)((Boolean)l | (Boolean)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new OrInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new OrInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new OrInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new OrUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new OrUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new OrUInt64());
+ case TypeCode.Boolean: return _Boolean ?? (_Boolean = new OrBoolean());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Or()";
+ }
+ }
+}
--- /dev/null
+//
+// ShlInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class ShlInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private ShlInstruction() {
+ }
+
+ internal sealed class ShlInt32 : ShlInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject((Int32)l << (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShlInt16 : ShlInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int32)((Int16)l << (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShlInt64 : ShlInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)((Int64)l << (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShlUInt16 : ShlInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int32)((UInt16)l << (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShlUInt32 : ShlInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)((UInt32)l << (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShlUInt64 : ShlInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)((UInt64)l << (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new ShlInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new ShlInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new ShlInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new ShlUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new ShlUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new ShlUInt64());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Shl()";
+ }
+ }
+}
--- /dev/null
+//
+// ShrInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class ShrInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private ShrInstruction() {
+ }
+
+ internal sealed class ShrInt32 : ShrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject((Int32)l >> (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShrInt16 : ShrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int32)((Int16)l >> (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShrInt64 : ShrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)((Int64)l >> (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShrUInt16 : ShrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int32)((UInt16)l >> (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShrUInt32 : ShrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)((UInt32)l >> (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class ShrUInt64 : ShrInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)((UInt64)l >> (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new ShrInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new ShrInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new ShrInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new ShrUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new ShrUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new ShrUInt64());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Shr()";
+ }
+ }
+}
--- /dev/null
+//
+// SubInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class SubInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Single, _Double;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private SubInstruction() {
+ }
+
+ internal sealed class SubInt32 : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject(unchecked((Int32)l - (Int32)r));
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubInt16 : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)unchecked((Int16)l - (Int16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubInt64 : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)unchecked((Int64)l - (Int64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubUInt16 : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)unchecked((UInt16)l - (UInt16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubUInt32 : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)unchecked((UInt32)l - (UInt32)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubUInt64 : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)unchecked((UInt64)l - (UInt64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubSingle : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Single)((Single)l - (Single)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubDouble : SubInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Double)l - (Double)r;
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new SubInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new SubInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new SubInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new SubUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new SubUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new SubUInt64());
+ case TypeCode.Single: return _Single ?? (_Single = new SubSingle());
+ case TypeCode.Double: return _Double ?? (_Double = new SubDouble());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Sub()";
+ }
+ }
+
+ internal abstract class SubOvfInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Single, _Double;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private SubOvfInstruction() {
+ }
+
+ internal sealed class SubOvfInt32 : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject(checked((Int32)l - (Int32)r));
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubOvfInt16 : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)checked((Int16)l - (Int16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubOvfInt64 : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)checked((Int64)l - (Int64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubOvfUInt16 : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)checked((UInt16)l - (UInt16)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubOvfUInt32 : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)checked((UInt32)l - (UInt32)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubOvfUInt64 : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)checked((UInt64)l - (UInt64)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubOvfSingle : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Single)((Single)l - (Single)r);
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ internal sealed class SubOvfDouble : SubOvfInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Double)l - (Double)r;
+ frame.StackIndex--;
+ return +1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new SubOvfInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new SubOvfInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new SubOvfInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new SubOvfUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new SubOvfUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new SubOvfUInt64());
+ case TypeCode.Single: return _Single ?? (_Single = new SubOvfSingle());
+ case TypeCode.Double: return _Double ?? (_Double = new SubOvfDouble());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "SubOvf()";
+ }
+ }
+}
--- /dev/null
+//
+// AndbInstruction.cs:
+//
+// Authors: Marek Safar (marek.safar@gmail.com)
+//
+// Copyright 2014 Xamarin Inc
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//
+
+using System;
+using System.Diagnostics;
+using Microsoft.Scripting.Runtime;
+using Microsoft.Scripting.Utils;
+
+namespace Microsoft.Scripting.Interpreter {
+ internal abstract class XorInstruction : Instruction {
+ private static Instruction _Int16, _Int32, _Int64, _UInt16, _UInt32, _UInt64, _Boolean;
+
+ public override int ConsumedStack { get { return 2; } }
+ public override int ProducedStack { get { return 1; } }
+
+ private XorInstruction() {
+ }
+
+ internal sealed class XorInt32 : XorInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = ScriptingRuntimeHelpers.Int32ToObject((Int32)l ^ (Int32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class XorInt16 : XorInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int16)((Int16)l ^ (Int16)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class XorInt64 : XorInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Int64)((Int64)l ^ (Int64)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class XorUInt16 : XorInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt16)((UInt16)l ^ (UInt16)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class XorUInt32 : XorInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt32)((UInt32)l ^ (UInt32)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class XorUInt64 : XorInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (UInt64)((UInt64)l ^ (UInt64)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ internal sealed class XorBoolean : XorInstruction {
+ public override int Run(InterpretedFrame frame) {
+ object l = frame.Data[frame.StackIndex - 2];
+ object r = frame.Data[frame.StackIndex - 1];
+ frame.Data[frame.StackIndex - 2] = (Boolean)((Boolean)l ^ (Boolean)r);
+ frame.StackIndex--;
+ return 1;
+ }
+ }
+
+ public static Instruction Create(Type type) {
+ Debug.Assert(!type.IsEnum());
+ switch (type.GetTypeCode()) {
+ case TypeCode.Int16: return _Int16 ?? (_Int16 = new XorInt16());
+ case TypeCode.Int32: return _Int32 ?? (_Int32 = new XorInt32());
+ case TypeCode.Int64: return _Int64 ?? (_Int64 = new XorInt64());
+ case TypeCode.UInt16: return _UInt16 ?? (_UInt16 = new XorUInt16());
+ case TypeCode.UInt32: return _UInt32 ?? (_UInt32 = new XorUInt32());
+ case TypeCode.UInt64: return _UInt64 ?? (_UInt64 = new XorUInt64());
+ case TypeCode.Boolean: return _Boolean ?? (_Boolean = new XorBoolean());
+
+ default:
+ throw Assert.Unreachable;
+ }
+ }
+
+ public override string ToString() {
+ return "Xor()";
+ }
+ }
+}
case ExpressionType.Multiply:
case ExpressionType.MultiplyChecked:
case ExpressionType.Divide:
+ case ExpressionType.Modulo:
CompileArithmetic(node.NodeType, node.Left, node.Right);
return;
CompileComparison(node.NodeType, node.Left, node.Right);
return;
+ case ExpressionType.LeftShift:
+ case ExpressionType.RightShift:
+ CompileShift(node.NodeType, node.Left, node.Right);
+ return;
+
+ case ExpressionType.And:
+ case ExpressionType.Or:
+ case ExpressionType.ExclusiveOr:
+ CompileLogical(node.NodeType, node.Left, node.Right);
+ return;
+
default:
throw new NotImplementedException(node.NodeType.ToString());
}
case ExpressionType.Multiply: _instructions.EmitMul(left.Type, false); break;
case ExpressionType.MultiplyChecked: _instructions.EmitMul(left.Type, true); break;
case ExpressionType.Divide: _instructions.EmitDiv(left.Type); break;
+ case ExpressionType.Modulo: _instructions.EmitMod(left.Type); break;
+ default: throw Assert.Unreachable;
+ }
+ }
+
+ private void CompileShift(ExpressionType nodeType, Expression left, Expression right) {
+ Debug.Assert(right.Type == typeof (int));
+ Compile(left);
+ Compile(right);
+ switch (nodeType) {
+ case ExpressionType.LeftShift: _instructions.EmitShl(left.Type); break;
+ case ExpressionType.RightShift: _instructions.EmitShr(left.Type); break;
+ default: throw Assert.Unreachable;
+ }
+ }
+
+ private void CompileLogical(ExpressionType nodeType, Expression left, Expression right) {
+ Debug.Assert(left.Type == right.Type && TypeUtils.IsIntegerOrBool(left.Type));
+ Compile(left);
+ Compile(right);
+ switch (nodeType) {
+ case ExpressionType.And: _instructions.EmitAnd(left.Type); break;
+ case ExpressionType.Or: _instructions.EmitOr(left.Type); break;
+ case ExpressionType.ExclusiveOr: _instructions.EmitExclusiveOr(left.Type); break;
default: throw Assert.Unreachable;
}
}
return;
}
+ private void CompileNegateExpression(UnaryExpression node, bool @checked) {
+ Compile(node.Operand);
+ _instructions.EmitNegate(node.Type, @checked);
+ }
+
private void CompileNotExpression(UnaryExpression node) {
- if (node.Operand.Type == typeof(bool)) {
- Compile(node.Operand);
- _instructions.EmitNot();
- } else {
- throw new NotImplementedException();
- }
+ Compile(node.Operand);
+ _instructions.EmitNot(node.Type);
}
private void CompileUnaryExpression(Expression expr) {
EmitCall(node.Method);
} else {
switch (node.NodeType) {
+ case ExpressionType.ArrayLength:
+ Compile(node.Operand);
+ _instructions.EmitGetArrayLength (node.Type);
+ return;
+ case ExpressionType.Negate:
+ CompileNegateExpression(node, false);
+ return;
+ case ExpressionType.NegateChecked:
+ CompileNegateExpression(node, true);
+ return;
case ExpressionType.Not:
CompileNotExpression(node);
return;
+ case ExpressionType.UnaryPlus:
+ // unary plus is a nop:
+ Compile(node.Operand);
+ return;
case ExpressionType.TypeAs:
CompileTypeAsExpression(node);
return;
// need to generate code.
if (!CollectionUtils.TrueForAll(parameters, (p) => !p.ParameterType.IsByRef) ||
(!node.Method.IsStatic && node.Method.DeclaringType.IsValueType() && !node.Method.DeclaringType.IsPrimitive())) {
+#if MONO_INTERPRETER
+ throw new NotImplementedException ("Interpreter of ref types");
+#else
_forceCompile = true;
+#endif
}
// CF bug workaround
projects / mono.git / commitdiff