CGCall.h revision 425ef72306d4ff6b3698b744353e5f0e56b4b884 
1//===----- CGCall.h - Encapsulate calling convention details ----*- 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 classes wrap the information about a call or function
11// definition used to handle ABI compliancy.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef CLANG_CODEGEN_CGCALL_H
16#define CLANG_CODEGEN_CGCALL_H
17
18#include "llvm/ADT/FoldingSet.h"
19#include "llvm/Value.h"
20#include "clang/AST/Type.h"
21#include "clang/AST/CanonicalType.h"
22
23#include "CGValue.h"
24
25// FIXME: Restructure so we don't have to expose so much stuff.
26#include "ABIInfo.h"
27
28namespace llvm {
29  struct AttributeWithIndex;
30  class Function;
31  class Type;
32  class Value;
33
34  template<typename T, unsigned> class SmallVector;
35}
36
37namespace clang {
38  class ASTContext;
39  class Decl;
40  class FunctionDecl;
41  class ObjCMethodDecl;
42  class VarDecl;
43
44namespace CodeGen {
45  typedef llvm::SmallVector<llvm::AttributeWithIndex, 8> AttributeListType;
46
47  /// CallArgList - Type for representing both the value and type of
48  /// arguments in a call.
49  typedef llvm::SmallVector<std::pair<RValue, QualType>, 16> CallArgList;
50
51  /// FunctionArgList - Type for representing both the decl and type
52  /// of parameters to a function. The decl must be either a
53  /// ParmVarDecl or ImplicitParamDecl.
54  typedef llvm::SmallVector<std::pair<const VarDecl*, QualType>,
55                            16> FunctionArgList;
56
57  /// CGFunctionInfo - Class to encapsulate the information about a
58  /// function definition.
59  class CGFunctionInfo : public llvm::FoldingSetNode {
60    struct ArgInfo {
61      CanQualType type;
62      ABIArgInfo info;
63    };
64
65    /// The LLVM::CallingConv to use for this function (as specified by the
66    /// user).
67    unsigned CallingConvention;
68
69    /// The LLVM::CallingConv to actually use for this function, which may
70    /// depend on the ABI.
71    unsigned EffectiveCallingConvention;
72
73    /// Whether this function is noreturn.
74    bool NoReturn;
75
76    unsigned NumArgs;
77    ArgInfo *Args;
78
79    /// How many arguments to pass inreg.
80    unsigned RegParm;
81
82  public:
83    typedef const ArgInfo *const_arg_iterator;
84    typedef ArgInfo *arg_iterator;
85
86    CGFunctionInfo(unsigned CallingConvention,
87                   bool NoReturn,
88                   unsigned RegParm,
89                   CanQualType ResTy,
90                   const llvm::SmallVectorImpl<CanQualType> &ArgTys);
91    ~CGFunctionInfo() { delete[] Args; }
92
93    const_arg_iterator arg_begin() const { return Args + 1; }
94    const_arg_iterator arg_end() const { return Args + 1 + NumArgs; }
95    arg_iterator arg_begin() { return Args + 1; }
96    arg_iterator arg_end() { return Args + 1 + NumArgs; }
97
98    unsigned  arg_size() const { return NumArgs; }
99
100    bool isNoReturn() const { return NoReturn; }
101
102    /// getCallingConvention - Return the user specified calling
103    /// convention.
104    unsigned getCallingConvention() const { return CallingConvention; }
105
106    /// getEffectiveCallingConvention - Return the actual calling convention to
107    /// use, which may depend on the ABI.
108    unsigned getEffectiveCallingConvention() const {
109      return EffectiveCallingConvention;
110    }
111    void setEffectiveCallingConvention(unsigned Value) {
112      EffectiveCallingConvention = Value;
113    }
114
115    unsigned getRegParm() const { return RegParm; }
116
117    CanQualType getReturnType() const { return Args[0].type; }
118
119    ABIArgInfo &getReturnInfo() { return Args[0].info; }
120    const ABIArgInfo &getReturnInfo() const { return Args[0].info; }
121
122    void Profile(llvm::FoldingSetNodeID &ID) {
123      ID.AddInteger(getCallingConvention());
124      ID.AddBoolean(NoReturn);
125      ID.AddInteger(RegParm);
126      getReturnType().Profile(ID);
127      for (arg_iterator it = arg_begin(), ie = arg_end(); it != ie; ++it)
128        it->type.Profile(ID);
129    }
130    template<class Iterator>
131    static void Profile(llvm::FoldingSetNodeID &ID,
132                        const FunctionType::ExtInfo &Info,
133                        CanQualType ResTy,
134                        Iterator begin,
135                        Iterator end) {
136      ID.AddInteger(Info.getCC());
137      ID.AddBoolean(Info.getNoReturn());
138      ID.AddInteger(Info.getRegParm());
139      ResTy.Profile(ID);
140      for (; begin != end; ++begin) {
141        CanQualType T = *begin; // force iterator to be over canonical types
142        T.Profile(ID);
143      }
144    }
145  };
146
147  /// ReturnValueSlot - Contains the address where the return value of a
148  /// function can be stored, and whether the address is volatile or not.
149  class ReturnValueSlot {
150    llvm::PointerIntPair<llvm::Value *, 1, bool> Value;
151
152  public:
153    ReturnValueSlot() {}
154    ReturnValueSlot(llvm::Value *Value, bool IsVolatile)
155      : Value(Value, IsVolatile) {}
156
157    bool isNull() const { return !getValue(); }
158
159    bool isVolatile() const { return Value.getInt(); }
160    llvm::Value *getValue() const { return Value.getPointer(); }
161  };
162
163}  // end namespace CodeGen
164}  // end namespace clang
165
166#endif
167