1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/* Copyright (c) 2022 The Khronos Group 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.
*
* Author: Spencer Fricke <spencerfricke@gmail.com>
*/
#include "shader_instruction.h"
#include "shader_module.h"
#include "spirv_grammar_helper.h"
Instruction::Instruction(std::vector<uint32_t>::const_iterator it) : result_id_(0), type_id_(0) {
words_.emplace_back(*it++);
words_.reserve(Length());
for (uint32_t i = 1; i < Length(); i++) {
words_.emplace_back(*it++);
}
const bool has_result = OpcodeHasResult(Opcode());
if (OpcodeHasType(Opcode())) {
type_id_ = 1;
if (has_result) {
result_id_ = 2;
}
} else if (has_result) {
result_id_ = 1;
}
}
std::string Instruction::Describe() const {
std::ostringstream ss;
const uint32_t opcode = Opcode();
uint32_t operand_offset = 1; // where to start printing operands
// common disassembled for SPIR-V is
// %result = Opcode %result_type %operands
if (OpcodeHasResult(opcode)) {
operand_offset++;
ss << "%" << (OpcodeHasType(opcode) ? Word(2) : Word(1)) << " = ";
}
ss << string_SpvOpcode(opcode);
if (OpcodeHasType(opcode)) {
operand_offset++;
ss << " %" << Word(1);
}
// TODO - For now don't list the '%' for any operands since they are only for reference IDs. Without generating a table of each
// instructions operand types and covering the many edge cases (such as optional, paired, or variable operands) this is the
// simplest way to print the instruction and give the developer something to look into when an error occurs.
//
// For now this safely should be able to assume it will never come across a LiteralString such as in OpExtInstImport or
// OpEntryPoint
for (uint32_t i = operand_offset; i < Length(); i++) {
ss << " " << Word(i);
}
return ss.str();
}
// While simple, function name provides a more human readable description why Word(3) is used
uint32_t Instruction::GetConstantValue() const {
// This should be a OpConstant (not a OpSpecConstant), if this asserts then 2 things are happening
// 1. This function is being used where we don't actually know it is a constant and is a bug in the validation layers
// 2. The CreateFoldSpecConstantOpAndCompositePass didn't fully fold everything and is a bug in spirv-opt
assert(Opcode() == spv::OpConstant);
return Word(3);
}
// The idea of this function is to not have to constantly lookup which operand for the width
// inst.Word(2) -> inst.GetBitWidth()
uint32_t Instruction::GetBitWidth() const {
const uint32_t opcode = Opcode();
uint32_t bit_width = 0;
switch (opcode) {
case spv::Op::OpTypeFloat:
case spv::Op::OpTypeInt:
bit_width = Word(2);
break;
case spv::Op::OpTypeBool:
// The Spec states:
// "Boolean values considered as 32-bit integer values for the purpose of this calculation"
// when getting the size for the limits
bit_width = 32;
break;
default:
// Most likely the caller is not checking for this being a matrix/array/struct/etc
// This class only knows a single instruction's information
assert(0);
break;
}
return bit_width;
}
AtomicInstructionInfo Instruction::GetAtomicInfo(const SHADER_MODULE_STATE& module_state) const {
AtomicInstructionInfo info;
// All atomics have a pointer referenced
const uint32_t pointer_index = Opcode() == spv::OpAtomicStore ? 1 : 3;
const Instruction* access = module_state.FindDef(Word(pointer_index));
// spirv-val will catch if not OpTypePointer
const Instruction* pointer = module_state.FindDef(access->Word(1));
info.storage_class = pointer->Word(2);
const Instruction* data_type = module_state.FindDef(pointer->Word(3));
info.type = data_type->Opcode();
info.bit_width = data_type->GetBitWidth();
return info;
}
spv::BuiltIn Instruction::GetBuiltIn() const {
if (Opcode() == spv::OpDecorate) {
return static_cast<spv::BuiltIn>(Word(3));
} else if (Opcode() == spv::OpMemberDecorate) {
return static_cast<spv::BuiltIn>(Word(4));
} else {
assert(false); // non valid Opcode
return spv::BuiltInMax;
}
}
|
