Track undefined sym in the symtab. Remove hack for missing relocs against undef.

src/IceELFObjectWriter.h

 //===- subzero/src/IceELFObjectWriter.h - ELF object writer -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Abstraction for a writer that is responsible for writing an ELF file.
@@ skipping 15 matching lines @@
 // Higher level ELF object writer.  Manages section information and writes
 // the final ELF object.  The object writer will write to file the code
 // and data as it is being defined (rather than keep a copy).
 // After all definitions are written out, it will finalize the bookkeeping
 // sections and write them out.  Expected usage:
 //
 // (1) writeInitialELFHeader (invoke once)
 // (2) writeDataSection  (invoke once)
 // (3) writeFunctionCode (must invoke once per function)
 // (4) writeConstantPool (must invoke once per pooled primitive type)
-// (5) writeNonUserSections (invoke once)
+// (5) setUndefinedSyms (invoke once)
+// (6) writeNonUserSections (invoke once)
 //
 // The requirement for writeDataSection to be invoked only once can
 // be relaxed if using -fdata-sections. The requirement to invoke only once
 // without -fdata-sections is so that variables that belong to each possible
 // SectionType are contiguous in the file. With -fdata-sections, each global
 // variable is in a separate section and therefore the sections will be
 // trivially contiguous.
 //
 // The motivation for requiring that writeFunctionCode happen after
 // writeDataSection: to keep the .text and .data sections contiguous in the
@@ skipping 22 matching lines @@
   // Copy the text fixups for use after all functions are written.
   // The text buffer and fixups are extracted from the Assembler object.
   void writeFunctionCode(const IceString &FuncName, bool IsInternal,
                          const Assembler *Asm);
 
   // Queries the GlobalContext for constant pools of the given type
   // and writes out read-only data sections for those constants. This also
   // fills the symbol table with labels for each constant pool entry.
   template <typename ConstType> void writeConstantPool(Type Ty);
 
+  // Populate the symbol table with a list of external/undefined symbols.
+  void setUndefinedSyms(const ConstantList &UndefSyms);
+
   // Do final layout and write out the rest of the object file.
   // Finally, patch up the initial ELF header with the final info.
   void writeNonUserSections();
 
   // Which type of ELF section a global variable initializer belongs to.
   // This is used as an array index so should start at 0 and be contiguous.
   enum SectionType { ROData = 0, Data, BSS, NumSectionTypes };
 
 private:
   GlobalContext &Ctx;
@@ skipping 66 matching lines @@
 
   // Write the ELF file header with the given information about sections.
   template <bool IsELF64>
   void writeELFHeaderInternal(Elf64_Off SectionHeaderOffset,
                               SizeT SectHeaderStrIndex, SizeT NumSections);
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEELFOBJECTWRITER_H