Subzero: Use a common RelocOffsetType / RelocOffsetT.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the representation of function declarations,
@@ skipping 198 matching lines @@
     void dump(GlobalContext *Ctx, Ostream &Stream) const final;
     static bool classof(const Initializer *Z) {
       return Z->getKind() == ZeroInitializerKind;
     }
 
   private:
     // The number of bytes to be zero initialized.
     SizeT Size;
   };
 
-  // Relocation address offsets must be 32 bit values.
-  typedef int32_t RelocOffsetType;
-  static const SizeT RelocAddrSize = 4;
-
   /// Defines the relocation value of another global declaration.
   class RelocInitializer : public Initializer {
     RelocInitializer(const RelocInitializer &) = delete;
     RelocInitializer &operator=(const RelocInitializer &) = delete;
 
   public:
     RelocInitializer(const GlobalDeclaration *Declaration,
-                     RelocOffsetType Offset)
+                     RelocOffsetT Offset)
         : Initializer(RelocInitializerKind), Declaration(Declaration),
           Offset(Offset) {}
     ~RelocInitializer() override {}
-    RelocOffsetType getOffset() const { return Offset; }
+    RelocOffsetT getOffset() const { return Offset; }
     const GlobalDeclaration *getDeclaration() const { return Declaration; }
-    SizeT getNumBytes() const final { return RelocAddrSize; }
+    SizeT getNumBytes() const final { return sizeof(RelocOffsetT); }

[jvoung (off chromium), 2014/11/04 19:21:55]

or I can keep the constant, and put it alongside RelocOffsetT

[Karl, 2014/11/04 20:15:00]

I would prefer the constant, in case we change the type of SizeT. The size must
always be 4.

[Jim Stichnoth, 2014/11/04 20:18:05]

But RelocOffsetT (as well as RelocOffsetType) is defined at int32_t, which will
always be 4.

[Karl, 2014/11/04 23:01:21]

I have no problem with this, so long as a comment is added to RelocOffsetType
(if not already there) that it must be 4 bytes long.

     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:
     // The global declaration used in the relocation.
     const GlobalDeclaration *Declaration;
     // The offset to add to the relocation.
-    const RelocOffsetType Offset;
+    const RelocOffsetT Offset;
   };
 
   /// Models the list of initializers.
   typedef std::vector<Initializer *> InitializerListType;
 
   static VariableDeclaration *create(GlobalContext *Ctx);
   ~VariableDeclaration() final;
 
   const InitializerListType &getInitializers() const { return Initializers; }
   bool getIsConstant() const { return IsConstant; }
@@ skipping 62 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