Add constant blinding/pooling option for X8632 code translation

src/IceClFlags.cpp

 //===- subzero/src/IceClFlags.cpp - Command line flags and parsing --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines commandline flags parsing.
@@ skipping 88 matching lines @@
 cl::opt<bool>
     EnablePhiEdgeSplit("phi-edge-split",
                        cl::desc("Enable edge splitting for Phi lowering"),
                        cl::init(true));
 
 // TODO(stichnot): See if we can easily use LLVM's -rng-seed option
 // and implementation.  I expect the implementation is different and
 // therefore the tests would need to be changed.
 cl::opt<unsigned long long>
     RandomSeed("sz-seed", cl::desc("Seed the random number generator"),
                cl::init(time(0)));

[Jim Stichnoth, 2015/06/21 00:05:27]

Why did this get switched back???

[qining, 2015/06/21 00:30:47]

I think we can explicitly set this seed. Originally, there is only
cl::init(time(0))). cl::init(1) was added by me for testing. Should I add the
init(1) back and comment the time(0) again?

[Jim Stichnoth, 2015/06/21 00:40:09]

Yes, please make this init(1) by default.  I think it was a mistake for it to
have been init(time(0)) by default in the first place.  We'll have to do
something besides init(1) in production, but whatever it is will surely not be
time(0), so let's avoid nondeterminism in the meantime.

 
 cl::opt<bool> ShouldDoNopInsertion("nop-insertion",
                                    cl::desc("Randomly insert NOPs"),
                                    cl::init(false));
 
 cl::opt<bool>
     RandomizeRegisterAllocation("randomize-regalloc",
                                 cl::desc("Randomize register allocation"),
                                 cl::init(false));
 
@@ skipping 131 matching lines @@
 cl::opt<bool> LLVMVerboseErrors(
     "verbose-llvm-parse-errors",
     cl::desc("Print out more descriptive PNaCl bitcode parse errors when "
              "building LLVM IR first"),
     cl::init(false));
 cl::opt<std::string> OutputFilename("o", cl::desc("Override output filename"),
                                     cl::init("-"), cl::value_desc("filename"));
 
 Ice::IceString AppName;
 
+// Define the command line options for immediates pooling and randomization
+cl::opt<Ice::RandomizeAndPoolImmediatesEnum> RandomizeAndPoolImmediatesOption(
+    "randomize-pool-immediates",
+    cl::desc("Randomize or pooling the representation of immediates"),
+    cl::init(Ice::RPI_None),
+    cl::values(clEnumValN(Ice::RPI_None, "none",
+                          "Do not randomize or pooling immediates (default)"),
+               clEnumValN(Ice::RPI_Randomize, "randomize",
+                          "Turn on immediate constants blinding"),
+               clEnumValN(Ice::RPI_Pool, "pool",
+                          "Turn on immediate constants pooling"),
+               clEnumValEnd));
+// Command line option for x86 immediate integer randomization/pooling
+// threshold. Immediates whose representation are between:
+// -RandomizeAndPoolImmediatesThreshold/2 and
+// +RandomizeAndPoolImmediatesThreshold/2 will be randomized or pooled.
+cl::opt<uint32_t> RandomizeAndPoolImmediatesThreshold(
+    "randomize-pool-threshold",
+    cl::desc("The threshold for immediates randomization and pooling"),
+    cl::init(0xffff));
+
 } // end of anonymous namespace
 
 namespace Ice {
 
 void ClFlags::parseFlags(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv);
   AppName = IceString(argv[0]);
 }
 
 void ClFlags::resetClFlags(ClFlags &OutFlags) {
@@ skipping 72 matching lines @@
   OutFlags.setTestPrefix(::TestPrefix);
   OutFlags.setTimeEachFunction(::TimeEachFunction);
   OutFlags.setTimingFocusOn(::TimingFocusOn);
   OutFlags.setTranslateOnly(::TranslateOnly);
   OutFlags.setUseSandboxing(::UseSandboxing);
   OutFlags.setVerboseFocusOn(::VerboseFocusOn);
   OutFlags.setOutFileType(::OutFileType);
   OutFlags.setMaxNopsPerInstruction(::MaxNopsPerInstruction);
   OutFlags.setNopProbabilityAsPercentage(::NopProbabilityAsPercentage);
   OutFlags.setVerbose(VMask);
+
+  // set for immediates randomization or pooling option
+  OutFlags.setRandomizeAndPoolImmediatesOption(
+      ::RandomizeAndPoolImmediatesOption);
+  OutFlags.setRandomizeAndPoolImmediatesThreshold(
+      ::RandomizeAndPoolImmediatesThreshold);
 }
 
 void ClFlags::getParsedClFlagsExtra(ClFlagsExtra &OutFlagsExtra) {
   OutFlagsExtra.setAlwaysExitSuccess(AlwaysExitSuccess);
   OutFlagsExtra.setBuildOnRead(BuildOnRead);
   OutFlagsExtra.setGenerateBuildAtts(GenerateBuildAtts);
   OutFlagsExtra.setLLVMVerboseErrors(LLVMVerboseErrors);
   OutFlagsExtra.setAppName(AppName);
   OutFlagsExtra.setInputFileFormat(InputFileFormat);
   OutFlagsExtra.setIRFilename(IRFilename);
   OutFlagsExtra.setLogFilename(LogFilename);
   OutFlagsExtra.setOutputFilename(OutputFilename);
 }
 
 } // end of namespace Ice