StepOver, StepInto, StepOut

runtime/vm/opt_code_generator_ia32.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/opt_code_generator.h"
 
 #include "vm/assembler_macros.h"
@@ skipping 841 matching lines @@
                        deopt_blob->label());
     PropagateBackLocalClass(node->operand(), double_class_);
   }
   const bool using_temp =
       (node->info() != NULL) && node->info()->allow_temp();
   if (!using_temp) {
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
     const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
     __ pushl(kOperandRegister);
-    GenerateCall(node->token_index(), &label);
+    GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
     ASSERT(kResultRegister == EAX);
     __ popl(kOperandRegister);
   } else if (info.is_temp()) {
     __ movl(kResultRegister, kOperandRegister);
   } else {
     const Double& double_object =
         Double::ZoneHandle(Double::New(0.0, Heap::kOld));
     __ LoadObject(kResultRegister, double_object);
   }
   __ movsd(XMM0, FieldAddress(kOperandRegister, Double::value_offset()));
@@ skipping 269 matching lines @@
         (node->info() != NULL) && node->info()->allow_temp();
     if (!using_temp) {
       // Parent node cannot handle a temporary double object, allocate one
       // each time.
       result_register = kAllocatedRegister;
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
       __ pushl(kLeftRegister);
       __ pushl(kRightRegister);
-      GenerateCall(node->token_index(), &label);
+      GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
       __ movl(result_register, EAX);
       __ popl(kRightRegister);
       __ popl(kLeftRegister);
     } else if (left_info.IsClass(double_class_) && left_info.is_temp()) {
       result_register = kLeftRegister;
     } else if (right_info.IsClass(double_class_) && right_info.is_temp()) {
       result_register = kRightRegister;
     } else {
       result_register = kAllocatedRegister;
       // Use inlined temporary double object.
@@ skipping 1802 matching lines @@
           target.ToFullyQualifiedCString(),
           Recognizer::KindToCString(recognized));
     }
     if ((recognized == Recognizer::kIntegerToDouble) &&
         AtIdNodeHasClassAt(node, node->id(), smi_class_, 0)) {
       // TODO(srdjan): Check if we could use temporary double instead of
       // allocating a new object every time.
       const Code& stub =
           Code::Handle(StubCode::GetAllocationStubForClass(double_class_));
       const ExternalLabel label(double_class_.ToCString(), stub.EntryPoint());
-      GenerateCall(node->token_index(), &label);
+      GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
       // EAX is double object.
       DeoptimizationBlob* deopt_blob =
           AddDeoptimizationBlob(node, EBX, kDeoptIntegerToDouble);
       __ popl(EBX);  // Receiver
       __ testl(EBX, Immediate(kSmiTagMask));
       __ j(NOT_ZERO, deopt_blob->label());  // Deoptimize if not Smi.
       __ SmiUntag(EBX);
       __ cvtsi2sd(XMM0, EBX);
       __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
       return true;
@@ skipping 27 matching lines @@
                                  EBX,  // Class register.
                                  &call_method,
                                  EAX);  // Result register.
     __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
     __ jmp(&done);
     __ Bind(&smi_to_double);
     __ Bind(&call_method);
     __ LoadObject(ECX, node->function());
     __ LoadObject(EDX, ArgumentsDescriptor(node->arguments()->length(),
                                            node->arguments()->names()));
-    GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
+    GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel(),
+                 PcDescriptors::kFuncCall);
     __ Bind(&done);
     return true;
   }
   return false;
 }
 
 
 void OptimizingCodeGenerator::VisitStaticCallNode(StaticCallNode* node) {
   node->arguments()->Visit(this);
   if (TryInlineStaticCall(node)) {
     // Static method is inlined, result is in EAX.
   } else {
     __ LoadObject(ECX, node->function());
     __ LoadObject(EDX, ArgumentsDescriptor(node->arguments()->length(),
                                            node->arguments()->names()));
-    GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
+    GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel(),
+                 PcDescriptors::kFuncCall);
   }
   __ addl(ESP, Immediate(node->arguments()->length() * kWordSize));
   // Result is in EAX.
   HandleResult(node, EAX);
 }
 
 
 void OptimizingCodeGenerator::VisitReturnNode(ReturnNode* node) {
   if ((node->inlined_finally_list_length() > 0) || FLAG_enable_type_checks) {
     CodeGenerator::VisitReturnNode(node);
@@ skipping 96 matching lines @@
     }
   }
   // TODO(srdjan): Implement unary kSUB (negate) Mint.
   CodeGenerator::VisitUnaryOpNode(node);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32