contrib/llvm/include/llvm/IR/AutoUpgrade.h

   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     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