[SubZero] Implement Fcmp, ICmp, Cast and Select for vector type

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 961 matching lines @@
 
 public:
   static VariableVecOn32 *create(Cfg *Func, Type Ty, SizeT Index) {
     return new (Func->allocate<VariableVecOn32>())
         VariableVecOn32(Func, kVariableVecOn32, Ty, Index);
   }
 
   void setName(const Cfg *Func, const std::string &NewName) override {
     Variable::setName(Func, NewName);
     if (!Containers.empty()) {
-      for (SizeT i = 0; i < ElementsPerContainer; ++i) {
+      for (SizeT i = 0; i < ContainersPerVector; ++i) {
         Containers[i]->setName(Func, getName() + "__cont" + std::to_string(i));
       }
     }
   }
 
   void setIsArg(bool Val = true) override {
     Variable::setIsArg(Val);
     for (Variable *Var : Containers) {
       Var->setIsArg(getIsArg());
     }
   }
 
   const VarList &getContainers() const { return Containers; }
 
   void initVecElement(Cfg *Func) {
-    for (SizeT i = 0; i < ElementsPerContainer; ++i) {
+    for (SizeT i = 0; i < ContainersPerVector; ++i) {
       Variable *Var = Func->makeVariable(IceType_i32);
       Var->setIsArg(getIsArg());
       if (BuildDefs::dump()) {
         Var->setName(Func, getName() + "__cont" + std::to_string(i));
       }
       Containers.push_back(Var);
     }
   }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kVariableVecOn32;
   }
 
   // A 128-bit vector value is mapped onto 4 32-bit register values.
-  static constexpr SizeT ElementsPerContainer = 4;
+  static constexpr SizeT ContainersPerVector = 4;
 
 protected:
   VariableVecOn32(const Cfg *Func, OperandKind K, Type Ty, SizeT Index)
       : Variable(Func, K, Ty, Index) {
     assert(typeWidthInBytes(Ty) ==
-           ElementsPerContainer * typeWidthInBytes(IceType_i32));
+           ContainersPerVector * typeWidthInBytes(IceType_i32));
   }
 
   VarList Containers;
 };
 
 enum MetadataKind {
   VMK_Uses,       /// Track only uses, not defs
   VMK_SingleDefs, /// Track uses+defs, but only record single def
   VMK_All         /// Track uses+defs, including full def list
 };
@@ skipping 133 matching lines @@
     return Operand->getKind() == kVariableBoolean;
   }
 
 private:
   Variable *BoolSource = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H