Use a reserved stack local variable to store the Code object so that it can be looked up easily whe…

vm/code_generator_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 167 matching lines @@
     __ popl(EDX);
     __ popl(ECX);
   }
 
   const bool code_generation_finished = TryIntrinsify();
   // In some cases intrinsifier can generate all code and no AST based
   // code generation is needed. In some cases slow-paths (e.g., overflows) are
   // implemented by the AST based code generation and 'code_generation_finished'
   // is false.
   if (!code_generation_finished) {
-    GeneratePreEntryCode();
     GenerateEntryCode();
     if (FLAG_print_scopes) {
       // Print the function scope (again) after generating the prologue in order
       // to see annotations such as allocation indices of locals.
       if (FLAG_print_ast) {
         // Second printing.
         OS::Print("Annotated ");
       }
       AstPrinter::PrintFunctionScope(parsed_function_);
     }
@@ skipping 190 matching lines @@
   //
   // TODO(regis): We may give up reserving space on stack for args/locals
   // because pushes of initial values may be more effective than moves.
   LocalScope* scope = parsed_function_.node_sequence()->scope();
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_opt_params = function.num_optional_parameters();
   const int num_copied_params = parsed_function_.copied_parameter_count();
   const int stack_slot_count =
       num_copied_params + parsed_function_.stack_local_count();
   set_locals_space_size(stack_slot_count * kWordSize);
-  __ EnterFrame(locals_space_size());
+  AssemblerMacros::EnterDartFrame(assembler_, locals_space_size());
 
   // 2. Optionally check if the number of arguments matches.  We check the
   // number of passed arguments when we have to copy them due to the
   // presence of optional named parameters.  No such checking code is
   // generated if only fixed parameters are declared, unless we are in debug
   // mode or unless we are compiling a closure.
   if (num_copied_params == 0) {
     ASSERT(num_opt_params == 0);
 #if defined(DEBUG)
     const bool check_arguments = true;  // Always check arguments in debug mode.
@@ skipping 13 matching lines @@
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(AstNode::kNoId,
                             0,
                             kClosureArgumentMismatchRuntimeEntry);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
-    ASSERT(parsed_function_.first_parameter_index() == -1);
+    ASSERT(parsed_function_.first_parameter_index() ==
+           ParsedFunction::kFirstStackSlotIndex);
     // Copy positional arguments.
     // Check that no fewer than num_fixed_params positional arguments are passed
     // in and that no more than num_params arguments are passed in.
-    // Passed argument i at fp[1 + argc - i] copied to fp[-1 - i].
+    // Passed argument i at fp[1 + argc - i] copied to
+    // fp[ParsedFunction::kFirstStackSlotIndex - i].
     const int num_params = num_fixed_params + num_opt_params;
 
     // Total number of args is the first Smi in args descriptor array (EDX).
     __ movl(EBX, FieldAddress(EDX, Array::data_offset()));
     // Check that num_args <= num_params.
     Label wrong_num_arguments;
     __ cmpl(EBX, Immediate(Smi::RawValue(num_params)));
     __ j(GREATER, &wrong_num_arguments);
     // Number of positional args is the second Smi in descriptor array (EDX).
     __ movl(ECX, FieldAddress(EDX, Array::data_offset() + (1 * kWordSize)));
     // Check that num_pos_args >= num_fixed_params.
     __ cmpl(ECX, Immediate(Smi::RawValue(num_fixed_params)));
     __ j(LESS, &wrong_num_arguments);
     // Since EBX and ECX are Smi, use TIMES_2 instead of TIMES_4.
     // Let EBX point to the last passed positional argument, i.e. to
     // fp[1 + num_args - (num_pos_args - 1)].
     __ subl(EBX, ECX);
     __ leal(EBX, Address(EBP, EBX, TIMES_2, 2 * kWordSize));
     // Let EDI point to the last copied positional argument, i.e. to
-    // fp[-1 - (num_pos_args - 1)].
-    __ movl(EDI, EBP);
+    // fp[ParsedFunction::kFirstStackSlotIndex - (num_pos_args - 1)].
+    int index = ParsedFunction::kFirstStackSlotIndex + 1;

[regis, 2012/05/14 17:33:10]

const

[siva, 2012/05/15 23:52:39]

Done.

+    __ leal(EDI, Address(EBP, (index * kWordSize)));
     __ subl(EDI, ECX);  // ECX is a Smi, subtract twice for TIMES_4 scaling.
     __ subl(EDI, ECX);
     __ SmiUntag(ECX);
     Label loop, loop_condition;
     __ jmp(&loop_condition, Assembler::kNearJump);
     // We do not use the final allocation index of the variable here, i.e.
     // scope->VariableAt(i)->index(), because captured variables still need
     // to be copied to the context that is not yet allocated.
     const Address argument_addr(EBX, ECX, TIMES_4, 0);
     const Address copy_addr(EDI, ECX, TIMES_4, 0);
@@ skipping 54 matching lines @@
       Address argument_addr(EBX, EAX, TIMES_2, 0);  // EAX is a negative Smi.
       __ movl(EAX, argument_addr);
       __ jmp(&assign_optional_parameter, Assembler::kNearJump);
       __ Bind(&load_default_value);
       // Load EAX with default argument at pos.
       const Object& value = Object::ZoneHandle(
           parsed_function_.default_parameter_values().At(
               param_pos - num_fixed_params));
       __ LoadObject(EAX, value);
       __ Bind(&assign_optional_parameter);
-      // Assign EAX to fp[-1 - param_pos].
+      // Assign EAX to fp[ParsedFunction::kFirstStackSlotIndex - param_pos].
       // We do not use the final allocation index of the variable here, i.e.
       // scope->VariableAt(i)->index(), because captured variables still need
       // to be copied to the context that is not yet allocated.
-      const Address param_addr(EBP, (-1 - param_pos) * kWordSize);
+      const Address param_addr(
+          EBP, (ParsedFunction::kFirstStackSlotIndex - param_pos) * kWordSize);
       __ movl(param_addr, EAX);
       __ Bind(&next_parameter);
     }
     delete[] opt_param;
     delete[] opt_param_position;
     // Check that EDI now points to the null terminator in the array descriptor.
     Label all_arguments_processed;
     __ cmpl(Address(EDI, 0), raw_null);
     __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
 
     __ Bind(&wrong_num_arguments);
+    if (locals_space_size() != 0) {
+      // We need to unwind the space we reserved for locals/copied parms etc.

[regis, 2012/05/14 17:33:10]

I add a comment here when reviewing your other overlapping cl.

[siva, 2012/05/15 23:52:39]

Yes, I incorporated your comment into the other CL, so this CL does not have
this change anymore.

On 2012/05/14 17:33:10, regis wrote:

+      // as the NoSuchMethodFunction stub does not expect to see that area on
+      // the stack.
+      __ addl(ESP, Immediate(locals_space_size()));
+    }
     if (function.IsClosureFunction()) {
       GenerateCallRuntime(AstNode::kNoId,
                           0,
                           kClosureArgumentMismatchRuntimeEntry);
     } else {
       // Invoke noSuchMethod function.
       const int kNumArgsChecked = 1;
       ICData& ic_data = ICData::ZoneHandle();
       ic_data = ICData::New(parsed_function().function(),
                             String::Handle(function.name()),
                             AstNode::kNoId,
                             kNumArgsChecked);
       __ LoadObject(ECX, ic_data);
+      // EBP - 4 : PC marker, allows easy identification of RawInstruction obj.
       // EBP : points to previous frame pointer.
       // EBP + 4 : points to return address.
       // EBP + 8 : address of last argument (arg n-1).
       // ESP + 8 + 4*(n-1) : address of first argument (arg 0).
       // ECX : ic-data.
       // EDX : arguments descriptor array.
       __ call(&StubCode::CallNoSuchMethodFunctionLabel());
     }
 
     if (FLAG_trace_functions) {
@@ skipping 61 matching lines @@
   if (parsed_function_.saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     GenerateLoadVariable(CTX, *parsed_function_.saved_context_var());
   } else {
     while (current_context_level-- > 0) {
       __ movl(CTX, FieldAddress(CTX, Context::parent_offset()));
     }
   }
 #ifdef DEBUG
   // Check that the entry stack size matches the exit stack size.
-  __ movl(EDX, EBP);
+  __ leal(EDX, Address(EBP, kLocalsOffsetFromFP));
   __ subl(EDX, ESP);
   ASSERT(locals_space_size() >= 0);
   __ cmpl(EDX, Immediate(locals_space_size()));
   Label wrong_stack;
   __ j(NOT_EQUAL, &wrong_stack, Assembler::kNearJump);
 #endif  // DEBUG.
 
   if (!IsOptimizing()) {
     // Count only in unoptimized code.
     // TODO(srdjan): Replace the counting code with a type feedback
@@ skipping 214 matching lines @@
     set_context_level(scope->context_level());
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (node_sequence == parsed_function_.node_sequence()) {
       ASSERT(scope->context_level() == 1);
       const Immediate raw_null =
           Immediate(reinterpret_cast<intptr_t>(Object::null()));
       const Function& function = parsed_function_.function();
       const int num_params = function.NumberOfParameters();
-      int param_frame_index =
-          (num_params == function.num_fixed_parameters()) ? 1 + num_params : -1;
+      int param_frame_index = (num_params == function.num_fixed_parameters()) ?
+          (1 + num_params) : ParsedFunction::kFirstStackSlotIndex;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         LocalVariable* parameter = scope->VariableAt(pos);
         ASSERT(parameter->owner() == scope);
         if (parameter->is_captured()) {
           // Copy parameter from local frame to current context.
           const Address local_addr(EBP, param_frame_index * kWordSize);
           __ movl(EAX, local_addr);
           GenerateStoreVariable(*parameter, EAX, EDX);
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
@@ skipping 1890 matching lines @@
 }
 
 
 void CodeGenerator::VisitNativeBodyNode(NativeBodyNode* node) {
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in EAX.
   if (!node->has_optional_parameters()) {
     __ leal(EAX, Address(EBP, (1 + node->argument_count()) * kWordSize));
   } else {
-    __ leal(EAX, Address(EBP, -1 * kWordSize));
+    __ leal(EAX,
+            Address(EBP, ParsedFunction::kFirstStackSlotIndex * kWordSize));
   }
   __ movl(ECX, Immediate(reinterpret_cast<uword>(node->native_c_function())));
   __ movl(EDX, Immediate(node->argument_count()));
   GenerateCall(node->token_index(),
                &StubCode::CallNativeCFunctionLabel(),
                PcDescriptors::kOther);
   // Result is on the stack.
   if (!IsResultNeeded(node)) {
     __ popl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitCatchClauseNode(CatchClauseNode* node) {
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restore CTX from local variable ':saved_context'.
   GenerateLoadVariable(CTX, node->context_var());
 
   // Restore ESP from EBP as we are coming from a throw and the code for
   // popping arguments has not been run.
   ASSERT(locals_space_size() >= 0);
-  if (locals_space_size() == 0) {
-    __ movl(ESP, EBP);
-  } else {
-    __ leal(ESP, Address(EBP, -locals_space_size()));
-  }
+  intptr_t offset_size = -locals_space_size() + kLocalsOffsetFromFP;
+  __ leal(ESP, Address(EBP, offset_size));
 
   // The JumpToExceptionHandler trampoline code sets up
   // - the exception object in EAX (kExceptionObjectReg)
   // - the stacktrace object in register EDX (kStackTraceObjectReg)
   // We now setup the exception object and the trace object
   // so that the handler code has access to these objects.
   GenerateStoreVariable(node->exception_var(),
                         kExceptionObjectReg,
                         kNoRegister);
   GenerateStoreVariable(node->stacktrace_var(),
@@ skipping 131 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_IA32