[csa] Add assertions to CSA

src/code-stub-assembler.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 V8_CODE_STUB_ASSEMBLER_H_
 #define V8_CODE_STUB_ASSEMBLER_H_
 
 #include <functional>
 
 #include "src/compiler/code-assembler.h"
@@ skipping 23 matching lines @@
   V(FeedbackVectorMap, FeedbackVectorMap)             \
   V(FixedArrayMap, FixedArrayMap)                     \
   V(FixedCOWArrayMap, FixedCOWArrayMap)               \
   V(FixedDoubleArrayMap, FixedDoubleArrayMap)         \
   V(FunctionTemplateInfoMap, FunctionTemplateInfoMap) \
   V(GlobalPropertyCellMap, PropertyCellMap)           \
   V(has_instance_symbol, HasInstanceSymbol)           \
   V(HeapNumberMap, HeapNumberMap)                     \
   V(length_string, LengthString)                      \
   V(ManyClosuresCellMap, ManyClosuresCellMap)         \
+  V(MetaMap, MetaMap)                                 \
   V(MinusZeroValue, MinusZero)                        \
   V(MutableHeapNumberMap, MutableHeapNumberMap)       \
   V(NanValue, Nan)                                    \
   V(NoClosuresCellMap, NoClosuresCellMap)             \
   V(NullValue, Null)                                  \
   V(OneClosureCellMap, OneClosureCellMap)             \
   V(prototype_string, PrototypeString)                \
   V(SpeciesProtector, SpeciesProtector)               \
   V(SymbolMap, SymbolMap)                             \
   V(TheHoleValue, TheHole)                            \
@@ skipping 56 matching lines @@
   Node* ParameterToTagged(Node* value, ParameterMode mode) {
     if (mode != SMI_PARAMETERS) value = SmiTag(value);
     return value;
   }
 
   Node* TaggedToParameter(Node* value, ParameterMode mode) {
     if (mode != SMI_PARAMETERS) value = SmiUntag(value);
     return value;
   }
 
+  Node* MatchesParameterMode(Node* value, ParameterMode mode);
+
 #define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName) \
   Node* OpName(Node* a, Node* b, ParameterMode mode) {   \
     if (mode == SMI_PARAMETERS) {                        \
       return SmiOpName(a, b);                            \
     } else {                                             \
       DCHECK_EQ(INTPTR_PARAMETERS, mode);                \
       return IntPtrOpName(a, b);                         \
     }                                                    \
   }
   PARAMETER_BINOP(IntPtrOrSmiMin, IntPtrMin, SmiMin)
@@ skipping 639 matching lines @@
   Node* IsJSReceiver(Node* object);
   Node* IsJSReceiverMap(Node* map);
   Node* IsMap(Node* object);
   Node* IsCallableMap(Node* map);
   Node* IsDeprecatedMap(Node* map);
   Node* IsCallable(Node* object);
   Node* IsBoolean(Node* object);
   Node* IsPropertyCell(Node* object);
   Node* IsAccessorInfo(Node* object);
   Node* IsAccessorPair(Node* object);
+  Node* IsAnyHeapNumber(Node* object);
   Node* IsHeapNumber(Node* object);
   Node* IsMutableHeapNumber(Node* object);
   Node* IsName(Node* object);
   Node* IsSymbolInstanceType(Node* instance_type);
   Node* IsSymbol(Node* object);
   Node* IsPrivateSymbol(Node* object);
   Node* IsJSValueInstanceType(Node* instance_type);
   Node* IsJSValue(Node* object);
   Node* IsJSValueMap(Node* map);
   Node* IsJSArrayInstanceType(Node* instance_type);
   Node* IsJSArray(Node* object);
   Node* IsJSArrayMap(Node* object);
+  Node* IsFixedArray(Node* object);
+  Node* IsFixedArrayWithKindOrEmpty(Node* object, ElementsKind kind);
+  Node* IsFixedArrayWithKind(Node* object, ElementsKind kind);
   Node* IsNativeContext(Node* object);
   Node* IsWeakCell(Node* object);
   Node* IsFixedDoubleArray(Node* object);
   Node* IsHashTable(Node* object);
   Node* IsDictionary(Node* object);
   Node* IsUnseededNumberDictionary(Node* object);
   Node* IsConstructorMap(Node* map);
   Node* IsJSFunctionInstanceType(Node* instance_type);
   Node* IsJSFunction(Node* object);
   Node* IsJSFunctionMap(Node* object);
@@ skipping 30 matching lines @@
   // [from,to[ of string.  |from| and |to| are expected to be tagged.
   // If flags has the value FROM_TO_ARE_BOUNDED then from and to are in
   // the range [0, string-length)
   Node* SubString(Node* context, Node* string, Node* from, Node* to,
                   SubStringFlags flags = SubStringFlags::NONE);
 
   // Return a new string object produced by concatenating |first| with |second|.
   Node* StringAdd(Node* context, Node* first, Node* second,
                   AllocationFlags flags = kNone);
 
-  // Unpack the external string, returning a pointer that (offset-wise) looks
-  // like a sequential string.
-  // Note that this pointer is not tagged and does not point to a real
-  // sequential string instance, and may only be used to access the string
-  // data. The pointer is GC-safe as long as a reference to the container
-  // ExternalString is live.
-  // |string| must be an external string. Bailout for short external strings.
-  Node* TryDerefExternalString(Node* const string, Node* const instance_type,
-                               Label* if_bailout);
-
   // Check if |string| is an indirect (thin or flat cons) string type that can
   // be dereferenced by DerefIndirectString.
   void BranchIfCanDerefIndirectString(Node* string, Node* instance_type,
                                       Label* can_deref, Label* cannot_deref);
   // Unpack an indirect (thin or flat cons) string type.
   void DerefIndirectString(Variable* var_string, Node* instance_type);
   // Check if |var_string| has an indirect (thin or flat cons) string type,
   // and unpack it if so.
   void MaybeDerefIndirectString(Variable* var_string, Node* instance_type,
                                 Variable* var_did_something);
@@ skipping 808 matching lines @@
   }
 #else
 #define CSA_SLOW_ASSERT(csa, x) ((void)0)
 #endif
 
 DEFINE_OPERATORS_FOR_FLAGS(CodeStubAssembler::AllocationFlags);
 
 }  // namespace internal
 }  // namespace v8
 #endif  // V8_CODE_STUB_ASSEMBLER_H_