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.size() == 0) {

[Jim Stichnoth, 2015/01/09 19:23:45]

Pool.empty()

[jvoung (off chromium), 2015/01/09 19:52:16]

Done.

+    return;
+  }
+  SizeT Align = typeAlignInBytes(Ty);
+  SizeT EntSize = typeWidthInBytes(Ty);
+  // Assume that writing EntSize bytes at a time allows us to avoid aligning
+  // between entries.
+  assert(EntSize % Align == 0);
+  assert(EntSize == sizeof(typename ConstType::PrimType));
+  const Elf64_Xword ShFlags = SHF_ALLOC | SHF_MERGE;
+  std::string SecBuffer;
+  llvm::raw_string_ostream SecStrBuf(SecBuffer);
+  SecStrBuf << ".rodata.cst" << EntSize;
+  ELFDataSection *Section = createSection<ELFDataSection>(
+      SecStrBuf.str(), SHT_PROGBITS, ShFlags, Align, EntSize);
+  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) {
+    ConstType *Const = llvm::cast<ConstType>(C);

[Jim Stichnoth, 2015/01/09 19:23:45]

Could use "auto Const" here.

[jvoung (off chromium), 2015/01/09 19:52:16]

Done.

+    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();
+    char Buf[20];
+    assert(EntSize < llvm::array_lengthof(Buf));
+    memcpy(Buf, &Value, EntSize);

[Jim Stichnoth, 2015/01/09 19:23:45]

Can you make this safer in the NDEBUG build by using something like
std::min(EntSize, llvm::array_lengthof(Buf)) ?

[jvoung (off chromium), 2015/01/09 19:52:16]

Done.

+    Str.writeBytes(llvm::StringRef(Buf, EntSize));
+    OffsetInSection += EntSize;
+  }
+  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.

[jvoung (off chromium), 2015/01/09 02:05:50]

Wasn't sure of a better way =/

I think on ARM we'll end up with movw/movt so it wouldn't actually need const
pools for integer in that case either?

There can be jump table pools if we use that for switch lowering, but those are
not fixed-sized entry things like this has been assuming.

[Jim Stichnoth, 2015/01/09 19:23:45]

I think this is the usual way...
After I get back to https://codereview.chromium.org/460233002/ (constant
blinding/pooling), then even x86 would potentially have integer constant pools
to emit.  Probably deserves a comment here.

[jvoung (off chromium), 2015/01/09 19:52:16]

Done.

+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