reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

include/llvm/Transforms/Scalar/GVNExpression.h
  136 class BasicExpression : public Expression {
  538 class DeadExpression final : public Expression {
  549 class VariableExpression final : public Expression {
  585 class ConstantExpression final : public Expression {
  622 class UnknownExpression final : public Expression {

References

include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Support/Casting.h
   34   using SimpleType = From; // The real type this represents...
   37   static SimpleType &getSimplifiedValue(From &Val) { return Val; }
   41   using NonConstSimpleType = typename simplify_type<From>::SimpleType;
   47   static RetType getSimplifiedValue(const From& Val) {
   57   static inline bool doit(const From &Val) {
   76   static inline bool doit(const From &Val) {
   77     return isa_impl<To, From>::doit(Val);
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
  142   return isa_impl_wrap<X, const Y,
  143                        typename simplify_type<const Y>::SimpleType>::doit(Val);
  236       std::is_same<X, typename simplify_type<X>::SimpleType>::value;
  236       std::is_same<X, typename simplify_type<X>::SimpleType>::value;
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/type_traits.h
   55 struct add_const_past_pointer { using type = const T; };
include/llvm/Transforms/Scalar/GVNExpression.h
   69   Expression(const Expression &) = delete;
   70   Expression &operator=(const Expression &) = delete;
   70   Expression &operator=(const Expression &) = delete;
   76   bool operator!=(const Expression &Other) const { return !(*this == Other); }
   77   bool operator==(const Expression &Other) const {
  100   virtual bool equals(const Expression &Other) const { return true; }
  104   virtual bool exactlyEquals(const Expression &Other) const {
  131 inline raw_ostream &operator<<(raw_ostream &OS, const Expression &E) {
  136 class BasicExpression : public Expression {
  156   static bool classof(const Expression *EB) {
  213   bool equals(const Expression &Other) const override {
  275   static bool classof(const Expression *EB) {
  284   bool equals(const Expression &Other) const override {
  309   static bool classof(const Expression *EB) {
  345   static bool classof(const Expression *EB) {
  355   bool equals(const Expression &Other) const override;
  356   bool exactlyEquals(const Expression &Other) const override {
  387   static bool classof(const Expression *EB) {
  394   bool equals(const Expression &Other) const override;
  396   bool exactlyEquals(const Expression &Other) const override {
  429   static bool classof(const Expression *EB) {
  456   bool equals(const Expression &Other) const override {
  514   static bool classof(const Expression *EB) {
  518   bool equals(const Expression &Other) const override {
  538 class DeadExpression final : public Expression {
  544   static bool classof(const Expression *E) {
  549 class VariableExpression final : public Expression {
  559   static bool classof(const Expression *EB) {
  566   bool equals(const Expression &Other) const override {
  585 class ConstantExpression final : public Expression {
  596   static bool classof(const Expression *EB) {
  603   bool equals(const Expression &Other) const override {
  622 class UnknownExpression final : public Expression {
  632   static bool classof(const Expression *EB) {
  639   bool equals(const Expression &Other) const override {
lib/Transforms/Scalar/GVNSink.cpp
  385   DenseMap<GVNExpression::Expression *, uint32_t> ExpressionNumbering;
lib/Transforms/Scalar/NewGVN.cpp
  301   CongruenceClass(unsigned ID, Value *Leader, const Expression *E)
  332   const Expression *getDefiningExpr() const { return DefiningExpr; }
  412   const Expression *DefiningExpr = nullptr;
  432   const Expression &E;
  434   explicit ExactEqualsExpression(const Expression &E) : E(E) {}
  438   bool operator==(const Expression &Other) const {
  444   static const Expression *getEmptyKey() {
  446     Val <<= PointerLikeTypeTraits<const Expression *>::NumLowBitsAvailable;
  450   static const Expression *getTombstoneKey() {
  452     Val <<= PointerLikeTypeTraits<const Expression *>::NumLowBitsAvailable;
  456   static unsigned getHashValue(const Expression *E) {
  464   static bool isEqual(const ExactEqualsExpression &LHS, const Expression *RHS) {
  470   static bool isEqual(const Expression *LHS, const Expression *RHS) {
  470   static bool isEqual(const Expression *LHS, const Expression *RHS) {
  525   DenseMap<Value *, const Expression *> ValueToExpression;
  551   DenseMap<const Expression *, SmallPtrSet<Instruction *, 2>>
  608   using ExpressionClassMap = DenseMap<const Expression *, CongruenceClass *>;
  668   const Expression *createExpression(Instruction *) const;
  669   const Expression *createBinaryExpression(unsigned, Type *, Value *, Value *,
  682   const Expression *createVariableOrConstant(Value *V) const;
  695   CongruenceClass *createCongruenceClass(Value *Leader, const Expression *E) {
  722   const Expression *makePossiblePHIOfOps(Instruction *,
  741   const Expression *checkSimplificationResults(Expression *, Instruction *,
  741   const Expression *checkSimplificationResults(Expression *, Instruction *,
  743   const Expression *performSymbolicEvaluation(Value *,
  745   const Expression *performSymbolicLoadCoercion(Type *, Value *, LoadInst *,
  748   const Expression *performSymbolicLoadEvaluation(Instruction *) const;
  749   const Expression *performSymbolicStoreEvaluation(Instruction *) const;
  750   const Expression *performSymbolicCallEvaluation(Instruction *) const;
  752   const Expression *performSymbolicPHIEvaluation(ArrayRef<ValPair>,
  755   const Expression *performSymbolicAggrValueEvaluation(Instruction *) const;
  756   const Expression *performSymbolicCmpEvaluation(Instruction *) const;
  757   const Expression *performSymbolicPredicateInfoEvaluation(Instruction *) const;
  762   CongruenceClass *getClassForExpression(const Expression *E) const;
  763   void performCongruenceFinding(Instruction *, const Expression *);
  764   void moveValueToNewCongruenceClass(Instruction *, const Expression *,
  797   Value *findPHIOfOpsLeader(const Expression *, const Instruction *,
  814   void markPhiOfOpsChanged(const Expression *E);
  832   void deleteExpression(const Expression *E) const;
  871 static bool equalsLoadStoreHelper(const T &LHS, const Expression &RHS) {
  877 bool LoadExpression::equals(const Expression &Other) const {
  881 bool StoreExpression::equals(const Expression &Other) const {
  934 void NewGVN::deleteExpression(const Expression *E) const {
 1037 const Expression *NewGVN::createBinaryExpression(unsigned Opcode, Type *T,
 1057   if (const Expression *SimplifiedE = checkSimplificationResults(E, I, V))
 1065 const Expression *NewGVN::checkSimplificationResults(Expression *E,
 1065 const Expression *NewGVN::checkSimplificationResults(Expression *E,
 1123 const Expression *NewGVN::createExpression(Instruction *I) const {
 1154     if (const Expression *SimplifiedE = checkSimplificationResults(E, I, V))
 1163       if (const Expression *SimplifiedE = checkSimplificationResults(E, I, V))
 1169     if (const Expression *SimplifiedE = checkSimplificationResults(E, I, V))
 1174     if (const Expression *SimplifiedE = checkSimplificationResults(E, I, V))
 1179     if (const Expression *SimplifiedE = checkSimplificationResults(E, I, V))
 1194       if (const Expression *SimplifiedE = checkSimplificationResults(E, I, V))
 1232 const Expression *NewGVN::createVariableOrConstant(Value *V) const {
 1363 const Expression *NewGVN::performSymbolicStoreEvaluation(Instruction *I) const {
 1414 const Expression *
 1490 const Expression *NewGVN::performSymbolicLoadEvaluation(Instruction *I) const {
 1516       if (const auto *CoercionResult =
 1532 const Expression *
 1628 const Expression *NewGVN::performSymbolicCallEvaluation(Instruction *I) const {
 1634         if (const auto *Result = performSymbolicPredicateInfoEvaluation(I))
 1737 const Expression *
 1819 const Expression *
 1834 const Expression *NewGVN::performSymbolicCmpEvaluation(Instruction *I) const {
 1955 const Expression *
 1958   const Expression *E = nullptr;
 2239 void NewGVN::moveValueToNewCongruenceClass(Instruction *I, const Expression *E,
 2327 void NewGVN::markPhiOfOpsChanged(const Expression *E) {
 2332 void NewGVN::performCongruenceFinding(Instruction *I, const Expression *E) {
 2478         const Expression *E = createExpression(I);
 2664   const Expression *E = performSymbolicEvaluation(TransInst, Visited);
 2686 const Expression *
 3081     const Expression *Symbolized = nullptr;
 3762 CongruenceClass *NewGVN::getClassForExpression(const Expression *E) const {
 3772 Value *NewGVN::findPHIOfOpsLeader(const Expression *E,
usr/include/c++/7.4.0/type_traits
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1983     { typedef _Up     type; };