Home | History | Annotate | Download | only in arm64
      1 // Copyright 2013 the V8 project authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef V8_ARM64_DECODER_ARM64_H_
      6 #define V8_ARM64_DECODER_ARM64_H_
      7 
      8 #include <list>
      9 
     10 #include "src/arm64/instructions-arm64.h"
     11 #include "src/globals.h"
     12 
     13 namespace v8 {
     14 namespace internal {
     15 
     16 
     17 // List macro containing all visitors needed by the decoder class.
     18 
     19 #define VISITOR_LIST(V)             \
     20   V(PCRelAddressing)                \
     21   V(AddSubImmediate)                \
     22   V(LogicalImmediate)               \
     23   V(MoveWideImmediate)              \
     24   V(Bitfield)                       \
     25   V(Extract)                        \
     26   V(UnconditionalBranch)            \
     27   V(UnconditionalBranchToRegister)  \
     28   V(CompareBranch)                  \
     29   V(TestBranch)                     \
     30   V(ConditionalBranch)              \
     31   V(System)                         \
     32   V(Exception)                      \
     33   V(LoadStorePairPostIndex)         \
     34   V(LoadStorePairOffset)            \
     35   V(LoadStorePairPreIndex)          \
     36   V(LoadStorePairNonTemporal)       \
     37   V(LoadLiteral)                    \
     38   V(LoadStoreUnscaledOffset)        \
     39   V(LoadStorePostIndex)             \
     40   V(LoadStorePreIndex)              \
     41   V(LoadStoreRegisterOffset)        \
     42   V(LoadStoreUnsignedOffset)        \
     43   V(LogicalShifted)                 \
     44   V(AddSubShifted)                  \
     45   V(AddSubExtended)                 \
     46   V(AddSubWithCarry)                \
     47   V(ConditionalCompareRegister)     \
     48   V(ConditionalCompareImmediate)    \
     49   V(ConditionalSelect)              \
     50   V(DataProcessing1Source)          \
     51   V(DataProcessing2Source)          \
     52   V(DataProcessing3Source)          \
     53   V(FPCompare)                      \
     54   V(FPConditionalCompare)           \
     55   V(FPConditionalSelect)            \
     56   V(FPImmediate)                    \
     57   V(FPDataProcessing1Source)        \
     58   V(FPDataProcessing2Source)        \
     59   V(FPDataProcessing3Source)        \
     60   V(FPIntegerConvert)               \
     61   V(FPFixedPointConvert)            \
     62   V(Unallocated)                    \
     63   V(Unimplemented)
     64 
     65 // The Visitor interface. Disassembler and simulator (and other tools)
     66 // must provide implementations for all of these functions.
     67 class DecoderVisitor {
     68  public:
     69   virtual ~DecoderVisitor() {}
     70 
     71   #define DECLARE(A) virtual void Visit##A(Instruction* instr) = 0;
     72   VISITOR_LIST(DECLARE)
     73   #undef DECLARE
     74 };
     75 
     76 
     77 // A visitor that dispatches to a list of visitors.
     78 class DispatchingDecoderVisitor : public DecoderVisitor {
     79  public:
     80   DispatchingDecoderVisitor() {}
     81   virtual ~DispatchingDecoderVisitor() {}
     82 
     83   // Register a new visitor class with the decoder.
     84   // Decode() will call the corresponding visitor method from all registered
     85   // visitor classes when decoding reaches the leaf node of the instruction
     86   // decode tree.
     87   // Visitors are called in the order.
     88   // A visitor can only be registered once.
     89   // Registering an already registered visitor will update its position.
     90   //
     91   //   d.AppendVisitor(V1);
     92   //   d.AppendVisitor(V2);
     93   //   d.PrependVisitor(V2);            // Move V2 at the start of the list.
     94   //   d.InsertVisitorBefore(V3, V2);
     95   //   d.AppendVisitor(V4);
     96   //   d.AppendVisitor(V4);             // No effect.
     97   //
     98   //   d.Decode(i);
     99   //
    100   // will call in order visitor methods in V3, V2, V1, V4.
    101   void AppendVisitor(DecoderVisitor* visitor);
    102   void PrependVisitor(DecoderVisitor* visitor);
    103   void InsertVisitorBefore(DecoderVisitor* new_visitor,
    104                            DecoderVisitor* registered_visitor);
    105   void InsertVisitorAfter(DecoderVisitor* new_visitor,
    106                           DecoderVisitor* registered_visitor);
    107 
    108   // Remove a previously registered visitor class from the list of visitors
    109   // stored by the decoder.
    110   void RemoveVisitor(DecoderVisitor* visitor);
    111 
    112   #define DECLARE(A) void Visit##A(Instruction* instr);
    113   VISITOR_LIST(DECLARE)
    114   #undef DECLARE
    115 
    116  private:
    117   // Visitors are registered in a list.
    118   std::list<DecoderVisitor*> visitors_;
    119 };
    120 
    121 
    122 template<typename V>
    123 class Decoder : public V {
    124  public:
    125   Decoder() {}
    126   virtual ~Decoder() {}
    127 
    128   // Top-level instruction decoder function. Decodes an instruction and calls
    129   // the visitor functions registered with the Decoder class.
    130   virtual void Decode(Instruction *instr);
    131 
    132  private:
    133   // Decode the PC relative addressing instruction, and call the corresponding
    134   // visitors.
    135   // On entry, instruction bits 27:24 = 0x0.
    136   void DecodePCRelAddressing(Instruction* instr);
    137 
    138   // Decode the add/subtract immediate instruction, and call the corresponding
    139   // visitors.
    140   // On entry, instruction bits 27:24 = 0x1.
    141   void DecodeAddSubImmediate(Instruction* instr);
    142 
    143   // Decode the branch, system command, and exception generation parts of
    144   // the instruction tree, and call the corresponding visitors.
    145   // On entry, instruction bits 27:24 = {0x4, 0x5, 0x6, 0x7}.
    146   void DecodeBranchSystemException(Instruction* instr);
    147 
    148   // Decode the load and store parts of the instruction tree, and call
    149   // the corresponding visitors.
    150   // On entry, instruction bits 27:24 = {0x8, 0x9, 0xC, 0xD}.
    151   void DecodeLoadStore(Instruction* instr);
    152 
    153   // Decode the logical immediate and move wide immediate parts of the
    154   // instruction tree, and call the corresponding visitors.
    155   // On entry, instruction bits 27:24 = 0x2.
    156   void DecodeLogical(Instruction* instr);
    157 
    158   // Decode the bitfield and extraction parts of the instruction tree,
    159   // and call the corresponding visitors.
    160   // On entry, instruction bits 27:24 = 0x3.
    161   void DecodeBitfieldExtract(Instruction* instr);
    162 
    163   // Decode the data processing parts of the instruction tree, and call the
    164   // corresponding visitors.
    165   // On entry, instruction bits 27:24 = {0x1, 0xA, 0xB}.
    166   void DecodeDataProcessing(Instruction* instr);
    167 
    168   // Decode the floating point parts of the instruction tree, and call the
    169   // corresponding visitors.
    170   // On entry, instruction bits 27:24 = {0xE, 0xF}.
    171   void DecodeFP(Instruction* instr);
    172 
    173   // Decode the Advanced SIMD (NEON) load/store part of the instruction tree,
    174   // and call the corresponding visitors.
    175   // On entry, instruction bits 29:25 = 0x6.
    176   void DecodeAdvSIMDLoadStore(Instruction* instr);
    177 
    178   // Decode the Advanced SIMD (NEON) data processing part of the instruction
    179   // tree, and call the corresponding visitors.
    180   // On entry, instruction bits 27:25 = 0x7.
    181   void DecodeAdvSIMDDataProcessing(Instruction* instr);
    182 };
    183 
    184 
    185 } }  // namespace v8::internal
    186 
    187 #endif  // V8_ARM64_DECODER_ARM64_H_
    188