Emit mementos in crankshaft.

src/hydrogen.h

 // Copyright 2012 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_HYDROGEN_H_
 #define V8_HYDROGEN_H_
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 987 matching lines @@
   HBasicBlock* true_branch() const { return true_branch_; }
   HBasicBlock* false_branch() const { return false_branch_; }
 
  private:
   bool continuation_captured_;
   HBasicBlock* true_branch_;
   HBasicBlock* false_branch_;
 };
 
 
-class HAllocationMode V8_FINAL BASE_EMBEDDED {
- public:
-  explicit HAllocationMode(Handle<AllocationSite> feedback_site)
-      : current_site_(NULL), feedback_site_(feedback_site),
-        pretenure_flag_(NOT_TENURED) {}
-  explicit HAllocationMode(HValue* current_site)
-      : current_site_(current_site), pretenure_flag_(NOT_TENURED) {}
-  explicit HAllocationMode(PretenureFlag pretenure_flag)
-      : current_site_(NULL), pretenure_flag_(pretenure_flag) {}
-  HAllocationMode()
-      : current_site_(NULL), pretenure_flag_(NOT_TENURED) {}
-
-  HValue* current_site() const { return current_site_; }
-  Handle<AllocationSite> feedback_site() const { return feedback_site_; }
-
-  bool CreateAllocationMementos() const V8_WARN_UNUSED_RESULT {
-    return current_site() != NULL;
-  }
-
-  PretenureFlag GetPretenureMode() const V8_WARN_UNUSED_RESULT {
-    if (!feedback_site().is_null()) return feedback_site()->GetPretenureMode();
-    return pretenure_flag_;
-  }
-
- private:
-  HValue* current_site_;
-  Handle<AllocationSite> feedback_site_;
-  PretenureFlag pretenure_flag_;
-};
-
-
 class HGraphBuilder {
  public:
   explicit HGraphBuilder(CompilationInfo* info)
       : info_(info),
         graph_(NULL),
         current_block_(NULL),
         position_(HSourcePosition::Unknown()),
         start_position_(0) {}
   virtual ~HGraphBuilder() {}
 
@@ skipping 1018 matching lines @@
   FunctionState* function_state() const { return function_state_; }
 
   void VisitDeclarations(ZoneList<Declaration*>* declarations);
 
   void* operator new(size_t size, Zone* zone) {
     return zone->New(static_cast<int>(size));
   }
   void operator delete(void* pointer, Zone* zone) { }
   void operator delete(void* pointer) { }
 
+  void InitializeAllocationModeForCallNew(CallNew* expr, HAllocationMode* mode);
+
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
  protected:
   // Type of a member function that generates inline code for a native function.
   typedef void (HOptimizedGraphBuilder::*InlineFunctionGenerator)
       (CallRuntime* call);
 
   // Forward declarations for inner scope classes.
   class SubgraphScope;
 
@@ skipping 167 matching lines @@
                                             LookupResult* lookup,
                                             PropertyAccessType access_type);
 
   void EnsureArgumentsArePushedForAccess();
   bool TryArgumentsAccess(Property* expr);
 
   // Try to optimize fun.apply(receiver, arguments) pattern.
   bool TryCallApply(Call* expr);
 
   bool TryHandleArrayCall(Call* expr, HValue* function);
-  bool TryHandleArrayCallNew(CallNew* expr, HValue* function);
+  bool TryHandleArrayCallNew(CallNew* expr, HValue* function,
+                             HAllocationMode mode);
   void BuildArrayCall(Expression* expr, int arguments_count, HValue* function,
-                      Handle<AllocationSite> cell);
+                      Handle<AllocationSite> cell, HAllocationMode mode);
 
   enum ArrayIndexOfMode { kFirstIndexOf, kLastIndexOf };
   HValue* BuildArrayIndexOf(HValue* receiver,
                             HValue* search_element,
                             ElementsKind kind,
                             ArrayIndexOfMode mode);
 
   HValue* ImplicitReceiverFor(HValue* function,
                               Handle<JSFunction> target);
 
@@ skipping 76 matching lines @@
       ExternalArrayType array_type, size_t element_size,
       ElementsKind fixed_elements_kind,
       HValue* byte_length, HValue* length);
 
   Handle<JSFunction> array_function() {
     return handle(isolate()->native_context()->array_function());
   }
 
   bool IsCallArrayInlineable(int argument_count, Handle<AllocationSite> site);
   void BuildInlinedCallArray(Expression* expression, int argument_count,
-                             Handle<AllocationSite> site);
+                             HAllocationMode mode, Handle<AllocationSite> site);
 
   class PropertyAccessInfo {
    public:
     PropertyAccessInfo(HOptimizedGraphBuilder* builder,
                        PropertyAccessType access_type,
                        Type* type,
                        Handle<String> name)
         : lookup_(builder->isolate()),
           builder_(builder),
           access_type_(access_type),
@@ skipping 456 matching lines @@
   }
 
  private:
   HGraphBuilder* builder_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_