99ceb03a1c
This formats all copyright comments according to SPDX formatting guidelines. Additionally, this resolves the remaining GPLv2 only licensed files by relicensing them to GPLv2.0-or-later.
259 lines
10 KiB
C++
259 lines
10 KiB
C++
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
|
|
#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
|
|
#include "shader_recompiler/frontend/ir/value.h"
|
|
|
|
namespace Shader::Backend::GLSL {
|
|
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();
|
|
}
|
|
|
|
void BitwiseLogicalOp(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b,
|
|
char lop) {
|
|
const auto result{ctx.var_alloc.Define(inst, GlslVarType::U32)};
|
|
ctx.Add("{}={}{}{};", result, a, lop, b);
|
|
SetZeroFlag(ctx, inst, result);
|
|
SetSignFlag(ctx, inst, result);
|
|
}
|
|
} // Anonymous namespace
|
|
|
|
void EmitIAdd32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
// Compute the overflow CC first as it requires the original operand values,
|
|
// which may be overwritten by the result of the addition
|
|
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())};
|
|
const auto sub_a{fmt::format("{}u-{}", s32_max, a)};
|
|
const auto positive_result{fmt::format("int({})>int({})", b, sub_a)};
|
|
const auto negative_result{fmt::format("int({})<int({})", b, sub_a)};
|
|
ctx.AddU1("{}=int({})>=0?{}:{};", *overflow, a, positive_result, negative_result);
|
|
overflow->Invalidate();
|
|
}
|
|
const auto result{ctx.var_alloc.Define(inst, GlslVarType::U32)};
|
|
if (IR::Inst* const carry{inst.GetAssociatedPseudoOperation(IR::Opcode::GetCarryFromOp)}) {
|
|
ctx.uses_cc_carry = true;
|
|
ctx.Add("{}=uaddCarry({},{},carry);", result, a, b);
|
|
ctx.AddU1("{}=carry!=0;", *carry);
|
|
carry->Invalidate();
|
|
} else {
|
|
ctx.Add("{}={}+{};", result, a, b);
|
|
}
|
|
SetZeroFlag(ctx, inst, result);
|
|
SetSignFlag(ctx, inst, result);
|
|
}
|
|
|
|
void EmitIAdd64(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU64("{}={}+{};", inst, a, b);
|
|
}
|
|
|
|
void EmitISub32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}={}-{};", inst, a, b);
|
|
}
|
|
|
|
void EmitISub64(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU64("{}={}-{};", inst, a, b);
|
|
}
|
|
|
|
void EmitIMul32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}=uint({}*{});", inst, a, b);
|
|
}
|
|
|
|
void EmitSDiv32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}=uint(int({})/int({}));", inst, a, b);
|
|
}
|
|
|
|
void EmitUDiv32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}={}/{};", inst, a, b);
|
|
}
|
|
|
|
void EmitINeg32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU32("{}=uint(int(0)-int({}));", inst, value);
|
|
}
|
|
|
|
void EmitINeg64(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU64("{}=uint64_t(int64_t(0)-int64_t({}));", inst, value);
|
|
}
|
|
|
|
void EmitIAbs32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU32("{}=abs(int({}));", inst, value);
|
|
}
|
|
|
|
void EmitShiftLeftLogical32(EmitContext& ctx, IR::Inst& inst, std::string_view base,
|
|
std::string_view shift) {
|
|
ctx.AddU32("{}={}<<{};", inst, base, shift);
|
|
}
|
|
|
|
void EmitShiftLeftLogical64(EmitContext& ctx, IR::Inst& inst, std::string_view base,
|
|
std::string_view shift) {
|
|
ctx.AddU64("{}={}<<{};", inst, base, shift);
|
|
}
|
|
|
|
void EmitShiftRightLogical32(EmitContext& ctx, IR::Inst& inst, std::string_view base,
|
|
std::string_view shift) {
|
|
ctx.AddU32("{}={}>>{};", inst, base, shift);
|
|
}
|
|
|
|
void EmitShiftRightLogical64(EmitContext& ctx, IR::Inst& inst, std::string_view base,
|
|
std::string_view shift) {
|
|
ctx.AddU64("{}={}>>{};", inst, base, shift);
|
|
}
|
|
|
|
void EmitShiftRightArithmetic32(EmitContext& ctx, IR::Inst& inst, std::string_view base,
|
|
std::string_view shift) {
|
|
ctx.AddU32("{}=int({})>>{};", inst, base, shift);
|
|
}
|
|
|
|
void EmitShiftRightArithmetic64(EmitContext& ctx, IR::Inst& inst, std::string_view base,
|
|
std::string_view shift) {
|
|
ctx.AddU64("{}=int64_t({})>>{};", inst, base, shift);
|
|
}
|
|
|
|
void EmitBitwiseAnd32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
BitwiseLogicalOp(ctx, inst, a, b, '&');
|
|
}
|
|
|
|
void EmitBitwiseOr32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
BitwiseLogicalOp(ctx, inst, a, b, '|');
|
|
}
|
|
|
|
void EmitBitwiseXor32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
BitwiseLogicalOp(ctx, inst, a, b, '^');
|
|
}
|
|
|
|
void EmitBitFieldInsert(EmitContext& ctx, IR::Inst& inst, std::string_view base,
|
|
std::string_view insert, std::string_view offset, std::string_view count) {
|
|
ctx.AddU32("{}=bitfieldInsert({},{},int({}),int({}));", inst, base, insert, offset, count);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
SetZeroFlag(ctx, inst, result);
|
|
SetSignFlag(ctx, inst, result);
|
|
}
|
|
|
|
void EmitBitReverse32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU32("{}=bitfieldReverse({});", inst, value);
|
|
}
|
|
|
|
void EmitBitCount32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU32("{}=bitCount({});", inst, value);
|
|
}
|
|
|
|
void EmitBitwiseNot32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU32("{}=~{};", inst, value);
|
|
}
|
|
|
|
void EmitFindSMsb32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU32("{}=findMSB(int({}));", inst, value);
|
|
}
|
|
|
|
void EmitFindUMsb32(EmitContext& ctx, IR::Inst& inst, std::string_view value) {
|
|
ctx.AddU32("{}=findMSB(uint({}));", inst, value);
|
|
}
|
|
|
|
void EmitSMin32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}=min(int({}),int({}));", inst, a, b);
|
|
}
|
|
|
|
void EmitUMin32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}=min(uint({}),uint({}));", inst, a, b);
|
|
}
|
|
|
|
void EmitSMax32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}=max(int({}),int({}));", inst, a, b);
|
|
}
|
|
|
|
void EmitUMax32(EmitContext& ctx, IR::Inst& inst, std::string_view a, std::string_view b) {
|
|
ctx.AddU32("{}=max(uint({}),uint({}));", inst, a, b);
|
|
}
|
|
|
|
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)};
|
|
ctx.Add("{}=clamp(int({}),int({}),int({}));", result, value, min, max);
|
|
SetZeroFlag(ctx, inst, result);
|
|
SetSignFlag(ctx, inst, result);
|
|
}
|
|
|
|
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)};
|
|
ctx.Add("{}=clamp(uint({}),uint({}),uint({}));", result, value, min, max);
|
|
SetZeroFlag(ctx, inst, result);
|
|
SetSignFlag(ctx, inst, result);
|
|
}
|
|
|
|
void EmitSLessThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
|
|
ctx.AddU1("{}=int({})<int({});", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitULessThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
|
|
ctx.AddU1("{}=uint({})<uint({});", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitIEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
|
|
ctx.AddU1("{}={}=={};", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitSLessThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
|
|
std::string_view rhs) {
|
|
ctx.AddU1("{}=int({})<=int({});", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitULessThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
|
|
std::string_view rhs) {
|
|
ctx.AddU1("{}=uint({})<=uint({});", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitSGreaterThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
|
|
std::string_view rhs) {
|
|
ctx.AddU1("{}=int({})>int({});", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitUGreaterThan(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
|
|
std::string_view rhs) {
|
|
ctx.AddU1("{}=uint({})>uint({});", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitINotEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs, std::string_view rhs) {
|
|
ctx.AddU1("{}={}!={};", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitSGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
|
|
std::string_view rhs) {
|
|
ctx.AddU1("{}=int({})>=int({});", inst, lhs, rhs);
|
|
}
|
|
|
|
void EmitUGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, std::string_view lhs,
|
|
std::string_view rhs) {
|
|
ctx.AddU1("{}=uint({})>=uint({});", inst, lhs, rhs);
|
|
}
|
|
} // namespace Shader::Backend::GLSL
|