1 //===--- SemaStmtAttr.cpp - Statement Attribute Handling ------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file implements stmt-related attribute processing.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Sema/SemaInternal.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/Basic/SourceManager.h"
17 #include "clang/Sema/DelayedDiagnostic.h"
18 #include "clang/Sema/Lookup.h"
19 #include "clang/Sema/LoopHint.h"
20 #include "clang/Sema/ScopeInfo.h"
21 #include "llvm/ADT/StringExtras.h"
22 
23 using namespace clang;
24 using namespace sema;
25 
26 static Attr *handleFallThroughAttr(Sema &S, Stmt *St, const AttributeList &A,
27                                    SourceRange Range) {
28   FallThroughAttr Attr(A.getRange(), S.Context,
29                        A.getAttributeSpellingListIndex());
30   if (!isa<NullStmt>(St)) {
31     S.Diag(A.getRange().getBegin(), diag::err_fallthrough_attr_wrong_target)
32         << Attr.getSpelling() << St->getLocStart();
33     if (isa<SwitchCase>(St)) {
34       SourceLocation L = S.getLocForEndOfToken(Range.getEnd());
35       S.Diag(L, diag::note_fallthrough_insert_semi_fixit)
36           << FixItHint::CreateInsertion(L, ";");
37     }
38     return nullptr;
39   }
40   auto *FnScope = S.getCurFunction();
41   if (FnScope->SwitchStack.empty()) {
42     S.Diag(A.getRange().getBegin(), diag::err_fallthrough_attr_outside_switch);
43     return nullptr;
44   }
45 
46   // If this is spelled as the standard C++1z attribute, but not in C++1z, warn
47   // about using it as an extension.
48   if (!S.getLangOpts().CPlusPlus1z && A.isCXX11Attribute() &&
49       !A.getScopeName())
50     S.Diag(A.getLoc(), diag::ext_cxx1z_attr) << A.getName();
51 
52   FnScope->setHasFallthroughStmt();
53   return ::new (S.Context) auto(Attr);
54 }
55 
56 static Attr *handleSuppressAttr(Sema &S, Stmt *St, const AttributeList &A,
57                                 SourceRange Range) {
58   if (A.getNumArgs() < 1) {
59     S.Diag(A.getLoc(), diag::err_attribute_too_few_arguments)
60         << A.getName() << 1;
61     return nullptr;
62   }
63 
64   std::vector<StringRef> DiagnosticIdentifiers;
65   for (unsigned I = 0, E = A.getNumArgs(); I != E; ++I) {
66     StringRef RuleName;
67 
68     if (!S.checkStringLiteralArgumentAttr(A, I, RuleName, nullptr))
69       return nullptr;
70 
71     // FIXME: Warn if the rule name is unknown. This is tricky because only
72     // clang-tidy knows about available rules.
73     DiagnosticIdentifiers.push_back(RuleName);
74   }
75 
76   return ::new (S.Context) SuppressAttr(
77       A.getRange(), S.Context, DiagnosticIdentifiers.data(),
78       DiagnosticIdentifiers.size(), A.getAttributeSpellingListIndex());
79 }
80 
81 static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A,
82                                 SourceRange) {
83   IdentifierLoc *PragmaNameLoc = A.getArgAsIdent(0);
84   IdentifierLoc *OptionLoc = A.getArgAsIdent(1);
85   IdentifierLoc *StateLoc = A.getArgAsIdent(2);
86   Expr *ValueExpr = A.getArgAsExpr(3);
87 
88   bool PragmaUnroll = PragmaNameLoc->Ident->getName() == "unroll";
89   bool PragmaNoUnroll = PragmaNameLoc->Ident->getName() == "nounroll";
90   if (St->getStmtClass() != Stmt::DoStmtClass &&
91       St->getStmtClass() != Stmt::ForStmtClass &&
92       St->getStmtClass() != Stmt::CXXForRangeStmtClass &&
93       St->getStmtClass() != Stmt::WhileStmtClass) {
94     const char *Pragma =
95         llvm::StringSwitch<const char *>(PragmaNameLoc->Ident->getName())
96             .Case("unroll", "#pragma unroll")
97             .Case("nounroll", "#pragma nounroll")
98             .Default("#pragma clang loop");
99     S.Diag(St->getLocStart(), diag::err_pragma_loop_precedes_nonloop) << Pragma;
100     return nullptr;
101   }
102 
103   LoopHintAttr::Spelling Spelling;
104   LoopHintAttr::OptionType Option;
105   LoopHintAttr::LoopHintState State;
106   if (PragmaNoUnroll) {
107     // #pragma nounroll
108     Spelling = LoopHintAttr::Pragma_nounroll;
109     Option = LoopHintAttr::Unroll;
110     State = LoopHintAttr::Disable;
111   } else if (PragmaUnroll) {
112     Spelling = LoopHintAttr::Pragma_unroll;
113     if (ValueExpr) {
114       // #pragma unroll N
115       Option = LoopHintAttr::UnrollCount;
116       State = LoopHintAttr::Numeric;
117     } else {
118       // #pragma unroll
119       Option = LoopHintAttr::Unroll;
120       State = LoopHintAttr::Enable;
121     }
122   } else {
123     // #pragma clang loop ...
124     Spelling = LoopHintAttr::Pragma_clang_loop;
125     assert(OptionLoc && OptionLoc->Ident &&
126            "Attribute must have valid option info.");
127     Option = llvm::StringSwitch<LoopHintAttr::OptionType>(
128                  OptionLoc->Ident->getName())
129                  .Case("vectorize", LoopHintAttr::Vectorize)
130                  .Case("vectorize_width", LoopHintAttr::VectorizeWidth)
131                  .Case("interleave", LoopHintAttr::Interleave)
132                  .Case("interleave_count", LoopHintAttr::InterleaveCount)
133                  .Case("unroll", LoopHintAttr::Unroll)
134                  .Case("unroll_count", LoopHintAttr::UnrollCount)
135                  .Case("distribute", LoopHintAttr::Distribute)
136                  .Default(LoopHintAttr::Vectorize);
137     if (Option == LoopHintAttr::VectorizeWidth ||
138         Option == LoopHintAttr::InterleaveCount ||
139         Option == LoopHintAttr::UnrollCount) {
140       assert(ValueExpr && "Attribute must have a valid value expression.");
141       if (S.CheckLoopHintExpr(ValueExpr, St->getLocStart()))
142         return nullptr;
143       State = LoopHintAttr::Numeric;
144     } else if (Option == LoopHintAttr::Vectorize ||
145                Option == LoopHintAttr::Interleave ||
146                Option == LoopHintAttr::Unroll ||
147                Option == LoopHintAttr::Distribute) {
148       assert(StateLoc && StateLoc->Ident && "Loop hint must have an argument");
149       if (StateLoc->Ident->isStr("disable"))
150         State = LoopHintAttr::Disable;
151       else if (StateLoc->Ident->isStr("assume_safety"))
152         State = LoopHintAttr::AssumeSafety;
153       else if (StateLoc->Ident->isStr("full"))
154         State = LoopHintAttr::Full;
155       else if (StateLoc->Ident->isStr("enable"))
156         State = LoopHintAttr::Enable;
157       else
158         llvm_unreachable("bad loop hint argument");
159     } else
160       llvm_unreachable("bad loop hint");
161   }
162 
163   return LoopHintAttr::CreateImplicit(S.Context, Spelling, Option, State,
164                                       ValueExpr, A.getRange());
165 }
166 
167 static void
168 CheckForIncompatibleAttributes(Sema &S,
169                                const SmallVectorImpl<const Attr *> &Attrs) {
170   // There are 4 categories of loop hints attributes: vectorize, interleave,
171   // unroll and distribute. Except for distribute they come in two variants: a
172   // state form and a numeric form.  The state form selectively
173   // defaults/enables/disables the transformation for the loop (for unroll,
174   // default indicates full unrolling rather than enabling the transformation).
175   // The numeric form form provides an integer hint (for example, unroll count)
176   // to the transformer. The following array accumulates the hints encountered
177   // while iterating through the attributes to check for compatibility.
178   struct {
179     const LoopHintAttr *StateAttr;
180     const LoopHintAttr *NumericAttr;
181   } HintAttrs[] = {{nullptr, nullptr},
182                    {nullptr, nullptr},
183                    {nullptr, nullptr},
184                    {nullptr, nullptr}};
185 
186   for (const auto *I : Attrs) {
187     const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(I);
188 
189     // Skip non loop hint attributes
190     if (!LH)
191       continue;
192 
193     LoopHintAttr::OptionType Option = LH->getOption();
194     enum { Vectorize, Interleave, Unroll, Distribute } Category;
195     switch (Option) {
196     case LoopHintAttr::Vectorize:
197     case LoopHintAttr::VectorizeWidth:
198       Category = Vectorize;
199       break;
200     case LoopHintAttr::Interleave:
201     case LoopHintAttr::InterleaveCount:
202       Category = Interleave;
203       break;
204     case LoopHintAttr::Unroll:
205     case LoopHintAttr::UnrollCount:
206       Category = Unroll;
207       break;
208     case LoopHintAttr::Distribute:
209       // Perform the check for duplicated 'distribute' hints.
210       Category = Distribute;
211       break;
212     };
213 
214     auto &CategoryState = HintAttrs[Category];
215     const LoopHintAttr *PrevAttr;
216     if (Option == LoopHintAttr::Vectorize ||
217         Option == LoopHintAttr::Interleave || Option == LoopHintAttr::Unroll ||
218         Option == LoopHintAttr::Distribute) {
219       // Enable|Disable|AssumeSafety hint.  For example, vectorize(enable).
220       PrevAttr = CategoryState.StateAttr;
221       CategoryState.StateAttr = LH;
222     } else {
223       // Numeric hint.  For example, vectorize_width(8).
224       PrevAttr = CategoryState.NumericAttr;
225       CategoryState.NumericAttr = LH;
226     }
227 
228     PrintingPolicy Policy(S.Context.getLangOpts());
229     SourceLocation OptionLoc = LH->getRange().getBegin();
230     if (PrevAttr)
231       // Cannot specify same type of attribute twice.
232       S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
233           << /*Duplicate=*/true << PrevAttr->getDiagnosticName(Policy)
234           << LH->getDiagnosticName(Policy);
235 
236     if (CategoryState.StateAttr && CategoryState.NumericAttr &&
237         (Category == Unroll ||
238          CategoryState.StateAttr->getState() == LoopHintAttr::Disable)) {
239       // Disable hints are not compatible with numeric hints of the same
240       // category.  As a special case, numeric unroll hints are also not
241       // compatible with enable or full form of the unroll pragma because these
242       // directives indicate full unrolling.
243       S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
244           << /*Duplicate=*/false
245           << CategoryState.StateAttr->getDiagnosticName(Policy)
246           << CategoryState.NumericAttr->getDiagnosticName(Policy);
247     }
248   }
249 }
250 
251 static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const AttributeList &A,
252                                     SourceRange Range) {
253   // Although the feature was introduced only in OpenCL C v2.0 s6.11.5, it's
254   // useful for OpenCL 1.x too and doesn't require HW support.
255   // opencl_unroll_hint can have 0 arguments (compiler
256   // determines unrolling factor) or 1 argument (the unroll factor provided
257   // by the user).
258 
259   unsigned NumArgs = A.getNumArgs();
260 
261   if (NumArgs > 1) {
262     S.Diag(A.getLoc(), diag::err_attribute_too_many_arguments) << A.getName()
263                                                                << 1;
264     return nullptr;
265   }
266 
267   unsigned UnrollFactor = 0;
268 
269   if (NumArgs == 1) {
270     Expr *E = A.getArgAsExpr(0);
271     llvm::APSInt ArgVal(32);
272 
273     if (!E->isIntegerConstantExpr(ArgVal, S.Context)) {
274       S.Diag(A.getLoc(), diag::err_attribute_argument_type)
275           << A.getName() << AANT_ArgumentIntegerConstant << E->getSourceRange();
276       return nullptr;
277     }
278 
279     int Val = ArgVal.getSExtValue();
280 
281     if (Val <= 0) {
282       S.Diag(A.getRange().getBegin(),
283              diag::err_attribute_requires_positive_integer)
284           << A.getName();
285       return nullptr;
286     }
287     UnrollFactor = Val;
288   }
289 
290   return OpenCLUnrollHintAttr::CreateImplicit(S.Context, UnrollFactor);
291 }
292 
293 static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const AttributeList &A,
294                                   SourceRange Range) {
295   switch (A.getKind()) {
296   case AttributeList::UnknownAttribute:
297     S.Diag(A.getLoc(), A.isDeclspecAttribute() ?
298            diag::warn_unhandled_ms_attribute_ignored :
299            diag::warn_unknown_attribute_ignored) << A.getName();
300     return nullptr;
301   case AttributeList::AT_FallThrough:
302     return handleFallThroughAttr(S, St, A, Range);
303   case AttributeList::AT_LoopHint:
304     return handleLoopHintAttr(S, St, A, Range);
305   case AttributeList::AT_OpenCLUnrollHint:
306     return handleOpenCLUnrollHint(S, St, A, Range);
307   case AttributeList::AT_Suppress:
308     return handleSuppressAttr(S, St, A, Range);
309   default:
310     // if we're here, then we parsed a known attribute, but didn't recognize
311     // it as a statement attribute => it is declaration attribute
312     S.Diag(A.getRange().getBegin(), diag::err_decl_attribute_invalid_on_stmt)
313         << A.getName() << St->getLocStart();
314     return nullptr;
315   }
316 }
317 
318 StmtResult Sema::ProcessStmtAttributes(Stmt *S, AttributeList *AttrList,
319                                        SourceRange Range) {
320   SmallVector<const Attr*, 8> Attrs;
321   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
322     if (Attr *a = ProcessStmtAttribute(*this, S, *l, Range))
323       Attrs.push_back(a);
324   }
325 
326   CheckForIncompatibleAttributes(*this, Attrs);
327 
328   if (Attrs.empty())
329     return S;
330 
331   return ActOnAttributedStmt(Range.getBegin(), Attrs, S);
332 }
333