1 //===--- OpenMPClause.cpp - Classes for OpenMP clauses --------------------===// 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 the subclesses of Stmt class declared in OpenMPClause.h 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/OpenMPClause.h" 15 16 #include "clang/AST/ASTContext.h" 17 18 using namespace clang; 19 20 OMPClause::child_range OMPClause::children() { 21 switch (getClauseKind()) { 22 default: 23 break; 24 #define OPENMP_CLAUSE(Name, Class) \ 25 case OMPC_##Name: \ 26 return static_cast<Class *>(this)->children(); 27 #include "clang/Basic/OpenMPKinds.def" 28 } 29 llvm_unreachable("unknown OMPClause"); 30 } 31 32 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { 33 assert(VL.size() == varlist_size() && 34 "Number of private copies is not the same as the preallocated buffer"); 35 std::copy(VL.begin(), VL.end(), varlist_end()); 36 } 37 38 OMPPrivateClause * 39 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc, 40 SourceLocation LParenLoc, SourceLocation EndLoc, 41 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) { 42 // Allocate space for private variables and initializer expressions. 43 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause), 44 llvm::alignOf<Expr *>()) + 45 2 * sizeof(Expr *) * VL.size()); 46 OMPPrivateClause *Clause = 47 new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 48 Clause->setVarRefs(VL); 49 Clause->setPrivateCopies(PrivateVL); 50 return Clause; 51 } 52 53 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C, 54 unsigned N) { 55 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause), 56 llvm::alignOf<Expr *>()) + 57 2 * sizeof(Expr *) * N); 58 return new (Mem) OMPPrivateClause(N); 59 } 60 61 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { 62 assert(VL.size() == varlist_size() && 63 "Number of private copies is not the same as the preallocated buffer"); 64 std::copy(VL.begin(), VL.end(), varlist_end()); 65 } 66 67 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) { 68 assert(VL.size() == varlist_size() && 69 "Number of inits is not the same as the preallocated buffer"); 70 std::copy(VL.begin(), VL.end(), getPrivateCopies().end()); 71 } 72 73 OMPFirstprivateClause * 74 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc, 75 SourceLocation LParenLoc, SourceLocation EndLoc, 76 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL, 77 ArrayRef<Expr *> InitVL) { 78 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause), 79 llvm::alignOf<Expr *>()) + 80 3 * sizeof(Expr *) * VL.size()); 81 OMPFirstprivateClause *Clause = 82 new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 83 Clause->setVarRefs(VL); 84 Clause->setPrivateCopies(PrivateVL); 85 Clause->setInits(InitVL); 86 return Clause; 87 } 88 89 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C, 90 unsigned N) { 91 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause), 92 llvm::alignOf<Expr *>()) + 93 3 * sizeof(Expr *) * N); 94 return new (Mem) OMPFirstprivateClause(N); 95 } 96 97 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) { 98 assert(PrivateCopies.size() == varlist_size() && 99 "Number of private copies is not the same as the preallocated buffer"); 100 std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end()); 101 } 102 103 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { 104 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is " 105 "not the same as the " 106 "preallocated buffer"); 107 std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end()); 108 } 109 110 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { 111 assert(DstExprs.size() == varlist_size() && "Number of destination " 112 "expressions is not the same as " 113 "the preallocated buffer"); 114 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end()); 115 } 116 117 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { 118 assert(AssignmentOps.size() == varlist_size() && 119 "Number of assignment expressions is not the same as the preallocated " 120 "buffer"); 121 std::copy(AssignmentOps.begin(), AssignmentOps.end(), 122 getDestinationExprs().end()); 123 } 124 125 OMPLastprivateClause *OMPLastprivateClause::Create( 126 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 127 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 128 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) { 129 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause), 130 llvm::alignOf<Expr *>()) + 131 5 * sizeof(Expr *) * VL.size()); 132 OMPLastprivateClause *Clause = 133 new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 134 Clause->setVarRefs(VL); 135 Clause->setSourceExprs(SrcExprs); 136 Clause->setDestinationExprs(DstExprs); 137 Clause->setAssignmentOps(AssignmentOps); 138 return Clause; 139 } 140 141 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C, 142 unsigned N) { 143 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause), 144 llvm::alignOf<Expr *>()) + 145 5 * sizeof(Expr *) * N); 146 return new (Mem) OMPLastprivateClause(N); 147 } 148 149 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C, 150 SourceLocation StartLoc, 151 SourceLocation LParenLoc, 152 SourceLocation EndLoc, 153 ArrayRef<Expr *> VL) { 154 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause), 155 llvm::alignOf<Expr *>()) + 156 sizeof(Expr *) * VL.size()); 157 OMPSharedClause *Clause = 158 new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size()); 159 Clause->setVarRefs(VL); 160 return Clause; 161 } 162 163 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) { 164 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause), 165 llvm::alignOf<Expr *>()) + 166 sizeof(Expr *) * N); 167 return new (Mem) OMPSharedClause(N); 168 } 169 170 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) { 171 assert(PL.size() == varlist_size() && 172 "Number of privates is not the same as the preallocated buffer"); 173 std::copy(PL.begin(), PL.end(), varlist_end()); 174 } 175 176 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) { 177 assert(IL.size() == varlist_size() && 178 "Number of inits is not the same as the preallocated buffer"); 179 std::copy(IL.begin(), IL.end(), getPrivates().end()); 180 } 181 182 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) { 183 assert(UL.size() == varlist_size() && 184 "Number of updates is not the same as the preallocated buffer"); 185 std::copy(UL.begin(), UL.end(), getInits().end()); 186 } 187 188 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) { 189 assert(FL.size() == varlist_size() && 190 "Number of final updates is not the same as the preallocated buffer"); 191 std::copy(FL.begin(), FL.end(), getUpdates().end()); 192 } 193 194 OMPLinearClause *OMPLinearClause::Create( 195 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 196 OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, 197 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL, 198 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep) { 199 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions 200 // (Step and CalcStep). 201 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause), 202 llvm::alignOf<Expr *>()) + 203 (5 * VL.size() + 2) * sizeof(Expr *)); 204 OMPLinearClause *Clause = new (Mem) OMPLinearClause( 205 StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size()); 206 Clause->setVarRefs(VL); 207 Clause->setPrivates(PL); 208 Clause->setInits(IL); 209 // Fill update and final expressions with zeroes, they are provided later, 210 // after the directive construction. 211 std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(), 212 nullptr); 213 std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(), 214 nullptr); 215 Clause->setStep(Step); 216 Clause->setCalcStep(CalcStep); 217 return Clause; 218 } 219 220 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C, 221 unsigned NumVars) { 222 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions 223 // (Step and CalcStep). 224 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause), 225 llvm::alignOf<Expr *>()) + 226 (5 * NumVars + 2) * sizeof(Expr *)); 227 return new (Mem) OMPLinearClause(NumVars); 228 } 229 230 OMPAlignedClause * 231 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc, 232 SourceLocation LParenLoc, SourceLocation ColonLoc, 233 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) { 234 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause), 235 llvm::alignOf<Expr *>()) + 236 sizeof(Expr *) * (VL.size() + 1)); 237 OMPAlignedClause *Clause = new (Mem) 238 OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size()); 239 Clause->setVarRefs(VL); 240 Clause->setAlignment(A); 241 return Clause; 242 } 243 244 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C, 245 unsigned NumVars) { 246 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause), 247 llvm::alignOf<Expr *>()) + 248 sizeof(Expr *) * (NumVars + 1)); 249 return new (Mem) OMPAlignedClause(NumVars); 250 } 251 252 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { 253 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is " 254 "not the same as the " 255 "preallocated buffer"); 256 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end()); 257 } 258 259 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { 260 assert(DstExprs.size() == varlist_size() && "Number of destination " 261 "expressions is not the same as " 262 "the preallocated buffer"); 263 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end()); 264 } 265 266 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { 267 assert(AssignmentOps.size() == varlist_size() && 268 "Number of assignment expressions is not the same as the preallocated " 269 "buffer"); 270 std::copy(AssignmentOps.begin(), AssignmentOps.end(), 271 getDestinationExprs().end()); 272 } 273 274 OMPCopyinClause *OMPCopyinClause::Create( 275 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 276 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 277 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) { 278 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause), 279 llvm::alignOf<Expr *>()) + 280 4 * sizeof(Expr *) * VL.size()); 281 OMPCopyinClause *Clause = 282 new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size()); 283 Clause->setVarRefs(VL); 284 Clause->setSourceExprs(SrcExprs); 285 Clause->setDestinationExprs(DstExprs); 286 Clause->setAssignmentOps(AssignmentOps); 287 return Clause; 288 } 289 290 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) { 291 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause), 292 llvm::alignOf<Expr *>()) + 293 4 * sizeof(Expr *) * N); 294 return new (Mem) OMPCopyinClause(N); 295 } 296 297 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { 298 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is " 299 "not the same as the " 300 "preallocated buffer"); 301 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end()); 302 } 303 304 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { 305 assert(DstExprs.size() == varlist_size() && "Number of destination " 306 "expressions is not the same as " 307 "the preallocated buffer"); 308 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end()); 309 } 310 311 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { 312 assert(AssignmentOps.size() == varlist_size() && 313 "Number of assignment expressions is not the same as the preallocated " 314 "buffer"); 315 std::copy(AssignmentOps.begin(), AssignmentOps.end(), 316 getDestinationExprs().end()); 317 } 318 319 OMPCopyprivateClause *OMPCopyprivateClause::Create( 320 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 321 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 322 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) { 323 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause), 324 llvm::alignOf<Expr *>()) + 325 4 * sizeof(Expr *) * VL.size()); 326 OMPCopyprivateClause *Clause = 327 new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 328 Clause->setVarRefs(VL); 329 Clause->setSourceExprs(SrcExprs); 330 Clause->setDestinationExprs(DstExprs); 331 Clause->setAssignmentOps(AssignmentOps); 332 return Clause; 333 } 334 335 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C, 336 unsigned N) { 337 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause), 338 llvm::alignOf<Expr *>()) + 339 4 * sizeof(Expr *) * N); 340 return new (Mem) OMPCopyprivateClause(N); 341 } 342 343 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) { 344 assert(Privates.size() == varlist_size() && 345 "Number of private copies is not the same as the preallocated buffer"); 346 std::copy(Privates.begin(), Privates.end(), varlist_end()); 347 } 348 349 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) { 350 assert( 351 LHSExprs.size() == varlist_size() && 352 "Number of LHS expressions is not the same as the preallocated buffer"); 353 std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end()); 354 } 355 356 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) { 357 assert( 358 RHSExprs.size() == varlist_size() && 359 "Number of RHS expressions is not the same as the preallocated buffer"); 360 std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end()); 361 } 362 363 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) { 364 assert(ReductionOps.size() == varlist_size() && "Number of reduction " 365 "expressions is not the same " 366 "as the preallocated buffer"); 367 std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end()); 368 } 369 370 OMPReductionClause *OMPReductionClause::Create( 371 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 372 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL, 373 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, 374 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs, 375 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps) { 376 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause), 377 llvm::alignOf<Expr *>()) + 378 5 * sizeof(Expr *) * VL.size()); 379 OMPReductionClause *Clause = new (Mem) OMPReductionClause( 380 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo); 381 Clause->setVarRefs(VL); 382 Clause->setPrivates(Privates); 383 Clause->setLHSExprs(LHSExprs); 384 Clause->setRHSExprs(RHSExprs); 385 Clause->setReductionOps(ReductionOps); 386 return Clause; 387 } 388 389 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C, 390 unsigned N) { 391 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause), 392 llvm::alignOf<Expr *>()) + 393 5 * sizeof(Expr *) * N); 394 return new (Mem) OMPReductionClause(N); 395 } 396 397 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C, 398 SourceLocation StartLoc, 399 SourceLocation LParenLoc, 400 SourceLocation EndLoc, 401 ArrayRef<Expr *> VL) { 402 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause), 403 llvm::alignOf<Expr *>()) + 404 sizeof(Expr *) * VL.size()); 405 OMPFlushClause *Clause = 406 new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size()); 407 Clause->setVarRefs(VL); 408 return Clause; 409 } 410 411 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) { 412 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause), 413 llvm::alignOf<Expr *>()) + 414 sizeof(Expr *) * N); 415 return new (Mem) OMPFlushClause(N); 416 } 417 418 OMPDependClause * 419 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc, 420 SourceLocation LParenLoc, SourceLocation EndLoc, 421 OpenMPDependClauseKind DepKind, SourceLocation DepLoc, 422 SourceLocation ColonLoc, ArrayRef<Expr *> VL) { 423 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPDependClause), 424 llvm::alignOf<Expr *>()) + 425 sizeof(Expr *) * VL.size()); 426 OMPDependClause *Clause = 427 new (Mem) OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size()); 428 Clause->setVarRefs(VL); 429 Clause->setDependencyKind(DepKind); 430 Clause->setDependencyLoc(DepLoc); 431 Clause->setColonLoc(ColonLoc); 432 return Clause; 433 } 434 435 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N) { 436 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPDependClause), 437 llvm::alignOf<Expr *>()) + 438 sizeof(Expr *) * N); 439 return new (Mem) OMPDependClause(N); 440 } 441 442 OMPMapClause *OMPMapClause::Create(const ASTContext &C, SourceLocation StartLoc, 443 SourceLocation LParenLoc, 444 SourceLocation EndLoc, ArrayRef<Expr *> VL, 445 OpenMPMapClauseKind TypeModifier, 446 OpenMPMapClauseKind Type, 447 SourceLocation TypeLoc) { 448 void *Mem = C.Allocate( 449 llvm::RoundUpToAlignment(sizeof(OMPMapClause), llvm::alignOf<Expr *>()) + 450 sizeof(Expr *) * VL.size()); 451 OMPMapClause *Clause = new (Mem) OMPMapClause( 452 TypeModifier, Type, TypeLoc, StartLoc, LParenLoc, EndLoc, VL.size()); 453 Clause->setVarRefs(VL); 454 Clause->setMapTypeModifier(TypeModifier); 455 Clause->setMapType(Type); 456 Clause->setMapLoc(TypeLoc); 457 return Clause; 458 } 459 460 OMPMapClause *OMPMapClause::CreateEmpty(const ASTContext &C, unsigned N) { 461 void *Mem = C.Allocate( 462 llvm::RoundUpToAlignment(sizeof(OMPMapClause), llvm::alignOf<Expr *>()) + 463 sizeof(Expr *) * N); 464 return new (Mem) OMPMapClause(N); 465 } 466
