[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 613 matching lines @@
 }
 
 void FlowGraphAllocator::SplitInitialDefinitionAt(LiveRange* range,
                                                   intptr_t pos) {
   if (range->End() > pos) {
     LiveRange* tail = range->SplitAt(pos);
     CompleteRange(tail, Location::kRegister);
   }
 }
 
+#if defined(TARGET_ARCH_DBC)

[Vyacheslav Egorov (Google), 2017/08/13 13:19:23]

I think I liked original version of the function that was not split more.

In the current version there is a lot of duplicated code.

[zra, 2017/08/14 19:59:05]

I'll defer to Slava here.

 void FlowGraphAllocator::ProcessInitialDefinition(Definition* defn,
                                                   LiveRange* range,
                                                   BlockEntryInstr* block) {
-#if defined(TARGET_ARCH_DBC)
   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 11 matching lines @@
       if (use != NULL) {
         LiveRange* tail = SplitBetween(range, block->start_pos(), use->pos());
         // Parameters and constants are tagged, so allocated to CPU registers.
         ASSERT(constant->representation() == kTagged);
         CompleteRange(tail, Location::kRegister);
       }
       ConvertAllUses(range);
     }
     return;
   }
-#endif
 
   // Save the range end because it may change below.
   intptr_t range_end = range->End();
   if (defn->IsParameter()) {
     ParameterInstr* param = defn->AsParameter();
     // Assert that copied and non-copied parameters are mutually exclusive.
     // This might change in the future and, if so, the index will be wrong.
     ASSERT((flow_graph_.num_copied_params() == 0) ||
            (flow_graph_.num_non_copied_params() == 0));
     intptr_t slot_index = param->index();
     ASSERT(slot_index >= 0);
     ASSERT((param->base_reg() == FPREG) || (param->base_reg() == SPREG));
     if (param->base_reg() == FPREG) {
       // Slot index for the leftmost copied parameter is 0.
       // Slot index for the rightmost fixed parameter is -1.
       slot_index -= flow_graph_.num_non_copied_params();
     }
-
-#if defined(TARGET_ARCH_DBC)
     ASSERT(param->base_reg() == FPREG);
     if (slot_index >= 0) {
       AssignSafepoints(defn, range);
       range->finger()->Initialize(range);
       range->set_assigned_location(Location::RegisterLocation(slot_index));
       SplitInitialDefinitionAt(range, kNormalEntryPos);
       ConvertAllUses(range);
       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) {
+      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++;
+      }
+      AssignSafepoints(defn, range);

[Vyacheslav Egorov (Google), 2017/08/13 13:19:23]

I think lines 710-717 and 724-729 should be almost the same with the only
difference that we assign different location to the range. 

Please refactor this accordingly to avoid duplicating code.

[regis, 2017/08/14 23:29:19]

Done.

+      range->finger()->Initialize(range);
+      range->set_assigned_location(Location::RegisterLocation(context_reg));
+      if (range->End() > kNormalEntryPos) {
+        LiveRange* tail = range->SplitAt(kNormalEntryPos);
+        CompleteRange(tail, Location::kRegister);
+      }
+      ConvertAllUses(range);
+      return;
+    }
+    ASSERT(param->kind() == SpecialParameterInstr::kTypeArgs);
+    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));
+    if (range->End() > kNormalEntryPos) {
+      LiveRange* tail = range->SplitAt(kNormalEntryPos);
+      CompleteRange(tail, Location::kRegister);
+    }
+    ConvertAllUses(range);
+    return;
+  } 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());
+  if (use != NULL) {
+    LiveRange* tail = SplitBetween(range, block->start_pos(), use->pos());
+    // Parameters and constants are tagged, so allocated to CPU registers.
+    CompleteRange(tail, Location::kRegister);
+  }
+  ConvertAllUses(range);
+  if (range->spill_slot().IsStackSlot() &&
+      (range->spill_slot().stack_index() >= 0)) {
+    // On entry to the function, range is stored on the stack above the FP in
+    // the same space which is used for spill slots. Update spill slot state to
+    // reflect that and prevent register allocator from reusing this space as a
+    // spill slot.
+    spill_slots_.Add(range_end);
+    quad_spill_slots_.Add(false);
+    untagged_spill_slots_.Add(false);
+    // Note, all incoming parameters are assumed to be tagged.
+    MarkAsObjectAtSafepoints(range);
+  } else if (defn->IsConstant() && block->IsCatchBlockEntry()) {
+    // Constants at catch block entries consume spill slots.
+    spill_slots_.Add(range_end);
+    quad_spill_slots_.Add(false);
+    untagged_spill_slots_.Add(false);
+  }
+}
+#else
+void FlowGraphAllocator::ProcessInitialDefinition(Definition* defn,
+                                                  LiveRange* range,
+                                                  BlockEntryInstr* block) {
+  // Save the range end because it may change below.
+  intptr_t range_end = range->End();
+  if (defn->IsParameter()) {
+    ParameterInstr* param = defn->AsParameter();
+    // Assert that copied and non-copied parameters are mutually exclusive.
+    // This might change in the future and, if so, the index will be wrong.
+    ASSERT((flow_graph_.num_copied_params() == 0) ||
+           (flow_graph_.num_non_copied_params() == 0));
+    intptr_t slot_index = param->index();
+    ASSERT(slot_index >= 0);
+    ASSERT((param->base_reg() == FPREG) || (param->base_reg() == SPREG));
+    if (param->base_reg() == FPREG) {
+      // Slot index for the leftmost copied parameter is 0.
+      // Slot index for the rightmost fixed parameter is -1.
+      slot_index -= flow_graph_.num_non_copied_params();
+    }
     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)
       const Register context_reg = CTX;
-#else
-      const intptr_t context_reg = flow_graph_.num_copied_params();
-#endif
-
       AssignSafepoints(defn, range);
       range->finger()->Initialize(range);
       range->set_assigned_location(Location::RegisterLocation(context_reg));
       if (range->End() > kNormalEntryPos) {
         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();
     range->set_assigned_location(Location::StackSlot(slot_index, FPREG));
     range->set_spill_slot(Location::StackSlot(slot_index, FPREG));
   } 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);
@@ skipping 17 matching lines @@
     untagged_spill_slots_.Add(false);
     // Note, all incoming parameters are assumed to be tagged.
     MarkAsObjectAtSafepoints(range);
   } else if (defn->IsConstant() && block->IsCatchBlockEntry()) {
     // Constants at catch block entries consume spill slots.
     spill_slots_.Add(range_end);
     quad_spill_slots_.Add(false);
     untagged_spill_slots_.Add(false);
   }
 }
+#endif  // defined(TARGET_ARCH_DBC)
 
 static Location::Kind RegisterKindFromPolicy(Location loc) {
   if (loc.policy() == Location::kRequiresFpuRegister) {
     return Location::kFpuRegister;
   } else {
     return Location::kRegister;
   }
 }
 
 static Location::Kind RegisterKindForResult(Instruction* instr) {
@@ skipping 2236 matching lines @@
 #ifndef PRODUCT
       FlowGraphPrinter printer(flow_graph_, true);
       printer.PrintBlocks();
 #endif
     }
     THR_Print("----------------------------------------------\n");
   }
 }
 
 }  // namespace dart