From 73ef70b50f8798b638a271161f1a0c32869fb382 Mon Sep 17 00:00:00 2001 From: Shankar Easwaran Date: Fri, 1 Feb 2013 05:26:02 +0000 Subject: [PATCH] add hexagon scatter bits and split hexgontargethandler to hexagonrelocationhander llvm-svn: 174148 --- lld/lib/ReaderWriter/ELF/Hexagon/CMakeLists.txt | 1 + .../ELF/Hexagon/HexagonRelocationFunctions.h | 45 + .../ELF/Hexagon/HexagonRelocationHandler.cpp | 108 + .../ELF/Hexagon/HexagonRelocationHandler.h | 37 + .../ELF/Hexagon/HexagonTargetHandler.cpp | 91 - .../ELF/Hexagon/HexagonTargetHandler.h | 14 +- .../ReaderWriter/ELF/Hexagon/HexagonV4Encodings.h | 3556 ++++++++++++++++++++ 7 files changed, 3748 insertions(+), 104 deletions(-) create mode 100644 lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationFunctions.h create mode 100644 lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp create mode 100644 lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h create mode 100644 lld/lib/ReaderWriter/ELF/Hexagon/HexagonV4Encodings.h diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/CMakeLists.txt b/lld/lib/ReaderWriter/ELF/Hexagon/CMakeLists.txt index 40aafac..013e5e5 100644 --- a/lld/lib/ReaderWriter/ELF/Hexagon/CMakeLists.txt +++ b/lld/lib/ReaderWriter/ELF/Hexagon/CMakeLists.txt @@ -1,6 +1,7 @@ add_lld_library(lldHexagonELFTarget HexagonTargetHandler.cpp HexagonTargetInfo.cpp + HexagonRelocationHandler.cpp ) target_link_libraries(lldHexagonELFTarget diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationFunctions.h b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationFunctions.h new file mode 100644 index 0000000..a584a5a --- /dev/null +++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationFunctions.h @@ -0,0 +1,45 @@ +//===- HexagonRelocationFunction.h ----------------------------------------===// +// +// The MCLinker Project +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#ifndef LLD_READER_WRITER_ELF_HEXAGON_RELOCATION_FUNCTIONS_H +#define LLD_READER_WRITER_ELF_HEXAGON_RELOCATION_FUNCTIONS_H + +namespace lld { +namespace elf { + +/// \brief HexagonInstruction which is used to store various values +typedef struct { + const char *insnSyntax; + uint32_t insnMask; + uint32_t insnCmpMask; + uint32_t insnBitMask; + bool isDuplex; +} Instruction; + +#include "HexagonV4Encodings.h" + + +/// \brief finds the scatter Bits that need to be used to apply relocations +uint32_t findBitMask(uint32_t insn, Instruction *encodings, int32_t numInsns) { + for (int32_t i = 0; i < numInsns ; i++) { + if (((insn & 0xc000) == 0) && !(encodings[i].isDuplex)) + continue; + + if (((insn & 0xc000) != 0) && (encodings[i].isDuplex)) + continue; + + if (((encodings[i].insnMask) & insn) == encodings[i].insnCmpMask) + return encodings[i].insnBitMask; + } + assert(0 && "found unknown instruction"); +} + +} // elf +} // lld + +#endif // LLD_READER_WRITER_ELF_HEXAGON_RELOCATION_FUNCTIONS_H diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp new file mode 100644 index 0000000..e237879 --- /dev/null +++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp @@ -0,0 +1,108 @@ +//===- lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp ---------===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "HexagonTargetHandler.h" +#include "HexagonTargetInfo.h" +#include "HexagonRelocationHandler.h" + + +using namespace lld; +using namespace elf; + +using namespace llvm::ELF; + +namespace { +/// \brief Word32_B22: 0x01ff3ffe : (S + A - P) >> 2 : Verify +int relocB22PCREL(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { + int32_t result = (uint32_t)(((S + A) - P)>>2); + if ((result < 0x200000) && (result > -0x200000)) { + result = lld::scatterBits(result, 0x01ff3ffe); + *reinterpret_cast(location) = result | + (uint32_t)*reinterpret_cast(location); + return 0; + } + return 1; +} + +/// \brief Word32_B15: 0x00df20fe : (S + A - P) >> 2 : Verify +int relocB15PCREL(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { + int32_t result = (uint32_t)(((S + A) - P)>>2); + if ((result < 0x8000) && (result > -0x8000)) { + result = lld::scatterBits(result, 0x00df20fe); + *reinterpret_cast(location) = result | + (uint32_t)*reinterpret_cast(location); + return 0; + } + return 1; +} + +/// \brief Word32_LO: 0x00c03fff : (S + A) : Truncate +int relocLO16(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { + uint32_t result = (uint32_t)(S + A); + result = lld::scatterBits(result, 0x00c03fff); + *reinterpret_cast(location) = result | + (uint32_t)*reinterpret_cast(location); + return 0; +} + +/// \brief Word32_LO: 0x00c03fff : (S + A) >> 16 : Truncate +int relocHI16(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { + uint32_t result = (uint32_t)((S + A)>>16); + result = lld::scatterBits(result, 0x00c03fff); + *reinterpret_cast(location) = result | + (uint32_t)*reinterpret_cast(location); + return 0; +} + +/// \brief Word32: 0xffffffff : (S + A) : Truncate +int reloc32(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { + uint32_t result = (uint32_t)(S + A); + *reinterpret_cast(location) = result | + (uint32_t)*reinterpret_cast(location); + return 0; +} +} // end anon namespace + +ErrorOr HexagonTargetRelocationHandler::applyRelocation( + ELFWriter &writer, llvm::FileOutputBuffer &buf, const AtomLayout &atom, + const Reference &ref) const { + uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset; + uint8_t *location = atomContent + ref.offsetInAtom(); + uint64_t targetVAddress = writer.addressOfAtom(ref.target()); + uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom(); + + switch (ref.kind()) { + case R_HEX_B22_PCREL: + relocB22PCREL(location, relocVAddress, targetVAddress, ref.addend()); + break; + case R_HEX_B15_PCREL: + relocB15PCREL(location, relocVAddress, targetVAddress, ref.addend()); + break; + case R_HEX_LO16: + relocLO16(location, relocVAddress, targetVAddress, ref.addend()); + break; + case R_HEX_HI16: + relocHI16(location, relocVAddress, targetVAddress, ref.addend()); + break; + case R_HEX_32: + reloc32(location, relocVAddress, targetVAddress, ref.addend()); + break; + default: { + std::string str; + llvm::raw_string_ostream s(str); + auto name = _targetInfo.stringFromRelocKind(ref.kind()); + s << "Unhandled relocation: " + << (name ? *name : "" ) << " (" << ref.kind() << ")"; + s.flush(); + llvm_unreachable(str.c_str()); + } + } + + return error_code::success(); +} diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h new file mode 100644 index 0000000..f6dc81a --- /dev/null +++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h @@ -0,0 +1,37 @@ +//===- lld/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h -----------===// +// +// The MCLinker Project +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#ifndef LLD_READER_WRITER_ELF_HEXAGON_RELOCATION_FUNCTIONS_H +#define LLD_READER_WRITER_ELF_HEXAGON_RELOCATION_FUNCTIONS_H + +#include "HexagonTargetHandler.h" +#include "HexagonRelocationFunctions.h" +#include "lld/ReaderWriter/RelocationHelperFunctions.h" + +namespace lld { +namespace elf { +typedef llvm::object::ELFType HexagonELFType; + +class HexagonTargetInfo; + +class HexagonTargetRelocationHandler LLVM_FINAL + : public TargetRelocationHandler { +public: + HexagonTargetRelocationHandler(const HexagonTargetInfo &ti) : _targetInfo(ti) + {} + + virtual ErrorOr applyRelocation(ELFWriter &, llvm::FileOutputBuffer &, + const AtomLayout &, + const Reference &)const; + +private: + const HexagonTargetInfo &_targetInfo; +}; +} // elf +} // lld +#endif diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp index 4eec78a..5118877 100644 --- a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp +++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp @@ -9,103 +9,12 @@ #include "HexagonTargetHandler.h" #include "HexagonTargetInfo.h" -#include "lld/ReaderWriter/RelocationHelperFunctions.h" using namespace lld; using namespace elf; using namespace llvm::ELF; -namespace { -/// \brief Word32_B22: 0x01ff3ffe : (S + A - P) >> 2 : Verify -int relocB22PCREL(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { - int32_t result = (uint32_t)(((S + A) - P)>>2); - if ((result < 0x200000) && (result > -0x200000)) { - result = lld::scatterBits(result, 0x01ff3ffe); - *reinterpret_cast(location) = result | - (uint32_t)*reinterpret_cast(location); - return 0; - } - return 1; -} - -/// \brief Word32_B15: 0x00df20fe : (S + A - P) >> 2 : Verify -int relocB15PCREL(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { - int32_t result = (uint32_t)(((S + A) - P)>>2); - if ((result < 0x8000) && (result > -0x8000)) { - result = lld::scatterBits(result, 0x00df20fe); - *reinterpret_cast(location) = result | - (uint32_t)*reinterpret_cast(location); - return 0; - } - return 1; -} - -/// \brief Word32_LO: 0x00c03fff : (S + A) : Truncate -int relocLO16(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { - uint32_t result = (uint32_t)(S + A); - result = lld::scatterBits(result, 0x00c03fff); - *reinterpret_cast(location) = result | - (uint32_t)*reinterpret_cast(location); - return 0; -} - -/// \brief Word32_LO: 0x00c03fff : (S + A) >> 16 : Truncate -int relocHI16(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { - uint32_t result = (uint32_t)((S + A)>>16); - result = lld::scatterBits(result, 0x00c03fff); - *reinterpret_cast(location) = result | - (uint32_t)*reinterpret_cast(location); - return 0; -} - -/// \brief Word32: 0xffffffff : (S + A) : Truncate -int reloc32(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) { - uint32_t result = (uint32_t)(S + A); - *reinterpret_cast(location) = result | - (uint32_t)*reinterpret_cast(location); - return 0; -} -} // end anon namespace - -ErrorOr HexagonTargetRelocationHandler::applyRelocation( - ELFWriter &writer, llvm::FileOutputBuffer &buf, const AtomLayout &atom, - const Reference &ref) const { - uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset; - uint8_t *location = atomContent + ref.offsetInAtom(); - uint64_t targetVAddress = writer.addressOfAtom(ref.target()); - uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom(); - - switch (ref.kind()) { - case R_HEX_B22_PCREL: - relocB22PCREL(location, relocVAddress, targetVAddress, ref.addend()); - break; - case R_HEX_B15_PCREL: - relocB15PCREL(location, relocVAddress, targetVAddress, ref.addend()); - break; - case R_HEX_LO16: - relocLO16(location, relocVAddress, targetVAddress, ref.addend()); - break; - case R_HEX_HI16: - relocHI16(location, relocVAddress, targetVAddress, ref.addend()); - break; - case R_HEX_32: - reloc32(location, relocVAddress, targetVAddress, ref.addend()); - break; - default: { - std::string str; - llvm::raw_string_ostream s(str); - auto name = _targetInfo.stringFromRelocKind(ref.kind()); - s << "Unhandled relocation: " - << (name ? *name : "" ) << " (" << ref.kind() << ")"; - s.flush(); - llvm_unreachable(str.c_str()); - } - } - - return error_code::success(); -} - HexagonTargetHandler::HexagonTargetHandler(HexagonTargetInfo &targetInfo) : DefaultTargetHandler(targetInfo), _relocationHandler(targetInfo), _targetLayout(targetInfo) { diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h index 7875d10..f3fe1d8 100644 --- a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h +++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h @@ -11,6 +11,7 @@ #define LLD_READER_WRITER_ELF_HEXAGON_TARGET_HANDLER_H #include "DefaultTargetHandler.h" +#include "HexagonRelocationHandler.h" #include "TargetLayout.h" namespace lld { @@ -18,19 +19,6 @@ namespace elf { typedef llvm::object::ELFType HexagonELFType; class HexagonTargetInfo; -class HexagonTargetRelocationHandler LLVM_FINAL - : public TargetRelocationHandler { -public: - HexagonTargetRelocationHandler(const HexagonTargetInfo &ti) : _targetInfo(ti) {} - - virtual ErrorOr applyRelocation(ELFWriter &, llvm::FileOutputBuffer &, - const AtomLayout &, - const Reference &)const; - -private: - const HexagonTargetInfo &_targetInfo; -}; - class HexagonTargetHandler LLVM_FINAL : public DefaultTargetHandler { public: diff --git a/lld/lib/ReaderWriter/ELF/Hexagon/HexagonV4Encodings.h b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonV4Encodings.h new file mode 100644 index 0000000..1e26810 --- /dev/null +++ b/lld/lib/ReaderWriter/ELF/Hexagon/HexagonV4Encodings.h @@ -0,0 +1,3556 @@ +//===- lib/ReaderWriter/ELF/Hexagon/HexagonV4Encodings.h -000-------------===// +// +// The LLVM Linker +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +Instruction insn_encodings_v4[] = { + { "if (Pv4) memb(Rs32+#u6:0)=Rt32", + 0xffe00004, + 0x40000000, + 0x20f8, + 0x0 + }, + { "Rdd32=memubh(Rt32<<#3+#U6)", + 0xffe03080, + 0x9ca03080, + 0xf60, + 0x0 + }, + { "memd(gp+#u16:3)=Rtt32", + 0xf9e00000, + 0x48c00000, + 0x61f20ff, + 0x0 + }, + { "p1=cmp.gt(Rs16,#-1); if (p1.new) jump:t #r9:2", + 0xf7c02300, + 0x13802100, + 0x3000fe, + 0x0 + }, + { "p3=sp2loop0(#r7:2,Rs32)", + 0xffe00000, + 0x60c00000, + 0x1f18, + 0x0 + }, + { "p3=sp2loop0(#r7:2,#U10)", + 0xffe00000, + 0x69c00000, + 0x1f18, + 0x0 + }, + { "if (Pt4.new) Rd32=memb(Rs32+#u6:0)", + 0xffe02000, + 0x43000000, + 0x7e0, + 0x0 + }, + { "memb(Rs32+#u6:0)|=Rt32", + 0xff602060, + 0x3e000060, + 0x1f80, + 0x0 + }, + { "Rdd32=membh(Re32=#U6)", + 0xffe03000, + 0x9ae01000, + 0xf60, + 0x0 + }, + { "Rd32=memuh(Rs32+#s11:1)", + 0xf9e00000, + 0x91600000, + 0x6003fe0, + 0x0 + }, + { "if (!Pv4) memb(#u6)=Rt32", + 0xffe02084, + 0xaf000084, + 0x30078, + 0x0 + }, + { "memb(Rs32+#u6:0)-=Rt32", + 0xff602060, + 0x3e000020, + 0x1f80, + 0x0 + }, + { "memh(Rs32+#u6:1)&=Rt32", + 0xff602060, + 0x3e200040, + 0x1f80, + 0x0 + }, + { "p0=cmp.gt(Rs16,#U5); if (!p0.new) jump:t #r9:2", + 0xf7c02000, + 0x10c02000, + 0x3000fe, + 0x0 + }, + { "loop1(#r7:2,Rs32)", + 0xffe00000, + 0x60200000, + 0x1f18, + 0x0 + }, + { "loop1(#r7:2,#U10)", + 0xffe00000, + 0x69200000, + 0x1f18, + 0x0 + }, + { "memh(Ru32<<#0+#U6)=Nt8.new", + 0xffe038c0, + 0xada00880, + 0x3f, + 0x0 + }, + { "Rdd32=combine(Rs32,#s8)", + 0xff602000, + 0x73002000, + 0x1fe0, + 0x0 + }, + { "if (!cmp.gt(Ns8.new,#-1)) jump:t #r9:2", + 0xf7c02000, + 0x26c02000, + 0x3000fe, + 0x0 + }, + { "if (!Pt4.new) Rd32=memh(#u6)", + 0xffe03880, + 0x9f403880, + 0x1f0100, + 0x0 + }, + { "memh(gp+#u16:1)=Rt32", + 0xf9e00000, + 0x48400000, + 0x61f20ff, + 0x0 + }, + { "if (Pt4) Rd32=memuh(Rs32+#u6:1)", + 0xffe02000, + 0x41600000, + 0x7e0, + 0x0 + }, + { "if (Pv4) memb(#u6)=Rt32", + 0xffe02084, + 0xaf000080, + 0x30078, + 0x0 + }, + { "p1=cmp.gt(Rs16,#-1); if (p1.new) jump:nt #r9:2", + 0xf7c02300, + 0x13800100, + 0x3000fe, + 0x0 + }, + { "if (!Pv4.new) memb(Rs32+#u6:0)=Nt8.new", + 0xffe01804, + 0x46a00000, + 0x20f8, + 0x0 + }, + { "if (Pv4.new) memh(Rs32+#u6:1)=Rt32", + 0xffe00004, + 0x42400000, + 0x20f8, + 0x0 + }, + { "if (!cmp.gtu(Rt32,Ns8.new)) jump:nt #r9:2", + 0xf7c02000, + 0x22400000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.eq(Rs16,#U5); if (!p1.new) jump:t #r9:2", + 0xf7c02000, + 0x12402000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; Rdd8=combine(#3,#u2)", + 0xfc003d18, + 0x28003c18, + 0x3f00000, + 0x1 + }, + { "if (Pv4.new) memb(Rs32+#u6:0)=#S6", + 0xffe00000, + 0x39000000, + 0x201f, + 0x0 + }, + { "Pd4=cmph.gtu(Rs32,#u7)", + 0xff601018, + 0xdd400008, + 0xfe0, + 0x0 + }, + { "Pd4=cmp.gt(Rs32,#s10)", + 0xffc0001c, + 0x75400000, + 0x203fe0, + 0x0 + }, + { "Rd16=#u6 ; if (!p0.new) dealloc_return:nt", + 0xfc003fc7, + 0x48003f47, + 0x3f00000, + 0x1 + }, + { "Rdd32=memubh(Rt32<<#2+#U6)", + 0xffe03080, + 0x9ca03000, + 0xf60, + 0x0 + }, + { "Ryy32=memb_fifo(Rs32+#s11:0)", + 0xf9e00000, + 0x90800000, + 0x6003fe0, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; if (p0) jumpr Lr", + 0xf8003fc7, + 0x40003fc4, + 0x7f00000, + 0x1 + }, + { "Rd16=#U6 ; allocframe(#u5:3)", + 0xfc003e00, + 0x68003c00, + 0x3f00000, + 0x1 + }, + { "Rx16=add(Rx16,#s7) ; if (!p0) jumpr Lr", + 0xf8003fc7, + 0x40003fc5, + 0x7f00000, + 0x1 + }, + { "Rd32=memw(Rs32+#s11:2)", + 0xf9e00000, + 0x91800000, + 0x6003fe0, + 0x0 + }, + { "memw(Rs32+#u6:2)|=Rt32", + 0xff602060, + 0x3e400060, + 0x1f80, + 0x0 + }, + { "memb(Rs32+#u6:0)+=Rt32", + 0xff602060, + 0x3e000000, + 0x1f80, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rdd8=combine(#3,#u2)", + 0xf8003d18, + 0x20003c18, + 0x7f00000, + 0x1 + }, + { "Ry16=add(Ry16,#s7) ; Rx16=add(Rs16,Rx16)", + 0xf8003f00, + 0x20003800, + 0x7f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; Rdd8=combine(#2,#u2)", + 0xf8003d18, + 0x20003c10, + 0x7f00000, + 0x1 + }, + { "Rd32=!cmp.eq(Rs32,#s8)", + 0xff602000, + 0x73602000, + 0x1fe0, + 0x0 + }, + { "if (Pt4) Rd32=memb(#u6)", + 0xffe03880, + 0x9f002080, + 0x1f0100, + 0x0 + }, + { "if (!Pt4.new) Rd32=memb(Rs32+#u6:0)", + 0xffe02000, + 0x47000000, + 0x7e0, + 0x0 + }, + { "Rd32=memh(Rs32+#s11:1)", + 0xf9e00000, + 0x91400000, + 0x6003fe0, + 0x0 + }, + { "memd(Re32=#U6)=Rtt32", + 0xffe02080, + 0xabc00080, + 0x3f, + 0x0 + }, + { "if (cmp.gt(Ns8.new,Rt32)) jump:t #r9:2", + 0xf7c02000, + 0x20802000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; if (p0) dealloc_return", + 0xf8003fc7, + 0x40003f44, + 0x7f00000, + 0x1 + }, + { "if (!Pv4.new) memw(#u6)=Nt8.new", + 0xffe03884, + 0xafa03084, + 0x30078, + 0x0 + }, + { "Rd32=memb(Re32=#U6)", + 0xffe03000, + 0x9b001000, + 0xf60, + 0x0 + }, + { "if (Pv4.new) memh(Rs32+#u6:1)=Nt8.new", + 0xffe01804, + 0x42a00800, + 0x20f8, + 0x0 + }, + { "Re16=#U6 ; Rd16=add(Rs16,#1)", + 0xfc003f00, + 0x28003100, + 0x3f00000, + 0x1 + }, + { "memw(Re32=#U6)=Rt32", + 0xffe02080, + 0xab800080, + 0x3f, + 0x0 + }, + { "if (!cmp.gt(Ns8.new,#U5)) jump:nt #r9:2", + 0xf7c02000, + 0x24c00000, + 0x3000fe, + 0x0 + }, + { "if (!Pv4.new) memh(Rs32+#u6:1)=#S6", + 0xffe00000, + 0x39a00000, + 0x201f, + 0x0 + }, + { "p1=tstbit(Rs16,#0); if (p1.new) jump:t #r9:2", + 0xf7c02300, + 0x13802300, + 0x3000fe, + 0x0 + }, + { "if (!Pv4.new) memh(Rs32+#u6:1)=Nt8.new", + 0xffe01804, + 0x46a00800, + 0x20f8, + 0x0 + }, + { "memh(Ru32<<#2+#U6)=Rt.H32", + 0xffe020c0, + 0xad602080, + 0x3f, + 0x0 + }, + { "Re16=#u6 ; Rd16=sxtb(Rs16)", + 0xfc003f00, + 0x28003500, + 0x3f00000, + 0x1 + }, + { "Re16=#u6 ; Rd16=sxth(Rs16)", + 0xfc003f00, + 0x28003400, + 0x3f00000, + 0x1 + }, + { "memh(Ru32<<#1+#U6)=Rt.H32", + 0xffe020c0, + 0xad6000c0, + 0x3f, + 0x0 + }, + { "loop0(#r7:2,Rs32)", + 0xffe00000, + 0x60000000, + 0x1f18, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=memw(Rs16+#u4:2)", + 0xf8003000, + 0x40000000, + 0x7f00000, + 0x1 + }, + { "loop0(#r7:2,#U10)", + 0xffe00000, + 0x69000000, + 0x1f18, + 0x0 + }, + { "Rd32=memubh(Rt32<<#1+#U6)", + 0xffe03080, + 0x9c601080, + 0xf60, + 0x0 + }, + { "Rdd32=membh(Rt32<<#0+#U6)", + 0xffe03080, + 0x9ce01000, + 0xf60, + 0x0 + }, + { "Rd32=memubh(Rt32<<#0+#U6)", + 0xffe03080, + 0x9c601000, + 0xf60, + 0x0 + }, + { "p1=cmp.gtu(Rs16,#U5); if (!p1.new) jump:t #r9:2", + 0xf7c02000, + 0x13402000, + 0x3000fe, + 0x0 + }, + { "Rd32=memubh(Rt32<<#2+#U6)", + 0xffe03080, + 0x9c603000, + 0xf60, + 0x0 + }, + { "if (!cmp.gt(Rt32,Ns8.new)) jump:nt #r9:2", + 0xf7c02000, + 0x21c00000, + 0x3000fe, + 0x0 + }, + { "Rd16=#U6 ; memw(Rs16+#u4:2)=Rt16", + 0xfc003000, + 0x68000000, + 0x3f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; memh(Rs16+#u3:1)=Rt16", + 0xf8003800, + 0x60002000, + 0x7f00000, + 0x1 + }, + { "if (!Pv4.new) memw(#u6)=Rt32", + 0xffe02084, + 0xaf802084, + 0x30078, + 0x0 + }, + { "Re16=#U6 ; Rd16=memw(Rs16+#u4:2)", + 0xfc003000, + 0x48000000, + 0x3f00000, + 0x1 + }, + { "p0=cmp.gt(Rs16,#-1); if (!p0.new) jump:t #r9:2", + 0xf7c02300, + 0x11c02100, + 0x3000fe, + 0x0 + }, + { "p1=cmp.gt(Rs16,#U5); if (p1.new) jump:nt #r9:2", + 0xf7c02000, + 0x12800000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; if (p0.new) Rd16=#0", + 0xfc003e70, + 0x28003a40, + 0x3f00000, + 0x1 + }, + { "Re16=#U6 ; Rd16=add(Rs16,#-1)", + 0xfc003f00, + 0x28003300, + 0x3f00000, + 0x1 + }, + { "Rd32=+mpyi(Rs32,#u8)", + 0xff800000, + 0xe0000000, + 0x1fe0, + 0x0 + }, + { "memw(Rs32+#u6:2)+=#U5", + 0xff602060, + 0x3f400000, + 0x1f80, + 0x0 + }, + { "if (Pv4.new) memb(Rs32+#u6:0)=Rt32", + 0xffe00004, + 0x42000000, + 0x20f8, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; memb(Rs16+#u4:0)=#1", + 0xf8003f00, + 0x60003300, + 0x7f00000, + 0x1 + }, + { "if (Pv4.new) memb(Rs32+#u6:0)=Nt8.new", + 0xffe01804, + 0x42a00000, + 0x20f8, + 0x0 + }, + { "p1=cmp.gt(Rs16,#U5); if (!p1.new) jump:nt #r9:2", + 0xf7c02000, + 0x12c00000, + 0x3000fe, + 0x0 + }, + { "immext(#u26:6)", + 0xf0000000, + 0x0, + 0xfff3fff, + 0x0 + }, + { "Rx32=sub(#u8,lsr(Rx32,#U5))", + 0xff000016, + 0xde000016, + 0xe020e8, + 0x0 + }, + { "Rd32=memub(Re32=#U6)", + 0xffe03000, + 0x9b201000, + 0xf60, + 0x0 + }, + { "memh(Re32=#U6)=Nt8.new", + 0xffe03880, + 0xaba00880, + 0x3f, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=memw(Sp+#u5:2)", + 0xf8003e00, + 0x40003c00, + 0x7f00000, + 0x1 + }, + { "memh(Rs32+#u6:1)=clrbit(#U5)", + 0xff602060, + 0x3f200040, + 0x1f80, + 0x0 + }, + { "if (!Pt4.new) Rd32=memub(#u6)", + 0xffe03880, + 0x9f203880, + 0x1f0100, + 0x0 + }, + { "if (!cmp.gt(Ns8.new,Rt32)) jump:nt #r9:2", + 0xf7c02000, + 0x20c00000, + 0x3000fe, + 0x0 + }, + { "memh(gp+#u16:1)=Nt8.new", + 0xf9e01800, + 0x48a00800, + 0x61f20ff, + 0x0 + }, + { "Rdd32=memubh(Rs32+#s11:2)", + 0xf9e00000, + 0x90a00000, + 0x6003fe0, + 0x0 + }, + { "if (!Pu4.new) Rd32=add(Rs32,#s8)", + 0xff802000, + 0x74802000, + 0x1fe0, + 0x0 + }, + { "Ryy32=memh_fifo(Re32=#U6)", + 0xffe03000, + 0x9a401000, + 0xf60, + 0x0 + }, + { "p0=cmp.eq(Rs16,#U5); if (p0.new) jump:t #r9:2", + 0xf7c02000, + 0x10002000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.gt(Rs16,Rt16); if (p1.new) jump:t #r9:2", + 0xf7c03000, + 0x14803000, + 0x3000fe, + 0x0 + }, + { "memb(Ru32<<#3+#U6)=Rt32", + 0xffe020c0, + 0xad0020c0, + 0x3f, + 0x0 + }, + { "Pd4=cmp.gtu(Rs32,#u9)", + 0xffe0001c, + 0x75800000, + 0x3fe0, + 0x0 + }, + { "memw(gp+#u16:2)=Nt8.new", + 0xf9e01800, + 0x48a01000, + 0x61f20ff, + 0x0 + }, + { "Rdd32=memd(Rt32<<#2+#U6)", + 0xffe03080, + 0x9dc03000, + 0xf60, + 0x0 + }, + { "Rdd32=memd(Rt32<<#3+#U6)", + 0xffe03080, + 0x9dc03080, + 0xf60, + 0x0 + }, + { "Rdd32=memd(Rt32<<#0+#U6)", + 0xffe03080, + 0x9dc01000, + 0xf60, + 0x0 + }, + { "Rdd32=memd(Rt32<<#1+#U6)", + 0xffe03080, + 0x9dc01080, + 0xf60, + 0x0 + }, + { "Rd32=memuh(Rt32<<#0+#U6)", + 0xffe03080, + 0x9d601000, + 0xf60, + 0x0 + }, + { "Rd32=memuh(Rt32<<#1+#U6)", + 0xffe03080, + 0x9d601080, + 0xf60, + 0x0 + }, + { "Rd32=memuh(Rt32<<#2+#U6)", + 0xffe03080, + 0x9d603000, + 0xf60, + 0x0 + }, + { "Rd32=memuh(Rt32<<#3+#U6)", + 0xffe03080, + 0x9d603080, + 0xf60, + 0x0 + }, + { "Re16=#U6 ; Rd16=memw(Sp+#u5:2)", + 0xfc003e00, + 0x48003c00, + 0x3f00000, + 0x1 + }, + { "if (!Pv4.new) memh(#u6)=Rt32", + 0xffe02084, + 0xaf402084, + 0x30078, + 0x0 + }, + { "if (!Pv4.new) memh(Rs32+#u6:1)=Rt.H32", + 0xffe00004, + 0x46600000, + 0x20f8, + 0x0 + }, + { "if (Pt4.new) Rd32=memub(#u6)", + 0xffe03880, + 0x9f203080, + 0x1f0100, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=add(Rs16,#1)", + 0xf8003f00, + 0x20003100, + 0x7f00000, + 0x1 + }, + { "p0=cmp.gtu(Rs16,#U5); if (!p0.new) jump:t #r9:2", + 0xf7c02000, + 0x11402000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rdd8=combine(#0,Rs16)", + 0xf8003d08, + 0x20003d00, + 0x7f00000, + 0x1 + }, + { "Rdd32=memubh(Rt32<<#1+#U6)", + 0xffe03080, + 0x9ca01080, + 0xf60, + 0x0 + }, + { "Rdd32=memubh(Rt32<<#0+#U6)", + 0xffe03080, + 0x9ca01000, + 0xf60, + 0x0 + }, + { "if (!Pv4) memh(Rs32+#u6:1)=#S6", + 0xffe00000, + 0x38a00000, + 0x201f, + 0x0 + }, + { "p0=cmp.eq(Rs16,#-1); if (p0.new) jump:nt #r9:2", + 0xf7c02300, + 0x11800000, + 0x3000fe, + 0x0 + }, + { "p1=tstbit(Rs16,#0); if (!p1.new) jump:t #r9:2", + 0xf7c02300, + 0x13c02300, + 0x3000fe, + 0x0 + }, + { "Rdd32=membh(Rt32<<#2+#U6)", + 0xffe03080, + 0x9ce03000, + 0xf60, + 0x0 + }, + { "Rdd32=membh(Rs32+#s11:2)", + 0xf9e00000, + 0x90e00000, + 0x6003fe0, + 0x0 + }, + { "if (Pv4) memh(#u6)=Rt32", + 0xffe02084, + 0xaf400080, + 0x30078, + 0x0 + }, + { "Rdd32=membh(Rt32<<#3+#U6)", + 0xffe03080, + 0x9ce03080, + 0xf60, + 0x0 + }, + { "Rd32=#s16", + 0xff000000, + 0x78000000, + 0xdf3fe0, + 0x0 + }, + { "Rdd32=membh(Rt32<<#1+#U6)", + 0xffe03080, + 0x9ce01080, + 0xf60, + 0x0 + }, + { "memw(Re32=#U6)=Nt8.new", + 0xffe03880, + 0xaba01080, + 0x3f, + 0x0 + }, + { "memb(Ru32<<#2+#U6)=Rt32", + 0xffe020c0, + 0xad002080, + 0x3f, + 0x0 + }, + { "memb(Ru32<<#1+#U6)=Rt32", + 0xffe020c0, + 0xad0000c0, + 0x3f, + 0x0 + }, + { "memb(Ru32<<#0+#U6)=Rt32", + 0xffe020c0, + 0xad000080, + 0x3f, + 0x0 + }, + { "if (cmp.gtu(Ns8.new,#U5)) jump:nt #r9:2", + 0xf7c02000, + 0x25000000, + 0x3000fe, + 0x0 + }, + { "memh(Rs32+#u6:1)-=#U5", + 0xff602060, + 0x3f200020, + 0x1f80, + 0x0 + }, + { "if (!Pv4) memd(#u6)=Rtt32", + 0xffe02084, + 0xafc00084, + 0x30078, + 0x0 + }, + { "if (!cmp.eq(Ns8.new,#U5)) jump:nt #r9:2", + 0xf7c02000, + 0x24400000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; Rd16=memub(Rs16+#u4:0)", + 0xfc003000, + 0x48001000, + 0x3f00000, + 0x1 + }, + { "memw(Rs32+#s11:2)=Nt8.new", + 0xf9e01800, + 0xa1a01000, + 0x60020ff, + 0x0 + }, + { "memb(Rs32+#u6:0)=clrbit(#U5)", + 0xff602060, + 0x3f000040, + 0x1f80, + 0x0 + }, + { "if (!Pv4.new) memh(#u6)=Rt.H32", + 0xffe02084, + 0xaf602084, + 0x30078, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; Rd16=sxth(Rs16)", + 0xf8003f00, + 0x20003400, + 0x7f00000, + 0x1 + }, + { "if (!Pv4) memh(#u6)=Rt32", + 0xffe02084, + 0xaf400084, + 0x30078, + 0x0 + }, + { "if (!Pv4) memw(Rs32+#u6:2)=Nt8.new", + 0xffe01804, + 0x44a01000, + 0x20f8, + 0x0 + }, + { "memh(Rs32+#u6:1)+=Rt32", + 0xff602060, + 0x3e200000, + 0x1f80, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; if (!p0) Rd16=#0", + 0xf8003e70, + 0x20003a70, + 0x7f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; Rdd8=memd(Sp+#u5:3)", + 0xf8003f00, + 0x40003e00, + 0x7f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=add(Rs16,#-1)", + 0xf8003f00, + 0x20003300, + 0x7f00000, + 0x1 + }, + { "p1=tstbit(Rs16,#0); if (p1.new) jump:nt #r9:2", + 0xf7c02300, + 0x13800300, + 0x3000fe, + 0x0 + }, + { "memb(Ru32<<#0+#U6)=Nt8.new", + 0xffe038c0, + 0xada00080, + 0x3f, + 0x0 + }, + { "Rd32=memh(gp+#u16:1)", + 0xf9e00000, + 0x49400000, + 0x61f3fe0, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=memuh(Rs16+#u3:1)", + 0xf8003800, + 0x40002800, + 0x7f00000, + 0x1 + }, + { "memb(Ru32<<#3+#U6)=Nt8.new", + 0xffe038c0, + 0xada020c0, + 0x3f, + 0x0 + }, + { "if (Pv4) memh(#u6)=Nt8.new", + 0xffe03884, + 0xafa00880, + 0x30078, + 0x0 + }, + { "Rd32=memb(gp+#u16:0)", + 0xf9e00000, + 0x49000000, + 0x61f3fe0, + 0x0 + }, + { "Rd32=add(#u6,mpyi(Rs32,Rt32))", + 0xff800000, + 0xd7000000, + 0x6020e0, + 0x0 + }, + { "Rx32|=and(Rs32,#s10)", + 0xffc00000, + 0xda000000, + 0x203fe0, + 0x0 + }, + { "p1=cmp.gt(Rs16,#U5); if (p1.new) jump:t #r9:2", + 0xf7c02000, + 0x12802000, + 0x3000fe, + 0x0 + }, + { "Rd32=memuh(gp+#u16:1)", + 0xf9e00000, + 0x49600000, + 0x61f3fe0, + 0x0 + }, + { "if (!Pt4.new) Rd32=memh(Rs32+#u6:1)", + 0xffe02000, + 0x47400000, + 0x7e0, + 0x0 + }, + { "Rdd32=memd(gp+#u16:3)", + 0xf9e00000, + 0x49c00000, + 0x61f3fe0, + 0x0 + }, + { "Rdd32=memd(Re32=#U6)", + 0xffe03000, + 0x9bc01000, + 0xf60, + 0x0 + }, + { "p1=cmp.gt(Rs16,#-1); if (!p1.new) jump:nt #r9:2", + 0xf7c02300, + 0x13c00100, + 0x3000fe, + 0x0 + }, + { "if (!Pt4) Rd32=memb(#u6)", + 0xffe03880, + 0x9f002880, + 0x1f0100, + 0x0 + }, + { "Rd32=memuh(Re32=#U6)", + 0xffe03000, + 0x9b601000, + 0xf60, + 0x0 + }, + { "if (Pv4) memh(Rs32+#u6:1)=Nt8.new", + 0xffe01804, + 0x40a00800, + 0x20f8, + 0x0 + }, + { "if (Pv4.new) memw(Rs32+#u6:2)=Rt32", + 0xffe00004, + 0x42800000, + 0x20f8, + 0x0 + }, + { "p0=cmp.gt(Rs16,Rt16); if (p0.new) jump:nt #r9:2", + 0xf7c03000, + 0x14800000, + 0x3000fe, + 0x0 + }, + { "Rd16=#U6 ; memb(Rs16+#u4:0)=Rt16", + 0xfc003000, + 0x68001000, + 0x3f00000, + 0x1 + }, + { "Rd16=#u6 ; if (p0) dealloc_return", + 0xfc003fc7, + 0x48003f44, + 0x3f00000, + 0x1 + }, + { "Rd16=#u6 ; if (!p0) dealloc_return", + 0xfc003fc7, + 0x48003f45, + 0x3f00000, + 0x1 + }, + { "p0=cmp.gt(Rs16,#U5); if (p0.new) jump:nt #r9:2", + 0xf7c02000, + 0x10800000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; if (!p0.new) Rd16=#0", + 0xf8003e70, + 0x20003a50, + 0x7f00000, + 0x1 + }, + { "if (cmp.gtu(Ns8.new,Rt32)) jump:t #r9:2", + 0xf7c02000, + 0x21002000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; jumpr Lr", + 0xf8003fc4, + 0x40003fc0, + 0x7f00000, + 0x1 + }, + { "memb(gp+#u16:0)=Rt32", + 0xf9e00000, + 0x48000000, + 0x61f20ff, + 0x0 + }, + { "Pd4=!cmp.eq(Rs32,#s10)", + 0xffc0001c, + 0x75000010, + 0x203fe0, + 0x0 + }, + { "Ry16=add(Ry16,#s7) ; Rx16=add(Rx16,Rs16)", + 0xf8003f00, + 0x20003800, + 0x7f00000, + 0x1 + }, + { "memw(Rs32+#s11:2)=Rt32", + 0xf9e00000, + 0xa1800000, + 0x60020ff, + 0x0 + }, + { "if (Rs32<=#0) jump:nt #r13:2", + 0xffc01000, + 0x61c00000, + 0x202ffe, + 0x0 + }, + { "if (Pv4.new) memh(#u6)=Rt32", + 0xffe02084, + 0xaf402080, + 0x30078, + 0x0 + }, + { "if (!Pt4) Rd32=memuh(#u6)", + 0xffe03880, + 0x9f602880, + 0x1f0100, + 0x0 + }, + { "Rd16=#U6 ; memw(Rs16+#u4:2)=#0", + 0xfc003f00, + 0x68003000, + 0x3f00000, + 0x1 + }, + { "Rd16=#U6 ; memw(Rs16+#u4:2)=#1", + 0xfc003f00, + 0x68003100, + 0x3f00000, + 0x1 + }, + { "memh(Rs32+#u6:1)+=#U5", + 0xff602060, + 0x3f200000, + 0x1f80, + 0x0 + }, + { "Ryy32=memb_fifo(Re32=#U6)", + 0xffe03000, + 0x9a801000, + 0xf60, + 0x0 + }, + { "if (cmp.gt(Ns8.new,#U5)) jump:t #r9:2", + 0xf7c02000, + 0x24802000, + 0x3000fe, + 0x0 + }, + { "if (Pv4.new) memd(Rs32+#u6:3)=Rtt32", + 0xffe00004, + 0x42c00000, + 0x20f8, + 0x0 + }, + { "p0=cmp.eq(Rs16,#-1); if (p0.new) jump:t #r9:2", + 0xf7c02300, + 0x11802000, + 0x3000fe, + 0x0 + }, + { "if (Rs32>=#0) jump:t #r13:2", + 0xffc01000, + 0x61401000, + 0x202ffe, + 0x0 + }, + { "if (Pt4.new) Rdd32=memd(Rs32+#u6:3)", + 0xffe02000, + 0x43c00000, + 0x7e0, + 0x0 + }, + { "p0=cmp.gtu(Rs16,#U5); if (!p0.new) jump:nt #r9:2", + 0xf7c02000, + 0x11400000, + 0x3000fe, + 0x0 + }, + { "if (cmp.gt(Rt32,Ns8.new)) jump:nt #r9:2", + 0xf7c02000, + 0x21800000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; Rd16=add(Sp,#u6:2)", + 0xfc003c00, + 0x28002c00, + 0x3f00000, + 0x1 + }, + { "Re16=#U6 ; Rd16=and(Rs16,#1)", + 0xfc003f00, + 0x28003200, + 0x3f00000, + 0x1 + }, + { "Ryy32=memb_fifo(Rt32<<#3+#U6)", + 0xffe03080, + 0x9c803080, + 0xf60, + 0x0 + }, + { "p1=cmp.gt(Rs16,Rt16); if (!p1.new) jump:t #r9:2", + 0xf7c03000, + 0x14c03000, + 0x3000fe, + 0x0 + }, + { "Rd32=add(Rs32,sub(#s6,Ru32))", + 0xff800000, + 0xdb800000, + 0x6020e0, + 0x0 + }, + { "if (!cmp.gtu(Rt32,Ns8.new)) jump:t #r9:2", + 0xf7c02000, + 0x22402000, + 0x3000fe, + 0x0 + }, + { "if (!Pv4.new) memw(Rs32+#u6:2)=Rt32", + 0xffe00004, + 0x46800000, + 0x20f8, + 0x0 + }, + { "p3=sp1loop0(#r7:2,#U10)", + 0xffe00000, + 0x69a00000, + 0x1f18, + 0x0 + }, + { "Rd16=#U6 ; memd(Sp+#s6:3)=Rtt8", + 0xfc003e00, + 0x68002a00, + 0x3f00000, + 0x1 + }, + { "p3=sp1loop0(#r7:2,Rs32)", + 0xffe00000, + 0x60a00000, + 0x1f18, + 0x0 + }, + { "if (!cmp.gtu(Ns8.new,#U5)) jump:nt #r9:2", + 0xf7c02000, + 0x25400000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; if (!p0) Rd16=#0", + 0xfc003e70, + 0x28003a70, + 0x3f00000, + 0x1 + }, + { "Ryy32=memb_fifo(Rt32<<#2+#U6)", + 0xffe03080, + 0x9c803000, + 0xf60, + 0x0 + }, + { "if (Rs32>=#0) jump:nt #r13:2", + 0xffc01000, + 0x61400000, + 0x202ffe, + 0x0 + }, + { "if (Pv4.new) memw(Rs32+#u6:2)=Nt8.new", + 0xffe01804, + 0x42a01000, + 0x20f8, + 0x0 + }, + { "Pd4=cmp.eq(Rs32,#s10)", + 0xffc0001c, + 0x75000000, + 0x203fe0, + 0x0 + }, + { "if (Pv4.new) memd(#u6)=Rtt32", + 0xffe02084, + 0xafc02080, + 0x30078, + 0x0 + }, + { "if (!Pv4) memh(#u6)=Nt8.new", + 0xffe03884, + 0xafa00884, + 0x30078, + 0x0 + }, + { "if (Pv4.new) memb(#u6)=Nt8.new", + 0xffe03884, + 0xafa02080, + 0x30078, + 0x0 + }, + { "if (!Pv4) memw(Rs32+#u6:2)=#S6", + 0xffe00000, + 0x38c00000, + 0x201f, + 0x0 + }, + { "if (Rs32!=#0) jump:t #r13:2", + 0xffc01000, + 0x61001000, + 0x202ffe, + 0x0 + }, + { "memw(gp+#u16:2)=Rt32", + 0xf9e00000, + 0x48800000, + 0x61f20ff, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=memb(Rs16+#u3:0)", + 0xf8003800, + 0x40003000, + 0x7f00000, + 0x1 + }, + { "p1=cmp.gtu(Rs16,Rt16); if (!p1.new) jump:t #r9:2", + 0xf7c03000, + 0x15403000, + 0x3000fe, + 0x0 + }, + { "p0=cmp.gtu(Rs16,Rt16); if (!p0.new) jump:nt #r9:2", + 0xf7c03000, + 0x15400000, + 0x3000fe, + 0x0 + }, + { "if (cmp.gtu(Ns8.new,Rt32)) jump:nt #r9:2", + 0xf7c02000, + 0x21000000, + 0x3000fe, + 0x0 + }, + { "if (Pv4) memd(Rs32+#u6:3)=Rtt32", + 0xffe00004, + 0x40c00000, + 0x20f8, + 0x0 + }, + { "if (!Pv4.new) memw(Rs32+#u6:2)=Nt8.new", + 0xffe01804, + 0x46a01000, + 0x20f8, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rdd8=combine(Rs16,#0)", + 0xf8003d08, + 0x20003d08, + 0x7f00000, + 0x1 + }, + { "memb(Ru32<<#2+#U6)=Nt8.new", + 0xffe038c0, + 0xada02080, + 0x3f, + 0x0 + }, + { "Rd32=membh(Rt32<<#2+#U6)", + 0xffe03080, + 0x9c203000, + 0xf60, + 0x0 + }, + { "Rd16=#U6 ; memh(Rs16+#u3:1)=Rt16", + 0xfc003800, + 0x68002000, + 0x3f00000, + 0x1 + }, + { "Rd32=memubh(Rs32+#s11:1)", + 0xf9e00000, + 0x90600000, + 0x6003fe0, + 0x0 + }, + { "p0=cmp.eq(Rs16,Rt16); if (p0.new) jump:nt #r9:2", + 0xf7c03000, + 0x14000000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; if (p0.new) Rd16=#0", + 0xf8003e70, + 0x20003a40, + 0x7f00000, + 0x1 + }, + { "if (Pu4.new) jump:nt #r15:2", + 0xff201800, + 0x5c000800, + 0xdf20fe, + 0x0 + }, + { "if (Pt4) Rd32=memw(Rs32+#u6:2)", + 0xffe02000, + 0x41800000, + 0x7e0, + 0x0 + }, + { "Rd32=add(Rs32,add(Ru32,#s6))", + 0xff800000, + 0xdb000000, + 0x6020e0, + 0x0 + }, + { "Re16=#U6 ; Rdd8=memd(Sp+#u5:3)", + 0xfc003f00, + 0x48003e00, + 0x3f00000, + 0x1 + }, + { "p0=cmp.eq(Rs16,Rt16); if (p0.new) jump:t #r9:2", + 0xf7c03000, + 0x14002000, + 0x3000fe, + 0x0 + }, + { "p0=cmp.gt(Rs16,#-1); if (p0.new) jump:nt #r9:2", + 0xf7c02300, + 0x11800100, + 0x3000fe, + 0x0 + }, + { "Rd16=#U6 ; memw(Sp+#u5:2)=Rt16", + 0xfc003e00, + 0x68002800, + 0x3f00000, + 0x1 + }, + { "if (!Pv4) memd(Rs32+#u6:3)=Rtt32", + 0xffe00004, + 0x44c00000, + 0x20f8, + 0x0 + }, + { "if (!Pt4.new) Rd32=memb(#u6)", + 0xffe03880, + 0x9f003880, + 0x1f0100, + 0x0 + }, + { "Rd32=cmp.eq(Rs32,#s8)", + 0xff602000, + 0x73402000, + 0x1fe0, + 0x0 + }, + { "if (Pv4) memh(Rs32+#u6:1)=#S6", + 0xffe00000, + 0x38200000, + 0x201f, + 0x0 + }, + { "if (cmp.gt(Ns8.new,#U5)) jump:nt #r9:2", + 0xf7c02000, + 0x24800000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.gtu(Rs16,Rt16); if (p1.new) jump:nt #r9:2", + 0xf7c03000, + 0x15001000, + 0x3000fe, + 0x0 + }, + { "Rdd32=combine(#s8,#U6)", + 0xff800000, + 0x7c800000, + 0x1f2000, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; if (p0.new) jumpr:nt Lr", + 0xf8003fc7, + 0x40003fc6, + 0x7f00000, + 0x1 + }, + { "p1=cmp.eq(Rs16,#U5); if (p1.new) jump:nt #r9:2", + 0xf7c02000, + 0x12000000, + 0x3000fe, + 0x0 + }, + { "Rdd32=combine(#s8,Rs32)", + 0xff602000, + 0x73202000, + 0x1fe0, + 0x0 + }, + { "p1=cmp.eq(Rs16,#-1); if (!p1.new) jump:nt #r9:2", + 0xf7c02300, + 0x13c00000, + 0x3000fe, + 0x0 + }, + { "memw(Rs32+#u6:2)=clrbit(#U5)", + 0xff602060, + 0x3f400040, + 0x1f80, + 0x0 + }, + { "if (cmp.eq(Ns8.new,#U5)) jump:t #r9:2", + 0xf7c02000, + 0x24002000, + 0x3000fe, + 0x0 + }, + { "if (Pv4) memw(#u6)=Rt32", + 0xffe02084, + 0xaf800080, + 0x30078, + 0x0 + }, + { "if (!Pv4) memb(Rs32+#u6:0)=#S6", + 0xffe00000, + 0x38800000, + 0x201f, + 0x0 + }, + { "Rd16=#u6 ; Rx16=add(Rx16,Rs16)", + 0xfc003f00, + 0x28003800, + 0x3f00000, + 0x1 + }, + { "Ryy32=memb_fifo(Rt32<<#1+#U6)", + 0xffe03080, + 0x9c801080, + 0xf60, + 0x0 + }, + { "memh(Ru32<<#1+#U6)=Rt32", + 0xffe020c0, + 0xad4000c0, + 0x3f, + 0x0 + }, + { "if (Pv4.new) memw(Rs32+#u6:2)=#S6", + 0xffe00000, + 0x39400000, + 0x201f, + 0x0 + }, + { "p1=cmp.gt(Rs16,#-1); if (!p1.new) jump:t #r9:2", + 0xf7c02300, + 0x13c02100, + 0x3000fe, + 0x0 + }, + { "memh(Ru32<<#0+#U6)=Rt32", + 0xffe020c0, + 0xad400080, + 0x3f, + 0x0 + }, + { "if (!Pt4.new) Rd32=memuh(#u6)", + 0xffe03880, + 0x9f603880, + 0x1f0100, + 0x0 + }, + { "Rx32=or(#u8,asl(Rx32,#U5))", + 0xff000016, + 0xde000002, + 0xe020e8, + 0x0 + }, + { "Re16=#U6 ; Rdd8=combine(#0,Rs16)", + 0xfc003d08, + 0x28003d00, + 0x3f00000, + 0x1 + }, + { "Re16=#u6 ; Rd16=Rs16", + 0xfc003f00, + 0x28003000, + 0x3f00000, + 0x1 + }, + { "Ryy32=memh_fifo(Rt32<<#0+#U6)", + 0xffe03080, + 0x9c401000, + 0xf60, + 0x0 + }, + { "if (!cmp.gtu(Ns8.new,Rt32)) jump:t #r9:2", + 0xf7c02000, + 0x21402000, + 0x3000fe, + 0x0 + }, + { "if (!Pu4.new) jump:nt #r15:2", + 0xff201800, + 0x5c200800, + 0xdf20fe, + 0x0 + }, + { "if (Pv4) memw(Rs32+#u6:2)=Nt8.new", + 0xffe01804, + 0x40a01000, + 0x20f8, + 0x0 + }, + { "Rd16=#U6 ; memb(Rs16+#u4:0)=#1", + 0xfc003f00, + 0x68003300, + 0x3f00000, + 0x1 + }, + { "Rd16=#U6 ; memb(Rs16+#u4:0)=#0", + 0xfc003f00, + 0x68003200, + 0x3f00000, + 0x1 + }, + { "p1=cmp.gtu(Rs16,Rt16); if (!p1.new) jump:nt #r9:2", + 0xf7c03000, + 0x15401000, + 0x3000fe, + 0x0 + }, + { "if (!Pv4) memh(Rs32+#u6:1)=Nt8.new", + 0xffe01804, + 0x44a00800, + 0x20f8, + 0x0 + }, + { "if (cmp.eq(Ns8.new,#-1)) jump:nt #r9:2", + 0xf7c02000, + 0x26000000, + 0x3000fe, + 0x0 + }, + { "Rx32=or(Ru32,and(Rx32,#s10))", + 0xffc00000, + 0xda400000, + 0x203fe0, + 0x0 + }, + { "if (Pv4) memh(Rs32+#u6:1)=Rt.H32", + 0xffe00004, + 0x40600000, + 0x20f8, + 0x0 + }, + { "memh(Re32=#U6)=Rt.H32", + 0xffe02080, + 0xab600080, + 0x3f, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; Rd16=zxth(Rs16)", + 0xf8003f00, + 0x20003600, + 0x7f00000, + 0x1 + }, + { "p0=tstbit(Rs16,#0); if (!p0.new) jump:nt #r9:2", + 0xf7c02300, + 0x11c00300, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=and(Rs16,#255)", + 0xf8003f00, + 0x20003700, + 0x7f00000, + 0x1 + }, + { "if (!tstbit(Ns8.new,#0)) jump:nt #r9:2", + 0xf7c02000, + 0x25c00000, + 0x3000fe, + 0x0 + }, + { "p0=tstbit(Rs16,#0); if (p0.new) jump:nt #r9:2", + 0xf7c02300, + 0x11800300, + 0x3000fe, + 0x0 + }, + { "if (!Pt4) Rd32=memw(#u6)", + 0xffe03880, + 0x9f802880, + 0x1f0100, + 0x0 + }, + { "Re16=#U6 ; Rd16=memb(Rs16+#u3:0)", + 0xfc003800, + 0x48003000, + 0x3f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=add(Sp,#u6:2)", + 0xf8003c00, + 0x20002c00, + 0x7f00000, + 0x1 + }, + { "p0=cmp.eq(Rs16,#U5); if (!p0.new) jump:nt #r9:2", + 0xf7c02000, + 0x10400000, + 0x3000fe, + 0x0 + }, + { "memw(Rs32+#u6:2)=setbit(#U5)", + 0xff602060, + 0x3f400060, + 0x1f80, + 0x0 + }, + { "Ryy32=memb_fifo(Rt32<<#0+#U6)", + 0xffe03080, + 0x9c801000, + 0xf60, + 0x0 + }, + { "memw(Rs32+#u6:2)&=Rt32", + 0xff602060, + 0x3e400040, + 0x1f80, + 0x0 + }, + { "p0=cmp.eq(Rs16,Rt16); if (!p0.new) jump:t #r9:2", + 0xf7c03000, + 0x14402000, + 0x3000fe, + 0x0 + }, + { "Pd4=!cmp.gtu(Rs32,#u9)", + 0xffe0001c, + 0x75800010, + 0x3fe0, + 0x0 + }, + { "Rx32=add(#u8,lsr(Rx32,#U5))", + 0xff000016, + 0xde000014, + 0xe020e8, + 0x0 + }, + { "p0=cmp.eq(Rs16,#-1); if (!p0.new) jump:t #r9:2", + 0xf7c02300, + 0x11c02000, + 0x3000fe, + 0x0 + }, + { "Pd4=cmph.gt(Rs32,#s8)", + 0xff600018, + 0xdd200008, + 0x1fe0, + 0x0 + }, + { "memh(Rs32+#u6:1)|=Rt32", + 0xff602060, + 0x3e200060, + 0x1f80, + 0x0 + }, + { "Rx32=sub(#u8,asl(Rx32,#U5))", + 0xff000016, + 0xde000006, + 0xe020e8, + 0x0 + }, + { "if (!Pv4) memh(Rs32+#u6:1)=Rt.H32", + 0xffe00004, + 0x44600000, + 0x20f8, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; memw(Sp+#u5:2)=Rt16", + 0xf8003e00, + 0x60002800, + 0x7f00000, + 0x1 + }, + { "memb(Rs32+#u6:0)=#S8", + 0xfe600000, + 0x3c000000, + 0x207f, + 0x0 + }, + { "if (!Pv4.new) memh(#u6)=Nt8.new", + 0xffe03884, + 0xafa02884, + 0x30078, + 0x0 + }, + { "p0=tstbit(Rs16,#0); if (p0.new) jump:t #r9:2", + 0xf7c02300, + 0x11802300, + 0x3000fe, + 0x0 + }, + { "if (Pv4) memb(Rs32+#u6:0)=#S6", + 0xffe00000, + 0x38000000, + 0x201f, + 0x0 + }, + { "if (Pu4) jump #r15:2", + 0xff200800, + 0x5c000000, + 0xdf20fe, + 0x0 + }, + { "p1=cmp.gtu(Rs16,#U5); if (!p1.new) jump:nt #r9:2", + 0xf7c02000, + 0x13400000, + 0x3000fe, + 0x0 + }, + { "if (!Pu4) jump #r15:2", + 0xff200800, + 0x5c200000, + 0xdf20fe, + 0x0 + }, + { "if (Pt4) Rd32=memb(Rs32+#u6:0)", + 0xffe02000, + 0x41000000, + 0x7e0, + 0x0 + }, + { "if (!Pt4) Rdd32=memd(#u6)", + 0xffe03880, + 0x9fc02880, + 0x1f0100, + 0x0 + }, + { "if (!Pv4.new) memb(Rs32+#u6:0)=Rt32", + 0xffe00004, + 0x46000000, + 0x20f8, + 0x0 + }, + { "memb(Rs32+#u6:0)-=#U5", + 0xff602060, + 0x3f000020, + 0x1f80, + 0x0 + }, + { "Re16=#U6 ; Rdd8=combine(Rs16,#0)", + 0xfc003d08, + 0x28003d08, + 0x3f00000, + 0x1 + }, + { "memh(Rs32+#u6:1)=setbit(#U5)", + 0xff602060, + 0x3f200060, + 0x1f80, + 0x0 + }, + { "memh(Ru32<<#3+#U6)=Nt8.new", + 0xffe038c0, + 0xada028c0, + 0x3f, + 0x0 + }, + { "memh(Ru32<<#1+#U6)=Nt8.new", + 0xffe038c0, + 0xada008c0, + 0x3f, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; Rd16=sxtb(Rs16)", + 0xf8003f00, + 0x20003500, + 0x7f00000, + 0x1 + }, + { "Rd16=#u6 ; dealloc_return", + 0xfc003fc4, + 0x48003f40, + 0x3f00000, + 0x1 + }, + { "memb(gp+#u16:0)=Nt8.new", + 0xf9e01800, + 0x48a00000, + 0x61f20ff, + 0x0 + }, + { "p0=cmp.gt(Rs16,Rt16); if (p0.new) jump:t #r9:2", + 0xf7c03000, + 0x14802000, + 0x3000fe, + 0x0 + }, + { "Rd16=#U6 ; p0=cmp.eq(Rs16,#u2)", + 0xfc003f00, + 0x28003900, + 0x3f00000, + 0x1 + }, + { "Rx16=add(Rx16,#s7) ; if (!p0.new) jumpr:nt Lr", + 0xf8003fc7, + 0x40003fc7, + 0x7f00000, + 0x1 + }, + { "if (!Pt4) Rd32=memh(Rs32+#u6:1)", + 0xffe02000, + 0x45400000, + 0x7e0, + 0x0 + }, + { "memh(Ru32<<#2+#U6)=Nt8.new", + 0xffe038c0, + 0xada02880, + 0x3f, + 0x0 + }, + { "if (Pv4.new) memb(#u6)=Rt32", + 0xffe02084, + 0xaf002080, + 0x30078, + 0x0 + }, + { "if (!Pt4.new) Rd32=memw(#u6)", + 0xffe03880, + 0x9f803880, + 0x1f0100, + 0x0 + }, + { "p0=cmp.gtu(Rs16,Rt16); if (p0.new) jump:nt #r9:2", + 0xf7c03000, + 0x15000000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; Rd16=and(Rs16,#255)", + 0xfc003f00, + 0x28003700, + 0x3f00000, + 0x1 + }, + { "Re16=#u6 ; Rd16=zxth(Rs16)", + 0xfc003f00, + 0x28003600, + 0x3f00000, + 0x1 + }, + { "if (!Pt4.new) Rd32=memub(Rs32+#u6:0)", + 0xffe02000, + 0x47200000, + 0x7e0, + 0x0 + }, + { "memb(Re32=#U6)=Nt8.new", + 0xffe03880, + 0xaba00080, + 0x3f, + 0x0 + }, + { "if (Pv4) memd(#u6)=Rtt32", + 0xffe02084, + 0xafc00080, + 0x30078, + 0x0 + }, + { "Rd32=mux(Pu4,#s8,Rs32)", + 0xff802000, + 0x73800000, + 0x1fe0, + 0x0 + }, + { "if (!Pt4) Rd32=memub(#u6)", + 0xffe03880, + 0x9f202880, + 0x1f0100, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rdd8=combine(#0,#u2)", + 0xf8003d18, + 0x20003c00, + 0x7f00000, + 0x1 + }, + { "memh(Rs32+#s11:1)=Rt.H32", + 0xf9e00000, + 0xa1600000, + 0x60020ff, + 0x0 + }, + { "if (!Pv4) memw(Rs32+#u6:2)=Rt32", + 0xffe00004, + 0x44800000, + 0x20f8, + 0x0 + }, + { "if (cmp.gt(Rt32,Ns8.new)) jump:t #r9:2", + 0xf7c02000, + 0x21802000, + 0x3000fe, + 0x0 + }, + { "Rd32=add(#u6,mpyi(Rs32,#U6))", + 0xff000000, + 0xd8000000, + 0x6020e0, + 0x0 + }, + { "memb(Rs32+#s11:0)=Rt32", + 0xf9e00000, + 0xa1000000, + 0x60020ff, + 0x0 + }, + { "if (!Pv4) memb(#u6)=Nt8.new", + 0xffe03884, + 0xafa00084, + 0x30078, + 0x0 + }, + { "if (!Pu4.new) jump:t #r15:2", + 0xff201800, + 0x5c201800, + 0xdf20fe, + 0x0 + }, + { "Rx32=and(#u8,lsr(Rx32,#U5))", + 0xff000016, + 0xde000010, + 0xe020e8, + 0x0 + }, + { "if (Pt4.new) Rd32=memuh(#u6)", + 0xffe03880, + 0x9f603080, + 0x1f0100, + 0x0 + }, + { "if (Pt4) Rdd32=memd(Rs32+#u6:3)", + 0xffe02000, + 0x41c00000, + 0x7e0, + 0x0 + }, + { "if (!cmp.eq(Ns8.new,Rt32)) jump:t #r9:2", + 0xf7c02000, + 0x20402000, + 0x3000fe, + 0x0 + }, + { "Rx32+=mpyi(Rs32,#u8)", + 0xff800000, + 0xe1000000, + 0x1fe0, + 0x0 + }, + { "memh(Rs32+#s11:1)=Rt32", + 0xf9e00000, + 0xa1400000, + 0x60020ff, + 0x0 + }, + { "p0=cmp.gt(Rs16,Rt16); if (!p0.new) jump:nt #r9:2", + 0xf7c03000, + 0x14c00000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; if (!p0.new) dealloc_return:nt", + 0xf8003fc7, + 0x40003f47, + 0x7f00000, + 0x1 + }, + { "if (Pv4) memw(Rs32+#u6:2)=Rt32", + 0xffe00004, + 0x40800000, + 0x20f8, + 0x0 + }, + { "Rx32-=mpyi(Rs32,#u8)", + 0xff800000, + 0xe1800000, + 0x1fe0, + 0x0 + }, + { "p0=cmp.gt(Rs16,#-1); if (p0.new) jump:t #r9:2", + 0xf7c02300, + 0x11802100, + 0x3000fe, + 0x0 + }, + { "Rd32=memw(gp+#u16:2)", + 0xf9e00000, + 0x49800000, + 0x61f3fe0, + 0x0 + }, + { "if (!cmp.eq(Ns8.new,#-1)) jump:nt #r9:2", + 0xf7c02000, + 0x26400000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=#u6", + 0xf8003c00, + 0x20002800, + 0x7f00000, + 0x1 + }, + { "if (Pu4.new) Rd32=#s12", + 0xff902000, + 0x7e002000, + 0xf1fe0, + 0x0 + }, + { "if (!Pu4.new) Rd32=#s12", + 0xff902000, + 0x7e802000, + 0xf1fe0, + 0x0 + }, + { "Rdd32=memd(Rs32+#s11:3)", + 0xf9e00000, + 0x91c00000, + 0x6003fe0, + 0x0 + }, + { "if (Pv4.new) memh(#u6)=Nt8.new", + 0xffe03884, + 0xafa02880, + 0x30078, + 0x0 + }, + { "if (cmp.gtu(Rt32,Ns8.new)) jump:nt #r9:2", + 0xf7c02000, + 0x22000000, + 0x3000fe, + 0x0 + }, + { "Rd32=memub(Rt32<<#2+#U6)", + 0xffe03080, + 0x9d203000, + 0xf60, + 0x0 + }, + { "if (cmp.eq(Ns8.new,#-1)) jump:t #r9:2", + 0xf7c02000, + 0x26002000, + 0x3000fe, + 0x0 + }, + { "Rx32+=add(Rs32,#s8)", + 0xff800000, + 0xe2000000, + 0x1fe0, + 0x0 + }, + { "if (!cmp.gt(Ns8.new,#-1)) jump:nt #r9:2", + 0xf7c02000, + 0x26c00000, + 0x3000fe, + 0x0 + }, + { "memw(Rs32+#u6:2)+=Rt32", + 0xff602060, + 0x3e400000, + 0x1f80, + 0x0 + }, + { "if (Pv4) memw(Rs32+#u6:2)=#S6", + 0xffe00000, + 0x38400000, + 0x201f, + 0x0 + }, + { "Re16=#U6 ; Rd16=memh(Rs16+#u3:1)", + 0xfc003800, + 0x48002000, + 0x3f00000, + 0x1 + }, + { "Rx32=and(#u8,asl(Rx32,#U5))", + 0xff000016, + 0xde000000, + 0xe020e8, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; Rd16=Rs16", + 0xf8003f00, + 0x20003000, + 0x7f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; if (p0) Rd16=#0", + 0xf8003e70, + 0x20003a60, + 0x7f00000, + 0x1 + }, + { "if (!Pu4) Rd32=#s12", + 0xff902000, + 0x7e800000, + 0xf1fe0, + 0x0 + }, + { "memh(Ru32<<#3+#U6)=Rt.H32", + 0xffe020c0, + 0xad6020c0, + 0x3f, + 0x0 + }, + { "p1=cmp.eq(Rs16,#-1); if (p1.new) jump:t #r9:2", + 0xf7c02300, + 0x13802000, + 0x3000fe, + 0x0 + }, + { "memh(Ru32<<#0+#U6)=Rt.H32", + 0xffe020c0, + 0xad600080, + 0x3f, + 0x0 + }, + { "if (Pu4) Rd32=#s12", + 0xff902000, + 0x7e000000, + 0xf1fe0, + 0x0 + }, + { "Rd16=Rs16 ; jump #r9:2", + 0xf7000000, + 0x17000000, + 0x3000fe, + 0x0 + }, + { "Rd16=#U6 ; jump #r9:2", + 0xf7000000, + 0x16000000, + 0x3000fe, + 0x0 + }, + { "if (cmp.gtu(Ns8.new,#U5)) jump:t #r9:2", + 0xf7c02000, + 0x25002000, + 0x3000fe, + 0x0 + }, + { "Rd16=#u6 ; if (!p0.new) jumpr:nt Lr", + 0xfc003fc7, + 0x48003fc7, + 0x3f00000, + 0x1 + }, + { "if (Rs32==#0) jump:t #r13:2", + 0xffc01000, + 0x61801000, + 0x202ffe, + 0x0 + }, + { "if (Pv4.new) memw(#u6)=Nt8.new", + 0xffe03884, + 0xafa03080, + 0x30078, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; dealloc_return", + 0xf8003fc4, + 0x40003f40, + 0x7f00000, + 0x1 + }, + { "Re16=#U6 ; if (p0) Rd16=#0", + 0xfc003e70, + 0x28003a60, + 0x3f00000, + 0x1 + }, + { "p1=cmp.eq(Rs16,#-1); if (p1.new) jump:nt #r9:2", + 0xf7c02300, + 0x13800000, + 0x3000fe, + 0x0 + }, + { "if (Pt4) Rd32=memw(#u6)", + 0xffe03880, + 0x9f802080, + 0x1f0100, + 0x0 + }, + { "Rd32=add(Rs32,#s16)", + 0xf0000000, + 0xb0000000, + 0xfe03fe0, + 0x0 + }, + { "if (Pt4) Rd32=memh(#u6)", + 0xffe03880, + 0x9f402080, + 0x1f0100, + 0x0 + }, + { "if (Pt4.new) Rd32=memub(Rs32+#u6:0)", + 0xffe02000, + 0x43200000, + 0x7e0, + 0x0 + }, + { "if (!Pv4.new) memb(Rs32+#u6:0)=#S6", + 0xffe00000, + 0x39800000, + 0x201f, + 0x0 + }, + { "if (!Pt4.new) Rdd32=memd(#u6)", + 0xffe03880, + 0x9fc03880, + 0x1f0100, + 0x0 + }, + { "if (!Pt4) Rd32=memuh(Rs32+#u6:1)", + 0xffe02000, + 0x45600000, + 0x7e0, + 0x0 + }, + { "Rd32=memub(Rs32+#s11:0)", + 0xf9e00000, + 0x91200000, + 0x6003fe0, + 0x0 + }, + { "if (Pt4.new) Rd32=memuh(Rs32+#u6:1)", + 0xffe02000, + 0x43600000, + 0x7e0, + 0x0 + }, + { "Rd16=#u6 ; Rx16=add(Rs16,Rx16)", + 0xfc003f00, + 0x28003800, + 0x3f00000, + 0x1 + }, + { "if (Pu4) Rd32=add(Rs32,#s8)", + 0xff802000, + 0x74000000, + 0x1fe0, + 0x0 + }, + { "if (!Pv4.new) memb(#u6)=Rt32", + 0xffe02084, + 0xaf002084, + 0x30078, + 0x0 + }, + { "if (!Pu4) Rd32=add(Rs32,#s8)", + 0xff802000, + 0x74800000, + 0x1fe0, + 0x0 + }, + { "p0=cmp.gt(Rs16,Rt16); if (!p0.new) jump:t #r9:2", + 0xf7c03000, + 0x14c02000, + 0x3000fe, + 0x0 + }, + { "call #r22:2", + 0xfe000001, + 0x5a000000, + 0x1ff3ffe, + 0x0 + }, + { "memw(Rs32+#u6:2)-=#U5", + 0xff602060, + 0x3f400020, + 0x1f80, + 0x0 + }, + { "p0=cmp.gt(Rs16,#U5); if (p0.new) jump:t #r9:2", + 0xf7c02000, + 0x10802000, + 0x3000fe, + 0x0 + }, + { "if (Pv4.new) memw(#u6)=Rt32", + 0xffe02084, + 0xaf802080, + 0x30078, + 0x0 + }, + { "if (!Pv4.new) memh(Rs32+#u6:1)=Rt32", + 0xffe00004, + 0x46400000, + 0x20f8, + 0x0 + }, + { "memw(Ru32<<#0+#U6)=Rt32", + 0xffe020c0, + 0xad800080, + 0x3f, + 0x0 + }, + { "memw(Ru32<<#1+#U6)=Rt32", + 0xffe020c0, + 0xad8000c0, + 0x3f, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; if (!p0) dealloc_return", + 0xf8003fc7, + 0x40003f45, + 0x7f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; memd(Sp+#s6:3)=Rtt8", + 0xf8003e00, + 0x60002a00, + 0x7f00000, + 0x1 + }, + { "if (!Pv4) memh(#u6)=Rt.H32", + 0xffe02084, + 0xaf600084, + 0x30078, + 0x0 + }, + { "Rd32=membh(Rt32<<#0+#U6)", + 0xffe03080, + 0x9c201000, + 0xf60, + 0x0 + }, + { "if (Pt4.new) Rd32=memh(Rs32+#u6:1)", + 0xffe02000, + 0x43400000, + 0x7e0, + 0x0 + }, + { "Rd32=membh(Rt32<<#3+#U6)", + 0xffe03080, + 0x9c203080, + 0xf60, + 0x0 + }, + { "if (Pt4) Rd32=memub(Rs32+#u6:0)", + 0xffe02000, + 0x41200000, + 0x7e0, + 0x0 + }, + { "Rd32=membh(Rt32<<#1+#U6)", + 0xffe03080, + 0x9c201080, + 0xf60, + 0x0 + }, + { "p0=tstbit(Rs16,#0); if (!p0.new) jump:t #r9:2", + 0xf7c02300, + 0x11c02300, + 0x3000fe, + 0x0 + }, + { "if (Pt4.new) Rdd32=memd(#u6)", + 0xffe03880, + 0x9fc03080, + 0x1f0100, + 0x0 + }, + { "if (!Pt4) Rd32=memh(#u6)", + 0xffe03880, + 0x9f402880, + 0x1f0100, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=memh(Rs16+#u3:1)", + 0xf8003800, + 0x40002000, + 0x7f00000, + 0x1 + }, + { "if (!cmp.eq(Ns8.new,#U5)) jump:t #r9:2", + 0xf7c02000, + 0x24402000, + 0x3000fe, + 0x0 + }, + { "if (!cmp.gt(Ns8.new,Rt32)) jump:t #r9:2", + 0xf7c02000, + 0x20c02000, + 0x3000fe, + 0x0 + }, + { "p0=cmp.eq(Rs16,#-1); if (!p0.new) jump:nt #r9:2", + 0xf7c02300, + 0x11c00000, + 0x3000fe, + 0x0 + }, + { "if (!Pt4) Rd32=memub(Rs32+#u6:0)", + 0xffe02000, + 0x45200000, + 0x7e0, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; p0=cmp.eq(Rs16,#u2)", + 0xf8003f00, + 0x20003900, + 0x7f00000, + 0x1 + }, + { "p0=cmp.gt(Rs16,#-1); if (!p0.new) jump:nt #r9:2", + 0xf7c02300, + 0x11c00100, + 0x3000fe, + 0x0 + }, + { "if (!Pv4) memw(#u6)=Rt32", + 0xffe02084, + 0xaf800084, + 0x30078, + 0x0 + }, + { "memh(Rs32+#u6:1)=#S8", + 0xfe600000, + 0x3c200000, + 0x207f, + 0x0 + }, + { "if (cmp.gt(Ns8.new,#-1)) jump:nt #r9:2", + 0xf7c02000, + 0x26800000, + 0x3000fe, + 0x0 + }, + { "if (Pt4.new) Rd32=memb(#u6)", + 0xffe03880, + 0x9f003080, + 0x1f0100, + 0x0 + }, + { "if (!Pv4) memw(#u6)=Nt8.new", + 0xffe03884, + 0xafa01084, + 0x30078, + 0x0 + }, + { "Rd32=and(Rs32,#s10)", + 0xffc00000, + 0x76000000, + 0x203fe0, + 0x0 + }, + { "memb(Rs32+#u6:0)&=Rt32", + 0xff602060, + 0x3e000040, + 0x1f80, + 0x0 + }, + { "memd(Ru32<<#3+#U6)=Rtt32", + 0xffe020c0, + 0xadc020c0, + 0x3f, + 0x0 + }, + { "if (!Pv4) memh(Rs32+#u6:1)=Rt32", + 0xffe00004, + 0x44400000, + 0x20f8, + 0x0 + }, + { "memd(Ru32<<#2+#U6)=Rtt32", + 0xffe020c0, + 0xadc02080, + 0x3f, + 0x0 + }, + { "memw(Rs32+#u6:2)=#S8", + 0xfe600000, + 0x3c400000, + 0x207f, + 0x0 + }, + { "if (!cmp.eq(Ns8.new,Rt32)) jump:nt #r9:2", + 0xf7c02000, + 0x20400000, + 0x3000fe, + 0x0 + }, + { "Rdd32=combine(#s8,#S8)", + 0xff800000, + 0x7c000000, + 0x1fe0, + 0x0 + }, + { "if (Pv4) memb(#u6)=Nt8.new", + 0xffe03884, + 0xafa00080, + 0x30078, + 0x0 + }, + { "if (Pu4.new) jump:t #r15:2", + 0xff201800, + 0x5c001800, + 0xdf20fe, + 0x0 + }, + { "if (!Pt4.new) Rd32=memw(Rs32+#u6:2)", + 0xffe02000, + 0x47800000, + 0x7e0, + 0x0 + }, + { "Pd4=cmpb.gtu(Rs32,#u7)", + 0xff601018, + 0xdd400000, + 0xfe0, + 0x0 + }, + { "memh(Ru32<<#3+#U6)=Rt32", + 0xffe020c0, + 0xad4020c0, + 0x3f, + 0x0 + }, + { "memh(Ru32<<#2+#U6)=Rt32", + 0xffe020c0, + 0xad402080, + 0x3f, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=memub(Rs16+#u4:0)", + 0xf8003000, + 0x40001000, + 0x7f00000, + 0x1 + }, + { "if (!Pv4.new) memd(#u6)=Rtt32", + 0xffe02084, + 0xafc02084, + 0x30078, + 0x0 + }, + { "Ryy32=memh_fifo(Rt32<<#3+#U6)", + 0xffe03080, + 0x9c403080, + 0xf60, + 0x0 + }, + { "Re16=#U6 ; Rd16=#-1", + 0xfc003e40, + 0x28003a00, + 0x3f00000, + 0x1 + }, + { "memw(Ru32<<#1+#U6)=Nt8.new", + 0xffe038c0, + 0xada010c0, + 0x3f, + 0x0 + }, + { "memw(Ru32<<#0+#U6)=Nt8.new", + 0xffe038c0, + 0xada01080, + 0x3f, + 0x0 + }, + { "memw(Ru32<<#3+#U6)=Nt8.new", + 0xffe038c0, + 0xada030c0, + 0x3f, + 0x0 + }, + { "memw(Ru32<<#2+#U6)=Nt8.new", + 0xffe038c0, + 0xada03080, + 0x3f, + 0x0 + }, + { "if (cmp.gt(Ns8.new,Rt32)) jump:nt #r9:2", + 0xf7c02000, + 0x20800000, + 0x3000fe, + 0x0 + }, + { "Rd16=#u6 ; if (p0.new) dealloc_return:nt", + 0xfc003fc7, + 0x48003f46, + 0x3f00000, + 0x1 + }, + { "if (!Pv4) memb(Rs32+#u6:0)=Nt8.new", + 0xffe01804, + 0x44a00000, + 0x20f8, + 0x0 + }, + { "if (cmp.eq(Ns8.new,Rt32)) jump:t #r9:2", + 0xf7c02000, + 0x20002000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.gt(Rs16,#U5); if (!p1.new) jump:t #r9:2", + 0xf7c02000, + 0x12c02000, + 0x3000fe, + 0x0 + }, + { "Rd32=memubh(Re32=#U6)", + 0xffe03000, + 0x9a601000, + 0xf60, + 0x0 + }, + { "Rx32|=or(Rs32,#s10)", + 0xffc00000, + 0xda800000, + 0x203fe0, + 0x0 + }, + { "Ryy32=memh_fifo(Rs32+#s11:1)", + 0xf9e00000, + 0x90400000, + 0x6003fe0, + 0x0 + }, + { "if (!Pt4.new) Rd32=memuh(Rs32+#u6:1)", + 0xffe02000, + 0x47600000, + 0x7e0, + 0x0 + }, + { "Rd32=memh(Rt32<<#2+#U6)", + 0xffe03080, + 0x9d403000, + 0xf60, + 0x0 + }, + { "Rd32=memh(Rt32<<#3+#U6)", + 0xffe03080, + 0x9d403080, + 0xf60, + 0x0 + }, + { "Rd32=memh(Rt32<<#0+#U6)", + 0xffe03080, + 0x9d401000, + 0xf60, + 0x0 + }, + { "Rd32=memh(Rt32<<#1+#U6)", + 0xffe03080, + 0x9d401080, + 0xf60, + 0x0 + }, + { "if (Pt4) Rd32=memh(Rs32+#u6:1)", + 0xffe02000, + 0x41400000, + 0x7e0, + 0x0 + }, + { "Rd32=add(Ru32,mpyi(Rs32,#u6))", + 0xff800000, + 0xdf800000, + 0x6020e0, + 0x0 + }, + { "if (Rs32!=#0) jump:nt #r13:2", + 0xffc01000, + 0x61000000, + 0x202ffe, + 0x0 + }, + { "if (Pt4) Rd32=memub(#u6)", + 0xffe03880, + 0x9f202080, + 0x1f0100, + 0x0 + }, + { "Rd16=#u6 ; if (p0.new) jumpr:nt Lr", + 0xfc003fc7, + 0x48003fc6, + 0x3f00000, + 0x1 + }, + { "Rd32=mux(Pu4,#s8,#S8)", + 0xfe000000, + 0x7a000000, + 0x1fe0, + 0x0 + }, + { "Rd32=add(pc,#u6)", + 0xffff0000, + 0x6a490000, + 0x1f80, + 0x0 + }, + { "Rd32=mux(Pu4,Rs32,#s8)", + 0xff802000, + 0x73000000, + 0x1fe0, + 0x0 + }, + { "memh(Rs32+#u6:1)-=Rt32", + 0xff602060, + 0x3e200020, + 0x1f80, + 0x0 + }, + { "if (cmp.eq(Ns8.new,#U5)) jump:nt #r9:2", + 0xf7c02000, + 0x24000000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=#-1", + 0xf8003e40, + 0x20003a00, + 0x7f00000, + 0x1 + }, + { "p1=cmp.eq(Rs16,Rt16); if (!p1.new) jump:nt #r9:2", + 0xf7c03000, + 0x14401000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rd16=and(Rs16,#1)", + 0xf8003f00, + 0x20003200, + 0x7f00000, + 0x1 + }, + { "Rd32=sub(#s10,Rs32)", + 0xffc00000, + 0x76400000, + 0x203fe0, + 0x0 + }, + { "if (cmp.gtu(Rt32,Ns8.new)) jump:t #r9:2", + 0xf7c02000, + 0x22002000, + 0x3000fe, + 0x0 + }, + { "if (Rs32<=#0) jump:t #r13:2", + 0xffc01000, + 0x61c01000, + 0x202ffe, + 0x0 + }, + { "p1=cmp.gt(Rs16,Rt16); if (p1.new) jump:nt #r9:2", + 0xf7c03000, + 0x14801000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.eq(Rs16,#U5); if (p1.new) jump:t #r9:2", + 0xf7c02000, + 0x12002000, + 0x3000fe, + 0x0 + }, + { "p0=cmp.eq(Rs16,#U5); if (!p0.new) jump:t #r9:2", + 0xf7c02000, + 0x10402000, + 0x3000fe, + 0x0 + }, + { "if (!Pu4) call #r15:2", + 0xff201800, + 0x5d200000, + 0xdf20fe, + 0x0 + }, + { "if (!cmp.gtu(Ns8.new,Rt32)) jump:nt #r9:2", + 0xf7c02000, + 0x21400000, + 0x3000fe, + 0x0 + }, + { "if (Pu4) call #r15:2", + 0xff201800, + 0x5d000000, + 0xdf20fe, + 0x0 + }, + { "if (!Pt4) Rdd32=memd(Rs32+#u6:3)", + 0xffe02000, + 0x45c00000, + 0x7e0, + 0x0 + }, + { "if (tstbit(Ns8.new,#0)) jump:t #r9:2", + 0xf7c02000, + 0x25802000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; if (!p0.new) Rd16=#0", + 0xfc003e70, + 0x28003a50, + 0x3f00000, + 0x1 + }, + { "p1=tstbit(Rs16,#0); if (!p1.new) jump:nt #r9:2", + 0xf7c02300, + 0x13c00300, + 0x3000fe, + 0x0 + }, + { "memh(Rs32+#s11:1)=Nt8.new", + 0xf9e01800, + 0xa1a00800, + 0x60020ff, + 0x0 + }, + { "if (Pt4.new) Rd32=memw(Rs32+#u6:2)", + 0xffe02000, + 0x43800000, + 0x7e0, + 0x0 + }, + { "Rd16=#u6 ; jumpr Lr", + 0xfc003fc4, + 0x48003fc0, + 0x3f00000, + 0x1 + }, + { "Rx32-=add(Rs32,#s8)", + 0xff800000, + 0xe2800000, + 0x1fe0, + 0x0 + }, + { "p1=cmp.eq(Rs16,#-1); if (!p1.new) jump:t #r9:2", + 0xf7c02300, + 0x13c02000, + 0x3000fe, + 0x0 + }, + { "Rd32=memw(Rt32<<#3+#U6)", + 0xffe03080, + 0x9d803080, + 0xf60, + 0x0 + }, + { "Rd32=memw(Rt32<<#2+#U6)", + 0xffe03080, + 0x9d803000, + 0xf60, + 0x0 + }, + { "Rd32=memw(Rt32<<#1+#U6)", + 0xffe03080, + 0x9d801080, + 0xf60, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; deallocframe", + 0xf8003fc4, + 0x40003f00, + 0x7f00000, + 0x1 + }, + { "if (!Pv4.new) memw(Rs32+#u6:2)=#S6", + 0xffe00000, + 0x39c00000, + 0x201f, + 0x0 + }, + { "Rd32=memub(Rt32<<#3+#U6)", + 0xffe03080, + 0x9d203080, + 0xf60, + 0x0 + }, + { "memb(Re32=#U6)=Rt32", + 0xffe02080, + 0xab000080, + 0x3f, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; allocframe(#u5:3)", + 0xf8003e00, + 0x60003c00, + 0x7f00000, + 0x1 + }, + { "if (Pt4) Rd32=memuh(#u6)", + 0xffe03880, + 0x9f602080, + 0x1f0100, + 0x0 + }, + { "Rd32=or(Rs32,#s10)", + 0xffc00000, + 0x76800000, + 0x203fe0, + 0x0 + }, + { "if (!Pv4.new) memb(#u6)=Nt8.new", + 0xffe03884, + 0xafa02084, + 0x30078, + 0x0 + }, + { "p1=cmp.gtu(Rs16,#U5); if (p1.new) jump:t #r9:2", + 0xf7c02000, + 0x13002000, + 0x3000fe, + 0x0 + }, + { "Rd32=memb(Rs32+#s11:0)", + 0xf9e00000, + 0x91000000, + 0x6003fe0, + 0x0 + }, + { "Rd32=memub(Rt32<<#1+#U6)", + 0xffe03080, + 0x9d201080, + 0xf60, + 0x0 + }, + { "p0=cmp.gtu(Rs16,Rt16); if (p0.new) jump:t #r9:2", + 0xf7c03000, + 0x15002000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; memw(Rs16+#u4:2)=Rt16", + 0xf8003000, + 0x60000000, + 0x7f00000, + 0x1 + }, + { "if (Rs32==#0) jump:nt #r13:2", + 0xffc01000, + 0x61800000, + 0x202ffe, + 0x0 + }, + { "p0=cmp.eq(Rs16,Rt16); if (!p0.new) jump:nt #r9:2", + 0xf7c03000, + 0x14400000, + 0x3000fe, + 0x0 + }, + { "Rd32=memh(Re32=#U6)", + 0xffe03000, + 0x9b401000, + 0xf60, + 0x0 + }, + { "p1=cmp.eq(Rs16,Rt16); if (p1.new) jump:t #r9:2", + 0xf7c03000, + 0x14003000, + 0x3000fe, + 0x0 + }, + { "if (Pt4) Rdd32=memd(#u6)", + 0xffe03880, + 0x9fc02080, + 0x1f0100, + 0x0 + }, + { "Rd16=#u6 ; deallocframe", + 0xfc003fc4, + 0x48003f00, + 0x3f00000, + 0x1 + }, + { "if (!Pt4) Rd32=memb(Rs32+#u6:0)", + 0xffe02000, + 0x45000000, + 0x7e0, + 0x0 + }, + { "Re16=#U6 ; Rd16=memuh(Rs16+#u3:1)", + 0xfc003800, + 0x48002800, + 0x3f00000, + 0x1 + }, + { "Rd16=#u6 ; if (!p0) jumpr Lr", + 0xfc003fc7, + 0x48003fc5, + 0x3f00000, + 0x1 + }, + { "Re16=#U6 ; Rdd8=combine(#0,#u2)", + 0xfc003d18, + 0x28003c00, + 0x3f00000, + 0x1 + }, + { "Rd16=#u6 ; if (p0) jumpr Lr", + 0xfc003fc7, + 0x48003fc4, + 0x3f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; memb(Rs16+#u4:0)=#0", + 0xf8003f00, + 0x60003200, + 0x7f00000, + 0x1 + }, + { "if (Pv4) memh(#u6)=Rt.H32", + 0xffe02084, + 0xaf600080, + 0x30078, + 0x0 + }, + { "memb(Rs32+#s11:0)=Nt8.new", + 0xf9e01800, + 0xa1a00000, + 0x60020ff, + 0x0 + }, + { "p1=cmp.eq(Rs16,Rt16); if (p1.new) jump:nt #r9:2", + 0xf7c03000, + 0x14001000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.gt(Rs16,Rt16); if (!p1.new) jump:nt #r9:2", + 0xf7c03000, + 0x14c01000, + 0x3000fe, + 0x0 + }, + { "if (!Pv4.new) memd(Rs32+#u6:3)=Rtt32", + 0xffe00004, + 0x46c00000, + 0x20f8, + 0x0 + }, + { "p1=cmp.gtu(Rs16,Rt16); if (p1.new) jump:t #r9:2", + 0xf7c03000, + 0x15003000, + 0x3000fe, + 0x0 + }, + { "p0=cmp.eq(Rs16,#U5); if (p0.new) jump:nt #r9:2", + 0xf7c02000, + 0x10000000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; Rdd8=combine(#1,#u2)", + 0xf8003d18, + 0x20003c08, + 0x7f00000, + 0x1 + }, + { "Pd4=!cmp.gt(Rs32,#s10)", + 0xffc0001c, + 0x75400010, + 0x203fe0, + 0x0 + }, + { "memh(gp+#u16:1)=Rt.H32", + 0xf9e00000, + 0x48600000, + 0x61f20ff, + 0x0 + }, + { "Rd32=memubh(Rt32<<#3+#U6)", + 0xffe03080, + 0x9c603080, + 0xf60, + 0x0 + }, + { "jump #r22:2", + 0xfe000000, + 0x58000000, + 0x1ff3ffe, + 0x0 + }, + { "Rd32=membh(Re32=#U6)", + 0xffe03000, + 0x9a201000, + 0xf60, + 0x0 + }, + { "p3=sp3loop0(#r7:2,#U10)", + 0xffe00000, + 0x69e00000, + 0x1f18, + 0x0 + }, + { "memw(Ru32<<#2+#U6)=Rt32", + 0xffe020c0, + 0xad802080, + 0x3f, + 0x0 + }, + { "if (!Pt4.new) Rdd32=memd(Rs32+#u6:3)", + 0xffe02000, + 0x47c00000, + 0x7e0, + 0x0 + }, + { "p3=sp3loop0(#r7:2,Rs32)", + 0xffe00000, + 0x60e00000, + 0x1f18, + 0x0 + }, + { "p0=cmp.gtu(Rs16,Rt16); if (!p0.new) jump:t #r9:2", + 0xf7c03000, + 0x15402000, + 0x3000fe, + 0x0 + }, + { "memw(Ru32<<#3+#U6)=Rt32", + 0xffe020c0, + 0xad8020c0, + 0x3f, + 0x0 + }, + { "Rx32=or(#u8,lsr(Rx32,#U5))", + 0xff000016, + 0xde000012, + 0xe020e8, + 0x0 + }, + { "if (!tstbit(Ns8.new,#0)) jump:t #r9:2", + 0xf7c02000, + 0x25c02000, + 0x3000fe, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; memw(Rs16+#u4:2)=#1", + 0xf8003f00, + 0x60003100, + 0x7f00000, + 0x1 + }, + { "Rx16=add(Rx16,#S7) ; memw(Rs16+#u4:2)=#0", + 0xf8003f00, + 0x60003000, + 0x7f00000, + 0x1 + }, + { "if (tstbit(Ns8.new,#0)) jump:nt #r9:2", + 0xf7c02000, + 0x25800000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.eq(Rs16,Rt16); if (!p1.new) jump:t #r9:2", + 0xf7c03000, + 0x14403000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; Rdd8=combine(#1,#u2)", + 0xfc003d18, + 0x28003c08, + 0x3f00000, + 0x1 + }, + { "if (Pt4.new) Rd32=memh(#u6)", + 0xffe03880, + 0x9f403080, + 0x1f0100, + 0x0 + }, + { "if (!cmp.gtu(Ns8.new,#U5)) jump:t #r9:2", + 0xf7c02000, + 0x25402000, + 0x3000fe, + 0x0 + }, + { "p0=cmp.gt(Rs16,#U5); if (!p0.new) jump:nt #r9:2", + 0xf7c02000, + 0x10c00000, + 0x3000fe, + 0x0 + }, + { "if (!Pt4) Rd32=memw(Rs32+#u6:2)", + 0xffe02000, + 0x45800000, + 0x7e0, + 0x0 + }, + { "if (Pt4.new) Rd32=memw(#u6)", + 0xffe03880, + 0x9f803080, + 0x1f0100, + 0x0 + }, + { "Rd32=memb(Rt32<<#0+#U6)", + 0xffe03080, + 0x9d001000, + 0xf60, + 0x0 + }, + { "Rd32=memb(Rt32<<#1+#U6)", + 0xffe03080, + 0x9d001080, + 0xf60, + 0x0 + }, + { "Rd32=memb(Rt32<<#2+#U6)", + 0xffe03080, + 0x9d003000, + 0xf60, + 0x0 + }, + { "Rd32=memb(Rt32<<#3+#U6)", + 0xffe03080, + 0x9d003080, + 0xf60, + 0x0 + }, + { "Rd32=memw(Rt32<<#0+#U6)", + 0xffe03080, + 0x9d801000, + 0xf60, + 0x0 + }, + { "Rd32=memub(gp+#u16:0)", + 0xf9e00000, + 0x49200000, + 0x61f3fe0, + 0x0 + }, + { "memd(Rs32+#s11:3)=Rtt32", + 0xf9e00000, + 0xa1c00000, + 0x60020ff, + 0x0 + }, + { "Rd32=membh(Rs32+#s11:1)", + 0xf9e00000, + 0x90200000, + 0x6003fe0, + 0x0 + }, + { "Rd32=memub(Rt32<<#0+#U6)", + 0xffe03080, + 0x9d201000, + 0xf60, + 0x0 + }, + { "if (Pv4) memw(#u6)=Nt8.new", + 0xffe03884, + 0xafa01080, + 0x30078, + 0x0 + }, + { "if (Pv4.new) memh(#u6)=Rt.H32", + 0xffe02084, + 0xaf602080, + 0x30078, + 0x0 + }, + { "memb(Ru32<<#1+#U6)=Nt8.new", + 0xffe038c0, + 0xada000c0, + 0x3f, + 0x0 + }, + { "memh(Re32=#U6)=Rt32", + 0xffe02080, + 0xab400080, + 0x3f, + 0x0 + }, + { "Rx32=add(#u8,asl(Rx32,#U5))", + 0xff000016, + 0xde000004, + 0xe020e8, + 0x0 + }, + { "if (!Pv4) memb(Rs32+#u6:0)=Rt32", + 0xffe00004, + 0x44000000, + 0x20f8, + 0x0 + }, + { "if (cmp.eq(Ns8.new,Rt32)) jump:nt #r9:2", + 0xf7c02000, + 0x20000000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; Rdd8=combine(#2,#u2)", + 0xfc003d18, + 0x28003c10, + 0x3f00000, + 0x1 + }, + { "Pd4=cmph.eq(Rs32,#s8)", + 0xff600018, + 0xdd000008, + 0x1fe0, + 0x0 + }, + { "memd(Ru32<<#1+#U6)=Rtt32", + 0xffe020c0, + 0xadc000c0, + 0x3f, + 0x0 + }, + { "memd(Ru32<<#0+#U6)=Rtt32", + 0xffe020c0, + 0xadc00080, + 0x3f, + 0x0 + }, + { "Rd32=memw(Re32=#U6)", + 0xffe03000, + 0x9b801000, + 0xf60, + 0x0 + }, + { "Rx16=add(Rx16,#s7) ; if (p0.new) dealloc_return:nt", + 0xf8003fc7, + 0x40003f46, + 0x7f00000, + 0x1 + }, + { "if (!cmp.gt(Rt32,Ns8.new)) jump:t #r9:2", + 0xf7c02000, + 0x21c02000, + 0x3000fe, + 0x0 + }, + { "if (Pv4) memb(Rs32+#u6:0)=Nt8.new", + 0xffe01804, + 0x40a00000, + 0x20f8, + 0x0 + }, + { "if (!cmp.eq(Ns8.new,#-1)) jump:t #r9:2", + 0xf7c02000, + 0x26402000, + 0x3000fe, + 0x0 + }, + { "Ryy32=memh_fifo(Rt32<<#1+#U6)", + 0xffe03080, + 0x9c401080, + 0xf60, + 0x0 + }, + { "if (Pv4.new) memh(Rs32+#u6:1)=#S6", + 0xffe00000, + 0x39200000, + 0x201f, + 0x0 + }, + { "Ryy32=memh_fifo(Rt32<<#2+#U6)", + 0xffe03080, + 0x9c403000, + 0xf60, + 0x0 + }, + { "p0=cmp.gtu(Rs16,#U5); if (p0.new) jump:t #r9:2", + 0xf7c02000, + 0x11002000, + 0x3000fe, + 0x0 + }, + { "Re16=#U6 ; Rd16=#u6", + 0xfc003c00, + 0x28002800, + 0x3f00000, + 0x1 + }, + { "if (Pv4) memh(Rs32+#u6:1)=Rt32", + 0xffe00004, + 0x40400000, + 0x20f8, + 0x0 + }, + { "if (cmp.gt(Ns8.new,#-1)) jump:t #r9:2", + 0xf7c02000, + 0x26802000, + 0x3000fe, + 0x0 + }, + { "p1=cmp.gtu(Rs16,#U5); if (p1.new) jump:nt #r9:2", + 0xf7c02000, + 0x13000000, + 0x3000fe, + 0x0 + }, + { "if (Pv4.new) memh(Rs32+#u6:1)=Rt.H32", + 0xffe00004, + 0x42600000, + 0x20f8, + 0x0 + }, + { "Rx16=add(Rx16,#S7) ; memb(Rs16+#u4:0)=Rt16", + 0xf8003000, + 0x60001000, + 0x7f00000, + 0x1 + }, + { "memw(Rs32+#u6:2)-=Rt32", + 0xff602060, + 0x3e400020, + 0x1f80, + 0x0 + }, + { "memb(Rs32+#u6:0)+=#U5", + 0xff602060, + 0x3f000000, + 0x1f80, + 0x0 + }, + { "if (!cmp.gt(Ns8.new,#U5)) jump:t #r9:2", + 0xf7c02000, + 0x24c02000, + 0x3000fe, + 0x0 + }, + { "if (Pu4.new) Rd32=add(Rs32,#s8)", + 0xff802000, + 0x74002000, + 0x1fe0, + 0x0 + }, + { "Ry16=add(Ry16,#S7) ; Rx16=add(Rx16,#s7)", + 0xf8003800, + 0x20002000, + 0x7f00000, + 0x1 + }, + { "Rdd32=memubh(Re32=#U6)", + 0xffe03000, + 0x9aa01000, + 0xf60, + 0x0 + }, + { "p1=cmp.eq(Rs16,#U5); if (!p1.new) jump:nt #r9:2", + 0xf7c02000, + 0x12400000, + 0x3000fe, + 0x0 + }, + { "memb(Rs32+#u6:0)=setbit(#U5)", + 0xff602060, + 0x3f000060, + 0x1f80, + 0x0 + }, + { "p0=cmp.gtu(Rs16,#U5); if (p0.new) jump:nt #r9:2", + 0xf7c02000, + 0x11000000, + 0x3000fe, + 0x0 + }, +}; -- 2.7.4