spv_result_t Function::RegisterLoopMerge(uint32_t merge_id,
uint32_t continue_id) {
RegisterBlock(merge_id, false);
RegisterBlock(continue_id, false);
BasicBlock& merge_block = blocks_.at(merge_id);
BasicBlock& continue_target_block = blocks_.at(continue_id);
assert(current_block_ &&
"RegisterLoopMerge must be called when called within a block");
current_block_->set_type(kBlockTypeLoop);
merge_block.set_type(kBlockTypeMerge);
continue_target_block.set_type(kBlockTypeContinue);
Construct& loop_construct =
AddConstruct({ConstructType::kLoop, current_block_, &merge_block});
Construct& continue_construct =
AddConstruct({ConstructType::kContinue, &continue_target_block});
continue_construct.set_corresponding_constructs({&loop_construct});
loop_construct.set_corresponding_constructs({&continue_construct});
merge_block_header_[&merge_block] = current_block_;
if (continue_target_headers_.find(&continue_target_block) ==
continue_target_headers_.end()) {
continue_target_headers_[&continue_target_block] = {current_block_};
} else {
continue_target_headers_[&continue_target_block].push_back(current_block_);
}
return SPV_SUCCESS;
}
spv_result_t Function::RegisterSelectionMerge(uint32_t merge_id) {
RegisterBlock(merge_id, false);
BasicBlock& merge_block = blocks_.at(merge_id);
current_block_->set_type(kBlockTypeHeader);
merge_block.set_type(kBlockTypeMerge);
AddConstruct({ConstructType::kSelection, current_block(), &merge_block});
return SPV_SUCCESS;
}
static void* DebugAllocator(size_t size, bool Noexcept, ALLOCATION_TYPE type,const char* Function, const char* File, int Line)
{
size_t realSize = GetRequiredSize(size);
auto Info = static_cast<MEMINFO*>(malloc(realSize));
if (!Info)
{
if (Noexcept)
return nullptr;
else
throw far_bad_alloc(File, Line, Function, type, size);
}
Info->AllocationType = type;
Info->Size = realSize;
Info->Function = Function;
Info->File = File;
Info->Line = Line;
GetMarker(Info) = EndMarker;
RegisterBlock(Info);
return ToUser(Info);
}