[XRay] Add initial support for loongarch64

[SixWeining]

Summary

Only support patching FunctionEntry/FunctionExit/FunctionTailExit for now.

[SixWeining]

D140725 is abandoned. Let me defer this change until we support 64bit PC-relative relocation for SymA - SymB.

[SixWeining]

In D140727#4019019, @SixWeining wrote:

D140725 is abandoned. Let me defer this change until we support 64bit PC-relative relocation for SymA - SymB.

Update: R_LARCH_64_PCREL can be emitted after D153872. And I'd like to ask @Ami-zhang to update this patch later.

llvm/test/CodeGen/LoongArch/xray-attribute-instrumentation.ll

11

CHECK-COUNT-11

[MaskRay]

llvm/test/CodeGen/LoongArch/xray-attribute-instrumentation.ll

1

I think you want to read my recent updates to other xray-attribute-instrumentation.ll. Certain changes can make the test less sensitive to non-xray updates.

[Ami-zhang]

(1) Rebase
(2) Make some minor changes to xray-attribute-instrumentation.ll

[MaskRay]

compiler-rt/lib/xray/xray_loongarch64.cpp

154

I know you copy the pattern from other patterns, but we should use TODO here. An unimplemented minor feature is not FIXME.

compiler-rt/lib/xray/xray_trampoline_loongarch64.S

28

You can use .irpc to simplify this a bit. See libunwind/src/UnwindRegistersSave.S

compiler-rt/test/xray/TestCases/Posix/arg1-arg0-logging.cpp

9

I added aarch64 support. You may rebase and add loongarch64 on the REQUIRES: line.

compiler-rt/test/xray/TestCases/Posix/basic-filtering.cpp

26

Most REQUIRES: x86_64-target-arch are unnecessarily constrained. I just removed them. You may rebase and avoid changes to these test files.

[MaskRay]

compiler-rt/lib/xray/xray_loongarch64.cpp

24

I think the PO_ style actually harms readability. Most instructions are used just once. It's more readable just using the magic number when it is needed paired with an inline comment

Address[10] = insn2RI12(0x02c00000, RegNum::RN_S, ...) // addi.d ...

[SixWeining]

Since R_LARCH_64_PCREL has been supported, we can use version 2 xray and the patch summary should be modified accordingly.

llvm/lib/Target/LoongArch/LoongArchAsmPrinter.cpp

228

should use version 2:

recordSled(BeginOfSled, MI, Kind, 2);

[Ami-zhang]

compiler-rt/lib/xray/xray_loongarch64.cpp

24

Ok, updated it. Thanks for your suggestion.

154

Done.

compiler-rt/lib/xray/xray_trampoline_loongarch64.S

28

Done.

compiler-rt/test/xray/TestCases/Posix/arg1-arg0-logging.cpp

9

Rebased.

compiler-rt/test/xray/TestCases/Posix/basic-filtering.cpp

26

Rebased.

llvm/lib/Target/LoongArch/LoongArchAsmPrinter.cpp

228

Yes, updated it.

llvm/test/CodeGen/LoongArch/xray-attribute-instrumentation.ll

11

Done.

[Ami-zhang]

Rebase and make some improvements.

[xen0n]

compiler-rt/lib/xray/xray_loongarch64.cpp

23–26

I think people usually just declare the register ABI names with decimal numbers for readability?

This is minor but I personally find it slightly distracting to have to think about what's 0xc in decimal (that's the case even though I'm already very familiar with these kinds of thing). Not sure if others also prefer decimals though...

33

Parens not needed in this case. (If you want to enhance readability for those people having difficulties remembering precedence and associativeness of operators, you should instead put the parens around Rj << 5 and Imm << 10...)

I'd suggest re-ordering the operands too, to imitate the expected bit layout of the result.

40

Similarly here.

43–48

Does this look *very* similar to encodeInstruction2RI12? ;-)

Actually, if you don't bounds-check the operands, you only need one helper for each combination of slots involved. Check for example the static uint32_t insn implementation in my D138135, or the auto-generated encoding helpers for the QEMU TCG LoongArch64 port, for some alternative approaches.

59

.tmpN: for it to not look like a directive?

72

All-lowercase i.e. tracing for consistency? Or am I missing something?

74

I think idiomatically it's not "create/delete stack frame" but rather "(de-)allocate" or "setup/teardown"... anyway please fix the usage of articles (put the "the"'s properly) and also add a space after the ; because it's usually aesthetically better.

This is all minor though, and it's not like people will misunderstand anything otherwise, but rather it's mostly just me pushing for more natural English usage.

81

("set back" happens to be an idiomatic phrase verb so I got confused here for ~1 second, so I think it's probably easier to just avoid this coincidence.)

compiler-rt/lib/xray/xray_trampoline_loongarch64.S

84

Use pseudo-instruction for idiomatic expression of intent.

llvm/lib/Target/LoongArch/LoongArchAsmPrinter.cpp

193–218

We don't have to repeat the instruction pattern when we can just refer people to the source file containing this. Also the comment seems to be explanation for the magic number 11, so it should probably come before the definition.

[Ami-zhang]

compiler-rt/lib/xray/xray_loongarch64.cpp

23–26

Ok, use decimal numbers to declare the register ABI names.

33

What you said makes sense. Thanks for your suggestion and attentiveness. I have adjusted parens and operands order.

40

Done.

43–48

It is indeed similar to encodeInstruction2RI12. Given its exclusive use in this context, I prefer the unified 2RIx format.

Thanks for the suggestion. While we appreciate it, we are more inclined to use one 2RIx format helper here.

59

Use the real .Lxray_sled_endN.

72

It should be a copy from mips. I think it can be written tracing hook or TracingHook. To maintain all-lowercase consistency here, I use tracing hook.

74

Ok, a space after the ; is added. About article the, i also added it. But i am not sure whether the usage of the is proper. If there are any further issues , I would greatly appreciate your feedback.

Thanks for your effort.

81

Done.

compiler-rt/lib/xray/xray_trampoline_loongarch64.S

84

Done.

llvm/lib/Target/LoongArch/LoongArchAsmPrinter.cpp

193–218

Done.

[Ami-zhang]

Addressed @xen0n's comments.

[xen0n]

Thanks for following up with the suggestions. This now looks mostly okay to me; let's wait for more people to chip in!

[xen0n]

Ah, the patch summary probably needs some update as well. We no longer care about version 0 and the backend changes for R_LARCH_64_PCREL are already in, for example.

[MaskRay]

compiler-rt/lib/xray/xray_trampoline_loongarch64.S

21

The symbol needs to be hidden and consider using some macros. See xray_trampoline_AArch64.S

[MaskRay]

compiler-rt/lib/xray/xray_loongarch64.cpp

31

Early xray code unfortunately does not respect the conventional style that well.
The usual order is static inline

[Ami-zhang]

compiler-rt/lib/xray/xray_loongarch64.cpp

31

Done, adjusted to static inline.

compiler-rt/lib/xray/xray_trampoline_loongarch64.S

21

Ok, I have modified them.
Thanks for your suggestion.

[Ami-zhang]

Hide some symbols and using some macros in asm.

[MaskRay]

One nit about the test.

llvm/test/CodeGen/LoongArch/xray-attribute-instrumentation.ll

25

See llvm/test/CodeGen/X86/xray-attribute-instrumentation.ll. I use something like [[TMP:.Ltmp[0-9]+]]: so that we don't need to adjust the test if the compiler happens to produce more .Ltmp* symbols.

[Ami-zhang]

llvm/test/CodeGen/LoongArch/xray-attribute-instrumentation.ll

25

Done.

[Ami-zhang]

Make xray-attribute-instrumentation.ll less sensitive to .Ltmp/.Lxray_fn_idx label changes

[Ami-zhang]

Remove unnecessary '\' symbol in xray-attribute-instrumentation.ll

clang/lib/Driver/XRayArgs.cpp

if (!Args.hasFlag(options::OPT_fxray_instrument,
     return;
   if (Triple.getOS() == llvm::Triple::Linux) {
     switch (Triple.getArch()) {
     case llvm::Triple::x86_64:
     case llvm::Triple::arm:
     case llvm::Triple::aarch64:
     case llvm::Triple::hexagon:
     case llvm::Triple::ppc64le:
+    case llvm::Triple::loongarch64:
     case llvm::Triple::mips:
     case llvm::Triple::mipsel:
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
       break;
     default:
       D.Diag(diag::err_drv_clang_unsupported)
           << (std::string(XRayInstrumentOption) + " on " + Triple.str());

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake

 set(ALL_SCUDO_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS32}
     ${MIPS64} ${PPC64} ${HEXAGON} ${LOONGARCH64})
 set(ALL_SCUDO_STANDALONE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64} ${HEXAGON} ${LOONGARCH64})
 if(APPLE)
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64})
 else()
 set(ALL_XRAY_SUPPORTED_ARCH ${X86_64} ${ARM32} ${ARM64} ${MIPS32} ${MIPS64}
-    powerpc64le ${HEXAGON})
+    powerpc64le ${HEXAGON} ${LOONGARCH64})
 endif()
 set(ALL_SHADOWCALLSTACK_SUPPORTED_ARCH ${ARM64})
 
 if (UNIX)
 set(ALL_ORC_SUPPORTED_ARCH ${X86_64} ${ARM64} ${ARM32})
 endif()
 
 if (WIN32)
   set(ALL_ORC_SUPPORTED_ARCH ${X86_64})
 endif()

compiler-rt/lib/xray/CMakeLists.txt

set(armhf_SOURCES
   ${arm_SOURCES}
   )
 
 set(aarch64_SOURCES
   xray_AArch64.cpp
   xray_trampoline_AArch64.S
   )
 
+set(loongarch64_SOURCES
+  xray_loongarch64.cpp
+  xray_trampoline_loongarch64.S
+  )
+
 set(mips_SOURCES
   xray_mips.cpp
   xray_trampoline_mips.S
   )
 
 set(mipsel_SOURCES
   xray_mips.cpp
   xray_trampoline_mips.S
set(XRAY_ALL_SOURCE_FILES
   ${XRAY_SOURCES}
   ${XRAY_FDR_MODE_SOURCES}
   ${XRAY_BASIC_MODE_SOURCES}
   ${XRAY_PROFILING_MODE_SOURCES}
   ${x86_64_SOURCES}
   ${arm_SOURCES}
   ${armhf_SOURCES}
   ${hexagon_SOURCES}
+  ${loongarch64_SOURCES}
   ${mips_SOURCES}
   ${mipsel_SOURCES}
   ${mips64_SOURCES}
   ${mips64el_SOURCES}
   ${powerpc64le_SOURCES}
   ${XRAY_IMPL_HEADERS}
   )
 list(REMOVE_DUPLICATES XRAY_ALL_SOURCE_FILES)

compiler-rt/lib/xray/xray_interface.cpp

 namespace __xray {
 
 #if defined(__x86_64__)
 static const int16_t cSledLength = 12;
 #elif defined(__aarch64__)
 static const int16_t cSledLength = 32;
 #elif defined(__arm__)
 static const int16_t cSledLength = 28;
+#elif SANITIZER_LOONGARCH64
+static const int16_t cSledLength = 48;
 #elif SANITIZER_MIPS32
 static const int16_t cSledLength = 48;
 #elif SANITIZER_MIPS64
 static const int16_t cSledLength = 64;
 #elif defined(__powerpc64__)
 static const int16_t cSledLength = 8;
 #elif defined(__hexagon__)
 static const int16_t cSledLength = 20;

compiler-rt/lib/xray/xray_loongarch64.cpp

+//===-------- xray_loongarch64.cpp ------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of XRay, a dynamic runtime instrumentation system.
+//
+// Implementation of loongarch-specific routines.
+//
+//===----------------------------------------------------------------------===//
+#include "sanitizer_common/sanitizer_common.h"
+#include "xray_defs.h"
+#include "xray_interface_internal.h"
+#include <atomic>
+
+namespace __xray {
+
+// The machine codes for some instructions used in runtime patching.
+enum PatchOpcodes : uint32_t {
+  PO_ADDID = 0x02c00000,  // addi.d rd, rj, imm
+  PO_SD = 0x29c00000,     // st.d rd, base, offset
+  PO_LU12IW = 0x14000000, // lu12i.w rd, imm
+  PO_ORI = 0x03800000,    // ori rd, rs, imm
+  PO_LU32ID = 0x16000000, // lu32i.d rd, imm
+  PO_LU52ID = 0x03000000, // lu52i.d rd, rj, imm
+  PO_JIRL = 0x4c000000,   // jirl rd, rj, 0
+  PO_LD = 0x28c00000,     // ld.d rd, base, offset
+  PO_B48 = 0x50003000,    // b #48
+};
+
+enum RegNum : uint32_t {
+  RN_T0 = 0xC,
+  RN_T1 = 0xD,
+  RN_RA = 0x1,
+  RN_SP = 0x3,
+};
+
+// Encode instructions in 2RI12 format, e.g. addi.d/lu521.d/ori/ld.d/st.d.
+inline static uint32_t
+encodeInstruction2RI12(uint32_t Opcode, uint32_t Rd, uint32_t Rj,
+                       uint32_t Imm) XRAY_NEVER_INSTRUMENT {
+  return (Opcode | Rj << 5 | Rd | Imm << 10);
+}
+
+// Encode instructions in 1RI20 format, e.g. lu12i.w/lu32i.d.
+inline static uint32_t
+encodeInstruction1RI20(uint32_t Opcode, uint32_t Rd,
+                       uint32_t Imm) XRAY_NEVER_INSTRUMENT {
+  return (Opcode | Rd | Imm << 5);
+}
+
+// Encode instructions in 2RI16 format, e.g. jirl.
+inline static uint32_t
+encodeInstruction2RI16(uint32_t Opcode, uint32_t Rd, uint32_t Rj,
+                       uint32_t Imm) XRAY_NEVER_INSTRUMENT {
+  return (Opcode | Rj << 5 | Rd | Imm << 10);
+}
+
+inline static bool patchSled(const bool Enable, const uint32_t FuncId,
+                             const XRaySledEntry &Sled,
+                             void (*TracingHook)()) XRAY_NEVER_INSTRUMENT {
+  // When |Enable| == true,
+  // We replace the following compile-time stub (sled):
+  //
+  // xray_sled_n:
+  //  B .tmpN
+  //  11 NOPs (44 bytes)
+  //  .tmpN
+  //
+  // With the following runtime patch:
+  //
+  // xray_sled_n:
+  //   addi.d  sp, sp, -16                       ;create stack frame
+  //   st.d    ra, sp, 8                         ;save return address
+  //   lu12i.w t0, %abs_hi20(__xray_FunctionEntry/Exit)
+  //   ori     t0, t0, %abs_lo12(__xray_FunctionEntry/Exit)
+  //   lu32i.d t0, %abs64_lo20(__xray_FunctionEntry/Exit)
+  //   lu52i.d t0, t0, %abs64_hi12(__xray_FunctionEntry/Exit)
+  //   lu12i.w t1, %abs_hi20(function_id)
+  //   ori     t1, t1, %abs_lo12(function_id)    ;pass function id
+  //   jirl    ra, t0, 0                         ;call Tracing hook
+  //   ld.d    ra, sp, 8                         ;restore return address
+  //   addi.d  sp, sp, 16                        ;delete stack frame
+  //
+  // Replacement of the first 4-byte instruction should be the last and atomic
+  // operation, so that the user code which reaches the sled concurrently
+  // either jumps over the whole sled, or executes the whole sled when the
+  // latter is ready.
+  //
+  // When |Enable|==false, we set back the first instruction in the sled to be
+  //   B #48
+
+  uint32_t *Address = reinterpret_cast<uint32_t *>(Sled.address());
+  if (Enable) {
+    uint32_t LoTracingHookAddr = reinterpret_cast<int64_t>(TracingHook) & 0xfff;
+    uint32_t HiTracingHookAddr =
+        (reinterpret_cast<int64_t>(TracingHook) >> 12) & 0xfffff;
+    uint32_t HigherTracingHookAddr =
+        (reinterpret_cast<int64_t>(TracingHook) >> 32) & 0xfffff;
+    uint32_t HighestTracingHookAddr =
+        (reinterpret_cast<int64_t>(TracingHook) >> 52) & 0xfff;
+    uint32_t LoFunctionID = FuncId & 0xfff;
+    uint32_t HiFunctionID = (FuncId >> 12) & 0xfffff;
+    Address[1] = encodeInstruction2RI12(PatchOpcodes::PO_SD, RegNum::RN_RA,
+                                        RegNum::RN_SP, 0x8);
+    Address[2] = encodeInstruction1RI20(PatchOpcodes::PO_LU12IW, RegNum::RN_T0,
+                                        HiTracingHookAddr);
+    Address[3] = encodeInstruction2RI12(PatchOpcodes::PO_ORI, RegNum::RN_T0,
+                                        RegNum::RN_T0, LoTracingHookAddr);
+    Address[4] = encodeInstruction1RI20(PatchOpcodes::PO_LU32ID, RegNum::RN_T0,
+                                        HigherTracingHookAddr);
+    Address[5] = encodeInstruction2RI12(PatchOpcodes::PO_LU52ID, RegNum::RN_T0,
+                                        RegNum::RN_T0, HighestTracingHookAddr);
+    Address[6] = encodeInstruction1RI20(PatchOpcodes::PO_LU12IW, RegNum::RN_T1,
+                                        HiFunctionID);
+    Address[7] = encodeInstruction2RI12(PatchOpcodes::PO_ORI, RegNum::RN_T1,
+                                        RegNum::RN_T1, LoFunctionID);
+    Address[8] = encodeInstruction2RI16(PatchOpcodes::PO_JIRL, RegNum::RN_RA,
+                                        RegNum::RN_T0, 0);
+    Address[9] = encodeInstruction2RI12(PatchOpcodes::PO_LD, RegNum::RN_RA,
+                                        RegNum::RN_SP, 0x8);
+    Address[10] = encodeInstruction2RI12(PatchOpcodes::PO_ADDID, RegNum::RN_SP,
+                                         RegNum::RN_SP, 0x10);
+    uint32_t CreateStackSpace = encodeInstruction2RI12(
+        PatchOpcodes::PO_ADDID, RegNum::RN_SP, RegNum::RN_SP, 0xff0);
+    std::atomic_store_explicit(
+        reinterpret_cast<std::atomic<uint32_t> *>(Address), CreateStackSpace,
+        std::memory_order_release);
+  } else {
+    std::atomic_store_explicit(
+        reinterpret_cast<std::atomic<uint32_t> *>(Address),
+        uint32_t(PatchOpcodes::PO_B48), std::memory_order_release);
+  }
+  return true;
+}
+
+bool patchFunctionEntry(const bool Enable, const uint32_t FuncId,
+                        const XRaySledEntry &Sled,
+                        void (*Trampoline)()) XRAY_NEVER_INSTRUMENT {
+  return patchSled(Enable, FuncId, Sled, Trampoline);
+}
+
+bool patchFunctionExit(const bool Enable, const uint32_t FuncId,
+                       const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
+  return patchSled(Enable, FuncId, Sled, __xray_FunctionExit);
+}
+
+bool patchFunctionTailExit(const bool Enable, const uint32_t FuncId,
+                           const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
+  // FIXME: In the future we'd need to distinguish between non-tail exits and
+  // tail exits for better information preservation.
+  return patchSled(Enable, FuncId, Sled, __xray_FunctionExit);
+}
+
+bool patchCustomEvent(const bool Enable, const uint32_t FuncId,
+                      const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
+  // FIXME: Implement in loongarch?
+  return false;
+}
+
+bool patchTypedEvent(const bool Enable, const uint32_t FuncId,
+                     const XRaySledEntry &Sled) XRAY_NEVER_INSTRUMENT {
+  // FIXME: Implement in loongarch?
+  return false;
+}
+} // namespace __xray
+
+extern "C" void __xray_ArgLoggerEntry() XRAY_NEVER_INSTRUMENT {
+  // FIXME: this will have to be implemented in the trampoline assembly file
+}

compiler-rt/lib/xray/xray_trampoline_loongarch64.S

+//===-- xray_trampoline_loongarch64.s ---------------------------*- ASM -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of XRay, a dynamic runtime instrumentation system.
+//
+// This implements the loongarch-specific assembler for the trampolines.
+//
+//===----------------------------------------------------------------------===//
+
+  .text
+  .file "xray_trampoline_loongarch64.S"
+  .globl __xray_FunctionEntry
+  .p2align 2
+  .type __xray_FunctionEntry,@function
+__xray_FunctionEntry:
+  .cfi_startproc
+  // Save argument registers before doing any actual work.
+  .cfi_def_cfa_offset 136
+  addi.d  $sp, $sp, -136
+  st.d    $ra, $sp, 128
+  .cfi_offset 1, -8
+  st.d    $a7, $sp, 120
+  st.d    $a6, $sp, 112
+  st.d    $a5, $sp, 104
+  st.d    $a4, $sp, 96
+  st.d    $a3, $sp, 88
+  st.d    $a2, $sp, 80
+  st.d    $a1, $sp, 72
+  st.d    $a0, $sp, 64
+  fst.d   $f7, $sp, 56
+  fst.d   $f6, $sp, 48
+  fst.d   $f5, $sp, 40
+  fst.d   $f4, $sp, 32
+  fst.d   $f3, $sp, 24
+  fst.d   $f2, $sp, 16
+  fst.d   $f1, $sp, 8
+  fst.d   $f0, $sp, 0
+
+  la.got  $t2, _ZN6__xray19XRayPatchedFunctionE
+  ld.d    $t2, $t2, 0
+
+  beqz    $t2, FunctionEntry_restore
+
+  // a1=0 means that we are tracing an entry event
+  move    $a1, $zero
+  // Function ID is in t1 (the first parameter).
+  move    $a0, $t1
+  jirl    $ra, $t2, 0
+
+FunctionEntry_restore:
+  // Restore argument registers
+  fld.d   $f0, $sp, 0
+  fld.d   $f1, $sp, 8
+  fld.d   $f2, $sp, 16
+  fld.d   $f3, $sp, 24
+  fld.d   $f4, $sp, 32
+  fld.d   $f5, $sp, 40
+  fld.d   $f6, $sp, 48
+  fld.d   $f7, $sp, 56
+  ld.d    $a0, $sp, 64
+  ld.d    $a1, $sp, 72
+  ld.d    $a2, $sp, 80
+  ld.d    $a3, $sp, 88
+  ld.d    $a4, $sp, 96
+  ld.d    $a5, $sp, 104
+  ld.d    $a6, $sp, 112
+  ld.d    $a7, $sp, 120
+  ld.d    $ra, $sp, 128
+  addi.d  $sp, $sp, 136
+  ret
+FunctionEntry_end:
+  .size __xray_FunctionEntry, FunctionEntry_end-__xray_FunctionEntry
+  .cfi_endproc
+
+  .text
+  .globl __xray_FunctionExit
+  .p2align 2
+  .type __xray_FunctionExit,@function
+__xray_FunctionExit:
+  .cfi_startproc
+  // Save return registers before doing any actual work.
+  .cfi_def_cfa_offset 48
+  addi.d  $sp, $sp, -48
+  st.d    $ra, $sp, 40
+  .cfi_offset 1, -8
+  st.d    $fp, $sp, 32
+  st.d    $a1, $sp, 24
+  st.d    $a0, $sp, 16
+  fst.d   $f1, $sp, 8
+  fst.d   $f0, $sp, 0
+
+  la.got  $t2, _ZN6__xray19XRayPatchedFunctionE
+  ld.d    $t2, $t2, 0
+
+  beqz    $t2, FunctionExit_restore
+
+  // a1=1 means that we are tracing an exit event
+  ori     $a1, $zero, 1
+  // Function ID is in t1 (the first parameter).
+  move    $a0, $t1
+  jirl    $ra, $t2, 0
+
+FunctionExit_restore:
+  // Restore return registers
+  fld.d   $f0, $sp, 0
+  fld.d   $f1, $sp, 8
+  ld.d    $a1, $sp, 24
+  ld.d    $a0, $sp, 16
+  ld.d    $fp, $sp, 32
+  ld.d    $ra, $sp, 40
+  addi.d  $sp, $sp, 48
+  ret
+
+FunctionExit_end:
+  .size __xray_FunctionExit, FunctionExit_end-__xray_FunctionExit
+  .cfi_endproc

compiler-rt/lib/xray/xray_tsc.h

 
 #else // SANITIZER_FUCHSIA
 
 #if defined(__x86_64__)
 #include "xray_x86_64.inc"
 #elif defined(__powerpc64__)
 #include "xray_powerpc64.inc"
 #elif defined(__arm__) || defined(__aarch64__) || defined(__mips__) ||         \
-    defined(__hexagon__)
+    defined(__hexagon__) || defined(__loongarch_lp64)
 // Emulated TSC.
 // There is no instruction like RDTSCP in user mode on ARM. ARM's CP15 does
 //   not have a constant frequency like TSC on x86(_64), it may go faster
 //   or slower depending on CPU turbo or power saving mode. Furthermore,
 //   to read from CP15 on ARM a kernel modification or a driver is needed.
 //   We can not require this from users of compiler-rt.
 // So on ARM we use clock_gettime() which gives the result in nanoseconds.
 //   To get the measurements per second, we scale this by the number of

compiler-rt/test/xray/TestCases/Posix/always-never-instrument.cpp

 // Test that the always/never instrument lists apply.
 // RUN: echo "fun:main" > %tmp-always.txt
 // RUN: echo "fun:__xray*" > %tmp-never.txt
 // RUN: %clangxx_xray \
 // RUN:     -fxray-never-instrument=%tmp-never.txt \
 // RUN:     -fxray-always-instrument=%tmp-always.txt \
 // RUN:     %s -o %t
 // RUN: %llvm_xray extract -symbolize %t | \
 // RUN:    FileCheck %s --check-prefix NOINSTR
 // RUN: %llvm_xray extract -symbolize %t | \
 // RUN:    FileCheck %s --check-prefix ALWAYSINSTR
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 // NOINSTR-NOT: {{.*__xray_NeverInstrumented.*}}
 int __xray_NeverInstrumented() {
   return 0;
 }
 
 // ALWAYSINSTR: {{.*function-name:.*main.*}}
 int main(int argc, char *argv[]) {
   return __xray_NeverInstrumented();
 }

compiler-rt/test/xray/TestCases/Posix/arg1-arg0-logging.cpp

 // Allow having both the no-arg and arg1 logging implementation live together,
 // and be called in the correct cases.
 //
 // RUN: rm -f arg0-arg1-logging-*
 // RUN: %clangxx_xray -std=c++11 %s -o %t
 // RUN: XRAY_OPTIONS="patch_premain=true verbosity=1 xray_logfile_base=arg0-arg1-logging-" %run %t
 //
 // TODO: Support these in ARM and PPC
-// XFAIL: target={{(arm|aarch64|mips).*}}
+// XFAIL: target={{(arm|aarch64|loongarch64|mips).*}}
 // UNSUPPORTED: target=powerpc64le{{.*}}
 
 #include "xray/xray_interface.h"
 #include <cassert>
 #include <cstdio>
 
 using namespace std;
 

compiler-rt/test/xray/TestCases/Posix/arg1-logger.cpp

 // Check that we can get the first function argument logged
 // using a custom logging function.
 //
 // RUN: %clangxx_xray -std=c++11 %s -o %t
 // RUN: rm -f arg1-logger-*
 // RUN: XRAY_OPTIONS="patch_premain=true verbosity=1 xray_mode=xray-basic \
 // RUN:    xray_logfile_base=arg1-logger-" %run %t 2>&1 | FileCheck %s
 //
 // After all that, clean up the XRay log file.
 //
 // RUN: rm -f arg1-logger-*
 //
 // At the time of writing, the ARM trampolines weren't written yet.
-// XFAIL: target={{(arm|aarch64|mips).*}}
+// XFAIL: target={{(arm|aarch64|loongarch64|mips).*}}
 // See the mailing list discussion of r296998.
 // UNSUPPORTED: target=powerpc64le{{.*}}
 
 #include "xray/xray_interface.h"
 
 #include <cinttypes>
 #include <cstdio>
 

compiler-rt/test/xray/TestCases/Posix/arg1-logging-implicit-this.cpp

 // Intercept the implicit 'this' argument of class member functions.
 //
 // RUN: %clangxx_xray -g -std=c++11 %s -o %t
 // RUN: rm -f log-args-this-*
 // RUN: XRAY_OPTIONS="patch_premain=true verbosity=1 xray_logfile_base=log-args-this-" %run %t
 //
-// XFAIL: target={{(arm|aarch64|mips).*}}
+// XFAIL: target={{(arm|aarch64|loongarch64|mips).*}}
 // UNSUPPORTED: target=powerpc64le{{.*}}
 #include "xray/xray_interface.h"
 #include <cassert>
 
 class A {
  public:
   [[clang::xray_always_instrument, clang::xray_log_args(1)]] void f() {
     // does nothing.

compiler-rt/test/xray/TestCases/Posix/basic-filtering.cpp

 // RUN:     xray_logfile_base=basic-filtering-" \
 // RUN: XRAY_BASIC_OPTIONS="func_duration_threshold_us=1000 max_stack_depth=2" \
 // RUN:     %run %t 2>&1 | FileCheck %s
 // RUN: %llvm_xray convert --symbolize --output-format=yaml -instr_map=%t \
 // RUN:     "`ls basic-filtering-* | head -1`" | \
 // RUN:     FileCheck %s --check-prefix TRACE
 // RUN: rm -f basic-filtering-*
 //
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 #include <cstdio>
 #include <time.h>
 
 [[clang::xray_always_instrument]] void __attribute__((noinline)) filtered() {
   printf("filtered was called.\n");
 }

compiler-rt/test/xray/TestCases/Posix/c-test.cpp

 // RUN: %clang_xray -g -fxray-modes=xray-basic,xray-fdr,xray-profiling -o %t %s
 // RUN: rm -f xray-log.c-test.*
 // RUN: XRAY_OPTIONS=patch_premain=true:verbosity=1:xray_mode=xray-basic %t \
 // RUN:     2>&1 | FileCheck %s
 // RUN: rm -f xray-log.c-test.*
 //
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 __attribute__((xray_always_instrument)) void always() {}
 
 int main() {
   always();
 }
 
 // CHECK: =={{[0-9].*}}==XRay: Log file in '{{.*}}'

compiler-rt/test/xray/TestCases/Posix/clang-no-xray-instrument.cpp

 // Test that we cannot actually find XRay instrumentation when we build with
 // -fno-xray-instrument but have code that's marked as 'xray_always_instrument'.
 //
 // RUN: %clangxx -fno-xray-instrument -c %s -o %t.o
 // RUN: not %llvm_xray extract -symbolize %t.o 2>&1 | FileCheck %s
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 // CHECK: llvm-xray: Cannot extract instrumentation map
 // CHECK-NOT: {{.*always_instrumented.*}}
 [[clang::xray_always_instrument]] int always_instrumented() { return 42; }

compiler-rt/test/xray/TestCases/Posix/fdr-mode-inmemory.cpp

 // RUN: %clangxx_xray -g -std=c++11 %s -o %t -fxray-modes=xray-fdr
 // RUN: rm -f fdr-inmemory-test-*
 // RUN: XRAY_OPTIONS="patch_premain=false xray_logfile_base=fdr-inmemory-test- \
 // RUN:     verbosity=1" \
 // RUN: XRAY_FDR_OPTIONS="no_file_flush=true func_duration_threshold_us=0" \
 // RUN:     %run %t 2>&1 | FileCheck %s
 // RUN: FILES=`find %T -name 'fdr-inmemory-test-*' | wc -l`
 // RUN: [ $FILES -eq 0 ]
 // RUN: rm -f fdr-inmemory-test-*
 //
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 #include "xray/xray_log_interface.h"
 #include <cassert>
 #include <iostream>
 
 uint64_t var = 0;
 uint64_t buffers = 0;

compiler-rt/test/xray/TestCases/Posix/fdr-mode-multiple.cpp

 // RUN: %clangxx_xray -g -std=c++11 %s -o %t -fxray-modes=xray-fdr
 // RUN: rm -f fdr-inmemory-test-*
 // RUN: XRAY_OPTIONS="patch_premain=false xray_logfile_base=fdr-inmemory-test- \
 // RUN:     verbosity=1" \
 // RUN: XRAY_FDR_OPTIONS="no_file_flush=true func_duration_threshold_us=0" \
 // RUN:     %run %t 2>&1 | FileCheck %s
 // RUN: FILES=`find %T -name 'fdr-inmemory-test-*' | wc -l`
 // RUN: [ $FILES -eq 0 ]
 // RUN: rm -f fdr-inmemory-test-*
 //
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 #include "xray/xray_log_interface.h"
 #include <cassert>
 #include <iostream>
 
 uint64_t var = 0;
 uint64_t buffers = 0;

compiler-rt/test/xray/TestCases/Posix/fdr-single-thread.cpp

 // RUN: %clangxx_xray -g -std=c++11 %s -o %t
 // RUN: rm -f fdr-logging-1thr-*
 // RUN: XRAY_OPTIONS=XRAY_OPTIONS="verbosity=1 patch_premain=true \
 // RUN:   xray_fdr_log=true \
 // RUN:   xray_fdr_log_func_duration_threshold_us=0 \
 // RUN:   xray_logfile_base=fdr-logging-1thr-" %run %t 2>&1
 // RUN: %llvm_xray convert --output-format=yaml --symbolize --instr_map=%t \
 // RUN:   "`ls fdr-logging-1thr-* | head -n1`" | FileCheck %s
 // RUN: rm fdr-logging-1thr-*
 //
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 
 #include "xray/xray_log_interface.h"
 #include <cassert>
 
 [[clang::xray_always_instrument]] void __attribute__((noinline)) fn() { }
 
 int main(int argc, char *argv[]) {
   auto status = __xray_log_init_mode("xray-fdr", "");

compiler-rt/test/xray/TestCases/Posix/fdr-thread-order.cpp

 // RUN: rm -rf %t && mkdir %t
 // RUN: %clangxx_xray -g -std=c++11 %s -o %t.exe
 // RUN: XRAY_OPTIONS="patch_premain=false \
 // RUN:    xray_logfile_base=%t/ xray_mode=xray-fdr verbosity=1" \
 // RUN:    XRAY_FDR_OPTIONS=func_duration_threshold_us=0 %run %t.exe 2>&1 | \
 // RUN:    FileCheck %s
 // RUN: %llvm_xray convert --symbolize --output-format=yaml -instr_map=%t.exe %t/*
 // RUN: %llvm_xray convert --symbolize --output-format=yaml -instr_map=%t.exe %t/* | \
 // RUN:   FileCheck %s --check-prefix TRACE
 // FIXME: Make llvm-xray work on non-x86_64 as well.
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 #include "xray/xray_log_interface.h"
 #include <atomic>
 #include <cassert>
 #include <thread>
 
 std::atomic<uint64_t> var{0};

compiler-rt/test/xray/TestCases/Posix/profiling-multi-threaded.cpp

 // Check that we can get a profile from a single-threaded application, on
 // demand through the XRay logging implementation API.
 //
 // FIXME: Make -fxray-modes=xray-profiling part of the default?
 // RUN: %clangxx_xray -std=c++11 %s -o %t -fxray-modes=xray-profiling
 // RUN: rm -f xray-log.profiling-multi-*
 // RUN: XRAY_OPTIONS=verbosity=1 \
 // RUN:     XRAY_PROFILING_OPTIONS=no_flush=1 %run %t
 // RUN: XRAY_OPTIONS=verbosity=1 %run %t
 // RUN: PROFILES=`ls xray-log.profiling-multi-* | wc -l`
 // RUN: [ $PROFILES -eq 1 ]
 // RUN: rm -f xray-log.profiling-multi-*
 //
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 #include "xray/xray_interface.h"
 #include "xray/xray_log_interface.h"
 #include <cassert>
 #include <cstdio>
 #include <string>
 #include <thread>

compiler-rt/test/xray/TestCases/Posix/profiling-single-threaded.cpp

 // Check that we can get a profile from a single-threaded application, on
 // demand through the XRay logging implementation API.
 //
 // FIXME: Make -fxray-modes=xray-profiling part of the default?
 // RUN: %clangxx_xray -std=c++11 %s -o %t -fxray-modes=xray-profiling
 // RUN: rm -f xray-log.profiling-single-*
 // RUN: XRAY_OPTIONS=verbosity=1 \
 // RUN:     XRAY_PROFILING_OPTIONS=no_flush=true %run %t
 // RUN: XRAY_OPTIONS=verbosity=1 %run %t
 // RUN: PROFILES=`ls xray-log.profiling-single-* | wc -l`
 // RUN: [ $PROFILES -eq 2 ]
 // RUN: rm -f xray-log.profiling-single-*
 //
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 // REQUIRES: built-in-llvm-tree
 
 #include "xray/xray_interface.h"
 #include "xray/xray_log_interface.h"
 #include <cassert>
 #include <cstdio>
 #include <string>
 

compiler-rt/test/xray/TestCases/Posix/quiet-start.cpp

 // Ensure that we have a quiet startup when we don't have the XRay
 // instrumentation sleds.
 //
 // RUN: %clangxx -std=c++11 %s -o %t %xraylib
 // RUN: XRAY_OPTIONS="patch_premain=true verbosity=1" %run %t 2>&1 | \
 // RUN:    FileCheck %s --check-prefix NOISY
 // RUN: XRAY_OPTIONS="patch_premain=true verbosity=0" %run %t 2>&1 | \
 // RUN:    FileCheck %s --check-prefix QUIET
 // RUN: XRAY_OPTIONS="" %run %t 2>&1 | FileCheck %s --check-prefix DEFAULT
 //
 // FIXME: Understand how to make this work on other platforms
 // REQUIRES: built-in-llvm-tree
-// REQUIRES: x86_64-target-arch
+// REQUIRES: x86_64-target-arch || loongarch64-target-arch
 #include <iostream>
 
 using namespace std;
 
 int main(int, char**) {
   // NOISY: {{.*}}XRay instrumentation map missing. Not initializing XRay.
   // QUIET-NOT: {{.*}}XRay instrumentation map missing. Not initializing XRay.
   // DEFAULT-NOT: {{.*}}XRay instrumentation map missing. Not initializing XRay.
   cout << "Hello, XRay!" << endl;
   // NOISY: Hello, XRay!
   // QUIET: Hello, XRay!
   // DEFAULT: Hello, XRay!
 }

llvm/lib/CodeGen/XRayInstrumentation.cpp

bool XRayInstrumentation::runOnMachineFunction(MachineFunction &MF) {
   }
 
   if (!F.hasFnAttribute("xray-skip-exit")) {
     switch (MF.getTarget().getTargetTriple().getArch()) {
     case Triple::ArchType::arm:
     case Triple::ArchType::thumb:
     case Triple::ArchType::aarch64:
     case Triple::ArchType::hexagon:
+    case Triple::ArchType::loongarch64:
     case Triple::ArchType::mips:
     case Triple::ArchType::mipsel:
     case Triple::ArchType::mips64:
     case Triple::ArchType::mips64el: {
       // For the architectures which don't have a single return instruction
       InstrumentationOptions op;
       op.HandleTailcall = false;
       op.HandleAllReturns = true;

llvm/lib/Target/LoongArch/LoongArchAsmPrinter.h

public:
 
   void emitInstruction(const MachineInstr *MI) override;
 
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                        const char *ExtraCode, raw_ostream &OS) override;
   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
                              const char *ExtraCode, raw_ostream &OS) override;
 
+  void emitSled(const MachineInstr &MI, SledKind Kind);
+
+  void LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI);
+  void LowerPATCHABLE_FUNCTION_EXIT(const MachineInstr &MI);
+  void LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI);
+
   // tblgen'erated function.
   bool emitPseudoExpansionLowering(MCStreamer &OutStreamer,
                                    const MachineInstr *MI);
   // Wrapper needed for tblgenned pseudo lowering.
   bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const {
     return lowerLoongArchMachineOperandToMCOperand(MO, MCOp, *this);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_LOONGARCH_LOONGARCHASMPRINTER_H

llvm/lib/Target/LoongArch/LoongArchAsmPrinter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "LoongArchAsmPrinter.h"
 #include "LoongArch.h"
 #include "LoongArchTargetMachine.h"
 #include "MCTargetDesc/LoongArchInstPrinter.h"
 #include "TargetInfo/LoongArchTargetInfo.h"
 #include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/TargetRegistry.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "loongarch-asm-printer"
 
 // Simple pseudo-instructions have their lowering (with expansion to real
 // instructions) auto-generated.
 #include "LoongArchGenMCPseudoLowering.inc"
 
 void LoongArchAsmPrinter::emitInstruction(const MachineInstr *MI) {
   LoongArch_MC::verifyInstructionPredicates(
       MI->getOpcode(), getSubtargetInfo().getFeatureBits());
 
   // Do any auto-generated pseudo lowerings.
   if (emitPseudoExpansionLowering(*OutStreamer, MI))
     return;
 
+  switch (MI->getOpcode()) {
+  case TargetOpcode::PATCHABLE_FUNCTION_ENTER:
+    LowerPATCHABLE_FUNCTION_ENTER(*MI);
+    return;
+
+  case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
+    LowerPATCHABLE_FUNCTION_EXIT(*MI);
+    return;
+
+  case TargetOpcode::PATCHABLE_TAIL_CALL:
+    LowerPATCHABLE_TAIL_CALL(*MI);
+    return;
+  }
+
   MCInst TmpInst;
   if (!lowerLoongArchMachineInstrToMCInst(MI, TmpInst, *this))
     EmitToStreamer(*OutStreamer, TmpInst);
 }
 
+void LoongArchAsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(
+    const MachineInstr &MI) {
+  // TODO: handle "patchable-function-entry" function attribute
+  emitSled(MI, SledKind::FUNCTION_ENTER);
+}
+
+void LoongArchAsmPrinter::LowerPATCHABLE_FUNCTION_EXIT(const MachineInstr &MI) {
+  emitSled(MI, SledKind::FUNCTION_EXIT);
+}
+
+void LoongArchAsmPrinter::LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI) {
+  emitSled(MI, SledKind::TAIL_CALL);
+}
+
+void LoongArchAsmPrinter::emitSled(const MachineInstr &MI, SledKind Kind) {
+  const int8_t NoopsInSledCount = 11;
+  // For loongarch64 we want to emit the following pattern:
+  //
+  // .Lxray_sled_beginN:
+  //   ALIGN
+  //   B .Lxray_sled_endN
+  //   11 NOP instructions (44 bytes)
+  // .Lxray_sled_endN
+  //
+  // We need the 44 bytes (11instructions) because at runtime, we'd be patching
+  // over the full 48 bytes (12 instructions) with the following pattern:
+  //
+  //   addi.d  sp, sp, -16                        ;create stack frame
+  //   st.d    ra, sp, 8                          ;save return address
+  //   lu12i.w t0, %abs_hi20(__xray_FunctionEntry/Exit)
+  //   ori     t0, t0, %abs_lo12(__xray_FunctionEntry/Exit)
+  //   lu32i.d t0, %abs64_lo20(__xray_FunctionEntry/Exit)
+  //   lu52i.d t0, t0, %abs64_hi12(__xray_FunctionEntry/Exit)
+  //   lu12i.w t1, %abs_hi20(function_id)
+  //   ori     t1, t1, %abs_lo12(function_id)     ;pass function id
+  //   jirl    ra, t0, 0                          ;call Tracing hook
+  //   ld.d    ra, sp, 8                          ;restore return address
+  //   addi.d  sp, sp, 16                         ;delete stack frame
+  //
+  // Update compiler-rt/lib/xray/xray_loongarch64.cpp accordingly when number
+  // of instructions change.
+  OutStreamer->emitCodeAlignment(Align(4), &getSubtargetInfo());
+  MCSymbol *BeginOfSled = OutContext.createTempSymbol("xray_sled_begin");
+  MCSymbol *EndOfSled = OutContext.createTempSymbol("xray_sled_end");
+  OutStreamer->emitLabel(BeginOfSled);
+  EmitToStreamer(*OutStreamer,
+                 MCInstBuilder(LoongArch::B)
+                     .addExpr(MCSymbolRefExpr::create(EndOfSled, OutContext)));
+  emitNops(NoopsInSledCount);
+  OutStreamer->emitLabel(EndOfSled);
+  recordSled(BeginOfSled, MI, Kind); // FIXME: use version 2
+}
+
 bool LoongArchAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                                           const char *ExtraCode,
                                           raw_ostream &OS) {
   // First try the generic code, which knows about modifiers like 'c' and 'n'.
   if (!AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS))
     return false;
 
   const MachineOperand &MO = MI->getOperand(OpNo);
bool LoongArchAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
   else
     return true;
 
   return false;
 }
 
 bool LoongArchAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
   AsmPrinter::runOnMachineFunction(MF);
+  // Emit the XRay table for this function.
+  emitXRayTable();
   return true;
 }
 
 // Force static initialization.
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeLoongArchAsmPrinter() {
   RegisterAsmPrinter<LoongArchAsmPrinter> X(getTheLoongArch32Target());
   RegisterAsmPrinter<LoongArchAsmPrinter> Y(getTheLoongArch64Target());
 }

llvm/lib/Target/LoongArch/LoongArchInstrInfo.h

public:
   reverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const override;
 
   std::pair<unsigned, unsigned>
   decomposeMachineOperandsTargetFlags(unsigned TF) const override;
 
   ArrayRef<std::pair<unsigned, const char *>>
   getSerializableDirectMachineOperandTargetFlags() const override;
 
+  MCInst getNop() const override;
+
 protected:
   const LoongArchSubtarget &STI;
 };
 
 } // end namespace llvm
 #endif // LLVM_LIB_TARGET_LOONGARCH_LOONGARCHINSTRINFO_H

llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp

 
 #include "LoongArchInstrInfo.h"
 #include "LoongArch.h"
 #include "LoongArchMachineFunctionInfo.h"
 #include "LoongArchRegisterInfo.h"
 #include "MCTargetDesc/LoongArchMCTargetDesc.h"
 #include "MCTargetDesc/LoongArchMatInt.h"
 #include "llvm/CodeGen/RegisterScavenging.h"
+#include "llvm/MC/MCInstBuilder.h"
 
 using namespace llvm;
 
 #define GET_INSTRINFO_CTOR_DTOR
 #include "LoongArchGenInstrInfo.inc"
 
 LoongArchInstrInfo::LoongArchInstrInfo(LoongArchSubtarget &STI)
     : LoongArchGenInstrInfo(LoongArch::ADJCALLSTACKDOWN,
static const std::pair<unsigned, const char *> TargetFlags[] = {
       {MO_LE_HI, "loongarch-le-hi"},
       {MO_LE_LO, "loongarch-le-lo"},
       {MO_IE_PC_HI, "loongarch-ie-pc-hi"},
       {MO_IE_PC_LO, "loongarch-ie-pc-lo"},
       {MO_LD_PC_HI, "loongarch-ld-pc-hi"},
       {MO_GD_PC_HI, "loongarch-gd-pc-hi"}};
   return makeArrayRef(TargetFlags);
 }
+
+MCInst LoongArchInstrInfo::getNop() const {
+  return MCInstBuilder(LoongArch::ANDI)
+      .addReg(LoongArch::R0)
+      .addReg(LoongArch::R0)
+      .addImm(0);
+}

llvm/lib/Target/LoongArch/LoongArchSubtarget.h

public:
   bool hasExtLVZ() const { return HasExtLVZ; }
   bool hasExtLBT() const { return HasExtLBT; }
   bool hasLaGlobalWithPcrel() const { return HasLaGlobalWithPcrel; }
   bool hasLaGlobalWithAbs() const { return HasLaGlobalWithAbs; }
   bool hasLaLocalWithAbs() const { return HasLaLocalWithAbs; }
   MVT getGRLenVT() const { return GRLenVT; }
   unsigned getGRLen() const { return GRLen; }
   LoongArchABI::ABI getTargetABI() const { return TargetABI; }
+  bool isXRaySupported() const override { return is64Bit(); }
 };
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_LOONGARCH_LOONGARCHSUBTARGET_H

llvm/lib/XRay/InstrumentationMap.cpp

loadObj(StringRef Filename, object::OwningBinary<object::ObjectFile> &ObjFile,
         InstrumentationMap::SledContainer &Sleds,
         InstrumentationMap::FunctionAddressMap &FunctionAddresses,
         InstrumentationMap::FunctionAddressReverseMap &FunctionIds) {
   InstrumentationMap Map;
 
   // Find the section named "xray_instr_map".
   if ((!ObjFile.getBinary()->isELF() && !ObjFile.getBinary()->isMachO()) ||
       !(ObjFile.getBinary()->getArch() == Triple::x86_64 ||
+        ObjFile.getBinary()->getArch() == Triple::loongarch64 ||
         ObjFile.getBinary()->getArch() == Triple::ppc64le ||
         ObjFile.getBinary()->getArch() == Triple::arm ||
         ObjFile.getBinary()->getArch() == Triple::aarch64))
     return make_error<StringError>(
         "File format not supported (only does ELF and Mach-O little endian "
         "64-bit).",
         std::make_error_code(std::errc::not_supported));
 

llvm/test/CodeGen/LoongArch/xray-attribute-instrumentation.ll

+; RUN: llc --mtriple=loongarch64 %s -o - | FileCheck %s
+; RUN: llc --mtriple=loongarch64 -filetype=obj %s -o %t
+; RUN: llvm-readobj -r %t | FileCheck %s --check-prefix=RELOC
+
+define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" {
+; CHECK-LABEL: foo:
+; CHECK-LABEL: .Lfunc_begin0:
+; CHECK:       .p2align 2
+; CHECK-LABEL: .Lxray_sled_begin0:
+; CHECK-NEXT:  b .Lxray_sled_end0
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-LABEL: .Lxray_sled_end0:
+  ret i32 0
+; CHECK-LABEL: .Lxray_sled_begin1:
+; CHECK-NEXT:  b .Lxray_sled_end1
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT:  nop
+; CHECK-NEXT: .Lxray_sled_end1:
+; CHECK-NEXT:  ret
+; CHECK-NEXT: .Lfunc_end0:
+}
+
+; CHECK-LABEL: .section xray_instr_map
+; CHECK-NEXT: .Lxray_sleds_start0:
+; CHECK-NEXT: .dword .Lxray_sled_begin0
+; CHECK-NEXT: .dword foo
+; CHECK-NEXT: .byte 0x00
+; CHECK-NEXT: .byte 0x01
+; CHECK-NEXT: .byte 0x00
+; CHECK-NEXT: .space 13
+; CHECK-NEXT: .dword .Lxray_sled_begin1
+; CHECK-NEXT: .dword foo
+; CHECK-NEXT: .byte 0x01
+; CHECK-NEXT: .byte 0x01
+; CHECK-NEXT: .byte 0x00
+; CHECK-NEXT: .space 13
+; CHECK-NEXT: .Lxray_sleds_end0:
+
+; CHECK-LABEL:  .section xray_fn_idx
+; CHECK:      .dword .Lxray_sleds_start0
+; CHECK-NEXT: .dword .Lxray_sleds_end0
+
+; RELOC:      Section ([[#]]) .relaxray_instr_map {
+; RELOC-NEXT:   0x0 R_LARCH_64 .text 0x0
+; RELOC-NEXT:   0x8 R_LARCH_64 foo 0x0
+; RELOC-NEXT:   0x20 R_LARCH_64 .text 0x34
+; RELOC-NEXT:   0x28 R_LARCH_64 foo 0x0
+; RELOC-NEXT: }
+; RELOC-NEXT: Section ([[#]]) .relaxray_fn_idx {
+; RELOC-NEXT:   0x0 R_LARCH_64 xray_instr_map 0x0
+; RELOC-NEXT:   0x8 R_LARCH_64 xray_instr_map 0x40
+; RELOC-NEXT: }