| /* |
| * Copyright 2018 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef SKSL_STANDALONE |
| |
| #include "src/core/SkRasterPipeline.h" |
| #include "src/sksl/SkSLExternalValue.h" |
| #include "src/sksl/SkSLInterpreter.h" |
| #include "src/sksl/ir/SkSLBinaryExpression.h" |
| #include "src/sksl/ir/SkSLExpressionStatement.h" |
| #include "src/sksl/ir/SkSLForStatement.h" |
| #include "src/sksl/ir/SkSLFunctionCall.h" |
| #include "src/sksl/ir/SkSLFunctionReference.h" |
| #include "src/sksl/ir/SkSLIfStatement.h" |
| #include "src/sksl/ir/SkSLIndexExpression.h" |
| #include "src/sksl/ir/SkSLPostfixExpression.h" |
| #include "src/sksl/ir/SkSLPrefixExpression.h" |
| #include "src/sksl/ir/SkSLProgram.h" |
| #include "src/sksl/ir/SkSLStatement.h" |
| #include "src/sksl/ir/SkSLTernaryExpression.h" |
| #include "src/sksl/ir/SkSLVarDeclarations.h" |
| #include "src/sksl/ir/SkSLVarDeclarationsStatement.h" |
| #include "src/sksl/ir/SkSLVariableReference.h" |
| |
| namespace SkSL { |
| |
| static constexpr int UNINITIALIZED = 0xDEADBEEF; |
| |
| Interpreter::Interpreter(std::unique_ptr<Program> program, |
| std::unique_ptr<ByteCode> byteCode, |
| Interpreter::Value inputs[]) |
| : fProgram(std::move(program)) |
| , fByteCode(std::move(byteCode)) |
| , fGlobals(fByteCode->fGlobalCount, UNINITIALIZED) { |
| this->setInputs(inputs); |
| } |
| |
| void Interpreter::setInputs(Interpreter::Value inputs[]) { |
| for (uint8_t slot : fByteCode->fInputSlots) { |
| fGlobals[slot] = *inputs++; |
| } |
| } |
| |
| void Interpreter::run(const ByteCodeFunction& f, Interpreter::Value args[], |
| Interpreter::Value* outReturn) { |
| #ifdef TRACE |
| this->disassemble(f); |
| #endif |
| Value smallStack[128]; |
| std::unique_ptr<Value[]> largeStack; |
| Value* stack = smallStack; |
| if ((int) SK_ARRAY_COUNT(smallStack) < f.fStackCount) { |
| largeStack.reset(new Value[f.fStackCount]); |
| stack = largeStack.get(); |
| } |
| |
| memcpy(stack, args, f.fParameterCount * sizeof(Value)); |
| this->innerRun(f, stack, outReturn); |
| |
| for (const Variable* p : f.fDeclaration.fParameters) { |
| const int nvalues = p->fType.columns() |
| * p->fType.rows(); |
| if (p->fModifiers.fFlags & Modifiers::kOut_Flag) { |
| memcpy(args, stack, nvalues * sizeof(Value)); |
| } |
| args += nvalues; |
| stack += nvalues; |
| } |
| } |
| |
| template <typename T> |
| static T unaligned_load(const void* ptr) { |
| T val; |
| memcpy(&val, ptr, sizeof(val)); |
| return val; |
| } |
| |
| #define READ8() (*(ip++)) |
| #define READ16() (ip += 2, unaligned_load<uint16_t>(ip - 2)) |
| #define READ32() (ip += 4, unaligned_load<uint32_t>(ip - 4)) |
| |
| #define VECTOR_DISASSEMBLE(op, text) \ |
| case ByteCodeInstruction::op: printf(text); break; \ |
| case ByteCodeInstruction::op##2: printf(text "2"); break; \ |
| case ByteCodeInstruction::op##3: printf(text "3"); break; \ |
| case ByteCodeInstruction::op##4: printf(text "4"); break; |
| |
| void Interpreter::disassemble(const ByteCodeFunction& f) { |
| const uint8_t* ip = f.fCode.data(); |
| while (ip < f.fCode.data() + f.fCode.size()) { |
| printf("%d: ", (int) (ip - f.fCode.data())); |
| switch ((ByteCodeInstruction) READ8()) { |
| VECTOR_DISASSEMBLE(kAddF, "addf") |
| VECTOR_DISASSEMBLE(kAddI, "addi") |
| case ByteCodeInstruction::kAndB: printf("andb"); break; |
| case ByteCodeInstruction::kAndI: printf("andi"); break; |
| case ByteCodeInstruction::kBranch: printf("branch %d", READ16()); break; |
| case ByteCodeInstruction::kCall: printf("call %d", READ8()); break; |
| case ByteCodeInstruction::kCallExternal: { |
| int argumentCount = READ8(); |
| int returnCount = READ8(); |
| int externalValue = READ8(); |
| printf("callexternal %d, %d, %d", argumentCount, returnCount, externalValue); |
| break; |
| } |
| VECTOR_DISASSEMBLE(kCompareIEQ, "compareieq") |
| VECTOR_DISASSEMBLE(kCompareINEQ, "compareineq") |
| VECTOR_DISASSEMBLE(kCompareFEQ, "comparefeq") |
| VECTOR_DISASSEMBLE(kCompareFNEQ, "comparefneq") |
| VECTOR_DISASSEMBLE(kCompareFGT, "comparefgt") |
| VECTOR_DISASSEMBLE(kCompareFGTEQ, "comparefgteq") |
| VECTOR_DISASSEMBLE(kCompareFLT, "compareflt") |
| VECTOR_DISASSEMBLE(kCompareFLTEQ, "compareflteq") |
| VECTOR_DISASSEMBLE(kCompareSGT, "comparesgt") |
| VECTOR_DISASSEMBLE(kCompareSGTEQ, "comparesgteq") |
| VECTOR_DISASSEMBLE(kCompareSLT, "compareslt") |
| VECTOR_DISASSEMBLE(kCompareSLTEQ, "compareslteq") |
| VECTOR_DISASSEMBLE(kCompareUGT, "compareugt") |
| VECTOR_DISASSEMBLE(kCompareUGTEQ, "compareugteq") |
| VECTOR_DISASSEMBLE(kCompareULT, "compareult") |
| VECTOR_DISASSEMBLE(kCompareULTEQ, "compareulteq") |
| case ByteCodeInstruction::kConditionalBranch: |
| printf("conditionalbranch %d", READ16()); |
| break; |
| case ByteCodeInstruction::kDebugPrint: printf("debugprint"); break; |
| VECTOR_DISASSEMBLE(kDivideF, "dividef") |
| VECTOR_DISASSEMBLE(kDivideS, "divideS") |
| VECTOR_DISASSEMBLE(kDivideU, "divideu") |
| VECTOR_DISASSEMBLE(kDup, "dup") |
| VECTOR_DISASSEMBLE(kFloatToInt, "floattoint") |
| case ByteCodeInstruction::kLoad: printf("load %d", READ8()); break; |
| case ByteCodeInstruction::kLoad2: printf("load2 %d", READ8()); break; |
| case ByteCodeInstruction::kLoad3: printf("load3 %d", READ8()); break; |
| case ByteCodeInstruction::kLoad4: printf("load4 %d", READ8()); break; |
| case ByteCodeInstruction::kLoadGlobal: printf("loadglobal %d", READ8()); break; |
| case ByteCodeInstruction::kLoadGlobal2: printf("loadglobal2 %d", READ8()); break; |
| case ByteCodeInstruction::kLoadGlobal3: printf("loadglobal3 %d", READ8()); break; |
| case ByteCodeInstruction::kLoadGlobal4: printf("loadglobal4 %d", READ8()); break; |
| case ByteCodeInstruction::kLoadSwizzle: { |
| int target = READ8(); |
| int count = READ8(); |
| printf("loadswizzle %d %d", target, count); |
| for (int i = 0; i < count; ++i) { |
| printf(", %d", READ8()); |
| } |
| break; |
| } |
| case ByteCodeInstruction::kLoadSwizzleGlobal: { |
| int target = READ8(); |
| int count = READ8(); |
| printf("loadswizzleglobal %d %d", target, count); |
| for (int i = 0; i < count; ++i) { |
| printf(", %d", READ8()); |
| } |
| break; |
| } |
| VECTOR_DISASSEMBLE(kMultiplyF, "multiplyf") |
| VECTOR_DISASSEMBLE(kMultiplyI, "multiplyi") |
| VECTOR_DISASSEMBLE(kNegateF, "negatef") |
| VECTOR_DISASSEMBLE(kNegateS, "negates") |
| VECTOR_DISASSEMBLE(kNot, "not") |
| VECTOR_DISASSEMBLE(kOrB, "orb") |
| VECTOR_DISASSEMBLE(kOrI, "ori") |
| VECTOR_DISASSEMBLE(kPop, "pop") |
| case ByteCodeInstruction::kPushImmediate: { |
| uint32_t v = READ32(); |
| union { uint32_t u; float f; } pun = { v }; |
| printf("pushimmediate %s", (to_string(v) + "(" + to_string(pun.f) + ")").c_str()); |
| break; |
| } |
| case ByteCodeInstruction::kReadExternal: printf("readexternal %d", READ8()); break; |
| case ByteCodeInstruction::kReadExternal2: printf("readexternal2 %d", READ8()); break; |
| case ByteCodeInstruction::kReadExternal3: printf("readexternal3 %d", READ8()); break; |
| case ByteCodeInstruction::kReadExternal4: printf("readexternal4 %d", READ8()); break; |
| VECTOR_DISASSEMBLE(kRemainderF, "remainderf") |
| VECTOR_DISASSEMBLE(kRemainderS, "remainders") |
| VECTOR_DISASSEMBLE(kRemainderU, "remainderu") |
| case ByteCodeInstruction::kReturn: printf("return %d", READ8()); break; |
| VECTOR_DISASSEMBLE(kSignedToFloat, "signedtofloat") |
| case ByteCodeInstruction::kStore: printf("store %d", READ8()); break; |
| case ByteCodeInstruction::kStore2: printf("store2 %d", READ8()); break; |
| case ByteCodeInstruction::kStore3: printf("store3 %d", READ8()); break; |
| case ByteCodeInstruction::kStore4: printf("store4 %d", READ8()); break; |
| case ByteCodeInstruction::kStoreGlobal: printf("storeglobal %d", READ8()); break; |
| case ByteCodeInstruction::kStoreGlobal2: printf("storeglobal2 %d", READ8()); break; |
| case ByteCodeInstruction::kStoreGlobal3: printf("storeglobal3 %d", READ8()); break; |
| case ByteCodeInstruction::kStoreGlobal4: printf("storeglobal4 %d", READ8()); break; |
| case ByteCodeInstruction::kStoreSwizzle: { |
| int target = READ8(); |
| int count = READ8(); |
| printf("storeswizzle %d %d", target, count); |
| for (int i = 0; i < count; ++i) { |
| printf(", %d", READ8()); |
| } |
| break; |
| } |
| case ByteCodeInstruction::kStoreSwizzleGlobal: { |
| int target = READ8(); |
| int count = READ8(); |
| printf("storeswizzleglobal %d %d", target, count); |
| for (int i = 0; i < count; ++i) { |
| printf(", %d", READ8()); |
| } |
| break; |
| } |
| VECTOR_DISASSEMBLE(kSubtractF, "subtractf") |
| VECTOR_DISASSEMBLE(kSubtractI, "subtracti") |
| case ByteCodeInstruction::kSwizzle: { |
| printf("swizzle %d, ", READ8()); |
| int count = READ8(); |
| printf("%d", count); |
| for (int i = 0; i < count; ++i) { |
| printf(", %d", READ8()); |
| } |
| break; |
| } |
| VECTOR_DISASSEMBLE(kUnsignedToFloat, "unsignedtofloat") |
| case ByteCodeInstruction::kWriteExternal: printf("writeexternal %d", READ8()); break; |
| case ByteCodeInstruction::kWriteExternal2: printf("writeexternal2 %d", READ8()); break; |
| case ByteCodeInstruction::kWriteExternal3: printf("writeexternal3 %d", READ8()); break; |
| case ByteCodeInstruction::kWriteExternal4: printf("writeexternal4 %d", READ8()); break; |
| default: printf("unknown(%d)\n", *(ip - 1)); SkASSERT(false); |
| } |
| printf("\n"); |
| } |
| } |
| |
| #define VECTOR_BINARY_OP(base, type, src, target, op) \ |
| case ByteCodeInstruction::base ## 4: \ |
| sp[-4].target = sp[-4].src op sp[0].src; \ |
| POP(); \ |
| /* fall through */ \ |
| case ByteCodeInstruction::base ## 3: { \ |
| int count = (int) ByteCodeInstruction::base - (int) inst - 1; \ |
| sp[count].target = sp[count].src op sp[0].src; \ |
| POP(); \ |
| } /* fall through */ \ |
| case ByteCodeInstruction::base ## 2: { \ |
| int count = (int) ByteCodeInstruction::base - (int) inst - 1; \ |
| sp[count].target = sp[count].src op sp[0].src; \ |
| POP(); \ |
| } /* fall through */ \ |
| case ByteCodeInstruction::base: { \ |
| int count = (int) ByteCodeInstruction::base - (int) inst - 1; \ |
| sp[count].target = sp[count].src op sp[0].src; \ |
| POP(); \ |
| break; \ |
| } |
| |
| #define VECTOR_BINARY_FN(base, type, src, target, fn) \ |
| case ByteCodeInstruction::base ## 4: \ |
| sp[-4].target = fn(sp[-4].src, sp[0].src); \ |
| POP(); \ |
| /* fall through */ \ |
| case ByteCodeInstruction::base ## 3: { \ |
| int count = (int) ByteCodeInstruction::base - (int) inst - 1; \ |
| sp[count].target = fn(sp[count].src, sp[0].src); \ |
| POP(); \ |
| } /* fall through */ \ |
| case ByteCodeInstruction::base ## 2: { \ |
| int count = (int) ByteCodeInstruction::base - (int) inst - 1; \ |
| sp[count].target = fn(sp[count].src, sp[0].src); \ |
| POP(); \ |
| } /* fall through */ \ |
| case ByteCodeInstruction::base: { \ |
| int count = (int) ByteCodeInstruction::base - (int) inst - 1; \ |
| sp[count].target = fn(sp[count].src, sp[0].src); \ |
| POP(); \ |
| break; \ |
| } |
| |
| struct StackFrame { |
| const uint8_t* fCode; |
| const uint8_t* fIP; |
| Interpreter::Value* fStack; |
| }; |
| |
| void Interpreter::innerRun(const ByteCodeFunction& f, Value* stack, Value* outReturn) { |
| Value* sp = stack + f.fParameterCount + f.fLocalCount - 1; |
| |
| auto POP = [&] { SkASSERT(sp >= stack); return *(sp--); }; |
| auto PUSH = [&](Value v) { SkASSERT(sp + 1 >= stack); *(++sp) = v; }; |
| |
| const uint8_t* code = f.fCode.data(); |
| const uint8_t* ip = code; |
| std::vector<StackFrame> frames; |
| |
| for (;;) { |
| ByteCodeInstruction inst = (ByteCodeInstruction) READ8(); |
| #ifdef TRACE |
| printf("at %d\n", (int) (ip - code - 1)); |
| #endif |
| switch (inst) { |
| VECTOR_BINARY_OP(kAddI, int32_t, fSigned, fSigned, +) |
| VECTOR_BINARY_OP(kAddF, float, fFloat, fFloat, +) |
| case ByteCodeInstruction::kBranch: |
| ip = code + READ16(); |
| break; |
| case ByteCodeInstruction::kCall: { |
| // Precursor code has pushed all parameters to the stack. Update our bottom of |
| // stack to point at the first parameter, and our sp to point past those parameters |
| // (plus space for locals). |
| int target = READ8(); |
| const ByteCodeFunction* fun = fByteCode->fFunctions[target].get(); |
| frames.push_back({ code, ip, stack }); |
| ip = code = fun->fCode.data(); |
| stack = sp - fun->fParameterCount + 1; |
| sp = stack + fun->fParameterCount + fun->fLocalCount - 1; |
| break; |
| } |
| case ByteCodeInstruction::kCallExternal: { |
| int argumentCount = READ8(); |
| int returnCount = READ8(); |
| int target = READ8(); |
| ExternalValue* v = fByteCode->fExternalValues[target]; |
| sp -= argumentCount - 1; |
| |
| Value tmp[4]; |
| SkASSERT(returnCount <= (int)SK_ARRAY_COUNT(tmp)); |
| v->call(sp, tmp); |
| memcpy(sp, tmp, returnCount * sizeof(Value)); |
| sp += returnCount - 1; |
| break; |
| } |
| VECTOR_BINARY_OP(kCompareIEQ, int32_t, fSigned, fBool, ==) |
| VECTOR_BINARY_OP(kCompareFEQ, float, fFloat, fBool, ==) |
| VECTOR_BINARY_OP(kCompareINEQ, int32_t, fSigned, fBool, !=) |
| VECTOR_BINARY_OP(kCompareFNEQ, float, fFloat, fBool, !=) |
| VECTOR_BINARY_OP(kCompareSGT, int32_t, fSigned, fBool, >) |
| VECTOR_BINARY_OP(kCompareUGT, uint32_t, fUnsigned, fBool, >) |
| VECTOR_BINARY_OP(kCompareFGT, float, fFloat, fBool, >) |
| VECTOR_BINARY_OP(kCompareSGTEQ, int32_t, fSigned, fBool, >=) |
| VECTOR_BINARY_OP(kCompareUGTEQ, uint32_t, fUnsigned, fBool, >=) |
| VECTOR_BINARY_OP(kCompareFGTEQ, float, fFloat, fBool, >=) |
| VECTOR_BINARY_OP(kCompareSLT, int32_t, fSigned, fBool, <) |
| VECTOR_BINARY_OP(kCompareULT, uint32_t, fUnsigned, fBool, <) |
| VECTOR_BINARY_OP(kCompareFLT, float, fFloat, fBool, <) |
| VECTOR_BINARY_OP(kCompareSLTEQ, int32_t, fSigned, fBool, <=) |
| VECTOR_BINARY_OP(kCompareULTEQ, uint32_t, fUnsigned, fBool, <=) |
| VECTOR_BINARY_OP(kCompareFLTEQ, float, fFloat, fBool, <=) |
| case ByteCodeInstruction::kConditionalBranch: { |
| int target = READ16(); |
| if (POP().fBool) { |
| ip = code + target; |
| } |
| break; |
| } |
| case ByteCodeInstruction::kDebugPrint: { |
| Value v = POP(); |
| printf("Debug: %d(int), %d(uint), %f(float)\n", v.fSigned, v.fUnsigned, v.fFloat); |
| break; |
| } |
| VECTOR_BINARY_OP(kDivideS, int32_t, fSigned, fSigned, /) |
| VECTOR_BINARY_OP(kDivideU, uint32_t, fUnsigned, fUnsigned, /) |
| VECTOR_BINARY_OP(kDivideF, float, fFloat, fFloat, /) |
| |
| case ByteCodeInstruction::kDup4: PUSH(sp[(int)ByteCodeInstruction::kDup - (int)inst]); |
| case ByteCodeInstruction::kDup3: PUSH(sp[(int)ByteCodeInstruction::kDup - (int)inst]); |
| case ByteCodeInstruction::kDup2: PUSH(sp[(int)ByteCodeInstruction::kDup - (int)inst]); |
| case ByteCodeInstruction::kDup : PUSH(sp[(int)ByteCodeInstruction::kDup - (int)inst]); |
| break; |
| |
| case ByteCodeInstruction::kFloatToInt4: sp[-3].fSigned = (int)sp[-3].fFloat; |
| case ByteCodeInstruction::kFloatToInt3: sp[-2].fSigned = (int)sp[-2].fFloat; |
| case ByteCodeInstruction::kFloatToInt2: sp[-1].fSigned = (int)sp[-1].fFloat; |
| case ByteCodeInstruction::kFloatToInt: sp[ 0].fSigned = (int)sp[ 0].fFloat; |
| break; |
| |
| case ByteCodeInstruction::kSignedToFloat4: sp[-3].fFloat = sp[-3].fSigned; |
| case ByteCodeInstruction::kSignedToFloat3: sp[-2].fFloat = sp[-2].fSigned; |
| case ByteCodeInstruction::kSignedToFloat2: sp[-1].fFloat = sp[-1].fSigned; |
| case ByteCodeInstruction::kSignedToFloat : sp[ 0].fFloat = sp[ 0].fSigned; |
| break; |
| |
| case ByteCodeInstruction::kUnsignedToFloat4: sp[-3].fFloat = sp[-3].fUnsigned; |
| case ByteCodeInstruction::kUnsignedToFloat3: sp[-2].fFloat = sp[-2].fUnsigned; |
| case ByteCodeInstruction::kUnsignedToFloat2: sp[-1].fFloat = sp[-1].fUnsigned; |
| case ByteCodeInstruction::kUnsignedToFloat : sp[ 0].fFloat = sp[ 0].fUnsigned; |
| break; |
| |
| case ByteCodeInstruction::kLoad4: sp[4] = stack[*ip + 3]; |
| case ByteCodeInstruction::kLoad3: sp[3] = stack[*ip + 2]; |
| case ByteCodeInstruction::kLoad2: sp[2] = stack[*ip + 1]; |
| case ByteCodeInstruction::kLoad : sp[1] = stack[*ip + 0]; |
| ++ip; |
| sp += (int)inst - (int)ByteCodeInstruction::kLoad + 1; |
| break; |
| |
| case ByteCodeInstruction::kLoadGlobal4: sp[4] = fGlobals[*ip + 3]; |
| case ByteCodeInstruction::kLoadGlobal3: sp[3] = fGlobals[*ip + 2]; |
| case ByteCodeInstruction::kLoadGlobal2: sp[2] = fGlobals[*ip + 1]; |
| case ByteCodeInstruction::kLoadGlobal : sp[1] = fGlobals[*ip + 0]; |
| ++ip; |
| sp += (int)inst - (int)ByteCodeInstruction::kLoadGlobal + 1; |
| break; |
| |
| case ByteCodeInstruction::kLoadSwizzle: { |
| int src = READ8(); |
| int count = READ8(); |
| for (int i = 0; i < count; ++i) { |
| PUSH(stack[src + *(ip + i)]); |
| } |
| ip += count; |
| break; |
| } |
| case ByteCodeInstruction::kLoadSwizzleGlobal: { |
| int src = READ8(); |
| SkASSERT(src < (int) fGlobals.size()); |
| int count = READ8(); |
| for (int i = 0; i < count; ++i) { |
| PUSH(fGlobals[src + *(ip + i)]); |
| } |
| ip += count; |
| break; |
| } |
| VECTOR_BINARY_OP(kMultiplyI, int32_t, fSigned, fSigned, *) |
| VECTOR_BINARY_OP(kMultiplyF, float, fFloat, fFloat, *) |
| case ByteCodeInstruction::kNot: |
| sp[0].fBool = !sp[0].fBool; |
| break; |
| |
| case ByteCodeInstruction::kNegateF4: sp[-3].fFloat = -sp[-3].fFloat; |
| case ByteCodeInstruction::kNegateF3: sp[-2].fFloat = -sp[-2].fFloat; |
| case ByteCodeInstruction::kNegateF2: sp[-1].fFloat = -sp[-1].fFloat; |
| case ByteCodeInstruction::kNegateF : sp[ 0].fFloat = -sp[ 0].fFloat; |
| break; |
| |
| case ByteCodeInstruction::kNegateS4: sp[-3].fSigned = -sp[-3].fSigned; |
| case ByteCodeInstruction::kNegateS3: sp[-2].fSigned = -sp[-2].fSigned; |
| case ByteCodeInstruction::kNegateS2: sp[-1].fSigned = -sp[-1].fSigned; |
| case ByteCodeInstruction::kNegateS : sp[ 0].fSigned = -sp [0].fSigned; |
| break; |
| |
| case ByteCodeInstruction::kPop4: POP(); |
| case ByteCodeInstruction::kPop3: POP(); |
| case ByteCodeInstruction::kPop2: POP(); |
| case ByteCodeInstruction::kPop : POP(); |
| break; |
| |
| case ByteCodeInstruction::kPushImmediate: |
| PUSH(READ32()); |
| break; |
| case ByteCodeInstruction::kReadExternal: // fall through |
| case ByteCodeInstruction::kReadExternal2: // fall through |
| case ByteCodeInstruction::kReadExternal3: // fall through |
| case ByteCodeInstruction::kReadExternal4: { |
| int src = READ8(); |
| fByteCode->fExternalValues[src]->read(sp + 1); |
| sp += (int) inst - (int) ByteCodeInstruction::kReadExternal + 1; |
| break; |
| } |
| VECTOR_BINARY_FN(kRemainderF, int32_t, fFloat, fFloat, fmodf) |
| VECTOR_BINARY_OP(kRemainderS, int32_t, fSigned, fSigned, %) |
| VECTOR_BINARY_OP(kRemainderU, uint32_t, fUnsigned, fUnsigned, %) |
| case ByteCodeInstruction::kReturn: { |
| int count = READ8(); |
| if (frames.empty()) { |
| if (outReturn) { |
| memcpy(outReturn, sp - count + 1, count * sizeof(Value)); |
| } |
| return; |
| } else { |
| // When we were called, 'stack' was positioned at the old top-of-stack (where |
| // our parameters were placed). So copy our return values to that same spot. |
| memmove(stack, sp - count + 1, count * sizeof(Value)); |
| |
| // Now move the stack pointer to the end of the just-pushed return values, |
| // and restore everything else. |
| const StackFrame& frame(frames.back()); |
| sp = stack + count - 1; |
| stack = frame.fStack; |
| code = frame.fCode; |
| ip = frame.fIP; |
| frames.pop_back(); |
| break; |
| } |
| } |
| |
| case ByteCodeInstruction::kStore4: stack[*ip + 3] = POP(); |
| case ByteCodeInstruction::kStore3: stack[*ip + 2] = POP(); |
| case ByteCodeInstruction::kStore2: stack[*ip + 1] = POP(); |
| case ByteCodeInstruction::kStore : stack[*ip + 0] = POP(); |
| ++ip; |
| break; |
| |
| case ByteCodeInstruction::kStoreGlobal4: fGlobals[*ip + 3] = POP(); |
| case ByteCodeInstruction::kStoreGlobal3: fGlobals[*ip + 2] = POP(); |
| case ByteCodeInstruction::kStoreGlobal2: fGlobals[*ip + 1] = POP(); |
| case ByteCodeInstruction::kStoreGlobal : fGlobals[*ip + 0] = POP(); |
| ++ip; |
| break; |
| |
| case ByteCodeInstruction::kStoreSwizzle: { |
| int target = READ8(); |
| int count = READ8(); |
| for (int i = count - 1; i >= 0; --i) { |
| stack[target + *(ip + i)] = POP(); |
| } |
| ip += count; |
| break; |
| } |
| case ByteCodeInstruction::kStoreSwizzleGlobal: { |
| int target = READ8(); |
| int count = READ8(); |
| for (int i = count - 1; i >= 0; --i) { |
| fGlobals[target + *(ip + i)] = POP(); |
| } |
| ip += count; |
| break; |
| } |
| VECTOR_BINARY_OP(kSubtractI, int32_t, fSigned, fSigned, -) |
| VECTOR_BINARY_OP(kSubtractF, float, fFloat, fFloat, -) |
| case ByteCodeInstruction::kSwizzle: { |
| Value tmp[4]; |
| for (int i = READ8() - 1; i >= 0; --i) { |
| tmp[i] = POP(); |
| } |
| for (int i = READ8() - 1; i >= 0; --i) { |
| PUSH(tmp[READ8()]); |
| } |
| break; |
| } |
| case ByteCodeInstruction::kWriteExternal: // fall through |
| case ByteCodeInstruction::kWriteExternal2: // fall through |
| case ByteCodeInstruction::kWriteExternal3: // fall through |
| case ByteCodeInstruction::kWriteExternal4: { |
| int count = (int) inst - (int) ByteCodeInstruction::kWriteExternal + 1; |
| int target = READ8(); |
| fByteCode->fExternalValues[target]->write(sp - count + 1); |
| sp -= count; |
| break; |
| } |
| default: |
| SkDEBUGFAILF("unsupported instruction %d\n", (int) inst); |
| } |
| #ifdef TRACE |
| int stackSize = (int) (sp - stack + 1); |
| printf("STACK(%d):", stackSize); |
| for (int i = 0; i < stackSize(); ++i) { |
| printf(" %d(%f)", stack[i].fSigned, stack[i].fFloat); |
| } |
| printf("\n"); |
| #endif |
| } |
| } |
| |
| } // namespace |
| |
| #endif |