V8. ASM-2-WASM. Changes the asm-types library.

src/wasm/asm-types.h

 // Copyright 2016 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 SRC_WASM_ASM_TYPES_H_
 #define SRC_WASM_ASM_TYPES_H_
 
 #include <string>
-#include <type_traits>
 
 #include "src/base/macros.h"
 #include "src/zone-containers.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 class AsmType;
@@ skipping 20 matching lines @@
   V(Float, "float", 13, kAsmFloatQ)                                           \
   /* Types used for expressing the Heap accesses. */                          \
   V(Uint8Array, "Uint8Array", 14, kAsmHeap)                                   \
   V(Int8Array, "Int8Array", 15, kAsmHeap)                                     \
   V(Uint16Array, "Uint16Array", 16, kAsmHeap)                                 \
   V(Int16Array, "Int16Array", 17, kAsmHeap)                                   \
   V(Uint32Array, "Uint32Array", 18, kAsmHeap)                                 \
   V(Int32Array, "Int32Array", 19, kAsmHeap)                                   \
   V(Float32Array, "Float32Array", 20, kAsmHeap)                               \
   V(Float64Array, "Float64Array", 21, kAsmHeap)                               \
-  V(FloatishDoubleQ, "floatish|double?", 22, kAsmFloatish | kAsmDoubleQ)      \
-  V(FloatQDoubleQ, "float?|double?", 23, kAsmFloatQ | kAsmDoubleQ)            \
+  /* Pseudo-types used in representing heap access for fp types.*/            \
+  V(FloatishDoubleQ, "floatish|double?", 23, kAsmFloatish | kAsmDoubleQ)      \
+  V(FloatQDoubleQ, "float?|double?", 24, kAsmFloatQ | kAsmDoubleQ)            \
   /* None is used to represent errors in the type checker. */                 \
   V(None, "<none>", 31, 0)
 
 // List of V(CamelName)
 #define FOR_EACH_ASM_CALLABLE_TYPE_LIST(V) \
   V(FunctionType)                          \
   V(OverloadedFunctionType)
 
 class AsmValueType {
  public:
@@ skipping 131 matching lines @@
   }
 
   // Overloaded function types. Not creatable by asm source, but useful to
   // represent the overloaded stdlib functions.
   static AsmType* OverloadedFunction(Zone* zone) {
     auto* f = new (zone) AsmOverloadedFunctionType(zone);
     return reinterpret_cast<AsmType*>(f);
   }
 
   // The type for fround(src).
-  static AsmType* FroundType(Zone* zone, AsmType* src);
+  static AsmType* FroundType(Zone* zone);
 
   // The (variadic) type for min and max.
-  static AsmType* MinMaxType(Zone* zone, AsmType* type);
+  static AsmType* MinMaxType(Zone* zone, AsmType* dest, AsmType* src);
 
   std::string Name();
   // IsExactly returns true if this is the exact same type as that. For
   // non-value types (e.g., callables), this returns this == that.
   bool IsExactly(AsmType* that);
   // IsA is used to query whether this is an instance of that (i.e., if this is
   // a type derived from that.) For non-value types (e.g., callables), this
   // returns this == that.
   bool IsA(AsmType* that);
 
@@ skipping 29 matching lines @@
   // Returns the store type if this is a heap type. AsmType::None is returned if
   // this is not a heap type.
   AsmType* StoreType();
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // SRC_WASM_ASM_TYPES_H_