[llvm-commits] [llvm] r110077 - in /llvm/trunk: include/llvm/Analysis/Passes.h include/llvm/LinkAllPasses.h lib/Analysis/TypeBasedAliasAnalysis.cpp

[Devang Patel]

Dan,

On Aug 2, 2010, at 4:11 PM, Dan Gohman wrote:

> Author: djg
> Date: Mon Aug  2 18:11:01 2010
> New Revision: 110077
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=110077&view=rev
> Log:
> Sketch up a preliminary Type-Based Alias Analysis implementation.
> 
> Added:
>    llvm/trunk/lib/Analysis/TypeBasedAliasAnalysis.cpp
> Modified:
>    llvm/trunk/include/llvm/Analysis/Passes.h
>    llvm/trunk/include/llvm/LinkAllPasses.h
> 
> Modified: llvm/trunk/include/llvm/Analysis/Passes.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/Passes.h?rev=110077&r1=110076&r2=110077&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/Passes.h (original)
> +++ llvm/trunk/include/llvm/Analysis/Passes.h Mon Aug  2 18:11:01 2010
> @@ -81,6 +81,13 @@
> 
>   //===--------------------------------------------------------------------===//
>   //
> +  // createTypeBasedAliasAnalysisPass - This pass implements metadata-based
> +  // type-based alias analysis.
> +  //
> +  ImmutablePass *createTypeBasedAliasAnalysisPass();
> +
> +  //===--------------------------------------------------------------------===//
> +  //
>   // createProfileLoaderPass - This pass loads information from a profile dump
>   // file.
>   //
> 
> Modified: llvm/trunk/include/llvm/LinkAllPasses.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/LinkAllPasses.h?rev=110077&r1=110076&r2=110077&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/LinkAllPasses.h (original)
> +++ llvm/trunk/include/llvm/LinkAllPasses.h Mon Aug  2 18:11:01 2010
> @@ -53,6 +53,7 @@
>       (void) llvm::createBasicAliasAnalysisPass();
>       (void) llvm::createLibCallAliasAnalysisPass(0);
>       (void) llvm::createScalarEvolutionAliasAnalysisPass();
> +      (void) llvm::createTypeBasedAliasAnalysisPass();
>       (void) llvm::createBlockPlacementPass();
>       (void) llvm::createBreakCriticalEdgesPass();
>       (void) llvm::createCFGSimplificationPass();
> 
> Added: llvm/trunk/lib/Analysis/TypeBasedAliasAnalysis.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/TypeBasedAliasAnalysis.cpp?rev=110077&view=auto
> ==============================================================================
> --- llvm/trunk/lib/Analysis/TypeBasedAliasAnalysis.cpp (added)
> +++ llvm/trunk/lib/Analysis/TypeBasedAliasAnalysis.cpp Mon Aug  2 18:11:01 2010
> @@ -0,0 +1,191 @@
> +//===- TypeBasedAliasAnalysis.cpp - Type-Based Alias Analysis -------------===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file defines the TypeBasedAliasAnalysis pass, which implements
> +// metadata-based TBAA.
> +//
> +// In LLVM IR, memory does not have types, so LLVM's own type system is not
> +// suitable for doing TBAA. Instead, metadata is added to the IR to describe
> +// a type system of a higher level language.
> +//
> +// This pass is language-independent. The type system is encoded in
> +// metadata. This allows this pass to support typical C and C++ TBAA, but
> +// it can also support custom aliasing behavior for other languages.
> +//
> +// This is a work-in-progress. It doesn't work yet, and the metadata
> +// format isn't stable.
> +//
> +// TODO: getModRefBehavior. The AliasAnalysis infrastructure will need to
> +//       be extended.
> +// TODO: AA chaining
> +// TODO: struct fields
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "llvm/Analysis/AliasAnalysis.h"
> +#include "llvm/Analysis/Passes.h"
> +#include "llvm/Module.h"
> +#include "llvm/Metadata.h"
> +#include "llvm/Pass.h"
> +using namespace llvm;
> +
> +namespace {
> +  /// TBAANode - This is a simple wrapper around an MDNode which provides a
> +  /// higher-level interface by hiding the details of how alias analysis
> +  /// information is encoded in its operands.
> +  class TBAANode {
> +    const MDNode *Node;
> +
> +  public:
> +    TBAANode() : Node(0) {}
> +    explicit TBAANode(MDNode *N) : Node(N) {}
> +
> +    /// getNode - Get the MDNode for this TBAANode.
> +    const MDNode *getNode() const { return Node; }
> +
> +    /// getParent - Get this TBAANode's Alias DAG parent.
> +    TBAANode getParent() const {
> +      if (Node->getNumOperands() < 2)
> +        return TBAANode();
> +      MDNode *P = dyn_cast<MDNode>(Node->getOperand(1));
> +      if (!P)
> +        return TBAANode();
> +      // Ok, this node has a valid parent. Return it.
> +      return TBAANode(P);
> +    }
> +
> +    /// TypeIsImmutable - Test if this TBAANode represents a type for objects
> +    /// which are not modified (by any means) in the context where this
> +    /// AliasAnalysis is relevant.
> +    bool TypeIsImmutable() const {
> +      if (Node->getNumOperands() < 3)
> +        return false;
> +      ConstantInt *CI = dyn_cast<ConstantInt>(Node->getOperand(2));
> +      if (!CI)
> +        return false;
> +      // TODO: Think about the encoding.
> +      return CI->isOne();
> +    }

This method needs some description of how immutable types are encoded as a MDNode. 

> +  };
> +}
> +
> +namespace {
> +  /// TypeBasedAliasAnalysis - This is a simple alias analysis
> +  /// implementation that uses TypeBased to answer queries.
> +  class TypeBasedAliasAnalysis : public ImmutablePass,
> +                                 public AliasAnalysis {
> +  public:
> +    static char ID; // Class identification, replacement for typeinfo
> +    TypeBasedAliasAnalysis() : ImmutablePass(&ID) {}
> +
> +    /// getAdjustedAnalysisPointer - This method is used when a pass implements
> +    /// an analysis interface through multiple inheritance.  If needed, it
> +    /// should override this to adjust the this pointer as needed for the
> +    /// specified pass info.
> +    virtual void *getAdjustedAnalysisPointer(const PassInfo *PI) {
> +      if (PI->isPassID(&AliasAnalysis::ID))
> +        return (AliasAnalysis*)this;
> +      return this;
> +    }
> +
> +  private:
> +    virtual void getAnalysisUsage(AnalysisUsage &AU) const;
> +    virtual AliasResult alias(const Value *V1, unsigned V1Size,
> +                              const Value *V2, unsigned V2Size);
> +    virtual bool pointsToConstantMemory(const Value *P);
> +  };
> +}  // End of anonymous namespace
> +
> +// Register this pass...
> +char TypeBasedAliasAnalysis::ID = 0;
> +INITIALIZE_AG_PASS(TypeBasedAliasAnalysis, AliasAnalysis, "tbaa",
> +                   "Type-Based Alias Analysis", false, true, false);
> +
> +ImmutablePass *llvm::createTypeBasedAliasAnalysisPass() {
> +  return new TypeBasedAliasAnalysis();
> +}
> +
> +void
> +TypeBasedAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
> +  AU.setPreservesAll();
> +  AliasAnalysis::getAnalysisUsage(AU);
> +}
> +
> +AliasAnalysis::AliasResult
> +TypeBasedAliasAnalysis::alias(const Value *A, unsigned ASize,
> +                              const Value *B, unsigned BSize) {
> +  // Currently, metadata can only be attached to Instructions.
> +  const Instruction *AI = dyn_cast<Instruction>(A);
> +  if (!AI) return MayAlias;
> +  const Instruction *BI = dyn_cast<Instruction>(B);
> +  if (!BI) return MayAlias;

What if two instructions are not from same function ?

> +  // Get the attached MDNodes. If either value lacks a tbaa MDNode, we must
> +  // be conservative.
> +  MDNode *AM =
> +    AI->getMetadata(AI->getParent()->getParent()->getParent()
> +                      ->getMDKindID("tbaa"));
> +  if (!AM) return MayAlias;
> +  MDNode *BM =
> +    AI->getMetadata(BI->getParent()->getParent()->getParent()
> +                      ->getMDKindID("tbaa"));

typo here.  BI->getMetadata...

-
Devang