LLVM  3.7.0
LibCallSemantics.h
Go to the documentation of this file.
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 
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  ///
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 {
50  };
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  ///
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.
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.
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.
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.
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  ///
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,
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.
184  // The two SEH personality functions can catch asynch exceptions. We assume
185  // unknown personalities don't catch asynch exceptions.
186  switch (Pers) {
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) {
203  return true;
204  default: return false;
205  }
206  llvm_unreachable("invalid enum");
207  }
208 
209  /// \brief Return true if this personality may be safely removed if there
210  /// are no invoke instructions remaining in the current function.
211  inline bool isNoOpWithoutInvoke(EHPersonality Pers) {
212  switch (Pers) {
214  return false;
215  // All known personalities currently have this behavior
216  default: return true;
217  }
218  llvm_unreachable("invalid enum");
219  }
220 
221  bool canSimplifyInvokeNoUnwind(const Function *F);
222 
223 } // end namespace llvm
224 
225 #endif
const LibCallFunctionInfo * getFunctionInfo(const Function *F) const
getFunctionInfo - Return the LibCallFunctionInfo object corresponding to the specified function if we...
const LocationMRInfo * LocationDetails
LocationDetails - This is a pointer to an array of LocationMRInfo structs which indicates the behavio...
DoesNot - If DetailsType is set to DoesNot, then the sense of the LocationDetails array is completely...
DoesOnly - If DetailsType is set to DoesOnly, then we know that the only mod/ref behavior of this fun...
F(f)
LibCallInfo - Abstract interface to query about library call information.
unsigned LocationID
LocationID - ID # of the accessed location or ~0U for array end.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
const char * Name
Name - This is the name of the libcall this describes.
bool canSimplifyInvokeNoUnwind(const Function *F)
LibCallFunctionInfo - Each record in the array of FunctionInfo structs records the behavior of one li...
LocResult
isLocation - Return a LocResult if the specified pointer refers to this location for the specified ca...
enum llvm::LibCallFunctionInfo::@26 DetailsType
DetailsType - Indicate the sense of the LocationDetails array.
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
AliasAnalysis::ModRefResult UniversalBehavior
TODO: Constant folding function: Constant* vector -> Constant*.
virtual const LibCallFunctionInfo * getFunctionInfoArray() const =0
getFunctionInfoArray - Return an array of descriptors that describe the set of libcalls represented b...
AliasAnalysis::ModRefResult MRInfo
MRInfo - Mod/Ref info for this location.
Representation for a specific memory location.
virtual unsigned getLocationInfo(const LibCallLocationInfo *&Array) const
getLocationInfo - Return descriptors for the locations referenced by this set of libcalls.
LocResult(* isLocation)(ImmutableCallSite CS, const MemoryLocation &Loc)
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:418
bool isAsynchronousEHPersonality(EHPersonality Pers)
Returns true if this personality function catches asynchronous exceptions.
ModRefResult
Simple mod/ref information...
const LibCallLocationInfo & getLocationInfo(unsigned LocID) const
getLocationInfo - Return information about the specified LocationID.
LocationMRInfo - This pair captures info about whether a specific location is modified or referenced ...
bool isNoOpWithoutInvoke(EHPersonality Pers)
Return true if this personality may be safely removed if there are no invoke instructions remaining i...
bool isMSVCEHPersonality(EHPersonality Pers)
Returns true if this is an MSVC personality function.
LibCallLocationInfo - This struct describes a set of memory locations that are accessed by libcalls...