gdb/cris-tdep.c

   1 /* Target dependent code for CRIS, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2001-2016 Free Software Foundation, Inc.
   4
   5    Contributed by Axis Communications AB.
   6    Written by Hendrik Ruijter, Stefan Andersson, and Orjan Friberg.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "frame.h"
  25 #include "frame-unwind.h"
  26 #include "frame-base.h"
  27 #include "trad-frame.h"
  28 #include "dwarf2-frame.h"
  29 #include "symtab.h"
  30 #include "inferior.h"
  31 #include "gdbtypes.h"
  32 #include "gdbcore.h"
  33 #include "gdbcmd.h"
  34 #include "target.h"
  35 #include "value.h"
  36 #include "opcode/cris.h"
  37 #include "osabi.h"
  38 #include "arch-utils.h"
  39 #include "regcache.h"
  40
  41 #include "objfiles.h"
  42
  43 #include "solib.h"              /* Support for shared libraries.  */
  44 #include "solib-svr4.h"
  45 #include "dis-asm.h"
  46
  47 #include "cris-tdep.h"
  48
  49 enum cris_num_regs
  50 {
  51   /* There are no floating point registers.  Used in gdbserver low-linux.c.  */
  52   NUM_FREGS = 0,
  53
  54   /* There are 16 general registers.  */
  55   NUM_GENREGS = 16,
  56
  57   /* There are 16 special registers.  */
  58   NUM_SPECREGS = 16,
  59
  60   /* CRISv32 has a pseudo PC register, not noted here.  */
  61
  62   /* CRISv32 has 16 support registers.  */
  63   NUM_SUPPREGS = 16
  64 };
  65
  66 /* Register numbers of various important registers.
  67    CRIS_FP_REGNUM   Contains address of executing stack frame.
  68    STR_REGNUM  Contains the address of structure return values.
  69    RET_REGNUM  Contains the return value when shorter than or equal to 32 bits
  70    ARG1_REGNUM Contains the first parameter to a function.
  71    ARG2_REGNUM Contains the second parameter to a function.
  72    ARG3_REGNUM Contains the third parameter to a function.
  73    ARG4_REGNUM Contains the fourth parameter to a function.  Rest on stack.
  74    gdbarch_sp_regnum Contains address of top of stack.
  75    gdbarch_pc_regnum Contains address of next instruction.
  76    SRP_REGNUM  Subroutine return pointer register.
  77    BRP_REGNUM  Breakpoint return pointer register.  */
  78
  79 enum cris_regnums
  80 {
  81   /* Enums with respect to the general registers, valid for all
  82      CRIS versions.  The frame pointer is always in R8.  */
  83   CRIS_FP_REGNUM = 8,
  84   /* ABI related registers.  */
  85   STR_REGNUM  = 9,
  86   RET_REGNUM  = 10,
  87   ARG1_REGNUM = 10,
  88   ARG2_REGNUM = 11,
  89   ARG3_REGNUM = 12,
  90   ARG4_REGNUM = 13,
  91
  92   /* Registers which happen to be common.  */
  93   VR_REGNUM   = 17,
  94   MOF_REGNUM  = 23,
  95   SRP_REGNUM  = 27,
  96
  97   /* CRISv10 et al. specific registers.  */
  98   P0_REGNUM   = 16,
  99   P4_REGNUM   = 20,
 100   CCR_REGNUM  = 21,
 101   P8_REGNUM   = 24,
 102   IBR_REGNUM  = 25,
 103   IRP_REGNUM  = 26,
 104   BAR_REGNUM  = 28,
 105   DCCR_REGNUM = 29,
 106   BRP_REGNUM  = 30,
 107   USP_REGNUM  = 31,
 108
 109   /* CRISv32 specific registers.  */
 110   ACR_REGNUM  = 15,
 111   BZ_REGNUM   = 16,
 112   PID_REGNUM  = 18,
 113   SRS_REGNUM  = 19,
 114   WZ_REGNUM   = 20,
 115   EXS_REGNUM  = 21,
 116   EDA_REGNUM  = 22,
 117   DZ_REGNUM   = 24,
 118   EBP_REGNUM  = 25,
 119   ERP_REGNUM  = 26,
 120   NRP_REGNUM  = 28,
 121   CCS_REGNUM  = 29,
 122   CRISV32USP_REGNUM  = 30, /* Shares name but not number with CRISv10.  */
 123   SPC_REGNUM  = 31,
 124   CRISV32PC_REGNUM   = 32, /* Shares name but not number with CRISv10.  */
 125
 126   S0_REGNUM = 33,
 127   S1_REGNUM = 34,
 128   S2_REGNUM = 35,
 129   S3_REGNUM = 36,
 130   S4_REGNUM = 37,
 131   S5_REGNUM = 38,
 132   S6_REGNUM = 39,
 133   S7_REGNUM = 40,
 134   S8_REGNUM = 41,
 135   S9_REGNUM = 42,
 136   S10_REGNUM = 43,
 137   S11_REGNUM = 44,
 138   S12_REGNUM = 45,
 139   S13_REGNUM = 46,
 140   S14_REGNUM = 47,
 141   S15_REGNUM = 48,
 142 };
 143
 144 extern const struct cris_spec_reg cris_spec_regs[];
 145
 146 /* CRIS version, set via the user command 'set cris-version'.  Affects
 147    register names and sizes.  */
 148 static unsigned int usr_cmd_cris_version;
 149
 150 /* Indicates whether to trust the above variable.  */
 151 static int usr_cmd_cris_version_valid = 0;
 152
 153 static const char cris_mode_normal[] = "normal";
 154 static const char cris_mode_guru[] = "guru";
 155 static const char *const cris_modes[] = {
 156   cris_mode_normal,
 157   cris_mode_guru,
 158   0
 159 };
 160
 161 /* CRIS mode, set via the user command 'set cris-mode'.  Affects
 162    type of break instruction among other things.  */
 163 static const char *usr_cmd_cris_mode = cris_mode_normal;
 164
 165 /* Whether to make use of Dwarf-2 CFI (default on).  */
 166 static int usr_cmd_cris_dwarf2_cfi = 1;
 167
 168 /* Sigtramp identification code copied from i386-linux-tdep.c.  */
 169
 170 #define SIGTRAMP_INSN0    0x9c5f  /* movu.w 0xXX, $r9 */
 171 #define SIGTRAMP_OFFSET0  0
 172 #define SIGTRAMP_INSN1    0xe93d  /* break 13 */
 173 #define SIGTRAMP_OFFSET1  4
 174
 175 static const unsigned short sigtramp_code[] =
 176 {
 177   SIGTRAMP_INSN0, 0x0077,  /* movu.w $0x77, $r9 */
 178   SIGTRAMP_INSN1           /* break 13 */
 179 };
 180
 181 #define SIGTRAMP_LEN (sizeof sigtramp_code)
 182
 183 /* Note: same length as normal sigtramp code.  */
 184
 185 static const unsigned short rt_sigtramp_code[] =
 186 {
 187   SIGTRAMP_INSN0, 0x00ad,  /* movu.w $0xad, $r9 */
 188   SIGTRAMP_INSN1           /* break 13 */
 189 };
 190
 191 /* If PC is in a sigtramp routine, return the address of the start of
 192    the routine.  Otherwise, return 0.  */
 193
 194 static CORE_ADDR
 195 cris_sigtramp_start (struct frame_info *this_frame)
 196 {
 197   CORE_ADDR pc = get_frame_pc (this_frame);
 198   gdb_byte buf[SIGTRAMP_LEN];
 199
 200   if (!safe_frame_unwind_memory (this_frame, pc, buf, SIGTRAMP_LEN))
 201     return 0;
 202
 203   if (((buf[1] << 8) + buf[0]) != SIGTRAMP_INSN0)
 204     {
 205       if (((buf[1] << 8) + buf[0]) != SIGTRAMP_INSN1)
 206         return 0;
 207
 208       pc -= SIGTRAMP_OFFSET1;
 209       if (!safe_frame_unwind_memory (this_frame, pc, buf, SIGTRAMP_LEN))
 210         return 0;
 211     }
 212
 213   if (memcmp (buf, sigtramp_code, SIGTRAMP_LEN) != 0)
 214     return 0;
 215
 216   return pc;
 217 }
 218
 219 /* If PC is in a RT sigtramp routine, return the address of the start of
 220    the routine.  Otherwise, return 0.  */
 221
 222 static CORE_ADDR
 223 cris_rt_sigtramp_start (struct frame_info *this_frame)
 224 {
 225   CORE_ADDR pc = get_frame_pc (this_frame);
 226   gdb_byte buf[SIGTRAMP_LEN];
 227
 228   if (!safe_frame_unwind_memory (this_frame, pc, buf, SIGTRAMP_LEN))
 229     return 0;
 230
 231   if (((buf[1] << 8) + buf[0]) != SIGTRAMP_INSN0)
 232     {
 233       if (((buf[1] << 8) + buf[0]) != SIGTRAMP_INSN1)
 234         return 0;
 235
 236       pc -= SIGTRAMP_OFFSET1;
 237       if (!safe_frame_unwind_memory (this_frame, pc, buf, SIGTRAMP_LEN))
 238         return 0;
 239     }
 240
 241   if (memcmp (buf, rt_sigtramp_code, SIGTRAMP_LEN) != 0)
 242     return 0;
 243
 244   return pc;
 245 }
 246
 247 /* Assuming THIS_FRAME is a frame for a GNU/Linux sigtramp routine,
 248    return the address of the associated sigcontext structure.  */
 249
 250 static CORE_ADDR
 251 cris_sigcontext_addr (struct frame_info *this_frame)
 252 {
 253   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 254   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 255   CORE_ADDR pc;
 256   CORE_ADDR sp;
 257   gdb_byte buf[4];
 258
 259   get_frame_register (this_frame, gdbarch_sp_regnum (gdbarch), buf);
 260   sp = extract_unsigned_integer (buf, 4, byte_order);
 261
 262   /* Look for normal sigtramp frame first.  */
 263   pc = cris_sigtramp_start (this_frame);
 264   if (pc)
 265     {
 266       /* struct signal_frame (arch/cris/kernel/signal.c) contains
 267          struct sigcontext as its first member, meaning the SP points to
 268          it already.  */
 269       return sp;
 270     }
 271
 272   pc = cris_rt_sigtramp_start (this_frame);
 273   if (pc)
 274     {
 275       /* struct rt_signal_frame (arch/cris/kernel/signal.c) contains
 276          a struct ucontext, which in turn contains a struct sigcontext.
 277          Magic digging:
 278          4 + 4 + 128 to struct ucontext, then
 279          4 + 4 + 12 to struct sigcontext.  */
 280       return (sp + 156);
 281     }
 282
 283   error (_("Couldn't recognize signal trampoline."));
 284   return 0;
 285 }
 286
 287 struct cris_unwind_cache
 288 {
 289   /* The previous frame's inner most stack address.  Used as this
 290      frame ID's stack_addr.  */
 291   CORE_ADDR prev_sp;
 292   /* The frame's base, optionally used by the high-level debug info.  */
 293   CORE_ADDR base;
 294   int size;
 295   /* How far the SP and r8 (FP) have been offset from the start of
 296      the stack frame (as defined by the previous frame's stack
 297      pointer).  */
 298   LONGEST sp_offset;
 299   LONGEST r8_offset;
 300   int uses_frame;
 301
 302   /* From old frame_extra_info struct.  */
 303   CORE_ADDR return_pc;
 304   int leaf_function;
 305
 306   /* Table indicating the location of each and every register.  */
 307   struct trad_frame_saved_reg *saved_regs;
 308 };
 309
 310 static struct cris_unwind_cache *
 311 cris_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
 312                                   void **this_cache)
 313 {
 314   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 315   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 316   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 317   struct cris_unwind_cache *info;
 318   CORE_ADDR addr;
 319   gdb_byte buf[4];
 320   int i;
 321
 322   if ((*this_cache))
 323     return (struct cris_unwind_cache *) (*this_cache);
 324
 325   info = FRAME_OBSTACK_ZALLOC (struct cris_unwind_cache);
 326   (*this_cache) = info;
 327   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 328
 329   /* Zero all fields.  */
 330   info->prev_sp = 0;
 331   info->base = 0;
 332   info->size = 0;
 333   info->sp_offset = 0;
 334   info->r8_offset = 0;
 335   info->uses_frame = 0;
 336   info->return_pc = 0;
 337   info->leaf_function = 0;
 338
 339   get_frame_register (this_frame, gdbarch_sp_regnum (gdbarch), buf);
 340   info->base = extract_unsigned_integer (buf, 4, byte_order);
 341
 342   addr = cris_sigcontext_addr (this_frame);
 343
 344   /* Layout of the sigcontext struct:
 345      struct sigcontext {
 346         struct pt_regs regs;
 347         unsigned long oldmask;
 348         unsigned long usp;
 349      }; */
 350
 351   if (tdep->cris_version == 10)
 352     {
 353       /* R0 to R13 are stored in reverse order at offset (2 * 4) in
 354          struct pt_regs.  */
 355       for (i = 0; i <= 13; i++)
 356         info->saved_regs[i].addr = addr + ((15 - i) * 4);
 357
 358       info->saved_regs[MOF_REGNUM].addr = addr + (16 * 4);
 359       info->saved_regs[DCCR_REGNUM].addr = addr + (17 * 4);
 360       info->saved_regs[SRP_REGNUM].addr = addr + (18 * 4);
 361       /* Note: IRP is off by 2 at this point.  There's no point in correcting
 362          it though since that will mean that the backtrace will show a PC
 363          different from what is shown when stopped.  */
 364       info->saved_regs[IRP_REGNUM].addr = addr + (19 * 4);
 365       info->saved_regs[gdbarch_pc_regnum (gdbarch)]
 366         = info->saved_regs[IRP_REGNUM];
 367       info->saved_regs[gdbarch_sp_regnum (gdbarch)].addr = addr + (24 * 4);
 368     }
 369   else
 370     {
 371       /* CRISv32.  */
 372       /* R0 to R13 are stored in order at offset (1 * 4) in
 373          struct pt_regs.  */
 374       for (i = 0; i <= 13; i++)
 375         info->saved_regs[i].addr = addr + ((i + 1) * 4);
 376
 377       info->saved_regs[ACR_REGNUM].addr = addr + (15 * 4);
 378       info->saved_regs[SRS_REGNUM].addr = addr + (16 * 4);
 379       info->saved_regs[MOF_REGNUM].addr = addr + (17 * 4);
 380       info->saved_regs[SPC_REGNUM].addr = addr + (18 * 4);
 381       info->saved_regs[CCS_REGNUM].addr = addr + (19 * 4);
 382       info->saved_regs[SRP_REGNUM].addr = addr + (20 * 4);
 383       info->saved_regs[ERP_REGNUM].addr = addr + (21 * 4);
 384       info->saved_regs[EXS_REGNUM].addr = addr + (22 * 4);
 385       info->saved_regs[EDA_REGNUM].addr = addr + (23 * 4);
 386
 387       /* FIXME: If ERP is in a delay slot at this point then the PC will
 388          be wrong at this point.  This problem manifests itself in the
 389          sigaltstack.exp test case, which occasionally generates FAILs when
 390          the signal is received while in a delay slot.
 391
 392          This could be solved by a couple of read_memory_unsigned_integer and a
 393          trad_frame_set_value.  */
 394       info->saved_regs[gdbarch_pc_regnum (gdbarch)]
 395         = info->saved_regs[ERP_REGNUM];
 396
 397       info->saved_regs[gdbarch_sp_regnum (gdbarch)].addr
 398         = addr + (25 * 4);
 399     }
 400
 401   return info;
 402 }
 403
 404 static void
 405 cris_sigtramp_frame_this_id (struct frame_info *this_frame, void **this_cache,
 406                              struct frame_id *this_id)
 407 {
 408   struct cris_unwind_cache *cache =
 409     cris_sigtramp_frame_unwind_cache (this_frame, this_cache);
 410   (*this_id) = frame_id_build (cache->base, get_frame_pc (this_frame));
 411 }
 412
 413 /* Forward declaration.  */
 414
 415 static struct value *cris_frame_prev_register (struct frame_info *this_frame,
 416                                                void **this_cache, int regnum);
 417 static struct value *
 418 cris_sigtramp_frame_prev_register (struct frame_info *this_frame,
 419                                    void **this_cache, int regnum)
 420 {
 421   /* Make sure we've initialized the cache.  */
 422   cris_sigtramp_frame_unwind_cache (this_frame, this_cache);
 423   return cris_frame_prev_register (this_frame, this_cache, regnum);
 424 }
 425
 426 static int
 427 cris_sigtramp_frame_sniffer (const struct frame_unwind *self,
 428                              struct frame_info *this_frame,
 429                              void **this_cache)
 430 {
 431   if (cris_sigtramp_start (this_frame)
 432       || cris_rt_sigtramp_start (this_frame))
 433     return 1;
 434
 435   return 0;
 436 }
 437
 438 static const struct frame_unwind cris_sigtramp_frame_unwind =
 439 {
 440   SIGTRAMP_FRAME,
 441   default_frame_unwind_stop_reason,
 442   cris_sigtramp_frame_this_id,
 443   cris_sigtramp_frame_prev_register,
 444   NULL,
 445   cris_sigtramp_frame_sniffer
 446 };
 447
 448 static int
 449 crisv32_single_step_through_delay (struct gdbarch *gdbarch,
 450                                    struct frame_info *this_frame)
 451 {
 452   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 453   ULONGEST erp;
 454   int ret = 0;
 455
 456   if (tdep->cris_mode == cris_mode_guru)
 457     erp = get_frame_register_unsigned (this_frame, NRP_REGNUM);
 458   else
 459     erp = get_frame_register_unsigned (this_frame, ERP_REGNUM);
 460
 461   if (erp & 0x1)
 462     {
 463       /* In delay slot - check if there's a breakpoint at the preceding
 464          instruction.  */
 465       if (breakpoint_here_p (get_frame_address_space (this_frame), erp & ~0x1))
 466         ret = 1;
 467     }
 468   return ret;
 469 }
 470
 471 /* The instruction environment needed to find single-step breakpoints.  */
 472
 473 typedef
 474 struct instruction_environment
 475 {
 476   unsigned long reg[NUM_GENREGS];
 477   unsigned long preg[NUM_SPECREGS];
 478   unsigned long branch_break_address;
 479   unsigned long delay_slot_pc;
 480   unsigned long prefix_value;
 481   int   branch_found;
 482   int   prefix_found;
 483   int   invalid;
 484   int   slot_needed;
 485   int   delay_slot_pc_active;
 486   int   xflag_found;
 487   int   disable_interrupt;
 488   enum bfd_endian byte_order;
 489 } inst_env_type;
 490
 491 /* Machine-dependencies in CRIS for opcodes.  */
 492
 493 /* Instruction sizes.  */
 494 enum cris_instruction_sizes
 495 {
 496   INST_BYTE_SIZE  = 0,
 497   INST_WORD_SIZE  = 1,
 498   INST_DWORD_SIZE = 2
 499 };
 500
 501 /* Addressing modes.  */
 502 enum cris_addressing_modes
 503 {
 504   REGISTER_MODE = 1,
 505   INDIRECT_MODE = 2,
 506   AUTOINC_MODE  = 3
 507 };
 508
 509 /* Prefix addressing modes.  */
 510 enum cris_prefix_addressing_modes
 511 {
 512   PREFIX_INDEX_MODE  = 2,
 513   PREFIX_ASSIGN_MODE = 3,
 514
 515   /* Handle immediate byte offset addressing mode prefix format.  */
 516   PREFIX_OFFSET_MODE = 2
 517 };
 518
 519 /* Masks for opcodes.  */
 520 enum cris_opcode_masks
 521 {
 522   BRANCH_SIGNED_SHORT_OFFSET_MASK = 0x1,
 523   SIGNED_EXTEND_BIT_MASK          = 0x2,
 524   SIGNED_BYTE_MASK                = 0x80,
 525   SIGNED_BYTE_EXTEND_MASK         = 0xFFFFFF00,
 526   SIGNED_WORD_MASK                = 0x8000,
 527   SIGNED_WORD_EXTEND_MASK         = 0xFFFF0000,
 528   SIGNED_DWORD_MASK               = 0x80000000,
 529   SIGNED_QUICK_VALUE_MASK         = 0x20,
 530   SIGNED_QUICK_VALUE_EXTEND_MASK  = 0xFFFFFFC0
 531 };
 532
 533 /* Functions for opcodes.  The general form of the ETRAX 16-bit instruction:
 534    Bit 15 - 12   Operand2
 535        11 - 10   Mode
 536         9 -  6   Opcode
 537         5 -  4   Size
 538         3 -  0   Operand1  */
 539
 540 static int
 541 cris_get_operand2 (unsigned short insn)
 542 {
 543   return ((insn & 0xF000) >> 12);
 544 }
 545
 546 static int
 547 cris_get_mode (unsigned short insn)
 548 {
 549   return ((insn & 0x0C00) >> 10);
 550 }
 551
 552 static int
 553 cris_get_opcode (unsigned short insn)
 554 {
 555   return ((insn & 0x03C0) >> 6);
 556 }
 557
 558 static int
 559 cris_get_size (unsigned short insn)
 560 {
 561   return ((insn & 0x0030) >> 4);
 562 }
 563
 564 static int
 565 cris_get_operand1 (unsigned short insn)
 566 {
 567   return (insn & 0x000F);
 568 }
 569
 570 /* Additional functions in order to handle opcodes.  */
 571
 572 static int
 573 cris_get_quick_value (unsigned short insn)
 574 {
 575   return (insn & 0x003F);
 576 }
 577
 578 static int
 579 cris_get_bdap_quick_offset (unsigned short insn)
 580 {
 581   return (insn & 0x00FF);
 582 }
 583
 584 static int
 585 cris_get_branch_short_offset (unsigned short insn)
 586 {
 587   return (insn & 0x00FF);
 588 }
 589
 590 static int
 591 cris_get_asr_shift_steps (unsigned long value)
 592 {
 593   return (value & 0x3F);
 594 }
 595
 596 static int
 597 cris_get_clear_size (unsigned short insn)
 598 {
 599   return ((insn) & 0xC000);
 600 }
 601
 602 static int
 603 cris_is_signed_extend_bit_on (unsigned short insn)
 604 {
 605   return (((insn) & 0x20) == 0x20);
 606 }
 607
 608 static int
 609 cris_is_xflag_bit_on (unsigned short insn)
 610 {
 611   return (((insn) & 0x1000) == 0x1000);
 612 }
 613
 614 static void
 615 cris_set_size_to_dword (unsigned short *insn)
 616 {
 617   *insn &= 0xFFCF;
 618   *insn |= 0x20;
 619 }
 620
 621 static signed char
 622 cris_get_signed_offset (unsigned short insn)
 623 {
 624   return ((signed char) (insn & 0x00FF));
 625 }
 626
 627 /* Calls an op function given the op-type, working on the insn and the
 628    inst_env.  */
 629 static void cris_gdb_func (struct gdbarch *, enum cris_op_type, unsigned short,
 630                            inst_env_type *);
 631
 632 static struct gdbarch *cris_gdbarch_init (struct gdbarch_info,
 633                                           struct gdbarch_list *);
 634
 635 static void cris_dump_tdep (struct gdbarch *, struct ui_file *);
 636
 637 static void set_cris_version (char *ignore_args, int from_tty,
 638                               struct cmd_list_element *c);
 639
 640 static void set_cris_mode (char *ignore_args, int from_tty,
 641                            struct cmd_list_element *c);
 642
 643 static void set_cris_dwarf2_cfi (char *ignore_args, int from_tty,
 644                                  struct cmd_list_element *c);
 645
 646 static CORE_ADDR cris_scan_prologue (CORE_ADDR pc,
 647                                      struct frame_info *this_frame,
 648                                      struct cris_unwind_cache *info);
 649
 650 static CORE_ADDR crisv32_scan_prologue (CORE_ADDR pc,
 651                                         struct frame_info *this_frame,
 652                                         struct cris_unwind_cache *info);
 653
 654 static CORE_ADDR cris_unwind_pc (struct gdbarch *gdbarch,
 655                                  struct frame_info *next_frame);
 656
 657 static CORE_ADDR cris_unwind_sp (struct gdbarch *gdbarch,
 658                                  struct frame_info *next_frame);
 659
 660 /* When arguments must be pushed onto the stack, they go on in reverse
 661    order.  The below implements a FILO (stack) to do this.
 662    Copied from d10v-tdep.c.  */
 663
 664 struct stack_item
 665 {
 666   int len;
 667   struct stack_item *prev;
 668   gdb_byte *data;
 669 };
 670
 671 static struct stack_item *
 672 push_stack_item (struct stack_item *prev, const gdb_byte *contents, int len)
 673 {
 674   struct stack_item *si = XNEW (struct stack_item);
 675   si->data = (gdb_byte *) xmalloc (len);
 676   si->len = len;
 677   si->prev = prev;
 678   memcpy (si->data, contents, len);
 679   return si;
 680 }
 681
 682 static struct stack_item *
 683 pop_stack_item (struct stack_item *si)
 684 {
 685   struct stack_item *dead = si;
 686   si = si->prev;
 687   xfree (dead->data);
 688   xfree (dead);
 689   return si;
 690 }
 691
 692 /* Put here the code to store, into fi->saved_regs, the addresses of
 693    the saved registers of frame described by FRAME_INFO.  This
 694    includes special registers such as pc and fp saved in special ways
 695    in the stack frame.  sp is even more special: the address we return
 696    for it IS the sp for the next frame.  */
 697
 698 static struct cris_unwind_cache *
 699 cris_frame_unwind_cache (struct frame_info *this_frame,
 700                          void **this_prologue_cache)
 701 {
 702   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 703   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 704   struct cris_unwind_cache *info;
 705
 706   if ((*this_prologue_cache))
 707     return (struct cris_unwind_cache *) (*this_prologue_cache);
 708
 709   info = FRAME_OBSTACK_ZALLOC (struct cris_unwind_cache);
 710   (*this_prologue_cache) = info;
 711   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 712
 713   /* Zero all fields.  */
 714   info->prev_sp = 0;
 715   info->base = 0;
 716   info->size = 0;
 717   info->sp_offset = 0;
 718   info->r8_offset = 0;
 719   info->uses_frame = 0;
 720   info->return_pc = 0;
 721   info->leaf_function = 0;
 722
 723   /* Prologue analysis does the rest...  */
 724   if (tdep->cris_version == 32)
 725     crisv32_scan_prologue (get_frame_func (this_frame), this_frame, info);
 726   else
 727     cris_scan_prologue (get_frame_func (this_frame), this_frame, info);
 728
 729   return info;
 730 }
 731
 732 /* Given a GDB frame, determine the address of the calling function's
 733    frame.  This will be used to create a new GDB frame struct.  */
 734
 735 static void
 736 cris_frame_this_id (struct frame_info *this_frame,
 737                     void **this_prologue_cache,
 738                     struct frame_id *this_id)
 739 {
 740   struct cris_unwind_cache *info
 741     = cris_frame_unwind_cache (this_frame, this_prologue_cache);
 742   CORE_ADDR base;
 743   CORE_ADDR func;
 744   struct frame_id id;
 745
 746   /* The FUNC is easy.  */
 747   func = get_frame_func (this_frame);
 748
 749   /* Hopefully the prologue analysis either correctly determined the
 750      frame's base (which is the SP from the previous frame), or set
 751      that base to "NULL".  */
 752   base = info->prev_sp;
 753   if (base == 0)
 754     return;
 755
 756   id = frame_id_build (base, func);
 757
 758   (*this_id) = id;
 759 }
 760
 761 static struct value *
 762 cris_frame_prev_register (struct frame_info *this_frame,
 763                           void **this_prologue_cache, int regnum)
 764 {
 765   struct cris_unwind_cache *info
 766     = cris_frame_unwind_cache (this_frame, this_prologue_cache);
 767   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
 768 }
 769
 770 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
 771    frame.  The frame ID's base needs to match the TOS value saved by
 772    save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint.  */
 773
 774 static struct frame_id
 775 cris_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 776 {
 777   CORE_ADDR sp;
 778   sp = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
 779   return frame_id_build (sp, get_frame_pc (this_frame));
 780 }
 781
 782 static CORE_ADDR
 783 cris_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 784 {
 785   /* Align to the size of an instruction (so that they can safely be
 786      pushed onto the stack).  */
 787   return sp & ~3;
 788 }
 789
 790 static CORE_ADDR
 791 cris_push_dummy_code (struct gdbarch *gdbarch,
 792                       CORE_ADDR sp, CORE_ADDR funaddr,
 793                       struct value **args, int nargs,
 794                       struct type *value_type,
 795                       CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
 796                       struct regcache *regcache)
 797 {
 798   /* Allocate space sufficient for a breakpoint.  */
 799   sp = (sp - 4) & ~3;
 800   /* Store the address of that breakpoint */
 801   *bp_addr = sp;
 802   /* CRIS always starts the call at the callee's entry point.  */
 803   *real_pc = funaddr;
 804   return sp;
 805 }
 806
 807 static CORE_ADDR
 808 cris_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 809                       struct regcache *regcache, CORE_ADDR bp_addr,
 810                       int nargs, struct value **args, CORE_ADDR sp,
 811                       int struct_return, CORE_ADDR struct_addr)
 812 {
 813   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 814   int argreg;
 815   int argnum;
 816
 817   struct stack_item *si = NULL;
 818
 819   /* Push the return address.  */
 820   regcache_cooked_write_unsigned (regcache, SRP_REGNUM, bp_addr);
 821
 822   /* Are we returning a value using a structure return or a normal value
 823      return?  struct_addr is the address of the reserved space for the return
 824      structure to be written on the stack.  */
 825   if (struct_return)
 826     {
 827       regcache_cooked_write_unsigned (regcache, STR_REGNUM, struct_addr);
 828     }
 829
 830   /* Now load as many as possible of the first arguments into registers,
 831      and push the rest onto the stack.  */
 832   argreg = ARG1_REGNUM;
 833
 834   for (argnum = 0; argnum < nargs; argnum++)
 835     {
 836       int len;
 837       const gdb_byte *val;
 838       int reg_demand;
 839       int i;
 840
 841       len = TYPE_LENGTH (value_type (args[argnum]));
 842       val = value_contents (args[argnum]);
 843
 844       /* How may registers worth of storage do we need for this argument?  */
 845       reg_demand = (len / 4) + (len % 4 != 0 ? 1 : 0);
 846
 847       if (len <= (2 * 4) && (argreg + reg_demand - 1 <= ARG4_REGNUM))
 848         {
 849           /* Data passed by value.  Fits in available register(s).  */
 850           for (i = 0; i < reg_demand; i++)
 851             {
 852               regcache_cooked_write (regcache, argreg, val);
 853               argreg++;
 854               val += 4;
 855             }
 856         }
 857       else if (len <= (2 * 4) && argreg <= ARG4_REGNUM)
 858         {
 859           /* Data passed by value. Does not fit in available register(s).
 860              Use the register(s) first, then the stack.  */
 861           for (i = 0; i < reg_demand; i++)
 862             {
 863               if (argreg <= ARG4_REGNUM)
 864                 {
 865                   regcache_cooked_write (regcache, argreg, val);
 866                   argreg++;
 867                   val += 4;
 868                 }
 869               else
 870                 {
 871                   /* Push item for later so that pushed arguments
 872                      come in the right order.  */
 873                   si = push_stack_item (si, val, 4);
 874                   val += 4;
 875                 }
 876             }
 877         }
 878       else if (len > (2 * 4))
 879         {
 880           /* Data passed by reference.  Push copy of data onto stack
 881              and pass pointer to this copy as argument.  */
 882           sp = (sp - len) & ~3;
 883           write_memory (sp, val, len);
 884
 885           if (argreg <= ARG4_REGNUM)
 886             {
 887               regcache_cooked_write_unsigned (regcache, argreg, sp);
 888               argreg++;
 889             }
 890           else
 891             {
 892               gdb_byte buf[4];
 893               store_unsigned_integer (buf, 4, byte_order, sp);
 894               si = push_stack_item (si, buf, 4);
 895             }
 896         }
 897       else
 898         {
 899           /* Data passed by value.  No available registers.  Put it on
 900              the stack.  */
 901            si = push_stack_item (si, val, len);
 902         }
 903     }
 904
 905   while (si)
 906     {
 907       /* fp_arg must be word-aligned (i.e., don't += len) to match
 908          the function prologue.  */
 909       sp = (sp - si->len) & ~3;
 910       write_memory (sp, si->data, si->len);
 911       si = pop_stack_item (si);
 912     }
 913
 914   /* Finally, update the SP register.  */
 915   regcache_cooked_write_unsigned (regcache, gdbarch_sp_regnum (gdbarch), sp);
 916
 917   return sp;
 918 }
 919
 920 static const struct frame_unwind cris_frame_unwind =
 921 {
 922   NORMAL_FRAME,
 923   default_frame_unwind_stop_reason,
 924   cris_frame_this_id,
 925   cris_frame_prev_register,
 926   NULL,
 927   default_frame_sniffer
 928 };
 929
 930 static CORE_ADDR
 931 cris_frame_base_address (struct frame_info *this_frame, void **this_cache)
 932 {
 933   struct cris_unwind_cache *info
 934     = cris_frame_unwind_cache (this_frame, this_cache);
 935   return info->base;
 936 }
 937
 938 static const struct frame_base cris_frame_base =
 939 {
 940   &cris_frame_unwind,
 941   cris_frame_base_address,
 942   cris_frame_base_address,
 943   cris_frame_base_address
 944 };
 945
 946 /* Frames information. The definition of the struct frame_info is
 947
 948    CORE_ADDR frame
 949    CORE_ADDR pc
 950    enum frame_type type;
 951    CORE_ADDR return_pc
 952    int leaf_function
 953
 954    If the compilation option -fno-omit-frame-pointer is present the
 955    variable frame will be set to the content of R8 which is the frame
 956    pointer register.
 957
 958    The variable pc contains the address where execution is performed
 959    in the present frame.  The innermost frame contains the current content
 960    of the register PC.  All other frames contain the content of the
 961    register PC in the next frame.
 962
 963    The variable `type' indicates the frame's type: normal, SIGTRAMP
 964    (associated with a signal handler), dummy (associated with a dummy
 965    frame).
 966
 967    The variable return_pc contains the address where execution should be
 968    resumed when the present frame has finished, the return address.
 969
 970    The variable leaf_function is 1 if the return address is in the register
 971    SRP, and 0 if it is on the stack.
 972
 973    Prologue instructions C-code.
 974    The prologue may consist of (-fno-omit-frame-pointer)
 975    1)                2)
 976    push   srp
 977    push   r8         push   r8
 978    move.d sp,r8      move.d sp,r8
 979    subq   X,sp       subq   X,sp
 980    movem  rY,[sp]    movem  rY,[sp]
 981    move.S rZ,[r8-U]  move.S rZ,[r8-U]
 982
 983    where 1 is a non-terminal function, and 2 is a leaf-function.
 984
 985    Note that this assumption is extremely brittle, and will break at the
 986    slightest change in GCC's prologue.
 987
 988    If local variables are declared or register contents are saved on stack
 989    the subq-instruction will be present with X as the number of bytes
 990    needed for storage.  The reshuffle with respect to r8 may be performed
 991    with any size S (b, w, d) and any of the general registers Z={0..13}.
 992    The offset U should be representable by a signed 8-bit value in all cases.
 993    Thus, the prefix word is assumed to be immediate byte offset mode followed
 994    by another word containing the instruction.
 995
 996    Degenerate cases:
 997    3)
 998    push   r8
 999    move.d sp,r8
1000    move.d r8,sp
1001    pop    r8
1002
1003    Prologue instructions C++-code.
1004    Case 1) and 2) in the C-code may be followed by
1005
1006    move.d r10,rS    ; this
1007    move.d r11,rT    ; P1
1008    move.d r12,rU    ; P2
1009    move.d r13,rV    ; P3
1010    move.S [r8+U],rZ ; P4
1011
1012    if any of the call parameters are stored.  The host expects these
1013    instructions to be executed in order to get the call parameters right.  */
1014
1015 /* Examine the prologue of a function.  The variable ip is the address of
1016    the first instruction of the prologue.  The variable limit is the address
1017    of the first instruction after the prologue.  The variable fi contains the
1018    information in struct frame_info.  The variable frameless_p controls whether
1019    the entire prologue is examined (0) or just enough instructions to
1020    determine that it is a prologue (1).  */
1021
1022 static CORE_ADDR
1023 cris_scan_prologue (CORE_ADDR pc, struct frame_info *this_frame,
1024                     struct cris_unwind_cache *info)
1025 {
1026   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1027   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1028
1029   /* Present instruction.  */
1030   unsigned short insn;
1031
1032   /* Next instruction, lookahead.  */
1033   unsigned short insn_next;
1034   int regno;
1035
1036   /* Number of byte on stack used for local variables and movem.  */
1037   int val;
1038
1039   /* Highest register number in a movem.  */
1040   int regsave;
1041
1042   /* move.d r<source_register>,rS */
1043   short source_register;
1044
1045   /* Scan limit.  */
1046   int limit;
1047
1048   /* This frame is with respect to a leaf until a push srp is found.  */
1049   if (info)
1050     {
1051       info->leaf_function = 1;
1052     }
1053
1054   /* Assume nothing on stack.  */
1055   val = 0;
1056   regsave = -1;
1057
1058   /* If we were called without a this_frame, that means we were called
1059      from cris_skip_prologue which already tried to find the end of the
1060      prologue through the symbol information.  64 instructions past current
1061      pc is arbitrarily chosen, but at least it means we'll stop eventually.  */
1062   limit = this_frame ? get_frame_pc (this_frame) : pc + 64;
1063
1064   /* Find the prologue instructions.  */
1065   while (pc > 0 && pc < limit)
1066     {
1067       insn = read_memory_unsigned_integer (pc, 2, byte_order);
1068       pc += 2;
1069       if (insn == 0xE1FC)
1070         {
1071           /* push <reg> 32 bit instruction.  */
1072           insn_next = read_memory_unsigned_integer (pc, 2, byte_order);
1073           pc += 2;
1074           regno = cris_get_operand2 (insn_next);
1075           if (info)
1076             {
1077               info->sp_offset += 4;
1078             }
1079           /* This check, meant to recognize srp, used to be regno ==
1080              (SRP_REGNUM - NUM_GENREGS), but that covers r11 also.  */
1081           if (insn_next == 0xBE7E)
1082             {
1083               if (info)
1084                 {
1085                   info->leaf_function = 0;
1086                 }
1087             }
1088           else if (insn_next == 0x8FEE)
1089             {
1090               /* push $r8 */
1091               if (info)
1092                 {
1093                   info->r8_offset = info->sp_offset;
1094                 }
1095             }
1096         }
1097       else if (insn == 0x866E)
1098         {
1099           /* move.d sp,r8 */
1100           if (info)
1101             {
1102               info->uses_frame = 1;
1103             }
1104           continue;
1105         }
1106       else if (cris_get_operand2 (insn) == gdbarch_sp_regnum (gdbarch)
1107                && cris_get_mode (insn) == 0x0000
1108                && cris_get_opcode (insn) == 0x000A)
1109         {
1110           /* subq <val>,sp */
1111           if (info)
1112             {
1113               info->sp_offset += cris_get_quick_value (insn);
1114             }
1115         }
1116       else if (cris_get_mode (insn) == 0x0002
1117                && cris_get_opcode (insn) == 0x000F
1118                && cris_get_size (insn) == 0x0003
1119                && cris_get_operand1 (insn) == gdbarch_sp_regnum (gdbarch))
1120         {
1121           /* movem r<regsave>,[sp] */
1122           regsave = cris_get_operand2 (insn);
1123         }
1124       else if (cris_get_operand2 (insn) == gdbarch_sp_regnum (gdbarch)
1125                && ((insn & 0x0F00) >> 8) == 0x0001
1126                && (cris_get_signed_offset (insn) < 0))
1127         {
1128           /* Immediate byte offset addressing prefix word with sp as base
1129              register.  Used for CRIS v8 i.e. ETRAX 100 and newer if <val>
1130              is between 64 and 128.
1131              movem r<regsave>,[sp=sp-<val>] */
1132           if (info)
1133             {
1134               info->sp_offset += -cris_get_signed_offset (insn);
1135             }
1136           insn_next = read_memory_unsigned_integer (pc, 2, byte_order);
1137           pc += 2;
1138           if (cris_get_mode (insn_next) == PREFIX_ASSIGN_MODE
1139               && cris_get_opcode (insn_next) == 0x000F
1140               && cris_get_size (insn_next) == 0x0003
1141               && cris_get_operand1 (insn_next) == gdbarch_sp_regnum
1142                                                   (gdbarch))
1143             {
1144               regsave = cris_get_operand2 (insn_next);
1145             }
1146           else
1147             {
1148               /* The prologue ended before the limit was reached.  */
1149               pc -= 4;
1150               break;
1151             }
1152         }
1153       else if (cris_get_mode (insn) == 0x0001
1154                && cris_get_opcode (insn) == 0x0009
1155                && cris_get_size (insn) == 0x0002)
1156         {
1157           /* move.d r<10..13>,r<0..15> */
1158           source_register = cris_get_operand1 (insn);
1159
1160           /* FIXME?  In the glibc solibs, the prologue might contain something
1161              like (this example taken from relocate_doit):
1162              move.d $pc,$r0
1163              sub.d 0xfffef426,$r0
1164              which isn't covered by the source_register check below.  Question
1165              is whether to add a check for this combo, or make better use of
1166              the limit variable instead.  */
1167           if (source_register < ARG1_REGNUM || source_register > ARG4_REGNUM)
1168             {
1169               /* The prologue ended before the limit was reached.  */
1170               pc -= 2;
1171               break;
1172             }
1173         }
1174       else if (cris_get_operand2 (insn) == CRIS_FP_REGNUM
1175                /* The size is a fixed-size.  */
1176                && ((insn & 0x0F00) >> 8) == 0x0001
1177                /* A negative offset.  */
1178                && (cris_get_signed_offset (insn) < 0))
1179         {
1180           /* move.S rZ,[r8-U] (?) */
1181           insn_next = read_memory_unsigned_integer (pc, 2, byte_order);
1182           pc += 2;
1183           regno = cris_get_operand2 (insn_next);
1184           if ((regno >= 0 && regno < gdbarch_sp_regnum (gdbarch))
1185               && cris_get_mode (insn_next) == PREFIX_OFFSET_MODE
1186               && cris_get_opcode (insn_next) == 0x000F)
1187             {
1188               /* move.S rZ,[r8-U] */
1189               continue;
1190             }
1191           else
1192             {
1193               /* The prologue ended before the limit was reached.  */
1194               pc -= 4;
1195               break;
1196             }
1197         }
1198       else if (cris_get_operand2 (insn) == CRIS_FP_REGNUM
1199                /* The size is a fixed-size.  */
1200                && ((insn & 0x0F00) >> 8) == 0x0001
1201                /* A positive offset.  */
1202                && (cris_get_signed_offset (insn) > 0))
1203         {
1204           /* move.S [r8+U],rZ (?) */
1205           insn_next = read_memory_unsigned_integer (pc, 2, byte_order);
1206           pc += 2;
1207           regno = cris_get_operand2 (insn_next);
1208           if ((regno >= 0 && regno < gdbarch_sp_regnum (gdbarch))
1209               && cris_get_mode (insn_next) == PREFIX_OFFSET_MODE
1210               && cris_get_opcode (insn_next) == 0x0009
1211               && cris_get_operand1 (insn_next) == regno)
1212             {
1213               /* move.S [r8+U],rZ */
1214               continue;
1215             }
1216           else
1217             {
1218               /* The prologue ended before the limit was reached.  */
1219               pc -= 4;
1220               break;
1221             }
1222         }
1223       else
1224         {
1225           /* The prologue ended before the limit was reached.  */
1226           pc -= 2;
1227           break;
1228         }
1229     }
1230
1231   /* We only want to know the end of the prologue when this_frame and info
1232      are NULL (called from cris_skip_prologue i.e.).  */
1233   if (this_frame == NULL && info == NULL)
1234     {
1235       return pc;
1236     }
1237
1238   info->size = info->sp_offset;
1239
1240   /* Compute the previous frame's stack pointer (which is also the
1241      frame's ID's stack address), and this frame's base pointer.  */
1242   if (info->uses_frame)
1243     {
1244       ULONGEST this_base;
1245       /* The SP was moved to the FP.  This indicates that a new frame
1246          was created.  Get THIS frame's FP value by unwinding it from
1247          the next frame.  */
1248       this_base = get_frame_register_unsigned (this_frame, CRIS_FP_REGNUM);
1249       info->base = this_base;
1250       info->saved_regs[CRIS_FP_REGNUM].addr = info->base;
1251
1252       /* The FP points at the last saved register.  Adjust the FP back
1253          to before the first saved register giving the SP.  */
1254       info->prev_sp = info->base + info->r8_offset;
1255     }
1256   else
1257     {
1258       ULONGEST this_base;
1259       /* Assume that the FP is this frame's SP but with that pushed
1260          stack space added back.  */
1261       this_base = get_frame_register_unsigned (this_frame,
1262                                                gdbarch_sp_regnum (gdbarch));
1263       info->base = this_base;
1264       info->prev_sp = info->base + info->size;
1265     }
1266
1267   /* Calculate the addresses for the saved registers on the stack.  */
1268   /* FIXME: The address calculation should really be done on the fly while
1269      we're analyzing the prologue (we only hold one regsave value as it is
1270      now).  */
1271   val = info->sp_offset;
1272
1273   for (regno = regsave; regno >= 0; regno--)
1274     {
1275       info->saved_regs[regno].addr = info->base + info->r8_offset - val;
1276       val -= 4;
1277     }
1278
1279   /* The previous frame's SP needed to be computed.  Save the computed
1280      value.  */
1281   trad_frame_set_value (info->saved_regs,
1282                         gdbarch_sp_regnum (gdbarch), info->prev_sp);
1283
1284   if (!info->leaf_function)
1285     {
1286       /* SRP saved on the stack.  But where?  */
1287       if (info->r8_offset == 0)
1288         {
1289           /* R8 not pushed yet.  */
1290           info->saved_regs[SRP_REGNUM].addr = info->base;
1291         }
1292       else
1293         {
1294           /* R8 pushed, but SP may or may not be moved to R8 yet.  */
1295           info->saved_regs[SRP_REGNUM].addr = info->base + 4;
1296         }
1297     }
1298
1299   /* The PC is found in SRP (the actual register or located on the stack).  */
1300   info->saved_regs[gdbarch_pc_regnum (gdbarch)]
1301     = info->saved_regs[SRP_REGNUM];
1302
1303   return pc;
1304 }
1305
1306 static CORE_ADDR
1307 crisv32_scan_prologue (CORE_ADDR pc, struct frame_info *this_frame,
1308                     struct cris_unwind_cache *info)
1309 {
1310   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1311   ULONGEST this_base;
1312
1313   /* Unlike the CRISv10 prologue scanner (cris_scan_prologue), this is not
1314      meant to be a full-fledged prologue scanner.  It is only needed for
1315      the cases where we end up in code always lacking DWARF-2 CFI, notably:
1316
1317        * PLT stubs (library calls)
1318        * call dummys
1319        * signal trampolines
1320
1321      For those cases, it is assumed that there is no actual prologue; that
1322      the stack pointer is not adjusted, and (as a consequence) the return
1323      address is not pushed onto the stack.  */
1324
1325   /* We only want to know the end of the prologue when this_frame and info
1326      are NULL (called from cris_skip_prologue i.e.).  */
1327   if (this_frame == NULL && info == NULL)
1328     {
1329       return pc;
1330     }
1331
1332   /* The SP is assumed to be unaltered.  */
1333   this_base = get_frame_register_unsigned (this_frame,
1334                                            gdbarch_sp_regnum (gdbarch));
1335   info->base = this_base;
1336   info->prev_sp = this_base;
1337
1338   /* The PC is assumed to be found in SRP.  */
1339   info->saved_regs[gdbarch_pc_regnum (gdbarch)]
1340     = info->saved_regs[SRP_REGNUM];
1341
1342   return pc;
1343 }
1344
1345 /* Advance pc beyond any function entry prologue instructions at pc
1346    to reach some "real" code.  */
1347
1348 /* Given a PC value corresponding to the start of a function, return the PC
1349    of the first instruction after the function prologue.  */
1350
1351 static CORE_ADDR
1352 cris_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1353 {
1354   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1355   CORE_ADDR func_addr, func_end;
1356   struct symtab_and_line sal;
1357   CORE_ADDR pc_after_prologue;
1358
1359   /* If we have line debugging information, then the end of the prologue
1360      should the first assembly instruction of the first source line.  */
1361   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
1362     {
1363       sal = find_pc_line (func_addr, 0);
1364       if (sal.end > 0 && sal.end < func_end)
1365         return sal.end;
1366     }
1367
1368   if (tdep->cris_version == 32)
1369     pc_after_prologue = crisv32_scan_prologue (pc, NULL, NULL);
1370   else
1371     pc_after_prologue = cris_scan_prologue (pc, NULL, NULL);
1372
1373   return pc_after_prologue;
1374 }
1375
1376 static CORE_ADDR
1377 cris_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1378 {
1379   ULONGEST pc;
1380   pc = frame_unwind_register_unsigned (next_frame,
1381                                        gdbarch_pc_regnum (gdbarch));
1382   return pc;
1383 }
1384
1385 static CORE_ADDR
1386 cris_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1387 {
1388   ULONGEST sp;
1389   sp = frame_unwind_register_unsigned (next_frame,
1390                                        gdbarch_sp_regnum (gdbarch));
1391   return sp;
1392 }
1393
1394 static int
1395 cris_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
1396 {
1397   return 2;
1398 }
1399
1400 static const gdb_byte *
1401 cris_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
1402 {
1403   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1404   static unsigned char break8_insn[] = {0x38, 0xe9};
1405   static unsigned char break15_insn[] = {0x3f, 0xe9};
1406
1407   *size = kind;
1408
1409   if (tdep->cris_mode == cris_mode_guru)
1410     return break15_insn;
1411   else
1412     return break8_insn;
1413 }
1414
1415 /* Use the program counter to determine the contents and size of a breakpoint
1416    instruction.  It returns a pointer to a string of bytes that encode a
1417    breakpoint instruction, stores the length of the string to *lenptr, and
1418    adjusts pcptr (if necessary) to point to the actual memory location where
1419    the breakpoint should be inserted.  */
1420
1421 GDBARCH_BREAKPOINT_FROM_PC (cris)
1422
1423 /* Returns 1 if spec_reg is applicable to the current gdbarch's CRIS version,
1424    0 otherwise.  */
1425
1426 static int
1427 cris_spec_reg_applicable (struct gdbarch *gdbarch,
1428                           struct cris_spec_reg spec_reg)
1429 {
1430   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1431   unsigned int version = tdep->cris_version;
1432
1433   switch (spec_reg.applicable_version)
1434     {
1435     case cris_ver_version_all:
1436       return 1;
1437     case cris_ver_warning:
1438       /* Indeterminate/obsolete.  */
1439       return 0;
1440     case cris_ver_v0_3:
1441       return (version >= 0 && version <= 3);
1442     case cris_ver_v3p:
1443       return (version >= 3);
1444     case cris_ver_v8:
1445       return (version == 8 || version == 9);
1446     case cris_ver_v8p:
1447       return (version >= 8);
1448     case cris_ver_v0_10:
1449       return (version >= 0 && version <= 10);
1450     case cris_ver_v3_10:
1451       return (version >= 3 && version <= 10);
1452     case cris_ver_v8_10:
1453       return (version >= 8 && version <= 10);
1454     case cris_ver_v10:
1455       return (version == 10);
1456     case cris_ver_v10p:
1457       return (version >= 10);
1458     case cris_ver_v32p:
1459       return (version >= 32);
1460     default:
1461       /* Invalid cris version.  */
1462       return 0;
1463     }
1464 }
1465
1466 /* Returns the register size in unit byte.  Returns 0 for an unimplemented
1467    register, -1 for an invalid register.  */
1468
1469 static int
1470 cris_register_size (struct gdbarch *gdbarch, int regno)
1471 {
1472   int i;
1473   int spec_regno;
1474
1475   if (regno >= 0 && regno < NUM_GENREGS)
1476     {
1477       /* General registers (R0 - R15) are 32 bits.  */
1478       return 4;
1479     }
1480   else if (regno >= NUM_GENREGS && regno < (NUM_GENREGS + NUM_SPECREGS))
1481     {
1482       /* Special register (R16 - R31).  cris_spec_regs is zero-based.
1483          Adjust regno accordingly.  */
1484       spec_regno = regno - NUM_GENREGS;
1485
1486       for (i = 0; cris_spec_regs[i].name != NULL; i++)
1487         {
1488           if (cris_spec_regs[i].number == spec_regno
1489               && cris_spec_reg_applicable (gdbarch, cris_spec_regs[i]))
1490             /* Go with the first applicable register.  */
1491             return cris_spec_regs[i].reg_size;
1492         }
1493       /* Special register not applicable to this CRIS version.  */
1494       return 0;
1495     }
1496   else if (regno >= gdbarch_pc_regnum (gdbarch)
1497            && regno < gdbarch_num_regs (gdbarch))
1498     {
1499       /* This will apply to CRISv32 only where there are additional registers
1500          after the special registers (pseudo PC and support registers).  */
1501       return 4;
1502     }
1503
1504
1505   return -1;
1506 }
1507
1508 /* Nonzero if regno should not be fetched from the target.  This is the case
1509    for unimplemented (size 0) and non-existant registers.  */
1510
1511 static int
1512 cris_cannot_fetch_register (struct gdbarch *gdbarch, int regno)
1513 {
1514   return ((regno < 0 || regno >= gdbarch_num_regs (gdbarch))
1515           || (cris_register_size (gdbarch, regno) == 0));
1516 }
1517
1518 /* Nonzero if regno should not be written to the target, for various
1519    reasons.  */
1520
1521 static int
1522 cris_cannot_store_register (struct gdbarch *gdbarch, int regno)
1523 {
1524   /* There are three kinds of registers we refuse to write to.
1525      1. Those that not implemented.
1526      2. Those that are read-only (depends on the processor mode).
1527      3. Those registers to which a write has no effect.  */
1528
1529   if (regno < 0
1530       || regno >= gdbarch_num_regs (gdbarch)
1531       || cris_register_size (gdbarch, regno) == 0)
1532     /* Not implemented.  */
1533     return 1;
1534
1535   else if  (regno == VR_REGNUM)
1536     /* Read-only.  */
1537     return 1;
1538
1539   else if  (regno == P0_REGNUM || regno == P4_REGNUM || regno == P8_REGNUM)
1540     /* Writing has no effect.  */
1541     return 1;
1542
1543   /* IBR, BAR, BRP and IRP are read-only in user mode.  Let the debug
1544      agent decide whether they are writable.  */
1545
1546   return 0;
1547 }
1548
1549 /* Nonzero if regno should not be fetched from the target.  This is the case
1550    for unimplemented (size 0) and non-existant registers.  */
1551
1552 static int
1553 crisv32_cannot_fetch_register (struct gdbarch *gdbarch, int regno)
1554 {
1555   return ((regno < 0 || regno >= gdbarch_num_regs (gdbarch))
1556           || (cris_register_size (gdbarch, regno) == 0));
1557 }
1558
1559 /* Nonzero if regno should not be written to the target, for various
1560    reasons.  */
1561
1562 static int
1563 crisv32_cannot_store_register (struct gdbarch *gdbarch, int regno)
1564 {
1565   /* There are three kinds of registers we refuse to write to.
1566      1. Those that not implemented.
1567      2. Those that are read-only (depends on the processor mode).
1568      3. Those registers to which a write has no effect.  */
1569
1570   if (regno < 0
1571       || regno >= gdbarch_num_regs (gdbarch)
1572       || cris_register_size (gdbarch, regno) == 0)
1573     /* Not implemented.  */
1574     return 1;
1575
1576   else if  (regno == VR_REGNUM)
1577     /* Read-only.  */
1578     return 1;
1579
1580   else if  (regno == BZ_REGNUM || regno == WZ_REGNUM || regno == DZ_REGNUM)
1581     /* Writing has no effect.  */
1582     return 1;
1583
1584   /* Many special registers are read-only in user mode.  Let the debug
1585      agent decide whether they are writable.  */
1586
1587   return 0;
1588 }
1589
1590 /* Return the GDB type (defined in gdbtypes.c) for the "standard" data type
1591    of data in register regno.  */
1592
1593 static struct type *
1594 cris_register_type (struct gdbarch *gdbarch, int regno)
1595 {
1596   if (regno == gdbarch_pc_regnum (gdbarch))
1597     return builtin_type (gdbarch)->builtin_func_ptr;
1598   else if (regno == gdbarch_sp_regnum (gdbarch)
1599            || regno == CRIS_FP_REGNUM)
1600     return builtin_type (gdbarch)->builtin_data_ptr;
1601   else if ((regno >= 0 && regno < gdbarch_sp_regnum (gdbarch))
1602            || (regno >= MOF_REGNUM && regno <= USP_REGNUM))
1603     /* Note: R8 taken care of previous clause.  */
1604     return builtin_type (gdbarch)->builtin_uint32;
1605   else if (regno >= P4_REGNUM && regno <= CCR_REGNUM)
1606       return builtin_type (gdbarch)->builtin_uint16;
1607   else if (regno >= P0_REGNUM && regno <= VR_REGNUM)
1608       return builtin_type (gdbarch)->builtin_uint8;
1609   else
1610       /* Invalid (unimplemented) register.  */
1611       return builtin_type (gdbarch)->builtin_int0;
1612 }
1613
1614 static struct type *
1615 crisv32_register_type (struct gdbarch *gdbarch, int regno)
1616 {
1617   if (regno == gdbarch_pc_regnum (gdbarch))
1618     return builtin_type (gdbarch)->builtin_func_ptr;
1619   else if (regno == gdbarch_sp_regnum (gdbarch)
1620            || regno == CRIS_FP_REGNUM)
1621     return builtin_type (gdbarch)->builtin_data_ptr;
1622   else if ((regno >= 0 && regno <= ACR_REGNUM)
1623            || (regno >= EXS_REGNUM && regno <= SPC_REGNUM)
1624            || (regno == PID_REGNUM)
1625            || (regno >= S0_REGNUM && regno <= S15_REGNUM))
1626     /* Note: R8 and SP taken care of by previous clause.  */
1627     return builtin_type (gdbarch)->builtin_uint32;
1628   else if (regno == WZ_REGNUM)
1629       return builtin_type (gdbarch)->builtin_uint16;
1630   else if (regno == BZ_REGNUM || regno == VR_REGNUM || regno == SRS_REGNUM)
1631       return builtin_type (gdbarch)->builtin_uint8;
1632   else
1633     {
1634       /* Invalid (unimplemented) register.  Should not happen as there are
1635          no unimplemented CRISv32 registers.  */
1636       warning (_("crisv32_register_type: unknown regno %d"), regno);
1637       return builtin_type (gdbarch)->builtin_int0;
1638     }
1639 }
1640
1641 /* Stores a function return value of type type, where valbuf is the address
1642    of the value to be stored.  */
1643
1644 /* In the CRIS ABI, R10 and R11 are used to store return values.  */
1645
1646 static void
1647 cris_store_return_value (struct type *type, struct regcache *regcache,
1648                          const gdb_byte *valbuf)
1649 {
1650   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1651   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1652   ULONGEST val;
1653   int len = TYPE_LENGTH (type);
1654
1655   if (len <= 4)
1656     {
1657       /* Put the return value in R10.  */
1658       val = extract_unsigned_integer (valbuf, len, byte_order);
1659       regcache_cooked_write_unsigned (regcache, ARG1_REGNUM, val);
1660     }
1661   else if (len <= 8)
1662     {
1663       /* Put the return value in R10 and R11.  */
1664       val = extract_unsigned_integer (valbuf, 4, byte_order);
1665       regcache_cooked_write_unsigned (regcache, ARG1_REGNUM, val);
1666       val = extract_unsigned_integer (valbuf + 4, len - 4, byte_order);
1667       regcache_cooked_write_unsigned (regcache, ARG2_REGNUM, val);
1668     }
1669   else
1670     error (_("cris_store_return_value: type length too large."));
1671 }
1672
1673 /* Return the name of register regno as a string.  Return NULL for an
1674    invalid or unimplemented register.  */
1675
1676 static const char *
1677 cris_special_register_name (struct gdbarch *gdbarch, int regno)
1678 {
1679   int spec_regno;
1680   int i;
1681
1682   /* Special register (R16 - R31).  cris_spec_regs is zero-based.
1683      Adjust regno accordingly.  */
1684   spec_regno = regno - NUM_GENREGS;
1685
1686   /* Assume nothing about the layout of the cris_spec_regs struct
1687      when searching.  */
1688   for (i = 0; cris_spec_regs[i].name != NULL; i++)
1689     {
1690       if (cris_spec_regs[i].number == spec_regno
1691           && cris_spec_reg_applicable (gdbarch, cris_spec_regs[i]))
1692         /* Go with the first applicable register.  */
1693         return cris_spec_regs[i].name;
1694     }
1695   /* Special register not applicable to this CRIS version.  */
1696   return NULL;
1697 }
1698
1699 static const char *
1700 cris_register_name (struct gdbarch *gdbarch, int regno)
1701 {
1702   static char *cris_genreg_names[] =
1703   { "r0",  "r1",  "r2",  "r3", \
1704     "r4",  "r5",  "r6",  "r7", \
1705     "r8",  "r9",  "r10", "r11", \
1706     "r12", "r13", "sp",  "pc" };
1707
1708   if (regno >= 0 && regno < NUM_GENREGS)
1709     {
1710       /* General register.  */
1711       return cris_genreg_names[regno];
1712     }
1713   else if (regno >= NUM_GENREGS && regno < gdbarch_num_regs (gdbarch))
1714     {
1715       return cris_special_register_name (gdbarch, regno);
1716     }
1717   else
1718     {
1719       /* Invalid register.  */
1720       return NULL;
1721     }
1722 }
1723
1724 static const char *
1725 crisv32_register_name (struct gdbarch *gdbarch, int regno)
1726 {
1727   static char *crisv32_genreg_names[] =
1728     { "r0",  "r1",  "r2",  "r3", \
1729       "r4",  "r5",  "r6",  "r7", \
1730       "r8",  "r9",  "r10", "r11", \
1731       "r12", "r13", "sp",  "acr"
1732     };
1733
1734   static char *crisv32_sreg_names[] =
1735     { "s0",  "s1",  "s2",  "s3", \
1736       "s4",  "s5",  "s6",  "s7", \
1737       "s8",  "s9",  "s10", "s11", \
1738       "s12", "s13", "s14",  "s15"
1739     };
1740
1741   if (regno >= 0 && regno < NUM_GENREGS)
1742     {
1743       /* General register.  */
1744       return crisv32_genreg_names[regno];
1745     }
1746   else if (regno >= NUM_GENREGS && regno < (NUM_GENREGS + NUM_SPECREGS))
1747     {
1748       return cris_special_register_name (gdbarch, regno);
1749     }
1750   else if (regno == gdbarch_pc_regnum (gdbarch))
1751     {
1752       return "pc";
1753     }
1754   else if (regno >= S0_REGNUM && regno <= S15_REGNUM)
1755     {
1756       return crisv32_sreg_names[regno - S0_REGNUM];
1757     }
1758   else
1759     {
1760       /* Invalid register.  */
1761       return NULL;
1762     }
1763 }
1764
1765 /* Convert DWARF register number REG to the appropriate register
1766    number used by GDB.  */
1767
1768 static int
1769 cris_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg)
1770 {
1771   /* We need to re-map a couple of registers (SRP is 16 in Dwarf-2 register
1772      numbering, MOF is 18).
1773      Adapted from gcc/config/cris/cris.h.  */
1774   static int cris_dwarf_regmap[] = {
1775     0,  1,  2,  3,
1776     4,  5,  6,  7,
1777     8,  9,  10, 11,
1778     12, 13, 14, 15,
1779     27, -1, -1, -1,
1780     -1, -1, -1, 23,
1781     -1, -1, -1, 27,
1782     -1, -1, -1, -1
1783   };
1784   int regnum = -1;
1785
1786   if (reg >= 0 && reg < ARRAY_SIZE (cris_dwarf_regmap))
1787     regnum = cris_dwarf_regmap[reg];
1788
1789   return regnum;
1790 }
1791
1792 /* DWARF-2 frame support.  */
1793
1794 static void
1795 cris_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
1796                             struct dwarf2_frame_state_reg *reg,
1797                             struct frame_info *this_frame)
1798 {
1799   /* The return address column.  */
1800   if (regnum == gdbarch_pc_regnum (gdbarch))
1801     reg->how = DWARF2_FRAME_REG_RA;
1802
1803   /* The call frame address.  */
1804   else if (regnum == gdbarch_sp_regnum (gdbarch))
1805     reg->how = DWARF2_FRAME_REG_CFA;
1806 }
1807
1808 /* Extract from an array regbuf containing the raw register state a function
1809    return value of type type, and copy that, in virtual format, into
1810    valbuf.  */
1811
1812 /* In the CRIS ABI, R10 and R11 are used to store return values.  */
1813
1814 static void
1815 cris_extract_return_value (struct type *type, struct regcache *regcache,
1816                            gdb_byte *valbuf)
1817 {
1818   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1819   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1820   ULONGEST val;
1821   int len = TYPE_LENGTH (type);
1822
1823   if (len <= 4)
1824     {
1825       /* Get the return value from R10.  */
1826       regcache_cooked_read_unsigned (regcache, ARG1_REGNUM, &val);
1827       store_unsigned_integer (valbuf, len, byte_order, val);
1828     }
1829   else if (len <= 8)
1830     {
1831       /* Get the return value from R10 and R11.  */
1832       regcache_cooked_read_unsigned (regcache, ARG1_REGNUM, &val);
1833       store_unsigned_integer (valbuf, 4, byte_order, val);
1834       regcache_cooked_read_unsigned (regcache, ARG2_REGNUM, &val);
1835       store_unsigned_integer (valbuf + 4, len - 4, byte_order, val);
1836     }
1837   else
1838     error (_("cris_extract_return_value: type length too large"));
1839 }
1840
1841 /* Handle the CRIS return value convention.  */
1842
1843 static enum return_value_convention
1844 cris_return_value (struct gdbarch *gdbarch, struct value *function,
1845                    struct type *type, struct regcache *regcache,
1846                    gdb_byte *readbuf, const gdb_byte *writebuf)
1847 {
1848   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
1849       || TYPE_CODE (type) == TYPE_CODE_UNION
1850       || TYPE_LENGTH (type) > 8)
1851     /* Structs, unions, and anything larger than 8 bytes (2 registers)
1852        goes on the stack.  */
1853     return RETURN_VALUE_STRUCT_CONVENTION;
1854
1855   if (readbuf)
1856     cris_extract_return_value (type, regcache, readbuf);
1857   if (writebuf)
1858     cris_store_return_value (type, regcache, writebuf);
1859
1860   return RETURN_VALUE_REGISTER_CONVENTION;
1861 }
1862
1863 /* Calculates a value that measures how good inst_args constraints an
1864    instruction.  It stems from cris_constraint, found in cris-dis.c.  */
1865
1866 static int
1867 constraint (unsigned int insn, const char *inst_args,
1868             inst_env_type *inst_env)
1869 {
1870   int retval = 0;
1871   int tmp, i;
1872
1873   const gdb_byte *s = (const gdb_byte *) inst_args;
1874
1875   for (; *s; s++)
1876     switch (*s)
1877       {
1878       case 'm':
1879         if ((insn & 0x30) == 0x30)
1880           return -1;
1881         break;
1882
1883       case 'S':
1884         /* A prefix operand.  */
1885         if (inst_env->prefix_found)
1886           break;
1887         else
1888           return -1;
1889
1890       case 'B':
1891         /* A "push" prefix.  (This check was REMOVED by san 970921.)  Check for
1892            valid "push" size.  In case of special register, it may be != 4.  */
1893         if (inst_env->prefix_found)
1894           break;
1895         else
1896           return -1;
1897
1898       case 'D':
1899         retval = (((insn >> 0xC) & 0xF) == (insn & 0xF));
1900         if (!retval)
1901           return -1;
1902         else
1903           retval += 4;
1904         break;
1905
1906       case 'P':
1907         tmp = (insn >> 0xC) & 0xF;
1908
1909         for (i = 0; cris_spec_regs[i].name != NULL; i++)
1910           {
1911             /* Since we match four bits, we will give a value of
1912                4 - 1 = 3 in a match.  If there is a corresponding
1913                exact match of a special register in another pattern, it
1914                will get a value of 4, which will be higher.  This should
1915                be correct in that an exact pattern would match better that
1916                a general pattern.
1917                Note that there is a reason for not returning zero; the
1918                pattern for "clear" is partly  matched in the bit-pattern
1919                (the two lower bits must be zero), while the bit-pattern
1920                for a move from a special register is matched in the
1921                register constraint.
1922                This also means we will will have a race condition if
1923                there is a partly match in three bits in the bit pattern.  */
1924             if (tmp == cris_spec_regs[i].number)
1925               {
1926                 retval += 3;
1927                 break;
1928               }
1929           }
1930
1931         if (cris_spec_regs[i].name == NULL)
1932           return -1;
1933         break;
1934       }
1935   return retval;
1936 }
1937
1938 /* Returns the number of bits set in the variable value.  */
1939
1940 static int
1941 number_of_bits (unsigned int value)
1942 {
1943   int number_of_bits = 0;
1944
1945   while (value != 0)
1946     {
1947       number_of_bits += 1;
1948       value &= (value - 1);
1949     }
1950   return number_of_bits;
1951 }
1952
1953 /* Finds the address that should contain the single step breakpoint(s).
1954    It stems from code in cris-dis.c.  */
1955
1956 static int
1957 find_cris_op (unsigned short insn, inst_env_type *inst_env)
1958 {
1959   int i;
1960   int max_level_of_match = -1;
1961   int max_matched = -1;
1962   int level_of_match;
1963
1964   for (i = 0; cris_opcodes[i].name != NULL; i++)
1965     {
1966       if (((cris_opcodes[i].match & insn) == cris_opcodes[i].match)
1967           && ((cris_opcodes[i].lose & insn) == 0)
1968           /* Only CRISv10 instructions, please.  */
1969           && (cris_opcodes[i].applicable_version != cris_ver_v32p))
1970         {
1971           level_of_match = constraint (insn, cris_opcodes[i].args, inst_env);
1972           if (level_of_match >= 0)
1973             {
1974               level_of_match +=
1975                 number_of_bits (cris_opcodes[i].match | cris_opcodes[i].lose);
1976               if (level_of_match > max_level_of_match)
1977                 {
1978                   max_matched = i;
1979                   max_level_of_match = level_of_match;
1980                   if (level_of_match == 16)
1981                     {
1982                       /* All bits matched, cannot find better.  */
1983                       break;
1984                     }
1985                 }
1986             }
1987         }
1988     }
1989   return max_matched;
1990 }
1991
1992 /* Attempts to find single-step breakpoints.  Returns -1 on failure which is
1993    actually an internal error.  */
1994
1995 static int
1996 find_step_target (struct frame_info *frame, inst_env_type *inst_env)
1997 {
1998   int i;
1999   int offset;
2000   unsigned short insn;
2001   struct gdbarch *gdbarch = get_frame_arch (frame);
2002   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2003
2004   /* Create a local register image and set the initial state.  */
2005   for (i = 0; i < NUM_GENREGS; i++)
2006     {
2007       inst_env->reg[i] =
2008         (unsigned long) get_frame_register_unsigned (frame, i);
2009     }
2010   offset = NUM_GENREGS;
2011   for (i = 0; i < NUM_SPECREGS; i++)
2012     {
2013       inst_env->preg[i] =
2014         (unsigned long) get_frame_register_unsigned (frame, offset + i);
2015     }
2016   inst_env->branch_found = 0;
2017   inst_env->slot_needed = 0;
2018   inst_env->delay_slot_pc_active = 0;
2019   inst_env->prefix_found = 0;
2020   inst_env->invalid = 0;
2021   inst_env->xflag_found = 0;
2022   inst_env->disable_interrupt = 0;
2023   inst_env->byte_order = byte_order;
2024
2025   /* Look for a step target.  */
2026   do
2027     {
2028       /* Read an instruction from the client.  */
2029       insn = read_memory_unsigned_integer
2030              (inst_env->reg[gdbarch_pc_regnum (gdbarch)], 2, byte_order);
2031
2032       /* If the instruction is not in a delay slot the new content of the
2033          PC is [PC] + 2.  If the instruction is in a delay slot it is not
2034          that simple.  Since a instruction in a delay slot cannot change
2035          the content of the PC, it does not matter what value PC will have.
2036          Just make sure it is a valid instruction.  */
2037       if (!inst_env->delay_slot_pc_active)
2038         {
2039           inst_env->reg[gdbarch_pc_regnum (gdbarch)] += 2;
2040         }
2041       else
2042         {
2043           inst_env->delay_slot_pc_active = 0;
2044           inst_env->reg[gdbarch_pc_regnum (gdbarch)]
2045             = inst_env->delay_slot_pc;
2046         }
2047       /* Analyse the present instruction.  */
2048       i = find_cris_op (insn, inst_env);
2049       if (i == -1)
2050         {
2051           inst_env->invalid = 1;
2052         }
2053       else
2054         {
2055           cris_gdb_func (gdbarch, cris_opcodes[i].op, insn, inst_env);
2056         }
2057     } while (!inst_env->invalid
2058              && (inst_env->prefix_found || inst_env->xflag_found
2059                  || inst_env->slot_needed));
2060   return i;
2061 }
2062
2063 /* There is no hardware single-step support.  The function find_step_target
2064    digs through the opcodes in order to find all possible targets.
2065    Either one ordinary target or two targets for branches may be found.  */
2066
2067 static int
2068 cris_software_single_step (struct frame_info *frame)
2069 {
2070   struct gdbarch *gdbarch = get_frame_arch (frame);
2071   struct address_space *aspace = get_frame_address_space (frame);
2072   inst_env_type inst_env;
2073
2074   /* Analyse the present instruction environment and insert
2075      breakpoints.  */
2076   int status = find_step_target (frame, &inst_env);
2077   if (status == -1)
2078     {
2079       /* Could not find a target.  Things are likely to go downhill
2080          from here.  */
2081       warning (_("CRIS software single step could not find a step target."));
2082     }
2083   else
2084     {
2085       /* Insert at most two breakpoints.  One for the next PC content
2086          and possibly another one for a branch, jump, etc.  */
2087       CORE_ADDR next_pc
2088         = (CORE_ADDR) inst_env.reg[gdbarch_pc_regnum (gdbarch)];
2089       insert_single_step_breakpoint (gdbarch, aspace, next_pc);
2090       if (inst_env.branch_found
2091           && (CORE_ADDR) inst_env.branch_break_address != next_pc)
2092         {
2093           CORE_ADDR branch_target_address
2094                 = (CORE_ADDR) inst_env.branch_break_address;
2095           insert_single_step_breakpoint (gdbarch,
2096                                          aspace, branch_target_address);
2097         }
2098     }
2099
2100   return 1;
2101 }
2102
2103 /* Calculates the prefix value for quick offset addressing mode.  */
2104
2105 static void
2106 quick_mode_bdap_prefix (unsigned short inst, inst_env_type *inst_env)
2107 {
2108   /* It's invalid to be in a delay slot.  You can't have a prefix to this
2109      instruction (not 100% sure).  */
2110   if (inst_env->slot_needed || inst_env->prefix_found)
2111     {
2112       inst_env->invalid = 1;
2113       return;
2114     }
2115
2116   inst_env->prefix_value = inst_env->reg[cris_get_operand2 (inst)];
2117   inst_env->prefix_value += cris_get_bdap_quick_offset (inst);
2118
2119   /* A prefix doesn't change the xflag_found.  But the rest of the flags
2120      need updating.  */
2121   inst_env->slot_needed = 0;
2122   inst_env->prefix_found = 1;
2123 }
2124
2125 /* Updates the autoincrement register.  The size of the increment is derived
2126    from the size of the operation.  The PC is always kept aligned on even
2127    word addresses.  */
2128
2129 static void
2130 process_autoincrement (int size, unsigned short inst, inst_env_type *inst_env)
2131 {
2132   if (size == INST_BYTE_SIZE)
2133     {
2134       inst_env->reg[cris_get_operand1 (inst)] += 1;
2135
2136       /* The PC must be word aligned, so increase the PC with one
2137          word even if the size is byte.  */
2138       if (cris_get_operand1 (inst) == REG_PC)
2139         {
2140           inst_env->reg[REG_PC] += 1;
2141         }
2142     }
2143   else if (size == INST_WORD_SIZE)
2144     {
2145       inst_env->reg[cris_get_operand1 (inst)] += 2;
2146     }
2147   else if (size == INST_DWORD_SIZE)
2148     {
2149       inst_env->reg[cris_get_operand1 (inst)] += 4;
2150     }
2151   else
2152     {
2153       /* Invalid size.  */
2154       inst_env->invalid = 1;
2155     }
2156 }
2157
2158 /* Just a forward declaration.  */
2159
2160 static unsigned long get_data_from_address (unsigned short *inst,
2161                                             CORE_ADDR address,
2162                                             enum bfd_endian byte_order);
2163
2164 /* Calculates the prefix value for the general case of offset addressing
2165    mode.  */
2166
2167 static void
2168 bdap_prefix (unsigned short inst, inst_env_type *inst_env)
2169 {
2170   /* It's invalid to be in a delay slot.  */
2171   if (inst_env->slot_needed || inst_env->prefix_found)
2172     {
2173       inst_env->invalid = 1;
2174       return;
2175     }
2176
2177   /* The calculation of prefix_value used to be after process_autoincrement,
2178      but that fails for an instruction such as jsr [$r0+12] which is encoded
2179      as 5f0d 0c00 30b9 when compiled with -fpic.  Since PC is operand1 it
2180      mustn't be incremented until we have read it and what it points at.  */
2181   inst_env->prefix_value = inst_env->reg[cris_get_operand2 (inst)];
2182
2183   /* The offset is an indirection of the contents of the operand1 register.  */
2184   inst_env->prefix_value +=
2185     get_data_from_address (&inst, inst_env->reg[cris_get_operand1 (inst)],
2186                            inst_env->byte_order);
2187
2188   if (cris_get_mode (inst) == AUTOINC_MODE)
2189     {
2190       process_autoincrement (cris_get_size (inst), inst, inst_env);
2191     }
2192
2193   /* A prefix doesn't change the xflag_found.  But the rest of the flags
2194      need updating.  */
2195   inst_env->slot_needed = 0;
2196   inst_env->prefix_found = 1;
2197 }
2198
2199 /* Calculates the prefix value for the index addressing mode.  */
2200
2201 static void
2202 biap_prefix (unsigned short inst, inst_env_type *inst_env)
2203 {
2204   /* It's invalid to be in a delay slot.  I can't see that it's possible to
2205      have a prefix to this instruction.  So I will treat this as invalid.  */
2206   if (inst_env->slot_needed || inst_env->prefix_found)
2207     {
2208       inst_env->invalid = 1;
2209       return;
2210     }
2211
2212   inst_env->prefix_value = inst_env->reg[cris_get_operand1 (inst)];
2213
2214   /* The offset is the operand2 value shifted the size of the instruction
2215      to the left.  */
2216   inst_env->prefix_value +=
2217     inst_env->reg[cris_get_operand2 (inst)] << cris_get_size (inst);
2218
2219   /* If the PC is operand1 (base) the address used is the address after
2220      the main instruction, i.e. address + 2 (the PC is already compensated
2221      for the prefix operation).  */
2222   if (cris_get_operand1 (inst) == REG_PC)
2223     {
2224       inst_env->prefix_value += 2;
2225     }
2226
2227   /* A prefix doesn't change the xflag_found.  But the rest of the flags
2228      need updating.  */
2229   inst_env->slot_needed = 0;
2230   inst_env->xflag_found = 0;
2231   inst_env->prefix_found = 1;
2232 }
2233
2234 /* Calculates the prefix value for the double indirect addressing mode.  */
2235
2236 static void
2237 dip_prefix (unsigned short inst, inst_env_type *inst_env)
2238 {
2239
2240   CORE_ADDR address;
2241
2242   /* It's invalid to be in a delay slot.  */
2243   if (inst_env->slot_needed || inst_env->prefix_found)
2244     {
2245       inst_env->invalid = 1;
2246       return;
2247     }
2248
2249   /* The prefix value is one dereference of the contents of the operand1
2250      register.  */
2251   address = (CORE_ADDR) inst_env->reg[cris_get_operand1 (inst)];
2252   inst_env->prefix_value
2253     = read_memory_unsigned_integer (address, 4, inst_env->byte_order);
2254
2255   /* Check if the mode is autoincrement.  */
2256   if (cris_get_mode (inst) == AUTOINC_MODE)
2257     {
2258       inst_env->reg[cris_get_operand1 (inst)] += 4;
2259     }
2260
2261   /* A prefix doesn't change the xflag_found.  But the rest of the flags
2262      need updating.  */
2263   inst_env->slot_needed = 0;
2264   inst_env->xflag_found = 0;
2265   inst_env->prefix_found = 1;
2266 }
2267
2268 /* Finds the destination for a branch with 8-bits offset.  */
2269
2270 static void
2271 eight_bit_offset_branch_op (unsigned short inst, inst_env_type *inst_env)
2272 {
2273
2274   short offset;
2275
2276   /* If we have a prefix or are in a delay slot it's bad.  */
2277   if (inst_env->slot_needed || inst_env->prefix_found)
2278     {
2279       inst_env->invalid = 1;
2280       return;
2281     }
2282
2283   /* We have a branch, find out where the branch will land.  */
2284   offset = cris_get_branch_short_offset (inst);
2285
2286   /* Check if the offset is signed.  */
2287   if (offset & BRANCH_SIGNED_SHORT_OFFSET_MASK)
2288     {
2289       offset |= 0xFF00;
2290     }
2291
2292   /* The offset ends with the sign bit, set it to zero.  The address
2293      should always be word aligned.  */
2294   offset &= ~BRANCH_SIGNED_SHORT_OFFSET_MASK;
2295
2296   inst_env->branch_found = 1;
2297   inst_env->branch_break_address = inst_env->reg[REG_PC] + offset;
2298
2299   inst_env->slot_needed = 1;
2300   inst_env->prefix_found = 0;
2301   inst_env->xflag_found = 0;
2302   inst_env->disable_interrupt = 1;
2303 }
2304
2305 /* Finds the destination for a branch with 16-bits offset.  */
2306
2307 static void
2308 sixteen_bit_offset_branch_op (unsigned short inst, inst_env_type *inst_env)
2309 {
2310   short offset;
2311
2312   /* If we have a prefix or is in a delay slot it's bad.  */
2313   if (inst_env->slot_needed || inst_env->prefix_found)
2314     {
2315       inst_env->invalid = 1;
2316       return;
2317     }
2318
2319   /* We have a branch, find out the offset for the branch.  */
2320   offset = read_memory_integer (inst_env->reg[REG_PC], 2,
2321                                 inst_env->byte_order);
2322
2323   /* The instruction is one word longer than normal, so add one word
2324      to the PC.  */
2325   inst_env->reg[REG_PC] += 2;
2326
2327   inst_env->branch_found = 1;
2328   inst_env->branch_break_address = inst_env->reg[REG_PC] + offset;
2329
2330
2331   inst_env->slot_needed = 1;
2332   inst_env->prefix_found = 0;
2333   inst_env->xflag_found = 0;
2334   inst_env->disable_interrupt = 1;
2335 }
2336
2337 /* Handles the ABS instruction.  */
2338
2339 static void
2340 abs_op (unsigned short inst, inst_env_type *inst_env)
2341 {
2342
2343   long value;
2344
2345   /* ABS can't have a prefix, so it's bad if it does.  */
2346   if (inst_env->prefix_found)
2347     {
2348       inst_env->invalid = 1;
2349       return;
2350     }
2351
2352   /* Check if the operation affects the PC.  */
2353   if (cris_get_operand2 (inst) == REG_PC)
2354     {
2355
2356       /* It's invalid to change to the PC if we are in a delay slot.  */
2357       if (inst_env->slot_needed)
2358         {
2359           inst_env->invalid = 1;
2360           return;
2361         }
2362
2363       value = (long) inst_env->reg[REG_PC];
2364
2365       /* The value of abs (SIGNED_DWORD_MASK) is SIGNED_DWORD_MASK.  */
2366       if (value != SIGNED_DWORD_MASK)
2367         {
2368           value = -value;
2369           inst_env->reg[REG_PC] = (long) value;
2370         }
2371     }
2372
2373   inst_env->slot_needed = 0;
2374   inst_env->prefix_found = 0;
2375   inst_env->xflag_found = 0;
2376   inst_env->disable_interrupt = 0;
2377 }
2378
2379 /* Handles the ADDI instruction.  */
2380
2381 static void
2382 addi_op (unsigned short inst, inst_env_type *inst_env)
2383 {
2384   /* It's invalid to have the PC as base register.  And ADDI can't have
2385      a prefix.  */
2386   if (inst_env->prefix_found || (cris_get_operand1 (inst) == REG_PC))
2387     {
2388       inst_env->invalid = 1;
2389       return;
2390     }
2391
2392   inst_env->slot_needed = 0;
2393   inst_env->prefix_found = 0;
2394   inst_env->xflag_found = 0;
2395   inst_env->disable_interrupt = 0;
2396 }
2397
2398 /* Handles the ASR instruction.  */
2399
2400 static void
2401 asr_op (unsigned short inst, inst_env_type *inst_env)
2402 {
2403   int shift_steps;
2404   unsigned long value;
2405   unsigned long signed_extend_mask = 0;
2406
2407   /* ASR can't have a prefix, so check that it doesn't.  */
2408   if (inst_env->prefix_found)
2409     {
2410       inst_env->invalid = 1;
2411       return;
2412     }
2413
2414   /* Check if the PC is the target register.  */
2415   if (cris_get_operand2 (inst) == REG_PC)
2416     {
2417       /* It's invalid to change the PC in a delay slot.  */
2418       if (inst_env->slot_needed)
2419         {
2420           inst_env->invalid = 1;
2421           return;
2422         }
2423       /* Get the number of bits to shift.  */
2424       shift_steps
2425         = cris_get_asr_shift_steps (inst_env->reg[cris_get_operand1 (inst)]);
2426       value = inst_env->reg[REG_PC];
2427
2428       /* Find out how many bits the operation should apply to.  */
2429       if (cris_get_size (inst) == INST_BYTE_SIZE)
2430         {
2431           if (value & SIGNED_BYTE_MASK)
2432             {
2433               signed_extend_mask = 0xFF;
2434               signed_extend_mask = signed_extend_mask >> shift_steps;
2435               signed_extend_mask = ~signed_extend_mask;
2436             }
2437           value = value >> shift_steps;
2438           value |= signed_extend_mask;
2439           value &= 0xFF;
2440           inst_env->reg[REG_PC] &= 0xFFFFFF00;
2441           inst_env->reg[REG_PC] |= value;
2442         }
2443       else if (cris_get_size (inst) == INST_WORD_SIZE)
2444         {
2445           if (value & SIGNED_WORD_MASK)
2446             {
2447               signed_extend_mask = 0xFFFF;
2448               signed_extend_mask = signed_extend_mask >> shift_steps;
2449               signed_extend_mask = ~signed_extend_mask;
2450             }
2451           value = value >> shift_steps;
2452           value |= signed_extend_mask;
2453           value &= 0xFFFF;
2454           inst_env->reg[REG_PC] &= 0xFFFF0000;
2455           inst_env->reg[REG_PC] |= value;
2456         }
2457       else if (cris_get_size (inst) == INST_DWORD_SIZE)
2458         {
2459           if (value & SIGNED_DWORD_MASK)
2460             {
2461               signed_extend_mask = 0xFFFFFFFF;
2462               signed_extend_mask = signed_extend_mask >> shift_steps;
2463               signed_extend_mask = ~signed_extend_mask;
2464             }
2465           value = value >> shift_steps;
2466           value |= signed_extend_mask;
2467           inst_env->reg[REG_PC]  = value;
2468         }
2469     }
2470   inst_env->slot_needed = 0;
2471   inst_env->prefix_found = 0;
2472   inst_env->xflag_found = 0;
2473   inst_env->disable_interrupt = 0;
2474 }
2475
2476 /* Handles the ASRQ instruction.  */
2477
2478 static void
2479 asrq_op (unsigned short inst, inst_env_type *inst_env)
2480 {
2481
2482   int shift_steps;
2483   unsigned long value;
2484   unsigned long signed_extend_mask = 0;
2485
2486   /* ASRQ can't have a prefix, so check that it doesn't.  */
2487   if (inst_env->prefix_found)
2488     {
2489       inst_env->invalid = 1;
2490       return;
2491     }
2492
2493   /* Check if the PC is the target register.  */
2494   if (cris_get_operand2 (inst) == REG_PC)
2495     {
2496
2497       /* It's invalid to change the PC in a delay slot.  */
2498       if (inst_env->slot_needed)
2499         {
2500           inst_env->invalid = 1;
2501           return;
2502         }
2503       /* The shift size is given as a 5 bit quick value, i.e. we don't
2504          want the sign bit of the quick value.  */
2505       shift_steps = cris_get_asr_shift_steps (inst);
2506       value = inst_env->reg[REG_PC];
2507       if (value & SIGNED_DWORD_MASK)
2508         {
2509           signed_extend_mask = 0xFFFFFFFF;
2510           signed_extend_mask = signed_extend_mask >> shift_steps;
2511           signed_extend_mask = ~signed_extend_mask;
2512         }
2513       value = value >> shift_steps;
2514       value |= signed_extend_mask;
2515       inst_env->reg[REG_PC]  = value;
2516     }
2517   inst_env->slot_needed = 0;
2518   inst_env->prefix_found = 0;
2519   inst_env->xflag_found = 0;
2520   inst_env->disable_interrupt = 0;
2521 }
2522
2523 /* Handles the AX, EI and SETF instruction.  */
2524
2525 static void
2526 ax_ei_setf_op (unsigned short inst, inst_env_type *inst_env)
2527 {
2528   if (inst_env->prefix_found)
2529     {
2530       inst_env->invalid = 1;
2531       return;
2532     }
2533   /* Check if the instruction is setting the X flag.  */
2534   if (cris_is_xflag_bit_on (inst))
2535     {
2536       inst_env->xflag_found = 1;
2537     }
2538   else
2539     {
2540       inst_env->xflag_found = 0;
2541     }
2542   inst_env->slot_needed = 0;
2543   inst_env->prefix_found = 0;
2544   inst_env->disable_interrupt = 1;
2545 }
2546
2547 /* Checks if the instruction is in assign mode.  If so, it updates the assign
2548    register.  Note that check_assign assumes that the caller has checked that
2549    there is a prefix to this instruction.  The mode check depends on this.  */
2550
2551 static void
2552 check_assign (unsigned short inst, inst_env_type *inst_env)
2553 {
2554   /* Check if it's an assign addressing mode.  */
2555   if (cris_get_mode (inst) == PREFIX_ASSIGN_MODE)
2556     {
2557       /* Assign the prefix value to operand 1.  */
2558       inst_env->reg[cris_get_operand1 (inst)] = inst_env->prefix_value;
2559     }
2560 }
2561
2562 /* Handles the 2-operand BOUND instruction.  */
2563
2564 static void
2565 two_operand_bound_op (unsigned short inst, inst_env_type *inst_env)
2566 {
2567   /* It's invalid to have the PC as the index operand.  */
2568   if (cris_get_operand2 (inst) == REG_PC)
2569     {
2570       inst_env->invalid = 1;
2571       return;
2572     }
2573   /* Check if we have a prefix.  */
2574   if (inst_env->prefix_found)
2575     {
2576       check_assign (inst, inst_env);
2577     }
2578   /* Check if this is an autoincrement mode.  */
2579   else if (cris_get_mode (inst) == AUTOINC_MODE)
2580     {
2581       /* It's invalid to change the PC in a delay slot.  */
2582       if (inst_env->slot_needed)
2583         {
2584           inst_env->invalid = 1;
2585           return;
2586         }
2587       process_autoincrement (cris_get_size (inst), inst, inst_env);
2588     }
2589   inst_env->slot_needed = 0;
2590   inst_env->prefix_found = 0;
2591   inst_env->xflag_found = 0;
2592   inst_env->disable_interrupt = 0;
2593 }
2594
2595 /* Handles the 3-operand BOUND instruction.  */
2596
2597 static void
2598 three_operand_bound_op (unsigned short inst, inst_env_type *inst_env)
2599 {
2600   /* It's an error if we haven't got a prefix.  And it's also an error
2601      if the PC is the destination register.  */
2602   if ((!inst_env->prefix_found) || (cris_get_operand1 (inst) == REG_PC))
2603     {
2604       inst_env->invalid = 1;
2605       return;
2606     }
2607   inst_env->slot_needed = 0;
2608   inst_env->prefix_found = 0;
2609   inst_env->xflag_found = 0;
2610   inst_env->disable_interrupt = 0;
2611 }
2612
2613 /* Clears the status flags in inst_env.  */
2614
2615 static void
2616 btst_nop_op (unsigned short inst, inst_env_type *inst_env)
2617 {
2618   /* It's an error if we have got a prefix.  */
2619   if (inst_env->prefix_found)
2620     {
2621       inst_env->invalid = 1;
2622       return;
2623     }
2624
2625   inst_env->slot_needed = 0;
2626   inst_env->prefix_found = 0;
2627   inst_env->xflag_found = 0;
2628   inst_env->disable_interrupt = 0;
2629 }
2630
2631 /* Clears the status flags in inst_env.  */
2632
2633 static void
2634 clearf_di_op (unsigned short inst, inst_env_type *inst_env)
2635 {
2636   /* It's an error if we have got a prefix.  */
2637   if (inst_env->prefix_found)
2638     {
2639       inst_env->invalid = 1;
2640       return;
2641     }
2642
2643   inst_env->slot_needed = 0;
2644   inst_env->prefix_found = 0;
2645   inst_env->xflag_found = 0;
2646   inst_env->disable_interrupt = 1;
2647 }
2648
2649 /* Handles the CLEAR instruction if it's in register mode.  */
2650
2651 static void
2652 reg_mode_clear_op (unsigned short inst, inst_env_type *inst_env)
2653 {
2654   /* Check if the target is the PC.  */
2655   if (cris_get_operand2 (inst) == REG_PC)
2656     {
2657       /* The instruction will clear the instruction's size bits.  */
2658       int clear_size = cris_get_clear_size (inst);
2659       if (clear_size == INST_BYTE_SIZE)
2660         {
2661           inst_env->delay_slot_pc = inst_env->reg[REG_PC] & 0xFFFFFF00;
2662         }
2663       if (clear_size == INST_WORD_SIZE)
2664         {
2665           inst_env->delay_slot_pc = inst_env->reg[REG_PC] & 0xFFFF0000;
2666         }
2667       if (clear_size == INST_DWORD_SIZE)
2668         {
2669           inst_env->delay_slot_pc = 0x0;
2670         }
2671       /* The jump will be delayed with one delay slot.  So we need a delay
2672          slot.  */
2673       inst_env->slot_needed = 1;
2674       inst_env->delay_slot_pc_active = 1;
2675     }
2676   else
2677     {
2678       /* The PC will not change => no delay slot.  */
2679       inst_env->slot_needed = 0;
2680     }
2681   inst_env->prefix_found = 0;
2682   inst_env->xflag_found = 0;
2683   inst_env->disable_interrupt = 0;
2684 }
2685
2686 /* Handles the TEST instruction if it's in register mode.  */
2687
2688 static void
2689 reg_mode_test_op (unsigned short inst, inst_env_type *inst_env)
2690 {
2691   /* It's an error if we have got a prefix.  */
2692   if (inst_env->prefix_found)
2693     {
2694       inst_env->invalid = 1;
2695       return;
2696     }
2697   inst_env->slot_needed = 0;
2698   inst_env->prefix_found = 0;
2699   inst_env->xflag_found = 0;
2700   inst_env->disable_interrupt = 0;
2701
2702 }
2703
2704 /* Handles the CLEAR and TEST instruction if the instruction isn't
2705    in register mode.  */
2706
2707 static void
2708 none_reg_mode_clear_test_op (unsigned short inst, inst_env_type *inst_env)
2709 {
2710   /* Check if we are in a prefix mode.  */
2711   if (inst_env->prefix_found)
2712     {
2713       /* The only way the PC can change is if this instruction is in
2714          assign addressing mode.  */
2715       check_assign (inst, inst_env);
2716     }
2717   /* Indirect mode can't change the PC so just check if the mode is
2718      autoincrement.  */
2719   else if (cris_get_mode (inst) == AUTOINC_MODE)
2720     {
2721       process_autoincrement (cris_get_size (inst), inst, inst_env);
2722     }
2723   inst_env->slot_needed = 0;
2724   inst_env->prefix_found = 0;
2725   inst_env->xflag_found = 0;
2726   inst_env->disable_interrupt = 0;
2727 }
2728
2729 /* Checks that the PC isn't the destination register or the instructions has
2730    a prefix.  */
2731
2732 static void
2733 dstep_logshift_mstep_neg_not_op (unsigned short inst, inst_env_type *inst_env)
2734 {
2735   /* It's invalid to have the PC as the destination.  The instruction can't
2736      have a prefix.  */
2737   if ((cris_get_operand2 (inst) == REG_PC) || inst_env->prefix_found)
2738     {
2739       inst_env->invalid = 1;
2740       return;
2741     }
2742
2743   inst_env->slot_needed = 0;
2744   inst_env->prefix_found = 0;
2745   inst_env->xflag_found = 0;
2746   inst_env->disable_interrupt = 0;
2747 }
2748
2749 /* Checks that the instruction doesn't have a prefix.  */
2750
2751 static void
2752 break_op (unsigned short inst, inst_env_type *inst_env)
2753 {
2754   /* The instruction can't have a prefix.  */
2755   if (inst_env->prefix_found)
2756     {
2757       inst_env->invalid = 1;
2758       return;
2759     }
2760
2761   inst_env->slot_needed = 0;
2762   inst_env->prefix_found = 0;
2763   inst_env->xflag_found = 0;
2764   inst_env->disable_interrupt = 1;
2765 }
2766
2767 /* Checks that the PC isn't the destination register and that the instruction
2768    doesn't have a prefix.  */
2769
2770 static void
2771 scc_op (unsigned short inst, inst_env_type *inst_env)
2772 {
2773   /* It's invalid to have the PC as the destination.  The instruction can't
2774      have a prefix.  */
2775   if ((cris_get_operand2 (inst) == REG_PC) || inst_env->prefix_found)
2776     {
2777       inst_env->invalid = 1;
2778       return;
2779     }
2780
2781   inst_env->slot_needed = 0;
2782   inst_env->prefix_found = 0;
2783   inst_env->xflag_found = 0;
2784   inst_env->disable_interrupt = 1;
2785 }
2786
2787 /* Handles the register mode JUMP instruction.  */
2788
2789 static void
2790 reg_mode_jump_op (unsigned short inst, inst_env_type *inst_env)
2791 {
2792   /* It's invalid to do a JUMP in a delay slot.  The mode is register, so
2793      you can't have a prefix.  */
2794   if ((inst_env->slot_needed) || (inst_env->prefix_found))
2795     {
2796       inst_env->invalid = 1;
2797       return;
2798     }
2799
2800   /* Just change the PC.  */
2801   inst_env->reg[REG_PC] = inst_env->reg[cris_get_operand1 (inst)];
2802   inst_env->slot_needed = 0;
2803   inst_env->prefix_found = 0;
2804   inst_env->xflag_found = 0;
2805   inst_env->disable_interrupt = 1;
2806 }
2807
2808 /* Handles the JUMP instruction for all modes except register.  */
2809
2810 static void
2811 none_reg_mode_jump_op (unsigned short inst, inst_env_type *inst_env)
2812 {
2813   unsigned long newpc;
2814   CORE_ADDR address;
2815
2816   /* It's invalid to do a JUMP in a delay slot.  */
2817   if (inst_env->slot_needed)
2818     {
2819       inst_env->invalid = 1;
2820     }
2821   else
2822     {
2823       /* Check if we have a prefix.  */
2824       if (inst_env->prefix_found)
2825         {
2826           check_assign (inst, inst_env);
2827
2828           /* Get the new value for the PC.  */
2829           newpc =
2830             read_memory_unsigned_integer ((CORE_ADDR) inst_env->prefix_value,
2831                                           4, inst_env->byte_order);
2832         }
2833       else
2834         {
2835           /* Get the new value for the PC.  */
2836           address = (CORE_ADDR) inst_env->reg[cris_get_operand1 (inst)];
2837           newpc = read_memory_unsigned_integer (address,
2838                                                 4, inst_env->byte_order);
2839
2840           /* Check if we should increment a register.  */
2841           if (cris_get_mode (inst) == AUTOINC_MODE)
2842             {
2843               inst_env->reg[cris_get_operand1 (inst)] += 4;
2844             }
2845         }
2846       inst_env->reg[REG_PC] = newpc;
2847     }
2848   inst_env->slot_needed = 0;
2849   inst_env->prefix_found = 0;
2850   inst_env->xflag_found = 0;
2851   inst_env->disable_interrupt = 1;
2852 }
2853
2854 /* Handles moves to special registers (aka P-register) for all modes.  */
2855
2856 static void
2857 move_to_preg_op (struct gdbarch *gdbarch, unsigned short inst,
2858                  inst_env_type *inst_env)
2859 {
2860   if (inst_env->prefix_found)
2861     {
2862       /* The instruction has a prefix that means we are only interested if
2863          the instruction is in assign mode.  */
2864       if (cris_get_mode (inst) == PREFIX_ASSIGN_MODE)
2865         {
2866           /* The prefix handles the problem if we are in a delay slot.  */
2867           if (cris_get_operand1 (inst) == REG_PC)
2868             {
2869               /* Just take care of the assign.  */
2870               check_assign (inst, inst_env);
2871             }
2872         }
2873     }
2874   else if (cris_get_mode (inst) == AUTOINC_MODE)
2875     {
2876       /* The instruction doesn't have a prefix, the only case left that we
2877          are interested in is the autoincrement mode.  */
2878       if (cris_get_operand1 (inst) == REG_PC)
2879         {
2880           /* If the PC is to be incremented it's invalid to be in a
2881              delay slot.  */
2882           if (inst_env->slot_needed)
2883             {
2884               inst_env->invalid = 1;
2885               return;
2886             }
2887
2888           /* The increment depends on the size of the special register.  */
2889           if (cris_register_size (gdbarch, cris_get_operand2 (inst)) == 1)
2890             {
2891               process_autoincrement (INST_BYTE_SIZE, inst, inst_env);
2892             }
2893           else if (cris_register_size (gdbarch, cris_get_operand2 (inst)) == 2)
2894             {
2895               process_autoincrement (INST_WORD_SIZE, inst, inst_env);
2896             }
2897           else
2898             {
2899               process_autoincrement (INST_DWORD_SIZE, inst, inst_env);
2900             }
2901         }
2902     }
2903   inst_env->slot_needed = 0;
2904   inst_env->prefix_found = 0;
2905   inst_env->xflag_found = 0;
2906   inst_env->disable_interrupt = 1;
2907 }
2908
2909 /* Handles moves from special registers (aka P-register) for all modes
2910    except register.  */
2911
2912 static void
2913 none_reg_mode_move_from_preg_op (struct gdbarch *gdbarch, unsigned short inst,
2914                                  inst_env_type *inst_env)
2915 {
2916   if (inst_env->prefix_found)
2917     {
2918       /* The instruction has a prefix that means we are only interested if
2919          the instruction is in assign mode.  */
2920       if (cris_get_mode (inst) == PREFIX_ASSIGN_MODE)
2921         {
2922           /* The prefix handles the problem if we are in a delay slot.  */
2923           if (cris_get_operand1 (inst) == REG_PC)
2924             {
2925               /* Just take care of the assign.  */
2926               check_assign (inst, inst_env);
2927             }
2928         }
2929     }
2930   /* The instruction doesn't have a prefix, the only case left that we
2931      are interested in is the autoincrement mode.  */
2932   else if (cris_get_mode (inst) == AUTOINC_MODE)
2933     {
2934       if (cris_get_operand1 (inst) == REG_PC)
2935         {
2936           /* If the PC is to be incremented it's invalid to be in a
2937              delay slot.  */
2938           if (inst_env->slot_needed)
2939             {
2940               inst_env->invalid = 1;
2941               return;
2942             }
2943
2944           /* The increment depends on the size of the special register.  */
2945           if (cris_register_size (gdbarch, cris_get_operand2 (inst)) == 1)
2946             {
2947               process_autoincrement (INST_BYTE_SIZE, inst, inst_env);
2948             }
2949           else if (cris_register_size (gdbarch, cris_get_operand2 (inst)) == 2)
2950             {
2951               process_autoincrement (INST_WORD_SIZE, inst, inst_env);
2952             }
2953           else
2954             {
2955               process_autoincrement (INST_DWORD_SIZE, inst, inst_env);
2956             }
2957         }
2958     }
2959   inst_env->slot_needed = 0;
2960   inst_env->prefix_found = 0;
2961   inst_env->xflag_found = 0;
2962   inst_env->disable_interrupt = 1;
2963 }
2964
2965 /* Handles moves from special registers (aka P-register) when the mode
2966    is register.  */
2967
2968 static void
2969 reg_mode_move_from_preg_op (unsigned short inst, inst_env_type *inst_env)
2970 {
2971   /* Register mode move from special register can't have a prefix.  */
2972   if (inst_env->prefix_found)
2973     {
2974       inst_env->invalid = 1;
2975       return;
2976     }
2977
2978   if (cris_get_operand1 (inst) == REG_PC)
2979     {
2980       /* It's invalid to change the PC in a delay slot.  */
2981       if (inst_env->slot_needed)
2982         {
2983           inst_env->invalid = 1;
2984           return;
2985         }
2986       /* The destination is the PC, the jump will have a delay slot.  */
2987       inst_env->delay_slot_pc = inst_env->preg[cris_get_operand2 (inst)];
2988       inst_env->slot_needed = 1;
2989       inst_env->delay_slot_pc_active = 1;
2990     }
2991   else
2992     {
2993       /* If the destination isn't PC, there will be no jump.  */
2994       inst_env->slot_needed = 0;
2995     }
2996   inst_env->prefix_found = 0;
2997   inst_env->xflag_found = 0;
2998   inst_env->disable_interrupt = 1;
2999 }
3000
3001 /* Handles the MOVEM from memory to general register instruction.  */
3002
3003 static void
3004 move_mem_to_reg_movem_op (unsigned short inst, inst_env_type *inst_env)
3005 {
3006   if (inst_env->prefix_found)
3007     {
3008       /* The prefix handles the problem if we are in a delay slot.  Is the
3009          MOVEM instruction going to change the PC?  */
3010       if (cris_get_operand2 (inst) >= REG_PC)
3011         {
3012           inst_env->reg[REG_PC] =
3013             read_memory_unsigned_integer (inst_env->prefix_value,
3014                                           4, inst_env->byte_order);
3015         }
3016       /* The assign value is the value after the increment.  Normally, the
3017          assign value is the value before the increment.  */
3018       if ((cris_get_operand1 (inst) == REG_PC)
3019           && (cris_get_mode (inst) == PREFIX_ASSIGN_MODE))
3020         {
3021           inst_env->reg[REG_PC] = inst_env->prefix_value;
3022           inst_env->reg[REG_PC] += 4 * (cris_get_operand2 (inst) + 1);
3023         }
3024     }
3025   else
3026     {
3027       /* Is the MOVEM instruction going to change the PC?  */
3028       if (cris_get_operand2 (inst) == REG_PC)
3029         {
3030           /* It's invalid to change the PC in a delay slot.  */
3031           if (inst_env->slot_needed)
3032             {
3033               inst_env->invalid = 1;
3034               return;
3035             }
3036           inst_env->reg[REG_PC] =
3037             read_memory_unsigned_integer (inst_env->reg[cris_get_operand1 (inst)],
3038                                           4, inst_env->byte_order);
3039         }
3040       /* The increment is not depending on the size, instead it's depending
3041          on the number of registers loaded from memory.  */
3042       if ((cris_get_operand1 (inst) == REG_PC)
3043           && (cris_get_mode (inst) == AUTOINC_MODE))
3044         {
3045           /* It's invalid to change the PC in a delay slot.  */
3046           if (inst_env->slot_needed)
3047             {
3048               inst_env->invalid = 1;
3049               return;
3050             }
3051           inst_env->reg[REG_PC] += 4 * (cris_get_operand2 (inst) + 1);
3052         }
3053     }
3054   inst_env->slot_needed = 0;
3055   inst_env->prefix_found = 0;
3056   inst_env->xflag_found = 0;
3057   inst_env->disable_interrupt = 0;
3058 }
3059
3060 /* Handles the MOVEM to memory from general register instruction.  */
3061
3062 static void
3063 move_reg_to_mem_movem_op (unsigned short inst, inst_env_type *inst_env)
3064 {
3065   if (inst_env->prefix_found)
3066     {
3067       /* The assign value is the value after the increment.  Normally, the
3068          assign value is the value before the increment.  */
3069       if ((cris_get_operand1 (inst) == REG_PC)
3070           && (cris_get_mode (inst) == PREFIX_ASSIGN_MODE))
3071         {
3072           /* The prefix handles the problem if we are in a delay slot.  */
3073           inst_env->reg[REG_PC] = inst_env->prefix_value;
3074           inst_env->reg[REG_PC] += 4 * (cris_get_operand2 (inst) + 1);
3075         }
3076     }
3077   else
3078     {
3079       /* The increment is not depending on the size, instead it's depending
3080          on the number of registers loaded to memory.  */
3081       if ((cris_get_operand1 (inst) == REG_PC)
3082           && (cris_get_mode (inst) == AUTOINC_MODE))
3083         {
3084           /* It's invalid to change the PC in a delay slot.  */
3085           if (inst_env->slot_needed)
3086             {
3087               inst_env->invalid = 1;
3088               return;
3089             }
3090           inst_env->reg[REG_PC] += 4 * (cris_get_operand2 (inst) + 1);
3091         }
3092     }
3093   inst_env->slot_needed = 0;
3094   inst_env->prefix_found = 0;
3095   inst_env->xflag_found = 0;
3096   inst_env->disable_interrupt = 0;
3097 }
3098
3099 /* Handles the intructions that's not yet implemented, by setting
3100    inst_env->invalid to true.  */
3101
3102 static void
3103 not_implemented_op (unsigned short inst, inst_env_type *inst_env)
3104 {
3105   inst_env->invalid = 1;
3106 }
3107
3108 /* Handles the XOR instruction.  */
3109
3110 static void
3111 xor_op (unsigned short inst, inst_env_type *inst_env)
3112 {
3113   /* XOR can't have a prefix.  */
3114   if (inst_env->prefix_found)
3115     {
3116       inst_env->invalid = 1;
3117       return;
3118     }
3119
3120   /* Check if the PC is the target.  */
3121   if (cris_get_operand2 (inst) == REG_PC)
3122     {
3123       /* It's invalid to change the PC in a delay slot.  */
3124       if (inst_env->slot_needed)
3125         {
3126           inst_env->invalid = 1;
3127           return;
3128         }
3129       inst_env->reg[REG_PC] ^= inst_env->reg[cris_get_operand1 (inst)];
3130     }
3131   inst_env->slot_needed = 0;
3132   inst_env->prefix_found = 0;
3133   inst_env->xflag_found = 0;
3134   inst_env->disable_interrupt = 0;
3135 }
3136
3137 /* Handles the MULS instruction.  */
3138
3139 static void
3140 muls_op (unsigned short inst, inst_env_type *inst_env)
3141 {
3142   /* MULS/U can't have a prefix.  */
3143   if (inst_env->prefix_found)
3144     {
3145       inst_env->invalid = 1;
3146       return;
3147     }
3148
3149   /* Consider it invalid if the PC is the target.  */
3150   if (cris_get_operand2 (inst) == REG_PC)
3151     {
3152       inst_env->invalid = 1;
3153       return;
3154     }
3155   inst_env->slot_needed = 0;
3156   inst_env->prefix_found = 0;
3157   inst_env->xflag_found = 0;
3158   inst_env->disable_interrupt = 0;
3159 }
3160
3161 /* Handles the MULU instruction.  */
3162
3163 static void
3164 mulu_op (unsigned short inst, inst_env_type *inst_env)
3165 {
3166   /* MULS/U can't have a prefix.  */
3167   if (inst_env->prefix_found)
3168     {
3169       inst_env->invalid = 1;
3170       return;
3171     }
3172
3173   /* Consider it invalid if the PC is the target.  */
3174   if (cris_get_operand2 (inst) == REG_PC)
3175     {
3176       inst_env->invalid = 1;
3177       return;
3178     }
3179   inst_env->slot_needed = 0;
3180   inst_env->prefix_found = 0;
3181   inst_env->xflag_found = 0;
3182   inst_env->disable_interrupt = 0;
3183 }
3184
3185 /* Calculate the result of the instruction for ADD, SUB, CMP AND, OR and MOVE.
3186    The MOVE instruction is the move from source to register.  */
3187
3188 static void
3189 add_sub_cmp_and_or_move_action (unsigned short inst, inst_env_type *inst_env,
3190                                 unsigned long source1, unsigned long source2)
3191 {
3192   unsigned long pc_mask;
3193   unsigned long operation_mask;
3194
3195   /* Find out how many bits the operation should apply to.  */
3196   if (cris_get_size (inst) == INST_BYTE_SIZE)
3197     {
3198       pc_mask = 0xFFFFFF00;
3199       operation_mask = 0xFF;
3200     }
3201   else if (cris_get_size (inst) == INST_WORD_SIZE)
3202     {
3203       pc_mask = 0xFFFF0000;
3204       operation_mask = 0xFFFF;
3205     }
3206   else if (cris_get_size (inst) == INST_DWORD_SIZE)
3207     {
3208       pc_mask = 0x0;
3209       operation_mask = 0xFFFFFFFF;
3210     }
3211   else
3212     {
3213       /* The size is out of range.  */
3214       inst_env->invalid = 1;
3215       return;
3216     }
3217
3218   /* The instruction just works on uw_operation_mask bits.  */
3219   source2 &= operation_mask;
3220   source1 &= operation_mask;
3221
3222   /* Now calculate the result.  The opcode's 3 first bits separates
3223      the different actions.  */
3224   switch (cris_get_opcode (inst) & 7)
3225     {
3226     case 0:  /* add */
3227       source1 += source2;
3228       break;
3229
3230     case 1:  /* move */
3231       source1 = source2;
3232       break;
3233
3234     case 2:  /* subtract */
3235       source1 -= source2;
3236       break;
3237
3238     case 3:  /* compare */
3239       break;
3240
3241     case 4:  /* and */
3242       source1 &= source2;
3243       break;
3244
3245     case 5:  /* or */
3246       source1 |= source2;
3247       break;
3248
3249     default:
3250       inst_env->invalid = 1;
3251       return;
3252
3253       break;
3254     }
3255
3256   /* Make sure that the result doesn't contain more than the instruction
3257      size bits.  */
3258   source2 &= operation_mask;
3259
3260   /* Calculate the new breakpoint address.  */
3261   inst_env->reg[REG_PC] &= pc_mask;
3262   inst_env->reg[REG_PC] |= source1;
3263
3264 }
3265
3266 /* Extends the value from either byte or word size to a dword.  If the mode
3267    is zero extend then the value is extended with zero.  If instead the mode
3268    is signed extend the sign bit of the value is taken into consideration.  */
3269
3270 static unsigned long
3271 do_sign_or_zero_extend (unsigned long value, unsigned short *inst)
3272 {
3273   /* The size can be either byte or word, check which one it is.
3274      Don't check the highest bit, it's indicating if it's a zero
3275      or sign extend.  */
3276   if (cris_get_size (*inst) & INST_WORD_SIZE)
3277     {
3278       /* Word size.  */
3279       value &= 0xFFFF;
3280
3281       /* Check if the instruction is signed extend.  If so, check if value has
3282          the sign bit on.  */
3283       if (cris_is_signed_extend_bit_on (*inst) && (value & SIGNED_WORD_MASK))
3284         {
3285           value |= SIGNED_WORD_EXTEND_MASK;
3286         }
3287     }
3288   else
3289     {
3290       /* Byte size.  */
3291       value &= 0xFF;
3292
3293       /* Check if the instruction is signed extend.  If so, check if value has
3294          the sign bit on.  */
3295       if (cris_is_signed_extend_bit_on (*inst) && (value & SIGNED_BYTE_MASK))
3296         {
3297           value |= SIGNED_BYTE_EXTEND_MASK;
3298         }
3299     }
3300   /* The size should now be dword.  */
3301   cris_set_size_to_dword (inst);
3302   return value;
3303 }
3304
3305 /* Handles the register mode for the ADD, SUB, CMP, AND, OR and MOVE
3306    instruction.  The MOVE instruction is the move from source to register.  */
3307
3308 static void
3309 reg_mode_add_sub_cmp_and_or_move_op (unsigned short inst,
3310                                      inst_env_type *inst_env)
3311 {
3312   unsigned long operand1;
3313   unsigned long operand2;
3314
3315   /* It's invalid to have a prefix to the instruction.  This is a register
3316      mode instruction and can't have a prefix.  */
3317   if (inst_env->prefix_found)
3318     {
3319       inst_env->invalid = 1;
3320       return;
3321     }
3322   /* Check if the instruction has PC as its target.  */
3323   if (cris_get_operand2 (inst) == REG_PC)
3324     {
3325       if (inst_env->slot_needed)
3326         {
3327           inst_env->invalid = 1;
3328           return;
3329         }
3330       /* The instruction has the PC as its target register.  */
3331       operand1 = inst_env->reg[cris_get_operand1 (inst)];
3332       operand2 = inst_env->reg[REG_PC];
3333
3334       /* Check if it's a extend, signed or zero instruction.  */
3335       if (cris_get_opcode (inst) < 4)
3336         {
3337           operand1 = do_sign_or_zero_extend (operand1, &inst);
3338         }
3339       /* Calculate the PC value after the instruction, i.e. where the
3340          breakpoint should be.  The order of the udw_operands is vital.  */
3341       add_sub_cmp_and_or_move_action (inst, inst_env, operand2, operand1);
3342     }
3343   inst_env->slot_needed = 0;
3344   inst_env->prefix_found = 0;
3345   inst_env->xflag_found = 0;
3346   inst_env->disable_interrupt = 0;
3347 }
3348
3349 /* Returns the data contained at address.  The size of the data is derived from
3350    the size of the operation.  If the instruction is a zero or signed
3351    extend instruction, the size field is changed in instruction.  */
3352
3353 static unsigned long
3354 get_data_from_address (unsigned short *inst, CORE_ADDR address,
3355                        enum bfd_endian byte_order)
3356 {
3357   int size = cris_get_size (*inst);
3358   unsigned long value;
3359
3360   /* If it's an extend instruction we don't want the signed extend bit,
3361      because it influences the size.  */
3362   if (cris_get_opcode (*inst) < 4)
3363     {
3364       size &= ~SIGNED_EXTEND_BIT_MASK;
3365     }
3366   /* Is there a need for checking the size?  Size should contain the number of
3367      bytes to read.  */
3368   size = 1 << size;
3369   value = read_memory_unsigned_integer (address, size, byte_order);
3370
3371   /* Check if it's an extend, signed or zero instruction.  */
3372   if (cris_get_opcode (*inst) < 4)
3373     {
3374       value = do_sign_or_zero_extend (value, inst);
3375     }
3376   return value;
3377 }
3378
3379 /* Handles the assign addresing mode for the ADD, SUB, CMP, AND, OR and MOVE
3380    instructions.  The MOVE instruction is the move from source to register.  */
3381
3382 static void
3383 handle_prefix_assign_mode_for_aritm_op (unsigned short inst,
3384                                         inst_env_type *inst_env)
3385 {
3386   unsigned long operand2;
3387   unsigned long operand3;
3388
3389   check_assign (inst, inst_env);
3390   if (cris_get_operand2 (inst) == REG_PC)
3391     {
3392       operand2 = inst_env->reg[REG_PC];
3393
3394       /* Get the value of the third operand.  */
3395       operand3 = get_data_from_address (&inst, inst_env->prefix_value,
3396                                         inst_env->byte_order);
3397
3398       /* Calculate the PC value after the instruction, i.e. where the
3399          breakpoint should be.  The order of the udw_operands is vital.  */
3400       add_sub_cmp_and_or_move_action (inst, inst_env, operand2, operand3);
3401     }
3402   inst_env->slot_needed = 0;
3403   inst_env->prefix_found = 0;
3404   inst_env->xflag_found = 0;
3405   inst_env->disable_interrupt = 0;
3406 }
3407
3408 /* Handles the three-operand addressing mode for the ADD, SUB, CMP, AND and
3409    OR instructions.  Note that for this to work as expected, the calling
3410    function must have made sure that there is a prefix to this instruction.  */
3411
3412 static void
3413 three_operand_add_sub_cmp_and_or_op (unsigned short inst,
3414                                      inst_env_type *inst_env)
3415 {
3416   unsigned long operand2;
3417   unsigned long operand3;
3418
3419   if (cris_get_operand1 (inst) == REG_PC)
3420     {
3421       /* The PC will be changed by the instruction.  */
3422       operand2 = inst_env->reg[cris_get_operand2 (inst)];
3423
3424       /* Get the value of the third operand.  */
3425       operand3 = get_data_from_address (&inst, inst_env->prefix_value,
3426                                         inst_env->byte_order);
3427
3428       /* Calculate the PC value after the instruction, i.e. where the
3429          breakpoint should be.  */
3430       add_sub_cmp_and_or_move_action (inst, inst_env, operand2, operand3);
3431     }
3432   inst_env->slot_needed = 0;
3433   inst_env->prefix_found = 0;
3434   inst_env->xflag_found = 0;
3435   inst_env->disable_interrupt = 0;
3436 }
3437
3438 /* Handles the index addresing mode for the ADD, SUB, CMP, AND, OR and MOVE
3439    instructions.  The MOVE instruction is the move from source to register.  */
3440
3441 static void
3442 handle_prefix_index_mode_for_aritm_op (unsigned short inst,
3443                                        inst_env_type *inst_env)
3444 {
3445   if (cris_get_operand1 (inst) != cris_get_operand2 (inst))
3446     {
3447       /* If the instruction is MOVE it's invalid.  If the instruction is ADD,
3448          SUB, AND or OR something weird is going on (if everything works these
3449          instructions should end up in the three operand version).  */
3450       inst_env->invalid = 1;
3451       return;
3452     }
3453   else
3454     {
3455       /* three_operand_add_sub_cmp_and_or does the same as we should do here
3456          so use it.  */
3457       three_operand_add_sub_cmp_and_or_op (inst, inst_env);
3458     }
3459   inst_env->slot_needed = 0;
3460   inst_env->prefix_found = 0;
3461   inst_env->xflag_found = 0;
3462   inst_env->disable_interrupt = 0;
3463 }
3464
3465 /* Handles the autoincrement and indirect addresing mode for the ADD, SUB,
3466    CMP, AND OR and MOVE instruction.  The MOVE instruction is the move from
3467    source to register.  */
3468
3469 static void
3470 handle_inc_and_index_mode_for_aritm_op (unsigned short inst,
3471                                         inst_env_type *inst_env)
3472 {
3473   unsigned long operand1;
3474   unsigned long operand2;
3475   unsigned long operand3;
3476   int size;
3477
3478   /* The instruction is either an indirect or autoincrement addressing mode.
3479      Check if the destination register is the PC.  */
3480   if (cris_get_operand2 (inst) == REG_PC)
3481     {
3482       /* Must be done here, get_data_from_address may change the size
3483          field.  */
3484       size = cris_get_size (inst);
3485       operand2 = inst_env->reg[REG_PC];
3486
3487       /* Get the value of the third operand, i.e. the indirect operand.  */
3488       operand1 = inst_env->reg[cris_get_operand1 (inst)];
3489       operand3 = get_data_from_address (&inst, operand1, inst_env->byte_order);
3490
3491       /* Calculate the PC value after the instruction, i.e. where the
3492          breakpoint should be.  The order of the udw_operands is vital.  */
3493       add_sub_cmp_and_or_move_action (inst, inst_env, operand2, operand3);
3494     }
3495   /* If this is an autoincrement addressing mode, check if the increment
3496      changes the PC.  */
3497   if ((cris_get_operand1 (inst) == REG_PC)
3498       && (cris_get_mode (inst) == AUTOINC_MODE))
3499     {
3500       /* Get the size field.  */
3501       size = cris_get_size (inst);
3502
3503       /* If it's an extend instruction we don't want the signed extend bit,
3504          because it influences the size.  */
3505       if (cris_get_opcode (inst) < 4)
3506         {
3507           size &= ~SIGNED_EXTEND_BIT_MASK;
3508         }
3509       process_autoincrement (size, inst, inst_env);
3510     }
3511   inst_env->slot_needed = 0;
3512   inst_env->prefix_found = 0;
3513   inst_env->xflag_found = 0;
3514   inst_env->disable_interrupt = 0;
3515 }
3516
3517 /* Handles the two-operand addressing mode, all modes except register, for
3518    the ADD, SUB CMP, AND and OR instruction.  */
3519
3520 static void
3521 none_reg_mode_add_sub_cmp_and_or_move_op (unsigned short inst,
3522                                           inst_env_type *inst_env)
3523 {
3524   if (inst_env->prefix_found)
3525     {
3526       if (cris_get_mode (inst) == PREFIX_INDEX_MODE)
3527         {
3528           handle_prefix_index_mode_for_aritm_op (inst, inst_env);
3529         }
3530       else if (cris_get_mode (inst) == PREFIX_ASSIGN_MODE)
3531         {
3532           handle_prefix_assign_mode_for_aritm_op (inst, inst_env);
3533         }
3534       else
3535         {
3536           /* The mode is invalid for a prefixed base instruction.  */
3537           inst_env->invalid = 1;
3538           return;
3539         }
3540     }
3541   else
3542     {
3543       handle_inc_and_index_mode_for_aritm_op (inst, inst_env);
3544     }
3545 }
3546
3547 /* Handles the quick addressing mode for the ADD and SUB instruction.  */
3548
3549 static void
3550 quick_mode_add_sub_op (unsigned short inst, inst_env_type *inst_env)
3551 {
3552   unsigned long operand1;
3553   unsigned long operand2;
3554
3555   /* It's a bad idea to be in a prefix instruction now.  This is a quick mode
3556      instruction and can't have a prefix.  */
3557   if (inst_env->prefix_found)
3558     {
3559       inst_env->invalid = 1;
3560       return;
3561     }
3562
3563   /* Check if the instruction has PC as its target.  */
3564   if (cris_get_operand2 (inst) == REG_PC)
3565     {
3566       if (inst_env->slot_needed)
3567         {
3568           inst_env->invalid = 1;
3569           return;
3570         }
3571       operand1 = cris_get_quick_value (inst);
3572       operand2 = inst_env->reg[REG_PC];
3573
3574       /* The size should now be dword.  */
3575       cris_set_size_to_dword (&inst);
3576
3577       /* Calculate the PC value after the instruction, i.e. where the
3578          breakpoint should be.  */
3579       add_sub_cmp_and_or_move_action (inst, inst_env, operand2, operand1);
3580     }
3581   inst_env->slot_needed = 0;
3582   inst_env->prefix_found = 0;
3583   inst_env->xflag_found = 0;
3584   inst_env->disable_interrupt = 0;
3585 }
3586
3587 /* Handles the quick addressing mode for the CMP, AND and OR instruction.  */
3588
3589 static void
3590 quick_mode_and_cmp_move_or_op (unsigned short inst, inst_env_type *inst_env)
3591 {
3592   unsigned long operand1;
3593   unsigned long operand2;
3594
3595   /* It's a bad idea to be in a prefix instruction now.  This is a quick mode
3596      instruction and can't have a prefix.  */
3597   if (inst_env->prefix_found)
3598     {
3599       inst_env->invalid = 1;
3600       return;
3601     }
3602   /* Check if the instruction has PC as its target.  */
3603   if (cris_get_operand2 (inst) == REG_PC)
3604     {
3605       if (inst_env->slot_needed)
3606         {
3607           inst_env->invalid = 1;
3608           return;
3609         }
3610       /* The instruction has the PC as its target register.  */
3611       operand1 = cris_get_quick_value (inst);
3612       operand2 = inst_env->reg[REG_PC];
3613
3614       /* The quick value is signed, so check if we must do a signed extend.  */
3615       if (operand1 & SIGNED_QUICK_VALUE_MASK)
3616         {
3617           /* sign extend  */
3618           operand1 |= SIGNED_QUICK_VALUE_EXTEND_MASK;
3619         }
3620       /* The size should now be dword.  */
3621       cris_set_size_to_dword (&inst);
3622
3623       /* Calculate the PC value after the instruction, i.e. where the
3624          breakpoint should be.  */
3625       add_sub_cmp_and_or_move_action (inst, inst_env, operand2, operand1);
3626     }
3627   inst_env->slot_needed = 0;
3628   inst_env->prefix_found = 0;
3629   inst_env->xflag_found = 0;
3630   inst_env->disable_interrupt = 0;
3631 }
3632
3633 /* Translate op_type to a function and call it.  */
3634
3635 static void
3636 cris_gdb_func (struct gdbarch *gdbarch, enum cris_op_type op_type,
3637                unsigned short inst, inst_env_type *inst_env)
3638 {
3639   switch (op_type)
3640     {
3641     case cris_not_implemented_op:
3642       not_implemented_op (inst, inst_env);
3643       break;
3644
3645     case cris_abs_op:
3646       abs_op (inst, inst_env);
3647       break;
3648
3649     case cris_addi_op:
3650       addi_op (inst, inst_env);
3651       break;
3652
3653     case cris_asr_op:
3654       asr_op (inst, inst_env);
3655       break;
3656
3657     case cris_asrq_op:
3658       asrq_op (inst, inst_env);
3659       break;
3660
3661     case cris_ax_ei_setf_op:
3662       ax_ei_setf_op (inst, inst_env);
3663       break;
3664
3665     case cris_bdap_prefix:
3666       bdap_prefix (inst, inst_env);
3667       break;
3668
3669     case cris_biap_prefix:
3670       biap_prefix (inst, inst_env);
3671       break;
3672
3673     case cris_break_op:
3674       break_op (inst, inst_env);
3675       break;
3676
3677     case cris_btst_nop_op:
3678       btst_nop_op (inst, inst_env);
3679       break;
3680
3681     case cris_clearf_di_op:
3682       clearf_di_op (inst, inst_env);
3683       break;
3684
3685     case cris_dip_prefix:
3686       dip_prefix (inst, inst_env);
3687       break;
3688
3689     case cris_dstep_logshift_mstep_neg_not_op:
3690       dstep_logshift_mstep_neg_not_op (inst, inst_env);
3691       break;
3692
3693     case cris_eight_bit_offset_branch_op:
3694       eight_bit_offset_branch_op (inst, inst_env);
3695       break;
3696
3697     case cris_move_mem_to_reg_movem_op:
3698       move_mem_to_reg_movem_op (inst, inst_env);
3699       break;
3700
3701     case cris_move_reg_to_mem_movem_op:
3702       move_reg_to_mem_movem_op (inst, inst_env);
3703       break;
3704
3705     case cris_move_to_preg_op:
3706       move_to_preg_op (gdbarch, inst, inst_env);
3707       break;
3708
3709     case cris_muls_op:
3710       muls_op (inst, inst_env);
3711       break;
3712
3713     case cris_mulu_op:
3714       mulu_op (inst, inst_env);
3715       break;
3716
3717     case cris_none_reg_mode_add_sub_cmp_and_or_move_op:
3718       none_reg_mode_add_sub_cmp_and_or_move_op (inst, inst_env);
3719       break;
3720
3721     case cris_none_reg_mode_clear_test_op:
3722       none_reg_mode_clear_test_op (inst, inst_env);
3723       break;
3724
3725     case cris_none_reg_mode_jump_op:
3726       none_reg_mode_jump_op (inst, inst_env);
3727       break;
3728
3729     case cris_none_reg_mode_move_from_preg_op:
3730       none_reg_mode_move_from_preg_op (gdbarch, inst, inst_env);
3731       break;
3732
3733     case cris_quick_mode_add_sub_op:
3734       quick_mode_add_sub_op (inst, inst_env);
3735       break;
3736
3737     case cris_quick_mode_and_cmp_move_or_op:
3738       quick_mode_and_cmp_move_or_op (inst, inst_env);
3739       break;
3740
3741     case cris_quick_mode_bdap_prefix:
3742       quick_mode_bdap_prefix (inst, inst_env);
3743       break;
3744
3745     case cris_reg_mode_add_sub_cmp_and_or_move_op:
3746       reg_mode_add_sub_cmp_and_or_move_op (inst, inst_env);
3747       break;
3748
3749     case cris_reg_mode_clear_op:
3750       reg_mode_clear_op (inst, inst_env);
3751       break;
3752
3753     case cris_reg_mode_jump_op:
3754       reg_mode_jump_op (inst, inst_env);
3755       break;
3756
3757     case cris_reg_mode_move_from_preg_op:
3758       reg_mode_move_from_preg_op (inst, inst_env);
3759       break;
3760
3761     case cris_reg_mode_test_op:
3762       reg_mode_test_op (inst, inst_env);
3763       break;
3764
3765     case cris_scc_op:
3766       scc_op (inst, inst_env);
3767       break;
3768
3769     case cris_sixteen_bit_offset_branch_op:
3770       sixteen_bit_offset_branch_op (inst, inst_env);
3771       break;
3772
3773     case cris_three_operand_add_sub_cmp_and_or_op:
3774       three_operand_add_sub_cmp_and_or_op (inst, inst_env);
3775       break;
3776
3777     case cris_three_operand_bound_op:
3778       three_operand_bound_op (inst, inst_env);
3779       break;
3780
3781     case cris_two_operand_bound_op:
3782       two_operand_bound_op (inst, inst_env);
3783       break;
3784
3785     case cris_xor_op:
3786       xor_op (inst, inst_env);
3787       break;
3788     }
3789 }
3790
3791 /* This wrapper is to avoid cris_get_assembler being called before
3792    exec_bfd has been set.  */
3793
3794 static int
3795 cris_delayed_get_disassembler (bfd_vma addr, struct disassemble_info *info)
3796 {
3797   int (*print_insn) (bfd_vma addr, struct disassemble_info *info);
3798   /* FIXME: cagney/2003-08-27: It should be possible to select a CRIS
3799      disassembler, even when there is no BFD.  Does something like
3800      "gdb; target remote; disassmeble *0x123" work?  */
3801   gdb_assert (exec_bfd != NULL);
3802   print_insn = cris_get_disassembler (exec_bfd);
3803   gdb_assert (print_insn != NULL);
3804   return print_insn (addr, info);
3805 }
3806
3807 /* Originally from <asm/elf.h>.  */
3808 typedef unsigned char cris_elf_greg_t[4];
3809
3810 /* Same as user_regs_struct struct in <asm/user.h>.  */
3811 #define CRISV10_ELF_NGREG 35
3812 typedef cris_elf_greg_t cris_elf_gregset_t[CRISV10_ELF_NGREG];
3813
3814 #define CRISV32_ELF_NGREG 32
3815 typedef cris_elf_greg_t crisv32_elf_gregset_t[CRISV32_ELF_NGREG];
3816
3817 /* Unpack a cris_elf_gregset_t into GDB's register cache.  */
3818
3819 static void
3820 cris_supply_gregset (struct regcache *regcache, cris_elf_gregset_t *gregsetp)
3821 {
3822   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3823   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3824   int i;
3825   cris_elf_greg_t *regp = *gregsetp;
3826
3827   /* The kernel dumps all 32 registers as unsigned longs, but supply_register
3828      knows about the actual size of each register so that's no problem.  */
3829   for (i = 0; i < NUM_GENREGS + NUM_SPECREGS; i++)
3830     {
3831       regcache_raw_supply (regcache, i, (char *)&regp[i]);
3832     }
3833
3834   if (tdep->cris_version == 32)
3835     {
3836       /* Needed to set pseudo-register PC for CRISv32.  */
3837       /* FIXME: If ERP is in a delay slot at this point then the PC will
3838          be wrong.  Issue a warning to alert the user.  */
3839       regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
3840                            (char *)&regp[ERP_REGNUM]);
3841
3842       if (*(char *)&regp[ERP_REGNUM] & 0x1)
3843         fprintf_unfiltered (gdb_stderr, "Warning: PC in delay slot\n");
3844     }
3845 }
3846
3847 /*  Use a local version of this function to get the correct types for
3848     regsets, until multi-arch core support is ready.  */
3849
3850 static void
3851 fetch_core_registers (struct regcache *regcache,
3852                       char *core_reg_sect, unsigned core_reg_size,
3853                       int which, CORE_ADDR reg_addr)
3854 {
3855   cris_elf_gregset_t gregset;
3856
3857   switch (which)
3858     {
3859     case 0:
3860       if (core_reg_size != sizeof (cris_elf_gregset_t)
3861           && core_reg_size != sizeof (crisv32_elf_gregset_t))
3862         {
3863           warning (_("wrong size gregset struct in core file"));
3864         }
3865       else
3866         {
3867           memcpy (&gregset, core_reg_sect, sizeof (gregset));
3868           cris_supply_gregset (regcache, &gregset);
3869         }
3870
3871     default:
3872       /* We've covered all the kinds of registers we know about here,
3873          so this must be something we wouldn't know what to do with
3874          anyway.  Just ignore it.  */
3875       break;
3876     }
3877 }
3878
3879 static struct core_fns cris_elf_core_fns =
3880 {
3881   bfd_target_elf_flavour,               /* core_flavour */
3882   default_check_format,                 /* check_format */
3883   default_core_sniffer,                 /* core_sniffer */
3884   fetch_core_registers,                 /* core_read_registers */
3885   NULL                                  /* next */
3886 };
3887
3888 extern initialize_file_ftype _initialize_cris_tdep; /* -Wmissing-prototypes */
3889
3890 void
3891 _initialize_cris_tdep (void)
3892 {
3893   gdbarch_register (bfd_arch_cris, cris_gdbarch_init, cris_dump_tdep);
3894
3895   /* CRIS-specific user-commands.  */
3896   add_setshow_zuinteger_cmd ("cris-version", class_support,
3897                              &usr_cmd_cris_version,
3898                              _("Set the current CRIS version."),
3899                              _("Show the current CRIS version."),
3900                              _("\
3901 Set to 10 for CRISv10 or 32 for CRISv32 if autodetection fails.\n\
3902 Defaults to 10. "),
3903                              set_cris_version,
3904                              NULL, /* FIXME: i18n: Current CRIS version
3905                                       is %s.  */
3906                              &setlist, &showlist);
3907
3908   add_setshow_enum_cmd ("cris-mode", class_support,
3909                         cris_modes, &usr_cmd_cris_mode,
3910                         _("Set the current CRIS mode."),
3911                         _("Show the current CRIS mode."),
3912                         _("\
3913 Set to CRIS_MODE_GURU when debugging in guru mode.\n\
3914 Makes GDB use the NRP register instead of the ERP register in certain cases."),
3915                         set_cris_mode,
3916                         NULL, /* FIXME: i18n: Current CRIS version is %s.  */
3917                         &setlist, &showlist);
3918
3919   add_setshow_boolean_cmd ("cris-dwarf2-cfi", class_support,
3920                            &usr_cmd_cris_dwarf2_cfi,
3921                            _("Set the usage of Dwarf-2 CFI for CRIS."),
3922                            _("Show the usage of Dwarf-2 CFI for CRIS."),
3923                            _("Set this to \"off\" if using gcc-cris < R59."),
3924                            set_cris_dwarf2_cfi,
3925                            NULL, /* FIXME: i18n: Usage of Dwarf-2 CFI
3926                                     for CRIS is %d.  */
3927                            &setlist, &showlist);
3928
3929   deprecated_add_core_fns (&cris_elf_core_fns);
3930 }
3931
3932 /* Prints out all target specific values.  */
3933
3934 static void
3935 cris_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3936 {
3937   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3938   if (tdep != NULL)
3939     {
3940       fprintf_unfiltered (file, "cris_dump_tdep: tdep->cris_version = %i\n",
3941                           tdep->cris_version);
3942       fprintf_unfiltered (file, "cris_dump_tdep: tdep->cris_mode = %s\n",
3943                           tdep->cris_mode);
3944       fprintf_unfiltered (file, "cris_dump_tdep: tdep->cris_dwarf2_cfi = %i\n",
3945                           tdep->cris_dwarf2_cfi);
3946     }
3947 }
3948
3949 static void
3950 set_cris_version (char *ignore_args, int from_tty,
3951                   struct cmd_list_element *c)
3952 {
3953   struct gdbarch_info info;
3954
3955   usr_cmd_cris_version_valid = 1;
3956
3957   /* Update the current architecture, if needed.  */
3958   gdbarch_info_init (&info);
3959   if (!gdbarch_update_p (info))
3960     internal_error (__FILE__, __LINE__,
3961                     _("cris_gdbarch_update: failed to update architecture."));
3962 }
3963
3964 static void
3965 set_cris_mode (char *ignore_args, int from_tty,
3966                struct cmd_list_element *c)
3967 {
3968   struct gdbarch_info info;
3969
3970   /* Update the current architecture, if needed.  */
3971   gdbarch_info_init (&info);
3972   if (!gdbarch_update_p (info))
3973     internal_error (__FILE__, __LINE__,
3974                     "cris_gdbarch_update: failed to update architecture.");
3975 }
3976
3977 static void
3978 set_cris_dwarf2_cfi (char *ignore_args, int from_tty,
3979                      struct cmd_list_element *c)
3980 {
3981   struct gdbarch_info info;
3982
3983   /* Update the current architecture, if needed.  */
3984   gdbarch_info_init (&info);
3985   if (!gdbarch_update_p (info))
3986     internal_error (__FILE__, __LINE__,
3987                     _("cris_gdbarch_update: failed to update architecture."));
3988 }
3989
3990 static struct gdbarch *
3991 cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3992 {
3993   struct gdbarch *gdbarch;
3994   struct gdbarch_tdep *tdep;
3995   unsigned int cris_version;
3996
3997   if (usr_cmd_cris_version_valid)
3998     {
3999       /* Trust the user's CRIS version setting.  */
4000       cris_version = usr_cmd_cris_version;
4001     }
4002   else if (info.abfd && bfd_get_mach (info.abfd) == bfd_mach_cris_v32)
4003     {
4004       cris_version = 32;
4005     }
4006   else
4007     {
4008       /* Assume it's CRIS version 10.  */
4009       cris_version = 10;
4010     }
4011
4012   /* Make the current settings visible to the user.  */
4013   usr_cmd_cris_version = cris_version;
4014
4015   /* Find a candidate among the list of pre-declared architectures.  */
4016   for (arches = gdbarch_list_lookup_by_info (arches, &info);
4017        arches != NULL;
4018        arches = gdbarch_list_lookup_by_info (arches->next, &info))
4019     {
4020       if ((gdbarch_tdep (arches->gdbarch)->cris_version
4021            == usr_cmd_cris_version)
4022           && (gdbarch_tdep (arches->gdbarch)->cris_mode
4023            == usr_cmd_cris_mode)
4024           && (gdbarch_tdep (arches->gdbarch)->cris_dwarf2_cfi
4025               == usr_cmd_cris_dwarf2_cfi))
4026         return arches->gdbarch;
4027     }
4028
4029   /* No matching architecture was found.  Create a new one.  */
4030   tdep = XNEW (struct gdbarch_tdep);
4031   gdbarch = gdbarch_alloc (&info, tdep);
4032
4033   tdep->cris_version = usr_cmd_cris_version;
4034   tdep->cris_mode = usr_cmd_cris_mode;
4035   tdep->cris_dwarf2_cfi = usr_cmd_cris_dwarf2_cfi;
4036
4037   /* INIT shall ensure that the INFO.BYTE_ORDER is non-zero.  */
4038   switch (info.byte_order)
4039     {
4040     case BFD_ENDIAN_LITTLE:
4041       /* Ok.  */
4042       break;
4043
4044     case BFD_ENDIAN_BIG:
4045       /* Cris is always little endian, but the user could have forced
4046          big endian with "set endian".  */
4047       return 0;
4048
4049     default:
4050       internal_error (__FILE__, __LINE__,
4051                       _("cris_gdbarch_init: unknown byte order in info"));
4052     }
4053
4054   set_gdbarch_return_value (gdbarch, cris_return_value);
4055
4056   set_gdbarch_sp_regnum (gdbarch, 14);
4057
4058   /* Length of ordinary registers used in push_word and a few other
4059      places.  register_size() is the real way to know how big a
4060      register is.  */
4061
4062   set_gdbarch_double_bit (gdbarch, 64);
4063   /* The default definition of a long double is 2 * gdbarch_double_bit,
4064      which means we have to set this explicitly.  */
4065   set_gdbarch_long_double_bit (gdbarch, 64);
4066
4067   /* The total amount of space needed to store (in an array called registers)
4068      GDB's copy of the machine's register state.  Note: We can not use
4069      cris_register_size at this point, since it relies on gdbarch
4070      being set.  */
4071   switch (tdep->cris_version)
4072     {
4073     case 0:
4074     case 1:
4075     case 2:
4076     case 3:
4077     case 8:
4078     case 9:
4079       /* Old versions; not supported.  */
4080       return 0;
4081
4082     case 10:
4083     case 11:
4084       /* CRIS v10 and v11, a.k.a. ETRAX 100LX.  In addition to ETRAX 100,
4085          P7 (32 bits), and P15 (32 bits) have been implemented.  */
4086       set_gdbarch_pc_regnum (gdbarch, 15);
4087       set_gdbarch_register_type (gdbarch, cris_register_type);
4088       /* There are 32 registers (some of which may not be implemented).  */
4089       set_gdbarch_num_regs (gdbarch, 32);
4090       set_gdbarch_register_name (gdbarch, cris_register_name);
4091       set_gdbarch_cannot_store_register (gdbarch, cris_cannot_store_register);
4092       set_gdbarch_cannot_fetch_register (gdbarch, cris_cannot_fetch_register);
4093
4094       set_gdbarch_software_single_step (gdbarch, cris_software_single_step);
4095       break;
4096
4097     case 32:
4098       /* CRIS v32.  General registers R0 - R15 (32 bits), special registers
4099          P0 - P15 (32 bits) except P0, P1, P3 (8 bits) and P4 (16 bits)
4100          and pseudo-register PC (32 bits).  */
4101       set_gdbarch_pc_regnum (gdbarch, 32);
4102       set_gdbarch_register_type (gdbarch, crisv32_register_type);
4103       /* 32 registers + pseudo-register PC + 16 support registers.  */
4104       set_gdbarch_num_regs (gdbarch, 32 + 1 + 16);
4105       set_gdbarch_register_name (gdbarch, crisv32_register_name);
4106
4107       set_gdbarch_cannot_store_register
4108         (gdbarch, crisv32_cannot_store_register);
4109       set_gdbarch_cannot_fetch_register
4110         (gdbarch, crisv32_cannot_fetch_register);
4111
4112       set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
4113
4114       set_gdbarch_single_step_through_delay
4115         (gdbarch, crisv32_single_step_through_delay);
4116
4117       break;
4118
4119     default:
4120       /* Unknown version.  */
4121       return 0;
4122     }
4123
4124   /* Dummy frame functions (shared between CRISv10 and CRISv32 since they
4125      have the same ABI).  */
4126   set_gdbarch_push_dummy_code (gdbarch, cris_push_dummy_code);
4127   set_gdbarch_push_dummy_call (gdbarch, cris_push_dummy_call);
4128   set_gdbarch_frame_align (gdbarch, cris_frame_align);
4129   set_gdbarch_skip_prologue (gdbarch, cris_skip_prologue);
4130
4131   /* The stack grows downward.  */
4132   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
4133
4134   SET_GDBARCH_BREAKPOINT_MANIPULATION (cris);
4135
4136   set_gdbarch_unwind_pc (gdbarch, cris_unwind_pc);
4137   set_gdbarch_unwind_sp (gdbarch, cris_unwind_sp);
4138   set_gdbarch_dummy_id (gdbarch, cris_dummy_id);
4139
4140   if (tdep->cris_dwarf2_cfi == 1)
4141     {
4142       /* Hook in the Dwarf-2 frame sniffer.  */
4143       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, cris_dwarf2_reg_to_regnum);
4144       dwarf2_frame_set_init_reg (gdbarch, cris_dwarf2_frame_init_reg);
4145       dwarf2_append_unwinders (gdbarch);
4146     }
4147
4148   if (tdep->cris_mode != cris_mode_guru)
4149     {
4150       frame_unwind_append_unwinder (gdbarch, &cris_sigtramp_frame_unwind);
4151     }
4152
4153   frame_unwind_append_unwinder (gdbarch, &cris_frame_unwind);
4154   frame_base_set_default (gdbarch, &cris_frame_base);
4155
4156   /* Hook in ABI-specific overrides, if they have been registered.  */
4157   gdbarch_init_osabi (info, gdbarch);
4158
4159   /* FIXME: cagney/2003-08-27: It should be possible to select a CRIS
4160      disassembler, even when there is no BFD.  Does something like
4161      "gdb; target remote; disassmeble *0x123" work?  */
4162   set_gdbarch_print_insn (gdbarch, cris_delayed_get_disassembler);
4163
4164   return gdbarch;
4165 }