diff --git a/compiler/optimizing/bounds_check_elimination_test.cc b/compiler/optimizing/bounds_check_elimination_test.cc
index 851838c..1523478 100644
--- a/compiler/optimizing/bounds_check_elimination_test.cc
+++ b/compiler/optimizing/bounds_check_elimination_test.cc
@@ -32,10 +32,9 @@
 /**
  * Fixture class for the BoundsCheckElimination tests.
  */
-class BoundsCheckEliminationTest : public testing::Test {
+class BoundsCheckEliminationTest : public OptimizingUnitTest {
  public:
-  BoundsCheckEliminationTest()  : pool_(), allocator_(&pool_) {
-    graph_ = CreateGraph(&allocator_);
+  BoundsCheckEliminationTest()  : graph_(CreateGraph()) {
     graph_->SetHasBoundsChecks(true);
   }
 
@@ -57,8 +56,6 @@
     BoundsCheckElimination(graph_, side_effects, &induction).Run();
   }
 
-  ArenaPool pool_;
-  ArenaAllocator allocator_;
   HGraph* graph_;
 };
 
@@ -67,12 +64,12 @@
 // else if (i >= array.length) { array[i] = 1; // Can't eliminate. }
 // else { array[i] = 1; // Can eliminate. }
 TEST_F(BoundsCheckEliminationTest, NarrowingRangeArrayBoundsElimination) {
-  HBasicBlock* entry = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* entry = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(entry);
   graph_->SetEntryBlock(entry);
-  HInstruction* parameter1 = new (&allocator_) HParameterValue(
+  HInstruction* parameter1 = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kReference);  // array
-  HInstruction* parameter2 = new (&allocator_) HParameterValue(
+  HInstruction* parameter2 = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kInt32);  // i
   entry->AddInstruction(parameter1);
   entry->AddInstruction(parameter2);
@@ -80,70 +77,70 @@
   HInstruction* constant_1 = graph_->GetIntConstant(1);
   HInstruction* constant_0 = graph_->GetIntConstant(0);
 
-  HBasicBlock* block1 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block1 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block1);
-  HInstruction* cmp = new (&allocator_) HGreaterThanOrEqual(parameter2, constant_0);
-  HIf* if_inst = new (&allocator_) HIf(cmp);
+  HInstruction* cmp = new (GetAllocator()) HGreaterThanOrEqual(parameter2, constant_0);
+  HIf* if_inst = new (GetAllocator()) HIf(cmp);
   block1->AddInstruction(cmp);
   block1->AddInstruction(if_inst);
   entry->AddSuccessor(block1);
 
-  HBasicBlock* block2 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block2 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block2);
-  HNullCheck* null_check = new (&allocator_) HNullCheck(parameter1, 0);
-  HArrayLength* array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check2 = new (&allocator_)
+  HNullCheck* null_check = new (GetAllocator()) HNullCheck(parameter1, 0);
+  HArrayLength* array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check2 = new (GetAllocator())
       HBoundsCheck(parameter2, array_length, 0);
-  HArraySet* array_set = new (&allocator_) HArraySet(
+  HArraySet* array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check2, constant_1, DataType::Type::kInt32, 0);
   block2->AddInstruction(null_check);
   block2->AddInstruction(array_length);
   block2->AddInstruction(bounds_check2);
   block2->AddInstruction(array_set);
 
-  HBasicBlock* block3 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block3 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block3);
-  null_check = new (&allocator_) HNullCheck(parameter1, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  cmp = new (&allocator_) HLessThan(parameter2, array_length);
-  if_inst = new (&allocator_) HIf(cmp);
+  null_check = new (GetAllocator()) HNullCheck(parameter1, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  cmp = new (GetAllocator()) HLessThan(parameter2, array_length);
+  if_inst = new (GetAllocator()) HIf(cmp);
   block3->AddInstruction(null_check);
   block3->AddInstruction(array_length);
   block3->AddInstruction(cmp);
   block3->AddInstruction(if_inst);
 
-  HBasicBlock* block4 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block4 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block4);
-  null_check = new (&allocator_) HNullCheck(parameter1, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check4 = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter1, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check4 = new (GetAllocator())
       HBoundsCheck(parameter2, array_length, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check4, constant_1, DataType::Type::kInt32, 0);
   block4->AddInstruction(null_check);
   block4->AddInstruction(array_length);
   block4->AddInstruction(bounds_check4);
   block4->AddInstruction(array_set);
 
-  HBasicBlock* block5 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block5 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block5);
-  null_check = new (&allocator_) HNullCheck(parameter1, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check5 = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter1, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check5 = new (GetAllocator())
       HBoundsCheck(parameter2, array_length, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check5, constant_1, DataType::Type::kInt32, 0);
   block5->AddInstruction(null_check);
   block5->AddInstruction(array_length);
   block5->AddInstruction(bounds_check5);
   block5->AddInstruction(array_set);
 
-  HBasicBlock* exit = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* exit = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(exit);
   block2->AddSuccessor(exit);
   block4->AddSuccessor(exit);
   block5->AddSuccessor(exit);
-  exit->AddInstruction(new (&allocator_) HExit());
+  exit->AddInstruction(new (GetAllocator()) HExit());
 
   block1->AddSuccessor(block3);  // True successor
   block1->AddSuccessor(block2);  // False successor
@@ -164,12 +161,12 @@
 //   if (j < array.length) array[j] = 1;  // Can't eliminate.
 // }
 TEST_F(BoundsCheckEliminationTest, OverflowArrayBoundsElimination) {
-  HBasicBlock* entry = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* entry = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(entry);
   graph_->SetEntryBlock(entry);
-  HInstruction* parameter1 = new (&allocator_) HParameterValue(
+  HInstruction* parameter1 = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kReference);  // array
-  HInstruction* parameter2 = new (&allocator_) HParameterValue(
+  HInstruction* parameter2 = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kInt32);  // i
   entry->AddInstruction(parameter1);
   entry->AddInstruction(parameter2);
@@ -178,39 +175,40 @@
   HInstruction* constant_0 = graph_->GetIntConstant(0);
   HInstruction* constant_max_int = graph_->GetIntConstant(INT_MAX);
 
-  HBasicBlock* block1 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block1 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block1);
-  HInstruction* cmp = new (&allocator_) HLessThanOrEqual(parameter2, constant_0);
-  HIf* if_inst = new (&allocator_) HIf(cmp);
+  HInstruction* cmp = new (GetAllocator()) HLessThanOrEqual(parameter2, constant_0);
+  HIf* if_inst = new (GetAllocator()) HIf(cmp);
   block1->AddInstruction(cmp);
   block1->AddInstruction(if_inst);
   entry->AddSuccessor(block1);
 
-  HBasicBlock* block2 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block2 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block2);
-  HInstruction* add = new (&allocator_) HAdd(DataType::Type::kInt32, parameter2, constant_max_int);
-  HNullCheck* null_check = new (&allocator_) HNullCheck(parameter1, 0);
-  HArrayLength* array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HInstruction* cmp2 = new (&allocator_) HGreaterThanOrEqual(add, array_length);
-  if_inst = new (&allocator_) HIf(cmp2);
+  HInstruction* add =
+      new (GetAllocator()) HAdd(DataType::Type::kInt32, parameter2, constant_max_int);
+  HNullCheck* null_check = new (GetAllocator()) HNullCheck(parameter1, 0);
+  HArrayLength* array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HInstruction* cmp2 = new (GetAllocator()) HGreaterThanOrEqual(add, array_length);
+  if_inst = new (GetAllocator()) HIf(cmp2);
   block2->AddInstruction(add);
   block2->AddInstruction(null_check);
   block2->AddInstruction(array_length);
   block2->AddInstruction(cmp2);
   block2->AddInstruction(if_inst);
 
-  HBasicBlock* block3 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block3 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block3);
-  HBoundsCheck* bounds_check = new (&allocator_)
+  HBoundsCheck* bounds_check = new (GetAllocator())
       HBoundsCheck(add, array_length, 0);
-  HArraySet* array_set = new (&allocator_) HArraySet(
+  HArraySet* array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check, constant_1, DataType::Type::kInt32, 0);
   block3->AddInstruction(bounds_check);
   block3->AddInstruction(array_set);
 
-  HBasicBlock* exit = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* exit = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(exit);
-  exit->AddInstruction(new (&allocator_) HExit());
+  exit->AddInstruction(new (GetAllocator()) HExit());
   block1->AddSuccessor(exit);    // true successor
   block1->AddSuccessor(block2);  // false successor
   block2->AddSuccessor(exit);    // true successor
@@ -228,12 +226,12 @@
 //   if (j > 0) array[j] = 1;    // Can't eliminate.
 // }
 TEST_F(BoundsCheckEliminationTest, UnderflowArrayBoundsElimination) {
-  HBasicBlock* entry = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* entry = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(entry);
   graph_->SetEntryBlock(entry);
-  HInstruction* parameter1 = new (&allocator_) HParameterValue(
+  HInstruction* parameter1 = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kReference);  // array
-  HInstruction* parameter2 = new (&allocator_) HParameterValue(
+  HInstruction* parameter2 = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kInt32);  // i
   entry->AddInstruction(parameter1);
   entry->AddInstruction(parameter2);
@@ -242,41 +240,42 @@
   HInstruction* constant_0 = graph_->GetIntConstant(0);
   HInstruction* constant_max_int = graph_->GetIntConstant(INT_MAX);
 
-  HBasicBlock* block1 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block1 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block1);
-  HNullCheck* null_check = new (&allocator_) HNullCheck(parameter1, 0);
-  HArrayLength* array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HInstruction* cmp = new (&allocator_) HGreaterThanOrEqual(parameter2, array_length);
-  HIf* if_inst = new (&allocator_) HIf(cmp);
+  HNullCheck* null_check = new (GetAllocator()) HNullCheck(parameter1, 0);
+  HArrayLength* array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HInstruction* cmp = new (GetAllocator()) HGreaterThanOrEqual(parameter2, array_length);
+  HIf* if_inst = new (GetAllocator()) HIf(cmp);
   block1->AddInstruction(null_check);
   block1->AddInstruction(array_length);
   block1->AddInstruction(cmp);
   block1->AddInstruction(if_inst);
   entry->AddSuccessor(block1);
 
-  HBasicBlock* block2 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block2 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block2);
-  HInstruction* sub1 = new (&allocator_) HSub(DataType::Type::kInt32, parameter2, constant_max_int);
-  HInstruction* sub2 = new (&allocator_) HSub(DataType::Type::kInt32, sub1, constant_max_int);
-  HInstruction* cmp2 = new (&allocator_) HLessThanOrEqual(sub2, constant_0);
-  if_inst = new (&allocator_) HIf(cmp2);
+  HInstruction* sub1 =
+      new (GetAllocator()) HSub(DataType::Type::kInt32, parameter2, constant_max_int);
+  HInstruction* sub2 = new (GetAllocator()) HSub(DataType::Type::kInt32, sub1, constant_max_int);
+  HInstruction* cmp2 = new (GetAllocator()) HLessThanOrEqual(sub2, constant_0);
+  if_inst = new (GetAllocator()) HIf(cmp2);
   block2->AddInstruction(sub1);
   block2->AddInstruction(sub2);
   block2->AddInstruction(cmp2);
   block2->AddInstruction(if_inst);
 
-  HBasicBlock* block3 = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block3 = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block3);
-  HBoundsCheck* bounds_check = new (&allocator_)
+  HBoundsCheck* bounds_check = new (GetAllocator())
       HBoundsCheck(sub2, array_length, 0);
-  HArraySet* array_set = new (&allocator_) HArraySet(
+  HArraySet* array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check, constant_1, DataType::Type::kInt32, 0);
   block3->AddInstruction(bounds_check);
   block3->AddInstruction(array_set);
 
-  HBasicBlock* exit = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* exit = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(exit);
-  exit->AddInstruction(new (&allocator_) HExit());
+  exit->AddInstruction(new (GetAllocator()) HExit());
   block1->AddSuccessor(exit);    // true successor
   block1->AddSuccessor(block2);  // false successor
   block2->AddSuccessor(exit);    // true successor
@@ -292,10 +291,10 @@
 // array[5] = 1; // Can eliminate.
 // array[4] = 1; // Can eliminate.
 TEST_F(BoundsCheckEliminationTest, ConstantArrayBoundsElimination) {
-  HBasicBlock* entry = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* entry = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(entry);
   graph_->SetEntryBlock(entry);
-  HInstruction* parameter = new (&allocator_) HParameterValue(
+  HInstruction* parameter = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kReference);
   entry->AddInstruction(parameter);
 
@@ -304,49 +303,49 @@
   HInstruction* constant_6 = graph_->GetIntConstant(6);
   HInstruction* constant_1 = graph_->GetIntConstant(1);
 
-  HBasicBlock* block = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block);
   entry->AddSuccessor(block);
 
-  HNullCheck* null_check = new (&allocator_) HNullCheck(parameter, 0);
-  HArrayLength* array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check6 = new (&allocator_)
+  HNullCheck* null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  HArrayLength* array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check6 = new (GetAllocator())
       HBoundsCheck(constant_6, array_length, 0);
-  HInstruction* array_set = new (&allocator_) HArraySet(
+  HInstruction* array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check6, constant_1, DataType::Type::kInt32, 0);
   block->AddInstruction(null_check);
   block->AddInstruction(array_length);
   block->AddInstruction(bounds_check6);
   block->AddInstruction(array_set);
 
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check5 = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check5 = new (GetAllocator())
       HBoundsCheck(constant_5, array_length, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check5, constant_1, DataType::Type::kInt32, 0);
   block->AddInstruction(null_check);
   block->AddInstruction(array_length);
   block->AddInstruction(bounds_check5);
   block->AddInstruction(array_set);
 
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check4 = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check4 = new (GetAllocator())
       HBoundsCheck(constant_4, array_length, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
     null_check, bounds_check4, constant_1, DataType::Type::kInt32, 0);
   block->AddInstruction(null_check);
   block->AddInstruction(array_length);
   block->AddInstruction(bounds_check4);
   block->AddInstruction(array_set);
 
-  block->AddInstruction(new (&allocator_) HGoto());
+  block->AddInstruction(new (GetAllocator()) HGoto());
 
-  HBasicBlock* exit = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* exit = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(exit);
   block->AddSuccessor(exit);
-  exit->AddInstruction(new (&allocator_) HExit());
+  exit->AddInstruction(new (GetAllocator()) HExit());
 
   RunBCE();
 
@@ -429,28 +428,28 @@
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination1a) {
   // for (int i=0; i<array.length; i++) { array[i] = 10; // Can eliminate with gvn. }
-  HInstruction* bounds_check = BuildSSAGraph1(graph_, &allocator_, 0, 1);
+  HInstruction* bounds_check = BuildSSAGraph1(graph_, GetAllocator(), 0, 1);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination1b) {
   // for (int i=1; i<array.length; i++) { array[i] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph1(graph_, &allocator_, 1, 1);
+  HInstruction* bounds_check = BuildSSAGraph1(graph_, GetAllocator(), 1, 1);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination1c) {
   // for (int i=-1; i<array.length; i++) { array[i] = 10; // Can't eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph1(graph_, &allocator_, -1, 1);
+  HInstruction* bounds_check = BuildSSAGraph1(graph_, GetAllocator(), -1, 1);
   RunBCE();
   ASSERT_FALSE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination1d) {
   // for (int i=0; i<=array.length; i++) { array[i] = 10; // Can't eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph1(graph_, &allocator_, 0, 1, kCondGT);
+  HInstruction* bounds_check = BuildSSAGraph1(graph_, GetAllocator(), 0, 1, kCondGT);
   RunBCE();
   ASSERT_FALSE(IsRemoved(bounds_check));
 }
@@ -458,14 +457,14 @@
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination1e) {
   // for (int i=0; i<array.length; i += 2) {
   //   array[i] = 10; // Can't eliminate due to overflow concern. }
-  HInstruction* bounds_check = BuildSSAGraph1(graph_, &allocator_, 0, 2);
+  HInstruction* bounds_check = BuildSSAGraph1(graph_, GetAllocator(), 0, 2);
   RunBCE();
   ASSERT_FALSE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination1f) {
   // for (int i=1; i<array.length; i += 2) { array[i] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph1(graph_, &allocator_, 1, 2);
+  HInstruction* bounds_check = BuildSSAGraph1(graph_, GetAllocator(), 1, 2);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
@@ -546,35 +545,35 @@
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination2a) {
   // for (int i=array.length; i>0; i--) { array[i-1] = 10; // Can eliminate with gvn. }
-  HInstruction* bounds_check = BuildSSAGraph2(graph_, &allocator_, 0);
+  HInstruction* bounds_check = BuildSSAGraph2(graph_, GetAllocator(), 0);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination2b) {
   // for (int i=array.length; i>1; i--) { array[i-1] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph2(graph_, &allocator_, 1);
+  HInstruction* bounds_check = BuildSSAGraph2(graph_, GetAllocator(), 1);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination2c) {
   // for (int i=array.length; i>-1; i--) { array[i-1] = 10; // Can't eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph2(graph_, &allocator_, -1);
+  HInstruction* bounds_check = BuildSSAGraph2(graph_, GetAllocator(), -1);
   RunBCE();
   ASSERT_FALSE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination2d) {
   // for (int i=array.length; i>=0; i--) { array[i-1] = 10; // Can't eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph2(graph_, &allocator_, 0, -1, kCondLT);
+  HInstruction* bounds_check = BuildSSAGraph2(graph_, GetAllocator(), 0, -1, kCondLT);
   RunBCE();
   ASSERT_FALSE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination2e) {
   // for (int i=array.length; i>0; i-=2) { array[i-1] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph2(graph_, &allocator_, 0, -2);
+  HInstruction* bounds_check = BuildSSAGraph2(graph_, GetAllocator(), 0, -2);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
@@ -653,7 +652,7 @@
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination3a) {
   // int[] array = new int[10];
   // for (int i=0; i<10; i++) { array[i] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph3(graph_, &allocator_, 0, 1, kCondGE);
+  HInstruction* bounds_check = BuildSSAGraph3(graph_, GetAllocator(), 0, 1, kCondGE);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
@@ -661,7 +660,7 @@
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination3b) {
   // int[] array = new int[10];
   // for (int i=1; i<10; i++) { array[i] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph3(graph_, &allocator_, 1, 1, kCondGE);
+  HInstruction* bounds_check = BuildSSAGraph3(graph_, GetAllocator(), 1, 1, kCondGE);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
@@ -669,7 +668,7 @@
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination3c) {
   // int[] array = new int[10];
   // for (int i=0; i<=10; i++) { array[i] = 10; // Can't eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph3(graph_, &allocator_, 0, 1, kCondGT);
+  HInstruction* bounds_check = BuildSSAGraph3(graph_, GetAllocator(), 0, 1, kCondGT);
   RunBCE();
   ASSERT_FALSE(IsRemoved(bounds_check));
 }
@@ -677,7 +676,7 @@
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination3d) {
   // int[] array = new int[10];
   // for (int i=1; i<10; i+=8) { array[i] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph3(graph_, &allocator_, 1, 8, kCondGE);
+  HInstruction* bounds_check = BuildSSAGraph3(graph_, GetAllocator(), 1, 8, kCondGE);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
@@ -759,21 +758,21 @@
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination4a) {
   // for (int i=0; i<array.length; i++) { array[array.length-i-1] = 10; // Can eliminate with gvn. }
-  HInstruction* bounds_check = BuildSSAGraph4(graph_, &allocator_, 0);
+  HInstruction* bounds_check = BuildSSAGraph4(graph_, GetAllocator(), 0);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination4b) {
   // for (int i=1; i<array.length; i++) { array[array.length-i-1] = 10; // Can eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph4(graph_, &allocator_, 1);
+  HInstruction* bounds_check = BuildSSAGraph4(graph_, GetAllocator(), 1);
   RunBCE();
   ASSERT_TRUE(IsRemoved(bounds_check));
 }
 
 TEST_F(BoundsCheckEliminationTest, LoopArrayBoundsElimination4c) {
   // for (int i=0; i<=array.length; i++) { array[array.length-i] = 10; // Can't eliminate. }
-  HInstruction* bounds_check = BuildSSAGraph4(graph_, &allocator_, 0, kCondGT);
+  HInstruction* bounds_check = BuildSSAGraph4(graph_, GetAllocator(), 0, kCondGT);
   RunBCE();
   ASSERT_FALSE(IsRemoved(bounds_check));
 }
@@ -790,10 +789,10 @@
 //  }
 // }
 TEST_F(BoundsCheckEliminationTest, BubbleSortArrayBoundsElimination) {
-  HBasicBlock* entry = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* entry = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(entry);
   graph_->SetEntryBlock(entry);
-  HInstruction* parameter = new (&allocator_) HParameterValue(
+  HInstruction* parameter = new (GetAllocator()) HParameterValue(
       graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kReference);
   entry->AddInstruction(parameter);
 
@@ -801,23 +800,23 @@
   HInstruction* constant_minus_1 = graph_->GetIntConstant(-1);
   HInstruction* constant_1 = graph_->GetIntConstant(1);
 
-  HBasicBlock* block = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block);
   entry->AddSuccessor(block);
-  block->AddInstruction(new (&allocator_) HGoto());
+  block->AddInstruction(new (GetAllocator()) HGoto());
 
-  HBasicBlock* exit = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* exit = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(exit);
-  exit->AddInstruction(new (&allocator_) HExit());
+  exit->AddInstruction(new (GetAllocator()) HExit());
 
-  HBasicBlock* outer_header = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* outer_header = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(outer_header);
-  HPhi* phi_i = new (&allocator_) HPhi(&allocator_, 0, 0, DataType::Type::kInt32);
-  HNullCheck* null_check = new (&allocator_) HNullCheck(parameter, 0);
-  HArrayLength* array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HAdd* add = new (&allocator_) HAdd(DataType::Type::kInt32, array_length, constant_minus_1);
-  HInstruction* cmp = new (&allocator_) HGreaterThanOrEqual(phi_i, add);
-  HIf* if_inst = new (&allocator_) HIf(cmp);
+  HPhi* phi_i = new (GetAllocator()) HPhi(GetAllocator(), 0, 0, DataType::Type::kInt32);
+  HNullCheck* null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  HArrayLength* array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HAdd* add = new (GetAllocator()) HAdd(DataType::Type::kInt32, array_length, constant_minus_1);
+  HInstruction* cmp = new (GetAllocator()) HGreaterThanOrEqual(phi_i, add);
+  HIf* if_inst = new (GetAllocator()) HIf(cmp);
   outer_header->AddPhi(phi_i);
   outer_header->AddInstruction(null_check);
   outer_header->AddInstruction(array_length);
@@ -826,15 +825,15 @@
   outer_header->AddInstruction(if_inst);
   phi_i->AddInput(constant_0);
 
-  HBasicBlock* inner_header = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* inner_header = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(inner_header);
-  HPhi* phi_j = new (&allocator_) HPhi(&allocator_, 0, 0, DataType::Type::kInt32);
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HSub* sub = new (&allocator_) HSub(DataType::Type::kInt32, array_length, phi_i);
-  add = new (&allocator_) HAdd(DataType::Type::kInt32, sub, constant_minus_1);
-  cmp = new (&allocator_) HGreaterThanOrEqual(phi_j, add);
-  if_inst = new (&allocator_) HIf(cmp);
+  HPhi* phi_j = new (GetAllocator()) HPhi(GetAllocator(), 0, 0, DataType::Type::kInt32);
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HSub* sub = new (GetAllocator()) HSub(DataType::Type::kInt32, array_length, phi_i);
+  add = new (GetAllocator()) HAdd(DataType::Type::kInt32, sub, constant_minus_1);
+  cmp = new (GetAllocator()) HGreaterThanOrEqual(phi_j, add);
+  if_inst = new (GetAllocator()) HIf(cmp);
   inner_header->AddPhi(phi_j);
   inner_header->AddInstruction(null_check);
   inner_header->AddInstruction(array_length);
@@ -844,25 +843,25 @@
   inner_header->AddInstruction(if_inst);
   phi_j->AddInput(constant_0);
 
-  HBasicBlock* inner_body_compare = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* inner_body_compare = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(inner_body_compare);
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check1 = new (&allocator_) HBoundsCheck(phi_j, array_length, 0);
-  HArrayGet* array_get_j = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check1 = new (GetAllocator()) HBoundsCheck(phi_j, array_length, 0);
+  HArrayGet* array_get_j = new (GetAllocator())
       HArrayGet(null_check, bounds_check1, DataType::Type::kInt32, 0);
   inner_body_compare->AddInstruction(null_check);
   inner_body_compare->AddInstruction(array_length);
   inner_body_compare->AddInstruction(bounds_check1);
   inner_body_compare->AddInstruction(array_get_j);
-  HInstruction* j_plus_1 = new (&allocator_) HAdd(DataType::Type::kInt32, phi_j, constant_1);
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HBoundsCheck* bounds_check2 = new (&allocator_) HBoundsCheck(j_plus_1, array_length, 0);
-  HArrayGet* array_get_j_plus_1 = new (&allocator_)
+  HInstruction* j_plus_1 = new (GetAllocator()) HAdd(DataType::Type::kInt32, phi_j, constant_1);
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HBoundsCheck* bounds_check2 = new (GetAllocator()) HBoundsCheck(j_plus_1, array_length, 0);
+  HArrayGet* array_get_j_plus_1 = new (GetAllocator())
       HArrayGet(null_check, bounds_check2, DataType::Type::kInt32, 0);
-  cmp = new (&allocator_) HGreaterThanOrEqual(array_get_j, array_get_j_plus_1);
-  if_inst = new (&allocator_) HIf(cmp);
+  cmp = new (GetAllocator()) HGreaterThanOrEqual(array_get_j, array_get_j_plus_1);
+  if_inst = new (GetAllocator()) HIf(cmp);
   inner_body_compare->AddInstruction(j_plus_1);
   inner_body_compare->AddInstruction(null_check);
   inner_body_compare->AddInstruction(array_length);
@@ -871,14 +870,14 @@
   inner_body_compare->AddInstruction(cmp);
   inner_body_compare->AddInstruction(if_inst);
 
-  HBasicBlock* inner_body_swap = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* inner_body_swap = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(inner_body_swap);
-  j_plus_1 = new (&allocator_) HAdd(DataType::Type::kInt32, phi_j, constant_1);
+  j_plus_1 = new (GetAllocator()) HAdd(DataType::Type::kInt32, phi_j, constant_1);
   // temp = array[j+1]
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HInstruction* bounds_check3 = new (&allocator_) HBoundsCheck(j_plus_1, array_length, 0);
-  array_get_j_plus_1 = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HInstruction* bounds_check3 = new (GetAllocator()) HBoundsCheck(j_plus_1, array_length, 0);
+  array_get_j_plus_1 = new (GetAllocator())
       HArrayGet(null_check, bounds_check3, DataType::Type::kInt32, 0);
   inner_body_swap->AddInstruction(j_plus_1);
   inner_body_swap->AddInstruction(null_check);
@@ -886,48 +885,48 @@
   inner_body_swap->AddInstruction(bounds_check3);
   inner_body_swap->AddInstruction(array_get_j_plus_1);
   // array[j+1] = array[j]
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HInstruction* bounds_check4 = new (&allocator_) HBoundsCheck(phi_j, array_length, 0);
-  array_get_j = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HInstruction* bounds_check4 = new (GetAllocator()) HBoundsCheck(phi_j, array_length, 0);
+  array_get_j = new (GetAllocator())
       HArrayGet(null_check, bounds_check4, DataType::Type::kInt32, 0);
   inner_body_swap->AddInstruction(null_check);
   inner_body_swap->AddInstruction(array_length);
   inner_body_swap->AddInstruction(bounds_check4);
   inner_body_swap->AddInstruction(array_get_j);
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HInstruction* bounds_check5 = new (&allocator_) HBoundsCheck(j_plus_1, array_length, 0);
-  HArraySet* array_set_j_plus_1 = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HInstruction* bounds_check5 = new (GetAllocator()) HBoundsCheck(j_plus_1, array_length, 0);
+  HArraySet* array_set_j_plus_1 = new (GetAllocator())
       HArraySet(null_check, bounds_check5, array_get_j, DataType::Type::kInt32, 0);
   inner_body_swap->AddInstruction(null_check);
   inner_body_swap->AddInstruction(array_length);
   inner_body_swap->AddInstruction(bounds_check5);
   inner_body_swap->AddInstruction(array_set_j_plus_1);
   // array[j] = temp
-  null_check = new (&allocator_) HNullCheck(parameter, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HInstruction* bounds_check6 = new (&allocator_) HBoundsCheck(phi_j, array_length, 0);
-  HArraySet* array_set_j = new (&allocator_)
+  null_check = new (GetAllocator()) HNullCheck(parameter, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HInstruction* bounds_check6 = new (GetAllocator()) HBoundsCheck(phi_j, array_length, 0);
+  HArraySet* array_set_j = new (GetAllocator())
       HArraySet(null_check, bounds_check6, array_get_j_plus_1, DataType::Type::kInt32, 0);
   inner_body_swap->AddInstruction(null_check);
   inner_body_swap->AddInstruction(array_length);
   inner_body_swap->AddInstruction(bounds_check6);
   inner_body_swap->AddInstruction(array_set_j);
-  inner_body_swap->AddInstruction(new (&allocator_) HGoto());
+  inner_body_swap->AddInstruction(new (GetAllocator()) HGoto());
 
-  HBasicBlock* inner_body_add = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* inner_body_add = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(inner_body_add);
-  add = new (&allocator_) HAdd(DataType::Type::kInt32, phi_j, constant_1);
+  add = new (GetAllocator()) HAdd(DataType::Type::kInt32, phi_j, constant_1);
   inner_body_add->AddInstruction(add);
-  inner_body_add->AddInstruction(new (&allocator_) HGoto());
+  inner_body_add->AddInstruction(new (GetAllocator()) HGoto());
   phi_j->AddInput(add);
 
-  HBasicBlock* outer_body_add = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* outer_body_add = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(outer_body_add);
-  add = new (&allocator_) HAdd(DataType::Type::kInt32, phi_i, constant_1);
+  add = new (GetAllocator()) HAdd(DataType::Type::kInt32, phi_i, constant_1);
   outer_body_add->AddInstruction(add);
-  outer_body_add->AddInstruction(new (&allocator_) HGoto());
+  outer_body_add->AddInstruction(new (GetAllocator()) HGoto());
   phi_i->AddInput(add);
 
   block->AddSuccessor(outer_header);
@@ -961,10 +960,10 @@
 //   array[param_i%10] = 10;      // Can't eliminate, when param_i < 0
 // }
 TEST_F(BoundsCheckEliminationTest, ModArrayBoundsElimination) {
-  HBasicBlock* entry = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* entry = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(entry);
   graph_->SetEntryBlock(entry);
-  HInstruction* param_i = new (&allocator_)
+  HInstruction* param_i = new (GetAllocator())
       HParameterValue(graph_->GetDexFile(), dex::TypeIndex(0), 0, DataType::Type::kInt32);
   entry->AddInstruction(param_i);
 
@@ -974,17 +973,17 @@
   HInstruction* constant_200 = graph_->GetIntConstant(200);
   HInstruction* constant_minus_10 = graph_->GetIntConstant(-10);
 
-  HBasicBlock* block = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* block = new (GetAllocator()) HBasicBlock(graph_);
   graph_->AddBlock(block);
   entry->AddSuccessor(block);
   // We pass a bogus constant for the class to avoid mocking one.
-  HInstruction* new_array = new (&allocator_) HNewArray(constant_10, constant_10, 0);
+  HInstruction* new_array = new (GetAllocator()) HNewArray(constant_10, constant_10, 0);
   block->AddInstruction(new_array);
-  block->AddInstruction(new (&allocator_) HGoto());
+  block->AddInstruction(new (GetAllocator()) HGoto());
 
-  HBasicBlock* loop_header = new (&allocator_) HBasicBlock(graph_);
-  HBasicBlock* loop_body = new (&allocator_) HBasicBlock(graph_);
-  HBasicBlock* exit = new (&allocator_) HBasicBlock(graph_);
+  HBasicBlock* loop_header = new (GetAllocator()) HBasicBlock(graph_);
+  HBasicBlock* loop_body = new (GetAllocator()) HBasicBlock(graph_);
+  HBasicBlock* exit = new (GetAllocator()) HBasicBlock(graph_);
 
   graph_->AddBlock(loop_header);
   graph_->AddBlock(loop_body);
@@ -994,9 +993,9 @@
   loop_header->AddSuccessor(loop_body);  // false successor
   loop_body->AddSuccessor(loop_header);
 
-  HPhi* phi = new (&allocator_) HPhi(&allocator_, 0, 0, DataType::Type::kInt32);
-  HInstruction* cmp = new (&allocator_) HGreaterThanOrEqual(phi, constant_200);
-  HInstruction* if_inst = new (&allocator_) HIf(cmp);
+  HPhi* phi = new (GetAllocator()) HPhi(GetAllocator(), 0, 0, DataType::Type::kInt32);
+  HInstruction* cmp = new (GetAllocator()) HGreaterThanOrEqual(phi, constant_200);
+  HInstruction* if_inst = new (GetAllocator()) HIf(cmp);
   loop_header->AddPhi(phi);
   loop_header->AddInstruction(cmp);
   loop_header->AddInstruction(if_inst);
@@ -1005,49 +1004,52 @@
   //////////////////////////////////////////////////////////////////////////////////
   // LOOP BODY:
   // array[i % 10] = 10;
-  HRem* i_mod_10 = new (&allocator_) HRem(DataType::Type::kInt32, phi, constant_10, 0);
-  HBoundsCheck* bounds_check_i_mod_10 = new (&allocator_) HBoundsCheck(i_mod_10, constant_10, 0);
-  HInstruction* array_set = new (&allocator_) HArraySet(
+  HRem* i_mod_10 = new (GetAllocator()) HRem(DataType::Type::kInt32, phi, constant_10, 0);
+  HBoundsCheck* bounds_check_i_mod_10 = new (GetAllocator()) HBoundsCheck(i_mod_10, constant_10, 0);
+  HInstruction* array_set = new (GetAllocator()) HArraySet(
       new_array, bounds_check_i_mod_10, constant_10, DataType::Type::kInt32, 0);
   loop_body->AddInstruction(i_mod_10);
   loop_body->AddInstruction(bounds_check_i_mod_10);
   loop_body->AddInstruction(array_set);
 
   // array[i % 1] = 10;
-  HRem* i_mod_1 = new (&allocator_) HRem(DataType::Type::kInt32, phi, constant_1, 0);
-  HBoundsCheck* bounds_check_i_mod_1 = new (&allocator_) HBoundsCheck(i_mod_1, constant_10, 0);
-  array_set = new (&allocator_) HArraySet(
+  HRem* i_mod_1 = new (GetAllocator()) HRem(DataType::Type::kInt32, phi, constant_1, 0);
+  HBoundsCheck* bounds_check_i_mod_1 = new (GetAllocator()) HBoundsCheck(i_mod_1, constant_10, 0);
+  array_set = new (GetAllocator()) HArraySet(
       new_array, bounds_check_i_mod_1, constant_10, DataType::Type::kInt32, 0);
   loop_body->AddInstruction(i_mod_1);
   loop_body->AddInstruction(bounds_check_i_mod_1);
   loop_body->AddInstruction(array_set);
 
   // array[i % 200] = 10;
-  HRem* i_mod_200 = new (&allocator_) HRem(DataType::Type::kInt32, phi, constant_1, 0);
-  HBoundsCheck* bounds_check_i_mod_200 = new (&allocator_) HBoundsCheck(i_mod_200, constant_10, 0);
-  array_set = new (&allocator_) HArraySet(
+  HRem* i_mod_200 = new (GetAllocator()) HRem(DataType::Type::kInt32, phi, constant_1, 0);
+  HBoundsCheck* bounds_check_i_mod_200 = new (GetAllocator()) HBoundsCheck(
+      i_mod_200, constant_10, 0);
+  array_set = new (GetAllocator()) HArraySet(
       new_array, bounds_check_i_mod_200, constant_10, DataType::Type::kInt32, 0);
   loop_body->AddInstruction(i_mod_200);
   loop_body->AddInstruction(bounds_check_i_mod_200);
   loop_body->AddInstruction(array_set);
 
   // array[i % -10] = 10;
-  HRem* i_mod_minus_10 = new (&allocator_) HRem(DataType::Type::kInt32, phi, constant_minus_10, 0);
-  HBoundsCheck* bounds_check_i_mod_minus_10 = new (&allocator_) HBoundsCheck(
+  HRem* i_mod_minus_10 = new (GetAllocator()) HRem(
+      DataType::Type::kInt32, phi, constant_minus_10, 0);
+  HBoundsCheck* bounds_check_i_mod_minus_10 = new (GetAllocator()) HBoundsCheck(
       i_mod_minus_10, constant_10, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
       new_array, bounds_check_i_mod_minus_10, constant_10, DataType::Type::kInt32, 0);
   loop_body->AddInstruction(i_mod_minus_10);
   loop_body->AddInstruction(bounds_check_i_mod_minus_10);
   loop_body->AddInstruction(array_set);
 
   // array[i%array.length] = 10;
-  HNullCheck* null_check = new (&allocator_) HNullCheck(new_array, 0);
-  HArrayLength* array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HRem* i_mod_array_length = new (&allocator_) HRem(DataType::Type::kInt32, phi, array_length, 0);
-  HBoundsCheck* bounds_check_i_mod_array_len = new (&allocator_) HBoundsCheck(
+  HNullCheck* null_check = new (GetAllocator()) HNullCheck(new_array, 0);
+  HArrayLength* array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HRem* i_mod_array_length = new (GetAllocator()) HRem(
+      DataType::Type::kInt32, phi, array_length, 0);
+  HBoundsCheck* bounds_check_i_mod_array_len = new (GetAllocator()) HBoundsCheck(
       i_mod_array_length, array_length, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
       null_check, bounds_check_i_mod_array_len, constant_10, DataType::Type::kInt32, 0);
   loop_body->AddInstruction(null_check);
   loop_body->AddInstruction(array_length);
@@ -1056,23 +1058,23 @@
   loop_body->AddInstruction(array_set);
 
   // array[param_i % 10] = 10;
-  HRem* param_i_mod_10 = new (&allocator_) HRem(DataType::Type::kInt32, param_i, constant_10, 0);
-  HBoundsCheck* bounds_check_param_i_mod_10 = new (&allocator_) HBoundsCheck(
+  HRem* param_i_mod_10 = new (GetAllocator()) HRem(DataType::Type::kInt32, param_i, constant_10, 0);
+  HBoundsCheck* bounds_check_param_i_mod_10 = new (GetAllocator()) HBoundsCheck(
       param_i_mod_10, constant_10, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
       new_array, bounds_check_param_i_mod_10, constant_10, DataType::Type::kInt32, 0);
   loop_body->AddInstruction(param_i_mod_10);
   loop_body->AddInstruction(bounds_check_param_i_mod_10);
   loop_body->AddInstruction(array_set);
 
   // array[param_i%array.length] = 10;
-  null_check = new (&allocator_) HNullCheck(new_array, 0);
-  array_length = new (&allocator_) HArrayLength(null_check, 0);
-  HRem* param_i_mod_array_length = new (&allocator_) HRem(
+  null_check = new (GetAllocator()) HNullCheck(new_array, 0);
+  array_length = new (GetAllocator()) HArrayLength(null_check, 0);
+  HRem* param_i_mod_array_length = new (GetAllocator()) HRem(
       DataType::Type::kInt32, param_i, array_length, 0);
-  HBoundsCheck* bounds_check_param_i_mod_array_len = new (&allocator_) HBoundsCheck(
+  HBoundsCheck* bounds_check_param_i_mod_array_len = new (GetAllocator()) HBoundsCheck(
       param_i_mod_array_length, array_length, 0);
-  array_set = new (&allocator_) HArraySet(
+  array_set = new (GetAllocator()) HArraySet(
       null_check, bounds_check_param_i_mod_array_len, constant_10, DataType::Type::kInt32, 0);
   loop_body->AddInstruction(null_check);
   loop_body->AddInstruction(array_length);
@@ -1081,13 +1083,13 @@
   loop_body->AddInstruction(array_set);
 
   // i++;
-  HInstruction* add = new (&allocator_) HAdd(DataType::Type::kInt32, phi, constant_1);
+  HInstruction* add = new (GetAllocator()) HAdd(DataType::Type::kInt32, phi, constant_1);
   loop_body->AddInstruction(add);
-  loop_body->AddInstruction(new (&allocator_) HGoto());
+  loop_body->AddInstruction(new (GetAllocator()) HGoto());
   phi->AddInput(add);
   //////////////////////////////////////////////////////////////////////////////////
 
-  exit->AddInstruction(new (&allocator_) HExit());
+  exit->AddInstruction(new (GetAllocator()) HExit());
 
   RunBCE();