[OpenMP] Add support for omp simd pragmas without runtime

[huntergr]

Summary

Adds a new flag ('-fopenmp-simd') to clang which enables processing
of 'simd' and 'declare simd' pragmas without supporting the rest
of OpenMP.

The pragma handler will filter out directives and clauses which
aren't related to simd, and the driver will not add lib(g)omp to
the list of libraries to link.

Documentation updated to describe the new flag.

[fpetrogalli]

Hi Graham,

thank you for working on this. I understand that you are gonna take care of the CodeGen side of things for the new -fopenmp-simd option in a separate patch?

I am asking because I expect that the tests in test/OpenMP/declare_simd_* will give the same results when invoking clang with the new flag instead of -fopenmp.

Thank you,

Francesco

[huntergr]

In D31417#712008, @fpetrogalli wrote:

Hi Graham,

thank you for working on this. I understand that you are gonna take care of the CodeGen side of things for the new -fopenmp-simd option in a separate patch?

CodeGen for 'simd' pragmas works fine with this patch. 'declare simd' doesn't quite work yet, but yes, I was planning to do that in a separate patch.

I am asking because I expect that the tests in test/OpenMP/declare_simd_* will give the same results when invoking clang with the new flag instead of -fopenmp.

So 'isAllowedClauseForDirective' needs to be updated; at present, it just bails out immediately if the directive kind passed in is OMPD_declare_simd. The clauses for a 'declare simd' are handled a little differently in ParseOpenMP.cpp, and I need to look into why.

I mainly wanted feedback on the approach at this point, since the patch is pretty small and changes won't be too cumbersome.

[rengolin]

Hi Graham,

I don't know much about Clang's machinery, but would it be possible to have -fopenmp-simd generate the same handler, but with restrictions? I fear this slight duplication could get considerably worse as we support more and more "non-RT" OMP pragmas.

Alternatively, if this is for testing purposes, we have another pragma which does exactly the same thing as omp simd, which are the Clang vectorizer pragmas (http://llvm.org/docs/Vectorizers.html#pragma-loop-hint-directives).

cheers,
--renato

[huntergr]

Hi Renato,

In D31417#713162, @rengolin wrote:

I don't know much about Clang's machinery, but would it be possible to have -fopenmp-simd generate the same handler, but with restrictions? I fear this slight duplication could get considerably worse as we support more and more "non-RT" OMP pragmas.

Sure, I can combine the handlers and switch behaviour within that if that's preferable. The other alternative I thought of was to perform the filtering in ParseOpenMP.cpp instead, but I need to figure out how to delete or skip tokens there without cluttering up the rest of the OpenMP parsing.

I'll come up with a new version with the combined handler tomorrow.

Alternatively, if this is for testing purposes, we have another pragma which does exactly the same thing as omp simd, which are the Clang vectorizer pragmas (http://llvm.org/docs/Vectorizers.html#pragma-loop-hint-directives).

This feature comes from user requests, and basically matches the functionality of other compilers (e.g. gcc).

Thanks for the comments.

-Graham

[rengolin]

In D31417#713171, @huntergr wrote:

The other alternative I thought of was to perform the filtering in ParseOpenMP.cpp instead, but I need to figure out how to delete or skip tokens there without cluttering up the rest of the OpenMP parsing.

That was my first thought, yes, but I'm not sure how invasive this could get.

This feature comes from user requests, and basically matches the functionality of other compilers (e.g. gcc).

Right, in this case, I think we have a stronger motivation to make that an integral part of the existing OpenMP parser.

cheers,
--renato

[huntergr]

Changed to transform combined constructs to simd in ParseOpenMP.cpp instead of creating a new pragma handler. This also made it easier to add support for 'declare simd': only needed the addition of a check for the option when code generating functions to enable it, so I've added a RUN line to test it in the 'declare simd' codegen tests.

[rengolin]

Hi Graham,

It looks much simpler now, thanks!

I'm ok with the change, but I'd like @ABataev to confirm that the semantics is the expected one for all cases and approve.

cheers,
--renato

lib/Parse/ParseOpenMP.cpp

174

I'd like @ABataev to confirm this is the right semantics.

1047

What if it's really unknown, even to -fopenmp-simd?

[huntergr]

lib/Parse/ParseOpenMP.cpp

174

Yes, would be good. I don't think there's a formal spec for this feature, but it's possible that directives intended for a different target than the cpu shouldn't apply with this flag.

1047

I did wonder about handling this case; I defaulted to ignoring it, since we are already filtering out other non-simd constructs.

If we do want to catch it, then I can think of two options: creating the diagnostic right before the filter switch (possibly messy), or adding a new enum value of OMPD_non_simd_construct (or a similar name) to represent constructs we recognize but don't want to handle and differentiate against a true unknown. I think the latter would be preferable.

[ABataev]

lib/CodeGen/CodeGenModule.cpp

122–123

I don't think you need to create OpenMP runtime support object if you're not going to use it (and you're not going to use it because you don't want to link it). You'd better create your own OMPSIMDRuntime class, that supports emission of the simd code only.

lib/Parse/ParseOpenMP.cpp

174

I don't think you need it here. Instead, you should keep an existing logic in Sema/Parsing code, but you need to create your own OpenMPRuntime support class, that supports only emission of simd part of the constructs.

1047

Leave it as is, we still have to report errors, even in simd-only mode

[kkwli0]

docs/ClangCommandLineReference.rst

1454

I am not sure if it is target architecture specific or not. If it is, should we be under the target flag instead?

[huntergr]

lib/Parse/ParseOpenMP.cpp

174

Thanks for taking a look.

I tried this method first, but came to the conclusion it was too invasive. I've now tried it a second time and came to the same conclusion.

The problem isn't in generating 'simd' or 'declare simd' from a custom runtime class, but in generating everything else. Take a 'parallel for' directive -- I have to generate something close to unmodified code, but 'emitCommonOMPParallelDirective' in CGStmtOpenMP.cpp will only pass the loop codegen lambda through to the runtime class's 'emitParallelOutlinedFunction', which doesn't take the current CodeGenFunction as an argument (as it's expected to create a new one). There doesn't seem to be a good way to look up the CGF that the call will be made from.

You also won't get unmodified code in that instance anyway, as the loop is generated by CodeGenFunction::EmitWorkSharingLoop, and a cancellation region may be created; very little of this is under the control of the runtime class, so it would need extensive modification to work.

So I'll switch to using a simd-only 'runtime' class, but I still think we need to filter out non-simd directives before we get to codegen. Will post updated patch soon.

[ABataev]

lib/Parse/ParseOpenMP.cpp

174

1. I don't think it is a good idea to skip the checks for non-simd constructs in this new mode. I'd prefer to emit all diagnostics as usual. Thus, we can't simply translate all simd-related constructs into 'omp simd' only, as we're going to loose checks/diagnostics.

Keep in minв that you will need to update all diagnostics-specific tests to check that the same errors/warnings are emitted even in -fopenmp-simd mode.

2. You should not rewrite everything. You can do something like this:

file lib/CodeGen/CGStmt.cpp, function void CodeGenFunction::EmitStmt(const Stmt *S)
Insert before switch (S->getStmtClass()):

if (LangOpts.OpenMPSimd && isa<OMPExecutableDirective>(S)) {
  if (isOpenMPSimdDirective(S))
    EmitOMPSimdDirective(S);
  else
    EmitOMPInlinedDirective(S);
  return;
}

EmitOMPSimdDirective(S) shall emit the simd-specific code for all simd-related directives, while EmitOMPInlinedDirective(S) shall emit the code for all other constructs, ingnoring OpenMP directives.

[hfinkel]

Is this still being worked on?

[huntergr]

In D31417#886441, @hfinkel wrote:

Is this still being worked on?

Hi, yes it is. Sorry for the delay in posting new changes but priorities shifted a bit and I had to work on something else for a while.

I do have a new version that's just about ready based on Alexey's idea. Simd constructs work, and non-simd constructs just pass the code straight through; combined constructs pose a bit of an issue, since they will have captured stmts from non-simd directives as well. Some additional work will be needed to handle that case. I'll post what I have after a bit of tidying for comments and suggestions; it's possible that the mixed case could be dealt with in another patch.

[hfinkel]

In D31417#886826, @huntergr wrote:

In D31417#886441, @hfinkel wrote:

Is this still being worked on?

Hi, yes it is. Sorry for the delay in posting new changes but priorities shifted a bit and I had to work on something else for a while.

No problem.

I do have a new version that's just about ready based on Alexey's idea. Simd constructs work, and non-simd constructs just pass the code straight through; combined constructs pose a bit of an issue, since they will have captured stmts from non-simd directives as well. Some additional work will be needed to handle that case. I'll post what I have after a bit of tidying for comments and suggestions; it's possible that the mixed case could be dealt with in another patch.

Splitting patches in this way is generally a good idea.

The other thing I'd like in this regard is some kind of preprocessor feature that my users can use to test whether OpenMP SIMD is supported. Enabling -fopenmp-simd won't define _OPENMP (at least I suspect that it shouldn't because there might not be a meaningful <omp.h> to include). Maybe we should make #if __has_extension(openmp_simd) work?

[ABataev]

I think we can abandon this one as support for -fopenmp-simd was committed already?

[xtian]

LGTM. This provides a consistent behavior same as GCC and ICC w/ -fopenmp-simd option. To answer, Kelvin's question. it is not directly tied with "target".

[huntergr]

In D31417#1450587, @xtian wrote:

LGTM. This provides a consistent behavior same as GCC and ICC w/ -fopenmp-simd option. To answer, Kelvin's question. it is not directly tied with "target".

Thanks for the review Xinmin, but as Alexey notes in the previous comment -fopenmp-simd support has already been committed -- I missed that comment earlier, but should have closed it then.

Apologies for the delay in implementing it Alexey, I just had too many other things to take care of at the time, and thanks for getting a better implementation in.

docs/ClangCommandLineReference.rst

 .. option:: -fobjc-weak, -fno-objc-weak
 
 Enable ARC-style weak references in Objective-C
 
 .. option:: -fomit-frame-pointer, -fno-omit-frame-pointer
 
 .. option:: -fopenmp, -fno-openmp
 
+.. option:: -fopenmp-simd, -fno-openmp-simd
+
 .. option:: -fopenmp-dump-offload-linker-script
 
 .. option:: -fopenmp-use-tls
 
 .. option:: -fopenmp-version=<arg>
 
 .. program:: clang1
 .. option:: -fopenmp=<arg>

docs/UsersManual.rst

 set of atomic constructs, ``proc_bind`` clause for all parallel-based
 directives, ``depend`` clause for ``#pragma omp task`` directive (except for
 array sections), ``#pragma omp cancel`` and ``#pragma omp cancellation point``
 directives, and ``#pragma omp taskgroup`` directive.
 
 Use `-fopenmp` to enable OpenMP. Support for OpenMP can be disabled with
 `-fno-openmp`.
 
+Use `-fopenmp-simd` to enable OpenMP simd features only, without linking
+the runtime library; for combined constructs
+(e.g. ``#pragma omp parallel for simd``) the non-simd directives and clauses
+will be ignored. This can be disabled with `-fno-openmp-simd`.
+
 Controlling implementation limits
 ---------------------------------
 
 .. option:: -fopenmp-use-tls
 
  Controls code generation for OpenMP threadprivate variables. In presence of
  this option all threadprivate variables are generated the same way as thread
  local variables, using TLS support. If `-fno-openmp-use-tls`

include/clang/Basic/LangOptions.def

 
 LANGOPT(OpenCL            , 1, 0, "OpenCL")
 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL version")
 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")
 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(OpenMP            , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)")
+LANGOPT(OpenMPSimd        , 1, 0, "OpenMP support for simd and declare simd directives only")
 LANGOPT(OpenMPUseTLS      , 1, 0, "Use TLS for threadprivates or runtime calls")
 LANGOPT(OpenMPIsDevice    , 1, 0, "Generate code only for OpenMP target device")
 LANGOPT(RenderScript      , 1, 0, "RenderScript")
 
 LANGOPT(CUDAIsDevice      , 1, 0, "compiling for CUDA device")
 LANGOPT(CUDAAllowVariadicFunctions, 1, 0, "allowing variadic functions in CUDA device code")
 LANGOPT(CUDAHostDeviceConstexpr, 1, 1, "treating unattributed constexpr functions as __host__ __device__")
 LANGOPT(CUDADeviceFlushDenormalsToZero, 1, 0, "flushing denormals to zero")

include/clang/Driver/Options.td

 def fobjc_nonfragile_abi_version_EQ : Joined<["-"], "fobjc-nonfragile-abi-version=">, Group<f_Group>;
 def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>;
 def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>;
 
 def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;
 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
 def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
 def fno_openmp : Flag<["-"], "fno-openmp">, Group<f_Group>, Flags<[NoArgumentUnused]>;
+def fopenmp_simd : Flag<["-"], "fopenmp-simd">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
+def fno_openmp_simd : Flag<["-"], "fno-openmp-simd">, Group<f_Group>, Flags<[NoArgumentUnused]>;
 def fopenmp_version_EQ : Joined<["-"], "fopenmp-version=">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
 def fopenmp_EQ : Joined<["-"], "fopenmp=">, Group<f_Group>;
 def fopenmp_use_tls : Flag<["-"], "fopenmp-use-tls">, Group<f_Group>, Flags<[NoArgumentUnused]>;
 def fnoopenmp_use_tls : Flag<["-"], "fnoopenmp-use-tls">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>;
 def fopenmp_targets_EQ : CommaJoined<["-"], "fopenmp-targets=">, Flags<[DriverOption, CC1Option]>,
   HelpText<"Specify comma-separated list of triples OpenMP offloading targets to be supported">;
 def fopenmp_dump_offload_linker_script : Flag<["-"], "fopenmp-dump-offload-linker-script">, Group<f_Group>, 
   Flags<[NoArgumentUnused]>;

lib/CodeGen/CodeGenFunction.cpp

if (const auto *XRayAttr = D->getAttr<XRayInstrumentAttr>()) {
       if (!CGM.imbueXRayAttrs(Fn, Loc))
         Fn->addFnAttr(
             "xray-instruction-threshold",
             llvm::itostr(CGM.getCodeGenOpts().XRayInstructionThreshold));
     }
   }
 
   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
-    if (CGM.getLangOpts().OpenMP && FD->hasAttr<OMPDeclareSimdDeclAttr>())
+    if ((CGM.getLangOpts().OpenMP || CGM.getLangOpts().OpenMPSimd)
+        && FD->hasAttr<OMPDeclareSimdDeclAttr>())
       CGM.getOpenMPRuntime().emitDeclareSimdFunction(FD, Fn);
 
   // Add no-jump-tables value.
   Fn->addFnAttr("no-jump-tables",
                 llvm::toStringRef(CGM.getCodeGenOpts().NoUseJumpTables));
 
   if (getLangOpts().OpenCL) {
     // Add metadata for a kernel function.

lib/CodeGen/CodeGenModule.cpp

CodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO,
 
   RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
   BuiltinCC = getTargetCodeGenInfo().getABIInfo().getBuiltinCC();
 
   if (LangOpts.ObjC1)
     createObjCRuntime();
   if (LangOpts.OpenCL)
     createOpenCLRuntime();
-  if (LangOpts.OpenMP)
+  if (LangOpts.OpenMP || LangOpts.OpenMPSimd)
     createOpenMPRuntime();
   if (LangOpts.CUDA)
     createCUDARuntime();
 
   // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
   if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
       (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
     TBAA.reset(new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
                                getCXXABI().getMangleContext()));

lib/Driver/ToolChains/Clang.cpp

default:
       // By default, if Clang doesn't know how to generate useful OpenMP code
       // for a specific runtime library, we just don't pass the '-fopenmp' flag
       // down to the actual compilation.
       // FIXME: It would be better to have a mode which *only* omits IR
       // generation based on the OpenMP support so that we get consistent
       // semantic analysis, etc.
       break;
     }
-  }
+  } else if (Args.hasFlag(options::OPT_fopenmp_simd,
+                          options::OPT_fno_openmp_simd, /*Default=*/false))
+    CmdArgs.push_back("-fopenmp-simd");
 
   const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs();
   Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType);
 
   const XRayArgs &XRay = getToolChain().getXRayArgs();
   XRay.addArgs(getToolChain(), Args, CmdArgs, InputType);
 
   if (getToolChain().SupportsProfiling())

lib/Frontend/CompilerInvocation.cpp

#include "clang/Frontend/LangStandards.def"
   }
 
   // Check if -fopenmp is specified.
   Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 1 : 0;
   Opts.OpenMPUseTLS =
       Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
   Opts.OpenMPIsDevice =
       Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
+  Opts.OpenMPSimd = !Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_simd);
 
   if (Opts.OpenMP) {
     int Version =
         getLastArgIntValue(Args, OPT_fopenmp_version_EQ, Opts.OpenMP, Diags);
     if (Version != 0)
       Opts.OpenMP = Version;
     // Provide diagnostic when a given target is not expected to be an OpenMP
     // device or host.

lib/Parse/ParseOpenMP.cpp

for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) {
     if (SDKind == OMPD_unknown)
       continue;
 
     if (SDKind == F[i][1]) {
       P.ConsumeToken();
       DKind = F[i][2];
     }
   }
+
+  // If we're only interested in the simd pragmas, convert any combined
+  // construct with a simd directive to just 'simd' or 'declare simd',
+  // and any other to 'unknown'.
+  if (P.getLangOpts().OpenMPSimd) {
+    switch (DKind) {
+      default:
+        DKind = OMPD_unknown;
+        break;
+      case OMPD_declare_simd:
+        break;
+      case OMPD_simd:
+      case OMPD_parallel_for_simd:
+      case OMPD_for_simd:
+      case OMPD_taskloop_simd:
+      case OMPD_distribute_parallel_for_simd:
+      case OMPD_distribute_simd:
+      case OMPD_target_simd:
+      case OMPD_teams_distribute_simd:
+      case OMPD_teams_distribute_parallel_for_simd:
+      case OMPD_target_teams_distribute_parallel_for_simd:
+      case OMPD_target_teams_distribute_simd:
+        DKind = OMPD_simd;
+        break;
+    }
+  }
+
   return DKind < OMPD_unknown ? static_cast<OpenMPDirectiveKind>(DKind)
                               : OMPD_unknown;
 }
 
 static DeclarationName parseOpenMPReductionId(Parser &P) {
   Token Tok = P.getCurToken();
   Sema &Actions = P.getActions();
   OverloadedOperatorKind OOK = OO_None;
StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective(
   case OMPD_declare_simd:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
     Diag(Tok, diag::err_omp_unexpected_directive)
         << getOpenMPDirectiveName(DKind);
     SkipUntil(tok::annot_pragma_openmp_end);
     break;
   case OMPD_unknown:
+    // Don't report unknown directives if we're only looking at simd,
+    // as the filter function will have switched the kind.
+    if (!getLangOpts().OpenMPSimd)
       Diag(Tok, diag::err_omp_unknown_directive);
     SkipUntil(tok::annot_pragma_openmp_end);
     break;
   }
   return Directive;
 }
 
 // Parses simple list:
 //   simple-variable-list:

 ///       thread_limit-clause | priority-clause | grainsize-clause |
 ///       nogroup-clause | num_tasks-clause | hint-clause | to-clause |
 ///       from-clause | is_device_ptr-clause
 ///
 OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
                                      OpenMPClauseKind CKind, bool FirstClause) {
   OMPClause *Clause = nullptr;
   bool ErrorFound = false;
+
+  // If we're only interpreting 'simd' directives, filter out clauses that
+  // don't apply without an error.
+  if (DKind == OMPD_simd && getLangOpts().OpenMPSimd &&
+      !isAllowedClauseForDirective(DKind, CKind)) {
+
+    if (PP.LookAhead(/*N=*/0).is(tok::l_paren))
+      SkipUntil(tok::r_paren);
+
+    return nullptr;
+  }
+
   // Check if clause is allowed for the given directive.
   if (CKind != OMPC_unknown && !isAllowedClauseForDirective(DKind, CKind)) {
     Diag(Tok, diag::err_omp_unexpected_clause) << getOpenMPClauseName(CKind)
                                                << getOpenMPDirectiveName(DKind);
     ErrorFound = true;
   }
 
   switch (CKind) {

lib/Parse/ParsePragma.cpp

void Parser::initializePragmaHandlers() {
   PP.AddPragmaHandler("STDC", FPContractHandler.get());
 
   if (getLangOpts().OpenCL) {
     OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler());
     PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());
 
     PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
   }
-  if (getLangOpts().OpenMP)
+  if (getLangOpts().OpenMP || getLangOpts().OpenMPSimd)
     OpenMPHandler.reset(new PragmaOpenMPHandler());
   else
     OpenMPHandler.reset(new PragmaNoOpenMPHandler());
   PP.AddPragmaHandler(OpenMPHandler.get());
 
   if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) {
     MSCommentHandler.reset(new PragmaCommentHandler(Actions));
     PP.AddPragmaHandler(MSCommentHandler.get());

lib/Sema/SemaExpr.cpp

bool Sema::tryCaptureVariable(
   
   // If the variable is declared in the current context, there is no need to
   // capture it.
   if (VarDC == DC) return true;
 
   // Capture global variables if it is required to use private copy of this
   // variable.
   bool IsGlobal = !Var->hasLocalStorage();
-  if (IsGlobal && !(LangOpts.OpenMP && IsOpenMPCapturedDecl(Var)))
+  if (IsGlobal && !((LangOpts.OpenMP || LangOpts.OpenMPSimd) &&
+                    IsOpenMPCapturedDecl(Var)))
     return true;
 
   // Walk up the stack to determine whether we can capture the variable,
   // performing the "simple" checks that don't depend on type. We stop when
   // we've either hit the declared scope of the variable or find an existing
   // capture of that variable.  We start from the innermost capturing-entity
   // (the DC) and ensure that all intervening capturing-entities 
   // (blocks/lambdas etc.) between the innermost capturer and the variable`s

lib/Sema/SemaOpenMP.cpp

 }
 
 unsigned Sema::getOpenMPNestingLevel() const {
   assert(getLangOpts().OpenMP);
   return DSAStack->getNestingLevel();
 }
 
 VarDecl *Sema::IsOpenMPCapturedDecl(ValueDecl *D) {
-  assert(LangOpts.OpenMP && "OpenMP is not allowed");
+  assert((LangOpts.OpenMP || LangOpts.OpenMPSimd) && "OpenMP is not allowed");
   D = getCanonicalDecl(D);
 
   // If we are attempting to capture a global variable in a directive with
   // 'target' we return true so that this global is also mapped to the device.
   //
   // FIXME: If the declaration is enclosed in a 'declare target' directive,
   // then it should not be captured. Therefore, an extra check has to be
   // inserted here once support for 'declare target' is added.
DVarPrivate = DSAStack->hasDSA(
         DSAStack->isClauseParsingMode());
     if (DVarPrivate.CKind != OMPC_unknown)
       return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
   }
   return nullptr;
 }
 
 bool Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level) {
-  assert(LangOpts.OpenMP && "OpenMP is not allowed");
+  assert((LangOpts.OpenMP || LangOpts.OpenMPSimd) && "OpenMP is not allowed");
   return DSAStack->hasExplicitDSA(
       D, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level);
 }
 
 bool Sema::isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level) {
   assert(LangOpts.OpenMP && "OpenMP is not allowed");
   // Return true if the current level is no longer enclosed in a target region.
 

test/OpenMP/declare_simd_codegen.cpp

 // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp -x c++ -emit-llvm %s -o - -femit-all-decls | FileCheck %s
+// RUN: %clang_cc1 -verify -triple x86_64-apple-darwin10 -fopenmp-simd -x c++ -emit-llvm %s -o - -femit-all-decls | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-apple-darwin10 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-apple-darwin10 -include-pch %t -verify %s -emit-llvm -o - -femit-all-decls | FileCheck %s
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER
 
 #pragma omp declare simd linear(d : 8)
 #pragma omp declare simd inbranch simdlen(32)

test/OpenMP/linking.c

 // RUN:     -fopenmp=libiomp5 -target x86_64-msvc-win32 -rtlib=platform \
 // RUN:   | FileCheck --check-prefix=CHECK-MSVC-ILINK-64 %s
 // CHECK-MSVC-ILINK-64: link.exe
 // CHECK-MSVC-ILINK-64-SAME: -nodefaultlib:vcomp.lib
 // CHECK-MSVC-ILINK-64-SAME: -nodefaultlib:vcompd.lib
 // CHECK-MSVC-ILINK-64-SAME: -libpath:{{.+}}/../lib
 // CHECK-MSVC-ILINK-64-SAME: -defaultlib:libiomp5md.lib
 //
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -fopenmp-simd -target aarch64-linux-gnu \
+// RUN:   | FileCheck --check-prefix=CHECK-SIMD-ONLY-AA64 %s
+// CHECK-SIMD-ONLY-AA64-NOT: "-l[[DEFAULT_OPENMP_LIB]]"
+// CHECK-SIMD-ONLY-AA64-NOT: "-lpthread"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     -fopenmp-simd -target x86_64-unknown_linux \
+// RUN:   | FileCheck --check-prefix=CHECK-SIMD-ONLY-X64 %s
+// CHECK-SIMD-ONLY-X64-NOT: "-l[[DEFAULT_OPENMP_LIB]]"
+// CHECK-SIMD-ONLY-X64-NOT: "-lpthread"

test/OpenMP/simd_only.c

+// RUN: %clang_cc1 -verify -fopenmp-simd -x c -triple aarch64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -verify -fopenmp-simd -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
+// expected-no-diagnostics
+
+// CHECK-LABEL: @simd_plain
+// CHECK-LABEL: omp.inner.for.body:
+// CHECK: load float, float* %arrayidx{{.*}} !llvm.mem.parallel_loop_access
+// CHECK: load float, float* %arrayidx{{.*}} !llvm.mem.parallel_loop_access
+// CHECK: store float %{{.*}}, float* %arrayidx{{.*}} !llvm.mem.parallel_loop_access
+// CHECK: ret void
+void simd_plain(float *a, float *b, float *c, int N) {
+  #pragma omp simd
+  for (int i = 0; i < N; i += 2)
+    a[i] = b[i] * c[i];
+}
+
+// CHECK-LABEL: @simd_safelen_clause
+// CHECK-NOT: !llvm.mem.parallel_loop_access
+// CHECK-LABEL: omp.inner.for.inc:
+// CHECK: br label %omp.inner.for.cond, !llvm.loop
+// CHECK: ret void
+void simd_safelen_clause(float *a, float *b, float *c, int N) {
+  #pragma omp simd safelen(4)
+  for (int i = 0; i < N; i += 2)
+    a[i] = b[i] * c[i];
+}
+
+extern long long initial_val();
+
+// CHECK-LABEL: @simd_simdlen_and_linear_clause
+// CHECK: omp.inner.for.body:
+// CHECK: !llvm.mem.parallel_loop_access
+// CHECK: ret void
+void simd_simdlen_and_linear_clause(float *a, float *b, float *c, int N) {
+  long long lv = initial_val();
+  #pragma omp simd simdlen(2) linear(lv: 4)
+  for (int i = 0; i < N; ++i) {
+    a[lv] = b[lv] * c[lv];
+    lv += 4;
+  }
+}
+
+extern float gfloat;
+
+// CHECK-LABEL: @simd_aligned_and_private_clause
+// CHECK-LABEL: entry:
+// CHECK: %gfloat = alloca float, align 4
+// CHECK: store float 1.000000e+00, float* @gfloat, align 4
+// CHECK-LABEL: omp.inner.for.body:
+// CHECK-NOT: @gfloat
+// CHECK: load{{.*}}!llvm.mem.parallel_loop_access
+// CHECK: store float {{.*}}, float* %gfloat, align 4, !llvm.mem.parallel_loop_access
+// CHECK: %[[FADD:add[0-9]+]] = fadd float %{{[0-9]+}}, 2.000000e+00
+// CHECK: store float %[[FADD]], float* {{.*}}, align 4, !llvm.mem.parallel_loop_access
+// CHECK: ret void
+void simd_aligned_and_private_clause(float *a, float *b, float *c, int N) {
+  gfloat = 1.0f;
+  #pragma omp simd aligned(a:4) private(gfloat)
+  for (int i = 0; i < N; i += 2) {
+    gfloat = b[i] * c[i];
+    a[i] = gfloat + 2.0f;
+  }
+}
+
+// CHECK-LABEL: @simd_lastprivate_and_reduction_clause
+// CHECK-LABEL: entry:
+// CHECK: %[[SUMVAR:sum[0-9]+]] = alloca float, align 4
+// CHECK: store float 0.000000e+00, float* %[[SUMVAR]], align 4
+// CHECK-LABEL: omp.inner.for.body
+// CHECK: %[[LOAD:[0-9]+]] = load float, float* %[[SUMVAR]], align 4, !llvm.mem.parallel_loop_access
+// CHECK: %[[FADD:add[0-9]+]] = fadd float %[[LOAD]], %mul{{.*}}
+// CHECK: store float %[[FADD]], float* %[[SUMVAR]], align 4, !llvm.mem.parallel_loop_access
+// CHECK: store i32{{.*}}, i32* %[[IDXVAR:idx[0-9]+]]
+// CHECK-LABEL: omp.inner.for.end:
+// CHECK-DAG: %[[TMP1:[0-9]+]] = load i32, i32* %[[IDXVAR]], align 4
+// CHECK-DAG: store i32 %[[TMP1]], i32* %idx, align 4
+// CHECK-DAG: %[[INITVAL:[0-9]+]] = load float, float* %sum, align 4
+// CHECK-DAG: %[[TMP2:[0-9]+]] = load float, float* %[[SUMVAR]], align 4
+// CHECK-DAG: %[[SUMMED:add[0-9]+]] = fadd float %[[INITVAL]], %[[TMP2]]
+// CHECK-DAG: store float %[[SUMMED]], float* %sum, align 4
+// CHECK-LABEL: simd.if.end:
+// CHECK: %[[OUTVAL:[0-9]+]] = load float, float* %sum, align 4
+// CHECK: %[[OUTADDR:[0-9]+]] = load float*, float** %a.addr, align 8
+// CHECK: store float %[[OUTVAL]], float* %[[OUTADDR]], align 4
+// CHECK: %[[RETIDX:[0-9]+]] = load i32, i32* %idx, align 4
+// CHECK: ret i32 %[[RETIDX]]
+int simd_lastprivate_and_reduction_clause(float *a, float *b, float *c, int N) {
+  float sum = 0.0f;
+  int idx;
+  #pragma omp simd lastprivate(idx) reduction(+:sum)
+  for (int i = 0; i < N; ++i) {
+    sum += b[i] * c[i];
+    idx = i * 2;
+  }
+
+  *a = sum;
+  return idx;
+}
+
+// CHECK-LABEL: @simd_collapse_clause
+// CHECK: omp.inner.for.body:
+// CHECK-NOT: for.body:
+// CHECK: ret void
+void simd_collapse_clause(float **a, float **b, float **c, int N, int M) {
+  #pragma omp simd collapse(2)
+  for (int i = 0; i < N; ++i)
+    for (int j = 0; j < N; ++j)
+      a[i][j] = b[i][j] * c[i][j];
+}
+
+// Negative tests; no simd directive, so should be normal code.
+
+// CHECK-LABEL: @parallel_for
+// CHECK-NOT: call void {{.*}} @__kmpc_fork_call
+// CHECK-NOT: @.omp_outlined.
+// CHECK-NOT: omp.inner.for.body:
+// CHECK: ret void
+void parallel_for(float *a, float *b, float *c, int N) {
+  #pragma omp parallel for
+  for (int i = 0; i < N; ++i)
+    a[i] = b[i] * c[i];
+}
+
+extern void long_running_func(int);
+
+// CHECK-LABEL: @taskloop
+// CHECK-NOT: call i8* @__kmpc_omp_task_alloc
+// CHECK-NOT: call void @__kmpc_taskloop
+// CHECK: ret void
+void taskloop(int N) {
+  #pragma omp taskloop
+  for (int i = 0; i < N; ++i)
+    long_running_func(i);
+}
+
+// Combined constructs; simd part should work, rest should be ignored.
+
+// CHECK-LABEL: @parallel_for_simd
+// CHECK-NOT: call void {{.*}} @__kmpc_fork_call
+// CHECK-NOT: @.omp_outlined.
+// CHECK: omp.inner.for.body:
+// CHECK: ret void
+void parallel_for_simd(float *a, float *b, float *c, int N) {
+#pragma omp parallel for simd num_threads(2) simdlen(4)
+  for (int i = 0; i < N; ++i)
+    a[i] = b[i] * c[i];
+}
+
+// Make sure there's no declarations for libomp runtime functions
+// CHECK-NOT: declare void @__kmpc
+
+// CHECK-LABEL: !llvm.ident = !{!0}
+
+// simd_safelen_clause width md
+// CHECK-DAG: !{{[0-9]+}} = !{!"llvm.loop.vectorize.width", i32 4}
+// simd_simdlen_clause width md
+// CHECK-DAG: !{{[0-9]+}} = !{!"llvm.loop.vectorize.width", i32 2}