[clang-tidy] Add readability-simd-intrinsics check.

[MaskRay]

Summary

Many architectures provide SIMD operations (e.g. x86 SSE/AVX, Power AltiVec/VSX,
ARM NEON). It is common that SIMD code implementing the same algorithm, is
written in multiple target-dispatching pieces to optimize for different
architectures or micro-architectures.

The C++ standard proposal P0214 and its extensions cover many common SIMD
operations. By migrating from target-dependent intrinsics to P0214 operations,
the SIMD code can be simplified and pieces for different targets can be unified.

Refer to http://wg21.link/p0214 for introduction and motivation for the
data-parallel standard library.

[MaskRay]

Add test/clang-tidy/readability-simd-intrinsics.cpp

[MaskRay]

I haven't used clang-tidy before :) Do you have any suggestions on my workflow?

% ninja -C ~/Dev/llvm/build clangTidyReadabilityModule
% ~/Dev/llvm/build/bin/clang-tidy -checks='-*,readability-simd-intrinsics' a.cc
# for local testing

# Ensure tests are correct
% PATH=~/Dev/llvm/build/bin:$PATH test/clang-tidy/check_clang_tidy.py test/clang-tidy/readability-simd-intrinsics.cpp readability-simd-intrinsics /tmp/t

# In case I want to debug, sorry I should use lldb but ...
% cgdb -x =(printf 'set auto-solib-add off\nstart\nsha stdc\|LLVMCore.so\|Support\|clangTidy') --args ~/Dev/llvm/build/bin/clang-tidy -checks='llvm-namespace-comment' /tmp/c/a.cc

I check llvm::Triple::ArchType to reduce number of target-dependent string matching. But in the test I don't know how to enable -target ppc64le -maltivec so that I can test PPC.

[MaskRay]

Move CHECK-MESSAGES: to comform to the prevaling style

[Eugene.Zelenko]

Please mention this check in docs/ReleaseNotes.rst (in alphabetical order).

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

25

Please make function static instead of using anonymous namespace. See LLVM Coding Style.

29

I think returning {} will be better. Same for trailing return.

48

Please make function static instead of using anonymous namespace. See LLVM Coding Style.

56

I think returning {} will be better. Same for trailing return.

78

You should enable this check only when compiling in appropriate C++ version. See getLangOpts() usage in other checks.

clang-tidy/readability/SIMDIntrinsicsCheck.h

31

Please remove private section and empty line before it.

[MaskRay]

LLVM Style

[MaskRay]

Remove private section

[MaskRay]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

78

Thx, I didn't know getLangOpts() before.

I think even in -x c mode, :: is still the prefix of an identifier.

matchesName("^(_mm_|_mm256_|_mm512_|vec_)")

doesn't match anything but

matchesName("^::(_mm_|_mm256_|_mm512_|vec_)")

matches.

verified via clang-tidy -checks='-*,readability-simd-intrinsics' a.c -- -xc

[Eugene.Zelenko]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

78

Check should be enabled only for C++ version which has std::experimental::simd implementation, so this is why you need to use getLangOpts().

[MaskRay]

if (!Result.Context->getLangOpts().CPlusPlus11) return;

[MaskRay]

docs/ReleaseNotes.rst

[Eugene.Zelenko]

docs/ReleaseNotes.rst

103

Please move it new checks section.

[timshen]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

23

"Check" usually indicates to return a bool, but what it actually returns is a possible mapped result based on the input. Maybe some name like "TrySuggestPPC"?

[timshen]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

25

Can you either find or create a wrapper for this?

bool StripPrefix(StringRef Prefix, StringRef& S) {
  if (S.startwith(Prefix)) {
    S = S.substr(Prefix.size());
    return true;
  }
  return false;
}

Which is a huge readability boost and DRY.

[timshen]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

25

Found it: StringRef::consume_front()

[timshen]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

35

Technically, std::experimental::simd::operator+ (an all other binary operators) don't exist, as they are free functions, not member functions. operator+ for std::experimental::simd objects do exist.

[MaskRay]

docs/ReleaseNotes.rst and use StringRef::consume_front

[MaskRay]

Warning messages of operator+ as operator+ operator- .. are free functions on simd objects.

[lebedev.ri]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

27

You probably want to move Mapping out of the function.

35

To point the obvious, this is not exhaustive list, at least div is missing.

56

This function was not updated to use the Mapping map.

76

Is it reasonable to suggest to use <experimental/*>?
I would guess it should be CPlusPlus2a

85

I would refactor this as astmatcher, at least a local one, e.g. something like

AST_MATCHER(CallExpr, hasDirectCallee) {
  return Node.getDirectCallee();
}

+

void SIMDIntrinsicsCheck::registerMatchers(MatchFinder *Finder) {
  Finder->addMatcher(
      callExpr(callee(
+            allOf(
                     functionDecl(matchesName("^::(_mm_|_mm256_|_mm512_|vec_)")
+                  , hasDirectCallee()
+            )
               )),
               unless(isExpansionInSystemHeader()))
          .bind("call"),
      this);
}

Unless of course there is already a narrower that does that

88

Same here, i *think* something like this would be better?

AST_MATCHER(FunctionDecl, isVectorFunction) {
 bool IsVector = Node.getReturnType()->isVectorType();
  for (const ParmVarDecl *Parm : Node.parameters()) {
    QualType Type = Parm->getType();
    if (Type->isPointerType())
      Type = Type->getPointeeType();
    if (Type->isVectorType())
      IsVector = true;

  return IsVector;
}

+

void SIMDIntrinsicsCheck::registerMatchers(MatchFinder *Finder) {
  Finder->addMatcher(
      callExpr(callee(
            allOf(
                     functionDecl(
+                   allOf(
                         matchesName("^::(_mm_|_mm256_|_mm512_|vec_)")
+                     , isVectorFunction()
+                   )
                  , hasDirectCallee()
            )
               )),
               unless(isExpansionInSystemHeader()))
          .bind("call"),
      this);
}

docs/clang-tidy/checks/readability-simd-intrinsics.rst

2

This should be

.. title:: clang-tidy - readability-simd-intrinsics

4

Here too

[MaskRay]

Fix word order of readability-simd-intrinsics

[MaskRay]

Add check-specific option Experimental

StringRef Std;
if (Result.Context->getLangOpts().CPlusPlus2a) {
  Std = "std";
} else if (Result.Context->getLangOpts().CPlusPlus11 && Experimental) {
  // libcxx implementation backports it to C++11 std::experimental::simd.
  Std = "std::experimental";
} else
  return;

[MaskRay]

Use unnamed namespace to enclose AST_MATCHER and TrySuggest*

[MaskRay]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

76

Added a check-specific option readability-simd-intrinsics.Experiment.

85

AST_MATCHER(CallExpr, hasDirectCallee) {
  return Node.getDirectCallee();
}

looks too overkill and I still have to call Call->getDirectCallee() in SIMDIntrinsicsCheck::check and then Callee->getName(). I decide to keep it as is.

That said, I should also study why AST_MATCHER(CallExpr, hasDirectCallee) does not compile:

../tools/clang/tools/extra/clang-tidy/readability/SIMDIntrinsicsCheck.cpp:95:16: error: call to 'callee' is ambiguous
      callExpr(callee(allOf(functionDecl(allOf(
               ^~~~~~
../tools/clang/include/clang/ASTMatchers/ASTMatchers.h:2811:25: note: candidate function
AST_MATCHER_P(CallExpr, callee, internal::Matcher<Stmt>,
                        ^
../tools/clang/include/clang/ASTMatchers/ASTMatchers.h:2827:34: note: candidate function
AST_MATCHER_P_OVERLOAD(CallExpr, callee, internal::Matcher<Decl>, InnerMatcher,

88

Thanks! Added isVectorFunction. I guess I may should use unnamed namespace for AST_MATCHER, but do I also need the unnamed namespace to enclose TrySuggestPPC and TrySuggestX86?

[MaskRay]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

27

Does keeping static const llvm::StringMap<std::string> Mapping{ ... } inside the function avoid a global constructor? The blacklist will surely be modified to cover more operations after the revision

35

Yes, the blacklist will be modified to cover more instructions.

Another fun fact is that though _mm_div_epi* are listed in Intel's intrinsics guide, no there are no mapping hardware instructions and the functions only exist in ICC/ICPC (I guess) not in clang/lib/Headers/*.h

56

This is because on Power, these functions are overloaded vec_add vec_sub ...
But on x86, there are suffixes, e.g. _mm_add_epi32.

[lebedev.ri]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

78

I think this is still not done,

Experimental(Options.getLocalOrGlobal("Experimental", 1) != 0)

means it will still be on by default for C++11

107

This logic should be in the beginning of registerMatchers(), so this wouldn't even be registered/called if it won't do anything.

clang-tidy/readability/SIMDIntrinsicsCheck.h

28

I think usually this is in .cpp file

[MaskRay]

readability-simd-intrinsics.rst

[timshen]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

76

Is it reasonable to suggest to use <experimental/*>?

I think there are two approaches to proceed:

1. We just warn the users, but don't suggest <experimental/simd> fixes.
2. We warn and suggest <experimental/simd> fixes, but only when a flag is turned on (off by default). The flag documentation should clearly include "suggest <experimental/simd> API".

I'm not sure which one fits better.

[lebedev.ri]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

76

Ok, i should have commented in more words :)

I wasn't questioning the use of <experimental/simd>
I was questioning the whole approach of defaulting to issuing the warning as long as that header can be used with specified C++ standard.
E.g. there is <experimental/filesystem>, but there isn't any check to complain on fopen()/fclose() and friends.
(I do agree that this argument is chicken-or-the-egg problem)

88

I may should use unnamed namespace for AST_MATCHER

I think so.

do I also need the unnamed namespace to enclose TrySuggestPPC and TrySuggestX86?

No, but do make those static.

[MaskRay]

Add option Enabled which defaults to 0.
Suggest std::simd (-std=c++2a) or std::experimental::std (-std=c++11) only if enabled.

[MaskRay]

The check must be manually enabled now:

% clang-tidy -checks='-*,readability-simd-intrinsics' a.cc -- -std=c++2a
# Not enabled by default

% clang-tidy -checks='-*,readability-simd-intrinsics' -config='{CheckOptions: [{key: readability-simd-intrinsics.Enabled, value: 1}]}' a.cc -- -std=c++11
# warn and suggest std::experimental::simd

% clang-tidy -checks='-*,readability-simd-intrinsics' -config='{CheckOptions: [{key: readability-simd-intrinsics.Enabled, value: 1}]}' a.cc -- -std=c++2a
# warn and suggest std::simd

Current add sub mul suggestions are only POC. More checks will be added in follow-up revisions.

[MaskRay]

Set Enabled to 1 in test/clang-tidy/readability-simd-intrinsics.cpp

[MaskRay]

Split test/clang-tidy/readability-simd-intrinsics.cpp to x86 and ppc

[MaskRay]

.rst

[lebedev.ri]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

47

I think you can use llvm::StringRef here instead of std::string

89

Enabled seems too broad to me.
How about UseStdExperimental? (still defaults to false)

99

So sorry for beating the same stuff again, but i believe as of right now, it's still only in std::experimental namespace, not in std?

[MaskRay]

Rename Enabled to UseStdExperimental and only suggest std::experimental:: (not std::)

[hokein]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

47

consider using llvm::StringSwitch?

103

nit: use early return for readability.

docs/clang-tidy/checks/readability-simd-intrinsics.rst

39

We don't use check's option to enable the check in clang-tidy, if users want to enable the check, they need to pass the check explicitly to clang-tidy (e.g. -checks="<your-check>"). I'd suggest to remove this option.

[MaskRay]

Remove UseStdExperimental

[MaskRay]

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

47

The list is currently a scaffold and more operations will be added. It may be more efficient to use a lookup table instead of cascading .Case("add", ...)?

docs/clang-tidy/checks/readability-simd-intrinsics.rst

39

Removed.I don't think the option is necessary.

[MaskRay]

Add an option Suggest.

Only suggest P0214 alternatives if it is true.

[hokein]

The clang-tidy code looks good. If no one has further comments, feel free to commit it.

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

47

I see. In your case, the normal switch-case statement seems enough? But up to you.

docs/clang-tidy/checks/readability-simd-intrinsics.rst

9

nit: I think it is stale?

test/clang-tidy/readability-simd-intrinsics-ppc.cpp

4

consider adding test when Suggest is 0?

test/clang-tidy/readability-simd-intrinsics-x86.cpp

26

nit: this is not needed. If clang-tidy gives the warning for this case, the lit test will fail.

[MaskRay]

Update .rst

[MaskRay]

Update

[MaskRay]

test/clang-tidy/readability-simd-intrinsics-ppc.cpp

4

I'll have to duplicate the CHECK-MESSAGE lines for each intrinsic, which seems a lot of boilerplate.

[alexfh]

A late comment here: should this check start a new "portability" module? This seems to be the main focus of the check rather than making code more readable.

[MaskRay]

In D42983#1025179, @alexfh wrote:

A late comment here: should this check start a new "portability" module? This seems to be the main focus of the check rather than making code more readable.

SG. Should I rename it?

[alexfh]

In D42983#1028093, @MaskRay wrote:

In D42983#1025179, @alexfh wrote:

A late comment here: should this check start a new "portability" module? This seems to be the main focus of the check rather than making code more readable.

SG. Should I rename it?

If nobody objects, yes, please. You'll need create the module manually and then use the rename_check.py script for the actual renaming.

[MaskRay]

In D42983#1028241, @alexfh wrote:

In D42983#1028093, @MaskRay wrote:

In D42983#1025179, @alexfh wrote:

A late comment here: should this check start a new "portability" module? This seems to be the main focus of the check rather than making code more readable.

SG. Should I rename it?

If nobody objects, yes, please. You'll need create the module manually and then use the rename_check.py script for the actual renaming.

I just created D44173 . Didn't know rename_check.py and manually renamed a bunch of files...

clang-tidy/readability/CMakeLists.txt

add_clang_library(clangTidyReadabilityModule
   ReadabilityTidyModule.cpp
   RedundantControlFlowCheck.cpp
   RedundantDeclarationCheck.cpp
   RedundantFunctionPtrDereferenceCheck.cpp
   RedundantMemberInitCheck.cpp
   RedundantStringCStrCheck.cpp
   RedundantSmartptrGetCheck.cpp
   RedundantStringInitCheck.cpp
+  SIMDIntrinsicsCheck.cpp
   SimplifyBooleanExprCheck.cpp
   StaticAccessedThroughInstanceCheck.cpp
   StaticDefinitionInAnonymousNamespaceCheck.cpp
   StringCompareCheck.cpp
   UniqueptrDeleteReleaseCheck.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   clangTooling
   )

clang-tidy/readability/ReadabilityTidyModule.cpp

 #include "NonConstParameterCheck.h"
 #include "RedundantControlFlowCheck.h"
 #include "RedundantDeclarationCheck.h"
 #include "RedundantFunctionPtrDereferenceCheck.h"
 #include "RedundantMemberInitCheck.h"
 #include "RedundantSmartptrGetCheck.h"
 #include "RedundantStringCStrCheck.h"
 #include "RedundantStringInitCheck.h"
+#include "SIMDIntrinsicsCheck.h"
 #include "SimplifyBooleanExprCheck.h"
 #include "StaticAccessedThroughInstanceCheck.h"
 #include "StaticDefinitionInAnonymousNamespaceCheck.h"
 #include "StringCompareCheck.h"
 #include "UniqueptrDeleteReleaseCheck.h"
 
 namespace clang {
 namespace tidy {
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<RedundantDeclarationCheck>(
         "readability-redundant-declaration");
     CheckFactories.registerCheck<RedundantSmartptrGetCheck>(
         "readability-redundant-smartptr-get");
     CheckFactories.registerCheck<RedundantStringCStrCheck>(
         "readability-redundant-string-cstr");
     CheckFactories.registerCheck<RedundantStringInitCheck>(
         "readability-redundant-string-init");
+    CheckFactories.registerCheck<SIMDIntrinsicsCheck>(
+        "readability-simd-intrinsics");
     CheckFactories.registerCheck<SimplifyBooleanExprCheck>(
         "readability-simplify-boolean-expr");
     CheckFactories.registerCheck<UniqueptrDeleteReleaseCheck>(
         "readability-uniqueptr-delete-release");
   }
 };
 
 // Register the ReadabilityModule using this statically initialized variable.

clang-tidy/readability/SIMDIntrinsicsCheck.h

+//===--- SIMDIntrinsicsCheck.h - clang-tidy----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SIMD_INTRINSICS_CHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SIMD_INTRINSICS_CHECK_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// Find SIMD intrinsics calls and suggest std::experimental::simd alternatives.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability-simd-intrinsics.html
+class SIMDIntrinsicsCheck : public ClangTidyCheck {
+public:
+  SIMDIntrinsicsCheck(StringRef Name, ClangTidyContext *Context);
+
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+ private:
+  const bool Suggest;
+  StringRef Std;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SIMD_INTRINSICS_CHECK_H

clang-tidy/readability/SIMDIntrinsicsCheck.cpp

+//===--- SIMDIntrinsicsCheck.cpp - clang-tidy------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SIMDIntrinsicsCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/Regex.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+namespace {
+
+// If the callee has parameter of VectorType or pointer to VectorType,
+// or the return type is VectorType, we consider it a vector function
+// and a candidate for checking.
+AST_MATCHER(FunctionDecl, isVectorFunction) {
+  bool IsVector = Node.getReturnType()->isVectorType();
+  for (const ParmVarDecl *Parm : Node.parameters()) {
+    QualType Type = Parm->getType();
+    if (Type->isPointerType())
+      Type = Type->getPointeeType();
+    if (Type->isVectorType())
+      IsVector = true;
+  }
+  return IsVector;
+}
+
+} // namespace
+
+static StringRef TrySuggestPPC(StringRef Name) {
+  if (!Name.consume_front("vec_"))
+    return {};
+
+  static const llvm::StringMap<StringRef> Mapping{
+    // [simd.alg]
+    {"max", "$std::max"},
+    {"min", "$std::min"},
+
+    // [simd.binary]
+    {"add", "operator+ on $simd objects"},
+    {"sub", "operator- on $simd objects"},
+    {"mul", "operator* on $simd objects"},
+  };
+
+  auto It = Mapping.find(Name);
+  if (It != Mapping.end())
+    return It->second;
+  return {};
+}
+
+static StringRef TrySuggestX86(StringRef Name) {
+  if (!(Name.consume_front("_mm_") || Name.consume_front("_mm256_") ||
+        Name.consume_front("_mm512_")))
+    return {};
+
+  // [simd.alg]
+  if (Name.startswith("max_"))
+    return "$simd::max";
+  if (Name.startswith("min_"))
+    return "$simd::min";
+
+  // [simd.binary]
+  if (Name.startswith("add_"))
+    return "operator+ on $simd objects";
+  if (Name.startswith("sub_"))
+    return "operator- on $simd objects";
+  if (Name.startswith("mul_"))
+    return "operator* on $simd objects";
+
+  return {};
+}
+
+SIMDIntrinsicsCheck::SIMDIntrinsicsCheck(StringRef Name,
+                                         ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context), Suggest(Options.get("Suggest", 0) != 0) {}
+
+void SIMDIntrinsicsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "Suggest", 0);
+}
+
+void SIMDIntrinsicsCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus11)
+    return;
+  // libcxx implementation backports it to C++11 std::experimental::simd.
+  Std = getLangOpts().CPlusPlus2a ? "std" : "std::experimental";
+
+  Finder->addMatcher(callExpr(callee(functionDecl(allOf(
+                                  matchesName("^::(_mm_|_mm256_|_mm512_|vec_)"),
+                                  isVectorFunction()))),
+                              unless(isExpansionInSystemHeader()))
+                         .bind("call"),
+                     this);
+}
+
+void SIMDIntrinsicsCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
+  assert(Call != nullptr);
+  const FunctionDecl *Callee = Call->getDirectCallee();
+  if (!Callee)
+    return;
+
+  StringRef Old = Callee->getName();
+  StringRef New;
+  llvm::Triple::ArchType Arch =
+      Result.Context->getTargetInfo().getTriple().getArch();
+
+  switch (Arch) {
+    default:
+      break;
+    case llvm::Triple::ppc:
+    case llvm::Triple::ppc64:
+    case llvm::Triple::ppc64le:
+      New = TrySuggestPPC(Old);
+      break;
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      New = TrySuggestX86(Old);
+      break;
+  }
+
+  if (!New.empty()) {
+    std::string Message;
+    // If Suggest is true, give a P0214 alternative, otherwise point it out it
+    // is non-portable.
+    if (Suggest) {
+      Message = (Twine("'") + Old + "' can be replaced by " + New).str();
+      Message = llvm::Regex("\\$std").sub(Std, Message);
+      Message = llvm::Regex("\\$simd").sub(Std.str() + "::simd", Message);
+    } else {
+      Message = (Twine("'") + Old + "' is a non-portable " +
+                 llvm::Triple::getArchTypeName(Arch) + " intrinsic function")
+                    .str();
+    }
+    diag(Call->getExprLoc(), Message);
+  }
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

docs/ReleaseNotes.rst

- New `fuchsia-statically-constructed-objects
   explicit constructor.
   
 - New `fuchsia-trailing-return
   <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-trailing-return.html>`_ check
 
   Functions that have trailing returns are disallowed, except for those 
   using decltype specifiers and lambda with otherwise unutterable 
   return types.
-    
+- New `readability-simd-intrinsics
+  <http://clang.llvm.org/extra/clang-tidy/checks/readability-simd-intrinsics.html>`_ check
+
+  Warns if SIMD intrinsics are used which can be replaced by
+  ``std::experimental::simd`` operations.
+    
 - New alias `hicpp-avoid-goto
   <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-avoid-goto.html>`_ to 
   `cppcoreguidelines-avoid-goto <http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-avoid-goto.html>`_
   added.
 
 - New `bugprone-throw-keyword-missing
   <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-throw-keyword-missing.html>`_ check
 
   Diagnoses when a temporary object that appears to be an exception is constructed but not thrown.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 
 Improvements to modularize
 --------------------------
 
 The improvements are...

docs/clang-tidy/checks/list.rst

.. toctree::
    readability-non-const-parameter
    readability-redundant-control-flow
    readability-redundant-declaration
    readability-redundant-function-ptr-dereference
    readability-redundant-member-init
    readability-redundant-smartptr-get
    readability-redundant-string-cstr
    readability-redundant-string-init
+   readability-simd-intrinsics
    readability-simplify-boolean-expr
    readability-static-accessed-through-instance
    readability-static-definition-in-anonymous-namespace
    readability-string-compare
    readability-uniqueptr-delete-release

docs/clang-tidy/checks/readability-simd-intrinsics.rst

+.. title:: clang-tidy - readability-simd-intrinsics
+
+readability-simd-intrinsics
+===========================
+
+Finds SIMD intrinsics calls and suggests ``std::experimental::simd`` (`P0214`_) alternatives.
+
+If the option ``Suggest`` is set to non-zero, for
+
+.. code-block:: c++
+
+  _mm_add_epi32(a, b); // x86
+  vec_add(a, b);       // Power
+
+the check suggests an alternative:
+
+.. code-block::
+
+  operator+ on std::experimental::simd objects
+
+Otherwise, it just complains the intrinsics are non-portable (and there are `P0214`_ alternatives).
+
+Many architectures provide SIMD operations (e.g. x86 SSE/AVX, Power AltiVec/VSX,
+ARM NEON). It is common that SIMD code implementing the same algorithm, is
+written in multiple target-dispatching pieces to optimize for different
+architectures or micro-architectures.
+
+The C++ standard proposal `P0214`_ and its extensions cover many common SIMD
+operations. By migrating from target-dependent intrinsics to `P0214` operations,
+the SIMD code can be simplified and pieces for different targets can be unified.
+
+Refer to `P0214`_ for introduction and motivation for the data-parallel standard
+library.
+
+Options
+-------
+
+.. option:: Suggest
+
+   If this option is set to non-zero (default is `0`), the check will suggest P0214 alternatives, otherwise it only points out the intrinsic function is non-portable.
+
+.. _P0214: http://wg21.link/p0214

test/clang-tidy/readability-simd-intrinsics-ppc.cpp

+// RUN: %check_clang_tidy %s readability-simd-intrinsics %t -- \
+// RUN:  -config='{CheckOptions: [ \
+// RUN:    {key: readability-simd-intrinsics.Suggest, value: 1} \
+// RUN:  ]}' -- -target ppc64le -maltivec -std=c++11
+
+vector int vec_add(vector int, vector int);
+
+void PPC() {
+  vector int i0, i1;
+
+  vec_add(i0, i1);
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'vec_add' can be replaced by operator+ on std::experimental::simd objects [readability-simd-intrinsics]
+}

test/clang-tidy/readability-simd-intrinsics-x86.cpp

+// RUN: %check_clang_tidy %s readability-simd-intrinsics %t -- \
+// RUN:  -config='{CheckOptions: [ \
+// RUN:    {key: readability-simd-intrinsics.Suggest, value: 1} \
+// RUN:  ]}' -- -target x86_64 -std=c++11
+
+typedef long long __m128i __attribute__((vector_size(16)));
+typedef double __m256 __attribute__((vector_size(32)));
+
+__m128i _mm_add_epi32(__m128i, __m128i);
+__m256 _mm256_load_pd(double const *);
+void _mm256_store_pd(double *, __m256);
+
+int _mm_add_fake(int, int);
+
+void X86() {
+  __m128i i0, i1;
+  __m256 d0;
+
+  _mm_add_epi32(i0, i1);
+// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: '_mm_add_epi32' can be replaced by operator+ on std::experimental::simd objects [readability-simd-intrinsics]
+  d0 = _mm256_load_pd(0);
+  _mm256_store_pd(0, d0);
+
+  _mm_add_fake(0, 1);
+}