/*
* Copyright 2017, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Builtin.h"
#include "cxxabi.h"
#include "spirit.h"
#include "transformer.h"
#include <stdint.h>
#include <map>
#include <string>
#include <vector>
namespace android {
namespace spirit {
namespace {
Instruction *translateClampVector(const char *name,
const FunctionCallInst *call, Transformer *tr,
Builder *b, Module *m) {
int width = name[10] - '0';
if (width < 2 || width > 4) {
return nullptr;
}
uint32_t extOpCode = 0;
switch (name[strlen(name) - 1]) {
case 'f':
extOpCode = 43;
break; // FClamp
// TODO: Do we get _Z5clampDV_uuu at all? Does LLVM convert u into i?
case 'u':
extOpCode = 44;
break; // UClamp
case 'i':
extOpCode = 45;
break; // SClamp
default:
return nullptr;
}
std::vector<IdRef> minConstituents(width, call->mOperand2[1]);
std::unique_ptr<Instruction> min(
b->MakeCompositeConstruct(call->mResultType, minConstituents));
tr->insert(min.get());
std::vector<IdRef> maxConstituents(width, call->mOperand2[2]);
std::unique_ptr<Instruction> max(
b->MakeCompositeConstruct(call->mResultType, maxConstituents));
tr->insert(max.get());
std::vector<IdRef> extOpnds = {call->mOperand2[0], min.get(), max.get()};
return b->MakeExtInst(call->mResultType, m->getGLExt(), extOpCode, extOpnds);
}
Instruction *translateExtInst(const uint32_t extOpCode,
const FunctionCallInst *call, Builder *b,
Module *m) {
return b->MakeExtInst(call->mResultType, m->getGLExt(), extOpCode,
{call->mOperand2[0]});
}
} // anonymous namespace
typedef std::function<Instruction *(const char *, const FunctionCallInst *,
Transformer *, Builder *, Module *)>
InstTrTy;
class BuiltinLookupTable {
public:
BuiltinLookupTable() {
for (sNameCode const *p = &mFPMathFuncOpCode[0]; p->name; p++) {
const char *name = p->name;
const uint32_t extOpCode = p->code;
addMapping(name, {"*"}, {{"float+"}}, {1, 2, 3, 4},
[extOpCode](const char *, const FunctionCallInst *call,
Transformer *, Builder *b, Module *m) {
return translateExtInst(extOpCode, call, b, m);
});
}
addMapping("abs", {"*"}, {{"int+"}, {"char+"}}, {1, 2, 3, 4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *m) {
return translateExtInst(5, call, b, m); // SAbs
});
addMapping("clamp", {"*"},
{{"int+", "int", "int"}, {"float+", "float", "float"}},
{1, 2, 3, 4}, [](const char *name, const FunctionCallInst *call,
Transformer *tr, Builder *b, Module *m) {
return translateClampVector(name, call, tr, b, m);
});
addMapping("convert", {"char+", "int+", "uchar+", "uint+"},
{{"char+"}, {"int+"}, {"uchar+"}, {"uint+"}}, {1, 2, 3, 4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *) -> Instruction * {
return b->MakeUConvert(call->mResultType, call->mOperand2[0]);
});
addMapping(
"convert", {"char+", "int+", "uchar+", "uint+"}, {{"float+"}},
{1, 2, 3, 4}, [](const char *, const FunctionCallInst *call,
Transformer *, Builder *b, Module *) -> Instruction * {
return b->MakeConvertFToU(call->mResultType, call->mOperand2[0]);
});
addMapping(
"convert", {"float+"}, {{"char+"}, {"int+"}, {"uchar+"}, {"uint+"}},
{1, 2, 3, 4}, [](const char *, const FunctionCallInst *call,
Transformer *, Builder *b, Module *) {
return b->MakeConvertUToF(call->mResultType, call->mOperand2[0]);
});
addMapping("dot", {"*"}, {{"float+"}}, {1, 2, 3, 4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *) {
return b->MakeDot(call->mResultType, call->mOperand2[0],
call->mOperand2[1]);
});
addMapping("min", {"*"}, {{"uint+"}, {"uchar+"}}, {1, 2, 3, 4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *m) {
return translateExtInst(38, call, b, m); // UMin
});
addMapping("min", {"*"}, {{"int+"}, {"char+"}}, {1, 2, 3, 4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *m) {
return translateExtInst(39, call, b, m); // SMin
});
addMapping("max", {"*"}, {{"uint+"}, {"uchar+"}}, {1, 2, 3, 4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *m) {
return translateExtInst(41, call, b, m); // UMax
});
addMapping("max", {"*"}, {{"int+"}, {"char+"}}, {1, 2, 3, 4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *m) {
return translateExtInst(42, call, b, m); // SMax
});
addMapping("rsUnpackColor8888", {"*"}, {{"uchar+"}}, {4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *m) {
auto cast = b->MakeBitcast(m->getUnsignedIntType(32),
call->mOperand2[0]);
return b->MakeExtInst(call->mResultType, m->getGLExt(), 64,
{cast}); // UnpackUnorm4x8
});
addMapping("rsPackColorTo8888", {"*"}, {{"float+"}}, {4},
[](const char *, const FunctionCallInst *call, Transformer *,
Builder *b, Module *m) {
// PackUnorm4x8
auto packed = b->MakeExtInst(call->mResultType, m->getGLExt(),
55, {call->mOperand2[0]});
return b->MakeBitcast(
m->getVectorType(m->getUnsignedIntType(8), 4), packed);
});
}
static const BuiltinLookupTable &getInstance() {
static BuiltinLookupTable table;
return table;
}
void addMapping(const char *funcName,
const std::vector<std::string> &retTypes,
const std::vector<std::vector<std::string>> &argTypes,
const std::vector<uint8_t> &vecWidths, InstTrTy fp) {
for (auto width : vecWidths) {
for (auto retType : retTypes) {
std::string suffixed(funcName);
if (retType != "*") {
if (retType.back() == '+') {
retType.pop_back();
if (width > 1) {
retType.append(1, '0' + width);
}
}
suffixed.append("_").append(retType);
}
for (auto argList : argTypes) {
std::string args("(");
bool first = true;
for (auto argType : argList) {
if (first) {
first = false;
} else {
args.append(", ");
}
if (argType.front() == 'u') {
argType.replace(0, 1, "unsigned ");
}
if (argType.back() == '+') {
argType.pop_back();
if (width > 1) {
argType.append(" vector[");
argType.append(1, '0' + width);
argType.append("]");
}
}
args.append(argType);
}
args.append(")");
mFuncNameMap[suffixed + args] = fp;
}
}
}
}
InstTrTy lookupTranslation(const char *mangled) const {
const char *demangled =
__cxxabiv1::__cxa_demangle(mangled, nullptr, nullptr, nullptr);
if (!demangled) {
// All RS runtime/builtin functions are overloaded, therefore
// name-mangled.
return nullptr;
}
std::string strDemangled(demangled);
auto it = mFuncNameMap.find(strDemangled);
if (it == mFuncNameMap.end()) {
return nullptr;
}
return it->second;
}
private:
std::map<std::string, InstTrTy> mFuncNameMap;
struct sNameCode {
const char *name;
uint32_t code;
};
static sNameCode constexpr mFPMathFuncOpCode[] = {
{"abs", 4}, {"sin", 13}, {"cos", 14}, {"tan", 15},
{"asin", 16}, {"acos", 17}, {"atan", 18}, {"sinh", 19},
{"cosh", 20}, {"tanh", 21}, {"asinh", 22}, {"acosh", 23},
{"atanh", 24}, {"atan2", 25}, {"pow", 26}, {"exp", 27},
{"log", 28}, {"exp2", 29}, {"log2", 30}, {"sqrt", 31},
{"modf", 35}, {"min", 37}, {"max", 40}, {"length", 66},
{"normalize", 69}, {nullptr, 0},
};
}; // BuiltinLookupTable
BuiltinLookupTable::sNameCode constexpr BuiltinLookupTable::mFPMathFuncOpCode[];
class BuiltinTransformer : public Transformer {
public:
// BEGIN: cleanup unrelated to builtin functions, but necessary for LLVM-SPIRV
// converter generated code.
// TODO: Move these in its own pass
std::vector<uint32_t> runAndSerialize(Module *module, int *error) override {
module->addExtInstImport("GLSL.std.450");
return Transformer::runAndSerialize(module, error);
}
Instruction *transform(CapabilityInst *inst) override {
if (inst->mOperand1 == Capability::Linkage ||
inst->mOperand1 == Capability::Kernel) {
return nullptr;
}
return inst;
}
Instruction *transform(ExtInstImportInst *inst) override {
if (inst->mOperand1.compare("OpenCL.std") == 0) {
return nullptr;
}
return inst;
}
Instruction *transform(SourceInst *inst) override {
if (inst->mOperand1 == SourceLanguage::Unknown) {
return nullptr;
}
return inst;
}
Instruction *transform(DecorateInst *inst) override {
if (inst->mOperand2 == Decoration::LinkageAttributes ||
inst->mOperand2 == Decoration::Alignment) {
return nullptr;
}
return inst;
}
// END: cleanup unrelated to builtin functions
Instruction *transform(FunctionCallInst *call) {
FunctionInst *func =
static_cast<FunctionInst *>(call->mOperand1.mInstruction);
// TODO: attach name to the instruction to avoid linear search in the debug
// section, i.e.,
// const char *name = func->getName();
const char *name = getModule()->lookupNameByInstruction(func);
if (!name) {
return call;
}
// Maps name into a SPIR-V instruction
auto fpTranslate =
BuiltinLookupTable::getInstance().lookupTranslation(name);
if (!fpTranslate) {
return call;
}
Instruction *inst = fpTranslate(name, call, this, &mBuilder, getModule());
if (inst) {
inst->setId(call->getId());
}
return inst;
}
private:
Builder mBuilder;
};
} // namespace spirit
} // namespace android
namespace rs2spirv {
android::spirit::Pass *CreateBuiltinPass() {
return new android::spirit::BuiltinTransformer();
}
} // namespace rs2spirv