StepOver, StepInto, StepOut

runtime/vm/code_generator_x64.cc

 // Copyright (c) 2012, 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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 681 matching lines @@
     __ LoadObject(RBX, function);
     __ pushq(RBX);
     GenerateCallRuntime(AstNode::kNoId,
                         0,
                         kTraceFunctionExitRuntimeEntry);
     __ popq(RAX);  // Remove argument.
     __ popq(RAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
-  // TODO(hausner): insert generation of of PcDescriptor::kReturn,
-  // analogous to 32bit version.
+
+  // Generate 8 bytes of NOPs so that the debugger can patch the
+  // return pattern with a call to the debug stub.
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  __ nop(1);
+  AddCurrentDescriptor(PcDescriptors::kReturn,
+                       node->id(),
+                       node->token_index());
+
 
 #ifdef DEBUG
   __ Bind(&wrong_stack);
   __ Stop("Exit stack size does not match the entry stack size.");
 #endif  // DEBUG.
 }
 
 
 void CodeGenerator::VisitReturnNode(ReturnNode* node) {
   ASSERT(!IsResultNeeded(node));
@@ skipping 86 matching lines @@
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     GenerateInstantiatorTypeArguments(node->token_index());
   }
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(function));
   const ExternalLabel label(function.ToCString(), stub.EntryPoint());
-  GenerateCall(node->token_index(), &label);
+  GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
   if (requires_type_arguments) {
     __ popq(RCX);  // Pop type arguments.
   }
   if (function.IsImplicitInstanceClosureFunction()) {
     __ popq(RCX);  // Pop receiver.
   }
   if (IsResultNeeded(node)) {
     __ pushq(RAX);
   }
 }
@@ skipping 20 matching lines @@
   CodeGeneratorState codegen_state(this);
   LocalScope* scope = node_sequence->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   if (num_context_variables > 0) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     __ movq(R10, Immediate(num_context_variables));
     const ExternalLabel label("alloc_context",
                               StubCode::AllocateContextEntryPoint());
-    GenerateCall(node_sequence->token_index(), &label);
+    GenerateCall(node_sequence->token_index(), &label, PcDescriptors::kOther);
 
     // Chain the new context in RAX to its parent in CTX.
     __ StoreIntoObject(RAX,
                        FieldAddress(RAX, Context::parent_offset()),
                        CTX);
     // Set new context as current context.
     __ movq(CTX, RAX);
     state()->set_context_level(scope->context_level());
 
     // If this node_sequence is the body of the function being compiled, copy
@@ skipping 60 matching lines @@
     element->Visit(this);
   }
 
   // Allocate the array.
   //   R10 : Array length as Smi.
   //   RBX : element type for the array.
   __ movq(R10, Immediate(Smi::RawValue(node->length())));
   const AbstractTypeArguments& element_type = node->type_arguments();
   ASSERT(element_type.IsNull() || element_type.IsInstantiated());
   __ LoadObject(RBX, element_type);
-  GenerateCall(node->token_index(), &StubCode::AllocateArrayLabel());
+  GenerateCall(node->token_index(),
+               &StubCode::AllocateArrayLabel(),
+               PcDescriptors::kOther);
 
   // Pop the element values from the stack into the array.
   __ leaq(RCX, FieldAddress(RAX, Array::data_offset()));
   for (int i = node->length() - 1; i >= 0; i--) {
     __ popq(Address(RCX, i * kWordSize));
   }
 
   if (IsResultNeeded(node)) {
     __ pushq(RAX);
   }
@@ skipping 1174 matching lines @@
   }
 
   // Could not concatenate at compile time, generate a call to
   // interpolation function.
   ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_index());
   interpol_arg->Add(node->values());
   node->values()->Visit(this);
   __ LoadObject(RBX, interpol_func);
   __ LoadObject(R10, ArgumentsDescriptor(interpol_arg->length(),
                                          interpol_arg->names()));
-  GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
+  GenerateCall(node->token_index(),
+               &StubCode::CallStaticFunctionLabel(),
+               PcDescriptors::kOther);
   __ addq(RSP, Immediate(interpol_arg->length() * kWordSize));
   // Result is in RAX.
   if (IsResultNeeded(node)) {
     __ pushq(RAX);
   }
 }
 
 
 void CodeGenerator::VisitInstanceCallNode(InstanceCallNode* node) {
   const int number_of_arguments = node->arguments()->length() + 1;
@@ skipping 16 matching lines @@
     __ pushq(RAX);
   }
 }
 
 
 void CodeGenerator::VisitStaticCallNode(StaticCallNode* node) {
   node->arguments()->Visit(this);
   __ LoadObject(RBX, node->function());
   __ LoadObject(R10, ArgumentsDescriptor(node->arguments()->length(),
                                          node->arguments()->names()));
-  GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
+  GenerateCall(node->token_index(),
+               &StubCode::CallStaticFunctionLabel(),
+               PcDescriptors::kFuncCall);
   __ addq(RSP, Immediate(node->arguments()->length() * kWordSize));
   // Result is in RAX.
   if (IsResultNeeded(node)) {
     __ pushq(RAX);
   }
 }
 
 
 void CodeGenerator::VisitClosureCallNode(ClosureCallNode* node) {
   // The spec states that the closure is evaluated before the arguments.
   // Preserve the current context, since it will be overridden by the closure
   // context during the call.
   __ pushq(CTX);
   // Compute the closure object and pass it as first argument to the stub.
   node->closure()->Visit(this);
   // Now compute the arguments to the call.
   node->arguments()->Visit(this);
   // Set up the number of arguments (excluding the closure) to the ClosureCall
   // stub which will setup the closure context and jump to the entrypoint of the
   // closure function (the function will be compiled if it has not already been
   // compiled).
   // NOTE: The stub accesses the closure before the parameter list.
   __ LoadObject(R10, ArgumentsDescriptor(node->arguments()->length(),
                                          node->arguments()->names()));
-  GenerateCall(node->token_index(), &StubCode::CallClosureFunctionLabel());
+  GenerateCall(node->token_index(),
+               &StubCode::CallClosureFunctionLabel(),
+               PcDescriptors::kOther);
   __ addq(RSP, Immediate((node->arguments()->length() + 1) * kWordSize));
   // Restore the context.
   __ popq(CTX);
   // Result is in RAX.
   if (IsResultNeeded(node)) {
     __ pushq(RAX);
   }
 }
 
 
@@ skipping 124 matching lines @@
     const bool requires_type_arguments = true;  // Always first arg to factory.
     GenerateTypeArguments(node, requires_type_arguments);
     // The top of stack is an instantiated AbstractTypeArguments object
     // (or null).
     int num_args = node->arguments()->length() + 1;  // +1 to include type args.
     node->arguments()->Visit(this);
     // Call the factory.
     __ LoadObject(RBX, node->constructor());
     __ LoadObject(R10, ArgumentsDescriptor(num_args,
                                            node->arguments()->names()));
-    GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
+    GenerateCall(node->token_index(),
+                 &StubCode::CallStaticFunctionLabel(),
+                 PcDescriptors::kFuncCall);
     // Factory constructor returns object in RAX.
     __ addq(RSP, Immediate(num_args * kWordSize));
     if (IsResultNeeded(node)) {
       __ pushq(RAX);
     }
     return;
   }
 
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   const bool requires_type_arguments = cls.HasTypeArguments();
   GenerateTypeArguments(node, requires_type_arguments);
 
   // If cls is parameterized, the type arguments and the instantiator's
   // type arguments are on the stack.
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
-  GenerateCall(node->token_index(), &label);
+  GenerateCall(node->token_index(), &label, PcDescriptors::kOther);
   if (requires_type_arguments) {
     __ popq(RCX);  // Pop type arguments.
     __ popq(RCX);  // Pop instantiator type arguments.
   }
 
   if (IsResultNeeded(node)) {
     __ pushq(RAX);  // Set up return value from allocate.
   }
 
   // First argument(this) for constructor call which follows.
   __ pushq(RAX);
   // Second argument is the implicit construction phase parameter.
   // Run both the constructor initializer list and the constructor body.
   __ PushObject(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
 
 
   // Now setup rest of the arguments for the constructor call.
   node->arguments()->Visit(this);
 
   // Call the constructor.
   // +2 to include implicit receiver and phase arguments.
   int num_args = node->arguments()->length() + 2;
   __ LoadObject(RBX, node->constructor());
   __ LoadObject(R10, ArgumentsDescriptor(num_args, node->arguments()->names()));
-  GenerateCall(node->token_index(), &StubCode::CallStaticFunctionLabel());
+  GenerateCall(node->token_index(),
+               &StubCode::CallStaticFunctionLabel(),
+               PcDescriptors::kFuncCall);
   // Constructors do not return any value.
 
   // Pop out all the other arguments on the stack.
   __ addq(RSP, Immediate(num_args * kWordSize));
 }
 
 
 // Expects receiver on stack, returns result in RAX..
 void CodeGenerator::GenerateInstanceGetterCall(intptr_t node_id,
                                                intptr_t token_index,
@@ skipping 73 matching lines @@
   const Function& function =
       Function::ZoneHandle(field_class.LookupStaticFunction(getter_name));
   if (function.IsNull()) {
     ErrorMsg(token_index, "Static getter does not exist: %s",
         getter_name.ToCString());
   }
   __ LoadObject(RBX, function);
   const int kNumberOfArguments = 0;
   const Array& kNoArgumentNames = Array::Handle();
   __ LoadObject(R10, ArgumentsDescriptor(kNumberOfArguments, kNoArgumentNames));
-  GenerateCall(token_index, &StubCode::CallStaticFunctionLabel());
+  GenerateCall(token_index,
+               &StubCode::CallStaticFunctionLabel(),
+               PcDescriptors::kFuncCall);
   // No arguments were pushed, hence nothing to pop.
 }
 
 
 // Call to static getter.
 void CodeGenerator::VisitStaticGetterNode(StaticGetterNode* node) {
   GenerateStaticGetterCall(node->token_index(),
                            node->cls(),
                            node->field_name());
   // Result is in RAX.
   if (IsResultNeeded(node)) {
     __ pushq(RAX);
   }
 }
 
 
 // Expects value on stack.
 void CodeGenerator::GenerateStaticSetterCall(intptr_t token_index,
                                              const Class& field_class,
                                              const String& field_name) {
   const String& setter_name = String::Handle(Field::SetterName(field_name));
   const Function& function =
       Function::ZoneHandle(field_class.LookupStaticFunction(setter_name));
   __ LoadObject(RBX, function);
   const int kNumberOfArguments = 1;  // value.
   const Array& kNoArgumentNames = Array::Handle();
   __ LoadObject(R10, ArgumentsDescriptor(kNumberOfArguments, kNoArgumentNames));
-  GenerateCall(token_index, &StubCode::CallStaticFunctionLabel());
+  GenerateCall(token_index,
+               &StubCode::CallStaticFunctionLabel(),
+               PcDescriptors::kFuncCall);
   __ addq(RSP, Immediate(kNumberOfArguments * kWordSize));
 }
 
 
 // The call to static setter implements assignment to a static field.
 // The result of the assignment is the value being stored.
 void CodeGenerator::VisitStaticSetterNode(StaticSetterNode* node) {
   node->value()->Visit(this);
   if (IsResultNeeded(node)) {
     // Preserve the original value when returning from setter.
@@ skipping 12 matching lines @@
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in RAX.
   if (!node->has_optional_parameters()) {
     __ leaq(RAX, Address(RBP, (1 + node->argument_count()) * kWordSize));
   } else {
     __ leaq(RAX, Address(RBP, -1 * kWordSize));
   }
   __ movq(RBX, Immediate(reinterpret_cast<uword>(node->native_c_function())));
   __ movq(R10, Immediate(node->argument_count()));
-  GenerateCall(node->token_index(), &StubCode::CallNativeCFunctionLabel());
+  GenerateCall(node->token_index(),
+               &StubCode::CallNativeCFunctionLabel(),
+               PcDescriptors::kOther);
   // Result is on the stack.
   if (!IsResultNeeded(node)) {
     __ popq(RAX);
   }
 }
 
 
 void CodeGenerator::VisitCatchClauseNode(CatchClauseNode* node) {
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
@@ skipping 105 matching lines @@
   GenerateLoadVariable(CTX, node->context_var());
   node->finally_block()->Visit(this);
 
   if (try_index >= 0) {
     state()->set_try_index(try_index);
   }
 }
 
 
 void CodeGenerator::GenerateCall(intptr_t token_index,
-                                 const ExternalLabel* ext_label) {
+                                 const ExternalLabel* ext_label,
+                                 PcDescriptors::Kind desc_kind) {
   __ call(ext_label);
-  AddCurrentDescriptor(PcDescriptors::kOther, AstNode::kNoId, token_index);
+  AddCurrentDescriptor(desc_kind, AstNode::kNoId, token_index);
 }
 
 
 void CodeGenerator::GenerateCallRuntime(intptr_t node_id,
                                         intptr_t token_index,
                                         const RuntimeEntry& entry) {
   __ CallRuntimeFromDart(entry);
   AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
 }
 
@@ skipping 25 matching lines @@
   const Error& error = Error::Handle(
       Parser::FormatError(script, token_index, "Error", format, args));
   va_end(args);
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64