Add UBSAN build option and fix undefined behaviour errors.

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
-/// This file declares the Operand class and its target-independent
-/// subclasses.  The main classes are Variable, which represents an
-/// LLVM variable that is either register- or stack-allocated, and the
-/// Constant hierarchy, which represents integer, floating-point,
-/// and/or symbolic constants.
+/// This file declares the Operand class and its target-independent subclasses.
+/// The main classes are Variable, which represents an LLVM variable that is
+/// either register- or stack-allocated, and the Constant hierarchy, which
+/// represents integer, floating-point, and/or symbolic constants.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
 #include "IceCfg.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
+#include "IceTargetKinds.def"
 #include "IceTypes.h"
 
 namespace Ice {
 
 class Operand {
   Operand() = delete;
   Operand(const Operand &) = delete;
   Operand &operator=(const Operand &) = delete;
 
 public:
-  static const size_t MaxTargetKinds = 10;
   enum OperandKind {
     kConst_Base,
     kConstInteger32,
     kConstInteger64,
     kConstFloat,
     kConstDouble,
     kConstRelocatable,
     kConstUndef,
-    kConst_Target, // leave space for target-specific constant kinds
-    kConst_Num = kConst_Target + MaxTargetKinds,
+#define X(n) kConst_Target##n,
+    TARGETKINDS_TABLE
+#undef X
+    kConst_Max = kConst_Target0 + TARGETKINDS_TABLE_MAX,
     kVariable,
-    kVariable_Target, // leave space for target-specific variable kinds
-    kVariable_Num = kVariable_Target + MaxTargetKinds,
+#define X(n) kVariable_Target##n,
+    TARGETKINDS_TABLE
+#undef X
+    kVariable_Max = kVariable_Target0 + TARGETKINDS_TABLE_MAX,
     // Target-specific operand classes use kTarget as the starting
     // point for their Kind enum space. Note that the value-spaces are shared
     // across targets. To avoid confusion over the definition of shared
     // values, an object specific to one target should never be passed
     // to a different target.
-    kTarget
+#define X(n) kTarget##n,
+    TARGETKINDS_TABLE
+#undef X
   };
   OperandKind getKind() const { return Kind; }
   Type getType() const { return Ty; }
 
-  /// Every Operand keeps an array of the Variables referenced in
-  /// the operand.  This is so that the liveness operations can get
-  /// quick access to the variables of interest, without having to dig
-  /// so far into the operand.
+  /// Every Operand keeps an array of the Variables referenced in the operand.
+  /// This is so that the liveness operations can get quick access to the
+  /// variables of interest, without having to dig so far into the operand.
   SizeT getNumVars() const { return NumVars; }
   Variable *getVar(SizeT I) const {
     assert(I < getNumVars());
     return Vars[I];
   }
   virtual void emit(const Cfg *Func) const = 0;
 
   /// \name Dumping functions.
   /// @{
 
@@ skipping 38 matching lines @@
 
 public:
   void emitPoolLabel(Ostream &Str) const {
     Str << ".L$" << getType() << "$" << PoolEntryID;
   }
   void emit(const Cfg *Func) const override { emit(Func->getTarget()); }
   virtual void emit(TargetLowering *Target) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
-    return Kind >= kConst_Base && Kind <= kConst_Num;
+    return Kind >= kConst_Base && Kind <= kConst_Max;
   }
 
   /// Judge if this given immediate should be randomized or pooled
   /// By default should return false, only constant integers should
   /// truly go through this method.
   virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
     (void)Ctx;
     return false;
   }
 
@@ skipping 369 matching lines @@
 
   void emit(const Cfg *Func) const override;
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   /// Return reg num of base register, if different from stack/frame register.
   virtual int32_t getBaseRegNum() const { return NoRegister; }
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
-    return Kind >= kVariable && Kind <= kVariable_Num;
+    return Kind >= kVariable && Kind <= kVariable_Max;
   }
 
 protected:
   Variable(OperandKind K, Type Ty, SizeT Index)
       : Operand(K, Ty), Number(Index) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
   }
   /// Number is unique across all variables, and is used as a
@@ skipping 134 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H