[stubs] Enable graph verification for builtins.

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 67 matching lines @@
   ParameterMode OptimalParameterMode() const {
     return Is64() ? INTPTR_PARAMETERS : SMI_PARAMETERS;
   }
 
   MachineRepresentation OptimalParameterRepresentation() const {
     return OptimalParameterMode() == INTPTR_PARAMETERS
                ? MachineType::PointerRepresentation()
                : MachineRepresentation::kTaggedSigned;
   }
 
-  Node* UntagParameter(Node* value, ParameterMode mode) {
-    if (mode != SMI_PARAMETERS) value = SmiUntag(value);
+  Node* ParameterToWord(Node* value, ParameterMode mode) {
+    if (mode == SMI_PARAMETERS) value = SmiUntag(value);
     return value;
   }
 
-  Node* TagParameter(Node* value, ParameterMode mode) {
+  Node* WordToParameter(Node* value, ParameterMode mode) {
+    if (mode == SMI_PARAMETERS) value = SmiTag(value);
+    return value;
+  }
+
+  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;
+  }
+
 #define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName, Int32OpName) \
   Node* OpName(Node* a, Node* b, ParameterMode mode) {                \
     if (mode == SMI_PARAMETERS) {                                     \
       return SmiOpName(a, b);                                         \
     } else if (mode == INTPTR_PARAMETERS) {                           \
       return IntPtrOpName(a, b);                                      \
     } else {                                                          \
       DCHECK_EQ(INTEGER_PARAMETERS, mode);                            \
       return Int32OpName(a, b);                                       \
     }                                                                 \
   }
   PARAMETER_BINOP(IntPtrOrSmiAdd, IntPtrAdd, SmiAdd, Int32Add)
   PARAMETER_BINOP(IntPtrOrSmiLessThan, IntPtrLessThan, SmiLessThan,
                   Int32LessThan)
   PARAMETER_BINOP(IntPtrOrSmiGreaterThan, IntPtrGreaterThan, SmiGreaterThan,
                   Int32GreaterThan)
+  PARAMETER_BINOP(IntPtrOrSmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual,
+                  SmiGreaterThanOrEqual, Int32GreaterThanOrEqual)
   PARAMETER_BINOP(UintPtrOrSmiLessThan, UintPtrLessThan, SmiBelow,
                   Uint32LessThan)
   PARAMETER_BINOP(UintPtrOrSmiGreaterThanOrEqual, UintPtrGreaterThanOrEqual,
                   SmiAboveOrEqual, Uint32GreaterThanOrEqual)
 #undef PARAMETER_BINOP
 
   Node* NoContextConstant();
 #define HEAP_CONSTANT_ACCESSOR(rootName, name) Node* name##Constant();
   HEAP_CONSTANT_LIST(HEAP_CONSTANT_ACCESSOR)
 #undef HEAP_CONSTANT_ACCESSOR
@@ skipping 59 matching lines @@
   Node* SmiOpName(Node* a, Node* b) {                                    \
     return IntPtrOpName(BitcastTaggedToWord(a), BitcastTaggedToWord(b)); \
   }
   SMI_COMPARISON_OP(SmiEqual, WordEqual)
   SMI_COMPARISON_OP(SmiAbove, UintPtrGreaterThan)
   SMI_COMPARISON_OP(SmiAboveOrEqual, UintPtrGreaterThanOrEqual)
   SMI_COMPARISON_OP(SmiBelow, UintPtrLessThan)
   SMI_COMPARISON_OP(SmiLessThan, IntPtrLessThan)
   SMI_COMPARISON_OP(SmiLessThanOrEqual, IntPtrLessThanOrEqual)
   SMI_COMPARISON_OP(SmiGreaterThan, IntPtrGreaterThan)
+  SMI_COMPARISON_OP(SmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual)
 #undef SMI_COMPARISON_OP
   Node* SmiMax(Node* a, Node* b);
   Node* SmiMin(Node* a, Node* b);
   // Computes a % b for Smi inputs a and b; result is not necessarily a Smi.
   Node* SmiMod(Node* a, Node* b);
   // Computes a * b for Smi inputs a and b; result is not necessarily a Smi.
   Node* SmiMul(Node* a, Node* b);
 
   // Smi | HeapNumber operations.
   Node* NumberInc(Node* value);
@@ skipping 547 matching lines @@
 
   // Returns true if any of the mask's bits in given |word32| are set.
   Node* IsSetWord32(Node* word32, uint32_t mask) {
     return Word32NotEqual(Word32And(word32, Int32Constant(mask)),
                           Int32Constant(0));
   }
 
   // Returns true if any of the |T|'s bits in given |word| are set.
   template <typename T>
   Node* IsSetWord(Node* word) {
-    return WordNotEqual(WordAnd(word, IntPtrConstant(T::kMask)),
-                        IntPtrConstant(0));
+    return IsSetWord(word, T::kMask);
   }
 
   // Returns true if any of the mask's bits in given |word| are set.
   Node* IsSetWord(Node* word, uint32_t mask) {
-    return WordNotEqual(WordAnd(word, Int32Constant(mask)), Int32Constant(0));
+    return WordNotEqual(WordAnd(word, IntPtrConstant(mask)), IntPtrConstant(0));
   }
 
   void SetCounter(StatsCounter* counter, int value);
   void IncrementCounter(StatsCounter* counter, int delta);
   void DecrementCounter(StatsCounter* counter, int delta);
 
   void Increment(Variable& variable, int value = 1,
                  ParameterMode mode = INTPTR_PARAMETERS);
 
   // Generates "if (false) goto label" code. Useful for marking a label as
@@ skipping 355 matching lines @@
   Node* AllocateConsString(Heap::RootListIndex map_root_index, Node* length,
                            Node* first, Node* second, AllocationFlags flags);
 
   static const int kElementLoopUnrollThreshold = 8;
 };
 
 class CodeStubArguments {
  public:
   typedef compiler::Node Node;
 
-  // |argc| specifies the number of arguments passed to the builtin excluding
-  // the receiver.
-  CodeStubArguments(CodeStubAssembler* assembler, Node* argc,
-                    CodeStubAssembler::ParameterMode mode =
-                        CodeStubAssembler::INTPTR_PARAMETERS);
+  // |argc| is an uint32 value which specifies the number of arguments passed
+  // to the builtin excluding the receiver.
+  CodeStubArguments(CodeStubAssembler* assembler, Node* argc);
 
   Node* GetReceiver() const;
 
   // |index| is zero-based and does not include the receiver
   Node* AtIndex(Node* index, CodeStubAssembler::ParameterMode mode =
                                  CodeStubAssembler::INTPTR_PARAMETERS) const;
 
   Node* AtIndex(int index) const;
 
   Node* GetLength() const { return argc_; }
@@ skipping 39 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_