← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/Analysis/LibCallSemantics.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/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
 
 
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 Value *Ptr, unsigned Size);
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(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.
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