clang 19.0.0git
AttrImpl.cpp
Go to the documentation of this file.
1//===--- AttrImpl.cpp - Classes for representing attributes -----*- 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// This file contains out-of-line methods for Attr classes.
10//
11//===----------------------------------------------------------------------===//
12
14#include "clang/AST/Attr.h"
15#include "clang/AST/Expr.h"
16#include "clang/AST/Type.h"
17#include <optional>
18using namespace clang;
19
20void LoopHintAttr::printPrettyPragma(raw_ostream &OS,
21 const PrintingPolicy &Policy) const {
22 unsigned SpellingIndex = getAttributeSpellingListIndex();
23 // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
24 // "nounroll" is already emitted as the pragma name.
25 if (SpellingIndex == Pragma_nounroll ||
26 SpellingIndex == Pragma_nounroll_and_jam)
27 return;
28 else if (SpellingIndex == Pragma_unroll ||
29 SpellingIndex == Pragma_unroll_and_jam) {
30 OS << ' ' << getValueString(Policy);
31 return;
32 }
33
34 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
35 OS << ' ' << getOptionName(option) << getValueString(Policy);
36}
37
38// Return a string containing the loop hint argument including the
39// enclosing parentheses.
40std::string LoopHintAttr::getValueString(const PrintingPolicy &Policy) const {
41 std::string ValueName;
42 llvm::raw_string_ostream OS(ValueName);
43 OS << "(";
44 if (state == Numeric)
45 value->printPretty(OS, nullptr, Policy);
46 else if (state == FixedWidth || state == ScalableWidth) {
47 if (value) {
48 value->printPretty(OS, nullptr, Policy);
49 if (state == ScalableWidth)
50 OS << ", scalable";
51 } else if (state == ScalableWidth)
52 OS << "scalable";
53 else
54 OS << "fixed";
55 } else if (state == Enable)
56 OS << "enable";
57 else if (state == Full)
58 OS << "full";
59 else if (state == AssumeSafety)
60 OS << "assume_safety";
61 else
62 OS << "disable";
63 OS << ")";
64 return ValueName;
65}
66
67// Return a string suitable for identifying this attribute in diagnostics.
68std::string
69LoopHintAttr::getDiagnosticName(const PrintingPolicy &Policy) const {
70 unsigned SpellingIndex = getAttributeSpellingListIndex();
71 if (SpellingIndex == Pragma_nounroll)
72 return "#pragma nounroll";
73 else if (SpellingIndex == Pragma_unroll)
74 return "#pragma unroll" +
75 (option == UnrollCount ? getValueString(Policy) : "");
76 else if (SpellingIndex == Pragma_nounroll_and_jam)
77 return "#pragma nounroll_and_jam";
78 else if (SpellingIndex == Pragma_unroll_and_jam)
79 return "#pragma unroll_and_jam" +
80 (option == UnrollAndJamCount ? getValueString(Policy) : "");
81
82 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
83 return getOptionName(option) + getValueString(Policy);
84}
85
86void OMPDeclareSimdDeclAttr::printPrettyPragma(
87 raw_ostream &OS, const PrintingPolicy &Policy) const {
88 if (getBranchState() != BS_Undefined)
89 OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
90 if (auto *E = getSimdlen()) {
91 OS << " simdlen(";
92 E->printPretty(OS, nullptr, Policy);
93 OS << ")";
94 }
95 if (uniforms_size() > 0) {
96 OS << " uniform";
97 StringRef Sep = "(";
98 for (auto *E : uniforms()) {
99 OS << Sep;
100 E->printPretty(OS, nullptr, Policy);
101 Sep = ", ";
102 }
103 OS << ")";
104 }
105 alignments_iterator NI = alignments_begin();
106 for (auto *E : aligneds()) {
107 OS << " aligned(";
108 E->printPretty(OS, nullptr, Policy);
109 if (*NI) {
110 OS << ": ";
111 (*NI)->printPretty(OS, nullptr, Policy);
112 }
113 OS << ")";
114 ++NI;
115 }
116 steps_iterator I = steps_begin();
117 modifiers_iterator MI = modifiers_begin();
118 for (auto *E : linears()) {
119 OS << " linear(";
120 if (*MI != OMPC_LINEAR_unknown)
121 OS << getOpenMPSimpleClauseTypeName(llvm::omp::Clause::OMPC_linear, *MI)
122 << "(";
123 E->printPretty(OS, nullptr, Policy);
124 if (*MI != OMPC_LINEAR_unknown)
125 OS << ")";
126 if (*I) {
127 OS << ": ";
128 (*I)->printPretty(OS, nullptr, Policy);
129 }
130 OS << ")";
131 ++I;
132 ++MI;
133 }
134}
135
136void OMPDeclareTargetDeclAttr::printPrettyPragma(
137 raw_ostream &OS, const PrintingPolicy &Policy) const {
138 // Use fake syntax because it is for testing and debugging purpose only.
139 if (getDevType() != DT_Any)
140 OS << " device_type(" << ConvertDevTypeTyToStr(getDevType()) << ")";
141 if (getMapType() != MT_To && getMapType() != MT_Enter)
142 OS << ' ' << ConvertMapTypeTyToStr(getMapType());
143 if (Expr *E = getIndirectExpr()) {
144 OS << " indirect(";
145 E->printPretty(OS, nullptr, Policy);
146 OS << ")";
147 } else if (getIndirect()) {
148 OS << " indirect";
149 }
150}
151
152std::optional<OMPDeclareTargetDeclAttr *>
153OMPDeclareTargetDeclAttr::getActiveAttr(const ValueDecl *VD) {
154 if (llvm::all_of(VD->redecls(), [](const Decl *D) { return !D->hasAttrs(); }))
155 return std::nullopt;
156 unsigned Level = 0;
157 OMPDeclareTargetDeclAttr *FoundAttr = nullptr;
158 for (const Decl *D : VD->redecls()) {
159 for (auto *Attr : D->specific_attrs<OMPDeclareTargetDeclAttr>()) {
160 if (Level <= Attr->getLevel()) {
161 Level = Attr->getLevel();
162 FoundAttr = Attr;
163 }
164 }
165 }
166 if (FoundAttr)
167 return FoundAttr;
168 return std::nullopt;
169}
170
171std::optional<OMPDeclareTargetDeclAttr::MapTypeTy>
172OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
173 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
174 if (ActiveAttr)
175 return (*ActiveAttr)->getMapType();
176 return std::nullopt;
177}
178
179std::optional<OMPDeclareTargetDeclAttr::DevTypeTy>
180OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
181 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
182 if (ActiveAttr)
183 return (*ActiveAttr)->getDevType();
184 return std::nullopt;
185}
186
187std::optional<SourceLocation>
188OMPDeclareTargetDeclAttr::getLocation(const ValueDecl *VD) {
189 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
190 if (ActiveAttr)
191 return (*ActiveAttr)->getRange().getBegin();
192 return std::nullopt;
193}
194
195namespace clang {
196llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo &TI);
197llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
198}
199
200void OMPDeclareVariantAttr::printPrettyPragma(
201 raw_ostream &OS, const PrintingPolicy &Policy) const {
202 if (const Expr *E = getVariantFuncRef()) {
203 OS << "(";
204 E->printPretty(OS, nullptr, Policy);
205 OS << ")";
206 }
207 OS << " match(" << traitInfos << ")";
208
209 auto PrintExprs = [&OS, &Policy](Expr **Begin, Expr **End) {
210 for (Expr **I = Begin; I != End; ++I) {
211 assert(*I && "Expected non-null Stmt");
212 if (I != Begin)
213 OS << ",";
214 (*I)->printPretty(OS, nullptr, Policy);
215 }
216 };
217 if (adjustArgsNothing_size()) {
218 OS << " adjust_args(nothing:";
219 PrintExprs(adjustArgsNothing_begin(), adjustArgsNothing_end());
220 OS << ")";
221 }
222 if (adjustArgsNeedDevicePtr_size()) {
223 OS << " adjust_args(need_device_ptr:";
224 PrintExprs(adjustArgsNeedDevicePtr_begin(), adjustArgsNeedDevicePtr_end());
225 OS << ")";
226 }
227
228 auto PrintInteropInfo = [&OS](OMPInteropInfo *Begin, OMPInteropInfo *End) {
229 for (OMPInteropInfo *I = Begin; I != End; ++I) {
230 if (I != Begin)
231 OS << ", ";
232 OS << "interop(";
233 OS << getInteropTypeString(I);
234 OS << ")";
235 }
236 };
237 if (appendArgs_size()) {
238 OS << " append_args(";
239 PrintInteropInfo(appendArgs_begin(), appendArgs_end());
240 OS << ")";
241 }
242}
243
244unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
245 assert(!isAlignmentDependent());
246 if (getCachedAlignmentValue())
247 return *getCachedAlignmentValue();
248
249 // Handle alignmentType case.
250 if (!isAlignmentExpr()) {
251 QualType T = getAlignmentType()->getType();
252
253 // C++ [expr.alignof]p3:
254 // When alignof is applied to a reference type, the result is the
255 // alignment of the referenced type.
256 T = T.getNonReferenceType();
257
258 if (T.getQualifiers().hasUnaligned())
259 return Ctx.getCharWidth();
260
261 return Ctx.getTypeAlignInChars(T.getTypePtr()).getQuantity() *
262 Ctx.getCharWidth();
263 }
264
265 // Handle alignmentExpr case.
266 if (alignmentExpr)
267 return alignmentExpr->EvaluateKnownConstInt(Ctx).getZExtValue() *
268 Ctx.getCharWidth();
269
271}
272
273#include "clang/AST/AttrImpl.inc"
Defines the clang::ASTContext interface.
const Decl * D
Expr * E
C Language Family Type Representation.
SourceLocation Begin
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:186
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
unsigned getTargetDefaultAlignForAttributeAligned() const
Return the default alignment for attribute((aligned)) on this target, to be used if no alignment valu...
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2386
Attr - This represents one attribute.
Definition: Attr.h:42
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:185
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:565
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:1028
This represents one expression.
Definition: Expr.h:110
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
A (possibly-)qualified type.
Definition: Type.h:942
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:667
The JSON file list parser is used to communicate input to InstallAPI.
const char * getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type)
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
@ OMPC_LINEAR_unknown
Definition: OpenMPKinds.h:66
const FunctionProtoType * T
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57