Add constant blinding/pooling option for X8632 code translation

src/IceOperand.cpp

 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===//
 //
 //                        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 Operand class and its target-independent
@@ skipping 473 matching lines @@
 Ostream &operator<<(Ostream &Str, const RegWeight &W) {
   if (!ALLOW_DUMP)
     return Str;
   if (W.getWeight() == RegWeight::Inf)
     Str << "Inf";
   else
     Str << W.getWeight();
   return Str;
 }
 
+// =========== Immediate Randomization and Pooling routines ==============
+// Immediates randomization and pooling threshold, we should not
+// randomize or pool small constants e.g. 2,4 etc.
+static const uint32_t X86_INT_IMMEDIATE_RANDOMIZATION_THRESHOLD = 0x1;

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

Do you really mean to set such a low threshold?

IceOperand.cpp represents the high-level IR, and should not contain references
to a specific target like x86.

Don't use such a global static variable.  I think you can just move it inside
the function below, and also make it a constexpr:

  constexpr uint32_t Threshold = 0xWhatever;

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

Done. Chang back to 0xffff. Do we need to add a command line option for it?

[Jim Stichnoth, 2015/06/19 23:12:15]

I think a command line option would be most excellent.  (defaulting to 0xffff or
whatever)

[qining, 2015/06/20 00:22:28]

Done.

+
+// Specialization of the template member function for ConstantInteger32

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

It seems that you're trying to specialize for i32 on x86, but by specializing
ConstantInteger32, it's forcing the same logic on all targets.  You could try to
move the specialization into a target-specific file, but then you'd have issues
with multiply defined symbols when multiple targets are included.

I think it would be better to precompute this as a flag in the Constant object. 
The only thing is that the Constants are created through the GlobalContext,
which would have to consult the TargetLowering to get the flag's proper value.

This probably means a lot of changes, across the code, so let's leave it as is
for now, but add a TODO(stichnot) comment here to fix it.

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

Done. I've labeled that with a TODO tag. But actually this function can be moved
into TargetX8632. Just add a Constant* as an argument. However, that means some
type checking will be necessary. I think the only benefit of this specialization
is avoiding type checking (This may not improve performance at all :( ).

+template <>
+bool ConstantInteger32::shouldBeRandomizedOrPooled(const GlobalContext *Ctx) {
+  if (Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_None)
+    return false;
+  if (getType() != IceType_i32 && getType() != IceType_i16 &&
+      getType() != IceType_i8)
+    return false;
+  // if(getType() != IceType_i32)  return false;

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

remove commented code

+  // The Following checks if the signed representation of Value is between
+  // -THRESHOLD/2 and +THRESHOLD/2
+  bool largerThanThreshold =
+      X86_INT_IMMEDIATE_RANDOMIZATION_THRESHOLD / 2 + Value >=
+      X86_INT_IMMEDIATE_RANDOMIZATION_THRESHOLD;
+  return largerThanThreshold;
+}
+
 } // end of namespace Ice