yuzu-mirror/sirit
1
0
Fork 0
mirror of https://github.com/yuzu-mirror/sirit.git synced 2026-03-11 04:43:50 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
sirit/src/instructions/memory.cpp

75 lines
2.7 KiB
C++
Raw Normal View History

Add OpVariable
2018-10-18 09:27:17 +02:00
/* This file is part of the sirit project.
Relicense to The BSD 3-clause license
2019-07-14 23:48:59 +02:00
* Copyright (c) 2019 sirit
* This software may be used and distributed according to the terms of the
* 3-Clause BSD License
Add OpVariable
2018-10-18 09:27:17 +02:00
*/
Change clang-format settings
2019-03-11 07:26:21 +01:00
#include <cassert>
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
Add OpVariable
2018-10-18 09:27:17 +02:00
#include "sirit/sirit.h"
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
#include "stream.h"
Add OpVariable
2018-10-18 09:27:17 +02:00
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
namespace Sirit {
Add OpVariable
2018-10-18 09:27:17 +02:00
memory: Add OpImageTexelPointer
2020-06-02 07:13:37 +02:00
Id Module::OpImageTexelPointer(Id result_type, Id image, Id coordinate, Id sample) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(6);
return *code << OpId{spv::Op::OpImageTexelPointer, result_type} << image << coordinate << sample
<< EndOp{};
memory: Add OpImageTexelPointer
2020-06-02 07:13:37 +02:00
}
Change clang-format settings
2019-03-11 07:26:21 +01:00
Id Module::OpLoad(Id result_type, Id pointer, std::optional<spv::MemoryAccessMask> memory_access) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(5);
return *code << OpId{spv::Op::OpLoad, result_type} << pointer << memory_access << EndOp{};
Add OpLoad
2018-10-31 08:16:26 +01:00
}
Change clang-format settings
2019-03-11 07:26:21 +01:00
Id Module::OpStore(Id pointer, Id object, std::optional<spv::MemoryAccessMask> memory_access) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(4);
return *code << spv::Op::OpStore << pointer << object << memory_access << EndOp{};
Add OpStore
2018-10-31 09:05:06 +01:00
}
Upgrade to C++20 and use std::span
2020-07-29 10:46:50 +02:00
Id Module::OpAccessChain(Id result_type, Id base, std::span<const Id> indexes) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
assert(!indexes.empty());
code->Reserve(4 + indexes.size());
return *code << OpId{spv::Op::OpAccessChain, result_type} << base << indexes << EndOp{};
Add OpAccessChain
2018-10-31 07:37:36 +01:00
}
Add OpVectorExtractDynamic and OpVectorInsertDynamic
2019-09-09 20:41:53 +02:00
Id Module::OpVectorExtractDynamic(Id result_type, Id vector, Id index) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(5);
return *code << OpId{spv::Op::OpVectorExtractDynamic, result_type} << vector << index
<< EndOp{};
Add OpVectorExtractDynamic and OpVectorInsertDynamic
2019-09-09 20:41:53 +02:00
}
Id Module::OpVectorInsertDynamic(Id result_type, Id vector, Id component, Id index) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(6);
return *code << OpId{spv::Op::OpVectorInsertDynamic, result_type} << vector << component
<< index << EndOp{};
Add OpVectorExtractDynamic and OpVectorInsertDynamic
2019-09-09 20:41:53 +02:00
}
Add missing GLSL instructions
2022-11-06 20:02:05 +01:00
Id Module::OpVectorShuffle(Id result_type, Id vector_1, Id vector_2, std::span<const Literal> components) {
code->Reserve(5 + components.size());
return *code << OpId{spv::Op::OpVectorShuffle, result_type} << vector_1 << vector_2
<< components << EndOp{};
}
Rename Ref alias to Id
2018-11-01 02:20:49 +01:00
Id Module::OpCompositeInsert(Id result_type, Id object, Id composite,
Upgrade to C++20 and use std::span
2020-07-29 10:46:50 +02:00
std::span<const Literal> indexes) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(5 + indexes.size());
return *code << OpId{spv::Op::OpCompositeInsert, result_type} << object << composite << indexes
<< EndOp{};
Add OpStore
2018-10-31 09:05:06 +01:00
}
Upgrade to C++20 and use std::span
2020-07-29 10:46:50 +02:00
Id Module::OpCompositeExtract(Id result_type, Id composite, std::span<const Literal> indexes) {
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(4 + indexes.size());
return *code << OpId{spv::Op::OpCompositeExtract, result_type} << composite << indexes
<< EndOp{};
Add OpCompositeExtract
2018-11-04 00:41:03 +01:00
}
Upgrade to C++20 and use std::span
2020-07-29 10:46:50 +02:00
Id Module::OpCompositeConstruct(Id result_type, std::span<const Id> ids) {
Add OpCompositeConstruct
2018-11-04 06:38:13 +01:00
assert(ids.size() >= 1);
Stream SPIR-V instructions directly to a binary Before this commit sirit generated a stream of tokens that would then be inserted to the final SPIR-V binary. This design was carried from the initial design of manually inserting opcodes into the code. Now that all instructions but labels are inserted when their respective function is called, the old design can be dropped in favor of generating a valid stream of SPIR-V opcodes. The API for variables is broken, but adopting the new one is trivial. Instead of calling OpVariable and then adding a global or local variable, OpVariable was removed and global or local variables are generated when they are called. Avoiding duplicates is now done with an std::unordered_set instead of using a linear search jumping through vtables.
2020-08-01 06:50:01 +02:00
code->Reserve(3 + ids.size());
return *code << OpId{spv::Op::OpCompositeConstruct, result_type} << ids << EndOp{};
Add OpCompositeConstruct
2018-11-04 06:38:13 +01:00
}
Add OpVariable
2018-10-18 09:27:17 +02:00
} // namespace Sirit
Reference in a new issue Copy permalink