include/llvm/Analysis/LibCallSemantics.h

   1 //===- LibCallSemantics.h - Describe library semantics --------------------===//
   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 // This file defines interfaces that can be used to describe language specific
  11 // runtime library interfaces (e.g. libc, libm, etc) to LLVM optimizers.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_ANALYSIS_LIBCALLSEMANTICS_H
  16 #define LLVM_ANALYSIS_LIBCALLSEMANTICS_H
  17
  18 #include "llvm/Analysis/AliasAnalysis.h"
  19
  20 namespace llvm {
  21 class InvokeInst;
  22
  23   /// LibCallLocationInfo - This struct describes a set of memory locations that
  24   /// are accessed by libcalls.  Identification of a location is doing with a
  25   /// simple callback function.
  26   ///
  27   /// For example, the LibCallInfo may be set up to model the behavior of
  28   /// standard libm functions.  The location that they may be interested in is
  29   /// an abstract location that represents errno for the current target.  In
  30   /// this case, a location for errno is anything such that the predicate
  31   /// returns true.  On Mac OS X, this predicate would return true if the
  32   /// pointer is the result of a call to "__error()".
  33   ///
  34   /// Locations can also be defined in a constant-sensitive way.  For example,
  35   /// it is possible to define a location that returns true iff it is passed
  36   /// into the call as a specific argument.  This is useful for modeling things
  37   /// like "printf", which can store to memory, but only through pointers passed
  38   /// with a '%n' constraint.
  39   ///
  40   struct LibCallLocationInfo {
  41     // TODO: Flags: isContextSensitive etc.
  42
  43     /// isLocation - Return a LocResult if the specified pointer refers to this
  44     /// location for the specified call site.  This returns "Yes" if we can tell
  45     /// that the pointer *does definitely* refer to the location, "No" if we can
  46     /// tell that the location *definitely does not* refer to the location, and
  47     /// returns "Unknown" if we cannot tell for certain.
  48     enum LocResult {
  49       Yes, No, Unknown
  50     };
  51     LocResult (*isLocation)(ImmutableCallSite CS, const MemoryLocation &Loc);
  52   };
  53
  54   /// LibCallFunctionInfo - Each record in the array of FunctionInfo structs
  55   /// records the behavior of one libcall that is known by the optimizer.  This
  56   /// captures things like the side effects of the call.  Side effects are
  57   /// modeled both universally (in the readnone/readonly) sense, but also
  58   /// potentially against a set of abstract locations defined by the optimizer.
  59   /// This allows an optimizer to define that some libcall (e.g. sqrt) is
  60   /// side-effect free except that it might modify errno (thus, the call is
  61   /// *not* universally readonly).  Or it might say that the side effects
  62   /// are unknown other than to say that errno is not modified.
  63   ///
  64   struct LibCallFunctionInfo {
  65     /// Name - This is the name of the libcall this describes.
  66     const char *Name;
  67
  68     /// TODO: Constant folding function: Constant* vector -> Constant*.
  69
  70     /// UniversalBehavior - This captures the absolute mod/ref behavior without
  71     /// any specific context knowledge.  For example, if the function is known
  72     /// to be readonly, this would be set to 'ref'.  If known to be readnone,
  73     /// this is set to NoModRef.
  74     AliasAnalysis::ModRefResult UniversalBehavior;
  75
  76     /// LocationMRInfo - This pair captures info about whether a specific
  77     /// location is modified or referenced by a libcall.
  78     struct LocationMRInfo {
  79       /// LocationID - ID # of the accessed location or ~0U for array end.
  80       unsigned LocationID;
  81       /// MRInfo - Mod/Ref info for this location.
  82       AliasAnalysis::ModRefResult MRInfo;
  83     };
  84
  85     /// DetailsType - Indicate the sense of the LocationDetails array.  This
  86     /// controls how the LocationDetails array is interpreted.
  87     enum {
  88       /// DoesOnly - If DetailsType is set to DoesOnly, then we know that the
  89       /// *only* mod/ref behavior of this function is captured by the
  90       /// LocationDetails array.  If we are trying to say that 'sqrt' can only
  91       /// modify errno, we'd have the {errnoloc,mod} in the LocationDetails
  92       /// array and have DetailsType set to DoesOnly.
  93       DoesOnly,
  94
  95       /// DoesNot - If DetailsType is set to DoesNot, then the sense of the
  96       /// LocationDetails array is completely inverted.  This means that we *do
  97       /// not* know everything about the side effects of this libcall, but we do
  98       /// know things that the libcall cannot do.  This is useful for complex
  99       /// functions like 'ctime' which have crazy mod/ref behavior, but are
 100       /// known to never read or write errno.  In this case, we'd have
 101       /// {errnoloc,modref} in the LocationDetails array and DetailsType would
 102       /// be set to DoesNot, indicating that ctime does not read or write the
 103       /// errno location.
 104       DoesNot
 105     } DetailsType;
 106
 107     /// LocationDetails - This is a pointer to an array of LocationMRInfo
 108     /// structs which indicates the behavior of the libcall w.r.t. specific
 109     /// locations.  For example, if this libcall is known to only modify
 110     /// 'errno', it would have a LocationDetails array with the errno ID and
 111     /// 'mod' in it.  See the DetailsType field for how this is interpreted.
 112     ///
 113     /// In the "DoesOnly" case, this information is 'may' information for: there
 114     /// is no guarantee that the specified side effect actually does happen,
 115     /// just that it could.  In the "DoesNot" case, this is 'must not' info.
 116     ///
 117     /// If this pointer is null, no details are known.
 118     ///
 119     const LocationMRInfo *LocationDetails;
 120   };
 121
 122
 123   /// LibCallInfo - Abstract interface to query about library call information.
 124   /// Instances of this class return known information about some set of
 125   /// libcalls.
 126   ///
 127   class LibCallInfo {
 128     // Implementation details of this object, private.
 129     mutable void *Impl;
 130     mutable const LibCallLocationInfo *Locations;
 131     mutable unsigned NumLocations;
 132   public:
 133     LibCallInfo() : Impl(nullptr), Locations(nullptr), NumLocations(0) {}
 134     virtual ~LibCallInfo();
 135
 136     //===------------------------------------------------------------------===//
 137     //  Accessor Methods: Efficient access to contained data.
 138     //===------------------------------------------------------------------===//
 139
 140     /// getLocationInfo - Return information about the specified LocationID.
 141     const LibCallLocationInfo &getLocationInfo(unsigned LocID) const;
 142
 143
 144     /// getFunctionInfo - Return the LibCallFunctionInfo object corresponding to
 145     /// the specified function if we have it.  If not, return null.
 146     const LibCallFunctionInfo *getFunctionInfo(const Function *F) const;
 147
 148
 149     //===------------------------------------------------------------------===//
 150     //  Implementation Methods: Subclasses should implement these.
 151     //===------------------------------------------------------------------===//
 152
 153     /// getLocationInfo - Return descriptors for the locations referenced by
 154     /// this set of libcalls.
 155     virtual unsigned getLocationInfo(const LibCallLocationInfo *&Array) const {
 156       return 0;
 157     }
 158
 159     /// getFunctionInfoArray - Return an array of descriptors that describe the
 160     /// set of libcalls represented by this LibCallInfo object.  This array is
 161     /// terminated by an entry with a NULL name.
 162     virtual const LibCallFunctionInfo *getFunctionInfoArray() const = 0;
 163   };
 164
 165   enum class EHPersonality {
 166     Unknown,
 167     GNU_Ada,
 168     GNU_C,
 169     GNU_CXX,
 170     GNU_ObjC,
 171     MSVC_X86SEH,
 172     MSVC_Win64SEH,
 173     MSVC_CXX,
 174   };
 175
 176   /// \brief See if the given exception handling personality function is one
 177   /// that we understand.  If so, return a description of it; otherwise return
 178   /// Unknown.
 179   EHPersonality classifyEHPersonality(const Value *Pers);
 180
 181   /// \brief Returns true if this personality function catches asynchronous
 182   /// exceptions.
 183   inline bool isAsynchronousEHPersonality(EHPersonality Pers) {
 184     // The two SEH personality functions can catch asynch exceptions. We assume
 185     // unknown personalities don't catch asynch exceptions.
 186     switch (Pers) {
 187     case EHPersonality::MSVC_X86SEH:
 188     case EHPersonality::MSVC_Win64SEH:
 189       return true;
 190     default: return false;
 191     }
 192     llvm_unreachable("invalid enum");
 193   }
 194
 195   /// \brief Returns true if this is an MSVC personality function.
 196   inline bool isMSVCEHPersonality(EHPersonality Pers) {
 197     // The two SEH personality functions can catch asynch exceptions. We assume
 198     // unknown personalities don't catch asynch exceptions.
 199     switch (Pers) {
 200     case EHPersonality::MSVC_CXX:
 201     case EHPersonality::MSVC_X86SEH:
 202     case EHPersonality::MSVC_Win64SEH:
 203       return true;
 204     default: return false;
 205     }
 206     llvm_unreachable("invalid enum");
 207   }
 208
 209   bool canSimplifyInvokeNoUnwind(const Function *F);
 210
 211 } // end namespace llvm
 212
 213 #endif