yuzu/src/shader_recompiler/backend/glsl/emit_glsl_integer.cpp

245 lines
9.3 KiB
C++
Raw Normal View History

2021-05-21 08:00:12 +02:00
// Copyright 2021 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <string_view>
#include "shader_recompiler/backend/glsl/emit_context.h"
2021-05-29 08:09:29 +02:00
#include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
2021-05-21 08:00:12 +02:00
#include "shader_recompiler/frontend/ir/value.h"
namespace Shader::Backend::GLSL {
2021-05-28 04:28:33 +02:00
namespace {
void SetZeroFlag(EmitContext& ctx, IR::Inst& inst, std::string_view result) {
IR::Inst* const zero{inst.GetAssociatedPseudoOperation(IR::Opcode::GetZeroFromOp)};
if (!zero) {
return;
}
ctx.AddU1("{}={}==0;", *zero, result);
zero->Invalidate();
}
void SetSignFlag(EmitContext& ctx, IR::Inst& inst, std::string_view result) {
IR::Inst* const sign{inst.GetAssociatedPseudoOperation(IR::Opcode::GetSignFromOp)};
if (!sign) {
return;
}
ctx.AddU1("{}=int({})<0;", *sign, result);
sign->Invalidate();
}
} // Anonymous namespace
2021-05-22 03:37:13 +02:00
void EmitIAdd32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
const auto result{ctx.var_alloc.Define(inst, GlslVarType::U32)};
2021-05-28 21:51:50 +02:00
if (IR::Inst* const carry{inst.GetAssociatedPseudoOperation(IR::Opcode::GetCarryFromOp)}) {
2021-05-30 02:00:06 +02:00
ctx.uses_cc_carry = true;
2021-05-28 21:51:50 +02:00
ctx.Add("{}=uaddCarry({},{},carry);", result, a, b);
ctx.AddU1("{}=carry!=0;", *carry, result);
carry->Invalidate();
} else {
ctx.Add("{}={}+{};", result, a, b);
}
2021-05-28 04:28:33 +02:00
SetZeroFlag(ctx, inst, result);
SetSignFlag(ctx, inst, result);
2021-05-28 21:51:50 +02:00
if (IR::Inst * overflow{inst.GetAssociatedPseudoOperation(IR::Opcode::GetOverflowFromOp)}) {
// https://stackoverflow.com/questions/55468823/how-to-detect-integer-overflow-in-c
constexpr u32 s32_max{static_cast<u32>(std::numeric_limits<s32>::max())};
ctx.AddU1("{}=int({})>=0?int({})>int({}-{}):int({})<int({}-{});", *overflow, a, b, s32_max,
a, b, s32_max, a);
overflow->Invalidate();
}
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitIAdd64(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
ctx.AddU64("{}={}+{};", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitISub32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
2021-05-22 03:31:41 +02:00
ctx.AddU32("{}={}-{};", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitISub64(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
ctx.AddU64("{}={}-{};", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitIMul32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
2021-05-30 02:00:06 +02:00
ctx.AddU32("{}=uint({}*{});", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitINeg32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
2021-05-30 02:00:06 +02:00
ctx.AddU32("{}=uint(-({}));", inst, value);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitINeg64(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
2021-05-23 05:31:30 +02:00
ctx.AddU64("{}=-({});", inst, value);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitIAbs32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
ctx.AddU32("{}=abs(int({}));", inst, value);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitIAbs64(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
ctx.AddU64("{}=abs(int64_t({}));", inst, value);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitShiftLeftLogical32(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view shift) {
ctx.AddU32("{}={}<<{};", inst, base, shift);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitShiftLeftLogical64(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view shift) {
ctx.AddU64("{}={}<<{};", inst, base, shift);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitShiftRightLogical32(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view shift) {
ctx.AddU32("{}={}>>{};", inst, base, shift);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitShiftRightLogical64(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view shift) {
ctx.AddU64("{}={}>>{};", inst, base, shift);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitShiftRightArithmetic32(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view shift) {
2021-06-11 06:41:28 +02:00
ctx.AddU32("{}=int({})>>{};", inst, base, shift);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitShiftRightArithmetic64(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view shift) {
ctx.AddU64("{}=int64_t({})>>{};", inst, base, shift);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitwiseAnd32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
ctx.AddU32("{}={}&{};", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitwiseOr32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
ctx.AddU32("{}={}|{};", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitwiseXor32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
ctx.AddU32("{}={}^{};", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitFieldInsert(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view insert, std::string_view offset, std::string_view count) {
2021-05-30 02:00:06 +02:00
ctx.AddU32("{}=bitfieldInsert({},{},int({}),int({}));", inst, base, insert, offset, count);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitFieldSExtract(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view offset, std::string_view count) {
const auto result{ctx.var_alloc.Define(inst, GlslVarType::U32)};
ctx.Add("{}=uint(bitfieldExtract(int({}),int({}),int({})));", result, base, offset, count);
SetZeroFlag(ctx, inst, result);
SetSignFlag(ctx, inst, result);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitFieldUExtract(EmitContext& ctx, IR::Inst& inst, std::string_view base,
std::string_view offset, std::string_view count) {
const auto result{ctx.var_alloc.Define(inst, GlslVarType::U32)};
ctx.Add("{}=uint(bitfieldExtract(uint({}),int({}),int({})));", result, base, offset, count);
2021-05-28 04:28:33 +02:00
SetZeroFlag(ctx, inst, result);
SetSignFlag(ctx, inst, result);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitReverse32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
2021-05-22 03:31:41 +02:00
ctx.AddU32("{}=bitfieldReverse({});", inst, value);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitCount32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
ctx.AddU32("{}=bitCount({});", inst, value);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitBitwiseNot32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
ctx.AddU32("{}=~{};", inst, value);
2021-05-21 08:00:12 +02:00
}
void EmitFindSMsb32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
ctx.AddU32("{}=findMSB(int({}));", inst, value);
2021-05-21 08:00:12 +02:00
}
void EmitFindUMsb32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
ctx.AddU32("{}=findMSB(uint({}));", inst, value);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitSMin32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
2021-05-30 02:00:06 +02:00
ctx.AddU32("{}=min(int({}),int({}));", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitUMin32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
2021-05-30 02:00:06 +02:00
ctx.AddU32("{}=min(uint({}),uint({}));", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitSMax32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
2021-05-30 02:00:06 +02:00
ctx.AddU32("{}=max(int({}),int({}));", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitUMax32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
2021-05-30 02:00:06 +02:00
ctx.AddU32("{}=max(uint({}),uint({}));", inst, a, b);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitSClamp32(EmitContext& ctx, IR::Inst& inst, std::string_view value, std::string_view min,
std::string_view max) {
const auto result{ctx.var_alloc.Define(inst, GlslVarType::U32)};
2021-05-30 02:00:06 +02:00
ctx.Add("{}=clamp(int({}),int({}),int({}));", result, value, min, max);
SetZeroFlag(ctx, inst, result);
SetSignFlag(ctx, inst, result);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitUClamp32(EmitContext& ctx, IR::Inst& inst, std::string_view value, std::string_view min,
std::string_view max) {
const auto result{ctx.var_alloc.Define(inst, GlslVarType::U32)};
2021-05-30 02:00:06 +02:00
ctx.Add("{}=clamp(uint({}),uint({}),uint({}));", result, value, min, max);
SetZeroFlag(ctx, inst, result);
SetSignFlag(ctx, inst, result);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitSLessThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
ctx.AddU1("{}=int({})<int({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitULessThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
2021-05-28 21:51:50 +02:00
ctx.AddU1("{}=uint({})<uint({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitIEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
ctx.AddU1("{}={}=={};", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitSLessThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
std::string_view rhs) {
ctx.AddU1("{}=int({})<=int({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitULessThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
std::string_view rhs) {
ctx.AddU1("{}=uint({})<=uint({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitSGreaterThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
std::string_view rhs) {
ctx.AddU1("{}=int({})>int({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitUGreaterThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
std::string_view rhs) {
ctx.AddU1("{}=uint({})>uint({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitINotEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
ctx.AddU1("{}={}!={};", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitSGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
std::string_view rhs) {
ctx.AddU1("{}=int({})>=int({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
2021-05-22 03:37:13 +02:00
void EmitUGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
std::string_view rhs) {
ctx.AddU1("{}=uint({})>=uint({});", inst, lhs, rhs);
2021-05-21 08:00:12 +02:00
}
} // namespace Shader::Backend::GLSL