llvm.org GIT mirror llvm / c758209
PassInfo keep tracks whether a pass is an analysis pass or not. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@48554 91177308-0d34-0410-b5e6-96231b3b80d8 Devang Patel 12 years ago
35 changed file(s) with 93 addition(s) and 76 deletion(s). Raw diff Collapse all Expand all
291291 initialization value is not important.

292292
293293

                  
                
294 RegisterPass<Hello> X("hello", "Hello World Pass");
294 RegisterPass<Hello> X("hello", "Hello World Pass",
295 false /* Only looks at CFG */,
296 false /* Analysis Pass */);
295297 } // end of anonymous namespace
296298
297299
298300

Lastly, we register our class Hello,

299301 giving it a command line
300 argument "hello", and a name "Hello World Pass".

302 argument "hello", and a name "Hello World Pass".
303 Last two RegisterPass arguments are optional. Their default value is false.
304 If a pass walks CFG without modifying it then third argument is set to true.
305 If a pass is an analysis pass, for example dominator tree pass, then true
306 is supplied as fourth argument.

301307
302308

As a whole, the .cpp file looks like:

303309
663663 static char ID; // Pass ID, replacement for typeid
664664 DominatorTreeBase* DT;
665665
666 DominatorTree() : FunctionPass(intptr_t(&ID), true) {
666 DominatorTree() : FunctionPass(intptr_t(&ID)) {
667667 DT = new DominatorTreeBase(false);
668668 }
669669
836836
837837 public:
838838 DominanceFrontierBase(intptr_t ID, bool isPostDom)
839 : FunctionPass(ID, true), IsPostDominators(isPostDom) {}
839 : FunctionPass(ID), IsPostDominators(isPostDom) {}
840840
841841 /// getRoots - Return the root blocks of the current CFG. This may include
842842 /// multiple blocks if we are computing post dominators. For forward
2424 std::set UsedTypes;
2525 public:
2626 static char ID; // Pass identification, replacement for typeid
27 FindUsedTypes() : ModulePass((intptr_t)&ID, true) {}
27 FindUsedTypes() : ModulePass((intptr_t)&ID) {}
2828
2929 /// getTypes - After the pass has been run, return the set containing all of
3030 /// the types used in the module.
4646 public:
4747 static char ID; // Pass identification, replacement for typeid
4848
49 IntervalPartition() : FunctionPass((intptr_t)&ID, true), RootInterval(0) {}
49 IntervalPartition() : FunctionPass((intptr_t)&ID), RootInterval(0) {}
5050
5151 // run - Calculate the interval partition for this function
5252 virtual bool runOnFunction(Function &F);
878878 public:
879879 static char ID; // Pass identification, replacement for typeid
880880
881 LoopInfo() : FunctionPass(intptr_t(&ID), true) {
881 LoopInfo() : FunctionPass(intptr_t(&ID)) {
882882 LI = new LoopInfoBase();
883883 }
884884
917917 inline bool isLoopHeader(BasicBlock *BB) const {
918918 return LI->isLoopHeader(BB);
919919 }
920
921 /// isAnalysis - Return true if this pass is implementing an analysis pass.
922 bool isAnalysis() const { return true; }
920923
921924 /// runOnFunction - Calculate the natural loop information.
922925 ///
2828 class LoopPass : public Pass {
2929
3030 public:
31 explicit LoopPass(intptr_t pid, bool AP = false) : Pass(pid, AP) {}
31 explicit LoopPass(intptr_t pid) : Pass(pid) {}
3232
3333 // runOnLoop - This method should be implemented by the subclass to perform
3434 // whatever action is necessary for the specfied Loop.
6565 static Instruction* const Dirty;
6666
6767 static char ID; // Class identification, replacement for typeinfo
68 MemoryDependenceAnalysis() : FunctionPass((intptr_t)&ID, true) {}
68 MemoryDependenceAnalysis() : FunctionPass((intptr_t)&ID) {}
6969
7070 /// Pass Implementation stuff. This doesn't do any analysis.
7171 ///
2424 static char ID; // Pass identification, replacement for typeid
2525 DominatorTreeBase* DT;
2626
27 PostDominatorTree() : FunctionPass((intptr_t)&ID, true) {
27 PostDominatorTree() : FunctionPass((intptr_t)&ID) {
2828 DT = new DominatorTreeBase(true);
2929 }
3030
191191 void *Impl; // ScalarEvolution uses the pimpl pattern
192192 public:
193193 static char ID; // Pass identification, replacement for typeid
194 ScalarEvolution() : FunctionPass((intptr_t)&ID, true), Impl(0) {}
194 ScalarEvolution() : FunctionPass((intptr_t)&ID), Impl(0) {}
195195
196196 /// getSCEV - Return a SCEV expression handle for the full generality of the
197197 /// specified expression.
3030
3131 struct CallGraphSCCPass : public Pass {
3232
33 explicit CallGraphSCCPass(intptr_t pid, bool AP = false) : Pass(pid, AP) {}
33 explicit CallGraphSCCPass(intptr_t pid) : Pass(pid) {}
3434
3535 /// doInitialization - This method is called before the SCC's of the program
3636 /// has been processed, allowing the pass to do initialization as necessary.
7272 class Pass {
7373 AnalysisResolver *Resolver; // Used to resolve analysis
7474 intptr_t PassID;
75 bool isAnalysisPass; // True if this pass is an analysis pass.
7675 // AnalysisImpls - This keeps track of which passes implement the interfaces
7776 // that are required by the current pass (to implement getAnalysis()).
7877 //
8180 void operator=(const Pass&); // DO NOT IMPLEMENT
8281 Pass(const Pass &); // DO NOT IMPLEMENT
8382 public:
84 explicit Pass(intptr_t pid, bool AP = false) : Resolver(0), PassID(pid),
85 isAnalysisPass(AP) {}
86 explicit Pass(const void *pid, bool AP = false) : Resolver(0),
87 PassID((intptr_t)pid),
88 isAnalysisPass(AP) {}
83 explicit Pass(intptr_t pid) : Resolver(0), PassID(pid) {}
84 explicit Pass(const void *pid) : Resolver(0),
85 PassID((intptr_t)pid) {}
8986 virtual ~Pass();
9087
91 bool isAnalysis() const { return isAnalysisPass; }
9288 /// getPassName - Return a nice clean name for a pass. This usually
9389 /// implemented in terms of the name that is registered by one of the
9490 /// Registration templates, but can be overloaded directly.
230226 return PMT_ModulePassManager;
231227 }
232228
233 explicit ModulePass(intptr_t pid, bool AP = false) : Pass(pid, AP) {}
234 explicit ModulePass(const void *pid, bool AP = false) : Pass(pid, AP) {}
229 explicit ModulePass(intptr_t pid) : Pass(pid) {}
230 explicit ModulePass(const void *pid) : Pass(pid) {}
235231 // Force out-of-line virtual method.
236232 virtual ~ModulePass();
237233 };
256252 ///
257253 bool runOnModule(Module &M) { return false; }
258254
259 explicit ImmutablePass(intptr_t pid, bool AP = false) : ModulePass(pid, AP) {}
260 explicit ImmutablePass(const void *pid, bool AP = false)
261 : ModulePass(pid, AP) {}
255 explicit ImmutablePass(intptr_t pid) : ModulePass(pid) {}
256 explicit ImmutablePass(const void *pid)
257 : ModulePass(pid) {}
262258
263259 // Force out-of-line virtual method.
264260 virtual ~ImmutablePass();
275271 ///
276272 class FunctionPass : public Pass {
277273 public:
278 explicit FunctionPass(intptr_t pid, bool AP = false) : Pass(pid, AP) {}
279 explicit FunctionPass(const void *pid, bool AP = false) : Pass(pid, AP) {}
274 explicit FunctionPass(intptr_t pid) : Pass(pid) {}
275 explicit FunctionPass(const void *pid) : Pass(pid) {}
280276
281277 /// doInitialization - Virtual method overridden by subclasses to do
282278 /// any necessary per-module initialization.
327323 ///
328324 class BasicBlockPass : public Pass {
329325 public:
330 explicit BasicBlockPass(intptr_t pid, bool AP = false) : Pass(pid, AP) {}
331 explicit BasicBlockPass(const void *pid, bool AP = false) : Pass(pid, AP) {}
326 explicit BasicBlockPass(intptr_t pid) : Pass(pid) {}
327 explicit BasicBlockPass(const void *pid) : Pass(pid) {}
332328
333329 /// doInitialization - Virtual method overridden by subclasses to do
334330 /// any necessary per-module initialization.
3838 const char *PassArgument; // Command Line argument to run this pass
3939 intptr_t PassID;
4040 bool IsCFGOnlyPass; // Pass only looks at the CFG.
41 bool IsAnalysis; // True if an analysis pass.
4142 bool IsAnalysisGroup; // True if an analysis group.
4243 std::vector ItfImpl;// Interfaces implemented by this pass
4344
4748 /// PassInfo ctor - Do not call this directly, this should only be invoked
4849 /// through RegisterPass.
4950 PassInfo(const char *name, const char *arg, intptr_t pi,
50 Pass *(*normal)() = 0, bool isCFGOnly = false)
51 Pass *(*normal)() = 0, bool isCFGOnly = false, bool isAnalysis = false)
5152 : PassName(name), PassArgument(arg), PassID(pi),
52 IsCFGOnlyPass(isCFGOnly), IsAnalysisGroup(false), NormalCtor(normal) {
53 IsCFGOnlyPass(isCFGOnly),
54 IsAnalysis(isAnalysis), IsAnalysisGroup(false), NormalCtor(normal) {
5355 }
5456
5557 /// getPassName - Return the friendly name for the pass, never returns null
7173 /// pass.
7274 ///
7375 bool isAnalysisGroup() const { return IsAnalysisGroup; }
76 bool isAnalysis() const { return IsAnalysis; }
7477 void SetIsAnalysisGroup() { IsAnalysisGroup = true; }
7578
7679 /// isCFGOnlyPass - return true if this pass only looks at the CFG for the
139142 typedef Pass* (*NormalCtor_t)();
140143
141144 RegisterPassBase(const char *Name, const char *Arg, intptr_t TI,
142 NormalCtor_t NormalCtor = 0, bool CFGOnly = false)
143 : PIObj(Name, Arg, TI, NormalCtor, CFGOnly) {
145 NormalCtor_t NormalCtor = 0, bool CFGOnly = false,
146 bool IsAnalysis = false)
147 : PIObj(Name, Arg, TI, NormalCtor, CFGOnly, IsAnalysis) {
144148 registerPass();
145149 }
146150 explicit RegisterPassBase(intptr_t TI)
163167 struct RegisterPass : public RegisterPassBase {
164168
165169 // Register Pass using default constructor...
166 RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false)
170 RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false,
171 bool IsAnalysis = false)
167172 : RegisterPassBase(Name, PassArg, intptr_t(&PassName::ID),
168 RegisterPassBase::NormalCtor_t(callDefaultCtor), CFGOnly) {
173 RegisterPassBase::NormalCtor_t(callDefaultCtor),
174 CFGOnly, IsAnalysis) {
169175 }
170176 };
171177
3434 Module *M;
3535 public:
3636 static char ID; // Class identification, replacement for typeinfo
37 AliasAnalysisCounter() : ModulePass((intptr_t) &ID, true) {
37 AliasAnalysisCounter() : ModulePass((intptr_t) &ID) {
3838 No = May = Must = 0;
3939 NoMR = JustRef = JustMod = MR = 0;
4040 }
115115
116116 char AliasAnalysisCounter::ID = 0;
117117 RegisterPass
118 X("count-aa", "Count Alias Analysis Query Responses");
118 X("count-aa", "Count Alias Analysis Query Responses", true, true);
119119 RegisterAnalysisGroup Y(X);
120120 }
121121
5151
5252 public:
5353 static char ID; // Pass identification, replacement for typeid
54 AAEval() : FunctionPass((intptr_t)&ID, true) {}
54 AAEval() : FunctionPass((intptr_t)&ID) {}
5555
5656 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
5757 AU.addRequired();
7575
7676 char AAEval::ID = 0;
7777 RegisterPass
78 X("aa-eval", "Exhaustive Alias Analysis Precision Evaluator");
78 X("aa-eval", "Exhaustive Alias Analysis Precision Evaluator", true, true);
7979 }
8080
8181 FunctionPass *llvm::createAAEvalPass() { return new AAEval(); }
4040
4141 public:
4242 static char ID; // Class identification, replacement for typeinfo
43 AliasDebugger() : ModulePass((intptr_t)&ID, true) {}
43 AliasDebugger() : ModulePass((intptr_t)&ID) {}
4444
4545 bool runOnModule(Module &M) {
4646 InitializeAliasAnalysis(this); // set up super class
122122 };
123123
124124 char AliasDebugger::ID = 0;
125 RegisterPass X("debug-aa", "AA use debugger");
125 RegisterPass X("debug-aa", "AA use debugger", true, true);
126126 RegisterAnalysisGroup Y(X);
127127 }
128128
550550 AliasSetTracker *Tracker;
551551 public:
552552 static char ID; // Pass identification, replacement for typeid
553 AliasSetPrinter() : FunctionPass((intptr_t)&ID, true) {}
553 AliasSetPrinter() : FunctionPass((intptr_t)&ID) {}
554554
555555 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
556556 AU.setPreservesAll();
568568 }
569569 };
570570 char AliasSetPrinter::ID = 0;
571 RegisterPass X("print-alias-sets", "Alias Set Printer");
572 }
571 RegisterPass X("print-alias-sets", "Alias Set Printer", true, true);
572 }
8282 // Register this pass...
8383 char NoAA::ID = 0;
8484 RegisterPass
85 U("no-aa", "No Alias Analysis (always returns 'may' alias)");
85 U("no-aa", "No Alias Analysis (always returns 'may' alias)", true, true);
8686
8787 // Declare that we implement the AliasAnalysis interface
8888 RegisterAnalysisGroup V(U);
127127 // Register this pass...
128128 char BasicAliasAnalysis::ID = 0;
129129 RegisterPass
130 X("basicaa", "Basic Alias Analysis (default AA impl)");
130 X("basicaa", "Basic Alias Analysis (default AA impl)", true, true);
131131
132132 // Declare that we implement the AliasAnalysis interface
133133 RegisterAnalysisGroup Y(X);
9191 namespace {
9292 struct VISIBILITY_HIDDEN CFGViewer : public FunctionPass {
9393 static char ID; // Pass identifcation, replacement for typeid
94 CFGViewer() : FunctionPass((intptr_t)&ID, true) {}
94 CFGViewer() : FunctionPass((intptr_t)&ID) {}
9595
9696 virtual bool runOnFunction(Function &F) {
9797 F.viewCFG();
107107
108108 char CFGViewer::ID = 0;
109109 RegisterPass V0("view-cfg",
110 "View CFG of function");
110 "View CFG of function", true, true);
111111
112112 struct VISIBILITY_HIDDEN CFGOnlyViewer : public FunctionPass {
113113 static char ID; // Pass identifcation, replacement for typeid
114 CFGOnlyViewer() : FunctionPass((intptr_t)&ID, true) {}
114 CFGOnlyViewer() : FunctionPass((intptr_t)&ID) {}
115115
116116 virtual bool runOnFunction(Function &F) {
117117 CFGOnly = true;
129129
130130 char CFGOnlyViewer::ID = 0;
131131 RegisterPass V1("view-cfg-only",
132 "View CFG of function (with no function bodies)");
132 "View CFG of function (with no function bodies)", true, true);
133133
134134 struct VISIBILITY_HIDDEN CFGPrinter : public FunctionPass {
135135 static char ID; // Pass identification, replacement for typeid
136136 CFGPrinter() : FunctionPass((intptr_t)&ID) {}
137 explicit CFGPrinter(intptr_t pid) : FunctionPass(pid, true) {}
137 explicit CFGPrinter(intptr_t pid) : FunctionPass(pid) {}
138138
139139 virtual bool runOnFunction(Function &F) {
140140 std::string Filename = "cfg." + F.getName() + ".dot";
158158
159159 char CFGPrinter::ID = 0;
160160 RegisterPass P1("print-cfg",
161 "Print CFG of function to 'dot' file");
161 "Print CFG of function to 'dot' file", true, true);
162162
163163 struct VISIBILITY_HIDDEN CFGOnlyPrinter : public CFGPrinter {
164164 static char ID; // Pass identification, replacement for typeid
180180 char CFGOnlyPrinter::ID = 0;
181181 RegisterPass
182182 P2("print-cfg-only",
183 "Print CFG of function to 'dot' file (with no function bodies)");
183 "Print CFG of function to 'dot' file (with no function bodies)", true, true);
184184 }
185185
186186 /// viewCFG - This function is meant for use from the debugger. You can just
429429
430430 public:
431431 static char ID;
432 Andersens() : ModulePass((intptr_t)&ID, true) {}
432 Andersens() : ModulePass((intptr_t)&ID) {}
433433
434434 bool runOnModule(Module &M) {
435435 InitializeAliasAnalysis(this);
601601
602602 char Andersens::ID = 0;
603603 RegisterPass X("anders-aa",
604 "Andersen's Interprocedural Alias Analysis");
604 "Andersen's Interprocedural Alias Analysis", true,
605 true);
605606 RegisterAnalysisGroup Y(X);
606607
607608 // Initialize Timestamp Counter (static).
190190 };
191191
192192 RegisterAnalysisGroup X("Call Graph");
193 RegisterPass Y("basiccg", "Basic CallGraph Construction");
193 RegisterPass Y("basiccg", "Basic CallGraph Construction", false, true);
194194 RegisterAnalysisGroup Z(Y);
195195
196196 } //End anonymous namespace
2222
2323 char FindUsedTypes::ID = 0;
2424 static RegisterPass
25 X("printusedtypes", "Find Used Types");
25 X("printusedtypes", "Find Used Types", true, true);
2626
2727 // IncorporateType - Incorporate one type and all of its subtypes into the
2828 // collection of used types.
8383
8484 public:
8585 static char ID;
86 GlobalsModRef() : ModulePass((intptr_t)&ID, true) {}
86 GlobalsModRef() : ModulePass((intptr_t)&ID) {}
8787
8888 bool runOnModule(Module &M) {
8989 InitializeAliasAnalysis(this); // set up super class
148148
149149 char GlobalsModRef::ID = 0;
150150 RegisterPass X("globalsmodref-aa",
151 "Simple mod/ref analysis for globals");
151 "Simple mod/ref analysis for globals", true,
152 true);
152153 RegisterAnalysisGroup Y(X);
153154 }
154155
5151 }
5252 public:
5353 static char ID; // Pass identification, replacement for typeid
54 InstCount() : FunctionPass((intptr_t)&ID, true) {}
54 InstCount() : FunctionPass((intptr_t)&ID) {}
5555
5656 virtual bool runOnFunction(Function &F);
5757
6464
6565 char InstCount::ID = 0;
6666 RegisterPass X("instcount",
67 "Counts the various types of Instructions");
67 "Counts the various types of Instructions", true, true);
6868 }
6969
7070 FunctionPass *llvm::createInstCountPass() { return new InstCount(); }
1616
1717 char IntervalPartition::ID = 0;
1818 static RegisterPass
19 X("intervals", "Interval Partition Construction", true);
19 X("intervals", "Interval Partition Construction", true, true);
2020
2121 //===----------------------------------------------------------------------===//
2222 // IntervalPartition Implementation
4040 // FIXME: This should not be a FunctionPass.
4141 struct VISIBILITY_HIDDEN LoadVN : public FunctionPass, public ValueNumbering {
4242 static char ID; // Class identification, replacement for typeinfo
43 LoadVN() : FunctionPass((intptr_t)&ID, true) {}
43 LoadVN() : FunctionPass((intptr_t)&ID) {}
4444
4545 /// Pass Implementation stuff. This doesn't do any analysis.
4646 ///
8484
8585 char LoadVN::ID = 0;
8686 // Register this pass...
87 RegisterPass X("load-vn", "Load Value Numbering");
87 RegisterPass X("load-vn", "Load Value Numbering", true, true);
8888
8989 // Declare that we implement the ValueNumbering interface
9090 RegisterAnalysisGroup Y(X);
2828
2929 char LoopInfo::ID = 0;
3030 static RegisterPass
31 X("loops", "Natural Loop Construction", true);
31 X("loops", "Natural Loop Construction", true, true);
3232
3333 //===----------------------------------------------------------------------===//
3434 // Loop implementation
4747
4848 // Register this pass...
4949 static RegisterPass X("memdep",
50 "Memory Dependence Analysis");
50 "Memory Dependence Analysis", true, true);
5151
5252 void MemoryDependenceAnalysis::ping(Instruction *D) {
5353 for (depMapType::iterator I = depGraphLocal.begin(), E = depGraphLocal.end();
2525 char PostDominatorTree::ID = 0;
2626 char PostDominanceFrontier::ID = 0;
2727 static RegisterPass
28 F("postdomtree", "Post-Dominator Tree Construction", true);
28 F("postdomtree", "Post-Dominator Tree Construction", true, true);
2929
3030 bool PostDominatorTree::runOnFunction(Function &F) {
3131 DT->recalculate(F);
3737 //===----------------------------------------------------------------------===//
3838
3939 static RegisterPass
40 H("postdomfrontier", "Post-Dominance Frontier Construction", true);
40 H("postdomfrontier", "Post-Dominance Frontier Construction", true, true);
4141
4242 const DominanceFrontier::DomSetType &
4343 PostDominanceFrontier::calculate(const PostDominatorTree &DT,
9292 char NoProfileInfo::ID = 0;
9393 // Register this pass...
9494 RegisterPass
95 X("no-profile", "No Profile Information");
95 X("no-profile", "No Profile Information", true, true);
9696
9797 // Declare that we implement the ProfileInfo interface
9898 RegisterAnalysisGroup Y(X);
3333 public:
3434 static char ID; // Class identification, replacement for typeinfo
3535 explicit LoaderPass(const std::string &filename = "")
36 : ModulePass((intptr_t)&ID, true), Filename(filename) {
36 : ModulePass((intptr_t)&ID), Filename(filename) {
3737 if (filename.empty()) Filename = ProfileInfoFilename;
3838 }
3939
5151
5252 char LoaderPass::ID = 0;
5353 RegisterPass
54 X("profile-loader", "Load profile information from llvmprof.out");
54 X("profile-loader", "Load profile information from llvmprof.out", true, true);
5555
5656 RegisterAnalysisGroup Y(X);
5757 } // End of anonymous namespace
102102
103103 namespace {
104104 RegisterPass
105 R("scalar-evolution", "Scalar Evolution Analysis");
105 R("scalar-evolution", "Scalar Evolution Analysis", true, true);
106106 }
107107 char ScalarEvolution::ID = 0;
108108
6767 char BasicVN::ID = 0;
6868 // Register this pass...
6969 RegisterPass
70 X("basicvn", "Basic Value Numbering (default GVN impl)");
70 X("basicvn", "Basic Value Numbering (default GVN impl)", true, true);
7171
7272 // Declare that we implement the ValueNumbering interface
7373 RegisterAnalysisGroup Y(X);
3232 // Handle the Pass registration stuff necessary to use TargetData's.
3333 namespace {
3434 // Register the default SparcV9 implementation...
35 RegisterPass X("targetdata", "Target Data Layout");
35 RegisterPass X("targetdata", "Target Data Layout", false,
36 true);
3637 }
3738 char TargetData::ID = 0;
3839
5353
5454 char DominatorTree::ID = 0;
5555 static RegisterPass
56 E("domtree", "Dominator Tree Construction", true);
56 E("domtree", "Dominator Tree Construction", true, true);
5757
5858 bool DominatorTree::runOnFunction(Function &F) {
5959 DT->recalculate(F);
6767
6868 char DominanceFrontier::ID = 0;
6969 static RegisterPass
70 G("domfrontier", "Dominance Frontier Construction", true);
70 G("domfrontier", "Dominance Frontier Construction", true, true);
7171
7272 // NewBB is split and now it has one successor. Update dominace frontier to
7373 // reflect this change.
425425 // Give pass a chance to prepare the stage.
426426 P->preparePassManager(activeStack);
427427
428 #if 1
428429 // If P is an analysis pass and it is available then do not
429430 // generate the analysis again. Stale analysis info should not be
430431 // available at this point.
431 if (P->isAnalysis() && findAnalysisPass(P->getPassInfo()))
432 if (P->getPassInfo() &&
433 P->getPassInfo()->isAnalysis() && findAnalysisPass(P->getPassInfo()))
432434 return;
435 #endif
433436
434437 AnalysisUsage AnUsage;
435438 P->getAnalysisUsage(AnUsage);