mirror/pineapple
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

early-access version 2532

Browse source
This commit is contained in:
pineappleEA 2022-03-08 07:02:31 +01:00
parent 9e7f43eb4a
commit f236550083
4 changed files with 192 additions and 217 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 2531. This is the source code for early-access 2532.
## Legal Notice ## Legal Notice

17
src/core/hle/kernel/k_page_table.cpp
View file

@ -297,16 +297,15 @@ ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::
KMemoryState src_state{}; KMemoryState src_state{};
KMemoryPermission src_perm{}; KMemoryPermission src_perm{};
std::size_t num_src_allocator_blocks{}; std::size_t num_src_allocator_blocks{};
R_TRY(this->CheckMemoryState(std::addressof(src_state), std::addressof(src_perm), nullptr, R_TRY(this->CheckMemoryState(&src_state, &src_perm, nullptr, &num_src_allocator_blocks,
std::addressof(num_src_allocator_blocks), src_address, size, src_address, size, KMemoryState::All, KMemoryState::Normal,
KMemoryState::All, KMemoryState::Normal, KMemoryPermission::All, KMemoryPermission::All, KMemoryPermission::UserReadWrite,
KMemoryPermission::UserReadWrite, KMemoryAttribute::All, KMemoryAttribute::All, KMemoryAttribute::None));
KMemoryAttribute::None));
// Verify that the destination memory is unmapped. // Verify that the destination memory is unmapped.
std::size_t num_dst_allocator_blocks{}; std::size_t num_dst_allocator_blocks{};
R_TRY(this->CheckMemoryState(std::addressof(num_dst_allocator_blocks), dst_address, size, R_TRY(this->CheckMemoryState(&num_dst_allocator_blocks, dst_address, size, KMemoryState::All,
KMemoryState::All, KMemoryState::Free, KMemoryPermission::None, KMemoryState::Free, KMemoryPermission::None,
KMemoryPermission::None, KMemoryAttribute::None, KMemoryPermission::None, KMemoryAttribute::None,
KMemoryAttribute::None)); KMemoryAttribute::None));
@ -320,8 +319,8 @@ ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::
AddRegionToPages(src_address, num_pages, pg); AddRegionToPages(src_address, num_pages, pg);
// Reprotect the source as kernel-read/not mapped. // Reprotect the source as kernel-read/not mapped.
const KMemoryPermission new_perm = static_cast<KMemoryPermission>( const auto new_perm = static_cast<KMemoryPermission>(KMemoryPermission::KernelRead |
KMemoryPermission::KernelRead | KMemoryPermission::NotMapped); KMemoryPermission::NotMapped);
R_TRY(Operate(src_address, num_pages, new_perm, OperationType::ChangePermissions)); R_TRY(Operate(src_address, num_pages, new_perm, OperationType::ChangePermissions));
// Ensure that we unprotect the source pages on failure. // Ensure that we unprotect the source pages on failure.

336
src/shader_recompiler/frontend/maxwell/translate/impl/logic_operation_three_input.cpp
View file

@ -20,31 +20,31 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
case 1: case 1:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseOr(b, c))); return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseOr(b, c)));
case 2: case 2:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseOr(b, ir.BitwiseNot(c)))); return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseOr(a, b)));
case 3: case 3:
return ir.BitwiseNot(ir.BitwiseOr(a, b)); return ir.BitwiseNot(ir.BitwiseOr(a, b));
case 4: case 4:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c))))); return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseOr(a, c)));
case 5: case 5:
return ir.BitwiseNot(ir.BitwiseOr(a, c)); return ir.BitwiseNot(ir.BitwiseOr(a, c));
case 6: case 6:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseXor(b, c)))); return ir.BitwiseAnd(ir.BitwiseNot(a), ir.BitwiseXor(b, c));
case 7: case 7:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseAnd(b, c))); return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseAnd(b, c)));
case 8: case 8:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseAnd(b, c)))); return ir.BitwiseAnd(ir.BitwiseAnd(b, c), ir.BitwiseNot(a));
case 9: case 9:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseXor(b, c))); return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseXor(b, c)));
case 10: case 10:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c))); return ir.BitwiseAnd(c, ir.BitwiseNot(a));
case 11: case 11:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)))); return ir.BitwiseAnd(ir.BitwiseNot(a), ir.BitwiseOr(c, ir.BitwiseNot(b)));
case 12: case 12:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b))); return ir.BitwiseAnd(b, ir.BitwiseNot(a));
case 13: case 13:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c))))); return ir.BitwiseAnd(ir.BitwiseNot(a), ir.BitwiseOr(b, ir.BitwiseNot(c)));
case 14: case 14:
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, c)))); return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
case 15: case 15:
return ir.BitwiseNot(a); return ir.BitwiseNot(a);
case 16: case 16:
@ -52,146 +52,144 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
case 17: case 17:
return ir.BitwiseNot(ir.BitwiseOr(b, c)); return ir.BitwiseNot(ir.BitwiseOr(b, c));
case 18: case 18:
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseXor(a, c)))); return ir.BitwiseAnd(ir.BitwiseNot(b), ir.BitwiseXor(a, c));
case 19: case 19:
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseAnd(a, c))); return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseAnd(a, c)));
case 20: case 20:
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseXor(a, b)))); return ir.BitwiseAnd(ir.BitwiseNot(c), ir.BitwiseXor(a, b));
case 21: case 21:
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseAnd(a, b))); return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseAnd(a, b)));
case 22: case 22:
return ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c))); return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseAnd(a, b)));
case 23: case 23:
return ir.BitwiseNot( return ir.BitwiseXor(ir.BitwiseNot(a),
ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)))); ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
case 24: case 24:
return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)); return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c));
case 25: case 25:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c))); return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c)));
case 26: case 26:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))); return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(c, ir.BitwiseNot(b)));
case 27: case 27:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseAnd(b, ir.BitwiseNot(c)))); return ir.BitwiseXor(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(c)));
case 28: case 28:
return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, c))); return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(b, ir.BitwiseNot(c)));
case 29: case 29:
return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, ir.BitwiseNot(c))); return ir.BitwiseXor(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
case 30: case 30:
return ir.BitwiseXor(a, ir.BitwiseOr(b, c)); return ir.BitwiseXor(a, ir.BitwiseOr(b, c));
case 31: case 31:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseOr(b, c))); return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseOr(b, c)));
case 32: case 32:
return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c)))); return ir.BitwiseAnd(ir.BitwiseAnd(a, c), ir.BitwiseNot(b));
case 33: case 33:
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseXor(a, c))); return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseXor(a, c)));
case 34: case 34:
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c))); return ir.BitwiseAnd(c, ir.BitwiseNot(b));
case 35: case 35:
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseAnd(a, ir.BitwiseNot(c)))); return ir.BitwiseAnd(ir.BitwiseNot(b), ir.BitwiseOr(c, ir.BitwiseNot(a)));
case 36: case 36:
return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))); return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(b, c));
case 37: case 37:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c))); return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c)));
case 38: case 38:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))); return ir.BitwiseAnd(ir.BitwiseXor(b, c), ir.BitwiseOr(c, ir.BitwiseNot(a)));
case 39: case 39:
return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c))); return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c)));
case 40: case 40:
return ir.BitwiseAnd(c, ir.BitwiseXor(a, b)); return ir.BitwiseAnd(c, ir.BitwiseXor(a, b));
case 41: case 41:
return ir.BitwiseXor(a, return ir.BitwiseXor(ir.BitwiseOr(a, b),
ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))); ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(c)));
case 42: case 42:
return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, b))); return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, b)));
case 43: case 43:
return ir.BitwiseNot(ir.BitwiseXor( return ir.BitwiseOr(ir.BitwiseAnd(c, ir.BitwiseXor(a, b)),
a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))))); ir.BitwiseNot(ir.BitwiseOr(a, b)));
case 44: case 44:
return ir.BitwiseAnd(ir.BitwiseXor(a, b), return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, b));
ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c))));
case 45: case 45:
return ir.BitwiseXor(a, ir.BitwiseOr(b, ir.BitwiseNot(c))); return ir.BitwiseXor(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
case 46: case 46:
return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, c)); return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, c));
case 47: case 47:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseOr(b, ir.BitwiseNot(c)))); return ir.BitwiseOr(ir.BitwiseNot(a), ir.BitwiseAnd(c, ir.BitwiseNot(b)));
case 48: case 48:
return ir.BitwiseAnd(a, ir.BitwiseNot(b)); return ir.BitwiseAnd(a, ir.BitwiseNot(b));
case 49: case 49:
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c))))); return ir.BitwiseAnd(ir.BitwiseNot(b), ir.BitwiseOr(a, ir.BitwiseNot(c)));
case 50: case 50:
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, c)))); return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
case 51: case 51:
return ir.BitwiseNot(b); return ir.BitwiseNot(b);
case 52: case 52:
return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c))); return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c)));
case 53: case 53:
return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c))); return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
case 54: case 54:
return ir.BitwiseXor(b, ir.BitwiseOr(a, c)); return ir.BitwiseXor(b, ir.BitwiseOr(a, c));
case 55: case 55:
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseOr(a, c))); return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseOr(a, c)));
case 56: case 56:
return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, c)); return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, b));
case 57: case 57:
return ir.BitwiseXor(b, ir.BitwiseOr(a, ir.BitwiseNot(c))); return ir.BitwiseXor(b, ir.BitwiseOr(a, ir.BitwiseNot(c)));
case 58: case 58:
return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, c)); return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, c));
case 59: case 59:
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseOr(a, ir.BitwiseNot(c)))); return ir.BitwiseOr(ir.BitwiseNot(b), ir.BitwiseAnd(c, ir.BitwiseNot(a)));
case 60: case 60:
return ir.BitwiseXor(a, b); return ir.BitwiseXor(a, b);
case 61: case 61:
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c))); return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c)));
case 62: case 62:
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)))); return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(c, ir.BitwiseNot(a)));
case 63: case 63:
return ir.BitwiseNot(ir.BitwiseAnd(a, b)); return ir.BitwiseNot(ir.BitwiseAnd(a, b));
case 64: case 64:
return ir.BitwiseAnd(a, ir.BitwiseAnd(b, ir.BitwiseNot(c))); return ir.BitwiseAnd(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
case 65: case 65:
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseXor(a, b))); return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseXor(a, b)));
case 66: case 66:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))); return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseXor(b, c));
case 67: case 67:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, c))); return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(a, b)));
case 68: case 68:
return ir.BitwiseAnd(b, ir.BitwiseNot(c)); return ir.BitwiseAnd(b, ir.BitwiseNot(c));
case 69: case 69:
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)))); return ir.BitwiseAnd(ir.BitwiseNot(c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
case 70: case 70:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c)))); return ir.BitwiseAnd(ir.BitwiseXor(b, c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
case 71: case 71:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, ir.BitwiseNot(c)))); return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(b)));
case 72: case 72:
return ir.BitwiseAnd(b, ir.BitwiseXor(a, c)); return ir.BitwiseAnd(b, ir.BitwiseXor(a, c));
case 73: case 73:
return ir.BitwiseXor(a, return ir.BitwiseXor(ir.BitwiseOr(a, c),
ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c)))); ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(b)));
case 74: case 74:
return ir.BitwiseAnd(ir.BitwiseXor(a, c), return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, c));
ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b))));
case 75: case 75:
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)))); return ir.BitwiseXor(a, ir.BitwiseOr(c, ir.BitwiseNot(b)));
case 76: case 76:
return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, c))); return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, c)));
case 77: case 77:
return ir.BitwiseXor(a, return ir.BitwiseOr(ir.BitwiseAnd(b, ir.BitwiseXor(a, c)),
ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))); ir.BitwiseNot(ir.BitwiseOr(a, c)));
case 78: case 78:
return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(b, c)); return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(b, c));
case 79: case 79:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c))))); return ir.BitwiseOr(ir.BitwiseNot(a), ir.BitwiseAnd(b, ir.BitwiseNot(c)));
case 80: case 80:
return ir.BitwiseAnd(a, ir.BitwiseNot(c)); return ir.BitwiseAnd(a, ir.BitwiseNot(c));
case 81: case 81:
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b))))); return ir.BitwiseAnd(ir.BitwiseNot(c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
case 82: case 82:
return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(a, ir.BitwiseNot(b))); return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
case 83: case 83:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c)))); return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(a)));
case 84: case 84:
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, b)))); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
case 85: case 85:
return ir.BitwiseNot(c); return ir.BitwiseNot(c);
case 86: case 86:
@ -205,82 +203,80 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
case 90: case 90:
return ir.BitwiseXor(a, c); return ir.BitwiseXor(a, c);
case 91: case 91:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))); return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
case 92: case 92:
return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, c)); return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(a, b));
case 93: case 93:
return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseOr(a, ir.BitwiseNot(b)))); return ir.BitwiseOr(ir.BitwiseNot(c), ir.BitwiseAnd(b, ir.BitwiseNot(a)));
case 94: case 94:
return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)))); return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(b, ir.BitwiseNot(a)));
case 95: case 95:
return ir.BitwiseNot(ir.BitwiseAnd(a, c)); return ir.BitwiseNot(ir.BitwiseAnd(a, c));
case 96: case 96:
return ir.BitwiseAnd(a, ir.BitwiseXor(b, c)); return ir.BitwiseAnd(a, ir.BitwiseXor(b, c));
case 97: case 97:
return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), return ir.BitwiseXor(ir.BitwiseOr(b, c),
ir.BitwiseNot(ir.BitwiseXor(b, c)))); ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(a)));
case 98: case 98:
return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c)); return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c));
case 99: case 99:
return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseAnd(a, ir.BitwiseNot(c)))); return ir.BitwiseXor(b, ir.BitwiseOr(c, ir.BitwiseNot(a)));
case 100: case 100:
return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c)); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c));
case 101: case 101:
return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)))); return ir.BitwiseXor(c, ir.BitwiseOr(b, ir.BitwiseNot(a)));
case 102: case 102:
return ir.BitwiseXor(b, c); return ir.BitwiseXor(b, c);
case 103: case 103:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))); return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
case 104: case 104:
return ir.BitwiseXor(a, return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))));
case 105: case 105:
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseXor(b, c))); return ir.BitwiseXor(ir.BitwiseNot(a), ir.BitwiseXor(b, c));
case 106: case 106:
return ir.BitwiseXor(c, ir.BitwiseAnd(a, b)); return ir.BitwiseXor(c, ir.BitwiseAnd(a, b));
case 107: case 107:
return ir.BitwiseNot( return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, b)),
ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c)))); ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
case 108: case 108:
return ir.BitwiseXor(b, ir.BitwiseAnd(a, c)); return ir.BitwiseXor(b, ir.BitwiseAnd(a, c));
case 109: case 109:
return ir.BitwiseNot( return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, c)),
ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c)))); ir.BitwiseXor(b, ir.BitwiseAnd(a, c)));
case 110: case 110:
return ir.BitwiseNot( return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseAnd(b, ir.BitwiseNot(a)));
ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseNot(ir.BitwiseXor(b, c))));
case 111: case 111:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseXor(b, c)))); return ir.BitwiseOr(ir.BitwiseNot(a), ir.BitwiseXor(b, c));
case 112: case 112:
return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, c))); return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, c)));
case 113: case 113:
return ir.BitwiseNot( return ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseXor(b, c)),
ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)))); ir.BitwiseNot(ir.BitwiseOr(b, c)));
case 114: case 114:
return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseAnd(b, c)); return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseOr(a, c));
case 115: case 115:
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c))))); return ir.BitwiseOr(ir.BitwiseNot(b), ir.BitwiseAnd(a, ir.BitwiseNot(c)));
case 116: case 116:
return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, c)); return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseOr(a, b));
case 117: case 117:
return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b))))); return ir.BitwiseOr(ir.BitwiseNot(c), ir.BitwiseAnd(a, ir.BitwiseNot(b)));
case 118: case 118:
return ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c)); return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseAnd(a, ir.BitwiseNot(b)));
case 119: case 119:
return ir.BitwiseNot(ir.BitwiseAnd(b, c)); return ir.BitwiseNot(ir.BitwiseAnd(b, c));
case 120: case 120:
return ir.BitwiseXor(a, ir.BitwiseAnd(b, c)); return ir.BitwiseXor(a, ir.BitwiseAnd(b, c));
case 121: case 121:
return ir.BitwiseNot(ir.BitwiseXor( return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(b, c)),
a, ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c)))); ir.BitwiseXor(a, ir.BitwiseAnd(b, c)));
case 122: case 122:
return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(a, ir.BitwiseNot(b))); return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(a, ir.BitwiseNot(b)));
case 123: case 123:
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseXor(a, c)))); return ir.BitwiseOr(ir.BitwiseNot(b), ir.BitwiseXor(a, c));
case 124: case 124:
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c))); return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c)));
case 125: case 125:
return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseXor(a, b)))); return ir.BitwiseOr(ir.BitwiseNot(c), ir.BitwiseXor(a, b));
case 126: case 126:
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)); return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c));
case 127: case 127:
@ -290,55 +286,54 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
case 129: case 129:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))); return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
case 130: case 130:
return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseXor(a, b))); return ir.BitwiseAnd(c, ir.BitwiseXor(a, ir.BitwiseNot(b)));
case 131: case 131:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c)))); return ir.BitwiseAnd(ir.BitwiseOr(c, ir.BitwiseNot(a)), ir.BitwiseXor(a, ir.BitwiseNot(b)));
case 132: case 132:
return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseXor(a, c))); return ir.BitwiseAnd(b, ir.BitwiseXor(a, ir.BitwiseNot(c)));
case 133: case 133:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(a, ir.BitwiseNot(b)))); return ir.BitwiseAnd(ir.BitwiseOr(b, ir.BitwiseNot(a)), ir.BitwiseXor(a, ir.BitwiseNot(c)));
case 134: case 134:
return ir.BitwiseXor(a, return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c)));
case 135: case 135:
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(b, c))); return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseNot(a));
case 136: case 136:
return ir.BitwiseAnd(b, c); return ir.BitwiseAnd(b, c);
case 137: case 137:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c))); return ir.BitwiseAnd(ir.BitwiseOr(b, ir.BitwiseNot(a)), ir.BitwiseXor(b, ir.BitwiseNot(c)));
case 138: case 138:
return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b)))); return ir.BitwiseAnd(c, ir.BitwiseOr(b, ir.BitwiseNot(a)));
case 139: case 139:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, c))); return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
case 140: case 140:
return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c)))); return ir.BitwiseAnd(b, ir.BitwiseOr(c, ir.BitwiseNot(a)));
case 141: case 141:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseAnd(b, c))); return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(ir.BitwiseOr(a, c)));
case 142: case 142:
return ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))); return ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
case 143: case 143:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, c)))); return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(a));
case 144: case 144:
return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseXor(b, c))); return ir.BitwiseAnd(a, ir.BitwiseXor(b, ir.BitwiseNot(c)));
case 145: case 145:
return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseNot(ir.BitwiseXor(b, c))); return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, ir.BitwiseNot(c)));
case 146: case 146:
return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c))); return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
case 147: case 147:
return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseAnd(a, c))); return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseNot(b));
case 148: case 148:
return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c))); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
case 149: case 149:
return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseAnd(a, b))); return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
case 150: case 150:
return ir.BitwiseXor(a, ir.BitwiseXor(b, c)); return ir.BitwiseXor(a, ir.BitwiseXor(b, c));
case 151: case 151:
return ir.BitwiseNot(ir.BitwiseXor( return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, b)),
a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))))); ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
case 152: case 152:
return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, ir.BitwiseNot(c)));
case 153: case 153:
return ir.BitwiseNot(ir.BitwiseXor(b, c)); return ir.BitwiseXor(b, ir.BitwiseNot(c));
case 154: case 154:
return ir.BitwiseXor(c, ir.BitwiseAnd(a, ir.BitwiseNot(b))); return ir.BitwiseXor(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)));
case 155: case 155:
@ -348,139 +343,129 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
case 157: case 157:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c))); return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c)));
case 158: case 158:
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseXor(a, ir.BitwiseOr(b, c)));
ir.BitwiseNot(ir.BitwiseXor(b, c)))));
case 159: case 159:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseXor(b, c))); return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseXor(b, c)));
case 160: case 160:
return ir.BitwiseAnd(a, c); return ir.BitwiseAnd(a, c);
case 161: case 161:
return ir.BitwiseNot( return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseXor(a, ir.BitwiseNot(c)));
ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)))));
case 162: case 162:
return ir.BitwiseAnd(c, ir.BitwiseOr(a, ir.BitwiseNot(b))); return ir.BitwiseAnd(c, ir.BitwiseOr(a, ir.BitwiseNot(b)));
case 163: case 163:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, c))); return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
case 164: case 164:
return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, ir.BitwiseNot(c)));
case 165: case 165:
return ir.BitwiseNot(ir.BitwiseXor(a, c)); return ir.BitwiseXor(a, ir.BitwiseNot(c));
case 166: case 166:
return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseOr(a, ir.BitwiseNot(b)))); return ir.BitwiseXor(c, ir.BitwiseAnd(b, ir.BitwiseNot(a)));
case 167: case 167:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, c))); return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, c)));
case 168: case 168:
return ir.BitwiseAnd(c, ir.BitwiseOr(a, b)); return ir.BitwiseAnd(c, ir.BitwiseOr(a, b));
case 169: case 169:
return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseOr(a, b))); return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
case 170: case 170:
return c; return c;
case 171: case 171:
return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, b))); return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, b)));
case 172: case 172:
return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c))); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(a)));
case 173: case 173:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(a, ir.BitwiseNot(b)))); return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseXor(a, ir.BitwiseNot(c)));
case 174: case 174:
return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)))); return ir.BitwiseOr(c, ir.BitwiseAnd(b, ir.BitwiseNot(a)));
case 175: case 175:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c))); return ir.BitwiseOr(c, ir.BitwiseNot(a));
case 176: case 176:
return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c)))); return ir.BitwiseAnd(a, ir.BitwiseOr(c, ir.BitwiseNot(b)));
case 177: case 177:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(b, c))); return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseOr(b, c)));
case 178: case 178:
return ir.BitwiseNot(ir.BitwiseXor( return ir.BitwiseXor(b, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))));
case 179: case 179:
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, c)))); return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(b));
case 180: case 180:
return ir.BitwiseXor(a, ir.BitwiseAnd(b, ir.BitwiseNot(c))); return ir.BitwiseXor(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)));
case 181: case 181:
return ir.BitwiseNot( return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, c)));
ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b)))));
case 182: case 182:
return ir.BitwiseNot(ir.BitwiseXor( return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(b, ir.BitwiseOr(a, c)));
a, ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
case 183: case 183:
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseXor(a, c))); return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseXor(a, c)));
case 184: case 184:
return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, ir.BitwiseNot(c))); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(b)));
case 185: case 185:
return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c))); return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(b, ir.BitwiseNot(c)));
case 186: case 186:
return ir.BitwiseOr(c, ir.BitwiseAnd(a, ir.BitwiseNot(b))); return ir.BitwiseOr(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)));
case 187: case 187:
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c))); return ir.BitwiseOr(c, ir.BitwiseNot(b));
case 188: case 188:
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, c)); return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(a, b));
case 189: case 189:
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))); return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, ir.BitwiseNot(c)));
case 190: case 190:
return ir.BitwiseOr(c, ir.BitwiseXor(a, b)); return ir.BitwiseOr(c, ir.BitwiseXor(a, b));
case 191: case 191:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)))); return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseAnd(a, b)));
case 192: case 192:
return ir.BitwiseAnd(a, b); return ir.BitwiseAnd(a, b);
case 193: case 193:
return ir.BitwiseNot( return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(c)), ir.BitwiseXor(a, ir.BitwiseNot(b)));
ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)))));
case 194: case 194:
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c)))); return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
case 195: case 195:
return ir.BitwiseNot(ir.BitwiseXor(a, b)); return ir.BitwiseXor(a, ir.BitwiseNot(b));
case 196: case 196:
return ir.BitwiseAnd(b, ir.BitwiseOr(a, ir.BitwiseNot(c))); return ir.BitwiseAnd(b, ir.BitwiseOr(a, ir.BitwiseNot(c)));
case 197: case 197:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, c))); return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c)));
case 198: case 198:
return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseOr(a, ir.BitwiseNot(c)))); return ir.BitwiseXor(b, ir.BitwiseAnd(c, ir.BitwiseNot(a)));
case 199: case 199:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, c))); return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, b)));
case 200: case 200:
return ir.BitwiseAnd(b, ir.BitwiseOr(a, c)); return ir.BitwiseAnd(b, ir.BitwiseOr(a, c));
case 201: case 201:
return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseOr(a, c))); return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
case 202: case 202:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c)))); return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
case 203: case 203:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c)))); return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
case 204: case 204:
return b; return b;
case 205: case 205:
return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, c))); return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, c)));
case 206: case 206:
return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)))); return ir.BitwiseOr(b, ir.BitwiseAnd(c, ir.BitwiseNot(a)));
case 207: case 207:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b))); return ir.BitwiseOr(b, ir.BitwiseNot(a));
case 208: case 208:
return ir.BitwiseAnd(a, ir.BitwiseOr(b, ir.BitwiseNot(c))); return ir.BitwiseAnd(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
case 209: case 209:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, c))); return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseOr(b, c)));
case 210: case 210:
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseOr(b, ir.BitwiseNot(c)))); return ir.BitwiseXor(a, ir.BitwiseAnd(c, ir.BitwiseNot(b)));
case 211: case 211:
return ir.BitwiseNot( return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, b)));
ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c)))));
case 212: case 212:
return ir.BitwiseXor( return ir.BitwiseXor(c, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
case 213: case 213:
return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, b)))); return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
case 214: case 214:
return ir.BitwiseNot(ir.BitwiseXor( return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(c, ir.BitwiseOr(a, b)));
a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
case 215: case 215:
return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseXor(a, b))); return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseXor(a, b)));
case 216: case 216:
return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c))); return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c)));
case 217: case 217:
return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))); return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, ir.BitwiseNot(c)));
case 218: case 218:
return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c)); return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c));
case 219: case 219:
return ir.BitwiseNot( return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
case 220: case 220:
return ir.BitwiseOr(b, ir.BitwiseAnd(a, ir.BitwiseNot(c))); return ir.BitwiseOr(b, ir.BitwiseAnd(a, ir.BitwiseNot(c)));
case 221: case 221:
@ -488,47 +473,46 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
case 222: case 222:
return ir.BitwiseOr(b, ir.BitwiseXor(a, c)); return ir.BitwiseOr(b, ir.BitwiseXor(a, c));
case 223: case 223:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c))))); return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseAnd(a, c)));
case 224: case 224:
return ir.BitwiseAnd(a, ir.BitwiseOr(b, c)); return ir.BitwiseAnd(a, ir.BitwiseOr(b, c));
case 225: case 225:
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseOr(b, c))); return ir.BitwiseXor(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
case 226: case 226:
return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, ir.BitwiseNot(c)))); return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
case 227: case 227:
return ir.BitwiseNot( return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, c))));
case 228: case 228:
return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseAnd(b, ir.BitwiseNot(c))); return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(c)));
case 229: case 229:
return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))); return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, ir.BitwiseNot(c)));
case 230: case 230:
return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c)); return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c));
case 231: case 231:
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))); return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
case 232: case 232:
return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))); return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseAnd(a, b)));
case 233: case 233:
return ir.BitwiseNot( return ir.BitwiseOr(ir.BitwiseAnd(a, b),
ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c)))); ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseNot(c)));
case 234: case 234:
return ir.BitwiseOr(c, ir.BitwiseAnd(a, b)); return ir.BitwiseOr(c, ir.BitwiseAnd(a, b));
case 235: case 235:
return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseXor(a, b))); return ir.BitwiseOr(c, ir.BitwiseXor(a, ir.BitwiseNot(b)));
case 236: case 236:
return ir.BitwiseOr(b, ir.BitwiseAnd(a, c)); return ir.BitwiseOr(b, ir.BitwiseAnd(a, c));
case 237: case 237:
return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseXor(a, c))); return ir.BitwiseOr(b, ir.BitwiseXor(a, ir.BitwiseNot(c)));
case 238: case 238:
return ir.BitwiseOr(b, c); return ir.BitwiseOr(b, c);
case 239: case 239:
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseOr(b, c)))); return ir.BitwiseOr(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
case 240: case 240:
return a; return a;
case 241: case 241:
return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, c))); return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, c)));
case 242: case 242:
return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c)))); return ir.BitwiseOr(a, ir.BitwiseAnd(c, ir.BitwiseNot(b)));
case 243: case 243:
return ir.BitwiseOr(a, ir.BitwiseNot(b)); return ir.BitwiseOr(a, ir.BitwiseNot(b));
case 244: case 244:
@ -542,15 +526,15 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
case 248: case 248:
return ir.BitwiseOr(a, ir.BitwiseAnd(b, c)); return ir.BitwiseOr(a, ir.BitwiseAnd(b, c));
case 249: case 249:
return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseXor(b, c))); return ir.BitwiseOr(a, ir.BitwiseXor(b, ir.BitwiseNot(c)));
case 250: case 250:
return ir.BitwiseOr(a, c); return ir.BitwiseOr(a, c);
case 251: case 251:
return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c)))); return ir.BitwiseOr(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
case 252: case 252:
return ir.BitwiseOr(a, b); return ir.BitwiseOr(a, b);
case 253: case 253:
return ir.BitwiseOr(a, ir.BitwiseOr(b, ir.BitwiseNot(c))); return ir.BitwiseOr(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
case 254: case 254:
return ir.BitwiseOr(a, ir.BitwiseOr(b, c)); return ir.BitwiseOr(a, ir.BitwiseOr(b, c));
case 255: case 255:

54
src/shader_recompiler/frontend/maxwell/translate/impl/logic_operation_three_input_lut3.py
View file

@ -3,32 +3,25 @@
# terms of the Do What The Fuck You Want To Public License, Version 2, # terms of the Do What The Fuck You Want To Public License, Version 2,
# as published by Sam Hocevar. See http://www.wtfpl.net/ for more details. # as published by Sam Hocevar. See http://www.wtfpl.net/ for more details.
# Assume that the negation call is for free on the host GPU. from itertools import product
# In fact, there are often input or output negation flags for logic operations
support_neg = True
# The primitive instructions # The primitive instructions
OPS = { OPS = {
'ir.BitwiseAnd({lhs}, {rhs})' : lambda a,b: a&b, 'ir.BitwiseAnd({}, {})' : (2, 1, lambda a,b: a&b),
'ir.BitwiseOr({lhs}, {rhs})' : lambda a,b: a|b, 'ir.BitwiseOr({}, {})' : (2, 1, lambda a,b: a|b),
'ir.BitwiseXor({lhs}, {rhs})' : lambda a,b: a^b, 'ir.BitwiseXor({}, {})' : (2, 1, lambda a,b: a^b),
'ir.BitwiseNot({})' : (1, 0.1, lambda a: (~a) & 255), # Only tiny cost, as this can often inlined in other instructions
} }
if support_neg:
OPS.update({
'ir.BitwiseNot(ir.BitwiseAnd({lhs}, {rhs}))' : lambda a,b: 256 + ~(a&b),
'ir.BitwiseNot(ir.BitwiseOr({lhs}, {rhs}))' : lambda a,b: 256 + ~(a|b),
'ir.BitwiseNot(ir.BitwiseXor({lhs}, {rhs}))' : lambda a,b: 256 + ~(a^b),
})
# Our database of combination of instructions # Our database of combination of instructions
optimized_calls = {} optimized_calls = {}
def register(imm, instruction, count, latency): def register(imm, instruction, count, latency):
# Use the sum of instruction count and latency as metrik to evaluate which combination is best # Use the sum of instruction count and latency as costs to evaluate which combination is best
metrik = count + latency costs = count + latency + len(instruction) * 0.0001
# Update if new or better # Update if new or better
if imm not in optimized_calls or optimized_calls[imm][3] > metrik: if imm not in optimized_calls or optimized_calls[imm][3] > costs:
optimized_calls[imm] = (instruction, count, latency, metrik) optimized_calls[imm] = (instruction, count, latency, costs)
return True return True
return False return False
@ -46,12 +39,6 @@ inputs = {
tb : 'b', tb : 'b',
tc : 'c', tc : 'c',
} }
if support_neg:
inputs.update({
256 + ~ta : 'ir.BitwiseNot(a)',
256 + ~tb : 'ir.BitwiseNot(b)',
256 + ~tc : 'ir.BitwiseNot(c)',
})
for imm, instruction in inputs.items(): for imm, instruction in inputs.items():
register(imm, instruction, 0, 0) register(imm, instruction, 0, 0)
@ -60,14 +47,19 @@ for imm, instruction in inputs.items():
while True: while True:
registered = 0 registered = 0
calls_copy = optimized_calls.copy() calls_copy = optimized_calls.copy()
for imm_a, (value_a, count_a, latency_a, metrik_a) in calls_copy.items(): for OP, (argc, cost, f) in OPS.items():
for imm_b, (value_b, count_b, latency_b, metrik_b) in calls_copy.items(): for args in product(calls_copy.items(), repeat=argc):
for OP, f in OPS.items(): # unpack(transponse) the arrays
registered += register( imm = [arg[0] for arg in args]
f(imm_a, imm_b), # Updated code value = [arg[1][0] for arg in args]
OP.format(lhs=value_a, rhs=value_b), # New instruction string count = [arg[1][1] for arg in args]
count_a+count_b+1, # Sum of instructions + 1 latency = [arg[1][2] for arg in args]
max(latency_a, latency_b) + 1) # max latency + 1
registered += register(
f(*imm),
OP.format(*value),
sum(count) + cost,
max(latency) + cost)
if registered == 0: if registered == 0:
# No update at all? So terminate # No update at all? So terminate
break break
@ -76,4 +68,4 @@ while True:
s = """ case {imm}: s = """ case {imm}:
return {op};""" return {op};"""
for imm in range(256): for imm in range(256):
print(s.format(imm=imm, op=optimized_calls[imm][0])) print(s.format(imm=imm, op=optimized_calls[imm][0]))