Fixes the X86 Base template.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
 // consists almost entirely of the lowering sequence for each
 // high-level instruction.
 //
@@ skipping 67 matching lines @@
   // representation of the vector.
   static Type getInVectorElementType(Type Ty) {
     assert(isVectorType(Ty));
     size_t Index = static_cast<size_t>(Ty);
     (void)Index;
     assert(Index < TableTypeX8632AttributesSize);
     return TableTypeX8632Attributes[Ty].InVectorElementType;
   }
 
   // The maximum number of arguments to pass in XMM registers
-  static constexpr uint32_t X86_MAX_XMM_ARGS = 4;
+  static const uint32_t X86_MAX_XMM_ARGS = 4;

[Jim Stichnoth, 2015/06/24 21:58:46]

I'm curious why all these constexprs got downgraded to const?

[John, 2015/06/24 22:56:24]

It is dangerous to have them as constexpr as they are used (indirectly) in the
TargetLoweringX86Base template. Some compiler bug could (albeit unlikely) see
those uses and assume they are regular identifiers. If that happens, we would
see cryptic link-time errors (cryptic in the sense that the identifier is
defined but the linker would still complain about not being able to see it.)
I'll let the compiler/linker figure out whether this should be optimized -- or I
could change the code so that this Trait is defined before the
IceTargetLoweringX86Base.h file is included. For the time being, I'd rather just
be conservative and keep things const. Do you mind?

   // The number of bits in a byte
-  static constexpr uint32_t X86_CHAR_BIT = 8;
+  static const uint32_t X86_CHAR_BIT = 8;
   // Stack alignment
   static const uint32_t X86_STACK_ALIGNMENT_BYTES;
   // Size of the return address on the stack
-  static constexpr uint32_t X86_RET_IP_SIZE_BYTES = 4;
+  static const uint32_t X86_RET_IP_SIZE_BYTES = 4;
   // The number of different NOP instructions
-  static constexpr uint32_t X86_NUM_NOP_VARIANTS = 5;
+  static const uint32_t X86_NUM_NOP_VARIANTS = 5;
 
   // Value is in bytes. Return Value adjusted to the next highest multiple
   // of the stack alignment.
   static uint32_t applyStackAlignment(uint32_t Value) {
     return Utils::applyAlignment(Value, X86_STACK_ALIGNMENT_BYTES);
   }
 };
 
 const MachineTraits<TargetX8632>::TableFcmpType
     MachineTraits<TargetX8632>::TableFcmp[] = {
 #define X(val, dflt, swapS, C1, C2, swapV, pred)                               \
   { dflt, swapS, CondX86::C1, CondX86::C2, swapV, CondX86::pred }              \
   ,
         FCMPX8632_TABLE
 #undef X
 };
 
-constexpr size_t MachineTraits<TargetX8632>::TableFcmpSize =
+const size_t MachineTraits<TargetX8632>::TableFcmpSize =
     llvm::array_lengthof(TableFcmp);
 
 const MachineTraits<TargetX8632>::TableIcmp32Type
     MachineTraits<TargetX8632>::TableIcmp32[] = {
 #define X(val, C_32, C1_64, C2_64, C3_64)                                      \
   { CondX86::C_32 }                                                            \
   ,
         ICMPX8632_TABLE
 #undef X
 };
 
-constexpr size_t MachineTraits<TargetX8632>::TableIcmp32Size =
+const size_t MachineTraits<TargetX8632>::TableIcmp32Size =
     llvm::array_lengthof(TableIcmp32);
 
 const MachineTraits<TargetX8632>::TableIcmp64Type
     MachineTraits<TargetX8632>::TableIcmp64[] = {
 #define X(val, C_32, C1_64, C2_64, C3_64)                                      \
   { CondX86::C1_64, CondX86::C2_64, CondX86::C3_64 }                           \
   ,
         ICMPX8632_TABLE
 #undef X
 };
 
-constexpr size_t MachineTraits<TargetX8632>::TableIcmp64Size =
+const size_t MachineTraits<TargetX8632>::TableIcmp64Size =
     llvm::array_lengthof(TableIcmp64);
 
 const MachineTraits<TargetX8632>::TableTypeX8632AttributesType
     MachineTraits<TargetX8632>::TableTypeX8632Attributes[] = {
 #define X(tag, elementty, cvt, sdss, pack, width, fld)                         \
   { elementty }                                                                \
   ,
         ICETYPEX8632_TABLE
 #undef X
 };
 
-constexpr size_t MachineTraits<TargetX8632>::TableTypeX8632AttributesSize =
+const size_t MachineTraits<TargetX8632>::TableTypeX8632AttributesSize =
     llvm::array_lengthof(TableTypeX8632Attributes);
 
 const uint32_t MachineTraits<TargetX8632>::X86_STACK_ALIGNMENT_BYTES = 16;
 } // end of namespace X86Internal
 
 TargetX8632 *TargetX8632::create(Cfg *Func) {
   return X86Internal::TargetX86Base<TargetX8632>::create(Func);
 }
 
 TargetDataX8632::TargetDataX8632(GlobalContext *Ctx)
@@ skipping 254 matching lines @@
 // entries in case the high-level table has extra entries.
 #define X(tag, size, align, elts, elty, str)                                   \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE");
 ICETYPE_TABLE
 #undef X
 } // end of namespace dummy3
 } // end of anonymous namespace
 
 } // end of namespace Ice