Subzero: Fix symbol name mangling. Make flags global.

src/IceELFSection.h

 //===- subzero/src/IceELFSection.h - Model of ELF sections ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 222 matching lines @@
   /// Track additional relocations which start out relative to offset 0, but
   /// should be adjusted to be relative to BaseOff.
   void addRelocations(RelocOffsetT BaseOff, const FixupRefList &FixupRefs);
 
   /// Track a single additional relocation.
   void addRelocation(const AssemblerFixup &Fixup) { Fixups.push_back(Fixup); }
 
   size_t getSectionDataSize() const;
 
   template <bool IsELF64>
-  void writeData(const GlobalContext &Ctx, ELFStreamer &Str,
-                 const ELFSymbolTableSection *SymTab);
+  void writeData(ELFStreamer &Str, const ELFSymbolTableSection *SymTab);
 
   bool isRela() const { return Header.sh_type == SHT_RELA; }
 
 private:
   const ELFSection *RelatedSection;
   FixupList Fixups;
 };
 
 /// Models a string table. The user will build the string table by adding
 /// strings incrementally. At some point, all strings should be known and
@@ skipping 86 matching lines @@
       Str.writeAddrOrOffset<IsELF64>(SymInfo.st_value);
       Str.writeELFWord<IsELF64>(SymInfo.st_size);
       Str.write8(SymInfo.st_info);
       Str.write8(SymInfo.st_other);
       Str.writeLE16(SymInfo.st_shndx);
     }
   }
 }
 
 template <bool IsELF64>
-void ELFRelocationSection::writeData(const GlobalContext &Ctx, ELFStreamer &Str,
+void ELFRelocationSection::writeData(ELFStreamer &Str,
                                      const ELFSymbolTableSection *SymTab) {
   for (const AssemblerFixup &Fixup : Fixups) {
     const ELFSym *Symbol;
     if (Fixup.isNullSymbol()) {
       Symbol = SymTab->getNullSymbol();
     } else {
       constexpr Assembler *Asm = nullptr;
-      IceString Name = Fixup.symbol(&Ctx, Asm);
+      const IceString Name = Fixup.symbol(Asm);

[John, 2016/03/06 22:39:38]

Are you missing a reference here?

[Jim Stichnoth, 2016/03/07 00:03:10]

You mean like "const IceString &Name"?  The symbol() method constructs a new
string on the stack and returns it, so a reference won't do.

[John, 2016/03/07 16:41:08]

And that's why I would standardize into **never** returning string references.
It is weird that some methods return references while others return new objects.

Note. C++ guarantees that the returned object will be alive until the reference
to it goes out of scope -- it won't dangle!

#include <iostream>
#include <memory>

class Foo {
public:
  Foo(const Foo &) = default;
  ~Foo() { std::cerr << "Foo::~Foo()" "\n"; }
  static Foo create() { return Foo(); }

private:
  Foo() { std::cerr << "Foo::Foo()" "\n"; }
};

int main(int argc, char* argv[]) {
  const Foo &F = Foo::create();
  std::cerr << "before return." "\n";
  return 0;
}

prints:

Foo::Foo()
before return.
Foo::~Foo()

       Symbol = SymTab->findSymbol(Name);
       if (!Symbol)
         llvm::report_fatal_error(Name + ": Missing symbol mentioned in reloc");
     }
 
     if (IsELF64) {
       Elf64_Rela Rela;
       Rela.r_offset = Fixup.position();
       Rela.setSymbolAndType(Symbol->getNumber(), Fixup.kind());
       Rela.r_addend = Fixup.offset();
       Str.writeAddrOrOffset<IsELF64>(Rela.r_offset);
       Str.writeELFXword<IsELF64>(Rela.r_info);
       Str.writeELFXword<IsELF64>(Rela.r_addend);
     } else {
       Elf32_Rel Rel;
       Rel.r_offset = Fixup.position();
       Rel.setSymbolAndType(Symbol->getNumber(), Fixup.kind());
       Str.writeAddrOrOffset<IsELF64>(Rel.r_offset);
       Str.writeELFWord<IsELF64>(Rel.r_info);
     }
   }
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFSECTION_H