Wrok around MSVC bug 1085387.

lib/Transforms/NaCl/FlattenGlobals.cpp

 //===- FlattenGlobals.cpp - Flatten global variable initializers-----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass converts initializers for global variables into a
@@ skipping 64 matching lines @@
 
   // Define map from a relocation, appearing in the flattened global variable
   // initializers, to it's corresponding use handle.
   typedef DenseMap<Constant*, RelocUserType*> RelocMapType;
 
   // Define the list to hold the list of global variables being flattened.
   struct FlattenedGlobal;
   typedef std::vector<FlattenedGlobal*> FlattenedGlobalsVectorType;
 
   // Returns the corresponding relocation, for the given user handle.
-  static Constant *getRelocUse(RelocUserType *RelocUser) {
+  Constant *getRelocUseConstant(RelocUserType *RelocUser) {
     return cast<Constant>(RelocUser->getReturnValue());
   }
 
   // The state associated with flattening globals of a module.
   struct FlattenGlobalsState {
     /// The module being flattened.
     Module &M;
     /// The data layout to be used.
     DataLayout DL;
     /// The relocations (within the original global variable initializers)
@@ skipping 72 matching lines @@
     uint8_t *BufEnd;
 
     // 2) an array of relocations.
     class Reloc {
     private:
       unsigned RelOffset;  // Offset at which the relocation is to be applied.
       RelocUserType *RelocUser;
    public:
 
       unsigned getRelOffset() const { return RelOffset; }
-      Constant *getRelocUse() const { return ::getRelocUse(RelocUser); }
+      Constant *getRelocUse() const { return ::getRelocUseConstant(RelocUser); }
       Reloc(FlattenGlobalsState &State, unsigned RelOffset, Constant *NewVal)
-          : RelOffset(RelOffset),
-            RelocUser(State.getRelocUserHandle(NewVal)) {}
+          : RelOffset(RelOffset), RelocUser(State.getRelocUserHandle(NewVal)) {}
 
       explicit Reloc(const Reloc &R)
           : RelOffset(R.RelOffset), RelocUser(R.RelocUser) {}
 
       void operator=(const Reloc &R) {
         RelOffset = R.RelOffset;
         RelocUser = R.RelocUser;
       }
     };
     typedef SmallVector<Reloc, 10> RelocArray;
@@ skipping 313 matching lines @@
 void FlattenGlobalsState::removeDeadInitializerConstants() {
   // Detach original initializers.
   for (FlattenedGlobalsVectorType::iterator
            I = FlattenedGlobalsVector.begin(), E = FlattenedGlobalsVector.end();
        I != E; ++I) {
     (*I)->removeOriginalInitializer();
   }
   // Do cleanup of old initializers.
   for (RelocMapType::iterator I = RelocMap.begin(), E = RelocMap.end();
        I != E; ++I) {
-    getRelocUse(I->second)->removeDeadConstantUsers();
+    getRelocUseConstant(I->second)->removeDeadConstantUsers();
   }
 
 }
 
 void FlattenGlobalsState::replaceGlobalsWithFlattenedGlobals() {
   for (FlattenedGlobalsVectorType::iterator
            I = FlattenedGlobalsVector.begin(), E = FlattenedGlobalsVector.end();
        I != E; ++I) {
     (*I)->replaceGlobalWithFlattenedGlobal();
   }
@@ skipping 12 matching lines @@
   State.flattenGlobalsWithInitializers();
   State.removeDeadInitializerConstants();
   State.replaceGlobalsWithFlattenedGlobals();
   State.installFlattenedGlobalInitializers();
   return State.Modified;
 }
 
 ModulePass *llvm::createFlattenGlobalsPass() {
   return new FlattenGlobals();
 }