Coverage Report

Created: 2019-03-22 08:08

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/CodeGen/SwiftCallingConv.h
Line
Count
Source
1
//==-- SwiftCallingConv.h - Swift ABI lowering ------------------*- 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
// Defines constants and types related to Swift ABI lowering.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#ifndef LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H
14
#define LLVM_CLANG_CODEGEN_SWIFTCALLINGCONV_H
15
16
#include "clang/AST/CanonicalType.h"
17
#include "clang/AST/CharUnits.h"
18
#include "clang/AST/Type.h"
19
#include "llvm/Support/TrailingObjects.h"
20
#include <cassert>
21
22
namespace llvm {
23
  class IntegerType;
24
  class Type;
25
  class StructType;
26
  class VectorType;
27
}
28
29
namespace clang {
30
class Decl;
31
class FieldDecl;
32
class ASTRecordLayout;
33
34
namespace CodeGen {
35
class ABIArgInfo;
36
class CodeGenModule;
37
class CGFunctionInfo;
38
39
namespace swiftcall {
40
41
class SwiftAggLowering {
42
  CodeGenModule &CGM;
43
44
  struct StorageEntry {
45
    CharUnits Begin;
46
    CharUnits End;
47
    llvm::Type *Type;
48
49
24
    CharUnits getWidth() const {
50
24
      return End - Begin;
51
24
    }
52
  };
53
  SmallVector<StorageEntry, 4> Entries;
54
  bool Finished = false;
55
56
public:
57
1.06k
  SwiftAggLowering(CodeGenModule &CGM) : CGM(CGM) {}
58
59
16
  void addOpaqueData(CharUnits begin, CharUnits end) {
60
16
    addEntry(nullptr, begin, end);
61
16
  }
62
63
  void addTypedData(QualType type, CharUnits begin);
64
  void addTypedData(const RecordDecl *record, CharUnits begin);
65
  void addTypedData(const RecordDecl *record, CharUnits begin,
66
                    const ASTRecordLayout &layout);
67
  void addTypedData(llvm::Type *type, CharUnits begin);
68
  void addTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
69
70
  void finish();
71
72
  /// Does this lowering require passing any data?
73
1.06k
  bool empty() const {
74
1.06k
    assert(Finished && "didn't finish lowering before calling empty()");
75
1.06k
    return Entries.empty();
76
1.06k
  }
77
78
  /// According to the target Swift ABI, should a value with this lowering
79
  /// be passed indirectly?
80
  ///
81
  /// Note that this decision is based purely on the data layout of the
82
  /// value and does not consider whether the type is address-only,
83
  /// must be passed indirectly to match a function abstraction pattern, or
84
  /// anything else that is expected to be handled by high-level lowering.
85
  ///
86
  /// \param asReturnValue - if true, answer whether it should be passed
87
  ///   indirectly as a return value; if false, answer whether it should be
88
  ///   passed indirectly as an argument
89
  bool shouldPassIndirectly(bool asReturnValue) const;
90
91
  using EnumerationCallback =
92
    llvm::function_ref<void(CharUnits offset, CharUnits end, llvm::Type *type)>;
93
94
  /// Enumerate the expanded components of this type.
95
  ///
96
  /// The component types will always be legal vector, floating-point,
97
  /// integer, or pointer types.
98
  void enumerateComponents(EnumerationCallback callback) const;
99
100
  /// Return the types for a coerce-and-expand operation.
101
  ///
102
  /// The first type matches the memory layout of the data that's been
103
  /// added to this structure, including explicit [N x i8] arrays for any
104
  /// internal padding.
105
  ///
106
  /// The second type removes any internal padding members and, if only
107
  /// one element remains, is simply that element type.
108
  std::pair<llvm::StructType*, llvm::Type*> getCoerceAndExpandTypes() const;
109
110
private:
111
  void addBitFieldData(const FieldDecl *field, CharUnits begin,
112
                       uint64_t bitOffset);
113
  void addLegalTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
114
  void addEntry(llvm::Type *type, CharUnits begin, CharUnits end);
115
  void splitVectorEntry(unsigned index);
116
  static bool shouldMergeEntries(const StorageEntry &first,
117
                                 const StorageEntry &second,
118
                                 CharUnits chunkSize);
119
};
120
121
/// Should an aggregate which expands to the given type sequence
122
/// be passed/returned indirectly under swiftcall?
123
bool shouldPassIndirectly(CodeGenModule &CGM,
124
                          ArrayRef<llvm::Type*> types,
125
                          bool asReturnValue);
126
127
/// Return the maximum voluntary integer size for the current target.
128
CharUnits getMaximumVoluntaryIntegerSize(CodeGenModule &CGM);
129
130
/// Return the Swift CC's notion of the natural alignment of a type.
131
CharUnits getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type);
132
133
/// Is the given integer type "legal" for Swift's perspective on the
134
/// current platform?
135
bool isLegalIntegerType(CodeGenModule &CGM, llvm::IntegerType *type);
136
137
/// Is the given vector type "legal" for Swift's perspective on the
138
/// current platform?
139
bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
140
                       llvm::VectorType *vectorTy);
141
bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
142
                       llvm::Type *eltTy, unsigned numElts);
143
144
/// Minimally split a legal vector type.
145
std::pair<llvm::Type*, unsigned>
146
splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
147
                     llvm::VectorType *vectorTy);
148
149
/// Turn a vector type in a sequence of legal component vector types.
150
///
151
/// The caller may assume that the sum of the data sizes of the resulting
152
/// types will equal the data size of the vector type.
153
void legalizeVectorType(CodeGenModule &CGM, CharUnits vectorSize,
154
                        llvm::VectorType *vectorTy,
155
                        llvm::SmallVectorImpl<llvm::Type*> &types);
156
157
/// Is the given record type required to be passed and returned indirectly
158
/// because of language restrictions?
159
///
160
/// This considers *only* mandatory indirectness due to language restrictions,
161
/// such as C++'s non-trivially-copyable types and Objective-C's __weak
162
/// references.  A record for which this returns true may still be passed
163
/// indirectly for other reasons, such as being too large to fit in a
164
/// reasonable number of registers.
165
bool mustPassRecordIndirectly(CodeGenModule &CGM, const RecordDecl *record);
166
167
/// Classify the rules for how to return a particular type.
168
ABIArgInfo classifyReturnType(CodeGenModule &CGM, CanQualType type);
169
170
/// Classify the rules for how to pass a particular type.
171
ABIArgInfo classifyArgumentType(CodeGenModule &CGM, CanQualType type);
172
173
/// Compute the ABI information of a swiftcall function.  This is a
174
/// private interface for Clang.
175
void computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI);
176
177
/// Is swifterror lowered to a register by the target ABI?
178
bool isSwiftErrorLoweredInRegister(CodeGenModule &CGM);
179
180
} // end namespace swiftcall
181
} // end namespace CodeGen
182
} // end namespace clang
183
184
#endif