Function Layout, Global Variable Layout and Pooled Constants Layout Reordering

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 372 matching lines @@
       if (ST == ROData)
         Section->appendZeros(Str, SymbolSize);
       else
         Section->setSize(Section->getCurrentSize() + SymbolSize);
     } else {
       assert(ST != BSS);
       for (const std::unique_ptr<VariableDeclaration::Initializer> &Init :
            Var->getInitializers()) {
         switch (Init->getKind()) {
         case VariableDeclaration::Initializer::DataInitializerKind: {
-          const auto Data = llvm::cast<VariableDeclaration::DataInitializer>(
-                                Init.get())->getContents();
+          const auto Data =

[John, 2015/06/24 00:24:00]

please change this to

const auto& Data,

or this will copy contents.

[qining, 2015/06/24 01:20:40]

Done.

+              llvm::cast<VariableDeclaration::DataInitializer>(Init.get())
+                  ->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.get());
           AssemblerFixup NewFixup;
@@ skipping 95 matching lines @@
   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));
 
+  // If the -reorder-pooled-constant option is set to true, we should shuffle
+  // the constants before we emit them.
+  if (Ctx.getFlags().shouldReorderPooledConstants())
+    RandomShuffle(Pool.begin(), Pool.end(), [this](uint64_t N) {

[John, 2015/06/24 00:24:00]

Can you capture [Ctx] instead of [this]?

[qining, 2015/06/24 01:20:40]

Done. But it seems I can't capture Ctx or its reference directly as it is a
member of this class. My workaround is declaring a pointer to Ctx and capture
the pointer instead. But actually I'm not sure this is better than capturing
this.

[John, 2015/06/24 08:15:54]

Oh, I was genuinely asking whether capturing [Ctx] would work. I wasn't sure. My
hint that this should not work in C++11 is that capturing [Ctx] actually mean
capturing [this->Ctx], which is not valid.

+      return (uint32_t)Ctx.getRNG().next(N);
+    });
+
   // Write the data.
   for (Constant *C : Pool) {
     if (!C->getShouldBePooled())
       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,
@@ skipping 97 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice