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 
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/Attr.h"
15 #include "clang/AST/Expr.h"
16 #include "clang/AST/Type.h"
17 #include <optional>
18 using namespace clang;
19 
printPrettyPragma(raw_ostream & OS,const PrintingPolicy & Policy) const20 void 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.
getValueString(const PrintingPolicy & Policy) const40 std::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.
68 std::string
getDiagnosticName(const PrintingPolicy & Policy) const69 LoopHintAttr::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 
printPrettyPragma(raw_ostream & OS,const PrintingPolicy & Policy) const86 void 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 
printPrettyPragma(raw_ostream & OS,const PrintingPolicy & Policy) const136 void 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 
152 std::optional<OMPDeclareTargetDeclAttr *>
getActiveAttr(const ValueDecl * VD)153 OMPDeclareTargetDeclAttr::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 
171 std::optional<OMPDeclareTargetDeclAttr::MapTypeTy>
isDeclareTargetDeclaration(const ValueDecl * VD)172 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
173   std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
174   if (ActiveAttr)
175     return (*ActiveAttr)->getMapType();
176   return std::nullopt;
177 }
178 
179 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy>
getDeviceType(const ValueDecl * VD)180 OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
181   std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
182   if (ActiveAttr)
183     return (*ActiveAttr)->getDevType();
184   return std::nullopt;
185 }
186 
187 std::optional<SourceLocation>
getLocation(const ValueDecl * VD)188 OMPDeclareTargetDeclAttr::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 
195 namespace clang {
196 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo &TI);
197 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
198 }
199 
printPrettyPragma(raw_ostream & OS,const PrintingPolicy & Policy) const200 void 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 
getAlignment(ASTContext & Ctx) const244 unsigned 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 
270   return Ctx.getTargetDefaultAlignForAttributeAligned();
271 }
272 
273 #include "clang/AST/AttrImpl.inc"
274