Reland "Add handling for argument adaptor frames to inlining."

src/compiler/code-generator.cc

 // Copyright 2013 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.
 
 #include "src/compiler/code-generator.h"
 
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/pipeline.h"
 
@@ skipping 228 matching lines @@
 
   if (flags & CallDescriptor::kNeedsNopAfterCall) {
     AddNopForSmiCodeInlining();
   }
 
   if (needs_frame_state) {
     // If the frame state is present, it starts at argument 1
     // (just after the code address).
     InstructionOperandConverter converter(this, instr);
     // Deoptimization info starts at argument 1
-    int frame_state_offset = 1;
+    size_t frame_state_offset = 1;
     FrameStateDescriptor* descriptor =
         GetFrameStateDescriptor(instr, frame_state_offset);
     int pc_offset = masm()->pc_offset();
     int deopt_state_id = BuildTranslation(instr, pc_offset, frame_state_offset,
                                           descriptor->state_combine());
     // If the pre-call frame state differs from the post-call one, produce the
     // pre-call frame state, too.
     // TODO(jarin) We might want to avoid building the pre-call frame state
     // because it is only used to get locals and arguments (by the debugger and
     // f.arguments), and those are the same in the pre-call and post-call
     // states.
     if (descriptor->state_combine() != kIgnoreOutput) {
       deopt_state_id =
           BuildTranslation(instr, -1, frame_state_offset, kIgnoreOutput);
     }
 #if DEBUG
     // Make sure all the values live in stack slots or they are immediates.
     // (The values should not live in register because registers are clobbered
     // by calls.)
-    for (int i = 0; i < descriptor->size(); i++) {
+    for (size_t i = 0; i < descriptor->size(); i++) {
       InstructionOperand* op = instr->InputAt(frame_state_offset + 1 + i);
       CHECK(op->IsStackSlot() || op->IsImmediate());
     }
 #endif
     safepoints()->RecordLazyDeoptimizationIndex(deopt_state_id);
   }
 }
 
 
 int CodeGenerator::DefineDeoptimizationLiteral(Handle<Object> literal) {
   int result = static_cast<int>(deoptimization_literals_.size());
   for (unsigned i = 0; i < deoptimization_literals_.size(); ++i) {
     if (deoptimization_literals_[i].is_identical_to(literal)) return i;
   }
   deoptimization_literals_.push_back(literal);
   return result;
 }
 
 
 FrameStateDescriptor* CodeGenerator::GetFrameStateDescriptor(
-    Instruction* instr, int frame_state_offset) {
+    Instruction* instr, size_t frame_state_offset) {
   InstructionOperandConverter i(this, instr);
-  InstructionSequence::StateId state_id =
-      InstructionSequence::StateId::FromInt(i.InputInt32(frame_state_offset));
+  InstructionSequence::StateId state_id = InstructionSequence::StateId::FromInt(
+      i.InputInt32(static_cast<int>(frame_state_offset)));
   return code()->GetFrameStateDescriptor(state_id);
 }
 
 
 void CodeGenerator::BuildTranslationForFrameStateDescriptor(
     FrameStateDescriptor* descriptor, Instruction* instr,
-    Translation* translation, int frame_state_offset,
+    Translation* translation, size_t frame_state_offset,
     OutputFrameStateCombine state_combine) {
   // Outer-most state must be added to translation first.
   if (descriptor->outer_state() != NULL) {
-    BuildTranslationForFrameStateDescriptor(
-        descriptor->outer_state(), instr, translation,
-        frame_state_offset + descriptor->size(), kIgnoreOutput);
+    BuildTranslationForFrameStateDescriptor(descriptor->outer_state(), instr,
+                                            translation, frame_state_offset,
+                                            kIgnoreOutput);
   }
 
-  int height = descriptor->size() - descriptor->parameters_count();
-  switch (state_combine) {
-    case kPushOutput:
-      height++;
+  int id = Translation::kSelfLiteralId;
+  if (!descriptor->jsfunction().is_null()) {
+    id = DefineDeoptimizationLiteral(
+        Handle<Object>::cast(descriptor->jsfunction().ToHandleChecked()));
+  }
+
+  switch (descriptor->type()) {
+    case JS_FRAME:
+      translation->BeginJSFrame(
+          descriptor->bailout_id(), id,
+          static_cast<unsigned int>(descriptor->GetHeight(state_combine)));
       break;
-    case kIgnoreOutput:
+    case ARGUMENTS_ADAPTOR:
+      translation->BeginArgumentsAdaptorFrame(
+          id, static_cast<unsigned int>(descriptor->parameters_count()));
       break;
   }
 
-  translation->BeginJSFrame(descriptor->bailout_id(),
-                            Translation::kSelfLiteralId, height);
-
-  for (int i = 0; i < descriptor->size(); i++) {
-    AddTranslationForOperand(translation, instr,
-                             instr->InputAt(i + frame_state_offset));
+  frame_state_offset += descriptor->outer_state()->GetTotalSize();
+  for (size_t i = 0; i < descriptor->size(); i++) {
+    AddTranslationForOperand(
+        translation, instr,
+        instr->InputAt(static_cast<int>(frame_state_offset + i)));
   }
 
   switch (state_combine) {
     case kPushOutput:
       DCHECK(instr->OutputCount() == 1);
       AddTranslationForOperand(translation, instr, instr->OutputAt(0));
       break;
     case kIgnoreOutput:
       break;
   }
 }
 
 
 int CodeGenerator::BuildTranslation(Instruction* instr, int pc_offset,
-                                    int frame_state_offset,
+                                    size_t frame_state_offset,
                                     OutputFrameStateCombine state_combine) {
   FrameStateDescriptor* descriptor =
       GetFrameStateDescriptor(instr, frame_state_offset);
   frame_state_offset++;
 
-  int frame_count = descriptor->GetFrameCount();
-  Translation translation(&translations_, frame_count, frame_count, zone());
+  Translation translation(
+      &translations_, static_cast<int>(descriptor->GetFrameCount()),
+      static_cast<int>(descriptor->GetJSFrameCount()), zone());
   BuildTranslationForFrameStateDescriptor(descriptor, instr, &translation,
                                           frame_state_offset, state_combine);
 
   int deoptimization_id = static_cast<int>(deoptimization_states_.size());
 
   deoptimization_states_.push_back(new (zone()) DeoptimizationState(
       descriptor->bailout_id(), translation.index(), pc_offset));
 
   return deoptimization_id;
 }
@@ skipping 80 matching lines @@
 }
 
 
 void CodeGenerator::AddNopForSmiCodeInlining() { UNIMPLEMENTED(); }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8