xref: /minix3/external/bsd/llvm/dist/clang/lib/Parse/ParseOpenMP.cpp (revision f4a2713ac843a11c696ec80c0a5e3e5d80b4d338) 
1 //===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===//
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 /// \file
10 /// \brief This file implements parsing of all OpenMP directives and clauses.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/StmtOpenMP.h"
16 #include "clang/Parse/ParseDiagnostic.h"
17 #include "clang/Parse/Parser.h"
18 #include "clang/Sema/Scope.h"
19 #include "llvm/ADT/PointerIntPair.h"
20 #include "RAIIObjectsForParser.h"
21 using namespace clang;
22 
23 //===----------------------------------------------------------------------===//
24 // OpenMP declarative directives.
25 //===----------------------------------------------------------------------===//
26 
27 /// \brief Parsing of declarative OpenMP directives.
28 ///
29 ///       threadprivate-directive:
30 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
31 ///
32 Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
33   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
34   ParenBraceBracketBalancer BalancerRAIIObj(*this);
35 
36   SourceLocation Loc = ConsumeToken();
37   SmallVector<Expr *, 5> Identifiers;
38   OpenMPDirectiveKind DKind = Tok.isAnnotation() ?
39                                   OMPD_unknown :
40                                   getOpenMPDirectiveKind(PP.getSpelling(Tok));
41 
42   switch (DKind) {
43   case OMPD_threadprivate:
44     ConsumeToken();
45     if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, true)) {
46       // The last seen token is annot_pragma_openmp_end - need to check for
47       // extra tokens.
48       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
49         Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
50           << getOpenMPDirectiveName(OMPD_threadprivate);
51         SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
52       }
53       // Skip the last annot_pragma_openmp_end.
54       ConsumeToken();
55       return Actions.ActOnOpenMPThreadprivateDirective(Loc,
56                                                        Identifiers);
57     }
58     break;
59   case OMPD_unknown:
60     Diag(Tok, diag::err_omp_unknown_directive);
61     break;
62   case OMPD_parallel:
63   case OMPD_task:
64   case NUM_OPENMP_DIRECTIVES:
65     Diag(Tok, diag::err_omp_unexpected_directive)
66       << getOpenMPDirectiveName(DKind);
67     break;
68   }
69   SkipUntil(tok::annot_pragma_openmp_end);
70   return DeclGroupPtrTy();
71 }
72 
73 /// \brief Parsing of declarative or executable OpenMP directives.
74 ///
75 ///       threadprivate-directive:
76 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
77 ///         annot_pragma_openmp_end
78 ///
79 ///       parallel-directive:
80 ///         annot_pragma_openmp 'parallel' {clause} annot_pragma_openmp_end
81 ///
82 StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective() {
83   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
84   ParenBraceBracketBalancer BalancerRAIIObj(*this);
85   SmallVector<Expr *, 5> Identifiers;
86   SmallVector<OMPClause *, 5> Clauses;
87   SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, NUM_OPENMP_CLAUSES>
88                                                FirstClauses(NUM_OPENMP_CLAUSES);
89   const unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
90                               Scope::OpenMPDirectiveScope;
91   SourceLocation Loc = ConsumeToken(), EndLoc;
92   OpenMPDirectiveKind DKind = Tok.isAnnotation() ?
93                                   OMPD_unknown :
94                                   getOpenMPDirectiveKind(PP.getSpelling(Tok));
95   // Name of critical directive.
96   DeclarationNameInfo DirName;
97   StmtResult Directive = StmtError();
98 
99   switch (DKind) {
100   case OMPD_threadprivate:
101     ConsumeToken();
102     if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, false)) {
103       // The last seen token is annot_pragma_openmp_end - need to check for
104       // extra tokens.
105       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
106         Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
107           << getOpenMPDirectiveName(OMPD_threadprivate);
108         SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
109       }
110       DeclGroupPtrTy Res =
111         Actions.ActOnOpenMPThreadprivateDirective(Loc,
112                                                   Identifiers);
113       Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
114     }
115     SkipUntil(tok::annot_pragma_openmp_end);
116     break;
117   case OMPD_parallel: {
118     ConsumeToken();
119 
120     Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope());
121 
122     while (Tok.isNot(tok::annot_pragma_openmp_end)) {
123       OpenMPClauseKind CKind = Tok.isAnnotation() ?
124                                   OMPC_unknown :
125                                   getOpenMPClauseKind(PP.getSpelling(Tok));
126       OMPClause *Clause = ParseOpenMPClause(DKind, CKind,
127                                             !FirstClauses[CKind].getInt());
128       FirstClauses[CKind].setInt(true);
129       if (Clause) {
130         FirstClauses[CKind].setPointer(Clause);
131         Clauses.push_back(Clause);
132       }
133 
134       // Skip ',' if any.
135       if (Tok.is(tok::comma))
136         ConsumeToken();
137     }
138     // End location of the directive.
139     EndLoc = Tok.getLocation();
140     // Consume final annot_pragma_openmp_end.
141     ConsumeToken();
142 
143     StmtResult AssociatedStmt;
144     bool CreateDirective = true;
145     ParseScope OMPDirectiveScope(this, ScopeFlags);
146     {
147       // The body is a block scope like in Lambdas and Blocks.
148       Sema::CompoundScopeRAII CompoundScope(Actions);
149       Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_OpenMP, 1);
150       Actions.ActOnStartOfCompoundStmt();
151       // Parse statement
152       AssociatedStmt = ParseStatement();
153       Actions.ActOnFinishOfCompoundStmt();
154       if (!AssociatedStmt.isUsable()) {
155         Actions.ActOnCapturedRegionError();
156         CreateDirective = false;
157       } else {
158         AssociatedStmt = Actions.ActOnCapturedRegionEnd(AssociatedStmt.take());
159         CreateDirective = AssociatedStmt.isUsable();
160       }
161     }
162     if (CreateDirective)
163       Directive = Actions.ActOnOpenMPExecutableDirective(DKind, Clauses,
164                                                          AssociatedStmt.take(),
165                                                          Loc, EndLoc);
166 
167     // Exit scope.
168     Actions.EndOpenMPDSABlock(Directive.get());
169     OMPDirectiveScope.Exit();
170     }
171     break;
172   case OMPD_unknown:
173     Diag(Tok, diag::err_omp_unknown_directive);
174     SkipUntil(tok::annot_pragma_openmp_end);
175     break;
176   case OMPD_task:
177   case NUM_OPENMP_DIRECTIVES:
178     Diag(Tok, diag::err_omp_unexpected_directive)
179       << getOpenMPDirectiveName(DKind);
180     SkipUntil(tok::annot_pragma_openmp_end);
181     break;
182   }
183   return Directive;
184 }
185 
186 /// \brief Parses list of simple variables for '#pragma omp threadprivate'
187 /// directive.
188 ///
189 ///   simple-variable-list:
190 ///         '(' id-expression {, id-expression} ')'
191 ///
192 bool Parser::ParseOpenMPSimpleVarList(OpenMPDirectiveKind Kind,
193                                       SmallVectorImpl<Expr *> &VarList,
194                                       bool AllowScopeSpecifier) {
195   VarList.clear();
196   // Parse '('.
197   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
198   if (T.expectAndConsume(diag::err_expected_lparen_after,
199                          getOpenMPDirectiveName(Kind)))
200     return true;
201   bool IsCorrect = true;
202   bool NoIdentIsFound = true;
203 
204   // Read tokens while ')' or annot_pragma_openmp_end is not found.
205   while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) {
206     CXXScopeSpec SS;
207     SourceLocation TemplateKWLoc;
208     UnqualifiedId Name;
209     // Read var name.
210     Token PrevTok = Tok;
211     NoIdentIsFound = false;
212 
213     if (AllowScopeSpecifier && getLangOpts().CPlusPlus &&
214         ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false)) {
215       IsCorrect = false;
216       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
217                 StopBeforeMatch);
218     } else if (ParseUnqualifiedId(SS, false, false, false, ParsedType(),
219                                   TemplateKWLoc, Name)) {
220       IsCorrect = false;
221       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
222                 StopBeforeMatch);
223     } else if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren) &&
224                Tok.isNot(tok::annot_pragma_openmp_end)) {
225       IsCorrect = false;
226       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
227                 StopBeforeMatch);
228       Diag(PrevTok.getLocation(), diag::err_expected_ident)
229         << SourceRange(PrevTok.getLocation(), PrevTokLocation);
230     } else {
231       DeclarationNameInfo NameInfo = Actions.GetNameFromUnqualifiedId(Name);
232       ExprResult Res = Actions.ActOnOpenMPIdExpression(getCurScope(), SS,
233                                                        NameInfo);
234       if (Res.isUsable())
235         VarList.push_back(Res.take());
236     }
237     // Consume ','.
238     if (Tok.is(tok::comma)) {
239       ConsumeToken();
240     }
241   }
242 
243   if (NoIdentIsFound) {
244     Diag(Tok, diag::err_expected_ident);
245     IsCorrect = false;
246   }
247 
248   // Parse ')'.
249   IsCorrect = !T.consumeClose() && IsCorrect;
250 
251   return !IsCorrect && VarList.empty();
252 }
253 
254 /// \brief Parsing of OpenMP clauses.
255 ///
256 ///    clause:
257 ///       default-clause|private-clause|firstprivate-clause|shared-clause
258 ///
259 OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
260                                      OpenMPClauseKind CKind, bool FirstClause) {
261   OMPClause *Clause = 0;
262   bool ErrorFound = false;
263   // Check if clause is allowed for the given directive.
264   if (CKind != OMPC_unknown && !isAllowedClauseForDirective(DKind, CKind)) {
265     Diag(Tok, diag::err_omp_unexpected_clause)
266       << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
267     ErrorFound = true;
268   }
269 
270   switch (CKind) {
271   case OMPC_default:
272     // OpenMP [2.9.3.1, Restrictions]
273     //  Only a single default clause may be specified on a parallel or task
274     //  directive.
275     if (!FirstClause) {
276       Diag(Tok, diag::err_omp_more_one_clause)
277            << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind);
278     }
279 
280     Clause = ParseOpenMPSimpleClause(CKind);
281     break;
282   case OMPC_private:
283   case OMPC_firstprivate:
284   case OMPC_shared:
285     Clause = ParseOpenMPVarListClause(CKind);
286     break;
287   case OMPC_unknown:
288     Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
289       << getOpenMPDirectiveName(DKind);
290     SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
291     break;
292   case OMPC_threadprivate:
293   case NUM_OPENMP_CLAUSES:
294     Diag(Tok, diag::err_omp_unexpected_clause)
295       << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
296     SkipUntil(tok::comma, tok::annot_pragma_openmp_end, StopBeforeMatch);
297     break;
298   }
299   return ErrorFound ? 0 : Clause;
300 }
301 
302 /// \brief Parsing of simple OpenMP clauses like 'default'.
303 ///
304 ///    default-clause:
305 ///         'default' '(' 'none' | 'shared' ')
306 ///
307 OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind) {
308   SourceLocation Loc = Tok.getLocation();
309   SourceLocation LOpen = ConsumeToken();
310   // Parse '('.
311   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
312   if (T.expectAndConsume(diag::err_expected_lparen_after,
313                          getOpenMPClauseName(Kind)))
314     return 0;
315 
316   unsigned Type = Tok.isAnnotation() ?
317                      unsigned(OMPC_DEFAULT_unknown) :
318                      getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok));
319   SourceLocation TypeLoc = Tok.getLocation();
320   if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
321       Tok.isNot(tok::annot_pragma_openmp_end))
322     ConsumeAnyToken();
323 
324   // Parse ')'.
325   T.consumeClose();
326 
327   return Actions.ActOnOpenMPSimpleClause(Kind, Type, TypeLoc, LOpen, Loc,
328                                          Tok.getLocation());
329 }
330 
331 /// \brief Parsing of OpenMP clause 'private', 'firstprivate',
332 /// 'shared', 'copyin', or 'reduction'.
333 ///
334 ///    private-clause:
335 ///       'private' '(' list ')'
336 ///    firstprivate-clause:
337 ///       'firstprivate' '(' list ')'
338 ///    shared-clause:
339 ///       'shared' '(' list ')'
340 ///
341 OMPClause *Parser::ParseOpenMPVarListClause(OpenMPClauseKind Kind) {
342   SourceLocation Loc = Tok.getLocation();
343   SourceLocation LOpen = ConsumeToken();
344   // Parse '('.
345   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
346   if (T.expectAndConsume(diag::err_expected_lparen_after,
347                          getOpenMPClauseName(Kind)))
348     return 0;
349 
350   SmallVector<Expr *, 5> Vars;
351   bool IsComma = true;
352   while (IsComma || (Tok.isNot(tok::r_paren) &&
353                      Tok.isNot(tok::annot_pragma_openmp_end))) {
354     // Parse variable
355     ExprResult VarExpr = ParseAssignmentExpression();
356     if (VarExpr.isUsable()) {
357       Vars.push_back(VarExpr.take());
358     } else {
359       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
360                 StopBeforeMatch);
361     }
362     // Skip ',' if any
363     IsComma = Tok.is(tok::comma);
364     if (IsComma) {
365       ConsumeToken();
366     } else if (Tok.isNot(tok::r_paren) &&
367                Tok.isNot(tok::annot_pragma_openmp_end)) {
368       Diag(Tok, diag::err_omp_expected_punc)
369         << 1 << getOpenMPClauseName(Kind);
370     }
371   }
372 
373   // Parse ')'.
374   T.consumeClose();
375   if (Vars.empty())
376     return 0;
377 
378   return Actions.ActOnOpenMPVarListClause(Kind, Vars, Loc, LOpen,
379                                           Tok.getLocation());
380 }
381 
382