gdb/nios2-tdep.c

   1 /* Target-machine dependent code for Nios II, for GDB.
   2    Copyright (C) 2012-2014 Free Software Foundation, Inc.
   3    Contributed by Peter Brookes (pbrookes@altera.com)
   4    and Andrew Draper (adraper@altera.com).
   5    Contributed by Mentor Graphics, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "frame-unwind.h"
  25 #include "frame-base.h"
  26 #include "trad-frame.h"
  27 #include "dwarf2-frame.h"
  28 #include "symtab.h"
  29 #include "inferior.h"
  30 #include "gdbtypes.h"
  31 #include "gdbcore.h"
  32 #include "gdbcmd.h"
  33 #include "osabi.h"
  34 #include "target.h"
  35 #include "dis-asm.h"
  36 #include "regcache.h"
  37 #include "value.h"
  38 #include "symfile.h"
  39 #include "arch-utils.h"
  40 #include "floatformat.h"
  41 #include "infcall.h"
  42 #include "regset.h"
  43 #include "target-descriptions.h"
  44
  45 /* To get entry_point_address.  */
  46 #include "objfiles.h"
  47
  48 /* Nios II ISA specific encodings and macros.  */
  49 #include "opcode/nios2.h"
  50
  51 /* Nios II specific header.  */
  52 #include "nios2-tdep.h"
  53
  54 #include "features/nios2.c"
  55
  56 /* Control debugging information emitted in this file.  */
  57
  58 static int nios2_debug = 0;
  59
  60 /* The following structures are used in the cache for prologue
  61    analysis; see the reg_value and reg_saved tables in
  62    struct nios2_unwind_cache, respectively.  */
  63
  64 /* struct reg_value is used to record that a register has the same value
  65    as reg at the given offset from the start of a function.  */
  66
  67 struct reg_value
  68 {
  69   int reg;
  70   unsigned int offset;
  71 };
  72
  73 /* struct reg_saved is used to record that a register value has been saved at
  74    basereg + addr, for basereg >= 0.  If basereg < 0, that indicates
  75    that the register is not known to have been saved.  Note that when
  76    basereg == NIOS2_Z_REGNUM (that is, r0, which holds value 0),
  77    addr is an absolute address.  */
  78
  79 struct reg_saved
  80 {
  81   int basereg;
  82   CORE_ADDR addr;
  83 };
  84
  85 struct nios2_unwind_cache
  86 {
  87   /* The frame's base, optionally used by the high-level debug info.  */
  88   CORE_ADDR base;
  89
  90   /* The previous frame's inner most stack address.  Used as this
  91      frame ID's stack_addr.  */
  92   CORE_ADDR cfa;
  93
  94   /* The address of the first instruction in this function.  */
  95   CORE_ADDR pc;
  96
  97   /* Which register holds the return address for the frame.  */
  98   int return_regnum;
  99
 100   /* Table indicating what changes have been made to each register.  */
 101   struct reg_value reg_value[NIOS2_NUM_REGS];
 102
 103   /* Table indicating where each register has been saved.  */
 104   struct reg_saved reg_saved[NIOS2_NUM_REGS];
 105 };
 106
 107
 108 /* This array is a mapping from Dwarf-2 register numbering to GDB's.  */
 109
 110 static int nios2_dwarf2gdb_regno_map[] =
 111 {
 112   0, 1, 2, 3,
 113   4, 5, 6, 7,
 114   8, 9, 10, 11,
 115   12, 13, 14, 15,
 116   16, 17, 18, 19,
 117   20, 21, 22, 23,
 118   24, 25,
 119   NIOS2_GP_REGNUM,        /* 26 */
 120   NIOS2_SP_REGNUM,        /* 27 */
 121   NIOS2_FP_REGNUM,        /* 28 */
 122   NIOS2_EA_REGNUM,        /* 29 */
 123   NIOS2_BA_REGNUM,        /* 30 */
 124   NIOS2_RA_REGNUM,        /* 31 */
 125   NIOS2_PC_REGNUM,        /* 32 */
 126   NIOS2_STATUS_REGNUM,    /* 33 */
 127   NIOS2_ESTATUS_REGNUM,   /* 34 */
 128   NIOS2_BSTATUS_REGNUM,   /* 35 */
 129   NIOS2_IENABLE_REGNUM,   /* 36 */
 130   NIOS2_IPENDING_REGNUM,  /* 37 */
 131   NIOS2_CPUID_REGNUM,     /* 38 */
 132   39, /* CTL6 */          /* 39 */
 133   NIOS2_EXCEPTION_REGNUM, /* 40 */
 134   NIOS2_PTEADDR_REGNUM,   /* 41 */
 135   NIOS2_TLBACC_REGNUM,    /* 42 */
 136   NIOS2_TLBMISC_REGNUM,   /* 43 */
 137   NIOS2_ECCINJ_REGNUM,    /* 44 */
 138   NIOS2_BADADDR_REGNUM,   /* 45 */
 139   NIOS2_CONFIG_REGNUM,    /* 46 */
 140   NIOS2_MPUBASE_REGNUM,   /* 47 */
 141   NIOS2_MPUACC_REGNUM     /* 48 */
 142 };
 143
 144
 145 /* Implement the dwarf2_reg_to_regnum gdbarch method.  */
 146
 147 static int
 148 nios2_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int dw_reg)
 149 {
 150   if (dw_reg < 0 || dw_reg > NIOS2_NUM_REGS)
 151     {
 152       warning (_("Dwarf-2 uses unmapped register #%d"), dw_reg);
 153       return dw_reg;
 154     }
 155
 156   return nios2_dwarf2gdb_regno_map[dw_reg];
 157 }
 158
 159 /* Canonical names for the 49 registers.  */
 160
 161 static const char *const nios2_reg_names[NIOS2_NUM_REGS] =
 162 {
 163   "zero", "at", "r2", "r3", "r4", "r5", "r6", "r7",
 164   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 165   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 166   "et", "bt", "gp", "sp", "fp", "ea", "sstatus", "ra",
 167   "pc",
 168   "status", "estatus", "bstatus", "ienable",
 169   "ipending", "cpuid", "ctl6", "exception",
 170   "pteaddr", "tlbacc", "tlbmisc", "eccinj",
 171   "badaddr", "config", "mpubase", "mpuacc"
 172 };
 173
 174 /* Implement the register_name gdbarch method.  */
 175
 176 static const char *
 177 nios2_register_name (struct gdbarch *gdbarch, int regno)
 178 {
 179   /* Use mnemonic aliases for GPRs.  */
 180   if (regno >= 0 && regno < NIOS2_NUM_REGS)
 181     return nios2_reg_names[regno];
 182   else
 183     return tdesc_register_name (gdbarch, regno);
 184 }
 185
 186 /* Implement the register_type gdbarch method.  */
 187
 188 static struct type *
 189 nios2_register_type (struct gdbarch *gdbarch, int regno)
 190 {
 191   /* If the XML description has register information, use that to
 192      determine the register type.  */
 193   if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
 194     return tdesc_register_type (gdbarch, regno);
 195
 196   if (regno == NIOS2_PC_REGNUM)
 197     return builtin_type (gdbarch)->builtin_func_ptr;
 198   else if (regno == NIOS2_SP_REGNUM)
 199     return builtin_type (gdbarch)->builtin_data_ptr;
 200   else
 201     return builtin_type (gdbarch)->builtin_uint32;
 202 }
 203
 204 /* Given a return value in REGCACHE with a type VALTYPE,
 205    extract and copy its value into VALBUF.  */
 206
 207 static void
 208 nios2_extract_return_value (struct gdbarch *gdbarch, struct type *valtype,
 209                             struct regcache *regcache, gdb_byte *valbuf)
 210 {
 211   int len = TYPE_LENGTH (valtype);
 212
 213   /* Return values of up to 8 bytes are returned in $r2 $r3.  */
 214   if (len <= register_size (gdbarch, NIOS2_R2_REGNUM))
 215     regcache_cooked_read (regcache, NIOS2_R2_REGNUM, valbuf);
 216   else
 217     {
 218       gdb_assert (len <= (register_size (gdbarch, NIOS2_R2_REGNUM)
 219                           + register_size (gdbarch, NIOS2_R3_REGNUM)));
 220       regcache_cooked_read (regcache, NIOS2_R2_REGNUM, valbuf);
 221       regcache_cooked_read (regcache, NIOS2_R3_REGNUM, valbuf + 4);
 222     }
 223 }
 224
 225 /* Write into appropriate registers a function return value
 226    of type TYPE, given in virtual format.  */
 227
 228 static void
 229 nios2_store_return_value (struct gdbarch *gdbarch, struct type *valtype,
 230                           struct regcache *regcache, const gdb_byte *valbuf)
 231 {
 232   int len = TYPE_LENGTH (valtype);
 233
 234   /* Return values of up to 8 bytes are returned in $r2 $r3.  */
 235   if (len <= register_size (gdbarch, NIOS2_R2_REGNUM))
 236     regcache_cooked_write (regcache, NIOS2_R2_REGNUM, valbuf);
 237   else
 238     {
 239       gdb_assert (len <= (register_size (gdbarch, NIOS2_R2_REGNUM)
 240                           + register_size (gdbarch, NIOS2_R3_REGNUM)));
 241       regcache_cooked_write (regcache, NIOS2_R2_REGNUM, valbuf);
 242       regcache_cooked_write (regcache, NIOS2_R3_REGNUM, valbuf + 4);
 243     }
 244 }
 245
 246
 247 /* Set up the default values of the registers.  */
 248
 249 static void
 250 nios2_setup_default (struct nios2_unwind_cache *cache)
 251 {
 252   int i;
 253
 254   for (i = 0; i < NIOS2_NUM_REGS; i++)
 255   {
 256     /* All registers start off holding their previous values.  */
 257     cache->reg_value[i].reg    = i;
 258     cache->reg_value[i].offset = 0;
 259
 260     /* All registers start off not saved.  */
 261     cache->reg_saved[i].basereg = -1;
 262     cache->reg_saved[i].addr    = 0;
 263   }
 264 }
 265
 266 /* Initialize the unwind cache.  */
 267
 268 static void
 269 nios2_init_cache (struct nios2_unwind_cache *cache, CORE_ADDR pc)
 270 {
 271   cache->base = 0;
 272   cache->cfa = 0;
 273   cache->pc = pc;
 274   cache->return_regnum = NIOS2_RA_REGNUM;
 275   nios2_setup_default (cache);
 276 }
 277
 278 /* Helper function to identify when we're in a function epilogue;
 279    that is, the part of the function from the point at which the
 280    stack adjustment is made, to the return or sibcall.  On Nios II,
 281    we want to check that the CURRENT_PC is a return-type instruction
 282    and that the previous instruction is a stack adjustment.
 283    START_PC is the beginning of the function in question.  */
 284
 285 static int
 286 nios2_in_epilogue_p (struct gdbarch *gdbarch,
 287                      CORE_ADDR current_pc,
 288                      CORE_ADDR start_pc)
 289 {
 290   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 291
 292   /* There has to be a previous instruction in the function.  */
 293   if (current_pc > start_pc)
 294     {
 295
 296       /* Check whether the previous instruction was a stack
 297          adjustment.  */
 298       unsigned int insn
 299         = read_memory_unsigned_integer (current_pc - NIOS2_OPCODE_SIZE,
 300                                         NIOS2_OPCODE_SIZE, byte_order);
 301
 302       if ((insn & 0xffc0003c) == 0xdec00004     /* ADDI sp, sp, */
 303           || (insn & 0xffc1ffff) == 0xdec1883a  /* ADD  sp, sp, */
 304           || (insn & 0xffc0003f) == 0xdec00017) /* LDW  sp, constant(sp) */
 305         {
 306           /* Then check if it's followed by a return or a tail
 307              call.  */
 308           insn = read_memory_unsigned_integer (current_pc, NIOS2_OPCODE_SIZE,
 309                                                byte_order);
 310
 311           if (insn == 0xf800283a                        /* RET */
 312               || insn == 0xe800083a                     /* ERET */
 313               || (insn & 0x07ffffff) == 0x0000683a      /* JMP */
 314               || (insn & 0xffc0003f) == 6)              /* BR */
 315             return 1;
 316         }
 317     }
 318   return 0;
 319 }
 320
 321 /* Implement the in_function_epilogue_p gdbarch method.  */
 322
 323 static int
 324 nios2_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc)
 325 {
 326   CORE_ADDR func_addr;
 327
 328   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
 329     return nios2_in_epilogue_p (gdbarch, pc, func_addr);
 330
 331   return 0;
 332 }
 333
 334 /* Define some instruction patterns supporting wildcard bits via a
 335    mask.  */
 336
 337 typedef struct
 338 {
 339   unsigned int insn;
 340   unsigned int mask;
 341 } wild_insn;
 342
 343 static const wild_insn profiler_insn[] =
 344 {
 345   { 0x0010e03a, 0x00000000 }, /* nextpc r8 */
 346   { 0xf813883a, 0x00000000 }, /* mov    r9,ra */
 347   { 0x02800034, 0x003fffc0 }, /* movhi  r10,257 */
 348   { 0x52800004, 0x003fffc0 }, /* addi   r10,r10,-31992 */
 349   { 0x00000000, 0xffffffc0 }, /* call   <mcount> */
 350   { 0x483f883a, 0x00000000 }  /* mov    ra,r9 */
 351 };
 352
 353 static const wild_insn irqentry_insn[] =
 354 {
 355   { 0x0031307a, 0x00000000 }, /* rdctl  et,estatus */
 356   { 0xc600004c, 0x00000000 }, /* andi   et,et,1 */
 357   { 0xc0000026, 0x003fffc0 }, /* beq    et,zero, <software_exception> */
 358   { 0x0031313a, 0x00000000 }, /* rdctl  et,ipending */
 359   { 0xc0000026, 0x003fffc0 }  /* beq    et,zero, <software_exception> */
 360 };
 361
 362
 363 /* Attempt to match SEQUENCE, which is COUNT insns long, at START_PC.  */
 364
 365 static int
 366 nios2_match_sequence (struct gdbarch *gdbarch, CORE_ADDR start_pc,
 367                       const wild_insn *sequence, int count)
 368 {
 369   CORE_ADDR pc = start_pc;
 370   int i;
 371   unsigned int insn;
 372   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 373
 374   for (i = 0 ; i < count ; i++)
 375     {
 376       insn = read_memory_unsigned_integer (pc, NIOS2_OPCODE_SIZE, byte_order);
 377       if ((insn & ~sequence[i].mask) != sequence[i].insn)
 378         return 0;
 379
 380       pc += NIOS2_OPCODE_SIZE;
 381     }
 382
 383   return 1;
 384 }
 385
 386 /* Do prologue analysis, returning the PC of the first instruction
 387    after the function prologue.  Assumes CACHE has already been
 388    initialized.  THIS_FRAME can be null, in which case we are only
 389    interested in skipping the prologue.  Otherwise CACHE is filled in
 390    from the frame information.
 391
 392    The prologue will consist of the following parts:
 393      1) Optional profiling instrumentation.  The old version uses six
 394         instructions.  We step over this if there is an exact match.
 395           nextpc r8
 396           mov    r9, ra
 397           movhi  r10, %hiadj(.LP2)
 398           addi   r10, r10, %lo(.LP2)
 399           call   mcount
 400           mov    ra, r9
 401         The new version uses two or three instructions (the last of
 402         these might get merged in with the STW which saves RA to the
 403         stack).  We interpret these.
 404           mov    r8, ra
 405           call   mcount
 406           mov    ra, r8
 407
 408      2) Optional interrupt entry decision.  Again, we step over
 409         this if there is an exact match.
 410           rdctl  et,estatus
 411           andi   et,et,1
 412           beq    et,zero, <software_exception>
 413           rdctl  et,ipending
 414           beq    et,zero, <software_exception>
 415
 416      3) A stack adjustment or stack which, which will be one of:
 417           addi   sp, sp, -constant
 418         or:
 419           movi   r8, constant
 420           sub    sp, sp, r8
 421         or
 422           movhi  r8, constant
 423           addi   r8, r8, constant
 424           sub    sp, sp, r8
 425         or
 426           movhi  rx, %hiadj(newstack)
 427           addhi  rx, rx, %lo(newstack)
 428           stw    sp, constant(rx)
 429           mov    sp, rx
 430
 431      4) An optional stack check, which can take either of these forms:
 432           bgeu   sp, rx, +8
 433           break  3
 434         or
 435           bltu   sp, rx, .Lstack_overflow
 436           ...
 437         .Lstack_overflow:
 438           break  3
 439
 440      5) Saving any registers which need to be saved.  These will
 441         normally just be stored onto the stack:
 442           stw    rx, constant(sp)
 443         but in the large frame case will use r8 as an offset back
 444         to the cfa:
 445           add    r8, r8, sp
 446           stw    rx, -constant(r8)
 447
 448         Saving control registers looks slightly different:
 449           rdctl  rx, ctlN
 450           stw    rx, constant(sp)
 451
 452      6) An optional FP setup, either if the user has requested a
 453         frame pointer or if the function calls alloca.
 454         This is always:
 455           mov    fp, sp
 456
 457     The prologue instructions may be interleaved, and the register
 458     saves and FP setup can occur in either order.
 459
 460     To cope with all this variability we decode all the instructions
 461     from the start of the prologue until we hit a branch, call or
 462     return.  For each of the instructions mentioned in 3, 4 and 5 we
 463     handle the limited cases of stores to the stack and operations
 464     on constant values.  */
 465
 466 static CORE_ADDR
 467 nios2_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc,
 468                         const CORE_ADDR current_pc,
 469                         struct nios2_unwind_cache *cache,
 470                         struct frame_info *this_frame)
 471 {
 472   /* Maximum lines of prologue to check.
 473      Note that this number should not be too large, else we can
 474      potentially end up iterating through unmapped memory.  */
 475   CORE_ADDR limit_pc = start_pc + 200;
 476   int regno;
 477   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 478
 479   /* Does the frame set up the FP register?  */
 480   int base_reg = 0;
 481
 482   struct reg_value *value = cache->reg_value;
 483   struct reg_value temp_value[NIOS2_NUM_REGS];
 484
 485   int i;
 486
 487   /* Save the starting PC so we can correct the pc after running
 488      through the prolog, using symbol info.  */
 489   CORE_ADDR pc = start_pc;
 490
 491   /* Is this an exception handler?  */
 492   int exception_handler = 0;
 493
 494   /* What was the original value of SP (or fake original value for
 495      functions which switch stacks?  */
 496   CORE_ADDR frame_high;
 497
 498   /* Is this the end of the prologue?  */
 499   int within_prologue = 1;
 500
 501   CORE_ADDR prologue_end;
 502
 503   /* Is this the innermost function?  */
 504   int innermost = (this_frame ? (frame_relative_level (this_frame) == 0) : 1);
 505
 506   if (nios2_debug)
 507     fprintf_unfiltered (gdb_stdlog,
 508                         "{ nios2_analyze_prologue start=%s, current=%s ",
 509                         paddress (gdbarch, start_pc),
 510                         paddress (gdbarch, current_pc));
 511
 512   /* Set up the default values of the registers.  */
 513   nios2_setup_default (cache);
 514
 515   /* If the first few instructions are the profile entry, then skip
 516      over them.  Newer versions of the compiler use more efficient
 517      profiling code.  */
 518   if (nios2_match_sequence (gdbarch, pc, profiler_insn,
 519                             ARRAY_SIZE (profiler_insn)))
 520     pc += ARRAY_SIZE (profiler_insn) * NIOS2_OPCODE_SIZE;
 521
 522   /* If the first few instructions are an interrupt entry, then skip
 523      over them too.  */
 524   if (nios2_match_sequence (gdbarch, pc, irqentry_insn,
 525                             ARRAY_SIZE (irqentry_insn)))
 526     {
 527       pc += ARRAY_SIZE (irqentry_insn) * NIOS2_OPCODE_SIZE;
 528       exception_handler = 1;
 529     }
 530
 531   prologue_end = start_pc;
 532
 533   /* Find the prologue instructions.  */
 534   while (pc < limit_pc && within_prologue)
 535     {
 536       /* Present instruction.  */
 537       uint32_t insn;
 538
 539       int prologue_insn = 0;
 540
 541       if (pc == current_pc)
 542       {
 543         /* When we reach the current PC we must save the current
 544            register state (for the backtrace) but keep analysing
 545            because there might be more to find out (eg. is this an
 546            exception handler).  */
 547         memcpy (temp_value, value, sizeof (temp_value));
 548         value = temp_value;
 549         if (nios2_debug)
 550           fprintf_unfiltered (gdb_stdlog, "*");
 551       }
 552
 553       insn = read_memory_unsigned_integer (pc, NIOS2_OPCODE_SIZE, byte_order);
 554       pc += NIOS2_OPCODE_SIZE;
 555
 556       if (nios2_debug)
 557         fprintf_unfiltered (gdb_stdlog, "[%08X]", insn);
 558
 559       /* The following instructions can appear in the prologue.  */
 560
 561       if ((insn & MASK_R1_ADD) == MATCH_R1_ADD)
 562         {
 563           /* ADD   rc, ra, rb  (also used for MOV) */
 564
 565           int ra = GET_IW_R_A (insn);
 566           int rb = GET_IW_R_B (insn);
 567           int rc = GET_IW_R_C (insn);
 568
 569           if (rc == NIOS2_SP_REGNUM
 570               && rb == 0
 571               && value[ra].reg == cache->reg_saved[NIOS2_SP_REGNUM].basereg)
 572             {
 573               /* If the previous value of SP is available somewhere
 574                  near the new stack pointer value then this is a
 575                  stack switch.  */
 576
 577               /* If any registers were saved on the stack before then
 578                  we can't backtrace into them now.  */
 579               for (i = 0 ; i < NIOS2_NUM_REGS ; i++)
 580                 {
 581                   if (cache->reg_saved[i].basereg == NIOS2_SP_REGNUM)
 582                     cache->reg_saved[i].basereg = -1;
 583                   if (value[i].reg == NIOS2_SP_REGNUM)
 584                     value[i].reg = -1;
 585                 }
 586
 587               /* Create a fake "high water mark" 4 bytes above where SP
 588                  was stored and fake up the registers to be consistent
 589                  with that.  */
 590               value[NIOS2_SP_REGNUM].reg = NIOS2_SP_REGNUM;
 591               value[NIOS2_SP_REGNUM].offset
 592                 = (value[ra].offset
 593                    - cache->reg_saved[NIOS2_SP_REGNUM].addr
 594                    - 4);
 595               cache->reg_saved[NIOS2_SP_REGNUM].basereg = NIOS2_SP_REGNUM;
 596               cache->reg_saved[NIOS2_SP_REGNUM].addr = -4;
 597             }
 598
 599           else if (rc != 0)
 600             {
 601               if (value[rb].reg == 0)
 602                 value[rc].reg = value[ra].reg;
 603               else if (value[ra].reg == 0)
 604                 value[rc].reg = value[rb].reg;
 605               else
 606                 value[rc].reg = -1;
 607               value[rc].offset = value[ra].offset + value[rb].offset;
 608             }
 609           prologue_insn = 1;
 610         }
 611
 612       else if ((insn & MASK_R1_SUB) == MATCH_R1_SUB)
 613         {
 614           /* SUB   rc, ra, rb */
 615
 616           int ra = GET_IW_R_A (insn);
 617           int rb = GET_IW_R_B (insn);
 618           int rc = GET_IW_R_C (insn);
 619
 620           if (rc != 0)
 621             {
 622               if (value[rb].reg == 0)
 623                 value[rc].reg = value[ra].reg;
 624               else
 625                 value[rc].reg = -1;
 626               value[rc].offset = value[ra].offset - value[rb].offset;
 627             }
 628         }
 629
 630       else if ((insn & MASK_R1_ADDI) == MATCH_R1_ADDI)
 631         {
 632           /* ADDI  rb, ra, immed   (also used for MOVI) */
 633           short immed = GET_IW_I_IMM16 (insn);
 634           int ra = GET_IW_I_A (insn);
 635           int rb = GET_IW_I_B (insn);
 636
 637           /* The first stack adjustment is part of the prologue.
 638              Any subsequent stack adjustments are either down to
 639              alloca or the epilogue so stop analysing when we hit
 640              them.  */
 641           if (rb == NIOS2_SP_REGNUM
 642               && (value[rb].offset != 0 || value[ra].reg != NIOS2_SP_REGNUM))
 643             break;
 644
 645           if (rb != 0)
 646             {
 647               value[rb].reg    = value[ra].reg;
 648               value[rb].offset = value[ra].offset + immed;
 649             }
 650
 651           prologue_insn = 1;
 652         }
 653
 654       else if ((insn & MASK_R1_ORHI) == MATCH_R1_ORHI)
 655         {
 656           /* ORHI  rb, ra, immed   (also used for MOVHI) */
 657           unsigned int immed = GET_IW_I_IMM16 (insn);
 658           int ra = GET_IW_I_A (insn);
 659           int rb = GET_IW_I_B (insn);
 660
 661           if (rb != 0)
 662             {
 663               value[rb].reg    = (value[ra].reg == 0) ? 0 : -1;
 664               value[rb].offset = value[ra].offset | (immed << 16);
 665             }
 666         }
 667
 668       else if ((insn & MASK_R1_STW) == MATCH_R1_STW
 669                || (insn & MASK_R1_STWIO) == MATCH_R1_STWIO)
 670         {
 671           /* STW rb, immediate(ra) */
 672
 673           short immed16 = GET_IW_I_IMM16 (insn);
 674           int ra = GET_IW_I_A (insn);
 675           int rb = GET_IW_I_B (insn);
 676
 677           /* Are we storing the original value of a register?
 678              For exception handlers the value of EA-4 (return
 679              address from interrupts etc) is sometimes stored.  */
 680           int orig = value[rb].reg;
 681           if (orig > 0
 682               && (value[rb].offset == 0
 683                   || (orig == NIOS2_EA_REGNUM && value[rb].offset == -4)))
 684             {
 685               /* We are most interested in stores to the stack, but
 686                  also take note of stores to other places as they
 687                  might be useful later.  */
 688               if ((value[ra].reg == NIOS2_SP_REGNUM
 689                    && cache->reg_saved[orig].basereg != NIOS2_SP_REGNUM)
 690                   || cache->reg_saved[orig].basereg == -1)
 691                 {
 692                   if (pc < current_pc)
 693                     {
 694                       /* Save off callee saved registers.  */
 695                       cache->reg_saved[orig].basereg = value[ra].reg;
 696                       cache->reg_saved[orig].addr = value[ra].offset + immed16;
 697                     }
 698
 699                   prologue_insn = 1;
 700
 701                   if (orig == NIOS2_EA_REGNUM || orig == NIOS2_ESTATUS_REGNUM)
 702                     exception_handler = 1;
 703                 }
 704             }
 705           else
 706             /* Non-stack memory writes are not part of the
 707                prologue.  */
 708             within_prologue = 0;
 709         }
 710
 711       else if ((insn & MASK_R1_RDCTL) == MATCH_R1_RDCTL)
 712         {
 713           /* RDCTL rC, ctlN */
 714           int rc = GET_IW_R_C (insn);
 715           int n = GET_IW_R_A (insn);
 716
 717           if (rc != 0)
 718             {
 719               value[rc].reg    = NIOS2_STATUS_REGNUM + n;
 720               value[rc].offset = 0;
 721             }
 722
 723           prologue_insn = 1;
 724         }
 725
 726       else if ((insn & MASK_R1_CALL) == MATCH_R1_CALL
 727                && value[8].reg == NIOS2_RA_REGNUM
 728                && value[8].offset == 0
 729                && value[NIOS2_SP_REGNUM].reg == NIOS2_SP_REGNUM
 730                && value[NIOS2_SP_REGNUM].offset == 0)
 731         {
 732           /* A CALL instruction.  This is treated as a call to mcount
 733              if ra has been stored into r8 beforehand and if it's
 734              before the stack adjust.
 735              Note mcount corrupts r2-r3, r9-r15 & ra.  */
 736           for (i = 2 ; i <= 3 ; i++)
 737             value[i].reg = -1;
 738           for (i = 9 ; i <= 15 ; i++)
 739             value[i].reg = -1;
 740           value[NIOS2_RA_REGNUM].reg = -1;
 741
 742           prologue_insn = 1;
 743         }
 744
 745       else if ((insn & 0xf83fffff) == 0xd800012e)
 746         {
 747            /* BGEU sp, rx, +8
 748               BREAK 3
 749               This instruction sequence is used in stack checking;
 750               we can ignore it.  */
 751           unsigned int next_insn
 752             = read_memory_unsigned_integer (pc, NIOS2_OPCODE_SIZE, byte_order);
 753
 754           if (next_insn != 0x003da0fa)
 755             within_prologue = 0;
 756           else
 757             pc += NIOS2_OPCODE_SIZE;
 758         }
 759
 760       else if ((insn & 0xf800003f) == 0xd8000036)
 761         {
 762            /* BLTU sp, rx, .Lstackoverflow
 763               If the location branched to holds a BREAK 3 instruction
 764               then this is also stack overflow detection.  We can
 765               ignore it.  */
 766           CORE_ADDR target_pc = pc + ((insn & 0x3fffc0) >> 6);
 767           unsigned int target_insn
 768             = read_memory_unsigned_integer (target_pc, NIOS2_OPCODE_SIZE,
 769                                             byte_order);
 770
 771           if (target_insn != 0x003da0fa)
 772             within_prologue = 0;
 773         }
 774
 775       /* Any other instructions are allowed to be moved up into the
 776          prologue.  If we reach a branch, call or return then the
 777          prologue is considered over.  We also consider a second stack
 778          adjustment as terminating the prologue (see above).  */
 779       else
 780         {
 781           switch (GET_IW_R1_OP (insn))
 782             {
 783             case R1_OP_BEQ:
 784             case R1_OP_BGE:
 785             case R1_OP_BGEU:
 786             case R1_OP_BLT:
 787             case R1_OP_BLTU:
 788             case R1_OP_BNE:
 789             case R1_OP_BR:
 790             case R1_OP_CALL:
 791               within_prologue = 0;
 792               break;
 793             case R1_OP_OPX:
 794               if (GET_IW_R_OPX (insn) == R1_OPX_RET
 795                   || GET_IW_R_OPX (insn) == R1_OPX_ERET
 796                   || GET_IW_R_OPX (insn) == R1_OPX_BRET
 797                   || GET_IW_R_OPX (insn) == R1_OPX_CALLR
 798                   || GET_IW_R_OPX (insn) == R1_OPX_JMP)
 799                 within_prologue = 0;
 800               break;
 801             default:
 802               break;
 803             }
 804         }
 805
 806       if (prologue_insn)
 807         prologue_end = pc;
 808     }
 809
 810   /* If THIS_FRAME is NULL, we are being called from skip_prologue
 811      and are only interested in the PROLOGUE_END value, so just
 812      return that now and skip over the cache updates, which depend
 813      on having frame information.  */
 814   if (this_frame == NULL)
 815     return prologue_end;
 816
 817   /* If we are in the function epilogue and have already popped
 818      registers off the stack in preparation for returning, then we
 819      want to go back to the original register values.  */
 820   if (innermost && nios2_in_epilogue_p (gdbarch, current_pc, start_pc))
 821     nios2_setup_default (cache);
 822
 823   /* Exception handlers use a different return address register.  */
 824   if (exception_handler)
 825     cache->return_regnum = NIOS2_EA_REGNUM;
 826
 827   if (nios2_debug)
 828     fprintf_unfiltered (gdb_stdlog, "\n-> retreg=%d, ", cache->return_regnum);
 829
 830   if (cache->reg_value[NIOS2_FP_REGNUM].reg == NIOS2_SP_REGNUM)
 831     /* If the FP now holds an offset from the CFA then this is a
 832        normal frame which uses the frame pointer.  */
 833     base_reg = NIOS2_FP_REGNUM;
 834   else if (cache->reg_value[NIOS2_SP_REGNUM].reg == NIOS2_SP_REGNUM)
 835     /* FP doesn't hold an offset from the CFA.  If SP still holds an
 836        offset from the CFA then we might be in a function which omits
 837        the frame pointer, or we might be partway through the prologue.
 838        In both cases we can find the CFA using SP.  */
 839     base_reg = NIOS2_SP_REGNUM;
 840   else
 841     {
 842       /* Somehow the stack pointer has been corrupted.
 843          We can't return.  */
 844       if (nios2_debug)
 845         fprintf_unfiltered (gdb_stdlog, "<can't reach cfa> }\n");
 846       return 0;
 847     }
 848
 849   if (cache->reg_value[base_reg].offset == 0
 850       || cache->reg_saved[NIOS2_RA_REGNUM].basereg != NIOS2_SP_REGNUM
 851       || cache->reg_saved[cache->return_regnum].basereg != NIOS2_SP_REGNUM)
 852     {
 853       /* If the frame didn't adjust the stack, didn't save RA or
 854          didn't save EA in an exception handler then it must either
 855          be a leaf function (doesn't call any other functions) or it
 856          can't return.  If it has called another function then it
 857          can't be a leaf, so set base == 0 to indicate that we can't
 858          backtrace past it.  */
 859
 860       if (!innermost)
 861         {
 862           /* If it isn't the innermost function then it can't be a
 863              leaf, unless it was interrupted.  Check whether RA for
 864              this frame is the same as PC.  If so then it probably
 865              wasn't interrupted.  */
 866           CORE_ADDR ra
 867             = get_frame_register_unsigned (this_frame, NIOS2_RA_REGNUM);
 868
 869           if (ra == current_pc)
 870             {
 871               if (nios2_debug)
 872                 fprintf_unfiltered
 873                   (gdb_stdlog,
 874                    "<noreturn ADJUST %s, r31@r%d+?>, r%d@r%d+?> }\n",
 875                    paddress (gdbarch, cache->reg_value[base_reg].offset),
 876                    cache->reg_saved[NIOS2_RA_REGNUM].basereg,
 877                    cache->return_regnum,
 878                    cache->reg_saved[cache->return_regnum].basereg);
 879               return 0;
 880             }
 881         }
 882     }
 883
 884   /* Get the value of whichever register we are using for the
 885      base.  */
 886   cache->base = get_frame_register_unsigned (this_frame, base_reg);
 887
 888   /* What was the value of SP at the start of this function (or just
 889      after the stack switch).  */
 890   frame_high = cache->base - cache->reg_value[base_reg].offset;
 891
 892   /* Adjust all the saved registers such that they contain addresses
 893      instead of offsets.  */
 894   for (i = 0; i < NIOS2_NUM_REGS; i++)
 895     if (cache->reg_saved[i].basereg == NIOS2_SP_REGNUM)
 896       {
 897         cache->reg_saved[i].basereg = NIOS2_Z_REGNUM;
 898         cache->reg_saved[i].addr += frame_high;
 899       }
 900
 901   for (i = 0; i < NIOS2_NUM_REGS; i++)
 902     if (cache->reg_saved[i].basereg == NIOS2_GP_REGNUM)
 903       {
 904         CORE_ADDR gp = get_frame_register_unsigned (this_frame,
 905                                                     NIOS2_GP_REGNUM);
 906
 907         for ( ; i < NIOS2_NUM_REGS; i++)
 908           if (cache->reg_saved[i].basereg == NIOS2_GP_REGNUM)
 909             {
 910               cache->reg_saved[i].basereg = NIOS2_Z_REGNUM;
 911               cache->reg_saved[i].addr += gp;
 912             }
 913       }
 914
 915   /* Work out what the value of SP was on the first instruction of
 916      this function.  If we didn't switch stacks then this can be
 917      trivially computed from the base address.  */
 918   if (cache->reg_saved[NIOS2_SP_REGNUM].basereg == NIOS2_Z_REGNUM)
 919     cache->cfa
 920       = read_memory_unsigned_integer (cache->reg_saved[NIOS2_SP_REGNUM].addr,
 921                                       4, byte_order);
 922   else
 923     cache->cfa = frame_high;
 924
 925   /* Exception handlers restore ESTATUS into STATUS.  */
 926   if (exception_handler)
 927     {
 928       cache->reg_saved[NIOS2_STATUS_REGNUM]
 929         = cache->reg_saved[NIOS2_ESTATUS_REGNUM];
 930       cache->reg_saved[NIOS2_ESTATUS_REGNUM].basereg = -1;
 931     }
 932
 933   if (nios2_debug)
 934     fprintf_unfiltered (gdb_stdlog, "cfa=%s }\n",
 935                         paddress (gdbarch, cache->cfa));
 936
 937   return prologue_end;
 938 }
 939
 940 /* Implement the skip_prologue gdbarch hook.  */
 941
 942 static CORE_ADDR
 943 nios2_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 944 {
 945   CORE_ADDR limit_pc;
 946   CORE_ADDR func_addr;
 947
 948   struct nios2_unwind_cache cache;
 949
 950   /* See if we can determine the end of the prologue via the symbol
 951      table.  If so, then return either PC, or the PC after the
 952      prologue, whichever is greater.  */
 953   if (find_pc_partial_function (start_pc, NULL, &func_addr, NULL))
 954     {
 955       CORE_ADDR post_prologue_pc
 956         = skip_prologue_using_sal (gdbarch, func_addr);
 957
 958       if (post_prologue_pc != 0)
 959         return max (start_pc, post_prologue_pc);
 960     }
 961
 962   /* Prologue analysis does the rest....  */
 963   nios2_init_cache (&cache, start_pc);
 964   return nios2_analyze_prologue (gdbarch, start_pc, start_pc, &cache, NULL);
 965 }
 966
 967 /* Implement the breakpoint_from_pc gdbarch hook.  */
 968
 969 static const gdb_byte*
 970 nios2_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
 971                           int *bp_size)
 972 {
 973   /* break encoding: 31->27  26->22  21->17  16->11 10->6 5->0 */
 974   /*                 00000   00000   0x1d    0x2d   11111 0x3a */
 975   /*                 00000   00000   11101   101101 11111 111010 */
 976   /* In bytes:       00000000 00111011 01101111 11111010 */
 977   /*                 0x0       0x3b    0x6f     0xfa */
 978   static const gdb_byte breakpoint_le[] = {0xfa, 0x6f, 0x3b, 0x0};
 979   static const gdb_byte breakpoint_be[] = {0x0, 0x3b, 0x6f, 0xfa};
 980
 981   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
 982
 983   *bp_size = 4;
 984   if (gdbarch_byte_order_for_code (gdbarch) == BFD_ENDIAN_BIG)
 985     return breakpoint_be;
 986   else
 987     return breakpoint_le;
 988 }
 989
 990 /* Implement the print_insn gdbarch method.  */
 991
 992 static int
 993 nios2_print_insn (bfd_vma memaddr, disassemble_info *info)
 994 {
 995   if (info->endian == BFD_ENDIAN_BIG)
 996     return print_insn_big_nios2 (memaddr, info);
 997   else
 998     return print_insn_little_nios2 (memaddr, info);
 999 }
1000
1001
1002 /* Implement the frame_align gdbarch method.  */
1003
1004 static CORE_ADDR
1005 nios2_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
1006 {
1007   return align_down (addr, 4);
1008 }
1009
1010
1011 /* Implement the return_value gdbarch method.  */
1012
1013 static enum return_value_convention
1014 nios2_return_value (struct gdbarch *gdbarch, struct value *function,
1015                     struct type *type, struct regcache *regcache,
1016                     gdb_byte *readbuf, const gdb_byte *writebuf)
1017 {
1018   if (TYPE_LENGTH (type) > 8)
1019     return RETURN_VALUE_STRUCT_CONVENTION;
1020
1021   if (readbuf)
1022     nios2_extract_return_value (gdbarch, type, regcache, readbuf);
1023   if (writebuf)
1024     nios2_store_return_value (gdbarch, type, regcache, writebuf);
1025
1026   return RETURN_VALUE_REGISTER_CONVENTION;
1027 }
1028
1029 /* Implement the dummy_id gdbarch method.  */
1030
1031 static struct frame_id
1032 nios2_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1033 {
1034   return frame_id_build
1035     (get_frame_register_unsigned (this_frame, NIOS2_SP_REGNUM),
1036      get_frame_pc (this_frame));
1037 }
1038
1039 /* Implement the push_dummy_call gdbarch method.  */
1040
1041 static CORE_ADDR
1042 nios2_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1043                        struct regcache *regcache, CORE_ADDR bp_addr,
1044                        int nargs, struct value **args, CORE_ADDR sp,
1045                        int struct_return, CORE_ADDR struct_addr)
1046 {
1047   int argreg;
1048   int float_argreg;
1049   int argnum;
1050   int len = 0;
1051   int stack_offset = 0;
1052   CORE_ADDR func_addr = find_function_addr (function, NULL);
1053   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1054
1055   /* Set the return address register to point to the entry point of
1056      the program, where a breakpoint lies in wait.  */
1057   regcache_cooked_write_signed (regcache, NIOS2_RA_REGNUM, bp_addr);
1058
1059   /* Now make space on the stack for the args.  */
1060   for (argnum = 0; argnum < nargs; argnum++)
1061     len += align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
1062   sp -= len;
1063
1064   /* Initialize the register pointer.  */
1065   argreg = NIOS2_FIRST_ARGREG;
1066
1067   /* The struct_return pointer occupies the first parameter-passing
1068      register.  */
1069   if (struct_return)
1070     regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
1071
1072   /* Now load as many as possible of the first arguments into
1073      registers, and push the rest onto the stack.  Loop through args
1074      from first to last.  */
1075   for (argnum = 0; argnum < nargs; argnum++)
1076     {
1077       const gdb_byte *val;
1078       gdb_byte valbuf[MAX_REGISTER_SIZE];
1079       struct value *arg = args[argnum];
1080       struct type *arg_type = check_typedef (value_type (arg));
1081       int len = TYPE_LENGTH (arg_type);
1082       enum type_code typecode = TYPE_CODE (arg_type);
1083
1084       val = value_contents (arg);
1085
1086       /* Copy the argument to general registers or the stack in
1087          register-sized pieces.  Large arguments are split between
1088          registers and stack.  */
1089       while (len > 0)
1090         {
1091           int partial_len = (len < 4 ? len : 4);
1092
1093           if (argreg <= NIOS2_LAST_ARGREG)
1094             {
1095               /* The argument is being passed in a register.  */
1096               CORE_ADDR regval = extract_unsigned_integer (val, partial_len,
1097                                                            byte_order);
1098
1099               regcache_cooked_write_unsigned (regcache, argreg, regval);
1100               argreg++;
1101             }
1102           else
1103             {
1104               /* The argument is being passed on the stack.  */
1105               CORE_ADDR addr = sp + stack_offset;
1106
1107               write_memory (addr, val, partial_len);
1108               stack_offset += align_up (partial_len, 4);
1109             }
1110
1111           len -= partial_len;
1112           val += partial_len;
1113         }
1114     }
1115
1116   regcache_cooked_write_signed (regcache, NIOS2_SP_REGNUM, sp);
1117
1118   /* Return adjusted stack pointer.  */
1119   return sp;
1120 }
1121
1122 /* Implement the unwind_pc gdbarch method.  */
1123
1124 static CORE_ADDR
1125 nios2_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1126 {
1127   gdb_byte buf[4];
1128
1129   frame_unwind_register (next_frame, NIOS2_PC_REGNUM, buf);
1130   return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
1131 }
1132
1133 /* Implement the unwind_sp gdbarch method.  */
1134
1135 static CORE_ADDR
1136 nios2_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
1137 {
1138   return frame_unwind_register_unsigned (this_frame, NIOS2_SP_REGNUM);
1139 }
1140
1141 /* Use prologue analysis to fill in the register cache
1142    *THIS_PROLOGUE_CACHE for THIS_FRAME.  This function initializes
1143    *THIS_PROLOGUE_CACHE first.  */
1144
1145 static struct nios2_unwind_cache *
1146 nios2_frame_unwind_cache (struct frame_info *this_frame,
1147                           void **this_prologue_cache)
1148 {
1149   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1150   CORE_ADDR current_pc;
1151   struct nios2_unwind_cache *cache;
1152   int i;
1153
1154   if (*this_prologue_cache)
1155     return *this_prologue_cache;
1156
1157   cache = FRAME_OBSTACK_ZALLOC (struct nios2_unwind_cache);
1158   *this_prologue_cache = cache;
1159
1160   /* Zero all fields.  */
1161   nios2_init_cache (cache, get_frame_func (this_frame));
1162
1163   /* Prologue analysis does the rest...  */
1164   current_pc = get_frame_pc (this_frame);
1165   if (cache->pc != 0)
1166     nios2_analyze_prologue (gdbarch, cache->pc, current_pc, cache, this_frame);
1167
1168   return cache;
1169 }
1170
1171 /* Implement the this_id function for the normal unwinder.  */
1172
1173 static void
1174 nios2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1175                      struct frame_id *this_id)
1176 {
1177   struct nios2_unwind_cache *cache =
1178     nios2_frame_unwind_cache (this_frame, this_cache);
1179
1180   /* This marks the outermost frame.  */
1181   if (cache->base == 0)
1182     return;
1183
1184   *this_id = frame_id_build (cache->cfa, cache->pc);
1185 }
1186
1187 /* Implement the prev_register function for the normal unwinder.  */
1188
1189 static struct value *
1190 nios2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1191                            int regnum)
1192 {
1193   struct nios2_unwind_cache *cache =
1194     nios2_frame_unwind_cache (this_frame, this_cache);
1195
1196   gdb_assert (regnum >= 0 && regnum < NIOS2_NUM_REGS);
1197
1198   /* The PC of the previous frame is stored in the RA register of
1199      the current frame.  Frob regnum so that we pull the value from
1200      the correct place.  */
1201   if (regnum == NIOS2_PC_REGNUM)
1202     regnum = cache->return_regnum;
1203
1204   if (regnum == NIOS2_SP_REGNUM && cache->cfa)
1205     return frame_unwind_got_constant (this_frame, regnum, cache->cfa);
1206
1207   /* If we've worked out where a register is stored then load it from
1208      there.  */
1209   if (cache->reg_saved[regnum].basereg == NIOS2_Z_REGNUM)
1210     return frame_unwind_got_memory (this_frame, regnum,
1211                                     cache->reg_saved[regnum].addr);
1212
1213   return frame_unwind_got_register (this_frame, regnum, regnum);
1214 }
1215
1216 /* Implement the this_base, this_locals, and this_args hooks
1217    for the normal unwinder.  */
1218
1219 static CORE_ADDR
1220 nios2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1221 {
1222   struct nios2_unwind_cache *info
1223     = nios2_frame_unwind_cache (this_frame, this_cache);
1224
1225   return info->base;
1226 }
1227
1228 /* Data structures for the normal prologue-analysis-based
1229    unwinder.  */
1230
1231 static const struct frame_unwind nios2_frame_unwind =
1232 {
1233   NORMAL_FRAME,
1234   default_frame_unwind_stop_reason,
1235   nios2_frame_this_id,
1236   nios2_frame_prev_register,
1237   NULL,
1238   default_frame_sniffer
1239 };
1240
1241 static const struct frame_base nios2_frame_base =
1242 {
1243   &nios2_frame_unwind,
1244   nios2_frame_base_address,
1245   nios2_frame_base_address,
1246   nios2_frame_base_address
1247 };
1248
1249 /* Fill in the register cache *THIS_CACHE for THIS_FRAME for use
1250    in the stub unwinder.  */
1251
1252 static struct trad_frame_cache *
1253 nios2_stub_frame_cache (struct frame_info *this_frame, void **this_cache)
1254 {
1255   CORE_ADDR pc;
1256   CORE_ADDR start_addr;
1257   CORE_ADDR stack_addr;
1258   struct trad_frame_cache *this_trad_cache;
1259   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1260   int num_regs = gdbarch_num_regs (gdbarch);
1261
1262   if (*this_cache != NULL)
1263     return *this_cache;
1264   this_trad_cache = trad_frame_cache_zalloc (this_frame);
1265   *this_cache = this_trad_cache;
1266
1267   /* The return address is in the link register.  */
1268   trad_frame_set_reg_realreg (this_trad_cache,
1269                               gdbarch_pc_regnum (gdbarch),
1270                               NIOS2_RA_REGNUM);
1271
1272   /* Frame ID, since it's a frameless / stackless function, no stack
1273      space is allocated and SP on entry is the current SP.  */
1274   pc = get_frame_pc (this_frame);
1275   find_pc_partial_function (pc, NULL, &start_addr, NULL);
1276   stack_addr = get_frame_register_unsigned (this_frame, NIOS2_SP_REGNUM);
1277   trad_frame_set_id (this_trad_cache, frame_id_build (start_addr, stack_addr));
1278   /* Assume that the frame's base is the same as the stack pointer.  */
1279   trad_frame_set_this_base (this_trad_cache, stack_addr);
1280
1281   return this_trad_cache;
1282 }
1283
1284 /* Implement the this_id function for the stub unwinder.  */
1285
1286 static void
1287 nios2_stub_frame_this_id (struct frame_info *this_frame, void **this_cache,
1288                           struct frame_id *this_id)
1289 {
1290   struct trad_frame_cache *this_trad_cache
1291     = nios2_stub_frame_cache (this_frame, this_cache);
1292
1293   trad_frame_get_id (this_trad_cache, this_id);
1294 }
1295
1296 /* Implement the prev_register function for the stub unwinder.  */
1297
1298 static struct value *
1299 nios2_stub_frame_prev_register (struct frame_info *this_frame,
1300                                 void **this_cache, int regnum)
1301 {
1302   struct trad_frame_cache *this_trad_cache
1303     = nios2_stub_frame_cache (this_frame, this_cache);
1304
1305   return trad_frame_get_register (this_trad_cache, this_frame, regnum);
1306 }
1307
1308 /* Implement the sniffer function for the stub unwinder.
1309    This unwinder is used for cases where the normal
1310    prologue-analysis-based unwinder can't work,
1311    such as PLT stubs.  */
1312
1313 static int
1314 nios2_stub_frame_sniffer (const struct frame_unwind *self,
1315                           struct frame_info *this_frame, void **cache)
1316 {
1317   gdb_byte dummy[4];
1318   struct obj_section *s;
1319   CORE_ADDR pc = get_frame_address_in_block (this_frame);
1320
1321   /* Use the stub unwinder for unreadable code.  */
1322   if (target_read_memory (get_frame_pc (this_frame), dummy, 4) != 0)
1323     return 1;
1324
1325   if (in_plt_section (pc))
1326     return 1;
1327
1328   return 0;
1329 }
1330
1331 /* Define the data structures for the stub unwinder.  */
1332
1333 static const struct frame_unwind nios2_stub_frame_unwind =
1334 {
1335   NORMAL_FRAME,
1336   default_frame_unwind_stop_reason,
1337   nios2_stub_frame_this_id,
1338   nios2_stub_frame_prev_register,
1339   NULL,
1340   nios2_stub_frame_sniffer
1341 };
1342
1343 /* Helper function to read an instruction at PC.  */
1344
1345 static unsigned long
1346 nios2_fetch_instruction (struct gdbarch *gdbarch, CORE_ADDR pc)
1347 {
1348   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1349
1350   return read_memory_unsigned_integer (pc, NIOS2_OPCODE_SIZE, byte_order);
1351 }
1352
1353 /* Determine where to set a single step breakpoint while considering
1354    branch prediction.  */
1355
1356 static CORE_ADDR
1357 nios2_get_next_pc (struct frame_info *frame, CORE_ADDR pc)
1358 {
1359   struct gdbarch *gdbarch = get_frame_arch (frame);
1360   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1361   unsigned long inst;
1362   int op;
1363   int imm16;
1364   int ra;
1365   int rb;
1366   int ras;
1367   int rbs;
1368   unsigned int rau;
1369   unsigned int rbu;
1370
1371   inst = nios2_fetch_instruction (gdbarch, pc);
1372   pc += NIOS2_OPCODE_SIZE;
1373
1374   imm16 = (short) GET_IW_I_IMM16 (inst);
1375   ra = GET_IW_I_A (inst);
1376   rb = GET_IW_I_B (inst);
1377   ras = get_frame_register_signed (frame, ra);
1378   rbs = get_frame_register_signed (frame, rb);
1379   rau = get_frame_register_unsigned (frame, ra);
1380   rbu = get_frame_register_unsigned (frame, rb);
1381
1382   switch (GET_IW_R1_OP (inst))
1383     {
1384     case R1_OP_BEQ:
1385       if (ras == rbs)
1386         pc += imm16;
1387       break;
1388
1389     case R1_OP_BGE:
1390       if (ras >= rbs)
1391         pc += imm16;
1392       break;
1393
1394     case R1_OP_BGEU:
1395       if (rau >= rbu)
1396         pc += imm16;
1397       break;
1398
1399     case R1_OP_BLT:
1400       if (ras < rbs)
1401         pc += imm16;
1402       break;
1403
1404     case R1_OP_BLTU:
1405       if (rau < rbu)
1406         pc += imm16;
1407       break;
1408
1409     case R1_OP_BNE:
1410       if (ras != rbs)
1411         pc += imm16;
1412       break;
1413
1414     case R1_OP_BR:
1415       pc += imm16;
1416       break;
1417
1418     case R1_OP_JMPI:
1419     case R1_OP_CALL:
1420       pc = (pc & 0xf0000000) | (GET_IW_J_IMM26 (inst) << 2);
1421       break;
1422
1423     case R1_OP_OPX:
1424       switch (GET_IW_R_OPX (inst))
1425         {
1426         case R1_OPX_JMP:
1427         case R1_OPX_CALLR:
1428         case R1_OPX_RET:
1429           pc = ras;
1430           break;
1431
1432         case R1_OPX_TRAP:
1433           if (tdep->syscall_next_pc != NULL)
1434             return tdep->syscall_next_pc (frame);
1435
1436         default:
1437           break;
1438         }
1439       break;
1440     default:
1441       break;
1442     }
1443   return pc;
1444 }
1445
1446 /* Implement the software_single_step gdbarch method.  */
1447
1448 static int
1449 nios2_software_single_step (struct frame_info *frame)
1450 {
1451   struct gdbarch *gdbarch = get_frame_arch (frame);
1452   struct address_space *aspace = get_frame_address_space (frame);
1453   CORE_ADDR next_pc = nios2_get_next_pc (frame, get_frame_pc (frame));
1454
1455   insert_single_step_breakpoint (gdbarch, aspace, next_pc);
1456
1457   return 1;
1458 }
1459
1460 /* Implement the get_longjump_target gdbarch method.  */
1461
1462 static int
1463 nios2_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1464 {
1465   struct gdbarch *gdbarch = get_frame_arch (frame);
1466   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1467   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1468   CORE_ADDR jb_addr = get_frame_register_unsigned (frame, NIOS2_R4_REGNUM);
1469   gdb_byte buf[4];
1470
1471   if (target_read_memory (jb_addr + (tdep->jb_pc * 4), buf, 4))
1472     return 0;
1473
1474   *pc = extract_unsigned_integer (buf, 4, byte_order);
1475   return 1;
1476 }
1477
1478 /* Initialize the Nios II gdbarch.  */
1479
1480 static struct gdbarch *
1481 nios2_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1482 {
1483   struct gdbarch *gdbarch;
1484   struct gdbarch_tdep *tdep;
1485   int register_bytes, i;
1486   struct tdesc_arch_data *tdesc_data = NULL;
1487   const struct target_desc *tdesc = info.target_desc;
1488
1489   if (!tdesc_has_registers (tdesc))
1490     /* Pick a default target description.  */
1491     tdesc = tdesc_nios2;
1492
1493   /* Check any target description for validity.  */
1494   if (tdesc_has_registers (tdesc))
1495     {
1496       const struct tdesc_feature *feature;
1497       int valid_p;
1498
1499       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.nios2.cpu");
1500       if (feature == NULL)
1501         return NULL;
1502
1503       tdesc_data = tdesc_data_alloc ();
1504
1505       valid_p = 1;
1506
1507       for (i = 0; i < NIOS2_NUM_REGS; i++)
1508         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1509                                             nios2_reg_names[i]);
1510
1511       if (!valid_p)
1512         {
1513           tdesc_data_cleanup (tdesc_data);
1514           return NULL;
1515         }
1516     }
1517
1518   /* Find a candidate among the list of pre-declared architectures.  */
1519   arches = gdbarch_list_lookup_by_info (arches, &info);
1520   if (arches != NULL)
1521     return arches->gdbarch;
1522
1523   /* None found, create a new architecture from the information
1524      provided.  */
1525   tdep = xcalloc (1, sizeof (struct gdbarch_tdep));
1526   gdbarch = gdbarch_alloc (&info, tdep);
1527
1528   /* longjmp support not enabled by default.  */
1529   tdep->jb_pc = -1;
1530
1531   /* Data type sizes.  */
1532   set_gdbarch_ptr_bit (gdbarch, 32);
1533   set_gdbarch_addr_bit (gdbarch, 32);
1534   set_gdbarch_short_bit (gdbarch, 16);
1535   set_gdbarch_int_bit (gdbarch, 32);
1536   set_gdbarch_long_bit (gdbarch, 32);
1537   set_gdbarch_long_long_bit (gdbarch, 64);
1538   set_gdbarch_float_bit (gdbarch, 32);
1539   set_gdbarch_double_bit (gdbarch, 64);
1540
1541   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1542   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1543
1544   /* The register set.  */
1545   set_gdbarch_num_regs (gdbarch, NIOS2_NUM_REGS);
1546   set_gdbarch_sp_regnum (gdbarch, NIOS2_SP_REGNUM);
1547   set_gdbarch_pc_regnum (gdbarch, NIOS2_PC_REGNUM);     /* Pseudo register PC */
1548
1549   set_gdbarch_register_name (gdbarch, nios2_register_name);
1550   set_gdbarch_register_type (gdbarch, nios2_register_type);
1551
1552   /* Provide register mappings for stabs and dwarf2.  */
1553   set_gdbarch_stab_reg_to_regnum (gdbarch, nios2_dwarf_reg_to_regnum);
1554   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, nios2_dwarf_reg_to_regnum);
1555
1556   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1557
1558   /* Call dummy code.  */
1559   set_gdbarch_frame_align (gdbarch, nios2_frame_align);
1560
1561   set_gdbarch_return_value (gdbarch, nios2_return_value);
1562
1563   set_gdbarch_skip_prologue (gdbarch, nios2_skip_prologue);
1564   set_gdbarch_in_function_epilogue_p (gdbarch, nios2_in_function_epilogue_p);
1565   set_gdbarch_breakpoint_from_pc (gdbarch, nios2_breakpoint_from_pc);
1566
1567   set_gdbarch_dummy_id (gdbarch, nios2_dummy_id);
1568   set_gdbarch_unwind_pc (gdbarch, nios2_unwind_pc);
1569   set_gdbarch_unwind_sp (gdbarch, nios2_unwind_sp);
1570
1571   /* The dwarf2 unwinder will normally produce the best results if
1572      the debug information is available, so register it first.  */
1573   dwarf2_append_unwinders (gdbarch);
1574   frame_unwind_append_unwinder (gdbarch, &nios2_stub_frame_unwind);
1575   frame_unwind_append_unwinder (gdbarch, &nios2_frame_unwind);
1576
1577   /* Single stepping.  */
1578   set_gdbarch_software_single_step (gdbarch, nios2_software_single_step);
1579
1580   /* Hook in ABI-specific overrides, if they have been registered.  */
1581   gdbarch_init_osabi (info, gdbarch);
1582
1583   if (tdep->jb_pc >= 0)
1584     set_gdbarch_get_longjmp_target (gdbarch, nios2_get_longjmp_target);
1585
1586   frame_base_set_default (gdbarch, &nios2_frame_base);
1587
1588   set_gdbarch_print_insn (gdbarch, nios2_print_insn);
1589
1590   /* Enable inferior call support.  */
1591   set_gdbarch_push_dummy_call (gdbarch, nios2_push_dummy_call);
1592
1593   if (tdesc_data)
1594     tdesc_use_registers (gdbarch, tdesc, tdesc_data);
1595
1596   return gdbarch;
1597 }
1598
1599 extern initialize_file_ftype _initialize_nios2_tdep; /* -Wmissing-prototypes */
1600
1601 void
1602 _initialize_nios2_tdep (void)
1603 {
1604   gdbarch_register (bfd_arch_nios2, nios2_gdbarch_init, NULL);
1605   initialize_tdesc_nios2 ();
1606
1607   /* Allow debugging this file's internals.  */
1608   add_setshow_boolean_cmd ("nios2", class_maintenance, &nios2_debug,
1609                            _("Set Nios II debugging."),
1610                            _("Show Nios II debugging."),
1611                            _("When on, Nios II specific debugging is enabled."),
1612                            NULL,
1613                            NULL,
1614                            &setdebuglist, &showdebuglist);
1615 }