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 477 matching lines @@
   }
   SizeT Align = typeAlignInBytes(Ty);
   size_t EntSize = typeWidthInBytes(Ty);
   char Buf[20];
   SizeT WriteAmt = std::min(EntSize, llvm::array_lengthof(Buf));
   assert(WriteAmt == EntSize);
   // Assume that writing WriteAmt bytes at a time allows us to avoid aligning
   // between entries.
   assert(WriteAmt % Align == 0);
   // Check that we write the full PrimType.
-  assert(WriteAmt == sizeof(typename ConstType::PrimType));
+  assert(WriteAmt == sizeof(typename ConstType::PrimType) ||
+         WriteAmt == sizeof(short) || WriteAmt == sizeof(char));
   const Elf64_Xword ShFlags = SHF_ALLOC | SHF_MERGE;
   std::string SecBuffer;
   llvm::raw_string_ostream SecStrBuf(SecBuffer);
   SecStrBuf << ".rodata.cst" << WriteAmt;
   ELFDataSection *Section = createSection<ELFDataSection>(
       SecStrBuf.str(), SHT_PROGBITS, ShFlags, Align, WriteAmt);
   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) {
+    if (!C->shouldBePooled)
+      continue;
     auto Const = llvm::cast<ConstType>(C);
     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