1//===----- ABIInfo.h - ABI information access & encapsulation ---*- 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#ifndef LLVM_CLANG_LIB_CODEGEN_ABIINFO_H
10#define LLVM_CLANG_LIB_CODEGEN_ABIINFO_H
11
12#include "clang/AST/Attr.h"
13#include "clang/AST/CharUnits.h"
14#include "clang/AST/Type.h"
15#include "llvm/IR/CallingConv.h"
16#include "llvm/IR/Type.h"
17
18namespace llvm {
19class Value;
20class LLVMContext;
21class DataLayout;
22class Type;
23} // namespace llvm
24
25namespace clang {
26class ASTContext;
27class CodeGenOptions;
28class TargetInfo;
29
30namespace CodeGen {
31class ABIArgInfo;
32class Address;
33class CGCXXABI;
34class CGFunctionInfo;
35class CodeGenFunction;
36class CodeGenTypes;
37class RValue;
38class AggValueSlot;
39
40// FIXME: All of this stuff should be part of the target interface
41// somehow. It is currently here because it is not clear how to factor
42// the targets to support this, since the Targets currently live in a
43// layer below types n'stuff.
44
45/// ABIInfo - Target specific hooks for defining how a type should be
46/// passed or returned from functions.
47class ABIInfo {
48protected:
49 CodeGen::CodeGenTypes &CGT;
50 llvm::CallingConv::ID RuntimeCC;
51
52public:
53 ABIInfo(CodeGen::CodeGenTypes &cgt)
54 : CGT(cgt), RuntimeCC(llvm::CallingConv::C) {}
55
56 virtual ~ABIInfo();
57
58 virtual bool allowBFloatArgsAndRet() const { return false; }
59
60 CodeGen::CGCXXABI &getCXXABI() const;
61 ASTContext &getContext() const;
62 llvm::LLVMContext &getVMContext() const;
63 const llvm::DataLayout &getDataLayout() const;
64 const TargetInfo &getTarget() const;
65 const CodeGenOptions &getCodeGenOpts() const;
66
67 /// Return the calling convention to use for system runtime
68 /// functions.
69 llvm::CallingConv::ID getRuntimeCC() const { return RuntimeCC; }
70
71 virtual void computeInfo(CodeGen::CGFunctionInfo &FI) const = 0;
72
73 /// EmitVAArg - Emit the target dependent code to load a value of
74 /// \arg Ty from the va_list pointed to by \arg VAListAddr.
75
76 // FIXME: This is a gaping layering violation if we wanted to drop
77 // the ABI information any lower than CodeGen. Of course, for
78 // VAArg handling it has to be at this level; there is no way to
79 // abstract this out.
80 virtual RValue EmitVAArg(CodeGen::CodeGenFunction &CGF,
81 CodeGen::Address VAListAddr, QualType Ty,
82 AggValueSlot Slot) const = 0;
83
84 bool isAndroid() const;
85 bool isOHOSFamily() const;
86
87 /// Emit the target dependent code to load a value of
88 /// \arg Ty from the \c __builtin_ms_va_list pointed to by \arg VAListAddr.
89 virtual RValue EmitMSVAArg(CodeGen::CodeGenFunction &CGF,
90 CodeGen::Address VAListAddr, QualType Ty,
91 AggValueSlot Slot) const;
92
93 virtual bool isHomogeneousAggregateBaseType(QualType Ty) const;
94
95 virtual bool isHomogeneousAggregateSmallEnough(const Type *Base,
96 uint64_t Members) const;
97 virtual bool isZeroLengthBitfieldPermittedInHomogeneousAggregate() const;
98
99 /// isHomogeneousAggregate - Return true if a type is an ELFv2 homogeneous
100 /// aggregate. Base is set to the base element type, and Members is set
101 /// to the number of base elements.
102 bool isHomogeneousAggregate(QualType Ty, const Type *&Base,
103 uint64_t &Members) const;
104
105 // Implement the Type::IsPromotableIntegerType for ABI specific needs. The
106 // only difference is that this considers bit-precise integer types as well.
107 bool isPromotableIntegerTypeForABI(QualType Ty) const;
108
109 /// A convenience method to return an indirect ABIArgInfo with an
110 /// expected alignment equal to the ABI alignment of the given type.
111 CodeGen::ABIArgInfo
112 getNaturalAlignIndirect(QualType Ty, bool ByVal = true, bool Realign = false,
113 llvm::Type *Padding = nullptr) const;
114
115 CodeGen::ABIArgInfo getNaturalAlignIndirectInReg(QualType Ty,
116 bool Realign = false) const;
117
118 virtual void appendAttributeMangling(TargetAttr *Attr,
119 raw_ostream &Out) const;
120 virtual void appendAttributeMangling(TargetVersionAttr *Attr,
121 raw_ostream &Out) const;
122 virtual void appendAttributeMangling(TargetClonesAttr *Attr, unsigned Index,
123 raw_ostream &Out) const;
124 virtual void appendAttributeMangling(StringRef AttrStr,
125 raw_ostream &Out) const;
126};
127
128/// Target specific hooks for defining how a type should be passed or returned
129/// from functions with one of the Swift calling conventions.
130class SwiftABIInfo {
131protected:
132 CodeGenTypes &CGT;
133 bool SwiftErrorInRegister;
134
135 bool occupiesMoreThan(ArrayRef<llvm::Type *> scalarTypes,
136 unsigned maxAllRegisters) const;
137
138public:
139 SwiftABIInfo(CodeGen::CodeGenTypes &CGT, bool SwiftErrorInRegister)
140 : CGT(CGT), SwiftErrorInRegister(SwiftErrorInRegister) {}
141
142 virtual ~SwiftABIInfo();
143
144 /// Returns true if an aggregate which expands to the given type sequence
145 /// should be passed / returned indirectly.
146 virtual bool shouldPassIndirectly(ArrayRef<llvm::Type *> ComponentTys,
147 bool AsReturnValue) const;
148
149 /// Returns true if the given vector type is legal from Swift's calling
150 /// convention perspective.
151 virtual bool isLegalVectorType(CharUnits VectorSize, llvm::Type *EltTy,
152 unsigned NumElts) const;
153
154 /// Returns true if swifterror is lowered to a register by the target ABI.
155 bool isSwiftErrorInRegister() const { return SwiftErrorInRegister; };
156};
157} // end namespace CodeGen
158} // end namespace clang
159
160#endif
161