fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e35fdff63273f45b259b78ecad0119626773a99a
Xenia-Canary/src/xenia/gpu/spirv/spv_emitter.cc

2258 lines
71 KiB
C++
Raw Blame History

/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
// Contents originally forked from:
// https://github.com/KhronosGroup/glslang/
//
// Copyright (C) 2014 LunarG, Inc.
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#include "xenia/gpu/spirv/spv_emitter.h"
#include <unordered_set>
#include "xenia/base/assert.h"
#include "xenia/base/logging.h"
namespace xe {
namespace gpu {
namespace spirv {
SpvEmitter::SpvEmitter() { clearAccessChain(); }
SpvEmitter::~SpvEmitter() = default;
Id SpvEmitter::import(const char* name) {
auto import = new Instruction(getUniqueId(), NoType, Op::OpExtInstImport);
import->addStringOperand(name);
imports_.push_back(import);
return import->result_id();
}
// For creating new grouped_types_ (will return old type if the requested one
// was
// already made).
Id SpvEmitter::makeVoidType() {
Instruction* type;
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeVoid)];
if (grouped_type.empty()) {
type = new Instruction(getUniqueId(), NoType, Op::OpTypeVoid);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
} else {
type = grouped_type.back();
}
return type->result_id();
}
Id SpvEmitter::makeBoolType() {
Instruction* type;
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeBool)];
if (grouped_type.empty()) {
type = new Instruction(getUniqueId(), NoType, Op::OpTypeBool);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
} else {
type = grouped_type.back();
}
return type->result_id();
}
Id SpvEmitter::makeSamplerType() {
Instruction* type;
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeSampler)];
if (grouped_type.empty()) {
type = new Instruction(getUniqueId(), NoType, Op::OpTypeSampler);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
} else {
type = grouped_type.back();
}
return type->result_id();
}
Id SpvEmitter::makePointer(spv::StorageClass storage_class, Id pointee) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypePointer)];
for (auto& type : grouped_type) {
if (type->immediate_operand(0) == (unsigned)storage_class &&
type->id_operand(1) == pointee) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypePointer);
type->addImmediateOperand(storage_class);
type->addIdOperand(pointee);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeIntegerType(int width, bool hasSign) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeInt)];
for (auto& type : grouped_type) {
if (type->immediate_operand(0) == (unsigned)width &&
type->immediate_operand(1) == (hasSign ? 1u : 0u)) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeInt);
type->addImmediateOperand(width);
type->addImmediateOperand(hasSign ? 1 : 0);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeFloatType(int width) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeFloat)];
for (auto& type : grouped_type) {
if (type->immediate_operand(0) == (unsigned)width) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeFloat);
type->addImmediateOperand(width);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
// Make a struct without checking for duplication.
// See makeStructResultType() for non-decorated structs
// needed as the result of some instructions, which does
// check for duplicates.
Id SpvEmitter::makeStructType(std::vector<Id>& members, const char* name) {
// Don't look for previous one, because in the general case,
// structs can be duplicated except for decorations.
// not found, make it
Instruction* type = new Instruction(getUniqueId(), NoType, Op::OpTypeStruct);
type->addIdOperands(members);
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeStruct)];
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
addName(type->result_id(), name);
return type->result_id();
}
// Make a struct for the simple results of several instructions,
// checking for duplication.
Id SpvEmitter::makeStructResultType(Id type0, Id type1) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeStruct)];
for (auto& type : grouped_type) {
if (type->operand_count() != 2) {
continue;
}
if (type->id_operand(0) != type0 || type->id_operand(1) != type1) {
continue;
}
return type->result_id();
}
// not found, make it
std::vector<spv::Id> members;
members.push_back(type0);
members.push_back(type1);
return makeStructType(members, "ResType");
}
Id SpvEmitter::makeVectorType(Id component, int size) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeVector)];
for (auto& type : grouped_type) {
if (type->id_operand(0) == component &&
type->immediate_operand(1) == (unsigned)size) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeVector);
type->addIdOperand(component);
type->addImmediateOperand(size);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeMatrixType(Id component, int cols, int rows) {
assert(cols <= kMaxMatrixSize && rows <= kMaxMatrixSize);
Id column = makeVectorType(component, rows);
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeMatrix)];
for (auto& type : grouped_type) {
if (type->id_operand(0) == column &&
type->immediate_operand(1) == (unsigned)cols) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeMatrix);
type->addIdOperand(column);
type->addImmediateOperand(cols);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeArrayType(Id element, unsigned size) {
// First, we need a constant instruction for the size
Id sizeId = makeUintConstant(size);
// try to find existing type
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeArray)];
for (auto& type : grouped_type) {
if (type->id_operand(0) == element && type->id_operand(1) == sizeId) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeArray);
type->addIdOperand(element);
type->addIdOperand(sizeId);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeRuntimeArray(Id element) {
Instruction* type =
new Instruction(getUniqueId(), NoType, Op::OpTypeRuntimeArray);
type->addIdOperand(element);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeFunctionType(Id return_type, std::vector<Id>& param_types) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeFunction)];
for (auto& type : grouped_type) {
if (type->id_operand(0) != return_type ||
(int)param_types.size() != type->operand_count() - 1) {
continue;
}
bool mismatch = false;
for (int p = 0; p < (int)param_types.size(); ++p) {
if (param_types[p] != type->id_operand(p + 1)) {
mismatch = true;
break;
}
}
if (!mismatch) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeFunction);
type->addIdOperand(return_type);
type->addIdOperands(param_types);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeImageType(Id sampledType, spv::Dim dim, bool depth,
bool arrayed, bool ms, unsigned sampled,
spv::ImageFormat format) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeImage)];
for (auto& type : grouped_type) {
if (type->id_operand(0) == sampledType &&
type->immediate_operand(1) == (unsigned int)dim &&
type->immediate_operand(2) == (depth ? 1u : 0u) &&
type->immediate_operand(3) == (arrayed ? 1u : 0u) &&
type->immediate_operand(4) == (ms ? 1u : 0u) &&
type->immediate_operand(5) == sampled &&
type->immediate_operand(6) == (unsigned int)format) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeImage);
type->addIdOperand(sampledType);
type->addImmediateOperand(dim);
type->addImmediateOperand(depth ? 1 : 0);
type->addImmediateOperand(arrayed ? 1 : 0);
type->addImmediateOperand(ms ? 1 : 0);
type->addImmediateOperand(sampled);
type->addImmediateOperand((unsigned int)format);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::makeSampledImageType(Id imageType) {
// try to find it
auto& grouped_type = grouped_types_[static_cast<int>(Op::OpTypeSampledImage)];
for (auto& type : grouped_type) {
if (type->id_operand(0) == imageType) {
return type->result_id();
}
}
// not found, make it
auto type = new Instruction(getUniqueId(), NoType, Op::OpTypeSampledImage);
type->addIdOperand(imageType);
grouped_type.push_back(type);
constants_types_globals_.push_back(type);
module_.mapInstruction(type);
return type->result_id();
}
Id SpvEmitter::getDerefTypeId(Id result_id) const {
Id type_id = getTypeId(result_id);
assert(isPointerType(type_id));
return module_.getInstruction(type_id)->immediate_operand(1);
}
Op SpvEmitter::getMostBasicTypeClass(Id type_id) const {
auto instr = module_.getInstruction(type_id);
Op type_class = instr->opcode();
switch (type_class) {
case Op::OpTypeVoid:
case Op::OpTypeBool:
case Op::OpTypeInt:
case Op::OpTypeFloat:
case Op::OpTypeStruct:
return type_class;
case Op::OpTypeVector:
case Op::OpTypeMatrix:
case Op::OpTypeArray:
case Op::OpTypeRuntimeArray:
return getMostBasicTypeClass(instr->id_operand(0));
case Op::OpTypePointer:
return getMostBasicTypeClass(instr->id_operand(1));
default:
assert(0);
return Op::OpTypeFloat;
}
}
int SpvEmitter::getNumTypeComponents(Id type_id) const {
auto instr = module_.getInstruction(type_id);
switch (instr->opcode()) {
case Op::OpTypeBool:
case Op::OpTypeInt:
case Op::OpTypeFloat:
return 1;
case Op::OpTypeVector:
case Op::OpTypeMatrix:
return instr->immediate_operand(1);
default:
assert(0);
return 1;
}
}
// Return the lowest-level type of scalar that an homogeneous composite is made
// out of.
// Typically, this is just to find out if something is made out of ints or
// floats.
// However, it includes returning a structure, if say, it is an array of
// structure.
Id SpvEmitter::getScalarTypeId(Id type_id) const {
auto instr = module_.getInstruction(type_id);
Op type_class = instr->opcode();
switch (type_class) {
case Op::OpTypeVoid:
case Op::OpTypeBool:
case Op::OpTypeInt:
case Op::OpTypeFloat:
case Op::OpTypeStruct:
return instr->result_id();
case Op::OpTypeVector:
case Op::OpTypeMatrix:
case Op::OpTypeArray:
case Op::OpTypeRuntimeArray:
case Op::OpTypePointer:
return getScalarTypeId(getContainedTypeId(type_id));
default:
assert(0);
return NoResult;
}
}
// Return the type of 'member' of a composite.
Id SpvEmitter::getContainedTypeId(Id type_id, int member) const {
auto instr = module_.getInstruction(type_id);
Op type_class = instr->opcode();
switch (type_class) {
case Op::OpTypeVector:
case Op::OpTypeMatrix:
case Op::OpTypeArray:
case Op::OpTypeRuntimeArray:
return instr->id_operand(0);
case Op::OpTypePointer:
return instr->id_operand(1);
case Op::OpTypeStruct:
return instr->id_operand(member);
default:
assert(0);
return NoResult;
}
}
// Return the immediately contained type of a given composite type.
Id SpvEmitter::getContainedTypeId(Id type_id) const {
return getContainedTypeId(type_id, 0);
}
// See if a scalar constant of this type has already been created, so it
// can be reused rather than duplicated. (Required by the specification).
Id SpvEmitter::findScalarConstant(Op type_class, Op opcode, Id type_id,
unsigned value) const {
auto& grouped_constant = grouped_constants_[static_cast<int>(type_class)];
for (auto& constant : grouped_constant) {
if (constant->opcode() == opcode && constant->type_id() == type_id &&
constant->immediate_operand(0) == value) {
return constant->result_id();
}
}
return 0;
}
// Version of findScalarConstant (see above) for scalars that take two operands
// (e.g. a 'double').
Id SpvEmitter::findScalarConstant(Op type_class, Op opcode, Id type_id,
unsigned v1, unsigned v2) const {
auto& grouped_constant = grouped_constants_[static_cast<int>(type_class)];
for (auto& constant : grouped_constant) {
if (constant->opcode() == opcode && constant->type_id() == type_id &&
constant->immediate_operand(0) == v1 &&
constant->immediate_operand(1) == v2) {
return constant->result_id();
}
}
return 0;
}
// Return true if consuming 'opcode' means consuming a constant.
// "constant" here means after final transform to executable code,
// the value consumed will be a constant, so includes specialization.
bool SpvEmitter::isConstantOpCode(Op opcode) const {
switch (opcode) {
case Op::OpUndef:
case Op::OpConstantTrue:
case Op::OpConstantFalse:
case Op::OpConstant:
case Op::OpConstantComposite:
case Op::OpConstantSampler:
case Op::OpConstantNull:
case Op::OpSpecConstantTrue:
case Op::OpSpecConstantFalse:
case Op::OpSpecConstant:
case Op::OpSpecConstantComposite:
case Op::OpSpecConstantOp:
return true;
default:
return false;
}
}
Id SpvEmitter::makeBoolConstant(bool b, bool is_spec_constant) {
Id type_id = makeBoolType();
Op opcode = is_spec_constant
? (b ? Op::OpSpecConstantTrue : Op::OpSpecConstantFalse)
: (b ? Op::OpConstantTrue : Op::OpConstantFalse);
// See if we already made it
Id existing = 0;
auto& grouped_constant = grouped_constants_[static_cast<int>(Op::OpTypeBool)];
for (auto& constant : grouped_constant) {
if (constant->type_id() == type_id && constant->opcode() == opcode) {
existing = constant->result_id();
}
}
if (existing) {
return existing;
}
// Make it
auto c = new Instruction(getUniqueId(), type_id, opcode);
constants_types_globals_.push_back(c);
grouped_constants_[static_cast<int>(Op::OpTypeBool)].push_back(c);
module_.mapInstruction(c);
return c->result_id();
}
Id SpvEmitter::makeIntConstant(Id type_id, unsigned value,
bool is_spec_constant) {
Op opcode = is_spec_constant ? Op::OpSpecConstant : Op::OpConstant;
Id existing = findScalarConstant(Op::OpTypeInt, opcode, type_id, value);
if (existing) {
return existing;
}
auto c = new Instruction(getUniqueId(), type_id, opcode);
c->addImmediateOperand(value);
constants_types_globals_.push_back(c);
grouped_constants_[static_cast<int>(Op::OpTypeInt)].push_back(c);
module_.mapInstruction(c);
return c->result_id();
}
Id SpvEmitter::makeFloatConstant(float f, bool is_spec_constant) {
Op opcode = is_spec_constant ? Op::OpSpecConstant : Op::OpConstant;
Id type_id = makeFloatType(32);
unsigned value = *(unsigned int*)&f;
Id existing = findScalarConstant(Op::OpTypeFloat, opcode, type_id, value);
if (existing) {
return existing;
}
auto c = new Instruction(getUniqueId(), type_id, opcode);
c->addImmediateOperand(value);
constants_types_globals_.push_back(c);
grouped_constants_[static_cast<int>(Op::OpTypeFloat)].push_back(c);
module_.mapInstruction(c);
return c->result_id();
}
Id SpvEmitter::makeDoubleConstant(double d, bool is_spec_constant) {
Op opcode = is_spec_constant ? Op::OpSpecConstant : Op::OpConstant;
Id type_id = makeFloatType(64);
unsigned long long value = *(unsigned long long*)&d;
unsigned op1 = value & 0xFFFFFFFF;
unsigned op2 = value >> 32;
Id existing = findScalarConstant(Op::OpTypeFloat, opcode, type_id, op1, op2);
if (existing) {
return existing;
}
auto c = new Instruction(getUniqueId(), type_id, opcode);
c->addImmediateOperand(op1);
c->addImmediateOperand(op2);
constants_types_globals_.push_back(c);
grouped_constants_[static_cast<int>(Op::OpTypeFloat)].push_back(c);
module_.mapInstruction(c);
return c->result_id();
}
Id SpvEmitter::findCompositeConstant(Op type_class,
std::vector<Id>& comps) const {
Instruction* constant = nullptr;
bool found = false;
auto& grouped_constant = grouped_constants_[static_cast<int>(type_class)];
for (auto& constant : grouped_constant) {
// same shape?
if (constant->operand_count() != (int)comps.size()) {
continue;
}
// same contents?
bool mismatch = false;
for (int op = 0; op < constant->operand_count(); ++op) {
if (constant->id_operand(op) != comps[op]) {
mismatch = true;
break;
}
}
if (!mismatch) {
found = true;
break;
}
}
return found ? constant->result_id() : NoResult;
}
Id SpvEmitter::makeCompositeConstant(Id type_id, std::vector<Id>& members) {
assert(type_id);
Op type_class = getTypeClass(type_id);
switch (type_class) {
case Op::OpTypeVector:
case Op::OpTypeArray:
case Op::OpTypeStruct:
case Op::OpTypeMatrix:
break;
default:
assert(0);
return makeFloatConstant(0.0);
}
Id existing = findCompositeConstant(type_class, members);
if (existing) {
return existing;
}
auto c = new Instruction(getUniqueId(), type_id, Op::OpConstantComposite);
c->addIdOperands(members);
constants_types_globals_.push_back(c);
grouped_constants_[static_cast<int>(type_class)].push_back(c);
module_.mapInstruction(c);
return c->result_id();
}
Instruction* SpvEmitter::addEntryPoint(spv::ExecutionModel model,
Function* function, const char* name) {
auto entry_point = new Instruction(Op::OpEntryPoint);
entry_point->addImmediateOperand(model);
entry_point->addIdOperand(function->id());
entry_point->addStringOperand(name);
entry_points_.push_back(entry_point);
return entry_point;
}
// Currently relying on the fact that all 'value' of interest are small
// non-negative values.
void SpvEmitter::addExecutionMode(Function* entry_point,
spv::ExecutionMode mode, int value1,
int value2, int value3) {
auto instr = new Instruction(Op::OpExecutionMode);
instr->addIdOperand(entry_point->id());
instr->addImmediateOperand(mode);
if (value1 >= 0) {
instr->addImmediateOperand(value1);
}
if (value2 >= 0) {
instr->addImmediateOperand(value2);
}
if (value3 >= 0) {
instr->addImmediateOperand(value3);
}
execution_modes_.push_back(instr);
}
void SpvEmitter::addName(Id id, const char* string) {
auto name = new Instruction(Op::OpName);
name->addIdOperand(id);
name->addStringOperand(string);
names_.push_back(name);
}
void SpvEmitter::addMemberName(Id id, int memberNumber, const char* string) {
auto name = new Instruction(Op::OpMemberName);
name->addIdOperand(id);
name->addImmediateOperand(memberNumber);
name->addStringOperand(string);
names_.push_back(name);
}
void SpvEmitter::addLine(Id target, Id file_name, int lineNum, int column) {
auto line = new Instruction(Op::OpLine);
line->addIdOperand(target);
line->addIdOperand(file_name);
line->addImmediateOperand(lineNum);
line->addImmediateOperand(column);
lines_.push_back(line);
}
void SpvEmitter::addDecoration(Id id, spv::Decoration decoration, int num) {
if (decoration == (spv::Decoration)BadValue) {
return;
}
auto dec = new Instruction(Op::OpDecorate);
dec->addIdOperand(id);
dec->addImmediateOperand(decoration);
if (num >= 0) {
dec->addImmediateOperand(num);
}
decorations_.push_back(dec);
}
void SpvEmitter::addMemberDecoration(Id id, unsigned int member,
spv::Decoration decoration, int num) {
auto dec = new Instruction(Op::OpMemberDecorate);
dec->addIdOperand(id);
dec->addImmediateOperand(member);
dec->addImmediateOperand(decoration);
if (num >= 0) {
dec->addImmediateOperand(num);
}
decorations_.push_back(dec);
}
Function* SpvEmitter::makeMain() {
assert(!main_function_);
Block* entry;
std::vector<Id> params;
main_function_ = makeFunctionEntry(makeVoidType(), "main", params, &entry);
return main_function_;
}
Function* SpvEmitter::makeFunctionEntry(Id return_type, const char* name,
std::vector<Id>& param_types,
Block** entry) {
Id type_id = makeFunctionType(return_type, param_types);
Id firstParamId =
param_types.empty() ? 0 : getUniqueIds((int)param_types.size());
auto function =
new Function(getUniqueId(), return_type, type_id, firstParamId, module_);
if (entry) {
*entry = new Block(getUniqueId(), *function);
function->push_block(*entry);
set_build_point(*entry);
}
if (name) {
addName(function->id(), name);
}
return function;
}
void SpvEmitter::makeReturn(bool implicit, Id retVal) {
if (retVal) {
auto inst = new Instruction(NoResult, NoType, Op::OpReturnValue);
inst->addIdOperand(retVal);
build_point_->push_instruction(inst);
} else {
build_point_->push_instruction(
new Instruction(NoResult, NoType, Op::OpReturn));
}
if (!implicit) {
createAndSetNoPredecessorBlock("post-return");
}
}
void SpvEmitter::leaveFunction() {
Block* block = build_point_;
Function& function = build_point_->parent();
assert(block);
// If our function did not contain a return, add a return void now.
if (!block->is_terminated()) {
// Whether we're in an unreachable (non-entry) block.
bool unreachable =
function.entry_block() != block && block->predecessor_count() == 0;
if (unreachable) {
// Given that this block is at the end of a function, it must be right
// after an
// explicit return, just remove it.
function.pop_block(block);
} else {
// We'll add a return instruction at the end of the current block,
// which for a non-void function is really error recovery (?), as the
// source
// being translated should have had an explicit return, which would have
// been
// followed by an unreachable block, which was handled above.
if (function.return_type() == makeVoidType()) {
makeReturn(true);
} else {
makeReturn(true, createUndefined(function.return_type()));
}
}
}
}
void SpvEmitter::makeDiscard() {
build_point_->push_instruction(new Instruction(Op::OpKill));
createAndSetNoPredecessorBlock("post-discard");
}
Id SpvEmitter::createVariable(spv::StorageClass storage_class, Id type,
const char* name) {
Id pointerType = makePointer(storage_class, type);
auto inst = new Instruction(getUniqueId(), pointerType, Op::OpVariable);
inst->addImmediateOperand(storage_class);
switch (storage_class) {
case spv::StorageClass::Function:
// Validation rules require the declaration in the entry block
build_point_->parent().push_local_variable(inst);
break;
default:
constants_types_globals_.push_back(inst);
module_.mapInstruction(inst);
break;
}
if (name) {
addName(inst->result_id(), name);
}
return inst->result_id();
}
Id SpvEmitter::createUndefined(Id type) {
auto inst = new Instruction(getUniqueId(), type, Op::OpUndef);
build_point_->push_instruction(inst);
return inst->result_id();
}
void SpvEmitter::createStore(Id rvalue, Id lvalue) {
auto store = new Instruction(Op::OpStore);
store->addIdOperand(lvalue);
store->addIdOperand(rvalue);
build_point_->push_instruction(store);
}
Id SpvEmitter::createLoad(Id lvalue) {
auto load =
new Instruction(getUniqueId(), getDerefTypeId(lvalue), Op::OpLoad);
load->addIdOperand(lvalue);
build_point_->push_instruction(load);
return load->result_id();
}
Id SpvEmitter::createAccessChain(spv::StorageClass storage_class, Id base,
std::vector<Id>& offsets) {
// Figure out the final resulting type.
spv::Id type_id = getTypeId(base);
assert(isPointerType(type_id) && !offsets.empty());
type_id = getContainedTypeId(type_id);
for (size_t i = 0; i < offsets.size(); ++i) {
if (isStructType(type_id)) {
assert(isConstantScalar(offsets[i]));
type_id = getContainedTypeId(type_id, getConstantScalar(offsets[i]));
} else {
type_id = getContainedTypeId(type_id, offsets[i]);
}
}
type_id = makePointer(storage_class, type_id);
// Make the instruction
auto chain = new Instruction(getUniqueId(), type_id, Op::OpAccessChain);
chain->addIdOperand(base);
chain->addIdOperands(offsets);
build_point_->push_instruction(chain);
return chain->result_id();
}
Id SpvEmitter::createArrayLength(Id base, unsigned int member) {
auto length =
new Instruction(getUniqueId(), makeIntType(32), Op::OpArrayLength);
length->addIdOperand(base);
length->addImmediateOperand(member);
build_point_->push_instruction(length);
return length->result_id();
}
Id SpvEmitter::createCompositeExtract(Id composite, Id type_id,
unsigned index) {
auto extract =
new Instruction(getUniqueId(), type_id, Op::OpCompositeExtract);
extract->addIdOperand(composite);
extract->addImmediateOperand(index);
build_point_->push_instruction(extract);
return extract->result_id();
}
Id SpvEmitter::createCompositeExtract(Id composite, Id type_id,
std::vector<unsigned>& indexes) {
auto extract =
new Instruction(getUniqueId(), type_id, Op::OpCompositeExtract);
extract->addIdOperand(composite);
extract->addImmediateOperands(indexes);
build_point_->push_instruction(extract);
return extract->result_id();
}
Id SpvEmitter::createCompositeInsert(Id object, Id composite, Id type_id,
unsigned index) {
auto insert = new Instruction(getUniqueId(), type_id, Op::OpCompositeInsert);
insert->addIdOperand(object);
insert->addIdOperand(composite);
insert->addImmediateOperand(index);
build_point_->push_instruction(insert);
return insert->result_id();
}
Id SpvEmitter::createCompositeInsert(Id object, Id composite, Id type_id,
std::vector<unsigned>& indexes) {
auto insert = new Instruction(getUniqueId(), type_id, Op::OpCompositeInsert);
insert->addIdOperand(object);
insert->addIdOperand(composite);
for (size_t i = 0; i < indexes.size(); ++i) {
insert->addImmediateOperand(indexes[i]);
}
build_point_->push_instruction(insert);
return insert->result_id();
}
Id SpvEmitter::createVectorExtractDynamic(Id vector, Id type_id,
Id component_index) {
auto extract =
new Instruction(getUniqueId(), type_id, Op::OpVectorExtractDynamic);
extract->addIdOperand(vector);
extract->addIdOperand(component_index);
build_point_->push_instruction(extract);
return extract->result_id();
}
Id SpvEmitter::createVectorInsertDynamic(Id vector, Id type_id, Id component,
Id component_index) {
auto insert =
new Instruction(getUniqueId(), type_id, Op::OpVectorInsertDynamic);
insert->addIdOperand(vector);
insert->addIdOperand(component);
insert->addIdOperand(component_index);
build_point_->push_instruction(insert);
return insert->result_id();
}
// An opcode that has no operands, no result id, and no type
void SpvEmitter::createNoResultOp(Op opcode) {
auto op = new Instruction(opcode);
build_point_->push_instruction(op);
}
// An opcode that has one operand, no result id, and no type
void SpvEmitter::createNoResultOp(Op opcode, Id operand) {
auto op = new Instruction(opcode);
op->addIdOperand(operand);
build_point_->push_instruction(op);
}
// An opcode that has one operand, no result id, and no type
void SpvEmitter::createNoResultOp(Op opcode, const std::vector<Id>& operands) {
auto op = new Instruction(opcode);
op->addIdOperands(operands);
build_point_->push_instruction(op);
}
void SpvEmitter::createControlBarrier(spv::Scope execution, spv::Scope memory,
spv::MemorySemanticsMask semantics) {
auto op = new Instruction(Op::OpControlBarrier);
op->addImmediateOperand(makeUintConstant(execution));
op->addImmediateOperand(makeUintConstant(memory));
op->addImmediateOperand(makeUintConstant(semantics));
build_point_->push_instruction(op);
}
void SpvEmitter::createMemoryBarrier(unsigned execution_scope,
unsigned memory_semantics) {
auto op = new Instruction(Op::OpMemoryBarrier);
op->addImmediateOperand(makeUintConstant(execution_scope));
op->addImmediateOperand(makeUintConstant(memory_semantics));
build_point_->push_instruction(op);
}
// An opcode that has one operands, a result id, and a type
Id SpvEmitter::createUnaryOp(Op opcode, Id type_id, Id operand) {
auto op = new Instruction(getUniqueId(), type_id, opcode);
op->addIdOperand(operand);
build_point_->push_instruction(op);
return op->result_id();
}
Id SpvEmitter::createBinOp(Op opcode, Id type_id, Id left, Id right) {
auto op = new Instruction(getUniqueId(), type_id, opcode);
op->addIdOperand(left);
op->addIdOperand(right);
build_point_->push_instruction(op);
return op->result_id();
}
Id SpvEmitter::createTriOp(Op opcode, Id type_id, Id op1, Id op2, Id op3) {
auto op = new Instruction(getUniqueId(), type_id, opcode);
op->addIdOperand(op1);
op->addIdOperand(op2);
op->addIdOperand(op3);
build_point_->push_instruction(op);
return op->result_id();
}
Id SpvEmitter::createOp(Op opcode, Id type_id,
const std::vector<Id>& operands) {
auto op = new Instruction(getUniqueId(), type_id, opcode);
op->addIdOperands(operands);
build_point_->push_instruction(op);
return op->result_id();
}
Id SpvEmitter::createFunctionCall(Function* function,
std::vector<spv::Id>& args) {
auto op = new Instruction(getUniqueId(), function->return_type(),
Op::OpFunctionCall);
op->addIdOperand(function->id());
op->addIdOperands(args);
build_point_->push_instruction(op);
return op->result_id();
}
Id SpvEmitter::createRvalueSwizzle(Id type_id, Id source,
std::vector<unsigned>& channels) {
if (channels.size() == 1)
return createCompositeExtract(source, type_id, channels.front());
auto swizzle = new Instruction(getUniqueId(), type_id, Op::OpVectorShuffle);
assert(isVector(source));
swizzle->addIdOperand(source);
swizzle->addIdOperand(source);
swizzle->addImmediateOperands(channels);
build_point_->push_instruction(swizzle);
return swizzle->result_id();
}
Id SpvEmitter::createLvalueSwizzle(Id type_id, Id target, Id source,
std::vector<unsigned>& channels) {
assert(getNumComponents(source) == (int)channels.size());
if (channels.size() == 1 && getNumComponents(source) == 1) {
return createCompositeInsert(source, target, type_id, channels.front());
}
auto swizzle = new Instruction(getUniqueId(), type_id, Op::OpVectorShuffle);
assert(isVector(source));
assert(isVector(target));
swizzle->addIdOperand(target);
swizzle->addIdOperand(source);
// Set up an identity shuffle from the base value to the result value
unsigned int components[4];
int numTargetComponents = getNumComponents(target);
for (int i = 0; i < numTargetComponents; ++i) {
components[i] = i;
}
// Punch in the l-value swizzle
for (int i = 0; i < (int)channels.size(); ++i) {
components[channels[i]] = numTargetComponents + i;
}
// finish the instruction with these components selectors
for (int i = 0; i < numTargetComponents; ++i) {
swizzle->addImmediateOperand(components[i]);
}
build_point_->push_instruction(swizzle);
return swizzle->result_id();
}
void SpvEmitter::promoteScalar(spv::Decoration precision, Id& left, Id& right) {
int direction = getNumComponents(right) - getNumComponents(left);
if (direction > 0) {
left = smearScalar(precision, left, getTypeId(right));
} else if (direction < 0) {
right = smearScalar(precision, right, getTypeId(left));
}
}
Id SpvEmitter::smearScalar(spv::Decoration precision, Id scalar,
Id vectorType) {
assert(getNumComponents(scalar) == 1);
int numComponents = getNumTypeComponents(vectorType);
if (numComponents == 1) {
return scalar;
}
auto smear =
new Instruction(getUniqueId(), vectorType, Op::OpCompositeConstruct);
for (int c = 0; c < numComponents; ++c) {
smear->addIdOperand(scalar);
}
build_point_->push_instruction(smear);
return smear->result_id();
}
Id SpvEmitter::createBuiltinCall(spv::Decoration precision, Id result_type,
Id builtins, int entry_point,
std::initializer_list<Id> args) {
auto inst = new Instruction(getUniqueId(), result_type, Op::OpExtInst);
inst->addIdOperand(builtins);
inst->addImmediateOperand(entry_point);
inst->addIdOperands(args);
build_point_->push_instruction(inst);
return inst->result_id();
}
// Accept all parameters needed to create a texture instruction.
// Create the correct instruction based on the inputs, and make the call.
Id SpvEmitter::createTextureCall(spv::Decoration precision, Id result_type,
bool fetch, bool proj, bool gather,
const TextureParameters& parameters) {
static const int maxTextureArgs = 10;
Id texArgs[maxTextureArgs] = {};
// Set up the fixed arguments
int numArgs = 0;
bool xplicit = false;
texArgs[numArgs++] = parameters.sampler;
texArgs[numArgs++] = parameters.coords;
if (parameters.Dref) {
texArgs[numArgs++] = parameters.Dref;
}
if (parameters.comp) {
texArgs[numArgs++] = parameters.comp;
}
// Set up the optional arguments
int optArgNum = numArgs; // track which operand, if it exists, is the mask of
// optional arguments
++numArgs; // speculatively make room for the mask operand
auto mask = spv::ImageOperandsMask::MaskNone; // the mask operand
if (parameters.bias) {
mask = mask | spv::ImageOperandsMask::Bias;
texArgs[numArgs++] = parameters.bias;
}
if (parameters.lod) {
mask = mask | spv::ImageOperandsMask::Lod;
texArgs[numArgs++] = parameters.lod;
xplicit = true;
}
if (parameters.gradX) {
mask = mask | spv::ImageOperandsMask::Grad;
texArgs[numArgs++] = parameters.gradX;
texArgs[numArgs++] = parameters.gradY;
xplicit = true;
}
if (parameters.offset) {
if (isConstant(parameters.offset)) {
mask = mask | spv::ImageOperandsMask::ConstOffset;
} else {
mask = mask | spv::ImageOperandsMask::Offset;
}
texArgs[numArgs++] = parameters.offset;
}
if (parameters.offsets) {
mask = mask | spv::ImageOperandsMask::ConstOffsets;
texArgs[numArgs++] = parameters.offsets;
}
if (parameters.sample) {
mask = mask | spv::ImageOperandsMask::Sample;
texArgs[numArgs++] = parameters.sample;
}
if (mask == spv::ImageOperandsMask::MaskNone) {
--numArgs; // undo speculative reservation for the mask argument
} else {
texArgs[optArgNum] = static_cast<Id>(mask);
}
// Set up the instruction
Op opcode;
opcode = Op::OpImageSampleImplicitLod;
if (fetch) {
opcode = Op::OpImageFetch;
} else if (gather) {
if (parameters.Dref)
opcode = Op::OpImageDrefGather;
else
opcode = Op::OpImageGather;
} else if (xplicit) {
if (parameters.Dref) {
if (proj)
opcode = Op::OpImageSampleProjDrefExplicitLod;
else
opcode = Op::OpImageSampleDrefExplicitLod;
} else {
if (proj)
opcode = Op::OpImageSampleProjExplicitLod;
else
opcode = Op::OpImageSampleExplicitLod;
}
} else {
if (parameters.Dref) {
if (proj)
opcode = Op::OpImageSampleProjDrefImplicitLod;
else
opcode = Op::OpImageSampleDrefImplicitLod;
} else {
if (proj)
opcode = Op::OpImageSampleProjImplicitLod;
else
opcode = Op::OpImageSampleImplicitLod;
}
}
// See if the result type is expecting a smeared result.
// This happens when a legacy shadow*() call is made, which
// gets a vec4 back instead of a float.
Id smearedType = result_type;
if (!isScalarType(result_type)) {
switch (opcode) {
case Op::OpImageSampleDrefImplicitLod:
case Op::OpImageSampleDrefExplicitLod:
case Op::OpImageSampleProjDrefImplicitLod:
case Op::OpImageSampleProjDrefExplicitLod:
result_type = getScalarTypeId(result_type);
break;
default:
break;
}
}
// Build the SPIR-V instruction
auto textureInst = new Instruction(getUniqueId(), result_type, opcode);
for (int op = 0; op < optArgNum; ++op) {
textureInst->addIdOperand(texArgs[op]);
}
if (optArgNum < numArgs) textureInst->addImmediateOperand(texArgs[optArgNum]);
for (int op = optArgNum + 1; op < numArgs; ++op) {
textureInst->addIdOperand(texArgs[op]);
}
setPrecision(textureInst->result_id(), precision);
build_point_->push_instruction(textureInst);
Id result_id = textureInst->result_id();
// When a smear is needed, do it, as per what was computed
// above when result_type was changed to a scalar type.
if (result_type != smearedType) {
result_id = smearScalar(precision, result_id, smearedType);
}
return result_id;
}
Id SpvEmitter::createTextureQueryCall(Op opcode,
const TextureParameters& parameters) {
// Figure out the result type
Id result_type = 0;
switch (opcode) {
case Op::OpImageQuerySize:
case Op::OpImageQuerySizeLod: {
int numComponents;
switch (getTypeDimensionality(getImageType(parameters.sampler))) {
case spv::Dim::Dim1D:
case spv::Dim::Buffer:
numComponents = 1;
break;
case spv::Dim::Dim2D:
case spv::Dim::Cube:
case spv::Dim::Rect:
numComponents = 2;
break;
case spv::Dim::Dim3D:
numComponents = 3;
break;
case spv::Dim::SubpassData:
CheckNotImplemented("input-attachment dim");
break;
default:
assert(0);
break;
}
if (isArrayedImageType(getImageType(parameters.sampler))) {
++numComponents;
}
if (numComponents == 1) {
result_type = makeIntType(32);
} else {
result_type = makeVectorType(makeIntType(32), numComponents);
}
break;
}
case Op::OpImageQueryLod:
result_type = makeVectorType(makeFloatType(32), 2);
break;
case Op::OpImageQueryLevels:
case Op::OpImageQuerySamples:
result_type = makeIntType(32);
break;
default:
assert(0);
break;
}
auto query = new Instruction(getUniqueId(), result_type, opcode);
query->addIdOperand(parameters.sampler);
if (parameters.coords) {
query->addIdOperand(parameters.coords);
}
if (parameters.lod) {
query->addIdOperand(parameters.lod);
}
build_point_->push_instruction(query);
return query->result_id();
}
Id SpvEmitter::createCompare(spv::Decoration precision, Id value1, Id value2,
bool equal) {
Id boolType = makeBoolType();
Id valueType = getTypeId(value1);
assert(valueType == getTypeId(value2));
assert(!isScalar(value1));
// Vectors
if (isVectorType(valueType)) {
Op op;
if (getMostBasicTypeClass(valueType) == Op::OpTypeFloat) {
op = equal ? Op::OpFOrdEqual : Op::OpFOrdNotEqual;
} else {
op = equal ? Op::OpIEqual : Op::OpINotEqual;
}
Id boolVectorType =
makeVectorType(boolType, getNumTypeComponents(valueType));
Id boolVector = createBinOp(op, boolVectorType, value1, value2);
setPrecision(boolVector, precision);
// Reduce vector compares with any() and all().
op = equal ? Op::OpAll : Op::OpAny;
return createUnaryOp(op, boolType, boolVector);
}
CheckNotImplemented("Composite comparison of non-vectors");
return NoResult;
// Recursively handle aggregates, which include matrices, arrays, and
// structures
// and accumulate the results.
// Matrices
// Arrays
// int numElements;
// const llvm::ArrayType* arrayType =
// llvm::dyn_cast<llvm::ArrayType>(value1->getType());
// if (arrayType)
// numElements = (int)arrayType->getNumElements();
// else {
// // better be structure
// const llvm::StructType* structType =
// llvm::dyn_cast<llvm::StructType>(value1->getType());
// assert(structType);
// numElements = structType->getNumElements();
//}
// assert(numElements > 0);
// for (int element = 0; element < numElements; ++element) {
// // Get intermediate comparison values
// llvm::Value* element1 = builder.CreateExtractValue(value1, element,
// "element1");
// setInstructionPrecision(element1, precision);
// llvm::Value* element2 = builder.CreateExtractValue(value2, element,
// "element2");
// setInstructionPrecision(element2, precision);
// llvm::Value* subResult = createCompare(precision, element1, element2,
// equal, "comp");
// // Accumulate intermediate comparison
// if (element == 0)
// result = subResult;
// else {
// if (equal)
// result = builder.CreateAnd(result, subResult);
// else
// result = builder.CreateOr(result, subResult);
// setInstructionPrecision(result, precision);
// }
//}
// return result;
}
// OpCompositeConstruct
Id SpvEmitter::createCompositeConstruct(Id type_id,
std::vector<Id>& constituents) {
assert(isAggregateType(type_id) ||
(getNumTypeComponents(type_id) > 1 &&
getNumTypeComponents(type_id) == (int)constituents.size()));
auto op = new Instruction(getUniqueId(), type_id, Op::OpCompositeConstruct);
op->addIdOperands(constituents);
build_point_->push_instruction(op);
return op->result_id();
}
// Vector or scalar constructor
Id SpvEmitter::createConstructor(spv::Decoration precision,
const std::vector<Id>& sources,
Id result_type_id) {
Id result = 0;
unsigned int numTargetComponents = getNumTypeComponents(result_type_id);
unsigned int targetComponent = 0;
// Special case: when calling a vector constructor with a single scalar
// argument, smear the scalar
if (sources.size() == 1 && isScalar(sources[0]) && numTargetComponents > 1) {
return smearScalar(precision, sources[0], result_type_id);
}
Id scalarTypeId = getScalarTypeId(result_type_id);
std::vector<Id>
constituents; // accumulate the arguments for OpCompositeConstruct
for (auto source : sources) {
assert(!isAggregate(source));
unsigned int sourceSize = getNumComponents(source);
unsigned int sourcesToUse = sourceSize;
if (sourcesToUse + targetComponent > numTargetComponents) {
sourcesToUse = numTargetComponents - targetComponent;
}
for (unsigned int s = 0; s < sourcesToUse; ++s) {
Id arg = source;
if (sourceSize > 1) {
std::vector<unsigned> swiz;
swiz.push_back(s);
arg = createRvalueSwizzle(scalarTypeId, arg, swiz);
}
if (numTargetComponents > 1) {
constituents.push_back(arg);
} else {
result = arg;
}
++targetComponent;
}
if (targetComponent >= numTargetComponents) {
break;
}
}
if (!constituents.empty()) {
result = createCompositeConstruct(result_type_id, constituents);
}
setPrecision(result, precision);
return result;
}
Id SpvEmitter::createMatrixConstructor(spv::Decoration precision,
const std::vector<Id>& sources,
Id result_type_id) {
Id componentTypeId = getScalarTypeId(result_type_id);
int numCols = getTypeNumColumns(result_type_id);
int numRows = getTypeNumRows(result_type_id);
// Will use a two step process
// 1. make a compile-time 2D array of values
// 2. construct a matrix from that array
// Step 1.
// initialize the array to the identity matrix
Id ids[kMaxMatrixSize][kMaxMatrixSize];
Id one = makeFloatConstant(1.0);
Id zero = makeFloatConstant(0.0);
for (int col = 0; col < 4; ++col) {
for (int row = 0; row < 4; ++row) {
if (col == row) {
ids[col][row] = one;
} else {
ids[col][row] = zero;
}
}
}
// modify components as dictated by the arguments
if (sources.size() == 1 && isScalar(sources[0])) {
// a single scalar; resets the diagonals
for (int col = 0; col < 4; ++col) {
ids[col][col] = sources[0];
}
} else if (isMatrix(sources[0])) {
// constructing from another matrix; copy over the parts that exist in both
// the argument and constructee
Id matrix = sources[0];
int minCols = std::min(numCols, getNumColumns(matrix));
int minRows = std::min(numRows, getNumRows(matrix));
for (int col = 0; col < minCols; ++col) {
std::vector<unsigned> indexes;
indexes.push_back(col);
for (int row = 0; row < minRows; ++row) {
indexes.push_back(row);
ids[col][row] =
createCompositeExtract(matrix, componentTypeId, indexes);
indexes.pop_back();
setPrecision(ids[col][row], precision);
}
}
} else {
// fill in the matrix in column-major order with whatever argument
// components are available
int row = 0;
int col = 0;
for (auto source : sources) {
Id argComp = source;
for (int comp = 0; comp < getNumComponents(source); ++comp) {
if (getNumComponents(source) > 1) {
argComp = createCompositeExtract(source, componentTypeId, comp);
setPrecision(argComp, precision);
}
ids[col][row++] = argComp;
if (row == numRows) {
row = 0;
col++;
}
}
}
}
// Step 2: Construct a matrix from that array.
// First make the column vectors, then make the matrix.
// make the column vectors
Id columnTypeId = getContainedTypeId(result_type_id);
std::vector<Id> matrixColumns;
for (int col = 0; col < numCols; ++col) {
std::vector<Id> vectorComponents;
for (int row = 0; row < numRows; ++row) {
vectorComponents.push_back(ids[col][row]);
}
matrixColumns.push_back(
createCompositeConstruct(columnTypeId, vectorComponents));
}
// make the matrix
return createCompositeConstruct(result_type_id, matrixColumns);
}
SpvEmitter::If::If(SpvEmitter& emitter, Id condition)
: emitter_(emitter), condition_(condition) {
function_ = &emitter_.build_point()->parent();
// make the blocks, but only put the then-block into the function,
// the else-block and merge-block will be added later, in order, after
// earlier code is emitted
then_block_ = new Block(emitter_.getUniqueId(), *function_);
merge_block_ = new Block(emitter_.getUniqueId(), *function_);
// Save the current block, so that we can add in the flow control split when
// makeEndIf is called.
header_block_ = emitter_.build_point();
function_->push_block(then_block_);
emitter_.set_build_point(then_block_);
}
void SpvEmitter::If::makeBeginElse() {
// Close out the "then" by having it jump to the merge_block
emitter_.createBranch(merge_block_);
// Make the first else block and add it to the function
else_block_ = new Block(emitter_.getUniqueId(), *function_);
function_->push_block(else_block_);
// Start building the else block
emitter_.set_build_point(else_block_);
}
void SpvEmitter::If::makeEndIf() {
// jump to the merge block
emitter_.createBranch(merge_block_);
// Go back to the header_block and make the flow control split
emitter_.set_build_point(header_block_);
emitter_.createSelectionMerge(merge_block_,
spv::SelectionControlMask::MaskNone);
if (else_block_) {
emitter_.createConditionalBranch(condition_, then_block_, else_block_);
} else {
emitter_.createConditionalBranch(condition_, then_block_, merge_block_);
}
// add the merge block to the function
function_->push_block(merge_block_);
emitter_.set_build_point(merge_block_);
}
void SpvEmitter::makeSwitch(Id selector, int numSegments,
std::vector<int>& caseValues,
std::vector<int>& valueIndexToSegment,
int defaultSegment,
std::vector<Block*>& segmentBlocks) {
Function& function = build_point_->parent();
// make all the blocks
for (int s = 0; s < numSegments; ++s) {
segmentBlocks.push_back(new Block(getUniqueId(), function));
}
Block* merge_block = new Block(getUniqueId(), function);
// make and insert the switch's selection-merge instruction
createSelectionMerge(merge_block, spv::SelectionControlMask::MaskNone);
// make the switch instruction
auto switchInst = new Instruction(NoResult, NoType, Op::OpSwitch);
switchInst->addIdOperand(selector);
switchInst->addIdOperand(defaultSegment >= 0
? segmentBlocks[defaultSegment]->id()
: merge_block->id());
for (int i = 0; i < (int)caseValues.size(); ++i) {
switchInst->addImmediateOperand(caseValues[i]);
switchInst->addIdOperand(segmentBlocks[valueIndexToSegment[i]]->id());
}
build_point_->push_instruction(switchInst);
// push the merge block
switch_merges_.push(merge_block);
}
void SpvEmitter::addSwitchBreak() {
// branch to the top of the merge block stack
createBranch(switch_merges_.top());
createAndSetNoPredecessorBlock("post-switch-break");
}
void SpvEmitter::nextSwitchSegment(std::vector<Block*>& segmentBlock,
int nextSegment) {
int lastSegment = nextSegment - 1;
if (lastSegment >= 0) {
// Close out previous segment by jumping, if necessary, to next segment
if (!build_point_->is_terminated()) {
createBranch(segmentBlock[nextSegment]);
}
}
Block* block = segmentBlock[nextSegment];
block->parent().push_block(block);
set_build_point(block);
}
void SpvEmitter::endSwitch(std::vector<Block*>& /*segmentBlock*/) {
// Close out previous segment by jumping, if necessary, to next segment
if (!build_point_->is_terminated()) {
addSwitchBreak();
}
switch_merges_.top()->parent().push_block(switch_merges_.top());
set_build_point(switch_merges_.top());
switch_merges_.pop();
}
void SpvEmitter::makeNewLoop(bool loopTestFirst) {
loops_.push(Loop(*this, loopTestFirst));
const Loop& loop = loops_.top();
// The loop test is always emitted before the loop body.
// But if the loop test executes at the bottom of the loop, then
// execute the test only on the second and subsequent iterations.
// Remember the block that branches to the loop header. This
// is required for the test-after-body case.
Block* preheader = build_point();
// Branch into the loop
createBranch(loop.header);
// Set ourselves inside the loop
loop.function->push_block(loop.header);
set_build_point(loop.header);
if (!loopTestFirst) {
// Generate code to defer the loop test until the second and
// subsequent iterations.
// It's always the first iteration when coming from the preheader.
// All other branches to this loop header will need to indicate "false",
// but we don't yet know where they will come from.
loop.is_first_iteration->addIdOperand(makeBoolConstant(true));
loop.is_first_iteration->addIdOperand(preheader->id());
build_point()->push_instruction(loop.is_first_iteration);
// Mark the end of the structured loop. This must exist in the loop header
// block.
createLoopMerge(loop.merge, loop.header, spv::LoopControlMask::MaskNone);
// Generate code to see if this is the first iteration of the loop.
// It needs to be in its own block, since the loop merge and
// the selection merge instructions can't both be in the same
// (header) block.
Block* firstIterationCheck = new Block(getUniqueId(), *loop.function);
createBranch(firstIterationCheck);
loop.function->push_block(firstIterationCheck);
set_build_point(firstIterationCheck);
// Control flow after this "if" normally reconverges at the loop body.
// However, the loop test has a "break branch" out of this selection
// construct because it can transfer control to the loop merge block.
createSelectionMerge(loop.body, spv::SelectionControlMask::MaskNone);
Block* loopTest = new Block(getUniqueId(), *loop.function);
createConditionalBranch(loop.is_first_iteration->result_id(), loop.body,
loopTest);
loop.function->push_block(loopTest);
set_build_point(loopTest);
}
}
void SpvEmitter::createLoopTestBranch(Id condition) {
const Loop& loop = loops_.top();
// Generate the merge instruction. If the loop test executes before
// the body, then this is a loop merge. Otherwise the loop merge
// has already been generated and this is a conditional merge.
if (loop.test_first) {
createLoopMerge(loop.merge, loop.header, spv::LoopControlMask::MaskNone);
// Branching to the "body" block will keep control inside
// the loop.
createConditionalBranch(condition, loop.body, loop.merge);
loop.function->push_block(loop.body);
set_build_point(loop.body);
} else {
// The branch to the loop merge block is the allowed exception
// to the structured control flow. Otherwise, control flow will
// continue to loop.body block. Since that is already the target
// of a merge instruction, and a block can't be the target of more
// than one merge instruction, we need to make an intermediate block.
Block* stayInLoopBlock = new Block(getUniqueId(), *loop.function);
createSelectionMerge(stayInLoopBlock, spv::SelectionControlMask::MaskNone);
// This is the loop test.
createConditionalBranch(condition, stayInLoopBlock, loop.merge);
// The dummy block just branches to the real loop body.
loop.function->push_block(stayInLoopBlock);
set_build_point(stayInLoopBlock);
createBranchToBody();
}
}
void SpvEmitter::createBranchToBody() {
const Loop& loop = loops_.top();
assert(loop.body);
// This is a reconvergence of control flow, so no merge instruction
// is required.
createBranch(loop.body);
loop.function->push_block(loop.body);
set_build_point(loop.body);
}
void SpvEmitter::createLoopContinue() {
createBranchToLoopHeaderFromInside(loops_.top());
// Set up a block for dead code.
createAndSetNoPredecessorBlock("post-loop-continue");
}
// Add an exit (e.g. "break") for the innermost loop that you're in
void SpvEmitter::createLoopExit() {
createBranch(loops_.top().merge);
// Set up a block for dead code.
createAndSetNoPredecessorBlock("post-loop-break");
}
// Close the innermost loop
void SpvEmitter::closeLoop() {
const Loop& loop = loops_.top();
// Branch back to the top
createBranchToLoopHeaderFromInside(loop);
// Add the merge block and set the build point to it
loop.function->push_block(loop.merge);
set_build_point(loop.merge);
loops_.pop();
}
// Create a branch to the header of the given loop, from inside
// the loop body.
// Adjusts the phi node for the first-iteration value if needeed.
void SpvEmitter::createBranchToLoopHeaderFromInside(const Loop& loop) {
createBranch(loop.header);
if (loop.is_first_iteration) {
loop.is_first_iteration->addIdOperand(makeBoolConstant(false));
loop.is_first_iteration->addIdOperand(build_point()->id());
}
}
void SpvEmitter::clearAccessChain() {
access_chain_.base = NoResult;
access_chain_.index_chain.clear();
access_chain_.instr = NoResult;
access_chain_.swizzle.clear();
access_chain_.component = NoResult;
access_chain_.pre_swizzle_base_type = NoType;
access_chain_.is_rvalue = false;
}
void SpvEmitter::accessChainPushSwizzle(std::vector<unsigned>& swizzle,
Id pre_swizzle_base_type) {
// swizzles can be stacked in GLSL, but simplified to a single
// one here; the base type doesn't change
if (access_chain_.pre_swizzle_base_type == NoType) {
access_chain_.pre_swizzle_base_type = pre_swizzle_base_type;
}
// if needed, propagate the swizzle for the current access chain
if (access_chain_.swizzle.size()) {
std::vector<unsigned> oldSwizzle = access_chain_.swizzle;
access_chain_.swizzle.resize(0);
for (unsigned int i = 0; i < swizzle.size(); ++i) {
access_chain_.swizzle.push_back(oldSwizzle[swizzle[i]]);
}
} else {
access_chain_.swizzle = swizzle;
}
// determine if we need to track this swizzle anymore
simplifyAccessChainSwizzle();
}
void SpvEmitter::accessChainStore(Id rvalue) {
assert(access_chain_.is_rvalue == false);
transferAccessChainSwizzle(true);
Id base = collapseAccessChain();
if (access_chain_.swizzle.size() && access_chain_.component != NoResult) {
CheckNotImplemented(
"simultaneous l-value swizzle and dynamic component selection");
}
// If swizzle still exists, it is out-of-order or not full, we must load the
// target vector,
// extract and insert elements to perform writeMask and/or swizzle.
Id source = NoResult;
if (access_chain_.swizzle.size()) {
Id tempBaseId = createLoad(base);
source = createLvalueSwizzle(getTypeId(tempBaseId), tempBaseId, rvalue,
access_chain_.swizzle);
}
// dynamic component selection
if (access_chain_.component != NoResult) {
Id tempBaseId = (source == NoResult) ? createLoad(base) : source;
source = createVectorInsertDynamic(tempBaseId, getTypeId(tempBaseId),
rvalue, access_chain_.component);
}
if (source == NoResult) {
source = rvalue;
}
createStore(source, base);
}
Id SpvEmitter::accessChainLoad(Id result_type) {
Id id;
if (access_chain_.is_rvalue) {
// transfer access chain, but keep it static, so we can stay in registers
transferAccessChainSwizzle(false);
if (!access_chain_.index_chain.empty()) {
Id swizzleBase = access_chain_.pre_swizzle_base_type != NoType
? access_chain_.pre_swizzle_base_type
: result_type;
// if all the accesses are constants, we can use OpCompositeExtract
std::vector<unsigned> indexes;
bool constant = true;
for (auto index : access_chain_.index_chain) {
if (isConstantScalar(index)) {
indexes.push_back(getConstantScalar(index));
} else {
constant = false;
break;
}
}
if (constant) {
id = createCompositeExtract(access_chain_.base, swizzleBase, indexes);
} else {
// make a new function variable for this r-value
Id lvalue = createVariable(spv::StorageClass::Function,
getTypeId(access_chain_.base), "indexable");
// store into it
createStore(access_chain_.base, lvalue);
// move base to the new variable
access_chain_.base = lvalue;
access_chain_.is_rvalue = false;
// load through the access chain
id = createLoad(collapseAccessChain());
}
} else {
id = access_chain_.base;
}
} else {
transferAccessChainSwizzle(true);
// load through the access chain
id = createLoad(collapseAccessChain());
}
// Done, unless there are swizzles to do
if (access_chain_.swizzle.empty() && access_chain_.component == NoResult) {
return id;
}
// Do remaining swizzling
// First, static swizzling
if (access_chain_.swizzle.size()) {
// static swizzle
Id swizzledType = getScalarTypeId(getTypeId(id));
if (access_chain_.swizzle.size() > 1) {
swizzledType =
makeVectorType(swizzledType, (int)access_chain_.swizzle.size());
}
id = createRvalueSwizzle(swizzledType, id, access_chain_.swizzle);
}
// dynamic single-component selection
if (access_chain_.component != NoResult) {
id = createVectorExtractDynamic(id, result_type, access_chain_.component);
}
return id;
}
Id SpvEmitter::accessChainGetLValue() {
assert(access_chain_.is_rvalue == false);
transferAccessChainSwizzle(true);
Id lvalue = collapseAccessChain();
// If swizzle exists, it is out-of-order or not full, we must load the target
// vector,
// extract and insert elements to perform writeMask and/or swizzle. This does
// not
// go with getting a direct l-value pointer.
assert(access_chain_.swizzle.empty());
assert(access_chain_.component == NoResult);
return lvalue;
}
void SpvEmitter::dump(std::vector<unsigned int>& out) const {
// Header, before first instructions:
out.push_back(spv::MagicNumber);
out.push_back(spv::Version);
out.push_back(builder_number_);
out.push_back(unique_id_ + 1);
out.push_back(0);
for (auto capability : capabilities_) {
Instruction capInst(0, 0, Op::OpCapability);
capInst.addImmediateOperand(capability);
capInst.dump(out);
}
// TBD: OpExtension ...
dumpInstructions(out, imports_);
Instruction memInst(0, 0, Op::OpMemoryModel);
memInst.addImmediateOperand(addressing_model_);
memInst.addImmediateOperand(memory_model_);
memInst.dump(out);
// Instructions saved up while building:
dumpInstructions(out, entry_points_);
dumpInstructions(out, execution_modes_);
// Debug instructions
if (source_language_ != spv::SourceLanguage::Unknown) {
Instruction sourceInst(0, 0, Op::OpSource);
sourceInst.addImmediateOperand(source_language_);
sourceInst.addImmediateOperand(source_version_);
sourceInst.dump(out);
}
for (auto extension : extensions_) {
Instruction extInst(0, 0, Op::OpSourceExtension);
extInst.addStringOperand(extension);
extInst.dump(out);
}
dumpInstructions(out, names_);
dumpInstructions(out, lines_);
// Annotation instructions
dumpInstructions(out, decorations_);
dumpInstructions(out, constants_types_globals_);
dumpInstructions(out, externals_);
// The functions
module_.dump(out);
}
// Turn the described access chain in 'accessChain' into an instruction
// computing its address. This *cannot* include complex swizzles, which must
// be handled after this is called, but it does include swizzles that select
// an individual element, as a single address of a scalar type can be
// computed by an OpAccessChain instruction.
Id SpvEmitter::collapseAccessChain() {
assert(access_chain_.is_rvalue == false);
if (!access_chain_.index_chain.empty()) {
if (!access_chain_.instr) {
auto storage_class =
module_.getStorageClass(getTypeId(access_chain_.base));
access_chain_.instr = createAccessChain(storage_class, access_chain_.base,
access_chain_.index_chain);
}
return access_chain_.instr;
} else {
return access_chain_.base;
}
// note that non-trivial swizzling is left pending...
}
// clear out swizzle if it is redundant, that is reselecting the same components
// that would be present without the swizzle.
void SpvEmitter::simplifyAccessChainSwizzle() {
// If the swizzle has fewer components than the vector, it is subsetting, and
// must stay
// to preserve that fact.
if (getNumTypeComponents(access_chain_.pre_swizzle_base_type) >
(int)access_chain_.swizzle.size()) {
return;
}
// if components are out of order, it is a swizzle
for (unsigned int i = 0; i < access_chain_.swizzle.size(); ++i) {
if (i != access_chain_.swizzle[i]) {
return;
}
}
// otherwise, there is no need to track this swizzle
access_chain_.swizzle.clear();
if (access_chain_.component == NoResult) {
access_chain_.pre_swizzle_base_type = NoType;
}
}
// To the extent any swizzling can become part of the chain
// of accesses instead of a post operation, make it so.
// If 'dynamic' is true, include transfering a non-static component index,
// otherwise, only transfer static indexes.
//
// Also, Boolean vectors are likely to be special. While
// for external storage, they should only be integer types,
// function-local bool vectors could use sub-word indexing,
// so keep that as a separate Insert/Extract on a loaded vector.
void SpvEmitter::transferAccessChainSwizzle(bool dynamic) {
// too complex?
if (access_chain_.swizzle.size() > 1) {
return;
}
// non existent?
if (access_chain_.swizzle.empty() && access_chain_.component == NoResult) {
return;
}
// single component...
// skip doing it for Boolean vectors
if (isBoolType(getContainedTypeId(access_chain_.pre_swizzle_base_type))) {
return;
}
if (access_chain_.swizzle.size() == 1) {
// handle static component
access_chain_.index_chain.push_back(
makeUintConstant(access_chain_.swizzle.front()));
access_chain_.swizzle.clear();
// note, the only valid remaining dynamic access would be to this one
// component, so don't bother even looking at access_chain_.component
access_chain_.pre_swizzle_base_type = NoType;
access_chain_.component = NoResult;
} else if (dynamic && access_chain_.component != NoResult) {
// handle dynamic component
access_chain_.index_chain.push_back(access_chain_.component);
access_chain_.pre_swizzle_base_type = NoType;
access_chain_.component = NoResult;
}
}
// Utility method for creating a new block and setting the insert point to
// be in it. This is useful for flow-control operations that need a "dummy"
// block proceeding them (e.g. instructions after a discard, etc).
void SpvEmitter::createAndSetNoPredecessorBlock(const char* name) {
Block* block = new Block(getUniqueId(), build_point_->parent());
block->set_unreachable(true);
build_point_->parent().push_block(block);
set_build_point(block);
// if (name)
// addName(block->id(), name);
}
void SpvEmitter::createBranch(Block* block) {
auto branch = new Instruction(Op::OpBranch);
branch->addIdOperand(block->id());
build_point_->push_instruction(branch);
block->push_predecessor(build_point_);
}
void SpvEmitter::createSelectionMerge(Block* merge_block,
spv::SelectionControlMask control) {
auto merge = new Instruction(Op::OpSelectionMerge);
merge->addIdOperand(merge_block->id());
merge->addImmediateOperand(control);
build_point_->push_instruction(merge);
}
void SpvEmitter::createLoopMerge(Block* merge_block, Block* continueBlock,
spv::LoopControlMask control) {
auto merge = new Instruction(Op::OpLoopMerge);
merge->addIdOperand(merge_block->id());
merge->addIdOperand(continueBlock->id());
merge->addImmediateOperand(control);
build_point_->push_instruction(merge);
}
void SpvEmitter::createConditionalBranch(Id condition, Block* then_block,
Block* else_block) {
auto branch = new Instruction(Op::OpBranchConditional);
branch->addIdOperand(condition);
branch->addIdOperand(then_block->id());
branch->addIdOperand(else_block->id());
build_point_->push_instruction(branch);
then_block->push_predecessor(build_point_);
else_block->push_predecessor(build_point_);
}
void SpvEmitter::dumpInstructions(
std::vector<unsigned int>& out,
const std::vector<Instruction*>& instructions) const {
for (int i = 0; i < (int)instructions.size(); ++i) {
instructions[i]->dump(out);
}
}
void SpvEmitter::CheckNotImplemented(const char* message) {
xe::FatalError("Missing functionality: %s", message);
}
SpvEmitter::Loop::Loop(SpvEmitter& emitter, bool testFirstArg)
: function(&emitter.build_point()->parent()),
header(new Block(emitter.getUniqueId(), *function)),
merge(new Block(emitter.getUniqueId(), *function)),
body(new Block(emitter.getUniqueId(), *function)),
test_first(testFirstArg),
is_first_iteration(nullptr) {
if (!test_first) {
// You may be tempted to rewrite this as
// new Instruction(builder.getUniqueId(), builder.makeBoolType(), OpPhi);
// This will cause subtle test failures because builder.getUniqueId(),
// and builder.makeBoolType() can then get run in a compiler-specific
// order making tests fail for certain configurations.
Id instructionId = emitter.getUniqueId();
is_first_iteration =
new Instruction(instructionId, emitter.makeBoolType(), Op::OpPhi);
}
}
} // namespace spirv
} // namespace gpu
} // namespace xe
Reference in New Issue View Git Blame Copy Permalink