[VM DBC compiler and simulator] Support reified generic functions.

runtime/vm/flow_graph_allocator.cc

 // Copyright (c) 2013, 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_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/il_printer.h"
@@ skipping 616 matching lines @@
                                                   intptr_t pos) {
   if (range->End() > pos) {
     LiveRange* tail = range->SplitAt(pos);
     CompleteRange(tail, Location::kRegister);
   }
 }
 
 void FlowGraphAllocator::ProcessInitialDefinition(Definition* defn,
                                                   LiveRange* range,
                                                   BlockEntryInstr* block) {
 #if defined(TARGET_ARCH_DBC)

[zra, 2017/08/08 17:47:17]

A pretty big portion of this function is now under "#if
defined(TARGET_ARCH_DBC)" I wonder if it would be easier to read if we did
something like:

#if defined(TARGET_ARCH_DBC)
void FlowGraphAllocator::ProcessInitialDefinition() {
  // dbc version
}
#else
void FlowGraphAllocator::ProcessInitialDefinition() {
  // regular version
}
#endif

[regis, 2017/08/08 22:58:28]

Done. It is now easier to read, but harder to maintain, because of the code
duplication. I am fine with either versions and do not mind to revert if Slava
prefers maintainability over readability.

   if (block->IsCatchBlockEntry()) {
     if (defn->IsParameter()) {
       // This must be in sync with FlowGraphCompiler::CatchEntryRegForVariable.
       ParameterInstr* param = defn->AsParameter();
       intptr_t slot_index = param->index();
       AssignSafepoints(defn, range);
       range->finger()->Initialize(range);
       slot_index = kNumberOfCpuRegisters - 1 - slot_index;
       range->set_assigned_location(Location::RegisterLocation(slot_index));
       SplitInitialDefinitionAt(range, block->lifetime_position() + 2);
@@ skipping 48 matching lines @@
       return;
     }
 #endif  // defined(TARGET_ARCH_DBC)
     range->set_assigned_location(
         Location::StackSlot(slot_index, param->base_reg()));
     range->set_spill_slot(Location::StackSlot(slot_index, param->base_reg()));
 
   } else if (defn->IsSpecialParameter()) {
     SpecialParameterInstr* param = defn->AsSpecialParameter();
     if (param->kind() == SpecialParameterInstr::kContext) {
-#if !defined(TARGET_ARCH_DBC)
+#if defined(TARGET_ARCH_DBC)
+      intptr_t context_reg = flow_graph_.num_copied_params();
+      ASSERT(-flow_graph_.parsed_function().first_stack_local_index() - 1 ==
+             context_reg);
+      if (flow_graph_.parsed_function().function_type_arguments() != NULL) {
+        // The first slot is used for function type arguments, either as their
+        // permanent location or as their temporary location when captured.
+        // So use the next one for the context.
+        context_reg++;
+      }
+#else
       const Register context_reg = CTX;
-#else
-      const intptr_t context_reg = flow_graph_.num_copied_params();
-#endif
+#endif  // defined(TARGET_ARCH_DBC)
 
       AssignSafepoints(defn, range);
       range->finger()->Initialize(range);
       range->set_assigned_location(Location::RegisterLocation(context_reg));
       if (range->End() > kNormalEntryPos) {

[Vyacheslav Egorov (Google), 2017/08/08 17:44:42]

I think you need this code (lines 723 - line 728) duplicated after

  735     range->set_assigned_location(Location::RegisterLocation(slot_index));

this should prevent the register from being reused. 

[regis, 2017/08/08 22:58:28]

Done. Awesome! That did it! Thanks.

         LiveRange* tail = range->SplitAt(kNormalEntryPos);
         CompleteRange(tail, Location::kRegister);
       }
       ConvertAllUses(range);
       return;
     }
     ASSERT(param->kind() == SpecialParameterInstr::kTypeArgs);
 #if defined(TARGET_ARCH_DBC)
-    UNIMPLEMENTED();
-#endif
+    const intptr_t slot_index = flow_graph_.num_copied_params();
+    ASSERT(-flow_graph_.parsed_function().first_stack_local_index() - 1 ==
+           slot_index);
+    range->set_assigned_location(Location::RegisterLocation(slot_index));
+#else
     const intptr_t slot_index = flow_graph_.num_copied_params();
     range->set_assigned_location(Location::StackSlot(slot_index, FPREG));
     range->set_spill_slot(Location::StackSlot(slot_index, FPREG));
+#endif  // defined(TARGET_ARCH_DBC)
   } else {
     ConstantInstr* constant = defn->AsConstant();
     ASSERT(constant != NULL);
     range->set_assigned_location(Location::Constant(constant));
     range->set_spill_slot(Location::Constant(constant));
   }
   AssignSafepoints(defn, range);
   range->finger()->Initialize(range);
   UsePosition* use =
       range->finger()->FirstRegisterBeneficialUse(block->start_pos());
@@ skipping 2270 matching lines @@
 #ifndef PRODUCT
       FlowGraphPrinter printer(flow_graph_, true);
       printer.PrintBlocks();
 #endif
     }
     THR_Print("----------------------------------------------\n");
   }
 }
 
 }  // namespace dart