ART: Use ScopedArenaAllocator for pass-local data.

Passes using local ArenaAllocator were hiding their memory
usage from the allocation counting, making it difficult to
track down where memory was used. Using ScopedArenaAllocator
reveals the memory usage.

This changes the HGraph constructor which requires a lot of
changes in tests. Refactor these tests to limit the amount
of work needed the next time we change that constructor.

Test: m test-art-host-gtest
Test: testrunner.py --host
Test: Build with kArenaAllocatorCountAllocations = true.
Bug: 64312607
Change-Id: I34939e4086b500d6e827ff3ef2211d1a421ac91a

1 files changed, 44 insertions, 39 deletions

diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc
index 6610bcc713..1cebeb5bd7 100644
--- a/compiler/optimizing/instruction_simplifier.cc
+++ b/compiler/optimizing/instruction_simplifier.cc
@@ -186,7 +186,7 @@ bool InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop(HBinaryOperation
   binop->ReplaceInput(right_neg->GetInput(), 1);
   left_neg->GetBlock()->RemoveInstruction(left_neg);
   right_neg->GetBlock()->RemoveInstruction(right_neg);
-  HNeg* neg = new (GetGraph()->GetArena()) HNeg(binop->GetType(), binop);
+  HNeg* neg = new (GetGraph()->GetAllocator()) HNeg(binop->GetType(), binop);
   binop->GetBlock()->InsertInstructionBefore(neg, binop->GetNext());
   binop->ReplaceWithExceptInReplacementAtIndex(neg, 0);
   RecordSimplification();
@@ -225,15 +225,15 @@ bool InstructionSimplifierVisitor::TryDeMorganNegationFactoring(HBinaryOperation
     // Replace the `HAnd` or `HOr`.
     HBinaryOperation* hbin;
     if (op->IsAnd()) {
-      hbin = new (GetGraph()->GetArena()) HOr(type, src_left, src_right, dex_pc);
+      hbin = new (GetGraph()->GetAllocator()) HOr(type, src_left, src_right, dex_pc);
     } else {
-      hbin = new (GetGraph()->GetArena()) HAnd(type, src_left, src_right, dex_pc);
+      hbin = new (GetGraph()->GetAllocator()) HAnd(type, src_left, src_right, dex_pc);
     }
     HInstruction* hnot;
     if (left->IsBooleanNot()) {
-      hnot = new (GetGraph()->GetArena()) HBooleanNot(hbin, dex_pc);
+      hnot = new (GetGraph()->GetAllocator()) HBooleanNot(hbin, dex_pc);
     } else {
-      hnot = new (GetGraph()->GetArena()) HNot(type, hbin, dex_pc);
+      hnot = new (GetGraph()->GetAllocator()) HNot(type, hbin, dex_pc);
     }
 
     op->GetBlock()->InsertInstructionBefore(hbin, op);
@@ -274,7 +274,7 @@ bool InstructionSimplifierVisitor::TryCombineVecMultiplyAccumulate(HVecMul* mul)
       return false;
   }
 
-  ArenaAllocator* arena = mul->GetBlock()->GetGraph()->GetArena();
+  ArenaAllocator* arena = mul->GetBlock()->GetGraph()->GetAllocator();
 
   if (mul->HasOnlyOneNonEnvironmentUse()) {
     HInstruction* use = mul->GetUses().front().GetUser();
@@ -407,7 +407,8 @@ bool InstructionSimplifierVisitor::ReplaceRotateWithRor(HBinaryOperation* op,
                                                         HUShr* ushr,
                                                         HShl* shl) {
   DCHECK(op->IsAdd() || op->IsXor() || op->IsOr()) << op->DebugName();
-  HRor* ror = new (GetGraph()->GetArena()) HRor(ushr->GetType(), ushr->GetLeft(), ushr->GetRight());
+  HRor* ror =
+      new (GetGraph()->GetAllocator()) HRor(ushr->GetType(), ushr->GetLeft(), ushr->GetRight());
   op->GetBlock()->ReplaceAndRemoveInstructionWith(op, ror);
   if (!ushr->HasUses()) {
     ushr->GetBlock()->RemoveInstruction(ushr);
@@ -667,7 +668,7 @@ void InstructionSimplifierVisitor::VisitInstanceOf(HInstanceOf* instruction) {
     MaybeRecordStat(stats_, kRemovedInstanceOf);
     if (outcome && can_be_null) {
       // Type test will succeed, we just need a null test.
-      HNotEqual* test = new (graph->GetArena()) HNotEqual(graph->GetNullConstant(), object);
+      HNotEqual* test = new (graph->GetAllocator()) HNotEqual(graph->GetNullConstant(), object);
       instruction->GetBlock()->InsertInstructionBefore(test, instruction);
       instruction->ReplaceWith(test);
     } else {
@@ -939,14 +940,14 @@ void InstructionSimplifierVisitor::VisitSelect(HSelect* select) {
         if ((cmp == kCondLT || cmp == kCondLE) &&
             (a == negated && a == false_value && IsInt64Value(b, 0))) {
           // Found a < 0 ? -a : a which can be replaced by ABS(a).
-          replace_with = NewIntegralAbs(GetGraph()->GetArena(), false_value, select);
+          replace_with = NewIntegralAbs(GetGraph()->GetAllocator(), false_value, select);
         }
       } else if (false_value->IsNeg()) {
         HInstruction* negated = false_value->InputAt(0);
         if ((cmp == kCondGT || cmp == kCondGE) &&
             (a == true_value && a == negated && IsInt64Value(b, 0))) {
           // Found a > 0 ? a : -a which can be replaced by ABS(a).
-          replace_with = NewIntegralAbs(GetGraph()->GetArena(), true_value, select);
+          replace_with = NewIntegralAbs(GetGraph()->GetAllocator(), true_value, select);
         }
       } else if (true_value->IsSub() && false_value->IsSub()) {
         HInstruction* true_sub1 = true_value->InputAt(0);
@@ -961,7 +962,7 @@ void InstructionSimplifierVisitor::VisitSelect(HSelect* select) {
           // Found a > b ? a - b  : b - a   or
           //       a < b ? b - a  : a - b
           // which can be replaced by ABS(a - b) for lower precision operands a, b.
-          replace_with = NewIntegralAbs(GetGraph()->GetArena(), true_value, select);
+          replace_with = NewIntegralAbs(GetGraph()->GetAllocator(), true_value, select);
         }
       }
     }
@@ -1173,7 +1174,8 @@ void InstructionSimplifierVisitor::VisitAdd(HAdd* instruction) {
     // particular, we do not want the live range of `b` to be extended if we are
     // not sure the initial 'NEG' instruction can be removed.
     HInstruction* other = left_is_neg ? right : left;
-    HSub* sub = new(GetGraph()->GetArena()) HSub(instruction->GetType(), other, neg->GetInput());
+    HSub* sub =
+        new(GetGraph()->GetAllocator()) HSub(instruction->GetType(), other, neg->GetInput());
     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, sub);
     RecordSimplification();
     neg->GetBlock()->RemoveInstruction(neg);
@@ -1251,10 +1253,10 @@ void InstructionSimplifierVisitor::VisitAnd(HAnd* instruction) {
       DCHECK_NE(new_and_input->GetType(), DataType::Type::kInt64);
       HConstant* new_const = GetGraph()->GetConstant(DataType::Type::kInt32, value);
       HAnd* new_and =
-          new (GetGraph()->GetArena()) HAnd(DataType::Type::kInt32, new_and_input, new_const);
+          new (GetGraph()->GetAllocator()) HAnd(DataType::Type::kInt32, new_and_input, new_const);
       instruction->GetBlock()->InsertInstructionBefore(new_and, instruction);
       HTypeConversion* new_conversion =
-          new (GetGraph()->GetArena()) HTypeConversion(DataType::Type::kInt64, new_and);
+          new (GetGraph()->GetAllocator()) HTypeConversion(DataType::Type::kInt64, new_and);
       instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, new_conversion);
       input_other->GetBlock()->RemoveInstruction(input_other);
       RecordSimplification();
@@ -1279,7 +1281,7 @@ void InstructionSimplifierVisitor::VisitAnd(HAnd* instruction) {
           input_other->HasOnlyOneNonEnvironmentUse()) {
         DCHECK(input_other->IsShr());  // For UShr, we would have taken the branch above.
         // Replace SHR+AND with USHR, for example "(x >> 24) & 0xff" -> "x >>> 24".
-        HUShr* ushr = new (GetGraph()->GetArena()) HUShr(instruction->GetType(),
+        HUShr* ushr = new (GetGraph()->GetAllocator()) HUShr(instruction->GetType(),
                                                          input_other->InputAt(0),
                                                          input_other->InputAt(1),
                                                          input_other->GetDexPc());
@@ -1410,7 +1412,8 @@ void InstructionSimplifierVisitor::VisitCondition(HCondition* condition) {
   // on the right hand side.
   if (condition->GetLeft()->IsConstant() && !condition->GetRight()->IsConstant()) {
     HBasicBlock* block = condition->GetBlock();
-    HCondition* replacement = GetOppositeConditionSwapOps(block->GetGraph()->GetArena(), condition);
+    HCondition* replacement =
+        GetOppositeConditionSwapOps(block->GetGraph()->GetAllocator(), condition);
     // If it is a fp we must set the opposite bias.
     if (replacement != nullptr) {
       if (condition->IsLtBias()) {
@@ -1506,7 +1509,7 @@ void InstructionSimplifierVisitor::VisitDiv(HDiv* instruction) {
     // with
     //    NEG dst, src
     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(
-        instruction, new (GetGraph()->GetArena()) HNeg(type, input_other));
+        instruction, new (GetGraph()->GetAllocator()) HNeg(type, input_other));
     RecordSimplification();
     return;
   }
@@ -1532,7 +1535,7 @@ void InstructionSimplifierVisitor::VisitDiv(HDiv* instruction) {
 
     if (reciprocal != nullptr) {
       instruction->GetBlock()->ReplaceAndRemoveInstructionWith(
-          instruction, new (GetGraph()->GetArena()) HMul(type, input_other, reciprocal));
+          instruction, new (GetGraph()->GetAllocator()) HMul(type, input_other, reciprocal));
       RecordSimplification();
       return;
     }
@@ -1544,7 +1547,7 @@ void InstructionSimplifierVisitor::VisitMul(HMul* instruction) {
   HInstruction* input_other = instruction->GetLeastConstantLeft();
   DataType::Type type = instruction->GetType();
   HBasicBlock* block = instruction->GetBlock();
-  ArenaAllocator* allocator = GetGraph()->GetArena();
+  ArenaAllocator* allocator = GetGraph()->GetAllocator();
 
   if (input_cst == nullptr) {
     return;
@@ -1683,8 +1686,8 @@ void InstructionSimplifierVisitor::VisitNeg(HNeg* instruction) {
     // removed.
     // We do not perform optimization for fp because we could lose the sign of zero.
     HSub* sub = input->AsSub();
-    HSub* new_sub =
-        new (GetGraph()->GetArena()) HSub(instruction->GetType(), sub->GetRight(), sub->GetLeft());
+    HSub* new_sub = new (GetGraph()->GetAllocator()) HSub(
+        instruction->GetType(), sub->GetRight(), sub->GetLeft());
     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, new_sub);
     if (!sub->HasUses()) {
       sub->GetBlock()->RemoveInstruction(sub);
@@ -1786,7 +1789,7 @@ void InstructionSimplifierVisitor::VisitSub(HSub* instruction) {
   }
 
   HBasicBlock* block = instruction->GetBlock();
-  ArenaAllocator* allocator = GetGraph()->GetArena();
+  ArenaAllocator* allocator = GetGraph()->GetAllocator();
 
   HInstruction* left = instruction->GetLeft();
   HInstruction* right = instruction->GetRight();
@@ -1818,7 +1821,7 @@ void InstructionSimplifierVisitor::VisitSub(HSub* instruction) {
     //    SUB dst, a, tmp
     // with
     //    ADD dst, a, b
-    HAdd* add = new(GetGraph()->GetArena()) HAdd(type, left, right->AsNeg()->GetInput());
+    HAdd* add = new(GetGraph()->GetAllocator()) HAdd(type, left, right->AsNeg()->GetInput());
     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, add);
     RecordSimplification();
     right->GetBlock()->RemoveInstruction(right);
@@ -1834,9 +1837,9 @@ void InstructionSimplifierVisitor::VisitSub(HSub* instruction) {
     //    NEG dst, tmp
     // The second version is not intrinsically better, but enables more
     // transformations.
-    HAdd* add = new(GetGraph()->GetArena()) HAdd(type, left->AsNeg()->GetInput(), right);
+    HAdd* add = new(GetGraph()->GetAllocator()) HAdd(type, left->AsNeg()->GetInput(), right);
     instruction->GetBlock()->InsertInstructionBefore(add, instruction);
-    HNeg* neg = new (GetGraph()->GetArena()) HNeg(instruction->GetType(), add);
+    HNeg* neg = new (GetGraph()->GetAllocator()) HNeg(instruction->GetType(), add);
     instruction->GetBlock()->InsertInstructionBefore(neg, instruction);
     instruction->ReplaceWith(neg);
     instruction->GetBlock()->RemoveInstruction(instruction);
@@ -1898,7 +1901,7 @@ void InstructionSimplifierVisitor::VisitXor(HXor* instruction) {
     //    XOR dst, src, 1
     // with
     //    BOOLEAN_NOT dst, src
-    HBooleanNot* boolean_not = new (GetGraph()->GetArena()) HBooleanNot(input_other);
+    HBooleanNot* boolean_not = new (GetGraph()->GetAllocator()) HBooleanNot(input_other);
     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, boolean_not);
     RecordSimplification();
     return;
@@ -1909,7 +1912,7 @@ void InstructionSimplifierVisitor::VisitXor(HXor* instruction) {
     //    XOR dst, src, 0xFFF...FF
     // with
     //    NOT dst, src
-    HNot* bitwise_not = new (GetGraph()->GetArena()) HNot(instruction->GetType(), input_other);
+    HNot* bitwise_not = new (GetGraph()->GetAllocator()) HNot(instruction->GetType(), input_other);
     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, bitwise_not);
     RecordSimplification();
     return;
@@ -1980,10 +1983,10 @@ void InstructionSimplifierVisitor::SimplifyRotate(HInvoke* invoke,
     // Unconditionally set the type of the negated distance to `int`,
     // as shift and rotate operations expect a 32-bit (or narrower)
     // value for their distance input.
-    distance = new (GetGraph()->GetArena()) HNeg(DataType::Type::kInt32, distance);
+    distance = new (GetGraph()->GetAllocator()) HNeg(DataType::Type::kInt32, distance);
     invoke->GetBlock()->InsertInstructionBefore(distance, invoke);
   }
-  HRor* ror = new (GetGraph()->GetArena()) HRor(type, value, distance);
+  HRor* ror = new (GetGraph()->GetAllocator()) HRor(type, value, distance);
   invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, ror);
   // Remove ClinitCheck and LoadClass, if possible.
   HInstruction* clinit = invoke->GetInputs().back();
@@ -2127,7 +2130,7 @@ void InstructionSimplifierVisitor::SimplifyCompare(HInvoke* invoke,
   } else {
     right = GetGraph()->GetIntConstant(0);
   }
-  HCompare* compare = new (GetGraph()->GetArena())
+  HCompare* compare = new (GetGraph()->GetAllocator())
       HCompare(type, left, right, ComparisonBias::kNoBias, dex_pc);
   invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, compare);
 }
@@ -2137,7 +2140,7 @@ void InstructionSimplifierVisitor::SimplifyIsNaN(HInvoke* invoke) {
   uint32_t dex_pc = invoke->GetDexPc();
   // IsNaN(x) is the same as x != x.
   HInstruction* x = invoke->InputAt(0);
-  HCondition* condition = new (GetGraph()->GetArena()) HNotEqual(x, x, dex_pc);
+  HCondition* condition = new (GetGraph()->GetAllocator()) HNotEqual(x, x, dex_pc);
   condition->SetBias(ComparisonBias::kLtBias);
   invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, condition);
 }
@@ -2164,11 +2167,11 @@ void InstructionSimplifierVisitor::SimplifyFP2Int(HInvoke* invoke) {
                          kNoThrow);
   }
   // Test IsNaN(x), which is the same as x != x.
-  HCondition* condition = new (GetGraph()->GetArena()) HNotEqual(x, x, dex_pc);
+  HCondition* condition = new (GetGraph()->GetAllocator()) HNotEqual(x, x, dex_pc);
   condition->SetBias(ComparisonBias::kLtBias);
   invoke->GetBlock()->InsertInstructionBefore(condition, invoke->GetNext());
   // Select between the two.
-  HInstruction* select = new (GetGraph()->GetArena()) HSelect(condition, nan, invoke, dex_pc);
+  HInstruction* select = new (GetGraph()->GetAllocator()) HSelect(condition, nan, invoke, dex_pc);
   invoke->GetBlock()->InsertInstructionBefore(select, condition->GetNext());
   invoke->ReplaceWithExceptInReplacementAtIndex(select, 0);  // false at index 0
 }
@@ -2177,7 +2180,7 @@ void InstructionSimplifierVisitor::SimplifyStringCharAt(HInvoke* invoke) {
   HInstruction* str = invoke->InputAt(0);
   HInstruction* index = invoke->InputAt(1);
   uint32_t dex_pc = invoke->GetDexPc();
-  ArenaAllocator* arena = GetGraph()->GetArena();
+  ArenaAllocator* arena = GetGraph()->GetAllocator();
   // We treat String as an array to allow DCE and BCE to seamlessly work on strings,
   // so create the HArrayLength, HBoundsCheck and HArrayGet.
   HArrayLength* length = new (arena) HArrayLength(str, dex_pc, /* is_string_length */ true);
@@ -2202,13 +2205,13 @@ void InstructionSimplifierVisitor::SimplifyStringIsEmptyOrLength(HInvoke* invoke
   // We treat String as an array to allow DCE and BCE to seamlessly work on strings,
   // so create the HArrayLength.
   HArrayLength* length =
-      new (GetGraph()->GetArena()) HArrayLength(str, dex_pc, /* is_string_length */ true);
+      new (GetGraph()->GetAllocator()) HArrayLength(str, dex_pc, /* is_string_length */ true);
   HInstruction* replacement;
   if (invoke->GetIntrinsic() == Intrinsics::kStringIsEmpty) {
     // For String.isEmpty(), create the `HEqual` representing the `length == 0`.
     invoke->GetBlock()->InsertInstructionBefore(length, invoke);
     HIntConstant* zero = GetGraph()->GetIntConstant(0);
-    HEqual* equal = new (GetGraph()->GetArena()) HEqual(length, zero, dex_pc);
+    HEqual* equal = new (GetGraph()->GetAllocator()) HEqual(length, zero, dex_pc);
     replacement = equal;
   } else {
     DCHECK_EQ(invoke->GetIntrinsic(), Intrinsics::kStringLength);
@@ -2278,9 +2281,11 @@ void InstructionSimplifierVisitor::SimplifyAllocationIntrinsic(HInvoke* invoke)
   }
 }
 
-void InstructionSimplifierVisitor::SimplifyMemBarrier(HInvoke* invoke, MemBarrierKind barrier_kind) {
+void InstructionSimplifierVisitor::SimplifyMemBarrier(HInvoke* invoke,
+                                                      MemBarrierKind barrier_kind) {
   uint32_t dex_pc = invoke->GetDexPc();
-  HMemoryBarrier* mem_barrier = new (GetGraph()->GetArena()) HMemoryBarrier(barrier_kind, dex_pc);
+  HMemoryBarrier* mem_barrier =
+      new (GetGraph()->GetAllocator()) HMemoryBarrier(barrier_kind, dex_pc);
   invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, mem_barrier);
 }
 
@@ -2519,7 +2524,7 @@ bool InstructionSimplifierVisitor::TrySubtractionChainSimplification(
   int64_t const3_val = ComputeAddition(type, const1_val, const2_val);
   HBasicBlock* block = instruction->GetBlock();
   HConstant* const3 = block->GetGraph()->GetConstant(type, const3_val);
-  ArenaAllocator* arena = instruction->GetArena();
+  ArenaAllocator* arena = instruction->GetAllocator();
   HInstruction* z;
 
   if (is_x_negated) {