495 lines
21 KiB
C++
495 lines
21 KiB
C++
// Copyright (c) 2020 The Khronos Group Inc.
|
|
// Copyright (c) 2020 Valve Corporation
|
|
// Copyright (c) 2020 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 "inst_debug_printf_pass.h"
|
|
|
|
#include "source/spirv_constant.h"
|
|
#include "source/util/string_utils.h"
|
|
#include "spirv/unified1/NonSemanticDebugPrintf.h"
|
|
|
|
namespace spvtools {
|
|
namespace opt {
|
|
|
|
void InstDebugPrintfPass::GenOutputValues(Instruction* val_inst,
|
|
std::vector<uint32_t>* val_ids,
|
|
InstructionBuilder* builder) {
|
|
uint32_t val_ty_id = val_inst->type_id();
|
|
analysis::TypeManager* type_mgr = context()->get_type_mgr();
|
|
analysis::Type* val_ty = type_mgr->GetType(val_ty_id);
|
|
switch (val_ty->kind()) {
|
|
case analysis::Type::kVector: {
|
|
analysis::Vector* v_ty = val_ty->AsVector();
|
|
const analysis::Type* c_ty = v_ty->element_type();
|
|
uint32_t c_ty_id = type_mgr->GetId(c_ty);
|
|
for (uint32_t c = 0; c < v_ty->element_count(); ++c) {
|
|
Instruction* c_inst =
|
|
builder->AddCompositeExtract(c_ty_id, val_inst->result_id(), {c});
|
|
GenOutputValues(c_inst, val_ids, builder);
|
|
}
|
|
return;
|
|
}
|
|
case analysis::Type::kBool: {
|
|
// Select between uint32 zero or one
|
|
uint32_t zero_id = builder->GetUintConstantId(0);
|
|
uint32_t one_id = builder->GetUintConstantId(1);
|
|
Instruction* sel_inst = builder->AddSelect(
|
|
GetUintId(), val_inst->result_id(), one_id, zero_id);
|
|
val_ids->push_back(sel_inst->result_id());
|
|
return;
|
|
}
|
|
case analysis::Type::kFloat: {
|
|
analysis::Float* f_ty = val_ty->AsFloat();
|
|
switch (f_ty->width()) {
|
|
case 16: {
|
|
// Convert float16 to float32 and recurse
|
|
Instruction* f32_inst = builder->AddUnaryOp(
|
|
GetFloatId(), spv::Op::OpFConvert, val_inst->result_id());
|
|
GenOutputValues(f32_inst, val_ids, builder);
|
|
return;
|
|
}
|
|
case 64: {
|
|
// Bitcast float64 to uint64 and recurse
|
|
Instruction* ui64_inst = builder->AddUnaryOp(
|
|
GetUint64Id(), spv::Op::OpBitcast, val_inst->result_id());
|
|
GenOutputValues(ui64_inst, val_ids, builder);
|
|
return;
|
|
}
|
|
case 32: {
|
|
// Bitcase float32 to uint32
|
|
Instruction* bc_inst = builder->AddUnaryOp(
|
|
GetUintId(), spv::Op::OpBitcast, val_inst->result_id());
|
|
val_ids->push_back(bc_inst->result_id());
|
|
return;
|
|
}
|
|
default:
|
|
assert(false && "unsupported float width");
|
|
return;
|
|
}
|
|
}
|
|
case analysis::Type::kInteger: {
|
|
analysis::Integer* i_ty = val_ty->AsInteger();
|
|
switch (i_ty->width()) {
|
|
case 64: {
|
|
Instruction* ui64_inst = val_inst;
|
|
if (i_ty->IsSigned()) {
|
|
// Bitcast sint64 to uint64
|
|
ui64_inst = builder->AddUnaryOp(GetUint64Id(), spv::Op::OpBitcast,
|
|
val_inst->result_id());
|
|
}
|
|
// Break uint64 into 2x uint32
|
|
Instruction* lo_ui64_inst = builder->AddUnaryOp(
|
|
GetUintId(), spv::Op::OpUConvert, ui64_inst->result_id());
|
|
Instruction* rshift_ui64_inst = builder->AddBinaryOp(
|
|
GetUint64Id(), spv::Op::OpShiftRightLogical,
|
|
ui64_inst->result_id(), builder->GetUintConstantId(32));
|
|
Instruction* hi_ui64_inst = builder->AddUnaryOp(
|
|
GetUintId(), spv::Op::OpUConvert, rshift_ui64_inst->result_id());
|
|
val_ids->push_back(lo_ui64_inst->result_id());
|
|
val_ids->push_back(hi_ui64_inst->result_id());
|
|
return;
|
|
}
|
|
case 8: {
|
|
Instruction* ui8_inst = val_inst;
|
|
if (i_ty->IsSigned()) {
|
|
// Bitcast sint8 to uint8
|
|
ui8_inst = builder->AddUnaryOp(GetUint8Id(), spv::Op::OpBitcast,
|
|
val_inst->result_id());
|
|
}
|
|
// Convert uint8 to uint32
|
|
Instruction* ui32_inst = builder->AddUnaryOp(
|
|
GetUintId(), spv::Op::OpUConvert, ui8_inst->result_id());
|
|
val_ids->push_back(ui32_inst->result_id());
|
|
return;
|
|
}
|
|
case 32: {
|
|
Instruction* ui32_inst = val_inst;
|
|
if (i_ty->IsSigned()) {
|
|
// Bitcast sint32 to uint32
|
|
ui32_inst = builder->AddUnaryOp(GetUintId(), spv::Op::OpBitcast,
|
|
val_inst->result_id());
|
|
}
|
|
// uint32 needs no further processing
|
|
val_ids->push_back(ui32_inst->result_id());
|
|
return;
|
|
}
|
|
default:
|
|
// TODO(greg-lunarg): Support non-32-bit int
|
|
assert(false && "unsupported int width");
|
|
return;
|
|
}
|
|
}
|
|
default:
|
|
assert(false && "unsupported type");
|
|
return;
|
|
}
|
|
}
|
|
|
|
void InstDebugPrintfPass::GenOutputCode(
|
|
Instruction* printf_inst, uint32_t stage_idx,
|
|
std::vector<std::unique_ptr<BasicBlock>>* new_blocks) {
|
|
BasicBlock* back_blk_ptr = &*new_blocks->back();
|
|
InstructionBuilder builder(
|
|
context(), back_blk_ptr,
|
|
IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping);
|
|
// Gen debug printf record validation-specific values. The format string
|
|
// will have its id written. Vectors will need to be broken down into
|
|
// component values. float16 will need to be converted to float32. Pointer
|
|
// and uint64 will need to be converted to two uint32 values. float32 will
|
|
// need to be bitcast to uint32. int32 will need to be bitcast to uint32.
|
|
std::vector<uint32_t> val_ids;
|
|
bool is_first_operand = false;
|
|
printf_inst->ForEachInId(
|
|
[&is_first_operand, &val_ids, &builder, this](const uint32_t* iid) {
|
|
// skip set operand
|
|
if (!is_first_operand) {
|
|
is_first_operand = true;
|
|
return;
|
|
}
|
|
Instruction* opnd_inst = get_def_use_mgr()->GetDef(*iid);
|
|
if (opnd_inst->opcode() == spv::Op::OpString) {
|
|
uint32_t string_id_id = builder.GetUintConstantId(*iid);
|
|
val_ids.push_back(string_id_id);
|
|
} else {
|
|
GenOutputValues(opnd_inst, &val_ids, &builder);
|
|
}
|
|
});
|
|
GenDebugStreamWrite(
|
|
builder.GetUintConstantId(shader_id_),
|
|
builder.GetUintConstantId(uid2offset_[printf_inst->unique_id()]),
|
|
GenStageInfo(stage_idx, &builder), val_ids, &builder);
|
|
context()->KillInst(printf_inst);
|
|
}
|
|
|
|
void InstDebugPrintfPass::GenDebugPrintfCode(
|
|
BasicBlock::iterator ref_inst_itr,
|
|
UptrVectorIterator<BasicBlock> ref_block_itr, uint32_t stage_idx,
|
|
std::vector<std::unique_ptr<BasicBlock>>* new_blocks) {
|
|
// If not DebugPrintf OpExtInst, return.
|
|
Instruction* printf_inst = &*ref_inst_itr;
|
|
if (printf_inst->opcode() != spv::Op::OpExtInst) return;
|
|
if (printf_inst->GetSingleWordInOperand(0) != ext_inst_printf_id_) return;
|
|
if (printf_inst->GetSingleWordInOperand(1) !=
|
|
NonSemanticDebugPrintfDebugPrintf)
|
|
return;
|
|
// Initialize DefUse manager before dismantling module
|
|
(void)get_def_use_mgr();
|
|
// Move original block's preceding instructions into first new block
|
|
std::unique_ptr<BasicBlock> new_blk_ptr;
|
|
MovePreludeCode(ref_inst_itr, ref_block_itr, &new_blk_ptr);
|
|
new_blocks->push_back(std::move(new_blk_ptr));
|
|
// Generate instructions to output printf args to printf buffer
|
|
GenOutputCode(printf_inst, stage_idx, new_blocks);
|
|
// Caller expects at least two blocks with last block containing remaining
|
|
// code, so end block after instrumentation, create remainder block, and
|
|
// branch to it
|
|
uint32_t rem_blk_id = TakeNextId();
|
|
std::unique_ptr<Instruction> rem_label(NewLabel(rem_blk_id));
|
|
BasicBlock* back_blk_ptr = &*new_blocks->back();
|
|
InstructionBuilder builder(
|
|
context(), back_blk_ptr,
|
|
IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping);
|
|
(void)builder.AddBranch(rem_blk_id);
|
|
// Gen remainder block
|
|
new_blk_ptr.reset(new BasicBlock(std::move(rem_label)));
|
|
builder.SetInsertPoint(&*new_blk_ptr);
|
|
// Move original block's remaining code into remainder block and add
|
|
// to new blocks
|
|
MovePostludeCode(ref_block_itr, &*new_blk_ptr);
|
|
new_blocks->push_back(std::move(new_blk_ptr));
|
|
}
|
|
|
|
// Return id for output buffer
|
|
uint32_t InstDebugPrintfPass::GetOutputBufferId() {
|
|
if (output_buffer_id_ == 0) {
|
|
// If not created yet, create one
|
|
analysis::DecorationManager* deco_mgr = get_decoration_mgr();
|
|
analysis::TypeManager* type_mgr = context()->get_type_mgr();
|
|
analysis::RuntimeArray* reg_uint_rarr_ty = GetUintRuntimeArrayType(32);
|
|
analysis::Integer* reg_uint_ty = GetInteger(32, false);
|
|
analysis::Type* reg_buf_ty =
|
|
GetStruct({reg_uint_ty, reg_uint_ty, reg_uint_rarr_ty});
|
|
uint32_t obufTyId = type_mgr->GetTypeInstruction(reg_buf_ty);
|
|
// By the Vulkan spec, a pre-existing struct containing a RuntimeArray
|
|
// must be a block, and will therefore be decorated with Block. Therefore
|
|
// the undecorated type returned here will not be pre-existing and can
|
|
// safely be decorated. Since this type is now decorated, it is out of
|
|
// sync with the TypeManager and therefore the TypeManager must be
|
|
// invalidated after this pass.
|
|
assert(context()->get_def_use_mgr()->NumUses(obufTyId) == 0 &&
|
|
"used struct type returned");
|
|
deco_mgr->AddDecoration(obufTyId, uint32_t(spv::Decoration::Block));
|
|
deco_mgr->AddMemberDecoration(obufTyId, kDebugOutputFlagsOffset,
|
|
uint32_t(spv::Decoration::Offset), 0);
|
|
deco_mgr->AddMemberDecoration(obufTyId, kDebugOutputSizeOffset,
|
|
uint32_t(spv::Decoration::Offset), 4);
|
|
deco_mgr->AddMemberDecoration(obufTyId, kDebugOutputDataOffset,
|
|
uint32_t(spv::Decoration::Offset), 8);
|
|
uint32_t obufTyPtrId_ =
|
|
type_mgr->FindPointerToType(obufTyId, spv::StorageClass::StorageBuffer);
|
|
output_buffer_id_ = TakeNextId();
|
|
std::unique_ptr<Instruction> newVarOp(new Instruction(
|
|
context(), spv::Op::OpVariable, obufTyPtrId_, output_buffer_id_,
|
|
{{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
|
|
{uint32_t(spv::StorageClass::StorageBuffer)}}}));
|
|
context()->AddGlobalValue(std::move(newVarOp));
|
|
context()->AddDebug2Inst(NewGlobalName(obufTyId, "OutputBuffer"));
|
|
context()->AddDebug2Inst(NewMemberName(obufTyId, 0, "flags"));
|
|
context()->AddDebug2Inst(NewMemberName(obufTyId, 1, "written_count"));
|
|
context()->AddDebug2Inst(NewMemberName(obufTyId, 2, "data"));
|
|
context()->AddDebug2Inst(NewGlobalName(output_buffer_id_, "output_buffer"));
|
|
deco_mgr->AddDecorationVal(
|
|
output_buffer_id_, uint32_t(spv::Decoration::DescriptorSet), desc_set_);
|
|
deco_mgr->AddDecorationVal(output_buffer_id_,
|
|
uint32_t(spv::Decoration::Binding),
|
|
GetOutputBufferBinding());
|
|
AddStorageBufferExt();
|
|
if (get_module()->version() >= SPV_SPIRV_VERSION_WORD(1, 4)) {
|
|
// Add the new buffer to all entry points.
|
|
for (auto& entry : get_module()->entry_points()) {
|
|
entry.AddOperand({SPV_OPERAND_TYPE_ID, {output_buffer_id_}});
|
|
context()->AnalyzeUses(&entry);
|
|
}
|
|
}
|
|
}
|
|
return output_buffer_id_;
|
|
}
|
|
|
|
uint32_t InstDebugPrintfPass::GetOutputBufferPtrId() {
|
|
if (output_buffer_ptr_id_ == 0) {
|
|
output_buffer_ptr_id_ = context()->get_type_mgr()->FindPointerToType(
|
|
GetUintId(), spv::StorageClass::StorageBuffer);
|
|
}
|
|
return output_buffer_ptr_id_;
|
|
}
|
|
|
|
uint32_t InstDebugPrintfPass::GetOutputBufferBinding() {
|
|
return kDebugOutputPrintfStream;
|
|
}
|
|
|
|
void InstDebugPrintfPass::GenDebugOutputFieldCode(uint32_t base_offset_id,
|
|
uint32_t field_offset,
|
|
uint32_t field_value_id,
|
|
InstructionBuilder* builder) {
|
|
// Cast value to 32-bit unsigned if necessary
|
|
uint32_t val_id = GenUintCastCode(field_value_id, builder);
|
|
// Store value
|
|
Instruction* data_idx_inst = builder->AddIAdd(
|
|
GetUintId(), base_offset_id, builder->GetUintConstantId(field_offset));
|
|
uint32_t buf_id = GetOutputBufferId();
|
|
uint32_t buf_uint_ptr_id = GetOutputBufferPtrId();
|
|
Instruction* achain_inst = builder->AddAccessChain(
|
|
buf_uint_ptr_id, buf_id,
|
|
{builder->GetUintConstantId(kDebugOutputDataOffset),
|
|
data_idx_inst->result_id()});
|
|
(void)builder->AddStore(achain_inst->result_id(), val_id);
|
|
}
|
|
|
|
uint32_t InstDebugPrintfPass::GetStreamWriteFunctionId(uint32_t param_cnt) {
|
|
enum {
|
|
kShaderId = 0,
|
|
kInstructionIndex = 1,
|
|
kStageInfo = 2,
|
|
kFirstParam = 3,
|
|
};
|
|
// Total param count is common params plus validation-specific
|
|
// params
|
|
if (param2output_func_id_[param_cnt] == 0) {
|
|
// Create function
|
|
param2output_func_id_[param_cnt] = TakeNextId();
|
|
analysis::TypeManager* type_mgr = context()->get_type_mgr();
|
|
|
|
const analysis::Type* uint_type = GetInteger(32, false);
|
|
const analysis::Vector v4uint(uint_type, 4);
|
|
const analysis::Type* v4uint_type = type_mgr->GetRegisteredType(&v4uint);
|
|
|
|
std::vector<const analysis::Type*> param_types(kFirstParam + param_cnt,
|
|
uint_type);
|
|
param_types[kStageInfo] = v4uint_type;
|
|
std::unique_ptr<Function> output_func = StartFunction(
|
|
param2output_func_id_[param_cnt], type_mgr->GetVoidType(), param_types);
|
|
|
|
std::vector<uint32_t> param_ids = AddParameters(*output_func, param_types);
|
|
|
|
// Create first block
|
|
auto new_blk_ptr = MakeUnique<BasicBlock>(NewLabel(TakeNextId()));
|
|
|
|
InstructionBuilder builder(
|
|
context(), &*new_blk_ptr,
|
|
IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping);
|
|
// Gen test if debug output buffer size will not be exceeded.
|
|
const uint32_t val_spec_offset = kInstStageOutCnt;
|
|
const uint32_t obuf_record_sz = val_spec_offset + param_cnt;
|
|
const uint32_t buf_id = GetOutputBufferId();
|
|
const uint32_t buf_uint_ptr_id = GetOutputBufferPtrId();
|
|
Instruction* obuf_curr_sz_ac_inst = builder.AddAccessChain(
|
|
buf_uint_ptr_id, buf_id,
|
|
{builder.GetUintConstantId(kDebugOutputSizeOffset)});
|
|
// Fetch the current debug buffer written size atomically, adding the
|
|
// size of the record to be written.
|
|
uint32_t obuf_record_sz_id = builder.GetUintConstantId(obuf_record_sz);
|
|
uint32_t mask_none_id =
|
|
builder.GetUintConstantId(uint32_t(spv::MemoryAccessMask::MaskNone));
|
|
uint32_t scope_invok_id =
|
|
builder.GetUintConstantId(uint32_t(spv::Scope::Invocation));
|
|
Instruction* obuf_curr_sz_inst = builder.AddQuadOp(
|
|
GetUintId(), spv::Op::OpAtomicIAdd, obuf_curr_sz_ac_inst->result_id(),
|
|
scope_invok_id, mask_none_id, obuf_record_sz_id);
|
|
uint32_t obuf_curr_sz_id = obuf_curr_sz_inst->result_id();
|
|
// Compute new written size
|
|
Instruction* obuf_new_sz_inst =
|
|
builder.AddIAdd(GetUintId(), obuf_curr_sz_id,
|
|
builder.GetUintConstantId(obuf_record_sz));
|
|
// Fetch the data bound
|
|
Instruction* obuf_bnd_inst =
|
|
builder.AddIdLiteralOp(GetUintId(), spv::Op::OpArrayLength,
|
|
GetOutputBufferId(), kDebugOutputDataOffset);
|
|
// Test that new written size is less than or equal to debug output
|
|
// data bound
|
|
Instruction* obuf_safe_inst = builder.AddBinaryOp(
|
|
GetBoolId(), spv::Op::OpULessThanEqual, obuf_new_sz_inst->result_id(),
|
|
obuf_bnd_inst->result_id());
|
|
uint32_t merge_blk_id = TakeNextId();
|
|
uint32_t write_blk_id = TakeNextId();
|
|
std::unique_ptr<Instruction> merge_label(NewLabel(merge_blk_id));
|
|
std::unique_ptr<Instruction> write_label(NewLabel(write_blk_id));
|
|
(void)builder.AddConditionalBranch(
|
|
obuf_safe_inst->result_id(), write_blk_id, merge_blk_id, merge_blk_id,
|
|
uint32_t(spv::SelectionControlMask::MaskNone));
|
|
// Close safety test block and gen write block
|
|
output_func->AddBasicBlock(std::move(new_blk_ptr));
|
|
new_blk_ptr = MakeUnique<BasicBlock>(std::move(write_label));
|
|
builder.SetInsertPoint(&*new_blk_ptr);
|
|
// Generate common and stage-specific debug record members
|
|
GenDebugOutputFieldCode(obuf_curr_sz_id, kInstCommonOutSize,
|
|
builder.GetUintConstantId(obuf_record_sz),
|
|
&builder);
|
|
// Store Shader Id
|
|
GenDebugOutputFieldCode(obuf_curr_sz_id, kInstCommonOutShaderId,
|
|
param_ids[kShaderId], &builder);
|
|
// Store Instruction Idx
|
|
GenDebugOutputFieldCode(obuf_curr_sz_id, kInstCommonOutInstructionIdx,
|
|
param_ids[kInstructionIndex], &builder);
|
|
// Store stage info. Stage Idx + 3 words of stage-specific data.
|
|
for (uint32_t i = 0; i < 4; ++i) {
|
|
Instruction* field =
|
|
builder.AddCompositeExtract(GetUintId(), param_ids[kStageInfo], {i});
|
|
GenDebugOutputFieldCode(obuf_curr_sz_id, kInstCommonOutStageIdx + i,
|
|
field->result_id(), &builder);
|
|
}
|
|
// Gen writes of validation specific data
|
|
for (uint32_t i = 0; i < param_cnt; ++i) {
|
|
GenDebugOutputFieldCode(obuf_curr_sz_id, val_spec_offset + i,
|
|
param_ids[kFirstParam + i], &builder);
|
|
}
|
|
// Close write block and gen merge block
|
|
(void)builder.AddBranch(merge_blk_id);
|
|
output_func->AddBasicBlock(std::move(new_blk_ptr));
|
|
new_blk_ptr = MakeUnique<BasicBlock>(std::move(merge_label));
|
|
builder.SetInsertPoint(&*new_blk_ptr);
|
|
// Close merge block and function and add function to module
|
|
(void)builder.AddNullaryOp(0, spv::Op::OpReturn);
|
|
|
|
output_func->AddBasicBlock(std::move(new_blk_ptr));
|
|
output_func->SetFunctionEnd(EndFunction());
|
|
context()->AddFunction(std::move(output_func));
|
|
|
|
std::string name("stream_write_");
|
|
name += std::to_string(param_cnt);
|
|
|
|
context()->AddDebug2Inst(
|
|
NewGlobalName(param2output_func_id_[param_cnt], name));
|
|
}
|
|
return param2output_func_id_[param_cnt];
|
|
}
|
|
|
|
void InstDebugPrintfPass::GenDebugStreamWrite(
|
|
uint32_t shader_id, uint32_t instruction_idx_id, uint32_t stage_info_id,
|
|
const std::vector<uint32_t>& validation_ids, InstructionBuilder* builder) {
|
|
// Call debug output function. Pass func_idx, instruction_idx and
|
|
// validation ids as args.
|
|
uint32_t val_id_cnt = static_cast<uint32_t>(validation_ids.size());
|
|
std::vector<uint32_t> args = {shader_id, instruction_idx_id, stage_info_id};
|
|
(void)args.insert(args.end(), validation_ids.begin(), validation_ids.end());
|
|
(void)builder->AddFunctionCall(GetVoidId(),
|
|
GetStreamWriteFunctionId(val_id_cnt), args);
|
|
}
|
|
|
|
std::unique_ptr<Instruction> InstDebugPrintfPass::NewGlobalName(
|
|
uint32_t id, const std::string& name_str) {
|
|
std::string prefixed_name{"inst_printf_"};
|
|
prefixed_name += name_str;
|
|
return NewName(id, prefixed_name);
|
|
}
|
|
|
|
std::unique_ptr<Instruction> InstDebugPrintfPass::NewMemberName(
|
|
uint32_t id, uint32_t member_index, const std::string& name_str) {
|
|
return MakeUnique<Instruction>(
|
|
context(), spv::Op::OpMemberName, 0, 0,
|
|
std::initializer_list<Operand>{
|
|
{SPV_OPERAND_TYPE_ID, {id}},
|
|
{SPV_OPERAND_TYPE_LITERAL_INTEGER, {member_index}},
|
|
{SPV_OPERAND_TYPE_LITERAL_STRING, utils::MakeVector(name_str)}});
|
|
}
|
|
|
|
void InstDebugPrintfPass::InitializeInstDebugPrintf() {
|
|
// Initialize base class
|
|
InitializeInstrument();
|
|
output_buffer_id_ = 0;
|
|
output_buffer_ptr_id_ = 0;
|
|
}
|
|
|
|
Pass::Status InstDebugPrintfPass::ProcessImpl() {
|
|
// Perform printf instrumentation on each entry point function in module
|
|
InstProcessFunction pfn =
|
|
[this](BasicBlock::iterator ref_inst_itr,
|
|
UptrVectorIterator<BasicBlock> ref_block_itr, uint32_t stage_idx,
|
|
std::vector<std::unique_ptr<BasicBlock>>* new_blocks) {
|
|
return GenDebugPrintfCode(ref_inst_itr, ref_block_itr, stage_idx,
|
|
new_blocks);
|
|
};
|
|
(void)InstProcessEntryPointCallTree(pfn);
|
|
// Remove DebugPrintf OpExtInstImport instruction
|
|
Instruction* ext_inst_import_inst =
|
|
get_def_use_mgr()->GetDef(ext_inst_printf_id_);
|
|
context()->KillInst(ext_inst_import_inst);
|
|
// If no remaining non-semantic instruction sets, remove non-semantic debug
|
|
// info extension from module and feature manager
|
|
bool non_sem_set_seen = false;
|
|
for (auto c_itr = context()->module()->ext_inst_import_begin();
|
|
c_itr != context()->module()->ext_inst_import_end(); ++c_itr) {
|
|
const std::string set_name = c_itr->GetInOperand(0).AsString();
|
|
if (spvtools::utils::starts_with(set_name, "NonSemantic.")) {
|
|
non_sem_set_seen = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!non_sem_set_seen) {
|
|
context()->RemoveExtension(kSPV_KHR_non_semantic_info);
|
|
}
|
|
return Status::SuccessWithChange;
|
|
}
|
|
|
|
Pass::Status InstDebugPrintfPass::Process() {
|
|
ext_inst_printf_id_ =
|
|
get_module()->GetExtInstImportId("NonSemantic.DebugPrintf");
|
|
if (ext_inst_printf_id_ == 0) return Status::SuccessWithoutChange;
|
|
InitializeInstDebugPrintf();
|
|
return ProcessImpl();
|
|
}
|
|
|
|
} // namespace opt
|
|
} // namespace spvtools
|