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 | |