[vm/inliner] Inlining of typed_data polymorphic getters/setters

Rationale:
Handles remaining polymorphic reason for typed_data
setters and getters (internal vs. external) during inlining.
Also introduces high level flow graph utilities that
can be reused throughout the compiler to reduce
future code duplication. Disables type speculation
for 64-bit AOT Dart2 to make all work.

Performance:
About 4x speedup on micro benchmarks (AOT64).

#33205

Change-Id: I678426719e49cd8aa1e5051523da12178120b3ba
Reviewed-on: https://dart-review.googlesource.com/59000
Reviewed-by: Vyacheslav Egorov <[email protected]>
Reviewed-by: Alexander Markov <[email protected]>
Commit-Queue: Aart Bik <[email protected]>

Author: aartbik

runtime/vm/compiler/backend/flow_graph.cc

@@ -2266,6 +2266,144 @@ void FlowGraph::AppendExtractNthOutputForMerged(Definition* instr,
   InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
+//
+// Static helpers for the flow graph utilities.
+//
+
+static TargetEntryInstr* NewTarget(FlowGraph* graph, Instruction* inherit) {
+  TargetEntryInstr* target = new (graph->zone())
+      TargetEntryInstr(graph->allocate_block_id(),
+                       inherit->GetBlock()->try_index(), Thread::kNoDeoptId);
+  target->InheritDeoptTarget(graph->zone(), inherit);
+  return target;
+}
+
+static JoinEntryInstr* NewJoin(FlowGraph* graph, Instruction* inherit) {
+  JoinEntryInstr* join = new (graph->zone())
+      JoinEntryInstr(graph->allocate_block_id(),
+                     inherit->GetBlock()->try_index(), Thread::kNoDeoptId);
+  join->InheritDeoptTarget(graph->zone(), inherit);
+  return join;
+}
+
+static GotoInstr* NewGoto(FlowGraph* graph,
+                          JoinEntryInstr* target,
+                          Instruction* inherit) {
+  GotoInstr* got = new (graph->zone()) GotoInstr(target, Thread::kNoDeoptId);
+  got->InheritDeoptTarget(graph->zone(), inherit);
+  return got;
+}
+
+static BranchInstr* NewBranch(FlowGraph* graph,
+                              ComparisonInstr* cmp,
+                              Instruction* inherit) {
+  BranchInstr* bra = new (graph->zone()) BranchInstr(cmp, Thread::kNoDeoptId);
+  bra->InheritDeoptTarget(graph->zone(), inherit);
+  return bra;
+}
+
+//
+// Flow graph utilities.
+//
+
+// Constructs new diamond decision at the given instruction.
+//
+//               ENTRY
+//             instruction
+//            if (compare)
+//              /   \
+//           B_TRUE B_FALSE
+//              \   /
+//               JOIN
+//
+JoinEntryInstr* FlowGraph::NewDiamond(Instruction* instruction,
+                                      Instruction* inherit,
+                                      ComparisonInstr* compare,
+                                      TargetEntryInstr** b_true,
+                                      TargetEntryInstr** b_false) {
+  BlockEntryInstr* entry = instruction->GetBlock();
+
+  TargetEntryInstr* bt = NewTarget(this, inherit);
+  TargetEntryInstr* bf = NewTarget(this, inherit);
+  JoinEntryInstr* join = NewJoin(this, inherit);
+  GotoInstr* gotot = NewGoto(this, join, inherit);
+  GotoInstr* gotof = NewGoto(this, join, inherit);
+  BranchInstr* bra = NewBranch(this, compare, inherit);
+
+  instruction->AppendInstruction(bra);
+  entry->set_last_instruction(bra);
+
+  *bra->true_successor_address() = bt;
+  *bra->false_successor_address() = bf;
+
+  bt->AppendInstruction(gotot);
+  bt->set_last_instruction(gotot);
+
+  bf->AppendInstruction(gotof);
+  bf->set_last_instruction(gotof);
+
+  // Update dominance relation incrementally.
+  for (intptr_t i = 0, n = entry->dominated_blocks().length(); i < n; ++i) {
+    join->AddDominatedBlock(entry->dominated_blocks()[i]);
+  }
+  entry->ClearDominatedBlocks();
+  entry->AddDominatedBlock(bt);
+  entry->AddDominatedBlock(bf);
+  entry->AddDominatedBlock(join);
+
+  // TODO(ajcbik): update pred/succ/ordering incrementally too.
+
+  // Return new blocks.
+  *b_true = bt;
+  *b_false = bf;
+  return join;
+}
+
+JoinEntryInstr* FlowGraph::NewDiamond(Instruction* instruction,
+                                      Instruction* inherit,
+                                      const LogicalAnd& condition,
+                                      TargetEntryInstr** b_true,
+                                      TargetEntryInstr** b_false) {
+  // First diamond for first comparison.
+  TargetEntryInstr* bt = nullptr;
+  TargetEntryInstr* bf = nullptr;
+  JoinEntryInstr* mid_point =
+      NewDiamond(instruction, inherit, condition.oper1, &bt, &bf);
+
+  // Short-circuit second comparison and connect through phi.
+  condition.oper2->InsertAfter(bt);
+  AllocateSSAIndexes(condition.oper2);
+  condition.oper2->InheritDeoptTarget(zone(), inherit);  // must inherit
+  PhiInstr* phi =
+      AddPhi(mid_point, condition.oper2, GetConstant(Bool::False()));
+  StrictCompareInstr* circuit = new (zone()) StrictCompareInstr(
+      inherit->token_pos(), Token::kEQ_STRICT, new (zone()) Value(phi),
+      new (zone()) Value(GetConstant(Bool::True())), false,
+      Thread::kNoDeoptId);  // don't inherit
+
+  // Return new blocks through the second diamond.
+  return NewDiamond(mid_point, inherit, circuit, b_true, b_false);
+}
+
+PhiInstr* FlowGraph::AddPhi(JoinEntryInstr* join,
+                            Definition* d1,
+                            Definition* d2) {
+  PhiInstr* phi = new (zone()) PhiInstr(join, 2);
+  Value* v1 = new (zone()) Value(d1);
+  Value* v2 = new (zone()) Value(d2);
+
+  AllocateSSAIndexes(phi);
+
+  phi->mark_alive();
+  phi->SetInputAt(0, v1);
+  phi->SetInputAt(1, v2);
+  d1->AddInputUse(v1);
+  d2->AddInputUse(v2);
+  join->InsertPhi(phi);
+
+  return phi;
+}
+
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)

runtime/vm/compiler/backend/flow_graph.h

@@ -351,6 +351,37 @@ class FlowGraph : public ZoneAllocated {
 
   bool should_print() const { return should_print_; }
 
+  //
+  // High-level utilities.
+  //
+
+  // Logical-AND (for use in short-circuit diamond).
+  struct LogicalAnd {
+    LogicalAnd(ComparisonInstr* x, ComparisonInstr* y) : oper1(x), oper2(y) {}
+    ComparisonInstr* oper1;
+    ComparisonInstr* oper2;
+  };
+
+  // Constructs a diamond control flow at the instruction, inheriting
+  // properties from inherit and using the given compare. Returns the
+  // join (and true/false blocks in out parameters). Updates dominance
+  // relation, but not the succ/pred ordering on block.
+  JoinEntryInstr* NewDiamond(Instruction* instruction,
+                             Instruction* inherit,
+                             ComparisonInstr* compare,
+                             TargetEntryInstr** block_true,
+                             TargetEntryInstr** block_false);
+
+  // As above, but with a short-circuit on two comparisons.
+  JoinEntryInstr* NewDiamond(Instruction* instruction,
+                             Instruction* inherit,
+                             const LogicalAnd& condition,
+                             TargetEntryInstr** block_true,
+                             TargetEntryInstr** block_false);
+
+  // Adds a 2-way phi.
+  PhiInstr* AddPhi(JoinEntryInstr* join, Definition* d1, Definition* d2);
+
  private:
   friend class IfConverter;
   friend class BranchSimplifier;