[LLDB][LoongArch] Make software single stepping work

[lh03061238]

Summary

Hardware single stepping is not currently supported by the linux kernel.
In order to support single step debugging, add EmulateInstructionLoongArch
to implement the software Single Stepping. This patch only support the
simplest single step execution of non-jump instructions.

[jingham]

Note that the two most common uses of single step in lldb are 1) stepping over the instruction under a breakpoint (which may be a branch) and 2) stepping to the next instruction from a branch instruction. So stepping won't work correctly till you get single step past a branch instruction working. But you probably knew that...

[lh03061238]

In D139158#3965478, @jingham wrote:

Note that the two most common uses of single step in lldb are 1) stepping over the instruction under a breakpoint (which may be a branch) and 2) stepping to the next instruction from a branch instruction. So stepping won't work correctly till you get single step past a branch instruction working. But you probably knew that...

Yes, you're right.
This patch just make the single stepping to work, only the non-jump instructions are supported, the effect is just like pc + 4. Support for jump instructions will be added in next patch.

[SixWeining]

I'm not sure whether lldb should follow llvm coding standard.

lldb/source/Plugins/Instruction/LoongArch/CMakeLists.txt

8–9

It's better to sort alphabetically.

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.cpp

38

Will the mask be changed in future? If so, better to leave a FIXME or TODO. If not, the following for loop always return the NonJMP opcode?

40

loongarch?

42

useless {

45

Ditto.

50

Could it be InstSize? https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

67–69

if (!(this->*opcode_data->callback)(inst))
  return false;

76–79

if (new_pc == old_pc && !WritePC(old_pc + inst_size)
    return false;

85

Remove useless blank line.

175

useless {

177

Ditto

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

29–37

Do you plan to support eInstructionTypeAny eInstructionTypePrologueEpilogue eInstructionTypeAll in future? If so, had better leave a TODO here. Otherwise this function can be simplied to:

return inst_type == eInstructionTypePCModifying;

67

Could it be a private function?

80

Is it a override function?

lldb/tools/lldb-server/SystemInitializerLLGS.cpp

56

Sort alphabetically?

[xen0n]

I think you can remove the example from your commit message altogether, it's giving essentially no information while making the text very lengthy. Only keeping the first paragraph should be enough.

lldb/source/Plugins/Instruction/CMakeLists.txt

8

The list is sorted alphabetically so this should come before MIPS.

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

11

Use ALL_CAPS for this include guard symbol.

25

Use "LoongArch" here because it's intended to be a human-readable string.

lldb/tools/lldb-server/CMakeLists.txt

58

Put before MIPS for alphabetical order too.

lldb/tools/lldb-server/SystemInitializerLLGS.cpp

54

There's no __loongarch, only __loongarch__ (we're more classical than RISC-V in this regard). Instead simply use #if defined(__loongarch__) as the code enabled by this condition isn't really caring its bitness.

77–79

Alphabetize this chunk too.

99–101

Ditto.

[lh03061238]

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

67

Could it be a private function?

We want this function to be used in its subclass,
so we define it as public

80

Is it a override function?

It is not override function, this function simply returns false.
SetupSoftwareSingleStepping () function will be updated PC (next_pc = PC + 4), when EvaluateInstruction exit.

[lh03061238]

(1) Use sort alphabetically in the following file
lldb/source/Plugins/Instruction/CMakeLists.txt
lldb/source/Plugins/Instruction/LoongArch/CMakeLists.txt
lldb/tools/lldb-server/CMakeLists.txt
lldb/tools/lldb-server/SystemInitializerLLGS.cpp

(2) Use ALL_CAPS for include guard symbol

(3) Modify the following functions
SupportsThisInstructionType(InstructionType inst_type)
GetOpcodeForInstruction(uint32_t inst)
EvaluateInstruction(uint32_t options)
CreateInstance(const ArchSpec &arch,InstructionType inst_type)

(4) Added TODO description in GetOpcodeForInstruction(uint32_t inst)

(5) Use #if defined(loongarch) in lldb/tools/lldb-server/SystemInitializerLLGS.cpp

(6) Remove the example from commit message

[DavidSpickett]

Looks mechanically fine. These classes are all a bit of a copy paste job right now, so if you were going to take inspiration riscv is your best bet.

On the subject of coding style, https://lldb.llvm.org/resources/contributing.html.

Coding Style: LLDB’s code style differs from LLVM’s coding style. Unfortunately there is no document describing the differences. Please be consistent with the existing code.

Which isn't super helpful but in general look at something central like lldb/source/Target/Process.cpp and see what it does. The main difference you'll see is variable_names_with_underscores_like_this and m_ prefix for class members.

For me, the style here looks fine.

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

59

I think the older targets use this form but for riscv they went with llvm::Optional<lldb::addr_t> ReadPC(); which I prefer over pointer plus addr_t.

[SixWeining]

In D139158#3974801, @DavidSpickett wrote:

Looks mechanically fine. These classes are all a bit of a copy paste job right now, so if you were going to take inspiration riscv is your best bet.

On the subject of coding style, https://lldb.llvm.org/resources/contributing.html.

Coding Style: LLDB’s code style differs from LLVM’s coding style. Unfortunately there is no document describing the differences. Please be consistent with the existing code.

Which isn't super helpful but in general look at something central like lldb/source/Target/Process.cpp and see what it does. The main difference you'll see is variable_names_with_underscores_like_this and m_ prefix for class members.

For me, the style here looks fine.

Thanks for the clarification. Then LGTM for LoongArch related change.

[lh03061238]

In D139158#3974801, @DavidSpickett wrote:

Looks mechanically fine. These classes are all a bit of a copy paste job right now, so if you were going to take inspiration riscv is your best bet.

On the subject of coding style, https://lldb.llvm.org/resources/contributing.html.

Coding Style: LLDB’s code style differs from LLVM’s coding style. Unfortunately there is no document describing the differences. Please be consistent with the existing code.

Which isn't super helpful but in general look at something central like lldb/source/Target/Process.cpp and see what it does. The main difference you'll see is variable_names_with_underscores_like_this and m_ prefix for class members.

For me, the style here looks fine.

Thanks for your suggestion

[lh03061238]

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

59

I think the older targets use this form but for riscv they went with llvm::Optional<lldb::addr_t> ReadPC(); which I prefer over pointer plus addr_t.

EmulateInstructionLoongArch is relatively simple Compared with riscv. If use llvm::Optional<lldb::addr_t> ReadPC(), There will be more type
conversions here. I prefer to keep that definition for now, Considering the complexity of the code at this stage.

Thank you.

[seehearfeel]

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

59

@DavidSpickett Are you OK with the current code?

[DavidSpickett]

This LGTM.

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

59

I prefer to keep that definition for now, Considering the complexity of the code at this stage.

Totally fine, this is a lot of duplicating existing code to begin with so I appreciate why you'd keep the differences minimal.

lldb/source/Plugins/Instruction/CMakeLists.txt

 add_subdirectory(ARM)
 add_subdirectory(ARM64)
+add_subdirectory(LoongArch)
 add_subdirectory(MIPS)
 add_subdirectory(MIPS64)
 add_subdirectory(PPC64)
 add_subdirectory(RISCV)

lldb/source/Plugins/Instruction/LoongArch/CMakeLists.txt

+add_lldb_library(lldbPluginInstructionLoongArch PLUGIN
+  EmulateInstructionLoongArch.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbInterpreter
+    lldbPluginProcessUtility
+    lldbSymbol
+  LINK_COMPONENTS
+    Support
+  )

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h

+//===---EmulateInstructionLoongArch.h--------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_INSTRUCTION_LOONGARCH_EMULATEINSTRUCTIONLOONGARCH_H
+#define LLDB_SOURCE_PLUGINS_INSTRUCTION_LOONGARCH_EMULATEINSTRUCTIONLOONGARCH_H
+
+#include "lldb/Core/EmulateInstruction.h"
+#include "lldb/Interpreter/OptionValue.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Status.h"
+
+namespace lldb_private {
+
+class EmulateInstructionLoongArch : public EmulateInstruction {
+public:
+  static llvm::StringRef GetPluginNameStatic() { return "LoongArch"; }
+
+  static llvm::StringRef GetPluginDescriptionStatic() {
+    return "Emulate instructions for the LoongArch architecture.";
+  }
+
+  static bool SupportsThisInstructionType(InstructionType inst_type) {
+    return inst_type == eInstructionTypePCModifying;
+  }
+
+  static bool SupportsThisArch(const ArchSpec &arch);
+
+  static lldb_private::EmulateInstruction *
+  CreateInstance(const lldb_private::ArchSpec &arch, InstructionType inst_type);
+
+  static void Initialize();
+
+  static void Terminate();
+
+public:
+  EmulateInstructionLoongArch(const ArchSpec &arch)
+      : EmulateInstruction(arch) {}
+
+  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
+
+  bool SupportsEmulatingInstructionsOfType(InstructionType inst_type) override {
+    return SupportsThisInstructionType(inst_type);
+  }
+
+  bool SetTargetTriple(const ArchSpec &arch) override;
+  bool ReadInstruction() override;
+  bool EvaluateInstruction(uint32_t options) override;
+  bool TestEmulation(Stream *out_stream, ArchSpec &arch,
+                     OptionValueDictionary *test_data) override;
+
+  llvm::Optional<RegisterInfo> GetRegisterInfo(lldb::RegisterKind reg_kind,
+                                               uint32_t reg_num) override;
+  lldb::addr_t ReadPC(bool *success);
+  bool WritePC(lldb::addr_t pc);
+
+private:
+  struct Opcode {
+    uint32_t mask;
+    uint32_t value;
+    bool (EmulateInstructionLoongArch::*callback)(uint32_t opcode);
+    const char *name;
+  };
+
+  Opcode *GetOpcodeForInstruction(uint32_t inst);
+
+  bool EmulateNonJMP(uint32_t inst);
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_INSTRUCTION_LOONGARCH_EMULATEINSTRUCTIONLOONGARCH_H

lldb/source/Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.cpp

+//===---EmulateInstructionLoongArch.cpp------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstdlib>
+
+#include "EmulateInstructionLoongArch.h"
+#include "Plugins/Process/Utility/InstructionUtils.h"
+#include "Plugins/Process/Utility/RegisterInfoPOSIX_loongarch64.h"
+#include "Plugins/Process/Utility/lldb-loongarch-register-enums.h"
+#include "lldb/Core/Address.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Interpreter/OptionValueArray.h"
+#include "lldb/Interpreter/OptionValueDictionary.h"
+#include "lldb/Symbol/UnwindPlan.h"
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/LLDBLog.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Stream.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+LLDB_PLUGIN_DEFINE_ADV(EmulateInstructionLoongArch, InstructionLoongArch)
+
+namespace lldb_private {
+
+EmulateInstructionLoongArch::Opcode *
+EmulateInstructionLoongArch::GetOpcodeForInstruction(uint32_t inst) {
+  // TODO: Add the mask of jump instruction.
+  static EmulateInstructionLoongArch::Opcode g_opcodes[] = {
+      {0x00000000, 0x00000000, &EmulateInstructionLoongArch::EmulateNonJMP,
+       "NonJMP"}};
+  static const size_t num_loongarch_opcodes = std::size(g_opcodes);
+
+  for (size_t i = 0; i < num_loongarch_opcodes; ++i)
+    if ((g_opcodes[i].mask & inst) == g_opcodes[i].value)
+      return &g_opcodes[i];
+  return nullptr;
+}
+
+bool EmulateInstructionLoongArch::EvaluateInstruction(uint32_t options) {
+  uint32_t inst_size = m_opcode.GetByteSize();
+  uint32_t inst = m_opcode.GetOpcode32();
+  bool increase_pc = options & eEmulateInstructionOptionAutoAdvancePC;
+  bool success = false;
+
+  Opcode *opcode_data = GetOpcodeForInstruction(inst);
+  if (!opcode_data)
+    return false;
+
+  lldb::addr_t old_pc = 0;
+  if (increase_pc) {
+    old_pc = ReadPC(&success);
+    if (!success)
+      return false;
+  }
+
+  // Call the Emulate... function.
+  if (!(this->*opcode_data->callback)(inst))
+    return false;
+
+  if (increase_pc) {
+    lldb::addr_t new_pc = ReadPC(&success);
+    if (!success)
+      return false;
+
+    if (new_pc == old_pc && !WritePC(old_pc + inst_size))
+      return false;
+  }
+  return true;
+}
+
+bool EmulateInstructionLoongArch::ReadInstruction() {
+  bool success = false;
+  m_addr = ReadPC(&success);
+  if (!success) {
+    m_addr = LLDB_INVALID_ADDRESS;
+    return false;
+  }
+
+  Context ctx;
+  ctx.type = eContextReadOpcode;
+  ctx.SetNoArgs();
+  uint32_t inst = (uint32_t)ReadMemoryUnsigned(ctx, m_addr, 4, 0, &success);
+  m_opcode.SetOpcode32(inst, GetByteOrder());
+
+  return true;
+}
+
+lldb::addr_t EmulateInstructionLoongArch::ReadPC(bool *success) {
+  return ReadRegisterUnsigned(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC,
+                              LLDB_INVALID_ADDRESS, success);
+}
+
+bool EmulateInstructionLoongArch::WritePC(lldb::addr_t pc) {
+  EmulateInstruction::Context ctx;
+  ctx.type = eContextAdvancePC;
+  ctx.SetNoArgs();
+  return WriteRegisterUnsigned(ctx, eRegisterKindGeneric,
+                               LLDB_REGNUM_GENERIC_PC, pc);
+}
+
+llvm::Optional<RegisterInfo>
+EmulateInstructionLoongArch::GetRegisterInfo(lldb::RegisterKind reg_kind,
+                                             uint32_t reg_index) {
+  if (reg_kind == eRegisterKindGeneric) {
+    switch (reg_index) {
+    case LLDB_REGNUM_GENERIC_PC:
+      reg_kind = eRegisterKindLLDB;
+      reg_index = gpr_pc_loongarch;
+      break;
+    case LLDB_REGNUM_GENERIC_SP:
+      reg_kind = eRegisterKindLLDB;
+      reg_index = gpr_sp_loongarch;
+      break;
+    case LLDB_REGNUM_GENERIC_FP:
+      reg_kind = eRegisterKindLLDB;
+      reg_index = gpr_fp_loongarch;
+      break;
+    case LLDB_REGNUM_GENERIC_RA:
+      reg_kind = eRegisterKindLLDB;
+      reg_index = gpr_ra_loongarch;
+      break;
+    // We may handle LLDB_REGNUM_GENERIC_ARGx when more instructions are
+    // supported.
+    default:
+      llvm_unreachable("unsupported register");
+    }
+  }
+
+  const RegisterInfo *array =
+      RegisterInfoPOSIX_loongarch64::GetRegisterInfoPtr(m_arch);
+  const uint32_t length =
+      RegisterInfoPOSIX_loongarch64::GetRegisterInfoCount(m_arch);
+
+  if (reg_index >= length || reg_kind != eRegisterKindLLDB)
+    return {};
+  return array[reg_index];
+}
+
+bool EmulateInstructionLoongArch::SetTargetTriple(const ArchSpec &arch) {
+  return SupportsThisArch(arch);
+}
+
+bool EmulateInstructionLoongArch::TestEmulation(
+    Stream *out_stream, ArchSpec &arch, OptionValueDictionary *test_data) {
+  return false;
+}
+
+void EmulateInstructionLoongArch::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance);
+}
+
+void EmulateInstructionLoongArch::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+lldb_private::EmulateInstruction *
+EmulateInstructionLoongArch::CreateInstance(const ArchSpec &arch,
+                                            InstructionType inst_type) {
+  if (EmulateInstructionLoongArch::SupportsThisInstructionType(inst_type) &&
+      SupportsThisArch(arch))
+    return new EmulateInstructionLoongArch(arch);
+  return nullptr;
+}
+
+bool EmulateInstructionLoongArch::SupportsThisArch(const ArchSpec &arch) {
+  return arch.GetTriple().isLoongArch();
+}
+
+bool EmulateInstructionLoongArch::EmulateNonJMP(uint32_t inst) { return false; }
+
+} // namespace lldb_private

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

default:
     llvm_unreachable("unknown clone_info.event");
   }
 
   return true;
 }
 
 bool NativeProcessLinux::SupportHardwareSingleStepping() const {
   if (m_arch.IsMIPS() || m_arch.GetMachine() == llvm::Triple::arm ||
-      m_arch.GetTriple().isRISCV())
+      m_arch.GetTriple().isRISCV() || m_arch.GetTriple().isLoongArch())
     return false;
   return true;
 }
 
 Status NativeProcessLinux::Resume(const ResumeActionList &resume_actions) {
   Log *log = GetLog(POSIXLog::Process);
   LLDB_LOG(log, "pid {0}", GetID());
 

lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.cpp

if (arch.GetMachine() == llvm::Triple::arm) {
     if (next_flags & 0x20) {
       // Thumb mode
       size_hint = 2;
     } else {
       // Arm mode
       size_hint = 4;
     }
   } else if (arch.IsMIPS() || arch.GetTriple().isPPC64() ||
-             arch.GetTriple().isRISCV())
+             arch.GetTriple().isRISCV() || arch.GetTriple().isLoongArch())
     size_hint = 4;
   error = process.SetBreakpoint(next_pc, size_hint, /*hardware=*/false);
 
   // If setting the breakpoint fails because next_pc is out of the address
   // space, ignore it and let the debugee segfault.
   if (error.GetError() == EIO || error.GetError() == EFAULT) {
     return Status();
   } else if (error.Fail())
     return error;
 
   m_threads_stepping_with_breakpoint.insert({thread.GetID(), next_pc});
 
   return Status();
 }

lldb/tools/lldb-server/CMakeLists.txt

add_lldb_tool(lldb-server
     SystemInitializerLLGS.cpp
 
     LINK_LIBS
       lldbHost
       lldbInitialization
       lldbVersion
       ${LLDB_PLUGINS}
       lldbPluginInstructionARM
+      lldbPluginInstructionLoongArch
       lldbPluginInstructionMIPS
       lldbPluginInstructionMIPS64
       lldbPluginInstructionRISCV
       ${LLDB_SYSTEM_LIBS}
 
     LINK_COMPONENTS
       Option
       Support
 )
 
 add_dependencies(lldb-server
   LLGSOptionsTableGen
   ${tablegen_deps}
 )
 target_include_directories(lldb-server PRIVATE "${LLDB_SOURCE_DIR}/source")
 target_link_libraries(lldb-server PRIVATE ${LLDB_SYSTEM_LIBS})

lldb/tools/lldb-server/SystemInitializerLLGS.cpp

 #endif
 
 #if defined(__arm__) || defined(__arm) || defined(_ARM) || defined(_M_ARM) ||  \
     defined(LLDB_TARGET_ARM64)
 #define LLDB_TARGET_ARM
 #include "Plugins/Instruction/ARM/EmulateInstructionARM.h"
 #endif
 
+#if defined(__loongarch__)
+#define LLDB_TARGET_LoongArch
+#include "Plugins/Instruction/LoongArch/EmulateInstructionLoongArch.h"
+#endif
+
 #if defined(__mips64__) || defined(mips64) || defined(__mips64) ||             \
     defined(__MIPS64__) || defined(_M_MIPS64)
 #define LLDB_TARGET_MIPS64
 #include "Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h"
 #endif
 
 #if defined(__mips__) || defined(mips) || defined(__mips) ||                   \
     defined(__MIPS__) || defined(_M_MIPS) || defined(LLDB_TARGET_MIPS64)
 #define LLDB_TARGET_MIPS
 #include "Plugins/Instruction/MIPS/EmulateInstructionMIPS.h"
 #endif
 
 #if defined(__riscv)
 #define LLDB_TARGET_RISCV
 #include "Plugins/Instruction/RISCV/EmulateInstructionRISCV.h"
 #endif
 
 using namespace lldb_private;
 
 llvm::Error SystemInitializerLLGS::Initialize() {
   if (auto e = SystemInitializerCommon::Initialize())
     return e;
 
   HostObjectFile::Initialize();
 
 #if defined(LLDB_TARGET_ARM) || defined(LLDB_TARGET_ARM64)
   EmulateInstructionARM::Initialize();
 #endif
+#if defined(LLDB_TARGET_LoongArch)
+  EmulateInstructionLoongArch::Initialize();
+#endif
 #if defined(LLDB_TARGET_MIPS) || defined(LLDB_TARGET_MIPS64)
   EmulateInstructionMIPS::Initialize();
 #endif
 #if defined(LLDB_TARGET_MIPS64)
   EmulateInstructionMIPS64::Initialize();
 #endif
 #if defined(LLDB_TARGET_RISCV)
   EmulateInstructionRISCV::Initialize();
 #endif
 
   return llvm::Error::success();
 }
 
 void SystemInitializerLLGS::Terminate() {
   HostObjectFile::Terminate();
 
 #if defined(LLDB_TARGET_ARM) || defined(LLDB_TARGET_ARM64)
   EmulateInstructionARM::Terminate();
 #endif
+#if defined(LLDB_TARGET_LoongArch)
+  EmulateInstructionLoongArch::Terminate();
+#endif
 #if defined(LLDB_TARGET_MIPS) || defined(LLDB_TARGET_MIPS64)
   EmulateInstructionMIPS::Terminate();
 #endif
 #if defined(LLDB_TARGET_MIPS64)
   EmulateInstructionMIPS64::Terminate();
 #endif
 #if defined(LLDB_TARGET_RISCV)
   EmulateInstructionRISCV::Terminate();
 #endif
 
   SystemInitializerCommon::Terminate();
 }