Revert "ARM64: Add NEON support"

src/arm64/decoder-arm64-inl.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_ARM64_DECODER_ARM64_INL_H_
 #define V8_ARM64_DECODER_ARM64_INL_H_
 
 #include "src/arm64/decoder-arm64.h"
 #include "src/globals.h"
 #include "src/utils.h"
@@ skipping 195 matching lines @@
 }
 
 
 template<typename V>
 void Decoder<V>::DecodeLoadStore(Instruction* instr) {
   DCHECK((instr->Bits(27, 24) == 0x8) ||
          (instr->Bits(27, 24) == 0x9) ||
          (instr->Bits(27, 24) == 0xC) ||
          (instr->Bits(27, 24) == 0xD) );
 
-  if ((instr->Bit(28) == 0) && (instr->Bit(29) == 0) && (instr->Bit(26) == 1)) {
-    DecodeNEONLoadStore(instr);
-    return;
-  }
-
   if (instr->Bit(24) == 0) {
     if (instr->Bit(28) == 0) {
       if (instr->Bit(29) == 0) {
         if (instr->Bit(26) == 0) {
           if (instr->Mask(0xA08000) == 0x800000 ||
               instr->Mask(0xA00000) == 0xA00000) {
             V::VisitUnallocated(instr);
           } else if (instr->Mask(0x808000) == 0) {
             // Load/Store exclusive without acquire/release are unimplemented.
             V::VisitUnimplemented(instr);
           } else {
             V::VisitLoadStoreAcquireRelease(instr);
           }
+        } else {
+          DecodeAdvSIMDLoadStore(instr);
         }
       } else {
         if ((instr->Bits(31, 30) == 0x3) ||
             (instr->Mask(0xC4400000) == 0x40000000)) {
           V::VisitUnallocated(instr);
         } else {
           if (instr->Bit(23) == 0) {
             if (instr->Mask(0xC4400000) == 0xC0400000) {
               V::VisitUnallocated(instr);
             } else {
@@ skipping 265 matching lines @@
   }
 }
 
 
 template<typename V>
 void Decoder<V>::DecodeFP(Instruction* instr) {
   DCHECK((instr->Bits(27, 24) == 0xE) ||
          (instr->Bits(27, 24) == 0xF) );
 
   if (instr->Bit(28) == 0) {
-    DecodeNEONVectorDataProcessing(instr);
+    DecodeAdvSIMDDataProcessing(instr);
   } else {
-    if (instr->Bits(31, 30) == 0x3) {
+    if (instr->Bit(29) == 1) {
       V::VisitUnallocated(instr);
-    } else if (instr->Bits(31, 30) == 0x1) {
-      DecodeNEONScalarDataProcessing(instr);
     } else {
-      if (instr->Bit(29) == 0) {
+      if (instr->Bits(31, 30) == 0x3) {
+        V::VisitUnallocated(instr);
+      } else if (instr->Bits(31, 30) == 0x1) {
+        DecodeAdvSIMDDataProcessing(instr);
+      } else {
         if (instr->Bit(24) == 0) {
           if (instr->Bit(21) == 0) {
             if ((instr->Bit(23) == 1) ||
                 (instr->Bit(18) == 1) ||
                 (instr->Mask(0x80008000) == 0x00000000) ||
                 (instr->Mask(0x000E0000) == 0x00000000) ||
                 (instr->Mask(0x000E0000) == 0x000A0000) ||
                 (instr->Mask(0x00160000) == 0x00000000) ||
                 (instr->Mask(0x00160000) == 0x00120000)) {
               V::VisitUnallocated(instr);
@@ skipping 86 matching lines @@
           }
         } else {
           // Bit 30 == 1 has been handled earlier.
           DCHECK(instr->Bit(30) == 0);
           if (instr->Mask(0xA0800000) != 0) {
             V::VisitUnallocated(instr);
           } else {
             V::VisitFPDataProcessing3Source(instr);
           }
         }
-      } else {
-        V::VisitUnallocated(instr);
-      }
-    }
-  }
-}
-
-template <typename V>
-void Decoder<V>::DecodeNEONLoadStore(Instruction* instr) {
-  DCHECK(instr->Bits(29, 25) == 0x6);
-  if (instr->Bit(31) == 0) {
-    if ((instr->Bit(24) == 0) && (instr->Bit(21) == 1)) {
-      V::VisitUnallocated(instr);
-      return;
-    }
-
-    if (instr->Bit(23) == 0) {
-      if (instr->Bits(20, 16) == 0) {
-        if (instr->Bit(24) == 0) {
-          V::VisitNEONLoadStoreMultiStruct(instr);
-        } else {
-          V::VisitNEONLoadStoreSingleStruct(instr);
-        }
-      } else {
-        V::VisitUnallocated(instr);
-      }
-    } else {
-      if (instr->Bit(24) == 0) {
-        V::VisitNEONLoadStoreMultiStructPostIndex(instr);
-      } else {
-        V::VisitNEONLoadStoreSingleStructPostIndex(instr);
-      }
-    }
-  } else {
-    V::VisitUnallocated(instr);
-  }
-}
-
-template <typename V>
-void Decoder<V>::DecodeNEONVectorDataProcessing(Instruction* instr) {
-  DCHECK(instr->Bits(28, 25) == 0x7);
-  if (instr->Bit(31) == 0) {
-    if (instr->Bit(24) == 0) {
-      if (instr->Bit(21) == 0) {
-        if (instr->Bit(15) == 0) {
-          if (instr->Bit(10) == 0) {
-            if (instr->Bit(29) == 0) {
-              if (instr->Bit(11) == 0) {
-                V::VisitNEONTable(instr);
-              } else {
-                V::VisitNEONPerm(instr);
-              }
-            } else {
-              V::VisitNEONExtract(instr);
-            }
-          } else {
-            if (instr->Bits(23, 22) == 0) {
-              V::VisitNEONCopy(instr);
-            } else {
-              V::VisitUnallocated(instr);
-            }
-          }
-        } else {
-          V::VisitUnallocated(instr);
-        }
-      } else {
-        if (instr->Bit(10) == 0) {
-          if (instr->Bit(11) == 0) {
-            V::VisitNEON3Different(instr);
-          } else {
-            if (instr->Bits(18, 17) == 0) {
-              if (instr->Bit(20) == 0) {
-                if (instr->Bit(19) == 0) {
-                  V::VisitNEON2RegMisc(instr);
-                } else {
-                  if (instr->Bits(30, 29) == 0x2) {
-                    V::VisitUnallocated(instr);
-                  } else {
-                    V::VisitUnallocated(instr);
-                  }
-                }
-              } else {
-                if (instr->Bit(19) == 0) {
-                  V::VisitNEONAcrossLanes(instr);
-                } else {
-                  V::VisitUnallocated(instr);
-                }
-              }
-            } else {
-              V::VisitUnallocated(instr);
-            }
-          }
-        } else {
-          V::VisitNEON3Same(instr);
-        }
-      }
-    } else {
-      if (instr->Bit(10) == 0) {
-        V::VisitNEONByIndexedElement(instr);
-      } else {
-        if (instr->Bit(23) == 0) {
-          if (instr->Bits(22, 19) == 0) {
-            V::VisitNEONModifiedImmediate(instr);
-          } else {
-            V::VisitNEONShiftImmediate(instr);
-          }
-        } else {
-          V::VisitUnallocated(instr);
-        }
-      }
-    }
-  } else {
-    V::VisitUnallocated(instr);
-  }
-}
-
-template <typename V>
-void Decoder<V>::DecodeNEONScalarDataProcessing(Instruction* instr) {
-  DCHECK(instr->Bits(28, 25) == 0xF);
-  if (instr->Bit(24) == 0) {
-    if (instr->Bit(21) == 0) {
-      if (instr->Bit(15) == 0) {
-        if (instr->Bit(10) == 0) {
-          if (instr->Bit(29) == 0) {
-            if (instr->Bit(11) == 0) {
-              V::VisitUnallocated(instr);
-            } else {
-              V::VisitUnallocated(instr);
-            }
-          } else {
-            V::VisitUnallocated(instr);
-          }
-        } else {
-          if (instr->Bits(23, 22) == 0) {
-            V::VisitNEONScalarCopy(instr);
-          } else {
-            V::VisitUnallocated(instr);
-          }
-        }
-      } else {
-        V::VisitUnallocated(instr);
-      }
-    } else {
-      if (instr->Bit(10) == 0) {
-        if (instr->Bit(11) == 0) {
-          V::VisitNEONScalar3Diff(instr);
-        } else {
-          if (instr->Bits(18, 17) == 0) {
-            if (instr->Bit(20) == 0) {
-              if (instr->Bit(19) == 0) {
-                V::VisitNEONScalar2RegMisc(instr);
-              } else {
-                if (instr->Bit(29) == 0) {
-                  V::VisitUnallocated(instr);
-                } else {
-                  V::VisitUnallocated(instr);
-                }
-              }
-            } else {
-              if (instr->Bit(19) == 0) {
-                V::VisitNEONScalarPairwise(instr);
-              } else {
-                V::VisitUnallocated(instr);
-              }
-            }
-          } else {
-            V::VisitUnallocated(instr);
-          }
-        }
-      } else {
-        V::VisitNEONScalar3Same(instr);
-      }
-    }
-  } else {
-    if (instr->Bit(10) == 0) {
-      V::VisitNEONScalarByIndexedElement(instr);
-    } else {
-      if (instr->Bit(23) == 0) {
-        V::VisitNEONScalarShiftImmediate(instr);
-      } else {
-        V::VisitUnallocated(instr);
       }
     }
   }
 }
 
 
+template<typename V>
+void Decoder<V>::DecodeAdvSIMDLoadStore(Instruction* instr) {
+  // TODO(all): Implement Advanced SIMD load/store instruction decode.
+  DCHECK(instr->Bits(29, 25) == 0x6);
+  V::VisitUnimplemented(instr);
+}
+
+
+template<typename V>
+void Decoder<V>::DecodeAdvSIMDDataProcessing(Instruction* instr) {
+  // TODO(all): Implement Advanced SIMD data processing instruction decode.
+  DCHECK(instr->Bits(27, 25) == 0x7);
+  V::VisitUnimplemented(instr);
+}
+
+
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_ARM64_DECODER_ARM64_INL_H_