Add constant blinding/pooling option for X8632 code translation

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 420 matching lines @@
   TypeToRegisterSet[IceType_i64] = IntegerRegisters;
   TypeToRegisterSet[IceType_f32] = FloatRegisters;
   TypeToRegisterSet[IceType_f64] = FloatRegisters;
   TypeToRegisterSet[IceType_v4i1] = VectorRegisters;
   TypeToRegisterSet[IceType_v8i1] = VectorRegisters;
   TypeToRegisterSet[IceType_v16i1] = VectorRegisters;
   TypeToRegisterSet[IceType_v16i8] = VectorRegisters;
   TypeToRegisterSet[IceType_v8i16] = VectorRegisters;
   TypeToRegisterSet[IceType_v4i32] = VectorRegisters;
   TypeToRegisterSet[IceType_v4f32] = VectorRegisters;
+
+  // qining: initialize the assistant pause flag

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

"qining:"?  (here and below)

What does "assistant" mean here?

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

Done. Removed

+  // for constant blinding and pooling.
+  // When this is set to true, all constant blinding
+  // and pooling will be disabled. This should be set to
+  // true for doLoadOpt() and advancedPhiLowering().
+  // Note, when a physical regs are available for the Dest

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

I'm not 100% sure what this part of the comment means, but I suspect you want to
leave a TODO here for when some other part of phi lowering gets fixed. 
Something like:

TODO(qining,stichnot): Recombobulate the frobnicator after phi lowering is
fixed.

+  // of Phi lowering assignment, we should set this flag to
+  // false to enable blinding/pooling for that instruction.
+  RandomizationPoolingPaused = false;

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

Do this simple initialization in the initializer list of the ctor.

[qining, 2015/06/13 00:41:26]

Agree, but should we still leave the comments (may be a TODO) here?

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

Done.

 }
 
 void TargetX8632::translateO2() {
   TimerMarker T(TimerStack::TT_O2, Func);
 
   if (!Ctx->getFlags().getPhiEdgeSplit()) {
     // Lower Phi instructions.
     Func->placePhiLoads();
     if (Func->hasError())
       return;
@@ skipping 24 matching lines @@
     return;
 
   // TODO: It should be sufficient to use the fastest liveness
   // calculation, i.e. livenessLightweight().  However, for some
   // reason that slows down the rest of the translation.  Investigate.
   Func->liveness(Liveness_Basic);
   if (Func->hasError())
     return;
   Func->dump("After x86 address mode opt");
 
+  // qining: disable constant blinding or pooling for load optimization
+  bool RPLatchForDoLoadOpt = RandomizationPoolingPaused;

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

You are using this pattern enough times (5?) that it might be cleaner to manage
the push/pop through a helper class defined in an anonymous namespace.  E.g.:

class BoolFlagSaver {
  // Disable default no-arg and copy ctors, and default assignment operator
public:
  BoolFlagSaver(bool &F, bool NewValue) : Flag(F) {
    OldValue = F;
    F = NewValue;
  }
  ~BoolFlagSaver() { Flag = OldValue; }
private:
  bool &Flag;
  bool OldValue;
};

Then use it like this:

  {
    BoolFlagSaver B(RandomizationPoolingPaused, true);
    doLoadOpt();
  }

This helper would go away once all the workarounds are fixed.

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

Done.

+  RandomizationPoolingPaused = true;
   doLoadOpt();
+  // qining: Resume constant blinding and pooling
+  RandomizationPoolingPaused = RPLatchForDoLoadOpt;
   Func->genCode();
   if (Func->hasError())
     return;
   Func->dump("After x86 codegen");
 
   // Register allocation.  This requires instruction renumbering and
   // full liveness analysis.
   Func->renumberInstructions();
   if (Func->hasError())
     return;
   Func->liveness(Liveness_Intervals);
   if (Func->hasError())
     return;
   // Validate the live range computations.  The expensive validation
   // call is deliberately only made when assertions are enabled.
   assert(Func->validateLiveness());
   // The post-codegen dump is done here, after liveness analysis and
   // associated cleanup, to make the dump cleaner and more useful.
   Func->dump("After initial x8632 codegen");
   Func->getVMetadata()->init(VMK_All);
   regAlloc(RAK_Global);
   if (Func->hasError())
     return;
   Func->dump("After linear scan regalloc");
 
   if (Ctx->getFlags().getPhiEdgeSplit()) {
+    // : In general we need to pause constant blinding or pooling

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

":" ?

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

Done. Should I remove this comment?

+    // advanced phi lowering, unless the lowering assignment has a

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

during advanced phi lowering

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

Done.

+    // physical register for the Dest Variable
+    bool RPLatchAdvancedPhiLowering = RandomizationPoolingPaused;
+    RandomizationPoolingPaused = true;
     Func->advancedPhiLowering();
+    // qining: recover the pause flag;
+    RandomizationPoolingPaused = RPLatchAdvancedPhiLowering;
     Func->dump("After advanced Phi lowering");
   }
 
   // Stack frame mapping.
   Func->genFrame();
   if (Func->hasError())
     return;
   Func->dump("After stack frame mapping");
 
   Func->contractEmptyNodes();
@@ skipping 232 matching lines @@
     return RegNames[RegNum];
   }
 }
 
 void TargetX8632::emitVariable(const Variable *Var) const {
   Ostream &Str = Ctx->getStrEmit();
   if (Var->hasReg()) {
     Str << "%" << getRegName(Var->getRegNum(), Var->getType());
     return;
   }
-  if (Var->getWeight().isInf())
+  if (Var->getWeight().isInf()) {
     llvm_unreachable("Infinite-weight Variable has no register assigned");
+  }
   int32_t Offset = Var->getStackOffset();
   if (!hasFramePointer())
     Offset += getStackAdjustment();
   if (Offset)
     Str << Offset;
   const Type FrameSPTy = IceType_i32;
   Str << "(%" << getRegName(getFrameOrStackReg(), FrameSPTy) << ")";
 }
 
 X8632::Address TargetX8632::stackVarToAsmOperand(const Variable *Var) const {
   if (Var->hasReg())
     llvm_unreachable("Stack Variable has a register assigned");
-  if (Var->getWeight().isInf())
+  if (Var->getWeight().isInf()) {
     llvm_unreachable("Infinite-weight Variable has no register assigned");
+  }
   int32_t Offset = Var->getStackOffset();
   if (!hasFramePointer())
     Offset += getStackAdjustment();
   return X8632::Address(RegX8632::getEncodedGPR(getFrameOrStackReg()), Offset);
 }
 
 void TargetX8632::lowerArguments() {
   VarList &Args = Func->getArgs();
   // The first four arguments of vector type, regardless of their
   // position relative to the other arguments in the argument list, are
@@ skipping 370 matching lines @@
 Operand *TargetX8632::loOperand(Operand *Operand) {
   assert(Operand->getType() == IceType_i64 ||
          Operand->getType() == IceType_f64);
   if (Operand->getType() != IceType_i64 && Operand->getType() != IceType_f64)
     return Operand;
   if (Variable *Var = llvm::dyn_cast<Variable>(Operand)) {
     split64(Var);
     return Var->getLo();
   }
   if (ConstantInteger64 *Const = llvm::dyn_cast<ConstantInteger64>(Operand)) {
-    return Ctx->getConstantInt32(static_cast<uint32_t>(Const->getValue()));
+    ConstantInteger32 *ConstInt = llvm::dyn_cast<ConstantInteger32>(

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

Use cast<> instead of dyn_cast<>.

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

Done

+        Ctx->getConstantInt32(static_cast<uint32_t>(Const->getValue())));

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

I think you should use int32_t instead of uint32_t.  (Realizing that the code
originally used uint32_t...)

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

Done

+    // check if we need to blind/pool the constant
+    return randomizeOrPoolImmediate(ConstInt);
   }
   if (OperandX8632Mem *Mem = llvm::dyn_cast<OperandX8632Mem>(Operand)) {
-    return OperandX8632Mem::create(Func, IceType_i32, Mem->getBase(),
-                                   Mem->getOffset(), Mem->getIndex(),
-                                   Mem->getShift(), Mem->getSegmentRegister());
+    OperandX8632Mem *MemOperand = OperandX8632Mem::create(
+        Func, IceType_i32, Mem->getBase(), Mem->getOffset(), Mem->getIndex(),
+        Mem->getShift(), Mem->getSegmentRegister());
+    // Test if we should randomize or pool the offset, if so randomize it or
+    // pool it then create mem operand with the blinded/pooled constant.
+    // Otherwise, return the mem operand as ordinary mem operand.
+    return randomizeOrPoolImmediate(MemOperand);
   }
   llvm_unreachable("Unsupported operand type");
   return nullptr;
 }
 
 Operand *TargetX8632::hiOperand(Operand *Operand) {
   assert(Operand->getType() == IceType_i64 ||
          Operand->getType() == IceType_f64);
   if (Operand->getType() != IceType_i64 && Operand->getType() != IceType_f64)
     return Operand;
   if (Variable *Var = llvm::dyn_cast<Variable>(Operand)) {
     split64(Var);
     return Var->getHi();
   }
   if (ConstantInteger64 *Const = llvm::dyn_cast<ConstantInteger64>(Operand)) {
-    return Ctx->getConstantInt32(
-        static_cast<uint32_t>(Const->getValue() >> 32));
+    ConstantInteger32 *ConstInt = llvm::dyn_cast<ConstantInteger32>(

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

cast<>

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

Done

+        Ctx->getConstantInt32(static_cast<uint32_t>(Const->getValue() >> 32)));

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

int32_t

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

Done

+    // check if we need to blind/pool the constant
+    return randomizeOrPoolImmediate(ConstInt);
   }
   if (OperandX8632Mem *Mem = llvm::dyn_cast<OperandX8632Mem>(Operand)) {
     Constant *Offset = Mem->getOffset();
     if (Offset == nullptr) {
       Offset = Ctx->getConstantInt32(4);
     } else if (ConstantInteger32 *IntOffset =
                    llvm::dyn_cast<ConstantInteger32>(Offset)) {
       Offset = Ctx->getConstantInt32(4 + IntOffset->getValue());
     } else if (ConstantRelocatable *SymOffset =
                    llvm::dyn_cast<ConstantRelocatable>(Offset)) {
       assert(!Utils::WouldOverflowAdd(SymOffset->getOffset(), 4));
       Offset =
           Ctx->getConstantSym(4 + SymOffset->getOffset(), SymOffset->getName(),
                               SymOffset->getSuppressMangling());
     }
-    return OperandX8632Mem::create(Func, IceType_i32, Mem->getBase(), Offset,
-                                   Mem->getIndex(), Mem->getShift(),
-                                   Mem->getSegmentRegister());
+    OperandX8632Mem *MemOperand = OperandX8632Mem::create(
+        Func, IceType_i32, Mem->getBase(), Offset, Mem->getIndex(),
+        Mem->getShift(), Mem->getSegmentRegister());
+    // Test if the Offset is an eligible i32 constants for randomization and
+    // pooling. Blind/pool it if it is. Otherwise return as oridinary mem
+    // operand.
+    return randomizeOrPoolImmediate(MemOperand);
   }
   llvm_unreachable("Unsupported operand type");
   return nullptr;
 }
 
 llvm::SmallBitVector TargetX8632::getRegisterSet(RegSetMask Include,
                                                  RegSetMask Exclude) const {
   llvm::SmallBitVector Registers(RegX8632::Reg_NUM);
 
 #define X(val, encode, name, name16, name8, scratch, preserved, stackptr,      \
@@ skipping 610 matching lines @@
     Operand *Src0Hi = hiOperand(Src0);
     Variable *DestLo = llvm::cast<Variable>(loOperand(Dest));
     Variable *DestHi = llvm::cast<Variable>(hiOperand(Dest));
     Variable *T_Lo = nullptr, *T_Hi = nullptr;
     _mov(T_Lo, Src0Lo);
     _mov(DestLo, T_Lo);
     _mov(T_Hi, Src0Hi);
     _mov(DestHi, T_Hi);
   } else {
     Operand *RI;
-    if (Dest->hasReg())
+    if (Dest->hasReg()) {
       // If Dest already has a physical register, then legalize the
       // Src operand into a Variable with the same register
       // assignment.  This is mostly a workaround for advanced phi
       // lowering's ad-hoc register allocation which assumes no
       // register allocation is needed when at least one of the
       // operands is non-memory.
+
+      // qining: if we have a physical register for the dest variable,
+      // we can enable our constant blinding or pooling again. Note
+      // this is only for advancedPhiLowering(), the flag flip should
+      // leave no other side effect.
+      bool RPLatchInLowerAssign = RandomizationPoolingPaused;
+      RandomizationPoolingPaused = false;
+
       RI = legalize(Src0, Legal_Reg, Dest->getRegNum());
-    else
+
+      // qining: Resume constant blinding and pooling
+      RandomizationPoolingPaused = RPLatchInLowerAssign;
+    } else {
       // If Dest could be a stack operand, then RI must be a physical
       // register or a scalar integer immediate.
       RI = legalize(Src0, Legal_Reg | Legal_Imm);
+    }
     if (isVectorType(Dest->getType()))
       _movp(Dest, RI);
     else
       _mov(Dest, RI);
   }
 }
 
 void TargetX8632::lowerBr(const InstBr *Inst) {
   if (Inst->isUnconditional()) {
     _br(Inst->getTargetUnconditional());
@@ skipping 1248 matching lines @@
     Context.insert(
         InstFakeUse::create(Func, Context.getLastInserted()->getDest()));
     return;
   }
   case Intrinsics::AtomicRMW:
     if (!Intrinsics::isMemoryOrderValid(
             ID, getConstantMemoryOrder(Instr->getArg(3)))) {
       Func->setError("Unexpected memory ordering for AtomicRMW");
       return;
     }
-    lowerAtomicRMW(Instr->getDest(),
-                   static_cast<uint32_t>(llvm::cast<ConstantInteger32>(
-                                             Instr->getArg(0))->getValue()),
-                   Instr->getArg(1), Instr->getArg(2));
+    lowerAtomicRMW(
+        Instr->getDest(),
+        static_cast<uint32_t>(
+            llvm::cast<ConstantInteger32>(Instr->getArg(0))->getValue()),
+        Instr->getArg(1), Instr->getArg(2));
     return;
   case Intrinsics::AtomicStore: {
     if (!Intrinsics::isMemoryOrderValid(
             ID, getConstantMemoryOrder(Instr->getArg(2)))) {
       Func->setError("Unexpected memory ordering for AtomicStore");
       return;
     }
     // We require the memory address to be naturally aligned.
     // Given that is the case, then normal stores are atomic.
     // Add a fence after the store to make it visible.
@@ skipping 1182 matching lines @@
   }
 }
 
 void TargetX8632::lowerUnreachable(const InstUnreachable * /*Inst*/) { _ud2(); }
 
 // Turn an i64 Phi instruction into a pair of i32 Phi instructions, to
 // preserve integrity of liveness analysis.  Undef values are also
 // turned into zeroes, since loOperand() and hiOperand() don't expect
 // Undef input.
 void TargetX8632::prelowerPhis() {
+  // Pause constant blinding or pooling, blinding or pooling will be done later
+  // during phi lowering assignments
+  RandomizationPoolingPaused = true;
+
   CfgNode *Node = Context.getNode();
   for (Inst &I : Node->getPhis()) {
     auto Phi = llvm::dyn_cast<InstPhi>(&I);
     if (Phi->isDeleted())
       continue;
     Variable *Dest = Phi->getDest();
     if (Dest->getType() == IceType_i64) {
       Variable *DestLo = llvm::cast<Variable>(loOperand(Dest));
       Variable *DestHi = llvm::cast<Variable>(hiOperand(Dest));
       InstPhi *PhiLo = InstPhi::create(Func, Phi->getSrcSize(), DestLo);
       InstPhi *PhiHi = InstPhi::create(Func, Phi->getSrcSize(), DestHi);
       for (SizeT I = 0; I < Phi->getSrcSize(); ++I) {
         Operand *Src = Phi->getSrc(I);
         CfgNode *Label = Phi->getLabel(I);
         if (llvm::isa<ConstantUndef>(Src))
           Src = Ctx->getConstantZero(Dest->getType());
         PhiLo->addArgument(loOperand(Src), Label);
         PhiHi->addArgument(hiOperand(Src), Label);
       }
       Node->getPhis().push_back(PhiLo);
       Node->getPhis().push_back(PhiHi);
       Phi->setDeleted();
     }
   }
+
+  // Recover the constant blinding/pooling state
+  RandomizationPoolingPaused = false;
 }
 
 namespace {
 
 bool isMemoryOperand(const Operand *Opnd) {
   if (const auto Var = llvm::dyn_cast<Variable>(Opnd))
     return !Var->hasReg();
   // We treat vector undef values the same as a memory operand,
   // because they do in fact need a register to materialize the vector
   // of zeroes into.
@@ skipping 250 matching lines @@
     }
     if (Index) {
       RegIndex = legalizeToVar(Index);
     }
     if (Base != RegBase || Index != RegIndex) {
       From =
           OperandX8632Mem::create(Func, Ty, RegBase, Mem->getOffset(), RegIndex,
                                   Mem->getShift(), Mem->getSegmentRegister());
     }
 
+    // qining: For all Memory Operands, we do randomization/pooling from here
+    From = randomizeOrPoolImmediate(llvm::dyn_cast<OperandX8632Mem>(From));

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

You've already done a dyn_cast<>(From) in the enclosing "if" statement, so I
think you could just use Mem here.  (But you would also have to change the "From
= ..." 6 lines up to be "Mem = ...".)

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

Done

+
     if (!(Allowed & Legal_Mem)) {
       From = copyToReg(From, RegNum);
     }
     return From;
   }
   if (llvm::isa<Constant>(From)) {
     if (llvm::isa<ConstantUndef>(From)) {
       // Lower undefs to zero.  Another option is to lower undefs to an
       // uninitialized register; however, using an uninitialized register
       // results in less predictable code.
       //
       // If in the future the implementation is changed to lower undef
       // values to uninitialized registers, a FakeDef will be needed:
       //     Context.insert(InstFakeDef::create(Func, Reg));
       // This is in order to ensure that the live range of Reg is not
       // overestimated.  If the constant being lowered is a 64 bit value,
       // then the result should be split and the lo and hi components will
       // need to go in uninitialized registers.
       if (isVectorType(Ty))
         return makeVectorOfZeros(Ty, RegNum);
       From = Ctx->getConstantZero(Ty);
     }
     // There should be no constants of vector type (other than undef).
     assert(!isVectorType(Ty));
+
+    // If the operand is an 32 bit constant integer, we should check
+    // whether we need to randomize it or pool it.
+    if (From && llvm::isa<ConstantInteger32>(From)) {

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

"From" must be non-null, so no need to test that.

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

Done

+      Operand *NewFrom =
+          randomizeOrPoolImmediate(llvm::cast<Constant>(From), RegNum);

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

You can avoid the cast<> and the earlier isa<> check by using dyn_cast<>.

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

Done

+      if (NewFrom != From)
+        return NewFrom;
+    }
+
     // Convert a scalar floating point constant into an explicit
     // memory operand.
     if (isScalarFloatingType(Ty)) {
       Variable *Base = nullptr;
       std::string Buffer;
       llvm::raw_string_ostream StrBuf(Buffer);
       llvm::cast<Constant>(From)->emitPoolLabel(StrBuf);
       Constant *Offset = Ctx->getConstantSym(0, StrBuf.str(), true);
       From = OperandX8632Mem::create(Func, Ty, Base, Offset);
     }
@@ skipping 43 matching lines @@
   bool IsSrc1ImmOrReg = false;
   if (llvm::isa<Constant>(Src1)) {
     IsSrc1ImmOrReg = true;
   } else if (Variable *Var = llvm::dyn_cast<Variable>(Src1)) {
     if (Var->hasReg())
       IsSrc1ImmOrReg = true;
   }
   return legalize(Src0, IsSrc1ImmOrReg ? (Legal_Reg | Legal_Mem) : Legal_Reg);
 }
 
-OperandX8632Mem *TargetX8632::formMemoryOperand(Operand *Operand, Type Ty,
+OperandX8632Mem *TargetX8632::formMemoryOperand(Operand *operand, Type Ty,

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

Variable names should be capitalized, so maybe Opnd instead?

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

Done, replaced with Opnd.

                                                 bool DoLegalize) {
-  OperandX8632Mem *Mem = llvm::dyn_cast<OperandX8632Mem>(Operand);
+  OperandX8632Mem *Mem = llvm::dyn_cast<OperandX8632Mem>(operand);
   // It may be the case that address mode optimization already creates
   // an OperandX8632Mem, so in that case it wouldn't need another level
   // of transformation.
   if (!Mem) {
-    Variable *Base = llvm::dyn_cast<Variable>(Operand);
-    Constant *Offset = llvm::dyn_cast<Constant>(Operand);
+    Variable *Base = llvm::dyn_cast<Variable>(operand);
+    Constant *Offset = llvm::dyn_cast<Constant>(operand);
     assert(Base || Offset);
     if (Offset) {
-      // Make sure Offset is not undef.
+      // qining: during memory operand building, we do not
+      // blind or pool the constant offset, we will work on
+      // the whole memory operand later as one entity later,
+      // this save one instruction. By turning blinding and
+      // pooling off, we guarantee legalize(Offset) will return
+      // a constant*
+      bool RPLatchForMemOperandBuilding = RandomizationPoolingPaused;
+      RandomizationPoolingPaused = true;
+
       Offset = llvm::cast<Constant>(legalize(Offset));
+
       assert(llvm::isa<ConstantInteger32>(Offset) ||
              llvm::isa<ConstantRelocatable>(Offset));
+
+      // qining: Resume constant blinding and pooling
+      RandomizationPoolingPaused = RPLatchForMemOperandBuilding;
     }
     Mem = OperandX8632Mem::create(Func, Ty, Base, Offset);
   }
-  return llvm::cast<OperandX8632Mem>(DoLegalize ? legalize(Mem) : Mem);
+  // qining: do legalization, which contains randomization/pooling
+  // or do randomization/pooling.
+  return llvm::cast<OperandX8632Mem>(
+      DoLegalize ? legalize(Mem) : randomizeOrPoolImmediate(Mem));
 }
 
 Variable *TargetX8632::makeReg(Type Type, int32_t RegNum) {
   // There aren't any 64-bit integer registers for x86-32.
   assert(Type != IceType_i64);
   Variable *Reg = Func->makeVariable(Type);
   if (RegNum == Variable::NoRegister)
     Reg->setWeightInfinite();
   else
     Reg->setRegNum(RegNum);
@@ skipping 220 matching lines @@
   typedef ConstantDouble IceType;
   static const Type Ty = IceType_f64;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<double>::TypeName = "double";
 const char *PoolTypeConverter<double>::AsmTag = ".quad";
 const char *PoolTypeConverter<double>::PrintfString = "0x%llx";
 
+// Add converter for int type constant pooling
+template <> struct PoolTypeConverter<int> {
+  typedef uint32_t PrimitiveIntType;
+  typedef ConstantInteger32 IceType;
+  static const Type Ty = IceType_i32;
+  static const char *TypeName;
+  static const char *AsmTag;
+  static const char *PrintfString;
+};
+const char *PoolTypeConverter<int>::TypeName = "i32";
+const char *PoolTypeConverter<int>::AsmTag = ".long";
+const char *PoolTypeConverter<int>::PrintfString = "0x%x";
+
 template <typename T>
 void TargetDataX8632::emitConstantPool(GlobalContext *Ctx) {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Ctx->getStrEmit();
   Type Ty = T::Ty;
   SizeT Align = typeAlignInBytes(Ty);
   ConstantList Pool = Ctx->getConstantPool(Ty);
 
   Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",@progbits," << Align
       << "\n";
   Str << "\t.align\t" << Align << "\n";
   for (Constant *C : Pool) {
     typename T::IceType *Const = llvm::cast<typename T::IceType>(C);
+    // When constant pooling turned on, only emit labels for eligible constants
+    // If C is i32 constant and not large enough, we should ignore it here.
+    if (llvm::isa<ConstantInteger32>(C) &&
+        llvm::dyn_cast_or_null<ConstantInteger32>(C)

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

Same comments here as in IceELFObjectWriter.cpp

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

Done. shouldBePooled will be checked before pooling for each constant.

+                ->shouldBeRandomizedOrPooled(Ctx) == false)
+      continue;
     typename T::IceType::PrimType Value = Const->getValue();
     // Use memcpy() to copy bits from Value into RawValue in a way
     // that avoids breaking strict-aliasing rules.
     typename T::PrimitiveIntType RawValue;
     memcpy(&RawValue, &Value, sizeof(Value));
     char buf[30];
     int CharsPrinted =
         snprintf(buf, llvm::array_lengthof(buf), T::PrintfString, RawValue);
     assert(CharsPrinted >= 0 &&
            (size_t)CharsPrinted < llvm::array_lengthof(buf));
     (void)CharsPrinted; // avoid warnings if asserts are disabled
     Const->emitPoolLabel(Str);
     Str << ":\n\t" << T::AsmTag << "\t" << buf << "\t# " << T::TypeName << " "
         << Value << "\n";
   }
 }
 
 void TargetDataX8632::lowerConstants() const {
   if (Ctx->getFlags().getDisableTranslation())
     return;
   // No need to emit constants from the int pool since (for x86) they
   // are embedded as immediates in the instructions, just emit float/double.
   switch (Ctx->getFlags().getOutFileType()) {
   case FT_Elf: {
     ELFObjectWriter *Writer = Ctx->getObjectWriter();
+
+    // If immediates pooling turned on, pool the integer constants
+    if (Ctx->getFlags().shouldPoolImmediates())
+      Writer->writeConstantPool<ConstantInteger32>(IceType_i32);
+
     Writer->writeConstantPool<ConstantFloat>(IceType_f32);
     Writer->writeConstantPool<ConstantDouble>(IceType_f64);
   } break;
   case FT_Asm:
   case FT_Iasm: {
     OstreamLocker L(Ctx);
+
+    // If immediates pooling turned on, pool the integer constants
+    if (Ctx->getFlags().shouldPoolImmediates())
+      emitConstantPool<PoolTypeConverter<int>>(Ctx);
+
     emitConstantPool<PoolTypeConverter<float>>(Ctx);
     emitConstantPool<PoolTypeConverter<double>>(Ctx);
   } break;
   }
 }
 
 TargetHeaderX8632::TargetHeaderX8632(GlobalContext *Ctx)
     : TargetHeaderLowering(Ctx) {}
 
+uint32_t TargetX8632::getRandomizationCookie() {
+  static uint64_t cookie = 0;

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

Don't use static non-const variables, as they are not thread-safe.  Maybe store
the cookie in GlobalContext instead?

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

Done. Moved getRandomizationCookie() and the cookie variable to GlobalContext
class, guarded by a lock.

+  static bool cookie_initialized = false;
+  if (!cookie_initialized) {
+    RandomNumberGenerator &RNG = Ctx->getRNG();
+    cookie =
+        (uint32_t)RNG.next((uint64_t)std::numeric_limits<uint32_t>::max() + 1);
+    cookie_initialized = true;
+  }
+  return cookie;
+}
+
+// Blind/pool an immediate value
+Operand *TargetX8632::randomizeOrPoolImmediate(Constant *immediate,

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

Capitalize "immediate" arg name.

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

Done

+                                               int32_t RegNum) {
+  assert(llvm::isa<ConstantInteger32>(immediate) ||
+         llvm::isa<ConstantRelocatable>(immediate));
+  if (Ctx->getFlags().shouldNotRandomizeOrPoolImmediates() == true ||
+      RandomizationPoolingPaused == true) {
+    // immediates randomization/pool turned off
+    return immediate;
+  }
+  if (llvm::isa<ConstantInteger32>(immediate) &&
+      llvm::dyn_cast<ConstantInteger32>(immediate)
+          ->shouldBeRandomizedOrPooled(Ctx)) {

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

Call immediate->shouldBeRandomizedOrPooled(Ctx) directly without type checking
or casting?

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

Done. Changed to:
if(Constant *C = dyn_cast_or_null<Constant>(Immediate)){
    if(C->shouldBeRandomizedOrPooled(Ctx)) {
.....
    }
}

+    Ctx->statsUpdateRPImms();
+    if (Ctx->getFlags().shouldRandomizeImmediates() == true) {
+      // blind the constant
+      // FROM:
+      //  imm
+      // TO:
+      //  insert: mov imm+cookie, Reg
+      //  insert: lea -cookie[Reg], Reg
+      //  => Reg
+      // if we have already assigned a phy register, we must come from
+      // andvancedPhiLowering()=>lowerAssign(). In this case we should reuse

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

advancedPhiLowering

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

Done.

+      // the assigned register as this assignment is that start of its use-def
+      // chain. So we add RegNum argument here.
+      Variable *Reg = makeReg(immediate->getType(), RegNum);
+      ConstantInteger32 *integer = llvm::cast<ConstantInteger32>(immediate);

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

Capitalize variable names

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

Done.

+      uint32_t value = integer->getValue();
+      uint64_t cookie = getRandomizationCookie();

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

uint32_t

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

Done.

+      _mov(Reg, Ctx->getConstantInt(IceType_i32, cookie + value));
+      Constant *offset = Ctx->getConstantInt(IceType_i32, 0 - cookie);
+      _lea(Reg, OperandX8632Mem::create(Func, offset->getType(), Reg, offset,
+                                        NULL, 0));
+      // make sure liveness analysis won't kill this variable, otherwise a
+      // liveness
+      // assertion will be triggered.
+      _set_dest_nonkillable();
+      return Reg;
+    } else {

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

Don't use this pattern:
  if (abc) {
    def;
    return;
  } else {
    ghi;
  }

Instead, use:
  if (abc) {
    def;
    return;
  }
  ghi;

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

Done. Changed to:

if (abc) {
   return xyz;
}
if (edf) {
   return uvw;
}
assert(false);

+      // pool the constant
+      // FROM:
+      //  imm
+      // TO:
+      //  insert: mov $label, Reg
+      //  => Reg
+      assert(Ctx->getFlags().shouldPoolImmediates() == true);
+      // if we have already assigned a phy register, we must come from
+      // andvancedPhiLowering()=>lowerAssign(). In this case we should reuse

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

advancedPhiLowering

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

Done.

+      // the assigned register as this assignment is that start of its use-def
+      // chain. So we add RegNum argument here.
+      Variable *Reg = makeReg(immediate->getType(), RegNum);
+      IceString label;
+      llvm::raw_string_ostream label_stream(label);
+      immediate->emitPoolLabel(label_stream);
+      Constant *symbol = Ctx->getConstantSym(0, label_stream.str(), true);

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

Try to avoid using non-obvious constants as arguments to function calls. 
Instead, something like this:

  const RelocOffsetT Offset = 0;
  const bool SuppressMangling = true;
  ... getConstantSym(Offset, label_stream.str(), SuppressMangling);

For better or worse, the ::create() methods seem to be exceptions to this
rule...

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

Done.

+      OperandX8632Mem *MemOperand =
+          OperandX8632Mem::create(Func, immediate->getType(), NULL, symbol);
+      _mov(Reg, MemOperand);
+      return Reg;
+    }
+  } else {
+    // the constant immediate is not eligible for blinding/pooling
+    return immediate;
+  }
+}
+
+OperandX8632Mem *
+TargetX8632::randomizeOrPoolImmediate(OperandX8632Mem *MemOperand,
+                                      int32_t RegNum) {
+  assert(llvm::isa<OperandX8632Mem>(MemOperand));

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

This assert isn't very useful and should always succeed (unless
MemOperand==nullptr in which case isa<> will crash).

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

Done. Changed to assert(MemOperand).

+  if (Ctx->getFlags().shouldNotRandomizeOrPoolImmediates() == true ||
+      RandomizationPoolingPaused == true) {
+    // immediates randomization/pooling is turned off
+    return MemOperand;
+  }
+
+  if (MemOperand->getOffset() &&

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

Something like this might be more compact:

if (auto *C = llvm::dyn_cast_or_null<Constant>(MemOperand->getOffset()) {
  if (C->shouldBeRandomizedOrPooled(Ctx)) {
    ...
  }
}

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

Done.

+      llvm::isa<ConstantInteger32>(MemOperand->getOffset()) &&
+      llvm::dyn_cast<ConstantInteger32>(MemOperand->getOffset())
+          ->shouldBeRandomizedOrPooled(Ctx)) {
+    // The offset of this mem operand should be blinded or pooled
+    Ctx->statsUpdateRPImms();
+    if (Ctx->getFlags().shouldRandomizeImmediates() == true) {
+      // blind the constant offset
+      // FROM:
+      //  offset[base, index, shift]
+      // TO:
+      //  insert: lea offset+cookie[base], RegTemp
+      //  => -cookie[RegTemp, index, shift]
+      uint32_t value =
+          llvm::dyn_cast<ConstantInteger32>(MemOperand->getOffset())
+              ->getValue();
+      uint64_t cookie = getRandomizationCookie();
+      Constant *mask1 = Ctx->getConstantInt(IceType_i32, cookie + value);
+      Constant *mask2 = Ctx->getConstantInt(IceType_i32, 0 - cookie);
+      // qining: We need to make sure the MemOperand->getBase() has a physical
+      // register, if it is a variable!
+      if (MemOperand->getBase() != NULL)

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

nullptr, or just leave out the != part

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

Done.

+        MemOperand->getBase()->setWeightInfinite();

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

This will get you into trouble.  The base variable could be a program variable
that is live throughout the function.  There could be many memory operands, each
with a different base variable that is live throughout the function.  The
register allocator won't have enough registers to satisfy all the
infinite-weight directives.

Because of this, we need to set infinite weight or a fixed register assignment
only to temporaries we create with a short lifetime.

The way to deal with this is to _mov the variable into a temporary variable with
infinite weight, and reconstruct the mem operand using that temporary for the
base.

However, I'm a bit puzzled that this is even necessary.  Normally legalize()
will rewrite any memory operand into one that guarantees all of its variables
have infinite weight, and all operands are supposed to be legalized.

+      OperandX8632Mem *TempMemOperand = OperandX8632Mem::create(
+          Func, MemOperand->getType(), MemOperand->getBase(), mask1);
+      // if we have already assigned a phy register, we must come from
+      // andvancedPhiLowering()=>lowerAssign(). In this case we should reuse
+      // the assigned register as this assignment is that start of its use-def
+      // chain. So we add RegNum argument here.
+
+      Variable *RegTemp = makeReg(MemOperand->getOffset()->getType(), RegNum);
+      _lea(RegTemp, TempMemOperand);
+      // as srcreg doesn't include dstreg, we don't need to add
+      // _set_dest_nonkillable()
+      // qining: but if we use the same Dest Reg, that is, with RegNum
+      // assigned, we should add this _set_dest_nonkillable()
+      if (RegNum != Variable::NoRegister)
+        _set_dest_nonkillable();
+
+      OperandX8632Mem *NewMemOperand = OperandX8632Mem::create(
+          Func, MemOperand->getType(), RegTemp, mask2, MemOperand->getIndex(),
+          MemOperand->getShift(), MemOperand->getSegmentRegister());
+
+      return NewMemOperand;
+
+    } else {
+      // pool the constant offset
+      // FROM:
+      //  offset[base, index, shift]
+      // TO:
+      //  insert: mov $label, RegTemp
+      //  insert: lea [base, RegTemp], RegTemp
+      //  =>[RegTemp, index, shift]
+      assert(Ctx->getFlags().shouldPoolImmediates() == true);
+      // qining: Mem operand should never exist as source operands in phi
+      // lowering
+      // assignments, so there is no need to reuse any registers here.
+      // However, for phi lowering, we should not ask for new physical
+      // registers in general.
+      // However, if we do meet MemOperand during phi lowering, we should not
+      // blind or pool the immediates for now
+      if (RegNum != Variable::NoRegister)
+        return MemOperand;
+      Variable *RegTemp = makeReg(MemOperand->getOffset()->getType());
+      IceString label;
+      llvm::raw_string_ostream label_stream(label);
+      MemOperand->getOffset()->emitPoolLabel(label_stream);
+      Constant *symbol = Ctx->getConstantSym(0, label_stream.str(), true);
+      OperandX8632Mem *SymbolOperand = OperandX8632Mem::create(
+          Func, MemOperand->getOffset()->getType(), NULL, symbol);
+      _mov(RegTemp, SymbolOperand);
+      // qining: We need to make sure the MemOperand->getBase() has a physical
+      // register! If we do not have base register here, we won't need an
+      // extra lea instruction anymore.
+      if (MemOperand->getBase() != NULL) {
+        MemOperand->getBase()->setWeightInfinite();
+        OperandX8632Mem *CalculateOperand = OperandX8632Mem::create(
+            Func, MemOperand->getType(), MemOperand->getBase(), NULL, RegTemp,
+            0, MemOperand->getSegmentRegister());
+        _lea(RegTemp, CalculateOperand);
+        _set_dest_nonkillable();
+      }
+      OperandX8632Mem *NewMemOperand = OperandX8632Mem::create(
+          Func, MemOperand->getType(), RegTemp, NULL, MemOperand->getIndex(),
+          MemOperand->getShift(), MemOperand->getSegmentRegister());
+      return NewMemOperand;
+    }
+  } else {
+    // the offset is not eligible for blinding or pooling, return the original
+    // mem operand
+    return MemOperand;
+  }
+}
 } // end of namespace Ice