Merged master:096b25a8d8e into amd-gfx:859d3327686

Local branch amd-gfx 859d332 Merged master:3e14b95d99d into amd-gfx:4ddd982cddd
Remote branch master 096b25a [CodeGen] Use SPLAT_VECTOR for zeroinitialiser with scalable types

clang-tools-extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp

@@ -23,19 +23,14 @@ namespace abseil {
 // `FactoryName`, return `None`.
 static llvm::Optional<DurationScale>
 getScaleForFactory(llvm::StringRef FactoryName) {
-  static const std::unordered_map<std::string, DurationScale> ScaleMap(
-      {{"Nanoseconds", DurationScale::Nanoseconds},
-       {"Microseconds", DurationScale::Microseconds},
-       {"Milliseconds", DurationScale::Milliseconds},
-       {"Seconds", DurationScale::Seconds},
-       {"Minutes", DurationScale::Minutes},
-       {"Hours", DurationScale::Hours}});
-
-  auto ScaleIter = ScaleMap.find(std::string(FactoryName));
-  if (ScaleIter == ScaleMap.end())
-    return llvm::None;
-
-  return ScaleIter->second;
+  return llvm::StringSwitch<llvm::Optional<DurationScale>>(FactoryName)
+      .Case("Nanoseconds", DurationScale::Nanoseconds)
+      .Case("Microseconds", DurationScale::Microseconds)
+      .Case("Milliseconds", DurationScale::Milliseconds)
+      .Case("Seconds", DurationScale::Seconds)
+      .Case("Minutes", DurationScale::Minutes)
+      .Case("Hours", DurationScale::Hours)
+      .Default(llvm::None);
 }
 
 // Given either an integer or float literal, return its value.

clang-tools-extra/clang-tidy/modernize/DeprecatedIosBaseAliasesCheck.cpp

@@ -21,10 +21,13 @@ static constexpr std::array<StringRef, 5> DeprecatedTypes = {
     "::std::ios_base::seek_dir", "::std::ios_base::streamoff",
     "::std::ios_base::streampos"};
 
-static const llvm::StringMap<StringRef> ReplacementTypes = {
-    {"io_state", "iostate"},
-    {"open_mode", "openmode"},
-    {"seek_dir", "seekdir"}};
+static llvm::Optional<const char *> getReplacementType(StringRef Type) {
+  return llvm::StringSwitch<llvm::Optional<const char *>>(Type)
+      .Case("io_state", "iostate")
+      .Case("open_mode", "openmode")
+      .Case("seek_dir", "seekdir")
+      .Default(llvm::None);
+}
 
 void DeprecatedIosBaseAliasesCheck::registerMatchers(MatchFinder *Finder) {
   auto IoStateDecl = typedefDecl(hasAnyName(DeprecatedTypes)).bind("TypeDecl");
@@ -40,23 +43,23 @@ void DeprecatedIosBaseAliasesCheck::check(
 
   const auto *Typedef = Result.Nodes.getNodeAs<TypedefDecl>("TypeDecl");
   StringRef TypeName = Typedef->getName();
-  bool HasReplacement = ReplacementTypes.count(TypeName);
+  auto Replacement = getReplacementType(TypeName);
 
   const auto *TL = Result.Nodes.getNodeAs<TypeLoc>("TypeLoc");
   SourceLocation IoStateLoc = TL->getBeginLoc();
 
   // Do not generate fixits for matches depending on template arguments and
   // macro expansions.
-  bool Fix = HasReplacement && !TL->getType()->isDependentType();
+  bool Fix = Replacement && !TL->getType()->isDependentType();
   if (IoStateLoc.isMacroID()) {
     IoStateLoc = SM.getSpellingLoc(IoStateLoc);
     Fix = false;
   }
 
   SourceLocation EndLoc = IoStateLoc.getLocWithOffset(TypeName.size() - 1);
 
-  if (HasReplacement) {
-    auto FixName = ReplacementTypes.lookup(TypeName);
+  if (Replacement) {
+    auto FixName = *Replacement;
     auto Builder = diag(IoStateLoc, "'std::ios_base::%0' is deprecated; use "
                                     "'std::ios_base::%1' instead")
                    << TypeName << FixName;

clang-tools-extra/clang-tidy/modernize/UseUsingCheck.cpp

@@ -58,6 +58,7 @@ void UseUsingCheck::check(const MatchFinder::MatchResult &Result) {
   printPolicy.SuppressScope = true;
   printPolicy.ConstantArraySizeAsWritten = true;
   printPolicy.UseVoidForZeroParams = false;
+  printPolicy.PrintInjectedClassNameWithArguments = false;
 
   std::string Type = MatchedDecl->getUnderlyingType().getAsString(printPolicy);
   std::string Name = MatchedDecl->getNameAsString();

clang-tools-extra/clang-tidy/portability/SIMDIntrinsicsCheck.cpp

@@ -43,21 +43,15 @@ 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 {};
+  return llvm::StringSwitch<StringRef>(Name)
+      // [simd.alg]
+      .Case("max", "$std::max")
+      .Case("min", "$std::min")
+      // [simd.binary]
+      .Case("add", "operator+ on $simd objects")
+      .Case("sub", "operator- on $simd objects")
+      .Case("mul", "operator* on $simd objects")
+      .Default({});
 }
 
 static StringRef TrySuggestX86(StringRef Name) {

clang-tools-extra/clangd/ParsedAST.cpp

@@ -239,13 +239,22 @@ void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS) {
 }
 
 llvm::Optional<ParsedAST>
-ParsedAST::build(llvm::StringRef Version,
+ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
                  std::unique_ptr<clang::CompilerInvocation> CI,
                  llvm::ArrayRef<Diag> CompilerInvocationDiags,
-                 std::shared_ptr<const PreambleData> Preamble,
-                 std::unique_ptr<llvm::MemoryBuffer> Buffer,
-                 llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
-                 const SymbolIndex *Index, const ParseOptions &Opts) {
+                 std::shared_ptr<const PreambleData> Preamble) {
+  trace::Span Tracer("BuildAST");
+  SPAN_ATTACH(Tracer, "File", Filename);
+
+  auto VFS = Inputs.FS;
+  if (Preamble && Preamble->StatCache)
+    VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
+  if (VFS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
+    log("Couldn't set working directory when building the preamble.");
+    // We proceed anyway, our lit-tests rely on results for non-existing working
+    // dirs.
+  }
+
   assert(CI);
   // Command-line parsing sets DisableFree to true by default, but we don't want
   // to leak memory in clangd.
@@ -255,18 +264,17 @@ ParsedAST::build(llvm::StringRef Version,
 
   // Recovery expression currently only works for C++.
   if (CI->getLangOpts()->CPlusPlus)
-    CI->getLangOpts()->RecoveryAST = Opts.BuildRecoveryAST;
+    CI->getLangOpts()->RecoveryAST = Inputs.Opts.BuildRecoveryAST;
   // This is on-by-default in windows to allow parsing SDK headers, but it
   // breaks many features. Disable it for the main-file (not preamble).
   CI->getLangOpts()->DelayedTemplateParsing = false;
 
   StoreDiags ASTDiags;
-  std::string Content = std::string(Buffer->getBuffer());
-  std::string Filename =
-      std::string(Buffer->getBufferIdentifier()); // Absolute.
 
-  auto Clang = prepareCompilerInstance(std::move(CI), PreamblePCH,
-                                       std::move(Buffer), VFS, ASTDiags);
+  auto Clang = prepareCompilerInstance(
+      std::move(CI), PreamblePCH,
+      llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, Filename), VFS,
+      ASTDiags);
   if (!Clang)
     return None;
 
@@ -290,12 +298,12 @@ ParsedAST::build(llvm::StringRef Version,
   {
     trace::Span Tracer("ClangTidyInit");
     dlog("ClangTidy configuration for file {0}: {1}", Filename,
-         tidy::configurationAsText(Opts.ClangTidyOpts));
+         tidy::configurationAsText(Inputs.Opts.ClangTidyOpts));
     tidy::ClangTidyCheckFactories CTFactories;
     for (const auto &E : tidy::ClangTidyModuleRegistry::entries())
       E.instantiate()->addCheckFactories(CTFactories);
     CTContext.emplace(std::make_unique<tidy::DefaultOptionsProvider>(
-        tidy::ClangTidyGlobalOptions(), Opts.ClangTidyOpts));
+        tidy::ClangTidyGlobalOptions(), Inputs.Opts.ClangTidyOpts));
     CTContext->setDiagnosticsEngine(&Clang->getDiagnostics());
     CTContext->setASTContext(&Clang->getASTContext());
     CTContext->setCurrentFile(Filename);
@@ -345,16 +353,17 @@ ParsedAST::build(llvm::StringRef Version,
   // (e.g. incomplete type) and attach include insertion fixes to diagnostics.
   llvm::Optional<IncludeFixer> FixIncludes;
   auto BuildDir = VFS->getCurrentWorkingDirectory();
-  if (Opts.SuggestMissingIncludes && Index && !BuildDir.getError()) {
-    auto Style = getFormatStyleForFile(Filename, Content, VFS.get());
+  if (Inputs.Opts.SuggestMissingIncludes && Inputs.Index &&
+      !BuildDir.getError()) {
+    auto Style = getFormatStyleForFile(Filename, Inputs.Contents, VFS.get());
     auto Inserter = std::make_shared<IncludeInserter>(
-        Filename, Content, Style, BuildDir.get(),
+        Filename, Inputs.Contents, Style, BuildDir.get(),
         &Clang->getPreprocessor().getHeaderSearchInfo());
     if (Preamble) {
       for (const auto &Inc : Preamble->Includes.MainFileIncludes)
         Inserter->addExisting(Inc);
     }
-    FixIncludes.emplace(Filename, Inserter, *Index,
+    FixIncludes.emplace(Filename, Inserter, *Inputs.Index,
                         /*IndexRequestLimit=*/5);
     ASTDiags.contributeFixes([&FixIncludes](DiagnosticsEngine::Level DiagLevl,
                                             const clang::Diagnostic &Info) {
@@ -434,7 +443,7 @@ ParsedAST::build(llvm::StringRef Version,
     std::vector<Diag> D = ASTDiags.take(CTContext.getPointer());
     Diags.insert(Diags.end(), D.begin(), D.end());
   }
-  return ParsedAST(Version, std::move(Preamble), std::move(Clang),
+  return ParsedAST(Inputs.Version, std::move(Preamble), std::move(Clang),
                    std::move(Action), std::move(Tokens), std::move(Macros),
                    std::move(ParsedDecls), std::move(Diags),
                    std::move(Includes), std::move(CanonIncludes));
@@ -536,28 +545,5 @@ ParsedAST::ParsedAST(llvm::StringRef Version,
   assert(this->Action);
 }
 
-llvm::Optional<ParsedAST>
-buildAST(PathRef FileName, std::unique_ptr<CompilerInvocation> Invocation,
-         llvm::ArrayRef<Diag> CompilerInvocationDiags,
-         const ParseInputs &Inputs,
-         std::shared_ptr<const PreambleData> Preamble) {
-  trace::Span Tracer("BuildAST");
-  SPAN_ATTACH(Tracer, "File", FileName);
-
-  auto VFS = Inputs.FS;
-  if (Preamble && Preamble->StatCache)
-    VFS = Preamble->StatCache->getConsumingFS(std::move(VFS));
-  if (VFS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory)) {
-    log("Couldn't set working directory when building the preamble.");
-    // We proceed anyway, our lit-tests rely on results for non-existing working
-    // dirs.
-  }
-
-  return ParsedAST::build(
-      Inputs.Version, std::move(Invocation), CompilerInvocationDiags, Preamble,
-      llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, FileName),
-      std::move(VFS), Inputs.Index, Inputs.Opts);
-}
-
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/ParsedAST.h

@@ -15,7 +15,6 @@
 //  - capturing diagnostics for later access
 //  - running clang-tidy checks checks
 //
-//
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H
@@ -45,15 +44,14 @@ class SymbolIndex;
 /// Stores and provides access to parsed AST.
 class ParsedAST {
 public:
-  /// Attempts to run Clang and store parsed AST. If \p Preamble is non-null
-  /// it is reused during parsing.
+  /// Attempts to run Clang and store the parsed AST.
+  /// If \p Preamble is non-null it is reused during parsing.
+  /// This function does not check if preamble is valid to reuse.
   static llvm::Optional<ParsedAST>
-  build(llvm::StringRef Version, std::unique_ptr<clang::CompilerInvocation> CI,
+  build(llvm::StringRef Filename, const ParseInputs &Inputs,
+        std::unique_ptr<clang::CompilerInvocation> CI,
         llvm::ArrayRef<Diag> CompilerInvocationDiags,
-        std::shared_ptr<const PreambleData> Preamble,
-        std::unique_ptr<llvm::MemoryBuffer> Buffer,
-        llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
-        const SymbolIndex *Index, const ParseOptions &Opts);
+        std::shared_ptr<const PreambleData> Preamble);
 
   ParsedAST(ParsedAST &&Other);
   ParsedAST &operator=(ParsedAST &&Other);
@@ -141,15 +139,6 @@ class ParsedAST {
   CanonicalIncludes CanonIncludes;
 };
 
-/// Build an AST from provided user inputs. This function does not check if
-/// preamble can be reused, as this function expects that \p Preamble is the
-/// result of calling buildPreamble.
-llvm::Optional<ParsedAST>
-buildAST(PathRef FileName, std::unique_ptr<CompilerInvocation> Invocation,
-         llvm::ArrayRef<Diag> CompilerInvocationDiags,
-         const ParseInputs &Inputs,
-         std::shared_ptr<const PreambleData> Preamble);
-
 /// For testing/debugging purposes. Note that this method deserializes all
 /// unserialized Decls, so use with care.
 void dumpAST(ParsedAST &AST, llvm::raw_ostream &OS);

clang-tools-extra/clangd/TUScheduler.cpp

@@ -665,9 +665,9 @@ void ASTWorker::runWithAST(
       // return a compatible preamble as ASTWorker::update blocks.
       llvm::Optional<ParsedAST> NewAST;
       if (Invocation) {
-        NewAST = buildAST(FileName, std::move(Invocation),
-                          CompilerInvocationDiagConsumer.take(), FileInputs,
-                          getPossiblyStalePreamble());
+        NewAST = ParsedAST::build(FileName, FileInputs, std::move(Invocation),
+                                  CompilerInvocationDiagConsumer.take(),
+                                  getPossiblyStalePreamble());
         ++ASTBuildCount;
       }
       AST = NewAST ? std::make_unique<ParsedAST>(std::move(*NewAST)) : nullptr;
@@ -804,8 +804,8 @@ void ASTWorker::generateDiagnostics(
   llvm::Optional<std::unique_ptr<ParsedAST>> AST = IdleASTs.take(this);
   if (!AST || !InputsAreLatest) {
     auto RebuildStartTime = DebouncePolicy::clock::now();
-    llvm::Optional<ParsedAST> NewAST = buildAST(
-        FileName, std::move(Invocation), CIDiags, Inputs, LatestPreamble);
+    llvm::Optional<ParsedAST> NewAST = ParsedAST::build(
+        FileName, Inputs, std::move(Invocation), CIDiags, LatestPreamble);
     auto RebuildDuration = DebouncePolicy::clock::now() - RebuildStartTime;
     ++ASTBuildCount;
     // Try to record the AST-build time, to inform future update debouncing.

clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp

@@ -79,6 +79,20 @@ TEST(CommandMangler, StripOutput) {
     EXPECT_THAT(Cmd, Not(Contains(Stripped)));
 }
 
+TEST(CommandMangler, StripShowIncludes) {
+  auto Mangler = CommandMangler::forTests();
+  std::vector<std::string> Cmd = {"clang-cl", "/showIncludes", "foo.cc"};
+  Mangler.adjust(Cmd);
+  EXPECT_THAT(Cmd, Not(Contains("/showIncludes")));
+}
+
+TEST(CommandMangler, StripShowIncludesUser) {
+  auto Mangler = CommandMangler::forTests();
+  std::vector<std::string> Cmd = {"clang-cl", "/showIncludes:user", "foo.cc"};
+  Mangler.adjust(Cmd);
+  EXPECT_THAT(Cmd, Not(Contains("/showIncludes:user")));
+}
+
 TEST(CommandMangler, ClangPath) {
   auto Mangler = CommandMangler::forTests();
   Mangler.ClangPath = testPath("fake/clang");

clang-tools-extra/clangd/unittests/TestTU.cpp

@@ -73,8 +73,8 @@ ParsedAST TestTU::build() const {
   auto Preamble =
       buildPreamble(testPath(Filename), *CI, Inputs,
                     /*StoreInMemory=*/true, /*PreambleCallback=*/nullptr);
-  auto AST = buildAST(testPath(Filename), std::move(CI), Diags.take(), Inputs,
-                      Preamble);
+  auto AST = ParsedAST::build(testPath(Filename), Inputs, std::move(CI),
+                              Diags.take(), Preamble);
   if (!AST.hasValue()) {
     ADD_FAILURE() << "Failed to build code:\n" << Code;
     llvm_unreachable("Failed to build TestTU!");

clang-tools-extra/test/clang-tidy/checkers/modernize-use-using.cpp

@@ -289,3 +289,16 @@ typedef enum { ea2, eb2 } EnumT2_CheckTypedefImpactFromAnotherFile;
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use 'using' instead of 'typedef'
 // CHECK-FIXES: using EnumT2_CheckTypedefImpactFromAnotherFile = enum { ea2, eb2 };
 
+template <int A>
+struct InjectedClassName {
+  typedef InjectedClassName b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use 'using' instead of 'typedef'
+  // CHECK-FIXES: using b = InjectedClassName;
+};
+
+template <int>
+struct InjectedClassNameWithUnnamedArgument {
+  typedef InjectedClassNameWithUnnamedArgument b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use 'using' instead of 'typedef'
+  // CHECK-FIXES: using b = InjectedClassNameWithUnnamedArgument;
+};

clang/include/clang/AST/PrettyPrinter.h

@@ -63,7 +63,7 @@ struct PrintingPolicy {
         MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true),
         MSVCFormatting(false), ConstantsAsWritten(false),
         SuppressImplicitBase(false), FullyQualifiedName(false),
-        PrintCanonicalTypes(false) {}
+        PrintCanonicalTypes(false), PrintInjectedClassNameWithArguments(true) {}
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
@@ -244,6 +244,11 @@ struct PrintingPolicy {
   /// Whether to print types as written or canonically.
   unsigned PrintCanonicalTypes : 1;
 
+  /// Whether to print an InjectedClassNameType with template arguments or as
+  /// written. When a template argument is unnamed, printing it results in
+  /// invalid C++ code.
+  unsigned PrintInjectedClassNameWithArguments : 1;
+
   /// Callbacks to use to allow the behavior of printing to be customized.
   const PrintingCallbacks *Callbacks = nullptr;
 };

clang/include/clang/Basic/BuiltinsAMDGPU.def

@@ -57,6 +57,7 @@ BUILTIN(__builtin_amdgcn_ds_gws_barrier, "vUiUi", "n")
 BUILTIN(__builtin_amdgcn_ds_gws_sema_v, "vUi", "n")
 BUILTIN(__builtin_amdgcn_ds_gws_sema_br, "vUiUi", "n")
 BUILTIN(__builtin_amdgcn_ds_gws_sema_p, "vUi", "n")
+BUILTIN(__builtin_amdgcn_fence, "vUicC*", "n")
 
 // FIXME: Need to disallow constant address space.
 BUILTIN(__builtin_amdgcn_div_scale, "dddbb*", "n")

clang/include/clang/Basic/TargetBuiltins.h

@@ -241,6 +241,7 @@ namespace clang {
     bool isPrefetch() const { return Flags & IsPrefetch; }
     bool isReverseCompare() const { return Flags & ReverseCompare; }
     bool isAppendSVALL() const { return Flags & IsAppendSVALL; }
+    bool isInsertOp1SVALL() const { return Flags & IsInsertOp1SVALL; }
 
     uint64_t getBits() const { return Flags; }
     bool isFlagSet(uint64_t Flag) const { return Flags & Flag; }