Merged main:5e53a8dadb00 into amd-gfx:a13c32b40a9c

Local branch amd-gfx a13c32b Merged main:38eaea73cab3 into amd-gfx:94128674bb5a
Remote branch main 5e53a8d AMDGPU: Fix verifier assert with out of bounds subregister indexes (llvm#119799)

Author: SC llvm team

clang/lib/Basic/Targets.cpp

@@ -726,6 +726,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
     case llvm::Triple::Linux:
         return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple,
                                                                         Opts);
+    case llvm::Triple::FreeBSD:
+      return std::make_unique<FreeBSDTargetInfo<LoongArch32TargetInfo>>(Triple,
+                                                                        Opts);
     default:
         return std::make_unique<LoongArch32TargetInfo>(Triple, Opts);
     }
@@ -734,6 +737,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
     case llvm::Triple::Linux:
         return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple,
                                                                         Opts);
+    case llvm::Triple::FreeBSD:
+      return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(Triple,
+                                                                        Opts);
     default:
         return std::make_unique<LoongArch64TargetInfo>(Triple, Opts);
     }

clang/lib/Basic/Targets/OSTargets.h

@@ -231,6 +231,9 @@ class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> {
     case llvm::Triple::riscv32:
     case llvm::Triple::riscv64:
       break;
+    case llvm::Triple::loongarch32:
+    case llvm::Triple::loongarch64:
+      break;
     }
   }
 };

clang/lib/Driver/SanitizerArgs.cpp

@@ -247,39 +247,49 @@ static SanitizerMask setGroupBits(SanitizerMask Kinds) {
   return Kinds;
 }
 
-static SanitizerMask parseSanitizeTrapArgs(const Driver &D,
-                                           const llvm::opt::ArgList &Args,
-                                           bool DiagnoseErrors) {
-  SanitizerMask TrapRemove; // During the loop below, the accumulated set of
-                            // sanitizers disabled by the current sanitizer
-                            // argument or any argument after it.
-  SanitizerMask TrappingKinds;
-  SanitizerMask TrappingSupportedWithGroups = setGroupBits(TrappingSupported);
+// Computes the sanitizer mask based on the default plus opt-in (if supported)
+// minus opt-out.
+static SanitizerMask
+parseSanitizeArgs(const Driver &D, const llvm::opt::ArgList &Args,
+                  bool DiagnoseErrors, SanitizerMask Supported,
+                  SanitizerMask Default, int OptInID, int OptOutID) {
+  SanitizerMask Remove; // During the loop below, the accumulated set of
+                        // sanitizers disabled by the current sanitizer
+                        // argument or any argument after it.
+  SanitizerMask Kinds;
+  SanitizerMask SupportedWithGroups = setGroupBits(Supported);
 
   for (const llvm::opt::Arg *Arg : llvm::reverse(Args)) {
-    if (Arg->getOption().matches(options::OPT_fsanitize_trap_EQ)) {
+    if (Arg->getOption().matches(OptInID)) {
       Arg->claim();
       SanitizerMask Add = parseArgValues(D, Arg, true);
-      Add &= ~TrapRemove;
-      SanitizerMask InvalidValues = Add & ~TrappingSupportedWithGroups;
+      Add &= ~Remove;
+      SanitizerMask InvalidValues = Add & ~SupportedWithGroups;
       if (InvalidValues && DiagnoseErrors) {
         SanitizerSet S;
         S.Mask = InvalidValues;
         D.Diag(diag::err_drv_unsupported_option_argument)
             << Arg->getSpelling() << toString(S);
       }
-      TrappingKinds |= expandSanitizerGroups(Add) & ~TrapRemove;
-    } else if (Arg->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) {
+      Kinds |= expandSanitizerGroups(Add) & ~Remove;
+    } else if (Arg->getOption().matches(OptOutID)) {
       Arg->claim();
-      TrapRemove |=
-          expandSanitizerGroups(parseArgValues(D, Arg, DiagnoseErrors));
+      Remove |= expandSanitizerGroups(parseArgValues(D, Arg, DiagnoseErrors));
     }
   }
 
-  // Apply default trapping behavior.
-  TrappingKinds |= TrappingDefault & ~TrapRemove;
+  // Apply default behavior.
+  Kinds |= Default & ~Remove;
+
+  return Kinds;
+}
 
-  return TrappingKinds;
+static SanitizerMask parseSanitizeTrapArgs(const Driver &D,
+                                           const llvm::opt::ArgList &Args,
+                                           bool DiagnoseErrors) {
+  return parseSanitizeArgs(D, Args, DiagnoseErrors, TrappingSupported,
+                           TrappingDefault, options::OPT_fsanitize_trap_EQ,
+                           options::OPT_fno_sanitize_trap_EQ);
 }
 
 bool SanitizerArgs::needsFuzzerInterceptors() const {

clang/lib/Driver/ToolChains/FreeBSD.cpp

@@ -213,6 +213,14 @@ void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
     CmdArgs.push_back("-m");
     CmdArgs.push_back("elf64lriscv");
     break;
+  case llvm::Triple::loongarch32:
+    CmdArgs.push_back("-m");
+    CmdArgs.push_back("elf32loongarch");
+    break;
+  case llvm::Triple::loongarch64:
+    CmdArgs.push_back("-m");
+    CmdArgs.push_back("elf64loongarch");
+    break;
   default:
     break;
   }
@@ -223,6 +231,12 @@ void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
       CmdArgs.push_back("--no-relax");
   }
 
+  if (Triple.isLoongArch64()) {
+    CmdArgs.push_back("-X");
+    if (Args.hasArg(options::OPT_mno_relax))
+      CmdArgs.push_back("--no-relax");
+  }
+
   if (Arg *A = Args.getLastArg(options::OPT_G)) {
     if (ToolChain.getTriple().isMIPS()) {
       StringRef v = A->getValue();

clang/test/Driver/freebsd.c

@@ -77,6 +77,21 @@
 // RUN:   | FileCheck --check-prefix=CHECK-RV64I-LD %s
 // CHECK-RV64I-LD: ld{{.*}}" {{.*}} "-m" "elf64lriscv"
 //
+// Check that LoongArch passes the correct linker emulation.
+//
+// RUN: %clang --target=loongarch32-freebsd -### %s %s 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-LA32-LD %s
+// CHECK-LA32-LD: ld{{.*}}" {{.*}} "-m" "elf32loongarch"
+// RUN: %clang --target=loongarch64-freebsd -### %s %s 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-LA64-LD %s
+// CHECK-LA64-LD: ld{{.*}}" {{.*}} "-m" "elf64loongarch"
+//
+// Check options passed to the linker on LoongArch
+//
+// RUN: %clang --target=loongarch64-freebsd -mno-relax -### %s %s 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-LA64-LD-OPTS %s
+// CHECK-LA64-LD-OPTS: ld{{.*}}" {{.*}} "-X" "--no-relax"
+//
 // Check that the new linker flags are passed to FreeBSD
 // RUN: %clang --target=x86_64-pc-freebsd10.0 -m32 %s \
 // RUN:   --sysroot=%S/Inputs/multiarch_freebsd64_tree -### 2>&1 \

libcxxabi/CMakeLists.txt

@@ -264,6 +264,49 @@ if (CXX_SUPPORTS_NOSTDINCXX_FLAG)
   string(REPLACE "-stdlib=libstdc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 endif()
 
+function(get_sanitizer_flags OUT_VAR  USE_SANITIZER)
+  set(SANITIZER_FLAGS)
+  set(USE_SANITIZER "${USE_SANITIZER}")
+  # NOTE: LLVM_USE_SANITIZER checks for a UNIX like system instead of MSVC.
+  # But we don't have LLVM_ON_UNIX so checking for MSVC is the best we can do.
+  if (USE_SANITIZER AND NOT MSVC)
+    append_flags_if_supported(SANITIZER_FLAGS "-fno-omit-frame-pointer")
+    append_flags_if_supported(SANITIZER_FLAGS "-gline-tables-only")
+
+    if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
+            NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
+      append_flags_if_supported(SANITIZER_FLAGS "-gline-tables-only")
+    endif()
+    if (USE_SANITIZER STREQUAL "Address")
+      append_flags(SANITIZER_FLAGS "-fsanitize=address")
+    elseif (USE_SANITIZER STREQUAL "HWAddress")
+      append_flags(SANITIZER_FLAGS "-fsanitize=hwaddress")
+    elseif (USE_SANITIZER MATCHES "Memory(WithOrigins)?")
+      append_flags(SANITIZER_FLAGS -fsanitize=memory)
+      if (USE_SANITIZER STREQUAL "MemoryWithOrigins")
+        append_flags(SANITIZER_FLAGS "-fsanitize-memory-track-origins")
+      endif()
+    elseif (USE_SANITIZER STREQUAL "Undefined")
+      append_flags(SANITIZER_FLAGS "-fsanitize=undefined" "-fno-sanitize=vptr,function" "-fno-sanitize-recover=all")
+    elseif (USE_SANITIZER STREQUAL "Address;Undefined" OR
+            USE_SANITIZER STREQUAL "Undefined;Address")
+      append_flags(SANITIZER_FLAGS "-fsanitize=address,undefined" "-fno-sanitize=vptr,function" "-fno-sanitize-recover=all")
+    elseif (USE_SANITIZER STREQUAL "Thread")
+      append_flags(SANITIZER_FLAGS -fsanitize=thread)
+    elseif (USE_SANITIZER STREQUAL "DataFlow")
+      append_flags(SANITIZER_FLAGS -fsanitize=dataflow)
+    else()
+      message(WARNING "Unsupported value of LLVM_USE_SANITIZER: ${USE_SANITIZER}")
+    endif()
+  elseif(USE_SANITIZER AND MSVC)
+    message(WARNING "LLVM_USE_SANITIZER is not supported on this platform.")
+  endif()
+  set(${OUT_VAR} "${SANITIZER_FLAGS}" PARENT_SCOPE)
+endfunction()
+
+get_sanitizer_flags(SANITIZER_FLAGS "${LLVM_USE_SANITIZER}")
+list(APPEND LIBCXXABI_COMPILE_FLAGS ${SANITIZER_FLAGS})
+
 # Let the library headers know they are currently being used to build the
 # library.
 add_definitions(-D_LIBCXXABI_BUILDING_LIBRARY)

lld/test/ELF/tls-opt.s

@@ -28,17 +28,17 @@
 // DISASM-NEXT:   addq $-8, %r28
 // DISASM-NEXT:   addq $-4, %r16
 # NDD
-// DISASM-NEXT:   addq $-10, %r16, %r16
-// DISASM-NEXT:   addq $-10, %r16, %r20
-// DISASM-NEXT:   addq $-10, %r16, %rax
-// DISASM-NEXT:   addq $-10, %rax, %r16
-// DISASM-NEXT:   addq $-10, %r8, %r16
-// DISASM-NEXT:   addq $-10, %rax, %r12
+// DISASM-NEXT:   addq $-8, %r16, %r16
+// DISASM-NEXT:   addq $-8, %r16, %r20
+// DISASM-NEXT:   addq $-8, %r16, %rax
+// DISASM-NEXT:   addq $-8, %rax, %r16
+// DISASM-NEXT:   addq $-8, %r8, %r16
+// DISASM-NEXT:   addq $-8, %rax, %r12
 # NDD + NF
-// DISASM-NEXT:   {nf} addq $-10, %r8, %r16
-// DISASM-NEXT:   {nf} addq $-10, %rax, %r12
+// DISASM-NEXT:   {nf} addq $-8, %r8, %r16
+// DISASM-NEXT:   {nf} addq $-8, %rax, %r12
 # NF
-// DISASM-NEXT:   {nf} addq $-10, %r12
+// DISASM-NEXT:   {nf} addq $-8, %r12
 
 // LD to LE:
 // DISASM-NEXT:   movq %fs:0, %rax

lld/test/ELF/x86-64-tls-ie-local.s

@@ -17,21 +17,21 @@
 ## &.got[1] - 0x1286 = 0x2380 - 0x1286 = 4346
 ## &.got[2] - 0x128e = 0x2378 - 0x128e = 4330
 ## &.got[3] - 0x1296 = 0x2380 - 0x1296 = 4330
-## &.got[0] - 0x12a0 = 0x2376 - 0x12a0 = 4310
-## &.got[1] - 0x12aa = 0x237e - 0x12aa = 4308
-## &.got[0] - 0x12b4 = 0x2376 - 0x12b4 = 4290
-## &.got[1] - 0x12be = 0x237e - 0x12be = 4288
-## &.got[0] - 0x12c8 = 0x2376 - 0x12c8 = 4270
+## &.got[0] - 0x12a0 = 0x2378 - 0x12a0 = 4312
+## &.got[1] - 0x12aa = 0x2380 - 0x12aa = 4310
+## &.got[0] - 0x12b4 = 0x2378 - 0x12b4 = 4292
+## &.got[1] - 0x12be = 0x2380 - 0x12be = 4290
+## &.got[0] - 0x12c8 = 0x2378 - 0x12c8 = 4272
 
 # CHECK:      1278:       addq 4345(%rip), %rax
 # CHECK-NEXT: 127f:       addq 4346(%rip), %rax
 # CHECK-NEXT: 1286:       addq 4330(%rip), %r16
 # CHECK-NEXT: 128e:       addq 4330(%rip), %r16
-# CHECK-NEXT: 1296:       addq %r8, 4310(%rip), %r16
-# CHECK-NEXT: 12a0:       addq 4308(%rip), %rax, %r12
-# CHECK-NEXT: 12aa:       {nf} addq %r8, 4290(%rip), %r16
-# CHECK-NEXT: 12b4:       {nf} addq 4288(%rip), %rax, %r12
-# CHECK-NEXT: 12be:       {nf} addq 4270(%rip), %r12
+# CHECK-NEXT: 1296:       addq %r8, 4312(%rip), %r16
+# CHECK-NEXT: 12a0:       addq 4310(%rip), %rax, %r12
+# CHECK-NEXT: 12aa:       {nf} addq %r8, 4292(%rip), %r16
+# CHECK-NEXT: 12b4:       {nf} addq 4290(%rip), %rax, %r12
+# CHECK-NEXT: 12be:       {nf} addq 4272(%rip), %r12
 
 addq foo@GOTTPOFF(%rip), %rax
 addq bar@GOTTPOFF(%rip), %rax

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_loongarch64.cpp

@@ -11,6 +11,7 @@
 #include "NativeRegisterContextLinux_loongarch64.h"
 
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/linux/Ptrace.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
@@ -62,6 +63,16 @@ NativeRegisterContextLinux_loongarch64::NativeRegisterContextLinux_loongarch64(
   ::memset(&m_fpr, 0, sizeof(m_fpr));
   ::memset(&m_gpr, 0, sizeof(m_gpr));
 
+  ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
+  ::memset(&m_hbp_regs, 0, sizeof(m_hbp_regs));
+
+  // Refer to:
+  // https://loongson.github.io/LoongArch-Documentation/LoongArch-Vol1-EN.html#control-and-status-registers-related-to-watchpoints
+  // 14 is just a maximum value, query hardware for actual watchpoint count.
+  m_max_hwp_supported = 14;
+  m_max_hbp_supported = 14;
+  m_refresh_hwdebug_info = true;
+
   m_gpr_is_valid = false;
   m_fpu_is_valid = false;
 }
@@ -337,4 +348,73 @@ NativeRegisterContextLinux_loongarch64::GetExpeditedRegisters(
   return expedited_reg_nums;
 }
 
+llvm::Error NativeRegisterContextLinux_loongarch64::ReadHardwareDebugInfo() {
+  if (!m_refresh_hwdebug_info)
+    return llvm::Error::success();
+
+  ::pid_t tid = m_thread.GetID();
+
+  int regset = NT_LOONGARCH_HW_WATCH;
+  struct iovec ioVec;
+  struct user_watch_state dreg_state;
+  Status error;
+
+  ioVec.iov_base = &dreg_state;
+  ioVec.iov_len = sizeof(dreg_state);
+  error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset,
+                                            &ioVec, ioVec.iov_len);
+  if (error.Fail())
+    return error.ToError();
+
+  m_max_hwp_supported = dreg_state.dbg_info & 0x3f;
+
+  regset = NT_LOONGARCH_HW_BREAK;
+  error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset,
+                                            &ioVec, ioVec.iov_len);
+  if (error.Fail())
+    return error.ToError();
+
+  m_max_hbp_supported = dreg_state.dbg_info & 0x3f;
+
+  m_refresh_hwdebug_info = false;
+
+  return llvm::Error::success();
+}
+
+llvm::Error NativeRegisterContextLinux_loongarch64::WriteHardwareDebugRegs(
+    DREGType hwbType) {
+  struct iovec ioVec;
+  struct user_watch_state dreg_state;
+  int regset;
+
+  memset(&dreg_state, 0, sizeof(dreg_state));
+  ioVec.iov_base = &dreg_state;
+
+  switch (hwbType) {
+  case eDREGTypeWATCH:
+    regset = NT_LOONGARCH_HW_WATCH;
+    ioVec.iov_len = sizeof(dreg_state.dbg_info) +
+                    (sizeof(dreg_state.dbg_regs[0]) * m_max_hwp_supported);
+
+    for (uint32_t i = 0; i < m_max_hwp_supported; i++) {
+      dreg_state.dbg_regs[i].addr = m_hwp_regs[i].address;
+      dreg_state.dbg_regs[i].ctrl = m_hwp_regs[i].control;
+    }
+    break;
+  case eDREGTypeBREAK:
+    regset = NT_LOONGARCH_HW_BREAK;
+    ioVec.iov_len = sizeof(dreg_state.dbg_info) +
+                    (sizeof(dreg_state.dbg_regs[0]) * m_max_hbp_supported);
+
+    for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
+      dreg_state.dbg_regs[i].addr = m_hbp_regs[i].address;
+      dreg_state.dbg_regs[i].ctrl = m_hbp_regs[i].control;
+    }
+    break;
+  }
+
+  return NativeProcessLinux::PtraceWrapper(PTRACE_SETREGSET, m_thread.GetID(),
+                                           &regset, &ioVec, ioVec.iov_len)
+      .ToError();
+}
 #endif // defined(__loongarch__) && __loongarch_grlen == 64

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_loongarch64.h

@@ -12,6 +12,7 @@
 #define lldb_NativeRegisterContextLinux_loongarch64_h
 
 #include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
+#include "Plugins/Process/Utility/NativeRegisterContextDBReg_loongarch.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_loongarch64.h"
 
 #include <asm/ptrace.h>
@@ -22,7 +23,8 @@ namespace process_linux {
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_loongarch64
-    : public NativeRegisterContextLinux {
+    : public NativeRegisterContextLinux,
+      public NativeRegisterContextDBReg_loongarch {
 public:
   NativeRegisterContextLinux_loongarch64(
       const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
@@ -71,6 +73,7 @@ class NativeRegisterContextLinux_loongarch64
 private:
   bool m_gpr_is_valid;
   bool m_fpu_is_valid;
+  bool m_refresh_hwdebug_info;
 
   RegisterInfoPOSIX_loongarch64::GPR m_gpr;
 
@@ -83,6 +86,10 @@ class NativeRegisterContextLinux_loongarch64
   uint32_t CalculateFprOffset(const RegisterInfo *reg_info) const;
 
   const RegisterInfoPOSIX_loongarch64 &GetRegisterInfo() const;
+
+  llvm::Error ReadHardwareDebugInfo() override;
+
+  llvm::Error WriteHardwareDebugRegs(DREGType hwbType) override;
 };
 
 } // namespace process_linux