From 57b4dca5d6e64b8924dd40223f0981fe03cf7fc8 Mon Sep 17 00:00:00 2001 From: Akira Saitoh Date: Tue, 11 May 2021 09:03:07 +0900 Subject: [PATCH] AArch64: Add atomic operation instructions introduced by FEAT_LSE This commit adds atomic operation instructions introduced by FEAT_LSE. Signed-off-by: Akira Saitoh --- compiler/aarch64/codegen/ARM64Debug.cpp | 224 +++++++++++++++++ .../aarch64/codegen/OMRInstOpCodeEnum.hpp | 228 ++++++++++++++++++ .../aarch64/codegen/OMRMemoryReference.cpp | 25 +- compiler/aarch64/codegen/OpBinary.cpp | 228 ++++++++++++++++++ 4 files changed, 698 insertions(+), 7 deletions(-) diff --git a/compiler/aarch64/codegen/ARM64Debug.cpp b/compiler/aarch64/codegen/ARM64Debug.cpp index 81c5fb146b4..89f3f66d9f8 100644 --- a/compiler/aarch64/codegen/ARM64Debug.cpp +++ b/compiler/aarch64/codegen/ARM64Debug.cpp @@ -322,6 +322,230 @@ static const char *opCodeToNameMap[] = "vstrimmd", "vldrimmd", "prfmimm", + "ldaddx", + "ldaddax", + "ldaddlx", + "ldaddalx", + "ldaddw", + "ldaddaw", + "ldaddlw", + "ldaddalw", + "ldaddb", + "ldaddab", + "ldaddlb", + "ldaddalb", + "ldaddh", + "ldaddah", + "ldaddlh", + "ldaddalh", + "ldclrx", + "ldclrax", + "ldclrlx", + "ldclralx", + "ldclrw", + "ldclraw", + "ldclrlw", + "ldclralw", + "ldclrb", + "ldclrab", + "ldclrlb", + "ldclralb", + "ldclrh", + "ldclrah", + "ldclrlh", + "ldclralh", + "ldeorx", + "ldeorax", + "ldeorlx", + "ldeoralx", + "ldeorw", + "ldeoraw", + "ldeorlw", + "ldeoralw", + "ldeorb", + "ldeorab", + "ldeorlb", + "ldeoralb", + "ldeorh", + "ldeorah", + "ldeorlh", + "ldeoralh", + "ldsetx", + "ldsetax", + "ldsetlx", + "ldsetalx", + "ldsetw", + "ldsetaw", + "ldsetlw", + "ldsetalw", + "ldsetb", + "ldsetab", + "ldsetlb", + "ldsetalb", + "ldseth", + "ldsetah", + "ldsetlh", + "ldsetalh", + "ldsmaxx", + "ldsmaxax", + "ldsmaxlx", + "ldsmaxalx", + "ldsmaxw", + "ldsmaxaw", + "ldsmaxlw", + "ldsmaxalw", + "ldsmaxb", + "ldsmaxab", + "ldsmaxlb", + "ldsmaxalb", + "ldsmaxh", + "ldsmaxah", + "ldsmaxlh", + "ldsmaxalh", + "ldsminx", + "ldsminax", + "ldsminlx", + "ldsminalx", + "ldsminw", + "ldsminaw", + "ldsminlw", + "ldsminalw", + "ldsminb", + "ldsminab", + "ldsminlb", + "ldsminalb", + "ldsminh", + "ldsminah", + "ldsminlh", + "ldsminalh", + "ldumaxx", + "ldumaxax", + "ldumaxlx", + "ldumaxalx", + "ldumaxw", + "ldumaxaw", + "ldumaxlw", + "ldumaxalw", + "ldumaxb", + "ldumaxab", + "ldumaxlb", + "ldumaxalb", + "ldumaxh", + "ldumaxah", + "ldumaxlh", + "ldumaxalh", + "lduminx", + "lduminax", + "lduminlx", + "lduminalx", + "lduminw", + "lduminaw", + "lduminlw", + "lduminalw", + "lduminb", + "lduminab", + "lduminlb", + "lduminalb", + "lduminh", + "lduminah", + "lduminlh", + "lduminalh", + "staddx", + "staddlx", + "staddw", + "staddlw", + "staddb", + "staddlb", + "staddh", + "staddlh", + "stclrx", + "stclrlx", + "stclrw", + "stclrlw", + "stclrb", + "stclrlb", + "stclrh", + "stclrlh", + "steorx", + "steorlx", + "steorw", + "steorlw", + "steorb", + "steorlb", + "steorh", + "steorlh", + "stsetx", + "stsetlx", + "stsetw", + "stsetlw", + "stsetb", + "stsetlb", + "stseth", + "stsetlh", + "stsmaxx", + "stsmaxlx", + "stsmaxw", + "stsmaxlw", + "stsmaxb", + "stsmaxlb", + "stsmaxh", + "stsmaxlh", + "stsminx", + "stsminlx", + "stsminw", + "stsminlw", + "stsminb", + "stsminlb", + "stsminh", + "stsminlh", + "stumaxx", + "stumaxlx", + "stumaxw", + "stumaxlw", + "stumaxb", + "stumaxlb", + "stumaxh", + "stumaxlh", + "stuminx", + "stuminlx", + "stuminw", + "stuminlw", + "stuminb", + "stuminlb", + "stuminh", + "stuminlh", + "swpx", + "swpax", + "swplx", + "swpalx", + "swpw", + "swpaw", + "swplw", + "swpalw", + "swpb", + "swpab", + "swplb", + "swpalb", + "swph", + "swpah", + "swplh", + "swpalh", + "casx", + "casax", + "caslx", + "casalx", + "casw", + "casaw", + "caslw", + "casalw", + "casb", + "casab", + "caslb", + "casalb", + "cash", + "casah", + "caslh", + "casalh", "adr", "adrp", "addimmw", diff --git a/compiler/aarch64/codegen/OMRInstOpCodeEnum.hpp b/compiler/aarch64/codegen/OMRInstOpCodeEnum.hpp index e130e481a29..ebda78af720 100644 --- a/compiler/aarch64/codegen/OMRInstOpCodeEnum.hpp +++ b/compiler/aarch64/codegen/OMRInstOpCodeEnum.hpp @@ -276,6 +276,234 @@ vstrimmd, /* 0xFD000000 STR */ vldrimmd, /* 0xFD400000 LDR */ prfmimm, /* 0xF9800000 PRFM */ + /* Atomic instructions introduced by FEAT_LSE */ + /* Atomic memory operation instructions */ + ldaddx, /* 0xF8200000 LDADD */ + ldaddax, /* 0xF8A00000 LDADDA */ + ldaddlx, /* 0xF8600000 LDADDL */ + ldaddalx, /* 0xF8E00000 LDADDAL */ + ldaddw, /* 0xB8200000 LDADD */ + ldaddaw, /* 0xB8A00000 LDADDA */ + ldaddlw, /* 0xB8600000 LDADDL */ + ldaddalw, /* 0xB8E00000 LDADDAL */ + ldaddb, /* 0x38200000 LDADDB */ + ldaddab, /* 0x38A00000 LDADDAB */ + ldaddlb, /* 0x38600000 LDADDLB */ + ldaddalb, /* 0x38E00000 LDADDALB */ + ldaddh, /* 0x78200000 LDADDH */ + ldaddah, /* 0x78A00000 LDADDAH */ + ldaddlh, /* 0x78600000 LDADDLH */ + ldaddalh, /* 0x78E00000 LDADDALH */ + ldclrx, /* 0xF8201000 LDCLR */ + ldclrax, /* 0xF8A01000 LDCLRA */ + ldclrlx, /* 0xF8601000 LDCLRL */ + ldclralx, /* 0xF8E01000 LDCLRAL */ + ldclrw, /* 0xB8201000 LDCLR */ + ldclraw, /* 0xB8A01000 LDCLRA */ + ldclrlw, /* 0xB8601000 LDCLRL */ + ldclralw, /* 0xB8E01000 LDCLRAL */ + ldclrb, /* 0x38201000 LDCLRB */ + ldclrab, /* 0x38A01000 LDCLRAB */ + ldclrlb, /* 0x38601000 LDCLRLB */ + ldclralb, /* 0x38E01000 LDCLRALB */ + ldclrh, /* 0x78201000 LDCLRH */ + ldclrah, /* 0x78A01000 LDCLRAH */ + ldclrlh, /* 0x78601000 LDCLRLH */ + ldclralh, /* 0x78E01000 LDCLRALH */ + ldeorx, /* 0xF8202000 LDEOR */ + ldeorax, /* 0xF8A02000 LDEORA */ + ldeorlx, /* 0xF8602000 LDEORL */ + ldeoralx, /* 0xF8E02000 LDEORAL */ + ldeorw, /* 0xB8202000 LDEOR */ + ldeoraw, /* 0xB8A02000 LDEORA */ + ldeorlw, /* 0xB8602000 LDEORL */ + ldeoralw, /* 0xB8E02000 LDEORAL */ + ldeorb, /* 0x38202000 LDEORB */ + ldeorab, /* 0x38A02000 LDEORAB */ + ldeorlb, /* 0x38602000 LDEORLB */ + ldeoralb, /* 0x38E02000 LDEORALB */ + ldeorh, /* 0x78202000 LDEORH */ + ldeorah, /* 0x78A02000 LDEORAH */ + ldeorlh, /* 0x78602000 LDEORLH */ + ldeoralh, /* 0x78E02000 LDEORALH */ + ldsetx, /* 0xF8203000 LDSET */ + ldsetax, /* 0xF8A03000 LDSETA */ + ldsetlx, /* 0xF8603000 LDSETL */ + ldsetalx, /* 0xF8E03000 LDSETAL */ + ldsetw, /* 0xB8203000 LDSET */ + ldsetaw, /* 0xB8A03000 LDSETA */ + ldsetlw, /* 0xB8603000 LDSETL */ + ldsetalw, /* 0xB8E03000 LDSETAL */ + ldsetb, /* 0x38203000 LDSETB */ + ldsetab, /* 0x38A03000 LDSETAB */ + ldsetlb, /* 0x38603000 LDSETLB */ + ldsetalb, /* 0x38E03000 LDSETALB */ + ldseth, /* 0x78203000 LDSETH */ + ldsetah, /* 0x78A03000 LDSETAH */ + ldsetlh, /* 0x78603000 LDSETLH */ + ldsetalh, /* 0x78E03000 LDSETALH */ + ldsmaxx, /* 0xF8204000 LDSMAX */ + ldsmaxax, /* 0xF8A04000 LDSMAXA */ + ldsmaxlx, /* 0xF8604000 LDSMAXL */ + ldsmaxalx, /* 0xF8E04000 LDSMAXAL */ + ldsmaxw, /* 0xB8204000 LDSMAX */ + ldsmaxaw, /* 0xB8A04000 LDSMAXA */ + ldsmaxlw, /* 0xB8604000 LDSMAXL */ + ldsmaxalw, /* 0xB8E04000 LDSMAXAL */ + ldsmaxb, /* 0x38204000 LDSMAXB */ + ldsmaxab, /* 0x38A04000 LDSMAXAB */ + ldsmaxlb, /* 0x38604000 LDSMAXLB */ + ldsmaxalb, /* 0x38E04000 LDSMAXALB */ + ldsmaxh, /* 0x78204000 LDSMAXH */ + ldsmaxah, /* 0x78A04000 LDSMAXAH */ + ldsmaxlh, /* 0x78604000 LDSMAXLH */ + ldsmaxalh, /* 0x78E04000 LDSMAXALH */ + ldsminx, /* 0xF8205000 LDSMIN */ + ldsminax, /* 0xF8A05000 LDSMINA */ + ldsminlx, /* 0xF8605000 LDSMINL */ + ldsminalx, /* 0xF8E05000 LDSMINAL */ + ldsminw, /* 0xB8205000 LDSMIN */ + ldsminaw, /* 0xB8A05000 LDSMINA */ + ldsminlw, /* 0xB8605000 LDSMINL */ + ldsminalw, /* 0xB8E05000 LDSMINAL */ + ldsminb, /* 0x38205000 LDSMINB */ + ldsminab, /* 0x38A05000 LDSMINAB */ + ldsminlb, /* 0x38605000 LDSMINLB */ + ldsminalb, /* 0x38E05000 LDSMINALB */ + ldsminh, /* 0x78205000 LDSMINH */ + ldsminah, /* 0x78A05000 LDSMINAH */ + ldsminlh, /* 0x78605000 LDSMINLH */ + ldsminalh, /* 0x78E05000 LDSMINALH */ + ldumaxx, /* 0xF8206000 LDUMAX */ + ldumaxax, /* 0xF8A06000 LDUMAXA */ + ldumaxlx, /* 0xF8606000 LDUMAXL */ + ldumaxalx, /* 0xF8E06000 LDUMAXAL */ + ldumaxw, /* 0xB8206000 LDUMAX */ + ldumaxaw, /* 0xB8A06000 LDUMAXA */ + ldumaxlw, /* 0xB8606000 LDUMAXL */ + ldumaxalw, /* 0xB8E06000 LDUMAXAL */ + ldumaxb, /* 0x38206000 LDUMAXB */ + ldumaxab, /* 0x38A06000 LDUMAXAB */ + ldumaxlb, /* 0x38606000 LDUMAXLB */ + ldumaxalb, /* 0x38E06000 LDUMAXALB */ + ldumaxh, /* 0x78206000 LDUMAXH */ + ldumaxah, /* 0x78A06000 LDUMAXAH */ + ldumaxlh, /* 0x78606000 LDUMAXLH */ + ldumaxalh, /* 0x78E06000 LDUMAXALH */ + lduminx, /* 0xF8207000 LDUMIN */ + lduminax, /* 0xF8A07000 LDUMINA */ + lduminlx, /* 0xF8607000 LDUMINL */ + lduminalx, /* 0xF8E07000 LDUMINAL */ + lduminw, /* 0xB8207000 LDUMIN */ + lduminaw, /* 0xB8A07000 LDUMINA */ + lduminlw, /* 0xB8607000 LDUMINL */ + lduminalw, /* 0xB8E07000 LDUMINAL */ + lduminb, /* 0x38207000 LDUMINB */ + lduminab, /* 0x38A07000 LDUMINAB */ + lduminlb, /* 0x38607000 LDUMINLB */ + lduminalb, /* 0x38E07000 LDUMINALB */ + lduminh, /* 0x78207000 LDUMINH */ + lduminah, /* 0x78A07000 LDUMINAH */ + lduminlh, /* 0x78607000 LDUMINLH */ + lduminalh, /* 0x78E07000 LDUMINALH */ + staddx, /* 0xF820001F STADD */ + staddlx, /* 0xF860001F STADDL */ + staddw, /* 0xB820001F STADD */ + staddlw, /* 0xB860001F STADDL */ + staddb, /* 0x3820001F STADDB */ + staddlb, /* 0x3860001F STADDLB */ + staddh, /* 0x7820001F STADDH */ + staddlh, /* 0x7860001F STADDLH */ + stclrx, /* 0xF820101F STCLR */ + stclrlx, /* 0xF860101F STCLRL */ + stclrw, /* 0xB820101F STCLR */ + stclrlw, /* 0xB860101F STCLRL */ + stclrb, /* 0x3820101F STCLRB */ + stclrlb, /* 0x3860101F STCLRLB */ + stclrh, /* 0x7820101F STCLRH */ + stclrlh, /* 0x7860101F STCLRLH */ + steorx, /* 0xF820201F STEOR */ + steorlx, /* 0xF860201F STEORL */ + steorw, /* 0xB820201F STEOR */ + steorlw, /* 0xB860201F STEORL */ + steorb, /* 0x3820201F STEORB */ + steorlb, /* 0x3860201F STEORLB */ + steorh, /* 0x7820201F STEORH */ + steorlh, /* 0x7860201F STEORLH */ + stsetx, /* 0xF820301F STSET */ + stsetlx, /* 0xF860301F STSETL */ + stsetw, /* 0xB820301F STSET */ + stsetlw, /* 0xB860301F STSETL */ + stsetb, /* 0x3820301F STSETB */ + stsetlb, /* 0x3860301F STSETLB */ + stseth, /* 0x7820301F STSETH */ + stsetlh, /* 0x7860301F STSETLH */ + stsmaxx, /* 0xF820401F STSMAX */ + stsmaxlx, /* 0xF860401F STSMAXL */ + stsmaxw, /* 0xB820401F STSMAX */ + stsmaxlw, /* 0xB860401F STSMAXL */ + stsmaxb, /* 0x3820401F STSMAXB */ + stsmaxlb, /* 0x3860401F STSMAXLB */ + stsmaxh, /* 0x7820401F STSMAXH */ + stsmaxlh, /* 0x7860401F STSMAXLH */ + stsminx, /* 0xF820501F STSMIN */ + stsminlx, /* 0xF860501F STSMINL */ + stsminw, /* 0xB820501F STSMIN */ + stsminlw, /* 0xB860501F STSMINL */ + stsminb, /* 0x3820501F STSMINB */ + stsminlb, /* 0x3860501F STSMINLB */ + stsminh, /* 0x7820501F STSMINH */ + stsminlh, /* 0x7860501F STSMINLH */ + stumaxx, /* 0xF820601F STUMAX */ + stumaxlx, /* 0xF860601F STUMAXL */ + stumaxw, /* 0xB820601F STUMAX */ + stumaxlw, /* 0xB860601F STUMAXL */ + stumaxb, /* 0x3820601F STUMAXB */ + stumaxlb, /* 0x3860601F STUMAXLB */ + stumaxh, /* 0x7820601F STUMAXH */ + stumaxlh, /* 0x7860601F STUMAXLH */ + stuminx, /* 0xF820701F STUMIN */ + stuminlx, /* 0xF860701F STUMINL */ + stuminw, /* 0xB820701F STUMIN */ + stuminlw, /* 0xB860701F STUMINL */ + stuminb, /* 0x3820701F STUMINB */ + stuminlb, /* 0x3860701F STUMINLB */ + stuminh, /* 0x7820701F STUMINH */ + stuminlh, /* 0x7860701F STUMINLH */ + /* Swap instructions */ + swpx, /* 0xF8208000 SWP */ + swpax, /* 0xF8A08000 SWPA */ + swplx, /* 0xF8608000 SWPL */ + swpalx, /* 0xF8E08000 SWPAL */ + swpw, /* 0xB8208000 SWP */ + swpaw, /* 0xB8A08000 SWPA */ + swplw, /* 0xB8608000 SWPL */ + swpalw, /* 0xB8E08000 SWPAL */ + swpb, /* 0x38208000 SWPB */ + swpab, /* 0x38A08000 SWPAB */ + swplb, /* 0x38608000 SWPLB */ + swpalb, /* 0x38E08000 SWPALB */ + swph, /* 0x78208000 SWPH */ + swpah, /* 0x78A08000 SWPAH */ + swplh, /* 0x78608000 SWPLH */ + swpalh, /* 0x78E08000 SWPALH */ + /* Compare and swap instructions */ + casx, /* 0xC8A07C00 CAS */ + casax, /* 0xC8E07C00 CASA */ + caslx, /* 0xC8A0FC00 CASL */ + casalx, /* 0xC8E0FC00 CASAL */ + casw, /* 0x88A07C00 CAS */ + casaw, /* 0x88E07C00 CASA */ + caslw, /* 0x88A0FC00 CASL */ + casalw, /* 0x88E0FC00 CASAL */ + casb, /* 0x08A07C00 CASB */ + casab, /* 0x08E07C00 CASAB */ + caslb, /* 0x08A0FC00 CASLB */ + casalb, /* 0x08E0FC00 CASALB */ + cash, /* 0x48A07C00 CASH */ + casah, /* 0x48E07C00 CASAH */ + caslh, /* 0x48A0FC00 CASLH */ + casalh, /* 0x48E0FC00 CASALH */ /* Data processing - Immediate */ /* PC-rel. addressing */ adr, /* 0x10000000 ADR */ diff --git a/compiler/aarch64/codegen/OMRMemoryReference.cpp b/compiler/aarch64/codegen/OMRMemoryReference.cpp index da473da710d..6b8005ca121 100644 --- a/compiler/aarch64/codegen/OMRMemoryReference.cpp +++ b/compiler/aarch64/codegen/OMRMemoryReference.cpp @@ -790,14 +790,16 @@ static bool isImm7OffsetGPRInstruction(uint32_t enc) } /* load/store exclusive */ -static bool isExclusiveMemAccessInstruction(TR::InstOpCode::Mnemonic op) +static bool isExclusiveMemAccessInstruction(uint32_t enc) { - return (op == TR::InstOpCode::ldxrx || op == TR::InstOpCode::ldxrw || - op == TR::InstOpCode::ldaxrx || op == TR::InstOpCode::ldaxrw || - op == TR::InstOpCode::stxrx || op == TR::InstOpCode::stxrw || - op == TR::InstOpCode::stlxrx || op == TR::InstOpCode::stlxrw); + return ((enc & 0x3f000000) == 0x08000000); } +/* atomic operation */ +static bool isAtomicOperationInstruction(uint32_t enc) + { + return ((enc & 0x3b200c00) == 0x38200000); + } uint8_t *OMR::ARM64::MemoryReference::generateBinaryEncoding(TR::Instruction *currentInstruction, uint8_t *cursor, TR::CodeGenerator *cg) { @@ -927,7 +929,12 @@ uint8_t *OMR::ARM64::MemoryReference::generateBinaryEncoding(TR::Instruction *cu TR_ASSERT_FATAL(false, "Offset is too large for specified instruction."); } } - else if (isExclusiveMemAccessInstruction(op.getMnemonic())) + else if (isExclusiveMemAccessInstruction(enc)) + { + TR_ASSERT(displacement == 0, "Offset must be zero for specified instruction."); + cursor += ARM64_INSTRUCTION_LENGTH; + } + else if (isAtomicOperationInstruction(enc)) { TR_ASSERT(displacement == 0, "Offset must be zero for specified instruction."); cursor += ARM64_INSTRUCTION_LENGTH; @@ -1103,7 +1110,11 @@ uint32_t OMR::ARM64::MemoryReference::estimateBinaryLength(TR::InstOpCode op) TR_ASSERT_FATAL(false, "Offset is too large for specified instruction."); } } - else if (isExclusiveMemAccessInstruction(op.getMnemonic())) + else if (isExclusiveMemAccessInstruction(enc)) + { + return ARM64_INSTRUCTION_LENGTH; + } + else if (isAtomicOperationInstruction(enc)) { return ARM64_INSTRUCTION_LENGTH; } diff --git a/compiler/aarch64/codegen/OpBinary.cpp b/compiler/aarch64/codegen/OpBinary.cpp index 082cb8a058d..121589b69b7 100644 --- a/compiler/aarch64/codegen/OpBinary.cpp +++ b/compiler/aarch64/codegen/OpBinary.cpp @@ -275,6 +275,234 @@ const OMR::ARM64::InstOpCode::OpCodeBinaryEntry OMR::ARM64::InstOpCode::binaryEn 0xFD000000, /* STR vstrimmd */ 0xFD400000, /* LDR vldrimmd */ 0xF9800000, /* PRFM prfmimm */ + /* Atomic instructions introduced by FEAT_LSE */ + /* Atomic memory operation instructions */ + 0xF8200000, /* LDADD ldaddx */ + 0xF8A00000, /* LDADDA ldaddax */ + 0xF8600000, /* LDADDL ldaddlx */ + 0xF8E00000, /* LDADDAL ldaddalx */ + 0xB8200000, /* LDADD ldaddw */ + 0xB8A00000, /* LDADDA ldaddaw */ + 0xB8600000, /* LDADDL ldaddlw */ + 0xB8E00000, /* LDADDAL ldaddalw */ + 0x38200000, /* LDADDB ldaddb */ + 0x38A00000, /* LDADDAB ldaddab */ + 0x38600000, /* LDADDLB ldaddlb */ + 0x38E00000, /* LDADDALB ldaddalb */ + 0x78200000, /* LDADDH ldaddh */ + 0x78A00000, /* LDADDAH ldaddah */ + 0x78600000, /* LDADDLH ldaddlh */ + 0x78E00000, /* LDADDALH ldaddalh */ + 0xF8201000, /* LDCLR ldclrx */ + 0xF8A01000, /* LDCLRA ldclrax */ + 0xF8601000, /* LDCLRL ldclrlx */ + 0xF8E01000, /* LDCLRAL ldclralx */ + 0xB8201000, /* LDCLR ldclrw */ + 0xB8A01000, /* LDCLRA ldclraw */ + 0xB8601000, /* LDCLRL ldclrlw */ + 0xB8E01000, /* LDCLRAL ldclralw */ + 0x38201000, /* LDCLRB ldclrb */ + 0x38A01000, /* LDCLRAB ldlrab */ + 0x38601000, /* LDCLRLB ldclrlb */ + 0x38E01000, /* LDCLRALB ldclralb */ + 0x78201000, /* LDCLRH ldclrh */ + 0x78A01000, /* LDCLRAH ldclrah */ + 0x78601000, /* LDCLRLH ldclrlh */ + 0x78E01000, /* LDCLRALH ldclralh */ + 0xF8202000, /* LDEOR ldeorx */ + 0xF8A02000, /* LDEORA ldeorax */ + 0xF8602000, /* LDEORL ldeorlx */ + 0xF8E02000, /* LDEORAL ldeoralx */ + 0xB8202000, /* LDEOR ldeorw */ + 0xB8A02000, /* LDEORA ldeoraw */ + 0xB8602000, /* LDEORL ldeorlw */ + 0xB8E02000, /* LDEORAL ldeoralw */ + 0x38202000, /* LDEORB ldeorb */ + 0x38A02000, /* LDEORAB ldeorab */ + 0x38602000, /* LDEORLB ldeorlb */ + 0x38E02000, /* LDEORALB ldeoralb */ + 0x78202000, /* LDEORH ldeorh */ + 0x78A02000, /* LDEORAH ldeorah */ + 0x78602000, /* LDEORLH ldeorlh */ + 0x78E02000, /* LDEORALH ldeoralh */ + 0xF8203000, /* LDSET ldsetx */ + 0xF8A03000, /* LDSETA ldsetax */ + 0xF8603000, /* LDSETL ldsetlx */ + 0xF8E03000, /* LDSETAL ldsetalx */ + 0xB8203000, /* LDSET ldsetw */ + 0xB8A03000, /* LDSETA ldsetaw */ + 0xB8603000, /* LDSETL ldsetlw */ + 0xB8E03000, /* LDSETAL ldsetalw */ + 0x38203000, /* LDSETB ldsetb */ + 0x38A03000, /* LDSETAB ldsetab */ + 0x38603000, /* LDSETLB ldsetlb */ + 0x38E03000, /* LDSETALB ldsetalb */ + 0x78203000, /* LDSETH ldseth */ + 0x78A03000, /* LDSETAH ldsetah */ + 0x78603000, /* LDSETLH ldsetlh */ + 0x78E03000, /* LDSETALH ldsetalh */ + 0xF8204000, /* LDSMAX ldsmaxx */ + 0xF8A04000, /* LDSMAXA ldsmaxax */ + 0xF8604000, /* LDSMAXL ldsmaxlx */ + 0xF8E04000, /* LDSMAXAL ldsmaxalx */ + 0xB8204000, /* LDSMAX ldsmaxw */ + 0xB8A04000, /* LDSMAXA ldsmaxaw */ + 0xB8604000, /* LDSMAXL ldsmaxlw */ + 0xB8E04000, /* LDSMAXAL ldsmaxalw */ + 0x38204000, /* LDSMAXB ldsmaxb */ + 0x38A04000, /* LDSMAXAB ldsmaxab */ + 0x38604000, /* LDSMAXLB ldsmaxlb */ + 0x38E04000, /* LDSMAXALB ldsmaxalb */ + 0x78204000, /* LDSMAXH ldsmaxh */ + 0x78A04000, /* LDSMAXAH ldsmaxah */ + 0x78604000, /* LDSMAXLH ldsmaxlh */ + 0x78E04000, /* LDSMAXALH ldsmaxalh */ + 0xF8205000, /* LDSMIN ldsminx */ + 0xF8A05000, /* LDSMINA ldsminax */ + 0xF8605000, /* LDSMINL ldsminlx */ + 0xF8E05000, /* LDSMINAL ldsminalx */ + 0xB8205000, /* LDSMIN ldsminw */ + 0xB8A05000, /* LDSMINA ldsminaw */ + 0xB8605000, /* LDSMINL ldsminlw */ + 0xB8E05000, /* LDSMINAL ldsminalw */ + 0x38205000, /* LDSMINB ldsminb */ + 0x38A05000, /* LDSMINAB ldsminab */ + 0x38605000, /* LDSMINLB ldsminlb */ + 0x38E05000, /* LDSMINALB ldsminalb */ + 0x78205000, /* LDSMINH ldsminh */ + 0x78A05000, /* LDSMINAH ldsminah */ + 0x78605000, /* LDSMINLH ldsminlh */ + 0x78E05000, /* LDSMINALH ldsminalh */ + 0xF8206000, /* LDUMAX ldumaxx */ + 0xF8A06000, /* LDUMAXA ldumaxax */ + 0xF8606000, /* LDUMAXL ldumaxlx */ + 0xF8E06000, /* LDUMAXAL ldumaxalx */ + 0xB8206000, /* LDUMAX ldumaxw */ + 0xB8A06000, /* LDUMAXA ldumaxaw */ + 0xB8606000, /* LDUMAXL ldumaxlw */ + 0xB8E06000, /* LDUMAXAL ldumaxalw */ + 0x38206000, /* LDUMAXB ldumaxb */ + 0x38A06000, /* LDUMAXAB ldumaxab */ + 0x38606000, /* LDUMAXLB ldumaxlb */ + 0x38E06000, /* LDUMAXALB ldumaxalb */ + 0x78206000, /* LDUMAXH ldumaxh */ + 0x78A06000, /* LDUMAXAH ldumaxah */ + 0x78606000, /* LDUMAXLH ldumaxlh */ + 0x78E06000, /* LDUMAXALH ldumaxalh */ + 0xF8207000, /* LDUMIN lduminx */ + 0xF8A07000, /* LDUMINA lduminax */ + 0xF8607000, /* LDUMINL lduminlx */ + 0xF8E07000, /* LDUMINAL lduminalx */ + 0xB8207000, /* LDUMIN lduminw */ + 0xB8A07000, /* LDUMINA lduminaw */ + 0xB8607000, /* LDUMINL lduminlw */ + 0xB8E07000, /* LDUMINAL lduminalw */ + 0x38207000, /* LDUMINB lduminb */ + 0x38A07000, /* LDUMINAB lduminab */ + 0x38607000, /* LDUMINLB lduminlb */ + 0x38E07000, /* LDUMINALB lduminalb */ + 0x78207000, /* LDUMINH lduminh */ + 0x78A07000, /* LDUMINAH lduminah */ + 0x78607000, /* LDUMINLH lduminlh */ + 0x78E07000, /* LDUMINALH lduminalh */ + 0xF820001F, /* STADDD staddx */ + 0xF860001F, /* STADDDL staddlx */ + 0xB820001F, /* STADDD staddw */ + 0xB860001F, /* STADDDL staddlw */ + 0x3820001F, /* STADDDB staddb */ + 0x3860001F, /* STADDDLB staddlb */ + 0x7820001F, /* STADDDH staddh */ + 0x7860001F, /* STADDDLH staddlh */ + 0xF820101F, /* STCLR stclrx */ + 0xF860101F, /* STCLRL stclrlx */ + 0xB820101F, /* STCLR stclrw */ + 0xB860101F, /* STCLRL stclrlw */ + 0x3820101F, /* STCLRB stclrb */ + 0x3860101F, /* STCLRLB stclrlb */ + 0x7820101F, /* STCLRH stclrh */ + 0x7860101F, /* STCLRLH stclrlh */ + 0xF820201F, /* STEOR steorx */ + 0xF860201F, /* STEORL steorlx */ + 0xB820201F, /* STEOR steorw */ + 0xB860201F, /* STEORL steorlw */ + 0x3820201F, /* STEORB steorb */ + 0x3860201F, /* STEORLB steorlb */ + 0x7820201F, /* STEORH steorh */ + 0x7860201F, /* STEORLH steorlh */ + 0xF820301F, /* STSET stsetx */ + 0xF860301F, /* STSETL stsetlx */ + 0xB820301F, /* STSET stsetw */ + 0xB860301F, /* STSETL stsetlw */ + 0x3820301F, /* STSETB stsetb */ + 0x3860301F, /* STSETLB stsetlb */ + 0x7820301F, /* STSETH stseth */ + 0x7860301F, /* STSETLH stsetlh */ + 0xF820401F, /* STSMAX stsmaxx */ + 0xF860401F, /* STSMAXL stsmaxlx */ + 0xB820401F, /* STSMAX stsmaxw */ + 0xB860401F, /* STSMAXL stsmaxlw */ + 0x3820401F, /* STSMAXB stsmaxb */ + 0x3860401F, /* STSMAXLB stsmaxlb */ + 0x7820401F, /* STSMAXH stsmaxh */ + 0x7860401F, /* STSMAXLH stsmaxlh */ + 0xF820501F, /* STSMIN stsminx */ + 0xF860501F, /* STSMINL stsminlx */ + 0xB820501F, /* STSMIN stsminw */ + 0xB860501F, /* STSMINL stsminlw */ + 0x3820501F, /* STSMINB stsminb */ + 0x3860501F, /* STSMINLB stsminlb */ + 0x7820501F, /* STSMINH stsminh */ + 0x7860501F, /* STSMINLH stsminlh */ + 0xF820601F, /* STUMAX stumaxx */ + 0xF860601F, /* STUMAXL stumaxlx */ + 0xB820601F, /* STUMAX stumaxw */ + 0xB860601F, /* STUMAXL stumaxlw */ + 0x3820601F, /* STUMAXB stumaxb */ + 0x3860601F, /* STUMAXLB stumaxlb */ + 0x7820601F, /* STUMAXH stumaxh */ + 0x7860601F, /* STUMAXLH stumaxlh */ + 0xF820701F, /* STUMIN stuminx */ + 0xF860701F, /* STUMINL stuminlx */ + 0xB820701F, /* STUMIN stuminw */ + 0xB860701F, /* STUMINL stuminlw */ + 0x3820701F, /* STUMINB stuminb */ + 0x3860701F, /* STUMINLB stuminlb */ + 0x7820701F, /* STUMINH stuminh */ + 0x7860701F, /* STUMINLH stuminlh */ + /* Swap instructions */ + 0xF8208000, /* SWP swpx */ + 0xF8A08000, /* SWPA swpax */ + 0xF8608000, /* SWPL swplx */ + 0xF8E08000, /* SWPAL swpalx */ + 0xB8208000, /* SWP swpw */ + 0xB8A08000, /* SWPA swpaw */ + 0xB8608000, /* SWPL swplw */ + 0xB8E08000, /* SWPAL swpalw */ + 0x38208000, /* SWPB swpb */ + 0x38A08000, /* SWPAB swpab */ + 0x38608000, /* SWPLB swplb */ + 0x38E08000, /* SWPALB swpalb */ + 0x78208000, /* SWPH swph */ + 0x78A08000, /* SWPAH swpah */ + 0x78608000, /* SWPLH swplh */ + 0x78E08000, /* SWPALH swpalh */ + /* Compare and swap instructions */ + 0xC8A07C00, /* CAS casx */ + 0xC8E07C00, /* CASA casax */ + 0xC8A0FC00, /* CASL caslx */ + 0xC8E0FC00, /* CASAL casalx */ + 0x88A07C00, /* CAS casw */ + 0x88E07C00, /* CASA casaw */ + 0x88A0FC00, /* CASL caslw */ + 0x88E0FC00, /* CASAL casalw */ + 0x08A07C00, /* CASB casb */ + 0x08E07C00, /* CASAB casab */ + 0x08A0FC00, /* CASLB caslb */ + 0x08E0FC00, /* CASALB casalb */ + 0x48A07C00, /* CASH cash */ + 0x48E07C00, /* CASAH casah */ + 0x48A0FC00, /* CASLH caslh */ + 0x48E0FC00, /* CASALH casalh */ /* Data processing - Immediate */ /* PC-rel. addressing */ 0x10000000, /* ADR adr */