Add constant blinding/pooling option for X8632 code translation

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the writer for ELF relocatable object files.
@@ skipping 365 matching lines @@
       assert(ST == BSS || ST == ROData);
       if (ST == ROData)
         Section->appendZeros(Str, SymbolSize);
       else
         Section->setSize(Section->getCurrentSize() + SymbolSize);
     } else {
       assert(ST != BSS);
       for (VariableDeclaration::Initializer *Init : Var->getInitializers()) {
         switch (Init->getKind()) {
         case VariableDeclaration::Initializer::DataInitializerKind: {
-          const auto Data = llvm::cast<VariableDeclaration::DataInitializer>(
-                                Init)->getContents();
+          const auto Data =
+              llvm::cast<VariableDeclaration::DataInitializer>(Init)
+                  ->getContents();
           Section->appendData(Str, llvm::StringRef(Data.data(), Data.size()));
           break;
         }
         case VariableDeclaration::Initializer::ZeroInitializerKind:
           Section->appendZeros(Str, Init->getNumBytes());
           break;
         case VariableDeclaration::Initializer::RelocInitializerKind: {
           const auto Reloc =
               llvm::cast<VariableDeclaration::RelocInitializer>(Init);
           AssemblerFixup NewFixup;
@@ skipping 99 matching lines @@
   RODataSections.push_back(Section);
   SizeT OffsetInSection = 0;
   // The symbol table entry doesn't need to know the defined symbol's
   // size since this is in a section with a fixed Entry Size.
   const SizeT SymbolSize = 0;
   Section->setFileOffset(alignFileOffset(Align));
 
   // Write the data.
   for (Constant *C : Pool) {
     auto Const = llvm::cast<ConstType>(C);
+    // When constant pooling turned on, only emit labels for eligible constants

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

end sentence with period

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

Done.

+    // If C is i32 constant and not large enough, we should ignore it here.
+    if (llvm::isa<ConstantInteger32>(C) &&

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

Normally this kind of type checking would be done like this:

if (auto *CI32 = llvm::dyn_cast<ConstantInteger32>(C)) {
  if (!CI32->shouldBeRandomizedOrPooled(&Ctx))
    continue;
}

Note the use of dyn_cast<> instead of dyn_cast_or_null<> since we know C will
not be null.  Also note that the dyn_cast<> pattern handles both the isa<> check
and the cast.

However, can't you avoid all the type checking and just do this?

  if (!Const->shouldBeRandomizedOrPooled(&Ctx))
    continue;

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

I have moved shouldBeRandomizedOrPooled() to class Constant or even Operand. 

shouldBePooled flag is also added to the Constant class.

+        llvm::dyn_cast_or_null<ConstantInteger32>(C)
+                ->shouldBeRandomizedOrPooled(&Ctx) == false)

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

use "!x" instead of "x==false"

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

Done.

+      continue;
     std::string SymBuffer;
     llvm::raw_string_ostream SymStrBuf(SymBuffer);
     Const->emitPoolLabel(SymStrBuf);
     std::string &SymName = SymStrBuf.str();
     SymTab->createDefinedSym(SymName, STT_NOTYPE, STB_LOCAL, Section,
                              OffsetInSection, SymbolSize);
     StrTab->add(SymName);
     typename ConstType::PrimType Value = Const->getValue();
     memcpy(Buf, &Value, WriteAmt);
     Str.writeBytes(llvm::StringRef(Buf, WriteAmt));
     OffsetInSection += WriteAmt;
   }
   Section->setSize(OffsetInSection);
 }
 
 // Instantiate known needed versions of the template, since we are
 // defining the function in the .cpp file instead of the .h file.
 // We may need to instantiate constant pools for integers as well
 // if we do constant-pooling of large integers to remove them
 // from the instruction stream (fewer bytes controlled by an attacker).
 template void ELFObjectWriter::writeConstantPool<ConstantFloat>(Type Ty);
 
 template void ELFObjectWriter::writeConstantPool<ConstantDouble>(Type Ty);
 
+template void ELFObjectWriter::writeConstantPool<ConstantInteger32>(Type Ty);
+
 void ELFObjectWriter::writeAllRelocationSections() {
   writeRelocationSections(RelTextSections);
   writeRelocationSections(RelDataSections);
   writeRelocationSections(RelRODataSections);
 }
 
 void ELFObjectWriter::setUndefinedSyms(const ConstantList &UndefSyms) {
   for (const Constant *S : UndefSyms) {
     const auto Sym = llvm::cast<ConstantRelocatable>(S);
     const IceString &Name = Sym->getName();
@@ skipping 66 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice