Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- PHITransAddr.h - PHI Translation for Addresses -----------*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This file declares the PHITransAddr class.
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_ANALYSIS_PHITRANSADDR_H
  14. #define LLVM_ANALYSIS_PHITRANSADDR_H
  15.  
  16. #include "llvm/ADT/SmallVector.h"
  17. #include "llvm/IR/Instruction.h"
  18.  
  19. namespace llvm {
  20.   class AssumptionCache;
  21.   class DominatorTree;
  22.   class DataLayout;
  23.   class TargetLibraryInfo;
  24.  
  25. /// PHITransAddr - An address value which tracks and handles phi translation.
  26. /// As we walk "up" the CFG through predecessors, we need to ensure that the
  27. /// address we're tracking is kept up to date.  For example, if we're analyzing
  28. /// an address of "&A[i]" and walk through the definition of 'i' which is a PHI
  29. /// node, we *must* phi translate i to get "&A[j]" or else we will analyze an
  30. /// incorrect pointer in the predecessor block.
  31. ///
  32. /// This is designed to be a relatively small object that lives on the stack and
  33. /// is copyable.
  34. ///
  35. class PHITransAddr {
  36.   /// Addr - The actual address we're analyzing.
  37.   Value *Addr;
  38.  
  39.   /// The DataLayout we are playing with.
  40.   const DataLayout &DL;
  41.  
  42.   /// TLI - The target library info if known, otherwise null.
  43.   const TargetLibraryInfo *TLI = nullptr;
  44.  
  45.   /// A cache of \@llvm.assume calls used by SimplifyInstruction.
  46.   AssumptionCache *AC;
  47.  
  48.   /// InstInputs - The inputs for our symbolic address.
  49.   SmallVector<Instruction*, 4> InstInputs;
  50.  
  51. public:
  52.   PHITransAddr(Value *addr, const DataLayout &DL, AssumptionCache *AC)
  53.       : Addr(addr), DL(DL), AC(AC) {
  54.     // If the address is an instruction, the whole thing is considered an input.
  55.     if (Instruction *I = dyn_cast<Instruction>(Addr))
  56.       InstInputs.push_back(I);
  57.   }
  58.  
  59.   Value *getAddr() const { return Addr; }
  60.  
  61.   /// NeedsPHITranslationFromBlock - Return true if moving from the specified
  62.   /// BasicBlock to its predecessors requires PHI translation.
  63.   bool NeedsPHITranslationFromBlock(BasicBlock *BB) const {
  64.     // We do need translation if one of our input instructions is defined in
  65.     // this block.
  66.     for (unsigned i = 0, e = InstInputs.size(); i != e; ++i)
  67.       if (InstInputs[i]->getParent() == BB)
  68.         return true;
  69.     return false;
  70.   }
  71.  
  72.   /// IsPotentiallyPHITranslatable - If this needs PHI translation, return true
  73.   /// if we have some hope of doing it.  This should be used as a filter to
  74.   /// avoid calling PHITranslateValue in hopeless situations.
  75.   bool IsPotentiallyPHITranslatable() const;
  76.  
  77.   /// PHITranslateValue - PHI translate the current address up the CFG from
  78.   /// CurBB to Pred, updating our state to reflect any needed changes.  If
  79.   /// 'MustDominate' is true, the translated value must dominate
  80.   /// PredBB.  This returns true on failure and sets Addr to null.
  81.   bool PHITranslateValue(BasicBlock *CurBB, BasicBlock *PredBB,
  82.                          const DominatorTree *DT, bool MustDominate);
  83.  
  84.   /// PHITranslateWithInsertion - PHI translate this value into the specified
  85.   /// predecessor block, inserting a computation of the value if it is
  86.   /// unavailable.
  87.   ///
  88.   /// All newly created instructions are added to the NewInsts list.  This
  89.   /// returns null on failure.
  90.   ///
  91.   Value *PHITranslateWithInsertion(BasicBlock *CurBB, BasicBlock *PredBB,
  92.                                    const DominatorTree &DT,
  93.                                    SmallVectorImpl<Instruction *> &NewInsts);
  94.  
  95.   void dump() const;
  96.  
  97.   /// Verify - Check internal consistency of this data structure.  If the
  98.   /// structure is valid, it returns true.  If invalid, it prints errors and
  99.   /// returns false.
  100.   bool Verify() const;
  101.  
  102. private:
  103.   Value *PHITranslateSubExpr(Value *V, BasicBlock *CurBB, BasicBlock *PredBB,
  104.                              const DominatorTree *DT);
  105.  
  106.   /// InsertPHITranslatedSubExpr - Insert a computation of the PHI translated
  107.   /// version of 'V' for the edge PredBB->CurBB into the end of the PredBB
  108.   /// block.  All newly created instructions are added to the NewInsts list.
  109.   /// This returns null on failure.
  110.   ///
  111.   Value *InsertPHITranslatedSubExpr(Value *InVal, BasicBlock *CurBB,
  112.                                     BasicBlock *PredBB, const DominatorTree &DT,
  113.                                     SmallVectorImpl<Instruction *> &NewInsts);
  114.  
  115.   /// AddAsInput - If the specified value is an instruction, add it as an input.
  116.   Value *AddAsInput(Value *V) {
  117.     // If V is an instruction, it is now an input.
  118.     if (Instruction *VI = dyn_cast<Instruction>(V))
  119.       InstInputs.push_back(VI);
  120.     return V;
  121.   }
  122. };
  123.  
  124. } // end namespace llvm
  125.  
  126. #endif
  127.