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

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 87 matching lines @@
 public:
   ConstantPool() {}
   TypePool<IceType_f32, float, ConstantFloat> Floats;
   TypePool<IceType_f64, double, ConstantDouble> Doubles;
   TypePool<IceType_i1, int8_t, ConstantInteger32> Integers1;
   TypePool<IceType_i8, int8_t, ConstantInteger32> Integers8;
   TypePool<IceType_i16, int16_t, ConstantInteger32> Integers16;
   TypePool<IceType_i32, int32_t, ConstantInteger32> Integers32;
   TypePool<IceType_i64, int64_t, ConstantInteger64> Integers64;
   TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable> Relocatables;
+  TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable>
+      ExternRelocatables;
   UndefPool Undefs;
 };
 
 void GlobalContext::CodeStats::dump(const IceString &Name, Ostream &Str) {
   if (!ALLOW_DUMP)
     return;
 #define X(str, tag)                                                            \
   Str << "|" << Name << "|" str "|" << Stats[CS_##tag] << "\n";
   CODESTATS_TABLE
 #undef X
@@ skipping 297 matching lines @@
   return getConstPool()->Doubles.getOrAdd(this, ConstantDouble);
 }
 
 Constant *GlobalContext::getConstantSym(RelocOffsetT Offset,
                                         const IceString &Name,
                                         bool SuppressMangling) {
   return getConstPool()->Relocatables.getOrAdd(
       this, RelocatableTuple(Offset, Name, SuppressMangling));
 }
 
+Constant *GlobalContext::getConstantExternSym(const IceString &Name) {
+  const RelocOffsetT Offset = 0;
+  const bool SuppressMangling = true;
+  return getConstPool()->ExternRelocatables.getOrAdd(
+      this, RelocatableTuple(Offset, Name, SuppressMangling));
+}
+
 Constant *GlobalContext::getConstantUndef(Type Ty) {
   return getConstPool()->Undefs.getOrAdd(this, Ty);
 }
 
 // All locking is done by the getConstant*() target function.
 Constant *GlobalContext::getConstantZero(Type Ty) {
   switch (Ty) {
   case IceType_i1:
     return getConstantInt1(0);
   case IceType_i8:
@@ skipping 52 matching lines @@
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
+ConstantList GlobalContext::getConstantExternSyms() {
+  return getConstPool()->ExternRelocatables.getConstantPool();
+}
+
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
   if (!ALLOW_DUMP)
     return 0;
   auto Timers = getTimers();
   TimerStackIdT NewID = Timers->size();
   Timers->push_back(TimerStack(Name));
   return NewID;
 }
 
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
@@ skipping 66 matching lines @@
 void TimerMarker::pushCfg(const Cfg *Func) {
   Ctx = Func->getContext();
   Active = Func->getFocusedTiming() || Ctx->getFlags().SubzeroTimingEnabled;
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice