stuff/suyu
stuff/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-11-27 05:46:34 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
suyu/src/video_core/shader/decode/conversion.cpp

322 lines
13 KiB
C++
Raw Normal View History

shader_ir: Initial implementation
2018-12-20 17:09:21 -05:00
// Copyright 2018 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
shader/conversion: Implement I2I sign extension, saturation and selection Reimplements I2I adding sign extension, saturation (clamp source value to the destination), selection and destination sizes that are not 32 bits wide. It doesn't implement CC yet.
2020-04-07 01:16:51 -04:00
#include <limits>
#include <optional>
#include <utility>
shader_ir: Initial implementation
2018-12-20 17:09:21 -05:00
#include "common/assert.h"
#include "common/common_types.h"
#include "video_core/engines/shader_bytecode.h"
shader: Use shared_ptr to store nodes and move initialization to file Instead of having a vector of unique_ptr stored in a vector and returning star pointers to this, use shared_ptr. While changing initialization code, move it to a separate file when possible. This is a first step to allow code analysis and node generation beyond the ShaderIR class.
2019-06-04 21:44:06 -04:00
#include "video_core/shader/node_helper.h"
shader_ir: Initial implementation
2018-12-20 17:09:21 -05:00
#include "video_core/shader/shader_ir.h"
namespace VideoCommon::Shader {
using Tegra::Shader::Instruction;
using Tegra::Shader::OpCode;
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
using Tegra::Shader::Register;
shader_ir: Initial implementation
2018-12-20 17:09:21 -05:00
shader_ir/conversion: Split int and float selector and implement F2F H1
2019-08-28 15:09:33 -04:00
namespace {
shader/conversion: Implement I2I sign extension, saturation and selection Reimplements I2I adding sign extension, saturation (clamp source value to the destination), selection and destination sizes that are not 32 bits wide. It doesn't implement CC yet.
2020-04-07 01:16:51 -04:00
shader_ir/conversion: Split int and float selector and implement F2F H1
2019-08-28 15:09:33 -04:00
constexpr OperationCode GetFloatSelector(u64 selector) {
return selector == 0 ? OperationCode::FCastHalf0 : OperationCode::FCastHalf1;
}
shader/conversion: Implement I2I sign extension, saturation and selection Reimplements I2I adding sign extension, saturation (clamp source value to the destination), selection and destination sizes that are not 32 bits wide. It doesn't implement CC yet.
2020-04-07 01:16:51 -04:00
constexpr u32 SizeInBits(Register::Size size) {
switch (size) {
case Register::Size::Byte:
return 8;
case Register::Size::Short:
return 16;
case Register::Size::Word:
return 32;
case Register::Size::Long:
return 64;
}
return 0;
}
constexpr std::optional<std::pair<s32, s32>> IntegerSaturateBounds(Register::Size src_size,
Register::Size dst_size,
bool src_signed,
bool dst_signed) {
const u32 dst_bits = SizeInBits(dst_size);
if (src_size == Register::Size::Word && dst_size == Register::Size::Word) {
if (src_signed == dst_signed) {
return std::nullopt;
}
return std::make_pair(0, std::numeric_limits<s32>::max());
}
if (dst_signed) {
// Signed destination, clamp to [-128, 127] for instance
return std::make_pair(-(1 << (dst_bits - 1)), (1 << (dst_bits - 1)) - 1);
} else {
// Unsigned destination
if (dst_bits == 32) {
// Avoid shifting by 32, that is undefined behavior
return std::make_pair(0, s32(std::numeric_limits<u32>::max()));
}
return std::make_pair(0, (1 << dst_bits) - 1);
}
}
shader_ir/conversion: Split int and float selector and implement F2F H1
2019-08-28 15:09:33 -04:00
} // Anonymous namespace
shader_ir: Rename BasicBlock to NodeBlock It's not always used as a basic block. Rename it for consistency.
2019-01-30 00:09:40 -05:00
u32 ShaderIR::DecodeConversion(NodeBlock& bb, u32 pc) {
shader_ir: Initial implementation
2018-12-20 17:09:21 -05:00
const Instruction instr = {program_code[pc]};
const auto opcode = OpCode::Decode(instr);
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
switch (opcode->get().GetId()) {
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::I2I_R:
case OpCode::Id::I2I_C:
case OpCode::Id::I2I_IMM: {
shader/conversion: Implement I2I sign extension, saturation and selection Reimplements I2I adding sign extension, saturation (clamp source value to the destination), selection and destination sizes that are not 32 bits wide. It doesn't implement CC yet.
2020-04-07 01:16:51 -04:00
const bool src_signed = instr.conversion.is_input_signed;
const bool dst_signed = instr.conversion.is_output_signed;
const Register::Size src_size = instr.conversion.src_size;
const Register::Size dst_size = instr.conversion.dst_size;
const u32 selector = static_cast<u32>(instr.conversion.int_src.selector);
shader_decode: Implement I2I
2018-12-17 19:14:25 -05:00
shader/conversion: Implement I2I sign extension, saturation and selection Reimplements I2I adding sign extension, saturation (clamp source value to the destination), selection and destination sizes that are not 32 bits wide. It doesn't implement CC yet.
2020-04-07 01:16:51 -04:00
Node value = [this, instr, opcode] {
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
switch (opcode->get().GetId()) {
case OpCode::Id::I2I_R:
return GetRegister(instr.gpr20);
case OpCode::Id::I2I_C:
return GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset());
case OpCode::Id::I2I_IMM:
return Immediate(instr.alu.GetSignedImm20_20());
default:
UNREACHABLE();
return Immediate(0);
}
}();
shader_decode: Implement I2I
2018-12-17 19:14:25 -05:00
shader/conversion: Implement I2I sign extension, saturation and selection Reimplements I2I adding sign extension, saturation (clamp source value to the destination), selection and destination sizes that are not 32 bits wide. It doesn't implement CC yet.
2020-04-07 01:16:51 -04:00
// Ensure the source selector is valid
switch (instr.conversion.src_size) {
case Register::Size::Byte:
break;
case Register::Size::Short:
ASSERT(selector == 0 || selector == 2);
break;
default:
ASSERT(selector == 0);
break;
}
if (src_size != Register::Size::Word || selector != 0) {
value = SignedOperation(OperationCode::IBitfieldExtract, src_signed, std::move(value),
Immediate(selector * 8), Immediate(SizeInBits(src_size)));
}
value = GetOperandAbsNegInteger(std::move(value), instr.conversion.abs_a,
instr.conversion.negate_a, src_signed);
if (instr.alu.saturate_d) {
if (src_signed && !dst_signed) {
Node is_negative = Operation(OperationCode::LogicalUGreaterEqual, value,
Immediate(1 << (SizeInBits(src_size) - 1)));
value = Operation(OperationCode::Select, std::move(is_negative), Immediate(0),
std::move(value));
// Simplify generated expressions, this can be removed without semantic impact
SetTemporary(bb, 0, std::move(value));
value = GetTemporary(0);
if (dst_size != Register::Size::Word) {
const Node limit = Immediate((1 << SizeInBits(dst_size)) - 1);
Node is_large =
Operation(OperationCode::LogicalUGreaterThan, std::move(value), limit);
value = Operation(OperationCode::Select, std::move(is_large), limit,
std::move(value));
}
} else if (const std::optional bounds =
IntegerSaturateBounds(src_size, dst_size, src_signed, dst_signed)) {
value = SignedOperation(OperationCode::IMax, src_signed, std::move(value),
Immediate(bounds->first));
value = SignedOperation(OperationCode::IMin, src_signed, std::move(value),
Immediate(bounds->second));
}
} else if (dst_size != Register::Size::Word) {
// No saturation, we only have to mask the result
Node mask = Immediate((1 << SizeInBits(dst_size)) - 1);
value = Operation(OperationCode::UBitwiseAnd, std::move(value), std::move(mask));
shader_decode: Implement I2I
2018-12-17 19:14:25 -05:00
}
shader_decode: Improve zero flag implementation
2018-12-27 14:50:36 -05:00
SetInternalFlagsFromInteger(bb, value, instr.generates_cc);
shader/conversion: Implement I2I sign extension, saturation and selection Reimplements I2I adding sign extension, saturation (clamp source value to the destination), selection and destination sizes that are not 32 bits wide. It doesn't implement CC yet.
2020-04-07 01:16:51 -04:00
SetRegister(bb, instr.gpr0, std::move(value));
shader_decode: Implement I2I
2018-12-17 19:14:25 -05:00
break;
}
shader_decode: Implement I2F
2018-12-20 23:53:05 -05:00
case OpCode::Id::I2F_R:
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::I2F_C:
case OpCode::Id::I2F_IMM: {
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
UNIMPLEMENTED_IF(instr.conversion.dst_size == Register::Size::Long);
shader_decode: Implement I2F
2018-12-20 23:53:05 -05:00
UNIMPLEMENTED_IF_MSG(instr.generates_cc,
"Condition codes generation in I2F is not implemented");
shader/conversion: Implement byte selector in I2F I2F's byte selector is used to choose what bytes to convert to float. e.g. if the input is 0xaabbccdd and the selector is ".B3" it will convert 0xaa. The default (when it's not shown in nvdisasm) is ".B0", in that example the default would convert 0xdd to float.
2019-12-17 22:05:08 -05:00
Node value = [&] {
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
switch (opcode->get().GetId()) {
case OpCode::Id::I2F_R:
shader_decode: Implement I2F
2018-12-20 23:53:05 -05:00
return GetRegister(instr.gpr20);
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::I2F_C:
shader_ir: Unify constant buffer offset values Constant buffer values on the shader IR were using different offsets if the access direct or indirect. cbuf34 has a non-multiplied offset while cbuf36 does. On shader decoding this commit multiplies it by four on cbuf34 queries.
2019-01-28 16:11:23 -05:00
return GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset());
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::I2F_IMM:
return Immediate(instr.alu.GetSignedImm20_20());
default:
UNREACHABLE();
return Immediate(0);
shader_decode: Implement I2F
2018-12-20 23:53:05 -05:00
}
}();
shader/conversion: Implement byte selector in I2F I2F's byte selector is used to choose what bytes to convert to float. e.g. if the input is 0xaabbccdd and the selector is ".B3" it will convert 0xaa. The default (when it's not shown in nvdisasm) is ".B0", in that example the default would convert 0xdd to float.
2019-12-17 22:05:08 -05:00
shader_decode: Implement I2F
2018-12-20 23:53:05 -05:00
const bool input_signed = instr.conversion.is_input_signed;
shader/conversion: Implement byte selector in I2F I2F's byte selector is used to choose what bytes to convert to float. e.g. if the input is 0xaabbccdd and the selector is ".B3" it will convert 0xaa. The default (when it's not shown in nvdisasm) is ".B0", in that example the default would convert 0xdd to float.
2019-12-17 22:05:08 -05:00
fix warning
2020-02-18 23:10:26 -05:00
if (const u32 offset = static_cast<u32>(instr.conversion.int_src.selector); offset > 0) {
shader_conversion: add conversion I2F for Short
2020-02-18 22:54:37 -05:00
ASSERT(instr.conversion.src_size == Register::Size::Byte ||
instr.conversion.src_size == Register::Size::Short);
shader_conversion: I2F : add Assert for case src_size is Short
2020-02-18 23:40:35 -05:00
if (instr.conversion.src_size == Register::Size::Short) {
ASSERT(offset == 0 || offset == 2);
}
shader_conversion: add conversion I2F for Short
2020-02-18 22:54:37 -05:00
value = SignedOperation(OperationCode::ILogicalShiftRight, input_signed,
std::move(value), Immediate(offset * 8));
shader/conversion: Implement byte selector in I2F I2F's byte selector is used to choose what bytes to convert to float. e.g. if the input is 0xaabbccdd and the selector is ".B3" it will convert 0xaa. The default (when it's not shown in nvdisasm) is ".B0", in that example the default would convert 0xdd to float.
2019-12-17 22:05:08 -05:00
}
clang-format fix
2020-02-18 23:02:59 -05:00
shader_decode: Implement I2F
2018-12-20 23:53:05 -05:00
value = ConvertIntegerSize(value, instr.conversion.src_size, input_signed);
value = GetOperandAbsNegInteger(value, instr.conversion.abs_a, false, input_signed);
value = SignedOperation(OperationCode::FCastInteger, input_signed, PRECISE, value);
value = GetOperandAbsNegFloat(value, false, instr.conversion.negate_a);
shader_decode: Improve zero flag implementation
2018-12-27 14:50:36 -05:00
SetInternalFlagsFromFloat(bb, value, instr.generates_cc);
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
if (instr.conversion.dst_size == Register::Size::Short) {
value = Operation(OperationCode::HCastFloat, PRECISE, value);
}
shader_decode: Implement I2F
2018-12-20 23:53:05 -05:00
SetRegister(bb, instr.gpr0, value);
break;
}
shader_decode: Implement F2F_C
2018-12-17 19:42:59 -05:00
case OpCode::Id::F2F_R:
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::F2F_C:
case OpCode::Id::F2F_IMM: {
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
UNIMPLEMENTED_IF(instr.conversion.dst_size == Register::Size::Long);
UNIMPLEMENTED_IF(instr.conversion.src_size == Register::Size::Long);
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
UNIMPLEMENTED_IF_MSG(instr.generates_cc,
"Condition codes generation in F2F is not implemented");
shader_decode: Implement F2F_C
2018-12-17 19:42:59 -05:00
Node value = [&]() {
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
switch (opcode->get().GetId()) {
case OpCode::Id::F2F_R:
shader_decode: Implement F2F_C
2018-12-17 19:42:59 -05:00
return GetRegister(instr.gpr20);
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::F2F_C:
shader_ir: Unify constant buffer offset values Constant buffer values on the shader IR were using different offsets if the access direct or indirect. cbuf34 has a non-multiplied offset while cbuf36 does. On shader decoding this commit multiplies it by four on cbuf34 queries.
2019-01-28 16:11:23 -05:00
return GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset());
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::F2F_IMM:
return GetImmediate19(instr);
default:
UNREACHABLE();
return Immediate(0);
shader_decode: Implement F2F_C
2018-12-17 19:42:59 -05:00
}
}();
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
if (instr.conversion.src_size == Register::Size::Short) {
shader_ir/conversion: Split int and float selector and implement F2F H1
2019-08-28 15:09:33 -04:00
value = Operation(GetFloatSelector(instr.conversion.float_src.selector), NO_PRECISE,
std::move(value));
} else {
ASSERT(instr.conversion.float_src.selector == 0);
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
}
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
value = GetOperandAbsNegFloat(value, instr.conversion.abs_a, instr.conversion.negate_a);
shader/conversion: Fix F2F rounding operations with different sizes Rounding operations only matter when the conversion size of source and destination is the same, i.e. .F16.F16, .F32.F32 and .F64.F64. When there is a mismatch (.F16.F32), these bits are used for IEEE rounding, we don't emulate this because GLSL and SPIR-V don't support configuring it per operation.
2020-03-26 00:58:49 -04:00
value = [&] {
if (instr.conversion.src_size != instr.conversion.dst_size) {
// Rounding operations only matter when the source and destination conversion size
// is the same.
return value;
}
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
switch (instr.conversion.f2f.GetRoundingMode()) {
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
case Tegra::Shader::F2fRoundingOp::None:
return value;
case Tegra::Shader::F2fRoundingOp::Round:
shader/conversion: Fix F2F rounding operations with different sizes Rounding operations only matter when the conversion size of source and destination is the same, i.e. .F16.F16, .F32.F32 and .F64.F64. When there is a mismatch (.F16.F32), these bits are used for IEEE rounding, we don't emulate this because GLSL and SPIR-V don't support configuring it per operation.
2020-03-26 00:58:49 -04:00
return Operation(OperationCode::FRoundEven, value);
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
case Tegra::Shader::F2fRoundingOp::Floor:
shader/conversion: Fix F2F rounding operations with different sizes Rounding operations only matter when the conversion size of source and destination is the same, i.e. .F16.F16, .F32.F32 and .F64.F64. When there is a mismatch (.F16.F32), these bits are used for IEEE rounding, we don't emulate this because GLSL and SPIR-V don't support configuring it per operation.
2020-03-26 00:58:49 -04:00
return Operation(OperationCode::FFloor, value);
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
case Tegra::Shader::F2fRoundingOp::Ceil:
shader/conversion: Fix F2F rounding operations with different sizes Rounding operations only matter when the conversion size of source and destination is the same, i.e. .F16.F16, .F32.F32 and .F64.F64. When there is a mismatch (.F16.F32), these bits are used for IEEE rounding, we don't emulate this because GLSL and SPIR-V don't support configuring it per operation.
2020-03-26 00:58:49 -04:00
return Operation(OperationCode::FCeil, value);
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
case Tegra::Shader::F2fRoundingOp::Trunc:
shader/conversion: Fix F2F rounding operations with different sizes Rounding operations only matter when the conversion size of source and destination is the same, i.e. .F16.F16, .F32.F32 and .F64.F64. When there is a mismatch (.F16.F32), these bits are used for IEEE rounding, we don't emulate this because GLSL and SPIR-V don't support configuring it per operation.
2020-03-26 00:58:49 -04:00
return Operation(OperationCode::FTrunc, value);
video_core: Silent -Wswitch warnings
2019-04-03 03:33:36 -04:00
default:
UNIMPLEMENTED_MSG("Unimplemented F2F rounding mode {}",
static_cast<u32>(instr.conversion.f2f.rounding.Value()));
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
return value;
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
}
}();
value = GetSaturatedFloat(value, instr.alu.saturate_d);
shader_decode: Improve zero flag implementation
2018-12-27 14:50:36 -05:00
SetInternalFlagsFromFloat(bb, value, instr.generates_cc);
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
if (instr.conversion.dst_size == Register::Size::Short) {
value = Operation(OperationCode::HCastFloat, PRECISE, value);
}
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
SetRegister(bb, instr.gpr0, value);
break;
}
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
case OpCode::Id::F2I_R:
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::F2I_C:
case OpCode::Id::F2I_IMM: {
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
UNIMPLEMENTED_IF(instr.conversion.src_size == Register::Size::Long);
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
UNIMPLEMENTED_IF_MSG(instr.generates_cc,
"Condition codes generation in F2I is not implemented");
Node value = [&]() {
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
switch (opcode->get().GetId()) {
case OpCode::Id::F2I_R:
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
return GetRegister(instr.gpr20);
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::F2I_C:
shader_ir: Unify constant buffer offset values Constant buffer values on the shader IR were using different offsets if the access direct or indirect. cbuf34 has a non-multiplied offset while cbuf36 does. On shader decoding this commit multiplies it by four on cbuf34 queries.
2019-01-28 16:11:23 -05:00
return GetConstBuffer(instr.cbuf34.index, instr.cbuf34.GetOffset());
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
case OpCode::Id::F2I_IMM:
return GetImmediate19(instr);
default:
UNREACHABLE();
return Immediate(0);
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
}
}();
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
if (instr.conversion.src_size == Register::Size::Short) {
shader_ir/conversion: Split int and float selector and implement F2F H1
2019-08-28 15:09:33 -04:00
value = Operation(GetFloatSelector(instr.conversion.float_src.selector), NO_PRECISE,
std::move(value));
} else {
ASSERT(instr.conversion.float_src.selector == 0);
Shader_Ir: Implement F16 Variants of F2F, F2I, I2F. This commit takes care of implementing the F16 Variants of the conversion instructions and makes sure conversions are done.
2019-07-20 17:38:25 -04:00
}
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
value = GetOperandAbsNegFloat(value, instr.conversion.abs_a, instr.conversion.negate_a);
value = [&]() {
switch (instr.conversion.f2i.rounding) {
Corrected F2I None mode to RoundEven.
2019-02-11 17:46:45 -05:00
case Tegra::Shader::F2iRoundingOp::RoundEven:
return Operation(OperationCode::FRoundEven, PRECISE, value);
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
case Tegra::Shader::F2iRoundingOp::Floor:
return Operation(OperationCode::FFloor, PRECISE, value);
case Tegra::Shader::F2iRoundingOp::Ceil:
return Operation(OperationCode::FCeil, PRECISE, value);
case Tegra::Shader::F2iRoundingOp::Trunc:
return Operation(OperationCode::FTrunc, PRECISE, value);
default:
UNIMPLEMENTED_MSG("Unimplemented F2I rounding mode {}",
static_cast<u32>(instr.conversion.f2i.rounding.Value()));
video_core: Return safe values after an assert hits
2018-12-21 16:47:22 -05:00
return Immediate(0);
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
}
}();
const bool is_signed = instr.conversion.is_output_signed;
value = SignedOperation(OperationCode::ICastFloat, is_signed, PRECISE, value);
Do some corrections in conversion shader instructions. Corrects encodings for I2F, F2F, I2I and F2I Implements Immediate variants of all four conversion types. Add assertions to unimplemented stuffs.
2019-04-15 19:04:33 -04:00
value = ConvertIntegerSize(value, instr.conversion.dst_size, is_signed);
shader_decode: Implement F2I
2018-12-20 23:57:13 -05:00
SetRegister(bb, instr.gpr0, value);
break;
}
shader_decode: Implement F2F
2018-12-15 15:32:51 -05:00
default:
UNIMPLEMENTED_MSG("Unhandled conversion instruction: {}", opcode->get().GetName());
}
shader_ir: Initial implementation
2018-12-20 17:09:21 -05:00
return pc;
}
Corrected F2I None mode to RoundEven.
2019-02-11 17:46:45 -05:00
} // namespace VideoCommon::Shader
Reference in a new issue Copy permalink