Vector ICs: ObjectLiteral refactoring for Oracle feedback

src/full-codegen/full-codegen.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_FULL_CODEGEN_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_FULL_CODEGEN_H_
 
 #include "src/allocation.h"
 #include "src/assert-scope.h"
 #include "src/ast.h"
@@ skipping 534 matching lines @@
   // Platform-specific code for loading variables.
   void EmitLoadGlobalCheckExtensions(VariableProxy* proxy,
                                      TypeofMode typeof_mode, Label* slow);
   MemOperand ContextSlotOperandCheckExtensions(Variable* var, Label* slow);
   void EmitDynamicLookupFastCase(VariableProxy* proxy, TypeofMode typeof_mode,
                                  Label* slow, Label* done);
   void EmitGlobalVariableLoad(VariableProxy* proxy, TypeofMode typeof_mode);
   void EmitVariableLoad(VariableProxy* proxy,
                         TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
 
-  void EmitAccessor(Expression* expression);
+  void EmitAccessor(ObjectLiteralProperty* property);
 
   bool NeedsHoleCheckForLoad(VariableProxy* proxy);
 
   // Expects the arguments and the function already pushed.
   void EmitResolvePossiblyDirectEval(int arg_count);
 
   // Platform-specific support for allocating a new closure based on
   // the given function info.
   void EmitNewClosure(Handle<SharedFunctionInfo> info, bool pretenure);
 
@@ skipping 13 matching lines @@
   // Expect receiver ('this' value), home_object and key on the stack.
   void EmitKeyedSuperPropertyLoad(Property* expr);
 
   // Load a value from a keyed property.
   // The receiver and the key is left on the stack by the IC.
   void EmitKeyedPropertyLoad(Property* expr);
 
   // Adds the properties to the class (function) object and to its prototype.
   // Expects the class (function) in the accumulator. The class (function) is
   // in the accumulator after installing all the properties.
-  void EmitClassDefineProperties(ClassLiteral* lit, int* used_store_slots);
+  void EmitClassDefineProperties(ClassLiteral* lit);
 
   // Pushes the property key as a Name on the stack.
   void EmitPropertyKey(ObjectLiteralProperty* property, BailoutId bailout_id);
 
   // Apply the compound assignment operator. Expects the left operand on top
   // of the stack and the right one in the accumulator.
   void EmitBinaryOp(BinaryOperation* expr, Token::Value op);
 
   // Helper functions for generating inlined smi code for certain
   // binary operations.
@@ skipping 33 matching lines @@
   // accumulator.
   void EmitKeyedPropertyAssignment(Assignment* expr);
 
   static bool NeedsHomeObject(Expression* expr) {
     return FunctionLiteral::NeedsHomeObject(expr);
   }
 
   // Adds the [[HomeObject]] to |initializer| if it is a FunctionLiteral.
   // The value of the initializer is expected to be at the top of the stack.
   // |offset| is the offset in the stack where the home object can be found.
-  void EmitSetHomeObjectIfNeeded(
-      Expression* initializer, int offset,
-      FeedbackVectorICSlot slot = FeedbackVectorICSlot::Invalid());
+  void EmitSetHomeObject(Expression* initializer, int offset,
+                         FeedbackVectorICSlot slot);
+
+  void EmitSetHomeObjectAccumulator(Expression* initializer, int offset,
+                                    FeedbackVectorICSlot slot);
 
   void EmitLoadSuperConstructor(SuperCallReference* super_call_ref);
 
   void CallIC(Handle<Code> code,
               TypeFeedbackId id = TypeFeedbackId::None());
 
   // Inside typeof reference errors are never thrown.
   void CallLoadIC(TypeofMode typeof_mode, LanguageMode language_mode = SLOPPY,
                   TypeFeedbackId id = TypeFeedbackId::None());
   void CallStoreIC(TypeFeedbackId id = TypeFeedbackId::None());
@@ skipping 426 matching lines @@
 
   Address start_;
   Address instruction_start_;
   uint32_t length_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_FULL_CODEGEN_H_