Rename vector_mode_ to synthesis_mode_.

Refactors the variable - to avoid confusion between synthesis
(sequential and vector) and vectorization (traditional and
predicated) modes.

Original author: Artem Serov <Artem.Serov@linaro.org>

Test: ./art/test/testrunner/testrunner.py --host --optimizing --jit
Test: ./art/test/testrunner/testrunner.py --target --optimizing --jit
Test: 661-checker-simd-cf-loops.

Test: target tests on arm64 with SVE (for details see
      art/test/README.arm_fvp).
Change-Id: I5816140971b588a51cc06714f18dda0f17eeb16a

1 files changed, 39 insertions, 39 deletions

diff --git a/compiler/optimizing/loop_optimization.cc b/compiler/optimizing/loop_optimization.cc
index 9372e116bb..8d698d6c82 100644
--- a/compiler/optimizing/loop_optimization.cc
+++ b/compiler/optimizing/loop_optimization.cc
@@ -532,7 +532,7 @@ HLoopOptimization::HLoopOptimization(HGraph* graph,
       vector_permanent_map_(nullptr),
       vector_external_set_(nullptr),
       predicate_info_map_(nullptr),
-      vector_mode_(VectorMode::kSequential),
+      synthesis_mode_(LoopSynthesisMode::kSequential),
       vector_preheader_(nullptr),
       vector_header_(nullptr),
       vector_body_(nullptr),
@@ -970,10 +970,10 @@ bool HLoopOptimization::TryVectorizePredicated(LoopNode* node,
 }
 
 bool HLoopOptimization::TryVectorizedTraditional(LoopNode* node,
-                                                HBasicBlock* body,
-                                                HBasicBlock* exit,
-                                                HPhi* main_phi,
-                                                int64_t trip_count) {
+                                                 HBasicBlock* body,
+                                                 HBasicBlock* exit,
+                                                 HPhi* main_phi,
+                                                 int64_t trip_count) {
   HBasicBlock* header = node->loop_info->GetHeader();
   size_t num_of_blocks = header->GetLoopInformation()->GetBlocks().NumSetBits();
 
@@ -1324,7 +1324,7 @@ void HLoopOptimization::VectorizePredicated(LoopNode* node,
   //    <vectorized-loop-body>
   HBasicBlock* preheader_for_vector_loop =
       graph_->TransformLoopForVectorization(vector_header_, vector_body_, exit);
-  vector_mode_ = VectorMode::kVector;
+  synthesis_mode_ = LoopSynthesisMode::kVector;
   GenerateNewLoopPredicated(node,
                             preheader_for_vector_loop,
                             vector_index_,
@@ -1335,7 +1335,7 @@ void HLoopOptimization::VectorizePredicated(LoopNode* node,
   // for ( ; i < stc; i += 1)
   //    <loop-body>
   if (needs_disambiguation_test) {
-    vector_mode_ = VectorMode::kSequential;
+    synthesis_mode_ = LoopSynthesisMode::kSequential;
     HBasicBlock* preheader_for_cleanup_loop =
         graph_->TransformLoopForVectorization(vector_header_, vector_body_, exit);
     // Use "Traditional" version for the sequential loop.
@@ -1476,7 +1476,7 @@ void HLoopOptimization::VectorizeTraditional(LoopNode* node,
   //       moved around during suspend checks, since all analysis was based on
   //       nothing more than the Android runtime alignment conventions.
   if (ptc != nullptr) {
-    vector_mode_ = VectorMode::kSequential;
+    synthesis_mode_ = LoopSynthesisMode::kSequential;
     HBasicBlock* preheader_for_peeling_loop =
         graph_->TransformLoopForVectorization(vector_header_, vector_body_, exit);
     GenerateNewLoopScalarOrTraditional(node,
@@ -1490,7 +1490,7 @@ void HLoopOptimization::VectorizeTraditional(LoopNode* node,
   // Generate vector loop, possibly further unrolled:
   // for ( ; i < vtc; i += chunk)
   //    <vectorized-loop-body>
-  vector_mode_ = VectorMode::kVector;
+  synthesis_mode_ = LoopSynthesisMode::kVector;
   HBasicBlock* preheader_for_vector_loop =
       graph_->TransformLoopForVectorization(vector_header_, vector_body_, exit);
   GenerateNewLoopScalarOrTraditional(node,
@@ -1504,7 +1504,7 @@ void HLoopOptimization::VectorizeTraditional(LoopNode* node,
   // for ( ; i < stc; i += 1)
   //    <loop-body>
   if (needs_cleanup) {
-    vector_mode_ = VectorMode::kSequential;
+    synthesis_mode_ = LoopSynthesisMode::kSequential;
     HBasicBlock* preheader_for_cleanup_loop =
         graph_->TransformLoopForVectorization(vector_header_, vector_body_, exit);
     GenerateNewLoopScalarOrTraditional(node,
@@ -1581,7 +1581,7 @@ void HLoopOptimization::GenerateNewLoopScalarOrTraditional(LoopNode* node,
                                                            HInstruction* hi,
                                                            HInstruction* step,
                                                            uint32_t unroll) {
-  DCHECK(unroll == 1 || vector_mode_ == VectorMode::kVector);
+  DCHECK(unroll == 1 || synthesis_mode_ == LoopSynthesisMode::kVector);
   DataType::Type induc_type = lo->GetType();
   HPhi* phi = InitializeForNewLoop(new_preheader, lo);
 
@@ -1603,7 +1603,7 @@ void HLoopOptimization::GenerateNewLoopPredicated(LoopNode* node,
                                                   HInstruction* hi,
                                                   HInstruction* step) {
   DCHECK(IsInPredicatedVectorizationMode());
-  DCHECK_EQ(vector_mode_, VectorMode::kVector);
+  DCHECK(synthesis_mode_ == LoopSynthesisMode::kVector);
   DataType::Type induc_type = lo->GetType();
   HPhi* phi = InitializeForNewLoop(new_preheader, lo);
 
@@ -1890,7 +1890,7 @@ bool HLoopOptimization::VectorizeUse(LoopNode* node,
            size_from >= size_vec &&
            VectorizeUse(node, opa, generate_code, type, restrictions))) {
         if (generate_code) {
-          if (vector_mode_ == VectorMode::kVector) {
+          if (synthesis_mode_ == LoopSynthesisMode::kVector) {
             vector_map_->Put(instruction, vector_map_->Get(opa));  // operand pass-through
           } else {
             GenerateVecOp(instruction, vector_map_->Get(opa), nullptr, type);
@@ -1966,7 +1966,7 @@ bool HLoopOptimization::VectorizeUse(LoopNode* node,
     // Accept shift operator for vectorizable/invariant operands.
     // TODO: accept symbolic, albeit loop invariant shift factors.
     DCHECK(r != nullptr);
-    if (generate_code && vector_mode_ != VectorMode::kVector) {  // de-idiom
+    if (generate_code && synthesis_mode_ != LoopSynthesisMode::kVector) {  // de-idiom
       r = opa;
     }
     int64_t distance = 0;
@@ -1994,7 +1994,7 @@ bool HLoopOptimization::VectorizeUse(LoopNode* node,
     }
     // Accept ABS(x) for vectorizable operand.
     DCHECK(r != nullptr);
-    if (generate_code && vector_mode_ != VectorMode::kVector) {  // de-idiom
+    if (generate_code && synthesis_mode_ != LoopSynthesisMode::kVector) {  // de-idiom
       r = opa;
     }
     if (VectorizeUse(node, r, generate_code, type, restrictions)) {
@@ -2190,7 +2190,7 @@ void HLoopOptimization::GenerateVecInv(HInstruction* org, DataType::Type type) {
   if (vector_map_->find(org) == vector_map_->end()) {
     // In scalar code, just use a self pass-through for scalar invariants
     // (viz. expression remains itself).
-    if (vector_mode_ == VectorMode::kSequential) {
+    if (synthesis_mode_ == LoopSynthesisMode::kSequential) {
       vector_map_->Put(org, org);
       return;
     }
@@ -2238,7 +2238,7 @@ void HLoopOptimization::GenerateVecMem(HInstruction* org,
                                        DataType::Type type) {
   uint32_t dex_pc = org->GetDexPc();
   HInstruction* vector = nullptr;
-  if (vector_mode_ == VectorMode::kVector) {
+  if (synthesis_mode_ == LoopSynthesisMode::kVector) {
     // Vector store or load.
     bool is_string_char_at = false;
     HInstruction* base = org->InputAt(0);
@@ -2270,7 +2270,7 @@ void HLoopOptimization::GenerateVecMem(HInstruction* org,
     }
   } else {
     // Scalar store or load.
-    DCHECK(vector_mode_ == VectorMode::kSequential);
+    DCHECK(synthesis_mode_ == LoopSynthesisMode::kSequential);
     if (opb != nullptr) {
       DataType::Type component_type = org->AsArraySet()->GetComponentType();
       vector = new (global_allocator_) HArraySet(
@@ -2288,7 +2288,7 @@ void HLoopOptimization::GenerateVecReductionPhi(HPhi* orig_phi) {
   DCHECK(reductions_->find(orig_phi) != reductions_->end());
   DCHECK(reductions_->Get(orig_phi->InputAt(1)) == orig_phi);
   HInstruction* vector = nullptr;
-  if (vector_mode_ == VectorMode::kSequential) {
+  if (synthesis_mode_ == LoopSynthesisMode::kSequential) {
     HPhi* new_phi = new (global_allocator_) HPhi(
         global_allocator_, kNoRegNumber, 0, orig_phi->GetType());
     vector_header_->AddPhi(new_phi);
@@ -2317,7 +2317,7 @@ void HLoopOptimization::GenerateVecReductionPhiInputs(HPhi* phi, HInstruction* r
     DCHECK(new_phi->IsVecOperation());
   }
   // Prepare the new initialization.
-  if (vector_mode_ == VectorMode::kVector) {
+  if (synthesis_mode_ == LoopSynthesisMode::kVector) {
     // Generate a [initial, 0, .., 0] vector for add or
     // a [initial, initial, .., initial] vector for min/max.
     HVecOperation* red_vector = new_red->AsVecOperation();
@@ -2380,13 +2380,13 @@ HInstruction* HLoopOptimization::ReduceAndExtractIfNeeded(HInstruction* instruct
   return instruction;
 }
 
-#define GENERATE_VEC(x, y)                           \
-  if (vector_mode_ == VectorMode::kVector) {         \
-    vector = (x);                                    \
-  } else {                                           \
-    DCHECK(vector_mode_ == VectorMode::kSequential); \
-    vector = (y);                                    \
-  }                                                  \
+#define GENERATE_VEC(x, y)                                     \
+  if (synthesis_mode_ == LoopSynthesisMode::kVector) {         \
+    vector = (x);                                              \
+  } else {                                                     \
+    DCHECK(synthesis_mode_ == LoopSynthesisMode::kSequential); \
+    vector = (y);                                              \
+  }                                                            \
   break;
 
 HInstruction* HLoopOptimization::GenerateVecOp(HInstruction* org,
@@ -2464,7 +2464,7 @@ HInstruction* HLoopOptimization::GenerateVecOp(HInstruction* org,
         new (global_allocator_) HAbs(org_type, opa, dex_pc));
     case HInstruction::kEqual: {
         // Special case.
-        DCHECK_EQ(vector_mode_, VectorMode::kVector);
+        DCHECK_EQ(synthesis_mode_, LoopSynthesisMode::kVector);
         vector = new (global_allocator_)
             HVecCondition(global_allocator_, opa, opb, type, vector_length_, dex_pc);
       }
@@ -2530,14 +2530,14 @@ bool HLoopOptimization::VectorizeHalvingAddIdiom(LoopNode* node,
       // Accept recognized halving add for vectorizable operands. Vectorized code uses the
       // shorthand idiomatic operation. Sequential code uses the original scalar expressions.
       DCHECK(r != nullptr && s != nullptr);
-      if (generate_code && vector_mode_ != VectorMode::kVector) {  // de-idiom
+      if (generate_code && synthesis_mode_ != LoopSynthesisMode::kVector) {  // de-idiom
         r = instruction->InputAt(0);
         s = instruction->InputAt(1);
       }
       if (VectorizeUse(node, r, generate_code, type, restrictions) &&
           VectorizeUse(node, s, generate_code, type, restrictions)) {
         if (generate_code) {
-          if (vector_mode_ == VectorMode::kVector) {
+          if (synthesis_mode_ == LoopSynthesisMode::kVector) {
             vector_map_->Put(instruction, new (global_allocator_) HVecHalvingAdd(
                 global_allocator_,
                 vector_map_->Get(r),
@@ -2606,14 +2606,14 @@ bool HLoopOptimization::VectorizeSADIdiom(LoopNode* node,
   // Accept SAD idiom for vectorizable operands. Vectorized code uses the shorthand
   // idiomatic operation. Sequential code uses the original scalar expressions.
   DCHECK(r != nullptr && s != nullptr);
-  if (generate_code && vector_mode_ != VectorMode::kVector) {  // de-idiom
+  if (generate_code && synthesis_mode_ != LoopSynthesisMode::kVector) {  // de-idiom
     r = s = abs->InputAt(0);
   }
   if (VectorizeUse(node, acc, generate_code, sub_type, restrictions) &&
       VectorizeUse(node, r, generate_code, sub_type, restrictions) &&
       VectorizeUse(node, s, generate_code, sub_type, restrictions)) {
     if (generate_code) {
-      if (vector_mode_ == VectorMode::kVector) {
+      if (synthesis_mode_ == LoopSynthesisMode::kVector) {
         vector_map_->Put(instruction, new (global_allocator_) HVecSADAccumulate(
             global_allocator_,
             vector_map_->Get(acc),
@@ -2679,7 +2679,7 @@ bool HLoopOptimization::VectorizeDotProdIdiom(LoopNode* node,
   DCHECK(r != nullptr && s != nullptr);
   // Accept dot product idiom for vectorizable operands. Vectorized code uses the shorthand
   // idiomatic operation. Sequential code uses the original scalar expressions.
-  if (generate_code && vector_mode_ != VectorMode::kVector) {  // de-idiom
+  if (generate_code && synthesis_mode_ != LoopSynthesisMode::kVector) {  // de-idiom
     r = mul_left;
     s = mul_right;
   }
@@ -2687,7 +2687,7 @@ bool HLoopOptimization::VectorizeDotProdIdiom(LoopNode* node,
       VectorizeUse(node, r, generate_code, op_type, restrictions) &&
       VectorizeUse(node, s, generate_code, op_type, restrictions)) {
     if (generate_code) {
-      if (vector_mode_ == VectorMode::kVector) {
+      if (synthesis_mode_ == LoopSynthesisMode::kVector) {
         vector_map_->Put(instruction, new (global_allocator_) HVecDotProd(
             global_allocator_,
             vector_map_->Get(acc),
@@ -2765,7 +2765,7 @@ bool HLoopOptimization::VectorizeIfCondition(LoopNode* node,
     return false;
   }
 
-  if (generate_code && vector_mode_ != VectorMode::kVector) {  // de-idiom
+  if (generate_code && synthesis_mode_ != LoopSynthesisMode::kVector) {  // de-idiom
     opa_promoted = opa;
     opb_promoted = opb;
   }
@@ -2777,7 +2777,7 @@ bool HLoopOptimization::VectorizeIfCondition(LoopNode* node,
                                              vector_map_->Get(opa_promoted),
                                              vector_map_->Get(opb_promoted),
                                              type);
-      DCHECK_EQ(vector_mode_, VectorMode::kVector);
+      DCHECK_EQ(synthesis_mode_, LoopSynthesisMode::kVector);
       HInstruction* vec_pred_not = new (global_allocator_)
           HVecPredNot(global_allocator_, vec_cond, type, vector_length_, hif->GetDexPc());
 
@@ -3176,11 +3176,11 @@ void HLoopOptimization::MaybeInsertInVectorExternalSet(HInstruction* instruction
   }
 }
 
-std::ostream& operator<<(std::ostream& os, const HLoopOptimization::VectorMode& mode) {
+std::ostream& operator<<(std::ostream& os, const HLoopOptimization::LoopSynthesisMode& mode) {
   switch (mode) {
-    case HLoopOptimization::VectorMode::kSequential:
+    case HLoopOptimization::LoopSynthesisMode::kSequential:
       return os << "kSequential";
-    case HLoopOptimization::VectorMode::kVector:
+    case HLoopOptimization::LoopSynthesisMode::kVector:
       return os << "kVector";
   }
   return os;