diff options
Diffstat (limited to 'third_party/webkit/PerformanceTests/ARES-6/Air/opcode.js')
| -rw-r--r-- | third_party/webkit/PerformanceTests/ARES-6/Air/opcode.js | 1655 |
1 files changed, 1655 insertions, 0 deletions
diff --git a/third_party/webkit/PerformanceTests/ARES-6/Air/opcode.js b/third_party/webkit/PerformanceTests/ARES-6/Air/opcode.js new file mode 100644 index 0000000000..0f05c31e9e --- /dev/null +++ b/third_party/webkit/PerformanceTests/ARES-6/Air/opcode.js @@ -0,0 +1,1655 @@ +"use strict"; +// Generated by opcode_generator.rb from JavaScriptCore/b3/air/AirOpcode.opcodes -- do not edit! +const Nop = Symbol("Nop"); +const Add32 = Symbol("Add32"); +const Add8 = Symbol("Add8"); +const Add16 = Symbol("Add16"); +const Add64 = Symbol("Add64"); +const AddDouble = Symbol("AddDouble"); +const AddFloat = Symbol("AddFloat"); +const Sub32 = Symbol("Sub32"); +const Sub64 = Symbol("Sub64"); +const SubDouble = Symbol("SubDouble"); +const SubFloat = Symbol("SubFloat"); +const Neg32 = Symbol("Neg32"); +const Neg64 = Symbol("Neg64"); +const NegateDouble = Symbol("NegateDouble"); +const Mul32 = Symbol("Mul32"); +const Mul64 = Symbol("Mul64"); +const MultiplyAdd32 = Symbol("MultiplyAdd32"); +const MultiplyAdd64 = Symbol("MultiplyAdd64"); +const MultiplySub32 = Symbol("MultiplySub32"); +const MultiplySub64 = Symbol("MultiplySub64"); +const MultiplyNeg32 = Symbol("MultiplyNeg32"); +const MultiplyNeg64 = Symbol("MultiplyNeg64"); +const Div32 = Symbol("Div32"); +const Div64 = Symbol("Div64"); +const MulDouble = Symbol("MulDouble"); +const MulFloat = Symbol("MulFloat"); +const DivDouble = Symbol("DivDouble"); +const DivFloat = Symbol("DivFloat"); +const X86ConvertToDoubleWord32 = Symbol("X86ConvertToDoubleWord32"); +const X86ConvertToQuadWord64 = Symbol("X86ConvertToQuadWord64"); +const X86Div32 = Symbol("X86Div32"); +const X86Div64 = Symbol("X86Div64"); +const Lea = Symbol("Lea"); +const And32 = Symbol("And32"); +const And64 = Symbol("And64"); +const AndDouble = Symbol("AndDouble"); +const AndFloat = Symbol("AndFloat"); +const XorDouble = Symbol("XorDouble"); +const XorFloat = Symbol("XorFloat"); +const Lshift32 = Symbol("Lshift32"); +const Lshift64 = Symbol("Lshift64"); +const Rshift32 = Symbol("Rshift32"); +const Rshift64 = Symbol("Rshift64"); +const Urshift32 = Symbol("Urshift32"); +const Urshift64 = Symbol("Urshift64"); +const Or32 = Symbol("Or32"); +const Or64 = Symbol("Or64"); +const Xor32 = Symbol("Xor32"); +const Xor64 = Symbol("Xor64"); +const Not32 = Symbol("Not32"); +const Not64 = Symbol("Not64"); +const AbsDouble = Symbol("AbsDouble"); +const AbsFloat = Symbol("AbsFloat"); +const CeilDouble = Symbol("CeilDouble"); +const CeilFloat = Symbol("CeilFloat"); +const FloorDouble = Symbol("FloorDouble"); +const FloorFloat = Symbol("FloorFloat"); +const SqrtDouble = Symbol("SqrtDouble"); +const SqrtFloat = Symbol("SqrtFloat"); +const ConvertInt32ToDouble = Symbol("ConvertInt32ToDouble"); +const ConvertInt64ToDouble = Symbol("ConvertInt64ToDouble"); +const ConvertInt32ToFloat = Symbol("ConvertInt32ToFloat"); +const ConvertInt64ToFloat = Symbol("ConvertInt64ToFloat"); +const CountLeadingZeros32 = Symbol("CountLeadingZeros32"); +const CountLeadingZeros64 = Symbol("CountLeadingZeros64"); +const ConvertDoubleToFloat = Symbol("ConvertDoubleToFloat"); +const ConvertFloatToDouble = Symbol("ConvertFloatToDouble"); +const Move = Symbol("Move"); +const Swap32 = Symbol("Swap32"); +const Swap64 = Symbol("Swap64"); +const Move32 = Symbol("Move32"); +const StoreZero32 = Symbol("StoreZero32"); +const SignExtend32ToPtr = Symbol("SignExtend32ToPtr"); +const ZeroExtend8To32 = Symbol("ZeroExtend8To32"); +const SignExtend8To32 = Symbol("SignExtend8To32"); +const ZeroExtend16To32 = Symbol("ZeroExtend16To32"); +const SignExtend16To32 = Symbol("SignExtend16To32"); +const MoveFloat = Symbol("MoveFloat"); +const MoveDouble = Symbol("MoveDouble"); +const MoveZeroToDouble = Symbol("MoveZeroToDouble"); +const Move64ToDouble = Symbol("Move64ToDouble"); +const Move32ToFloat = Symbol("Move32ToFloat"); +const MoveDoubleTo64 = Symbol("MoveDoubleTo64"); +const MoveFloatTo32 = Symbol("MoveFloatTo32"); +const Load8 = Symbol("Load8"); +const Store8 = Symbol("Store8"); +const Load8SignedExtendTo32 = Symbol("Load8SignedExtendTo32"); +const Load16 = Symbol("Load16"); +const Load16SignedExtendTo32 = Symbol("Load16SignedExtendTo32"); +const Store16 = Symbol("Store16"); +const Compare32 = Symbol("Compare32"); +const Compare64 = Symbol("Compare64"); +const Test32 = Symbol("Test32"); +const Test64 = Symbol("Test64"); +const CompareDouble = Symbol("CompareDouble"); +const CompareFloat = Symbol("CompareFloat"); +const Branch8 = Symbol("Branch8"); +const Branch32 = Symbol("Branch32"); +const Branch64 = Symbol("Branch64"); +const BranchTest8 = Symbol("BranchTest8"); +const BranchTest32 = Symbol("BranchTest32"); +const BranchTest64 = Symbol("BranchTest64"); +const BranchDouble = Symbol("BranchDouble"); +const BranchFloat = Symbol("BranchFloat"); +const BranchAdd32 = Symbol("BranchAdd32"); +const BranchAdd64 = Symbol("BranchAdd64"); +const BranchMul32 = Symbol("BranchMul32"); +const BranchMul64 = Symbol("BranchMul64"); +const BranchSub32 = Symbol("BranchSub32"); +const BranchSub64 = Symbol("BranchSub64"); +const BranchNeg32 = Symbol("BranchNeg32"); +const BranchNeg64 = Symbol("BranchNeg64"); +const MoveConditionally32 = Symbol("MoveConditionally32"); +const MoveConditionally64 = Symbol("MoveConditionally64"); +const MoveConditionallyTest32 = Symbol("MoveConditionallyTest32"); +const MoveConditionallyTest64 = Symbol("MoveConditionallyTest64"); +const MoveConditionallyDouble = Symbol("MoveConditionallyDouble"); +const MoveConditionallyFloat = Symbol("MoveConditionallyFloat"); +const MoveDoubleConditionally32 = Symbol("MoveDoubleConditionally32"); +const MoveDoubleConditionally64 = Symbol("MoveDoubleConditionally64"); +const MoveDoubleConditionallyTest32 = Symbol("MoveDoubleConditionallyTest32"); +const MoveDoubleConditionallyTest64 = Symbol("MoveDoubleConditionallyTest64"); +const MoveDoubleConditionallyDouble = Symbol("MoveDoubleConditionallyDouble"); +const MoveDoubleConditionallyFloat = Symbol("MoveDoubleConditionallyFloat"); +const Jump = Symbol("Jump"); +const Ret32 = Symbol("Ret32"); +const Ret64 = Symbol("Ret64"); +const RetFloat = Symbol("RetFloat"); +const RetDouble = Symbol("RetDouble"); +const Oops = Symbol("Oops"); +const Shuffle = Symbol("Shuffle"); +const Patch = Symbol("Patch"); +const CCall = Symbol("CCall"); +const ColdCCall = Symbol("ColdCCall"); +function Inst_forEachArg(inst, func) +{ + let replacement; + switch (inst.opcode) { + case Nop: + break; + break; + case Add32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Add8: + inst.visitArg(0, func, Arg.Use, GP, 8); + inst.visitArg(1, func, Arg.UseDef, GP, 8); + break; + break; + case Add16: + inst.visitArg(0, func, Arg.Use, GP, 16); + inst.visitArg(1, func, Arg.UseDef, GP, 16); + break; + break; + case Add64: + switch (inst.args.length) { + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Def, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case AddDouble: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Def, FP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.UseDef, FP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case AddFloat: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Def, FP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.UseDef, FP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Sub32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + break; + case Sub64: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + break; + case SubDouble: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Def, FP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.UseDef, FP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case SubFloat: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Def, FP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.UseDef, FP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Neg32: + inst.visitArg(0, func, Arg.UseZDef, GP, 32); + break; + break; + case Neg64: + inst.visitArg(0, func, Arg.UseDef, GP, 64); + break; + break; + case NegateDouble: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case Mul32: + switch (inst.args.length) { + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Mul64: + switch (inst.args.length) { + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Def, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MultiplyAdd32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case MultiplyAdd64: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Def, GP, 64); + break; + break; + case MultiplySub32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case MultiplySub64: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Def, GP, 64); + break; + break; + case MultiplyNeg32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + break; + case MultiplyNeg64: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.ZDef, GP, 64); + break; + break; + case Div32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + break; + case Div64: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Def, GP, 64); + break; + break; + case MulDouble: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Def, FP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.UseDef, FP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MulFloat: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Def, FP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.UseDef, FP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case DivDouble: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Def, FP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.UseDef, FP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case DivFloat: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Def, FP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.UseDef, FP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case X86ConvertToDoubleWord32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case X86ConvertToQuadWord64: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Def, GP, 64); + break; + break; + case X86Div32: + inst.visitArg(0, func, Arg.UseZDef, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + break; + break; + case X86Div64: + inst.visitArg(0, func, Arg.UseZDef, GP, 64); + inst.visitArg(1, func, Arg.UseZDef, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + break; + break; + case Lea: + inst.visitArg(0, func, Arg.UseAddr, GP, Ptr); + inst.visitArg(1, func, Arg.Def, GP, Ptr); + break; + break; + case And32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case And64: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Def, GP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case AndDouble: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Def, FP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.UseDef, FP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case AndFloat: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Def, FP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.UseDef, FP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case XorDouble: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Def, FP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.UseDef, FP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case XorFloat: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Def, FP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.UseDef, FP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Lshift32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Lshift64: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.ZDef, GP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Rshift32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Rshift64: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.ZDef, GP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Urshift32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Urshift64: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.ZDef, GP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Or32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Or64: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Def, GP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Xor32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.ZDef, GP, 32); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Xor64: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Def, GP, 64); + break; + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Not32: + switch (inst.args.length) { + case 2: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + case 1: + inst.visitArg(0, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case Not64: + switch (inst.args.length) { + case 2: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Def, GP, 64); + break; + case 1: + inst.visitArg(0, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case AbsDouble: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case AbsFloat: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case CeilDouble: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case CeilFloat: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case FloorDouble: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case FloorFloat: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case SqrtDouble: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case SqrtFloat: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case ConvertInt32ToDouble: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case ConvertInt64ToDouble: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case ConvertInt32ToFloat: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case ConvertInt64ToFloat: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case CountLeadingZeros32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case CountLeadingZeros64: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Def, GP, 64); + break; + break; + case ConvertDoubleToFloat: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case ConvertFloatToDouble: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case Move: + inst.visitArg(0, func, Arg.Use, GP, Ptr); + inst.visitArg(1, func, Arg.Def, GP, Ptr); + break; + break; + case Swap32: + inst.visitArg(0, func, Arg.UseDef, GP, 32); + inst.visitArg(1, func, Arg.UseDef, GP, 32); + break; + break; + case Swap64: + inst.visitArg(0, func, Arg.UseDef, GP, 64); + inst.visitArg(1, func, Arg.UseDef, GP, 64); + break; + break; + case Move32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case StoreZero32: + inst.visitArg(0, func, Arg.Use, GP, 32); + break; + break; + case SignExtend32ToPtr: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Def, GP, Ptr); + break; + break; + case ZeroExtend8To32: + inst.visitArg(0, func, Arg.Use, GP, 8); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case SignExtend8To32: + inst.visitArg(0, func, Arg.Use, GP, 8); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case ZeroExtend16To32: + inst.visitArg(0, func, Arg.Use, GP, 16); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case SignExtend16To32: + inst.visitArg(0, func, Arg.Use, GP, 16); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case MoveFloat: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case MoveDouble: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case MoveZeroToDouble: + inst.visitArg(0, func, Arg.Def, FP, 64); + break; + break; + case Move64ToDouble: + inst.visitArg(0, func, Arg.Use, GP, 64); + inst.visitArg(1, func, Arg.Def, FP, 64); + break; + break; + case Move32ToFloat: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Def, FP, 32); + break; + break; + case MoveDoubleTo64: + inst.visitArg(0, func, Arg.Use, FP, 64); + inst.visitArg(1, func, Arg.Def, GP, 64); + break; + break; + case MoveFloatTo32: + inst.visitArg(0, func, Arg.Use, FP, 32); + inst.visitArg(1, func, Arg.Def, GP, 32); + break; + break; + case Load8: + inst.visitArg(0, func, Arg.Use, GP, 8); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case Store8: + inst.visitArg(0, func, Arg.Use, GP, 8); + inst.visitArg(1, func, Arg.Def, GP, 8); + break; + break; + case Load8SignedExtendTo32: + inst.visitArg(0, func, Arg.Use, GP, 8); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case Load16: + inst.visitArg(0, func, Arg.Use, GP, 16); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case Load16SignedExtendTo32: + inst.visitArg(0, func, Arg.Use, GP, 16); + inst.visitArg(1, func, Arg.ZDef, GP, 32); + break; + break; + case Store16: + inst.visitArg(0, func, Arg.Use, GP, 16); + inst.visitArg(1, func, Arg.Def, GP, 16); + break; + break; + case Compare32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case Compare64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case Test32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case Test64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case CompareDouble: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Use, FP, 64); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case CompareFloat: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Use, FP, 32); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + break; + case Branch8: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 8); + inst.visitArg(2, func, Arg.Use, GP, 8); + break; + break; + case Branch32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + break; + break; + case Branch64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + break; + break; + case BranchTest8: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 8); + inst.visitArg(2, func, Arg.Use, GP, 8); + break; + break; + case BranchTest32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + break; + break; + case BranchTest64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + break; + break; + case BranchDouble: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Use, FP, 64); + break; + break; + case BranchFloat: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Use, FP, 32); + break; + break; + case BranchAdd32: + switch (inst.args.length) { + case 4: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.UseZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case BranchAdd64: + switch (inst.args.length) { + case 4: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.ZDef, GP, 64); + break; + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.UseDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case BranchMul32: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.UseZDef, GP, 32); + break; + case 4: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.ZDef, GP, 32); + break; + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Scratch, GP, 32); + inst.visitArg(4, func, Arg.Scratch, GP, 32); + inst.visitArg(5, func, Arg.ZDef, GP, 32); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case BranchMul64: + switch (inst.args.length) { + case 3: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.UseZDef, GP, 64); + break; + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Scratch, GP, 64); + inst.visitArg(4, func, Arg.Scratch, GP, 64); + inst.visitArg(5, func, Arg.ZDef, GP, 64); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case BranchSub32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.UseZDef, GP, 32); + break; + break; + case BranchSub64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.UseDef, GP, 64); + break; + break; + case BranchNeg32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 32); + break; + break; + case BranchNeg64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.UseZDef, GP, 64); + break; + break; + case MoveConditionally32: + switch (inst.args.length) { + case 5: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.UseDef, GP, Ptr); + break; + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.Use, GP, Ptr); + inst.visitArg(5, func, Arg.Def, GP, Ptr); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MoveConditionally64: + switch (inst.args.length) { + case 5: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.UseDef, GP, Ptr); + break; + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.Use, GP, Ptr); + inst.visitArg(5, func, Arg.Def, GP, Ptr); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MoveConditionallyTest32: + switch (inst.args.length) { + case 5: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.UseDef, GP, Ptr); + break; + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.Use, GP, Ptr); + inst.visitArg(5, func, Arg.Def, GP, Ptr); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MoveConditionallyTest64: + switch (inst.args.length) { + case 5: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.UseDef, GP, Ptr); + break; + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.Use, GP, Ptr); + inst.visitArg(5, func, Arg.Def, GP, Ptr); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MoveConditionallyDouble: + switch (inst.args.length) { + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Use, FP, 64); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.Use, GP, Ptr); + inst.visitArg(5, func, Arg.Def, GP, Ptr); + break; + case 5: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Use, FP, 64); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.UseDef, GP, Ptr); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MoveConditionallyFloat: + switch (inst.args.length) { + case 6: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Use, FP, 32); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.Use, GP, Ptr); + inst.visitArg(5, func, Arg.Def, GP, Ptr); + break; + case 5: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Use, FP, 32); + inst.visitArg(3, func, Arg.Use, GP, Ptr); + inst.visitArg(4, func, Arg.UseDef, GP, Ptr); + break; + default: + throw new Error("Bad overload"); + break; + } + break; + case MoveDoubleConditionally32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Use, FP, 64); + inst.visitArg(4, func, Arg.Use, FP, 64); + inst.visitArg(5, func, Arg.Def, FP, 64); + break; + break; + case MoveDoubleConditionally64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Use, FP, 64); + inst.visitArg(4, func, Arg.Use, FP, 64); + inst.visitArg(5, func, Arg.Def, FP, 64); + break; + break; + case MoveDoubleConditionallyTest32: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 32); + inst.visitArg(2, func, Arg.Use, GP, 32); + inst.visitArg(3, func, Arg.Use, FP, 64); + inst.visitArg(4, func, Arg.Use, FP, 64); + inst.visitArg(5, func, Arg.Def, FP, 64); + break; + break; + case MoveDoubleConditionallyTest64: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, GP, 64); + inst.visitArg(2, func, Arg.Use, GP, 64); + inst.visitArg(3, func, Arg.Use, FP, 64); + inst.visitArg(4, func, Arg.Use, FP, 64); + inst.visitArg(5, func, Arg.Def, FP, 64); + break; + break; + case MoveDoubleConditionallyDouble: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 64); + inst.visitArg(2, func, Arg.Use, FP, 64); + inst.visitArg(3, func, Arg.Use, FP, 64); + inst.visitArg(4, func, Arg.Use, FP, 64); + inst.visitArg(5, func, Arg.Def, FP, 64); + break; + break; + case MoveDoubleConditionallyFloat: + inst.visitArg(0, func, Arg.Use, GP, 32); + inst.visitArg(1, func, Arg.Use, FP, 32); + inst.visitArg(2, func, Arg.Use, FP, 32); + inst.visitArg(3, func, Arg.Use, FP, 64); + inst.visitArg(4, func, Arg.Use, FP, 64); + inst.visitArg(5, func, Arg.Def, FP, 64); + break; + break; + case Jump: + break; + break; + case Ret32: + inst.visitArg(0, func, Arg.Use, GP, 32); + break; + break; + case Ret64: + inst.visitArg(0, func, Arg.Use, GP, 64); + break; + break; + case RetFloat: + inst.visitArg(0, func, Arg.Use, FP, 32); + break; + break; + case RetDouble: + inst.visitArg(0, func, Arg.Use, FP, 64); + break; + break; + case Oops: + break; + break; + case Shuffle: + ShuffleCustom.forEachArg(inst, func); + break; + case Patch: + PatchCustom.forEachArg(inst, func); + break; + case CCall: + CCallCustom.forEachArg(inst, func); + break; + case ColdCCall: + ColdCCallCustom.forEachArg(inst, func); + break; + default: + throw "Bad opcode"; + } +} +function Inst_hasNonArgEffects(inst) +{ + switch (inst.opcode) { + case Branch8: + case Branch32: + case Branch64: + case BranchTest8: + case BranchTest32: + case BranchTest64: + case BranchDouble: + case BranchFloat: + case BranchAdd32: + case BranchAdd64: + case BranchMul32: + case BranchMul64: + case BranchSub32: + case BranchSub64: + case BranchNeg32: + case BranchNeg64: + case Jump: + case Ret32: + case Ret64: + case RetFloat: + case RetDouble: + case Oops: + return true; + case Shuffle: + return ShuffleCustom.hasNonArgNonControlEffects(inst); + case Patch: + return PatchCustom.hasNonArgNonControlEffects(inst); + case CCall: + return CCallCustom.hasNonArgNonControlEffects(inst); + case ColdCCall: + return ColdCCallCustom.hasNonArgNonControlEffects(inst); + default: + return false; + } +} +function opcodeCode(opcode) +{ + switch (opcode) { + case AbsDouble: + return 0 + case AbsFloat: + return 1 + case Add16: + return 2 + case Add32: + return 3 + case Add64: + return 4 + case Add8: + return 5 + case AddDouble: + return 6 + case AddFloat: + return 7 + case And32: + return 8 + case And64: + return 9 + case AndDouble: + return 10 + case AndFloat: + return 11 + case Branch32: + return 12 + case Branch64: + return 13 + case Branch8: + return 14 + case BranchAdd32: + return 15 + case BranchAdd64: + return 16 + case BranchDouble: + return 17 + case BranchFloat: + return 18 + case BranchMul32: + return 19 + case BranchMul64: + return 20 + case BranchNeg32: + return 21 + case BranchNeg64: + return 22 + case BranchSub32: + return 23 + case BranchSub64: + return 24 + case BranchTest32: + return 25 + case BranchTest64: + return 26 + case BranchTest8: + return 27 + case CCall: + return 28 + case CeilDouble: + return 29 + case CeilFloat: + return 30 + case ColdCCall: + return 31 + case Compare32: + return 32 + case Compare64: + return 33 + case CompareDouble: + return 34 + case CompareFloat: + return 35 + case ConvertDoubleToFloat: + return 36 + case ConvertFloatToDouble: + return 37 + case ConvertInt32ToDouble: + return 38 + case ConvertInt32ToFloat: + return 39 + case ConvertInt64ToDouble: + return 40 + case ConvertInt64ToFloat: + return 41 + case CountLeadingZeros32: + return 42 + case CountLeadingZeros64: + return 43 + case Div32: + return 44 + case Div64: + return 45 + case DivDouble: + return 46 + case DivFloat: + return 47 + case FloorDouble: + return 48 + case FloorFloat: + return 49 + case Jump: + return 50 + case Lea: + return 51 + case Load16: + return 52 + case Load16SignedExtendTo32: + return 53 + case Load8: + return 54 + case Load8SignedExtendTo32: + return 55 + case Lshift32: + return 56 + case Lshift64: + return 57 + case Move: + return 58 + case Move32: + return 59 + case Move32ToFloat: + return 60 + case Move64ToDouble: + return 61 + case MoveConditionally32: + return 62 + case MoveConditionally64: + return 63 + case MoveConditionallyDouble: + return 64 + case MoveConditionallyFloat: + return 65 + case MoveConditionallyTest32: + return 66 + case MoveConditionallyTest64: + return 67 + case MoveDouble: + return 68 + case MoveDoubleConditionally32: + return 69 + case MoveDoubleConditionally64: + return 70 + case MoveDoubleConditionallyDouble: + return 71 + case MoveDoubleConditionallyFloat: + return 72 + case MoveDoubleConditionallyTest32: + return 73 + case MoveDoubleConditionallyTest64: + return 74 + case MoveDoubleTo64: + return 75 + case MoveFloat: + return 76 + case MoveFloatTo32: + return 77 + case MoveZeroToDouble: + return 78 + case Mul32: + return 79 + case Mul64: + return 80 + case MulDouble: + return 81 + case MulFloat: + return 82 + case MultiplyAdd32: + return 83 + case MultiplyAdd64: + return 84 + case MultiplyNeg32: + return 85 + case MultiplyNeg64: + return 86 + case MultiplySub32: + return 87 + case MultiplySub64: + return 88 + case Neg32: + return 89 + case Neg64: + return 90 + case NegateDouble: + return 91 + case Nop: + return 92 + case Not32: + return 93 + case Not64: + return 94 + case Oops: + return 95 + case Or32: + return 96 + case Or64: + return 97 + case Patch: + return 98 + case Ret32: + return 99 + case Ret64: + return 100 + case RetDouble: + return 101 + case RetFloat: + return 102 + case Rshift32: + return 103 + case Rshift64: + return 104 + case Shuffle: + return 105 + case SignExtend16To32: + return 106 + case SignExtend32ToPtr: + return 107 + case SignExtend8To32: + return 108 + case SqrtDouble: + return 109 + case SqrtFloat: + return 110 + case Store16: + return 111 + case Store8: + return 112 + case StoreZero32: + return 113 + case Sub32: + return 114 + case Sub64: + return 115 + case SubDouble: + return 116 + case SubFloat: + return 117 + case Swap32: + return 118 + case Swap64: + return 119 + case Test32: + return 120 + case Test64: + return 121 + case Urshift32: + return 122 + case Urshift64: + return 123 + case X86ConvertToDoubleWord32: + return 124 + case X86ConvertToQuadWord64: + return 125 + case X86Div32: + return 126 + case X86Div64: + return 127 + case Xor32: + return 128 + case Xor64: + return 129 + case XorDouble: + return 130 + case XorFloat: + return 131 + case ZeroExtend16To32: + return 132 + case ZeroExtend8To32: + return 133 + default: + throw new Error("bad opcode"); + } +} |