Add constant blinding/pooling option for X8632 code translation

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Operand class and its target-independent
@@ skipping 142 matching lines @@
   using Constant::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (ALLOW_DUMP)
       Str << getValue();
   }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
+  // Judge if this given immediate should be randomized or pooled

[Jim Stichnoth, 2015/06/12 23:48:17]

End this and the next sentence with a period.

[qining, 2015/06/17 04:28:53]

Done.

+  // By default should return false, only constant integers should
+  // truely go through this method

[Jim Stichnoth, 2015/06/12 23:48:17]

truly

[qining, 2015/06/17 04:28:53]

Done.

+  bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) { return false; }
+
 private:
   ConstantPrimitive(Type Ty, PrimType Value, uint32_t PoolEntryID)
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
   ~ConstantPrimitive() override {}
   const PrimType Value;
 };
 
 typedef ConstantPrimitive<int32_t, Operand::kConstInteger32> ConstantInteger32;
 typedef ConstantPrimitive<int64_t, Operand::kConstInteger64> ConstantInteger64;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
 template <>
 inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
   if (!ALLOW_DUMP)
     return;
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
     Str << static_cast<int32_t>(getValue());
 }
 
+// Specialization of the template member function for ConstantInteger32
+template <>
+bool ConstantInteger32::shouldBeRandomizedOrPooled(const GlobalContext *Ctx);

[Jim Stichnoth, 2015/06/12 23:48:17]

I'm not sure it's sufficient to limit blinding to 32-bit integer constants. 
Might we want to apply it to ConstantInteger16 as well?

On the other hand, if the blinding threshold for i32 is 0xffff, then an attacker
already has 16 bits to control and in theory it might not matter to also let
them control all 16 bits of an i16 constant.

Maybe the best way is to implement blinding for i32, i16, and i8, but apply the
same threshold to all types.  For example, if the threshold remains 0xffff, then
we would end up never blinding any i16 or i8 values.  But if we changed the
threshold to 0xff, then we might blind some i16 constants, but never any i8
constants.  And so on.

[qining, 2015/06/17 04:28:53]

Done. We now support randomizing and pooling of i8 and i16 constant integers.

+
 template <>
 inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const {
   if (!ALLOW_DUMP)
     return;
   assert(getType() == IceType_i64);
   Str << static_cast<int64_t>(getValue());
 }
 
 // RelocatableTuple bundles the parameters that are used to
 // construct an ConstantRelocatable.  It is done this way so that
@@ skipping 436 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