merge main into amd-staging

Change-Id: I7ffdb0c467217f0fa9f9234f4185579daa948fcc

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

@@ -658,7 +658,7 @@ std::string IdentifierNamingCheck::HungarianNotation::getEnumPrefix(
  const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
 
  std::string Name = ED->getName().str();
- if (std::string::npos != Name.find("enum")) {
+ if (StringRef(Name).contains("enum")) {
  Name = Name.substr(strlen("enum"), Name.length() - strlen("enum"));
  Name = Name.erase(0, Name.find_first_not_of(' '));
  }

clang-tools-extra/test/clang-tidy/checkers/bugprone/implicit-widening-of-multiplication-result-char.cpp

@@ -5,7 +5,7 @@
 // RUN: %check_clang_tidy %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++ -fsigned-char
 
 // RUN: %check_clang_tidy -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c -funsigned-char
-// RUN: %check_clang_tidy %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown-x c++ -funsigned-char
+// RUN: %check_clang_tidy %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64 c++ -funsigned-char
 
 long t0(char a, char b) {
  return a * b;

clang/docs/ClangFormatStyleOptions.rst

@@ -1537,8 +1537,10 @@ the configuration (without a prefix: ``Auto``).
  Possible values:
 
  * ``RTBS_None`` (in configuration: ``None``)
- Break after return type automatically.
- ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
+ This is **deprecated**. See ``Automatic`` below.
+
+ * ``RTBS_Automatic`` (in configuration: ``Automatic``)
+ Break after return type based on ``PenaltyReturnTypeOnItsOwnLine``.
 
  .. code-block:: c++
 
@@ -1547,6 +1549,22 @@ the configuration (without a prefix: ``Auto``).
  };
  int f();
  int f() { return 1; }
+ int
+ LongName::AnotherLongName();
+
+ * ``RTBS_ExceptShortType`` (in configuration: ``ExceptShortType``)
+ Same as ``Automatic`` above, except that there is no break after short
+ return types.
+
+ .. code-block:: c++
+
+ class A {
+ int f() { return 0; };
+ };
+ int f();
+ int f() { return 1; }
+ int LongName::
+ AnotherLongName();
 
  * ``RTBS_All`` (in configuration: ``All``)
  Always break after the return type.
@@ -1565,6 +1583,8 @@ the configuration (without a prefix: ``Auto``).
  f() {
  return 1;
  }
+ int
+ LongName::AnotherLongName();
 
  * ``RTBS_TopLevel`` (in configuration: ``TopLevel``)
  Always break after the return types of top-level functions.
@@ -1580,6 +1600,8 @@ the configuration (without a prefix: ``Auto``).
  f() {
  return 1;
  }
+ int
+ LongName::AnotherLongName();
 
  * ``RTBS_AllDefinitions`` (in configuration: ``AllDefinitions``)
  Always break after the return type of function definitions.
@@ -1597,6 +1619,8 @@ the configuration (without a prefix: ``Auto``).
  f() {
  return 1;
  }
+ int
+ LongName::AnotherLongName();
 
  * ``RTBS_TopLevelDefinitions`` (in configuration: ``TopLevelDefinitions``)
  Always break after the return type of top-level definitions.
@@ -1611,6 +1635,8 @@ the configuration (without a prefix: ``Auto``).
  f() {
  return 1;
  }
+ int
+ LongName::AnotherLongName();
 
 
 

clang/include/clang/Format/Format.h

@@ -914,16 +914,31 @@ struct FormatStyle {
  /// Different ways to break after the function definition or
  /// declaration return type.
  enum ReturnTypeBreakingStyle : int8_t {
- /// Break after return type automatically.
- /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
+ /// This is **deprecated**. See ``Automatic`` below.
+ RTBS_None,
+ /// Break after return type based on ``PenaltyReturnTypeOnItsOwnLine``.
  /// \code
  /// class A {
  /// int f() { return 0; };
  /// };
  /// int f();
  /// int f() { return 1; }
+ /// int
+ /// LongName::AnotherLongName();
  /// \endcode
- RTBS_None,
+ RTBS_Automatic,
+ /// Same as ``Automatic`` above, except that there is no break after short
+ /// return types.
+ /// \code
+ /// class A {
+ /// int f() { return 0; };
+ /// };
+ /// int f();
+ /// int f() { return 1; }
+ /// int LongName::
+ /// AnotherLongName();
+ /// \endcode
+ RTBS_ExceptShortType,
  /// Always break after the return type.
  /// \code
  /// class A {
@@ -938,6 +953,8 @@ struct FormatStyle {
  /// f() {
  /// return 1;
  /// }
+ /// int
+ /// LongName::AnotherLongName();
  /// \endcode
  RTBS_All,
  /// Always break after the return types of top-level functions.
@@ -951,6 +968,8 @@ struct FormatStyle {
  /// f() {
  /// return 1;
  /// }
+ /// int
+ /// LongName::AnotherLongName();
  /// \endcode
  RTBS_TopLevel,
  /// Always break after the return type of function definitions.
@@ -966,6 +985,8 @@ struct FormatStyle {
  /// f() {
  /// return 1;
  /// }
+ /// int
+ /// LongName::AnotherLongName();
  /// \endcode
  RTBS_AllDefinitions,
  /// Always break after the return type of top-level definitions.
@@ -978,6 +999,8 @@ struct FormatStyle {
  /// f() {
  /// return 1;
  /// }
+ /// int
+ /// LongName::AnotherLongName();
  /// \endcode
  RTBS_TopLevelDefinitions,
  };

clang/lib/Basic/Targets/AMDGPU.h

@@ -168,9 +168,7 @@ class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
  return true;
  }
 
- bool HasLeftParen = false;
- if (S.consume_front("{"))
- HasLeftParen = true;
+ bool HasLeftParen = S.consume_front("{");
  if (S.empty())
  return false;
  if (S.front() != 'v' && S.front() != 's' && S.front() != 'a') {
@@ -196,9 +194,7 @@ class LLVM_LIBRARY_VISIBILITY AMDGPUTargetInfo final : public TargetInfo {
  Name = S.data() - 1;
  return true;
  }
- bool HasLeftBracket = false;
- if (S.consume_front("["))
- HasLeftBracket = true;
+ bool HasLeftBracket = S.consume_front("[");
  unsigned long long N;
  if (S.empty() || consumeUnsignedInteger(S, 10, N))
  return false;

clang/lib/Driver/Driver.cpp

@@ -1628,15 +1628,16 @@ Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
  const ToolChain &TC = getToolChain(
  *UArgs, computeTargetTriple(*this, TargetTriple, *UArgs));
 
- if (TC.getTriple().isAndroid()) {
- llvm::Triple Triple = TC.getTriple();
- StringRef TripleVersionName = Triple.getEnvironmentVersionString();
-
- if (Triple.getEnvironmentVersion().empty() && TripleVersionName != "") {
- Diags.Report(diag::err_drv_triple_version_invalid)
- << TripleVersionName << TC.getTripleString();
- ContainsError = true;
- }
+ // Check if the environment version is valid.
+ llvm::Triple Triple = TC.getTriple();
+ StringRef TripleVersionName = Triple.getEnvironmentVersionString();
+ StringRef TripleObjectFormat =
+ Triple.getObjectFormatTypeName(Triple.getObjectFormat());
+ if (Triple.getEnvironmentVersion().empty() && TripleVersionName != "" &&
+ TripleVersionName != TripleObjectFormat) {
+ Diags.Report(diag::err_drv_triple_version_invalid)
+ << TripleVersionName << TC.getTripleString();
+ ContainsError = true;
  }
 
  // Report warning when arm64EC option is overridden by specified target

clang/lib/Format/ContinuationIndenter.cpp

@@ -328,9 +328,17 @@ bool ContinuationIndenter::canBreak(const LineState &State) {
 
  // Don't break after very short return types (e.g. "void") as that is often
  // unexpected.
- if (Current.is(TT_FunctionDeclarationName) && State.Column < 6) {
- if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None)
+ if (Current.is(TT_FunctionDeclarationName)) {
+ if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None &&
+ State.Column < 6) {
  return false;
+ }
+
+ if (Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_ExceptShortType) {
+ assert(State.Column >= State.FirstIndent);
+ if (State.Column - State.FirstIndent < 6)
+ return false;
+ }
  }
 
  // If binary operators are moved to the next line (including commas for some
@@ -587,7 +595,7 @@ bool ContinuationIndenter::mustBreak(const LineState &State) {
  !State.Line->ReturnTypeWrapped &&
  // Don't break before a C# function when no break after return type.
  (!Style.isCSharp() ||
- Style.AlwaysBreakAfterReturnType != FormatStyle::RTBS_None) &&
+ Style.AlwaysBreakAfterReturnType > FormatStyle::RTBS_ExceptShortType) &&
  // Don't always break between a JavaScript `function` and the function
  // name.
  !Style.isJavaScript() && Previous.isNot(tok::kw_template) &&

clang/lib/Format/Format.cpp

@@ -558,6 +558,8 @@ template <>
 struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
  static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
  IO.enumCase(Value, "None", FormatStyle::RTBS_None);
+ IO.enumCase(Value, "Automatic", FormatStyle::RTBS_Automatic);
+ IO.enumCase(Value, "ExceptShortType", FormatStyle::RTBS_ExceptShortType);
  IO.enumCase(Value, "All", FormatStyle::RTBS_All);
  IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
  IO.enumCase(Value, "TopLevelDefinitions",

clang/lib/Format/TokenAnnotator.cpp

@@ -3434,6 +3434,8 @@ bool TokenAnnotator::mustBreakForReturnType(const AnnotatedLine &Line) const {
 
  switch (Style.AlwaysBreakAfterReturnType) {
  case FormatStyle::RTBS_None:
+ case FormatStyle::RTBS_Automatic:
+ case FormatStyle::RTBS_ExceptShortType:
  return false;
  case FormatStyle::RTBS_All:
  case FormatStyle::RTBS_TopLevel:

clang/test/CodeGen/fp128_complex.c

@@ -1,4 +1,4 @@
-// RUN: %clang -target aarch64-linux-gnuabi %s -S -emit-llvm -o - | FileCheck %s
+// RUN: %clang -target aarch64-linux-gnueabi %s -S -emit-llvm -o - | FileCheck %s
 
 _Complex long double a, b, c, d;
 void test_fp128_compound_assign(void) {

clang/test/Driver/mips-features.c

@@ -400,12 +400,12 @@
 // LONG-CALLS-DEF-NOT: "long-calls"
 //
 // -mbranch-likely
-// RUN: %clang -target -mips-mti-linux-gnu -### -c %s -mbranch-likely 2>&1 \
+// RUN: %clang --target=mips-mti-linux-gnu -### -c %s -mbranch-likely 2>&1 \
 // RUN: | FileCheck --check-prefix=BRANCH-LIKELY %s
 // BRANCH-LIKELY: argument unused during compilation: '-mbranch-likely'
 //
 // -mno-branch-likely
-// RUN: %clang -target -mips-mti-linux-gnu -### -c %s -mno-branch-likely 2>&1 \
+// RUN: %clang --target=mips-mti-linux-gnu -### -c %s -mno-branch-likely 2>&1 \
 // RUN: | FileCheck --check-prefix=NO-BRANCH-LIKELY %s
 // NO-BRANCH-LIKELY: argument unused during compilation: '-mno-branch-likely'
 

clang/test/Frontend/fixed_point_bit_widths.c

@@ -1,7 +1,7 @@
 // RUN: %clang -x c -ffixed-point -S -emit-llvm -o - %s | FileCheck %s
-// RUN: %clang -x c -ffixed-point -S -emit-llvm -o - --target=x86_64-scei-ps4-ubuntu-fast %s | FileCheck %s
+// RUN: %clang -x c -ffixed-point -S -emit-llvm -o - --target=x86_64-scei-ps4 %s | FileCheck %s
 // RUN: %clang -x c -ffixed-point -S -emit-llvm -o - --target=ppc64 %s | FileCheck %s
-// RUN: %clang -x c -ffixed-point -S -emit-llvm -o - --target=x86_64-scei-ps4-windows10pro-fast %s | FileCheck %s
+// RUN: %clang -x c -ffixed-point -S -emit-llvm -o - --target=x86_64-scei-ps4 %s | FileCheck %s
 
 /* Primary signed _Accum */
 

clang/unittests/Format/ConfigParseTest.cpp

@@ -680,6 +680,10 @@ TEST(ConfigParseTest, ParsesConfiguration) {
  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
  CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
  FormatStyle::RTBS_None);
+ CHECK_PARSE("AlwaysBreakAfterReturnType: Automatic",
+ AlwaysBreakAfterReturnType, FormatStyle::RTBS_Automatic);
+ CHECK_PARSE("AlwaysBreakAfterReturnType: ExceptShortType",
+ AlwaysBreakAfterReturnType, FormatStyle::RTBS_ExceptShortType);
  CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
  FormatStyle::RTBS_All);
  CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",

clang/unittests/Format/FormatTest.cpp

@@ -9867,14 +9867,48 @@ TEST_F(FormatTest, AlignsStringLiterals) {
 
 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
  FormatStyle Style = getLLVMStyle();
+ Style.ColumnLimit = 60;
+
  // No declarations or definitions should be moved to own line.
  Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
  verifyFormat("class A {\n"
  " int f() { return 1; }\n"
  " int g();\n"
+ " long\n"
+ " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n"
  "};\n"
  "int f() { return 1; }\n"
- "int g();",
+ "int g();\n"
+ "int foooooooooooooooooooooooooooo::\n"
+ " baaaaaaaaaaaaaaaaaaaaar();",
+ Style);
+
+ // It is now allowed to break after a short return type if necessary.
+ Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_Automatic;
+ verifyFormat("class A {\n"
+ " int f() { return 1; }\n"
+ " int g();\n"
+ " long\n"
+ " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n"
+ "};\n"
+ "int f() { return 1; }\n"
+ "int g();\n"
+ "int\n"
+ "foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaaar();",
+ Style);
+
+ // It now must never break after a short return type.
+ Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_ExceptShortType;
+ verifyFormat("class A {\n"
+ " int f() { return 1; }\n"
+ " int g();\n"
+ " long foooooooooooooooooooooooooooo::\n"
+ " baaaaaaaaaaaaaaaaaaaar();\n"
+ "};\n"
+ "int f() { return 1; }\n"
+ "int g();\n"
+ "int foooooooooooooooooooooooooooo::\n"
+ " baaaaaaaaaaaaaaaaaaaaar();",
  Style);
 
  // All declarations and definitions should have the return type moved to its
@@ -9891,13 +9925,17 @@ TEST_F(FormatTest, ReturnTypeBreakingStyle) {
  " }\n"
  " int\n"
  " g();\n"
+ " long\n"
+ " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n"
  "};\n"
  "int\n"
  "f() {\n"
  " return 1;\n"
  "}\n"
  "int\n"
- "g();",
+ "g();\n"
+ "int\n"
+ "foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaaar();",
  Style);
 
  // Top-level definitions, and no kinds of declarations should have the
@@ -9926,7 +9964,9 @@ TEST_F(FormatTest, ReturnTypeBreakingStyle) {
  " return 1;\n"
  "}\n"
  "int\n"
- "g();",
+ "g();\n"
+ "int\n"
+ "foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaaar();",
  Style);
 
  // All definitions should have the return type moved to its own line, but no

lldb/include/lldb/DataFormatters/FormatCache.h

@@ -45,15 +45,12 @@ class FormatCache {
  void Set(lldb::TypeSummaryImplSP);
  void Set(lldb::SyntheticChildrenSP);
  };
- typedef std::map<ConstString, Entry> CacheMap;
- CacheMap m_map;
+ std::map<ConstString, Entry> m_entries;
  std::recursive_mutex m_mutex;
 
  uint64_t m_cache_hits = 0;
  uint64_t m_cache_misses = 0;
 
- Entry &GetEntry(ConstString type);
-
 public:
  FormatCache() = default;