[stubs] Port builtin for Array.push fast-case from Crankshaft to TF

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"
 #include "src/globals.h"
 #include "src/objects.h"
 
 namespace v8 {
 namespace internal {
 
 class CallInterfaceDescriptor;
+class CodeStubArguments;
 class StatsCounter;
 class StubCache;
 
 enum class PrimitiveType { kBoolean, kNumber, kString, kSymbol };
 
 #define HEAP_CONSTANT_LIST(V)                 \
   V(BooleanMap, BooleanMap)                   \
   V(CodeMap, CodeMap)                         \
   V(empty_string, EmptyString)                \
   V(EmptyFixedArray, EmptyFixedArray)         \
@@ skipping 34 matching lines @@
   // On 32-bit platforms, there is a slight performance advantage to doing all
   // of the array offset/index arithmetic with SMIs, since it's possible
   // to save a few tag/untag operations without paying an extra expense when
   // calculating array offset (the smi math can be folded away) and there are
   // fewer live ranges. Thus only convert indices to untagged value on 64-bit
   // platforms.
   ParameterMode OptimalParameterMode() const {
     return Is64() ? INTPTR_PARAMETERS : SMI_PARAMETERS;
   }
 
+  MachineRepresentation OptimalParameterRepresentation() const {
+    return OptimalParameterMode() == INTPTR_PARAMETERS
+               ? MachineType::PointerRepresentation()
+               : MachineRepresentation::kTaggedSigned;
+  }
+
   compiler::Node* UntagParameter(compiler::Node* value, ParameterMode mode) {
     if (mode != SMI_PARAMETERS) value = SmiUntag(value);
     return value;
   }
 
   compiler::Node* TagParameter(compiler::Node* value, ParameterMode mode) {
     if (mode != SMI_PARAMETERS) value = SmiTag(value);
     return value;
   }
 
@@ skipping 53 matching lines @@
   compiler::Node* SmiMod(compiler::Node* a, compiler::Node* b);
   // Computes a * b for Smi inputs a and b; result is not necessarily a Smi.
   compiler::Node* SmiMul(compiler::Node* a, compiler::Node* b);
   compiler::Node* SmiOr(compiler::Node* a, compiler::Node* b) {
     return BitcastWordToTaggedSigned(
         WordOr(BitcastTaggedToWord(a), BitcastTaggedToWord(b)));
   }
 
   // Smi | HeapNumber operations.
   compiler::Node* NumberInc(compiler::Node* value);
+  void GotoIfNotNumber(compiler::Node* value, Label* is_not_number);

[Jakob Kummerow, 2016/11/23 17:17:06]

nit: when you rebase, please drop all the "compiler::" prefixes from your
changes in this file, we don't need them anymore.

[danno, 2016/11/29 14:39:59]

Done.

+  void GotoIfNumber(compiler::Node* value, Label* is_number);
 
   // Allocate an object of the given size.
   compiler::Node* Allocate(compiler::Node* size, AllocationFlags flags = kNone);
   compiler::Node* Allocate(int size, AllocationFlags flags = kNone);
   compiler::Node* InnerAllocate(compiler::Node* previous, int offset);
   compiler::Node* InnerAllocate(compiler::Node* previous,
                                 compiler::Node* offset);
   compiler::Node* IsRegularHeapObjectSize(compiler::Node* size);
 
   typedef std::function<compiler::Node*()> ConditionBody;
   void Assert(ConditionBody condition_body, const char* string = nullptr,
               const char* file = nullptr, int line = 0);
 
   // Check a value for smi-ness
   compiler::Node* TaggedIsSmi(compiler::Node* a);
+  compiler::Node* TaggedIsNotSmi(compiler::Node* a);
   // Check that the value is a non-negative smi.
   compiler::Node* WordIsPositiveSmi(compiler::Node* a);
   // Check that a word has a word-aligned address.
   compiler::Node* WordIsWordAligned(compiler::Node* word);
   compiler::Node* WordIsPowerOfTwo(compiler::Node* value);
 
   void BranchIfSmiEqual(compiler::Node* a, compiler::Node* b, Label* if_true,
                         Label* if_false) {
     Branch(SmiEqual(a, b), if_true, if_false);
   }
@@ skipping 24 matching lines @@
   void BranchIfSimd128Equal(compiler::Node* lhs, compiler::Node* rhs,
                             Label* if_equal, Label* if_notequal) {
     BranchIfSimd128Equal(lhs, LoadMap(lhs), rhs, LoadMap(rhs), if_equal,
                          if_notequal);
   }
 
   void BranchIfJSReceiver(compiler::Node* object, Label* if_true,
                           Label* if_false);
   void BranchIfJSObject(compiler::Node* object, Label* if_true,
                         Label* if_false);
+
+  enum class FastJSArrayAccessMode { INBOUNDS_READ, ANY_ACCESS };
+
   void BranchIfFastJSArray(compiler::Node* object, compiler::Node* context,
-                           Label* if_true, Label* if_false);
+                           FastJSArrayAccessMode mode, Label* if_true,
+                           Label* if_false);
 
   // Load value from current frame by given offset in bytes.
   compiler::Node* LoadFromFrame(int offset,
                                 MachineType rep = MachineType::AnyTagged());
   // Load value from current parent frame by given offset in bytes.
   compiler::Node* LoadFromParentFrame(
       int offset, MachineType rep = MachineType::AnyTagged());
 
   // Load an object pointer from a buffer that isn't in the heap.
   compiler::Node* LoadBufferObject(compiler::Node* buffer, int offset,
@@ skipping 149 matching lines @@
 
   compiler::Node* StoreFixedArrayElement(
       compiler::Node* object, compiler::Node* index, compiler::Node* value,
       WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER,
       ParameterMode parameter_mode = INTEGER_PARAMETERS);
 
   compiler::Node* StoreFixedDoubleArrayElement(
       compiler::Node* object, compiler::Node* index, compiler::Node* value,
       ParameterMode parameter_mode = INTEGER_PARAMETERS);
 
+  compiler::Node* BuildAppendJSArray(ElementsKind kind, compiler::Node* context,
+                                     compiler::Node* array,
+                                     CodeStubArguments& args,
+                                     Variable& arg_index, Label* bailout);
+
   void StoreFieldsNoWriteBarrier(compiler::Node* start_address,
                                  compiler::Node* end_address,
                                  compiler::Node* value);
 
   // Allocate a HeapNumber without initializing its value.
   compiler::Node* AllocateHeapNumber(MutableMode mode = IMMUTABLE);
   // Allocate a HeapNumber with a specific value.
   compiler::Node* AllocateHeapNumberWithValue(compiler::Node* value,
                                               MutableMode mode = IMMUTABLE);
   // Allocate a SeqOneByteString with the given length.
@@ skipping 190 matching lines @@
                                           compiler::Node* value);
   compiler::Node* TruncateTaggedToWord32(compiler::Node* context,
                                          compiler::Node* value);
   // Truncate the floating point value of a HeapNumber to an Int32.
   compiler::Node* TruncateHeapNumberValueToWord32(compiler::Node* object);
 
   // Conversions.
   compiler::Node* ChangeFloat64ToTagged(compiler::Node* value);
   compiler::Node* ChangeInt32ToTagged(compiler::Node* value);
   compiler::Node* ChangeUint32ToTagged(compiler::Node* value);
+  compiler::Node* ChangeNumberToFloat64(compiler::Node* value);
 
   // Type conversions.
   // Throws a TypeError for {method_name} if {value} is not coercible to Object,
   // or returns the {value} converted to a String otherwise.
   compiler::Node* ToThisString(compiler::Node* context, compiler::Node* value,
                                char const* method_name);
   // Throws a TypeError for {method_name} if {value} is neither of the given
   // {primitive_type} nor a JSValue wrapping a value of {primitive_type}, or
   // returns the {value} (or wrapped value) otherwise.
   compiler::Node* ToThisValue(compiler::Node* context, compiler::Node* value,
@@ skipping 140 matching lines @@
   template <typename T>
   compiler::Node* IsSetWord(compiler::Node* word) {
     return WordNotEqual(WordAnd(word, IntPtrConstant(T::kMask)),
                         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
   // "live" to avoid assertion failures during graph building. In the resulting
   // code this check will be eliminated.
   void Use(Label* label);
 
   // Various building blocks for stubs doing property lookups.
   void TryToName(compiler::Node* key, Label* if_keyisindex, Variable* var_index,
                  Label* if_keyisunique, Label* if_bailout);
 
   // Calculates array index for given dictionary entry and entry field.
@@ skipping 487 matching lines @@
 };
 
 class CodeStubArguments {
  public:
   // |argc| specifies the number of arguments passed to the builtin excluding
   // the receiver.
   CodeStubArguments(CodeStubAssembler* assembler, compiler::Node* argc,
                     CodeStubAssembler::ParameterMode mode =
                         CodeStubAssembler::INTPTR_PARAMETERS);
 
-  compiler::Node* GetReceiver();
+  compiler::Node* GetReceiver() const;
 
   // |index| is zero-based and does not include the receiver
   compiler::Node* AtIndex(compiler::Node* index,
                           CodeStubAssembler::ParameterMode mode =
-                              CodeStubAssembler::INTPTR_PARAMETERS);
+                              CodeStubAssembler::INTPTR_PARAMETERS) const;
 
-  compiler::Node* AtIndex(int index);
+  compiler::Node* AtIndex(int index) const;
+
+  compiler::Node* GetLength() const { return argc_; }
 
   typedef std::function<void(CodeStubAssembler* assembler, compiler::Node* arg)>
       ForEachBodyFunction;
 
   // Iteration doesn't include the receiver. |first| and |last| are zero-based.
   void ForEach(ForEachBodyFunction body, compiler::Node* first = nullptr,
                compiler::Node* last = nullptr,
                CodeStubAssembler::ParameterMode mode =
                    CodeStubAssembler::INTPTR_PARAMETERS) {
     CodeStubAssembler::VariableList list(0, assembler_->zone());
@@ skipping 32 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_