Subzero. Enables moar complex relocation offsets.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 26 matching lines @@
 #pragma clang diagnostic pop
 #endif // __clang__
 
 #include <algorithm> // max()
 #include <cctype>    // isdigit(), isupper()
 #include <locale>    // locale
 
 namespace std {
 template <> struct hash<Ice::RelocatableTuple> {
   size_t operator()(const Ice::RelocatableTuple &Key) const {
-    return hash<Ice::IceString>()(Key.Name) +
-           hash<Ice::RelocOffsetT>()(Key.Offset);
+    if (!Key.EmitString.empty()) {
+      return hash<Ice::IceString>()(Key.EmitString);
+    }
+    if (Key.OffsetExpr[0]->hasOffset()) {

[Jim Stichnoth, 2016/02/02 20:57:49]

Please assert(!Key.OffsetExpr.empty())
otherwise it looks like a bug.

[John, 2016/02/03 15:50:41]

Done.

+      return hash<Ice::IceString>()(Key.Name) +
+             hash<Ice::RelocOffsetT>()(Key.OffsetExpr[0]->getOffset());
+    }
+    return hash<Ice::IceString>()(Key.Name);
+    hash<std::size_t>()(Key.OffsetExpr.size());

[Jim Stichnoth, 2016/02/02 20:57:49]

remove this

[John, 2016/02/03 15:50:41]

I meant to add it to the return value.

   }
 };
 } // end of namespace std
 
 namespace Ice {
 
 namespace {
 
 // Define the key comparison function for the constant pool's unordered_map,
 // but only for key types of interest: integer types, floating point types, and
@@ skipping 719 matching lines @@
 }
 
 Constant *GlobalContext::getConstantFloat(float ConstantFloat) {
   return getConstPool()->Floats.getOrAdd(this, ConstantFloat);
 }
 
 Constant *GlobalContext::getConstantDouble(double ConstantDouble) {
   return getConstPool()->Doubles.getOrAdd(this, ConstantDouble);
 }
 
+Constant *GlobalContext::getConstantSym(const RelocOffsetArray &Offset,
+                                        const IceString &Name,
+                                        const IceString &EmitString,
+                                        bool SuppressMangling) {
+  return getConstPool()->Relocatables.getOrAdd(
+      this, RelocatableTuple(Offset, Name, EmitString, SuppressMangling));
+}
+
 Constant *GlobalContext::getConstantSym(RelocOffsetT Offset,
                                         const IceString &Name,
                                         bool SuppressMangling) {
-  return getConstPool()->Relocatables.getOrAdd(
-      this, RelocatableTuple(Offset, Name, SuppressMangling));
+  constexpr char EmptyEmitString[] = "";
+  return getConstantSym({RelocOffset::create(this, Offset)}, Name,
+                        EmptyEmitString, SuppressMangling);
 }
 
 Constant *GlobalContext::getConstantExternSym(const IceString &Name) {
   constexpr RelocOffsetT Offset = 0;
   constexpr bool SuppressMangling = true;
   return getConstPool()->ExternRelocatables.getOrAdd(
-      this, RelocatableTuple(Offset, Name, SuppressMangling));
+      this, RelocatableTuple({RelocOffset::create(this, 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:
@@ skipping 206 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice