merge main into amd-staging (llvm#2355)

Author: z1_cciauto

.ci/metrics/metrics.py

@@ -29,8 +29,8 @@
 # name.
 GITHUB_JOB_TO_TRACK = {
     "github_llvm_premerge_checks": {
-        "Build and Test Linux (Test Only - Please Ignore Results)": "premerge_linux",
-        "Build and Test Windows (Test Only - Please Ignore Results)": "premerge_windows",
+        "Build and Test Linux": "premerge_linux",
+        "Build and Test Windows": "premerge_windows",
     }
 }
 

.github/workflows/premerge.yaml

@@ -16,7 +16,6 @@ on:
       - closed
   push:
     branches:
-      - 'main'
       - 'release/**'
 
 concurrency:
@@ -25,7 +24,7 @@ concurrency:
 
 jobs:
   premerge-checks-linux:
-    name: Build and Test Linux (Test Only - Please Ignore Results)
+    name: Build and Test Linux
     if: >-
         github.repository_owner == 'llvm' &&
         (github.event_name != 'pull_request' || github.event.action != 'closed')
@@ -43,9 +42,6 @@ jobs:
         # Mark the job as a success even if the step fails so that people do
         # not get notified while the new premerge pipeline is in an
         # experimental state.
-        # TODO(boomanaiden154): Remove this once the pipeline is stable and we
-        # are ready for people to start recieving notifications.
-        continue-on-error: true
         run: |
           git config --global --add safe.directory '*'
 
@@ -74,7 +70,7 @@ jobs:
           include-hidden-files: 'true'
 
   premerge-checks-windows:
-    name: Build and Test Windows (Test Only - Please Ignore Results)
+    name: Build and Test Windows
     if: >-
         github.repository_owner == 'llvm' &&
         (github.event_name != 'pull_request' || github.event.action != 'closed')
@@ -110,9 +106,6 @@ jobs:
         # Mark the job as a success even if the step fails so that people do
         # not get notified while the new premerge pipeline is in an
         # experimental state.
-        # TODO(boomanaiden154): Remove this once the pipeline is stable and we
-        # are ready for people to start recieving notifications.
-        continue-on-error: true
         if: ${{ steps.vars.outputs.windows-projects != '' }}
         shell: cmd
         run: |

bolt/lib/Profile/BoltAddressTranslation.cpp

@@ -600,7 +600,7 @@ BoltAddressTranslation::getSecondaryEntryPointId(uint64_t Address,
   if (FunctionIt == SecondaryEntryPointsMap.end())
     return 0;
   const std::vector<uint32_t> &Offsets = FunctionIt->second;
-  auto OffsetIt = std::find(Offsets.begin(), Offsets.end(), Offset);
+  auto OffsetIt = llvm::find(Offsets, Offset);
   if (OffsetIt == Offsets.end())
     return 0;
   // Adding one here because main entry point is not stored in BAT, and

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

@@ -0,0 +1,47 @@
+//===--- AvoidPragmaOnceCheck.cpp - clang-tidy ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "AvoidPragmaOnceCheck.h"
+
+#include "clang/Basic/SourceManager.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang::tidy::portability {
+
+class PragmaOnceCallbacks : public PPCallbacks {
+public:
+  PragmaOnceCallbacks(AvoidPragmaOnceCheck *Check, const SourceManager &SM)
+      : Check(Check), SM(SM) {}
+  void PragmaDirective(SourceLocation Loc,
+                       PragmaIntroducerKind Introducer) override {
+    auto Str = llvm::StringRef(SM.getCharacterData(Loc));
+    if (!Str.consume_front("#"))
+      return;
+    Str = Str.trim();
+    if (!Str.consume_front("pragma"))
+      return;
+    Str = Str.trim();
+    if (Str.starts_with("once"))
+      Check->diag(Loc,
+                  "avoid 'pragma once' directive; use include guards instead");
+  }
+
+private:
+  AvoidPragmaOnceCheck *Check;
+  const SourceManager &SM;
+};
+
+void AvoidPragmaOnceCheck::registerPPCallbacks(const SourceManager &SM,
+                                               Preprocessor *PP,
+                                               Preprocessor *ModuleExpanderPP) {
+  PP->addPPCallbacks(std::make_unique<PragmaOnceCallbacks>(this, SM));
+}
+
+} // namespace clang::tidy::portability

clang-tools-extra/clang-tidy/portability/AvoidPragmaOnceCheck.h

@@ -0,0 +1,36 @@
+//===--- AvoidPragmaOnceCheck.h - clang-tidy --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_AVOIDPRAGMAONCECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_AVOIDPRAGMAONCECHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::portability {
+
+/// Finds uses of ``#pragma once`` and suggests replacing them with standard
+/// include guards (``#ifndef``/``#define``/``#endif``) for improved
+/// portability.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/portability/avoid-pragma-once.html
+class AvoidPragmaOnceCheck : public ClangTidyCheck {
+public:
+  AvoidPragmaOnceCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus || LangOpts.C99;
+  }
+
+  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
+                           Preprocessor *ModuleExpanderPP) override;
+};
+
+} // namespace clang::tidy::portability
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_AVOIDPRAGMAONCECHECK_H

clang-tools-extra/clang-tidy/portability/CMakeLists.txt

@@ -5,6 +5,7 @@ set(LLVM_LINK_COMPONENTS
   )
 
 add_clang_library(clangTidyPortabilityModule STATIC
+  AvoidPragmaOnceCheck.cpp
   PortabilityTidyModule.cpp
   RestrictSystemIncludesCheck.cpp
   SIMDIntrinsicsCheck.cpp

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

@@ -9,6 +9,7 @@
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
+#include "AvoidPragmaOnceCheck.h"
 #include "RestrictSystemIncludesCheck.h"
 #include "SIMDIntrinsicsCheck.h"
 #include "StdAllocatorConstCheck.h"
@@ -20,6 +21,8 @@ namespace portability {
 class PortabilityModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<AvoidPragmaOnceCheck>(
+        "portability-avoid-pragma-once");
     CheckFactories.registerCheck<RestrictSystemIncludesCheck>(
         "portability-restrict-system-includes");
     CheckFactories.registerCheck<SIMDIntrinsicsCheck>(

clang-tools-extra/clangd/test/path-mappings.test

@@ -2,7 +2,7 @@
 # RUN: rm -rf %t
 # RUN: cp -r %S/Inputs/path-mappings %t
 #
-# RUN: clangd --path-mappings 'C:\client=%t/server' -lit-test < %s | FileCheck -strict-whitespace %s
+# RUN: clangd --clang-tidy=false --path-mappings 'C:\client=%t/server' -lit-test < %s | FileCheck -strict-whitespace %s
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
 ---
 {

clang-tools-extra/clangd/test/system-include-extractor.test

@@ -52,7 +52,7 @@
 # Bless the mock driver we've just created so that clangd can execute it.
 # Note: include clangd's stderr in the FileCheck input with "2>&1" so that we
 # can match output lines like "ASTWorker building file"
-# RUN: clangd -lit-test -query-driver="**.test,**.sh" < %t.test 2>&1 | FileCheck -strict-whitespace %t.test
+# RUN: clangd --clang-tidy=false -lit-test -query-driver="**.test,**.sh" < %t.test 2>&1 | FileCheck -strict-whitespace %t.test
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{}}
 ---
 {
@@ -88,4 +88,4 @@
 
 # Run clangd a second time, to make sure it picks up the driver name from the config file
 # Note, we need to pass -enable-config because -lit-test otherwise disables it
-# RUN: clangd -lit-test -enable-config -query-driver="**.test,**.sh" < %t.test 2>&1 | FileCheck -strict-whitespace %t.test
+# RUN: clangd --clang-tidy=false -lit-test -enable-config -query-driver="**.test,**.sh" < %t.test 2>&1 | FileCheck -strict-whitespace %t.test

clang-tools-extra/docs/ReleaseNotes.rst

@@ -136,6 +136,12 @@ New checks
   Finds unintended character output from ``unsigned char`` and ``signed char``
   to an ``ostream``.
 
+- New :doc:`portability-avoid-pragma-once
+  <clang-tidy/checks/portability/avoid-pragma-once>` check.
+
+  Finds uses of ``#pragma once`` and suggests replacing them with standard
+  include guards (``#ifndef``/``#define``/``#endif``) for improved portability.
+
 - New :doc:`readability-ambiguous-smartptr-reset-call
   <clang-tidy/checks/readability/ambiguous-smartptr-reset-call>` check.
 

clang-tools-extra/docs/clang-tidy/checks/list.rst

@@ -351,6 +351,7 @@ Clang-Tidy Checks
    :doc:`performance-type-promotion-in-math-fn <performance/type-promotion-in-math-fn>`, "Yes"
    :doc:`performance-unnecessary-copy-initialization <performance/unnecessary-copy-initialization>`, "Yes"
    :doc:`performance-unnecessary-value-param <performance/unnecessary-value-param>`, "Yes"
+   :doc:`portability-avoid-pragma-once <portability/avoid-pragma-once>`,
    :doc:`portability-restrict-system-includes <portability/restrict-system-includes>`, "Yes"
    :doc:`portability-simd-intrinsics <portability/simd-intrinsics>`,
    :doc:`portability-std-allocator-const <portability/std-allocator-const>`,

clang-tools-extra/docs/clang-tidy/checks/portability/avoid-pragma-once.rst

@@ -0,0 +1,35 @@
+.. title:: clang-tidy - portability-avoid-pragma-once
+
+portability-avoid-pragma-once
+=============================
+
+Finds uses of ``#pragma once`` and suggests replacing them with standard
+include guards (``#ifndef``/``#define``/``#endif``) for improved portability.
+
+``#pragma once`` is a non-standard extension, despite being widely supported
+by modern compilers. Relying on it can lead to portability issues in
+some environments.
+
+Some older or specialized C/C++ compilers, particularly in embedded systems,
+may not fully support ``#pragma once``.
+
+It can also fail in certain file system configurations, like network drives
+or complex symbolic links, potentially leading to compilation issues.
+
+Consider the following header file:
+
+.. code:: c++
+
+  // my_header.h
+  #pragma once // warning: avoid 'pragma once' directive; use include guards instead
+
+
+The warning suggests using include guards:
+
+.. code:: c++
+
+  // my_header.h
+  #ifndef PATH_TO_MY_HEADER_H // Good: use include guards.
+  #define PATH_TO_MY_HEADER_H
+
+  #endif // PATH_TO_MY_HEADER_H

clang-tools-extra/test/clang-tidy/checkers/portability/Inputs/avoid-pragma-once/lib0.h

@@ -0,0 +1 @@
+#pragma once

clang-tools-extra/test/clang-tidy/checkers/portability/Inputs/avoid-pragma-once/lib1.h

@@ -0,0 +1 @@
+# pragma once

clang-tools-extra/test/clang-tidy/checkers/portability/Inputs/avoid-pragma-once/lib2.h

@@ -0,0 +1 @@
+# pragma   once

clang-tools-extra/test/clang-tidy/checkers/portability/avoid-pragma-once.cpp

@@ -0,0 +1,15 @@
+// RUN: %check_clang_tidy %s portability-avoid-pragma-once %t \
+// RUN:   -- --header-filter='.*' --  -I%S/Inputs/avoid-pragma-once
+
+// #pragma once
+#include "lib0.h"
+// CHECK-MESSAGES: lib0.h:1:1:  warning: avoid 'pragma once' directive; use include guards instead
+
+
+// # pragma once
+#include "lib1.h"
+// CHECK-MESSAGES: lib1.h:1:1:  warning: avoid 'pragma once' directive; use include guards instead
+
+// # pragma   once 
+#include "lib2.h"
+// CHECK-MESSAGES: lib2.h:1:1:  warning: avoid 'pragma once' directive; use include guards instead

clang/include/clang/Analysis/ProgramPoint.h

@@ -42,7 +42,7 @@ class ProgramPointTag {
 
   /// The description of this program point which will be dumped for debugging
   /// purposes. Do not use in user-facing output!
-  virtual StringRef getTagDescription() const = 0;
+  virtual StringRef getDebugTag() const = 0;
 
   /// Used to implement 'isKind' in subclasses.
   const void *getTagKind() const { return TagKind; }
@@ -55,7 +55,7 @@ class SimpleProgramPointTag : public ProgramPointTag {
   std::string Desc;
 public:
   SimpleProgramPointTag(StringRef MsgProvider, StringRef Msg);
-  StringRef getTagDescription() const override;
+  StringRef getDebugTag() const override;
 };
 
 class ProgramPoint {

clang/include/clang/Lex/HLSLRootSignatureTokenKinds.def

@@ -80,6 +80,7 @@ KEYWORD(RootSignature) // used only for diagnostic messaging
 KEYWORD(RootFlags)
 KEYWORD(DescriptorTable)
 KEYWORD(RootConstants)
+KEYWORD(StaticSampler)
 
 // RootConstants Keywords:
 KEYWORD(num32BitConstants)

clang/include/clang/Parse/ParseHLSLRootSignature.h

@@ -77,6 +77,7 @@ class RootSignatureParser {
   std::optional<llvm::hlsl::rootsig::DescriptorTable> parseDescriptorTable();
   std::optional<llvm::hlsl::rootsig::DescriptorTableClause>
   parseDescriptorTableClause();
+  std::optional<llvm::hlsl::rootsig::StaticSampler> parseStaticSampler();
 
   /// Parameter arguments (eg. `bReg`, `space`, ...) can be specified in any
   /// order and only exactly once. The following methods define a
@@ -108,6 +109,11 @@ class RootSignatureParser {
   std::optional<ParsedClauseParams>
   parseDescriptorTableClauseParams(RootSignatureToken::Kind RegType);
 
+  struct ParsedStaticSamplerParams {
+    std::optional<llvm::hlsl::rootsig::Register> Reg;
+  };
+  std::optional<ParsedStaticSamplerParams> parseStaticSamplerParams();
+
   // Common parsing methods
   std::optional<uint32_t> parseUIntParam();
   std::optional<llvm::hlsl::rootsig::Register> parseRegister();

clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h

@@ -758,7 +758,7 @@ class BugReporterContext {
 /// DataTag::Factory should be friend for every derived class.
 class DataTag : public ProgramPointTag {
 public:
-  StringRef getTagDescription() const override { return "Data Tag"; }
+  StringRef getDebugTag() const override { return "Data Tag"; }
 
   // Manage memory for DataTag objects.
   class Factory {
@@ -809,7 +809,7 @@ class NoteTag : public DataTag {
     return std::move(Msg);
   }
 
-  StringRef getTagDescription() const override {
+  StringRef getDebugTag() const override {
     // TODO: Remember a few examples of generated messages
     // and display them in the ExplodedGraph dump by
     // returning them from this function.

clang/include/clang/StaticAnalyzer/Core/Checker.h

@@ -526,7 +526,7 @@ class CheckerBase : public CheckerFrontend, public CheckerBackend {
 public:
   /// Attached to nodes created by this checker class when the ExplodedGraph is
   /// dumped for debugging.
-  StringRef getTagDescription() const override;
+  StringRef getDebugTag() const override;
 };
 
 /// Simple checker classes that implement one frontend (i.e. checker name)
@@ -547,16 +547,16 @@ class Checker : public CheckerBase, public CHECKs... {
 /// callbacks (i.e. classes like `check::PreStmt` or `eval::Call`) as template
 /// arguments of `FamilyChecker.`
 ///
-/// NOTE: Classes deriving from `CheckerFamily` must implement the pure
-/// virtual method `StringRef getTagDescription()` which is inherited from
-/// `ProgramPointTag` and should return the name of the class as a string.
+/// NOTE: Classes deriving from `CheckerFamily` must implement the pure virtual
+/// method `StringRef getDebugTag()` which is inherited from `ProgramPointTag`
+/// and should return the name of the class as a string.
 ///
 /// Obviously, this boilerplate is not a good thing, but unfortunately there is
 /// no portable way to stringify the name of a type (e.g. class), so any
-/// portable implementation of `getTagDescription` would need to take the
-/// name of the class from *somewhere* where it's present as a string -- and
-/// then directly placing it in a method override is much simpler than
-/// loading it from `Checkers.td`.
+/// portable implementation of `getDebugTag` would need to take the name of
+/// the class from *somewhere* where it's present as a string -- and then
+/// directly placing it in a method override is much simpler than loading it
+/// from `Checkers.td`.
 ///
 /// Note that the existing `CLASS` field in `Checkers.td` is not suitable for
 /// our goals, because instead of storing the same class name for each

clang/lib/Analysis/ProgramPoint.cpp

@@ -357,4 +357,4 @@ SimpleProgramPointTag::SimpleProgramPointTag(StringRef MsgProvider,
                                              StringRef Msg)
   : Desc((MsgProvider + " : " + Msg).str()) {}
 
-StringRef SimpleProgramPointTag::getTagDescription() const { return Desc; }
+StringRef SimpleProgramPointTag::getDebugTag() const { return Desc; }

clang/lib/Format/MacroCallReconstructor.cpp

@@ -511,9 +511,8 @@ MacroCallReconstructor::createUnwrappedLine(const ReconstructedLine &Line,
   for (const auto &N : Line.Tokens) {
     Result.Tokens.push_back(N->Tok);
     UnwrappedLineNode &Current = Result.Tokens.back();
-    auto NumChildren =
-        std::count_if(N->Children.begin(), N->Children.end(),
-                      [](const auto &Child) { return !Child->Tokens.empty(); });
+    auto NumChildren = llvm::count_if(
+        N->Children, [](const auto &Child) { return !Child->Tokens.empty(); });
     if (NumChildren == 1 && Current.Tok->isOneOf(tok::l_paren, tok::comma)) {
       // If we only have one child, and the child is due to a macro expansion
       // (either attached to a left parenthesis or comma), merge the child into