gdb/aarch64-tdep.c

   1 /* Common target dependent code for GDB on AArch64 systems.
   2
   3    Copyright (C) 2009-2016 Free Software Foundation, Inc.
   4    Contributed by ARM 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 "defs.h"
  22
  23 #include "frame.h"
  24 #include "inferior.h"
  25 #include "gdbcmd.h"
  26 #include "gdbcore.h"
  27 #include "dis-asm.h"
  28 #include "regcache.h"
  29 #include "reggroups.h"
  30 #include "doublest.h"
  31 #include "value.h"
  32 #include "arch-utils.h"
  33 #include "osabi.h"
  34 #include "frame-unwind.h"
  35 #include "frame-base.h"
  36 #include "trad-frame.h"
  37 #include "objfiles.h"
  38 #include "dwarf2-frame.h"
  39 #include "gdbtypes.h"
  40 #include "prologue-value.h"
  41 #include "target-descriptions.h"
  42 #include "user-regs.h"
  43 #include "language.h"
  44 #include "infcall.h"
  45 #include "ax.h"
  46 #include "ax-gdb.h"
  47
  48 #include "aarch64-tdep.h"
  49
  50 #include "elf-bfd.h"
  51 #include "elf/aarch64.h"
  52
  53 #include "vec.h"
  54
  55 #include "record.h"
  56 #include "record-full.h"
  57
  58 #include "features/aarch64.c"
  59
  60 #include "arch/aarch64-insn.h"
  61
  62 #include "opcode/aarch64.h"
  63 #include <algorithm>
  64
  65 #define submask(x) ((1L << ((x) + 1)) - 1)
  66 #define bit(obj,st) (((obj) >> (st)) & 1)
  67 #define bits(obj,st,fn) (((obj) >> (st)) & submask ((fn) - (st)))
  68
  69 /* Pseudo register base numbers.  */
  70 #define AARCH64_Q0_REGNUM 0
  71 #define AARCH64_D0_REGNUM (AARCH64_Q0_REGNUM + AARCH64_D_REGISTER_COUNT)
  72 #define AARCH64_S0_REGNUM (AARCH64_D0_REGNUM + 32)
  73 #define AARCH64_H0_REGNUM (AARCH64_S0_REGNUM + 32)
  74 #define AARCH64_B0_REGNUM (AARCH64_H0_REGNUM + 32)
  75
  76 /* The standard register names, and all the valid aliases for them.  */
  77 static const struct
  78 {
  79   const char *const name;
  80   int regnum;
  81 } aarch64_register_aliases[] =
  82 {
  83   /* 64-bit register names.  */
  84   {"fp", AARCH64_FP_REGNUM},
  85   {"lr", AARCH64_LR_REGNUM},
  86   {"sp", AARCH64_SP_REGNUM},
  87
  88   /* 32-bit register names.  */
  89   {"w0", AARCH64_X0_REGNUM + 0},
  90   {"w1", AARCH64_X0_REGNUM + 1},
  91   {"w2", AARCH64_X0_REGNUM + 2},
  92   {"w3", AARCH64_X0_REGNUM + 3},
  93   {"w4", AARCH64_X0_REGNUM + 4},
  94   {"w5", AARCH64_X0_REGNUM + 5},
  95   {"w6", AARCH64_X0_REGNUM + 6},
  96   {"w7", AARCH64_X0_REGNUM + 7},
  97   {"w8", AARCH64_X0_REGNUM + 8},
  98   {"w9", AARCH64_X0_REGNUM + 9},
  99   {"w10", AARCH64_X0_REGNUM + 10},
 100   {"w11", AARCH64_X0_REGNUM + 11},
 101   {"w12", AARCH64_X0_REGNUM + 12},
 102   {"w13", AARCH64_X0_REGNUM + 13},
 103   {"w14", AARCH64_X0_REGNUM + 14},
 104   {"w15", AARCH64_X0_REGNUM + 15},
 105   {"w16", AARCH64_X0_REGNUM + 16},
 106   {"w17", AARCH64_X0_REGNUM + 17},
 107   {"w18", AARCH64_X0_REGNUM + 18},
 108   {"w19", AARCH64_X0_REGNUM + 19},
 109   {"w20", AARCH64_X0_REGNUM + 20},
 110   {"w21", AARCH64_X0_REGNUM + 21},
 111   {"w22", AARCH64_X0_REGNUM + 22},
 112   {"w23", AARCH64_X0_REGNUM + 23},
 113   {"w24", AARCH64_X0_REGNUM + 24},
 114   {"w25", AARCH64_X0_REGNUM + 25},
 115   {"w26", AARCH64_X0_REGNUM + 26},
 116   {"w27", AARCH64_X0_REGNUM + 27},
 117   {"w28", AARCH64_X0_REGNUM + 28},
 118   {"w29", AARCH64_X0_REGNUM + 29},
 119   {"w30", AARCH64_X0_REGNUM + 30},
 120
 121   /*  specials */
 122   {"ip0", AARCH64_X0_REGNUM + 16},
 123   {"ip1", AARCH64_X0_REGNUM + 17}
 124 };
 125
 126 /* The required core 'R' registers.  */
 127 static const char *const aarch64_r_register_names[] =
 128 {
 129   /* These registers must appear in consecutive RAW register number
 130      order and they must begin with AARCH64_X0_REGNUM! */
 131   "x0", "x1", "x2", "x3",
 132   "x4", "x5", "x6", "x7",
 133   "x8", "x9", "x10", "x11",
 134   "x12", "x13", "x14", "x15",
 135   "x16", "x17", "x18", "x19",
 136   "x20", "x21", "x22", "x23",
 137   "x24", "x25", "x26", "x27",
 138   "x28", "x29", "x30", "sp",
 139   "pc", "cpsr"
 140 };
 141
 142 /* The FP/SIMD 'V' registers.  */
 143 static const char *const aarch64_v_register_names[] =
 144 {
 145   /* These registers must appear in consecutive RAW register number
 146      order and they must begin with AARCH64_V0_REGNUM! */
 147   "v0", "v1", "v2", "v3",
 148   "v4", "v5", "v6", "v7",
 149   "v8", "v9", "v10", "v11",
 150   "v12", "v13", "v14", "v15",
 151   "v16", "v17", "v18", "v19",
 152   "v20", "v21", "v22", "v23",
 153   "v24", "v25", "v26", "v27",
 154   "v28", "v29", "v30", "v31",
 155   "fpsr",
 156   "fpcr"
 157 };
 158
 159 /* AArch64 prologue cache structure.  */
 160 struct aarch64_prologue_cache
 161 {
 162   /* The program counter at the start of the function.  It is used to
 163      identify this frame as a prologue frame.  */
 164   CORE_ADDR func;
 165
 166   /* The program counter at the time this frame was created; i.e. where
 167      this function was called from.  It is used to identify this frame as a
 168      stub frame.  */
 169   CORE_ADDR prev_pc;
 170
 171   /* The stack pointer at the time this frame was created; i.e. the
 172      caller's stack pointer when this function was called.  It is used
 173      to identify this frame.  */
 174   CORE_ADDR prev_sp;
 175
 176   /* Is the target available to read from?  */
 177   int available_p;
 178
 179   /* The frame base for this frame is just prev_sp - frame size.
 180      FRAMESIZE is the distance from the frame pointer to the
 181      initial stack pointer.  */
 182   int framesize;
 183
 184   /* The register used to hold the frame pointer for this frame.  */
 185   int framereg;
 186
 187   /* Saved register offsets.  */
 188   struct trad_frame_saved_reg *saved_regs;
 189 };
 190
 191 static void
 192 show_aarch64_debug (struct ui_file *file, int from_tty,
 193                     struct cmd_list_element *c, const char *value)
 194 {
 195   fprintf_filtered (file, _("AArch64 debugging is %s.\n"), value);
 196 }
 197
 198 /* Analyze a prologue, looking for a recognizable stack frame
 199    and frame pointer.  Scan until we encounter a store that could
 200    clobber the stack frame unexpectedly, or an unknown instruction.  */
 201
 202 static CORE_ADDR
 203 aarch64_analyze_prologue (struct gdbarch *gdbarch,
 204                           CORE_ADDR start, CORE_ADDR limit,
 205                           struct aarch64_prologue_cache *cache)
 206 {
 207   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
 208   int i;
 209   /* Track X registers and D registers in prologue.  */
 210   pv_t regs[AARCH64_X_REGISTER_COUNT + AARCH64_D_REGISTER_COUNT];
 211   struct pv_area *stack;
 212   struct cleanup *back_to;
 213
 214   for (i = 0; i < AARCH64_X_REGISTER_COUNT + AARCH64_D_REGISTER_COUNT; i++)
 215     regs[i] = pv_register (i, 0);
 216   stack = make_pv_area (AARCH64_SP_REGNUM, gdbarch_addr_bit (gdbarch));
 217   back_to = make_cleanup_free_pv_area (stack);
 218
 219   for (; start < limit; start += 4)
 220     {
 221       uint32_t insn;
 222       aarch64_inst inst;
 223
 224       insn = read_memory_unsigned_integer (start, 4, byte_order_for_code);
 225
 226       if (aarch64_decode_insn (insn, &inst, 1) != 0)
 227         break;
 228
 229       if (inst.opcode->iclass == addsub_imm
 230           && (inst.opcode->op == OP_ADD
 231               || strcmp ("sub", inst.opcode->name) == 0))
 232         {
 233           unsigned rd = inst.operands[0].reg.regno;
 234           unsigned rn = inst.operands[1].reg.regno;
 235
 236           gdb_assert (aarch64_num_of_operands (inst.opcode) == 3);
 237           gdb_assert (inst.operands[0].type == AARCH64_OPND_Rd_SP);
 238           gdb_assert (inst.operands[1].type == AARCH64_OPND_Rn_SP);
 239           gdb_assert (inst.operands[2].type == AARCH64_OPND_AIMM);
 240
 241           if (inst.opcode->op == OP_ADD)
 242             {
 243               regs[rd] = pv_add_constant (regs[rn],
 244                                           inst.operands[2].imm.value);
 245             }
 246           else
 247             {
 248               regs[rd] = pv_add_constant (regs[rn],
 249                                           -inst.operands[2].imm.value);
 250             }
 251         }
 252       else if (inst.opcode->iclass == pcreladdr
 253                && inst.operands[1].type == AARCH64_OPND_ADDR_ADRP)
 254         {
 255           gdb_assert (aarch64_num_of_operands (inst.opcode) == 2);
 256           gdb_assert (inst.operands[0].type == AARCH64_OPND_Rd);
 257
 258           regs[inst.operands[0].reg.regno] = pv_unknown ();
 259         }
 260       else if (inst.opcode->iclass == branch_imm)
 261         {
 262           /* Stop analysis on branch.  */
 263           break;
 264         }
 265       else if (inst.opcode->iclass == condbranch)
 266         {
 267           /* Stop analysis on branch.  */
 268           break;
 269         }
 270       else if (inst.opcode->iclass == branch_reg)
 271         {
 272           /* Stop analysis on branch.  */
 273           break;
 274         }
 275       else if (inst.opcode->iclass == compbranch)
 276         {
 277           /* Stop analysis on branch.  */
 278           break;
 279         }
 280       else if (inst.opcode->op == OP_MOVZ)
 281         {
 282           gdb_assert (inst.operands[0].type == AARCH64_OPND_Rd);
 283           regs[inst.operands[0].reg.regno] = pv_unknown ();
 284         }
 285       else if (inst.opcode->iclass == log_shift
 286                && strcmp (inst.opcode->name, "orr") == 0)
 287         {
 288           unsigned rd = inst.operands[0].reg.regno;
 289           unsigned rn = inst.operands[1].reg.regno;
 290           unsigned rm = inst.operands[2].reg.regno;
 291
 292           gdb_assert (inst.operands[0].type == AARCH64_OPND_Rd);
 293           gdb_assert (inst.operands[1].type == AARCH64_OPND_Rn);
 294           gdb_assert (inst.operands[2].type == AARCH64_OPND_Rm_SFT);
 295
 296           if (inst.operands[2].shifter.amount == 0
 297               && rn == AARCH64_SP_REGNUM)
 298             regs[rd] = regs[rm];
 299           else
 300             {
 301               if (aarch64_debug)
 302                 {
 303                   debug_printf ("aarch64: prologue analysis gave up "
 304                                 "addr=%s opcode=0x%x (orr x register)\n",
 305                                 core_addr_to_string_nz (start), insn);
 306                 }
 307               break;
 308             }
 309         }
 310       else if (inst.opcode->op == OP_STUR)
 311         {
 312           unsigned rt = inst.operands[0].reg.regno;
 313           unsigned rn = inst.operands[1].addr.base_regno;
 314           int is64
 315             = (aarch64_get_qualifier_esize (inst.operands[0].qualifier) == 8);
 316
 317           gdb_assert (aarch64_num_of_operands (inst.opcode) == 2);
 318           gdb_assert (inst.operands[0].type == AARCH64_OPND_Rt);
 319           gdb_assert (inst.operands[1].type == AARCH64_OPND_ADDR_SIMM9);
 320           gdb_assert (!inst.operands[1].addr.offset.is_reg);
 321
 322           pv_area_store (stack, pv_add_constant (regs[rn],
 323                                                  inst.operands[1].addr.offset.imm),
 324                          is64 ? 8 : 4, regs[rt]);
 325         }
 326       else if ((inst.opcode->iclass == ldstpair_off
 327                 || (inst.opcode->iclass == ldstpair_indexed
 328                     && inst.operands[2].addr.preind))
 329                && strcmp ("stp", inst.opcode->name) == 0)
 330         {
 331           /* STP with addressing mode Pre-indexed and Base register.  */
 332           unsigned rt1;
 333           unsigned rt2;
 334           unsigned rn = inst.operands[2].addr.base_regno;
 335           int32_t imm = inst.operands[2].addr.offset.imm;
 336
 337           gdb_assert (inst.operands[0].type == AARCH64_OPND_Rt
 338                       || inst.operands[0].type == AARCH64_OPND_Ft);
 339           gdb_assert (inst.operands[1].type == AARCH64_OPND_Rt2
 340                       || inst.operands[1].type == AARCH64_OPND_Ft2);
 341           gdb_assert (inst.operands[2].type == AARCH64_OPND_ADDR_SIMM7);
 342           gdb_assert (!inst.operands[2].addr.offset.is_reg);
 343
 344           /* If recording this store would invalidate the store area
 345              (perhaps because rn is not known) then we should abandon
 346              further prologue analysis.  */
 347           if (pv_area_store_would_trash (stack,
 348                                          pv_add_constant (regs[rn], imm)))
 349             break;
 350
 351           if (pv_area_store_would_trash (stack,
 352                                          pv_add_constant (regs[rn], imm + 8)))
 353             break;
 354
 355           rt1 = inst.operands[0].reg.regno;
 356           rt2 = inst.operands[1].reg.regno;
 357           if (inst.operands[0].type == AARCH64_OPND_Ft)
 358             {
 359               /* Only bottom 64-bit of each V register (D register) need
 360                  to be preserved.  */
 361               gdb_assert (inst.operands[0].qualifier == AARCH64_OPND_QLF_S_D);
 362               rt1 += AARCH64_X_REGISTER_COUNT;
 363               rt2 += AARCH64_X_REGISTER_COUNT;
 364             }
 365
 366           pv_area_store (stack, pv_add_constant (regs[rn], imm), 8,
 367                          regs[rt1]);
 368           pv_area_store (stack, pv_add_constant (regs[rn], imm + 8), 8,
 369                          regs[rt2]);
 370
 371           if (inst.operands[2].addr.writeback)
 372             regs[rn] = pv_add_constant (regs[rn], imm);
 373
 374         }
 375       else if (inst.opcode->iclass == testbranch)
 376         {
 377           /* Stop analysis on branch.  */
 378           break;
 379         }
 380       else
 381         {
 382           if (aarch64_debug)
 383             {
 384               debug_printf ("aarch64: prologue analysis gave up addr=%s"
 385                             " opcode=0x%x\n",
 386                             core_addr_to_string_nz (start), insn);
 387             }
 388           break;
 389         }
 390     }
 391
 392   if (cache == NULL)
 393     {
 394       do_cleanups (back_to);
 395       return start;
 396     }
 397
 398   if (pv_is_register (regs[AARCH64_FP_REGNUM], AARCH64_SP_REGNUM))
 399     {
 400       /* Frame pointer is fp.  Frame size is constant.  */
 401       cache->framereg = AARCH64_FP_REGNUM;
 402       cache->framesize = -regs[AARCH64_FP_REGNUM].k;
 403     }
 404   else if (pv_is_register (regs[AARCH64_SP_REGNUM], AARCH64_SP_REGNUM))
 405     {
 406       /* Try the stack pointer.  */
 407       cache->framesize = -regs[AARCH64_SP_REGNUM].k;
 408       cache->framereg = AARCH64_SP_REGNUM;
 409     }
 410   else
 411     {
 412       /* We're just out of luck.  We don't know where the frame is.  */
 413       cache->framereg = -1;
 414       cache->framesize = 0;
 415     }
 416
 417   for (i = 0; i < AARCH64_X_REGISTER_COUNT; i++)
 418     {
 419       CORE_ADDR offset;
 420
 421       if (pv_area_find_reg (stack, gdbarch, i, &offset))
 422         cache->saved_regs[i].addr = offset;
 423     }
 424
 425   for (i = 0; i < AARCH64_D_REGISTER_COUNT; i++)
 426     {
 427       int regnum = gdbarch_num_regs (gdbarch);
 428       CORE_ADDR offset;
 429
 430       if (pv_area_find_reg (stack, gdbarch, i + AARCH64_X_REGISTER_COUNT,
 431                             &offset))
 432         cache->saved_regs[i + regnum + AARCH64_D0_REGNUM].addr = offset;
 433     }
 434
 435   do_cleanups (back_to);
 436   return start;
 437 }
 438
 439 /* Implement the "skip_prologue" gdbarch method.  */
 440
 441 static CORE_ADDR
 442 aarch64_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 443 {
 444   CORE_ADDR func_addr, limit_pc;
 445
 446   /* See if we can determine the end of the prologue via the symbol
 447      table.  If so, then return either PC, or the PC after the
 448      prologue, whichever is greater.  */
 449   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
 450     {
 451       CORE_ADDR post_prologue_pc
 452         = skip_prologue_using_sal (gdbarch, func_addr);
 453
 454       if (post_prologue_pc != 0)
 455         return std::max (pc, post_prologue_pc);
 456     }
 457
 458   /* Can't determine prologue from the symbol table, need to examine
 459      instructions.  */
 460
 461   /* Find an upper limit on the function prologue using the debug
 462      information.  If the debug information could not be used to
 463      provide that bound, then use an arbitrary large number as the
 464      upper bound.  */
 465   limit_pc = skip_prologue_using_sal (gdbarch, pc);
 466   if (limit_pc == 0)
 467     limit_pc = pc + 128;        /* Magic.  */
 468
 469   /* Try disassembling prologue.  */
 470   return aarch64_analyze_prologue (gdbarch, pc, limit_pc, NULL);
 471 }
 472
 473 /* Scan the function prologue for THIS_FRAME and populate the prologue
 474    cache CACHE.  */
 475
 476 static void
 477 aarch64_scan_prologue (struct frame_info *this_frame,
 478                        struct aarch64_prologue_cache *cache)
 479 {
 480   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
 481   CORE_ADDR prologue_start;
 482   CORE_ADDR prologue_end;
 483   CORE_ADDR prev_pc = get_frame_pc (this_frame);
 484   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 485
 486   cache->prev_pc = prev_pc;
 487
 488   /* Assume we do not find a frame.  */
 489   cache->framereg = -1;
 490   cache->framesize = 0;
 491
 492   if (find_pc_partial_function (block_addr, NULL, &prologue_start,
 493                                 &prologue_end))
 494     {
 495       struct symtab_and_line sal = find_pc_line (prologue_start, 0);
 496
 497       if (sal.line == 0)
 498         {
 499           /* No line info so use the current PC.  */
 500           prologue_end = prev_pc;
 501         }
 502       else if (sal.end < prologue_end)
 503         {
 504           /* The next line begins after the function end.  */
 505           prologue_end = sal.end;
 506         }
 507
 508       prologue_end = std::min (prologue_end, prev_pc);
 509       aarch64_analyze_prologue (gdbarch, prologue_start, prologue_end, cache);
 510     }
 511   else
 512     {
 513       CORE_ADDR frame_loc;
 514
 515       frame_loc = get_frame_register_unsigned (this_frame, AARCH64_FP_REGNUM);
 516       if (frame_loc == 0)
 517         return;
 518
 519       cache->framereg = AARCH64_FP_REGNUM;
 520       cache->framesize = 16;
 521       cache->saved_regs[29].addr = 0;
 522       cache->saved_regs[30].addr = 8;
 523     }
 524 }
 525
 526 /* Fill in *CACHE with information about the prologue of *THIS_FRAME.  This
 527    function may throw an exception if the inferior's registers or memory is
 528    not available.  */
 529
 530 static void
 531 aarch64_make_prologue_cache_1 (struct frame_info *this_frame,
 532                                struct aarch64_prologue_cache *cache)
 533 {
 534   CORE_ADDR unwound_fp;
 535   int reg;
 536
 537   aarch64_scan_prologue (this_frame, cache);
 538
 539   if (cache->framereg == -1)
 540     return;
 541
 542   unwound_fp = get_frame_register_unsigned (this_frame, cache->framereg);
 543   if (unwound_fp == 0)
 544     return;
 545
 546   cache->prev_sp = unwound_fp + cache->framesize;
 547
 548   /* Calculate actual addresses of saved registers using offsets
 549      determined by aarch64_analyze_prologue.  */
 550   for (reg = 0; reg < gdbarch_num_regs (get_frame_arch (this_frame)); reg++)
 551     if (trad_frame_addr_p (cache->saved_regs, reg))
 552       cache->saved_regs[reg].addr += cache->prev_sp;
 553
 554   cache->func = get_frame_func (this_frame);
 555
 556   cache->available_p = 1;
 557 }
 558
 559 /* Allocate and fill in *THIS_CACHE with information about the prologue of
 560    *THIS_FRAME.  Do not do this is if *THIS_CACHE was already allocated.
 561    Return a pointer to the current aarch64_prologue_cache in
 562    *THIS_CACHE.  */
 563
 564 static struct aarch64_prologue_cache *
 565 aarch64_make_prologue_cache (struct frame_info *this_frame, void **this_cache)
 566 {
 567   struct aarch64_prologue_cache *cache;
 568
 569   if (*this_cache != NULL)
 570     return (struct aarch64_prologue_cache *) *this_cache;
 571
 572   cache = FRAME_OBSTACK_ZALLOC (struct aarch64_prologue_cache);
 573   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 574   *this_cache = cache;
 575
 576   TRY
 577     {
 578       aarch64_make_prologue_cache_1 (this_frame, cache);
 579     }
 580   CATCH (ex, RETURN_MASK_ERROR)
 581     {
 582       if (ex.error != NOT_AVAILABLE_ERROR)
 583         throw_exception (ex);
 584     }
 585   END_CATCH
 586
 587   return cache;
 588 }
 589
 590 /* Implement the "stop_reason" frame_unwind method.  */
 591
 592 static enum unwind_stop_reason
 593 aarch64_prologue_frame_unwind_stop_reason (struct frame_info *this_frame,
 594                                            void **this_cache)
 595 {
 596   struct aarch64_prologue_cache *cache
 597     = aarch64_make_prologue_cache (this_frame, this_cache);
 598
 599   if (!cache->available_p)
 600     return UNWIND_UNAVAILABLE;
 601
 602   /* Halt the backtrace at "_start".  */
 603   if (cache->prev_pc <= gdbarch_tdep (get_frame_arch (this_frame))->lowest_pc)
 604     return UNWIND_OUTERMOST;
 605
 606   /* We've hit a wall, stop.  */
 607   if (cache->prev_sp == 0)
 608     return UNWIND_OUTERMOST;
 609
 610   return UNWIND_NO_REASON;
 611 }
 612
 613 /* Our frame ID for a normal frame is the current function's starting
 614    PC and the caller's SP when we were called.  */
 615
 616 static void
 617 aarch64_prologue_this_id (struct frame_info *this_frame,
 618                           void **this_cache, struct frame_id *this_id)
 619 {
 620   struct aarch64_prologue_cache *cache
 621     = aarch64_make_prologue_cache (this_frame, this_cache);
 622
 623   if (!cache->available_p)
 624     *this_id = frame_id_build_unavailable_stack (cache->func);
 625   else
 626     *this_id = frame_id_build (cache->prev_sp, cache->func);
 627 }
 628
 629 /* Implement the "prev_register" frame_unwind method.  */
 630
 631 static struct value *
 632 aarch64_prologue_prev_register (struct frame_info *this_frame,
 633                                 void **this_cache, int prev_regnum)
 634 {
 635   struct aarch64_prologue_cache *cache
 636     = aarch64_make_prologue_cache (this_frame, this_cache);
 637
 638   /* If we are asked to unwind the PC, then we need to return the LR
 639      instead.  The prologue may save PC, but it will point into this
 640      frame's prologue, not the next frame's resume location.  */
 641   if (prev_regnum == AARCH64_PC_REGNUM)
 642     {
 643       CORE_ADDR lr;
 644
 645       lr = frame_unwind_register_unsigned (this_frame, AARCH64_LR_REGNUM);
 646       return frame_unwind_got_constant (this_frame, prev_regnum, lr);
 647     }
 648
 649   /* SP is generally not saved to the stack, but this frame is
 650      identified by the next frame's stack pointer at the time of the
 651      call.  The value was already reconstructed into PREV_SP.  */
 652   /*
 653          +----------+  ^
 654          | saved lr |  |
 655       +->| saved fp |--+
 656       |  |          |
 657       |  |          |     <- Previous SP
 658       |  +----------+
 659       |  | saved lr |
 660       +--| saved fp |<- FP
 661          |          |
 662          |          |<- SP
 663          +----------+  */
 664   if (prev_regnum == AARCH64_SP_REGNUM)
 665     return frame_unwind_got_constant (this_frame, prev_regnum,
 666                                       cache->prev_sp);
 667
 668   return trad_frame_get_prev_register (this_frame, cache->saved_regs,
 669                                        prev_regnum);
 670 }
 671
 672 /* AArch64 prologue unwinder.  */
 673 struct frame_unwind aarch64_prologue_unwind =
 674 {
 675   NORMAL_FRAME,
 676   aarch64_prologue_frame_unwind_stop_reason,
 677   aarch64_prologue_this_id,
 678   aarch64_prologue_prev_register,
 679   NULL,
 680   default_frame_sniffer
 681 };
 682
 683 /* Allocate and fill in *THIS_CACHE with information about the prologue of
 684    *THIS_FRAME.  Do not do this is if *THIS_CACHE was already allocated.
 685    Return a pointer to the current aarch64_prologue_cache in
 686    *THIS_CACHE.  */
 687
 688 static struct aarch64_prologue_cache *
 689 aarch64_make_stub_cache (struct frame_info *this_frame, void **this_cache)
 690 {
 691   struct aarch64_prologue_cache *cache;
 692
 693   if (*this_cache != NULL)
 694     return (struct aarch64_prologue_cache *) *this_cache;
 695
 696   cache = FRAME_OBSTACK_ZALLOC (struct aarch64_prologue_cache);
 697   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 698   *this_cache = cache;
 699
 700   TRY
 701     {
 702       cache->prev_sp = get_frame_register_unsigned (this_frame,
 703                                                     AARCH64_SP_REGNUM);
 704       cache->prev_pc = get_frame_pc (this_frame);
 705       cache->available_p = 1;
 706     }
 707   CATCH (ex, RETURN_MASK_ERROR)
 708     {
 709       if (ex.error != NOT_AVAILABLE_ERROR)
 710         throw_exception (ex);
 711     }
 712   END_CATCH
 713
 714   return cache;
 715 }
 716
 717 /* Implement the "stop_reason" frame_unwind method.  */
 718
 719 static enum unwind_stop_reason
 720 aarch64_stub_frame_unwind_stop_reason (struct frame_info *this_frame,
 721                                        void **this_cache)
 722 {
 723   struct aarch64_prologue_cache *cache
 724     = aarch64_make_stub_cache (this_frame, this_cache);
 725
 726   if (!cache->available_p)
 727     return UNWIND_UNAVAILABLE;
 728
 729   return UNWIND_NO_REASON;
 730 }
 731
 732 /* Our frame ID for a stub frame is the current SP and LR.  */
 733
 734 static void
 735 aarch64_stub_this_id (struct frame_info *this_frame,
 736                       void **this_cache, struct frame_id *this_id)
 737 {
 738   struct aarch64_prologue_cache *cache
 739     = aarch64_make_stub_cache (this_frame, this_cache);
 740
 741   if (cache->available_p)
 742     *this_id = frame_id_build (cache->prev_sp, cache->prev_pc);
 743   else
 744     *this_id = frame_id_build_unavailable_stack (cache->prev_pc);
 745 }
 746
 747 /* Implement the "sniffer" frame_unwind method.  */
 748
 749 static int
 750 aarch64_stub_unwind_sniffer (const struct frame_unwind *self,
 751                              struct frame_info *this_frame,
 752                              void **this_prologue_cache)
 753 {
 754   CORE_ADDR addr_in_block;
 755   gdb_byte dummy[4];
 756
 757   addr_in_block = get_frame_address_in_block (this_frame);
 758   if (in_plt_section (addr_in_block)
 759       /* We also use the stub winder if the target memory is unreadable
 760          to avoid having the prologue unwinder trying to read it.  */
 761       || target_read_memory (get_frame_pc (this_frame), dummy, 4) != 0)
 762     return 1;
 763
 764   return 0;
 765 }
 766
 767 /* AArch64 stub unwinder.  */
 768 struct frame_unwind aarch64_stub_unwind =
 769 {
 770   NORMAL_FRAME,
 771   aarch64_stub_frame_unwind_stop_reason,
 772   aarch64_stub_this_id,
 773   aarch64_prologue_prev_register,
 774   NULL,
 775   aarch64_stub_unwind_sniffer
 776 };
 777
 778 /* Return the frame base address of *THIS_FRAME.  */
 779
 780 static CORE_ADDR
 781 aarch64_normal_frame_base (struct frame_info *this_frame, void **this_cache)
 782 {
 783   struct aarch64_prologue_cache *cache
 784     = aarch64_make_prologue_cache (this_frame, this_cache);
 785
 786   return cache->prev_sp - cache->framesize;
 787 }
 788
 789 /* AArch64 default frame base information.  */
 790 struct frame_base aarch64_normal_base =
 791 {
 792   &aarch64_prologue_unwind,
 793   aarch64_normal_frame_base,
 794   aarch64_normal_frame_base,
 795   aarch64_normal_frame_base
 796 };
 797
 798 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
 799    dummy frame.  The frame ID's base needs to match the TOS value
 800    saved by save_dummy_frame_tos () and returned from
 801    aarch64_push_dummy_call, and the PC needs to match the dummy
 802    frame's breakpoint.  */
 803
 804 static struct frame_id
 805 aarch64_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 806 {
 807   return frame_id_build (get_frame_register_unsigned (this_frame,
 808                                                       AARCH64_SP_REGNUM),
 809                          get_frame_pc (this_frame));
 810 }
 811
 812 /* Implement the "unwind_pc" gdbarch method.  */
 813
 814 static CORE_ADDR
 815 aarch64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
 816 {
 817   CORE_ADDR pc
 818     = frame_unwind_register_unsigned (this_frame, AARCH64_PC_REGNUM);
 819
 820   return pc;
 821 }
 822
 823 /* Implement the "unwind_sp" gdbarch method.  */
 824
 825 static CORE_ADDR
 826 aarch64_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
 827 {
 828   return frame_unwind_register_unsigned (this_frame, AARCH64_SP_REGNUM);
 829 }
 830
 831 /* Return the value of the REGNUM register in the previous frame of
 832    *THIS_FRAME.  */
 833
 834 static struct value *
 835 aarch64_dwarf2_prev_register (struct frame_info *this_frame,
 836                               void **this_cache, int regnum)
 837 {
 838   CORE_ADDR lr;
 839
 840   switch (regnum)
 841     {
 842     case AARCH64_PC_REGNUM:
 843       lr = frame_unwind_register_unsigned (this_frame, AARCH64_LR_REGNUM);
 844       return frame_unwind_got_constant (this_frame, regnum, lr);
 845
 846     default:
 847       internal_error (__FILE__, __LINE__,
 848                       _("Unexpected register %d"), regnum);
 849     }
 850 }
 851
 852 /* Implement the "init_reg" dwarf2_frame_ops method.  */
 853
 854 static void
 855 aarch64_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
 856                                struct dwarf2_frame_state_reg *reg,
 857                                struct frame_info *this_frame)
 858 {
 859   switch (regnum)
 860     {
 861     case AARCH64_PC_REGNUM:
 862       reg->how = DWARF2_FRAME_REG_FN;
 863       reg->loc.fn = aarch64_dwarf2_prev_register;
 864       break;
 865     case AARCH64_SP_REGNUM:
 866       reg->how = DWARF2_FRAME_REG_CFA;
 867       break;
 868     }
 869 }
 870
 871 /* When arguments must be pushed onto the stack, they go on in reverse
 872    order.  The code below implements a FILO (stack) to do this.  */
 873
 874 typedef struct
 875 {
 876   /* Value to pass on stack.  It can be NULL if this item is for stack
 877      padding.  */
 878   const gdb_byte *data;
 879
 880   /* Size in bytes of value to pass on stack.  */
 881   int len;
 882 } stack_item_t;
 883
 884 DEF_VEC_O (stack_item_t);
 885
 886 /* Return the alignment (in bytes) of the given type.  */
 887
 888 static int
 889 aarch64_type_align (struct type *t)
 890 {
 891   int n;
 892   int align;
 893   int falign;
 894
 895   t = check_typedef (t);
 896   switch (TYPE_CODE (t))
 897     {
 898     default:
 899       /* Should never happen.  */
 900       internal_error (__FILE__, __LINE__, _("unknown type alignment"));
 901       return 4;
 902
 903     case TYPE_CODE_PTR:
 904     case TYPE_CODE_ENUM:
 905     case TYPE_CODE_INT:
 906     case TYPE_CODE_FLT:
 907     case TYPE_CODE_SET:
 908     case TYPE_CODE_RANGE:
 909     case TYPE_CODE_BITSTRING:
 910     case TYPE_CODE_REF:
 911     case TYPE_CODE_CHAR:
 912     case TYPE_CODE_BOOL:
 913       return TYPE_LENGTH (t);
 914
 915     case TYPE_CODE_ARRAY:
 916       if (TYPE_VECTOR (t))
 917         {
 918           /* Use the natural alignment for vector types (the same for
 919              scalar type), but the maximum alignment is 128-bit.  */
 920           if (TYPE_LENGTH (t) > 16)
 921             return 16;
 922           else
 923             return TYPE_LENGTH (t);
 924         }
 925       else
 926         return aarch64_type_align (TYPE_TARGET_TYPE (t));
 927     case TYPE_CODE_COMPLEX:
 928       return aarch64_type_align (TYPE_TARGET_TYPE (t));
 929
 930     case TYPE_CODE_STRUCT:
 931     case TYPE_CODE_UNION:
 932       align = 1;
 933       for (n = 0; n < TYPE_NFIELDS (t); n++)
 934         {
 935           falign = aarch64_type_align (TYPE_FIELD_TYPE (t, n));
 936           if (falign > align)
 937             align = falign;
 938         }
 939       return align;
 940     }
 941 }
 942
 943 /* Return 1 if *TY is a homogeneous floating-point aggregate or
 944    homogeneous short-vector aggregate as defined in the AAPCS64 ABI
 945    document; otherwise return 0.  */
 946
 947 static int
 948 is_hfa_or_hva (struct type *ty)
 949 {
 950   switch (TYPE_CODE (ty))
 951     {
 952     case TYPE_CODE_ARRAY:
 953       {
 954         struct type *target_ty = TYPE_TARGET_TYPE (ty);
 955
 956         if (TYPE_VECTOR (ty))
 957           return 0;
 958
 959         if (TYPE_LENGTH (ty) <= 4 /* HFA or HVA has at most 4 members.  */
 960             && (TYPE_CODE (target_ty) == TYPE_CODE_FLT /* HFA */
 961                 || (TYPE_CODE (target_ty) == TYPE_CODE_ARRAY /* HVA */
 962                     && TYPE_VECTOR (target_ty))))
 963           return 1;
 964         break;
 965       }
 966
 967     case TYPE_CODE_UNION:
 968     case TYPE_CODE_STRUCT:
 969       {
 970         /* HFA or HVA has at most four members.  */
 971         if (TYPE_NFIELDS (ty) > 0 && TYPE_NFIELDS (ty) <= 4)
 972           {
 973             struct type *member0_type;
 974
 975             member0_type = check_typedef (TYPE_FIELD_TYPE (ty, 0));
 976             if (TYPE_CODE (member0_type) == TYPE_CODE_FLT
 977                 || (TYPE_CODE (member0_type) == TYPE_CODE_ARRAY
 978                     && TYPE_VECTOR (member0_type)))
 979               {
 980                 int i;
 981
 982                 for (i = 0; i < TYPE_NFIELDS (ty); i++)
 983                   {
 984                     struct type *member1_type;
 985
 986                     member1_type = check_typedef (TYPE_FIELD_TYPE (ty, i));
 987                     if (TYPE_CODE (member0_type) != TYPE_CODE (member1_type)
 988                         || (TYPE_LENGTH (member0_type)
 989                             != TYPE_LENGTH (member1_type)))
 990                       return 0;
 991                   }
 992                 return 1;
 993               }
 994           }
 995         return 0;
 996       }
 997
 998     default:
 999       break;
1000     }
1001
1002   return 0;
1003 }
1004
1005 /* AArch64 function call information structure.  */
1006 struct aarch64_call_info
1007 {
1008   /* the current argument number.  */
1009   unsigned argnum;
1010
1011   /* The next general purpose register number, equivalent to NGRN as
1012      described in the AArch64 Procedure Call Standard.  */
1013   unsigned ngrn;
1014
1015   /* The next SIMD and floating point register number, equivalent to
1016      NSRN as described in the AArch64 Procedure Call Standard.  */
1017   unsigned nsrn;
1018
1019   /* The next stacked argument address, equivalent to NSAA as
1020      described in the AArch64 Procedure Call Standard.  */
1021   unsigned nsaa;
1022
1023   /* Stack item vector.  */
1024   VEC(stack_item_t) *si;
1025 };
1026
1027 /* Pass a value in a sequence of consecutive X registers.  The caller
1028    is responsbile for ensuring sufficient registers are available.  */
1029
1030 static void
1031 pass_in_x (struct gdbarch *gdbarch, struct regcache *regcache,
1032            struct aarch64_call_info *info, struct type *type,
1033            struct value *arg)
1034 {
1035   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1036   int len = TYPE_LENGTH (type);
1037   enum type_code typecode = TYPE_CODE (type);
1038   int regnum = AARCH64_X0_REGNUM + info->ngrn;
1039   const bfd_byte *buf = value_contents (arg);
1040
1041   info->argnum++;
1042
1043   while (len > 0)
1044     {
1045       int partial_len = len < X_REGISTER_SIZE ? len : X_REGISTER_SIZE;
1046       CORE_ADDR regval = extract_unsigned_integer (buf, partial_len,
1047                                                    byte_order);
1048
1049
1050       /* Adjust sub-word struct/union args when big-endian.  */
1051       if (byte_order == BFD_ENDIAN_BIG
1052           && partial_len < X_REGISTER_SIZE
1053           && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
1054         regval <<= ((X_REGISTER_SIZE - partial_len) * TARGET_CHAR_BIT);
1055
1056       if (aarch64_debug)
1057         {
1058           debug_printf ("arg %d in %s = 0x%s\n", info->argnum,
1059                         gdbarch_register_name (gdbarch, regnum),
1060                         phex (regval, X_REGISTER_SIZE));
1061         }
1062       regcache_cooked_write_unsigned (regcache, regnum, regval);
1063       len -= partial_len;
1064       buf += partial_len;
1065       regnum++;
1066     }
1067 }
1068
1069 /* Attempt to marshall a value in a V register.  Return 1 if
1070    successful, or 0 if insufficient registers are available.  This
1071    function, unlike the equivalent pass_in_x() function does not
1072    handle arguments spread across multiple registers.  */
1073
1074 static int
1075 pass_in_v (struct gdbarch *gdbarch,
1076            struct regcache *regcache,
1077            struct aarch64_call_info *info,
1078            int len, const bfd_byte *buf)
1079 {
1080   if (info->nsrn < 8)
1081     {
1082       int regnum = AARCH64_V0_REGNUM + info->nsrn;
1083       gdb_byte reg[V_REGISTER_SIZE];
1084
1085       info->argnum++;
1086       info->nsrn++;
1087
1088       memset (reg, 0, sizeof (reg));
1089       /* PCS C.1, the argument is allocated to the least significant
1090          bits of V register.  */
1091       memcpy (reg, buf, len);
1092       regcache_cooked_write (regcache, regnum, reg);
1093
1094       if (aarch64_debug)
1095         {
1096           debug_printf ("arg %d in %s\n", info->argnum,
1097                         gdbarch_register_name (gdbarch, regnum));
1098         }
1099       return 1;
1100     }
1101   info->nsrn = 8;
1102   return 0;
1103 }
1104
1105 /* Marshall an argument onto the stack.  */
1106
1107 static void
1108 pass_on_stack (struct aarch64_call_info *info, struct type *type,
1109                struct value *arg)
1110 {
1111   const bfd_byte *buf = value_contents (arg);
1112   int len = TYPE_LENGTH (type);
1113   int align;
1114   stack_item_t item;
1115
1116   info->argnum++;
1117
1118   align = aarch64_type_align (type);
1119
1120   /* PCS C.17 Stack should be aligned to the larger of 8 bytes or the
1121      Natural alignment of the argument's type.  */
1122   align = align_up (align, 8);
1123
1124   /* The AArch64 PCS requires at most doubleword alignment.  */
1125   if (align > 16)
1126     align = 16;
1127
1128   if (aarch64_debug)
1129     {
1130       debug_printf ("arg %d len=%d @ sp + %d\n", info->argnum, len,
1131                     info->nsaa);
1132     }
1133
1134   item.len = len;
1135   item.data = buf;
1136   VEC_safe_push (stack_item_t, info->si, &item);
1137
1138   info->nsaa += len;
1139   if (info->nsaa & (align - 1))
1140     {
1141       /* Push stack alignment padding.  */
1142       int pad = align - (info->nsaa & (align - 1));
1143
1144       item.len = pad;
1145       item.data = NULL;
1146
1147       VEC_safe_push (stack_item_t, info->si, &item);
1148       info->nsaa += pad;
1149     }
1150 }
1151
1152 /* Marshall an argument into a sequence of one or more consecutive X
1153    registers or, if insufficient X registers are available then onto
1154    the stack.  */
1155
1156 static void
1157 pass_in_x_or_stack (struct gdbarch *gdbarch, struct regcache *regcache,
1158                     struct aarch64_call_info *info, struct type *type,
1159                     struct value *arg)
1160 {
1161   int len = TYPE_LENGTH (type);
1162   int nregs = (len + X_REGISTER_SIZE - 1) / X_REGISTER_SIZE;
1163
1164   /* PCS C.13 - Pass in registers if we have enough spare */
1165   if (info->ngrn + nregs <= 8)
1166     {
1167       pass_in_x (gdbarch, regcache, info, type, arg);
1168       info->ngrn += nregs;
1169     }
1170   else
1171     {
1172       info->ngrn = 8;
1173       pass_on_stack (info, type, arg);
1174     }
1175 }
1176
1177 /* Pass a value in a V register, or on the stack if insufficient are
1178    available.  */
1179
1180 static void
1181 pass_in_v_or_stack (struct gdbarch *gdbarch,
1182                     struct regcache *regcache,
1183                     struct aarch64_call_info *info,
1184                     struct type *type,
1185                     struct value *arg)
1186 {
1187   if (!pass_in_v (gdbarch, regcache, info, TYPE_LENGTH (type),
1188                   value_contents (arg)))
1189     pass_on_stack (info, type, arg);
1190 }
1191
1192 /* Implement the "push_dummy_call" gdbarch method.  */
1193
1194 static CORE_ADDR
1195 aarch64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1196                          struct regcache *regcache, CORE_ADDR bp_addr,
1197                          int nargs,
1198                          struct value **args, CORE_ADDR sp, int struct_return,
1199                          CORE_ADDR struct_addr)
1200 {
1201   int argnum;
1202   struct aarch64_call_info info;
1203   struct type *func_type;
1204   struct type *return_type;
1205   int lang_struct_return;
1206
1207   memset (&info, 0, sizeof (info));
1208
1209   /* We need to know what the type of the called function is in order
1210      to determine the number of named/anonymous arguments for the
1211      actual argument placement, and the return type in order to handle
1212      return value correctly.
1213
1214      The generic code above us views the decision of return in memory
1215      or return in registers as a two stage processes.  The language
1216      handler is consulted first and may decide to return in memory (eg
1217      class with copy constructor returned by value), this will cause
1218      the generic code to allocate space AND insert an initial leading
1219      argument.
1220
1221      If the language code does not decide to pass in memory then the
1222      target code is consulted.
1223
1224      If the language code decides to pass in memory we want to move
1225      the pointer inserted as the initial argument from the argument
1226      list and into X8, the conventional AArch64 struct return pointer
1227      register.
1228
1229      This is slightly awkward, ideally the flag "lang_struct_return"
1230      would be passed to the targets implementation of push_dummy_call.
1231      Rather that change the target interface we call the language code
1232      directly ourselves.  */
1233
1234   func_type = check_typedef (value_type (function));
1235
1236   /* Dereference function pointer types.  */
1237   if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
1238     func_type = TYPE_TARGET_TYPE (func_type);
1239
1240   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
1241               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
1242
1243   /* If language_pass_by_reference () returned true we will have been
1244      given an additional initial argument, a hidden pointer to the
1245      return slot in memory.  */
1246   return_type = TYPE_TARGET_TYPE (func_type);
1247   lang_struct_return = language_pass_by_reference (return_type);
1248
1249   /* Set the return address.  For the AArch64, the return breakpoint
1250      is always at BP_ADDR.  */
1251   regcache_cooked_write_unsigned (regcache, AARCH64_LR_REGNUM, bp_addr);
1252
1253   /* If we were given an initial argument for the return slot because
1254      lang_struct_return was true, lose it.  */
1255   if (lang_struct_return)
1256     {
1257       args++;
1258       nargs--;
1259     }
1260
1261   /* The struct_return pointer occupies X8.  */
1262   if (struct_return || lang_struct_return)
1263     {
1264       if (aarch64_debug)
1265         {
1266           debug_printf ("struct return in %s = 0x%s\n",
1267                         gdbarch_register_name (gdbarch,
1268                                                AARCH64_STRUCT_RETURN_REGNUM),
1269                         paddress (gdbarch, struct_addr));
1270         }
1271       regcache_cooked_write_unsigned (regcache, AARCH64_STRUCT_RETURN_REGNUM,
1272                                       struct_addr);
1273     }
1274
1275   for (argnum = 0; argnum < nargs; argnum++)
1276     {
1277       struct value *arg = args[argnum];
1278       struct type *arg_type;
1279       int len;
1280
1281       arg_type = check_typedef (value_type (arg));
1282       len = TYPE_LENGTH (arg_type);
1283
1284       switch (TYPE_CODE (arg_type))
1285         {
1286         case TYPE_CODE_INT:
1287         case TYPE_CODE_BOOL:
1288         case TYPE_CODE_CHAR:
1289         case TYPE_CODE_RANGE:
1290         case TYPE_CODE_ENUM:
1291           if (len < 4)
1292             {
1293               /* Promote to 32 bit integer.  */
1294               if (TYPE_UNSIGNED (arg_type))
1295                 arg_type = builtin_type (gdbarch)->builtin_uint32;
1296               else
1297                 arg_type = builtin_type (gdbarch)->builtin_int32;
1298               arg = value_cast (arg_type, arg);
1299             }
1300           pass_in_x_or_stack (gdbarch, regcache, &info, arg_type, arg);
1301           break;
1302
1303         case TYPE_CODE_COMPLEX:
1304           if (info.nsrn <= 6)
1305             {
1306               const bfd_byte *buf = value_contents (arg);
1307               struct type *target_type =
1308                 check_typedef (TYPE_TARGET_TYPE (arg_type));
1309
1310               pass_in_v (gdbarch, regcache, &info,
1311                          TYPE_LENGTH (target_type), buf);
1312               pass_in_v (gdbarch, regcache, &info,
1313                          TYPE_LENGTH (target_type),
1314                          buf + TYPE_LENGTH (target_type));
1315             }
1316           else
1317             {
1318               info.nsrn = 8;
1319               pass_on_stack (&info, arg_type, arg);
1320             }
1321           break;
1322         case TYPE_CODE_FLT:
1323           pass_in_v_or_stack (gdbarch, regcache, &info, arg_type, arg);
1324           break;
1325
1326         case TYPE_CODE_STRUCT:
1327         case TYPE_CODE_ARRAY:
1328         case TYPE_CODE_UNION:
1329           if (is_hfa_or_hva (arg_type))
1330             {
1331               int elements = TYPE_NFIELDS (arg_type);
1332
1333               /* Homogeneous Aggregates */
1334               if (info.nsrn + elements < 8)
1335                 {
1336                   int i;
1337
1338                   for (i = 0; i < elements; i++)
1339                     {
1340                       /* We know that we have sufficient registers
1341                          available therefore this will never fallback
1342                          to the stack.  */
1343                       struct value *field =
1344                         value_primitive_field (arg, 0, i, arg_type);
1345                       struct type *field_type =
1346                         check_typedef (value_type (field));
1347
1348                       pass_in_v_or_stack (gdbarch, regcache, &info,
1349                                           field_type, field);
1350                     }
1351                 }
1352               else
1353                 {
1354                   info.nsrn = 8;
1355                   pass_on_stack (&info, arg_type, arg);
1356                 }
1357             }
1358           else if (TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
1359                    && TYPE_VECTOR (arg_type) && (len == 16 || len == 8))
1360             {
1361               /* Short vector types are passed in V registers.  */
1362               pass_in_v_or_stack (gdbarch, regcache, &info, arg_type, arg);
1363             }
1364           else if (len > 16)
1365             {
1366               /* PCS B.7 Aggregates larger than 16 bytes are passed by
1367                  invisible reference.  */
1368
1369               /* Allocate aligned storage.  */
1370               sp = align_down (sp - len, 16);
1371
1372               /* Write the real data into the stack.  */
1373               write_memory (sp, value_contents (arg), len);
1374
1375               /* Construct the indirection.  */
1376               arg_type = lookup_pointer_type (arg_type);
1377               arg = value_from_pointer (arg_type, sp);
1378               pass_in_x_or_stack (gdbarch, regcache, &info, arg_type, arg);
1379             }
1380           else
1381             /* PCS C.15 / C.18 multiple values pass.  */
1382             pass_in_x_or_stack (gdbarch, regcache, &info, arg_type, arg);
1383           break;
1384
1385         default:
1386           pass_in_x_or_stack (gdbarch, regcache, &info, arg_type, arg);
1387           break;
1388         }
1389     }
1390
1391   /* Make sure stack retains 16 byte alignment.  */
1392   if (info.nsaa & 15)
1393     sp -= 16 - (info.nsaa & 15);
1394
1395   while (!VEC_empty (stack_item_t, info.si))
1396     {
1397       stack_item_t *si = VEC_last (stack_item_t, info.si);
1398
1399       sp -= si->len;
1400       if (si->data != NULL)
1401         write_memory (sp, si->data, si->len);
1402       VEC_pop (stack_item_t, info.si);
1403     }
1404
1405   VEC_free (stack_item_t, info.si);
1406
1407   /* Finally, update the SP register.  */
1408   regcache_cooked_write_unsigned (regcache, AARCH64_SP_REGNUM, sp);
1409
1410   return sp;
1411 }
1412
1413 /* Implement the "frame_align" gdbarch method.  */
1414
1415 static CORE_ADDR
1416 aarch64_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
1417 {
1418   /* Align the stack to sixteen bytes.  */
1419   return sp & ~(CORE_ADDR) 15;
1420 }
1421
1422 /* Return the type for an AdvSISD Q register.  */
1423
1424 static struct type *
1425 aarch64_vnq_type (struct gdbarch *gdbarch)
1426 {
1427   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1428
1429   if (tdep->vnq_type == NULL)
1430     {
1431       struct type *t;
1432       struct type *elem;
1433
1434       t = arch_composite_type (gdbarch, "__gdb_builtin_type_vnq",
1435                                TYPE_CODE_UNION);
1436
1437       elem = builtin_type (gdbarch)->builtin_uint128;
1438       append_composite_type_field (t, "u", elem);
1439
1440       elem = builtin_type (gdbarch)->builtin_int128;
1441       append_composite_type_field (t, "s", elem);
1442
1443       tdep->vnq_type = t;
1444     }
1445
1446   return tdep->vnq_type;
1447 }
1448
1449 /* Return the type for an AdvSISD D register.  */
1450
1451 static struct type *
1452 aarch64_vnd_type (struct gdbarch *gdbarch)
1453 {
1454   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1455
1456   if (tdep->vnd_type == NULL)
1457     {
1458       struct type *t;
1459       struct type *elem;
1460
1461       t = arch_composite_type (gdbarch, "__gdb_builtin_type_vnd",
1462                                TYPE_CODE_UNION);
1463
1464       elem = builtin_type (gdbarch)->builtin_double;
1465       append_composite_type_field (t, "f", elem);
1466
1467       elem = builtin_type (gdbarch)->builtin_uint64;
1468       append_composite_type_field (t, "u", elem);
1469
1470       elem = builtin_type (gdbarch)->builtin_int64;
1471       append_composite_type_field (t, "s", elem);
1472
1473       tdep->vnd_type = t;
1474     }
1475
1476   return tdep->vnd_type;
1477 }
1478
1479 /* Return the type for an AdvSISD S register.  */
1480
1481 static struct type *
1482 aarch64_vns_type (struct gdbarch *gdbarch)
1483 {
1484   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1485
1486   if (tdep->vns_type == NULL)
1487     {
1488       struct type *t;
1489       struct type *elem;
1490
1491       t = arch_composite_type (gdbarch, "__gdb_builtin_type_vns",
1492                                TYPE_CODE_UNION);
1493
1494       elem = builtin_type (gdbarch)->builtin_float;
1495       append_composite_type_field (t, "f", elem);
1496
1497       elem = builtin_type (gdbarch)->builtin_uint32;
1498       append_composite_type_field (t, "u", elem);
1499
1500       elem = builtin_type (gdbarch)->builtin_int32;
1501       append_composite_type_field (t, "s", elem);
1502
1503       tdep->vns_type = t;
1504     }
1505
1506   return tdep->vns_type;
1507 }
1508
1509 /* Return the type for an AdvSISD H register.  */
1510
1511 static struct type *
1512 aarch64_vnh_type (struct gdbarch *gdbarch)
1513 {
1514   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1515
1516   if (tdep->vnh_type == NULL)
1517     {
1518       struct type *t;
1519       struct type *elem;
1520
1521       t = arch_composite_type (gdbarch, "__gdb_builtin_type_vnh",
1522                                TYPE_CODE_UNION);
1523
1524       elem = builtin_type (gdbarch)->builtin_uint16;
1525       append_composite_type_field (t, "u", elem);
1526
1527       elem = builtin_type (gdbarch)->builtin_int16;
1528       append_composite_type_field (t, "s", elem);
1529
1530       tdep->vnh_type = t;
1531     }
1532
1533   return tdep->vnh_type;
1534 }
1535
1536 /* Return the type for an AdvSISD B register.  */
1537
1538 static struct type *
1539 aarch64_vnb_type (struct gdbarch *gdbarch)
1540 {
1541   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1542
1543   if (tdep->vnb_type == NULL)
1544     {
1545       struct type *t;
1546       struct type *elem;
1547
1548       t = arch_composite_type (gdbarch, "__gdb_builtin_type_vnb",
1549                                TYPE_CODE_UNION);
1550
1551       elem = builtin_type (gdbarch)->builtin_uint8;
1552       append_composite_type_field (t, "u", elem);
1553
1554       elem = builtin_type (gdbarch)->builtin_int8;
1555       append_composite_type_field (t, "s", elem);
1556
1557       tdep->vnb_type = t;
1558     }
1559
1560   return tdep->vnb_type;
1561 }
1562
1563 /* Implement the "dwarf2_reg_to_regnum" gdbarch method.  */
1564
1565 static int
1566 aarch64_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
1567 {
1568   if (reg >= AARCH64_DWARF_X0 && reg <= AARCH64_DWARF_X0 + 30)
1569     return AARCH64_X0_REGNUM + reg - AARCH64_DWARF_X0;
1570
1571   if (reg == AARCH64_DWARF_SP)
1572     return AARCH64_SP_REGNUM;
1573
1574   if (reg >= AARCH64_DWARF_V0 && reg <= AARCH64_DWARF_V0 + 31)
1575     return AARCH64_V0_REGNUM + reg - AARCH64_DWARF_V0;
1576
1577   return -1;
1578 }
1579 \f
1580
1581 /* Implement the "print_insn" gdbarch method.  */
1582
1583 static int
1584 aarch64_gdb_print_insn (bfd_vma memaddr, disassemble_info *info)
1585 {
1586   info->symbols = NULL;
1587   return print_insn_aarch64 (memaddr, info);
1588 }
1589
1590 /* AArch64 BRK software debug mode instruction.
1591    Note that AArch64 code is always little-endian.
1592    1101.0100.0010.0000.0000.0000.0000.0000 = 0xd4200000.  */
1593 static const gdb_byte aarch64_default_breakpoint[] = {0x00, 0x00, 0x20, 0xd4};
1594
1595 GDBARCH_BREAKPOINT_MANIPULATION (aarch64, aarch64_default_breakpoint)
1596
1597 /* Extract from an array REGS containing the (raw) register state a
1598    function return value of type TYPE, and copy that, in virtual
1599    format, into VALBUF.  */
1600
1601 static void
1602 aarch64_extract_return_value (struct type *type, struct regcache *regs,
1603                               gdb_byte *valbuf)
1604 {
1605   struct gdbarch *gdbarch = get_regcache_arch (regs);
1606   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1607
1608   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1609     {
1610       bfd_byte buf[V_REGISTER_SIZE];
1611       int len = TYPE_LENGTH (type);
1612
1613       regcache_cooked_read (regs, AARCH64_V0_REGNUM, buf);
1614       memcpy (valbuf, buf, len);
1615     }
1616   else if (TYPE_CODE (type) == TYPE_CODE_INT
1617            || TYPE_CODE (type) == TYPE_CODE_CHAR
1618            || TYPE_CODE (type) == TYPE_CODE_BOOL
1619            || TYPE_CODE (type) == TYPE_CODE_PTR
1620            || TYPE_CODE (type) == TYPE_CODE_REF
1621            || TYPE_CODE (type) == TYPE_CODE_ENUM)
1622     {
1623       /* If the the type is a plain integer, then the access is
1624          straight-forward.  Otherwise we have to play around a bit
1625          more.  */
1626       int len = TYPE_LENGTH (type);
1627       int regno = AARCH64_X0_REGNUM;
1628       ULONGEST tmp;
1629
1630       while (len > 0)
1631         {
1632           /* By using store_unsigned_integer we avoid having to do
1633              anything special for small big-endian values.  */
1634           regcache_cooked_read_unsigned (regs, regno++, &tmp);
1635           store_unsigned_integer (valbuf,
1636                                   (len > X_REGISTER_SIZE
1637                                    ? X_REGISTER_SIZE : len), byte_order, tmp);
1638           len -= X_REGISTER_SIZE;
1639           valbuf += X_REGISTER_SIZE;
1640         }
1641     }
1642   else if (TYPE_CODE (type) == TYPE_CODE_COMPLEX)
1643     {
1644       int regno = AARCH64_V0_REGNUM;
1645       bfd_byte buf[V_REGISTER_SIZE];
1646       struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1647       int len = TYPE_LENGTH (target_type);
1648
1649       regcache_cooked_read (regs, regno, buf);
1650       memcpy (valbuf, buf, len);
1651       valbuf += len;
1652       regcache_cooked_read (regs, regno + 1, buf);
1653       memcpy (valbuf, buf, len);
1654       valbuf += len;
1655     }
1656   else if (is_hfa_or_hva (type))
1657     {
1658       int elements = TYPE_NFIELDS (type);
1659       struct type *member_type = check_typedef (TYPE_FIELD_TYPE (type, 0));
1660       int len = TYPE_LENGTH (member_type);
1661       int i;
1662
1663       for (i = 0; i < elements; i++)
1664         {
1665           int regno = AARCH64_V0_REGNUM + i;
1666           bfd_byte buf[V_REGISTER_SIZE];
1667
1668           if (aarch64_debug)
1669             {
1670               debug_printf ("read HFA or HVA return value element %d from %s\n",
1671                             i + 1,
1672                             gdbarch_register_name (gdbarch, regno));
1673             }
1674           regcache_cooked_read (regs, regno, buf);
1675
1676           memcpy (valbuf, buf, len);
1677           valbuf += len;
1678         }
1679     }
1680   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
1681            && (TYPE_LENGTH (type) == 16 || TYPE_LENGTH (type) == 8))
1682     {
1683       /* Short vector is returned in V register.  */
1684       gdb_byte buf[V_REGISTER_SIZE];
1685
1686       regcache_cooked_read (regs, AARCH64_V0_REGNUM, buf);
1687       memcpy (valbuf, buf, TYPE_LENGTH (type));
1688     }
1689   else
1690     {
1691       /* For a structure or union the behaviour is as if the value had
1692          been stored to word-aligned memory and then loaded into
1693          registers with 64-bit load instruction(s).  */
1694       int len = TYPE_LENGTH (type);
1695       int regno = AARCH64_X0_REGNUM;
1696       bfd_byte buf[X_REGISTER_SIZE];
1697
1698       while (len > 0)
1699         {
1700           regcache_cooked_read (regs, regno++, buf);
1701           memcpy (valbuf, buf, len > X_REGISTER_SIZE ? X_REGISTER_SIZE : len);
1702           len -= X_REGISTER_SIZE;
1703           valbuf += X_REGISTER_SIZE;
1704         }
1705     }
1706 }
1707
1708
1709 /* Will a function return an aggregate type in memory or in a
1710    register?  Return 0 if an aggregate type can be returned in a
1711    register, 1 if it must be returned in memory.  */
1712
1713 static int
1714 aarch64_return_in_memory (struct gdbarch *gdbarch, struct type *type)
1715 {
1716   type = check_typedef (type);
1717
1718   if (is_hfa_or_hva (type))
1719     {
1720       /* v0-v7 are used to return values and one register is allocated
1721          for one member.  However, HFA or HVA has at most four members.  */
1722       return 0;
1723     }
1724
1725   if (TYPE_LENGTH (type) > 16)
1726     {
1727       /* PCS B.6 Aggregates larger than 16 bytes are passed by
1728          invisible reference.  */
1729
1730       return 1;
1731     }
1732
1733   return 0;
1734 }
1735
1736 /* Write into appropriate registers a function return value of type
1737    TYPE, given in virtual format.  */
1738
1739 static void
1740 aarch64_store_return_value (struct type *type, struct regcache *regs,
1741                             const gdb_byte *valbuf)
1742 {
1743   struct gdbarch *gdbarch = get_regcache_arch (regs);
1744   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1745
1746   if (TYPE_CODE (type) == TYPE_CODE_FLT)
1747     {
1748       bfd_byte buf[V_REGISTER_SIZE];
1749       int len = TYPE_LENGTH (type);
1750
1751       memcpy (buf, valbuf, len > V_REGISTER_SIZE ? V_REGISTER_SIZE : len);
1752       regcache_cooked_write (regs, AARCH64_V0_REGNUM, buf);
1753     }
1754   else if (TYPE_CODE (type) == TYPE_CODE_INT
1755            || TYPE_CODE (type) == TYPE_CODE_CHAR
1756            || TYPE_CODE (type) == TYPE_CODE_BOOL
1757            || TYPE_CODE (type) == TYPE_CODE_PTR
1758            || TYPE_CODE (type) == TYPE_CODE_REF
1759            || TYPE_CODE (type) == TYPE_CODE_ENUM)
1760     {
1761       if (TYPE_LENGTH (type) <= X_REGISTER_SIZE)
1762         {
1763           /* Values of one word or less are zero/sign-extended and
1764              returned in r0.  */
1765           bfd_byte tmpbuf[X_REGISTER_SIZE];
1766           LONGEST val = unpack_long (type, valbuf);
1767
1768           store_signed_integer (tmpbuf, X_REGISTER_SIZE, byte_order, val);
1769           regcache_cooked_write (regs, AARCH64_X0_REGNUM, tmpbuf);
1770         }
1771       else
1772         {
1773           /* Integral values greater than one word are stored in
1774              consecutive registers starting with r0.  This will always
1775              be a multiple of the regiser size.  */
1776           int len = TYPE_LENGTH (type);
1777           int regno = AARCH64_X0_REGNUM;
1778
1779           while (len > 0)
1780             {
1781               regcache_cooked_write (regs, regno++, valbuf);
1782               len -= X_REGISTER_SIZE;
1783               valbuf += X_REGISTER_SIZE;
1784             }
1785         }
1786     }
1787   else if (is_hfa_or_hva (type))
1788     {
1789       int elements = TYPE_NFIELDS (type);
1790       struct type *member_type = check_typedef (TYPE_FIELD_TYPE (type, 0));
1791       int len = TYPE_LENGTH (member_type);
1792       int i;
1793
1794       for (i = 0; i < elements; i++)
1795         {
1796           int regno = AARCH64_V0_REGNUM + i;
1797           bfd_byte tmpbuf[MAX_REGISTER_SIZE];
1798
1799           if (aarch64_debug)
1800             {
1801               debug_printf ("write HFA or HVA return value element %d to %s\n",
1802                             i + 1,
1803                             gdbarch_register_name (gdbarch, regno));
1804             }
1805
1806           memcpy (tmpbuf, valbuf, len);
1807           regcache_cooked_write (regs, regno, tmpbuf);
1808           valbuf += len;
1809         }
1810     }
1811   else if (TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
1812            && (TYPE_LENGTH (type) == 8 || TYPE_LENGTH (type) == 16))
1813     {
1814       /* Short vector.  */
1815       gdb_byte buf[V_REGISTER_SIZE];
1816
1817       memcpy (buf, valbuf, TYPE_LENGTH (type));
1818       regcache_cooked_write (regs, AARCH64_V0_REGNUM, buf);
1819     }
1820   else
1821     {
1822       /* For a structure or union the behaviour is as if the value had
1823          been stored to word-aligned memory and then loaded into
1824          registers with 64-bit load instruction(s).  */
1825       int len = TYPE_LENGTH (type);
1826       int regno = AARCH64_X0_REGNUM;
1827       bfd_byte tmpbuf[X_REGISTER_SIZE];
1828
1829       while (len > 0)
1830         {
1831           memcpy (tmpbuf, valbuf,
1832                   len > X_REGISTER_SIZE ? X_REGISTER_SIZE : len);
1833           regcache_cooked_write (regs, regno++, tmpbuf);
1834           len -= X_REGISTER_SIZE;
1835           valbuf += X_REGISTER_SIZE;
1836         }
1837     }
1838 }
1839
1840 /* Implement the "return_value" gdbarch method.  */
1841
1842 static enum return_value_convention
1843 aarch64_return_value (struct gdbarch *gdbarch, struct value *func_value,
1844                       struct type *valtype, struct regcache *regcache,
1845                       gdb_byte *readbuf, const gdb_byte *writebuf)
1846 {
1847
1848   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
1849       || TYPE_CODE (valtype) == TYPE_CODE_UNION
1850       || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
1851     {
1852       if (aarch64_return_in_memory (gdbarch, valtype))
1853         {
1854           if (aarch64_debug)
1855             debug_printf ("return value in memory\n");
1856           return RETURN_VALUE_STRUCT_CONVENTION;
1857         }
1858     }
1859
1860   if (writebuf)
1861     aarch64_store_return_value (valtype, regcache, writebuf);
1862
1863   if (readbuf)
1864     aarch64_extract_return_value (valtype, regcache, readbuf);
1865
1866   if (aarch64_debug)
1867     debug_printf ("return value in registers\n");
1868
1869   return RETURN_VALUE_REGISTER_CONVENTION;
1870 }
1871
1872 /* Implement the "get_longjmp_target" gdbarch method.  */
1873
1874 static int
1875 aarch64_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1876 {
1877   CORE_ADDR jb_addr;
1878   gdb_byte buf[X_REGISTER_SIZE];
1879   struct gdbarch *gdbarch = get_frame_arch (frame);
1880   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1881   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1882
1883   jb_addr = get_frame_register_unsigned (frame, AARCH64_X0_REGNUM);
1884
1885   if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
1886                           X_REGISTER_SIZE))
1887     return 0;
1888
1889   *pc = extract_unsigned_integer (buf, X_REGISTER_SIZE, byte_order);
1890   return 1;
1891 }
1892
1893 /* Implement the "gen_return_address" gdbarch method.  */
1894
1895 static void
1896 aarch64_gen_return_address (struct gdbarch *gdbarch,
1897                             struct agent_expr *ax, struct axs_value *value,
1898                             CORE_ADDR scope)
1899 {
1900   value->type = register_type (gdbarch, AARCH64_LR_REGNUM);
1901   value->kind = axs_lvalue_register;
1902   value->u.reg = AARCH64_LR_REGNUM;
1903 }
1904 \f
1905
1906 /* Return the pseudo register name corresponding to register regnum.  */
1907
1908 static const char *
1909 aarch64_pseudo_register_name (struct gdbarch *gdbarch, int regnum)
1910 {
1911   static const char *const q_name[] =
1912     {
1913       "q0", "q1", "q2", "q3",
1914       "q4", "q5", "q6", "q7",
1915       "q8", "q9", "q10", "q11",
1916       "q12", "q13", "q14", "q15",
1917       "q16", "q17", "q18", "q19",
1918       "q20", "q21", "q22", "q23",
1919       "q24", "q25", "q26", "q27",
1920       "q28", "q29", "q30", "q31",
1921     };
1922
1923   static const char *const d_name[] =
1924     {
1925       "d0", "d1", "d2", "d3",
1926       "d4", "d5", "d6", "d7",
1927       "d8", "d9", "d10", "d11",
1928       "d12", "d13", "d14", "d15",
1929       "d16", "d17", "d18", "d19",
1930       "d20", "d21", "d22", "d23",
1931       "d24", "d25", "d26", "d27",
1932       "d28", "d29", "d30", "d31",
1933     };
1934
1935   static const char *const s_name[] =
1936     {
1937       "s0", "s1", "s2", "s3",
1938       "s4", "s5", "s6", "s7",
1939       "s8", "s9", "s10", "s11",
1940       "s12", "s13", "s14", "s15",
1941       "s16", "s17", "s18", "s19",
1942       "s20", "s21", "s22", "s23",
1943       "s24", "s25", "s26", "s27",
1944       "s28", "s29", "s30", "s31",
1945     };
1946
1947   static const char *const h_name[] =
1948     {
1949       "h0", "h1", "h2", "h3",
1950       "h4", "h5", "h6", "h7",
1951       "h8", "h9", "h10", "h11",
1952       "h12", "h13", "h14", "h15",
1953       "h16", "h17", "h18", "h19",
1954       "h20", "h21", "h22", "h23",
1955       "h24", "h25", "h26", "h27",
1956       "h28", "h29", "h30", "h31",
1957     };
1958
1959   static const char *const b_name[] =
1960     {
1961       "b0", "b1", "b2", "b3",
1962       "b4", "b5", "b6", "b7",
1963       "b8", "b9", "b10", "b11",
1964       "b12", "b13", "b14", "b15",
1965       "b16", "b17", "b18", "b19",
1966       "b20", "b21", "b22", "b23",
1967       "b24", "b25", "b26", "b27",
1968       "b28", "b29", "b30", "b31",
1969     };
1970
1971   regnum -= gdbarch_num_regs (gdbarch);
1972
1973   if (regnum >= AARCH64_Q0_REGNUM && regnum < AARCH64_Q0_REGNUM + 32)
1974     return q_name[regnum - AARCH64_Q0_REGNUM];
1975
1976   if (regnum >= AARCH64_D0_REGNUM && regnum < AARCH64_D0_REGNUM + 32)
1977     return d_name[regnum - AARCH64_D0_REGNUM];
1978
1979   if (regnum >= AARCH64_S0_REGNUM && regnum < AARCH64_S0_REGNUM + 32)
1980     return s_name[regnum - AARCH64_S0_REGNUM];
1981
1982   if (regnum >= AARCH64_H0_REGNUM && regnum < AARCH64_H0_REGNUM + 32)
1983     return h_name[regnum - AARCH64_H0_REGNUM];
1984
1985   if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32)
1986     return b_name[regnum - AARCH64_B0_REGNUM];
1987
1988   internal_error (__FILE__, __LINE__,
1989                   _("aarch64_pseudo_register_name: bad register number %d"),
1990                   regnum);
1991 }
1992
1993 /* Implement the "pseudo_register_type" tdesc_arch_data method.  */
1994
1995 static struct type *
1996 aarch64_pseudo_register_type (struct gdbarch *gdbarch, int regnum)
1997 {
1998   regnum -= gdbarch_num_regs (gdbarch);
1999
2000   if (regnum >= AARCH64_Q0_REGNUM && regnum < AARCH64_Q0_REGNUM + 32)
2001     return aarch64_vnq_type (gdbarch);
2002
2003   if (regnum >= AARCH64_D0_REGNUM && regnum < AARCH64_D0_REGNUM + 32)
2004     return aarch64_vnd_type (gdbarch);
2005
2006   if (regnum >= AARCH64_S0_REGNUM && regnum < AARCH64_S0_REGNUM + 32)
2007     return aarch64_vns_type (gdbarch);
2008
2009   if (regnum >= AARCH64_H0_REGNUM && regnum < AARCH64_H0_REGNUM + 32)
2010     return aarch64_vnh_type (gdbarch);
2011
2012   if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32)
2013     return aarch64_vnb_type (gdbarch);
2014
2015   internal_error (__FILE__, __LINE__,
2016                   _("aarch64_pseudo_register_type: bad register number %d"),
2017                   regnum);
2018 }
2019
2020 /* Implement the "pseudo_register_reggroup_p" tdesc_arch_data method.  */
2021
2022 static int
2023 aarch64_pseudo_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
2024                                     struct reggroup *group)
2025 {
2026   regnum -= gdbarch_num_regs (gdbarch);
2027
2028   if (regnum >= AARCH64_Q0_REGNUM && regnum < AARCH64_Q0_REGNUM + 32)
2029     return group == all_reggroup || group == vector_reggroup;
2030   else if (regnum >= AARCH64_D0_REGNUM && regnum < AARCH64_D0_REGNUM + 32)
2031     return (group == all_reggroup || group == vector_reggroup
2032             || group == float_reggroup);
2033   else if (regnum >= AARCH64_S0_REGNUM && regnum < AARCH64_S0_REGNUM + 32)
2034     return (group == all_reggroup || group == vector_reggroup
2035             || group == float_reggroup);
2036   else if (regnum >= AARCH64_H0_REGNUM && regnum < AARCH64_H0_REGNUM + 32)
2037     return group == all_reggroup || group == vector_reggroup;
2038   else if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32)
2039     return group == all_reggroup || group == vector_reggroup;
2040
2041   return group == all_reggroup;
2042 }
2043
2044 /* Implement the "pseudo_register_read_value" gdbarch method.  */
2045
2046 static struct value *
2047 aarch64_pseudo_read_value (struct gdbarch *gdbarch,
2048                            struct regcache *regcache,
2049                            int regnum)
2050 {
2051   gdb_byte reg_buf[MAX_REGISTER_SIZE];
2052   struct value *result_value;
2053   gdb_byte *buf;
2054
2055   result_value = allocate_value (register_type (gdbarch, regnum));
2056   VALUE_LVAL (result_value) = lval_register;
2057   VALUE_REGNUM (result_value) = regnum;
2058   buf = value_contents_raw (result_value);
2059
2060   regnum -= gdbarch_num_regs (gdbarch);
2061
2062   if (regnum >= AARCH64_Q0_REGNUM && regnum < AARCH64_Q0_REGNUM + 32)
2063     {
2064       enum register_status status;
2065       unsigned v_regnum;
2066
2067       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_Q0_REGNUM;
2068       status = regcache_raw_read (regcache, v_regnum, reg_buf);
2069       if (status != REG_VALID)
2070         mark_value_bytes_unavailable (result_value, 0,
2071                                       TYPE_LENGTH (value_type (result_value)));
2072       else
2073         memcpy (buf, reg_buf, Q_REGISTER_SIZE);
2074       return result_value;
2075     }
2076
2077   if (regnum >= AARCH64_D0_REGNUM && regnum < AARCH64_D0_REGNUM + 32)
2078     {
2079       enum register_status status;
2080       unsigned v_regnum;
2081
2082       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_D0_REGNUM;
2083       status = regcache_raw_read (regcache, v_regnum, reg_buf);
2084       if (status != REG_VALID)
2085         mark_value_bytes_unavailable (result_value, 0,
2086                                       TYPE_LENGTH (value_type (result_value)));
2087       else
2088         memcpy (buf, reg_buf, D_REGISTER_SIZE);
2089       return result_value;
2090     }
2091
2092   if (regnum >= AARCH64_S0_REGNUM && regnum < AARCH64_S0_REGNUM + 32)
2093     {
2094       enum register_status status;
2095       unsigned v_regnum;
2096
2097       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_S0_REGNUM;
2098       status = regcache_raw_read (regcache, v_regnum, reg_buf);
2099       if (status != REG_VALID)
2100         mark_value_bytes_unavailable (result_value, 0,
2101                                       TYPE_LENGTH (value_type (result_value)));
2102       else
2103         memcpy (buf, reg_buf, S_REGISTER_SIZE);
2104       return result_value;
2105     }
2106
2107   if (regnum >= AARCH64_H0_REGNUM && regnum < AARCH64_H0_REGNUM + 32)
2108     {
2109       enum register_status status;
2110       unsigned v_regnum;
2111
2112       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_H0_REGNUM;
2113       status = regcache_raw_read (regcache, v_regnum, reg_buf);
2114       if (status != REG_VALID)
2115         mark_value_bytes_unavailable (result_value, 0,
2116                                       TYPE_LENGTH (value_type (result_value)));
2117       else
2118         memcpy (buf, reg_buf, H_REGISTER_SIZE);
2119       return result_value;
2120     }
2121
2122   if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32)
2123     {
2124       enum register_status status;
2125       unsigned v_regnum;
2126
2127       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_B0_REGNUM;
2128       status = regcache_raw_read (regcache, v_regnum, reg_buf);
2129       if (status != REG_VALID)
2130         mark_value_bytes_unavailable (result_value, 0,
2131                                       TYPE_LENGTH (value_type (result_value)));
2132       else
2133         memcpy (buf, reg_buf, B_REGISTER_SIZE);
2134       return result_value;
2135     }
2136
2137   gdb_assert_not_reached ("regnum out of bound");
2138 }
2139
2140 /* Implement the "pseudo_register_write" gdbarch method.  */
2141
2142 static void
2143 aarch64_pseudo_write (struct gdbarch *gdbarch, struct regcache *regcache,
2144                       int regnum, const gdb_byte *buf)
2145 {
2146   gdb_byte reg_buf[MAX_REGISTER_SIZE];
2147
2148   /* Ensure the register buffer is zero, we want gdb writes of the
2149      various 'scalar' pseudo registers to behavior like architectural
2150      writes, register width bytes are written the remainder are set to
2151      zero.  */
2152   memset (reg_buf, 0, sizeof (reg_buf));
2153
2154   regnum -= gdbarch_num_regs (gdbarch);
2155
2156   if (regnum >= AARCH64_Q0_REGNUM && regnum < AARCH64_Q0_REGNUM + 32)
2157     {
2158       /* pseudo Q registers */
2159       unsigned v_regnum;
2160
2161       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_Q0_REGNUM;
2162       memcpy (reg_buf, buf, Q_REGISTER_SIZE);
2163       regcache_raw_write (regcache, v_regnum, reg_buf);
2164       return;
2165     }
2166
2167   if (regnum >= AARCH64_D0_REGNUM && regnum < AARCH64_D0_REGNUM + 32)
2168     {
2169       /* pseudo D registers */
2170       unsigned v_regnum;
2171
2172       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_D0_REGNUM;
2173       memcpy (reg_buf, buf, D_REGISTER_SIZE);
2174       regcache_raw_write (regcache, v_regnum, reg_buf);
2175       return;
2176     }
2177
2178   if (regnum >= AARCH64_S0_REGNUM && regnum < AARCH64_S0_REGNUM + 32)
2179     {
2180       unsigned v_regnum;
2181
2182       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_S0_REGNUM;
2183       memcpy (reg_buf, buf, S_REGISTER_SIZE);
2184       regcache_raw_write (regcache, v_regnum, reg_buf);
2185       return;
2186     }
2187
2188   if (regnum >= AARCH64_H0_REGNUM && regnum < AARCH64_H0_REGNUM + 32)
2189     {
2190       /* pseudo H registers */
2191       unsigned v_regnum;
2192
2193       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_H0_REGNUM;
2194       memcpy (reg_buf, buf, H_REGISTER_SIZE);
2195       regcache_raw_write (regcache, v_regnum, reg_buf);
2196       return;
2197     }
2198
2199   if (regnum >= AARCH64_B0_REGNUM && regnum < AARCH64_B0_REGNUM + 32)
2200     {
2201       /* pseudo B registers */
2202       unsigned v_regnum;
2203
2204       v_regnum = AARCH64_V0_REGNUM + regnum - AARCH64_B0_REGNUM;
2205       memcpy (reg_buf, buf, B_REGISTER_SIZE);
2206       regcache_raw_write (regcache, v_regnum, reg_buf);
2207       return;
2208     }
2209
2210   gdb_assert_not_reached ("regnum out of bound");
2211 }
2212
2213 /* Callback function for user_reg_add.  */
2214
2215 static struct value *
2216 value_of_aarch64_user_reg (struct frame_info *frame, const void *baton)
2217 {
2218   const int *reg_p = (const int *) baton;
2219
2220   return value_of_register (*reg_p, frame);
2221 }
2222 \f
2223
2224 /* Implement the "software_single_step" gdbarch method, needed to
2225    single step through atomic sequences on AArch64.  */
2226
2227 static int
2228 aarch64_software_single_step (struct frame_info *frame)
2229 {
2230   struct gdbarch *gdbarch = get_frame_arch (frame);
2231   struct address_space *aspace = get_frame_address_space (frame);
2232   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
2233   const int insn_size = 4;
2234   const int atomic_sequence_length = 16; /* Instruction sequence length.  */
2235   CORE_ADDR pc = get_frame_pc (frame);
2236   CORE_ADDR breaks[2] = { -1, -1 };
2237   CORE_ADDR loc = pc;
2238   CORE_ADDR closing_insn = 0;
2239   uint32_t insn = read_memory_unsigned_integer (loc, insn_size,
2240                                                 byte_order_for_code);
2241   int index;
2242   int insn_count;
2243   int bc_insn_count = 0; /* Conditional branch instruction count.  */
2244   int last_breakpoint = 0; /* Defaults to 0 (no breakpoints placed).  */
2245   aarch64_inst inst;
2246
2247   if (aarch64_decode_insn (insn, &inst, 1) != 0)
2248     return 0;
2249
2250   /* Look for a Load Exclusive instruction which begins the sequence.  */
2251   if (inst.opcode->iclass != ldstexcl || bit (insn, 22) == 0)
2252     return 0;
2253
2254   for (insn_count = 0; insn_count < atomic_sequence_length; ++insn_count)
2255     {
2256       loc += insn_size;
2257       insn = read_memory_unsigned_integer (loc, insn_size,
2258                                            byte_order_for_code);
2259
2260       if (aarch64_decode_insn (insn, &inst, 1) != 0)
2261         return 0;
2262       /* Check if the instruction is a conditional branch.  */
2263       if (inst.opcode->iclass == condbranch)
2264         {
2265           gdb_assert (inst.operands[0].type == AARCH64_OPND_ADDR_PCREL19);
2266
2267           if (bc_insn_count >= 1)
2268             return 0;
2269
2270           /* It is, so we'll try to set a breakpoint at the destination.  */
2271           breaks[1] = loc + inst.operands[0].imm.value;
2272
2273           bc_insn_count++;
2274           last_breakpoint++;
2275         }
2276
2277       /* Look for the Store Exclusive which closes the atomic sequence.  */
2278       if (inst.opcode->iclass == ldstexcl && bit (insn, 22) == 0)
2279         {
2280           closing_insn = loc;
2281           break;
2282         }
2283     }
2284
2285   /* We didn't find a closing Store Exclusive instruction, fall back.  */
2286   if (!closing_insn)
2287     return 0;
2288
2289   /* Insert breakpoint after the end of the atomic sequence.  */
2290   breaks[0] = loc + insn_size;
2291
2292   /* Check for duplicated breakpoints, and also check that the second
2293      breakpoint is not within the atomic sequence.  */
2294   if (last_breakpoint
2295       && (breaks[1] == breaks[0]
2296           || (breaks[1] >= pc && breaks[1] <= closing_insn)))
2297     last_breakpoint = 0;
2298
2299   /* Insert the breakpoint at the end of the sequence, and one at the
2300      destination of the conditional branch, if it exists.  */
2301   for (index = 0; index <= last_breakpoint; index++)
2302     insert_single_step_breakpoint (gdbarch, aspace, breaks[index]);
2303
2304   return 1;
2305 }
2306
2307 struct displaced_step_closure
2308 {
2309   /* It is true when condition instruction, such as B.CON, TBZ, etc,
2310      is being displaced stepping.  */
2311   int cond;
2312
2313   /* PC adjustment offset after displaced stepping.  */
2314   int32_t pc_adjust;
2315 };
2316
2317 /* Data when visiting instructions for displaced stepping.  */
2318
2319 struct aarch64_displaced_step_data
2320 {
2321   struct aarch64_insn_data base;
2322
2323   /* The address where the instruction will be executed at.  */
2324   CORE_ADDR new_addr;
2325   /* Buffer of instructions to be copied to NEW_ADDR to execute.  */
2326   uint32_t insn_buf[DISPLACED_MODIFIED_INSNS];
2327   /* Number of instructions in INSN_BUF.  */
2328   unsigned insn_count;
2329   /* Registers when doing displaced stepping.  */
2330   struct regcache *regs;
2331
2332   struct displaced_step_closure *dsc;
2333 };
2334
2335 /* Implementation of aarch64_insn_visitor method "b".  */
2336
2337 static void
2338 aarch64_displaced_step_b (const int is_bl, const int32_t offset,
2339                           struct aarch64_insn_data *data)
2340 {
2341   struct aarch64_displaced_step_data *dsd
2342     = (struct aarch64_displaced_step_data *) data;
2343   int64_t new_offset = data->insn_addr - dsd->new_addr + offset;
2344
2345   if (can_encode_int32 (new_offset, 28))
2346     {
2347       /* Emit B rather than BL, because executing BL on a new address
2348          will get the wrong address into LR.  In order to avoid this,
2349          we emit B, and update LR if the instruction is BL.  */
2350       emit_b (dsd->insn_buf, 0, new_offset);
2351       dsd->insn_count++;
2352     }
2353   else
2354     {
2355       /* Write NOP.  */
2356       emit_nop (dsd->insn_buf);
2357       dsd->insn_count++;
2358       dsd->dsc->pc_adjust = offset;
2359     }
2360
2361   if (is_bl)
2362     {
2363       /* Update LR.  */
2364       regcache_cooked_write_unsigned (dsd->regs, AARCH64_LR_REGNUM,
2365                                       data->insn_addr + 4);
2366     }
2367 }
2368
2369 /* Implementation of aarch64_insn_visitor method "b_cond".  */
2370
2371 static void
2372 aarch64_displaced_step_b_cond (const unsigned cond, const int32_t offset,
2373                                struct aarch64_insn_data *data)
2374 {
2375   struct aarch64_displaced_step_data *dsd
2376     = (struct aarch64_displaced_step_data *) data;
2377
2378   /* GDB has to fix up PC after displaced step this instruction
2379      differently according to the condition is true or false.  Instead
2380      of checking COND against conditional flags, we can use
2381      the following instructions, and GDB can tell how to fix up PC
2382      according to the PC value.
2383
2384      B.COND TAKEN    ; If cond is true, then jump to TAKEN.
2385      INSN1     ;
2386      TAKEN:
2387      INSN2
2388   */
2389
2390   emit_bcond (dsd->insn_buf, cond, 8);
2391   dsd->dsc->cond = 1;
2392   dsd->dsc->pc_adjust = offset;
2393   dsd->insn_count = 1;
2394 }
2395
2396 /* Dynamically allocate a new register.  If we know the register
2397    statically, we should make it a global as above instead of using this
2398    helper function.  */
2399
2400 static struct aarch64_register
2401 aarch64_register (unsigned num, int is64)
2402 {
2403   return (struct aarch64_register) { num, is64 };
2404 }
2405
2406 /* Implementation of aarch64_insn_visitor method "cb".  */
2407
2408 static void
2409 aarch64_displaced_step_cb (const int32_t offset, const int is_cbnz,
2410                            const unsigned rn, int is64,
2411                            struct aarch64_insn_data *data)
2412 {
2413   struct aarch64_displaced_step_data *dsd
2414     = (struct aarch64_displaced_step_data *) data;
2415
2416   /* The offset is out of range for a compare and branch
2417      instruction.  We can use the following instructions instead:
2418
2419          CBZ xn, TAKEN   ; xn == 0, then jump to TAKEN.
2420          INSN1     ;
2421          TAKEN:
2422          INSN2
2423   */
2424   emit_cb (dsd->insn_buf, is_cbnz, aarch64_register (rn, is64), 8);
2425   dsd->insn_count = 1;
2426   dsd->dsc->cond = 1;
2427   dsd->dsc->pc_adjust = offset;
2428 }
2429
2430 /* Implementation of aarch64_insn_visitor method "tb".  */
2431
2432 static void
2433 aarch64_displaced_step_tb (const int32_t offset, int is_tbnz,
2434                            const unsigned rt, unsigned bit,
2435                            struct aarch64_insn_data *data)
2436 {
2437   struct aarch64_displaced_step_data *dsd
2438     = (struct aarch64_displaced_step_data *) data;
2439
2440   /* The offset is out of range for a test bit and branch
2441      instruction We can use the following instructions instead:
2442
2443      TBZ xn, #bit, TAKEN ; xn[bit] == 0, then jump to TAKEN.
2444      INSN1         ;
2445      TAKEN:
2446      INSN2
2447
2448   */
2449   emit_tb (dsd->insn_buf, is_tbnz, bit, aarch64_register (rt, 1), 8);
2450   dsd->insn_count = 1;
2451   dsd->dsc->cond = 1;
2452   dsd->dsc->pc_adjust = offset;
2453 }
2454
2455 /* Implementation of aarch64_insn_visitor method "adr".  */
2456
2457 static void
2458 aarch64_displaced_step_adr (const int32_t offset, const unsigned rd,
2459                             const int is_adrp, struct aarch64_insn_data *data)
2460 {
2461   struct aarch64_displaced_step_data *dsd
2462     = (struct aarch64_displaced_step_data *) data;
2463   /* We know exactly the address the ADR{P,} instruction will compute.
2464      We can just write it to the destination register.  */
2465   CORE_ADDR address = data->insn_addr + offset;
2466
2467   if (is_adrp)
2468     {
2469       /* Clear the lower 12 bits of the offset to get the 4K page.  */
2470       regcache_cooked_write_unsigned (dsd->regs, AARCH64_X0_REGNUM + rd,
2471                                       address & ~0xfff);
2472     }
2473   else
2474       regcache_cooked_write_unsigned (dsd->regs, AARCH64_X0_REGNUM + rd,
2475                                       address);
2476
2477   dsd->dsc->pc_adjust = 4;
2478   emit_nop (dsd->insn_buf);
2479   dsd->insn_count = 1;
2480 }
2481
2482 /* Implementation of aarch64_insn_visitor method "ldr_literal".  */
2483
2484 static void
2485 aarch64_displaced_step_ldr_literal (const int32_t offset, const int is_sw,
2486                                     const unsigned rt, const int is64,
2487                                     struct aarch64_insn_data *data)
2488 {
2489   struct aarch64_displaced_step_data *dsd
2490     = (struct aarch64_displaced_step_data *) data;
2491   CORE_ADDR address = data->insn_addr + offset;
2492   struct aarch64_memory_operand zero = { MEMORY_OPERAND_OFFSET, 0 };
2493
2494   regcache_cooked_write_unsigned (dsd->regs, AARCH64_X0_REGNUM + rt,
2495                                   address);
2496
2497   if (is_sw)
2498     dsd->insn_count = emit_ldrsw (dsd->insn_buf, aarch64_register (rt, 1),
2499                                   aarch64_register (rt, 1), zero);
2500   else
2501     dsd->insn_count = emit_ldr (dsd->insn_buf, aarch64_register (rt, is64),
2502                                 aarch64_register (rt, 1), zero);
2503
2504   dsd->dsc->pc_adjust = 4;
2505 }
2506
2507 /* Implementation of aarch64_insn_visitor method "others".  */
2508
2509 static void
2510 aarch64_displaced_step_others (const uint32_t insn,
2511                                struct aarch64_insn_data *data)
2512 {
2513   struct aarch64_displaced_step_data *dsd
2514     = (struct aarch64_displaced_step_data *) data;
2515
2516   aarch64_emit_insn (dsd->insn_buf, insn);
2517   dsd->insn_count = 1;
2518
2519   if ((insn & 0xfffffc1f) == 0xd65f0000)
2520     {
2521       /* RET */
2522       dsd->dsc->pc_adjust = 0;
2523     }
2524   else
2525     dsd->dsc->pc_adjust = 4;
2526 }
2527
2528 static const struct aarch64_insn_visitor visitor =
2529 {
2530   aarch64_displaced_step_b,
2531   aarch64_displaced_step_b_cond,
2532   aarch64_displaced_step_cb,
2533   aarch64_displaced_step_tb,
2534   aarch64_displaced_step_adr,
2535   aarch64_displaced_step_ldr_literal,
2536   aarch64_displaced_step_others,
2537 };
2538
2539 /* Implement the "displaced_step_copy_insn" gdbarch method.  */
2540
2541 struct displaced_step_closure *
2542 aarch64_displaced_step_copy_insn (struct gdbarch *gdbarch,
2543                                   CORE_ADDR from, CORE_ADDR to,
2544                                   struct regcache *regs)
2545 {
2546   struct displaced_step_closure *dsc = NULL;
2547   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
2548   uint32_t insn = read_memory_unsigned_integer (from, 4, byte_order_for_code);
2549   struct aarch64_displaced_step_data dsd;
2550   aarch64_inst inst;
2551
2552   if (aarch64_decode_insn (insn, &inst, 1) != 0)
2553     return NULL;
2554
2555   /* Look for a Load Exclusive instruction which begins the sequence.  */
2556   if (inst.opcode->iclass == ldstexcl && bit (insn, 22))
2557     {
2558       /* We can't displaced step atomic sequences.  */
2559       return NULL;
2560     }
2561
2562   dsc = XCNEW (struct displaced_step_closure);
2563   dsd.base.insn_addr = from;
2564   dsd.new_addr = to;
2565   dsd.regs = regs;
2566   dsd.dsc = dsc;
2567   dsd.insn_count = 0;
2568   aarch64_relocate_instruction (insn, &visitor,
2569                                 (struct aarch64_insn_data *) &dsd);
2570   gdb_assert (dsd.insn_count <= DISPLACED_MODIFIED_INSNS);
2571
2572   if (dsd.insn_count != 0)
2573     {
2574       int i;
2575
2576       /* Instruction can be relocated to scratch pad.  Copy
2577          relocated instruction(s) there.  */
2578       for (i = 0; i < dsd.insn_count; i++)
2579         {
2580           if (debug_displaced)
2581             {
2582               debug_printf ("displaced: writing insn ");
2583               debug_printf ("%.8x", dsd.insn_buf[i]);
2584               debug_printf (" at %s\n", paddress (gdbarch, to + i * 4));
2585             }
2586           write_memory_unsigned_integer (to + i * 4, 4, byte_order_for_code,
2587                                          (ULONGEST) dsd.insn_buf[i]);
2588         }
2589     }
2590   else
2591     {
2592       xfree (dsc);
2593       dsc = NULL;
2594     }
2595
2596   return dsc;
2597 }
2598
2599 /* Implement the "displaced_step_fixup" gdbarch method.  */
2600
2601 void
2602 aarch64_displaced_step_fixup (struct gdbarch *gdbarch,
2603                               struct displaced_step_closure *dsc,
2604                               CORE_ADDR from, CORE_ADDR to,
2605                               struct regcache *regs)
2606 {
2607   if (dsc->cond)
2608     {
2609       ULONGEST pc;
2610
2611       regcache_cooked_read_unsigned (regs, AARCH64_PC_REGNUM, &pc);
2612       if (pc - to == 8)
2613         {
2614           /* Condition is true.  */
2615         }
2616       else if (pc - to == 4)
2617         {
2618           /* Condition is false.  */
2619           dsc->pc_adjust = 4;
2620         }
2621       else
2622         gdb_assert_not_reached ("Unexpected PC value after displaced stepping");
2623     }
2624
2625   if (dsc->pc_adjust != 0)
2626     {
2627       if (debug_displaced)
2628         {
2629           debug_printf ("displaced: fixup: set PC to %s:%d\n",
2630                         paddress (gdbarch, from), dsc->pc_adjust);
2631         }
2632       regcache_cooked_write_unsigned (regs, AARCH64_PC_REGNUM,
2633                                       from + dsc->pc_adjust);
2634     }
2635 }
2636
2637 /* Implement the "displaced_step_hw_singlestep" gdbarch method.  */
2638
2639 int
2640 aarch64_displaced_step_hw_singlestep (struct gdbarch *gdbarch,
2641                                       struct displaced_step_closure *closure)
2642 {
2643   return 1;
2644 }
2645
2646 /* Initialize the current architecture based on INFO.  If possible,
2647    re-use an architecture from ARCHES, which is a list of
2648    architectures already created during this debugging session.
2649
2650    Called e.g. at program startup, when reading a core file, and when
2651    reading a binary file.  */
2652
2653 static struct gdbarch *
2654 aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
2655 {
2656   struct gdbarch_tdep *tdep;
2657   struct gdbarch *gdbarch;
2658   struct gdbarch_list *best_arch;
2659   struct tdesc_arch_data *tdesc_data = NULL;
2660   const struct target_desc *tdesc = info.target_desc;
2661   int i;
2662   int valid_p = 1;
2663   const struct tdesc_feature *feature;
2664   int num_regs = 0;
2665   int num_pseudo_regs = 0;
2666
2667   /* Ensure we always have a target descriptor.  */
2668   if (!tdesc_has_registers (tdesc))
2669     tdesc = tdesc_aarch64;
2670
2671   gdb_assert (tdesc);
2672
2673   feature = tdesc_find_feature (tdesc, "org.gnu.gdb.aarch64.core");
2674
2675   if (feature == NULL)
2676     return NULL;
2677
2678   tdesc_data = tdesc_data_alloc ();
2679
2680   /* Validate the descriptor provides the mandatory core R registers
2681      and allocate their numbers.  */
2682   for (i = 0; i < ARRAY_SIZE (aarch64_r_register_names); i++)
2683     valid_p &=
2684       tdesc_numbered_register (feature, tdesc_data, AARCH64_X0_REGNUM + i,
2685                                aarch64_r_register_names[i]);
2686
2687   num_regs = AARCH64_X0_REGNUM + i;
2688
2689   /* Look for the V registers.  */
2690   feature = tdesc_find_feature (tdesc, "org.gnu.gdb.aarch64.fpu");
2691   if (feature)
2692     {
2693       /* Validate the descriptor provides the mandatory V registers
2694          and allocate their numbers.  */
2695       for (i = 0; i < ARRAY_SIZE (aarch64_v_register_names); i++)
2696         valid_p &=
2697           tdesc_numbered_register (feature, tdesc_data, AARCH64_V0_REGNUM + i,
2698                                    aarch64_v_register_names[i]);
2699
2700       num_regs = AARCH64_V0_REGNUM + i;
2701
2702       num_pseudo_regs += 32;    /* add the Qn scalar register pseudos */
2703       num_pseudo_regs += 32;    /* add the Dn scalar register pseudos */
2704       num_pseudo_regs += 32;    /* add the Sn scalar register pseudos */
2705       num_pseudo_regs += 32;    /* add the Hn scalar register pseudos */
2706       num_pseudo_regs += 32;    /* add the Bn scalar register pseudos */
2707     }
2708
2709   if (!valid_p)
2710     {
2711       tdesc_data_cleanup (tdesc_data);
2712       return NULL;
2713     }
2714
2715   /* AArch64 code is always little-endian.  */
2716   info.byte_order_for_code = BFD_ENDIAN_LITTLE;
2717
2718   /* If there is already a candidate, use it.  */
2719   for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
2720        best_arch != NULL;
2721        best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
2722     {
2723       /* Found a match.  */
2724       break;
2725     }
2726
2727   if (best_arch != NULL)
2728     {
2729       if (tdesc_data != NULL)
2730         tdesc_data_cleanup (tdesc_data);
2731       return best_arch->gdbarch;
2732     }
2733
2734   tdep = XCNEW (struct gdbarch_tdep);
2735   gdbarch = gdbarch_alloc (&info, tdep);
2736
2737   /* This should be low enough for everything.  */
2738   tdep->lowest_pc = 0x20;
2739   tdep->jb_pc = -1;             /* Longjump support not enabled by default.  */
2740   tdep->jb_elt_size = 8;
2741
2742   set_gdbarch_push_dummy_call (gdbarch, aarch64_push_dummy_call);
2743   set_gdbarch_frame_align (gdbarch, aarch64_frame_align);
2744
2745   /* Frame handling.  */
2746   set_gdbarch_dummy_id (gdbarch, aarch64_dummy_id);
2747   set_gdbarch_unwind_pc (gdbarch, aarch64_unwind_pc);
2748   set_gdbarch_unwind_sp (gdbarch, aarch64_unwind_sp);
2749
2750   /* Advance PC across function entry code.  */
2751   set_gdbarch_skip_prologue (gdbarch, aarch64_skip_prologue);
2752
2753   /* The stack grows downward.  */
2754   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
2755
2756   /* Breakpoint manipulation.  */
2757   SET_GDBARCH_BREAKPOINT_MANIPULATION (aarch64);
2758   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
2759   set_gdbarch_software_single_step (gdbarch, aarch64_software_single_step);
2760
2761   /* Information about registers, etc.  */
2762   set_gdbarch_sp_regnum (gdbarch, AARCH64_SP_REGNUM);
2763   set_gdbarch_pc_regnum (gdbarch, AARCH64_PC_REGNUM);
2764   set_gdbarch_num_regs (gdbarch, num_regs);
2765
2766   set_gdbarch_num_pseudo_regs (gdbarch, num_pseudo_regs);
2767   set_gdbarch_pseudo_register_read_value (gdbarch, aarch64_pseudo_read_value);
2768   set_gdbarch_pseudo_register_write (gdbarch, aarch64_pseudo_write);
2769   set_tdesc_pseudo_register_name (gdbarch, aarch64_pseudo_register_name);
2770   set_tdesc_pseudo_register_type (gdbarch, aarch64_pseudo_register_type);
2771   set_tdesc_pseudo_register_reggroup_p (gdbarch,
2772                                         aarch64_pseudo_register_reggroup_p);
2773
2774   /* ABI */
2775   set_gdbarch_short_bit (gdbarch, 16);
2776   set_gdbarch_int_bit (gdbarch, 32);
2777   set_gdbarch_float_bit (gdbarch, 32);
2778   set_gdbarch_double_bit (gdbarch, 64);
2779   set_gdbarch_long_double_bit (gdbarch, 128);
2780   set_gdbarch_long_bit (gdbarch, 64);
2781   set_gdbarch_long_long_bit (gdbarch, 64);
2782   set_gdbarch_ptr_bit (gdbarch, 64);
2783   set_gdbarch_char_signed (gdbarch, 0);
2784   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
2785   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
2786   set_gdbarch_long_double_format (gdbarch, floatformats_ia64_quad);
2787
2788   /* Internal <-> external register number maps.  */
2789   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, aarch64_dwarf_reg_to_regnum);
2790
2791   /* Returning results.  */
2792   set_gdbarch_return_value (gdbarch, aarch64_return_value);
2793
2794   /* Disassembly.  */
2795   set_gdbarch_print_insn (gdbarch, aarch64_gdb_print_insn);
2796
2797   /* Virtual tables.  */
2798   set_gdbarch_vbit_in_delta (gdbarch, 1);
2799
2800   /* Hook in the ABI-specific overrides, if they have been registered.  */
2801   info.target_desc = tdesc;
2802   info.tdep_info = (void *) tdesc_data;
2803   gdbarch_init_osabi (info, gdbarch);
2804
2805   dwarf2_frame_set_init_reg (gdbarch, aarch64_dwarf2_frame_init_reg);
2806
2807   /* Add some default predicates.  */
2808   frame_unwind_append_unwinder (gdbarch, &aarch64_stub_unwind);
2809   dwarf2_append_unwinders (gdbarch);
2810   frame_unwind_append_unwinder (gdbarch, &aarch64_prologue_unwind);
2811
2812   frame_base_set_default (gdbarch, &aarch64_normal_base);
2813
2814   /* Now we have tuned the configuration, set a few final things,
2815      based on what the OS ABI has told us.  */
2816
2817   if (tdep->jb_pc >= 0)
2818     set_gdbarch_get_longjmp_target (gdbarch, aarch64_get_longjmp_target);
2819
2820   set_gdbarch_gen_return_address (gdbarch, aarch64_gen_return_address);
2821
2822   tdesc_use_registers (gdbarch, tdesc, tdesc_data);
2823
2824   /* Add standard register aliases.  */
2825   for (i = 0; i < ARRAY_SIZE (aarch64_register_aliases); i++)
2826     user_reg_add (gdbarch, aarch64_register_aliases[i].name,
2827                   value_of_aarch64_user_reg,
2828                   &aarch64_register_aliases[i].regnum);
2829
2830   return gdbarch;
2831 }
2832
2833 static void
2834 aarch64_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
2835 {
2836   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
2837
2838   if (tdep == NULL)
2839     return;
2840
2841   fprintf_unfiltered (file, _("aarch64_dump_tdep: Lowest pc = 0x%s"),
2842                       paddress (gdbarch, tdep->lowest_pc));
2843 }
2844
2845 /* Suppress warning from -Wmissing-prototypes.  */
2846 extern initialize_file_ftype _initialize_aarch64_tdep;
2847
2848 void
2849 _initialize_aarch64_tdep (void)
2850 {
2851   gdbarch_register (bfd_arch_aarch64, aarch64_gdbarch_init,
2852                     aarch64_dump_tdep);
2853
2854   initialize_tdesc_aarch64 ();
2855
2856   /* Debug this file's internals.  */
2857   add_setshow_boolean_cmd ("aarch64", class_maintenance, &aarch64_debug, _("\
2858 Set AArch64 debugging."), _("\
2859 Show AArch64 debugging."), _("\
2860 When on, AArch64 specific debugging is enabled."),
2861                             NULL,
2862                             show_aarch64_debug,
2863                             &setdebuglist, &showdebuglist);
2864 }
2865
2866 /* AArch64 process record-replay related structures, defines etc.  */
2867
2868 #define REG_ALLOC(REGS, LENGTH, RECORD_BUF) \
2869         do  \
2870           { \
2871             unsigned int reg_len = LENGTH; \
2872             if (reg_len) \
2873               { \
2874                 REGS = XNEWVEC (uint32_t, reg_len); \
2875                 memcpy(&REGS[0], &RECORD_BUF[0], sizeof(uint32_t)*LENGTH); \
2876               } \
2877           } \
2878         while (0)
2879
2880 #define MEM_ALLOC(MEMS, LENGTH, RECORD_BUF) \
2881         do  \
2882           { \
2883             unsigned int mem_len = LENGTH; \
2884             if (mem_len) \
2885             { \
2886               MEMS =  XNEWVEC (struct aarch64_mem_r, mem_len);  \
2887               memcpy(&MEMS->len, &RECORD_BUF[0], \
2888                      sizeof(struct aarch64_mem_r) * LENGTH); \
2889             } \
2890           } \
2891           while (0)
2892
2893 /* AArch64 record/replay structures and enumerations.  */
2894
2895 struct aarch64_mem_r
2896 {
2897   uint64_t len;    /* Record length.  */
2898   uint64_t addr;   /* Memory address.  */
2899 };
2900
2901 enum aarch64_record_result
2902 {
2903   AARCH64_RECORD_SUCCESS,
2904   AARCH64_RECORD_FAILURE,
2905   AARCH64_RECORD_UNSUPPORTED,
2906   AARCH64_RECORD_UNKNOWN
2907 };
2908
2909 typedef struct insn_decode_record_t
2910 {
2911   struct gdbarch *gdbarch;
2912   struct regcache *regcache;
2913   CORE_ADDR this_addr;                 /* Address of insn to be recorded.  */
2914   uint32_t aarch64_insn;               /* Insn to be recorded.  */
2915   uint32_t mem_rec_count;              /* Count of memory records.  */
2916   uint32_t reg_rec_count;              /* Count of register records.  */
2917   uint32_t *aarch64_regs;              /* Registers to be recorded.  */
2918   struct aarch64_mem_r *aarch64_mems;  /* Memory locations to be recorded.  */
2919 } insn_decode_record;
2920
2921 /* Record handler for data processing - register instructions.  */
2922
2923 static unsigned int
2924 aarch64_record_data_proc_reg (insn_decode_record *aarch64_insn_r)
2925 {
2926   uint8_t reg_rd, insn_bits24_27, insn_bits21_23;
2927   uint32_t record_buf[4];
2928
2929   reg_rd = bits (aarch64_insn_r->aarch64_insn, 0, 4);
2930   insn_bits24_27 = bits (aarch64_insn_r->aarch64_insn, 24, 27);
2931   insn_bits21_23 = bits (aarch64_insn_r->aarch64_insn, 21, 23);
2932
2933   if (!bit (aarch64_insn_r->aarch64_insn, 28))
2934     {
2935       uint8_t setflags;
2936
2937       /* Logical (shifted register).  */
2938       if (insn_bits24_27 == 0x0a)
2939         setflags = (bits (aarch64_insn_r->aarch64_insn, 29, 30) == 0x03);
2940       /* Add/subtract.  */
2941       else if (insn_bits24_27 == 0x0b)
2942         setflags = bit (aarch64_insn_r->aarch64_insn, 29);
2943       else
2944         return AARCH64_RECORD_UNKNOWN;
2945
2946       record_buf[0] = reg_rd;
2947       aarch64_insn_r->reg_rec_count = 1;
2948       if (setflags)
2949         record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_CPSR_REGNUM;
2950     }
2951   else
2952     {
2953       if (insn_bits24_27 == 0x0b)
2954         {
2955           /* Data-processing (3 source).  */
2956           record_buf[0] = reg_rd;
2957           aarch64_insn_r->reg_rec_count = 1;
2958         }
2959       else if (insn_bits24_27 == 0x0a)
2960         {
2961           if (insn_bits21_23 == 0x00)
2962             {
2963               /* Add/subtract (with carry).  */
2964               record_buf[0] = reg_rd;
2965               aarch64_insn_r->reg_rec_count = 1;
2966               if (bit (aarch64_insn_r->aarch64_insn, 29))
2967                 {
2968                   record_buf[1] = AARCH64_CPSR_REGNUM;
2969                   aarch64_insn_r->reg_rec_count = 2;
2970                 }
2971             }
2972           else if (insn_bits21_23 == 0x02)
2973             {
2974               /* Conditional compare (register) and conditional compare
2975                  (immediate) instructions.  */
2976               record_buf[0] = AARCH64_CPSR_REGNUM;
2977               aarch64_insn_r->reg_rec_count = 1;
2978             }
2979           else if (insn_bits21_23 == 0x04 || insn_bits21_23 == 0x06)
2980             {
2981               /* CConditional select.  */
2982               /* Data-processing (2 source).  */
2983               /* Data-processing (1 source).  */
2984               record_buf[0] = reg_rd;
2985               aarch64_insn_r->reg_rec_count = 1;
2986             }
2987           else
2988             return AARCH64_RECORD_UNKNOWN;
2989         }
2990     }
2991
2992   REG_ALLOC (aarch64_insn_r->aarch64_regs, aarch64_insn_r->reg_rec_count,
2993              record_buf);
2994   return AARCH64_RECORD_SUCCESS;
2995 }
2996
2997 /* Record handler for data processing - immediate instructions.  */
2998
2999 static unsigned int
3000 aarch64_record_data_proc_imm (insn_decode_record *aarch64_insn_r)
3001 {
3002   uint8_t reg_rd, insn_bit23, insn_bits24_27, setflags;
3003   uint32_t record_buf[4];
3004
3005   reg_rd = bits (aarch64_insn_r->aarch64_insn, 0, 4);
3006   insn_bit23 = bit (aarch64_insn_r->aarch64_insn, 23);
3007   insn_bits24_27 = bits (aarch64_insn_r->aarch64_insn, 24, 27);
3008
3009   if (insn_bits24_27 == 0x00                     /* PC rel addressing.  */
3010      || insn_bits24_27 == 0x03                   /* Bitfield and Extract.  */
3011      || (insn_bits24_27 == 0x02 && insn_bit23))  /* Move wide (immediate).  */
3012     {
3013       record_buf[0] = reg_rd;
3014       aarch64_insn_r->reg_rec_count = 1;
3015     }
3016   else if (insn_bits24_27 == 0x01)
3017     {
3018       /* Add/Subtract (immediate).  */
3019       setflags = bit (aarch64_insn_r->aarch64_insn, 29);
3020       record_buf[0] = reg_rd;
3021       aarch64_insn_r->reg_rec_count = 1;
3022       if (setflags)
3023         record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_CPSR_REGNUM;
3024     }
3025   else if (insn_bits24_27 == 0x02 && !insn_bit23)
3026     {
3027       /* Logical (immediate).  */
3028       setflags = bits (aarch64_insn_r->aarch64_insn, 29, 30) == 0x03;
3029       record_buf[0] = reg_rd;
3030       aarch64_insn_r->reg_rec_count = 1;
3031       if (setflags)
3032         record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_CPSR_REGNUM;
3033     }
3034   else
3035     return AARCH64_RECORD_UNKNOWN;
3036
3037   REG_ALLOC (aarch64_insn_r->aarch64_regs, aarch64_insn_r->reg_rec_count,
3038              record_buf);
3039   return AARCH64_RECORD_SUCCESS;
3040 }
3041
3042 /* Record handler for branch, exception generation and system instructions.  */
3043
3044 static unsigned int
3045 aarch64_record_branch_except_sys (insn_decode_record *aarch64_insn_r)
3046 {
3047   struct gdbarch_tdep *tdep = gdbarch_tdep (aarch64_insn_r->gdbarch);
3048   uint8_t insn_bits24_27, insn_bits28_31, insn_bits22_23;
3049   uint32_t record_buf[4];
3050
3051   insn_bits24_27 = bits (aarch64_insn_r->aarch64_insn, 24, 27);
3052   insn_bits28_31 = bits (aarch64_insn_r->aarch64_insn, 28, 31);
3053   insn_bits22_23 = bits (aarch64_insn_r->aarch64_insn, 22, 23);
3054
3055   if (insn_bits28_31 == 0x0d)
3056     {
3057       /* Exception generation instructions. */
3058       if (insn_bits24_27 == 0x04)
3059         {
3060           if (!bits (aarch64_insn_r->aarch64_insn, 2, 4)
3061               && !bits (aarch64_insn_r->aarch64_insn, 21, 23)
3062               && bits (aarch64_insn_r->aarch64_insn, 0, 1) == 0x01)
3063             {
3064               ULONGEST svc_number;
3065
3066               regcache_raw_read_unsigned (aarch64_insn_r->regcache, 8,
3067                                           &svc_number);
3068               return tdep->aarch64_syscall_record (aarch64_insn_r->regcache,
3069                                                    svc_number);
3070             }
3071           else
3072             return AARCH64_RECORD_UNSUPPORTED;
3073         }
3074       /* System instructions. */
3075       else if (insn_bits24_27 == 0x05 && insn_bits22_23 == 0x00)
3076         {
3077           uint32_t reg_rt, reg_crn;
3078
3079           reg_rt = bits (aarch64_insn_r->aarch64_insn, 0, 4);
3080           reg_crn = bits (aarch64_insn_r->aarch64_insn, 12, 15);
3081
3082           /* Record rt in case of sysl and mrs instructions.  */
3083           if (bit (aarch64_insn_r->aarch64_insn, 21))
3084             {
3085               record_buf[0] = reg_rt;
3086               aarch64_insn_r->reg_rec_count = 1;
3087             }
3088           /* Record cpsr for hint and msr(immediate) instructions.  */
3089           else if (reg_crn == 0x02 || reg_crn == 0x04)
3090             {
3091               record_buf[0] = AARCH64_CPSR_REGNUM;
3092               aarch64_insn_r->reg_rec_count = 1;
3093             }
3094         }
3095       /* Unconditional branch (register).  */
3096       else if((insn_bits24_27 & 0x0e) == 0x06)
3097         {
3098           record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_PC_REGNUM;
3099           if (bits (aarch64_insn_r->aarch64_insn, 21, 22) == 0x01)
3100             record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_LR_REGNUM;
3101         }
3102       else
3103         return AARCH64_RECORD_UNKNOWN;
3104     }
3105   /* Unconditional branch (immediate).  */
3106   else if ((insn_bits28_31 & 0x07) == 0x01 && (insn_bits24_27 & 0x0c) == 0x04)
3107     {
3108       record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_PC_REGNUM;
3109       if (bit (aarch64_insn_r->aarch64_insn, 31))
3110         record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_LR_REGNUM;
3111     }
3112   else
3113     /* Compare & branch (immediate), Test & branch (immediate) and
3114        Conditional branch (immediate).  */
3115     record_buf[aarch64_insn_r->reg_rec_count++] = AARCH64_PC_REGNUM;
3116
3117   REG_ALLOC (aarch64_insn_r->aarch64_regs, aarch64_insn_r->reg_rec_count,
3118              record_buf);
3119   return AARCH64_RECORD_SUCCESS;
3120 }
3121
3122 /* Record handler for advanced SIMD load and store instructions.  */
3123
3124 static unsigned int
3125 aarch64_record_asimd_load_store (insn_decode_record *aarch64_insn_r)
3126 {
3127   CORE_ADDR address;
3128   uint64_t addr_offset = 0;
3129   uint32_t record_buf[24];
3130   uint64_t record_buf_mem[24];
3131   uint32_t reg_rn, reg_rt;
3132   uint32_t reg_index = 0, mem_index = 0;
3133   uint8_t opcode_bits, size_bits;
3134
3135   reg_rt = bits (aarch64_insn_r->aarch64_insn, 0, 4);
3136   reg_rn = bits (aarch64_insn_r->aarch64_insn, 5, 9);
3137   size_bits = bits (aarch64_insn_r->aarch64_insn, 10, 11);
3138   opcode_bits = bits (aarch64_insn_r->aarch64_insn, 12, 15);
3139   regcache_raw_read_unsigned (aarch64_insn_r->regcache, reg_rn, &address);
3140
3141   if (record_debug)
3142     debug_printf ("Process record: Advanced SIMD load/store\n");
3143
3144   /* Load/store single structure.  */
3145   if (bit (aarch64_insn_r->aarch64_insn, 24))
3146     {
3147       uint8_t sindex, scale, selem, esize, replicate = 0;
3148       scale = opcode_bits >> 2;
3149       selem = ((opcode_bits & 0x02) |
3150               bit (aarch64_insn_r->aarch64_insn, 21)) + 1;
3151       switch (scale)
3152         {
3153         case 1:
3154           if (size_bits & 0x01)
3155             return AARCH64_RECORD_UNKNOWN;
3156           break;
3157         case 2:
3158           if ((size_bits >> 1) & 0x01)
3159             return AARCH64_RECORD_UNKNOWN;
3160           if (size_bits & 0x01)
3161             {
3162               if (!((opcode_bits >> 1) & 0x01))
3163                 scale = 3;
3164               else
3165                 return AARCH64_RECORD_UNKNOWN;
3166             }
3167           break;
3168         case 3:
3169           if (bit (aarch64_insn_r->aarch64_insn, 22) && !(opcode_bits & 0x01))
3170             {
3171               scale = size_bits;
3172               replicate = 1;
3173               break;
3174             }
3175           else
3176             return AARCH64_RECORD_UNKNOWN;
3177         default:
3178           break;
3179         }
3180       esize = 8 << scale;
3181       if (replicate)
3182         for (sindex = 0; sindex < selem; sindex++)
3183           {
3184             record_buf[reg_index++] = reg_rt + AARCH64_V0_REGNUM;
3185             reg_rt = (reg_rt + 1) % 32;
3186           }
3187       else
3188         {
3189           for (sindex = 0; sindex < selem; sindex++)
3190             {
3191               if (bit (aarch64_insn_r->aarch64_insn, 22))
3192                 record_buf[reg_index++] = reg_rt + AARCH64_V0_REGNUM;
3193               else
3194                 {
3195                   record_buf_mem[mem_index++] = esize / 8;
3196                   record_buf_mem[mem_index++] = address + addr_offset;
3197                 }
3198               addr_offset = addr_offset + (esize / 8);
3199               reg_rt = (reg_rt + 1) % 32;
3200             }
3201         }
3202     }
3203   /* Load/store multiple structure.  */
3204   else
3205     {
3206       uint8_t selem, esize, rpt, elements;
3207       uint8_t eindex, rindex;
3208
3209       esize = 8 << size_bits;
3210       if (bit (aarch64_insn_r->aarch64_insn, 30))
3211         elements = 128 / esize;
3212       else
3213         elements = 64 / esize;
3214
3215       switch (opcode_bits)
3216         {
3217         /*LD/ST4 (4 Registers).  */
3218         case 0:
3219           rpt = 1;
3220           selem = 4;
3221           break;
3222         /*LD/ST1 (4 Registers).  */
3223         case 2:
3224           rpt = 4;
3225           selem = 1;
3226           break;
3227         /*LD/ST3 (3 Registers).  */
3228         case 4:
3229           rpt = 1;
3230           selem = 3;
3231           break;
3232         /*LD/ST1 (3 Registers).  */
3233         case 6:
3234           rpt = 3;
3235           selem = 1;
3236           break;
3237         /*LD/ST1 (1 Register).  */
3238         case 7:
3239           rpt = 1;
3240           selem = 1;
3241           break;
3242         /*LD/ST2 (2 Registers).  */
3243         case 8:
3244           rpt = 1;
3245           selem = 2;
3246           break;
3247         /*LD/ST1 (2 Registers).  */
3248         case 10:
3249           rpt = 2;
3250           selem = 1;
3251           break;
3252         default:
3253           return AARCH64_RECORD_UNSUPPORTED;
3254           break;
3255         }
3256       for (rindex = 0; rindex < rpt; rindex++)
3257         for (eindex = 0; eindex < elements; eindex++)
3258           {
3259             uint8_t reg_tt, sindex;
3260             reg_tt = (reg_rt + rindex) % 32;
3261             for (sindex = 0; sindex < selem; sindex++)
3262               {
3263                 if (bit (aarch64_insn_r->aarch64_insn, 22))
3264                   record_buf[reg_index++] = reg_tt + AARCH64_V0_REGNUM;
3265                 else
3266                   {
3267                     record_buf_mem[mem_index++] = esize / 8;
3268                     record_buf_mem[mem_index++] = address + addr_offset;
3269                   }
3270                 addr_offset = addr_offset + (esize / 8);
3271                 reg_tt = (reg_tt + 1) % 32;
3272               }
3273           }
3274     }
3275
3276   if (bit (aarch64_insn_r->aarch64_insn, 23))
3277     record_buf[reg_index++] = reg_rn;
3278
3279   aarch64_insn_r->reg_rec_count = reg_index;
3280   aarch64_insn_r->mem_rec_count = mem_index / 2;
3281   MEM_ALLOC (aarch64_insn_r->aarch64_mems, aarch64_insn_r->mem_rec_count,
3282              record_buf_mem);
3283   REG_ALLOC (aarch64_insn_r->aarch64_regs, aarch64_insn_r->reg_rec_count,
3284              record_buf);
3285   return AARCH64_RECORD_SUCCESS;
3286 }
3287
3288 /* Record handler for load and store instructions.  */
3289
3290 static unsigned int
3291 aarch64_record_load_store (insn_decode_record *aarch64_insn_r)
3292 {
3293   uint8_t insn_bits24_27, insn_bits28_29, insn_bits10_11;
3294   uint8_t insn_bit23, insn_bit21;
3295   uint8_t opc, size_bits, ld_flag, vector_flag;
3296   uint32_t reg_rn, reg_rt, reg_rt2;
3297   uint64_t datasize, offset;
3298   uint32_t record_buf[8];
3299   uint64_t record_buf_mem[8];
3300   CORE_ADDR address;
3301
3302   insn_bits10_11 = bits (aarch64_insn_r->aarch64_insn, 10, 11);
3303   insn_bits24_27 = bits (aarch64_insn_r->aarch64_insn, 24, 27);
3304   insn_bits28_29 = bits (aarch64_insn_r->aarch64_insn, 28, 29);
3305   insn_bit21 = bit (aarch64_insn_r->aarch64_insn, 21);
3306   insn_bit23 = bit (aarch64_insn_r->aarch64_insn, 23);
3307   ld_flag = bit (aarch64_insn_r->aarch64_insn, 22);
3308   vector_flag = bit (aarch64_insn_r->aarch64_insn, 26);
3309   reg_rt = bits (aarch64_insn_r->aarch64_insn, 0, 4);
3310   reg_rn = bits (aarch64_insn_r->aarch64_insn, 5, 9);
3311   reg_rt2 = bits (aarch64_insn_r->aarch64_insn, 10, 14);
3312   size_bits = bits (aarch64_insn_r->aarch64_insn, 30, 31);
3313
3314   /* Load/store exclusive.  */
3315   if (insn_bits24_27 == 0x08 && insn_bits28_29 == 0x00)
3316     {
3317       if (record_debug)
3318         debug_printf ("Process record: load/store exclusive\n");
3319
3320       if (ld_flag)
3321         {
3322           record_buf[0] = reg_rt;
3323           aarch64_insn_r->reg_rec_count = 1;
3324           if (insn_bit21)
3325             {
3326               record_buf[1] = reg_rt2;
3327               aarch64_insn_r->reg_rec_count = 2;
3328             }
3329         }
3330       else
3331         {
3332           if (insn_bit21)
3333             datasize = (8 << size_bits) * 2;
3334           else
3335             datasize = (8 << size_bits);
3336           regcache_raw_read_unsigned (aarch64_insn_r->regcache, reg_rn,
3337                                       &address);
3338           record_buf_mem[0] = datasize / 8;
3339           record_buf_mem[1] = address;
3340           aarch64_insn_r->mem_rec_count = 1;
3341           if (!insn_bit23)
3342             {
3343               /* Save register rs.  */
3344               record_buf[0] = bits (aarch64_insn_r->aarch64_insn, 16, 20);
3345               aarch64_insn_r->reg_rec_count = 1;
3346             }
3347         }
3348     }
3349   /* Load register (literal) instructions decoding.  */
3350   else if ((insn_bits24_27 & 0x0b) == 0x08 && insn_bits28_29 == 0x01)
3351     {
3352       if (record_debug)
3353         debug_printf ("Process record: load register (literal)\n");
3354       if (vector_flag)
3355         record_buf[0] = reg_rt + AARCH64_V0_REGNUM;
3356       else
3357         record_buf[0] = reg_rt;
3358       aarch64_insn_r->reg_rec_count = 1;
3359     }
3360   /* All types of load/store pair instructions decoding.  */
3361   else if ((insn_bits24_27 & 0x0a) == 0x08 && insn_bits28_29 == 0x02)
3362     {
3363       if (record_debug)
3364         debug_printf ("Process record: load/store pair\n");
3365
3366       if (ld_flag)
3367         {
3368           if (vector_flag)
3369             {
3370               record_buf[0] = reg_rt + AARCH64_V0_REGNUM;
3371               record_buf[1] = reg_rt2 + AARCH64_V0_REGNUM;
3372             }
3373           else
3374             {
3375               record_buf[0] = reg_rt;
3376               record_buf[1] = reg_rt2;
3377             }
3378           aarch64_insn_r->reg_rec_count = 2;
3379         }
3380       else
3381         {
3382           uint16_t imm7_off;
3383           imm7_off = bits (aarch64_insn_r->aarch64_insn, 15, 21);
3384           if (!vector_flag)
3385             size_bits = size_bits >> 1;
3386           datasize = 8 << (2 + size_bits);
3387           offset = (imm7_off & 0x40) ? (~imm7_off & 0x007f) + 1 : imm7_off;
3388           offset = offset << (2 + size_bits);
3389           regcache_raw_read_unsigned (aarch64_insn_r->regcache, reg_rn,
3390                                       &address);
3391           if (!((insn_bits24_27 & 0x0b) == 0x08 && insn_bit23))
3392             {
3393               if (imm7_off & 0x40)
3394                 address = address - offset;
3395               else
3396                 address = address + offset;
3397             }
3398
3399           record_buf_mem[0] = datasize / 8;
3400           record_buf_mem[1] = address;
3401           record_buf_mem[2] = datasize / 8;
3402           record_buf_mem[3] = address + (datasize / 8);
3403           aarch64_insn_r->mem_rec_count = 2;
3404         }
3405       if (bit (aarch64_insn_r->aarch64_insn, 23))
3406         record_buf[aarch64_insn_r->reg_rec_count++] = reg_rn;
3407     }
3408   /* Load/store register (unsigned immediate) instructions.  */
3409   else if ((insn_bits24_27 & 0x0b) == 0x09 && insn_bits28_29 == 0x03)
3410     {
3411       opc = bits (aarch64_insn_r->aarch64_insn, 22, 23);
3412       if (!(opc >> 1))
3413         if (opc & 0x01)
3414           ld_flag = 0x01;
3415         else
3416           ld_flag = 0x0;
3417       else
3418         if (size_bits != 0x03)
3419           ld_flag = 0x01;
3420         else
3421           return AARCH64_RECORD_UNKNOWN;
3422
3423       if (record_debug)
3424         {
3425           debug_printf ("Process record: load/store (unsigned immediate):"
3426                         " size %x V %d opc %x\n", size_bits, vector_flag,
3427                         opc);
3428         }
3429
3430       if (!ld_flag)
3431         {
3432           offset = bits (aarch64_insn_r->aarch64_insn, 10, 21);
3433           datasize = 8 << size_bits;
3434           regcache_raw_read_unsigned (aarch64_insn_r->regcache, reg_rn,
3435                                       &address);
3436           offset = offset << size_bits;
3437           address = address + offset;
3438
3439           record_buf_mem[0] = datasize >> 3;
3440           record_buf_mem[1] = address;
3441           aarch64_insn_r->mem_rec_count = 1;
3442         }
3443       else
3444         {
3445           if (vector_flag)
3446             record_buf[0] = reg_rt + AARCH64_V0_REGNUM;
3447           else
3448             record_buf[0] = reg_rt;
3449           aarch64_insn_r->reg_rec_count = 1;
3450         }
3451     }
3452   /* Load/store register (register offset) instructions.  */
3453   else if ((insn_bits24_27 & 0x0b) == 0x08 && insn_bits28_29 == 0x03
3454            && insn_bits10_11 == 0x02 && insn_bit21)
3455     {
3456       if (record_debug)
3457         debug_printf ("Process record: load/store (register offset)\n");
3458       opc = bits (aarch64_insn_r->aarch64_insn, 22, 23);
3459       if (!(opc >> 1))
3460         if (opc & 0x01)
3461           ld_flag = 0x01;
3462         else
3463           ld_flag = 0x0;
3464       else
3465         if (size_bits != 0x03)
3466           ld_flag = 0x01;
3467         else
3468           return AARCH64_RECORD_UNKNOWN;
3469
3470       if (!ld_flag)
3471         {
3472           ULONGEST reg_rm_val;
3473
3474           regcache_raw_read_unsigned (aarch64_insn_r->regcache,
3475                      bits (aarch64_insn_r->aarch64_insn, 16, 20), &reg_rm_val);
3476           if (bit (aarch64_insn_r->aarch64_insn, 12))
3477             offset = reg_rm_val << size_bits;
3478           else
3479             offset = reg_rm_val;
3480           datasize = 8 << size_bits;
3481           regcache_raw_read_unsigned (aarch64_insn_r->regcache, reg_rn,
3482                                       &address);
3483           address = address + offset;
3484           record_buf_mem[0] = datasize >> 3;
3485           record_buf_mem[1] = address;
3486           aarch64_insn_r->mem_rec_count = 1;
3487         }
3488       else
3489         {
3490           if (vector_flag)
3491             record_buf[0] = reg_rt + AARCH64_V0_REGNUM;
3492           else
3493             record_buf[0] = reg_rt;
3494           aarch64_insn_r->reg_rec_count = 1;
3495         }
3496     }
3497   /* Load/store register (immediate and unprivileged) instructions.  */
3498   else if ((insn_bits24_27 & 0x0b) == 0x08 && insn_bits28_29 == 0x03
3499            && !insn_bit21)
3500     {
3501       if (record_debug)
3502         {
3503           debug_printf ("Process record: load/store "
3504                         "(immediate and unprivileged)\n");
3505         }
3506       opc = bits (aarch64_insn_r->aarch64_insn, 22, 23);
3507       if (!(opc >> 1))
3508         if (opc & 0x01)
3509           ld_flag = 0x01;
3510         else
3511           ld_flag = 0x0;
3512       else
3513         if (size_bits != 0x03)
3514           ld_flag = 0x01;
3515         else
3516           return AARCH64_RECORD_UNKNOWN;
3517
3518       if (!ld_flag)
3519         {
3520           uint16_t imm9_off;
3521           imm9_off = bits (aarch64_insn_r->aarch64_insn, 12, 20);
3522           offset = (imm9_off & 0x0100) ? (((~imm9_off) & 0x01ff) + 1) : imm9_off;
3523           datasize = 8 << size_bits;
3524           regcache_raw_read_unsigned (aarch64_insn_r->regcache, reg_rn,
3525                                       &address);
3526           if (insn_bits10_11 != 0x01)
3527             {
3528               if (imm9_off & 0x0100)
3529                 address = address - offset;
3530               else
3531                 address = address + offset;
3532             }
3533           record_buf_mem[0] = datasize >> 3;
3534           record_buf_mem[1] = address;
3535           aarch64_insn_r->mem_rec_count = 1;
3536         }
3537       else
3538         {
3539           if (vector_flag)
3540             record_buf[0] = reg_rt + AARCH64_V0_REGNUM;
3541           else
3542             record_buf[0] = reg_rt;
3543           aarch64_insn_r->reg_rec_count = 1;
3544         }
3545       if (insn_bits10_11 == 0x01 || insn_bits10_11 == 0x03)
3546         record_buf[aarch64_insn_r->reg_rec_count++] = reg_rn;
3547     }
3548   /* Advanced SIMD load/store instructions.  */
3549   else
3550     return aarch64_record_asimd_load_store (aarch64_insn_r);
3551
3552   MEM_ALLOC (aarch64_insn_r->aarch64_mems, aarch64_insn_r->mem_rec_count,
3553              record_buf_mem);
3554   REG_ALLOC (aarch64_insn_r->aarch64_regs, aarch64_insn_r->reg_rec_count,
3555              record_buf);
3556   return AARCH64_RECORD_SUCCESS;
3557 }
3558
3559 /* Record handler for data processing SIMD and floating point instructions.  */
3560
3561 static unsigned int
3562 aarch64_record_data_proc_simd_fp (insn_decode_record *aarch64_insn_r)
3563 {
3564   uint8_t insn_bit21, opcode, rmode, reg_rd;
3565   uint8_t insn_bits24_27, insn_bits28_31, insn_bits10_11, insn_bits12_15;
3566   uint8_t insn_bits11_14;
3567   uint32_t record_buf[2];
3568
3569   insn_bits24_27 = bits (aarch64_insn_r->aarch64_insn, 24, 27);
3570   insn_bits28_31 = bits (aarch64_insn_r->aarch64_insn, 28, 31);
3571   insn_bits10_11 = bits (aarch64_insn_r->aarch64_insn, 10, 11);
3572   insn_bits12_15 = bits (aarch64_insn_r->aarch64_insn, 12, 15);
3573   insn_bits11_14 = bits (aarch64_insn_r->aarch64_insn, 11, 14);
3574   opcode = bits (aarch64_insn_r->aarch64_insn, 16, 18);
3575   rmode = bits (aarch64_insn_r->aarch64_insn, 19, 20);
3576   reg_rd = bits (aarch64_insn_r->aarch64_insn, 0, 4);
3577   insn_bit21 = bit (aarch64_insn_r->aarch64_insn, 21);
3578
3579   if (record_debug)
3580     debug_printf ("Process record: data processing SIMD/FP: ");
3581
3582   if ((insn_bits28_31 & 0x05) == 0x01 && insn_bits24_27 == 0x0e)
3583     {
3584       /* Floating point - fixed point conversion instructions.  */
3585       if (!insn_bit21)
3586         {
3587           if (record_debug)
3588             debug_printf ("FP - fixed point conversion");
3589
3590           if ((opcode >> 1) == 0x0 && rmode == 0x03)
3591             record_buf[0] = reg_rd;
3592           else
3593             record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3594         }
3595       /* Floating point - conditional compare instructions.  */
3596       else if (insn_bits10_11 == 0x01)
3597         {
3598           if (record_debug)
3599             debug_printf ("FP - conditional compare");
3600
3601           record_buf[0] = AARCH64_CPSR_REGNUM;
3602         }
3603       /* Floating point - data processing (2-source) and
3604          conditional select instructions.  */
3605       else if (insn_bits10_11 == 0x02 || insn_bits10_11 == 0x03)
3606         {
3607           if (record_debug)
3608             debug_printf ("FP - DP (2-source)");
3609
3610           record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3611         }
3612       else if (insn_bits10_11 == 0x00)
3613         {
3614           /* Floating point - immediate instructions.  */
3615           if ((insn_bits12_15 & 0x01) == 0x01
3616               || (insn_bits12_15 & 0x07) == 0x04)
3617             {
3618               if (record_debug)
3619                 debug_printf ("FP - immediate");
3620               record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3621             }
3622           /* Floating point - compare instructions.  */
3623           else if ((insn_bits12_15 & 0x03) == 0x02)
3624             {
3625               if (record_debug)
3626                 debug_printf ("FP - immediate");
3627               record_buf[0] = AARCH64_CPSR_REGNUM;
3628             }
3629           /* Floating point - integer conversions instructions.  */
3630           else if (insn_bits12_15 == 0x00)
3631             {
3632               /* Convert float to integer instruction.  */
3633               if (!(opcode >> 1) || ((opcode >> 1) == 0x02 && !rmode))
3634                 {
3635                   if (record_debug)
3636                     debug_printf ("float to int conversion");
3637
3638                   record_buf[0] = reg_rd + AARCH64_X0_REGNUM;
3639                 }
3640               /* Convert integer to float instruction.  */
3641               else if ((opcode >> 1) == 0x01 && !rmode)
3642                 {
3643                   if (record_debug)
3644                     debug_printf ("int to float conversion");
3645
3646                   record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3647                 }
3648               /* Move float to integer instruction.  */
3649               else if ((opcode >> 1) == 0x03)
3650                 {
3651                   if (record_debug)
3652                     debug_printf ("move float to int");
3653
3654                   if (!(opcode & 0x01))
3655                     record_buf[0] = reg_rd + AARCH64_X0_REGNUM;
3656                   else
3657                     record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3658                 }
3659               else
3660                 return AARCH64_RECORD_UNKNOWN;
3661             }
3662           else
3663             return AARCH64_RECORD_UNKNOWN;
3664         }
3665       else
3666         return AARCH64_RECORD_UNKNOWN;
3667     }
3668   else if ((insn_bits28_31 & 0x09) == 0x00 && insn_bits24_27 == 0x0e)
3669     {
3670       if (record_debug)
3671         debug_printf ("SIMD copy");
3672
3673       /* Advanced SIMD copy instructions.  */
3674       if (!bits (aarch64_insn_r->aarch64_insn, 21, 23)
3675           && !bit (aarch64_insn_r->aarch64_insn, 15)
3676           && bit (aarch64_insn_r->aarch64_insn, 10))
3677         {
3678           if (insn_bits11_14 == 0x05 || insn_bits11_14 == 0x07)
3679             record_buf[0] = reg_rd + AARCH64_X0_REGNUM;
3680           else
3681             record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3682         }
3683       else
3684         record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3685     }
3686   /* All remaining floating point or advanced SIMD instructions.  */
3687   else
3688     {
3689       if (record_debug)
3690         debug_printf ("all remain");
3691
3692       record_buf[0] = reg_rd + AARCH64_V0_REGNUM;
3693     }
3694
3695   if (record_debug)
3696     debug_printf ("\n");
3697
3698   aarch64_insn_r->reg_rec_count++;
3699   gdb_assert (aarch64_insn_r->reg_rec_count == 1);
3700   REG_ALLOC (aarch64_insn_r->aarch64_regs, aarch64_insn_r->reg_rec_count,
3701              record_buf);
3702   return AARCH64_RECORD_SUCCESS;
3703 }
3704
3705 /* Decodes insns type and invokes its record handler.  */
3706
3707 static unsigned int
3708 aarch64_record_decode_insn_handler (insn_decode_record *aarch64_insn_r)
3709 {
3710   uint32_t ins_bit25, ins_bit26, ins_bit27, ins_bit28;
3711
3712   ins_bit25 = bit (aarch64_insn_r->aarch64_insn, 25);
3713   ins_bit26 = bit (aarch64_insn_r->aarch64_insn, 26);
3714   ins_bit27 = bit (aarch64_insn_r->aarch64_insn, 27);
3715   ins_bit28 = bit (aarch64_insn_r->aarch64_insn, 28);
3716
3717   /* Data processing - immediate instructions.  */
3718   if (!ins_bit26 && !ins_bit27 && ins_bit28)
3719     return aarch64_record_data_proc_imm (aarch64_insn_r);
3720
3721   /* Branch, exception generation and system instructions.  */
3722   if (ins_bit26 && !ins_bit27 && ins_bit28)
3723     return aarch64_record_branch_except_sys (aarch64_insn_r);
3724
3725   /* Load and store instructions.  */
3726   if (!ins_bit25 && ins_bit27)
3727     return aarch64_record_load_store (aarch64_insn_r);
3728
3729   /* Data processing - register instructions.  */
3730   if (ins_bit25 && !ins_bit26 && ins_bit27)
3731     return aarch64_record_data_proc_reg (aarch64_insn_r);
3732
3733   /* Data processing - SIMD and floating point instructions.  */
3734   if (ins_bit25 && ins_bit26 && ins_bit27)
3735     return aarch64_record_data_proc_simd_fp (aarch64_insn_r);
3736
3737   return AARCH64_RECORD_UNSUPPORTED;
3738 }
3739
3740 /* Cleans up local record registers and memory allocations.  */
3741
3742 static void
3743 deallocate_reg_mem (insn_decode_record *record)
3744 {
3745   xfree (record->aarch64_regs);
3746   xfree (record->aarch64_mems);
3747 }
3748
3749 /* Parse the current instruction and record the values of the registers and
3750    memory that will be changed in current instruction to record_arch_list
3751    return -1 if something is wrong.  */
3752
3753 int
3754 aarch64_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
3755                         CORE_ADDR insn_addr)
3756 {
3757   uint32_t rec_no = 0;
3758   uint8_t insn_size = 4;
3759   uint32_t ret = 0;
3760   gdb_byte buf[insn_size];
3761   insn_decode_record aarch64_record;
3762
3763   memset (&buf[0], 0, insn_size);
3764   memset (&aarch64_record, 0, sizeof (insn_decode_record));
3765   target_read_memory (insn_addr, &buf[0], insn_size);
3766   aarch64_record.aarch64_insn
3767     = (uint32_t) extract_unsigned_integer (&buf[0],
3768                                            insn_size,
3769                                            gdbarch_byte_order (gdbarch));
3770   aarch64_record.regcache = regcache;
3771   aarch64_record.this_addr = insn_addr;
3772   aarch64_record.gdbarch = gdbarch;
3773
3774   ret = aarch64_record_decode_insn_handler (&aarch64_record);
3775   if (ret == AARCH64_RECORD_UNSUPPORTED)
3776     {
3777       printf_unfiltered (_("Process record does not support instruction "
3778                            "0x%0x at address %s.\n"),
3779                          aarch64_record.aarch64_insn,
3780                          paddress (gdbarch, insn_addr));
3781       ret = -1;
3782     }
3783
3784   if (0 == ret)
3785     {
3786       /* Record registers.  */
3787       record_full_arch_list_add_reg (aarch64_record.regcache,
3788                                      AARCH64_PC_REGNUM);
3789       /* Always record register CPSR.  */
3790       record_full_arch_list_add_reg (aarch64_record.regcache,
3791                                      AARCH64_CPSR_REGNUM);
3792       if (aarch64_record.aarch64_regs)
3793         for (rec_no = 0; rec_no < aarch64_record.reg_rec_count; rec_no++)
3794           if (record_full_arch_list_add_reg (aarch64_record.regcache,
3795                                              aarch64_record.aarch64_regs[rec_no]))
3796             ret = -1;
3797
3798       /* Record memories.  */
3799       if (aarch64_record.aarch64_mems)
3800         for (rec_no = 0; rec_no < aarch64_record.mem_rec_count; rec_no++)
3801           if (record_full_arch_list_add_mem
3802               ((CORE_ADDR)aarch64_record.aarch64_mems[rec_no].addr,
3803                aarch64_record.aarch64_mems[rec_no].len))
3804             ret = -1;
3805
3806       if (record_full_arch_list_add_end ())
3807         ret = -1;
3808     }
3809
3810   deallocate_reg_mem (&aarch64_record);
3811   return ret;
3812 }