gdb/microblaze-tdep.c

   1 /* Target-dependent code for Xilinx MicroBlaze.
   2
   3    Copyright (C) 2009-2022 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "dis-asm.h"
  23 #include "frame.h"
  24 #include "trad-frame.h"
  25 #include "symtab.h"
  26 #include "value.h"
  27 #include "gdbcmd.h"
  28 #include "breakpoint.h"
  29 #include "inferior.h"
  30 #include "regcache.h"
  31 #include "target.h"
  32 #include "frame-base.h"
  33 #include "frame-unwind.h"
  34 #include "dwarf2/frame.h"
  35 #include "osabi.h"
  36 #include "target-descriptions.h"
  37 #include "opcodes/microblaze-opcm.h"
  38 #include "opcodes/microblaze-dis.h"
  39 #include "microblaze-tdep.h"
  40 #include "remote.h"
  41
  42 #include "features/microblaze-with-stack-protect.c"
  43 #include "features/microblaze.c"
  44 \f
  45 /* Instruction macros used for analyzing the prologue.  */
  46 /* This set of instruction macros need to be changed whenever the
  47    prologue generated by the compiler could have more instructions or
  48    different type of instructions.
  49    This set also needs to be verified if it is complete.  */
  50 #define IS_RETURN(op) (op == rtsd || op == rtid)
  51 #define IS_UPDATE_SP(op, rd, ra) \
  52   ((op == addik || op == addi) && rd == REG_SP && ra == REG_SP)
  53 #define IS_SPILL_SP(op, rd, ra) \
  54   ((op == swi || op == sw) && rd == REG_SP && ra == REG_SP)
  55 #define IS_SPILL_REG(op, rd, ra) \
  56   ((op == swi || op == sw) && rd != REG_SP && ra == REG_SP)
  57 #define IS_ALSO_SPILL_REG(op, rd, ra, rb) \
  58   ((op == swi || op == sw) && rd != REG_SP && ra == 0 && rb == REG_SP)
  59 #define IS_SETUP_FP(op, ra, rb) \
  60   ((op == add || op == addik || op == addk) && ra == REG_SP && rb == 0)
  61 #define IS_SPILL_REG_FP(op, rd, ra, fpregnum) \
  62   ((op == swi || op == sw) && rd != REG_SP && ra == fpregnum && ra != 0)
  63 #define IS_SAVE_HIDDEN_PTR(op, rd, ra, rb) \
  64   ((op == add || op == addik) && ra == MICROBLAZE_FIRST_ARGREG && rb == 0)
  65
  66 /* The registers of the Xilinx microblaze processor.  */
  67
  68 static const char * const microblaze_register_names[] =
  69 {
  70   "r0",   "r1",  "r2",    "r3",   "r4",   "r5",   "r6",   "r7",
  71   "r8",   "r9",  "r10",   "r11",  "r12",  "r13",  "r14",  "r15",
  72   "r16",  "r17", "r18",   "r19",  "r20",  "r21",  "r22",  "r23",
  73   "r24",  "r25", "r26",   "r27",  "r28",  "r29",  "r30",  "r31",
  74   "rpc",  "rmsr", "rear", "resr", "rfsr", "rbtr",
  75   "rpvr0", "rpvr1", "rpvr2", "rpvr3", "rpvr4", "rpvr5", "rpvr6",
  76   "rpvr7", "rpvr8", "rpvr9", "rpvr10", "rpvr11",
  77   "redr", "rpid", "rzpr", "rtlbx", "rtlbsx", "rtlblo", "rtlbhi",
  78   "rslr", "rshr"
  79 };
  80
  81 #define MICROBLAZE_NUM_REGS ARRAY_SIZE (microblaze_register_names)
  82 \f
  83 static unsigned int microblaze_debug_flag = 0;
  84
  85 #define microblaze_debug(fmt, ...) \
  86   debug_prefixed_printf_cond_nofunc (microblaze_debug_flag, "MICROBLAZE", \
  87                                      fmt, ## __VA_ARGS__)
  88
  89 \f
  90 /* Return the name of register REGNUM.  */
  91
  92 static const char *
  93 microblaze_register_name (struct gdbarch *gdbarch, int regnum)
  94 {
  95   if (regnum >= 0 && regnum < MICROBLAZE_NUM_REGS)
  96     return microblaze_register_names[regnum];
  97   return NULL;
  98 }
  99
 100 static struct type *
 101 microblaze_register_type (struct gdbarch *gdbarch, int regnum)
 102 {
 103   if (regnum == MICROBLAZE_SP_REGNUM)
 104     return builtin_type (gdbarch)->builtin_data_ptr;
 105
 106   if (regnum == MICROBLAZE_PC_REGNUM)
 107     return builtin_type (gdbarch)->builtin_func_ptr;
 108
 109   return builtin_type (gdbarch)->builtin_int;
 110 }
 111
 112 \f
 113 /* Fetch the instruction at PC.  */
 114
 115 static unsigned long
 116 microblaze_fetch_instruction (CORE_ADDR pc)
 117 {
 118   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 119   gdb_byte buf[4];
 120
 121   /* If we can't read the instruction at PC, return zero.  */
 122   if (target_read_code (pc, buf, sizeof (buf)))
 123     return 0;
 124
 125   return extract_unsigned_integer (buf, 4, byte_order);
 126 }
 127 \f
 128 constexpr gdb_byte microblaze_break_insn[] = MICROBLAZE_BREAKPOINT;
 129
 130 typedef BP_MANIPULATION (microblaze_break_insn) microblaze_breakpoint;
 131
 132 \f
 133 /* Allocate and initialize a frame cache.  */
 134
 135 static struct microblaze_frame_cache *
 136 microblaze_alloc_frame_cache (void)
 137 {
 138   struct microblaze_frame_cache *cache;
 139
 140   cache = FRAME_OBSTACK_ZALLOC (struct microblaze_frame_cache);
 141
 142   /* Base address.  */
 143   cache->base = 0;
 144   cache->pc = 0;
 145
 146   /* Frameless until proven otherwise.  */
 147   cache->frameless_p = 1;
 148
 149   return cache;
 150 }
 151
 152 /* The base of the current frame is actually in the stack pointer.
 153    This happens when there is no frame pointer (microblaze ABI does not
 154    require a frame pointer) or when we're stopped in the prologue or
 155    epilogue itself.  In these cases, microblaze_analyze_prologue will need
 156    to update fi->frame before returning or analyzing the register
 157    save instructions.  */
 158 #define MICROBLAZE_MY_FRAME_IN_SP 0x1
 159
 160 /* The base of the current frame is in a frame pointer register.
 161    This register is noted in frame_extra_info->fp_regnum.
 162
 163    Note that the existance of an FP might also indicate that the
 164    function has called alloca.  */
 165 #define MICROBLAZE_MY_FRAME_IN_FP 0x2
 166
 167 /* Function prologues on the Xilinx microblaze processors consist of:
 168
 169    - adjustments to the stack pointer (r1) (addi r1, r1, imm)
 170    - making a copy of r1 into another register (a "frame" pointer)
 171      (add r?, r1, r0)
 172    - store word/multiples that use r1 or the frame pointer as the
 173      base address (swi r?, r1, imm OR swi r?, fp, imm)
 174
 175    Note that microblaze really doesn't have a real frame pointer.
 176    Instead, the compiler may copy the SP into a register (usually
 177    r19) to act as an arg pointer.  For our target-dependent purposes,
 178    the frame info's "frame" member will be the beginning of the
 179    frame.  The SP could, in fact, point below this.
 180
 181    The prologue ends when an instruction fails to meet either of
 182    these criteria.  */
 183
 184 /* Analyze the prologue to determine where registers are saved,
 185    the end of the prologue, etc.  Return the address of the first line
 186    of "real" code (i.e., the end of the prologue).  */
 187
 188 static CORE_ADDR
 189 microblaze_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc,
 190                              CORE_ADDR current_pc,
 191                              struct microblaze_frame_cache *cache)
 192 {
 193   const char *name;
 194   CORE_ADDR func_addr, func_end, addr, stop, prologue_end_addr = 0;
 195   unsigned long insn;
 196   int rd, ra, rb, imm;
 197   enum microblaze_instr op;
 198   int save_hidden_pointer_found = 0;
 199   int non_stack_instruction_found = 0;
 200
 201   /* Find the start of this function.  */
 202   find_pc_partial_function (pc, &name, &func_addr, &func_end);
 203   if (func_addr < pc)
 204     pc = func_addr;
 205
 206   if (current_pc < pc)
 207     return current_pc;
 208
 209    /* Initialize info about frame.  */
 210    cache->framesize = 0;
 211    cache->fp_regnum = MICROBLAZE_SP_REGNUM;
 212    cache->frameless_p = 1;
 213
 214   /* Start decoding the prologue.  We start by checking two special cases:
 215
 216      1. We're about to return
 217      2. We're at the first insn of the prologue.
 218
 219      If we're about to return, our frame has already been deallocated.
 220      If we are stopped at the first instruction of a prologue,
 221      then our frame has not yet been set up.  */
 222
 223   /* Get the first insn from memory.  */
 224
 225   insn = microblaze_fetch_instruction (pc);
 226   op = microblaze_decode_insn (insn, &rd, &ra, &rb, &imm);
 227
 228   if (IS_RETURN(op))
 229     return pc;
 230
 231   /* Start at beginning of function and analyze until we get to the
 232      current pc, or the end of the function, whichever is first.  */
 233   stop = (current_pc < func_end ? current_pc : func_end);
 234
 235   microblaze_debug ("Scanning prologue: name=%s, func_addr=%s, stop=%s\n",
 236                     name, paddress (gdbarch, func_addr),
 237                     paddress (gdbarch, stop));
 238
 239   for (addr = func_addr; addr < stop; addr += INST_WORD_SIZE)
 240     {
 241       insn = microblaze_fetch_instruction (addr);
 242       op = microblaze_decode_insn (insn, &rd, &ra, &rb, &imm);
 243       microblaze_debug ("%s %08lx\n", paddress (gdbarch, pc), insn);
 244
 245       /* This code is very sensitive to what functions are present in the
 246          prologue.  It assumes that the (addi, addik, swi, sw) can be the
 247          only instructions in the prologue.  */
 248       if (IS_UPDATE_SP(op, rd, ra))
 249         {
 250           microblaze_debug ("got addi r1,r1,%d; contnuing\n", imm);
 251           if (cache->framesize)
 252             break;      /* break if framesize already computed.  */
 253           cache->framesize = -imm; /* stack grows towards low memory.  */
 254           cache->frameless_p = 0; /* Frame found.  */
 255           save_hidden_pointer_found = 0;
 256           non_stack_instruction_found = 0;
 257           continue;
 258         }
 259       else if (IS_SPILL_SP(op, rd, ra))
 260         {
 261           /* Spill stack pointer.  */
 262           cache->register_offsets[rd] = imm; /* SP spilled before updating.  */
 263
 264           microblaze_debug ("swi r1 r1 %d, continuing\n", imm);
 265           save_hidden_pointer_found = 0;
 266           if (!cache->framesize)
 267             non_stack_instruction_found = 0;
 268           continue;
 269         }
 270       else if (IS_SPILL_REG(op, rd, ra))
 271         {
 272           /* Spill register.  */
 273           cache->register_offsets[rd] = imm - cache->framesize;
 274
 275           microblaze_debug ("swi %d r1 %d, continuing\n", rd, imm);
 276           save_hidden_pointer_found = 0;
 277           if (!cache->framesize)
 278             non_stack_instruction_found = 0;
 279           continue;
 280         }
 281       else if (IS_ALSO_SPILL_REG(op, rd, ra, rb))
 282         {
 283           /* Spill register.  */
 284           cache->register_offsets[rd] = 0 - cache->framesize;
 285
 286           microblaze_debug ("sw %d r0 r1, continuing\n", rd);
 287           save_hidden_pointer_found = 0;
 288           if (!cache->framesize)
 289             non_stack_instruction_found = 0;
 290           continue;
 291         }
 292       else if (IS_SETUP_FP(op, ra, rb))
 293         {
 294           /* We have a frame pointer.  Note the register which is
 295              acting as the frame pointer.  */
 296           cache->fp_regnum = rd;
 297           microblaze_debug ("Found a frame pointer: r%d\n", cache->fp_regnum);
 298           save_hidden_pointer_found = 0;
 299           if (!cache->framesize)
 300             non_stack_instruction_found = 0;
 301           continue;
 302         }
 303       else if (IS_SPILL_REG_FP(op, rd, ra, cache->fp_regnum))
 304         {
 305           /* reg spilled after updating.  */
 306           cache->register_offsets[rd] = imm - cache->framesize;
 307
 308           microblaze_debug ("swi %d %d %d, continuing\n", rd, ra, imm);
 309           save_hidden_pointer_found = 0;
 310           if (!cache->framesize)
 311             non_stack_instruction_found = 0;
 312           continue;
 313         }
 314       else if (IS_SAVE_HIDDEN_PTR(op, rd, ra, rb))
 315         {
 316           /* If the first argument is a hidden pointer to the area where the
 317              return structure is to be saved, then it is saved as part of the
 318              prologue.  */
 319
 320           microblaze_debug ("add %d %d %d, continuing\n", rd, ra, rb);
 321           save_hidden_pointer_found = 1;
 322           if (!cache->framesize)
 323             non_stack_instruction_found = 0;
 324           continue;
 325         }
 326
 327       /* As a result of the modification in the next step where we continue
 328          to analyze the prologue till we reach a control flow instruction,
 329          we need another variable to store when exactly a non-stack
 330          instruction was encountered, which is the current definition
 331          of a prologue.  */
 332       if (!non_stack_instruction_found)
 333         prologue_end_addr = addr;
 334       non_stack_instruction_found = 1;
 335
 336       /* When optimizations are enabled, it is not guaranteed that prologue
 337          instructions are not mixed in with other instructions from the
 338          program.  Some programs show this behavior at -O2.  This can be
 339          avoided by adding -fno-schedule-insns2 switch as of now (edk 8.1)
 340          In such cases, we scan the function until we see the first control
 341          instruction.  */
 342
 343       {
 344         unsigned ctrl_op = (unsigned)insn >> 26;
 345
 346         /* continue if not control flow (branch, return).  */
 347         if (ctrl_op != 0x26 && ctrl_op != 0x27 && ctrl_op != 0x2d
 348             && ctrl_op != 0x2e && ctrl_op != 0x2f)
 349           continue;
 350         else if (ctrl_op == 0x2c)
 351           continue;    /* continue if imm.  */
 352       }
 353
 354       /* This is not a prologue insn, so stop here.  */
 355       microblaze_debug ("insn is not a prologue insn -- ending scan\n");
 356       break;
 357     }
 358
 359   microblaze_debug ("done analyzing prologue\n");
 360   microblaze_debug ("prologue end = 0x%x\n", (int) addr);
 361
 362   /* If the last instruction was an add rd, r5, r0 then don't count it as
 363      part of the prologue.  */
 364   if (save_hidden_pointer_found)
 365     prologue_end_addr -= INST_WORD_SIZE;
 366
 367   return prologue_end_addr;
 368 }
 369
 370 static CORE_ADDR
 371 microblaze_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 372 {
 373   gdb_byte buf[4];
 374   CORE_ADDR pc;
 375
 376   frame_unwind_register (next_frame, MICROBLAZE_PC_REGNUM, buf);
 377   pc = extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
 378   /* For sentinel frame, return address is actual PC.  For other frames,
 379      return address is pc+8.  This is a workaround because gcc does not
 380      generate correct return address in CIE.  */
 381   if (frame_relative_level (next_frame) >= 0)
 382     pc += 8;
 383   return pc;
 384 }
 385
 386 /* Return PC of first real instruction of the function starting at
 387    START_PC.  */
 388
 389 static CORE_ADDR
 390 microblaze_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 391 {
 392   struct symtab_and_line sal;
 393   CORE_ADDR func_start, func_end, ostart_pc;
 394   struct microblaze_frame_cache cache;
 395
 396   /* This is the preferred method, find the end of the prologue by
 397      using the debugging information.  Debugging info does not always
 398      give the right answer since parameters are stored on stack after this.
 399      Always analyze the prologue.  */
 400   if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end))
 401     {
 402       sal = find_pc_line (func_start, 0);
 403
 404       if (sal.end < func_end
 405           && start_pc <= sal.end)
 406         start_pc = sal.end;
 407     }
 408
 409   ostart_pc = microblaze_analyze_prologue (gdbarch, func_start, 0xffffffffUL,
 410                                            &cache);
 411
 412   if (ostart_pc > start_pc)
 413     return ostart_pc;
 414   return start_pc;
 415 }
 416
 417 /* Normal frames.  */
 418
 419 static struct microblaze_frame_cache *
 420 microblaze_frame_cache (struct frame_info *next_frame, void **this_cache)
 421 {
 422   struct microblaze_frame_cache *cache;
 423   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 424   int rn;
 425
 426   if (*this_cache)
 427     return (struct microblaze_frame_cache *) *this_cache;
 428
 429   cache = microblaze_alloc_frame_cache ();
 430   *this_cache = cache;
 431   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 432
 433   /* Clear offsets to saved regs in frame.  */
 434   for (rn = 0; rn < gdbarch_num_regs (gdbarch); rn++)
 435     cache->register_offsets[rn] = -1;
 436
 437   /* Call for side effects.  */
 438   get_frame_func (next_frame);
 439
 440   cache->pc = get_frame_address_in_block (next_frame);
 441
 442   return cache;
 443 }
 444
 445 static void
 446 microblaze_frame_this_id (struct frame_info *next_frame, void **this_cache,
 447                        struct frame_id *this_id)
 448 {
 449   struct microblaze_frame_cache *cache =
 450     microblaze_frame_cache (next_frame, this_cache);
 451
 452   /* This marks the outermost frame.  */
 453   if (cache->base == 0)
 454     return;
 455
 456   (*this_id) = frame_id_build (cache->base, cache->pc);
 457 }
 458
 459 static struct value *
 460 microblaze_frame_prev_register (struct frame_info *this_frame,
 461                                  void **this_cache, int regnum)
 462 {
 463   struct microblaze_frame_cache *cache =
 464     microblaze_frame_cache (this_frame, this_cache);
 465
 466   if (cache->frameless_p)
 467     {
 468       if (regnum == MICROBLAZE_PC_REGNUM)
 469         regnum = 15;
 470       if (regnum == MICROBLAZE_SP_REGNUM)
 471         regnum = 1;
 472       return trad_frame_get_prev_register (this_frame,
 473                                            cache->saved_regs, regnum);
 474     }
 475   else
 476     return trad_frame_get_prev_register (this_frame, cache->saved_regs,
 477                                          regnum);
 478
 479 }
 480
 481 static const struct frame_unwind microblaze_frame_unwind =
 482 {
 483   "microblaze prologue",
 484   NORMAL_FRAME,
 485   default_frame_unwind_stop_reason,
 486   microblaze_frame_this_id,
 487   microblaze_frame_prev_register,
 488   NULL,
 489   default_frame_sniffer
 490 };
 491 \f
 492 static CORE_ADDR
 493 microblaze_frame_base_address (struct frame_info *next_frame,
 494                                void **this_cache)
 495 {
 496   struct microblaze_frame_cache *cache =
 497     microblaze_frame_cache (next_frame, this_cache);
 498
 499   return cache->base;
 500 }
 501
 502 static const struct frame_base microblaze_frame_base =
 503 {
 504   &microblaze_frame_unwind,
 505   microblaze_frame_base_address,
 506   microblaze_frame_base_address,
 507   microblaze_frame_base_address
 508 };
 509 \f
 510 /* Extract from an array REGBUF containing the (raw) register state, a
 511    function return value of TYPE, and copy that into VALBUF.  */
 512 static void
 513 microblaze_extract_return_value (struct type *type, struct regcache *regcache,
 514                                  gdb_byte *valbuf)
 515 {
 516   gdb_byte buf[8];
 517
 518   /* Copy the return value (starting) in RETVAL_REGNUM to VALBUF.  */
 519   switch (TYPE_LENGTH (type))
 520     {
 521       case 1:   /* return last byte in the register.  */
 522         regcache->cooked_read (MICROBLAZE_RETVAL_REGNUM, buf);
 523         memcpy(valbuf, buf + MICROBLAZE_REGISTER_SIZE - 1, 1);
 524         return;
 525       case 2:   /* return last 2 bytes in register.  */
 526         regcache->cooked_read (MICROBLAZE_RETVAL_REGNUM, buf);
 527         memcpy(valbuf, buf + MICROBLAZE_REGISTER_SIZE - 2, 2);
 528         return;
 529       case 4:   /* for sizes 4 or 8, copy the required length.  */
 530       case 8:
 531         regcache->cooked_read (MICROBLAZE_RETVAL_REGNUM, buf);
 532         regcache->cooked_read (MICROBLAZE_RETVAL_REGNUM + 1, buf+4);
 533         memcpy (valbuf, buf, TYPE_LENGTH (type));
 534         return;
 535       default:
 536         internal_error (__FILE__, __LINE__,
 537                         _("Unsupported return value size requested"));
 538     }
 539 }
 540
 541 /* Store the return value in VALBUF (of type TYPE) where the caller
 542    expects to see it.
 543
 544    Integers up to four bytes are stored in r3.
 545
 546    Longs are stored in r3 (most significant word) and r4 (least
 547    significant word).
 548
 549    Small structures are always returned on stack.  */
 550
 551 static void
 552 microblaze_store_return_value (struct type *type, struct regcache *regcache,
 553                                const gdb_byte *valbuf)
 554 {
 555   int len = TYPE_LENGTH (type);
 556   gdb_byte buf[8];
 557
 558   memset (buf, 0, sizeof(buf));
 559
 560   /* Integral and pointer return values.  */
 561
 562   if (len > 4)
 563     {
 564        gdb_assert (len == 8);
 565        memcpy (buf, valbuf, 8);
 566        regcache->cooked_write (MICROBLAZE_RETVAL_REGNUM+1, buf + 4);
 567     }
 568   else
 569     /* ??? Do we need to do any sign-extension here?  */
 570     memcpy (buf + 4 - len, valbuf, len);
 571
 572   regcache->cooked_write (MICROBLAZE_RETVAL_REGNUM, buf);
 573 }
 574
 575 static enum return_value_convention
 576 microblaze_return_value (struct gdbarch *gdbarch, struct value *function,
 577                          struct type *type, struct regcache *regcache,
 578                          gdb_byte *readbuf, const gdb_byte *writebuf)
 579 {
 580   if (readbuf)
 581     microblaze_extract_return_value (type, regcache, readbuf);
 582   if (writebuf)
 583     microblaze_store_return_value (type, regcache, writebuf);
 584
 585   return RETURN_VALUE_REGISTER_CONVENTION;
 586 }
 587
 588 static int
 589 microblaze_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type)
 590 {
 591   return (TYPE_LENGTH (type) == 16);
 592 }
 593
 594 \f
 595 static int dwarf2_to_reg_map[78] =
 596 { 0  /* r0  */,   1  /* r1  */,   2  /* r2  */,   3  /* r3  */,  /*  0- 3 */
 597   4  /* r4  */,   5  /* r5  */,   6  /* r6  */,   7  /* r7  */,  /*  4- 7 */
 598   8  /* r8  */,   9  /* r9  */,  10  /* r10 */,  11  /* r11 */,  /*  8-11 */
 599   12 /* r12 */,  13  /* r13 */,  14  /* r14 */,  15  /* r15 */,  /* 12-15 */
 600   16 /* r16 */,  17  /* r17 */,  18  /* r18 */,  19  /* r19 */,  /* 16-19 */
 601   20 /* r20 */,  21  /* r21 */,  22  /* r22 */,  23  /* r23 */,  /* 20-23 */
 602   24 /* r24 */,  25  /* r25 */,  26  /* r26 */,  27  /* r27 */,  /* 24-25 */
 603   28 /* r28 */,  29  /* r29 */,  30  /* r30 */,  31  /* r31 */,  /* 28-31 */
 604   -1 /* $f0 */,  -1  /* $f1 */,  -1  /* $f2 */,  -1  /* $f3 */,  /* 32-35 */
 605   -1 /* $f4 */,  -1  /* $f5 */,  -1  /* $f6 */,  -1  /* $f7 */,  /* 36-39 */
 606   -1 /* $f8 */,  -1  /* $f9 */,  -1  /* $f10 */, -1  /* $f11 */, /* 40-43 */
 607   -1 /* $f12 */, -1  /* $f13 */, -1  /* $f14 */, -1  /* $f15 */, /* 44-47 */
 608   -1 /* $f16 */, -1  /* $f17 */, -1  /* $f18 */, -1  /* $f19 */, /* 48-51 */
 609   -1 /* $f20 */, -1  /* $f21 */, -1  /* $f22 */, -1  /* $f23 */, /* 52-55 */
 610   -1 /* $f24 */, -1  /* $f25 */, -1  /* $f26 */, -1  /* $f27 */, /* 56-59 */
 611   -1 /* $f28 */, -1  /* $f29 */, -1  /* $f30 */, -1  /* $f31 */, /* 60-63 */
 612   -1 /* hi   */, -1  /* lo   */, -1  /* accum*/, 33  /* rmsr */, /* 64-67 */
 613   -1 /* $fcc1*/, -1  /* $fcc2*/, -1  /* $fcc3*/, -1  /* $fcc4*/, /* 68-71 */
 614   -1 /* $fcc5*/, -1  /* $fcc6*/, -1  /* $fcc7*/, -1  /* $ap  */, /* 72-75 */
 615   -1 /* $rap */, -1  /* $frp */                                  /* 76-77 */
 616 };
 617
 618 static int
 619 microblaze_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg)
 620 {
 621   if (reg >= 0 && reg < sizeof (dwarf2_to_reg_map))
 622     return dwarf2_to_reg_map[reg];
 623   return -1;
 624 }
 625
 626 static void
 627 microblaze_register_g_packet_guesses (struct gdbarch *gdbarch)
 628 {
 629   register_remote_g_packet_guess (gdbarch,
 630                                   4 * MICROBLAZE_NUM_CORE_REGS,
 631                                   tdesc_microblaze);
 632
 633   register_remote_g_packet_guess (gdbarch,
 634                                   4 * MICROBLAZE_NUM_REGS,
 635                                   tdesc_microblaze_with_stack_protect);
 636 }
 637
 638 static struct gdbarch *
 639 microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 640 {
 641   struct gdbarch *gdbarch;
 642   tdesc_arch_data_up tdesc_data;
 643   const struct target_desc *tdesc = info.target_desc;
 644
 645   /* If there is already a candidate, use it.  */
 646   arches = gdbarch_list_lookup_by_info (arches, &info);
 647   if (arches != NULL)
 648     return arches->gdbarch;
 649   if (tdesc == NULL)
 650     tdesc = tdesc_microblaze;
 651
 652   /* Check any target description for validity.  */
 653   if (tdesc_has_registers (tdesc))
 654     {
 655       const struct tdesc_feature *feature;
 656       int valid_p;
 657       int i;
 658
 659       feature = tdesc_find_feature (tdesc,
 660                                     "org.gnu.gdb.microblaze.core");
 661       if (feature == NULL)
 662         return NULL;
 663       tdesc_data = tdesc_data_alloc ();
 664
 665       valid_p = 1;
 666       for (i = 0; i < MICROBLAZE_NUM_CORE_REGS; i++)
 667         valid_p &= tdesc_numbered_register (feature, tdesc_data.get (), i,
 668                                             microblaze_register_names[i]);
 669       feature = tdesc_find_feature (tdesc,
 670                                     "org.gnu.gdb.microblaze.stack-protect");
 671       if (feature != NULL)
 672         {
 673           valid_p = 1;
 674           valid_p &= tdesc_numbered_register (feature, tdesc_data.get (),
 675                                               MICROBLAZE_SLR_REGNUM,
 676                                               "rslr");
 677           valid_p &= tdesc_numbered_register (feature, tdesc_data.get (),
 678                                               MICROBLAZE_SHR_REGNUM,
 679                                               "rshr");
 680         }
 681
 682       if (!valid_p)
 683         return NULL;
 684     }
 685
 686   /* Allocate space for the new architecture.  */
 687   microblaze_gdbarch_tdep *tdep = new microblaze_gdbarch_tdep;
 688   gdbarch = gdbarch_alloc (&info, tdep);
 689
 690   set_gdbarch_long_double_bit (gdbarch, 128);
 691
 692   set_gdbarch_num_regs (gdbarch, MICROBLAZE_NUM_REGS);
 693   set_gdbarch_register_name (gdbarch, microblaze_register_name);
 694   set_gdbarch_register_type (gdbarch, microblaze_register_type);
 695
 696   /* Register numbers of various important registers.  */
 697   set_gdbarch_sp_regnum (gdbarch, MICROBLAZE_SP_REGNUM);
 698   set_gdbarch_pc_regnum (gdbarch, MICROBLAZE_PC_REGNUM);
 699
 700   /* Map Dwarf2 registers to GDB registers.  */
 701   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, microblaze_dwarf2_reg_to_regnum);
 702
 703   /* Call dummy code.  */
 704   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
 705
 706   set_gdbarch_return_value (gdbarch, microblaze_return_value);
 707   set_gdbarch_stabs_argument_has_addr
 708     (gdbarch, microblaze_stabs_argument_has_addr);
 709
 710   set_gdbarch_skip_prologue (gdbarch, microblaze_skip_prologue);
 711
 712   /* Stack grows downward.  */
 713   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 714
 715   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
 716                                        microblaze_breakpoint::kind_from_pc);
 717   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
 718                                        microblaze_breakpoint::bp_from_kind);
 719
 720   set_gdbarch_frame_args_skip (gdbarch, 8);
 721
 722   set_gdbarch_unwind_pc (gdbarch, microblaze_unwind_pc);
 723
 724   microblaze_register_g_packet_guesses (gdbarch);
 725
 726   frame_base_set_default (gdbarch, &microblaze_frame_base);
 727
 728   /* Hook in ABI-specific overrides, if they have been registered.  */
 729   gdbarch_init_osabi (info, gdbarch);
 730
 731   /* Unwind the frame.  */
 732   dwarf2_append_unwinders (gdbarch);
 733   frame_unwind_append_unwinder (gdbarch, &microblaze_frame_unwind);
 734   frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer);
 735   if (tdesc_data != NULL)
 736     tdesc_use_registers (gdbarch, tdesc, std::move (tdesc_data));
 737
 738   return gdbarch;
 739 }
 740
 741 void _initialize_microblaze_tdep ();
 742 void
 743 _initialize_microblaze_tdep ()
 744 {
 745   register_gdbarch_init (bfd_arch_microblaze, microblaze_gdbarch_init);
 746
 747   initialize_tdesc_microblaze_with_stack_protect ();
 748   initialize_tdesc_microblaze ();
 749   /* Debug this files internals.  */
 750   add_setshow_zuinteger_cmd ("microblaze", class_maintenance,
 751                              &microblaze_debug_flag, _("\
 752 Set microblaze debugging."), _("\
 753 Show microblaze debugging."), _("\
 754 When non-zero, microblaze specific debugging is enabled."),
 755                              NULL,
 756                              NULL,
 757                              &setdebuglist, &showdebuglist);
 758
 759 }