diff --git a/compiler/optimizing/nodes_vector_test.cc b/compiler/optimizing/nodes_vector_test.cc
index 7dbfcda..d3a499c 100644
--- a/compiler/optimizing/nodes_vector_test.cc
+++ b/compiler/optimizing/nodes_vector_test.cc
@@ -42,11 +42,6 @@
     graph_->AddBlock(exit_block_);
     graph_->SetEntryBlock(entry_block_);
     graph_->SetExitBlock(exit_block_);
-    parameter_ = new (&allocator_) HParameterValue(graph_->GetDexFile(),
-                                                   dex::TypeIndex(0),
-                                                   0,
-                                                   DataType::Type::kInt32);
-    entry_block_->AddInstruction(parameter_);
     int8_parameter_ = new (&allocator_) HParameterValue(graph_->GetDexFile(),
                                                         dex::TypeIndex(1),
                                                         0,
@@ -57,6 +52,11 @@
                                                          0,
                                                          DataType::Type::kInt16);
     entry_block_->AddInstruction(int16_parameter_);
+    int32_parameter_ = new (&allocator_) HParameterValue(graph_->GetDexFile(),
+                                                         dex::TypeIndex(0),
+                                                         0,
+                                                         DataType::Type::kInt32);
+    entry_block_->AddInstruction(int32_parameter_);
   }
 
   // General building fields.
@@ -67,9 +67,9 @@
   HBasicBlock* entry_block_;
   HBasicBlock* exit_block_;
 
-  HInstruction* parameter_;
   HInstruction* int8_parameter_;
   HInstruction* int16_parameter_;
+  HInstruction* int32_parameter_;
 };
 
 //
@@ -104,6 +104,10 @@
   EXPECT_FALSE(Alignment(16, 1).IsAlignedAt(16));
   EXPECT_FALSE(Alignment(16, 7).IsAlignedAt(16));
   EXPECT_FALSE(Alignment(16, 0).IsAlignedAt(32));
+
+  EXPECT_EQ(16u, Alignment(16, 0).Base());
+  EXPECT_EQ(0u, Alignment(16, 0).Offset());
+  EXPECT_EQ(4u, Alignment(16, 4).Offset());
 }
 
 TEST(NodesVector, AlignmentEQ) {
@@ -131,21 +135,22 @@
 
 TEST_F(NodesVectorTest, VectorOperationProperties) {
   HVecOperation* v0 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
   HVecOperation* v1 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
   HVecOperation* v2 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 2);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 2, kNoDexPc);
   HVecOperation* v3 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt16, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt16, 4, kNoDexPc);
   HVecOperation* v4 = new (&allocator_) HVecStore(
       &allocator_,
-      parameter_,
-      parameter_,
+      int32_parameter_,
+      int32_parameter_,
       v0,
       DataType::Type::kInt32,
       SideEffects::ArrayWriteOfType(DataType::Type::kInt32),
-      4);
+      4,
+      kNoDexPc);
 
   EXPECT_TRUE(v0->Equals(v0));
   EXPECT_TRUE(v1->Equals(v1));
@@ -194,26 +199,29 @@
 
 TEST_F(NodesVectorTest, VectorAlignmentAndStringCharAtMatterOnLoad) {
   HVecLoad* v0 = new (&allocator_) HVecLoad(&allocator_,
-                                            parameter_,
-                                            parameter_,
+                                            int32_parameter_,
+                                            int32_parameter_,
                                             DataType::Type::kInt32,
                                             SideEffects::ArrayReadOfType(DataType::Type::kInt32),
                                             4,
-                                            /*is_string_char_at*/ false);
+                                            /*is_string_char_at*/ false,
+                                            kNoDexPc);
   HVecLoad* v1 = new (&allocator_) HVecLoad(&allocator_,
-                                            parameter_,
-                                            parameter_,
+                                            int32_parameter_,
+                                            int32_parameter_,
                                             DataType::Type::kInt32,
                                             SideEffects::ArrayReadOfType(DataType::Type::kInt32),
                                             4,
-                                            /*is_string_char_at*/ false);
+                                            /*is_string_char_at*/ false,
+                                            kNoDexPc);
   HVecLoad* v2 = new (&allocator_) HVecLoad(&allocator_,
-                                            parameter_,
-                                            parameter_,
+                                            int32_parameter_,
+                                            int32_parameter_,
                                             DataType::Type::kInt32,
                                             SideEffects::ArrayReadOfType(DataType::Type::kInt32),
                                             4,
-                                            /*is_string_char_at*/ true);
+                                            /*is_string_char_at*/ true,
+                                            kNoDexPc);
 
   EXPECT_TRUE(v0->CanBeMoved());
   EXPECT_TRUE(v1->CanBeMoved());
@@ -228,7 +236,7 @@
   EXPECT_TRUE(v2->Equals(v2));
 
   EXPECT_TRUE(v0->Equals(v1));
-  EXPECT_FALSE(v0->Equals(v2));
+  EXPECT_FALSE(v0->Equals(v2));  // different is_string_char_at
 
   EXPECT_TRUE(v0->GetAlignment() == Alignment(4, 0));
   EXPECT_TRUE(v1->GetAlignment() == Alignment(4, 0));
@@ -241,24 +249,65 @@
   EXPECT_FALSE(v0->Equals(v1));  // no longer equal
 }
 
+TEST_F(NodesVectorTest, VectorAlignmentMattersOnStore) {
+  HVecOperation* p0 = new (&allocator_)
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
+  HVecStore* v0 = new (&allocator_) HVecStore(
+      &allocator_,
+      int32_parameter_,
+      int32_parameter_,
+      p0,
+      DataType::Type::kInt32,
+      SideEffects::ArrayWriteOfType(DataType::Type::kInt32),
+      4,
+      kNoDexPc);
+  HVecStore* v1 = new (&allocator_) HVecStore(
+      &allocator_,
+      int32_parameter_,
+      int32_parameter_,
+      p0,
+      DataType::Type::kInt32,
+      SideEffects::ArrayWriteOfType(DataType::Type::kInt32),
+      4,
+      kNoDexPc);
+
+  EXPECT_FALSE(v0->CanBeMoved());
+  EXPECT_FALSE(v1->CanBeMoved());
+
+  EXPECT_TRUE(v0->Equals(v1));
+
+  EXPECT_TRUE(v0->GetAlignment() == Alignment(4, 0));
+  EXPECT_TRUE(v1->GetAlignment() == Alignment(4, 0));
+
+  v1->SetAlignment(Alignment(8, 0));
+
+  EXPECT_TRUE(v1->GetAlignment() == Alignment(8, 0));
+
+  EXPECT_FALSE(v0->Equals(v1));  // no longer equal
+}
+
 TEST_F(NodesVectorTest, VectorSignMattersOnMin) {
   HVecOperation* p0 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
   HVecOperation* p1 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, int8_parameter_, DataType::Type::kInt8, 4);
+      HVecReplicateScalar(&allocator_, int8_parameter_, DataType::Type::kInt8, 4, kNoDexPc);
   HVecOperation* p2 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, int16_parameter_, DataType::Type::kInt16, 4);
+      HVecReplicateScalar(&allocator_, int16_parameter_, DataType::Type::kInt16, 4, kNoDexPc);
 
   HVecMin* v0 = new (&allocator_) HVecMin(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ true);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ true, kNoDexPc);
   HVecMin* v1 = new (&allocator_) HVecMin(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ false);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ false, kNoDexPc);
   HVecMin* v2 = new (&allocator_) HVecMin(
-      &allocator_, p0, p0, DataType::Type::kInt32, 2, /*is_unsigned*/ true);
-  HVecMin* v3 = new (&allocator_) HVecMin(&allocator_, p1, p1, DataType::Type::kUint8, 16);
-  HVecMin* v4 = new (&allocator_) HVecMin(&allocator_, p1, p1, DataType::Type::kInt8, 16);
-  HVecMin* v5 = new (&allocator_) HVecMin(&allocator_, p2, p2, DataType::Type::kUint16, 8);
-  HVecMin* v6 = new (&allocator_) HVecMin(&allocator_, p2, p2, DataType::Type::kInt16, 8);
+      &allocator_, p0, p0, DataType::Type::kInt32, 2, /*is_unsigned*/ true, kNoDexPc);
+  HVecMin* v3 = new (&allocator_) HVecMin(
+      &allocator_, p1, p1, DataType::Type::kUint8, 16, /*is_unsigned*/ false, kNoDexPc);
+  HVecMin* v4 = new (&allocator_) HVecMin(
+      &allocator_, p1, p1, DataType::Type::kInt8, 16, /*is_unsigned*/ false, kNoDexPc);
+  HVecMin* v5 = new (&allocator_) HVecMin(
+      &allocator_, p2, p2, DataType::Type::kUint16, 8, /*is_unsigned*/ false, kNoDexPc);
+  HVecMin* v6 = new (&allocator_) HVecMin(
+      &allocator_, p2, p2, DataType::Type::kInt16, 8, /*is_unsigned*/ false, kNoDexPc);
   HVecMin* min_insns[] = { v0, v1, v2, v3, v4, v5, v6 };
 
   EXPECT_FALSE(p0->CanBeMoved());
@@ -283,22 +332,26 @@
 
 TEST_F(NodesVectorTest, VectorSignMattersOnMax) {
   HVecOperation* p0 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
   HVecOperation* p1 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, int8_parameter_, DataType::Type::kInt8, 4);
+      HVecReplicateScalar(&allocator_, int8_parameter_, DataType::Type::kInt8, 4, kNoDexPc);
   HVecOperation* p2 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, int16_parameter_, DataType::Type::kInt16, 4);
+      HVecReplicateScalar(&allocator_, int16_parameter_, DataType::Type::kInt16, 4, kNoDexPc);
 
   HVecMax* v0 = new (&allocator_) HVecMax(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ true);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ true, kNoDexPc);
   HVecMax* v1 = new (&allocator_) HVecMax(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ false);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_unsigned*/ false, kNoDexPc);
   HVecMax* v2 = new (&allocator_) HVecMax(
-      &allocator_, p0, p0, DataType::Type::kInt32, 2, /*is_unsigned*/ true);
-  HVecMax* v3 = new (&allocator_) HVecMax(&allocator_, p1, p1, DataType::Type::kUint8, 16);
-  HVecMax* v4 = new (&allocator_) HVecMax(&allocator_, p1, p1, DataType::Type::kInt8, 16);
-  HVecMax* v5 = new (&allocator_) HVecMax(&allocator_, p2, p2, DataType::Type::kUint16, 8);
-  HVecMax* v6 = new (&allocator_) HVecMax(&allocator_, p2, p2, DataType::Type::kInt16, 8);
+      &allocator_, p0, p0, DataType::Type::kInt32, 2, /*is_unsigned*/ true, kNoDexPc);
+  HVecMax* v3 = new (&allocator_) HVecMax(
+      &allocator_, p1, p1, DataType::Type::kUint8, 16, /*is_unsigned*/ false, kNoDexPc);
+  HVecMax* v4 = new (&allocator_) HVecMax(
+      &allocator_, p1, p1, DataType::Type::kInt8, 16, /*is_unsigned*/ false, kNoDexPc);
+  HVecMax* v5 = new (&allocator_) HVecMax(
+      &allocator_, p2, p2, DataType::Type::kUint16, 8, /*is_unsigned*/ false, kNoDexPc);
+  HVecMax* v6 = new (&allocator_) HVecMax(
+      &allocator_, p2, p2, DataType::Type::kInt16, 8, /*is_unsigned*/ false, kNoDexPc);
   HVecMax* max_insns[] = { v0, v1, v2, v3, v4, v5, v6 };
 
   EXPECT_FALSE(p0->CanBeMoved());
@@ -323,38 +376,51 @@
 
 TEST_F(NodesVectorTest, VectorAttributesMatterOnHalvingAdd) {
   HVecOperation* p0 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
   HVecOperation* p1 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, int8_parameter_, DataType::Type::kInt8, 4);
+      HVecReplicateScalar(&allocator_, int8_parameter_, DataType::Type::kInt8, 4, kNoDexPc);
   HVecOperation* p2 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, int16_parameter_, DataType::Type::kInt16, 4);
+      HVecReplicateScalar(&allocator_, int16_parameter_, DataType::Type::kInt16, 4, kNoDexPc);
 
   HVecHalvingAdd* v0 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_rounded*/ true, /*is_unsigned*/ true);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4,
+      /*is_rounded*/ true, /*is_unsigned*/ true, kNoDexPc);
   HVecHalvingAdd* v1 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_rounded*/ false, /*is_unsigned*/ true);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4,
+      /*is_rounded*/ false, /*is_unsigned*/ true, kNoDexPc);
   HVecHalvingAdd* v2 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_rounded*/ true, /*is_unsigned*/ false);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4,
+      /*is_rounded*/ true, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v3 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p0, p0, DataType::Type::kInt32, 4, /*is_rounded*/ false, /*is_unsigned*/ false);
+      &allocator_, p0, p0, DataType::Type::kInt32, 4,
+      /*is_rounded*/ false, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v4 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p0, p0, DataType::Type::kInt32, 2, /*is_rounded*/ true, /*is_unsigned*/ true);
+      &allocator_, p0, p0, DataType::Type::kInt32, 2,
+      /*is_rounded*/ true, /*is_unsigned*/ true, kNoDexPc);
   HVecHalvingAdd* v5 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p1, p1, DataType::Type::kUint8, 16, /*is_rounded*/ true);
+      &allocator_, p1, p1, DataType::Type::kUint8, 16,
+      /*is_rounded*/ true, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v6 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p1, p1, DataType::Type::kUint8, 16, /*is_rounded*/ false);
+      &allocator_, p1, p1, DataType::Type::kUint8, 16,
+      /*is_rounded*/ false, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v7 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p1, p1, DataType::Type::kInt8, 16, /*is_rounded*/ true);
+      &allocator_, p1, p1, DataType::Type::kInt8, 16,
+      /*is_rounded*/ true, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v8 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p1, p1, DataType::Type::kInt8, 16, /*is_rounded*/ false);
+      &allocator_, p1, p1, DataType::Type::kInt8, 16,
+      /*is_rounded*/ false, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v9 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p2, p2, DataType::Type::kUint16, 8, /*is_rounded*/ true);
+      &allocator_, p2, p2, DataType::Type::kUint16, 8,
+      /*is_rounded*/ true, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v10 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p2, p2, DataType::Type::kUint16, 8, /*is_rounded*/ false);
+      &allocator_, p2, p2, DataType::Type::kUint16, 8,
+      /*is_rounded*/ false, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v11 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p2, p2, DataType::Type::kInt16, 2, /*is_rounded*/ true);
+      &allocator_, p2, p2, DataType::Type::kInt16, 2,
+      /*is_rounded*/ true, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* v12 = new (&allocator_) HVecHalvingAdd(
-      &allocator_, p2, p2, DataType::Type::kInt16, 2, /*is_rounded*/ false);
+      &allocator_, p2, p2, DataType::Type::kInt16, 2,
+      /*is_rounded*/ false, /*is_unsigned*/ false, kNoDexPc);
   HVecHalvingAdd* hadd_insns[] = { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12 };
 
   EXPECT_FALSE(p0->CanBeMoved());
@@ -395,14 +461,14 @@
 
 TEST_F(NodesVectorTest, VectorOperationMattersOnMultiplyAccumulate) {
   HVecOperation* v0 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
 
   HVecMultiplyAccumulate* v1 = new (&allocator_) HVecMultiplyAccumulate(
-      &allocator_, HInstruction::kAdd, v0, v0, v0, DataType::Type::kInt32, 4);
+      &allocator_, HInstruction::kAdd, v0, v0, v0, DataType::Type::kInt32, 4, kNoDexPc);
   HVecMultiplyAccumulate* v2 = new (&allocator_) HVecMultiplyAccumulate(
-      &allocator_, HInstruction::kSub, v0, v0, v0, DataType::Type::kInt32, 4);
+      &allocator_, HInstruction::kSub, v0, v0, v0, DataType::Type::kInt32, 4, kNoDexPc);
   HVecMultiplyAccumulate* v3 = new (&allocator_) HVecMultiplyAccumulate(
-      &allocator_, HInstruction::kAdd, v0, v0, v0, DataType::Type::kInt32, 2);
+      &allocator_, HInstruction::kAdd, v0, v0, v0, DataType::Type::kInt32, 2, kNoDexPc);
 
   EXPECT_FALSE(v0->CanBeMoved());
   EXPECT_TRUE(v1->CanBeMoved());
@@ -423,14 +489,14 @@
 
 TEST_F(NodesVectorTest, VectorKindMattersOnReduce) {
   HVecOperation* v0 = new (&allocator_)
-      HVecReplicateScalar(&allocator_, parameter_, DataType::Type::kInt32, 4);
+      HVecReplicateScalar(&allocator_, int32_parameter_, DataType::Type::kInt32, 4, kNoDexPc);
 
   HVecReduce* v1 = new (&allocator_) HVecReduce(
-      &allocator_, v0, DataType::Type::kInt32, 4, HVecReduce::kSum);
+      &allocator_, v0, DataType::Type::kInt32, 4, HVecReduce::kSum, kNoDexPc);
   HVecReduce* v2 = new (&allocator_) HVecReduce(
-      &allocator_, v0, DataType::Type::kInt32, 4, HVecReduce::kMin);
+      &allocator_, v0, DataType::Type::kInt32, 4, HVecReduce::kMin, kNoDexPc);
   HVecReduce* v3 = new (&allocator_) HVecReduce(
-      &allocator_, v0, DataType::Type::kInt32, 4, HVecReduce::kMax);
+      &allocator_, v0, DataType::Type::kInt32, 4, HVecReduce::kMax, kNoDexPc);
 
   EXPECT_FALSE(v0->CanBeMoved());
   EXPECT_TRUE(v1->CanBeMoved());