Commit 8df7af56 authored by Luofan Chen's avatar Luofan Chen
Browse files

[Attributor] Track AA dependency using dependency graph 

Summary: This patch added dependency graph to the attributor so that we can dump the dependencies between AAs more easily. We can also apply general graph algorithms to the graph, making it easier for us to create deep wrappers.

Reviewers: jdoerfert, sstefan1, uenoku, homerdin, baziotis

Reviewed By: jdoerfert

Subscribers: jfb, okura, mgrang, kuter, lebedev.ri, hiraditya, uenoku, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D78861
parent e21323a1

llvm/include/llvm/Transforms/IPO/Attributor.h

+89 −14
Original line number Diff line number Diff line
@@ -97,8 +97,10 @@ 
#ifndef LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H

#define LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H



#include "llvm/ADT/GraphTraits.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/SCCIterator.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SetVector.h"

#include "llvm/Analysis/AliasAnalysis.h"

#include "llvm/Analysis/AssumeBundleQueries.h"
@@ -116,10 +118,15 @@ 
#include "llvm/IR/ConstantRange.h"

#include "llvm/IR/PassManager.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/DOTGraphTraits.h"

#include "llvm/Support/GraphWriter.h"

#include "llvm/Transforms/Utils/CallGraphUpdater.h"



namespace llvm {



struct AADepGraphNode;

struct AADepGraph;

struct Attributor;

struct AbstractAttribute;

struct InformationCache;
@@ -144,6 +151,70 @@ enum class DepClassTy { 
};

///}



/// The data structure for the nodes of a dependency graph

struct AADepGraphNode {

public:

  virtual ~AADepGraphNode(){};

  using DepTy = PointerIntPair<AADepGraphNode *, 1>;



protected:

  /// Set of dependency graph nodes which this one depends on.

  /// The bit encodes if it is optional.

  TinyPtrVector<DepTy> Deps;



  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }

  static AbstractAttribute *DepGetValAA(DepTy &DT) {

    return cast<AbstractAttribute>(DT.getPointer());

  }



  operator AbstractAttribute *() { return cast<AbstractAttribute>(this); }



public:

  using iterator =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;

  using aaiterator =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetValAA)>;



  aaiterator begin() { return aaiterator(Deps.begin(), &DepGetValAA); }

  aaiterator end() { return aaiterator(Deps.end(), &DepGetValAA); }

  iterator child_begin() { return iterator(Deps.begin(), &DepGetVal); }

  iterator child_end() { return iterator(Deps.end(), &DepGetVal); }



  virtual void print(raw_ostream &OS) const { OS << "AADepNode Impl\n"; }

  TinyPtrVector<DepTy> &getDeps() { return Deps; }



  friend struct Attributor;

  friend struct AADepGraph;

};



struct AADepGraph {

  AADepGraph() {}

  ~AADepGraph() {}



  using DepTy = AADepGraphNode::DepTy;

  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }

  using iterator =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;



  /// There is no root node for the dependency graph. But the SCCIterator

  /// requires a single entry point, so we maintain a fake("synthetic") root

  /// node that depends on every node.

  AADepGraphNode SyntheticRoot;



  AADepGraphNode *GetEntryNode() { return &SyntheticRoot; }



  iterator begin() { return SyntheticRoot.child_begin(); }

  iterator end() { return SyntheticRoot.child_end(); }



  void viewGraph();



  /// Dump graph to file

  void dumpGraph();



  /// Print dependency graph

  void print();

};



/// Helper to describe and deal with positions in the LLVM-IR.

///

/// A position in the IR is described by an anchor value and an "offset" that
@@ -1001,7 +1072,9 @@ struct Attributor { 
    assert(!AAPtr && "Attribute already in map!");

    AAPtr = &AA;



    AllAbstractAttributes.push_back(&AA);

    DG.SyntheticRoot.Deps.push_back(

        AADepGraphNode::DepTy(&AA, unsigned(DepClassTy::REQUIRED)));



    return AA;

  }
@@ -1363,12 +1436,6 @@ private: 
  /// See getOrCreateAAFor.

  bool shouldSeedAttribute(AbstractAttribute &AA);



  /// The set of all abstract attributes.

  ///{

  using AAVector = SmallVector<AbstractAttribute *, 64>;

  AAVector AllAbstractAttributes;

  ///}



  /// A nested map to lookup abstract attributes based on the argument position

  /// on the outer level, and the addresses of the static member (AAType::ID) on

  /// the inner level.
@@ -1390,6 +1457,9 @@ private: 
  /// Helper to update an underlying call graph.

  CallGraphUpdater &CGUpdater;



  /// Abstract Attribute dependency graph

  AADepGraph DG;



  /// Set of functions for which we modified the content such that it might

  /// impact the call graph.

  SmallPtrSet<Function *, 8> CGModifiedFunctions;
@@ -1439,6 +1509,8 @@ private: 
  SmallPtrSet<BasicBlock *, 8> ToBeDeletedBlocks;

  SmallDenseSet<WeakVH, 8> ToBeDeletedInsts;

  ///}



  friend AADepGraph;

};



/// An interface to query the internal state of an abstract attribute.
@@ -2011,7 +2083,7 @@ struct IRAttribute : public BaseType { 
///       both directions will be added in the future.

/// NOTE: The mechanics of adding a new "concrete" abstract attribute are

///       described in the file comment.

struct AbstractAttribute : public IRPosition {

struct AbstractAttribute : public IRPosition, public AADepGraphNode {

  using StateType = AbstractState;



  AbstractAttribute(const IRPosition &IRP) : IRPosition(IRP) {}
@@ -2019,6 +2091,14 @@ struct AbstractAttribute : public IRPosition { 
  /// Virtual destructor.

  virtual ~AbstractAttribute() {}



  /// This function is used to identify if an \p DGN is of type

  /// AbstractAttribute so that the dyn_cast and cast can use such information

  /// to cast an AADepGraphNode to an AbstractAttribute.

  ///

  /// We eagerly return true here because all AADepGraphNodes except for the

  /// Synthethis Node are of type AbstractAttribute

  static bool classof(const AADepGraphNode *DGN) { return true; }



  /// Initialize the state with the information in the Attributor \p A.

  ///

  /// This function is called by the Attributor once all abstract attributes
@@ -2040,6 +2120,7 @@ struct AbstractAttribute : public IRPosition { 
  /// Helper functions, for debug purposes only.

  ///{

  virtual void print(raw_ostream &OS) const;

  virtual void printWithDeps(raw_ostream &OS) const;

  void dump() const { print(dbgs()); }



  /// This function should return the "summarized" assumed state as string.
@@ -2087,12 +2168,6 @@ protected: 
  ///

  /// \Return CHANGED if the internal state changed, otherwise UNCHANGED.

  virtual ChangeStatus updateImpl(Attributor &A) = 0;



private:

  /// Set of abstract attributes which were queried by this one. The bit encodes

  /// if there is an optional of required dependence.

  using DepTy = PointerIntPair<AbstractAttribute *, 1>;

  TinyPtrVector<DepTy> Deps;

};



/// Forward declarations of output streams for debug purposes.

llvm/lib/Transforms/IPO/Attributor.cpp

+173 −19
Original line number Diff line number Diff line
@@ -15,7 +15,10 @@ 


#include "llvm/Transforms/IPO/Attributor.h"



#include "llvm/ADT/GraphTraits.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/Statistic.h"

#include "llvm/ADT/TinyPtrVector.h"

#include "llvm/Analysis/LazyValueInfo.h"

#include "llvm/Analysis/MustExecute.h"

#include "llvm/Analysis/ValueTracking.h"
@@ -25,10 +28,15 @@ 
#include "llvm/InitializePasses.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/CommandLine.h"

#include "llvm/Support/Debug.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/GraphWriter.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/Transforms/Utils/BasicBlockUtils.h"

#include "llvm/Transforms/Utils/Local.h"



#include <cassert>

#include <string>



using namespace llvm;
@@ -85,6 +93,23 @@ static cl::list<std::string> 
                           "allowed to be seeded."),

                  cl::ZeroOrMore, cl::CommaSeparated);



static cl::opt<bool>

    DumpDepGraph("attributor-dump-dep-graph", cl::Hidden,

                 cl::desc("Dump the dependency graph to dot files."),

                 cl::init(false));



static cl::opt<std::string> DepGraphDotFileNamePrefix(

    "attributor-depgraph-dot-filename-prefix", cl::Hidden,

    cl::desc("The prefix used for the CallGraph dot file names."));



static cl::opt<bool> ViewDepGraph("attributor-view-dep-graph", cl::Hidden,

                                  cl::desc("View the dependency graph."),

                                  cl::init(false));



static cl::opt<bool> PrintDependencies("attributor-print-dep", cl::Hidden,

                                       cl::desc("Print attribute dependencies"),

                                       cl::init(false));



/// Logic operators for the change status enum class.

///

///{
@@ -498,9 +523,11 @@ Attributor::getAssumedConstant(const Value &V, const AbstractAttribute &AA, 
Attributor::~Attributor() {

  // The abstract attributes are allocated via the BumpPtrAllocator Allocator,

  // thus we cannot delete them. We can, and want to, destruct them though.

  for (AbstractAttribute *AA : AllAbstractAttributes)

  for (auto &DepAA : DG.SyntheticRoot.Deps) {

    AbstractAttribute *AA = cast<AbstractAttribute>(DepAA.getPointer());

    AA->~AbstractAttribute();

  }

}



bool Attributor::isAssumedDead(const AbstractAttribute &AA,

                               const AAIsDead *FnLivenessAA,
@@ -904,7 +931,7 @@ bool Attributor::checkForAllReadWriteInstructions( 


void Attributor::runTillFixpoint() {

  LLVM_DEBUG(dbgs() << "[Attributor] Identified and initialized "

                    << AllAbstractAttributes.size()

                    << DG.SyntheticRoot.Deps.size()

                    << " abstract attributes.\n");



  // Now that all abstract attributes are collected and initialized we start
@@ -914,11 +941,11 @@ void Attributor::runTillFixpoint() { 


  SmallVector<AbstractAttribute *, 32> ChangedAAs;

  SetVector<AbstractAttribute *> Worklist, InvalidAAs;

  Worklist.insert(AllAbstractAttributes.begin(), AllAbstractAttributes.end());

  Worklist.insert(DG.SyntheticRoot.begin(), DG.SyntheticRoot.end());



  do {

    // Remember the size to determine new attributes.

    size_t NumAAs = AllAbstractAttributes.size();

    size_t NumAAs = DG.SyntheticRoot.Deps.size();

    LLVM_DEBUG(dbgs() << "\n\n[Attributor] #Iteration: " << IterationCounter

                      << ", Worklist size: " << Worklist.size() << "\n");
@@ -935,7 +962,7 @@ void Attributor::runTillFixpoint() { 
      while (!InvalidAA->Deps.empty()) {

        const auto &Dep = InvalidAA->Deps.back();

        InvalidAA->Deps.pop_back();

        AbstractAttribute *DepAA = Dep.getPointer();

        AbstractAttribute *DepAA = cast<AbstractAttribute>(Dep.getPointer());

        if (Dep.getInt() == unsigned(DepClassTy::OPTIONAL)) {

          Worklist.insert(DepAA);

          continue;
@@ -953,7 +980,8 @@ void Attributor::runTillFixpoint() { 
    // changed to the work list.

    for (AbstractAttribute *ChangedAA : ChangedAAs)

      while (!ChangedAA->Deps.empty()) {

        Worklist.insert(ChangedAA->Deps.back().getPointer());

        Worklist.insert(

            cast<AbstractAttribute>(ChangedAA->Deps.back().getPointer()));

        ChangedAA->Deps.pop_back();

      }
@@ -981,8 +1009,8 @@ void Attributor::runTillFixpoint() { 


    // Add attributes to the changed set if they have been created in the last

    // iteration.

    ChangedAAs.append(AllAbstractAttributes.begin() + NumAAs,

                      AllAbstractAttributes.end());

    ChangedAAs.append(DG.SyntheticRoot.begin() + NumAAs,

                      DG.SyntheticRoot.end());



    // Reset the work list and repopulate with the changed abstract attributes.

    // Note that dependent ones are added above.
@@ -1015,7 +1043,8 @@ void Attributor::runTillFixpoint() { 
    }



    while (!ChangedAA->Deps.empty()) {

      ChangedAAs.push_back(ChangedAA->Deps.back().getPointer());

      ChangedAAs.push_back(

          cast<AbstractAttribute>(ChangedAA->Deps.back().getPointer()));

      ChangedAA->Deps.pop_back();

    }

  }
@@ -1037,12 +1066,13 @@ void Attributor::runTillFixpoint() { 
}



ChangeStatus Attributor::manifestAttributes() {

  size_t NumFinalAAs = AllAbstractAttributes.size();

  size_t NumFinalAAs = DG.SyntheticRoot.Deps.size();



  unsigned NumManifested = 0;

  unsigned NumAtFixpoint = 0;

  ChangeStatus ManifestChange = ChangeStatus::UNCHANGED;

  for (AbstractAttribute *AA : AllAbstractAttributes) {

  for (auto &DepAA : DG.SyntheticRoot.Deps) {

    AbstractAttribute *AA = cast<AbstractAttribute>(DepAA.getPointer());

    AbstractState &State = AA->getState();



    // If there is not already a fixpoint reached, we can now take the
@@ -1082,11 +1112,14 @@ ChangeStatus Attributor::manifestAttributes() { 
  NumAttributesValidFixpoint += NumAtFixpoint;



  (void)NumFinalAAs;

  if (NumFinalAAs != AllAbstractAttributes.size()) {

    for (unsigned u = NumFinalAAs; u < AllAbstractAttributes.size(); ++u)

      errs() << "Unexpected abstract attribute: " << *AllAbstractAttributes[u]

  if (NumFinalAAs != DG.SyntheticRoot.Deps.size()) {

    for (unsigned u = NumFinalAAs; u < DG.SyntheticRoot.Deps.size(); ++u)

      errs() << "Unexpected abstract attribute: "

             << cast<AbstractAttribute>(DG.SyntheticRoot.Deps[u].getPointer())

             << " :: "

             << AllAbstractAttributes[u]->getIRPosition().getAssociatedValue()

             << cast<AbstractAttribute>(DG.SyntheticRoot.Deps[u].getPointer())

                    ->getIRPosition()

                    .getAssociatedValue()

             << "\n";

    llvm_unreachable("Expected the final number of abstract attributes to "

                     "remain unchanged!");
@@ -1265,6 +1298,17 @@ ChangeStatus Attributor::cleanupIR() { 
ChangeStatus Attributor::run() {

  SeedingPeriod = false;

  runTillFixpoint();



  // dump graphs on demand

  if (DumpDepGraph)

    DG.dumpGraph();



  if (ViewDepGraph)

    DG.viewGraph();



  if (PrintDependencies)

    DG.print();



  ChangeStatus ManifestChange = manifestAttributes();

  ChangeStatus CleanupChange = cleanupIR();

  return ManifestChange | CleanupChange;
@@ -2028,8 +2072,31 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const AbstractAttribute &AA) { 
}



void AbstractAttribute::print(raw_ostream &OS) const {

  OS << "[P: " << getIRPosition() << "][" << getAsStr() << "][S: " << getState()

     << "]";

  OS << "[";

  OS << getName();

  OS << "] for CtxI ";



  if (auto *I = getCtxI()) {

    OS << "'";

    I->print(OS);

    OS << "'";

  } else

    OS << "<<null inst>>";



  OS << " at position " << getIRPosition() << " with state " << getAsStr()

     << '\n';

}



void AbstractAttribute::printWithDeps(raw_ostream &OS) const {

  print(OS);



  for (const auto &DepAA : Deps) {

    auto *AA = DepAA.getPointer();

    OS << "  updates ";

    AA->print(OS);

  }



  OS << '\n';

}

///}
@@ -2064,8 +2131,8 @@ static bool runAttributorOnFunctions(InformationCache &InfoCache, 
      NumFnWithoutExactDefinition++;



    // We look at internal functions only on-demand but if any use is not a

    // direct call or outside the current set of analyzed functions, we have to

    // do it eagerly.

    // direct call or outside the current set of analyzed functions, we have

    // to do it eagerly.

    if (F->hasLocalLinkage()) {

      if (llvm::all_of(F->uses(), [&Functions](const Use &U) {

            const auto *CB = dyn_cast<CallBase>(U.getUser());
@@ -2081,11 +2148,53 @@ static bool runAttributorOnFunctions(InformationCache &InfoCache, 
  }



  ChangeStatus Changed = A.run();



  LLVM_DEBUG(dbgs() << "[Attributor] Done with " << Functions.size()

                    << " functions, result: " << Changed << ".\n");

  return Changed == ChangeStatus::CHANGED;

}



void AADepGraph::viewGraph() { llvm::ViewGraph(this, "Dependency Graph"); }



void AADepGraph::dumpGraph() {

  static std::atomic<int> CallTimes;

  std::string Prefix;



  if (!DepGraphDotFileNamePrefix.empty())

    Prefix = DepGraphDotFileNamePrefix;

  else

    Prefix = "dep_graph";

  std::string Filename =

      Prefix + "_" + std::to_string(CallTimes.load()) + ".dot";



  outs() << "Dependency graph dump to " << Filename << ".\n";



  std::error_code EC;



  raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);

  if (!EC)

    llvm::WriteGraph(File, this);



  CallTimes++;

}



void AADepGraph::print() {

  SmallVector<AbstractAttribute *, 16> AAs;

  AAs.reserve(SyntheticRoot.Deps.size());



  for (auto tAA : SyntheticRoot.Deps)

    AAs.push_back(cast<AbstractAttribute>(tAA.getPointer()));



  llvm::sort(AAs, [](AbstractAttribute *LHS, AbstractAttribute *RHS) {

    if (LHS->getIdAddr() == RHS->getIdAddr())

      return LHS < RHS;

    return LHS->getIdAddr() < RHS->getIdAddr();

  });



  for (AbstractAttribute *AA : AAs)

    AA->printWithDeps(outs());

}



PreservedAnalyses AttributorPass::run(Module &M, ModuleAnalysisManager &AM) {

  FunctionAnalysisManager &FAM =

      AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
@@ -2132,6 +2241,51 @@ PreservedAnalyses AttributorCGSCCPass::run(LazyCallGraph::SCC &C, 
  return PreservedAnalyses::all();

}



namespace llvm {



template <> struct GraphTraits<AADepGraphNode *> {

  using NodeRef = AADepGraphNode *;

  using DepTy = PointerIntPair<AADepGraphNode *, 1>;

  using EdgeRef = PointerIntPair<AADepGraphNode *, 1>;



  static NodeRef getEntryNode(AADepGraphNode *DGN) { return DGN; }

  static NodeRef DepGetVal(DepTy &DT) { return DT.getPointer(); }



  using ChildIteratorType =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;

  using ChildEdgeIteratorType = TinyPtrVector<DepTy>::iterator;



  static ChildIteratorType child_begin(NodeRef N) { return N->child_begin(); }



  static ChildIteratorType child_end(NodeRef N) { return N->child_end(); }

};



template <>

struct GraphTraits<AADepGraph *> : public GraphTraits<AADepGraphNode *> {

  static NodeRef getEntryNode(AADepGraph *DG) { return DG->GetEntryNode(); }



  using nodes_iterator =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;



  static nodes_iterator nodes_begin(AADepGraph *DG) { return DG->begin(); }



  static nodes_iterator nodes_end(AADepGraph *DG) { return DG->end(); }

};



template <> struct DOTGraphTraits<AADepGraph *> : public DefaultDOTGraphTraits {

  DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}



  static std::string getNodeLabel(const AADepGraphNode *Node,

                                  const AADepGraph *DG) {

    std::string AAString = "";

    raw_string_ostream O(AAString);

    Node->print(O);

    return AAString;

  }

};



} // end namespace llvm



namespace {



struct AttributorLegacyPass : public ModulePass {

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

+4 −4
Original line number Diff line number Diff line
@@ -1052,9 +1052,10 @@ ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A) { 
  // map, NewRVsMap.

  decltype(ReturnedValues) NewRVsMap;



  auto HandleReturnValue = [&](Value *RV, SmallSetVector<ReturnInst *, 4> &RIs) {

    LLVM_DEBUG(dbgs() << "[AAReturnedValues] Returned value: " << *RV

                      << " by #" << RIs.size() << " RIs\n");

  auto HandleReturnValue = [&](Value *RV,

                               SmallSetVector<ReturnInst *, 4> &RIs) {

    LLVM_DEBUG(dbgs() << "[AAReturnedValues] Returned value: " << *RV << " by #"

                      << RIs.size() << " RIs\n");

    CallBase *CB = dyn_cast<CallBase>(RV);

    if (!CB || UnresolvedCalls.count(CB))

      return;
@@ -3425,7 +3426,6 @@ struct AADereferenceableFloating : AADereferenceableImpl { 
        T.GlobalState &= DS.GlobalState;

      }





      // For now we do not try to "increase" dereferenceability due to negative

      // indices as we first have to come up with code to deal with loops and

      // for overflows of the dereferenceable bytes.

llvm/test/Transforms/Attributor/depgraph.ll

0 → 100644
+152 −0

File added.

Preview size limit exceeded, changes collapsed.