Support inlining at call-sites with mismatched number of arguments.

src/deoptimizer.h

-// Copyright 2011 the V8 project authors. All rights reserved.
+// Copyright 2012 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
 //       with the distribution.
@@ skipping 100 matching lines @@
     EAGER,
     LAZY,
     OSR,
     // This last bailout type is not really a bailout, but used by the
     // debugger to deoptimize stack frames to allow inspection.
     DEBUGGER
   };
 
   int output_count() const { return output_count_; }
 
+  // Number of created JS frames. Not all created frames are necessarily JS.
+  int jsframe_count() const { return jsframe_count_; }
+
   static Deoptimizer* New(JSFunction* function,
                           BailoutType type,
                           unsigned bailout_id,
                           Address from,
                           int fp_to_sp_delta,
                           Isolate* isolate);
   static Deoptimizer* Grab(Isolate* isolate);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // The returned object with information on the optimized frame needs to be
   // freed before another one can be generated.
   static DeoptimizedFrameInfo* DebuggerInspectableFrame(JavaScriptFrame* frame,
-                                                        int frame_index,
+                                                        int jsframe_index,
                                                         Isolate* isolate);
   static void DeleteDebuggerInspectableFrame(DeoptimizedFrameInfo* info,
                                              Isolate* isolate);
 #endif
 
   // Makes sure that there is enough room in the relocation
   // information of a code object to perform lazy deoptimization
   // patching. If there is not enough room a new relocation
   // information object is allocated and comments are added until it
   // is big enough.
@@ skipping 44 matching lines @@
   static void RevertStackCheckCodeAt(Code* unoptimized_code,
                                      Address pc_after,
                                      Code* check_code,
                                      Code* replacement_code);
 
   ~Deoptimizer();
 
   void MaterializeHeapNumbers();
 #ifdef ENABLE_DEBUGGER_SUPPORT
   void MaterializeHeapNumbersForDebuggerInspectableFrame(
-      Address top, uint32_t size, DeoptimizedFrameInfo* info);
+      Address parameters_top,
+      uint32_t parameters_size,
+      Address expressions_top,
+      uint32_t expressions_size,
+      DeoptimizedFrameInfo* info);
 #endif
 
   static void ComputeOutputFrames(Deoptimizer* deoptimizer);
 
   static Address GetDeoptimizationEntry(int id, BailoutType type);
   static int GetDeoptimizationId(Address addr, BailoutType type);
   static int GetOutputInfo(DeoptimizationOutputData* data,
                            unsigned node_id,
                            SharedFunctionInfo* shared);
 
@@ skipping 40 matching lines @@
 
    protected:
     virtual void GeneratePrologue();
 
    private:
     int count() const { return count_; }
 
     int count_;
   };
 
+  int ConvertJSFrameIndexToFrameIndex(int jsframe_index);
+
  private:
   static const int kNumberOfEntries = 4096;
 
   Deoptimizer(Isolate* isolate,
               JSFunction* function,
               BailoutType type,
               unsigned bailout_id,
               Address from,
               int fp_to_sp_delta,
               Code* optimized_code);
   void DeleteFrameDescriptions();
 
   void DoComputeOutputFrames();
   void DoComputeOsrOutputFrame();
-  void DoComputeFrame(TranslationIterator* iterator, int frame_index);
+  void DoComputeJSFrame(TranslationIterator* iterator, int frame_index);
+  void DoComputeArgumentsAdaptorFrame(TranslationIterator* iterator,
+                                      int frame_index);
   void DoTranslateCommand(TranslationIterator* iterator,
                           int frame_index,
                           unsigned output_offset);
   // Translate a command for OSR.  Updates the input offset to be used for
   // the next command.  Returns false if translation of the command failed
   // (e.g., a number conversion failed) and may or may not have updated the
   // input offset.
   bool DoOsrTranslateCommand(TranslationIterator* iterator,
                              int* input_offset);
 
@@ skipping 27 matching lines @@
   Code* optimized_code_;
   unsigned bailout_id_;
   BailoutType bailout_type_;
   Address from_;
   int fp_to_sp_delta_;
 
   // Input frame description.
   FrameDescription* input_;
   // Number of output frames.
   int output_count_;
+  // Number of output js frames.
+  int jsframe_count_;
   // Array of output frame descriptions.
   FrameDescription** output_;
 
   // Frames can be dynamically padded on ia32 to align untagged doubles.
   Object* frame_alignment_marker_;
   intptr_t has_alignment_padding_;
 
   List<HeapNumberMaterializationDescriptor> deferred_heap_numbers_;
 
   static const int table_entry_size_;
@@ skipping 23 matching lines @@
     free(description);
   }
 
   uint32_t GetFrameSize() const {
     ASSERT(static_cast<uint32_t>(frame_size_) == frame_size_);
     return static_cast<uint32_t>(frame_size_);
   }
 
   JSFunction* GetFunction() const { return function_; }
 
-  unsigned GetOffsetFromSlotIndex(Deoptimizer* deoptimizer, int slot_index);
+  unsigned GetOffsetFromSlotIndex(int slot_index);
 
   intptr_t GetFrameSlot(unsigned offset) {
     return *GetFrameSlotPointer(offset);
   }
 
   double GetDoubleFrameSlot(unsigned offset) {
     intptr_t* ptr = GetFrameSlotPointer(offset);
 #if V8_TARGET_ARCH_MIPS
     // Prevent gcc from using load-double (mips ldc1) on (possibly)
     // non-64-bit aligned double. Uses two lwc1 instructions.
@@ skipping 40 matching lines @@
   void SetPc(intptr_t pc) { pc_ = pc; }
 
   intptr_t GetFp() const { return fp_; }
   void SetFp(intptr_t fp) { fp_ = fp; }
 
   Smi* GetState() const { return state_; }
   void SetState(Smi* state) { state_ = state; }
 
   void SetContinuation(intptr_t pc) { continuation_ = pc; }
 
+  StackFrame::Type GetType() const { return type_; }

[Kevin Millikin (Chromium), 2012/01/24 00:08:54]

Type and Kind are too generic (kind was before).   Suggest
GetFrameType/SetFrameType and GetCodeKind/SetCodeKind.

[Vyacheslav Egorov (Chromium), 2012/01/24 08:49:20]

Done.

+  void SetType(StackFrame::Type type) { type_ = type; }
+
 #ifdef DEBUG
   Code::Kind GetKind() const { return kind_; }
   void SetKind(Code::Kind kind) { kind_ = kind; }
 #endif
 
   // Get the incoming arguments count.
   int ComputeParametersCount();
 
   // Get a parameter value for an unoptimized frame.
-  Object* GetParameter(Deoptimizer* deoptimizer, int index);
+  Object* GetParameter(int index);
 
   // Get the expression stack height for a unoptimized frame.
-  unsigned GetExpressionCount(Deoptimizer* deoptimizer);
+  unsigned GetExpressionCount();
 
   // Get the expression stack value for an unoptimized frame.
-  Object* GetExpression(Deoptimizer* deoptimizer, int index);
+  Object* GetExpression(int index);
 
   static int registers_offset() {
     return OFFSET_OF(FrameDescription, registers_);
   }
 
   static int double_registers_offset() {
     return OFFSET_OF(FrameDescription, double_registers_);
   }
 
   static int frame_size_offset() {
@@ skipping 22 matching lines @@
   // Frame_size_ must hold a uint32_t value.  It is only a uintptr_t to
   // keep the variable-size array frame_content_ of type intptr_t at
   // the end of the structure aligned.
   uintptr_t frame_size_;  // Number of bytes.
   JSFunction* function_;
   intptr_t registers_[Register::kNumRegisters];
   double double_registers_[DoubleRegister::kNumAllocatableRegisters];
   intptr_t top_;
   intptr_t pc_;
   intptr_t fp_;
+  StackFrame::Type type_;
   Smi* state_;
 #ifdef DEBUG
   Code::Kind kind_;
 #endif
 
   // Continuation is the PC where the execution continues after
   // deoptimizing.
   intptr_t continuation_;
 
   // This must be at the end of the object as the object is allocated larger
   // than it's definition indicate to extend this array.
   intptr_t frame_content_[1];
 
   intptr_t* GetFrameSlotPointer(unsigned offset) {
     ASSERT(offset < frame_size_);
     return reinterpret_cast<intptr_t*>(
         reinterpret_cast<Address>(this) + frame_content_offset() + offset);
   }
+
+  int ComputeFixedSize();
 };
 
 
 class TranslationBuffer BASE_EMBEDDED {
  public:
   TranslationBuffer() : contents_(256) { }
 
   int CurrentIndex() const { return contents_.length(); }
   void Add(int32_t value);
 
@@ skipping 22 matching lines @@
  private:
   ByteArray* buffer_;
   int index_;
 };
 
 
 class Translation BASE_EMBEDDED {
  public:
   enum Opcode {
     BEGIN,
-    FRAME,
+    JS_FRAME,
+    ARGUMENTS_ADAPTOR_FRAME,
     REGISTER,
     INT32_REGISTER,
     DOUBLE_REGISTER,
     STACK_SLOT,
     INT32_STACK_SLOT,
     DOUBLE_STACK_SLOT,
     LITERAL,
     ARGUMENTS_OBJECT,
 
     // A prefix indicating that the next command is a duplicate of the one
     // that follows it.
     DUPLICATE
   };
 
-  Translation(TranslationBuffer* buffer, int frame_count)
+  Translation(TranslationBuffer* buffer, int frame_count, int jsframe_count)
       : buffer_(buffer),
         index_(buffer->CurrentIndex()) {
     buffer_->Add(BEGIN);
     buffer_->Add(frame_count);
+    buffer_->Add(jsframe_count);
   }
 
   int index() const { return index_; }
 
   // Commands.
-  void BeginFrame(int node_id, int literal_id, unsigned height);
+  void BeginJSFrame(int node_id, int literal_id, unsigned height);
+  void BeginArgumentsAdaptorFrame(int literal_id, unsigned height);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
   void StoreDoubleRegister(DoubleRegister reg);
   void StoreStackSlot(int index);
   void StoreInt32StackSlot(int index);
   void StoreDoubleStackSlot(int index);
   void StoreLiteral(int literal_id);
   void StoreArgumentsObject();
   void MarkDuplicate();
 
@@ skipping 69 matching lines @@
 
       case LITERAL:
         return literal_;
 
       default:
         UNREACHABLE();
         return Handle<Object>::null();
     }
   }
 
-  static void ComputeSlotMappingForArguments(JavaScriptFrame* frame,
-                                             int inlined_frame_index,
-                                             Vector<SlotRef>* args_slots);
+  static Vector<SlotRef> ComputeSlotMappingForArguments(
+      JavaScriptFrame* frame,
+      int inlined_frame_index,
+      int formal_parameter_count);
 
  private:
   Address addr_;
   Handle<Object> literal_;
   SlotRepresentation representation_;
 
   static Address SlotAddress(JavaScriptFrame* frame, int slot_index) {
     if (slot_index >= 0) {
       const int offset = JavaScriptFrameConstants::kLocal0Offset;
       return frame->fp() + offset - (slot_index * kPointerSize);
     } else {
       const int offset = JavaScriptFrameConstants::kLastParameterOffset;
       return frame->fp() + offset - ((slot_index + 1) * kPointerSize);
     }
   }
 
   static SlotRef ComputeSlotForNextArgument(TranslationIterator* iterator,
                                             DeoptimizationInputData* data,
                                             JavaScriptFrame* frame);
+
+  static void ComputeSlotsForArguments(
+      Vector<SlotRef>* args_slots,
+      TranslationIterator* iterator,
+      DeoptimizationInputData* data,
+      JavaScriptFrame* frame);
 };
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 // Class used to represent an unoptimized frame when the debugger
 // needs to inspect a frame that is part of an optimized frame. The
 // internally used FrameDescription objects are not GC safe so for use
 // by the debugger frame information is copied to an object of this type.
+// Represents parameters in unadapted form so their number might mismatch
+// formal parameter count.
 class DeoptimizedFrameInfo : public Malloced {
  public:
-  DeoptimizedFrameInfo(Deoptimizer* deoptimizer, int frame_index);
+  DeoptimizedFrameInfo(Deoptimizer* deoptimizer,
+                       int frame_index,
+                       bool has_arguments_adaptor);
   virtual ~DeoptimizedFrameInfo();
 
   // GC support.
   void Iterate(ObjectVisitor* v);
 
   // Return the number of incoming arguments.
   int parameters_count() { return parameters_count_; }
 
   // Return the height of the expression stack.
   int expression_count() { return expression_count_; }
@@ skipping 39 matching lines @@
   Object** parameters_;
   Object** expression_stack_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_