LLVM API Documentation

AliasAnalysis.cpp
Go to the documentation of this file.
00001 //===- AliasAnalysis.cpp - Generic Alias Analysis Interface Implementation -==//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file implements the generic AliasAnalysis interface which is used as the
00011 // common interface used by all clients and implementations of alias analysis.
00012 //
00013 // This file also implements the default version of the AliasAnalysis interface
00014 // that is to be used when no other implementation is specified.  This does some
00015 // simple tests that detect obvious cases: two different global pointers cannot
00016 // alias, a global cannot alias a malloc, two different mallocs cannot alias,
00017 // etc.
00018 //
00019 // This alias analysis implementation really isn't very good for anything, but
00020 // it is very fast, and makes a nice clean default implementation.  Because it
00021 // handles lots of little corner cases, other, more complex, alias analysis
00022 // implementations may choose to rely on this pass to resolve these simple and
00023 // easy cases.
00024 //
00025 //===----------------------------------------------------------------------===//
00026 
00027 #include "llvm/Analysis/AliasAnalysis.h"
00028 #include "llvm/Analysis/CFG.h"
00029 #include "llvm/Analysis/CaptureTracking.h"
00030 #include "llvm/Analysis/ValueTracking.h"
00031 #include "llvm/IR/BasicBlock.h"
00032 #include "llvm/IR/DataLayout.h"
00033 #include "llvm/IR/Dominators.h"
00034 #include "llvm/IR/Function.h"
00035 #include "llvm/IR/Instructions.h"
00036 #include "llvm/IR/IntrinsicInst.h"
00037 #include "llvm/IR/LLVMContext.h"
00038 #include "llvm/IR/Type.h"
00039 #include "llvm/Pass.h"
00040 #include "llvm/Target/TargetLibraryInfo.h"
00041 using namespace llvm;
00042 
00043 // Register the AliasAnalysis interface, providing a nice name to refer to.
00044 INITIALIZE_ANALYSIS_GROUP(AliasAnalysis, "Alias Analysis", NoAA)
00045 char AliasAnalysis::ID = 0;
00046 
00047 //===----------------------------------------------------------------------===//
00048 // Default chaining methods
00049 //===----------------------------------------------------------------------===//
00050 
00051 AliasAnalysis::AliasResult
00052 AliasAnalysis::alias(const Location &LocA, const Location &LocB) {
00053   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00054   return AA->alias(LocA, LocB);
00055 }
00056 
00057 bool AliasAnalysis::pointsToConstantMemory(const Location &Loc,
00058                                            bool OrLocal) {
00059   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00060   return AA->pointsToConstantMemory(Loc, OrLocal);
00061 }
00062 
00063 void AliasAnalysis::deleteValue(Value *V) {
00064   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00065   AA->deleteValue(V);
00066 }
00067 
00068 void AliasAnalysis::copyValue(Value *From, Value *To) {
00069   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00070   AA->copyValue(From, To);
00071 }
00072 
00073 void AliasAnalysis::addEscapingUse(Use &U) {
00074   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00075   AA->addEscapingUse(U);
00076 }
00077 
00078 
00079 AliasAnalysis::ModRefResult
00080 AliasAnalysis::getModRefInfo(ImmutableCallSite CS,
00081                              const Location &Loc) {
00082   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00083 
00084   ModRefBehavior MRB = getModRefBehavior(CS);
00085   if (MRB == DoesNotAccessMemory)
00086     return NoModRef;
00087 
00088   ModRefResult Mask = ModRef;
00089   if (onlyReadsMemory(MRB))
00090     Mask = Ref;
00091 
00092   if (onlyAccessesArgPointees(MRB)) {
00093     bool doesAlias = false;
00094     if (doesAccessArgPointees(MRB)) {
00095       MDNode *CSTag = CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa);
00096       for (ImmutableCallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end();
00097            AI != AE; ++AI) {
00098         const Value *Arg = *AI;
00099         if (!Arg->getType()->isPointerTy())
00100           continue;
00101         Location CSLoc(Arg, UnknownSize, CSTag);
00102         if (!isNoAlias(CSLoc, Loc)) {
00103           doesAlias = true;
00104           break;
00105         }
00106       }
00107     }
00108     if (!doesAlias)
00109       return NoModRef;
00110   }
00111 
00112   // If Loc is a constant memory location, the call definitely could not
00113   // modify the memory location.
00114   if ((Mask & Mod) && pointsToConstantMemory(Loc))
00115     Mask = ModRefResult(Mask & ~Mod);
00116 
00117   // If this is the end of the chain, don't forward.
00118   if (!AA) return Mask;
00119 
00120   // Otherwise, fall back to the next AA in the chain. But we can merge
00121   // in any mask we've managed to compute.
00122   return ModRefResult(AA->getModRefInfo(CS, Loc) & Mask);
00123 }
00124 
00125 AliasAnalysis::ModRefResult
00126 AliasAnalysis::getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) {
00127   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00128 
00129   // If CS1 or CS2 are readnone, they don't interact.
00130   ModRefBehavior CS1B = getModRefBehavior(CS1);
00131   if (CS1B == DoesNotAccessMemory) return NoModRef;
00132 
00133   ModRefBehavior CS2B = getModRefBehavior(CS2);
00134   if (CS2B == DoesNotAccessMemory) return NoModRef;
00135 
00136   // If they both only read from memory, there is no dependence.
00137   if (onlyReadsMemory(CS1B) && onlyReadsMemory(CS2B))
00138     return NoModRef;
00139 
00140   AliasAnalysis::ModRefResult Mask = ModRef;
00141 
00142   // If CS1 only reads memory, the only dependence on CS2 can be
00143   // from CS1 reading memory written by CS2.
00144   if (onlyReadsMemory(CS1B))
00145     Mask = ModRefResult(Mask & Ref);
00146 
00147   // If CS2 only access memory through arguments, accumulate the mod/ref
00148   // information from CS1's references to the memory referenced by
00149   // CS2's arguments.
00150   if (onlyAccessesArgPointees(CS2B)) {
00151     AliasAnalysis::ModRefResult R = NoModRef;
00152     if (doesAccessArgPointees(CS2B)) {
00153       MDNode *CS2Tag = CS2.getInstruction()->getMetadata(LLVMContext::MD_tbaa);
00154       for (ImmutableCallSite::arg_iterator
00155            I = CS2.arg_begin(), E = CS2.arg_end(); I != E; ++I) {
00156         const Value *Arg = *I;
00157         if (!Arg->getType()->isPointerTy())
00158           continue;
00159         Location CS2Loc(Arg, UnknownSize, CS2Tag);
00160         R = ModRefResult((R | getModRefInfo(CS1, CS2Loc)) & Mask);
00161         if (R == Mask)
00162           break;
00163       }
00164     }
00165     return R;
00166   }
00167 
00168   // If CS1 only accesses memory through arguments, check if CS2 references
00169   // any of the memory referenced by CS1's arguments. If not, return NoModRef.
00170   if (onlyAccessesArgPointees(CS1B)) {
00171     AliasAnalysis::ModRefResult R = NoModRef;
00172     if (doesAccessArgPointees(CS1B)) {
00173       MDNode *CS1Tag = CS1.getInstruction()->getMetadata(LLVMContext::MD_tbaa);
00174       for (ImmutableCallSite::arg_iterator
00175            I = CS1.arg_begin(), E = CS1.arg_end(); I != E; ++I) {
00176         const Value *Arg = *I;
00177         if (!Arg->getType()->isPointerTy())
00178           continue;
00179         Location CS1Loc(Arg, UnknownSize, CS1Tag);
00180         if (getModRefInfo(CS2, CS1Loc) != NoModRef) {
00181           R = Mask;
00182           break;
00183         }
00184       }
00185     }
00186     if (R == NoModRef)
00187       return R;
00188   }
00189 
00190   // If this is the end of the chain, don't forward.
00191   if (!AA) return Mask;
00192 
00193   // Otherwise, fall back to the next AA in the chain. But we can merge
00194   // in any mask we've managed to compute.
00195   return ModRefResult(AA->getModRefInfo(CS1, CS2) & Mask);
00196 }
00197 
00198 AliasAnalysis::ModRefBehavior
00199 AliasAnalysis::getModRefBehavior(ImmutableCallSite CS) {
00200   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00201 
00202   ModRefBehavior Min = UnknownModRefBehavior;
00203 
00204   // Call back into the alias analysis with the other form of getModRefBehavior
00205   // to see if it can give a better response.
00206   if (const Function *F = CS.getCalledFunction())
00207     Min = getModRefBehavior(F);
00208 
00209   // If this is the end of the chain, don't forward.
00210   if (!AA) return Min;
00211 
00212   // Otherwise, fall back to the next AA in the chain. But we can merge
00213   // in any result we've managed to compute.
00214   return ModRefBehavior(AA->getModRefBehavior(CS) & Min);
00215 }
00216 
00217 AliasAnalysis::ModRefBehavior
00218 AliasAnalysis::getModRefBehavior(const Function *F) {
00219   assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!");
00220   return AA->getModRefBehavior(F);
00221 }
00222 
00223 //===----------------------------------------------------------------------===//
00224 // AliasAnalysis non-virtual helper method implementation
00225 //===----------------------------------------------------------------------===//
00226 
00227 AliasAnalysis::Location AliasAnalysis::getLocation(const LoadInst *LI) {
00228   return Location(LI->getPointerOperand(),
00229                   getTypeStoreSize(LI->getType()),
00230                   LI->getMetadata(LLVMContext::MD_tbaa));
00231 }
00232 
00233 AliasAnalysis::Location AliasAnalysis::getLocation(const StoreInst *SI) {
00234   return Location(SI->getPointerOperand(),
00235                   getTypeStoreSize(SI->getValueOperand()->getType()),
00236                   SI->getMetadata(LLVMContext::MD_tbaa));
00237 }
00238 
00239 AliasAnalysis::Location AliasAnalysis::getLocation(const VAArgInst *VI) {
00240   return Location(VI->getPointerOperand(),
00241                   UnknownSize,
00242                   VI->getMetadata(LLVMContext::MD_tbaa));
00243 }
00244 
00245 AliasAnalysis::Location
00246 AliasAnalysis::getLocation(const AtomicCmpXchgInst *CXI) {
00247   return Location(CXI->getPointerOperand(),
00248                   getTypeStoreSize(CXI->getCompareOperand()->getType()),
00249                   CXI->getMetadata(LLVMContext::MD_tbaa));
00250 }
00251 
00252 AliasAnalysis::Location
00253 AliasAnalysis::getLocation(const AtomicRMWInst *RMWI) {
00254   return Location(RMWI->getPointerOperand(),
00255                   getTypeStoreSize(RMWI->getValOperand()->getType()),
00256                   RMWI->getMetadata(LLVMContext::MD_tbaa));
00257 }
00258 
00259 AliasAnalysis::Location 
00260 AliasAnalysis::getLocationForSource(const MemTransferInst *MTI) {
00261   uint64_t Size = UnknownSize;
00262   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
00263     Size = C->getValue().getZExtValue();
00264 
00265   // memcpy/memmove can have TBAA tags. For memcpy, they apply
00266   // to both the source and the destination.
00267   MDNode *TBAATag = MTI->getMetadata(LLVMContext::MD_tbaa);
00268 
00269   return Location(MTI->getRawSource(), Size, TBAATag);
00270 }
00271 
00272 AliasAnalysis::Location 
00273 AliasAnalysis::getLocationForDest(const MemIntrinsic *MTI) {
00274   uint64_t Size = UnknownSize;
00275   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
00276     Size = C->getValue().getZExtValue();
00277 
00278   // memcpy/memmove can have TBAA tags. For memcpy, they apply
00279   // to both the source and the destination.
00280   MDNode *TBAATag = MTI->getMetadata(LLVMContext::MD_tbaa);
00281   
00282   return Location(MTI->getRawDest(), Size, TBAATag);
00283 }
00284 
00285 
00286 
00287 AliasAnalysis::ModRefResult
00288 AliasAnalysis::getModRefInfo(const LoadInst *L, const Location &Loc) {
00289   // Be conservative in the face of volatile/atomic.
00290   if (!L->isUnordered())
00291     return ModRef;
00292 
00293   // If the load address doesn't alias the given address, it doesn't read
00294   // or write the specified memory.
00295   if (!alias(getLocation(L), Loc))
00296     return NoModRef;
00297 
00298   // Otherwise, a load just reads.
00299   return Ref;
00300 }
00301 
00302 AliasAnalysis::ModRefResult
00303 AliasAnalysis::getModRefInfo(const StoreInst *S, const Location &Loc) {
00304   // Be conservative in the face of volatile/atomic.
00305   if (!S->isUnordered())
00306     return ModRef;
00307 
00308   // If the store address cannot alias the pointer in question, then the
00309   // specified memory cannot be modified by the store.
00310   if (!alias(getLocation(S), Loc))
00311     return NoModRef;
00312 
00313   // If the pointer is a pointer to constant memory, then it could not have been
00314   // modified by this store.
00315   if (pointsToConstantMemory(Loc))
00316     return NoModRef;
00317 
00318   // Otherwise, a store just writes.
00319   return Mod;
00320 }
00321 
00322 AliasAnalysis::ModRefResult
00323 AliasAnalysis::getModRefInfo(const VAArgInst *V, const Location &Loc) {
00324   // If the va_arg address cannot alias the pointer in question, then the
00325   // specified memory cannot be accessed by the va_arg.
00326   if (!alias(getLocation(V), Loc))
00327     return NoModRef;
00328 
00329   // If the pointer is a pointer to constant memory, then it could not have been
00330   // modified by this va_arg.
00331   if (pointsToConstantMemory(Loc))
00332     return NoModRef;
00333 
00334   // Otherwise, a va_arg reads and writes.
00335   return ModRef;
00336 }
00337 
00338 AliasAnalysis::ModRefResult
00339 AliasAnalysis::getModRefInfo(const AtomicCmpXchgInst *CX, const Location &Loc) {
00340   // Acquire/Release cmpxchg has properties that matter for arbitrary addresses.
00341   if (CX->getSuccessOrdering() > Monotonic)
00342     return ModRef;
00343 
00344   // If the cmpxchg address does not alias the location, it does not access it.
00345   if (!alias(getLocation(CX), Loc))
00346     return NoModRef;
00347 
00348   return ModRef;
00349 }
00350 
00351 AliasAnalysis::ModRefResult
00352 AliasAnalysis::getModRefInfo(const AtomicRMWInst *RMW, const Location &Loc) {
00353   // Acquire/Release atomicrmw has properties that matter for arbitrary addresses.
00354   if (RMW->getOrdering() > Monotonic)
00355     return ModRef;
00356 
00357   // If the atomicrmw address does not alias the location, it does not access it.
00358   if (!alias(getLocation(RMW), Loc))
00359     return NoModRef;
00360 
00361   return ModRef;
00362 }
00363 
00364 namespace {
00365   /// Only find pointer captures which happen before the given instruction. Uses
00366   /// the dominator tree to determine whether one instruction is before another.
00367   /// Only support the case where the Value is defined in the same basic block
00368   /// as the given instruction and the use.
00369   struct CapturesBefore : public CaptureTracker {
00370     CapturesBefore(const Instruction *I, DominatorTree *DT)
00371       : BeforeHere(I), DT(DT), Captured(false) {}
00372 
00373     void tooManyUses() override { Captured = true; }
00374 
00375     bool shouldExplore(const Use *U) override {
00376       Instruction *I = cast<Instruction>(U->getUser());
00377       BasicBlock *BB = I->getParent();
00378       // We explore this usage only if the usage can reach "BeforeHere".
00379       // If use is not reachable from entry, there is no need to explore.
00380       if (BeforeHere != I && !DT->isReachableFromEntry(BB))
00381         return false;
00382       // If the value is defined in the same basic block as use and BeforeHere,
00383       // there is no need to explore the use if BeforeHere dominates use.
00384       // Check whether there is a path from I to BeforeHere.
00385       if (BeforeHere != I && DT->dominates(BeforeHere, I) &&
00386           !isPotentiallyReachable(I, BeforeHere, DT))
00387         return false;
00388       return true;
00389     }
00390 
00391     bool captured(const Use *U) override {
00392       Instruction *I = cast<Instruction>(U->getUser());
00393       BasicBlock *BB = I->getParent();
00394       // Same logic as in shouldExplore.
00395       if (BeforeHere != I && !DT->isReachableFromEntry(BB))
00396         return false;
00397       if (BeforeHere != I && DT->dominates(BeforeHere, I) &&
00398           !isPotentiallyReachable(I, BeforeHere, DT))
00399         return false;
00400       Captured = true;
00401       return true;
00402     }
00403 
00404     const Instruction *BeforeHere;
00405     DominatorTree *DT;
00406 
00407     bool Captured;
00408   };
00409 }
00410 
00411 // FIXME: this is really just shoring-up a deficiency in alias analysis.
00412 // BasicAA isn't willing to spend linear time determining whether an alloca
00413 // was captured before or after this particular call, while we are. However,
00414 // with a smarter AA in place, this test is just wasting compile time.
00415 AliasAnalysis::ModRefResult
00416 AliasAnalysis::callCapturesBefore(const Instruction *I,
00417                                   const AliasAnalysis::Location &MemLoc,
00418                                   DominatorTree *DT) {
00419   if (!DT || !DL) return AliasAnalysis::ModRef;
00420 
00421   const Value *Object = GetUnderlyingObject(MemLoc.Ptr, DL);
00422   if (!isIdentifiedObject(Object) || isa<GlobalValue>(Object) ||
00423       isa<Constant>(Object))
00424     return AliasAnalysis::ModRef;
00425 
00426   ImmutableCallSite CS(I);
00427   if (!CS.getInstruction() || CS.getInstruction() == Object)
00428     return AliasAnalysis::ModRef;
00429 
00430   CapturesBefore CB(I, DT);
00431   llvm::PointerMayBeCaptured(Object, &CB);
00432   if (CB.Captured)
00433     return AliasAnalysis::ModRef;
00434 
00435   unsigned ArgNo = 0;
00436   AliasAnalysis::ModRefResult R = AliasAnalysis::NoModRef;
00437   for (ImmutableCallSite::arg_iterator CI = CS.arg_begin(), CE = CS.arg_end();
00438        CI != CE; ++CI, ++ArgNo) {
00439     // Only look at the no-capture or byval pointer arguments.  If this
00440     // pointer were passed to arguments that were neither of these, then it
00441     // couldn't be no-capture.
00442     if (!(*CI)->getType()->isPointerTy() ||
00443         (!CS.doesNotCapture(ArgNo) && !CS.isByValArgument(ArgNo)))
00444       continue;
00445 
00446     // If this is a no-capture pointer argument, see if we can tell that it
00447     // is impossible to alias the pointer we're checking.  If not, we have to
00448     // assume that the call could touch the pointer, even though it doesn't
00449     // escape.
00450     if (isNoAlias(AliasAnalysis::Location(*CI),
00451       AliasAnalysis::Location(Object)))
00452       continue;
00453     if (CS.doesNotAccessMemory(ArgNo))
00454       continue;
00455     if (CS.onlyReadsMemory(ArgNo)) {
00456       R = AliasAnalysis::Ref;
00457       continue;
00458     }
00459     return AliasAnalysis::ModRef;
00460   }
00461   return R;
00462 }
00463 
00464 // AliasAnalysis destructor: DO NOT move this to the header file for
00465 // AliasAnalysis or else clients of the AliasAnalysis class may not depend on
00466 // the AliasAnalysis.o file in the current .a file, causing alias analysis
00467 // support to not be included in the tool correctly!
00468 //
00469 AliasAnalysis::~AliasAnalysis() {}
00470 
00471 /// InitializeAliasAnalysis - Subclasses must call this method to initialize the
00472 /// AliasAnalysis interface before any other methods are called.
00473 ///
00474 void AliasAnalysis::InitializeAliasAnalysis(Pass *P) {
00475   DataLayoutPass *DLP = P->getAnalysisIfAvailable<DataLayoutPass>();
00476   DL = DLP ? &DLP->getDataLayout() : nullptr;
00477   TLI = P->getAnalysisIfAvailable<TargetLibraryInfo>();
00478   AA = &P->getAnalysis<AliasAnalysis>();
00479 }
00480 
00481 // getAnalysisUsage - All alias analysis implementations should invoke this
00482 // directly (using AliasAnalysis::getAnalysisUsage(AU)).
00483 void AliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
00484   AU.addRequired<AliasAnalysis>();         // All AA's chain
00485 }
00486 
00487 /// getTypeStoreSize - Return the DataLayout store size for the given type,
00488 /// if known, or a conservative value otherwise.
00489 ///
00490 uint64_t AliasAnalysis::getTypeStoreSize(Type *Ty) {
00491   return DL ? DL->getTypeStoreSize(Ty) : UnknownSize;
00492 }
00493 
00494 /// canBasicBlockModify - Return true if it is possible for execution of the
00495 /// specified basic block to modify the value pointed to by Ptr.
00496 ///
00497 bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB,
00498                                         const Location &Loc) {
00499   return canInstructionRangeModify(BB.front(), BB.back(), Loc);
00500 }
00501 
00502 /// canInstructionRangeModify - Return true if it is possible for the execution
00503 /// of the specified instructions to modify the value pointed to by Ptr.  The
00504 /// instructions to consider are all of the instructions in the range of [I1,I2]
00505 /// INCLUSIVE.  I1 and I2 must be in the same basic block.
00506 ///
00507 bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1,
00508                                               const Instruction &I2,
00509                                               const Location &Loc) {
00510   assert(I1.getParent() == I2.getParent() &&
00511          "Instructions not in same basic block!");
00512   BasicBlock::const_iterator I = &I1;
00513   BasicBlock::const_iterator E = &I2;
00514   ++E;  // Convert from inclusive to exclusive range.
00515 
00516   for (; I != E; ++I) // Check every instruction in range
00517     if (getModRefInfo(I, Loc) & Mod)
00518       return true;
00519   return false;
00520 }
00521 
00522 /// isNoAliasCall - Return true if this pointer is returned by a noalias
00523 /// function.
00524 bool llvm::isNoAliasCall(const Value *V) {
00525   if (isa<CallInst>(V) || isa<InvokeInst>(V))
00526     return ImmutableCallSite(cast<Instruction>(V))
00527       .paramHasAttr(0, Attribute::NoAlias);
00528   return false;
00529 }
00530 
00531 /// isNoAliasArgument - Return true if this is an argument with the noalias
00532 /// attribute.
00533 bool llvm::isNoAliasArgument(const Value *V)
00534 {
00535   if (const Argument *A = dyn_cast<Argument>(V))
00536     return A->hasNoAliasAttr();
00537   return false;
00538 }
00539 
00540 /// isIdentifiedObject - Return true if this pointer refers to a distinct and
00541 /// identifiable object.  This returns true for:
00542 ///    Global Variables and Functions (but not Global Aliases)
00543 ///    Allocas and Mallocs
00544 ///    ByVal and NoAlias Arguments
00545 ///    NoAlias returns
00546 ///
00547 bool llvm::isIdentifiedObject(const Value *V) {
00548   if (isa<AllocaInst>(V))
00549     return true;
00550   if (isa<GlobalValue>(V) && !isa<GlobalAlias>(V))
00551     return true;
00552   if (isNoAliasCall(V))
00553     return true;
00554   if (const Argument *A = dyn_cast<Argument>(V))
00555     return A->hasNoAliasAttr() || A->hasByValAttr();
00556   return false;
00557 }