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 "IceTypes.h"
 
 namespace Ice {
 
 class Operand {
   Operand() = delete;
   Operand(const Operand &) = delete;
   Operand &operator=(const Operand &) = delete;
 
 public:
-  static const size_t MaxTargetKinds = 10;
+  static constexpr 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,
+    kConst_Max = kConst_Target + MaxTargetKinds,
     kVariable,
     kVariable_Target, // leave space for target-specific variable kinds
-    kVariable_Num = kVariable_Target + MaxTargetKinds,
+    kVariable_Max = kVariable_Target + MaxTargetKinds,
     // 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
+    kTarget,
+    kTarget_Max = kTarget + MaxTargetKinds,

[Jim Stichnoth, 2015/09/08 22:10:32]

What do you think of setting kTarget_Max = uint8_t::max(), plus a static_assert
that kTarget<=kTarget_Max?

   };
   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.
   /// @{
 
   /// The dump(Func,Str) implementation must be sure to handle the
   /// situation where Func==nullptr.
   virtual void dump(const Cfg *Func, Ostream &Str) const = 0;
   void dump(const Cfg *Func) const {
     if (!BuildDefs::dump())
       return;
     assert(Func);
     dump(Func, Func->getContext()->getStrDump());
   }
   void dump(Ostream &Str) const {
     if (BuildDefs::dump())
       dump(nullptr, Str);
   }
   /// @}
 
 protected:
-  Operand(OperandKind Kind, Type Ty) : Ty(Ty), Kind(Kind) {}
+  Operand(OperandKind Kind, Type Ty) : Ty(Ty), Kind(Kind) {
+    // It is undefined behavior to have a larger value in the enum
+    assert(Kind <= kTarget_Max);
+  }
   virtual ~Operand() = default;
 
   const Type Ty;
   const OperandKind Kind;
   /// Vars and NumVars are initialized by the derived class.
   SizeT NumVars = 0;
   Variable **Vars = nullptr;
 };
 
 template <class StreamType>
@@ skipping 11 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