S390: Optimize decoding opcode format by using format table

src/s390/constants-s390.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_S390_CONSTANTS_S390_H_
 #define V8_S390_CONSTANTS_S390_H_
 
 // Get the standard printf format macros for C99 stdint types.
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
@@ skipping 1062 matching lines @@
   // S390 Opcode Format Types
   //   Based on the first byte of the opcode, we can determine how to extract
   //   the entire opcode of the instruction.  The various favours include:
   enum OpcodeFormatType {
     ONE_BYTE_OPCODE,           // One Byte - Bits 0 to 7
     TWO_BYTE_OPCODE,           // Two Bytes - Bits 0 to 15
     TWO_BYTE_DISJOINT_OPCODE,  // Two Bytes - Bits 0 to 7, 40 to 47
     THREE_NIBBLE_OPCODE        // Three Nibbles - Bits 0 to 7, 12 to 15
   };
 
+  static OpcodeFormatType OpcodeFormatTable[256];
 // Helper macro to define static accessors.
 // We use the cast to char* trick to bypass the strict anti-aliasing rules.
 #define DECLARE_STATIC_TYPED_ACCESSOR(return_type, Name) \
   static inline return_type Name(Instr instr) {          \
     char* temp = reinterpret_cast<char*>(&instr);        \
     return reinterpret_cast<Instruction*>(temp)->Name(); \
   }
 
 #define DECLARE_STATIC_ACCESSOR(Name) DECLARE_STATIC_TYPED_ACCESSOR(int, Name)
 
@@ skipping 154 matching lines @@
       *reinterpret_cast<uint32_t*>(instr) = static_cast<uint32_t>(value >> 16);
       *reinterpret_cast<uint16_t*>(instr + 4) =
           static_cast<uint16_t>(value & 0xFFFF);
 #endif
     }
   }
 
   // Get Instruction Format Type
   static OpcodeFormatType getOpcodeFormatType(const byte* instr) {
     const byte firstByte = *instr;
-    // Based on Figure B-3 in z/Architecture Principles of
-    // Operation.
-
-    // 1-byte opcodes
-    //   I, RR, RS, RSI, RX, SS Formats
-    if ((0x04 <= firstByte && 0x9B >= firstByte) ||
-        (0xA8 <= firstByte && 0xB1 >= firstByte) ||
-        (0xBA <= firstByte && 0xBF >= firstByte) || (0xC5 == firstByte) ||
-        (0xC7 == firstByte) || (0xD0 <= firstByte && 0xE2 >= firstByte) ||
-        (0xE8 <= firstByte && 0xEA >= firstByte) ||
-        (0xEE <= firstByte && 0xFD >= firstByte)) {
-      return ONE_BYTE_OPCODE;
-    }
-
-    // 2-byte opcodes
-    //   E, IE, RRD, RRE, RRF, SIL, S, SSE Formats
-    if ((0x00 == firstByte) ||  // Software breakpoint 0x0001
-        (0x01 == firstByte) || (0xB2 == firstByte) || (0xB3 == firstByte) ||
-        (0xB9 == firstByte) || (0xE5 == firstByte)) {
-      return TWO_BYTE_OPCODE;
-    }
-
-    // 3-nibble opcodes
-    //   RI, RIL, SSF Formats
-    if ((0xA5 == firstByte) || (0xA7 == firstByte) ||
-        (0xC0 <= firstByte && 0xCC >= firstByte)) {  // C5,C7 handled above
-      return THREE_NIBBLE_OPCODE;
-    }
-    // Remaining ones are all TWO_BYTE_DISJOINT OPCODES.
-    DCHECK(InstructionLength(instr) == 6);
-    return TWO_BYTE_DISJOINT_OPCODE;
+    return OpcodeFormatTable[firstByte];
   }
 
   // Extract the full opcode from the instruction.
   static inline Opcode S390OpcodeValue(const byte* instr) {
     OpcodeFormatType opcodeType = getOpcodeFormatType(instr);
 
     // The native instructions are encoded in big-endian format
     // even if running on little-endian host.  Hence, we need
     // to ensure we use byte* based bit-wise logic.
     switch (opcodeType) {
       case ONE_BYTE_OPCODE:
         // One Byte - Bits 0 to 7
         return static_cast<Opcode>(*instr);
       case TWO_BYTE_OPCODE:
         // Two Bytes - Bits 0 to 15
         return static_cast<Opcode>((*instr << 8) | (*(instr + 1)));
       case TWO_BYTE_DISJOINT_OPCODE:
         // Two Bytes - Bits 0 to 7, 40 to 47
         return static_cast<Opcode>((*instr << 8) | (*(instr + 5) & 0xFF));
-      case THREE_NIBBLE_OPCODE:
+      default:
+        // case THREE_NIBBLE_OPCODE:
         // Three Nibbles - Bits 0 to 7, 12 to 15
         return static_cast<Opcode>((*instr << 4) | (*(instr + 1) & 0xF));
-      default:
-        break;
     }
 
     UNREACHABLE();
     return static_cast<Opcode>(-1);
   }
 
   // Fields used in Software interrupt instructions
   inline SoftwareInterruptCodes SvcValue() const {
     return static_cast<SoftwareInterruptCodes>(Bits<FourByteInstr, int>(15, 0));
   }
@@ skipping 230 matching lines @@
   static int Number(const char* name);
 
  private:
   static const char* names_[kNumDoubleRegisters];
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_S390_CONSTANTS_S390_H_