SPIRV-Tools/source/opt/insert_extract_elim.cpp
Eleni Maria Stea 045cc8f75b Fixes compile errors generated with -Wpedantic
This patch fixes the compile errors generated when the options
SPIRV_WARN_EVERYTHING and SPIRV_WERROR (that force -Wpedantic) are
set to cmake.
2018-03-22 09:40:11 -04:00

222 lines
8.5 KiB
C++

// Copyright (c) 2017 The Khronos Group Inc.
// Copyright (c) 2017 Valve Corporation
// Copyright (c) 2017 LunarG Inc.
//
// 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 "insert_extract_elim.h"
#include "composite.h"
#include "ir_context.h"
#include "iterator.h"
#include "latest_version_glsl_std_450_header.h"
#include <vector>
namespace spvtools {
namespace opt {
namespace {
const uint32_t kConstantValueInIdx = 0;
const uint32_t kExtractCompositeIdInIdx = 0;
const uint32_t kInsertObjectIdInIdx = 0;
const uint32_t kInsertCompositeIdInIdx = 1;
const uint32_t kVectorShuffleVec1IdInIdx = 0;
const uint32_t kVectorShuffleVec2IdInIdx = 1;
const uint32_t kVectorShuffleCompsInIdx = 2;
const uint32_t kTypeVectorCompTypeIdInIdx = 0;
const uint32_t kTypeVectorLengthInIdx = 1;
const uint32_t kTypeFloatWidthInIdx = 0;
const uint32_t kExtInstSetIdInIdx = 0;
const uint32_t kExtInstInstructionInIdx = 1;
const uint32_t kFMixXIdInIdx = 2;
const uint32_t kFMixYIdInIdx = 3;
const uint32_t kFMixAIdInIdx = 4;
} // anonymous namespace
uint32_t InsertExtractElimPass::DoExtract(ir::Instruction* compInst,
std::vector<uint32_t>* pExtIndices,
uint32_t extOffset) {
ir::Instruction* cinst = compInst;
uint32_t cid = 0;
uint32_t replId = 0;
while (true) {
if (cinst->opcode() == SpvOpCompositeInsert) {
if (ExtInsMatch(*pExtIndices, cinst, extOffset)) {
// Match! Use inserted value as replacement
replId = cinst->GetSingleWordInOperand(kInsertObjectIdInIdx);
break;
} else if (ExtInsConflict(*pExtIndices, cinst, extOffset)) {
// If extract has fewer indices than the insert, stop searching.
// Otherwise increment offset of extract indices considered and
// continue searching through the inserted value
if (pExtIndices->size() - extOffset < cinst->NumInOperands() - 2) {
break;
} else {
extOffset += cinst->NumInOperands() - 2;
cid = cinst->GetSingleWordInOperand(kInsertObjectIdInIdx);
}
} else {
// Consider next composite in insert chain
cid = cinst->GetSingleWordInOperand(kInsertCompositeIdInIdx);
}
} else if (cinst->opcode() == SpvOpVectorShuffle) {
// Get length of vector1
uint32_t v1_id = cinst->GetSingleWordInOperand(kVectorShuffleVec1IdInIdx);
ir::Instruction* v1_inst = get_def_use_mgr()->GetDef(v1_id);
uint32_t v1_type_id = v1_inst->type_id();
ir::Instruction* v1_type_inst = get_def_use_mgr()->GetDef(v1_type_id);
uint32_t v1_len =
v1_type_inst->GetSingleWordInOperand(kTypeVectorLengthInIdx);
// Get shuffle idx
uint32_t comp_idx = (*pExtIndices)[extOffset];
uint32_t shuffle_idx =
cinst->GetSingleWordInOperand(kVectorShuffleCompsInIdx + comp_idx);
// If undefined, give up
// TODO(greg-lunarg): Return OpUndef
if (shuffle_idx == 0xFFFFFFFF) break;
if (shuffle_idx < v1_len) {
cid = v1_id;
(*pExtIndices)[extOffset] = shuffle_idx;
} else {
cid = cinst->GetSingleWordInOperand(kVectorShuffleVec2IdInIdx);
(*pExtIndices)[extOffset] = shuffle_idx - v1_len;
}
} else if (cinst->opcode() == SpvOpExtInst &&
cinst->GetSingleWordInOperand(kExtInstSetIdInIdx) ==
get_feature_mgr()->GetExtInstImportId_GLSLstd450() &&
cinst->GetSingleWordInOperand(kExtInstInstructionInIdx) ==
GLSLstd450FMix) {
// If mixing value component is 0 or 1 we just match with x or y.
// Otherwise give up.
uint32_t comp_idx = (*pExtIndices)[extOffset];
std::vector<uint32_t> aIndices = {comp_idx};
uint32_t a_id = cinst->GetSingleWordInOperand(kFMixAIdInIdx);
ir::Instruction* a_inst = get_def_use_mgr()->GetDef(a_id);
uint32_t a_comp_id = DoExtract(a_inst, &aIndices, 0);
if (a_comp_id == 0) break;
ir::Instruction* a_comp_inst = get_def_use_mgr()->GetDef(a_comp_id);
if (a_comp_inst->opcode() != SpvOpConstant) break;
// If a value is not 32-bit, give up
uint32_t a_comp_type_id = a_comp_inst->type_id();
ir::Instruction* a_comp_type = get_def_use_mgr()->GetDef(a_comp_type_id);
if (a_comp_type->GetSingleWordInOperand(kTypeFloatWidthInIdx) != 32)
break;
uint32_t u = a_comp_inst->GetSingleWordInOperand(kConstantValueInIdx);
float* fp = reinterpret_cast<float*>(&u);
if (*fp == 0.0)
cid = cinst->GetSingleWordInOperand(kFMixXIdInIdx);
else if (*fp == 1.0)
cid = cinst->GetSingleWordInOperand(kFMixYIdInIdx);
else
break;
} else {
break;
}
cinst = get_def_use_mgr()->GetDef(cid);
}
// If search ended with CompositeConstruct or ConstantComposite
// and the extract has one index, return the appropriate component.
// TODO(greg-lunarg): Handle multiple-indices, ConstantNull, special
// vector composition, and additional CompositeInsert.
if (replId == 0 &&
(cinst->opcode() == SpvOpCompositeConstruct ||
cinst->opcode() == SpvOpConstantComposite) &&
(*pExtIndices).size() - extOffset == 1) {
uint32_t compIdx = (*pExtIndices)[extOffset];
// If a vector CompositeConstruct we make sure all preceding
// components are of component type (not vector composition).
uint32_t ctype_id = cinst->type_id();
ir::Instruction* ctype_inst = get_def_use_mgr()->GetDef(ctype_id);
if (ctype_inst->opcode() == SpvOpTypeVector &&
cinst->opcode() == SpvOpConstantComposite) {
uint32_t vec_comp_type_id =
ctype_inst->GetSingleWordInOperand(kTypeVectorCompTypeIdInIdx);
if (compIdx < cinst->NumInOperands()) {
uint32_t i = 0;
for (; i <= compIdx; i++) {
uint32_t compId = cinst->GetSingleWordInOperand(i);
ir::Instruction* componentInst = get_def_use_mgr()->GetDef(compId);
if (componentInst->type_id() != vec_comp_type_id) break;
}
if (i > compIdx) replId = cinst->GetSingleWordInOperand(compIdx);
}
} else {
replId = cinst->GetSingleWordInOperand(compIdx);
}
}
return replId;
}
bool InsertExtractElimPass::EliminateInsertExtract(ir::Function* func) {
bool modified = false;
for (auto bi = func->begin(); bi != func->end(); ++bi) {
ir::Instruction* inst = &*bi->begin();
while (inst) {
switch (inst->opcode()) {
case SpvOpCompositeExtract: {
uint32_t cid = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx);
ir::Instruction* cinst = get_def_use_mgr()->GetDef(cid);
// Capture extract indices
std::vector<uint32_t> extIndices;
uint32_t icnt = 0;
inst->ForEachInOperand([&icnt, &extIndices](const uint32_t* idp) {
if (icnt > 0) extIndices.push_back(*idp);
++icnt;
});
// Offset of extract indices being compared to insert indices.
// Offset increases as indices are matched.
uint32_t replId = DoExtract(cinst, &extIndices, 0);
if (replId != 0) {
const uint32_t extId = inst->result_id();
(void)context()->ReplaceAllUsesWith(extId, replId);
inst = context()->KillInst(inst);
modified = true;
} else {
inst = inst->NextNode();
}
} break;
default:
inst = inst->NextNode();
break;
}
}
}
return modified;
}
void InsertExtractElimPass::Initialize(ir::IRContext* c) {
InitializeProcessing(c);
}
Pass::Status InsertExtractElimPass::ProcessImpl() {
// Process all entry point functions.
ProcessFunction pfn = [this](ir::Function* fp) {
return EliminateInsertExtract(fp);
};
bool modified = ProcessEntryPointCallTree(pfn, get_module());
return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
}
InsertExtractElimPass::InsertExtractElimPass() {}
Pass::Status InsertExtractElimPass::Process(ir::IRContext* c) {
Initialize(c);
return ProcessImpl();
}
} // namespace opt
} // namespace spvtools