xref: /freebsd/contrib/llvm-project/clang/lib/CodeGen/CGCall.h (revision 4b50c451720d8b427757a6da1dd2bb4c52cd9e35) 
1 //===----- CGCall.h - Encapsulate calling convention details ----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // These classes wrap the information about a call or function
10 // definition used to handle ABI compliancy.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LIB_CODEGEN_CGCALL_H
15 #define LLVM_CLANG_LIB_CODEGEN_CGCALL_H
16 
17 #include "CGValue.h"
18 #include "EHScopeStack.h"
19 #include "clang/AST/CanonicalType.h"
20 #include "clang/AST/GlobalDecl.h"
21 #include "clang/AST/Type.h"
22 #include "llvm/IR/Value.h"
23 
24 // FIXME: Restructure so we don't have to expose so much stuff.
25 #include "ABIInfo.h"
26 
27 namespace llvm {
28 class AttributeList;
29 class Function;
30 class Type;
31 class Value;
32 }
33 
34 namespace clang {
35   class ASTContext;
36   class Decl;
37   class FunctionDecl;
38   class ObjCMethodDecl;
39   class VarDecl;
40 
41 namespace CodeGen {
42 
43 /// Abstract information about a function or function prototype.
44 class CGCalleeInfo {
45   /// The function prototype of the callee.
46   const FunctionProtoType *CalleeProtoTy;
47   /// The function declaration of the callee.
48   GlobalDecl CalleeDecl;
49 
50 public:
51   explicit CGCalleeInfo() : CalleeProtoTy(nullptr), CalleeDecl() {}
52   CGCalleeInfo(const FunctionProtoType *calleeProtoTy, GlobalDecl calleeDecl)
53       : CalleeProtoTy(calleeProtoTy), CalleeDecl(calleeDecl) {}
54   CGCalleeInfo(const FunctionProtoType *calleeProtoTy)
55       : CalleeProtoTy(calleeProtoTy), CalleeDecl() {}
56   CGCalleeInfo(GlobalDecl calleeDecl)
57       : CalleeProtoTy(nullptr), CalleeDecl(calleeDecl) {}
58 
59   const FunctionProtoType *getCalleeFunctionProtoType() const {
60     return CalleeProtoTy;
61   }
62   const GlobalDecl getCalleeDecl() const { return CalleeDecl; }
63   };
64 
65   /// All available information about a concrete callee.
66   class CGCallee {
67     enum class SpecialKind : uintptr_t {
68       Invalid,
69       Builtin,
70       PseudoDestructor,
71       Virtual,
72 
73       Last = Virtual
74     };
75 
76     struct BuiltinInfoStorage {
77       const FunctionDecl *Decl;
78       unsigned ID;
79     };
80     struct PseudoDestructorInfoStorage {
81       const CXXPseudoDestructorExpr *Expr;
82     };
83     struct VirtualInfoStorage {
84       const CallExpr *CE;
85       GlobalDecl MD;
86       Address Addr;
87       llvm::FunctionType *FTy;
88     };
89 
90     SpecialKind KindOrFunctionPointer;
91     union {
92       CGCalleeInfo AbstractInfo;
93       BuiltinInfoStorage BuiltinInfo;
94       PseudoDestructorInfoStorage PseudoDestructorInfo;
95       VirtualInfoStorage VirtualInfo;
96     };
97 
98     explicit CGCallee(SpecialKind kind) : KindOrFunctionPointer(kind) {}
99 
100     CGCallee(const FunctionDecl *builtinDecl, unsigned builtinID)
101         : KindOrFunctionPointer(SpecialKind::Builtin) {
102       BuiltinInfo.Decl = builtinDecl;
103       BuiltinInfo.ID = builtinID;
104     }
105 
106   public:
107     CGCallee() : KindOrFunctionPointer(SpecialKind::Invalid) {}
108 
109     /// Construct a callee.  Call this constructor directly when this
110     /// isn't a direct call.
111     CGCallee(const CGCalleeInfo &abstractInfo, llvm::Value *functionPtr)
112         : KindOrFunctionPointer(SpecialKind(uintptr_t(functionPtr))) {
113       AbstractInfo = abstractInfo;
114       assert(functionPtr && "configuring callee without function pointer");
115       assert(functionPtr->getType()->isPointerTy());
116       assert(functionPtr->getType()->getPointerElementType()->isFunctionTy());
117     }
118 
119     static CGCallee forBuiltin(unsigned builtinID,
120                                const FunctionDecl *builtinDecl) {
121       CGCallee result(SpecialKind::Builtin);
122       result.BuiltinInfo.Decl = builtinDecl;
123       result.BuiltinInfo.ID = builtinID;
124       return result;
125     }
126 
127     static CGCallee forPseudoDestructor(const CXXPseudoDestructorExpr *E) {
128       CGCallee result(SpecialKind::PseudoDestructor);
129       result.PseudoDestructorInfo.Expr = E;
130       return result;
131     }
132 
133     static CGCallee forDirect(llvm::Constant *functionPtr,
134                         const CGCalleeInfo &abstractInfo = CGCalleeInfo()) {
135       return CGCallee(abstractInfo, functionPtr);
136     }
137 
138     static CGCallee
139     forDirect(llvm::FunctionCallee functionPtr,
140               const CGCalleeInfo &abstractInfo = CGCalleeInfo()) {
141       return CGCallee(abstractInfo, functionPtr.getCallee());
142     }
143 
144     static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr,
145                                llvm::FunctionType *FTy) {
146       CGCallee result(SpecialKind::Virtual);
147       result.VirtualInfo.CE = CE;
148       result.VirtualInfo.MD = MD;
149       result.VirtualInfo.Addr = Addr;
150       result.VirtualInfo.FTy = FTy;
151       return result;
152     }
153 
154     bool isBuiltin() const {
155       return KindOrFunctionPointer == SpecialKind::Builtin;
156     }
157     const FunctionDecl *getBuiltinDecl() const {
158       assert(isBuiltin());
159       return BuiltinInfo.Decl;
160     }
161     unsigned getBuiltinID() const {
162       assert(isBuiltin());
163       return BuiltinInfo.ID;
164     }
165 
166     bool isPseudoDestructor() const {
167       return KindOrFunctionPointer == SpecialKind::PseudoDestructor;
168     }
169     const CXXPseudoDestructorExpr *getPseudoDestructorExpr() const {
170       assert(isPseudoDestructor());
171       return PseudoDestructorInfo.Expr;
172     }
173 
174     bool isOrdinary() const {
175       return uintptr_t(KindOrFunctionPointer) > uintptr_t(SpecialKind::Last);
176     }
177     CGCalleeInfo getAbstractInfo() const {
178       if (isVirtual())
179         return VirtualInfo.MD;
180       assert(isOrdinary());
181       return AbstractInfo;
182     }
183     llvm::Value *getFunctionPointer() const {
184       assert(isOrdinary());
185       return reinterpret_cast<llvm::Value*>(uintptr_t(KindOrFunctionPointer));
186     }
187     void setFunctionPointer(llvm::Value *functionPtr) {
188       assert(isOrdinary());
189       KindOrFunctionPointer = SpecialKind(uintptr_t(functionPtr));
190     }
191 
192     bool isVirtual() const {
193       return KindOrFunctionPointer == SpecialKind::Virtual;
194     }
195     const CallExpr *getVirtualCallExpr() const {
196       assert(isVirtual());
197       return VirtualInfo.CE;
198     }
199     GlobalDecl getVirtualMethodDecl() const {
200       assert(isVirtual());
201       return VirtualInfo.MD;
202     }
203     Address getThisAddress() const {
204       assert(isVirtual());
205       return VirtualInfo.Addr;
206     }
207     llvm::FunctionType *getVirtualFunctionType() const {
208       assert(isVirtual());
209       return VirtualInfo.FTy;
210     }
211 
212     /// If this is a delayed callee computation of some sort, prepare
213     /// a concrete callee.
214     CGCallee prepareConcreteCallee(CodeGenFunction &CGF) const;
215   };
216 
217   struct CallArg {
218   private:
219     union {
220       RValue RV;
221       LValue LV; /// The argument is semantically a load from this l-value.
222     };
223     bool HasLV;
224 
225     /// A data-flow flag to make sure getRValue and/or copyInto are not
226     /// called twice for duplicated IR emission.
227     mutable bool IsUsed;
228 
229   public:
230     QualType Ty;
231     CallArg(RValue rv, QualType ty)
232         : RV(rv), HasLV(false), IsUsed(false), Ty(ty) {}
233     CallArg(LValue lv, QualType ty)
234         : LV(lv), HasLV(true), IsUsed(false), Ty(ty) {}
235     bool hasLValue() const { return HasLV; }
236     QualType getType() const { return Ty; }
237 
238     /// \returns an independent RValue. If the CallArg contains an LValue,
239     /// a temporary copy is returned.
240     RValue getRValue(CodeGenFunction &CGF) const;
241 
242     LValue getKnownLValue() const {
243       assert(HasLV && !IsUsed);
244       return LV;
245     }
246     RValue getKnownRValue() const {
247       assert(!HasLV && !IsUsed);
248       return RV;
249     }
250     void setRValue(RValue _RV) {
251       assert(!HasLV);
252       RV = _RV;
253     }
254 
255     bool isAggregate() const { return HasLV || RV.isAggregate(); }
256 
257     void copyInto(CodeGenFunction &CGF, Address A) const;
258   };
259 
260   /// CallArgList - Type for representing both the value and type of
261   /// arguments in a call.
262   class CallArgList :
263     public SmallVector<CallArg, 8> {
264   public:
265     CallArgList() : StackBase(nullptr) {}
266 
267     struct Writeback {
268       /// The original argument.  Note that the argument l-value
269       /// is potentially null.
270       LValue Source;
271 
272       /// The temporary alloca.
273       Address Temporary;
274 
275       /// A value to "use" after the writeback, or null.
276       llvm::Value *ToUse;
277     };
278 
279     struct CallArgCleanup {
280       EHScopeStack::stable_iterator Cleanup;
281 
282       /// The "is active" insertion point.  This instruction is temporary and
283       /// will be removed after insertion.
284       llvm::Instruction *IsActiveIP;
285     };
286 
287     void add(RValue rvalue, QualType type) { push_back(CallArg(rvalue, type)); }
288 
289     void addUncopiedAggregate(LValue LV, QualType type) {
290       push_back(CallArg(LV, type));
291     }
292 
293     /// Add all the arguments from another CallArgList to this one. After doing
294     /// this, the old CallArgList retains its list of arguments, but must not
295     /// be used to emit a call.
296     void addFrom(const CallArgList &other) {
297       insert(end(), other.begin(), other.end());
298       Writebacks.insert(Writebacks.end(),
299                         other.Writebacks.begin(), other.Writebacks.end());
300       CleanupsToDeactivate.insert(CleanupsToDeactivate.end(),
301                                   other.CleanupsToDeactivate.begin(),
302                                   other.CleanupsToDeactivate.end());
303       assert(!(StackBase && other.StackBase) && "can't merge stackbases");
304       if (!StackBase)
305         StackBase = other.StackBase;
306     }
307 
308     void addWriteback(LValue srcLV, Address temporary,
309                       llvm::Value *toUse) {
310       Writeback writeback = { srcLV, temporary, toUse };
311       Writebacks.push_back(writeback);
312     }
313 
314     bool hasWritebacks() const { return !Writebacks.empty(); }
315 
316     typedef llvm::iterator_range<SmallVectorImpl<Writeback>::const_iterator>
317       writeback_const_range;
318 
319     writeback_const_range writebacks() const {
320       return writeback_const_range(Writebacks.begin(), Writebacks.end());
321     }
322 
323     void addArgCleanupDeactivation(EHScopeStack::stable_iterator Cleanup,
324                                    llvm::Instruction *IsActiveIP) {
325       CallArgCleanup ArgCleanup;
326       ArgCleanup.Cleanup = Cleanup;
327       ArgCleanup.IsActiveIP = IsActiveIP;
328       CleanupsToDeactivate.push_back(ArgCleanup);
329     }
330 
331     ArrayRef<CallArgCleanup> getCleanupsToDeactivate() const {
332       return CleanupsToDeactivate;
333     }
334 
335     void allocateArgumentMemory(CodeGenFunction &CGF);
336     llvm::Instruction *getStackBase() const { return StackBase; }
337     void freeArgumentMemory(CodeGenFunction &CGF) const;
338 
339     /// Returns if we're using an inalloca struct to pass arguments in
340     /// memory.
341     bool isUsingInAlloca() const { return StackBase; }
342 
343   private:
344     SmallVector<Writeback, 1> Writebacks;
345 
346     /// Deactivate these cleanups immediately before making the call.  This
347     /// is used to cleanup objects that are owned by the callee once the call
348     /// occurs.
349     SmallVector<CallArgCleanup, 1> CleanupsToDeactivate;
350 
351     /// The stacksave call.  It dominates all of the argument evaluation.
352     llvm::CallInst *StackBase;
353   };
354 
355   /// FunctionArgList - Type for representing both the decl and type
356   /// of parameters to a function. The decl must be either a
357   /// ParmVarDecl or ImplicitParamDecl.
358   class FunctionArgList : public SmallVector<const VarDecl*, 16> {
359   };
360 
361   /// ReturnValueSlot - Contains the address where the return value of a
362   /// function can be stored, and whether the address is volatile or not.
363   class ReturnValueSlot {
364     llvm::PointerIntPair<llvm::Value *, 2, unsigned int> Value;
365     CharUnits Alignment;
366 
367     // Return value slot flags
368     enum Flags {
369       IS_VOLATILE = 0x1,
370       IS_UNUSED = 0x2,
371     };
372 
373   public:
374     ReturnValueSlot() {}
375     ReturnValueSlot(Address Addr, bool IsVolatile, bool IsUnused = false)
376       : Value(Addr.isValid() ? Addr.getPointer() : nullptr,
377               (IsVolatile ? IS_VOLATILE : 0) | (IsUnused ? IS_UNUSED : 0)),
378         Alignment(Addr.isValid() ? Addr.getAlignment() : CharUnits::Zero()) {}
379 
380     bool isNull() const { return !getValue().isValid(); }
381 
382     bool isVolatile() const { return Value.getInt() & IS_VOLATILE; }
383     Address getValue() const { return Address(Value.getPointer(), Alignment); }
384     bool isUnused() const { return Value.getInt() & IS_UNUSED; }
385   };
386 
387 }  // end namespace CodeGen
388 }  // end namespace clang
389 
390 #endif
391