early-access version 2532
This commit is contained in:
pineappleEA
parent
9e7f43eb4a
commit
f236550083
4 changed files with 192 additions and 217 deletions
|
|
@ -1,7 +1,7 @@
|
|||
yuzu emulator early access
|
||||
=============
|
||||
|
||||
This is the source code for early-access 2531.
|
||||
This is the source code for early-access 2532.
|
||||
|
||||
## Legal Notice
|
||||
|
||||
|
|
|
|||
|
|
@ -297,16 +297,15 @@ ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::
|
|||
KMemoryState src_state{};
|
||||
KMemoryPermission src_perm{};
|
||||
std::size_t num_src_allocator_blocks{};
|
||||
R_TRY(this->CheckMemoryState(std::addressof(src_state), std::addressof(src_perm), nullptr,
|
||||
std::addressof(num_src_allocator_blocks), src_address, size,
|
||||
KMemoryState::All, KMemoryState::Normal, KMemoryPermission::All,
|
||||
KMemoryPermission::UserReadWrite, KMemoryAttribute::All,
|
||||
KMemoryAttribute::None));
|
||||
R_TRY(this->CheckMemoryState(&src_state, &src_perm, nullptr, &num_src_allocator_blocks,
|
||||
src_address, size, KMemoryState::All, KMemoryState::Normal,
|
||||
KMemoryPermission::All, KMemoryPermission::UserReadWrite,
|
||||
KMemoryAttribute::All, KMemoryAttribute::None));
|
||||
|
||||
// Verify that the destination memory is unmapped.
|
||||
std::size_t num_dst_allocator_blocks{};
|
||||
R_TRY(this->CheckMemoryState(std::addressof(num_dst_allocator_blocks), dst_address, size,
|
||||
KMemoryState::All, KMemoryState::Free, KMemoryPermission::None,
|
||||
R_TRY(this->CheckMemoryState(&num_dst_allocator_blocks, dst_address, size, KMemoryState::All,
|
||||
KMemoryState::Free, KMemoryPermission::None,
|
||||
KMemoryPermission::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);
|
||||
|
||||
// Reprotect the source as kernel-read/not mapped.
|
||||
const KMemoryPermission new_perm = static_cast<KMemoryPermission>(
|
||||
KMemoryPermission::KernelRead | KMemoryPermission::NotMapped);
|
||||
const auto new_perm = static_cast<KMemoryPermission>(KMemoryPermission::KernelRead |
|
||||
KMemoryPermission::NotMapped);
|
||||
R_TRY(Operate(src_address, num_pages, new_perm, OperationType::ChangePermissions));
|
||||
|
||||
// Ensure that we unprotect the source pages on failure.
|
||||
|
|
|
|||
|
|
@ -20,31 +20,31 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
|
|||
case 1:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseOr(b, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, b));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, c));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseAnd(b, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseXor(b, c)));
|
||||
case 10:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)));
|
||||
return ir.BitwiseAnd(c, ir.BitwiseNot(a));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)));
|
||||
return ir.BitwiseAnd(b, ir.BitwiseNot(a));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, c))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
|
||||
case 15:
|
||||
return ir.BitwiseNot(a);
|
||||
case 16:
|
||||
|
|
@ -52,146 +52,144 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
|
|||
case 17:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(b, c));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseAnd(a, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseAnd(a, b)));
|
||||
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:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))));
|
||||
return ir.BitwiseXor(ir.BitwiseNot(a),
|
||||
ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
|
||||
case 24:
|
||||
return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c));
|
||||
case 25:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c)));
|
||||
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:
|
||||
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:
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseXor(a, ir.BitwiseOr(b, c));
|
||||
case 31:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseOr(b, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseXor(a, c)));
|
||||
case 34:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c)));
|
||||
return ir.BitwiseAnd(c, ir.BitwiseNot(b));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c)));
|
||||
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:
|
||||
return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c)));
|
||||
case 40:
|
||||
return ir.BitwiseAnd(c, ir.BitwiseXor(a, b));
|
||||
case 41:
|
||||
return ir.BitwiseXor(a,
|
||||
ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseXor(ir.BitwiseOr(a, b),
|
||||
ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(c)));
|
||||
case 42:
|
||||
return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, b)));
|
||||
case 43:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(
|
||||
a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(c, ir.BitwiseXor(a, b)),
|
||||
ir.BitwiseNot(ir.BitwiseOr(a, b)));
|
||||
case 44:
|
||||
return ir.BitwiseAnd(ir.BitwiseXor(a, b),
|
||||
ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, b));
|
||||
case 45:
|
||||
return ir.BitwiseXor(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
|
||||
case 46:
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, c));
|
||||
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:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseNot(b));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, c))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
|
||||
case 51:
|
||||
return ir.BitwiseNot(b);
|
||||
case 52:
|
||||
return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c)));
|
||||
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:
|
||||
return ir.BitwiseXor(b, ir.BitwiseOr(a, c));
|
||||
case 55:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseOr(a, c)));
|
||||
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:
|
||||
return ir.BitwiseXor(b, ir.BitwiseOr(a, ir.BitwiseNot(c)));
|
||||
case 58:
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, c));
|
||||
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:
|
||||
return ir.BitwiseXor(a, b);
|
||||
case 61:
|
||||
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(a, b));
|
||||
case 64:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)));
|
||||
return ir.BitwiseAnd(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
|
||||
case 65:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseXor(a, b)));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseAnd(b, ir.BitwiseNot(c));
|
||||
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:
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseAnd(b, ir.BitwiseXor(a, c));
|
||||
case 73:
|
||||
return ir.BitwiseXor(a,
|
||||
ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseXor(ir.BitwiseOr(a, c),
|
||||
ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(b)));
|
||||
case 74:
|
||||
return ir.BitwiseAnd(ir.BitwiseXor(a, c),
|
||||
ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, c));
|
||||
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:
|
||||
return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, c)));
|
||||
case 77:
|
||||
return ir.BitwiseXor(a,
|
||||
ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(b, ir.BitwiseXor(a, c)),
|
||||
ir.BitwiseNot(ir.BitwiseOr(a, c)));
|
||||
case 78:
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(b, c));
|
||||
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:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseNot(c));
|
||||
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:
|
||||
return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, b))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
|
||||
case 85:
|
||||
return ir.BitwiseNot(c);
|
||||
case 86:
|
||||
|
|
@ -205,82 +203,80 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
|
|||
case 90:
|
||||
return ir.BitwiseXor(a, c);
|
||||
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:
|
||||
return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, c));
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(a, b));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(a, c));
|
||||
case 96:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseXor(b, c));
|
||||
case 97:
|
||||
return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)),
|
||||
ir.BitwiseNot(ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseXor(ir.BitwiseOr(b, c),
|
||||
ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(a)));
|
||||
case 98:
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c));
|
||||
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:
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c));
|
||||
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:
|
||||
return ir.BitwiseXor(b, c);
|
||||
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:
|
||||
return ir.BitwiseXor(a,
|
||||
ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
|
||||
case 105:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
|
||||
return ir.BitwiseXor(ir.BitwiseNot(a), ir.BitwiseXor(b, c));
|
||||
case 106:
|
||||
return ir.BitwiseXor(c, ir.BitwiseAnd(a, b));
|
||||
case 107:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, b)),
|
||||
ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
|
||||
case 108:
|
||||
return ir.BitwiseXor(b, ir.BitwiseAnd(a, c));
|
||||
case 109:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, c)),
|
||||
ir.BitwiseXor(b, ir.BitwiseAnd(a, c)));
|
||||
case 110:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseNot(ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseAnd(b, ir.BitwiseNot(a)));
|
||||
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:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, c)));
|
||||
case 113:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseXor(b, c)),
|
||||
ir.BitwiseNot(ir.BitwiseOr(b, c)));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, c));
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseOr(a, b));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(b, c));
|
||||
case 120:
|
||||
return ir.BitwiseXor(a, ir.BitwiseAnd(b, c));
|
||||
case 121:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(
|
||||
a, ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(b, c)),
|
||||
ir.BitwiseXor(a, ir.BitwiseAnd(b, c)));
|
||||
case 122:
|
||||
return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(a, ir.BitwiseNot(b)));
|
||||
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:
|
||||
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c)));
|
||||
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:
|
||||
return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c));
|
||||
case 127:
|
||||
|
|
@ -290,55 +286,54 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
|
|||
case 129:
|
||||
return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
|
||||
case 130:
|
||||
return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseXor(a, b)));
|
||||
return ir.BitwiseAnd(c, ir.BitwiseXor(a, ir.BitwiseNot(b)));
|
||||
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:
|
||||
return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseXor(a, c)));
|
||||
return ir.BitwiseAnd(b, ir.BitwiseXor(a, ir.BitwiseNot(c)));
|
||||
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:
|
||||
return ir.BitwiseXor(a,
|
||||
ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c)));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
|
||||
case 135:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(b, c)));
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseNot(a));
|
||||
case 136:
|
||||
return ir.BitwiseAnd(b, c);
|
||||
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:
|
||||
return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b))));
|
||||
return ir.BitwiseAnd(c, ir.BitwiseOr(b, ir.BitwiseNot(a)));
|
||||
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:
|
||||
return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c))));
|
||||
return ir.BitwiseAnd(b, ir.BitwiseOr(c, ir.BitwiseNot(a)));
|
||||
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:
|
||||
return ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
|
||||
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:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseXor(b, c)));
|
||||
return ir.BitwiseAnd(a, ir.BitwiseXor(b, ir.BitwiseNot(c)));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseAnd(a, c)));
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseNot(b));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
|
||||
return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
|
||||
case 150:
|
||||
return ir.BitwiseXor(a, ir.BitwiseXor(b, c));
|
||||
case 151:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(
|
||||
a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
|
||||
return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, b)),
|
||||
ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(b, c));
|
||||
return ir.BitwiseXor(b, ir.BitwiseNot(c));
|
||||
case 154:
|
||||
return ir.BitwiseXor(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)));
|
||||
case 155:
|
||||
|
|
@ -348,139 +343,129 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
|
|||
case 157:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c)));
|
||||
case 158:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)),
|
||||
ir.BitwiseNot(ir.BitwiseXor(b, c)))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseXor(a, ir.BitwiseOr(b, c)));
|
||||
case 159:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseXor(b, c)));
|
||||
case 160:
|
||||
return ir.BitwiseAnd(a, c);
|
||||
case 161:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseXor(a, ir.BitwiseNot(c)));
|
||||
case 162:
|
||||
return ir.BitwiseAnd(c, ir.BitwiseOr(a, ir.BitwiseNot(b)));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(a, c));
|
||||
return ir.BitwiseXor(a, ir.BitwiseNot(c));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, c)));
|
||||
case 168:
|
||||
return ir.BitwiseAnd(c, ir.BitwiseOr(a, b));
|
||||
case 169:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseOr(a, b)));
|
||||
return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
|
||||
case 170:
|
||||
return c;
|
||||
case 171:
|
||||
return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, b)));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b))));
|
||||
return ir.BitwiseOr(c, ir.BitwiseAnd(b, ir.BitwiseNot(a)));
|
||||
case 175:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c)));
|
||||
return ir.BitwiseOr(c, ir.BitwiseNot(a));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(
|
||||
a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))));
|
||||
return ir.BitwiseXor(b, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
|
||||
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:
|
||||
return ir.BitwiseXor(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)));
|
||||
case 181:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b)))));
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, c)));
|
||||
case 182:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(
|
||||
a, ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(b, ir.BitwiseOr(a, c)));
|
||||
case 183:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseXor(a, c)));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseOr(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)));
|
||||
case 187:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c)));
|
||||
return ir.BitwiseOr(c, ir.BitwiseNot(b));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseOr(c, ir.BitwiseXor(a, b));
|
||||
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:
|
||||
return ir.BitwiseAnd(a, b);
|
||||
case 193:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)))));
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(c)), ir.BitwiseXor(a, ir.BitwiseNot(b)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(a, b));
|
||||
return ir.BitwiseXor(a, ir.BitwiseNot(b));
|
||||
case 196:
|
||||
return ir.BitwiseAnd(b, ir.BitwiseOr(a, ir.BitwiseNot(c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseOr(a, ir.BitwiseNot(c))));
|
||||
return ir.BitwiseXor(b, ir.BitwiseAnd(c, ir.BitwiseNot(a)));
|
||||
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:
|
||||
return ir.BitwiseAnd(b, ir.BitwiseOr(a, c));
|
||||
case 201:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseOr(a, c)));
|
||||
return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
|
||||
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:
|
||||
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:
|
||||
return b;
|
||||
case 205:
|
||||
return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b)));
|
||||
return ir.BitwiseOr(b, ir.BitwiseNot(a));
|
||||
case 208:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseOr(b, ir.BitwiseNot(c))));
|
||||
return ir.BitwiseXor(a, ir.BitwiseAnd(c, ir.BitwiseNot(b)));
|
||||
case 211:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c)))));
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, b)));
|
||||
case 212:
|
||||
return ir.BitwiseXor(
|
||||
a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
|
||||
return ir.BitwiseXor(c, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
|
||||
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:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(
|
||||
a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(c, ir.BitwiseOr(a, b)));
|
||||
case 215:
|
||||
return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseXor(a, b)));
|
||||
case 216:
|
||||
return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c)));
|
||||
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:
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c));
|
||||
case 219:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
|
||||
case 220:
|
||||
return ir.BitwiseOr(b, ir.BitwiseAnd(a, ir.BitwiseNot(c)));
|
||||
case 221:
|
||||
|
|
@ -488,47 +473,46 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
|
|||
case 222:
|
||||
return ir.BitwiseOr(b, ir.BitwiseXor(a, c));
|
||||
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:
|
||||
return ir.BitwiseAnd(a, ir.BitwiseOr(b, c));
|
||||
case 225:
|
||||
return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseOr(b, c)));
|
||||
return ir.BitwiseXor(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
|
||||
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:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c));
|
||||
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:
|
||||
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:
|
||||
return ir.BitwiseNot(
|
||||
ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c))));
|
||||
return ir.BitwiseOr(ir.BitwiseAnd(a, b),
|
||||
ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseNot(c)));
|
||||
case 234:
|
||||
return ir.BitwiseOr(c, ir.BitwiseAnd(a, b));
|
||||
case 235:
|
||||
return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseXor(a, b)));
|
||||
return ir.BitwiseOr(c, ir.BitwiseXor(a, ir.BitwiseNot(b)));
|
||||
case 236:
|
||||
return ir.BitwiseOr(b, ir.BitwiseAnd(a, c));
|
||||
case 237:
|
||||
return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseXor(a, c)));
|
||||
return ir.BitwiseOr(b, ir.BitwiseXor(a, ir.BitwiseNot(c)));
|
||||
case 238:
|
||||
return ir.BitwiseOr(b, c);
|
||||
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:
|
||||
return a;
|
||||
case 241:
|
||||
return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, c)));
|
||||
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:
|
||||
return ir.BitwiseOr(a, ir.BitwiseNot(b));
|
||||
case 244:
|
||||
|
|
@ -542,15 +526,15 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
|
|||
case 248:
|
||||
return ir.BitwiseOr(a, ir.BitwiseAnd(b, c));
|
||||
case 249:
|
||||
return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseXor(b, c)));
|
||||
return ir.BitwiseOr(a, ir.BitwiseXor(b, ir.BitwiseNot(c)));
|
||||
case 250:
|
||||
return ir.BitwiseOr(a, c);
|
||||
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:
|
||||
return ir.BitwiseOr(a, b);
|
||||
case 253:
|
||||
return ir.BitwiseOr(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
|
||||
return ir.BitwiseOr(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
|
||||
case 254:
|
||||
return ir.BitwiseOr(a, ir.BitwiseOr(b, c));
|
||||
case 255:
|
||||
|
|
|
|||
|
|
@ -3,32 +3,25 @@
|
|||
# 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.
|
||||
|
||||
# Assume that the negation call is for free on the host GPU.
|
||||
# In fact, there are often input or output negation flags for logic operations
|
||||
support_neg = True
|
||||
from itertools import product
|
||||
|
||||
# The primitive instructions
|
||||
OPS = {
|
||||
'ir.BitwiseAnd({lhs}, {rhs})' : lambda a,b: a&b,
|
||||
'ir.BitwiseOr({lhs}, {rhs})' : lambda a,b: a|b,
|
||||
'ir.BitwiseXor({lhs}, {rhs})' : lambda a,b: a^b,
|
||||
'ir.BitwiseAnd({}, {})' : (2, 1, lambda a,b: a&b),
|
||||
'ir.BitwiseOr({}, {})' : (2, 1, 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
|
||||
optimized_calls = {}
|
||||
def register(imm, instruction, count, latency):
|
||||
# Use the sum of instruction count and latency as metrik to evaluate which combination is best
|
||||
metrik = count + latency
|
||||
# Use the sum of instruction count and latency as costs to evaluate which combination is best
|
||||
costs = count + latency + len(instruction) * 0.0001
|
||||
|
||||
# Update if new or better
|
||||
if imm not in optimized_calls or optimized_calls[imm][3] > metrik:
|
||||
optimized_calls[imm] = (instruction, count, latency, metrik)
|
||||
if imm not in optimized_calls or optimized_calls[imm][3] > costs:
|
||||
optimized_calls[imm] = (instruction, count, latency, costs)
|
||||
return True
|
||||
|
||||
return False
|
||||
|
|
@ -46,12 +39,6 @@ inputs = {
|
|||
tb : 'b',
|
||||
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():
|
||||
register(imm, instruction, 0, 0)
|
||||
|
||||
|
|
@ -60,14 +47,19 @@ for imm, instruction in inputs.items():
|
|||
while True:
|
||||
registered = 0
|
||||
calls_copy = optimized_calls.copy()
|
||||
for imm_a, (value_a, count_a, latency_a, metrik_a) in calls_copy.items():
|
||||
for imm_b, (value_b, count_b, latency_b, metrik_b) in calls_copy.items():
|
||||
for OP, f in OPS.items():
|
||||
registered += register(
|
||||
f(imm_a, imm_b), # Updated code
|
||||
OP.format(lhs=value_a, rhs=value_b), # New instruction string
|
||||
count_a+count_b+1, # Sum of instructions + 1
|
||||
max(latency_a, latency_b) + 1) # max latency + 1
|
||||
for OP, (argc, cost, f) in OPS.items():
|
||||
for args in product(calls_copy.items(), repeat=argc):
|
||||
# unpack(transponse) the arrays
|
||||
imm = [arg[0] for arg in args]
|
||||
value = [arg[1][0] for arg in args]
|
||||
count = [arg[1][1] for arg in args]
|
||||
latency = [arg[1][2] for arg in args]
|
||||
|
||||
registered += register(
|
||||
f(*imm),
|
||||
OP.format(*value),
|
||||
sum(count) + cost,
|
||||
max(latency) + cost)
|
||||
if registered == 0:
|
||||
# No update at all? So terminate
|
||||
break
|
||||
|
|
|
|||
Loading…
Reference in a new issue