/* Target-dependent code for GNU/Linux on LoongArch processors.

   Copyright (C) 2022-2024 Free Software Foundation, Inc.
   Contributed by Loongson Ltd.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "glibc-tdep.h"
#include "inferior.h"
#include "linux-tdep.h"
#include "loongarch-tdep.h"
#include "solib-svr4.h"
#include "target-descriptions.h"
#include "trad-frame.h"
#include "tramp-frame.h"
#include "xml-syscall.h"

/* The syscall's XML filename for LoongArch.  */
#define XML_SYSCALL_FILENAME_LOONGARCH "syscalls/loongarch-linux.xml"

/* Unpack an elf_gregset_t into GDB's register cache.  */

static void
loongarch_supply_gregset (const struct regset *regset,
			  struct regcache *regcache, int regnum,
			  const void *gprs, size_t len)
{
  int regsize = register_size (regcache->arch (), 0);
  const gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      regcache->raw_supply_zeroed (0);

      for (int i = 1; i < 32; i++)
	{
	  buf = (const gdb_byte*) gprs + regsize * i;
	  regcache->raw_supply (i, (const void *) buf);
	}

      buf = (const gdb_byte*) gprs + regsize * LOONGARCH_ORIG_A0_REGNUM;
      regcache->raw_supply (LOONGARCH_ORIG_A0_REGNUM, (const void *) buf);

      buf = (const gdb_byte*) gprs + regsize * LOONGARCH_PC_REGNUM;
      regcache->raw_supply (LOONGARCH_PC_REGNUM, (const void *) buf);

      buf = (const gdb_byte*) gprs + regsize * LOONGARCH_BADV_REGNUM;
      regcache->raw_supply (LOONGARCH_BADV_REGNUM, (const void *) buf);
    }
  else if (regnum == 0)
    regcache->raw_supply_zeroed (0);
  else if ((regnum > 0 && regnum < 32)
	   || regnum == LOONGARCH_ORIG_A0_REGNUM
	   || regnum == LOONGARCH_PC_REGNUM
	   || regnum == LOONGARCH_BADV_REGNUM)
    {
      buf = (const gdb_byte*) gprs + regsize * regnum;
      regcache->raw_supply (regnum, (const void *) buf);
    }
}

/* Pack the GDB's register cache value into an elf_gregset_t.  */

static void
loongarch_fill_gregset (const struct regset *regset,
			const struct regcache *regcache, int regnum,
			void *gprs, size_t len)
{
  int regsize = register_size (regcache->arch (), 0);
  gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      for (int i = 0; i < 32; i++)
	{
	  buf = (gdb_byte *) gprs + regsize * i;
	  regcache->raw_collect (i, (void *) buf);
	}

      buf = (gdb_byte *) gprs + regsize * LOONGARCH_ORIG_A0_REGNUM;
      regcache->raw_collect (LOONGARCH_ORIG_A0_REGNUM, (void *) buf);

      buf = (gdb_byte *) gprs + regsize * LOONGARCH_PC_REGNUM;
      regcache->raw_collect (LOONGARCH_PC_REGNUM, (void *) buf);

      buf = (gdb_byte *) gprs + regsize * LOONGARCH_BADV_REGNUM;
      regcache->raw_collect (LOONGARCH_BADV_REGNUM, (void *) buf);
    }
  else if ((regnum >= 0 && regnum < 32)
	   || regnum == LOONGARCH_ORIG_A0_REGNUM
	   || regnum == LOONGARCH_PC_REGNUM
	   || regnum == LOONGARCH_BADV_REGNUM)
    {
      buf = (gdb_byte *) gprs + regsize * regnum;
      regcache->raw_collect (regnum, (void *) buf);
    }
}

/* Define the general register regset.  */

const struct regset loongarch_gregset =
{
  nullptr,
  loongarch_supply_gregset,
  loongarch_fill_gregset,
};

/* Unpack an elf_fpregset_t into GDB's register cache.  */
static void
loongarch_supply_fpregset (const struct regset *r,
			   struct regcache *regcache, int regnum,
			   const void *fprs, size_t len)
{
  const gdb_byte *buf = nullptr;
  int fprsize = register_size (regcache->arch (), LOONGARCH_FIRST_FP_REGNUM);
  int fccsize = register_size (regcache->arch (), LOONGARCH_FIRST_FCC_REGNUM);

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_FPREGSET; i++)
	{
	  buf = (const gdb_byte *)fprs + fprsize * i;
	  regcache->raw_supply (LOONGARCH_FIRST_FP_REGNUM + i, (const void *)buf);
	}
      for (int i = 0; i < LOONGARCH_LINUX_NUM_FCC; i++)
	{
	  buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	    fccsize * i;
	  regcache->raw_supply (LOONGARCH_FIRST_FCC_REGNUM + i, (const void *)buf);
	}
      buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	fccsize * LOONGARCH_LINUX_NUM_FCC;
      regcache->raw_supply (LOONGARCH_FCSR_REGNUM, (const void *)buf);
    }
  else if (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum < LOONGARCH_FIRST_FCC_REGNUM)
    {
      buf = (const gdb_byte *)fprs + fprsize * (regnum - LOONGARCH_FIRST_FP_REGNUM);
      regcache->raw_supply (regnum, (const void *)buf);
    }
  else if (regnum >= LOONGARCH_FIRST_FCC_REGNUM && regnum < LOONGARCH_FCSR_REGNUM)
    {
      buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	fccsize * (regnum - LOONGARCH_FIRST_FCC_REGNUM);
      regcache->raw_supply (regnum, (const void *)buf);
    }
  else if (regnum == LOONGARCH_FCSR_REGNUM)
    {
      buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	fccsize * LOONGARCH_LINUX_NUM_FCC;
      regcache->raw_supply (regnum, (const void *)buf);
    }
}

/* Pack the GDB's register cache value into an elf_fpregset_t.  */
static void
loongarch_fill_fpregset (const struct regset *r,
			 const struct regcache *regcache, int regnum,
			 void *fprs, size_t len)
{
  gdb_byte *buf = nullptr;
  int fprsize = register_size (regcache->arch (), LOONGARCH_FIRST_FP_REGNUM);
  int fccsize = register_size (regcache->arch (), LOONGARCH_FIRST_FCC_REGNUM);

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_FPREGSET; i++)
	{
	  buf = (gdb_byte *)fprs + fprsize * i;
	  regcache->raw_collect (LOONGARCH_FIRST_FP_REGNUM + i, (void *)buf);
	}
      for (int i = 0; i < LOONGARCH_LINUX_NUM_FCC; i++)
	{
	  buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	    fccsize * i;
	  regcache->raw_collect (LOONGARCH_FIRST_FCC_REGNUM + i, (void *)buf);
	}
      buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	fccsize * LOONGARCH_LINUX_NUM_FCC;
      regcache->raw_collect (LOONGARCH_FCSR_REGNUM, (void *)buf);
    }
  else if (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum < LOONGARCH_FIRST_FCC_REGNUM)
    {
      buf = (gdb_byte *)fprs + fprsize * (regnum - LOONGARCH_FIRST_FP_REGNUM);
      regcache->raw_collect (regnum, (void *)buf);
    }
  else if (regnum >= LOONGARCH_FIRST_FCC_REGNUM && regnum < LOONGARCH_FCSR_REGNUM)
    {
      buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	fccsize * (regnum - LOONGARCH_FIRST_FCC_REGNUM);
      regcache->raw_collect (regnum, (void *)buf);
    }
  else if (regnum == LOONGARCH_FCSR_REGNUM)
    {
      buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	fccsize * LOONGARCH_LINUX_NUM_FCC;
      regcache->raw_collect (regnum, (void *)buf);
    }
}

/* Define the FP register regset.  */
const struct regset loongarch_fpregset =
{
  nullptr,
  loongarch_supply_fpregset,
  loongarch_fill_fpregset,
};

/* Unpack elf_lsxregset_t into GDB's register cache.  */

static void
loongarch_supply_lsxregset (const struct regset *regset,
			    struct regcache *regcache, int regnum,
			    const void *lsxrs, size_t len)
{
  int lsxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LSX_REGNUM);
  const gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_LSXREGSET; i++)
	{
	  buf = (const gdb_byte*) lsxrs + lsxrsize * i;
	  regcache->raw_supply (LOONGARCH_FIRST_LSX_REGNUM + i, (const void *) buf);
	}

    }
  else if (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM)
    {
      buf = (const gdb_byte*) lsxrs + lsxrsize * (regnum - LOONGARCH_FIRST_LSX_REGNUM);
      regcache->raw_supply (regnum, (const void *) buf);
    }
}

/* Pack the GDB's register cache value into an elf_lsxregset_t.  */

static void
loongarch_fill_lsxregset (const struct regset *regset,
			  const struct regcache *regcache, int regnum,
			  void *lsxrs, size_t len)
{
  int lsxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LSX_REGNUM);
  gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_LSXREGSET; i++)
	{
	  buf = (gdb_byte *) lsxrs + lsxrsize * i;
	  regcache->raw_collect (LOONGARCH_FIRST_LSX_REGNUM + i, (void *) buf);
	}
    }
  else if (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM)
    {
      buf = (gdb_byte *) lsxrs + lsxrsize * (regnum - LOONGARCH_FIRST_LSX_REGNUM);
      regcache->raw_collect (regnum, (void *) buf);
    }
}

/* Define the Loongson SIMD Extension register regset.  */

const struct regset loongarch_lsxregset =
{
  nullptr,
  loongarch_supply_lsxregset,
  loongarch_fill_lsxregset,
};

/* Unpack elf_lasxregset_t into GDB's register cache.  */

static void
loongarch_supply_lasxregset (const struct regset *regset,
			    struct regcache *regcache, int regnum,
			    const void *lasxrs, size_t len)
{
  int lasxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LASX_REGNUM);
  const gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_LASXREGSET; i++)
	{
	  buf = (const gdb_byte*) lasxrs + lasxrsize * i;
	  regcache->raw_supply (LOONGARCH_FIRST_LASX_REGNUM + i, (const void *) buf);
	}

    }
  else if (regnum >= LOONGARCH_FIRST_LASX_REGNUM
	   && regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET)
    {
      buf = (const gdb_byte*) lasxrs + lasxrsize * (regnum - LOONGARCH_FIRST_LASX_REGNUM);
      regcache->raw_supply (regnum, (const void *) buf);
    }
}

/* Pack the GDB's register cache value into an elf_lasxregset_t.  */

static void
loongarch_fill_lasxregset (const struct regset *regset,
			  const struct regcache *regcache, int regnum,
			  void *lasxrs, size_t len)
{
  int lasxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LASX_REGNUM);
  gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_LASXREGSET; i++)
	{
	  buf = (gdb_byte *) lasxrs + lasxrsize * i;
	  regcache->raw_collect (LOONGARCH_FIRST_LASX_REGNUM + i, (void *) buf);
	}
    }
  else if (regnum >= LOONGARCH_FIRST_LASX_REGNUM
	   && regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET)

    {
      buf = (gdb_byte *) lasxrs + lasxrsize * (regnum - LOONGARCH_FIRST_LASX_REGNUM);
      regcache->raw_collect (regnum, (void *) buf);
    }
}

/* Define the Loongson Advanced SIMD Extension register regset.  */

const struct regset loongarch_lasxregset =
{
  nullptr,
  loongarch_supply_lasxregset,
  loongarch_fill_lasxregset,
};

/* Unpack an lbt regset into GDB's register cache.  */

static void
loongarch_supply_lbtregset (const struct regset *regset,
			    struct regcache *regcache, int regnum,
			    const void *regs, size_t len)
{
  int scrsize = register_size (regcache->arch (), LOONGARCH_FIRST_SCR_REGNUM);
  int eflagssize = register_size (regcache->arch (), LOONGARCH_EFLAGS_REGNUM);
  const gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_SCR; i++)
	{
	  buf = (const gdb_byte *) regs + scrsize * i;
	  regcache->raw_supply (LOONGARCH_FIRST_SCR_REGNUM + i,
				(const void *) buf);
	}

      buf = (const gdb_byte*) regs + scrsize * LOONGARCH_LINUX_NUM_SCR;
      regcache->raw_supply (LOONGARCH_EFLAGS_REGNUM, (const void *) buf);

      buf = (const gdb_byte*) regs
	    + scrsize * LOONGARCH_LINUX_NUM_SCR
	    + eflagssize;
      regcache->raw_supply (LOONGARCH_FTOP_REGNUM, (const void *) buf);
    }
  else if (regnum >= LOONGARCH_FIRST_SCR_REGNUM
	   && regnum <= LOONGARCH_LAST_SCR_REGNUM)
    {
      buf = (const gdb_byte*) regs
	    + scrsize * (regnum - LOONGARCH_FIRST_SCR_REGNUM);
      regcache->raw_supply (regnum, (const void *) buf);
    }
  else if (regnum == LOONGARCH_EFLAGS_REGNUM)
    {
      buf = (const gdb_byte*) regs + scrsize * LOONGARCH_LINUX_NUM_SCR;
      regcache->raw_supply (regnum, (const void *) buf);
    }
  else if (regnum == LOONGARCH_FTOP_REGNUM)
    {
      buf = (const gdb_byte*) regs
	    + scrsize * LOONGARCH_LINUX_NUM_SCR
	    + eflagssize;
      regcache->raw_supply (regnum, (const void *) buf);
    }
}

/* Pack the GDB's register cache value into an lbt regset.  */

static void
loongarch_fill_lbtregset (const struct regset *regset,
			  const struct regcache *regcache, int regnum,
			  void *regs, size_t len)
{
  int scrsize = register_size (regcache->arch (), LOONGARCH_FIRST_SCR_REGNUM);
  int eflagssize = register_size (regcache->arch (), LOONGARCH_EFLAGS_REGNUM);
  gdb_byte *buf = nullptr;

  if (regnum == -1)
    {
      for (int i = 0; i < LOONGARCH_LINUX_NUM_SCR; i++)
	{
	  buf = (gdb_byte *) regs + scrsize * i;
	  regcache->raw_collect (LOONGARCH_FIRST_SCR_REGNUM + i, (void *) buf);
	}

      buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR;
      regcache->raw_collect (LOONGARCH_EFLAGS_REGNUM, (void *) buf);

      buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR + eflagssize;
      regcache->raw_collect (LOONGARCH_FTOP_REGNUM, (void *) buf);
    }
  else if (regnum >= LOONGARCH_FIRST_SCR_REGNUM
	   && regnum <= LOONGARCH_LAST_SCR_REGNUM)
    {
      buf = (gdb_byte *) regs + scrsize * (regnum - LOONGARCH_FIRST_SCR_REGNUM);
      regcache->raw_collect (regnum, (void *) buf);
    }
  else if (regnum == LOONGARCH_EFLAGS_REGNUM)
    {
      buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR;
      regcache->raw_collect (regnum, (void *) buf);
    }
  else if (regnum == LOONGARCH_FTOP_REGNUM)
    {
      buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR + eflagssize;
      regcache->raw_collect (regnum, (void *) buf);
    }
}

/* Define the lbt register regset.  */

const struct regset loongarch_lbtregset =
{
  nullptr,
  loongarch_supply_lbtregset,
  loongarch_fill_lbtregset,
};

/* Implement the "init" method of struct tramp_frame.  */

#define LOONGARCH_RT_SIGFRAME_UCONTEXT_OFFSET	128
#define LOONGARCH_UCONTEXT_SIGCONTEXT_OFFSET	176

static void
loongarch_linux_rt_sigframe_init (const struct tramp_frame *self,
				  const frame_info_ptr &this_frame,
				  struct trad_frame_cache *this_cache,
				  CORE_ADDR func)
{
  CORE_ADDR frame_sp = get_frame_sp (this_frame);
  CORE_ADDR sigcontext_base = (frame_sp + LOONGARCH_RT_SIGFRAME_UCONTEXT_OFFSET
			       + LOONGARCH_UCONTEXT_SIGCONTEXT_OFFSET);

  trad_frame_set_reg_addr (this_cache, LOONGARCH_PC_REGNUM, sigcontext_base);
  for (int i = 0; i < 32; i++)
    trad_frame_set_reg_addr (this_cache, i, sigcontext_base + 8 + i * 8);

  trad_frame_set_id (this_cache, frame_id_build (frame_sp, func));
}

/* li.w    a7, __NR_rt_sigreturn  */
#define LOONGARCH_INST_LIW_A7_RT_SIGRETURN	0x03822c0b
/* syscall 0  */
#define LOONGARCH_INST_SYSCALL			0x002b0000

static const struct tramp_frame loongarch_linux_rt_sigframe =
{
  SIGTRAMP_FRAME,
  4,
  {
    { LOONGARCH_INST_LIW_A7_RT_SIGRETURN, ULONGEST_MAX },
    { LOONGARCH_INST_SYSCALL, ULONGEST_MAX },
    { TRAMP_SENTINEL_INSN, ULONGEST_MAX }
  },
  loongarch_linux_rt_sigframe_init,
  nullptr
};

/* Implement the "iterate_over_regset_sections" gdbarch method.  */

static void
loongarch_iterate_over_regset_sections (struct gdbarch *gdbarch,
					iterate_over_regset_sections_cb *cb,
					void *cb_data,
					const struct regcache *regcache)
{
  int gprsize = register_size (gdbarch, 0);
  int gpsize = gprsize * LOONGARCH_LINUX_NUM_GREGSET;
  int fprsize = register_size (gdbarch, LOONGARCH_FIRST_FP_REGNUM);
  int fccsize = register_size (gdbarch, LOONGARCH_FIRST_FCC_REGNUM);
  int fcsrsize = register_size (gdbarch, LOONGARCH_FCSR_REGNUM);
  int fpsize = fprsize * LOONGARCH_LINUX_NUM_FPREGSET +
	       fccsize * LOONGARCH_LINUX_NUM_FCC + fcsrsize;
  int lsxrsize = register_size (gdbarch, LOONGARCH_FIRST_LSX_REGNUM);
  int lsxsize = lsxrsize * LOONGARCH_LINUX_NUM_LSXREGSET;
  int lasxrsize = register_size (gdbarch, LOONGARCH_FIRST_LASX_REGNUM);
  int lasxsize = lasxrsize * LOONGARCH_LINUX_NUM_LASXREGSET;
  int scrsize = register_size (gdbarch, LOONGARCH_FIRST_SCR_REGNUM);
  int eflagssize = register_size (gdbarch, LOONGARCH_EFLAGS_REGNUM);
  int ftopsize = register_size (gdbarch, LOONGARCH_FTOP_REGNUM);
  int lbtsize = scrsize * LOONGARCH_LINUX_NUM_SCR + eflagssize + ftopsize;

  cb (".reg", gpsize, gpsize,
      &loongarch_gregset, nullptr, cb_data);
  cb (".reg2", fpsize, fpsize,
      &loongarch_fpregset, nullptr, cb_data);
  cb (".reg-loongarch-lsx", lsxsize, lsxsize,
      &loongarch_lsxregset, nullptr, cb_data);
  cb (".reg-loongarch-lasx", lasxsize, lasxsize,
      &loongarch_lasxregset, nullptr, cb_data);
  cb (".reg-loongarch-lbt", lbtsize, lbtsize,
      &loongarch_lbtregset, nullptr, cb_data);
}

/* The following value is derived from __NR_rt_sigreturn in
   <include/uapi/asm-generic/unistd.h> from the Linux source tree.  */

#define LOONGARCH_NR_rt_sigreturn	139

/* When FRAME is at a syscall instruction, return the PC of the next
   instruction to be executed.  */

static CORE_ADDR
loongarch_linux_syscall_next_pc (const frame_info_ptr &frame)
{
  const CORE_ADDR pc = get_frame_pc (frame);
  ULONGEST a7 = get_frame_register_unsigned (frame, LOONGARCH_A7_REGNUM);

  /* If we are about to make a sigreturn syscall, use the unwinder to
     decode the signal frame.  */
  if (a7 == LOONGARCH_NR_rt_sigreturn)
    return frame_unwind_caller_pc (frame);

  return pc + 4;
}

/* Implement the "get_syscall_number" gdbarch method.  */

static LONGEST
loongarch_linux_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread)
{
  struct regcache *regcache = get_thread_regcache (thread);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  int regsize = register_size (gdbarch, LOONGARCH_A7_REGNUM);
  /* The content of a register.  */
  gdb_byte buf[8];
  /* The result.  */
  LONGEST ret;

  gdb_assert (regsize <= sizeof (buf));

  /* Getting the system call number from the register.
     When dealing with the LoongArch architecture, this information
     is stored at the a7 register.  */
  regcache->cooked_read (LOONGARCH_A7_REGNUM, buf);

  ret = extract_signed_integer (buf, regsize, byte_order);

  return ret;
}

/* Initialize LoongArch Linux ABI info.  */

static void
loongarch_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  loongarch_gdbarch_tdep *tdep = gdbarch_tdep<loongarch_gdbarch_tdep> (gdbarch);

  linux_init_abi (info, gdbarch, 0);

  set_solib_svr4_fetch_link_map_offsets (gdbarch,
					 info.bfd_arch_info->bits_per_address == 32
					 ? linux_ilp32_fetch_link_map_offsets
					 : linux_lp64_fetch_link_map_offsets);

  /* GNU/Linux uses SVR4-style shared libraries.  */
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);

  /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
  set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);

  /* Enable TLS support.  */
  set_gdbarch_fetch_tls_load_module_address (gdbarch, svr4_fetch_objfile_link_map);

  /* Prepend tramp frame unwinder for signal.  */
  tramp_frame_prepend_unwinder (gdbarch, &loongarch_linux_rt_sigframe);

  /* Core file support.  */
  set_gdbarch_iterate_over_regset_sections (gdbarch, loongarch_iterate_over_regset_sections);

  tdep->syscall_next_pc = loongarch_linux_syscall_next_pc;

  /* Set the correct XML syscall filename.  */
  set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_LOONGARCH);

  /* Get the syscall number from the arch's register.  */
  set_gdbarch_get_syscall_number (gdbarch, loongarch_linux_get_syscall_number);
}

/* Initialize LoongArch Linux target support.  */

void _initialize_loongarch_linux_tdep ();
void
_initialize_loongarch_linux_tdep ()
{
  gdbarch_register_osabi (bfd_arch_loongarch, bfd_mach_loongarch32,
			  GDB_OSABI_LINUX, loongarch_linux_init_abi);
  gdbarch_register_osabi (bfd_arch_loongarch, bfd_mach_loongarch64,
			  GDB_OSABI_LINUX, loongarch_linux_init_abi);
}