IVUsers.h

//===- llvm/Analysis/IVUsers.h - Induction Variable Users -------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements bookkeeping for "interesting" users of expressions
// computed from induction variables.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_ANALYSIS_IVUSERS_H
#define LLVM_ANALYSIS_IVUSERS_H

#include "llvm/Analysis/LoopPass.h"
#include "llvm/Support/ValueHandle.h"

namespace llvm {

class DominatorTree;
class Instruction;
class Value;
class IVUsers;
class ScalarEvolution;
class SCEV;

class IVStrideUse : public CallbackVH, public ilist_node<IVStrideUse> {
public:
  IVStrideUse(IVUsers *P, const SCEV *S, const SCEV *Off,
              Instruction* U, Value *O)
    : CallbackVH(U), Parent(P), Stride(S), Offset(Off),
      OperandValToReplace(O), IsUseOfPostIncrementedValue(false) {
  }

  Instruction *getUser() const {
    return cast<Instruction>(getValPtr());
  }

  void setUser(Instruction *NewUser) {
    setValPtr(NewUser);
  }

  IVUsers *getParent() const { return Parent; }

  const SCEV *getStride() const { return Stride; }

  void setStride(const SCEV *Val) {
    Stride = Val;
  }

  const SCEV *getOffset() const { return Offset; }

  void setOffset(const SCEV *Val) {
    Offset = Val;
  }

  Value *getOperandValToReplace() const {
    return OperandValToReplace;
  }

  void setOperandValToReplace(Value *Op) {
    OperandValToReplace = Op;
  }

  bool isUseOfPostIncrementedValue() const {
    return IsUseOfPostIncrementedValue;
  }

  void setIsUseOfPostIncrementedValue(bool Val) {
    IsUseOfPostIncrementedValue = Val;
  }

private:
  IVUsers *Parent;

  const SCEV *Stride;

  const SCEV *Offset;

  WeakVH OperandValToReplace;

  bool IsUseOfPostIncrementedValue;

  virtual void deleted();
};

template<> struct ilist_traits<IVStrideUse>
  : public ilist_default_traits<IVStrideUse> {
  // createSentinel is used to get hold of a node that marks the end of
  // the list...
  // The sentinel is relative to this instance, so we use a non-static
  // method.
  IVStrideUse *createSentinel() const {
    // since i(p)lists always publicly derive from the corresponding
    // traits, placing a data member in this class will augment i(p)list.
    // But since the NodeTy is expected to publicly derive from
    // ilist_node<NodeTy>, there is a legal viable downcast from it
    // to NodeTy. We use this trick to superpose i(p)list with a "ghostly"
    // NodeTy, which becomes the sentinel. Dereferencing the sentinel is
    // forbidden (save the ilist_node<NodeTy>) so no one will ever notice
    // the superposition.
    return static_cast<IVStrideUse*>(&Sentinel);
  }
  static void destroySentinel(IVStrideUse*) {}

  IVStrideUse *provideInitialHead() const { return createSentinel(); }
  IVStrideUse *ensureHead(IVStrideUse*) const { return createSentinel(); }
  static void noteHead(IVStrideUse*, IVStrideUse*) {}

private:
  mutable ilist_node<IVStrideUse> Sentinel;
};

class IVUsers : public LoopPass {
  friend class IVStrideUse;
  Loop *L;
  LoopInfo *LI;
  DominatorTree *DT;
  ScalarEvolution *SE;
  SmallPtrSet<Instruction*,16> Processed;

  ilist<IVStrideUse> IVUses;

  virtual void getAnalysisUsage(AnalysisUsage &AU) const;

  virtual bool runOnLoop(Loop *L, LPPassManager &LPM);

  virtual void releaseMemory();

public:
  static char ID; // Pass ID, replacement for typeid
  IVUsers();

  bool AddUsersIfInteresting(Instruction *I);

  IVStrideUse &AddUser(const SCEV *Stride, const SCEV *Offset,
                       Instruction *User, Value *Operand);

  const SCEV *getReplacementExpr(const IVStrideUse &U) const;

  const SCEV *getCanonicalExpr(const IVStrideUse &U) const;

  typedef ilist<IVStrideUse>::iterator iterator;
  typedef ilist<IVStrideUse>::const_iterator const_iterator;
  iterator begin() { return IVUses.begin(); }
  iterator end()   { return IVUses.end(); }
  const_iterator begin() const { return IVUses.begin(); }
  const_iterator end() const   { return IVUses.end(); }
  bool empty() const { return IVUses.empty(); }

  void print(raw_ostream &OS, const Module* = 0) const;

  void dump() const;
};

Pass *createIVUsersPass();

}

#endif

---