• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
22   /// LibCallLocationInfo - This struct describes a set of memory locations that
23   /// are accessed by libcalls.  Identification of a location is doing with a
24   /// simple callback function.
25   ///
26   /// For example, the LibCallInfo may be set up to model the behavior of
27   /// standard libm functions.  The location that they may be interested in is
28   /// an abstract location that represents errno for the current target.  In
29   /// this case, a location for errno is anything such that the predicate
30   /// returns true.  On Mac OS/X, this predicate would return true if the
31   /// pointer is the result of a call to "__error()".
32   ///
33   /// Locations can also be defined in a constant-sensitive way.  For example,
34   /// it is possible to define a location that returns true iff it is passed
35   /// into the call as a specific argument.  This is useful for modeling things
36   /// like "printf", which can store to memory, but only through pointers passed
37   /// with a '%n' constraint.
38   ///
39   struct LibCallLocationInfo {
40     // TODO: Flags: isContextSensitive etc.
41 
42     /// isLocation - Return a LocResult if the specified pointer refers to this
43     /// location for the specified call site.  This returns "Yes" if we can tell
44     /// that the pointer *does definitely* refer to the location, "No" if we can
45     /// tell that the location *definitely does not* refer to the location, and
46     /// returns "Unknown" if we cannot tell for certain.
47     enum LocResult {
48       Yes, No, Unknown
49     };
50     LocResult (*isLocation)(ImmutableCallSite CS,
51                             const AliasAnalysis::Location &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:
LibCallInfo()133     LibCallInfo() : Impl(0), Locations(0), 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.
getLocationInfo(const LibCallLocationInfo * & Array)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 } // end namespace llvm
166 
167 #endif
168