(unofficial mirror fork)
326c69896b
It's undefined behavior to cast down to any other type and dereference that pointer unless: 1. It's similar (*extremely* vague definition at face value, see below for clarification) 2. The casted to type is either the signed/unsigned variant of the original type. (e.g. it's fine to cast an int* to an unsigned int* and vice-versa). 3. The casted to pointer type is either std::byte*, char*, or unsigned char*. With regards to type similarity, two types (X and Y) are considered "similar" if: 1. They're the same type (naturally) 2. They're both pointers and the pointed-to types are similar (basically 1. but for pointers) 3. They're both pointers to members of the same class and the types of the pointed-to members are similar in type. 4. They're both arrays of the same size or both arrays of unknown size *and* the array element types are similar. Plus, doing it this way doesn't do a byte-by-byte appending to the underlying std::vector and instead allocates all the necessary memory up front and slaps the elements at the end of it. |
||
|---|---|---|
| externals | ||
| include/sirit | ||
| src | ||
| tests | ||
| .clang-format | ||
| .gitignore | ||
| .gitmodules | ||
| CMakeLists.txt | ||
| LICENSE.txt | ||
| README.md | ||
Sirit
A runtime SPIR-V assembler. It aims to ease dynamic SPIR-V code generation
without calling external applications (like Khronos' spirv-as)
Its design aims to move code that does not belong to the application in the library without, limitting its functionality.
What it does for you:
- Sort declaration opcodes
- Handle types and constant duplicates
- Emit SPIR-V opcodes
What does not do for you:
- Avoid ID duplicates (emitting the same instruction twice)
- Dump code to disk
- Handle code blocks/branches
- Compile from a higher level language
It's in early stages of development, many instructions are missing since they are written manually instead of being generated from a file.
Example
class MyModule : public Sirit::Module {
public:
MyModule() {}
~MyModule() = default;
void Generate() {
AddCapability(spv::Capability::Shader);
SetMemoryModel(spv::AddressingModel::Logical, spv::MemoryModel::GLSL450);
auto main_type{TypeFunction(TypeVoid())};
auto main_func{Emit(OpFunction(TypeVoid(), spv::FunctionControlMask::MaskNone, main_type))};
Emit(OpLabel());
Emit(OpReturn());
Emit(OpFunctionEnd());
AddEntryPoint(spv::ExecutionModel::Vertex, main_func, "main");
}
};
// Then...
MyModule module;
module.Generate();
std::vector<std::uint8_t> code{module.Assemble()};