Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(20)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/a64/decoder-a64-inl.h

Issue 181253002: A64: Make the Decoder a template (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Created 6 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/a64/decoder-a64.cc ('k') | src/a64/disasm-a64.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/a64/decoder-a64-inl.h
diff --git a/src/a64/decoder-a64.cc b/src/a64/decoder-a64-inl.h
similarity index 72%
copy from src/a64/decoder-a64.cc
copy to src/a64/decoder-a64-inl.h
index 6a0497b8a30003f48953213302f4a3ad888b78f1..0cc6e8e9360f1423cd9cf27fc5cedb69ee60024d 100644
--- a/src/a64/decoder-a64.cc
+++ b/src/a64/decoder-a64-inl.h
@@ -1,4 +1,4 @@
-// Copyright 2013 the V8 project authors. All rights reserved.
+// Copyright 2014 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
@@ -25,89 +25,23 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#include "v8.h"
-
-#if V8_TARGET_ARCH_A64
+#ifndef V8_A64_DECODER_A64_INL_H_
+#define V8_A64_DECODER_A64_INL_H_
+#include "a64/decoder-a64.h"
#include "globals.h"
#include "utils.h"
-#include "a64/decoder-a64.h"
namespace v8 {
namespace internal {
-void DispatchingDecoderVisitor::AppendVisitor(DecoderVisitor* new_visitor) {
- visitors_.remove(new_visitor);
- visitors_.push_front(new_visitor);
-}
-
-
-void DispatchingDecoderVisitor::PrependVisitor(DecoderVisitor* new_visitor) {
- visitors_.remove(new_visitor);
- visitors_.push_back(new_visitor);
-}
-
-
-void DispatchingDecoderVisitor::InsertVisitorBefore(
- DecoderVisitor* new_visitor, DecoderVisitor* registered_visitor) {
- visitors_.remove(new_visitor);
- std::list<DecoderVisitor*>::iterator it;
- for (it = visitors_.begin(); it != visitors_.end(); it++) {
- if (*it == registered_visitor) {
- visitors_.insert(it, new_visitor);
- return;
- }
- }
- // We reached the end of the list. The last element must be
- // registered_visitor.
- ASSERT(*it == registered_visitor);
- visitors_.insert(it, new_visitor);
-}
-
-
-void DispatchingDecoderVisitor::InsertVisitorAfter(
- DecoderVisitor* new_visitor, DecoderVisitor* registered_visitor) {
- visitors_.remove(new_visitor);
- std::list<DecoderVisitor*>::iterator it;
- for (it = visitors_.begin(); it != visitors_.end(); it++) {
- if (*it == registered_visitor) {
- it++;
- visitors_.insert(it, new_visitor);
- return;
- }
- }
- // We reached the end of the list. The last element must be
- // registered_visitor.
- ASSERT(*it == registered_visitor);
- visitors_.push_back(new_visitor);
-}
-
-
-void DispatchingDecoderVisitor::RemoveVisitor(DecoderVisitor* visitor) {
- visitors_.remove(visitor);
-}
-
-
-#define DEFINE_VISITOR_CALLERS(A) \
- void DispatchingDecoderVisitor::Visit##A(Instruction* instr) { \
- if (!(instr->Mask(A##FMask) == A##Fixed)) { \
- ASSERT(instr->Mask(A##FMask) == A##Fixed); \
- } \
- std::list<DecoderVisitor*>::iterator it; \
- for (it = visitors_.begin(); it != visitors_.end(); it++) { \
- (*it)->Visit##A(instr); \
- } \
- }
-VISITOR_LIST(DEFINE_VISITOR_CALLERS)
-#undef DEFINE_VISITOR_CALLERS
-
-
// Top-level instruction decode function.
-void Decoder::Decode(Instruction *instr) {
+template<typename V>
+void Decoder<V>::Decode(Instruction *instr) {
if (instr->Bits(28, 27) == 0) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
switch (instr->Bits(27, 24)) {
// 0: PC relative addressing.
@@ -183,16 +117,18 @@ void Decoder::Decode(Instruction *instr) {
}
-void Decoder::DecodePCRelAddressing(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodePCRelAddressing(Instruction* instr) {
ASSERT(instr->Bits(27, 24) == 0x0);
// We know bit 28 is set, as <b28:b27> = 0 is filtered out at the top level
// decode.
ASSERT(instr->Bit(28) == 0x1);
- VisitPCRelAddressing(instr);
+ V::VisitPCRelAddressing(instr);
}
-void Decoder::DecodeBranchSystemException(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeBranchSystemException(Instruction* instr) {
ASSERT((instr->Bits(27, 24) == 0x4) ||
(instr->Bits(27, 24) == 0x5) ||
(instr->Bits(27, 24) == 0x6) ||
@@ -201,15 +137,15 @@ void Decoder::DecodeBranchSystemException(Instruction* instr) {
switch (instr->Bits(31, 29)) {
case 0:
case 4: {
- VisitUnconditionalBranch(instr);
+ V::VisitUnconditionalBranch(instr);
break;
}
case 1:
case 5: {
if (instr->Bit(25) == 0) {
- VisitCompareBranch(instr);
+ V::VisitCompareBranch(instr);
} else {
- VisitTestBranch(instr);
+ V::VisitTestBranch(instr);
}
break;
}
@@ -217,12 +153,12 @@ void Decoder::DecodeBranchSystemException(Instruction* instr) {
if (instr->Bit(25) == 0) {
if ((instr->Bit(24) == 0x1) ||
(instr->Mask(0x01000010) == 0x00000010)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitConditionalBranch(instr);
+ V::VisitConditionalBranch(instr);
}
} else {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
}
break;
}
@@ -238,9 +174,9 @@ void Decoder::DecodeBranchSystemException(Instruction* instr) {
(instr->Mask(0x00E0001C) == 0x00800000) ||
(instr->Mask(0x00E0001F) == 0x00A00000) ||
(instr->Mask(0x00C0001C) == 0x00C00000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitException(instr);
+ V::VisitException(instr);
}
} else {
if (instr->Bits(23, 22) == 0) {
@@ -262,12 +198,12 @@ void Decoder::DecodeBranchSystemException(Instruction* instr) {
(instr->Mask(0x003FF800) == 0x00032800) ||
(instr->Mask(0x0038F000) == 0x00005000) ||
(instr->Mask(0x0038E000) == 0x00006000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitSystem(instr);
+ V::VisitSystem(instr);
}
} else {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
}
}
} else {
@@ -277,23 +213,24 @@ void Decoder::DecodeBranchSystemException(Instruction* instr) {
(instr->Bits(4, 0) != 0) ||
(instr->Bits(24, 21) == 0x3) ||
(instr->Bits(24, 22) == 0x3)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitUnconditionalBranchToRegister(instr);
+ V::VisitUnconditionalBranchToRegister(instr);
}
}
break;
}
case 3:
case 7: {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
break;
}
}
}
-void Decoder::DecodeLoadStore(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeLoadStore(Instruction* instr) {
ASSERT((instr->Bits(27, 24) == 0x8) ||
(instr->Bits(27, 24) == 0x9) ||
(instr->Bits(27, 24) == 0xC) ||
@@ -304,63 +241,63 @@ void Decoder::DecodeLoadStore(Instruction* instr) {
if (instr->Bit(29) == 0) {
if (instr->Bit(26) == 0) {
// TODO(all): VisitLoadStoreExclusive.
- VisitUnimplemented(instr);
+ V::VisitUnimplemented(instr);
} else {
DecodeAdvSIMDLoadStore(instr);
}
} else {
if ((instr->Bits(31, 30) == 0x3) ||
(instr->Mask(0xC4400000) == 0x40000000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if (instr->Bit(23) == 0) {
if (instr->Mask(0xC4400000) == 0xC0400000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitLoadStorePairNonTemporal(instr);
+ V::VisitLoadStorePairNonTemporal(instr);
}
} else {
- VisitLoadStorePairPostIndex(instr);
+ V::VisitLoadStorePairPostIndex(instr);
}
}
}
} else {
if (instr->Bit(29) == 0) {
if (instr->Mask(0xC4000000) == 0xC4000000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitLoadLiteral(instr);
+ V::VisitLoadLiteral(instr);
}
} else {
if ((instr->Mask(0x84C00000) == 0x80C00000) ||
(instr->Mask(0x44800000) == 0x44800000) ||
(instr->Mask(0x84800000) == 0x84800000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if (instr->Bit(21) == 0) {
switch (instr->Bits(11, 10)) {
case 0: {
- VisitLoadStoreUnscaledOffset(instr);
+ V::VisitLoadStoreUnscaledOffset(instr);
break;
}
case 1: {
if (instr->Mask(0xC4C00000) == 0xC0800000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitLoadStorePostIndex(instr);
+ V::VisitLoadStorePostIndex(instr);
}
break;
}
case 2: {
// TODO(all): VisitLoadStoreRegisterOffsetUnpriv.
- VisitUnimplemented(instr);
+ V::VisitUnimplemented(instr);
break;
}
case 3: {
if (instr->Mask(0xC4C00000) == 0xC0800000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitLoadStorePreIndex(instr);
+ V::VisitLoadStorePreIndex(instr);
}
break;
}
@@ -368,12 +305,12 @@ void Decoder::DecodeLoadStore(Instruction* instr) {
} else {
if (instr->Bits(11, 10) == 0x2) {
if (instr->Bit(14) == 0) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitLoadStoreRegisterOffset(instr);
+ V::VisitLoadStoreRegisterOffset(instr);
}
} else {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
}
}
}
@@ -382,29 +319,29 @@ void Decoder::DecodeLoadStore(Instruction* instr) {
} else {
if (instr->Bit(28) == 0) {
if (instr->Bit(29) == 0) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if ((instr->Bits(31, 30) == 0x3) ||
(instr->Mask(0xC4400000) == 0x40000000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if (instr->Bit(23) == 0) {
- VisitLoadStorePairOffset(instr);
+ V::VisitLoadStorePairOffset(instr);
} else {
- VisitLoadStorePairPreIndex(instr);
+ V::VisitLoadStorePairPreIndex(instr);
}
}
}
} else {
if (instr->Bit(29) == 0) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if ((instr->Mask(0x84C00000) == 0x80C00000) ||
(instr->Mask(0x44800000) == 0x44800000) ||
(instr->Mask(0x84800000) == 0x84800000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitLoadStoreUnsignedOffset(instr);
+ V::VisitLoadStoreUnsignedOffset(instr);
}
}
}
@@ -412,105 +349,109 @@ void Decoder::DecodeLoadStore(Instruction* instr) {
}
-void Decoder::DecodeLogical(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeLogical(Instruction* instr) {
ASSERT(instr->Bits(27, 24) == 0x2);
if (instr->Mask(0x80400000) == 0x00400000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if (instr->Bit(23) == 0) {
- VisitLogicalImmediate(instr);
+ V::VisitLogicalImmediate(instr);
} else {
if (instr->Bits(30, 29) == 0x1) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitMoveWideImmediate(instr);
+ V::VisitMoveWideImmediate(instr);
}
}
}
}
-void Decoder::DecodeBitfieldExtract(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeBitfieldExtract(Instruction* instr) {
ASSERT(instr->Bits(27, 24) == 0x3);
if ((instr->Mask(0x80400000) == 0x80000000) ||
(instr->Mask(0x80400000) == 0x00400000) ||
(instr->Mask(0x80008000) == 0x00008000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else if (instr->Bit(23) == 0) {
if ((instr->Mask(0x80200000) == 0x00200000) ||
(instr->Mask(0x60000000) == 0x60000000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitBitfield(instr);
+ V::VisitBitfield(instr);
}
} else {
if ((instr->Mask(0x60200000) == 0x00200000) ||
(instr->Mask(0x60000000) != 0x00000000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitExtract(instr);
+ V::VisitExtract(instr);
}
}
}
-void Decoder::DecodeAddSubImmediate(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeAddSubImmediate(Instruction* instr) {
ASSERT(instr->Bits(27, 24) == 0x1);
if (instr->Bit(23) == 1) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitAddSubImmediate(instr);
+ V::VisitAddSubImmediate(instr);
}
}
-void Decoder::DecodeDataProcessing(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeDataProcessing(Instruction* instr) {
ASSERT((instr->Bits(27, 24) == 0xA) ||
(instr->Bits(27, 24) == 0xB) );
if (instr->Bit(24) == 0) {
if (instr->Bit(28) == 0) {
if (instr->Mask(0x80008000) == 0x00008000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitLogicalShifted(instr);
+ V::VisitLogicalShifted(instr);
}
} else {
switch (instr->Bits(23, 21)) {
case 0: {
if (instr->Mask(0x0000FC00) != 0) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitAddSubWithCarry(instr);
+ V::VisitAddSubWithCarry(instr);
}
break;
}
case 2: {
if ((instr->Bit(29) == 0) ||
(instr->Mask(0x00000410) != 0)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if (instr->Bit(11) == 0) {
- VisitConditionalCompareRegister(instr);
+ V::VisitConditionalCompareRegister(instr);
} else {
- VisitConditionalCompareImmediate(instr);
+ V::VisitConditionalCompareImmediate(instr);
}
}
break;
}
case 4: {
if (instr->Mask(0x20000800) != 0x00000000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitConditionalSelect(instr);
+ V::VisitConditionalSelect(instr);
}
break;
}
case 6: {
if (instr->Bit(29) == 0x1) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if (instr->Bit(30) == 0) {
if ((instr->Bit(15) == 0x1) ||
@@ -521,9 +462,9 @@ void Decoder::DecodeDataProcessing(Instruction* instr) {
(instr->Mask(0x8000EC00) == 0x00004C00) ||
(instr->Mask(0x8000E800) == 0x80004000) ||
(instr->Mask(0x8000E400) == 0x80004000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitDataProcessing2Source(instr);
+ V::VisitDataProcessing2Source(instr);
}
} else {
if ((instr->Bit(13) == 1) ||
@@ -531,9 +472,9 @@ void Decoder::DecodeDataProcessing(Instruction* instr) {
(instr->Bits(15, 14) != 0) ||
(instr->Mask(0xA01FFC00) == 0x00000C00) ||
(instr->Mask(0x201FF800) == 0x00001800)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitDataProcessing1Source(instr);
+ V::VisitDataProcessing1Source(instr);
}
}
break;
@@ -542,7 +483,7 @@ void Decoder::DecodeDataProcessing(Instruction* instr) {
case 1:
case 3:
case 5:
- case 7: VisitUnallocated(instr); break;
+ case 7: V::VisitUnallocated(instr); break;
}
}
} else {
@@ -550,17 +491,17 @@ void Decoder::DecodeDataProcessing(Instruction* instr) {
if (instr->Bit(21) == 0) {
if ((instr->Bits(23, 22) == 0x3) ||
(instr->Mask(0x80008000) == 0x00008000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitAddSubShifted(instr);
+ V::VisitAddSubShifted(instr);
}
} else {
if ((instr->Mask(0x00C00000) != 0x00000000) ||
(instr->Mask(0x00001400) == 0x00001400) ||
(instr->Mask(0x00001800) == 0x00001800)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitAddSubExtended(instr);
+ V::VisitAddSubExtended(instr);
}
}
} else {
@@ -572,16 +513,17 @@ void Decoder::DecodeDataProcessing(Instruction* instr) {
(instr->Mask(0x60E00000) == 0x00E00000) ||
(instr->Mask(0x60E00000) == 0x00800000) ||
(instr->Mask(0x60E00000) == 0x00600000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitDataProcessing3Source(instr);
+ V::VisitDataProcessing3Source(instr);
}
}
}
}
-void Decoder::DecodeFP(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeFP(Instruction* instr) {
ASSERT((instr->Bits(27, 24) == 0xE) ||
(instr->Bits(27, 24) == 0xF) );
@@ -589,10 +531,10 @@ void Decoder::DecodeFP(Instruction* instr) {
DecodeAdvSIMDDataProcessing(instr);
} else {
if (instr->Bit(29) == 1) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
if (instr->Bits(31, 30) == 0x3) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else if (instr->Bits(31, 30) == 0x1) {
DecodeAdvSIMDDataProcessing(instr);
} else {
@@ -605,13 +547,13 @@ void Decoder::DecodeFP(Instruction* instr) {
(instr->Mask(0x000E0000) == 0x000A0000) ||
(instr->Mask(0x00160000) == 0x00000000) ||
(instr->Mask(0x00160000) == 0x00120000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitFPFixedPointConvert(instr);
+ V::VisitFPFixedPointConvert(instr);
}
} else {
if (instr->Bits(15, 10) == 32) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else if (instr->Bits(15, 10) == 0) {
if ((instr->Bits(23, 22) == 0x3) ||
(instr->Mask(0x000E0000) == 0x000A0000) ||
@@ -629,9 +571,9 @@ void Decoder::DecodeFP(Instruction* instr) {
(instr->Mask(0xA0D60000) == 0x00160000) ||
(instr->Mask(0xA0D60000) == 0x80560000) ||
(instr->Mask(0xA0D60000) == 0x80960000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitFPIntegerConvert(instr);
+ V::VisitFPIntegerConvert(instr);
}
} else if (instr->Bits(14, 10) == 16) {
const Instr masked_A0DF8000 = instr->Mask(0xA0DF8000);
@@ -646,46 +588,46 @@ void Decoder::DecodeFP(Instruction* instr) {
(instr->Mask(0xA0DE0000) == 0x00C00000) ||
(instr->Mask(0xA0DF0000) == 0x00C30000) ||
(instr->Mask(0xA0DC0000) == 0x00C40000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitFPDataProcessing1Source(instr);
+ V::VisitFPDataProcessing1Source(instr);
}
} else if (instr->Bits(13, 10) == 8) {
if ((instr->Bits(15, 14) != 0) ||
(instr->Bits(2, 0) != 0) ||
(instr->Mask(0x80800000) != 0x00000000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitFPCompare(instr);
+ V::VisitFPCompare(instr);
}
} else if (instr->Bits(12, 10) == 4) {
if ((instr->Bits(9, 5) != 0) ||
(instr->Mask(0x80800000) != 0x00000000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitFPImmediate(instr);
+ V::VisitFPImmediate(instr);
}
} else {
if (instr->Mask(0x80800000) != 0x00000000) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
switch (instr->Bits(11, 10)) {
case 1: {
- VisitFPConditionalCompare(instr);
+ V::VisitFPConditionalCompare(instr);
break;
}
case 2: {
if ((instr->Bits(15, 14) == 0x3) ||
(instr->Mask(0x00009000) == 0x00009000) ||
(instr->Mask(0x0000A000) == 0x0000A000)) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitFPDataProcessing2Source(instr);
+ V::VisitFPDataProcessing2Source(instr);
}
break;
}
case 3: {
- VisitFPConditionalSelect(instr);
+ V::VisitFPConditionalSelect(instr);
break;
}
default: UNREACHABLE();
@@ -697,9 +639,9 @@ void Decoder::DecodeFP(Instruction* instr) {
// Bit 30 == 1 has been handled earlier.
ASSERT(instr->Bit(30) == 0);
if (instr->Mask(0xA0800000) != 0) {
- VisitUnallocated(instr);
+ V::VisitUnallocated(instr);
} else {
- VisitFPDataProcessing3Source(instr);
+ V::VisitFPDataProcessing3Source(instr);
}
}
}
@@ -708,20 +650,22 @@ void Decoder::DecodeFP(Instruction* instr) {
}
-void Decoder::DecodeAdvSIMDLoadStore(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeAdvSIMDLoadStore(Instruction* instr) {
// TODO(all): Implement Advanced SIMD load/store instruction decode.
ASSERT(instr->Bits(29, 25) == 0x6);
- VisitUnimplemented(instr);
+ V::VisitUnimplemented(instr);
}
-void Decoder::DecodeAdvSIMDDataProcessing(Instruction* instr) {
+template<typename V>
+void Decoder<V>::DecodeAdvSIMDDataProcessing(Instruction* instr) {
// TODO(all): Implement Advanced SIMD data processing instruction decode.
ASSERT(instr->Bits(27, 25) == 0x7);
- VisitUnimplemented(instr);
+ V::VisitUnimplemented(instr);
}
} } // namespace v8::internal
-#endif // V8_TARGET_ARCH_A64
+#endif // V8_A64_DECODER_A64_INL_H_
« no previous file with comments | « src/a64/decoder-a64.cc ('k') | src/a64/disasm-a64.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698