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 99 matching lines @@
     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;
   }
 
+  // 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;
+  }
+
+  // Whether we should pool this constant. Usually Float/Doubled Relocatables
+  // and pooled Integers should be flaged true.
+  bool shouldBePooled;

[Jim Stichnoth, 2015/06/19 16:51:03]

Make this protected with a public getter and/or setter.

[qining, 2015/06/19 20:22:26]

Done.

+
 protected:
   Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
-      : Operand(Kind, Ty), PoolEntryID(PoolEntryID) {
+      : Operand(Kind, Ty), shouldBePooled(false), PoolEntryID(PoolEntryID) {
     Vars = nullptr;
     NumVars = 0;
   }
   ~Constant() override {}
   // PoolEntryID is an integer that uniquely identifies the constant
   // within its constant pool.  It is used for building the constant
   // pool in the object code and for referencing its entries.
   const uint32_t PoolEntryID;
 };
 
@@ skipping 20 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;
   }
 
+  virtual bool shouldBeRandomizedOrPooled(const GlobalContext *Ctx) override {
+    (void)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);
+
 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