Subzero: Use a common RelocOffsetType / RelocOffsetT.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the LLVM to ICE converter.
@@ skipping 641 matching lines @@
   void convertGlobalsToIce(
       Module *Mod,
       Ice::Translator::VariableDeclarationListType &VariableDeclarations);
 
 private:
   // Adds the Initializer to the list of initializers for the Global
   // variable declaraation.
   void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer) {
     const bool HasOffset = false;
-    const Ice::VariableDeclaration::RelocOffsetType Offset = 0;
+    const Ice::RelocOffsetT Offset = 0;
     addGlobalInitializer(Global, Initializer, HasOffset, Offset);
   }
 
   // Adds Initializer to the list of initializers for Global variable
   // declaration.  HasOffset is true only if Initializer is a
   // relocation initializer and Offset should be added to the
   // relocation.
   void addGlobalInitializer(Ice::VariableDeclaration &Global,
                             const Constant *Initializer, bool HasOffset,
-                            Ice::VariableDeclaration::RelocOffsetType Offset);
+                            Ice::RelocOffsetT Offset);
 
   // Converts the given constant C to the corresponding integer
   // literal it contains.
-  Ice::VariableDeclaration::RelocOffsetType
-  getIntegerLiteralConstant(const Value *C) {
+  Ice::RelocOffsetT getIntegerLiteralConstant(const Value *C) {
     const auto CI = dyn_cast<ConstantInt>(C);
     if (CI && CI->getType()->isIntegerTy(32))
       return CI->getSExtValue();
 
     std::string Buffer;
     raw_string_ostream StrBuf(Buffer);
     StrBuf << "Constant not i32 literal: " << *C;
     report_fatal_error(StrBuf.str());
     return 0;
   }
@@ skipping 40 matching lines @@
         }
       }
     } else {
       addGlobalInitializer(*VarDecl, Initializer);
     }
   }
 }
 
 void LLVM2ICEGlobalsConverter::addGlobalInitializer(
     Ice::VariableDeclaration &Global, const Constant *Initializer,
-    bool HasOffset, Ice::VariableDeclaration::RelocOffsetType Offset) {
+    bool HasOffset, Ice::RelocOffsetT Offset) {
   (void)HasOffset;
   assert(HasOffset || Offset == 0);
 
   if (const auto CDA = dyn_cast<ConstantDataArray>(Initializer)) {
     assert(!HasOffset && isa<IntegerType>(CDA->getElementType()) &&
            (cast<IntegerType>(CDA->getElementType())->getBitWidth() == 8));
     Global.addInitializer(new Ice::VariableDeclaration::DataInitializer(
         CDA->getRawDataValues().data(), CDA->getNumElements()));
     return;
   }
@@ skipping 149 matching lines @@
     Cfg *Fcn = FunctionConverter.convertFunction(&I);
     translateFcn(Fcn);
     if (Ctx->getFlags().TimeEachFunction)
       Ctx->popTimer(TimerID, StackID);
   }
 
   emitConstants();
 }
 
 } // end of namespace Ice