Merge branch 'main' into users/ojhunt/P2719

Author: ojhunt

clang/include/clang/Driver/Options.td

@@ -6677,6 +6677,7 @@ def fbinutils_version_EQ : Joined<["-"], "fbinutils-version=">,
 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>,
   Flags<[LinkOption]>, Visibility<[ClangOption, FlangOption, CLOption]>;
 def ld_path_EQ : Joined<["--"], "ld-path=">, Group<Link_Group>;
+def fuse_lipo_EQ : Joined<["-"], "fuse-lipo=">, Group<f_clang_Group>, Flags<[LinkOption]>;
 
 defm align_labels : BooleanFFlag<"align-labels">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_labels_EQ : Joined<["-"], "falign-labels=">, Group<clang_ignored_gcc_optimization_f_Group>;

clang/lib/CodeGen/CGExpr.cpp

@@ -3607,18 +3607,15 @@ void CodeGenFunction::EmitCheck(
   llvm::Value *RecoverableCond = nullptr;
   llvm::Value *TrapCond = nullptr;
   bool NoMerge = false;
-  for (int i = 0, n = Checked.size(); i < n; ++i) {
-    llvm::Value *Check = Checked[i].first;
+  for (auto &[Check, Ord] : Checked) {
     // -fsanitize-trap= overrides -fsanitize-recover=.
-    llvm::Value *&Cond =
-        CGM.getCodeGenOpts().SanitizeTrap.has(Checked[i].second)
-            ? TrapCond
-            : CGM.getCodeGenOpts().SanitizeRecover.has(Checked[i].second)
-                  ? RecoverableCond
-                  : FatalCond;
+    llvm::Value *&Cond = CGM.getCodeGenOpts().SanitizeTrap.has(Ord) ? TrapCond
+                         : CGM.getCodeGenOpts().SanitizeRecover.has(Ord)
+                             ? RecoverableCond
+                             : FatalCond;
     Cond = Cond ? Builder.CreateAnd(Cond, Check) : Check;
 
-    if (!CGM.getCodeGenOpts().SanitizeMergeHandlers.has(Checked[i].second))
+    if (!CGM.getCodeGenOpts().SanitizeMergeHandlers.has(Ord))
       NoMerge = true;
   }
 

clang/lib/Driver/ToolChains/Darwin.cpp

@@ -910,7 +910,9 @@ void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back(II.getFilename());
   }
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
+  StringRef LipoName = Args.getLastArgValue(options::OPT_fuse_lipo_EQ, "lipo");
+  const char *Exec =
+      Args.MakeArgString(getToolChain().GetProgramPath(LipoName.data()));
   C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
                                          Exec, CmdArgs, Inputs, Output));
 }

clang/test/Driver/fuse-lipo.c

@@ -0,0 +1,15 @@
+// RUN: %clang %s -### --target=arm64-apple-darwin -arch x86_64 -arch arm64 -fuse-lipo=llvm-lipo 2>&1 | FileCheck -check-prefix=TEST1 %s
+// TEST1: llvm-lipo
+
+// RUN: %clang %s -### --target=arm64-apple-darwin -arch x86_64 -arch arm64 -fuse-lipo=nonexistant-lipo 2>&1 | FileCheck -check-prefix=TEST2 %s
+// TEST2: nonexistant-lipo
+
+// RUN: %clang %s -### --target=arm64-apple-darwin -fuse-lipo=llvm-lipo 2>&1 | FileCheck -check-prefix=TEST3 %s
+// TEST3: clang: warning: argument unused during compilation: '-fuse-lipo=llvm-lipo'
+
+// RUN: %clang %s -### --target=arm64-apple-darwin -Wno-unused-command-line-argument -fuse-lipo=llvm-lipo 2>&1 | FileCheck -check-prefix=TEST4 %s
+// TEST4-NOT: llvm-lipo
+
+// RUN: %clang %s -### --target=arm64-apple-darwin -arch x86_64 -arch arm64 2>&1 | FileCheck -check-prefix=TEST5 %s
+// TEST5: lipo
+// TEST5-NOT: llvm-lipo

libcxx/test/configs/stdlib-libstdc++.cfg.in

@@ -1,15 +1,15 @@
 #
 # This testing configuration runs the test suite using the libstdc++ Standard library.
 #
-# The additional '--param libstdcxx-install-prefix=<PATH>', '--param libstdcxx-triple=<TRIPLE>' and
-# '--param libstdcxx-version=<VERSION>' lit parameters must be provided when invoking lit for the
+# The additional '--param libstdcxx_install_prefix=<PATH>', '--param libstdcxx_triple=<TRIPLE>' and
+# '--param libstdcxx_version=<VERSION>' lit parameters must be provided when invoking lit for the
 # configuration to find the appropriate headers and library.
 #
 # For example:
 #
-#  $ ./libcxx/utils/libcxx-lit <BUILD> -sv libcxx/test/std --param libstdcxx-install-prefix=/opt/homebrew/Cellar/gcc/14.1.0_1 \
-#                                                          --param libstdcxx-version=14 \
-#                                                          --param libstdcxx-triple=aarch64-apple-darwin22
+#  $ ./libcxx/utils/libcxx-lit <BUILD> -sv libcxx/test/std --param libstdcxx_install_prefix=/opt/homebrew/Cellar/gcc/14.1.0_1 \
+#                                                          --param libstdcxx_version=14 \
+#                                                          --param libstdcxx_triple=aarch64-apple-darwin22
 #
 
 lit_config.load_config(config, '@CMAKE_CURRENT_BINARY_DIR@/cmake-bridge.cfg')
@@ -20,19 +20,19 @@ import libcxx.test.params, libcxx.test.config, libcxx.test.dsl
 
 # Additional parameters for libstdc++
 LIBSTDCXX_PARAMETERS = [
-    libcxx.test.dsl.Parameter(name='libstdcxx-install-prefix', type=str,
+    libcxx.test.dsl.Parameter(name='libstdcxx_install_prefix', type=str,
         actions=lambda path: [libcxx.test.dsl.AddSubstitution('%{libstdcxx-install-prefix}', path)],
         help="""
         The installation prefix where libstdc++ was installed. This is used to find the libstdc++ headers,
         link against its built library, etc.
         """),
-    libcxx.test.dsl.Parameter(name='libstdcxx-triple', type=str,
+    libcxx.test.dsl.Parameter(name='libstdcxx_triple', type=str,
         actions=lambda triple: [libcxx.test.dsl.AddSubstitution('%{libstdcxx-triple}', triple)],
         help="""
         The target triple used for the target-specific include directory of libstdc++. This is used to find the
         libstdc++ headers.
         """),
-    libcxx.test.dsl.Parameter(name='libstdcxx-version', type=str,
+    libcxx.test.dsl.Parameter(name='libstdcxx_version', type=str,
         actions=lambda version: [libcxx.test.dsl.AddSubstitution('%{libstdcxx-version}', version)],
         help="""
         The version of libstdc++. This is used to find the libstdc++ headers and library.

libunwind/src/CMakeLists.txt

@@ -20,7 +20,12 @@ set(LIBUNWIND_C_SOURCES
     )
 set_source_files_properties(${LIBUNWIND_C_SOURCES}
                             PROPERTIES
-                              COMPILE_FLAGS "-std=c99")
+                              # We need to set `-fexceptions` here so that key
+                              # unwinding functions, like
+                              # _UNWIND_RaiseException, are not marked as
+                              # `nounwind`, which breaks LTO builds of
+                              # libunwind.  See #56825 and #120657 for context.
+                              COMPILE_FLAGS "-std=c99 -fexceptions")
 
 set(LIBUNWIND_ASM_SOURCES
     UnwindRegistersRestore.S

lldb/include/lldb/Utility/LLDBAssert.h

@@ -19,24 +19,30 @@
 // __FILE__ but only renders the last path component (the filename) instead of
 // an invocation dependent full path to that file.
 #define lldbassert(x)                                                          \
-  lldb_private::lldb_assert(static_cast<bool>(x), #x, __FUNCTION__,            \
-                            __FILE_NAME__, __LINE__)
+  lldb_private::_lldb_assert(static_cast<bool>(x), #x, __FUNCTION__,           \
+                             __FILE_NAME__, __LINE__)
 #else
 #define lldbassert(x)                                                          \
-  lldb_private::lldb_assert(static_cast<bool>(x), #x, __FUNCTION__, __FILE__,  \
-                            __LINE__)
+  lldb_private::_lldb_assert(static_cast<bool>(x), #x, __FUNCTION__, __FILE__, \
+                             __LINE__)
 #endif
 #endif
 
 namespace lldb_private {
-void lldb_assert(bool expression, const char *expr_text, const char *func,
-                 const char *file, unsigned int line);
 
+/// Don't use _lldb_assert directly. Use the lldbassert macro instead so that
+/// LLDB asserts become regular asserts in NDEBUG builds.
+void _lldb_assert(bool expression, const char *expr_text, const char *func,
+                  const char *file, unsigned int line);
+
+/// The default LLDB assert callback, which prints to stderr.
 typedef void (*LLDBAssertCallback)(llvm::StringRef message,
                                    llvm::StringRef backtrace,
                                    llvm::StringRef prompt);
 
+/// Replace the LLDB assert callback.
 void SetLLDBAssertCallback(LLDBAssertCallback callback);
+
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_LLDBASSERT_H

lldb/source/Utility/LLDBAssert.cpp

@@ -20,6 +20,7 @@
 
 namespace lldb_private {
 
+/// The default callback prints to stderr.
 static void DefaultAssertCallback(llvm::StringRef message,
                                   llvm::StringRef backtrace,
                                   llvm::StringRef prompt) {
@@ -31,8 +32,8 @@ static void DefaultAssertCallback(llvm::StringRef message,
 static std::atomic<LLDBAssertCallback> g_lldb_assert_callback =
     &DefaultAssertCallback;
 
-void lldb_assert(bool expression, const char *expr_text, const char *func,
-                 const char *file, unsigned int line) {
+void _lldb_assert(bool expression, const char *expr_text, const char *func,
+                  const char *file, unsigned int line) {
   if (LLVM_LIKELY(expression))
     return;
 
@@ -44,8 +45,6 @@ void lldb_assert(bool expression, const char *expr_text, const char *func,
   }
 #endif
 
-  // Print a warning and encourage the user to file a bug report, similar to
-  // LLVM’s crash handler, and then return execution.
   std::string buffer;
   llvm::raw_string_ostream backtrace(buffer);
   llvm::sys::PrintStackTrace(backtrace);

llvm/lib/Target/AMDGPU/GCNHazardRecognizer.cpp

@@ -3007,8 +3007,8 @@ bool GCNHazardRecognizer::fixVALUMaskWriteHazard(MachineInstr *MI) {
     switch (I.getOpcode()) {
     case AMDGPU::V_ADDC_U32_e32:
     case AMDGPU::V_ADDC_U32_dpp:
-    case AMDGPU::V_CNDMASK_B16_e32:
-    case AMDGPU::V_CNDMASK_B16_dpp:
+    case AMDGPU::V_CNDMASK_B16_fake16_e32:
+    case AMDGPU::V_CNDMASK_B16_fake16_dpp:
     case AMDGPU::V_CNDMASK_B32_e32:
     case AMDGPU::V_CNDMASK_B32_dpp:
     case AMDGPU::V_DIV_FMAS_F32_e64:
@@ -3023,8 +3023,8 @@ bool GCNHazardRecognizer::fixVALUMaskWriteHazard(MachineInstr *MI) {
              HazardReg == AMDGPU::VCC_HI;
     case AMDGPU::V_ADDC_U32_e64:
     case AMDGPU::V_ADDC_U32_e64_dpp:
-    case AMDGPU::V_CNDMASK_B16_e64:
-    case AMDGPU::V_CNDMASK_B16_e64_dpp:
+    case AMDGPU::V_CNDMASK_B16_fake16_e64:
+    case AMDGPU::V_CNDMASK_B16_fake16_e64_dpp:
     case AMDGPU::V_CNDMASK_B32_e64:
     case AMDGPU::V_CNDMASK_B32_e64_dpp:
     case AMDGPU::V_SUBB_U32_e64:

llvm/lib/Target/AMDGPU/SIInstructions.td

@@ -1245,11 +1245,22 @@ class VOPSelectPat <ValueType vt> : GCNPat <
   (vt (select i1:$src0, vt:$src1, vt:$src2)),
   (V_CNDMASK_B32_e64 0, VSrc_b32:$src2, 0, VSrc_b32:$src1, SSrc_i1:$src0)
 >;
+class VOPSelectPat_t16 <ValueType vt> : GCNPat <
+  (vt (select i1:$src0, vt:$src1, vt:$src2)),
+  (V_CNDMASK_B16_t16_e64 0, VSrcT_b16:$src2, 0, VSrcT_b16:$src1, SSrc_i1:$src0)
+>;
 
 def : VOPSelectModsPat <i32>;
 def : VOPSelectModsPat <f32>;
-def : VOPSelectPat <f16>;
-def : VOPSelectPat <i16>;
+foreach p = [NotHasTrue16BitInsts, UseFakeTrue16Insts] in
+let True16Predicate = p in {
+  def : VOPSelectPat <f16>;
+  def : VOPSelectPat <i16>;
+} // End True16Predicate = p
+let True16Predicate = UseRealTrue16Insts in {
+  def : VOPSelectPat_t16 <f16>;
+  def : VOPSelectPat_t16 <i16>;
+} // End True16Predicate = UseRealTrue16Insts
 
 let AddedComplexity = 1 in {
 def : GCNPat <