LLVM and SPIRV-LLVM-Translator pulldown (WW37)

Author: bb-sycl

clang-tools-extra/clangd/DumpAST.cpp

@@ -295,7 +295,7 @@ class DumpVisitor : public RecursiveASTVisitor<DumpVisitor> {
   }
   std::string getDetail(const TemplateName &TN) {
     return toString([&](raw_ostream &OS) {
-      TN.print(OS, Ctx.getPrintingPolicy(), /*SuppressNNS=*/true);
+      TN.print(OS, Ctx.getPrintingPolicy(), TemplateName::Qualified::None);
     });
   }
   std::string getDetail(const Attr *A) {

clang-tools-extra/clangd/PathMapping.cpp

@@ -40,7 +40,7 @@ llvm::Optional<std::string> doPathMapping(llvm::StringRef S,
     llvm::StringRef Body = Uri->body();
     if (Body.consume_front(From) && (Body.empty() || Body.front() == '/')) {
       std::string MappedBody = (To + Body).str();
-      return URI(Uri->scheme(), Uri->authority(), MappedBody.c_str())
+      return URI(Uri->scheme(), Uri->authority(), MappedBody)
           .toString();
     }
   }

clang-tools-extra/docs/clang-tidy/checks/abseil-no-internal-dependencies.rst

@@ -5,7 +5,7 @@ abseil-no-internal-dependencies
 
 Warns if code using Abseil depends on internal details. If something is in a
 namespace that includes the word "internal", code is not allowed to depend upon
-it beaucse it’s an implementation detail. They cannot friend it, include it,
+it because it’s an implementation detail. They cannot friend it, include it,
 you mention it or refer to it in any way. Doing so violates Abseil's
 compatibility guidelines and may result in breakage. See
 https://abseil.io/about/compatibility for more information.

clang-tools-extra/docs/clang-tidy/checks/abseil-time-subtraction.rst

@@ -25,7 +25,7 @@ Examples:
   int x;
   absl::Time t;
 
-  // Original - absl::Duration result and first operand is a absl::Time.
+  // Original - absl::Duration result and first operand is an absl::Time.
   absl::Duration d = absl::Seconds(absl::ToUnixSeconds(t) - x);
 
   // Suggestion - Perform subtraction in the Time domain instead.

clang-tools-extra/docs/clang-tidy/checks/bugprone-fold-init-type.rst

@@ -11,7 +11,7 @@ the latter, with ``operator+`` by default. This can cause loss of precision
 through:
 
 - Truncation: The following code uses a floating point range and an int
-  initial value, so trucation will happen at every application of ``operator+``
+  initial value, so truncation will happen at every application of ``operator+``
   and the result will be `0`, which might not be what the user expected.
 
 .. code-block:: c++

clang-tools-extra/docs/clang-tidy/checks/bugprone-redundant-branch-condition.rst

@@ -41,7 +41,7 @@ is an operand of a logical "and" (``&&``) or a logical "or" (``||``) operator:
 
 In the first case (logical "and") the suggested fix is to remove the redundant
 condition variable and keep the other side of the ``&&``. In the second case
-(logical "or") the whole ``if`` is removed similarily to the simple case on the
+(logical "or") the whole ``if`` is removed similarly to the simple case on the
 top.
 
 The condition of the outer ``if`` statement may also be a logical "and" (``&&``)

clang-tools-extra/docs/clang-tidy/checks/bugprone-signal-handler.rst

@@ -20,7 +20,7 @@ and has an alias name ``cert-sig30-c``.
 
 .. option:: AsyncSafeFunctionSet
 
-  Selects wich set of functions is considered as asynchronous-safe
+  Selects which set of functions is considered as asynchronous-safe
   (and therefore allowed in signal handlers). Value ``minimal`` selects
   a minimal set that is defined in the CERT SIG30-C rule and includes functions
   ``abort()``, ``_Exit()``, ``quick_exit()`` and ``signal()``. Value ``POSIX``

clang-tools-extra/docs/clang-tidy/checks/bugprone-suspicious-memory-comparison.rst

@@ -8,12 +8,12 @@ arguments. The following cases are covered:
 
 **Case 1: Non-standard-layout type**
 
-Comparing the object representaions of non-standard-layout objects may not
+Comparing the object representations of non-standard-layout objects may not
 properly compare the value representations.
 
 **Case 2: Types with no unique object representation**
 
-Objects with the same value may not have the same object representaion.
+Objects with the same value may not have the same object representation.
 This may be caused by padding or floating-point types.
 
 See also: 

clang-tools-extra/docs/clang-tidy/checks/bugprone-too-small-loop-variable.rst

@@ -33,7 +33,7 @@ a larger user input.
   Upper limit for the magnitude bits of the loop variable. If it's set the check
   filters out those catches in which the loop variable's type has more magnitude
   bits as the specified upper limit. The default value is 16.
-  For example, if the user sets this option to 31 (bits), then a 32-bit ``unsigend int``
+  For example, if the user sets this option to 31 (bits), then a 32-bit ``unsigned int``
   is ignored by the check, however a 32-bit ``int`` is not (A 32-bit ``signed int``
   has 31 magnitude bits).
 

clang-tools-extra/docs/clang-tidy/checks/bugprone-unhandled-exception-at-new.rst

@@ -21,5 +21,5 @@ is allowed to propagate out of the function (exception handler is checked for
 types ``std::bad_alloc``, ``std::exception``, and catch-all handler).
 The check assumes that any user-defined ``operator new`` is either
 ``noexcept`` or may throw an exception of type ``std::bad_alloc`` (or derived
-from it). Other exception types or exceptions occuring in the objects's
+from it). Other exception types or exceptions occurring in the objects's
 constructor are not taken into account.

clang-tools-extra/docs/clang-tidy/checks/cert-oop57-cpp.rst

@@ -11,15 +11,15 @@ Options
 
 .. option:: MemSetNames
 
-   Specify extra functions to flag that act similarily to ``memset``.
+   Specify extra functions to flag that act similarly to ``memset``.
    Specify names in a semicolon delimited list.
    Default is an empty string.
    The check will detect the following functions:
    `memset`, `std::memset`.
 
 .. option:: MemCpyNames
 
-   Specify extra functions to flag that act similarily to ``memcpy``.
+   Specify extra functions to flag that act similarly to ``memcpy``.
    Specify names in a semicolon delimited list.
    Default is an empty string.
    The check will detect the following functions:
@@ -28,7 +28,7 @@ Options
 
 .. option:: MemCmpNames
 
-   Specify extra functions to flag that act similarily to ``memcmp``.
+   Specify extra functions to flag that act similarly to ``memcmp``.
    Specify names in a semicolon delimited list.
    Default is an empty string.
    The check will detect the following functions:

clang-tools-extra/docs/clang-tidy/checks/cppcoreguidelines-narrowing-conversions.rst

@@ -44,7 +44,7 @@ Options
 .. option:: WarnWithinTemplateInstantiation
 
     When `true`, the check will warn on narrowing conversions within template
-    instantations. `false` by default.
+    instantiations. `false` by default.
 
 .. option:: WarnOnEquivalentBitWidth
 

clang-tools-extra/docs/clang-tidy/checks/google-upgrade-googletest-case.rst

@@ -49,5 +49,5 @@ becomes
 
 For better consistency of user code, the check renames both virtual and
 non-virtual member functions with matching names in derived types. The check
-tries to provide a only warning when a fix cannot be made safely, as is the case
+tries to provide only a warning when a fix cannot be made safely, as is the case
 with some template and macro uses.

clang-tools-extra/docs/clang-tidy/checks/hicpp-no-assembler.rst

@@ -5,6 +5,6 @@ hicpp-no-assembler
 
 Check for assembler statements. No fix is offered.
 
-Inline assembler is forbidden by the `High Intergrity C++ Coding Standard
+Inline assembler is forbidden by the `High Integrity C++ Coding Standard
 <http://www.codingstandard.com/section/7-5-the-asm-declaration/>`_ 
 as it restricts the portability of code.

clang-tools-extra/docs/clang-tidy/checks/readability-redundant-member-init.rst

@@ -29,7 +29,7 @@ Options
 
     When `true`, the check will ignore unnecessary base class initializations
     within copy constructors, since some compilers issue warnings/errors when
-    base classes are not explicitly intialized in copy constructors. For example,
+    base classes are not explicitly initialized in copy constructors. For example,
     ``gcc`` with ``-Wextra`` or ``-Werror=extra`` issues warning or error
     ``base class 'Bar' should be explicitly initialized in the copy constructor``
     if ``Bar()`` were removed in the following example:

clang/docs/LanguageExtensions.rst

@@ -3597,7 +3597,7 @@ specification, a stack is supported so that the ``pragma float_control``
 settings can be pushed or popped.
 
 When ``pragma float_control(precise, on)`` is enabled, the section of code
-governed by the pragma uses precise floating-point semantics, effectively
+governed by the pragma uses precise floating point semantics, effectively
 ``-ffast-math`` is disabled and ``-ffp-contract=on``
 (fused multiply add) is enabled.
 
@@ -3608,29 +3608,8 @@ when ``pragma float_control(precise, off)`` is enabled, the section of code
 governed by the pragma behaves as though the command-line option
 ``-ffp-exception-behavior=ignore`` is enabled.
 
-When ``pragma float_control(source, on)`` is enabled, the section of code governed
-by the pragma behaves as though the command-line option
-``-ffp-eval-method=source`` is enabled. Note: The default
-floating-point evaluation method is target-specific, typically ``source``.
-
-When ``pragma float_control(double, on)`` is enabled, the section of code governed
-by the pragma behaves as though the command-line option
-``-ffp-eval-method=double`` is enabled.
-
-When ``pragma float_control(extended, on)`` is enabled, the section of code governed
-by the pragma behaves as though the command-line option
-``-ffp-eval-method=extended`` is enabled.
-
-When ``pragma float_control(source, off)`` or
-``pragma float_control(double, off)`` or
-``pragma float_control(extended, off)`` is enabled,
-the section of code governed
-by the pragma behaves as though the command-line option
-``-ffp-eval-method=source`` is enabled, returning floating-point evaluation
-method to the default setting.
-
 The full syntax this pragma supports is
-``float_control(except|precise|source|double|extended, on|off [, push])`` and
+``float_control(except|precise, on|off [, push])`` and
 ``float_control(push|pop)``.
 The ``push`` and ``pop`` forms, including using ``push`` as the optional
 third argument, can only occur at file scope.

clang/docs/UsersManual.rst

@@ -1478,17 +1478,6 @@ Note that floating-point operations performed as part of constant initialization
    * ``maytrap`` The compiler avoids transformations that may raise exceptions that would not have been raised by the original code. Constant folding performed by the compiler is exempt from this option.
    * ``strict`` The compiler ensures that all transformations strictly preserve the floating point exception semantics of the original code.
 
-.. option:: -ffp-eval-method=<value>
-
-   Specify the floating-point evaluation method.
-
-   Valid values are: ``source``, ``double``, and ``extended``.
-   The default value is target-specific, typically ``source``.  Details:
-
-   * ``source`` The compiler uses the floating-point type declared in the source program as the evaluation method.
-   * ``double`` The compiler uses ``double`` as the floating-point evaluation method for all float expressions of type that is narrower than ``double``.
-   * ``extended`` The compiler uses ``long double`` as the floating-point evaluation method for all float expressions of type that is narrower than ``long double``.
-
 .. option:: -f[no-]protect-parens:
 
    This option pertains to floating-point types, complex types with

clang/include/clang/AST/TemplateName.h

@@ -309,16 +309,17 @@ class TemplateName {
   /// unexpanded parameter pack (for C++0x variadic templates).
   bool containsUnexpandedParameterPack() const;
 
+  enum class Qualified { None, AsWritten, Fully };
   /// Print the template name.
   ///
   /// \param OS the output stream to which the template name will be
   /// printed.
   ///
-  /// \param SuppressNNS if true, don't print the
-  /// nested-name-specifier that precedes the template name (if it has
-  /// one).
+  /// \param Qual print the (Qualified::None) simple name,
+  /// (Qualified::AsWritten) any written (possibly partial) qualifier, or
+  /// (Qualified::Fully) the fully qualified name.
   void print(raw_ostream &OS, const PrintingPolicy &Policy,
-             bool SuppressNNS = false) const;
+             Qualified Qual = Qualified::AsWritten) const;
 
   /// Debugging aid that dumps the template name.
   void dump(raw_ostream &OS) const;

clang/include/clang/AST/Type.h

@@ -3534,14 +3534,10 @@ class DependentSizedMatrixType final : public MatrixType {
                            Expr *ColumnExpr, SourceLocation loc);
 
 public:
-  QualType getElementType() const { return ElementType; }
   Expr *getRowExpr() const { return RowExpr; }
   Expr *getColumnExpr() const { return ColumnExpr; }
   SourceLocation getAttributeLoc() const { return loc; }
 
-  bool isSugared() const { return false; }
-  QualType desugar() const { return QualType(this, 0); }
-
   static bool classof(const Type *T) {
     return T->getTypeClass() == DependentSizedMatrix;
   }

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -29,6 +29,9 @@ def err_drv_invalid_riscv_arch_name : Error<
   "invalid arch name '%0', %1">;
 def err_drv_invalid_riscv_ext_arch_name : Error<
   "invalid arch name '%0', %1 '%2'">;
+def warn_drv_invalid_arch_name_with_suggestion : Warning<
+  "ignoring invalid /arch: argument '%0'; for %select{64|32}1-bit expected one of %2">,
+  InGroup<UnusedCommandLineArgument>;
 def warn_drv_avr_mcu_not_specified : Warning<
   "no target microcontroller specified on command line, cannot "
   "link standard libraries, please pass -mmcu=<mcu name>">,

clang/include/clang/Basic/DiagnosticIDs.h

@@ -28,7 +28,7 @@ namespace clang {
     // Size of each of the diagnostic categories.
     enum {
       DIAG_SIZE_COMMON        =  300,
-      DIAG_SIZE_DRIVER        =  250,
+      DIAG_SIZE_DRIVER        =  260,
       DIAG_SIZE_FRONTEND      =  150,
       DIAG_SIZE_SERIALIZATION =  120,
       DIAG_SIZE_LEX           =  400,

clang/include/clang/Basic/FPOptions.def

@@ -23,5 +23,4 @@ OPTION(NoHonorInfs, bool, 1, NoHonorNaNs)
 OPTION(NoSignedZero, bool, 1, NoHonorInfs)
 OPTION(AllowReciprocal, bool, 1, NoSignedZero)
 OPTION(AllowApproxFunc, bool, 1, AllowReciprocal)
-OPTION(FPEvalMethod, LangOptions::FPEvalMethodKind, 2, AllowApproxFunc)
 #undef OPTION

clang/include/clang/Basic/LangOptions.def

@@ -310,7 +310,6 @@ BENIGN_ENUM_LANGOPT(DefaultFPContractMode, FPModeKind, 2, FPM_Off, "FP contracti
 COMPATIBLE_LANGOPT(ExpStrictFP, 1, false, "Enable experimental strict floating point")
 BENIGN_ENUM_LANGOPT(FPRoundingMode, RoundingMode, 3, RoundingMode::NearestTiesToEven, "FP Rounding Mode type")
 BENIGN_ENUM_LANGOPT(FPExceptionMode, FPExceptionModeKind, 2, FPE_Ignore, "FP Exception Behavior Mode type")
-BENIGN_ENUM_LANGOPT(FPEvalMethod, FPEvalMethodKind, 2, FEM_TargetDefault, "FP type used for floating point arithmetic")
 LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
 LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
 LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")

clang/include/clang/Basic/LangOptions.h

@@ -238,19 +238,6 @@ class LangOptions : public LangOptionsBase {
   /// Possible exception handling behavior.
   enum class ExceptionHandlingKind { None, SjLj, WinEH, DwarfCFI, Wasm };
 
-  /// Possible float expression evaluation method choices.
-  enum FPEvalMethodKind {
-    /// Use the declared type for fp arithmetic.
-    FEM_Source,
-    /// Use the type double for fp arithmetic.
-    FEM_Double,
-    /// Use extended type for fp arithmetic.
-    FEM_Extended,
-    /// Use the default float eval method specified by Target:
-    //  most targets are defined with evaluation method FEM_Source.
-    FEM_TargetDefault
-  };
-
   enum class LaxVectorConversionKind {
     /// Permit no implicit vector bitcasts.
     None,
@@ -568,7 +555,6 @@ class FPOptions {
       setAllowFEnvAccess(true);
     else
       setAllowFEnvAccess(LangOptions::FPM_Off);
-    setFPEvalMethod(LO.getFPEvalMethod());
   }
 
   bool allowFPContractWithinStatement() const {

clang/include/clang/Basic/PragmaKinds.h

@@ -32,10 +32,7 @@ enum PragmaFloatControlKind {
   PFC_Except,    // #pragma float_control(except [,on])
   PFC_NoExcept,  // #pragma float_control(except, off)
   PFC_Push,      // #pragma float_control(push)
-  PFC_Pop,       // #pragma float_control(pop)
-  PFC_Source,    // #pragma float_control(source, {on|off} [,push])
-  PFC_Double,    // #pragma float_control(double, {on|off} [,push])
-  PFC_Extended,  // #pragma float_control(extended, {on|off} [,push])
+  PFC_Pop        // #pragma float_control(pop)
 };
 }
 

clang/include/clang/Basic/TargetInfo.h

@@ -684,8 +684,7 @@ class TargetInfo : public virtual TransferrableTargetInfo,
   }
 
   /// Return the value for the C99 FLT_EVAL_METHOD macro.
-  //  Note: implementation defined values may be negative.
-  virtual int getFPEvalMethod() const { return 0; }
+  virtual unsigned getFloatEvalMethod() const { return 0; }
 
   // getLargeArrayMinWidth/Align - Return the minimum array size that is
   // 'large' and its alignment.

clang/include/clang/Driver/Options.td

@@ -1484,11 +1484,6 @@ def : Flag<["-"], "fextended-identifiers">, Group<clang_ignored_f_Group>;
 def : Flag<["-"], "fno-extended-identifiers">, Group<f_Group>, Flags<[Unsupported]>;
 def fhosted : Flag<["-"], "fhosted">, Group<f_Group>;
 def fdenormal_fp_math_EQ : Joined<["-"], "fdenormal-fp-math=">, Group<f_Group>, Flags<[CC1Option]>;
-def ffp_eval_method_EQ : Joined<["-"], "ffp-eval-method=">, Group<f_Group>, Flags<[CC1Option]>,
-  HelpText<"Specifies the evaluation method to use for floating-point arithmetic.">,
-  Values<"source,double,extended">, NormalizedValuesScope<"LangOptions">,
-  NormalizedValues<["FEM_Source", "FEM_Double", "FEM_Extended"]>,
-  MarshallingInfoEnum<LangOpts<"FPEvalMethod">, "FEM_TargetDefault">;
 def ffp_model_EQ : Joined<["-"], "ffp-model=">, Group<f_Group>, Flags<[NoXarchOption]>,
   HelpText<"Controls the semantics of floating-point calculations.">;
 def ffp_exception_behavior_EQ : Joined<["-"], "ffp-exception-behavior=">, Group<f_Group>, Flags<[CC1Option]>,
@@ -3773,8 +3768,10 @@ def multi__module : Flag<["-"], "multi_module">;
 def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
 def multiply__defined : Separate<["-"], "multiply_defined">;
 def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
+def canonical_prefixes : Flag<["-"], "canonical-prefixes">, Flags<[HelpHidden, CoreOption]>,
+  HelpText<"Use absolute paths for invoking subcommands (default)">;
 def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden, CoreOption]>,
-  HelpText<"Use relative instead of canonical paths">;
+  HelpText<"Use relative paths for invoking subcommands">;
 def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
 def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[NoXarchOption]>;
 def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;

clang/include/clang/Frontend/CompilerInvocation.h

@@ -50,6 +50,11 @@ class HeaderSearchOptions;
 class PreprocessorOptions;
 class TargetOptions;
 
+// This lets us create the DiagnosticsEngine with a properly-filled-out
+// DiagnosticOptions instance.
+std::unique_ptr<DiagnosticOptions>
+CreateAndPopulateDiagOpts(ArrayRef<const char *> Argv);
+
 /// Fill out Opts based on the options given in Args.
 ///
 /// Args must have been created from the OptTable returned by

clang/include/clang/Lex/HeaderSearch.h

@@ -51,7 +51,7 @@ class TargetInfo;
 /// The preprocessor keeps track of this information for each
 /// file that is \#included.
 struct HeaderFileInfo {
-  /// True if this is a \#import'd or \#pragma once file.
+  /// True if this is a \#import'd file.
   unsigned isImport : 1;
 
   /// True if this is a \#pragma once file.
@@ -450,11 +450,10 @@ class HeaderSearch {
     return (SrcMgr::CharacteristicKind)getFileInfo(File).DirInfo;
   }
 
-  /// Mark the specified file as a "once only" file, e.g. due to
+  /// Mark the specified file as a "once only" file due to
   /// \#pragma once.
   void MarkFileIncludeOnce(const FileEntry *File) {
     HeaderFileInfo &FI = getFileInfo(File);
-    FI.isImport = true;
     FI.isPragmaOnce = true;
   }
 
@@ -500,8 +499,7 @@ class HeaderSearch {
   /// This routine does not consider the effect of \#import
   bool isFileMultipleIncludeGuarded(const FileEntry *File);
 
-  /// Determine whether the given file is known to have ever been \#imported
-  /// (or if it has been \#included and we've encountered a \#pragma once).
+  /// Determine whether the given file is known to have ever been \#imported.
   bool hasFileBeenImported(const FileEntry *File) {
     const HeaderFileInfo *FI = getExistingFileInfo(File);
     return FI && FI->isImport;