CGCall.h revision 360784 
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
27namespace llvm {
28class AttributeList;
29class Function;
30class Type;
31class Value;
32} // namespace llvm
33
34namespace clang {
35class ASTContext;
36class Decl;
37class FunctionDecl;
38class ObjCMethodDecl;
39class VarDecl;
40
41namespace CodeGen {
42
43/// Abstract information about a function or function prototype.
44class CGCalleeInfo {
45  /// The function prototype of the callee.
46  const FunctionProtoType *CalleeProtoTy;
47  /// The function declaration of the callee.
48  GlobalDecl CalleeDecl;
49
50public:
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.
66class 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
106public:
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 forDirect(llvm::FunctionCallee functionPtr,
139                            const CGCalleeInfo &abstractInfo = CGCalleeInfo()) {
140    return CGCallee(abstractInfo, functionPtr.getCallee());
141  }
142
143  static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr,
144                             llvm::FunctionType *FTy) {
145    CGCallee result(SpecialKind::Virtual);
146    result.VirtualInfo.CE = CE;
147    result.VirtualInfo.MD = MD;
148    result.VirtualInfo.Addr = Addr;
149    result.VirtualInfo.FTy = FTy;
150    return result;
151  }
152
153  bool isBuiltin() const {
154    return KindOrFunctionPointer == SpecialKind::Builtin;
155  }
156  const FunctionDecl *getBuiltinDecl() const {
157    assert(isBuiltin());
158    return BuiltinInfo.Decl;
159  }
160  unsigned getBuiltinID() const {
161    assert(isBuiltin());
162    return BuiltinInfo.ID;
163  }
164
165  bool isPseudoDestructor() const {
166    return KindOrFunctionPointer == SpecialKind::PseudoDestructor;
167  }
168  const CXXPseudoDestructorExpr *getPseudoDestructorExpr() const {
169    assert(isPseudoDestructor());
170    return PseudoDestructorInfo.Expr;
171  }
172
173  bool isOrdinary() const {
174    return uintptr_t(KindOrFunctionPointer) > uintptr_t(SpecialKind::Last);
175  }
176  CGCalleeInfo getAbstractInfo() const {
177    if (isVirtual())
178      return VirtualInfo.MD;
179    assert(isOrdinary());
180    return AbstractInfo;
181  }
182  llvm::Value *getFunctionPointer() const {
183    assert(isOrdinary());
184    return reinterpret_cast<llvm::Value *>(uintptr_t(KindOrFunctionPointer));
185  }
186  void setFunctionPointer(llvm::Value *functionPtr) {
187    assert(isOrdinary());
188    KindOrFunctionPointer = SpecialKind(uintptr_t(functionPtr));
189  }
190
191  bool isVirtual() const {
192    return KindOrFunctionPointer == SpecialKind::Virtual;
193  }
194  const CallExpr *getVirtualCallExpr() const {
195    assert(isVirtual());
196    return VirtualInfo.CE;
197  }
198  GlobalDecl getVirtualMethodDecl() const {
199    assert(isVirtual());
200    return VirtualInfo.MD;
201  }
202  Address getThisAddress() const {
203    assert(isVirtual());
204    return VirtualInfo.Addr;
205  }
206  llvm::FunctionType *getVirtualFunctionType() const {
207    assert(isVirtual());
208    return VirtualInfo.FTy;
209  }
210
211  /// If this is a delayed callee computation of some sort, prepare
212  /// a concrete callee.
213  CGCallee prepareConcreteCallee(CodeGenFunction &CGF) const;
214};
215
216struct CallArg {
217private:
218  union {
219    RValue RV;
220    LValue LV; /// The argument is semantically a load from this l-value.
221  };
222  bool HasLV;
223
224  /// A data-flow flag to make sure getRValue and/or copyInto are not
225  /// called twice for duplicated IR emission.
226  mutable bool IsUsed;
227
228public:
229  QualType Ty;
230  CallArg(RValue rv, QualType ty)
231      : RV(rv), HasLV(false), IsUsed(false), Ty(ty) {}
232  CallArg(LValue lv, QualType ty)
233      : LV(lv), HasLV(true), IsUsed(false), Ty(ty) {}
234  bool hasLValue() const { return HasLV; }
235  QualType getType() const { return Ty; }
236
237  /// \returns an independent RValue. If the CallArg contains an LValue,
238  /// a temporary copy is returned.
239  RValue getRValue(CodeGenFunction &CGF) const;
240
241  LValue getKnownLValue() const {
242    assert(HasLV && !IsUsed);
243    return LV;
244  }
245  RValue getKnownRValue() const {
246    assert(!HasLV && !IsUsed);
247    return RV;
248  }
249  void setRValue(RValue _RV) {
250    assert(!HasLV);
251    RV = _RV;
252  }
253
254  bool isAggregate() const { return HasLV || RV.isAggregate(); }
255
256  void copyInto(CodeGenFunction &CGF, Address A) const;
257};
258
259/// CallArgList - Type for representing both the value and type of
260/// arguments in a call.
261class CallArgList : public SmallVector<CallArg, 8> {
262public:
263  CallArgList() : StackBase(nullptr) {}
264
265  struct Writeback {
266    /// The original argument.  Note that the argument l-value
267    /// is potentially null.
268    LValue Source;
269
270    /// The temporary alloca.
271    Address Temporary;
272
273    /// A value to "use" after the writeback, or null.
274    llvm::Value *ToUse;
275  };
276
277  struct CallArgCleanup {
278    EHScopeStack::stable_iterator Cleanup;
279
280    /// The "is active" insertion point.  This instruction is temporary and
281    /// will be removed after insertion.
282    llvm::Instruction *IsActiveIP;
283  };
284
285  void add(RValue rvalue, QualType type) { push_back(CallArg(rvalue, type)); }
286
287  void addUncopiedAggregate(LValue LV, QualType type) {
288    push_back(CallArg(LV, type));
289  }
290
291  /// Add all the arguments from another CallArgList to this one. After doing
292  /// this, the old CallArgList retains its list of arguments, but must not
293  /// be used to emit a call.
294  void addFrom(const CallArgList &other) {
295    insert(end(), other.begin(), other.end());
296    Writebacks.insert(Writebacks.end(), other.Writebacks.begin(),
297                      other.Writebacks.end());
298    CleanupsToDeactivate.insert(CleanupsToDeactivate.end(),
299                                other.CleanupsToDeactivate.begin(),
300                                other.CleanupsToDeactivate.end());
301    assert(!(StackBase && other.StackBase) && "can't merge stackbases");
302    if (!StackBase)
303      StackBase = other.StackBase;
304  }
305
306  void addWriteback(LValue srcLV, Address temporary, llvm::Value *toUse) {
307    Writeback writeback = {srcLV, temporary, toUse};
308    Writebacks.push_back(writeback);
309  }
310
311  bool hasWritebacks() const { return !Writebacks.empty(); }
312
313  typedef llvm::iterator_range<SmallVectorImpl<Writeback>::const_iterator>
314      writeback_const_range;
315
316  writeback_const_range writebacks() const {
317    return writeback_const_range(Writebacks.begin(), Writebacks.end());
318  }
319
320  void addArgCleanupDeactivation(EHScopeStack::stable_iterator Cleanup,
321                                 llvm::Instruction *IsActiveIP) {
322    CallArgCleanup ArgCleanup;
323    ArgCleanup.Cleanup = Cleanup;
324    ArgCleanup.IsActiveIP = IsActiveIP;
325    CleanupsToDeactivate.push_back(ArgCleanup);
326  }
327
328  ArrayRef<CallArgCleanup> getCleanupsToDeactivate() const {
329    return CleanupsToDeactivate;
330  }
331
332  void allocateArgumentMemory(CodeGenFunction &CGF);
333  llvm::Instruction *getStackBase() const { return StackBase; }
334  void freeArgumentMemory(CodeGenFunction &CGF) const;
335
336  /// Returns if we're using an inalloca struct to pass arguments in
337  /// memory.
338  bool isUsingInAlloca() const { return StackBase; }
339
340private:
341  SmallVector<Writeback, 1> Writebacks;
342
343  /// Deactivate these cleanups immediately before making the call.  This
344  /// is used to cleanup objects that are owned by the callee once the call
345  /// occurs.
346  SmallVector<CallArgCleanup, 1> CleanupsToDeactivate;
347
348  /// The stacksave call.  It dominates all of the argument evaluation.
349  llvm::CallInst *StackBase;
350};
351
352/// FunctionArgList - Type for representing both the decl and type
353/// of parameters to a function. The decl must be either a
354/// ParmVarDecl or ImplicitParamDecl.
355class FunctionArgList : public SmallVector<const VarDecl *, 16> {};
356
357/// ReturnValueSlot - Contains the address where the return value of a
358/// function can be stored, and whether the address is volatile or not.
359class ReturnValueSlot {
360  llvm::PointerIntPair<llvm::Value *, 2, unsigned int> Value;
361  CharUnits Alignment;
362
363  // Return value slot flags
364  enum Flags {
365    IS_VOLATILE = 0x1,
366    IS_UNUSED = 0x2,
367  };
368
369public:
370  ReturnValueSlot() {}
371  ReturnValueSlot(Address Addr, bool IsVolatile, bool IsUnused = false)
372      : Value(Addr.isValid() ? Addr.getPointer() : nullptr,
373              (IsVolatile ? IS_VOLATILE : 0) | (IsUnused ? IS_UNUSED : 0)),
374        Alignment(Addr.isValid() ? Addr.getAlignment() : CharUnits::Zero()) {}
375
376  bool isNull() const { return !getValue().isValid(); }
377
378  bool isVolatile() const { return Value.getInt() & IS_VOLATILE; }
379  Address getValue() const { return Address(Value.getPointer(), Alignment); }
380  bool isUnused() const { return Value.getInt() & IS_UNUSED; }
381};
382
383} // end namespace CodeGen
384} // end namespace clang
385
386#endif
387