Clean-up CodeGenState: remove unused loop_level and move context_level to CodeGenerator (and add it…

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 23 matching lines @@
 // CodeGenerator::HandlerList can probably be moved to code_generator.cc, since
 // they seem to be architecture independent.
 
 
 CodeGeneratorState::CodeGeneratorState(CodeGenerator* codegen)
     : StackResource(Isolate::Current()),
       codegen_(codegen),
       parent_(codegen->state()) {
   if (parent_ != NULL) {
     root_node_ = parent_->root_node_;
-    loop_level_ = parent_->loop_level_;
-    context_level_ = parent_->context_level_;
     current_try_index_ = parent_->current_try_index_;
   } else {
     root_node_ = NULL;
-    loop_level_ = 0;
-    context_level_ = 0;
     current_try_index_ = CatchClauseNode::kInvalidTryIndex;
   }
   codegen_->set_state(this);
 }
 
 
 CodeGeneratorState::~CodeGeneratorState() {
   codegen_->set_state(parent_);
 }
 
@@ skipping 47 matching lines @@
 
 
 CodeGenerator::CodeGenerator(Assembler* assembler,
                              const ParsedFunction& parsed_function)
     : assembler_(assembler),
       parsed_function_(parsed_function),
       locals_space_size_(-1),
       state_(NULL),
       pc_descriptors_list_(NULL),
       exception_handlers_list_(NULL),
-      try_index_(CatchClauseNode::kInvalidTryIndex) {
+      try_index_(CatchClauseNode::kInvalidTryIndex),
+      context_level_(0) {
   ASSERT(assembler_ != NULL);
   ASSERT(parsed_function.node_sequence() != NULL);
   ASSERT(Isolate::Current()->long_jump_base()->IsSafeToJump());
   pc_descriptors_list_ = new CodeGenerator::DescriptorList();
   exception_handlers_list_ = new CodeGenerator::HandlerList();
 }
 
 
 bool CodeGenerator::IsResultNeeded(AstNode* node) const {
   return !state()->IsRootNode(node);
@@ skipping 104 matching lines @@
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
   code.set_exception_handlers(handlers);
 }
 
 
 void CodeGenerator::GenerateLoadVariable(Register dst,
                                          const LocalVariable& variable) {
   if (variable.is_captured()) {
     // The variable lives in the context.
-    int delta = state()->context_level() - variable.owner()->context_level();
+    intptr_t delta = context_level() - variable.owner()->context_level();
     ASSERT(delta >= 0);
     Register base = CTX;
     while (delta-- > 0) {
       __ movq(dst, FieldAddress(base, Context::parent_offset()));
       base = dst;
     }
     __ movq(dst,
             FieldAddress(base, Context::variable_offset(variable.index())));
   } else {
     // The variable lives in the current stack frame.
     __ movq(dst, Address(RBP, variable.index() * kWordSize));
   }
 }
 
 
 void CodeGenerator::GenerateStoreVariable(const LocalVariable& variable,
                                           Register src,
                                           Register scratch) {
   if (variable.is_captured()) {
     // The variable lives in the context.
-    int delta = state()->context_level() - variable.owner()->context_level();
+    intptr_t delta = context_level() - variable.owner()->context_level();
     ASSERT(delta >= 0);
     Register base = CTX;
     while (delta-- > 0) {
       __ movq(scratch, FieldAddress(base, Context::parent_offset()));
       base = scratch;
     }
     __ StoreIntoObject(
         base,
         FieldAddress(base, Context::variable_offset(variable.index())),
         src);
   } else {
     // The variable lives in the current stack frame.
     __ movq(Address(RBP, variable.index() * kWordSize), src);
   }
 }
 
 
 void CodeGenerator::GeneratePushVariable(const LocalVariable& variable,
                                          Register scratch) {
   if (variable.is_captured()) {
     // The variable lives in the context.
-    int delta = state()->context_level() - variable.owner()->context_level();
+    intptr_t delta = context_level() - variable.owner()->context_level();
     ASSERT(delta >= 0);
     Register base = CTX;
     while (delta-- > 0) {
       __ movq(scratch, FieldAddress(base, Context::parent_offset()));
       base = scratch;
     }
     __ pushq(FieldAddress(base, Context::variable_offset(variable.index())));
   } else {
     // The variable lives in the current stack frame.
     __ pushq(Address(RBP, variable.index() * kWordSize));
@@ skipping 309 matching lines @@
   __ j(ABOVE, &no_stack_overflow);
   GenerateCallRuntime(AstNode::kNoId,
                       0,
                       kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
 
 void CodeGenerator::GenerateReturnEpilog(ReturnNode* node) {
   // Unchain the context(s) up to context level 0.
-  int context_level = state()->context_level();
-  ASSERT(context_level >= 0);
+  intptr_t current_context_level = context_level();
+  ASSERT(current_context_level >= 0);
   if (!parsed_function_.function().IsClosureFunction()) {
-    if (context_level > 0) {
+    if (current_context_level > 0) {
       // CTX on entry was saved on the stack, but not linked as context parent.
       __ popq(CTX);
     }
   } else {
-    while (context_level-- > 0) {
+    while (current_context_level-- > 0) {
       __ movq(CTX, FieldAddress(CTX, Context::parent_offset()));
     }
   }
 #ifdef DEBUG
   // Check that the entry stack size matches the exit stack size.
   __ movq(R10, RBP);
   __ subq(R10, RSP);
   ASSERT(locals_space_size() >= 0);
   __ cmpq(R10, Immediate(locals_space_size()));
   Label wrong_stack;
@@ skipping 106 matching lines @@
   }
 }
 
 
 void CodeGenerator::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
   if (function.IsNonImplicitClosureFunction()) {
     // The context scope may have already been set by the new non-optimizing
     // compiler.  If it was not, set it here.
     if (function.context_scope() == ContextScope::null()) {
-      const int current_context_level = state()->context_level();
+      const intptr_t current_context_level = context_level();
       const ContextScope& context_scope = ContextScope::ZoneHandle(
           node->scope()->PreserveOuterScope(current_context_level));
       ASSERT(!function.HasCode());
       function.set_context_scope(context_scope);
     }
   } else if (function.IsImplicitInstanceClosureFunction()) {
     node->receiver()->Visit(this);
   }
   ASSERT(function.context_scope() != ContextScope::null());
 
@@ skipping 36 matching lines @@
   __ popq(RAX);
   __ popq(CTX);  // result: cloned context. Set as current context.
 }
 
 
 void CodeGenerator::VisitSequenceNode(SequenceNode* node_sequence) {
   CodeGeneratorState codegen_state(this);
   LocalScope* scope = node_sequence->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
+  intptr_t previous_context_level = context_level();
   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, PcDescriptors::kOther);
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it on the stack and restore it on exit.
     if ((node_sequence == parsed_function_.node_sequence()) &&
          !parsed_function_.function().IsClosureFunction()) {
       __ pushq(CTX);
       const Immediate raw_null =
           Immediate(reinterpret_cast<intptr_t>(Object::null()));
       __ movq(CTX, raw_null);
     }
 
     // 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());
+    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 =
@@ skipping 37 matching lines @@
   // If this node sequence is labeled, a break out of the sequence will have
   // taken care of unchaining the context.
   if (node_sequence->label() != NULL) {
     __ Bind(node_sequence->label()->break_label());
     if ((num_context_variables > 0) &&
         (node_sequence == parsed_function_.node_sequence()) &&
          !parsed_function_.function().IsClosureFunction()) {
       __ popq(CTX);
     }
   }
+  set_context_level(previous_context_level);
 }
 
 
 void CodeGenerator::VisitArgumentListNode(ArgumentListNode* arguments) {
   for (int i = 0; i < arguments->length(); i++) {
     AstNode* argument = arguments->NodeAt(i);
     argument->Visit(this);
   }
 }
 
@@ skipping 956 matching lines @@
 
   // Generate inlined code for all finally blocks as we may transfer
   // control out of the 'try' blocks if any.
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     node->InlinedFinallyNodeAt(i)->Visit(this);
   }
 
   // Unchain the context(s) up to the outer context level of the scope which
   // contains the destination label.
   ASSERT(label->owner() != NULL);
-  int target_context_level = 0;
+  intptr_t target_context_level = 0;
   LocalScope* target_scope = label->owner();
   if (target_scope->num_context_variables() > 0) {
     // The scope of the target label allocates a context, therefore its outer
     // scope is at a lower context level.
     target_context_level = target_scope->context_level() - 1;
   } else {
     // The scope of the target label does not allocate a context, so its outer
     // scope is at the same context level. Find it.
     while ((target_scope != NULL) &&
            (target_scope->num_context_variables() == 0)) {
       target_scope = target_scope->parent();
     }
     if (target_scope != NULL) {
       target_context_level = target_scope->context_level();
     }
   }
   ASSERT(target_context_level >= 0);
-  int context_level = state()->context_level();
-  ASSERT(context_level >= target_context_level);
-  while (context_level-- > target_context_level) {
+  int current_context_level = context_level();
+  ASSERT(current_context_level >= target_context_level);
+  while (current_context_level-- > target_context_level) {
     __ movq(CTX, FieldAddress(CTX, Context::parent_offset()));
   }
 
   if (node->kind() == Token::kBREAK) {
     __ jmp(label->break_label());
   } else {
     __ jmp(label->continue_label());
   }
 }
 
@@ skipping 641 matching lines @@
   // and ':stacktrace_var' can never be captured variables.
   // Restore CTX from local variable ':saved_context'.
   GenerateLoadVariable(CTX, node->context_var());
 
   // Restore RSP from RBP as we are coming from a throw and the code for
   // popping arguments has not been run.
   ASSERT(locals_space_size() >= 0);
   __ movq(RSP, RBP);
   __ subq(RSP, Immediate(locals_space_size()));
 
-  if ((state()->context_level() > 0) &&
+  if ((context_level() > 0) &&
       !parsed_function_.function().IsClosureFunction()) {
     // CTX was saved on entry.
     __ subq(RSP, Immediate(kWordSize));
   }
 
   // The JumpToExceptionHandler trampoline code sets up
   // - the exception object in RAX (kExceptionObjectReg)
   // - the stacktrace object in register RDX (kStackTraceObjectReg)
   // We now setup the exception object and the trace object
   // so that the handler code has access to these objects.
@@ skipping 135 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