Line data    Source code

       1             : //===- AutoUpgrade.h - AutoUpgrade Helpers ----------------------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : //  These functions are implemented by lib/IR/AutoUpgrade.cpp.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_IR_AUTOUPGRADE_H
      15             : #define LLVM_IR_AUTOUPGRADE_H
      16             : 
      17             : #include "llvm/ADT/StringRef.h"
      18             : 
      19             : namespace llvm {
      20             :   class CallInst;
      21             :   class Constant;
      22             :   class Function;
      23             :   class Instruction;
      24             :   class MDNode;
      25             :   class Module;
      26             :   class GlobalVariable;
      27             :   class Type;
      28             :   class Value;
      29             : 
      30             :   /// This is a more granular function that simply checks an intrinsic function
      31             :   /// for upgrading, and returns true if it requires upgrading. It may return
      32             :   /// null in NewFn if the all calls to the original intrinsic function
      33             :   /// should be transformed to non-function-call instructions.
      34             :   bool UpgradeIntrinsicFunction(Function *F, Function *&NewFn);
      35             : 
      36             :   /// This is the complement to the above, replacing a specific call to an
      37             :   /// intrinsic function with a call to the specified new function.
      38             :   void UpgradeIntrinsicCall(CallInst *CI, Function *NewFn);
      39             : 
      40             :   /// This is an auto-upgrade hook for any old intrinsic function syntaxes
      41             :   /// which need to have both the function updated as well as all calls updated
      42             :   /// to the new function. This should only be run in a post-processing fashion
      43             :   /// so that it can update all calls to the old function.
      44             :   void UpgradeCallsToIntrinsic(Function* F);
      45             : 
      46             :   /// This checks for global variables which should be upgraded. It returns true
      47             :   /// if it requires upgrading.
      48             :   bool UpgradeGlobalVariable(GlobalVariable *GV);
      49             : 
      50             :   /// This checks for module flags which should be upgraded. It returns true if
      51             :   /// module is modified.
      52             :   bool UpgradeModuleFlags(Module &M);
      53             : 
      54             :   /// If the given TBAA tag uses the scalar TBAA format, create a new node
      55             :   /// corresponding to the upgrade to the struct-path aware TBAA format.
      56             :   /// Otherwise return the \p TBAANode itself.
      57             :   MDNode *UpgradeTBAANode(MDNode &TBAANode);
      58             : 
      59             :   /// This is an auto-upgrade for bitcast between pointers with different
      60             :   /// address spaces: the instruction is replaced by a pair ptrtoint+inttoptr.
      61             :   Instruction *UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy,
      62             :                                   Instruction *&Temp);
      63             : 
      64             :   /// This is an auto-upgrade for bitcast constant expression between pointers
      65             :   /// with different address spaces: the instruction is replaced by a pair
      66             :   /// ptrtoint+inttoptr.
      67             :   Value *UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy);
      68             : 
      69             :   /// Check the debug info version number, if it is out-dated, drop the debug
      70             :   /// info. Return true if module is modified.
      71             :   bool UpgradeDebugInfo(Module &M);
      72             : 
      73             :   /// Check whether a string looks like an old loop attachment tag.
      74             :   inline bool mayBeOldLoopAttachmentTag(StringRef Name) {
      75         548 :     return Name.startswith("llvm.vectorizer.");
      76             :   }
      77             : 
      78             :   /// Upgrade the loop attachment metadata node.
      79             :   MDNode *upgradeInstructionLoopAttachment(MDNode &N);
      80             : 
      81             : } // End llvm namespace
      82             : 
      83             : #endif