Add support for fixed parameters in the register allocator.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 2268 matching lines @@
   const Function& function = parsed_function().function();
   TargetEntryInstr* normal_entry = new TargetEntryInstr();
   graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0);
   parsed_function().node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   GrowableArray<intptr_t> parent;
   GrowableArray<BitVector*> assigned_vars;
-  intptr_t variable_count = parsed_function_.function().num_fixed_parameters() +
+
+  const intptr_t fixed_param_count =

[Kevin Millikin (Google), 2012/07/26 09:29:08]

fixed_parameter_count is barely longer.

[Vyacheslav Egorov (Google), 2012/07/26 11:33:53]

Done.

+      parsed_function_.function().num_fixed_parameters();
+  const intptr_t variable_count = fixed_param_count +
       parsed_function_.copied_parameter_count() +
       parsed_function_.stack_local_count();
   // Perform a depth-first traversal of the graph to build preorder and
   // postorder block orders.
   graph_entry_->DiscoverBlocks(NULL,  // Entry block predecessor.
                                &preorder_block_entries_,
                                &postorder_block_entries_,
                                &parent,
                                &assigned_vars,
-                               variable_count);
+                               variable_count,
+                               fixed_param_count);
   // Number blocks in reverse postorder.
   intptr_t block_count = postorder_block_entries_.length();
   for (intptr_t i = 0; i < block_count; ++i) {
     postorder_block_entries_[i]->set_block_id(block_count - i - 1);
   }
 
   if (for_optimized) {
     // Link instructions backwards for optimized compilation.
     for (intptr_t i = 0; i < block_count; ++i) {
       BlockEntryInstr* entry = postorder_block_entries_[i];
@@ skipping 225 matching lines @@
   // TODO(fschneider): Support copied parameters.
   if (parsed_function().copied_parameter_count() != 0) {
     Bailout("Copied parameter support in SSA");
   }
   ASSERT(var_count == (parsed_function().stack_local_count() +
                        parsed_function().function().num_fixed_parameters()));
 
   // Initialize start environment.
   GrowableArray<Value*> start_env(var_count);
   intptr_t i = 0;
-  for (; i < parsed_function().function().num_fixed_parameters(); ++i) {
-    ParameterInstr* param = new ParameterInstr(i);
+  const intptr_t fixed_param_count =
+      parsed_function().function().num_fixed_parameters();
+  for (; i < fixed_param_count; ++i) {
+    ParameterInstr* param = new ParameterInstr(i - fixed_param_count);

[Kevin Millikin (Google), 2012/07/26 09:29:08]

I'm not thrilled with negative parameter indices here.  What is the index of the
leftmost parameter?

By the way, it's clearer to directly use the index you care about instead of
deriving it:

for (intptr i = fixed_parameter_count; i > 0; --i) {
  ParameterInstr* parameter = new ParameterInstr(i);
  ...
}

Value* null_value = new ConstantVal(Object::ZoneHandle());
while (start_env.length() < variable_count) {
  start_env.Add(null_value);
}

[Vyacheslav Egorov (Google), 2012/07/26 11:33:53]

The index of rightmost parameter is -1 and left most is fixed_parameter_count.

Changed to compute stack slot index in allocator.

Alternative would be to compute 

     param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
     start_env.Add(new UseVal(param));
   }
 
   // All locals are initialized with #null.
   Value* null_value = new ConstantVal(Object::ZoneHandle());
   for (; i < var_count; i++) {
     start_env.Add(null_value);
   }
-  graph_entry_->set_start_env(new Environment(start_env));
+  graph_entry_->set_start_env(new Environment(start_env, fixed_param_count));
 
   BlockEntryInstr* normal_entry = graph_entry_->SuccessorAt(0);
   ASSERT(normal_entry != NULL);  // Must have entry.
   GrowableArray<Value*> env(var_count);
   env.AddArray(start_env);
-  RenameRecursive(normal_entry, &env, var_count);
+  RenameRecursive(normal_entry,
+                  &env,
+                  var_count,
+                  parsed_function().function().num_fixed_parameters());

[Kevin Millikin (Google), 2012/07/26 09:29:08]

Can this be just fixed_param[eter]_count?

[Vyacheslav Egorov (Google), 2012/07/26 11:33:53]

Done.

 }
 
 
 // Helper to a copy a value iff it is a UseVal.
 static Value* CopyValue(Value* value) {
   return value->IsUse()
       ? new UseVal(value->AsUse()->definition())
       : value;
 }
 
 
 void FlowGraphBuilder::RenameRecursive(BlockEntryInstr* block_entry,
                                        GrowableArray<Value*>* env,
-                                       intptr_t var_count) {
+                                       intptr_t var_count,
+                                       intptr_t fixed_param_count) {
   // 1. Process phis first.
   if (block_entry->IsJoinEntry()) {
     JoinEntryInstr* join = block_entry->AsJoinEntry();
     if (join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) {
           (*env)[i] = new UseVal(phi);
           phi->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
         }
       }
     }
   }
 
   // 2. Process normal instructions.
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     // Attach current environment to the instruction.
     // TODO(fschneider): Currently each instruction gets a full copy of the
     // environment. This should be optimized: Only instructions that can
     // deoptimize should have uses of the environment values.
-    current->set_env(new Environment(*env));
+    current->set_env(new Environment(*env, fixed_param_count));
 
     // 2a. Handle uses:
     // Update expression stack environment for each use.
     // For each use of a LoadLocal or StoreLocal: Replace it with the value
     // from the environment.
     for (intptr_t i = 0; i < current->InputCount(); ++i) {
       Value* v = current->InputAt(i);
       if (!v->IsUse()) continue;
       // Update expression stack.
       ASSERT(env->length() > var_count);
       env->RemoveLast();
       BindInstr* as_bind = v->AsUse()->definition()->AsBind();
       if ((as_bind != NULL) && as_bind->computation()->IsLoadLocal()) {
         Computation* comp = as_bind->computation();
-        intptr_t index = comp->AsLoadLocal()->local().BitIndexIn(var_count);
+        intptr_t index =
+            comp->AsLoadLocal()->local().BitIndexIn(fixed_param_count);
         current->SetInputAt(i, CopyValue((*env)[index]));
       }
       if ((as_bind != NULL) && as_bind->computation()->IsStoreLocal()) {
         // For each use of a StoreLocal: Replace it with the value from the
         // environment.
         Computation* comp = as_bind->computation();
-        intptr_t index = comp->AsStoreLocal()->local().BitIndexIn(var_count);
+        intptr_t index =
+            comp->AsStoreLocal()->local().BitIndexIn(fixed_param_count);
         current->SetInputAt(i, CopyValue((*env)[index]));
       }
     }
 
     // 2b. Handle LoadLocal and StoreLocal.
     // For each LoadLocal: Remove it from the graph.
     // For each StoreLocal: Remove it from the graph and update the environment.
     BindInstr* bind = current->AsBind();
     if (bind != NULL) {
       LoadLocalComp* load = bind->computation()->AsLoadLocal();
       StoreLocalComp* store = bind->computation()->AsStoreLocal();
       if ((load != NULL) || (store != NULL)) {
         intptr_t index;
         if (store != NULL) {
-          index = store->local().BitIndexIn(var_count);
+          index = store->local().BitIndexIn(fixed_param_count);
           // Update renaming environment.
           (*env)[index] = store->value();
         } else {
           // The graph construction ensures we do not have an unused LoadLocal
           // computation.
           ASSERT(bind->is_used());
-          index = load->local().BitIndexIn(var_count);
+          index = load->local().BitIndexIn(fixed_param_count);
         }
         // Update expression stack and remove from graph.
         if (bind->is_used()) {
           env->Add(CopyValue((*env)[index]));
         }
         it.RemoveCurrentFromGraph();
       } else {
         // Not a load or store.
         if (bind->is_used()) {
           // Assign fresh SSA temporary and update expression stack.
           bind->set_ssa_temp_index(alloc_ssa_temp_index());
           env->Add(new UseVal(bind));
         }
       }
     }
   }
 
   // 3. Process dominated blocks.
   for (intptr_t i = 0; i < block_entry->dominated_blocks().length(); ++i) {
     BlockEntryInstr* block = block_entry->dominated_blocks()[i];
     GrowableArray<Value*> new_env(env->length());
     new_env.AddArray(*env);
-    RenameRecursive(block, &new_env, var_count);
+    RenameRecursive(block, &new_env, var_count, fixed_param_count);
   }
 
   // 4. Process successor block. We have edge-split form, so that only blocks
   // with one successor can have a join block as successor.
   if ((block_entry->last_instruction()->SuccessorCount() == 1) &&
       block_entry->last_instruction()->SuccessorAt(0)->IsJoinEntry()) {
     JoinEntryInstr* successor =
         block_entry->last_instruction()->SuccessorAt(0)->AsJoinEntry();
     intptr_t pred_index = successor->IndexOfPredecessor(block_entry);
     ASSERT(pred_index >= 0);
@@ skipping 20 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart