Implement target cache for constructor calls.

src/full-codegen.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 67 matching lines @@
   };
 
   explicit FullCodeGenerator(MacroAssembler* masm)
       : masm_(masm),
         info_(NULL),
         scope_(NULL),
         nesting_stack_(NULL),
         loop_depth_(0),
         context_(NULL),
         bailout_entries_(0),
-        stack_checks_(2) {  // There's always at least one.
+        stack_checks_(2),  // There's always at least one.
+        cache_cells_(0) {
   }
 
   static bool MakeCode(CompilationInfo* info);
 
   void Generate(CompilationInfo* info);
   void PopulateDeoptimizationData(Handle<Code> code);
+  void PopulateCacheCells(Handle<Code> code);
 
   Handle<FixedArray> handler_table() { return handler_table_; }
 
   class StateField : public BitField<State, 0, 8> { };
   class PcField    : public BitField<unsigned, 8, 32-8> { };
 
   static const char* State2String(State state) {
     switch (state) {
       case NO_REGISTERS: return "NO_REGISTERS";
       case TOS_REG: return "TOS_REG";
@@ skipping 280 matching lines @@
 
   // Platform-specific code for equality comparison with a nil-like value.
   void EmitLiteralCompareNil(CompareOperation* expr,
                              Expression* sub_expr,
                              NilValue nil);
 
   // Bailout support.
   void PrepareForBailout(Expression* node, State state);
   void PrepareForBailoutForId(unsigned id, State state);
 
+  // Cache cell support.  This associates AST ids with global property cells
+  // that will be cleared during GC and collected by the type-feedback oracle.
+  void RecordCacheCell(unsigned id, Handle<JSGlobalPropertyCell> cell);
+
   // Record a call's return site offset, used to rebuild the frame if the
   // called function was inlined at the site.
   void RecordJSReturnSite(Call* call);
 
   // Prepare for bailout before a test (or compare) and branch.  If
   // should_normalize, then the following comparison will not handle the
   // canonical JS true value so we will insert a (dead) test against true at
   // the actual bailout target from the optimized code. If not
   // should_normalize, the true and false labels are ignored.
   void PrepareForBailoutBeforeSplit(Expression* expr,
@@ skipping 159 matching lines @@
   void VisitLogicalExpression(BinaryOperation* expr);
   void VisitArithmeticExpression(BinaryOperation* expr);
 
   void VisitForTypeofValue(Expression* expr);
 
   struct BailoutEntry {
     unsigned id;
     unsigned pc_and_state;
   };
 
+  struct CacheCellEntry {
+    unsigned id;

[Vyacheslav Egorov (Chromium), 2012/01/25 15:51:55]

id -> ast_id ?

[Michael Starzinger, 2012/01/27 13:03:51]

Done.

+    Handle<JSGlobalPropertyCell> cell;
+  };
+
 
   class ExpressionContext BASE_EMBEDDED {
    public:
     explicit ExpressionContext(FullCodeGenerator* codegen)
         : masm_(codegen->masm()), old_(codegen->context()), codegen_(codegen) {
       codegen->set_new_context(this);
     }
 
     virtual ~ExpressionContext() {
       codegen_->set_new_context(old_);
@@ skipping 166 matching lines @@
 
   MacroAssembler* masm_;
   CompilationInfo* info_;
   Scope* scope_;
   Label return_label_;
   NestedStatement* nesting_stack_;
   int loop_depth_;
   const ExpressionContext* context_;
   ZoneList<BailoutEntry> bailout_entries_;
   ZoneList<BailoutEntry> stack_checks_;
+  ZoneList<CacheCellEntry> cache_cells_;
   Handle<FixedArray> handler_table_;
 
   friend class NestedStatement;
 
   DISALLOW_COPY_AND_ASSIGN(FullCodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_