1 /* Target-dependent code for GNU/Linux on LoongArch processors. 2 3 Copyright (C) 2022-2024 Free Software Foundation, Inc. 4 Contributed by Loongson Ltd. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "extract-store-integer.h" 22 #include "glibc-tdep.h" 23 #include "inferior.h" 24 #include "linux-tdep.h" 25 #include "loongarch-tdep.h" 26 #include "solib-svr4.h" 27 #include "target-descriptions.h" 28 #include "trad-frame.h" 29 #include "tramp-frame.h" 30 #include "xml-syscall.h" 31 32 /* The syscall's XML filename for LoongArch. */ 33 #define XML_SYSCALL_FILENAME_LOONGARCH "syscalls/loongarch-linux.xml" 34 35 /* Unpack an elf_gregset_t into GDB's register cache. */ 36 37 static void 38 loongarch_supply_gregset (const struct regset *regset, 39 struct regcache *regcache, int regnum, 40 const void *gprs, size_t len) 41 { 42 int regsize = register_size (regcache->arch (), 0); 43 const gdb_byte *buf = nullptr; 44 45 if (regnum == -1) 46 { 47 regcache->raw_supply_zeroed (0); 48 49 for (int i = 1; i < 32; i++) 50 { 51 buf = (const gdb_byte*) gprs + regsize * i; 52 regcache->raw_supply (i, (const void *) buf); 53 } 54 55 buf = (const gdb_byte*) gprs + regsize * LOONGARCH_ORIG_A0_REGNUM; 56 regcache->raw_supply (LOONGARCH_ORIG_A0_REGNUM, (const void *) buf); 57 58 buf = (const gdb_byte*) gprs + regsize * LOONGARCH_PC_REGNUM; 59 regcache->raw_supply (LOONGARCH_PC_REGNUM, (const void *) buf); 60 61 buf = (const gdb_byte*) gprs + regsize * LOONGARCH_BADV_REGNUM; 62 regcache->raw_supply (LOONGARCH_BADV_REGNUM, (const void *) buf); 63 } 64 else if (regnum == 0) 65 regcache->raw_supply_zeroed (0); 66 else if ((regnum > 0 && regnum < 32) 67 || regnum == LOONGARCH_ORIG_A0_REGNUM 68 || regnum == LOONGARCH_PC_REGNUM 69 || regnum == LOONGARCH_BADV_REGNUM) 70 { 71 buf = (const gdb_byte*) gprs + regsize * regnum; 72 regcache->raw_supply (regnum, (const void *) buf); 73 } 74 } 75 76 /* Pack the GDB's register cache value into an elf_gregset_t. */ 77 78 static void 79 loongarch_fill_gregset (const struct regset *regset, 80 const struct regcache *regcache, int regnum, 81 void *gprs, size_t len) 82 { 83 int regsize = register_size (regcache->arch (), 0); 84 gdb_byte *buf = nullptr; 85 86 if (regnum == -1) 87 { 88 for (int i = 0; i < 32; i++) 89 { 90 buf = (gdb_byte *) gprs + regsize * i; 91 regcache->raw_collect (i, (void *) buf); 92 } 93 94 buf = (gdb_byte *) gprs + regsize * LOONGARCH_ORIG_A0_REGNUM; 95 regcache->raw_collect (LOONGARCH_ORIG_A0_REGNUM, (void *) buf); 96 97 buf = (gdb_byte *) gprs + regsize * LOONGARCH_PC_REGNUM; 98 regcache->raw_collect (LOONGARCH_PC_REGNUM, (void *) buf); 99 100 buf = (gdb_byte *) gprs + regsize * LOONGARCH_BADV_REGNUM; 101 regcache->raw_collect (LOONGARCH_BADV_REGNUM, (void *) buf); 102 } 103 else if ((regnum >= 0 && regnum < 32) 104 || regnum == LOONGARCH_ORIG_A0_REGNUM 105 || regnum == LOONGARCH_PC_REGNUM 106 || regnum == LOONGARCH_BADV_REGNUM) 107 { 108 buf = (gdb_byte *) gprs + regsize * regnum; 109 regcache->raw_collect (regnum, (void *) buf); 110 } 111 } 112 113 /* Define the general register regset. */ 114 115 const struct regset loongarch_gregset = 116 { 117 nullptr, 118 loongarch_supply_gregset, 119 loongarch_fill_gregset, 120 }; 121 122 /* Unpack an elf_fpregset_t into GDB's register cache. */ 123 static void 124 loongarch_supply_fpregset (const struct regset *r, 125 struct regcache *regcache, int regnum, 126 const void *fprs, size_t len) 127 { 128 const gdb_byte *buf = nullptr; 129 int fprsize = register_size (regcache->arch (), LOONGARCH_FIRST_FP_REGNUM); 130 int fccsize = register_size (regcache->arch (), LOONGARCH_FIRST_FCC_REGNUM); 131 132 if (regnum == -1) 133 { 134 for (int i = 0; i < LOONGARCH_LINUX_NUM_FPREGSET; i++) 135 { 136 buf = (const gdb_byte *)fprs + fprsize * i; 137 regcache->raw_supply (LOONGARCH_FIRST_FP_REGNUM + i, (const void *)buf); 138 } 139 for (int i = 0; i < LOONGARCH_LINUX_NUM_FCC; i++) 140 { 141 buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 142 fccsize * i; 143 regcache->raw_supply (LOONGARCH_FIRST_FCC_REGNUM + i, (const void *)buf); 144 } 145 buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 146 fccsize * LOONGARCH_LINUX_NUM_FCC; 147 regcache->raw_supply (LOONGARCH_FCSR_REGNUM, (const void *)buf); 148 } 149 else if (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum < LOONGARCH_FIRST_FCC_REGNUM) 150 { 151 buf = (const gdb_byte *)fprs + fprsize * (regnum - LOONGARCH_FIRST_FP_REGNUM); 152 regcache->raw_supply (regnum, (const void *)buf); 153 } 154 else if (regnum >= LOONGARCH_FIRST_FCC_REGNUM && regnum < LOONGARCH_FCSR_REGNUM) 155 { 156 buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 157 fccsize * (regnum - LOONGARCH_FIRST_FCC_REGNUM); 158 regcache->raw_supply (regnum, (const void *)buf); 159 } 160 else if (regnum == LOONGARCH_FCSR_REGNUM) 161 { 162 buf = (const gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 163 fccsize * LOONGARCH_LINUX_NUM_FCC; 164 regcache->raw_supply (regnum, (const void *)buf); 165 } 166 } 167 168 /* Pack the GDB's register cache value into an elf_fpregset_t. */ 169 static void 170 loongarch_fill_fpregset (const struct regset *r, 171 const struct regcache *regcache, int regnum, 172 void *fprs, size_t len) 173 { 174 gdb_byte *buf = nullptr; 175 int fprsize = register_size (regcache->arch (), LOONGARCH_FIRST_FP_REGNUM); 176 int fccsize = register_size (regcache->arch (), LOONGARCH_FIRST_FCC_REGNUM); 177 178 if (regnum == -1) 179 { 180 for (int i = 0; i < LOONGARCH_LINUX_NUM_FPREGSET; i++) 181 { 182 buf = (gdb_byte *)fprs + fprsize * i; 183 regcache->raw_collect (LOONGARCH_FIRST_FP_REGNUM + i, (void *)buf); 184 } 185 for (int i = 0; i < LOONGARCH_LINUX_NUM_FCC; i++) 186 { 187 buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 188 fccsize * i; 189 regcache->raw_collect (LOONGARCH_FIRST_FCC_REGNUM + i, (void *)buf); 190 } 191 buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 192 fccsize * LOONGARCH_LINUX_NUM_FCC; 193 regcache->raw_collect (LOONGARCH_FCSR_REGNUM, (void *)buf); 194 } 195 else if (regnum >= LOONGARCH_FIRST_FP_REGNUM && regnum < LOONGARCH_FIRST_FCC_REGNUM) 196 { 197 buf = (gdb_byte *)fprs + fprsize * (regnum - LOONGARCH_FIRST_FP_REGNUM); 198 regcache->raw_collect (regnum, (void *)buf); 199 } 200 else if (regnum >= LOONGARCH_FIRST_FCC_REGNUM && regnum < LOONGARCH_FCSR_REGNUM) 201 { 202 buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 203 fccsize * (regnum - LOONGARCH_FIRST_FCC_REGNUM); 204 regcache->raw_collect (regnum, (void *)buf); 205 } 206 else if (regnum == LOONGARCH_FCSR_REGNUM) 207 { 208 buf = (gdb_byte *)fprs + fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 209 fccsize * LOONGARCH_LINUX_NUM_FCC; 210 regcache->raw_collect (regnum, (void *)buf); 211 } 212 } 213 214 /* Define the FP register regset. */ 215 const struct regset loongarch_fpregset = 216 { 217 nullptr, 218 loongarch_supply_fpregset, 219 loongarch_fill_fpregset, 220 }; 221 222 /* Unpack elf_lsxregset_t into GDB's register cache. */ 223 224 static void 225 loongarch_supply_lsxregset (const struct regset *regset, 226 struct regcache *regcache, int regnum, 227 const void *lsxrs, size_t len) 228 { 229 int lsxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LSX_REGNUM); 230 const gdb_byte *buf = nullptr; 231 232 if (regnum == -1) 233 { 234 for (int i = 0; i < LOONGARCH_LINUX_NUM_LSXREGSET; i++) 235 { 236 buf = (const gdb_byte*) lsxrs + lsxrsize * i; 237 regcache->raw_supply (LOONGARCH_FIRST_LSX_REGNUM + i, (const void *) buf); 238 } 239 240 } 241 else if (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM) 242 { 243 buf = (const gdb_byte*) lsxrs + lsxrsize * (regnum - LOONGARCH_FIRST_LSX_REGNUM); 244 regcache->raw_supply (regnum, (const void *) buf); 245 } 246 } 247 248 /* Pack the GDB's register cache value into an elf_lsxregset_t. */ 249 250 static void 251 loongarch_fill_lsxregset (const struct regset *regset, 252 const struct regcache *regcache, int regnum, 253 void *lsxrs, size_t len) 254 { 255 int lsxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LSX_REGNUM); 256 gdb_byte *buf = nullptr; 257 258 if (regnum == -1) 259 { 260 for (int i = 0; i < LOONGARCH_LINUX_NUM_LSXREGSET; i++) 261 { 262 buf = (gdb_byte *) lsxrs + lsxrsize * i; 263 regcache->raw_collect (LOONGARCH_FIRST_LSX_REGNUM + i, (void *) buf); 264 } 265 } 266 else if (regnum >= LOONGARCH_FIRST_LSX_REGNUM && regnum < LOONGARCH_FIRST_LASX_REGNUM) 267 { 268 buf = (gdb_byte *) lsxrs + lsxrsize * (regnum - LOONGARCH_FIRST_LSX_REGNUM); 269 regcache->raw_collect (regnum, (void *) buf); 270 } 271 } 272 273 /* Define the Loongson SIMD Extension register regset. */ 274 275 const struct regset loongarch_lsxregset = 276 { 277 nullptr, 278 loongarch_supply_lsxregset, 279 loongarch_fill_lsxregset, 280 }; 281 282 /* Unpack elf_lasxregset_t into GDB's register cache. */ 283 284 static void 285 loongarch_supply_lasxregset (const struct regset *regset, 286 struct regcache *regcache, int regnum, 287 const void *lasxrs, size_t len) 288 { 289 int lasxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LASX_REGNUM); 290 const gdb_byte *buf = nullptr; 291 292 if (regnum == -1) 293 { 294 for (int i = 0; i < LOONGARCH_LINUX_NUM_LASXREGSET; i++) 295 { 296 buf = (const gdb_byte*) lasxrs + lasxrsize * i; 297 regcache->raw_supply (LOONGARCH_FIRST_LASX_REGNUM + i, (const void *) buf); 298 } 299 300 } 301 else if (regnum >= LOONGARCH_FIRST_LASX_REGNUM 302 && regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET) 303 { 304 buf = (const gdb_byte*) lasxrs + lasxrsize * (regnum - LOONGARCH_FIRST_LASX_REGNUM); 305 regcache->raw_supply (regnum, (const void *) buf); 306 } 307 } 308 309 /* Pack the GDB's register cache value into an elf_lasxregset_t. */ 310 311 static void 312 loongarch_fill_lasxregset (const struct regset *regset, 313 const struct regcache *regcache, int regnum, 314 void *lasxrs, size_t len) 315 { 316 int lasxrsize = register_size (regcache->arch (), LOONGARCH_FIRST_LASX_REGNUM); 317 gdb_byte *buf = nullptr; 318 319 if (regnum == -1) 320 { 321 for (int i = 0; i < LOONGARCH_LINUX_NUM_LASXREGSET; i++) 322 { 323 buf = (gdb_byte *) lasxrs + lasxrsize * i; 324 regcache->raw_collect (LOONGARCH_FIRST_LASX_REGNUM + i, (void *) buf); 325 } 326 } 327 else if (regnum >= LOONGARCH_FIRST_LASX_REGNUM 328 && regnum < LOONGARCH_FIRST_LASX_REGNUM + LOONGARCH_LINUX_NUM_LASXREGSET) 329 330 { 331 buf = (gdb_byte *) lasxrs + lasxrsize * (regnum - LOONGARCH_FIRST_LASX_REGNUM); 332 regcache->raw_collect (regnum, (void *) buf); 333 } 334 } 335 336 /* Define the Loongson Advanced SIMD Extension register regset. */ 337 338 const struct regset loongarch_lasxregset = 339 { 340 nullptr, 341 loongarch_supply_lasxregset, 342 loongarch_fill_lasxregset, 343 }; 344 345 /* Unpack an lbt regset into GDB's register cache. */ 346 347 static void 348 loongarch_supply_lbtregset (const struct regset *regset, 349 struct regcache *regcache, int regnum, 350 const void *regs, size_t len) 351 { 352 int scrsize = register_size (regcache->arch (), LOONGARCH_FIRST_SCR_REGNUM); 353 int eflagssize = register_size (regcache->arch (), LOONGARCH_EFLAGS_REGNUM); 354 const gdb_byte *buf = nullptr; 355 356 if (regnum == -1) 357 { 358 for (int i = 0; i < LOONGARCH_LINUX_NUM_SCR; i++) 359 { 360 buf = (const gdb_byte *) regs + scrsize * i; 361 regcache->raw_supply (LOONGARCH_FIRST_SCR_REGNUM + i, 362 (const void *) buf); 363 } 364 365 buf = (const gdb_byte*) regs + scrsize * LOONGARCH_LINUX_NUM_SCR; 366 regcache->raw_supply (LOONGARCH_EFLAGS_REGNUM, (const void *) buf); 367 368 buf = (const gdb_byte*) regs 369 + scrsize * LOONGARCH_LINUX_NUM_SCR 370 + eflagssize; 371 regcache->raw_supply (LOONGARCH_FTOP_REGNUM, (const void *) buf); 372 } 373 else if (regnum >= LOONGARCH_FIRST_SCR_REGNUM 374 && regnum <= LOONGARCH_LAST_SCR_REGNUM) 375 { 376 buf = (const gdb_byte*) regs 377 + scrsize * (regnum - LOONGARCH_FIRST_SCR_REGNUM); 378 regcache->raw_supply (regnum, (const void *) buf); 379 } 380 else if (regnum == LOONGARCH_EFLAGS_REGNUM) 381 { 382 buf = (const gdb_byte*) regs + scrsize * LOONGARCH_LINUX_NUM_SCR; 383 regcache->raw_supply (regnum, (const void *) buf); 384 } 385 else if (regnum == LOONGARCH_FTOP_REGNUM) 386 { 387 buf = (const gdb_byte*) regs 388 + scrsize * LOONGARCH_LINUX_NUM_SCR 389 + eflagssize; 390 regcache->raw_supply (regnum, (const void *) buf); 391 } 392 } 393 394 /* Pack the GDB's register cache value into an lbt regset. */ 395 396 static void 397 loongarch_fill_lbtregset (const struct regset *regset, 398 const struct regcache *regcache, int regnum, 399 void *regs, size_t len) 400 { 401 int scrsize = register_size (regcache->arch (), LOONGARCH_FIRST_SCR_REGNUM); 402 int eflagssize = register_size (regcache->arch (), LOONGARCH_EFLAGS_REGNUM); 403 gdb_byte *buf = nullptr; 404 405 if (regnum == -1) 406 { 407 for (int i = 0; i < LOONGARCH_LINUX_NUM_SCR; i++) 408 { 409 buf = (gdb_byte *) regs + scrsize * i; 410 regcache->raw_collect (LOONGARCH_FIRST_SCR_REGNUM + i, (void *) buf); 411 } 412 413 buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR; 414 regcache->raw_collect (LOONGARCH_EFLAGS_REGNUM, (void *) buf); 415 416 buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR + eflagssize; 417 regcache->raw_collect (LOONGARCH_FTOP_REGNUM, (void *) buf); 418 } 419 else if (regnum >= LOONGARCH_FIRST_SCR_REGNUM 420 && regnum <= LOONGARCH_LAST_SCR_REGNUM) 421 { 422 buf = (gdb_byte *) regs + scrsize * (regnum - LOONGARCH_FIRST_SCR_REGNUM); 423 regcache->raw_collect (regnum, (void *) buf); 424 } 425 else if (regnum == LOONGARCH_EFLAGS_REGNUM) 426 { 427 buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR; 428 regcache->raw_collect (regnum, (void *) buf); 429 } 430 else if (regnum == LOONGARCH_FTOP_REGNUM) 431 { 432 buf = (gdb_byte *) regs + scrsize * LOONGARCH_LINUX_NUM_SCR + eflagssize; 433 regcache->raw_collect (regnum, (void *) buf); 434 } 435 } 436 437 /* Define the lbt register regset. */ 438 439 const struct regset loongarch_lbtregset = 440 { 441 nullptr, 442 loongarch_supply_lbtregset, 443 loongarch_fill_lbtregset, 444 }; 445 446 /* Implement the "init" method of struct tramp_frame. */ 447 448 #define LOONGARCH_RT_SIGFRAME_UCONTEXT_OFFSET 128 449 #define LOONGARCH_UCONTEXT_SIGCONTEXT_OFFSET 176 450 451 static void 452 loongarch_linux_rt_sigframe_init (const struct tramp_frame *self, 453 const frame_info_ptr &this_frame, 454 struct trad_frame_cache *this_cache, 455 CORE_ADDR func) 456 { 457 CORE_ADDR frame_sp = get_frame_sp (this_frame); 458 CORE_ADDR sigcontext_base = (frame_sp + LOONGARCH_RT_SIGFRAME_UCONTEXT_OFFSET 459 + LOONGARCH_UCONTEXT_SIGCONTEXT_OFFSET); 460 461 trad_frame_set_reg_addr (this_cache, LOONGARCH_PC_REGNUM, sigcontext_base); 462 for (int i = 0; i < 32; i++) 463 trad_frame_set_reg_addr (this_cache, i, sigcontext_base + 8 + i * 8); 464 465 trad_frame_set_id (this_cache, frame_id_build (frame_sp, func)); 466 } 467 468 /* li.w a7, __NR_rt_sigreturn */ 469 #define LOONGARCH_INST_LIW_A7_RT_SIGRETURN 0x03822c0b 470 /* syscall 0 */ 471 #define LOONGARCH_INST_SYSCALL 0x002b0000 472 473 static const struct tramp_frame loongarch_linux_rt_sigframe = 474 { 475 SIGTRAMP_FRAME, 476 4, 477 { 478 { LOONGARCH_INST_LIW_A7_RT_SIGRETURN, ULONGEST_MAX }, 479 { LOONGARCH_INST_SYSCALL, ULONGEST_MAX }, 480 { TRAMP_SENTINEL_INSN, ULONGEST_MAX } 481 }, 482 loongarch_linux_rt_sigframe_init, 483 nullptr 484 }; 485 486 /* Implement the "iterate_over_regset_sections" gdbarch method. */ 487 488 static void 489 loongarch_iterate_over_regset_sections (struct gdbarch *gdbarch, 490 iterate_over_regset_sections_cb *cb, 491 void *cb_data, 492 const struct regcache *regcache) 493 { 494 int gprsize = register_size (gdbarch, 0); 495 int gpsize = gprsize * LOONGARCH_LINUX_NUM_GREGSET; 496 int fprsize = register_size (gdbarch, LOONGARCH_FIRST_FP_REGNUM); 497 int fccsize = register_size (gdbarch, LOONGARCH_FIRST_FCC_REGNUM); 498 int fcsrsize = register_size (gdbarch, LOONGARCH_FCSR_REGNUM); 499 int fpsize = fprsize * LOONGARCH_LINUX_NUM_FPREGSET + 500 fccsize * LOONGARCH_LINUX_NUM_FCC + fcsrsize; 501 int lsxrsize = register_size (gdbarch, LOONGARCH_FIRST_LSX_REGNUM); 502 int lsxsize = lsxrsize * LOONGARCH_LINUX_NUM_LSXREGSET; 503 int lasxrsize = register_size (gdbarch, LOONGARCH_FIRST_LASX_REGNUM); 504 int lasxsize = lasxrsize * LOONGARCH_LINUX_NUM_LASXREGSET; 505 int scrsize = register_size (gdbarch, LOONGARCH_FIRST_SCR_REGNUM); 506 int eflagssize = register_size (gdbarch, LOONGARCH_EFLAGS_REGNUM); 507 int ftopsize = register_size (gdbarch, LOONGARCH_FTOP_REGNUM); 508 int lbtsize = scrsize * LOONGARCH_LINUX_NUM_SCR + eflagssize + ftopsize; 509 510 cb (".reg", gpsize, gpsize, 511 &loongarch_gregset, nullptr, cb_data); 512 cb (".reg2", fpsize, fpsize, 513 &loongarch_fpregset, nullptr, cb_data); 514 cb (".reg-loongarch-lsx", lsxsize, lsxsize, 515 &loongarch_lsxregset, nullptr, cb_data); 516 cb (".reg-loongarch-lasx", lasxsize, lasxsize, 517 &loongarch_lasxregset, nullptr, cb_data); 518 cb (".reg-loongarch-lbt", lbtsize, lbtsize, 519 &loongarch_lbtregset, nullptr, cb_data); 520 } 521 522 /* The following value is derived from __NR_rt_sigreturn in 523 <include/uapi/asm-generic/unistd.h> from the Linux source tree. */ 524 525 #define LOONGARCH_NR_rt_sigreturn 139 526 527 /* When FRAME is at a syscall instruction, return the PC of the next 528 instruction to be executed. */ 529 530 static CORE_ADDR 531 loongarch_linux_syscall_next_pc (const frame_info_ptr &frame) 532 { 533 const CORE_ADDR pc = get_frame_pc (frame); 534 ULONGEST a7 = get_frame_register_unsigned (frame, LOONGARCH_A7_REGNUM); 535 536 /* If we are about to make a sigreturn syscall, use the unwinder to 537 decode the signal frame. */ 538 if (a7 == LOONGARCH_NR_rt_sigreturn) 539 return frame_unwind_caller_pc (frame); 540 541 return pc + 4; 542 } 543 544 /* Implement the "get_syscall_number" gdbarch method. */ 545 546 static LONGEST 547 loongarch_linux_get_syscall_number (struct gdbarch *gdbarch, thread_info *thread) 548 { 549 struct regcache *regcache = get_thread_regcache (thread); 550 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 551 int regsize = register_size (gdbarch, LOONGARCH_A7_REGNUM); 552 /* The content of a register. */ 553 gdb_byte buf[8]; 554 /* The result. */ 555 LONGEST ret; 556 557 gdb_assert (regsize <= sizeof (buf)); 558 559 /* Getting the system call number from the register. 560 When dealing with the LoongArch architecture, this information 561 is stored at the a7 register. */ 562 regcache->cooked_read (LOONGARCH_A7_REGNUM, buf); 563 564 ret = extract_signed_integer (buf, regsize, byte_order); 565 566 return ret; 567 } 568 569 /* Initialize LoongArch Linux ABI info. */ 570 571 static void 572 loongarch_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 573 { 574 loongarch_gdbarch_tdep *tdep = gdbarch_tdep<loongarch_gdbarch_tdep> (gdbarch); 575 576 linux_init_abi (info, gdbarch, 0); 577 578 set_solib_svr4_fetch_link_map_offsets (gdbarch, 579 info.bfd_arch_info->bits_per_address == 32 580 ? linux_ilp32_fetch_link_map_offsets 581 : linux_lp64_fetch_link_map_offsets); 582 583 /* GNU/Linux uses SVR4-style shared libraries. */ 584 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 585 586 /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ 587 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); 588 589 /* Enable TLS support. */ 590 set_gdbarch_fetch_tls_load_module_address (gdbarch, svr4_fetch_objfile_link_map); 591 592 /* Prepend tramp frame unwinder for signal. */ 593 tramp_frame_prepend_unwinder (gdbarch, &loongarch_linux_rt_sigframe); 594 595 /* Core file support. */ 596 set_gdbarch_iterate_over_regset_sections (gdbarch, loongarch_iterate_over_regset_sections); 597 598 tdep->syscall_next_pc = loongarch_linux_syscall_next_pc; 599 600 /* Set the correct XML syscall filename. */ 601 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_LOONGARCH); 602 603 /* Get the syscall number from the arch's register. */ 604 set_gdbarch_get_syscall_number (gdbarch, loongarch_linux_get_syscall_number); 605 } 606 607 /* Initialize LoongArch Linux target support. */ 608 609 void _initialize_loongarch_linux_tdep (); 610 void 611 _initialize_loongarch_linux_tdep () 612 { 613 gdbarch_register_osabi (bfd_arch_loongarch, bfd_mach_loongarch32, 614 GDB_OSABI_LINUX, loongarch_linux_init_abi); 615 gdbarch_register_osabi (bfd_arch_loongarch, bfd_mach_loongarch64, 616 GDB_OSABI_LINUX, loongarch_linux_init_abi); 617 } 618
Indexes created Mon Mar 02 05:31:46 UTC 2026