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