source/opt/inst_buff_addr_check_pass.cpp - third_party/spirv-tools - Git at Google

 // Copyright (c) 2019 The Khronos Group Inc.
 // Copyright (c) 2019 Valve Corporation
 // Copyright (c) 2019 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_buff_addr_check_pass.h"

 namespace spvtools {
 namespace opt {

 uint32_t InstBuffAddrCheckPass::CloneOriginalReference(
     Instruction* ref_inst, InstructionBuilder* builder) {
   // Clone original ref with new result id (if load)
   assert((ref_inst->opcode() == spv::Op::OpLoad ||
           ref_inst->opcode() == spv::Op::OpStore) &&
          "unexpected ref");
   std::unique_ptr<Instruction> new_ref_inst(ref_inst->Clone(context()));
   uint32_t ref_result_id = ref_inst->result_id();
   uint32_t new_ref_id = 0;
   if (ref_result_id != 0) {
     new_ref_id = TakeNextId();
     new_ref_inst->SetResultId(new_ref_id);
   }
   // Register new reference and add to new block
   Instruction* added_inst = builder->AddInstruction(std::move(new_ref_inst));
   uid2offset_[added_inst->unique_id()] = uid2offset_[ref_inst->unique_id()];
   if (new_ref_id != 0)
     get_decoration_mgr()->CloneDecorations(ref_result_id, new_ref_id);
   return new_ref_id;
 }

 bool InstBuffAddrCheckPass::IsPhysicalBuffAddrReference(Instruction* ref_inst) {
   if (ref_inst->opcode() != spv::Op::OpLoad &&
       ref_inst->opcode() != spv::Op::OpStore)
     return false;
   uint32_t ptr_id = ref_inst->GetSingleWordInOperand(0);
   analysis::DefUseManager* du_mgr = get_def_use_mgr();
   Instruction* ptr_inst = du_mgr->GetDef(ptr_id);
   if (ptr_inst->opcode() != spv::Op::OpAccessChain) return false;
   uint32_t ptr_ty_id = ptr_inst->type_id();
   Instruction* ptr_ty_inst = du_mgr->GetDef(ptr_ty_id);
   if (spv::StorageClass(ptr_ty_inst->GetSingleWordInOperand(0)) !=
       spv::StorageClass::PhysicalStorageBufferEXT)
     return false;
   return true;
 }

 // TODO(greg-lunarg): Refactor with InstBindlessCheckPass::GenCheckCode() ??
 void InstBuffAddrCheckPass::GenCheckCode(
     uint32_t check_id, Instruction* ref_inst,
     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 conditional branch on check_id. Valid branch generates original
   // reference. Invalid generates debug output and zero result (if needed).
   uint32_t merge_blk_id = TakeNextId();
   uint32_t valid_blk_id = TakeNextId();
   uint32_t invalid_blk_id = TakeNextId();
   std::unique_ptr<Instruction> merge_label(NewLabel(merge_blk_id));
   std::unique_ptr<Instruction> valid_label(NewLabel(valid_blk_id));
   std::unique_ptr<Instruction> invalid_label(NewLabel(invalid_blk_id));
   (void)builder.AddConditionalBranch(
       check_id, valid_blk_id, invalid_blk_id, merge_blk_id,
       uint32_t(spv::SelectionControlMask::MaskNone));
   // Gen valid branch
   std::unique_ptr<BasicBlock> new_blk_ptr(
       new BasicBlock(std::move(valid_label)));
   builder.SetInsertPoint(&*new_blk_ptr);
   uint32_t new_ref_id = CloneOriginalReference(ref_inst, &builder);
   (void)builder.AddBranch(merge_blk_id);
   new_blocks->push_back(std::move(new_blk_ptr));
   // Gen invalid block
   new_blk_ptr.reset(new BasicBlock(std::move(invalid_label)));
   builder.SetInsertPoint(&*new_blk_ptr);
   // Gen zero for invalid load. If pointer type, need to convert uint64
   // zero to pointer; cannot create ConstantNull of pointer type.
   uint32_t null_id = 0;
   if (new_ref_id != 0) {
     uint32_t ref_type_id = ref_inst->type_id();
     analysis::TypeManager* type_mgr = context()->get_type_mgr();
     analysis::Type* ref_type = type_mgr->GetType(ref_type_id);
     if (ref_type->AsPointer() != nullptr) {
       uint32_t null_u64_id = GetNullId(GetUint64Id());
       Instruction* null_ptr_inst = builder.AddUnaryOp(
           ref_type_id, spv::Op::OpConvertUToPtr, null_u64_id);
       null_id = null_ptr_inst->result_id();
     } else {
       null_id = GetNullId(ref_type_id);
     }
   }
   (void)builder.AddBranch(merge_blk_id);
   new_blocks->push_back(std::move(new_blk_ptr));
   // Gen merge block
   new_blk_ptr.reset(new BasicBlock(std::move(merge_label)));
   builder.SetInsertPoint(&*new_blk_ptr);
   // Gen phi of new reference and zero, if necessary, and replace the
   // result id of the original reference with that of the Phi. Kill original
   // reference.
   if (new_ref_id != 0) {
     Instruction* phi_inst =
         builder.AddPhi(ref_inst->type_id(),
                        {new_ref_id, valid_blk_id, null_id, invalid_blk_id});
     context()->ReplaceAllUsesWith(ref_inst->result_id(), phi_inst->result_id());
   }
   new_blocks->push_back(std::move(new_blk_ptr));
   context()->KillInst(ref_inst);
 }

 uint32_t InstBuffAddrCheckPass::GetTypeLength(uint32_t type_id) {
   Instruction* type_inst = get_def_use_mgr()->GetDef(type_id);
   switch (type_inst->opcode()) {
     case spv::Op::OpTypeFloat:
     case spv::Op::OpTypeInt:
       return type_inst->GetSingleWordInOperand(0) / 8u;
     case spv::Op::OpTypeVector:
     case spv::Op::OpTypeMatrix:
       return type_inst->GetSingleWordInOperand(1) *
              GetTypeLength(type_inst->GetSingleWordInOperand(0));
     case spv::Op::OpTypePointer:
       assert(spv::StorageClass(type_inst->GetSingleWordInOperand(0)) ==
                  spv::StorageClass::PhysicalStorageBufferEXT &&
              "unexpected pointer type");
       return 8u;
     case spv::Op::OpTypeArray: {
       uint32_t const_id = type_inst->GetSingleWordInOperand(1);
       Instruction* const_inst = get_def_use_mgr()->GetDef(const_id);
       uint32_t cnt = const_inst->GetSingleWordInOperand(0);
       return cnt * GetTypeLength(type_inst->GetSingleWordInOperand(0));
     }
     case spv::Op::OpTypeStruct: {
       // Figure out the location of the last byte of the last member of the
       // structure.
       uint32_t last_offset = 0, last_len = 0;

       get_decoration_mgr()->ForEachDecoration(
           type_id, uint32_t(spv::Decoration::Offset),
           [&last_offset](const Instruction& deco_inst) {
             last_offset = deco_inst.GetSingleWordInOperand(3);
           });
       type_inst->ForEachInId([&last_len, this](const uint32_t* iid) {
         last_len = GetTypeLength(*iid);
       });
       return last_offset + last_len;
     }
     case spv::Op::OpTypeRuntimeArray:
     default:
       assert(false && "unexpected type");
       return 0;
   }
 }

 void InstBuffAddrCheckPass::AddParam(uint32_t type_id,
                                      std::vector<uint32_t>* param_vec,
                                      std::unique_ptr<Function>* input_func) {
   uint32_t pid = TakeNextId();
   param_vec->push_back(pid);
   std::unique_ptr<Instruction> param_inst(new Instruction(
       get_module()->context(), spv::Op::OpFunctionParameter, type_id, pid, {}));
   get_def_use_mgr()->AnalyzeInstDefUse(&*param_inst);
   (*input_func)->AddParameter(std::move(param_inst));
 }

 // This is a stub function for use with Import linkage
 // clang-format off
 // GLSL:
 //bool inst_bindless_search_and_test(const uint shader_id, const uint inst_num, const uvec4 stage_info,
 //				     const uint64 ref_ptr, const uint length) {
 //}
 // clang-format on
 uint32_t InstBuffAddrCheckPass::GetSearchAndTestFuncId() {
   enum {
     kShaderId = 0,
     kInstructionIndex = 1,
     kStageInfo = 2,
     kRefPtr = 3,
     kLength = 4,
     kNumArgs
   };
   if (search_test_func_id_ != 0) {
     return search_test_func_id_;
   }
   // Generate function "bool search_and_test(uint64_t ref_ptr, uint32_t len)"
   // which searches input buffer for buffer which most likely contains the
   // pointer value |ref_ptr| and verifies that the entire reference of
   // length |len| bytes is contained in the buffer.
   analysis::TypeManager* type_mgr = context()->get_type_mgr();
   const analysis::Integer* 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 = {
       uint_type, uint_type, v4uint_type, type_mgr->GetType(GetUint64Id()),
       uint_type};

   const std::string func_name{"inst_buff_addr_search_and_test"};
   const uint32_t func_id = TakeNextId();
   std::unique_ptr<Function> func =
       StartFunction(func_id, type_mgr->GetBoolType(), param_types);
   func->SetFunctionEnd(EndFunction());
   context()->AddFunctionDeclaration(std::move(func));
   context()->AddDebug2Inst(NewName(func_id, func_name));

   std::vector<Operand> operands{
       {spv_operand_type_t::SPV_OPERAND_TYPE_ID, {func_id}},
       {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
        {uint32_t(spv::Decoration::LinkageAttributes)}},
       {spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_STRING,
        utils::MakeVector(func_name.c_str())},
       {spv_operand_type_t::SPV_OPERAND_TYPE_LINKAGE_TYPE,
        {uint32_t(spv::LinkageType::Import)}},
   };
   get_decoration_mgr()->AddDecoration(spv::Op::OpDecorate, operands);

   search_test_func_id_ = func_id;
   return search_test_func_id_;
 }

 uint32_t InstBuffAddrCheckPass::GenSearchAndTest(Instruction* ref_inst,
                                                  InstructionBuilder* builder,
                                                  uint32_t* ref_uptr_id,
                                                  uint32_t stage_idx) {
   // Enable Int64 if necessary
   // Convert reference pointer to uint64
   const uint32_t ref_ptr_id = ref_inst->GetSingleWordInOperand(0);
   Instruction* ref_uptr_inst =
       builder->AddUnaryOp(GetUint64Id(), spv::Op::OpConvertPtrToU, ref_ptr_id);
   *ref_uptr_id = ref_uptr_inst->result_id();
   // Compute reference length in bytes
   analysis::DefUseManager* du_mgr = get_def_use_mgr();
   Instruction* ref_ptr_inst = du_mgr->GetDef(ref_ptr_id);
   const uint32_t ref_ptr_ty_id = ref_ptr_inst->type_id();
   Instruction* ref_ptr_ty_inst = du_mgr->GetDef(ref_ptr_ty_id);
   const uint32_t ref_len =
       GetTypeLength(ref_ptr_ty_inst->GetSingleWordInOperand(1));
   // Gen call to search and test function
   const uint32_t func_id = GetSearchAndTestFuncId();
   const std::vector<uint32_t> args = {
       builder->GetUintConstantId(shader_id_),
       builder->GetUintConstantId(ref_inst->unique_id()),
       GenStageInfo(stage_idx, builder), *ref_uptr_id,
       builder->GetUintConstantId(ref_len)};
   return GenReadFunctionCall(GetBoolId(), func_id, args, builder);
 }

 void InstBuffAddrCheckPass::GenBuffAddrCheckCode(
     BasicBlock::iterator ref_inst_itr,
     UptrVectorIterator<BasicBlock> ref_block_itr, uint32_t stage_idx,
     std::vector<std::unique_ptr<BasicBlock>>* new_blocks) {
   // Look for reference through indexed descriptor. If found, analyze and
   // save components. If not, return.
   Instruction* ref_inst = &*ref_inst_itr;
   if (!IsPhysicalBuffAddrReference(ref_inst)) return;
   // 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);
   InstructionBuilder builder(
       context(), &*new_blk_ptr,
       IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping);
   new_blocks->push_back(std::move(new_blk_ptr));
   // Generate code to do search and test if all bytes of reference
   // are within a listed buffer. Return reference pointer converted to uint64.
   uint32_t ref_uptr_id;
   uint32_t valid_id =
       GenSearchAndTest(ref_inst, &builder, &ref_uptr_id, stage_idx);
   // Generate test of search results with true branch
   // being full reference and false branch being debug output and zero
   // for the referenced value.
   GenCheckCode(valid_id, ref_inst, new_blocks);

   // Move original block's remaining code into remainder/merge block and add
   // to new blocks
   BasicBlock* back_blk_ptr = &*new_blocks->back();
   MovePostludeCode(ref_block_itr, back_blk_ptr);
 }

 void InstBuffAddrCheckPass::InitInstBuffAddrCheck() {
   // Initialize base class
   InitializeInstrument();
   // Initialize class
   search_test_func_id_ = 0;
 }

 Pass::Status InstBuffAddrCheckPass::ProcessImpl() {
   // The memory model and linkage must always be updated for spirv-link to work
   // correctly.
   AddStorageBufferExt();
   if (!get_feature_mgr()->HasExtension(kSPV_KHR_physical_storage_buffer)) {
     context()->AddExtension("SPV_KHR_physical_storage_buffer");
   }

   context()->AddCapability(spv::Capability::PhysicalStorageBufferAddresses);
   Instruction* memory_model = get_module()->GetMemoryModel();
   memory_model->SetInOperand(
       0u, {uint32_t(spv::AddressingModel::PhysicalStorageBuffer64)});

   context()->AddCapability(spv::Capability::Int64);
   context()->AddCapability(spv::Capability::Linkage);
   // Perform bindless bounds check 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 GenBuffAddrCheckCode(ref_inst_itr, ref_block_itr, stage_idx,
                                     new_blocks);
       };
   InstProcessEntryPointCallTree(pfn);
   // This pass always changes the memory model, so that linking will work
   // properly.
   return Status::SuccessWithChange;
 }

 Pass::Status InstBuffAddrCheckPass::Process() {
   InitInstBuffAddrCheck();
   return ProcessImpl();
 }

 }  // namespace opt
 }  // namespace spvtools
	// Copyright (c) 2019 The Khronos Group Inc.
	// Copyright (c) 2019 Valve Corporation
	// Copyright (c) 2019 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_buff_addr_check_pass.h"

	namespace spvtools {
	namespace opt {

	uint32_t InstBuffAddrCheckPass::CloneOriginalReference(
	Instruction* ref_inst, InstructionBuilder* builder) {
	// Clone original ref with new result id (if load)
	assert((ref_inst->opcode() == spv::Op::OpLoad \|\|
	ref_inst->opcode() == spv::Op::OpStore) &&
	"unexpected ref");
	std::unique_ptr<Instruction> new_ref_inst(ref_inst->Clone(context()));
	uint32_t ref_result_id = ref_inst->result_id();
	uint32_t new_ref_id = 0;
	if (ref_result_id != 0) {
	new_ref_id = TakeNextId();
	new_ref_inst->SetResultId(new_ref_id);
	}
	// Register new reference and add to new block
	Instruction* added_inst = builder->AddInstruction(std::move(new_ref_inst));
	uid2offset_[added_inst->unique_id()] = uid2offset_[ref_inst->unique_id()];
	if (new_ref_id != 0)
	get_decoration_mgr()->CloneDecorations(ref_result_id, new_ref_id);
	return new_ref_id;
	}

	bool InstBuffAddrCheckPass::IsPhysicalBuffAddrReference(Instruction* ref_inst) {
	if (ref_inst->opcode() != spv::Op::OpLoad &&
	ref_inst->opcode() != spv::Op::OpStore)
	return false;
	uint32_t ptr_id = ref_inst->GetSingleWordInOperand(0);
	analysis::DefUseManager* du_mgr = get_def_use_mgr();
	Instruction* ptr_inst = du_mgr->GetDef(ptr_id);
	if (ptr_inst->opcode() != spv::Op::OpAccessChain) return false;
	uint32_t ptr_ty_id = ptr_inst->type_id();
	Instruction* ptr_ty_inst = du_mgr->GetDef(ptr_ty_id);
	if (spv::StorageClass(ptr_ty_inst->GetSingleWordInOperand(0)) !=
	spv::StorageClass::PhysicalStorageBufferEXT)
	return false;
	return true;
	}

	// TODO(greg-lunarg): Refactor with InstBindlessCheckPass::GenCheckCode() ??
	void InstBuffAddrCheckPass::GenCheckCode(
	uint32_t check_id, Instruction* ref_inst,
	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 conditional branch on check_id. Valid branch generates original
	// reference. Invalid generates debug output and zero result (if needed).
	uint32_t merge_blk_id = TakeNextId();
	uint32_t valid_blk_id = TakeNextId();
	uint32_t invalid_blk_id = TakeNextId();
	std::unique_ptr<Instruction> merge_label(NewLabel(merge_blk_id));
	std::unique_ptr<Instruction> valid_label(NewLabel(valid_blk_id));
	std::unique_ptr<Instruction> invalid_label(NewLabel(invalid_blk_id));
	(void)builder.AddConditionalBranch(
	check_id, valid_blk_id, invalid_blk_id, merge_blk_id,
	uint32_t(spv::SelectionControlMask::MaskNone));
	// Gen valid branch
	std::unique_ptr<BasicBlock> new_blk_ptr(
	new BasicBlock(std::move(valid_label)));
	builder.SetInsertPoint(&*new_blk_ptr);
	uint32_t new_ref_id = CloneOriginalReference(ref_inst, &builder);
	(void)builder.AddBranch(merge_blk_id);
	new_blocks->push_back(std::move(new_blk_ptr));
	// Gen invalid block
	new_blk_ptr.reset(new BasicBlock(std::move(invalid_label)));
	builder.SetInsertPoint(&*new_blk_ptr);
	// Gen zero for invalid load. If pointer type, need to convert uint64
	// zero to pointer; cannot create ConstantNull of pointer type.
	uint32_t null_id = 0;
	if (new_ref_id != 0) {
	uint32_t ref_type_id = ref_inst->type_id();
	analysis::TypeManager* type_mgr = context()->get_type_mgr();
	analysis::Type* ref_type = type_mgr->GetType(ref_type_id);
	if (ref_type->AsPointer() != nullptr) {
	uint32_t null_u64_id = GetNullId(GetUint64Id());
	Instruction* null_ptr_inst = builder.AddUnaryOp(
	ref_type_id, spv::Op::OpConvertUToPtr, null_u64_id);
	null_id = null_ptr_inst->result_id();
	} else {
	null_id = GetNullId(ref_type_id);
	}
	}
	(void)builder.AddBranch(merge_blk_id);
	new_blocks->push_back(std::move(new_blk_ptr));
	// Gen merge block
	new_blk_ptr.reset(new BasicBlock(std::move(merge_label)));
	builder.SetInsertPoint(&*new_blk_ptr);
	// Gen phi of new reference and zero, if necessary, and replace the
	// result id of the original reference with that of the Phi. Kill original
	// reference.
	if (new_ref_id != 0) {
	Instruction* phi_inst =
	builder.AddPhi(ref_inst->type_id(),
	{new_ref_id, valid_blk_id, null_id, invalid_blk_id});
	context()->ReplaceAllUsesWith(ref_inst->result_id(), phi_inst->result_id());
	}
	new_blocks->push_back(std::move(new_blk_ptr));
	context()->KillInst(ref_inst);
	}

	uint32_t InstBuffAddrCheckPass::GetTypeLength(uint32_t type_id) {
	Instruction* type_inst = get_def_use_mgr()->GetDef(type_id);
	switch (type_inst->opcode()) {
	case spv::Op::OpTypeFloat:
	case spv::Op::OpTypeInt:
	return type_inst->GetSingleWordInOperand(0) / 8u;
	case spv::Op::OpTypeVector:
	case spv::Op::OpTypeMatrix:
	return type_inst->GetSingleWordInOperand(1) *
	GetTypeLength(type_inst->GetSingleWordInOperand(0));
	case spv::Op::OpTypePointer:
	assert(spv::StorageClass(type_inst->GetSingleWordInOperand(0)) ==
	spv::StorageClass::PhysicalStorageBufferEXT &&
	"unexpected pointer type");
	return 8u;
	case spv::Op::OpTypeArray: {
	uint32_t const_id = type_inst->GetSingleWordInOperand(1);
	Instruction* const_inst = get_def_use_mgr()->GetDef(const_id);
	uint32_t cnt = const_inst->GetSingleWordInOperand(0);
	return cnt * GetTypeLength(type_inst->GetSingleWordInOperand(0));
	}
	case spv::Op::OpTypeStruct: {
	// Figure out the location of the last byte of the last member of the
	// structure.
	uint32_t last_offset = 0, last_len = 0;

	get_decoration_mgr()->ForEachDecoration(
	type_id, uint32_t(spv::Decoration::Offset),
	[&last_offset](const Instruction& deco_inst) {
	last_offset = deco_inst.GetSingleWordInOperand(3);
	});
	type_inst->ForEachInId([&last_len, this](const uint32_t* iid) {
	last_len = GetTypeLength(*iid);
	});
	return last_offset + last_len;
	}
	case spv::Op::OpTypeRuntimeArray:
	default:
	assert(false && "unexpected type");
	return 0;
	}
	}

	void InstBuffAddrCheckPass::AddParam(uint32_t type_id,
	std::vector<uint32_t>* param_vec,
	std::unique_ptr<Function>* input_func) {
	uint32_t pid = TakeNextId();
	param_vec->push_back(pid);
	std::unique_ptr<Instruction> param_inst(new Instruction(
	get_module()->context(), spv::Op::OpFunctionParameter, type_id, pid, {}));
	get_def_use_mgr()->AnalyzeInstDefUse(&*param_inst);
	(*input_func)->AddParameter(std::move(param_inst));
	}

	// This is a stub function for use with Import linkage
	// clang-format off
	// GLSL:
	//bool inst_bindless_search_and_test(const uint shader_id, const uint inst_num, const uvec4 stage_info,
	// const uint64 ref_ptr, const uint length) {
	//}
	// clang-format on
	uint32_t InstBuffAddrCheckPass::GetSearchAndTestFuncId() {
	enum {
	kShaderId = 0,
	kInstructionIndex = 1,
	kStageInfo = 2,
	kRefPtr = 3,
	kLength = 4,
	kNumArgs
	};
	if (search_test_func_id_ != 0) {
	return search_test_func_id_;
	}
	// Generate function "bool search_and_test(uint64_t ref_ptr, uint32_t len)"
	// which searches input buffer for buffer which most likely contains the
	// pointer value \|ref_ptr\| and verifies that the entire reference of
	// length \|len\| bytes is contained in the buffer.
	analysis::TypeManager* type_mgr = context()->get_type_mgr();
	const analysis::Integer* 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 = {
	uint_type, uint_type, v4uint_type, type_mgr->GetType(GetUint64Id()),
	uint_type};

	const std::string func_name{"inst_buff_addr_search_and_test"};
	const uint32_t func_id = TakeNextId();
	std::unique_ptr<Function> func =
	StartFunction(func_id, type_mgr->GetBoolType(), param_types);
	func->SetFunctionEnd(EndFunction());
	context()->AddFunctionDeclaration(std::move(func));
	context()->AddDebug2Inst(NewName(func_id, func_name));

	std::vector<Operand> operands{
	{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {func_id}},
	{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
	{uint32_t(spv::Decoration::LinkageAttributes)}},
	{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_STRING,
	utils::MakeVector(func_name.c_str())},
	{spv_operand_type_t::SPV_OPERAND_TYPE_LINKAGE_TYPE,
	{uint32_t(spv::LinkageType::Import)}},
	};
	get_decoration_mgr()->AddDecoration(spv::Op::OpDecorate, operands);

	search_test_func_id_ = func_id;
	return search_test_func_id_;
	}

	uint32_t InstBuffAddrCheckPass::GenSearchAndTest(Instruction* ref_inst,
	InstructionBuilder* builder,
	uint32_t* ref_uptr_id,
	uint32_t stage_idx) {
	// Enable Int64 if necessary
	// Convert reference pointer to uint64
	const uint32_t ref_ptr_id = ref_inst->GetSingleWordInOperand(0);
	Instruction* ref_uptr_inst =
	builder->AddUnaryOp(GetUint64Id(), spv::Op::OpConvertPtrToU, ref_ptr_id);
	*ref_uptr_id = ref_uptr_inst->result_id();
	// Compute reference length in bytes
	analysis::DefUseManager* du_mgr = get_def_use_mgr();
	Instruction* ref_ptr_inst = du_mgr->GetDef(ref_ptr_id);
	const uint32_t ref_ptr_ty_id = ref_ptr_inst->type_id();
	Instruction* ref_ptr_ty_inst = du_mgr->GetDef(ref_ptr_ty_id);
	const uint32_t ref_len =
	GetTypeLength(ref_ptr_ty_inst->GetSingleWordInOperand(1));
	// Gen call to search and test function
	const uint32_t func_id = GetSearchAndTestFuncId();
	const std::vector<uint32_t> args = {
	builder->GetUintConstantId(shader_id_),
	builder->GetUintConstantId(ref_inst->unique_id()),
	GenStageInfo(stage_idx, builder), *ref_uptr_id,
	builder->GetUintConstantId(ref_len)};
	return GenReadFunctionCall(GetBoolId(), func_id, args, builder);
	}

	void InstBuffAddrCheckPass::GenBuffAddrCheckCode(
	BasicBlock::iterator ref_inst_itr,
	UptrVectorIterator<BasicBlock> ref_block_itr, uint32_t stage_idx,
	std::vector<std::unique_ptr<BasicBlock>>* new_blocks) {
	// Look for reference through indexed descriptor. If found, analyze and
	// save components. If not, return.
	Instruction* ref_inst = &*ref_inst_itr;
	if (!IsPhysicalBuffAddrReference(ref_inst)) return;
	// 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);
	InstructionBuilder builder(
	context(), &*new_blk_ptr,
	IRContext::kAnalysisDefUse \| IRContext::kAnalysisInstrToBlockMapping);
	new_blocks->push_back(std::move(new_blk_ptr));
	// Generate code to do search and test if all bytes of reference
	// are within a listed buffer. Return reference pointer converted to uint64.
	uint32_t ref_uptr_id;
	uint32_t valid_id =
	GenSearchAndTest(ref_inst, &builder, &ref_uptr_id, stage_idx);
	// Generate test of search results with true branch
	// being full reference and false branch being debug output and zero
	// for the referenced value.
	GenCheckCode(valid_id, ref_inst, new_blocks);

	// Move original block's remaining code into remainder/merge block and add
	// to new blocks
	BasicBlock* back_blk_ptr = &*new_blocks->back();
	MovePostludeCode(ref_block_itr, back_blk_ptr);
	}

	void InstBuffAddrCheckPass::InitInstBuffAddrCheck() {
	// Initialize base class
	InitializeInstrument();
	// Initialize class
	search_test_func_id_ = 0;
	}

	Pass::Status InstBuffAddrCheckPass::ProcessImpl() {
	// The memory model and linkage must always be updated for spirv-link to work
	// correctly.
	AddStorageBufferExt();
	if (!get_feature_mgr()->HasExtension(kSPV_KHR_physical_storage_buffer)) {
	context()->AddExtension("SPV_KHR_physical_storage_buffer");
	}

	context()->AddCapability(spv::Capability::PhysicalStorageBufferAddresses);
	Instruction* memory_model = get_module()->GetMemoryModel();
	memory_model->SetInOperand(
	0u, {uint32_t(spv::AddressingModel::PhysicalStorageBuffer64)});

	context()->AddCapability(spv::Capability::Int64);
	context()->AddCapability(spv::Capability::Linkage);
	// Perform bindless bounds check 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 GenBuffAddrCheckCode(ref_inst_itr, ref_block_itr, stage_idx,
	new_blocks);
	};
	InstProcessEntryPointCallTree(pfn);
	// This pass always changes the memory model, so that linking will work
	// properly.
	return Status::SuccessWithChange;
	}

	Pass::Status InstBuffAddrCheckPass::Process() {
	InitInstBuffAddrCheck();
	return ProcessImpl();
	}

	} // namespace opt
	} // namespace spvtools