Sink more Attr.h inline methods, NFC
[lldb.git] / clang / lib / AST / AttrImpl.cpp
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 using namespace clang;
18
19 void LoopHintAttr::printPrettyPragma(raw_ostream &OS,
20                                      const PrintingPolicy &Policy) const {
21   unsigned SpellingIndex = getAttributeSpellingListIndex();
22   // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
23   // "nounroll" is already emitted as the pragma name.
24   if (SpellingIndex == Pragma_nounroll ||
25       SpellingIndex == Pragma_nounroll_and_jam)
26     return;
27   else if (SpellingIndex == Pragma_unroll ||
28            SpellingIndex == Pragma_unroll_and_jam) {
29     OS << ' ' << getValueString(Policy);
30     return;
31   }
32
33   assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
34   OS << ' ' << getOptionName(option) << getValueString(Policy);
35 }
36
37 // Return a string containing the loop hint argument including the
38 // enclosing parentheses.
39 std::string LoopHintAttr::getValueString(const PrintingPolicy &Policy) const {
40   std::string ValueName;
41   llvm::raw_string_ostream OS(ValueName);
42   OS << "(";
43   if (state == Numeric)
44     value->printPretty(OS, nullptr, Policy);
45   else if (state == Enable)
46     OS << "enable";
47   else if (state == Full)
48     OS << "full";
49   else if (state == AssumeSafety)
50     OS << "assume_safety";
51   else
52     OS << "disable";
53   OS << ")";
54   return OS.str();
55 }
56
57 // Return a string suitable for identifying this attribute in diagnostics.
58 std::string
59 LoopHintAttr::getDiagnosticName(const PrintingPolicy &Policy) const {
60   unsigned SpellingIndex = getAttributeSpellingListIndex();
61   if (SpellingIndex == Pragma_nounroll)
62     return "#pragma nounroll";
63   else if (SpellingIndex == Pragma_unroll)
64     return "#pragma unroll" +
65            (option == UnrollCount ? getValueString(Policy) : "");
66   else if (SpellingIndex == Pragma_nounroll_and_jam)
67     return "#pragma nounroll_and_jam";
68   else if (SpellingIndex == Pragma_unroll_and_jam)
69     return "#pragma unroll_and_jam" +
70            (option == UnrollAndJamCount ? getValueString(Policy) : "");
71
72   assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
73   return getOptionName(option) + getValueString(Policy);
74 }
75
76 void OMPDeclareSimdDeclAttr::printPrettyPragma(
77     raw_ostream &OS, const PrintingPolicy &Policy) const {
78   if (getBranchState() != BS_Undefined)
79     OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
80   if (auto *E = getSimdlen()) {
81     OS << " simdlen(";
82     E->printPretty(OS, nullptr, Policy);
83     OS << ")";
84   }
85   if (uniforms_size() > 0) {
86     OS << " uniform";
87     StringRef Sep = "(";
88     for (auto *E : uniforms()) {
89       OS << Sep;
90       E->printPretty(OS, nullptr, Policy);
91       Sep = ", ";
92     }
93     OS << ")";
94   }
95   alignments_iterator NI = alignments_begin();
96   for (auto *E : aligneds()) {
97     OS << " aligned(";
98     E->printPretty(OS, nullptr, Policy);
99     if (*NI) {
100       OS << ": ";
101       (*NI)->printPretty(OS, nullptr, Policy);
102     }
103     OS << ")";
104     ++NI;
105   }
106   steps_iterator I = steps_begin();
107   modifiers_iterator MI = modifiers_begin();
108   for (auto *E : linears()) {
109     OS << " linear(";
110     if (*MI != OMPC_LINEAR_unknown)
111       OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "(";
112     E->printPretty(OS, nullptr, Policy);
113     if (*MI != OMPC_LINEAR_unknown)
114       OS << ")";
115     if (*I) {
116       OS << ": ";
117       (*I)->printPretty(OS, nullptr, Policy);
118     }
119     OS << ")";
120     ++I;
121     ++MI;
122   }
123 }
124
125 void OMPDeclareTargetDeclAttr::printPrettyPragma(
126     raw_ostream &OS, const PrintingPolicy &Policy) const {
127   // Use fake syntax because it is for testing and debugging purpose only.
128   if (getDevType() != DT_Any)
129     OS << " device_type(" << ConvertDevTypeTyToStr(getDevType()) << ")";
130   if (getMapType() != MT_To)
131     OS << ' ' << ConvertMapTypeTyToStr(getMapType());
132 }
133
134 llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy>
135 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
136   if (!VD->hasAttrs())
137     return llvm::None;
138   if (const auto *Attr = VD->getAttr<OMPDeclareTargetDeclAttr>())
139     return Attr->getMapType();
140
141   return llvm::None;
142 }
143
144 llvm::Optional<OMPDeclareTargetDeclAttr::DevTypeTy>
145 OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
146   if (!VD->hasAttrs())
147     return llvm::None;
148   if (const auto *Attr = VD->getAttr<OMPDeclareTargetDeclAttr>())
149     return Attr->getDevType();
150
151   return llvm::None;
152 }
153
154 void OMPDeclareVariantAttr::printPrettyPragma(
155     raw_ostream &OS, const PrintingPolicy &Policy) const {
156   if (const Expr *E = getVariantFuncRef()) {
157     OS << "(";
158     E->printPretty(OS, nullptr, Policy);
159     OS << ")";
160   }
161   OS << " match(";
162   traitInfos.print(OS, Policy);
163   OS << ")";
164 }
165
166 #include "clang/AST/AttrImpl.inc"