| /* |
| * 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 |
| |
| #ifdef SK_LLVM_AVAILABLE |
| |
| #include "SkSLJIT.h" |
| |
| #include "SkCpu.h" |
| #include "SkRasterPipeline.h" |
| #include "ir/SkSLAppendStage.h" |
| #include "ir/SkSLExpressionStatement.h" |
| #include "ir/SkSLFunctionCall.h" |
| #include "ir/SkSLFunctionReference.h" |
| #include "ir/SkSLIndexExpression.h" |
| #include "ir/SkSLProgram.h" |
| #include "ir/SkSLUnresolvedFunction.h" |
| #include "llvm/ExecutionEngine/RTDyldMemoryManager.h" |
| |
| static constexpr int MAX_VECTOR_COUNT = 16; |
| |
| extern "C" void sksl_pipeline_append(SkRasterPipeline* p, int stage, void* ctx) { |
| p->append((SkRasterPipeline::StockStage) stage, ctx); |
| } |
| |
| #define PTR_SIZE sizeof(void*) |
| |
| extern "C" void sksl_pipeline_append_callback(SkRasterPipeline* p, void* fn) { |
| p->append(fn, nullptr); |
| } |
| |
| extern "C" void sksl_debug_print(float f) { |
| printf("Debug: %f\n", f); |
| } |
| |
| extern "C" float sksl_clamp1(float f, float min, float max) { |
| return SkTPin(f, min, max); |
| } |
| |
| using float2 = __attribute__((vector_size(8))) float; |
| using float3 = __attribute__((vector_size(16))) float; |
| using float4 = __attribute__((vector_size(16))) float; |
| |
| extern "C" float2 sksl_clamp2(float2 f, float min, float max) { |
| return float2 { SkTPin(f[0], min, max), SkTPin(f[1], min, max) }; |
| } |
| |
| extern "C" float3 sksl_clamp3(float3 f, float min, float max) { |
| return float3 { SkTPin(f[0], min, max), SkTPin(f[1], min, max), SkTPin(f[2], min, max) }; |
| } |
| |
| extern "C" float4 sksl_clamp4(float4 f, float min, float max) { |
| return float4 { SkTPin(f[0], min, max), SkTPin(f[1], min, max), SkTPin(f[2], min, max), |
| SkTPin(f[3], min, max) }; |
| } |
| |
| namespace SkSL { |
| |
| static constexpr int STAGE_PARAM_COUNT = 12; |
| |
| static bool ends_with_branch(const Statement& stmt) { |
| switch (stmt.fKind) { |
| case Statement::kBlock_Kind: { |
| const Block& b = (const Block&) stmt; |
| if (b.fStatements.size()) { |
| return ends_with_branch(*b.fStatements.back()); |
| } |
| return false; |
| } |
| case Statement::kBreak_Kind: // fall through |
| case Statement::kContinue_Kind: // fall through |
| case Statement::kReturn_Kind: // fall through |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| JIT::JIT(Compiler* compiler) |
| : fCompiler(*compiler) { |
| LLVMInitializeNativeTarget(); |
| LLVMInitializeNativeAsmPrinter(); |
| LLVMLinkInMCJIT(); |
| SkASSERT(!SkCpu::Supports(SkCpu::SKX)); // not yet supported |
| if (SkCpu::Supports(SkCpu::HSW)) { |
| fVectorCount = 8; |
| fCPU = "haswell"; |
| } else if (SkCpu::Supports(SkCpu::AVX)) { |
| fVectorCount = 8; |
| fCPU = "ivybridge"; |
| } else { |
| fVectorCount = 4; |
| fCPU = nullptr; |
| } |
| fContext = LLVMContextCreate(); |
| fVoidType = LLVMVoidTypeInContext(fContext); |
| fInt1Type = LLVMInt1TypeInContext(fContext); |
| fInt1VectorType = LLVMVectorType(fInt1Type, fVectorCount); |
| fInt1Vector2Type = LLVMVectorType(fInt1Type, 2); |
| fInt1Vector3Type = LLVMVectorType(fInt1Type, 3); |
| fInt1Vector4Type = LLVMVectorType(fInt1Type, 4); |
| fInt8Type = LLVMInt8TypeInContext(fContext); |
| fInt8PtrType = LLVMPointerType(fInt8Type, 0); |
| fInt32Type = LLVMInt32TypeInContext(fContext); |
| fInt64Type = LLVMInt64TypeInContext(fContext); |
| fSizeTType = LLVMInt64TypeInContext(fContext); |
| fInt32VectorType = LLVMVectorType(fInt32Type, fVectorCount); |
| fInt32Vector2Type = LLVMVectorType(fInt32Type, 2); |
| fInt32Vector3Type = LLVMVectorType(fInt32Type, 3); |
| fInt32Vector4Type = LLVMVectorType(fInt32Type, 4); |
| fFloat32Type = LLVMFloatTypeInContext(fContext); |
| fFloat32VectorType = LLVMVectorType(fFloat32Type, fVectorCount); |
| fFloat32Vector2Type = LLVMVectorType(fFloat32Type, 2); |
| fFloat32Vector3Type = LLVMVectorType(fFloat32Type, 3); |
| fFloat32Vector4Type = LLVMVectorType(fFloat32Type, 4); |
| } |
| |
| JIT::~JIT() { |
| LLVMOrcDisposeInstance(fJITStack); |
| LLVMContextDispose(fContext); |
| } |
| |
| void JIT::addBuiltinFunction(const char* ourName, const char* realName, LLVMTypeRef returnType, |
| std::vector<LLVMTypeRef> parameters) { |
| bool found = false; |
| for (const auto& pair : *fProgram->fSymbols) { |
| if (Symbol::kFunctionDeclaration_Kind == pair.second->fKind) { |
| const FunctionDeclaration& f = (const FunctionDeclaration&) *pair.second; |
| if (pair.first != ourName || returnType != this->getType(f.fReturnType) || |
| parameters.size() != f.fParameters.size()) { |
| continue; |
| } |
| for (size_t i = 0; i < parameters.size(); ++i) { |
| if (parameters[i] != this->getType(f.fParameters[i]->fType)) { |
| goto next; |
| } |
| } |
| fFunctions[&f] = LLVMAddFunction(fModule, realName, LLVMFunctionType(returnType, |
| parameters.data(), |
| parameters.size(), |
| false)); |
| found = true; |
| } |
| if (Symbol::kUnresolvedFunction_Kind == pair.second->fKind) { |
| // FIXME consolidate this with the code above |
| for (const auto& f : ((const UnresolvedFunction&) *pair.second).fFunctions) { |
| if (pair.first != ourName || returnType != this->getType(f->fReturnType) || |
| parameters.size() != f->fParameters.size()) { |
| continue; |
| } |
| for (size_t i = 0; i < parameters.size(); ++i) { |
| if (parameters[i] != this->getType(f->fParameters[i]->fType)) { |
| goto next; |
| } |
| } |
| fFunctions[f] = LLVMAddFunction(fModule, realName, LLVMFunctionType( |
| returnType, |
| parameters.data(), |
| parameters.size(), |
| false)); |
| found = true; |
| } |
| } |
| next:; |
| } |
| SkASSERT(found); |
| } |
| |
| void JIT::loadBuiltinFunctions() { |
| this->addBuiltinFunction("abs", "fabs", fFloat32Type, { fFloat32Type }); |
| this->addBuiltinFunction("sin", "sinf", fFloat32Type, { fFloat32Type }); |
| this->addBuiltinFunction("cos", "cosf", fFloat32Type, { fFloat32Type }); |
| this->addBuiltinFunction("tan", "tanf", fFloat32Type, { fFloat32Type }); |
| this->addBuiltinFunction("sqrt", "sqrtf", fFloat32Type, { fFloat32Type }); |
| this->addBuiltinFunction("clamp", "sksl_clamp1", fFloat32Type, { fFloat32Type, |
| fFloat32Type, |
| fFloat32Type }); |
| this->addBuiltinFunction("clamp", "sksl_clamp2", fFloat32Vector2Type, { fFloat32Vector2Type, |
| fFloat32Type, |
| fFloat32Type }); |
| this->addBuiltinFunction("clamp", "sksl_clamp3", fFloat32Vector3Type, { fFloat32Vector3Type, |
| fFloat32Type, |
| fFloat32Type }); |
| this->addBuiltinFunction("clamp", "sksl_clamp4", fFloat32Vector4Type, { fFloat32Vector4Type, |
| fFloat32Type, |
| fFloat32Type }); |
| this->addBuiltinFunction("print", "sksl_debug_print", fVoidType, { fFloat32Type }); |
| } |
| |
| uint64_t JIT::resolveSymbol(const char* name, JIT* jit) { |
| LLVMOrcTargetAddress result; |
| if (!LLVMOrcGetSymbolAddress(jit->fJITStack, &result, name)) { |
| if (!strcmp(name, "_sksl_pipeline_append")) { |
| result = (uint64_t) &sksl_pipeline_append; |
| } else if (!strcmp(name, "_sksl_pipeline_append_callback")) { |
| result = (uint64_t) &sksl_pipeline_append_callback; |
| } else if (!strcmp(name, "_sksl_clamp1")) { |
| result = (uint64_t) &sksl_clamp1; |
| } else if (!strcmp(name, "_sksl_clamp2")) { |
| result = (uint64_t) &sksl_clamp2; |
| } else if (!strcmp(name, "_sksl_clamp3")) { |
| result = (uint64_t) &sksl_clamp3; |
| } else if (!strcmp(name, "_sksl_clamp4")) { |
| result = (uint64_t) &sksl_clamp4; |
| } else if (!strcmp(name, "_sksl_debug_print")) { |
| result = (uint64_t) &sksl_debug_print; |
| } else { |
| result = llvm::RTDyldMemoryManager::getSymbolAddressInProcess(name); |
| } |
| } |
| SkASSERT(result); |
| return result; |
| } |
| |
| LLVMValueRef JIT::compileFunctionCall(LLVMBuilderRef builder, const FunctionCall& fc) { |
| LLVMValueRef func = fFunctions[&fc.fFunction]; |
| SkASSERT(func); |
| std::vector<LLVMValueRef> parameters; |
| for (const auto& a : fc.fArguments) { |
| parameters.push_back(this->compileExpression(builder, *a)); |
| } |
| return LLVMBuildCall(builder, func, parameters.data(), parameters.size(), ""); |
| } |
| |
| LLVMTypeRef JIT::getType(const Type& type) { |
| switch (type.kind()) { |
| case Type::kOther_Kind: |
| if (type.name() == "void") { |
| return fVoidType; |
| } |
| SkASSERT(type.name() == "SkRasterPipeline"); |
| return fInt8PtrType; |
| case Type::kScalar_Kind: |
| if (type.isSigned() || type.isUnsigned()) { |
| return fInt32Type; |
| } |
| if (type.isUnsigned()) { |
| return fInt32Type; |
| } |
| if (type.isFloat()) { |
| return fFloat32Type; |
| } |
| SkASSERT(type.name() == "bool"); |
| return fInt1Type; |
| case Type::kArray_Kind: |
| return LLVMPointerType(this->getType(type.componentType()), 0); |
| case Type::kVector_Kind: |
| if (type.name() == "float2" || type.name() == "half2") { |
| return fFloat32Vector2Type; |
| } |
| if (type.name() == "float3" || type.name() == "half3") { |
| return fFloat32Vector3Type; |
| } |
| if (type.name() == "float4" || type.name() == "half4") { |
| return fFloat32Vector4Type; |
| } |
| if (type.name() == "int2" || type.name() == "short2" || type.name == "byte2") { |
| return fInt32Vector2Type; |
| } |
| if (type.name() == "int3" || type.name() == "short3" || type.name == "byte3") { |
| return fInt32Vector3Type; |
| } |
| if (type.name() == "int4" || type.name() == "short4" || type.name == "byte3") { |
| return fInt32Vector4Type; |
| } |
| // fall through |
| default: |
| ABORT("unsupported type"); |
| } |
| } |
| |
| void JIT::setBlock(LLVMBuilderRef builder, LLVMBasicBlockRef block) { |
| fCurrentBlock = block; |
| LLVMPositionBuilderAtEnd(builder, block); |
| } |
| |
| std::unique_ptr<JIT::LValue> JIT::getLValue(LLVMBuilderRef builder, const Expression& expr) { |
| switch (expr.fKind) { |
| case Expression::kVariableReference_Kind: { |
| class PointerLValue : public LValue { |
| public: |
| PointerLValue(LLVMValueRef ptr) |
| : fPointer(ptr) {} |
| |
| LLVMValueRef load(LLVMBuilderRef builder) override { |
| return LLVMBuildLoad(builder, fPointer, "lvalue load"); |
| } |
| |
| void store(LLVMBuilderRef builder, LLVMValueRef value) override { |
| LLVMBuildStore(builder, value, fPointer); |
| } |
| |
| private: |
| LLVMValueRef fPointer; |
| }; |
| const Variable* var = &((VariableReference&) expr).fVariable; |
| if (var->fStorage == Variable::kParameter_Storage && |
| !(var->fModifiers.fFlags & Modifiers::kOut_Flag) && |
| fPromotedParameters.find(var) == fPromotedParameters.end()) { |
| // promote parameter to variable |
| fPromotedParameters.insert(var); |
| LLVMPositionBuilderAtEnd(builder, fAllocaBlock); |
| LLVMValueRef alloca = LLVMBuildAlloca(builder, this->getType(var->fType), |
| String(var->fName).c_str()); |
| LLVMBuildStore(builder, fVariables[var], alloca); |
| LLVMPositionBuilderAtEnd(builder, fCurrentBlock); |
| fVariables[var] = alloca; |
| } |
| LLVMValueRef ptr = fVariables[var]; |
| return std::unique_ptr<LValue>(new PointerLValue(ptr)); |
| } |
| case Expression::kTernary_Kind: { |
| class TernaryLValue : public LValue { |
| public: |
| TernaryLValue(JIT* jit, LLVMValueRef test, std::unique_ptr<LValue> ifTrue, |
| std::unique_ptr<LValue> ifFalse) |
| : fJIT(*jit) |
| , fTest(test) |
| , fIfTrue(std::move(ifTrue)) |
| , fIfFalse(std::move(ifFalse)) {} |
| |
| LLVMValueRef load(LLVMBuilderRef builder) override { |
| LLVMBasicBlockRef trueBlock = LLVMAppendBasicBlockInContext( |
| fJIT.fContext, |
| fJIT.fCurrentFunction, |
| "true ? ..."); |
| LLVMBasicBlockRef falseBlock = LLVMAppendBasicBlockInContext( |
| fJIT.fContext, |
| fJIT.fCurrentFunction, |
| "false ? ..."); |
| LLVMBasicBlockRef merge = LLVMAppendBasicBlockInContext(fJIT.fContext, |
| fJIT.fCurrentFunction, |
| "ternary merge"); |
| LLVMBuildCondBr(builder, fTest, trueBlock, falseBlock); |
| fJIT.setBlock(builder, trueBlock); |
| LLVMValueRef ifTrue = fIfTrue->load(builder); |
| LLVMBuildBr(builder, merge); |
| fJIT.setBlock(builder, falseBlock); |
| LLVMValueRef ifFalse = fIfTrue->load(builder); |
| LLVMBuildBr(builder, merge); |
| fJIT.setBlock(builder, merge); |
| LLVMTypeRef type = LLVMPointerType(LLVMTypeOf(ifTrue), 0); |
| LLVMValueRef phi = LLVMBuildPhi(builder, type, "?"); |
| LLVMValueRef incomingValues[2] = { ifTrue, ifFalse }; |
| LLVMBasicBlockRef incomingBlocks[2] = { trueBlock, falseBlock }; |
| LLVMAddIncoming(phi, incomingValues, incomingBlocks, 2); |
| return phi; |
| } |
| |
| void store(LLVMBuilderRef builder, LLVMValueRef value) override { |
| LLVMBasicBlockRef trueBlock = LLVMAppendBasicBlockInContext( |
| fJIT.fContext, |
| fJIT.fCurrentFunction, |
| "true ? ..."); |
| LLVMBasicBlockRef falseBlock = LLVMAppendBasicBlockInContext( |
| fJIT.fContext, |
| fJIT.fCurrentFunction, |
| "false ? ..."); |
| LLVMBasicBlockRef merge = LLVMAppendBasicBlockInContext(fJIT.fContext, |
| fJIT.fCurrentFunction, |
| "ternary merge"); |
| LLVMBuildCondBr(builder, fTest, trueBlock, falseBlock); |
| fJIT.setBlock(builder, trueBlock); |
| fIfTrue->store(builder, value); |
| LLVMBuildBr(builder, merge); |
| fJIT.setBlock(builder, falseBlock); |
| fIfTrue->store(builder, value); |
| LLVMBuildBr(builder, merge); |
| fJIT.setBlock(builder, merge); |
| } |
| |
| private: |
| JIT& fJIT; |
| LLVMValueRef fTest; |
| std::unique_ptr<LValue> fIfTrue; |
| std::unique_ptr<LValue> fIfFalse; |
| }; |
| const TernaryExpression& t = (const TernaryExpression&) expr; |
| LLVMValueRef test = this->compileExpression(builder, *t.fTest); |
| return std::unique_ptr<LValue>(new TernaryLValue(this, |
| test, |
| this->getLValue(builder, |
| *t.fIfTrue), |
| this->getLValue(builder, |
| *t.fIfFalse))); |
| } |
| case Expression::kSwizzle_Kind: { |
| class SwizzleLValue : public LValue { |
| public: |
| SwizzleLValue(JIT* jit, LLVMTypeRef type, std::unique_ptr<LValue> base, |
| std::vector<int> components) |
| : fJIT(*jit) |
| , fType(type) |
| , fBase(std::move(base)) |
| , fComponents(components) {} |
| |
| LLVMValueRef load(LLVMBuilderRef builder) override { |
| LLVMValueRef base = fBase->load(builder); |
| if (fComponents.size() > 1) { |
| LLVMValueRef result = LLVMGetUndef(fType); |
| for (size_t i = 0; i < fComponents.size(); ++i) { |
| LLVMValueRef element = LLVMBuildExtractElement( |
| builder, |
| base, |
| LLVMConstInt(fJIT.fInt32Type, |
| fComponents[i], |
| false), |
| "swizzle extract"); |
| result = LLVMBuildInsertElement(builder, result, element, |
| LLVMConstInt(fJIT.fInt32Type, i, false), |
| "swizzle insert"); |
| } |
| return result; |
| } |
| SkASSERT(fComponents.size() == 1); |
| return LLVMBuildExtractElement(builder, base, |
| LLVMConstInt(fJIT.fInt32Type, |
| fComponents[0], |
| false), |
| "swizzle extract"); |
| } |
| |
| void store(LLVMBuilderRef builder, LLVMValueRef value) override { |
| LLVMValueRef result = fBase->load(builder); |
| if (fComponents.size() > 1) { |
| for (size_t i = 0; i < fComponents.size(); ++i) { |
| LLVMValueRef element = LLVMBuildExtractElement(builder, value, |
| LLVMConstInt( |
| fJIT.fInt32Type, |
| i, |
| false), |
| "swizzle extract"); |
| result = LLVMBuildInsertElement(builder, result, element, |
| LLVMConstInt(fJIT.fInt32Type, |
| fComponents[i], |
| false), |
| "swizzle insert"); |
| } |
| } else { |
| result = LLVMBuildInsertElement(builder, result, value, |
| LLVMConstInt(fJIT.fInt32Type, |
| fComponents[0], |
| false), |
| "swizzle insert"); |
| } |
| fBase->store(builder, result); |
| } |
| |
| private: |
| JIT& fJIT; |
| LLVMTypeRef fType; |
| std::unique_ptr<LValue> fBase; |
| std::vector<int> fComponents; |
| }; |
| const Swizzle& s = (const Swizzle&) expr; |
| return std::unique_ptr<LValue>(new SwizzleLValue(this, this->getType(s.fType), |
| this->getLValue(builder, *s.fBase), |
| s.fComponents)); |
| } |
| default: |
| ABORT("unsupported lvalue"); |
| } |
| } |
| |
| JIT::TypeKind JIT::typeKind(const Type& type) { |
| if (type.kind() == Type::kVector_Kind) { |
| return this->typeKind(type.componentType()); |
| } |
| if (type.fName == "int" || type.fName == "short" || type.fName == "byte") { |
| return JIT::kInt_TypeKind; |
| } else if (type.fName == "uint" || type.fName == "ushort" || type.fName == "ubyte") { |
| return JIT::kUInt_TypeKind; |
| } else if (type.fName == "float" || type.fName == "double" || type.fName == "half") { |
| return JIT::kFloat_TypeKind; |
| } |
| ABORT("unsupported type: %s\n", type.description().c_str()); |
| } |
| |
| void JIT::vectorize(LLVMBuilderRef builder, LLVMValueRef* value, int columns) { |
| LLVMValueRef result = LLVMGetUndef(LLVMVectorType(LLVMTypeOf(*value), columns)); |
| for (int i = 0; i < columns; ++i) { |
| result = LLVMBuildInsertElement(builder, |
| result, |
| *value, |
| LLVMConstInt(fInt32Type, i, false), |
| "vectorize"); |
| } |
| *value = result; |
| } |
| |
| void JIT::vectorize(LLVMBuilderRef builder, const BinaryExpression& b, LLVMValueRef* left, |
| LLVMValueRef* right) { |
| if (b.fLeft->fType.kind() == Type::kScalar_Kind && |
| b.fRight->fType.kind() == Type::kVector_Kind) { |
| this->vectorize(builder, left, b.fRight->fType.columns()); |
| } else if (b.fLeft->fType.kind() == Type::kVector_Kind && |
| b.fRight->fType.kind() == Type::kScalar_Kind) { |
| this->vectorize(builder, right, b.fLeft->fType.columns()); |
| } |
| } |
| |
| |
| LLVMValueRef JIT::compileBinary(LLVMBuilderRef builder, const BinaryExpression& b) { |
| #define BINARY(SFunc, UFunc, FFunc) { \ |
| LLVMValueRef left = this->compileExpression(builder, *b.fLeft); \ |
| LLVMValueRef right = this->compileExpression(builder, *b.fRight); \ |
| this->vectorize(builder, b, &left, &right); \ |
| switch (this->typeKind(b.fLeft->fType)) { \ |
| case kInt_TypeKind: \ |
| return SFunc(builder, left, right, "binary"); \ |
| case kUInt_TypeKind: \ |
| return UFunc(builder, left, right, "binary"); \ |
| case kFloat_TypeKind: \ |
| return FFunc(builder, left, right, "binary"); \ |
| default: \ |
| ABORT("unsupported typeKind"); \ |
| } \ |
| } |
| #define COMPOUND(SFunc, UFunc, FFunc) { \ |
| std::unique_ptr<LValue> lvalue = this->getLValue(builder, *b.fLeft); \ |
| LLVMValueRef left = lvalue->load(builder); \ |
| LLVMValueRef right = this->compileExpression(builder, *b.fRight); \ |
| this->vectorize(builder, b, &left, &right); \ |
| LLVMValueRef result; \ |
| switch (this->typeKind(b.fLeft->fType)) { \ |
| case kInt_TypeKind: \ |
| result = SFunc(builder, left, right, "binary"); \ |
| break; \ |
| case kUInt_TypeKind: \ |
| result = UFunc(builder, left, right, "binary"); \ |
| break; \ |
| case kFloat_TypeKind: \ |
| result = FFunc(builder, left, right, "binary"); \ |
| break; \ |
| default: \ |
| ABORT("unsupported typeKind"); \ |
| } \ |
| lvalue->store(builder, result); \ |
| return result; \ |
| } |
| #define COMPARE(SFunc, SOp, UFunc, UOp, FFunc, FOp) { \ |
| LLVMValueRef left = this->compileExpression(builder, *b.fLeft); \ |
| LLVMValueRef right = this->compileExpression(builder, *b.fRight); \ |
| this->vectorize(builder, b, &left, &right); \ |
| switch (this->typeKind(b.fLeft->fType)) { \ |
| case kInt_TypeKind: \ |
| return SFunc(builder, SOp, left, right, "binary"); \ |
| case kUInt_TypeKind: \ |
| return UFunc(builder, UOp, left, right, "binary"); \ |
| case kFloat_TypeKind: \ |
| return FFunc(builder, FOp, left, right, "binary"); \ |
| default: \ |
| ABORT("unsupported typeKind"); \ |
| } \ |
| } |
| switch (b.fOperator) { |
| case Token::EQ: { |
| std::unique_ptr<LValue> lvalue = this->getLValue(builder, *b.fLeft); |
| LLVMValueRef result = this->compileExpression(builder, *b.fRight); |
| lvalue->store(builder, result); |
| return result; |
| } |
| case Token::PLUS: |
| BINARY(LLVMBuildAdd, LLVMBuildAdd, LLVMBuildFAdd); |
| case Token::MINUS: |
| BINARY(LLVMBuildSub, LLVMBuildSub, LLVMBuildFSub); |
| case Token::STAR: |
| BINARY(LLVMBuildMul, LLVMBuildMul, LLVMBuildFMul); |
| case Token::SLASH: |
| BINARY(LLVMBuildSDiv, LLVMBuildUDiv, LLVMBuildFDiv); |
| case Token::PERCENT: |
| BINARY(LLVMBuildSRem, LLVMBuildURem, LLVMBuildSRem); |
| case Token::BITWISEAND: |
| BINARY(LLVMBuildAnd, LLVMBuildAnd, LLVMBuildAnd); |
| case Token::BITWISEOR: |
| BINARY(LLVMBuildOr, LLVMBuildOr, LLVMBuildOr); |
| case Token::SHL: |
| BINARY(LLVMBuildShl, LLVMBuildShl, LLVMBuildShl); |
| case Token::SHR: |
| BINARY(LLVMBuildAShr, LLVMBuildLShr, LLVMBuildAShr); |
| case Token::PLUSEQ: |
| COMPOUND(LLVMBuildAdd, LLVMBuildAdd, LLVMBuildFAdd); |
| case Token::MINUSEQ: |
| COMPOUND(LLVMBuildSub, LLVMBuildSub, LLVMBuildFSub); |
| case Token::STAREQ: |
| COMPOUND(LLVMBuildMul, LLVMBuildMul, LLVMBuildFMul); |
| case Token::SLASHEQ: |
| COMPOUND(LLVMBuildSDiv, LLVMBuildUDiv, LLVMBuildFDiv); |
| case Token::BITWISEANDEQ: |
| COMPOUND(LLVMBuildAnd, LLVMBuildAnd, LLVMBuildAnd); |
| case Token::BITWISEOREQ: |
| COMPOUND(LLVMBuildOr, LLVMBuildOr, LLVMBuildOr); |
| case Token::EQEQ: |
| switch (b.fLeft->fType.kind()) { |
| case Type::kScalar_Kind: |
| COMPARE(LLVMBuildICmp, LLVMIntEQ, |
| LLVMBuildICmp, LLVMIntEQ, |
| LLVMBuildFCmp, LLVMRealOEQ); |
| case Type::kVector_Kind: { |
| LLVMValueRef left = this->compileExpression(builder, *b.fLeft); |
| LLVMValueRef right = this->compileExpression(builder, *b.fRight); |
| this->vectorize(builder, b, &left, &right); |
| LLVMValueRef value; |
| switch (this->typeKind(b.fLeft->fType)) { |
| case kInt_TypeKind: |
| value = LLVMBuildICmp(builder, LLVMIntEQ, left, right, "binary"); |
| break; |
| case kUInt_TypeKind: |
| value = LLVMBuildICmp(builder, LLVMIntEQ, left, right, "binary"); |
| break; |
| case kFloat_TypeKind: |
| value = LLVMBuildFCmp(builder, LLVMRealOEQ, left, right, "binary"); |
| break; |
| default: |
| ABORT("unsupported typeKind"); |
| } |
| LLVMValueRef args[1] = { value }; |
| LLVMValueRef func; |
| switch (b.fLeft->fType.columns()) { |
| case 2: func = fFoldAnd2Func; break; |
| case 3: func = fFoldAnd3Func; break; |
| case 4: func = fFoldAnd4Func; break; |
| default: |
| SkASSERT(false); |
| func = fFoldAnd2Func; |
| } |
| return LLVMBuildCall(builder, func, args, 1, "all"); |
| } |
| default: |
| SkASSERT(false); |
| } |
| case Token::NEQ: |
| switch (b.fLeft->fType.kind()) { |
| case Type::kScalar_Kind: |
| COMPARE(LLVMBuildICmp, LLVMIntNE, |
| LLVMBuildICmp, LLVMIntNE, |
| LLVMBuildFCmp, LLVMRealONE); |
| case Type::kVector_Kind: { |
| LLVMValueRef left = this->compileExpression(builder, *b.fLeft); |
| LLVMValueRef right = this->compileExpression(builder, *b.fRight); |
| this->vectorize(builder, b, &left, &right); |
| LLVMValueRef value; |
| switch (this->typeKind(b.fLeft->fType)) { |
| case kInt_TypeKind: |
| value = LLVMBuildICmp(builder, LLVMIntNE, left, right, "binary"); |
| break; |
| case kUInt_TypeKind: |
| value = LLVMBuildICmp(builder, LLVMIntNE, left, right, "binary"); |
| break; |
| case kFloat_TypeKind: |
| value = LLVMBuildFCmp(builder, LLVMRealONE, left, right, "binary"); |
| break; |
| default: |
| ABORT("unsupported typeKind"); |
| } |
| LLVMValueRef args[1] = { value }; |
| LLVMValueRef func; |
| switch (b.fLeft->fType.columns()) { |
| case 2: func = fFoldOr2Func; break; |
| case 3: func = fFoldOr3Func; break; |
| case 4: func = fFoldOr4Func; break; |
| default: |
| SkASSERT(false); |
| func = fFoldOr2Func; |
| } |
| return LLVMBuildCall(builder, func, args, 1, "all"); |
| } |
| default: |
| SkASSERT(false); |
| } |
| case Token::LT: |
| COMPARE(LLVMBuildICmp, LLVMIntSLT, |
| LLVMBuildICmp, LLVMIntULT, |
| LLVMBuildFCmp, LLVMRealOLT); |
| case Token::LTEQ: |
| COMPARE(LLVMBuildICmp, LLVMIntSLE, |
| LLVMBuildICmp, LLVMIntULE, |
| LLVMBuildFCmp, LLVMRealOLE); |
| case Token::GT: |
| COMPARE(LLVMBuildICmp, LLVMIntSGT, |
| LLVMBuildICmp, LLVMIntUGT, |
| LLVMBuildFCmp, LLVMRealOGT); |
| case Token::GTEQ: |
| COMPARE(LLVMBuildICmp, LLVMIntSGE, |
| LLVMBuildICmp, LLVMIntUGE, |
| LLVMBuildFCmp, LLVMRealOGE); |
| case Token::LOGICALAND: { |
| LLVMValueRef left = this->compileExpression(builder, *b.fLeft); |
| LLVMBasicBlockRef ifFalse = fCurrentBlock; |
| LLVMBasicBlockRef ifTrue = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "true && ..."); |
| LLVMBasicBlockRef merge = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "&& merge"); |
| LLVMBuildCondBr(builder, left, ifTrue, merge); |
| this->setBlock(builder, ifTrue); |
| LLVMValueRef right = this->compileExpression(builder, *b.fRight); |
| LLVMBuildBr(builder, merge); |
| this->setBlock(builder, merge); |
| LLVMValueRef phi = LLVMBuildPhi(builder, fInt1Type, "&&"); |
| LLVMValueRef incomingValues[2] = { right, LLVMConstInt(fInt1Type, 0, false) }; |
| LLVMBasicBlockRef incomingBlocks[2] = { ifTrue, ifFalse }; |
| LLVMAddIncoming(phi, incomingValues, incomingBlocks, 2); |
| return phi; |
| } |
| case Token::LOGICALOR: { |
| LLVMValueRef left = this->compileExpression(builder, *b.fLeft); |
| LLVMBasicBlockRef ifTrue = fCurrentBlock; |
| LLVMBasicBlockRef ifFalse = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "false || ..."); |
| LLVMBasicBlockRef merge = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "|| merge"); |
| LLVMBuildCondBr(builder, left, merge, ifFalse); |
| this->setBlock(builder, ifFalse); |
| LLVMValueRef right = this->compileExpression(builder, *b.fRight); |
| LLVMBuildBr(builder, merge); |
| this->setBlock(builder, merge); |
| LLVMValueRef phi = LLVMBuildPhi(builder, fInt1Type, "||"); |
| LLVMValueRef incomingValues[2] = { right, LLVMConstInt(fInt1Type, 1, false) }; |
| LLVMBasicBlockRef incomingBlocks[2] = { ifFalse, ifTrue }; |
| LLVMAddIncoming(phi, incomingValues, incomingBlocks, 2); |
| return phi; |
| } |
| default: |
| printf("%s\n", b.description().c_str()); |
| ABORT("unsupported binary operator"); |
| } |
| } |
| |
| LLVMValueRef JIT::compileIndex(LLVMBuilderRef builder, const IndexExpression& idx) { |
| LLVMValueRef base = this->compileExpression(builder, *idx.fBase); |
| LLVMValueRef index = this->compileExpression(builder, *idx.fIndex); |
| LLVMValueRef ptr = LLVMBuildGEP(builder, base, &index, 1, "index ptr"); |
| return LLVMBuildLoad(builder, ptr, "index load"); |
| } |
| |
| LLVMValueRef JIT::compilePostfix(LLVMBuilderRef builder, const PostfixExpression& p) { |
| std::unique_ptr<LValue> lvalue = this->getLValue(builder, *p.fOperand); |
| LLVMValueRef result = lvalue->load(builder); |
| LLVMValueRef mod; |
| LLVMValueRef one = LLVMConstInt(this->getType(p.fType), 1, false); |
| switch (p.fOperator) { |
| case Token::PLUSPLUS: |
| switch (this->typeKind(p.fType)) { |
| case kInt_TypeKind: // fall through |
| case kUInt_TypeKind: |
| mod = LLVMBuildAdd(builder, result, one, "++"); |
| break; |
| case kFloat_TypeKind: |
| mod = LLVMBuildFAdd(builder, result, one, "++"); |
| break; |
| default: |
| ABORT("unsupported typeKind"); |
| } |
| break; |
| case Token::MINUSMINUS: |
| switch (this->typeKind(p.fType)) { |
| case kInt_TypeKind: // fall through |
| case kUInt_TypeKind: |
| mod = LLVMBuildSub(builder, result, one, "--"); |
| break; |
| case kFloat_TypeKind: |
| mod = LLVMBuildFSub(builder, result, one, "--"); |
| break; |
| default: |
| ABORT("unsupported typeKind"); |
| } |
| break; |
| default: |
| ABORT("unsupported postfix op"); |
| } |
| lvalue->store(builder, mod); |
| return result; |
| } |
| |
| LLVMValueRef JIT::compilePrefix(LLVMBuilderRef builder, const PrefixExpression& p) { |
| LLVMValueRef one = LLVMConstInt(this->getType(p.fType), 1, false); |
| if (Token::LOGICALNOT == p.fOperator) { |
| LLVMValueRef base = this->compileExpression(builder, *p.fOperand); |
| return LLVMBuildXor(builder, base, one, "!"); |
| } |
| if (Token::MINUS == p.fOperator) { |
| LLVMValueRef base = this->compileExpression(builder, *p.fOperand); |
| return LLVMBuildSub(builder, LLVMConstInt(this->getType(p.fType), 0, false), base, "-"); |
| } |
| std::unique_ptr<LValue> lvalue = this->getLValue(builder, *p.fOperand); |
| LLVMValueRef raw = lvalue->load(builder); |
| LLVMValueRef result; |
| switch (p.fOperator) { |
| case Token::PLUSPLUS: |
| switch (this->typeKind(p.fType)) { |
| case kInt_TypeKind: // fall through |
| case kUInt_TypeKind: |
| result = LLVMBuildAdd(builder, raw, one, "++"); |
| break; |
| case kFloat_TypeKind: |
| result = LLVMBuildFAdd(builder, raw, one, "++"); |
| break; |
| default: |
| ABORT("unsupported typeKind"); |
| } |
| break; |
| case Token::MINUSMINUS: |
| switch (this->typeKind(p.fType)) { |
| case kInt_TypeKind: // fall through |
| case kUInt_TypeKind: |
| result = LLVMBuildSub(builder, raw, one, "--"); |
| break; |
| case kFloat_TypeKind: |
| result = LLVMBuildFSub(builder, raw, one, "--"); |
| break; |
| default: |
| ABORT("unsupported typeKind"); |
| } |
| break; |
| default: |
| ABORT("unsupported prefix op"); |
| } |
| lvalue->store(builder, result); |
| return result; |
| } |
| |
| LLVMValueRef JIT::compileVariableReference(LLVMBuilderRef builder, const VariableReference& v) { |
| const Variable& var = v.fVariable; |
| if (Variable::kParameter_Storage == var.fStorage && |
| !(var.fModifiers.fFlags & Modifiers::kOut_Flag) && |
| fPromotedParameters.find(&var) == fPromotedParameters.end()) { |
| return fVariables[&var]; |
| } |
| return LLVMBuildLoad(builder, fVariables[&var], String(var.fName).c_str()); |
| } |
| |
| void JIT::appendStage(LLVMBuilderRef builder, const AppendStage& a) { |
| SkASSERT(a.fArguments.size() >= 1); |
| SkASSERT(a.fArguments[0]->fType == *fCompiler.context().fSkRasterPipeline_Type); |
| LLVMValueRef pipeline = this->compileExpression(builder, *a.fArguments[0]); |
| LLVMValueRef stage = LLVMConstInt(fInt32Type, a.fStage, 0); |
| switch (a.fStage) { |
| case SkRasterPipeline::callback: { |
| SkASSERT(a.fArguments.size() == 2); |
| SkASSERT(a.fArguments[1]->fKind == Expression::kFunctionReference_Kind); |
| const FunctionDeclaration& functionDecl = |
| *((FunctionReference&) *a.fArguments[1]).fFunctions[0]; |
| bool found = false; |
| for (const auto& pe : *fProgram) { |
| if (ProgramElement::kFunction_Kind == pe.fKind) { |
| const FunctionDefinition& def = (const FunctionDefinition&) pe; |
| if (&def.fDeclaration == &functionDecl) { |
| LLVMValueRef fn = this->compileStageFunction(def); |
| LLVMValueRef args[2] = { |
| pipeline, |
| LLVMBuildBitCast(builder, fn, fInt8PtrType, "callback cast") |
| }; |
| LLVMBuildCall(builder, fAppendCallbackFunc, args, 2, ""); |
| found = true; |
| break; |
| } |
| } |
| } |
| SkASSERT(found); |
| break; |
| } |
| default: { |
| LLVMValueRef ctx; |
| if (a.fArguments.size() == 2) { |
| ctx = this->compileExpression(builder, *a.fArguments[1]); |
| ctx = LLVMBuildBitCast(builder, ctx, fInt8PtrType, "context cast"); |
| } else { |
| SkASSERT(a.fArguments.size() == 1); |
| ctx = LLVMConstNull(fInt8PtrType); |
| } |
| LLVMValueRef args[3] = { |
| pipeline, |
| stage, |
| ctx |
| }; |
| LLVMBuildCall(builder, fAppendFunc, args, 3, ""); |
| break; |
| } |
| } |
| } |
| |
| LLVMValueRef JIT::compileConstructor(LLVMBuilderRef builder, const Constructor& c) { |
| switch (c.fType.kind()) { |
| case Type::kScalar_Kind: { |
| SkASSERT(c.fArguments.size() == 1); |
| TypeKind from = this->typeKind(c.fArguments[0]->fType); |
| TypeKind to = this->typeKind(c.fType); |
| LLVMValueRef base = this->compileExpression(builder, *c.fArguments[0]); |
| switch (to) { |
| case kFloat_TypeKind: |
| switch (from) { |
| case kInt_TypeKind: |
| return LLVMBuildSIToFP(builder, base, this->getType(c.fType), "cast"); |
| case kUInt_TypeKind: |
| return LLVMBuildUIToFP(builder, base, this->getType(c.fType), "cast"); |
| case kFloat_TypeKind: |
| return base; |
| case kBool_TypeKind: |
| SkASSERT(false); |
| } |
| case kInt_TypeKind: |
| switch (from) { |
| case kInt_TypeKind: |
| return base; |
| case kUInt_TypeKind: |
| return base; |
| case kFloat_TypeKind: |
| return LLVMBuildFPToSI(builder, base, this->getType(c.fType), "cast"); |
| case kBool_TypeKind: |
| SkASSERT(false); |
| } |
| case kUInt_TypeKind: |
| switch (from) { |
| case kInt_TypeKind: |
| return base; |
| case kUInt_TypeKind: |
| return base; |
| case kFloat_TypeKind: |
| return LLVMBuildFPToUI(builder, base, this->getType(c.fType), "cast"); |
| case kBool_TypeKind: |
| SkASSERT(false); |
| } |
| case kBool_TypeKind: |
| SkASSERT(false); |
| } |
| } |
| case Type::kVector_Kind: { |
| LLVMValueRef vec = LLVMGetUndef(this->getType(c.fType)); |
| if (c.fArguments.size() == 1 && c.fArguments[0]->fType.kind() == Type::kScalar_Kind) { |
| LLVMValueRef value = this->compileExpression(builder, *c.fArguments[0]); |
| for (int i = 0; i < c.fType.columns(); ++i) { |
| vec = LLVMBuildInsertElement(builder, vec, value, |
| LLVMConstInt(fInt32Type, i, false), |
| "vec build 1"); |
| } |
| } else { |
| int index = 0; |
| for (const auto& arg : c.fArguments) { |
| LLVMValueRef value = this->compileExpression(builder, *arg); |
| if (arg->fType.kind() == Type::kVector_Kind) { |
| for (int i = 0; i < arg->fType.columns(); ++i) { |
| LLVMValueRef column = LLVMBuildExtractElement(builder, |
| vec, |
| LLVMConstInt(fInt32Type, |
| i, |
| false), |
| "construct extract"); |
| vec = LLVMBuildInsertElement(builder, vec, column, |
| LLVMConstInt(fInt32Type, index++, false), |
| "vec build 2"); |
| } |
| } else { |
| vec = LLVMBuildInsertElement(builder, vec, value, |
| LLVMConstInt(fInt32Type, index++, false), |
| "vec build 3"); |
| } |
| } |
| } |
| return vec; |
| } |
| default: |
| break; |
| } |
| ABORT("unsupported constructor"); |
| } |
| |
| LLVMValueRef JIT::compileSwizzle(LLVMBuilderRef builder, const Swizzle& s) { |
| LLVMValueRef base = this->compileExpression(builder, *s.fBase); |
| if (s.fComponents.size() > 1) { |
| LLVMValueRef result = LLVMGetUndef(this->getType(s.fType)); |
| for (size_t i = 0; i < s.fComponents.size(); ++i) { |
| LLVMValueRef element = LLVMBuildExtractElement( |
| builder, |
| base, |
| LLVMConstInt(fInt32Type, |
| s.fComponents[i], |
| false), |
| "swizzle extract"); |
| result = LLVMBuildInsertElement(builder, result, element, |
| LLVMConstInt(fInt32Type, i, false), |
| "swizzle insert"); |
| } |
| return result; |
| } |
| SkASSERT(s.fComponents.size() == 1); |
| return LLVMBuildExtractElement(builder, base, |
| LLVMConstInt(fInt32Type, |
| s.fComponents[0], |
| false), |
| "swizzle extract"); |
| } |
| |
| LLVMValueRef JIT::compileTernary(LLVMBuilderRef builder, const TernaryExpression& t) { |
| LLVMValueRef test = this->compileExpression(builder, *t.fTest); |
| LLVMBasicBlockRef trueBlock = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "if true"); |
| LLVMBasicBlockRef merge = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "if merge"); |
| LLVMBasicBlockRef falseBlock = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "if false"); |
| LLVMBuildCondBr(builder, test, trueBlock, falseBlock); |
| this->setBlock(builder, trueBlock); |
| LLVMValueRef ifTrue = this->compileExpression(builder, *t.fIfTrue); |
| trueBlock = fCurrentBlock; |
| LLVMBuildBr(builder, merge); |
| this->setBlock(builder, falseBlock); |
| LLVMValueRef ifFalse = this->compileExpression(builder, *t.fIfFalse); |
| falseBlock = fCurrentBlock; |
| LLVMBuildBr(builder, merge); |
| this->setBlock(builder, merge); |
| LLVMValueRef phi = LLVMBuildPhi(builder, this->getType(t.fType), "?"); |
| LLVMValueRef incomingValues[2] = { ifTrue, ifFalse }; |
| LLVMBasicBlockRef incomingBlocks[2] = { trueBlock, falseBlock }; |
| LLVMAddIncoming(phi, incomingValues, incomingBlocks, 2); |
| return phi; |
| } |
| |
| LLVMValueRef JIT::compileExpression(LLVMBuilderRef builder, const Expression& expr) { |
| switch (expr.fKind) { |
| case Expression::kAppendStage_Kind: { |
| this->appendStage(builder, (const AppendStage&) expr); |
| return LLVMValueRef(); |
| } |
| case Expression::kBinary_Kind: |
| return this->compileBinary(builder, (BinaryExpression&) expr); |
| case Expression::kBoolLiteral_Kind: |
| return LLVMConstInt(fInt1Type, ((BoolLiteral&) expr).fValue, false); |
| case Expression::kConstructor_Kind: |
| return this->compileConstructor(builder, (Constructor&) expr); |
| case Expression::kIntLiteral_Kind: |
| return LLVMConstInt(this->getType(expr.fType), ((IntLiteral&) expr).fValue, true); |
| case Expression::kFieldAccess_Kind: |
| abort(); |
| case Expression::kFloatLiteral_Kind: |
| return LLVMConstReal(this->getType(expr.fType), ((FloatLiteral&) expr).fValue); |
| case Expression::kFunctionCall_Kind: |
| return this->compileFunctionCall(builder, (FunctionCall&) expr); |
| case Expression::kIndex_Kind: |
| return this->compileIndex(builder, (IndexExpression&) expr); |
| case Expression::kPrefix_Kind: |
| return this->compilePrefix(builder, (PrefixExpression&) expr); |
| case Expression::kPostfix_Kind: |
| return this->compilePostfix(builder, (PostfixExpression&) expr); |
| case Expression::kSetting_Kind: |
| abort(); |
| case Expression::kSwizzle_Kind: |
| return this->compileSwizzle(builder, (Swizzle&) expr); |
| case Expression::kVariableReference_Kind: |
| return this->compileVariableReference(builder, (VariableReference&) expr); |
| case Expression::kTernary_Kind: |
| return this->compileTernary(builder, (TernaryExpression&) expr); |
| case Expression::kTypeReference_Kind: |
| abort(); |
| default: |
| abort(); |
| } |
| ABORT("unsupported expression: %s\n", expr.description().c_str()); |
| } |
| |
| void JIT::compileBlock(LLVMBuilderRef builder, const Block& block) { |
| for (const auto& stmt : block.fStatements) { |
| this->compileStatement(builder, *stmt); |
| } |
| } |
| |
| void JIT::compileVarDeclarations(LLVMBuilderRef builder, const VarDeclarationsStatement& decls) { |
| for (const auto& declStatement : decls.fDeclaration->fVars) { |
| const VarDeclaration& decl = (VarDeclaration&) *declStatement; |
| LLVMPositionBuilderAtEnd(builder, fAllocaBlock); |
| LLVMValueRef alloca = LLVMBuildAlloca(builder, this->getType(decl.fVar->fType), |
| String(decl.fVar->fName).c_str()); |
| fVariables[decl.fVar] = alloca; |
| LLVMPositionBuilderAtEnd(builder, fCurrentBlock); |
| if (decl.fValue) { |
| LLVMValueRef result = this->compileExpression(builder, *decl.fValue); |
| LLVMBuildStore(builder, result, alloca); |
| } |
| } |
| } |
| |
| void JIT::compileIf(LLVMBuilderRef builder, const IfStatement& i) { |
| LLVMValueRef test = this->compileExpression(builder, *i.fTest); |
| LLVMBasicBlockRef ifTrue = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "if true"); |
| LLVMBasicBlockRef merge = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "if merge"); |
| LLVMBasicBlockRef ifFalse; |
| if (i.fIfFalse) { |
| ifFalse = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "if false"); |
| } else { |
| ifFalse = merge; |
| } |
| LLVMBuildCondBr(builder, test, ifTrue, ifFalse); |
| this->setBlock(builder, ifTrue); |
| this->compileStatement(builder, *i.fIfTrue); |
| if (!ends_with_branch(*i.fIfTrue)) { |
| LLVMBuildBr(builder, merge); |
| } |
| if (i.fIfFalse) { |
| this->setBlock(builder, ifFalse); |
| this->compileStatement(builder, *i.fIfFalse); |
| if (!ends_with_branch(*i.fIfFalse)) { |
| LLVMBuildBr(builder, merge); |
| } |
| } |
| this->setBlock(builder, merge); |
| } |
| |
| void JIT::compileFor(LLVMBuilderRef builder, const ForStatement& f) { |
| if (f.fInitializer) { |
| this->compileStatement(builder, *f.fInitializer); |
| } |
| LLVMBasicBlockRef start; |
| LLVMBasicBlockRef body = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "for body"); |
| LLVMBasicBlockRef next = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "for next"); |
| LLVMBasicBlockRef end = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "for end"); |
| if (f.fTest) { |
| start = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "for test"); |
| LLVMBuildBr(builder, start); |
| this->setBlock(builder, start); |
| LLVMValueRef test = this->compileExpression(builder, *f.fTest); |
| LLVMBuildCondBr(builder, test, body, end); |
| } else { |
| start = body; |
| LLVMBuildBr(builder, body); |
| } |
| this->setBlock(builder, body); |
| fBreakTarget.push_back(end); |
| fContinueTarget.push_back(next); |
| this->compileStatement(builder, *f.fStatement); |
| fBreakTarget.pop_back(); |
| fContinueTarget.pop_back(); |
| if (!ends_with_branch(*f.fStatement)) { |
| LLVMBuildBr(builder, next); |
| } |
| this->setBlock(builder, next); |
| if (f.fNext) { |
| this->compileExpression(builder, *f.fNext); |
| } |
| LLVMBuildBr(builder, start); |
| this->setBlock(builder, end); |
| } |
| |
| void JIT::compileDo(LLVMBuilderRef builder, const DoStatement& d) { |
| LLVMBasicBlockRef testBlock = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "do test"); |
| LLVMBasicBlockRef body = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "do body"); |
| LLVMBasicBlockRef end = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "do end"); |
| LLVMBuildBr(builder, body); |
| this->setBlock(builder, testBlock); |
| LLVMValueRef test = this->compileExpression(builder, *d.fTest); |
| LLVMBuildCondBr(builder, test, body, end); |
| this->setBlock(builder, body); |
| fBreakTarget.push_back(end); |
| fContinueTarget.push_back(body); |
| this->compileStatement(builder, *d.fStatement); |
| fBreakTarget.pop_back(); |
| fContinueTarget.pop_back(); |
| if (!ends_with_branch(*d.fStatement)) { |
| LLVMBuildBr(builder, testBlock); |
| } |
| this->setBlock(builder, end); |
| } |
| |
| void JIT::compileWhile(LLVMBuilderRef builder, const WhileStatement& w) { |
| LLVMBasicBlockRef testBlock = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "while test"); |
| LLVMBasicBlockRef body = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "while body"); |
| LLVMBasicBlockRef end = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, |
| "while end"); |
| LLVMBuildBr(builder, testBlock); |
| this->setBlock(builder, testBlock); |
| LLVMValueRef test = this->compileExpression(builder, *w.fTest); |
| LLVMBuildCondBr(builder, test, body, end); |
| this->setBlock(builder, body); |
| fBreakTarget.push_back(end); |
| fContinueTarget.push_back(testBlock); |
| this->compileStatement(builder, *w.fStatement); |
| fBreakTarget.pop_back(); |
| fContinueTarget.pop_back(); |
| if (!ends_with_branch(*w.fStatement)) { |
| LLVMBuildBr(builder, testBlock); |
| } |
| this->setBlock(builder, end); |
| } |
| |
| void JIT::compileBreak(LLVMBuilderRef builder, const BreakStatement& b) { |
| LLVMBuildBr(builder, fBreakTarget.back()); |
| } |
| |
| void JIT::compileContinue(LLVMBuilderRef builder, const ContinueStatement& b) { |
| LLVMBuildBr(builder, fContinueTarget.back()); |
| } |
| |
| void JIT::compileReturn(LLVMBuilderRef builder, const ReturnStatement& r) { |
| if (r.fExpression) { |
| LLVMBuildRet(builder, this->compileExpression(builder, *r.fExpression)); |
| } else { |
| LLVMBuildRetVoid(builder); |
| } |
| } |
| |
| void JIT::compileStatement(LLVMBuilderRef builder, const Statement& stmt) { |
| switch (stmt.fKind) { |
| case Statement::kBlock_Kind: |
| this->compileBlock(builder, (Block&) stmt); |
| break; |
| case Statement::kBreak_Kind: |
| this->compileBreak(builder, (BreakStatement&) stmt); |
| break; |
| case Statement::kContinue_Kind: |
| this->compileContinue(builder, (ContinueStatement&) stmt); |
| break; |
| case Statement::kDiscard_Kind: |
| abort(); |
| case Statement::kDo_Kind: |
| this->compileDo(builder, (DoStatement&) stmt); |
| break; |
| case Statement::kExpression_Kind: |
| this->compileExpression(builder, *((ExpressionStatement&) stmt).fExpression); |
| break; |
| case Statement::kFor_Kind: |
| this->compileFor(builder, (ForStatement&) stmt); |
| break; |
| case Statement::kGroup_Kind: |
| abort(); |
| case Statement::kIf_Kind: |
| this->compileIf(builder, (IfStatement&) stmt); |
| break; |
| case Statement::kNop_Kind: |
| break; |
| case Statement::kReturn_Kind: |
| this->compileReturn(builder, (ReturnStatement&) stmt); |
| break; |
| case Statement::kSwitch_Kind: |
| abort(); |
| case Statement::kVarDeclarations_Kind: |
| this->compileVarDeclarations(builder, (VarDeclarationsStatement&) stmt); |
| break; |
| case Statement::kWhile_Kind: |
| this->compileWhile(builder, (WhileStatement&) stmt); |
| break; |
| default: |
| abort(); |
| } |
| } |
| |
| void JIT::compileStageFunctionLoop(const FunctionDefinition& f, LLVMValueRef newFunc) { |
| // loop over fVectorCount pixels, running the body of the stage function for each of them |
| LLVMValueRef oldFunction = fCurrentFunction; |
| fCurrentFunction = newFunc; |
| std::unique_ptr<LLVMValueRef[]> params(new LLVMValueRef[STAGE_PARAM_COUNT]); |
| LLVMGetParams(fCurrentFunction, params.get()); |
| LLVMValueRef programParam = params.get()[1]; |
| LLVMBuilderRef builder = LLVMCreateBuilderInContext(fContext); |
| LLVMBasicBlockRef oldAllocaBlock = fAllocaBlock; |
| LLVMBasicBlockRef oldCurrentBlock = fCurrentBlock; |
| fAllocaBlock = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "alloca"); |
| this->setBlock(builder, fAllocaBlock); |
| // temporaries to store the color channel vectors |
| LLVMValueRef rVec = LLVMBuildAlloca(builder, fFloat32VectorType, "rVec"); |
| LLVMBuildStore(builder, params.get()[4], rVec); |
| LLVMValueRef gVec = LLVMBuildAlloca(builder, fFloat32VectorType, "gVec"); |
| LLVMBuildStore(builder, params.get()[5], gVec); |
| LLVMValueRef bVec = LLVMBuildAlloca(builder, fFloat32VectorType, "bVec"); |
| LLVMBuildStore(builder, params.get()[6], bVec); |
| LLVMValueRef aVec = LLVMBuildAlloca(builder, fFloat32VectorType, "aVec"); |
| LLVMBuildStore(builder, params.get()[7], aVec); |
| LLVMValueRef color = LLVMBuildAlloca(builder, fFloat32Vector4Type, "color"); |
| fVariables[f.fDeclaration.fParameters[1]] = LLVMBuildTrunc(builder, params.get()[3], fInt32Type, |
| "y->Int32"); |
| fVariables[f.fDeclaration.fParameters[2]] = color; |
| LLVMValueRef ivar = LLVMBuildAlloca(builder, fInt32Type, "i"); |
| LLVMBuildStore(builder, LLVMConstInt(fInt32Type, 0, false), ivar); |
| LLVMBasicBlockRef start = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "start"); |
| this->setBlock(builder, start); |
| LLVMValueRef iload = LLVMBuildLoad(builder, ivar, "load i"); |
| fVariables[f.fDeclaration.fParameters[0]] = LLVMBuildAdd(builder, |
| LLVMBuildTrunc(builder, |
| params.get()[2], |
| fInt32Type, |
| "x->Int32"), |
| iload, |
| "x"); |
| LLVMValueRef vectorSize = LLVMConstInt(fInt32Type, fVectorCount, false); |
| LLVMValueRef test = LLVMBuildICmp(builder, LLVMIntSLT, iload, vectorSize, "i < vectorSize"); |
| LLVMBasicBlockRef loopBody = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "body"); |
| LLVMBasicBlockRef loopEnd = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "end"); |
| LLVMBuildCondBr(builder, test, loopBody, loopEnd); |
| this->setBlock(builder, loopBody); |
| LLVMValueRef vec = LLVMGetUndef(fFloat32Vector4Type); |
| // extract the r, g, b, and a values from the color channel vectors and store them into "color" |
| for (int i = 0; i < 4; ++i) { |
| vec = LLVMBuildInsertElement(builder, vec, |
| LLVMBuildExtractElement(builder, |
| params.get()[4 + i], |
| iload, "initial"), |
| LLVMConstInt(fInt32Type, i, false), |
| "vec build"); |
| } |
| LLVMBuildStore(builder, vec, color); |
| // write actual loop body |
| this->compileStatement(builder, *f.fBody); |
| // extract the r, g, b, and a values from "color" and stick them back into the color channel |
| // vectors |
| LLVMValueRef colorLoad = LLVMBuildLoad(builder, color, "color load"); |
| LLVMBuildStore(builder, |
| LLVMBuildInsertElement(builder, LLVMBuildLoad(builder, rVec, "rVec"), |
| LLVMBuildExtractElement(builder, colorLoad, |
| LLVMConstInt(fInt32Type, 0, |
| false), |
| "rExtract"), |
| iload, "rInsert"), |
| rVec); |
| LLVMBuildStore(builder, |
| LLVMBuildInsertElement(builder, LLVMBuildLoad(builder, gVec, "gVec"), |
| LLVMBuildExtractElement(builder, colorLoad, |
| LLVMConstInt(fInt32Type, 1, |
| false), |
| "gExtract"), |
| iload, "gInsert"), |
| gVec); |
| LLVMBuildStore(builder, |
| LLVMBuildInsertElement(builder, LLVMBuildLoad(builder, bVec, "bVec"), |
| LLVMBuildExtractElement(builder, colorLoad, |
| LLVMConstInt(fInt32Type, 2, |
| false), |
| "bExtract"), |
| iload, "bInsert"), |
| bVec); |
| LLVMBuildStore(builder, |
| LLVMBuildInsertElement(builder, LLVMBuildLoad(builder, aVec, "aVec"), |
| LLVMBuildExtractElement(builder, colorLoad, |
| LLVMConstInt(fInt32Type, 3, |
| false), |
| "aExtract"), |
| iload, "aInsert"), |
| aVec); |
| LLVMValueRef inc = LLVMBuildAdd(builder, iload, LLVMConstInt(fInt32Type, 1, false), "inc i"); |
| LLVMBuildStore(builder, inc, ivar); |
| LLVMBuildBr(builder, start); |
| this->setBlock(builder, loopEnd); |
| // increment program pointer, call the next stage |
| LLVMValueRef rawNextPtr = LLVMBuildLoad(builder, programParam, "next load"); |
| LLVMTypeRef stageFuncType = LLVMTypeOf(newFunc); |
| LLVMValueRef nextPtr = LLVMBuildBitCast(builder, rawNextPtr, stageFuncType, "cast next->func"); |
| LLVMValueRef nextInc = LLVMBuildIntToPtr(builder, |
| LLVMBuildAdd(builder, |
| LLVMBuildPtrToInt(builder, |
| programParam, |
| fInt64Type, |
| "cast 1"), |
| LLVMConstInt(fInt64Type, PTR_SIZE, false), |
| "add"), |
| LLVMPointerType(fInt8PtrType, 0), "cast 2"); |
| LLVMValueRef args[STAGE_PARAM_COUNT] = { |
| params.get()[0], |
| nextInc, |
| params.get()[2], |
| params.get()[3], |
| LLVMBuildLoad(builder, rVec, "rVec"), |
| LLVMBuildLoad(builder, gVec, "gVec"), |
| LLVMBuildLoad(builder, bVec, "bVec"), |
| LLVMBuildLoad(builder, aVec, "aVec"), |
| params.get()[8], |
| params.get()[9], |
| params.get()[10], |
| params.get()[11] |
| }; |
| LLVMBuildCall(builder, nextPtr, args, STAGE_PARAM_COUNT, ""); |
| LLVMBuildRetVoid(builder); |
| // finish |
| LLVMPositionBuilderAtEnd(builder, fAllocaBlock); |
| LLVMBuildBr(builder, start); |
| LLVMDisposeBuilder(builder); |
| if (LLVMVerifyFunction(fCurrentFunction, LLVMPrintMessageAction)) { |
| ABORT("verify failed\n"); |
| } |
| fAllocaBlock = oldAllocaBlock; |
| fCurrentBlock = oldCurrentBlock; |
| fCurrentFunction = oldFunction; |
| } |
| |
| // FIXME maybe pluggable code generators? Need to do something to separate all |
| // of the normal codegen from the vector codegen and break this up into multiple |
| // classes. |
| |
| bool JIT::getVectorLValue(LLVMBuilderRef builder, const Expression& e, |
| LLVMValueRef out[CHANNELS]) { |
| switch (e.fKind) { |
| case Expression::kVariableReference_Kind: |
| if (fColorParam == &((VariableReference&) e).fVariable) { |
| memcpy(out, fChannels, sizeof(fChannels)); |
| return true; |
| } |
| return false; |
| case Expression::kSwizzle_Kind: { |
| const Swizzle& s = (const Swizzle&) e; |
| LLVMValueRef base[CHANNELS]; |
| if (!this->getVectorLValue(builder, *s.fBase, base)) { |
| return false; |
| } |
| for (size_t i = 0; i < s.fComponents.size(); ++i) { |
| out[i] = base[s.fComponents[i]]; |
| } |
| return true; |
| } |
| default: |
| return false; |
| } |
| } |
| |
| bool JIT::getVectorBinaryOperands(LLVMBuilderRef builder, const Expression& left, |
| LLVMValueRef outLeft[CHANNELS], const Expression& right, |
| LLVMValueRef outRight[CHANNELS]) { |
| if (!this->compileVectorExpression(builder, left, outLeft)) { |
| return false; |
| } |
| int leftColumns = left.fType.columns(); |
| int rightColumns = right.fType.columns(); |
| if (leftColumns == 1 && rightColumns > 1) { |
| for (int i = 1; i < rightColumns; ++i) { |
| outLeft[i] = outLeft[0]; |
| } |
| } |
| if (!this->compileVectorExpression(builder, right, outRight)) { |
| return false; |
| } |
| if (rightColumns == 1 && leftColumns > 1) { |
| for (int i = 1; i < leftColumns; ++i) { |
| outRight[i] = outRight[0]; |
| } |
| } |
| return true; |
| } |
| |
| bool JIT::compileVectorBinary(LLVMBuilderRef builder, const BinaryExpression& b, |
| LLVMValueRef out[CHANNELS]) { |
| LLVMValueRef left[CHANNELS]; |
| LLVMValueRef right[CHANNELS]; |
| #define VECTOR_BINARY(signedOp, unsignedOp, floatOp) { \ |
| if (!this->getVectorBinaryOperands(builder, *b.fLeft, left, *b.fRight, right)) { \ |
| return false; \ |
| } \ |
| for (int i = 0; i < b.fLeft->fType.columns(); ++i) { \ |
| switch (this->typeKind(b.fLeft->fType)) { \ |
| case kInt_TypeKind: \ |
| out[i] = signedOp(builder, left[i], right[i], "binary"); \ |
| break; \ |
| case kUInt_TypeKind: \ |
| out[i] = unsignedOp(builder, left[i], right[i], "binary"); \ |
| break; \ |
| case kFloat_TypeKind: \ |
| out[i] = floatOp(builder, left[i], right[i], "binary"); \ |
| break; \ |
| case kBool_TypeKind: \ |
| SkASSERT(false); \ |
| break; \ |
| } \ |
| } \ |
| return true; \ |
| } |
| switch (b.fOperator) { |
| case Token::EQ: { |
| if (!this->getVectorLValue(builder, *b.fLeft, left)) { |
| return false; |
| } |
| if (!this->compileVectorExpression(builder, *b.fRight, right)) { |
| return false; |
| } |
| int columns = b.fRight->fType.columns(); |
| for (int i = 0; i < columns; ++i) { |
| LLVMBuildStore(builder, right[i], left[i]); |
| } |
| return true; |
| } |
| case Token::PLUS: |
| VECTOR_BINARY(LLVMBuildAdd, LLVMBuildAdd, LLVMBuildFAdd); |
| case Token::MINUS: |
| VECTOR_BINARY(LLVMBuildSub, LLVMBuildSub, LLVMBuildFSub); |
| case Token::STAR: |
| VECTOR_BINARY(LLVMBuildMul, LLVMBuildMul, LLVMBuildFMul); |
| case Token::SLASH: |
| VECTOR_BINARY(LLVMBuildSDiv, LLVMBuildUDiv, LLVMBuildFDiv); |
| case Token::PERCENT: |
| VECTOR_BINARY(LLVMBuildSRem, LLVMBuildURem, LLVMBuildSRem); |
| case Token::BITWISEAND: |
| VECTOR_BINARY(LLVMBuildAnd, LLVMBuildAnd, LLVMBuildAnd); |
| case Token::BITWISEOR: |
| VECTOR_BINARY(LLVMBuildOr, LLVMBuildOr, LLVMBuildOr); |
| default: |
| printf("unsupported operator: %s\n", b.description().c_str()); |
| return false; |
| } |
| } |
| |
| bool JIT::compileVectorConstructor(LLVMBuilderRef builder, const Constructor& c, |
| LLVMValueRef out[CHANNELS]) { |
| switch (c.fType.kind()) { |
| case Type::kScalar_Kind: { |
| SkASSERT(c.fArguments.size() == 1); |
| TypeKind from = this->typeKind(c.fArguments[0]->fType); |
| TypeKind to = this->typeKind(c.fType); |
| LLVMValueRef base[CHANNELS]; |
| if (!this->compileVectorExpression(builder, *c.fArguments[0], base)) { |
| return false; |
| } |
| #define CONSTRUCT(fn) \ |
| out[0] = LLVMGetUndef(LLVMVectorType(this->getType(c.fType), fVectorCount)); \ |
| for (int i = 0; i < fVectorCount; ++i) { \ |
| LLVMValueRef index = LLVMConstInt(fInt32Type, i, false); \ |
| LLVMValueRef baseVal = LLVMBuildExtractElement(builder, base[0], index, \ |
| "construct extract"); \ |
| out[0] = LLVMBuildInsertElement(builder, out[0], \ |
| fn(builder, baseVal, this->getType(c.fType), \ |
| "cast"), \ |
| index, "construct insert"); \ |
| } \ |
| return true; |
| if (kFloat_TypeKind == to) { |
| if (kInt_TypeKind == from) { |
| CONSTRUCT(LLVMBuildSIToFP); |
| } |
| if (kUInt_TypeKind == from) { |
| CONSTRUCT(LLVMBuildUIToFP); |
| } |
| } |
| if (kInt_TypeKind == to) { |
| if (kFloat_TypeKind == from) { |
| CONSTRUCT(LLVMBuildFPToSI); |
| } |
| if (kUInt_TypeKind == from) { |
| return true; |
| } |
| } |
| if (kUInt_TypeKind == to) { |
| if (kFloat_TypeKind == from) { |
| CONSTRUCT(LLVMBuildFPToUI); |
| } |
| if (kInt_TypeKind == from) { |
| return base; |
| } |
| } |
| printf("%s\n", c.description().c_str()); |
| ABORT("unsupported constructor"); |
| } |
| case Type::kVector_Kind: { |
| if (c.fArguments.size() == 1) { |
| LLVMValueRef base[CHANNELS]; |
| if (!this->compileVectorExpression(builder, *c.fArguments[0], base)) { |
| return false; |
| } |
| for (int i = 0; i < c.fType.columns(); ++i) { |
| out[i] = base[0]; |
| } |
| } else { |
| SkASSERT(c.fArguments.size() == (size_t) c.fType.columns()); |
| for (int i = 0; i < c.fType.columns(); ++i) { |
| LLVMValueRef base[CHANNELS]; |
| if (!this->compileVectorExpression(builder, *c.fArguments[i], base)) { |
| return false; |
| } |
| out[i] = base[0]; |
| } |
| } |
| return true; |
| } |
| default: |
| break; |
| } |
| ABORT("unsupported constructor"); |
| } |
| |
| bool JIT::compileVectorFloatLiteral(LLVMBuilderRef builder, |
| const FloatLiteral& f, |
| LLVMValueRef out[CHANNELS]) { |
| LLVMValueRef value = LLVMConstReal(this->getType(f.fType), f.fValue); |
| LLVMValueRef values[MAX_VECTOR_COUNT]; |
| for (int i = 0; i < fVectorCount; ++i) { |
| values[i] = value; |
| } |
| out[0] = LLVMConstVector(values, fVectorCount); |
| return true; |
| } |
| |
| |
| bool JIT::compileVectorSwizzle(LLVMBuilderRef builder, const Swizzle& s, |
| LLVMValueRef out[CHANNELS]) { |
| LLVMValueRef all[CHANNELS]; |
| if (!this->compileVectorExpression(builder, *s.fBase, all)) { |
| return false; |
| } |
| for (size_t i = 0; i < s.fComponents.size(); ++i) { |
| out[i] = all[s.fComponents[i]]; |
| } |
| return true; |
| } |
| |
| bool JIT::compileVectorVariableReference(LLVMBuilderRef builder, const VariableReference& v, |
| LLVMValueRef out[CHANNELS]) { |
| if (&v.fVariable == fColorParam) { |
| for (int i = 0; i < CHANNELS; ++i) { |
| out[i] = LLVMBuildLoad(builder, fChannels[i], "variable reference"); |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| bool JIT::compileVectorExpression(LLVMBuilderRef builder, const Expression& expr, |
| LLVMValueRef out[CHANNELS]) { |
| switch (expr.fKind) { |
| case Expression::kBinary_Kind: |
| return this->compileVectorBinary(builder, (const BinaryExpression&) expr, out); |
| case Expression::kConstructor_Kind: |
| return this->compileVectorConstructor(builder, (const Constructor&) expr, out); |
| case Expression::kFloatLiteral_Kind: |
| return this->compileVectorFloatLiteral(builder, (const FloatLiteral&) expr, out); |
| case Expression::kSwizzle_Kind: |
| return this->compileVectorSwizzle(builder, (const Swizzle&) expr, out); |
| case Expression::kVariableReference_Kind: |
| return this->compileVectorVariableReference(builder, (const VariableReference&) expr, |
| out); |
| default: |
| return false; |
| } |
| } |
| |
| bool JIT::compileVectorStatement(LLVMBuilderRef builder, const Statement& stmt) { |
| switch (stmt.fKind) { |
| case Statement::kBlock_Kind: |
| for (const auto& s : ((const Block&) stmt).fStatements) { |
| if (!this->compileVectorStatement(builder, *s)) { |
| return false; |
| } |
| } |
| return true; |
| case Statement::kExpression_Kind: |
| LLVMValueRef result; |
| return this->compileVectorExpression(builder, |
| *((const ExpressionStatement&) stmt).fExpression, |
| &result); |
| default: |
| return false; |
| } |
| } |
| |
| bool JIT::compileStageFunctionVector(const FunctionDefinition& f, LLVMValueRef newFunc) { |
| LLVMValueRef oldFunction = fCurrentFunction; |
| fCurrentFunction = newFunc; |
| std::unique_ptr<LLVMValueRef[]> params(new LLVMValueRef[STAGE_PARAM_COUNT]); |
| LLVMGetParams(fCurrentFunction, params.get()); |
| LLVMValueRef programParam = params.get()[1]; |
| LLVMBuilderRef builder = LLVMCreateBuilderInContext(fContext); |
| LLVMBasicBlockRef oldAllocaBlock = fAllocaBlock; |
| LLVMBasicBlockRef oldCurrentBlock = fCurrentBlock; |
| fAllocaBlock = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "alloca"); |
| this->setBlock(builder, fAllocaBlock); |
| fChannels[0] = LLVMBuildAlloca(builder, fFloat32VectorType, "rVec"); |
| LLVMBuildStore(builder, params.get()[4], fChannels[0]); |
| fChannels[1] = LLVMBuildAlloca(builder, fFloat32VectorType, "gVec"); |
| LLVMBuildStore(builder, params.get()[5], fChannels[1]); |
| fChannels[2] = LLVMBuildAlloca(builder, fFloat32VectorType, "bVec"); |
| LLVMBuildStore(builder, params.get()[6], fChannels[2]); |
| fChannels[3] = LLVMBuildAlloca(builder, fFloat32VectorType, "aVec"); |
| LLVMBuildStore(builder, params.get()[7], fChannels[3]); |
| LLVMBasicBlockRef start = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "start"); |
| this->setBlock(builder, start); |
| bool success = this->compileVectorStatement(builder, *f.fBody); |
| if (success) { |
| // increment program pointer, call next |
| LLVMValueRef rawNextPtr = LLVMBuildLoad(builder, programParam, "next load"); |
| LLVMTypeRef stageFuncType = LLVMTypeOf(newFunc); |
| LLVMValueRef nextPtr = LLVMBuildBitCast(builder, rawNextPtr, stageFuncType, |
| "cast next->func"); |
| LLVMValueRef nextInc = LLVMBuildIntToPtr(builder, |
| LLVMBuildAdd(builder, |
| LLVMBuildPtrToInt(builder, |
| programParam, |
| fInt64Type, |
| "cast 1"), |
| LLVMConstInt(fInt64Type, PTR_SIZE, |
| false), |
| "add"), |
| LLVMPointerType(fInt8PtrType, 0), "cast 2"); |
| LLVMValueRef args[STAGE_PARAM_COUNT] = { |
| params.get()[0], |
| nextInc, |
| params.get()[2], |
| params.get()[3], |
| LLVMBuildLoad(builder, fChannels[0], "rVec"), |
| LLVMBuildLoad(builder, fChannels[1], "gVec"), |
| LLVMBuildLoad(builder, fChannels[2], "bVec"), |
| LLVMBuildLoad(builder, fChannels[3], "aVec"), |
| params.get()[8], |
| params.get()[9], |
| params.get()[10], |
| params.get()[11] |
| }; |
| LLVMBuildCall(builder, nextPtr, args, STAGE_PARAM_COUNT, ""); |
| LLVMBuildRetVoid(builder); |
| // finish |
| LLVMPositionBuilderAtEnd(builder, fAllocaBlock); |
| LLVMBuildBr(builder, start); |
| LLVMDisposeBuilder(builder); |
| if (LLVMVerifyFunction(fCurrentFunction, LLVMPrintMessageAction)) { |
| ABORT("verify failed\n"); |
| } |
| } else { |
| LLVMDeleteBasicBlock(fAllocaBlock); |
| LLVMDeleteBasicBlock(start); |
| } |
| |
| fAllocaBlock = oldAllocaBlock; |
| fCurrentBlock = oldCurrentBlock; |
| fCurrentFunction = oldFunction; |
| return success; |
| } |
| |
| LLVMValueRef JIT::compileStageFunction(const FunctionDefinition& f) { |
| LLVMTypeRef returnType = fVoidType; |
| LLVMTypeRef parameterTypes[12] = { fSizeTType, LLVMPointerType(fInt8PtrType, 0), fSizeTType, |
| fSizeTType, fFloat32VectorType, fFloat32VectorType, |
| fFloat32VectorType, fFloat32VectorType, fFloat32VectorType, |
| fFloat32VectorType, fFloat32VectorType, fFloat32VectorType }; |
| LLVMTypeRef stageFuncType = LLVMFunctionType(returnType, parameterTypes, 12, false); |
| LLVMValueRef result = LLVMAddFunction(fModule, |
| (String(f.fDeclaration.fName) + "$stage").c_str(), |
| stageFuncType); |
| fColorParam = f.fDeclaration.fParameters[2]; |
| if (!this->compileStageFunctionVector(f, result)) { |
| // vectorization failed, fall back to looping over the pixels |
| this->compileStageFunctionLoop(f, result); |
| } |
| return result; |
| } |
| |
| bool JIT::hasStageSignature(const FunctionDeclaration& f) { |
| return f.fReturnType == *fProgram->fContext->fVoid_Type && |
| f.fParameters.size() == 3 && |
| f.fParameters[0]->fType == *fProgram->fContext->fInt_Type && |
| f.fParameters[0]->fModifiers.fFlags == 0 && |
| f.fParameters[1]->fType == *fProgram->fContext->fInt_Type && |
| f.fParameters[1]->fModifiers.fFlags == 0 && |
| f.fParameters[2]->fType == *fProgram->fContext->fHalf4_Type && |
| f.fParameters[2]->fModifiers.fFlags == (Modifiers::kIn_Flag | Modifiers::kOut_Flag); |
| } |
| |
| LLVMValueRef JIT::compileFunction(const FunctionDefinition& f) { |
| if (this->hasStageSignature(f.fDeclaration)) { |
| this->compileStageFunction(f); |
| // we compile foo$stage *in addition* to compiling foo, as we can't be sure that the intent |
| // was to produce an SkJumper stage just because the signature matched or that the function |
| // is not otherwise called. May need a better way to handle this. |
| } |
| LLVMTypeRef returnType = this->getType(f.fDeclaration.fReturnType); |
| std::vector<LLVMTypeRef> parameterTypes; |
| for (const auto& p : f.fDeclaration.fParameters) { |
| LLVMTypeRef type = this->getType(p->fType); |
| if (p->fModifiers.fFlags & Modifiers::kOut_Flag) { |
| type = LLVMPointerType(type, 0); |
| } |
| parameterTypes.push_back(type); |
| } |
| fCurrentFunction = LLVMAddFunction(fModule, |
| String(f.fDeclaration.fName).c_str(), |
| LLVMFunctionType(returnType, parameterTypes.data(), |
| parameterTypes.size(), false)); |
| fFunctions[&f.fDeclaration] = fCurrentFunction; |
| |
| std::unique_ptr<LLVMValueRef[]> params(new LLVMValueRef[parameterTypes.size()]); |
| LLVMGetParams(fCurrentFunction, params.get()); |
| for (size_t i = 0; i < f.fDeclaration.fParameters.size(); ++i) { |
| fVariables[f.fDeclaration.fParameters[i]] = params.get()[i]; |
| } |
| LLVMBuilderRef builder = LLVMCreateBuilderInContext(fContext); |
| fAllocaBlock = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "alloca"); |
| LLVMBasicBlockRef start = LLVMAppendBasicBlockInContext(fContext, fCurrentFunction, "start"); |
| fCurrentBlock = start; |
| LLVMPositionBuilderAtEnd(builder, fCurrentBlock); |
| this->compileStatement(builder, *f.fBody); |
| if (!ends_with_branch(*f.fBody)) { |
| if (f.fDeclaration.fReturnType == *fProgram->fContext->fVoid_Type) { |
| LLVMBuildRetVoid(builder); |
| } else { |
| LLVMBuildUnreachable(builder); |
| } |
| } |
| LLVMPositionBuilderAtEnd(builder, fAllocaBlock); |
| LLVMBuildBr(builder, start); |
| LLVMDisposeBuilder(builder); |
| if (LLVMVerifyFunction(fCurrentFunction, LLVMPrintMessageAction)) { |
| ABORT("verify failed\n"); |
| } |
| return fCurrentFunction; |
| } |
| |
| void JIT::createModule() { |
| fPromotedParameters.clear(); |
| fModule = LLVMModuleCreateWithNameInContext("skslmodule", fContext); |
| this->loadBuiltinFunctions(); |
| LLVMTypeRef fold2Params[1] = { fInt1Vector2Type }; |
| fFoldAnd2Func = LLVMAddFunction(fModule, "llvm.experimental.vector.reduce.and.i1.v2i1", |
| LLVMFunctionType(fInt1Type, fold2Params, 1, false)); |
| fFoldOr2Func = LLVMAddFunction(fModule, "llvm.experimental.vector.reduce.or.i1.v2i1", |
| LLVMFunctionType(fInt1Type, fold2Params, 1, false)); |
| LLVMTypeRef fold3Params[1] = { fInt1Vector3Type }; |
| fFoldAnd3Func = LLVMAddFunction(fModule, "llvm.experimental.vector.reduce.and.i1.v3i1", |
| LLVMFunctionType(fInt1Type, fold3Params, 1, false)); |
| fFoldOr3Func = LLVMAddFunction(fModule, "llvm.experimental.vector.reduce.or.i1.v3i1", |
| LLVMFunctionType(fInt1Type, fold3Params, 1, false)); |
| LLVMTypeRef fold4Params[1] = { fInt1Vector4Type }; |
| fFoldAnd4Func = LLVMAddFunction(fModule, "llvm.experimental.vector.reduce.and.i1.v4i1", |
| LLVMFunctionType(fInt1Type, fold4Params, 1, false)); |
| fFoldOr4Func = LLVMAddFunction(fModule, "llvm.experimental.vector.reduce.or.i1.v4i1", |
| LLVMFunctionType(fInt1Type, fold4Params, 1, false)); |
| // LLVM doesn't do void*, have to declare it as int8* |
| LLVMTypeRef appendParams[3] = { fInt8PtrType, fInt32Type, fInt8PtrType }; |
| fAppendFunc = LLVMAddFunction(fModule, "sksl_pipeline_append", LLVMFunctionType(fVoidType, |
| appendParams, |
| 3, |
| false)); |
| LLVMTypeRef appendCallbackParams[2] = { fInt8PtrType, fInt8PtrType }; |
| fAppendCallbackFunc = LLVMAddFunction(fModule, "sksl_pipeline_append_callback", |
| LLVMFunctionType(fVoidType, appendCallbackParams, 2, |
| false)); |
| |
| LLVMTypeRef debugParams[3] = { fFloat32Type }; |
| fDebugFunc = LLVMAddFunction(fModule, "sksl_debug_print", LLVMFunctionType(fVoidType, |
| debugParams, |
| 1, |
| false)); |
| |
| for (const auto& e : *fProgram) { |
| if (e.fKind == ProgramElement::kFunction_Kind) { |
| this->compileFunction((FunctionDefinition&) e); |
| } |
| } |
| } |
| |
| std::unique_ptr<JIT::Module> JIT::compile(std::unique_ptr<Program> program) { |
| fCompiler.optimize(*program); |
| fProgram = std::move(program); |
| this->createModule(); |
| this->optimize(); |
| return std::unique_ptr<Module>(new Module(std::move(fProgram), fSharedModule, fJITStack)); |
| } |
| |
| void JIT::optimize() { |
| LLVMPassManagerBuilderRef pmb = LLVMPassManagerBuilderCreate(); |
| LLVMPassManagerBuilderSetOptLevel(pmb, 3); |
| LLVMPassManagerRef functionPM = LLVMCreateFunctionPassManagerForModule(fModule); |
| LLVMPassManagerBuilderPopulateFunctionPassManager(pmb, functionPM); |
| LLVMPassManagerRef modulePM = LLVMCreatePassManager(); |
| LLVMPassManagerBuilderPopulateModulePassManager(pmb, modulePM); |
| LLVMInitializeFunctionPassManager(functionPM); |
| |
| LLVMValueRef func = LLVMGetFirstFunction(fModule); |
| for (;;) { |
| if (!func) { |
| break; |
| } |
| LLVMRunFunctionPassManager(functionPM, func); |
| func = LLVMGetNextFunction(func); |
| } |
| LLVMRunPassManager(modulePM, fModule); |
| LLVMDisposePassManager(functionPM); |
| LLVMDisposePassManager(modulePM); |
| LLVMPassManagerBuilderDispose(pmb); |
| |
| std::string error_string; |
| if (LLVMLoadLibraryPermanently(nullptr)) { |
| ABORT("LLVMLoadLibraryPermanently failed"); |
| } |
| char* defaultTriple = LLVMGetDefaultTargetTriple(); |
| char* error; |
| LLVMTargetRef target; |
| if (LLVMGetTargetFromTriple(defaultTriple, &target, &error)) { |
| ABORT("LLVMGetTargetFromTriple failed"); |
| } |
| |
| if (!LLVMTargetHasJIT(target)) { |
| ABORT("!LLVMTargetHasJIT"); |
| } |
| LLVMTargetMachineRef targetMachine = LLVMCreateTargetMachine(target, |
| defaultTriple, |
| fCPU, |
| nullptr, |
| LLVMCodeGenLevelDefault, |
| LLVMRelocDefault, |
| LLVMCodeModelJITDefault); |
| LLVMDisposeMessage(defaultTriple); |
| LLVMTargetDataRef dataLayout = LLVMCreateTargetDataLayout(targetMachine); |
| LLVMSetModuleDataLayout(fModule, dataLayout); |
| LLVMDisposeTargetData(dataLayout); |
| |
| fJITStack = LLVMOrcCreateInstance(targetMachine); |
| fSharedModule = LLVMOrcMakeSharedModule(fModule); |
| LLVMOrcModuleHandle orcModule; |
| LLVMOrcAddEagerlyCompiledIR(fJITStack, &orcModule, fSharedModule, |
| (LLVMOrcSymbolResolverFn) resolveSymbol, this); |
| LLVMDisposeTargetMachine(targetMachine); |
| } |
| |
| void* JIT::Module::getSymbol(const char* name) { |
| LLVMOrcTargetAddress result; |
| if (LLVMOrcGetSymbolAddress(fJITStack, &result, name)) { |
| ABORT("GetSymbolAddress error"); |
| } |
| if (!result) { |
| ABORT("symbol not found"); |
| } |
| return (void*) result; |
| } |
| |
| void* JIT::Module::getJumperStage(const char* name) { |
| return this->getSymbol((String(name) + "$stage").c_str()); |
| } |
| |
| } // namespace |
| |
| #endif // SK_LLVM_AVAILABLE |
| |
| #endif // SKSL_STANDALONE |
