Subzero: Write float/double constant pools directly to the ELF file.

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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceELFSection.h"
 #include "IceELFStreamer.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
+#include "IceOperand.h"
 
 using namespace llvm::ELF;
 
 namespace Ice {
 
 namespace {
 
 struct {
   bool IsELF64;
   uint16_t ELFMachine;
@@ skipping 254 matching lines @@
   Str.writeLE16(0); // e_phentsize
   Str.writeLE16(0); // e_phnum
   Str.writeLE16(IsELF64 ? sizeof(Elf64_Shdr)
                         : sizeof(Elf32_Shdr)); // e_shentsize
   static_assert(sizeof(Elf64_Shdr) == 64 && sizeof(Elf32_Shdr) == 40,
                 "Elf_Shdr sizes cannot be derived from sizeof");
   Str.writeLE16(static_cast<Elf64_Half>(NumSections));        // e_shnum
   Str.writeLE16(static_cast<Elf64_Half>(SectHeaderStrIndex)); // e_shstrndx
 }
 
+template <typename ConstType> void ELFObjectWriter::writeConstantPool(Type Ty) {
+  ConstantList Pool = Ctx.getConstantPool(Ty);
+  if (Pool.empty()) {
+    return;
+  }
+  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));
+  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) {
+    auto Const = llvm::cast<ConstType>(C);
+    std::string SymBuffer;
+    llvm::raw_string_ostream SymStrBuf(SymBuffer);
+    SymStrBuf << ".L$" << Ty << "$" << Const->getPoolEntryID();
+    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);
+
 void ELFObjectWriter::writeNonUserSections() {
   bool IsELF64 = isELF64(Ctx.getTargetArch());
 
   // Write out the shstrtab now that all sections are known.
   ShStrTab->doLayout();
   ShStrTab->setSize(ShStrTab->getSectionDataSize());
   Elf64_Off ShStrTabOffset = alignFileOffset(ShStrTab->getSectionAlign());
   ShStrTab->setFileOffset(ShStrTabOffset);
   Str.writeBytes(ShStrTab->getSectionData());
 
@@ skipping 34 matching lines @@
   if (IsELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice