/*
* 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