Subzero. Adds symbolic references to RelocInitializer.

src/IceGlobalInits.h

 //===- subzero/src/IceGlobalInits.h - Global declarations -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the representation of function declarations, global variable
 /// declarations, and the corresponding variable initializers in Subzero.
 ///
 /// Global variable initializers are represented as a sequence of simple
 /// initializers.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALINITS_H
 #define SUBZERO_SRC_ICEGLOBALINITS_H
 
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceIntrinsics.h"
+#include "IceOperand.h"
 #include "IceTypes.h"
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #pragma clang diagnostic ignored "-Wredundant-move"
 #endif // __clang__
 
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" // for NaClBitcodeRecord.
 #include "llvm/IR/CallingConv.h"
@@ skipping 276 matching lines @@
     SizeT Size;
   };
 
   /// Defines the relocation value of another global declaration.
   class RelocInitializer : public Initializer {
     RelocInitializer(const RelocInitializer &) = delete;
     RelocInitializer &operator=(const RelocInitializer &) = delete;
 
   public:
     static std::unique_ptr<RelocInitializer>
-    create(const GlobalDeclaration *Declaration, RelocOffsetT Offset) {
-      return makeUnique<RelocInitializer>(Declaration, Offset);
+    create(const GlobalDeclaration *Declaration,
+           const RelocOffsetArray &OffsetExpr) {
+      return makeUnique<RelocInitializer>(Declaration, OffsetExpr);
     }
 
-    RelocOffsetT getOffset() const { return Offset; }
+    RelocOffsetT getOffset() const {
+      RelocOffsetT Offset = 0;
+      for (const auto *RelocOffset : OffsetExpr) {
+        Offset += RelocOffset->getOffset();
+      }
+      return Offset;
+    }
+
     const GlobalDeclaration *getDeclaration() const { return Declaration; }
     SizeT getNumBytes() const final { return RelocAddrSize; }
     void dump(GlobalContext *Ctx, Ostream &Stream) const final;
     void dumpType(Ostream &Stream) const final;
     static bool classof(const Initializer *R) {
       return R->getKind() == RelocInitializerKind;
     }
 
   private:
     ENABLE_MAKE_UNIQUE;
 
-    RelocInitializer(const GlobalDeclaration *Declaration, RelocOffsetT Offset)
-        : Initializer(RelocInitializerKind), Declaration(Declaration),
-          Offset(Offset) {} // The global declaration used in the relocation.
+    RelocInitializer(const GlobalDeclaration *Declaration,
+                     const RelocOffsetArray &OffsetExpr)
+        : Initializer(RelocInitializerKind),
+          Declaration(Declaration), // The global declaration used in the reloc.
+          OffsetExpr(OffsetExpr) {}
 
     const GlobalDeclaration *Declaration;
     /// The offset to add to the relocation.
-    const RelocOffsetT Offset;
+    const RelocOffsetArray OffsetExpr;
   };
 
   /// Models the list of initializers.
   using InitializerListType = std::vector<std::unique_ptr<Initializer>>;
 
   static VariableDeclaration *create(GlobalContext *Context) {
     return new (Context->allocate<VariableDeclaration>()) VariableDeclaration();
   }
 
   const InitializerListType &getInitializers() const { return *Initializers; }
@@ skipping 77 matching lines @@
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALINITS_H