Change class' public PassInfo variables to by initialized with the

address of the PassInfo directly instead of calling getPassInfo.
This eliminates a bunch of dynamic initializations of static data.

Also, fold RegisterPassBase into PassInfo, make a bunch of its
data members const, and rearrange some code to initialize data
members in constructors instead of using setter member functions.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51022 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/CodeGen/Passes.h

@@ -40,18 +40,18 @@ namespace llvm {
 
   /// MachineLoopInfo pass - This pass is a loop analysis pass.
   /// 
-  extern const PassInfo *MachineLoopInfoID;
+  extern const PassInfo *const MachineLoopInfoID;
 
   /// MachineDominators pass - This pass is a machine dominators analysis pass.
   /// 
-  extern const PassInfo *MachineDominatorsID;
+  extern const PassInfo *const MachineDominatorsID;
 
   /// PHIElimination pass - This pass eliminates machine instruction PHI nodes
   /// by inserting copy instructions.  This destroys SSA information, but is the
   /// desired input for some register allocators.  This pass is "required" by
   /// these register allocator like this: AU.addRequiredID(PHIEliminationID);
   ///
-  extern const PassInfo *PHIEliminationID;
+  extern const PassInfo *const PHIEliminationID;
   
   /// StrongPHIElimination pass - This pass eliminates machine instruction PHI
   /// nodes by inserting copy instructions.  This destroys SSA information, but
@@ -59,17 +59,17 @@ namespace llvm {
   /// "required" by these register allocator like this:
   ///    AU.addRequiredID(PHIEliminationID);
   ///  This pass is still in development
-  extern const PassInfo *StrongPHIEliminationID;
+  extern const PassInfo *const StrongPHIEliminationID;
 
   /// SimpleRegisterCoalescing pass.  Aggressively coalesces every register
   /// copy it can.
   ///
-  extern const PassInfo *SimpleRegisterCoalescingID;
+  extern const PassInfo *const SimpleRegisterCoalescingID;
 
   /// TwoAddressInstruction pass - This pass reduces two-address instructions to
   /// use two operands. This destroys SSA information but it is desired by
   /// register allocators.
-  extern const PassInfo *TwoAddressInstructionPassID;
+  extern const PassInfo *const TwoAddressInstructionPassID;
 
   /// Creates a register allocator as the user specified on the command line.
   ///

include/llvm/PassSupport.h

@@ -34,30 +34,43 @@ class TargetMachine;
 /// template, defined below.
 ///
 class PassInfo {
-  const char           *PassName;      // Nice name for Pass
-  const char           *PassArgument;  // Command Line argument to run this pass
-  intptr_t             PassID;      
-  bool IsCFGOnlyPass;                  // Pass only looks at the CFG.
-  bool IsAnalysis;                     // True if an analysis pass.
-  bool IsAnalysisGroup;                // True if an analysis group.
+public:
+  typedef Pass* (*NormalCtor_t)();
+
+private:
+  const char      *const PassName;     // Nice name for Pass
+  const char      *const PassArgument; // Command Line argument to run this pass
+  const intptr_t  PassID;      
+  const bool IsCFGOnlyPass;            // Pass only looks at the CFG.
+  const bool IsAnalysis;               // True if an analysis pass.
+  const bool IsAnalysisGroup;          // True if an analysis group.
   std::vector<const PassInfo*> ItfImpl;// Interfaces implemented by this pass
 
-  Pass *(*NormalCtor)();
+  NormalCtor_t NormalCtor;
 
 public:
   /// PassInfo ctor - Do not call this directly, this should only be invoked
   /// through RegisterPass.
   PassInfo(const char *name, const char *arg, intptr_t pi,
-           Pass *(*normal)() = 0, bool isCFGOnly = false, bool isAnalysis = false)
+           NormalCtor_t normal = 0,
+           bool isCFGOnly = false, bool isAnalysis = false)
     : PassName(name), PassArgument(arg), PassID(pi), 
       IsCFGOnlyPass(isCFGOnly), 
       IsAnalysis(isAnalysis), IsAnalysisGroup(false), NormalCtor(normal) {
+    registerPass();
+  }
+  /// PassInfo ctor - Do not call this directly, this should only be invoked
+  /// through RegisterPass. This version is for use by analysis groups; it
+  /// does not auto-register the pass.
+  PassInfo(const char *name, intptr_t pi)
+    : PassName(name), PassArgument(""), PassID(pi), 
+      IsCFGOnlyPass(false), 
+      IsAnalysis(false), IsAnalysisGroup(true), NormalCtor(0) {
   }
 
   /// getPassName - Return the friendly name for the pass, never returns null
   ///
   const char *getPassName() const { return PassName; }
-  void setPassName(const char *Name) { PassName = Name; }
 
   /// getPassArgument - Return the command line option that may be passed to
   /// 'opt' that will cause this pass to be run.  This will return null if there
@@ -74,7 +87,6 @@ public:
   ///
   bool isAnalysisGroup() const { return IsAnalysisGroup; }
   bool isAnalysis() const { return IsAnalysis; }
-  void SetIsAnalysisGroup() { IsAnalysisGroup = true; }
 
   /// isCFGOnlyPass - return true if this pass only looks at the CFG for the
   /// function.
@@ -84,10 +96,10 @@ public:
   /// an instance of the pass and returns it.  This pointer may be null if there
   /// is no default constructor for the pass.
   ///
-  Pass *(*getNormalCtor() const)() {
+  NormalCtor_t getNormalCtor() const {
     return NormalCtor;
   }
-  void setNormalCtor(Pass *(*Ctor)()) {
+  void setNormalCtor(NormalCtor_t Ctor) {
     NormalCtor = Ctor;
   }
 
@@ -114,9 +126,23 @@ public:
   const std::vector<const PassInfo*> &getInterfacesImplemented() const {
     return ItfImpl;
   }
+
+  /// getPassInfo - Deprecated API compaatibility function. This function
+  /// just returns 'this'.
+  ///
+  const PassInfo *getPassInfo() const {
+    return this;
+  }
+
+protected:
+  void registerPass();
+  void unregisterPass();
 };
 
 
+template<typename PassName>
+Pass *callDefaultCtor() { return new PassName(); }
+
 //===---------------------------------------------------------------------------
 /// RegisterPass<t> template - This template class is used to notify the system
 /// that a Pass is available for use, and registers it into the internal
@@ -134,44 +160,15 @@ public:
 ///
 /// static RegisterPass<PassClassName> tmp("passopt", "My Name");
 ///
-struct RegisterPassBase {
-  /// getPassInfo - Get the pass info for the registered class...
-  ///
-  const PassInfo *getPassInfo() const { return &PIObj; }
-
-  typedef Pass* (*NormalCtor_t)();
-  
-  RegisterPassBase(const char *Name, const char *Arg, intptr_t TI,
-                   NormalCtor_t NormalCtor = 0, bool CFGOnly = false, 
-                   bool IsAnalysis = false)
-    : PIObj(Name, Arg, TI, NormalCtor, CFGOnly, IsAnalysis) {
-    registerPass();
-  }
-  explicit RegisterPassBase(intptr_t TI)
-    : PIObj("", "", TI) {
-    // This ctor may only be used for analysis groups: it does not auto-register
-    // the pass.
-    PIObj.SetIsAnalysisGroup();
-  }
-
-protected:
-  PassInfo PIObj;       // The PassInfo object for this pass
-  void registerPass();
-  void unregisterPass();
-};
-
-template<typename PassName>
-Pass *callDefaultCtor() { return new PassName(); }
-
-template<typename PassName>
-struct RegisterPass : public RegisterPassBase {
+template<typename passName>
+struct RegisterPass : public PassInfo {
 
   // Register Pass using default constructor...
   RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false,
                bool IsAnalysis = false)
-    : RegisterPassBase(Name, PassArg, intptr_t(&PassName::ID),
-                      RegisterPassBase::NormalCtor_t(callDefaultCtor<PassName>),
-                      CFGOnly, IsAnalysis) {
+    : PassInfo(Name, PassArg, intptr_t(&passName::ID),
+               PassInfo::NormalCtor_t(callDefaultCtor<passName>),
+               CFGOnly, IsAnalysis) {
   }
 };
 
@@ -195,27 +192,27 @@ struct RegisterPass : public RegisterPassBase {
 /// second template argument).  The interface should be registered to associate
 /// a nice name with the interface.
 ///
-class RegisterAGBase : public RegisterPassBase {
+class RegisterAGBase : public PassInfo {
   PassInfo *InterfaceInfo;
   const PassInfo *ImplementationInfo;
   bool isDefaultImplementation;
 protected:
-  explicit RegisterAGBase(intptr_t InterfaceID,
+  explicit RegisterAGBase(const char *Name,
+                          intptr_t InterfaceID,
                           intptr_t PassID = 0,
                           bool isDefault = false);
-  void setGroupName(const char *Name);
 };
 
 template<typename Interface, bool Default = false>
 struct RegisterAnalysisGroup : public RegisterAGBase {
-  explicit RegisterAnalysisGroup(RegisterPassBase &RPB)
-    : RegisterAGBase(intptr_t(&Interface::ID), RPB.getPassInfo()->getTypeInfo(),
+  explicit RegisterAnalysisGroup(PassInfo &RPB)
+    : RegisterAGBase(RPB.getPassName(),
+                     intptr_t(&Interface::ID), RPB.getTypeInfo(),
                      Default) {
   }
 
   explicit RegisterAnalysisGroup(const char *Name)
-    : RegisterAGBase(intptr_t(&Interface::ID)) {
-    setGroupName(Name);
+    : RegisterAGBase(Name, intptr_t(&Interface::ID)) {
   }
 };
 

include/llvm/Transforms/Scalar.h

@@ -162,7 +162,7 @@ LoopPass *createLoopIndexSplitPass();
 //   ret int %Y
 //
 FunctionPass *createPromoteMemoryToRegisterPass();
-extern const PassInfo *PromoteMemoryToRegisterID;
+extern const PassInfo *const PromoteMemoryToRegisterID;
 
 //===----------------------------------------------------------------------===//
 //
@@ -171,7 +171,7 @@ extern const PassInfo *PromoteMemoryToRegisterID;
 // hacking easier.
 //
 FunctionPass *createDemoteRegisterToMemoryPass();
-extern const PassInfo *DemoteRegisterToMemoryID;
+extern const PassInfo *const DemoteRegisterToMemoryID;
 
 //===----------------------------------------------------------------------===//
 //
@@ -223,7 +223,7 @@ FunctionPass *createCFGSimplificationPass();
 // (set, immediate dominators, tree, and frontier) information.
 //
 FunctionPass *createBreakCriticalEdgesPass();
-extern const PassInfo *BreakCriticalEdgesID;
+extern const PassInfo *const BreakCriticalEdgesID;
 
 //===----------------------------------------------------------------------===//
 //
@@ -234,7 +234,7 @@ extern const PassInfo *BreakCriticalEdgesID;
 //   AU.addRequiredID(LoopSimplifyID);
 //
 FunctionPass *createLoopSimplifyPass();
-extern const PassInfo *LoopSimplifyID;
+extern const PassInfo *const LoopSimplifyID;
 
 //===----------------------------------------------------------------------===//
 //
@@ -244,7 +244,7 @@ extern const PassInfo *LoopSimplifyID;
 //   AU.addRequiredID(LowerAllocationsID);
 //
 Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false);
-extern const PassInfo *LowerAllocationsID;
+extern const PassInfo *const LowerAllocationsID;
 
 //===----------------------------------------------------------------------===//
 //
@@ -259,7 +259,7 @@ FunctionPass *createTailCallEliminationPass();
 // chained binary branch instructions.
 //
 FunctionPass *createLowerSwitchPass();
-extern const PassInfo *LowerSwitchID;
+extern const PassInfo *const LowerSwitchID;
 
 //===----------------------------------------------------------------------===//
 //
@@ -272,7 +272,7 @@ extern const PassInfo *LowerSwitchID;
 // lowering pass.
 //
 FunctionPass *createLowerInvokePass(const TargetLowering *TLI = NULL);
-extern const PassInfo *LowerInvokePassID;
+extern const PassInfo *const LowerInvokePassID;
 
 //===----------------------------------------------------------------------===//
 //
@@ -287,7 +287,7 @@ FunctionPass *createBlockPlacementPass();
 // optimizations.
 //
 LoopPass *createLCSSAPass();
-extern const PassInfo *LCSSAID;
+extern const PassInfo *const LCSSAID;
 
 //===----------------------------------------------------------------------===//
 //

lib/CodeGen/MachineDominators.cpp

@@ -25,4 +25,4 @@ char MachineDominatorTree::ID = 0;
 static RegisterPass<MachineDominatorTree>
 E("machinedomtree", "MachineDominator Tree Construction", true);
 
-const PassInfo *llvm::MachineDominatorsID = E.getPassInfo();
+const PassInfo *const llvm::MachineDominatorsID = &E;

lib/CodeGen/MachineLoopInfo.cpp

@@ -26,7 +26,7 @@ char MachineLoopInfo::ID = 0;
 static RegisterPass<MachineLoopInfo>
 X("machine-loops", "Machine Natural Loop Construction", true);
 
-const PassInfo *llvm::MachineLoopInfoID = X.getPassInfo();
+const PassInfo *const llvm::MachineLoopInfoID = &X;
 
 bool MachineLoopInfo::runOnMachineFunction(MachineFunction &) {
   releaseMemory();

lib/CodeGen/PHIElimination.cpp

@@ -79,7 +79,7 @@ char PNE::ID = 0;
 static RegisterPass<PNE>
 X("phi-node-elimination", "Eliminate PHI nodes for register allocation");
 
-const PassInfo *llvm::PHIEliminationID = X.getPassInfo();
+const PassInfo *const llvm::PHIEliminationID = &X;
 
 bool PNE::runOnMachineFunction(MachineFunction &Fn) {
   MRI = &Fn.getRegInfo();

lib/CodeGen/SimpleRegisterCoalescing.cpp

@@ -58,7 +58,7 @@ X("simple-register-coalescing", "Simple Register Coalescing");
 // Declare that we implement the RegisterCoalescer interface
 static RegisterAnalysisGroup<RegisterCoalescer, true/*The Default*/> V(X);
 
-const PassInfo *llvm::SimpleRegisterCoalescingID = X.getPassInfo();
+const PassInfo *const llvm::SimpleRegisterCoalescingID = &X;
 
 void SimpleRegisterCoalescing::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addPreserved<LiveIntervals>();

lib/CodeGen/StrongPHIElimination.cpp

@@ -147,7 +147,7 @@ static RegisterPass<StrongPHIElimination>
 X("strong-phi-node-elimination",
   "Eliminate PHI nodes for register allocation, intelligently");
 
-const PassInfo *llvm::StrongPHIEliminationID = X.getPassInfo();
+const PassInfo *const llvm::StrongPHIEliminationID = &X;
 
 /// computeDFS - Computes the DFS-in and DFS-out numbers of the dominator tree
 /// of the given MachineFunction.  These numbers are then used in other parts

lib/CodeGen/TwoAddressInstructionPass.cpp

@@ -81,7 +81,7 @@ char TwoAddressInstructionPass::ID = 0;
 static RegisterPass<TwoAddressInstructionPass>
 X("twoaddressinstruction", "Two-Address instruction pass");
 
-const PassInfo *llvm::TwoAddressInstructionPassID = X.getPassInfo();
+const PassInfo *const llvm::TwoAddressInstructionPassID = &X;
 
 /// Sink3AddrInstruction - A two-address instruction has been converted to a
 /// three-address instruction to avoid clobbering a register. Try to sink it

lib/Transforms/Scalar/Reg2Mem.cpp

@@ -119,7 +119,7 @@ X("reg2mem", "Demote all values to stack slots");
 
 // createDemoteRegisterToMemory - Provide an entry point to create this pass.
 //
-const PassInfo *llvm::DemoteRegisterToMemoryID = X.getPassInfo();
+const PassInfo *const llvm::DemoteRegisterToMemoryID = &X;
 FunctionPass *llvm::createDemoteRegisterToMemoryPass() {
   return new RegToMem();
 }

lib/Transforms/Utils/BreakCriticalEdges.cpp

@@ -55,7 +55,7 @@ static RegisterPass<BreakCriticalEdges>
 X("break-crit-edges", "Break critical edges in CFG");
 
 // Publically exposed interface to pass...
-const PassInfo *llvm::BreakCriticalEdgesID = X.getPassInfo();
+const PassInfo *const llvm::BreakCriticalEdgesID = &X;
 FunctionPass *llvm::createBreakCriticalEdgesPass() {
   return new BreakCriticalEdges();
 }

lib/Transforms/Utils/LCSSA.cpp

@@ -100,7 +100,7 @@ char LCSSA::ID = 0;
 static RegisterPass<LCSSA> X("lcssa", "Loop-Closed SSA Form Pass");
 
 LoopPass *llvm::createLCSSAPass() { return new LCSSA(); }
-const PassInfo *llvm::LCSSAID = X.getPassInfo();
+const PassInfo *const llvm::LCSSAID = &X;
 
 /// runOnFunction - Process all loops in the function, inner-most out.
 bool LCSSA::runOnLoop(Loop *L, LPPassManager &LPM) {

lib/Transforms/Utils/LoopSimplify.cpp

@@ -102,7 +102,7 @@ static RegisterPass<LoopSimplify>
 X("loopsimplify", "Canonicalize natural loops", true);
 
 // Publically exposed interface to pass...
-const PassInfo *llvm::LoopSimplifyID = X.getPassInfo();
+const PassInfo *const llvm::LoopSimplifyID = &X;
 FunctionPass *llvm::createLoopSimplifyPass() { return new LoopSimplify(); }
 
 /// runOnFunction - Run down all loops in the CFG (recursively, but we could do

lib/Transforms/Utils/LowerAllocations.cpp

@@ -73,7 +73,7 @@ static RegisterPass<LowerAllocations>
 X("lowerallocs", "Lower allocations from instructions to calls");
 
 // Publically exposed interface to pass...
-const PassInfo *llvm::LowerAllocationsID = X.getPassInfo();
+const PassInfo *const llvm::LowerAllocationsID = &X;
 // createLowerAllocationsPass - Interface to this file...
 Pass *llvm::createLowerAllocationsPass(bool LowerMallocArgToInteger) {
   return new LowerAllocations(LowerMallocArgToInteger);

lib/Transforms/Utils/LowerInvoke.cpp

@@ -104,7 +104,7 @@ char LowerInvoke::ID = 0;
 static RegisterPass<LowerInvoke>
 X("lowerinvoke", "Lower invoke and unwind, for unwindless code generators");
 
-const PassInfo *llvm::LowerInvokePassID = X.getPassInfo();
+const PassInfo *const llvm::LowerInvokePassID = &X;
 
 // Public Interface To the LowerInvoke pass.
 FunctionPass *llvm::createLowerInvokePass(const TargetLowering *TLI) { 

lib/Transforms/Utils/LowerSwitch.cpp

@@ -84,7 +84,7 @@ static RegisterPass<LowerSwitch>
 X("lowerswitch", "Lower SwitchInst's to branches");
 
 // Publically exposed interface to pass...
-const PassInfo *llvm::LowerSwitchID = X.getPassInfo();
+const PassInfo *const llvm::LowerSwitchID = &X;
 // createLowerSwitchPass - Interface to this file...
 FunctionPass *llvm::createLowerSwitchPass() {
   return new LowerSwitch();

lib/Transforms/Utils/Mem2Reg.cpp

@@ -84,7 +84,7 @@ bool PromotePass::runOnFunction(Function &F) {
 }
 
 // Publically exposed interface to pass...
-const PassInfo *llvm::PromoteMemoryToRegisterID = X.getPassInfo();
+const PassInfo *const llvm::PromoteMemoryToRegisterID = &X;
 // createPromoteMemoryToRegister - Provide an entry point to create this pass.
 //
 FunctionPass *llvm::createPromoteMemoryToRegisterPass() {

lib/VMCore/Pass.cpp

@@ -122,7 +122,8 @@ namespace {
 class PassRegistrar {
   /// PassInfoMap - Keep track of the passinfo object for each registered llvm
   /// pass.
-  std::map<intptr_t, PassInfo*> PassInfoMap;
+  typedef std::map<intptr_t, const PassInfo*> MapType;
+  MapType PassInfoMap;
   
   /// AnalysisGroupInfo - Keep track of information for each analysis group.
   struct AnalysisGroupInfo {
@@ -137,19 +138,18 @@ class PassRegistrar {
 public:
   
   const PassInfo *GetPassInfo(intptr_t TI) const {
-    std::map<intptr_t, PassInfo*>::const_iterator I = PassInfoMap.find(TI);
+    MapType::const_iterator I = PassInfoMap.find(TI);
     return I != PassInfoMap.end() ? I->second : 0;
   }
   
-  void RegisterPass(PassInfo &PI) {
+  void RegisterPass(const PassInfo &PI) {
     bool Inserted =
       PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second;
     assert(Inserted && "Pass registered multiple times!");
   }
   
-  void UnregisterPass(PassInfo &PI) {
-    std::map<intptr_t, PassInfo*>::iterator I =
-      PassInfoMap.find(PI.getTypeInfo());
+  void UnregisterPass(const PassInfo &PI) {
+    MapType::iterator I = PassInfoMap.find(PI.getTypeInfo());
     assert(I != PassInfoMap.end() && "Pass registered but not in map!");
     
     // Remove pass from the map.
@@ -157,7 +157,7 @@ public:
   }
   
   void EnumerateWith(PassRegistrationListener *L) {
-    for (std::map<intptr_t, PassInfo*>::const_iterator I = PassInfoMap.begin(),
+    for (MapType::const_iterator I = PassInfoMap.begin(),
          E = PassInfoMap.end(); I != E; ++I)
       L->passEnumerate(I->second);
   }
@@ -206,18 +206,18 @@ const PassInfo *Pass::lookupPassInfo(intptr_t TI) {
   return getPassRegistrar()->GetPassInfo(TI);
 }
 
-void RegisterPassBase::registerPass() {
-  getPassRegistrar()->RegisterPass(PIObj);
+void PassInfo::registerPass() {
+  getPassRegistrar()->RegisterPass(*this);
 
   // Notify any listeners.
   if (Listeners)
     for (std::vector<PassRegistrationListener*>::iterator
            I = Listeners->begin(), E = Listeners->end(); I != E; ++I)
-      (*I)->passRegistered(&PIObj);
+      (*I)->passRegistered(this);
 }
 
-void RegisterPassBase::unregisterPass() {
-  getPassRegistrar()->UnregisterPass(PIObj);
+void PassInfo::unregisterPass() {
+  getPassRegistrar()->UnregisterPass(*this);
 }
 
 //===----------------------------------------------------------------------===//
@@ -226,18 +226,18 @@ void RegisterPassBase::unregisterPass() {
 
 // RegisterAGBase implementation
 //
-RegisterAGBase::RegisterAGBase(intptr_t InterfaceID,
+RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID,
                                intptr_t PassID, bool isDefault)
-  : RegisterPassBase(InterfaceID),
+  : PassInfo(Name, InterfaceID),
     ImplementationInfo(0), isDefaultImplementation(isDefault) {
 
   InterfaceInfo = const_cast<PassInfo*>(Pass::lookupPassInfo(InterfaceID));
   if (InterfaceInfo == 0) {
     // First reference to Interface, register it now.
     registerPass();
-    InterfaceInfo = &PIObj;
+    InterfaceInfo = this;
   }
-  assert(PIObj.isAnalysisGroup() &&
+  assert(isAnalysisGroup() &&
          "Trying to join an analysis group that is a normal pass!");
 
   if (PassID) {
@@ -254,11 +254,6 @@ RegisterAGBase::RegisterAGBase(intptr_t InterfaceID,
   }
 }
 
-void RegisterAGBase::setGroupName(const char *Name) {
-  assert(InterfaceInfo->getPassName()[0] == 0 && "Interface Name already set!");
-  InterfaceInfo->setPassName(Name);
-}
-
 
 //===----------------------------------------------------------------------===//
 // PassRegistrationListener implementation

lib/VMCore/Verifier.cpp

@@ -97,7 +97,7 @@ namespace {  // Anonymous namespace for class
 char PreVerifier::ID = 0;
 static RegisterPass<PreVerifier>
 PreVer("preverify", "Preliminary module verification");
-static const PassInfo *PreVerifyID = PreVer.getPassInfo();
+static const PassInfo *PreVerifyID = &PreVer;
 
 namespace {
   struct VISIBILITY_HIDDEN