gdb/xtensa-tdep.c

   1 /* Target-dependent code for the Xtensa port of GDB, the GNU debugger.
   2
   3    Copyright (C) 2003, 2005, 2006, 2007 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "objfiles.h"
  27 #include "gdbtypes.h"
  28 #include "gdbcore.h"
  29 #include "value.h"
  30 #include "dis-asm.h"
  31 #include "inferior.h"
  32 #include "floatformat.h"
  33 #include "regcache.h"
  34 #include "reggroups.h"
  35 #include "regset.h"
  36
  37 #include "dummy-frame.h"
  38 #include "elf/dwarf2.h"
  39 #include "dwarf2-frame.h"
  40 #include "dwarf2loc.h"
  41 #include "frame.h"
  42 #include "frame-base.h"
  43 #include "frame-unwind.h"
  44
  45 #include "arch-utils.h"
  46 #include "gdbarch.h"
  47 #include "remote.h"
  48 #include "serial.h"
  49
  50 #include "command.h"
  51 #include "gdbcmd.h"
  52 #include "gdb_assert.h"
  53
  54 #include "xtensa-tdep.h"
  55
  56
  57 static int xtensa_debug_level = 0;
  58
  59 #define DEBUGWARN(args...) \
  60   if (xtensa_debug_level > 0) \
  61     fprintf_unfiltered (gdb_stdlog, "(warn ) " args)
  62
  63 #define DEBUGINFO(args...) \
  64   if (xtensa_debug_level > 1) \
  65     fprintf_unfiltered (gdb_stdlog, "(info ) " args)
  66
  67 #define DEBUGTRACE(args...) \
  68   if (xtensa_debug_level > 2) \
  69     fprintf_unfiltered (gdb_stdlog, "(trace) " args)
  70
  71 #define DEBUGVERB(args...) \
  72   if (xtensa_debug_level > 3) \
  73     fprintf_unfiltered (gdb_stdlog, "(verb ) " args)
  74
  75
  76 /* According to the ABI, the SP must be aligned to 16-byte boundaries.  */
  77
  78 #define SP_ALIGNMENT 16
  79
  80
  81 /* We use a6 through a11 for passing arguments to a function called by GDB.  */
  82
  83 #define ARGS_FIRST_REG    A6_REGNUM
  84 #define ARGS_NUM_REGS     6
  85 #define REGISTER_SIZE     4
  86
  87
  88 /* Extract the call size from the return address or ps register.  */
  89
  90 #define PS_CALLINC_SHIFT 16
  91 #define PS_CALLINC_MASK 0x00030000
  92 #define CALLINC(ps) (((ps) & PS_CALLINC_MASK) >> PS_CALLINC_SHIFT)
  93 #define WINSIZE(ra) (4 * (( (ra) >> 30) & 0x3))
  94
  95
  96 /* Convert a live Ax register number to the corresponding Areg number.  */
  97
  98 #define AREG_NUMBER(r, wb) \
  99   ((((r) - A0_REGNUM + (((wb) & WB_MASK)<<WB_SHIFT)) & AREGS_MASK) + AR_BASE)
 100
 101
 102 /* Define prototypes.  */
 103
 104 extern struct gdbarch_tdep *xtensa_config_tdep (struct gdbarch_info *);
 105 extern int xtensa_config_byte_order (struct gdbarch_info *);
 106
 107
 108 /* XTENSA_IS_ENTRY tests whether the first byte of an instruction
 109    indicates that the instruction is an ENTRY instruction.  */
 110
 111 #define XTENSA_IS_ENTRY(op1) \
 112   ((gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) \
 113    ? ((op1) == 0x6c) : ((op1) == 0x36))
 114
 115 #define XTENSA_ENTRY_LENGTH  3
 116
 117
 118 /* windowing_enabled() returns true, if windowing is enabled.
 119    WOE must be set to 1; EXCM to 0.
 120    Note: We assume that EXCM is always 0 for XEA1.  */
 121
 122 static inline int
 123 windowing_enabled (CORE_ADDR ps)
 124 {
 125   return ((ps & (1 << 4)) == 0 && (ps & (1 << 18)) != 0);
 126 }
 127
 128 /* Return the window size of the previous call to the function from which we
 129    have just returned.
 130
 131    This function is used to extract the return value after a called function
 132    has returned to the callee.  On Xtensa, the register that holds the return
 133    value (from the perspective of the caller) depends on what call
 134    instruction was used.  For now, we are assuming that the call instruction
 135    precedes the current address, so we simply analyze the call instruction.
 136    If we are in a dummy frame, we simply return 4 as we used a 'pseudo-call4'
 137    method to call the inferior function.  */
 138
 139 static int
 140 extract_call_winsize (CORE_ADDR pc)
 141 {
 142   int winsize = 4;      /* Default: No call, e.g. dummy frame.  */
 143   int insn;
 144   gdb_byte buf[4];
 145
 146   DEBUGTRACE ("extract_call_winsize (pc = 0x%08x)\n", (int) pc);
 147
 148   /* Read the previous instruction (should be a call[x]{4|8|12}.  */
 149   read_memory (pc-3, buf, 3);
 150   insn = extract_unsigned_integer (buf, 3);
 151
 152   /* Decode call instruction:
 153      Little Endian
 154        call{0,4,8,12}   OFFSET || {00,01,10,11} || 0101
 155        callx{0,4,8,12}  OFFSET || 11 || {00,01,10,11} || 0000
 156      Big Endian
 157        call{0,4,8,12}   0101 || {00,01,10,11} || OFFSET
 158        callx{0,4,8,12}  0000 || {00,01,10,11} || 11 || OFFSET.  */
 159
 160   /* Lookup call insn.
 161      (Return the default value (4) if we can't find a valid call insn.  */
 162
 163   if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
 164     {
 165       if (((insn & 0xf) == 0x5) || ((insn & 0xcf) == 0xc0))
 166         winsize = (insn & 0x30) >> 2;   /* 0, 4, 8, 12  */
 167     }
 168   else
 169     {
 170       if (((insn >> 20) == 0x5) || (((insn >> 16) & 0xf3) == 0x03))
 171         winsize = (insn >> 16) & 0xc;   /* 0, 4, 8, 12  */
 172     }
 173   return winsize;
 174 }
 175
 176
 177 /* REGISTER INFORMATION */
 178
 179 /* Returns the name of a register.  */
 180
 181 static const char *
 182 xtensa_register_name (int regnum)
 183 {
 184   /* Return the name stored in the register map.  */
 185   if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch)
 186                               + gdbarch_num_pseudo_regs (current_gdbarch))
 187     return REGMAP[regnum].name;
 188
 189   /* Invalid register number.  */
 190   internal_error (__FILE__, __LINE__, _("invalid register %d"), regnum);
 191   return 0;
 192 }
 193
 194
 195 /* Return the type of a register.  Create a new type, if necessary.  */
 196
 197 static struct ctype_cache
 198 {
 199   struct ctype_cache *next;
 200   int size;
 201   struct type *virtual_type;
 202 } *type_entries = NULL;
 203
 204 static struct type *
 205 xtensa_register_type (struct gdbarch *gdbarch, int regnum)
 206 {
 207   /* Return signed integer for ARx and Ax registers.  */
 208   if ((regnum >= AR_BASE && regnum < AR_BASE + NUM_AREGS)
 209       || (regnum >= A0_BASE && regnum < A0_BASE + 16))
 210     return builtin_type_int;
 211
 212   if (regnum == PC_REGNUM || regnum == A1_REGNUM)
 213     return lookup_pointer_type (builtin_type_void);
 214
 215   /* Return the stored type for all other registers.  */
 216   else if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch)
 217                                    + gdbarch_num_pseudo_regs (current_gdbarch))
 218     {
 219       xtensa_register_t* reg = &REGMAP[regnum];
 220
 221       /* Set ctype for this register (only the first time we ask for it).  */
 222
 223       if (reg->ctype == 0)
 224         {
 225           struct ctype_cache *tp;
 226           int size = reg->byte_size;
 227
 228           /* We always use the memory representation, even if the register
 229              width is smaller.  */
 230           switch (size)
 231             {
 232             case 1:
 233               reg->ctype = builtin_type_uint8;
 234               break;
 235
 236             case 2:
 237               reg->ctype = builtin_type_uint16;
 238               break;
 239
 240             case 4:
 241               reg->ctype = builtin_type_uint32;
 242               break;
 243
 244             case 8:
 245               reg->ctype = builtin_type_uint64;
 246               break;
 247
 248             case 16:
 249               reg->ctype = builtin_type_uint128;
 250               break;
 251
 252             default:
 253               for (tp = type_entries; tp != NULL; tp = tp->next)
 254                 if (tp->size == size)
 255                   break;
 256
 257               if (tp == NULL)
 258                 {
 259                   char *name = xmalloc (16);
 260                   tp = xmalloc (sizeof (struct ctype_cache));
 261                   tp->next = type_entries;
 262                   type_entries = tp;
 263                   tp->size = size;
 264
 265                   sprintf (name, "int%d", size * 8);
 266                   tp->virtual_type = init_type (TYPE_CODE_INT, size,
 267                                                 TYPE_FLAG_UNSIGNED, name,
 268                                                 NULL);
 269                 }
 270
 271               reg->ctype = tp->virtual_type;
 272             }
 273         }
 274       return reg->ctype;
 275     }
 276
 277   /* Invalid register number.  */
 278   internal_error (__FILE__, __LINE__, _("invalid register number %d"), regnum);
 279   return 0;
 280 }
 281
 282
 283 /* Returns the 'local' register number for stubs, dwarf2, etc.
 284    The debugging information enumerates registers starting from 0 for A0
 285    to n for An.  So, we only have to add the base number for A0.  */
 286
 287 static int
 288 xtensa_reg_to_regnum (int regnum)
 289 {
 290   int i;
 291
 292   if (regnum >= 0 && regnum < 16)
 293     return A0_BASE + regnum;
 294
 295   for (i = 0;
 296        i < gdbarch_num_regs (current_gdbarch)
 297            + gdbarch_num_pseudo_regs (current_gdbarch);
 298        i++)
 299     if (regnum == REGMAP[i].target_number)
 300       return i;
 301
 302   /* Invalid register number.  */
 303   internal_error (__FILE__, __LINE__,
 304                   _("invalid dwarf/stabs register number %d"), regnum);
 305   return 0;
 306 }
 307
 308
 309 /* Handle the special case of masked registers.  */
 310
 311 /* Write the bits of a masked register to the various registers that
 312    are combined into this register.  Only the masked areas of these
 313    registers are modified; the other fields are untouched.
 314    (Note: The size of masked registers is always less or equal 32 bits.)  */
 315
 316 static void
 317 xtensa_register_write_masked (struct regcache *regcache,
 318                               xtensa_register_t *reg, const gdb_byte *buffer)
 319 {
 320   unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
 321
 322   const xtensa_mask_t *mask = reg->mask;
 323
 324   int shift = 0;                /* Shift for next mask (mod 32).  */
 325   int start, size;              /* Start bit and size of current mask.  */
 326
 327   unsigned int *ptr = value;
 328   unsigned int regval, m, mem = 0;
 329
 330   int bytesize = reg->byte_size;
 331   int bitsize = bytesize * 8;
 332   int i, r;
 333
 334   DEBUGTRACE ("xtensa_register_write_masked ()\n");
 335
 336   /* Copy the masked register to host byte-order.  */
 337   if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
 338     for (i = 0; i < bytesize; i++)
 339       {
 340         mem >>= 8;
 341         mem |= (buffer[bytesize - i - 1] << 24);
 342         if ((i & 3) == 3)
 343           *ptr++ = mem;
 344       }
 345   else
 346     for (i = 0; i < bytesize; i++)
 347       {
 348         mem >>= 8;
 349         mem |= (buffer[i] << 24);
 350         if ((i & 3) == 3)
 351           *ptr++ = mem;
 352       }
 353
 354   /* We might have to shift the final value:
 355      bytesize & 3 == 0 -> nothing to do, we use the full 32 bits,
 356      bytesize & 3 == x -> shift (4-x) * 8.  */
 357
 358   *ptr = mem >> (((0 - bytesize) & 3) * 8);
 359   ptr = value;
 360   mem = *ptr;
 361
 362   /* Write the bits to the masked areas of the other registers.  */
 363   for (i = 0; i < mask->count; i++)
 364     {
 365       start = mask->mask[i].bit_start;
 366       size = mask->mask[i].bit_size;
 367       regval = mem >> shift;
 368
 369       if ((shift += size) > bitsize)
 370         error (_("size of all masks is larger than the register"));
 371
 372       if (shift >= 32)
 373         {
 374           mem = *(++ptr);
 375           shift -= 32;
 376           bitsize -= 32;
 377
 378           if (shift > 0)
 379             regval |= mem << (size - shift);
 380         }
 381
 382       /* Make sure we have a valid register.  */
 383       r = mask->mask[i].reg_num;
 384       if (r >= 0 && size > 0)
 385         {
 386           /* Don't overwrite the unmasked areas.  */
 387           ULONGEST old_val;
 388           regcache_cooked_read_unsigned (regcache, r, &old_val);
 389           m = 0xffffffff >> (32 - size) << start;
 390           regval <<= start;
 391           regval = (regval & m) | (old_val & ~m);
 392           regcache_cooked_write_unsigned (regcache, r, regval);
 393         }
 394     }
 395 }
 396
 397
 398 /* Read the masked areas of the registers and assemble it into a single
 399    register.  */
 400
 401 static void
 402 xtensa_register_read_masked (struct regcache *regcache,
 403                              xtensa_register_t *reg, gdb_byte *buffer)
 404 {
 405   unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
 406
 407   const xtensa_mask_t *mask = reg->mask;
 408
 409   int shift = 0;
 410   int start, size;
 411
 412   unsigned int *ptr = value;
 413   unsigned int regval, mem = 0;
 414
 415   int bytesize = reg->byte_size;
 416   int bitsize = bytesize * 8;
 417   int i;
 418
 419   DEBUGTRACE ("xtensa_register_read_masked (reg \"%s\", ...)\n",
 420               reg->name == 0 ? "" : reg->name);
 421
 422   /* Assemble the register from the masked areas of other registers.  */
 423   for (i = 0; i < mask->count; i++)
 424     {
 425       int r = mask->mask[i].reg_num;
 426       if (r >= 0)
 427         {
 428           ULONGEST val;
 429           regcache_cooked_read_unsigned (regcache, r, &val);
 430           regval = (unsigned int) val;
 431         }
 432       else
 433         regval = 0;
 434
 435       start = mask->mask[i].bit_start;
 436       size = mask->mask[i].bit_size;
 437
 438       regval >>= start;
 439
 440       if (size < 32)
 441         regval &= (0xffffffff >> (32 - size));
 442
 443       mem |= regval << shift;
 444
 445       if ((shift += size) > bitsize)
 446         error (_("size of all masks is larger than the register"));
 447
 448       if (shift >= 32)
 449         {
 450           *ptr++ = mem;
 451           bitsize -= 32;
 452           shift -= 32;
 453
 454           if (shift == 0)
 455             mem = 0;
 456           else
 457             mem = regval >> (size - shift);
 458         }
 459     }
 460
 461   if (shift > 0)
 462     *ptr = mem;
 463
 464   /* Copy value to target byte order.  */
 465   ptr = value;
 466   mem = *ptr;
 467
 468   if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
 469     for (i = 0; i < bytesize; i++)
 470       {
 471         if ((i & 3) == 0)
 472           mem = *ptr++;
 473         buffer[bytesize - i - 1] = mem & 0xff;
 474         mem >>= 8;
 475       }
 476   else
 477     for (i = 0; i < bytesize; i++)
 478       {
 479         if ((i & 3) == 0)
 480           mem = *ptr++;
 481         buffer[i] = mem & 0xff;
 482         mem >>= 8;
 483       }
 484 }
 485
 486
 487 /* Read pseudo registers.  */
 488
 489 static void
 490 xtensa_pseudo_register_read (struct gdbarch *gdbarch,
 491                              struct regcache *regcache,
 492                              int regnum,
 493                              gdb_byte *buffer)
 494 {
 495   DEBUGTRACE ("xtensa_pseudo_register_read (... regnum = %d (%s) ...)\n",
 496               regnum, xtensa_register_name (regnum));
 497
 498   /* Check if it is FP (renumber it in this case -> A0...A15).  */
 499   if (regnum == FP_ALIAS)
 500     error (_("trying to read FP"));
 501
 502   /* Read aliases a0..a15.  */
 503   if (regnum >= A0_REGNUM && regnum <= A15_REGNUM)
 504     {
 505       gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE);
 506
 507       regcache_raw_read (regcache, WB_REGNUM, buf);
 508       regnum = AREG_NUMBER (regnum, extract_unsigned_integer (buf, 4));
 509     }
 510
 511   /* We can always read 'regular' registers.  */
 512   if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
 513     regcache_raw_read (regcache, regnum, buffer);
 514
 515   /* Pseudo registers.  */
 516   else if (regnum >= 0
 517             && regnum < gdbarch_num_regs (current_gdbarch)
 518                         + gdbarch_num_pseudo_regs (current_gdbarch))
 519     {
 520       xtensa_register_t *reg = &REGMAP[regnum];
 521       xtensa_register_type_t type = reg->type;
 522       int flags = XTENSA_TARGET_FLAGS;
 523
 524       /* Can we read Unknown or Unmapped registers?  */
 525       if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown)
 526         {
 527           if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
 528             {
 529               warning (_("cannot read register %s"),
 530                        xtensa_register_name (regnum));
 531               return;
 532             }
 533         }
 534
 535       /* Some targets cannot read TIE register files.  */
 536       else if (type == xtRegisterTypeTieRegfile)
 537         {
 538           /* Use 'fetch' to get register?  */
 539           if (flags & xtTargetFlagsUseFetchStore)
 540             {
 541               warning (_("cannot read register"));
 542               return;
 543             }
 544
 545           /* On some targets (esp. simulators), we can always read the reg.  */
 546           else if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
 547             {
 548               warning (_("cannot read register"));
 549               return;
 550             }
 551         }
 552
 553       /* We can always read mapped registers.  */
 554       else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
 555         {
 556           xtensa_register_read_masked (regcache, reg, buffer);
 557           return;
 558         }
 559
 560       /* Assume that we can read the register.  */
 561       regcache_raw_read (regcache, regnum, buffer);
 562     }
 563
 564   else
 565     internal_error (__FILE__, __LINE__,
 566                     _("invalid register number %d"), regnum);
 567 }
 568
 569
 570 /* Write pseudo registers.  */
 571
 572 static void
 573 xtensa_pseudo_register_write (struct gdbarch *gdbarch,
 574                               struct regcache *regcache,
 575                               int regnum,
 576                               const gdb_byte *buffer)
 577 {
 578   DEBUGTRACE ("xtensa_pseudo_register_write (... regnum = %d (%s) ...)\n",
 579               regnum, xtensa_register_name (regnum));
 580
 581   /* Check if this is FP.  */
 582   if (regnum == FP_ALIAS)
 583     error (_("trying to write FP"));
 584
 585   /* Renumber register, if aliase a0..a15.  */
 586   if (regnum >= A0_REGNUM && regnum <= A15_REGNUM)
 587     {
 588       gdb_byte *buf = (gdb_byte *) alloca (MAX_REGISTER_SIZE);
 589       unsigned int wb;
 590
 591       regcache_raw_read (regcache, WB_REGNUM, buf);
 592       regnum = AREG_NUMBER (regnum, extract_unsigned_integer (buf, 4));
 593     }
 594
 595   /* We can always write 'core' registers.
 596      Note: We might have converted Ax->ARy.  */
 597   if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
 598     regcache_raw_write (regcache, regnum, buffer);
 599
 600   /* Pseudo registers.  */
 601   else if (regnum >= 0
 602            && regnum < gdbarch_num_regs (current_gdbarch)
 603                        + gdbarch_num_pseudo_regs (current_gdbarch))
 604     {
 605       xtensa_register_t *reg = &REGMAP[regnum];
 606       xtensa_register_type_t type = reg->type;
 607       int flags = XTENSA_TARGET_FLAGS;
 608
 609       /* On most targets, we can't write registers of type "Unknown"
 610          or "Unmapped".  */
 611       if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown)
 612         {
 613           if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
 614             {
 615               warning (_("cannot write register %s"),
 616                        xtensa_register_name (regnum));
 617               return;
 618             }
 619         }
 620
 621       /* Some targets cannot read TIE register files.  */
 622       else if (type == xtRegisterTypeTieRegfile)
 623         {
 624           /* Use 'store' to get register?  */
 625           if (flags & xtTargetFlagsUseFetchStore)
 626             {
 627               warning (_("cannot write register"));
 628               return;
 629             }
 630
 631           /* On some targets (esp. simulators), we can always write
 632              the register.  */
 633
 634           else if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
 635             {
 636               warning (_("cannot write register"));
 637               return;
 638             }
 639         }
 640
 641       /* We can always write mapped registers.  */
 642       else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
 643         {
 644           xtensa_register_write_masked (regcache, reg, buffer);
 645           return;
 646         }
 647
 648       /* Assume that we can write the register.  */
 649       regcache_raw_write (regcache, regnum, buffer);
 650     }
 651
 652   else
 653     internal_error (__FILE__, __LINE__,
 654                     _("invalid register number %d"), regnum);
 655 }
 656
 657
 658 static struct reggroup *xtensa_ar_reggroup;
 659 static struct reggroup *xtensa_user_reggroup;
 660 static struct reggroup *xtensa_vectra_reggroup;
 661
 662 static void
 663 xtensa_init_reggroups (void)
 664 {
 665   xtensa_ar_reggroup = reggroup_new ("ar", USER_REGGROUP);
 666   xtensa_user_reggroup = reggroup_new ("user", USER_REGGROUP);
 667   xtensa_vectra_reggroup = reggroup_new ("vectra", USER_REGGROUP);
 668 }
 669
 670
 671 static void
 672 xtensa_add_reggroups (struct gdbarch *gdbarch)
 673 {
 674   reggroup_add (gdbarch, all_reggroup);
 675   reggroup_add (gdbarch, save_reggroup);
 676   reggroup_add (gdbarch, restore_reggroup);
 677   reggroup_add (gdbarch, system_reggroup);
 678   reggroup_add (gdbarch, vector_reggroup);              /* vectra */
 679   reggroup_add (gdbarch, general_reggroup);             /* core */
 680   reggroup_add (gdbarch, float_reggroup);               /* float */
 681
 682   reggroup_add (gdbarch, xtensa_ar_reggroup);           /* ar */
 683   reggroup_add (gdbarch, xtensa_user_reggroup);         /* user */
 684   reggroup_add (gdbarch, xtensa_vectra_reggroup);       /* vectra */
 685 }
 686
 687
 688 #define SAVE_REST_FLAGS (XTENSA_REGISTER_FLAGS_READABLE \
 689                         | XTENSA_REGISTER_FLAGS_WRITABLE \
 690                         | XTENSA_REGISTER_FLAGS_VOLATILE)
 691
 692 #define SAVE_REST_VALID (XTENSA_REGISTER_FLAGS_READABLE \
 693                         | XTENSA_REGISTER_FLAGS_WRITABLE)
 694
 695 static int
 696 xtensa_register_reggroup_p (struct gdbarch *gdbarch,
 697                             int regnum,
 698                             struct reggroup *group)
 699 {
 700   xtensa_register_t* reg = &REGMAP[regnum];
 701   xtensa_register_type_t type = reg->type;
 702   xtensa_register_group_t rg = reg->group;
 703
 704   /* First, skip registers that are not visible to this target
 705      (unknown and unmapped registers when not using ISS).  */
 706
 707   if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown)
 708     return 0;
 709   if (group == all_reggroup)
 710     return 1;
 711   if (group == xtensa_ar_reggroup)
 712     return rg & xtRegisterGroupAddrReg;
 713   if (group == xtensa_user_reggroup)
 714     return rg & xtRegisterGroupUser;
 715   if (group == float_reggroup)
 716     return rg & xtRegisterGroupFloat;
 717   if (group == general_reggroup)
 718     return rg & xtRegisterGroupGeneral;
 719   if (group == float_reggroup)
 720     return rg & xtRegisterGroupFloat;
 721   if (group == system_reggroup)
 722     return rg & xtRegisterGroupState;
 723   if (group == vector_reggroup || group == xtensa_vectra_reggroup)
 724     return rg & xtRegisterGroupVectra;
 725   if (group == save_reggroup || group == restore_reggroup)
 726     return (regnum < gdbarch_num_regs (current_gdbarch)
 727             && (reg->flags & SAVE_REST_FLAGS) == SAVE_REST_VALID);
 728   else
 729     return 1;
 730 }
 731
 732
 733 /* CORE FILE SUPPORT */
 734
 735 /* Supply register REGNUM from the buffer specified by GREGS and LEN
 736    in the general-purpose register set REGSET to register cache
 737    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
 738
 739 static void
 740 xtensa_supply_gregset (const struct regset *regset,
 741                        struct regcache *rc,
 742                        int regnum,
 743                        const void *gregs,
 744                        size_t len)
 745 {
 746   const xtensa_elf_gregset_t *regs = gregs;
 747   int i;
 748
 749   DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...) \n", regnum);
 750
 751   if (regnum == PC_REGNUM || regnum == -1)
 752     regcache_raw_supply (rc, PC_REGNUM, (char *) &regs->pc);
 753   if (regnum == PS_REGNUM || regnum == -1)
 754     regcache_raw_supply (rc, PS_REGNUM, (char *) &regs->ps);
 755   if (regnum == WB_REGNUM || regnum == -1)
 756     regcache_raw_supply (rc, WB_REGNUM, (char *) &regs->windowbase);
 757   if (regnum == WS_REGNUM || regnum == -1)
 758     regcache_raw_supply (rc, WS_REGNUM, (char *) &regs->windowstart);
 759   if (regnum == LBEG_REGNUM || regnum == -1)
 760     regcache_raw_supply (rc, LBEG_REGNUM, (char *) &regs->lbeg);
 761   if (regnum == LEND_REGNUM || regnum == -1)
 762     regcache_raw_supply (rc, LEND_REGNUM, (char *) &regs->lend);
 763   if (regnum == LCOUNT_REGNUM || regnum == -1)
 764     regcache_raw_supply (rc, LCOUNT_REGNUM, (char *) &regs->lcount);
 765   if (regnum == SAR_REGNUM || regnum == -1)
 766     regcache_raw_supply (rc, SAR_REGNUM, (char *) &regs->sar);
 767   if (regnum == EXCCAUSE_REGNUM || regnum == -1)
 768     regcache_raw_supply (rc, EXCCAUSE_REGNUM, (char *) &regs->exccause);
 769   if (regnum == EXCVADDR_REGNUM || regnum == -1)
 770     regcache_raw_supply (rc, EXCVADDR_REGNUM, (char *) &regs->excvaddr);
 771   if (regnum >= AR_BASE && regnum < AR_BASE + NUM_AREGS)
 772     regcache_raw_supply (rc, regnum, (char *) &regs->ar[regnum - AR_BASE]);
 773   else if (regnum == -1)
 774     {
 775       for (i = 0; i < NUM_AREGS; ++i)
 776         regcache_raw_supply (rc, AR_BASE + i, (char *) &regs->ar[i]);
 777     }
 778 }
 779
 780
 781 /* Xtensa register set.  */
 782
 783 static struct regset
 784 xtensa_gregset =
 785 {
 786   NULL,
 787   xtensa_supply_gregset
 788 };
 789
 790
 791 /* Return the appropriate register set for the core section identified
 792    by SECT_NAME and SECT_SIZE.  */
 793
 794 static const struct regset *
 795 xtensa_regset_from_core_section (struct gdbarch *core_arch,
 796                                  const char *sect_name,
 797                                  size_t sect_size)
 798 {
 799   DEBUGTRACE ("xtensa_regset_from_core_section "
 800               "(..., sect_name==\"%s\", sect_size==%x) \n",
 801               sect_name, (int) sect_size);
 802
 803   if (strcmp (sect_name, ".reg") == 0
 804       && sect_size >= sizeof(xtensa_elf_gregset_t))
 805     return &xtensa_gregset;
 806
 807   return NULL;
 808 }
 809
 810
 811 /* F R A M E */
 812
 813 /* We currently don't support the call0-abi, so we have at max. 12 registers
 814    saved on the stack.  */
 815
 816 #define XTENSA_NUM_SAVED_AREGS 12
 817
 818 typedef struct xtensa_frame_cache
 819 {
 820   CORE_ADDR base;
 821   CORE_ADDR pc;
 822   CORE_ADDR ra;         /* The raw return address; use to compute call_inc.  */
 823   CORE_ADDR ps;
 824   int wb;               /* Base for this frame; -1 if not in regfile.  */
 825   int callsize;         /* Call size to next frame.  */
 826   int ws;
 827   CORE_ADDR aregs[XTENSA_NUM_SAVED_AREGS];
 828   CORE_ADDR prev_sp;
 829 } xtensa_frame_cache_t;
 830
 831
 832 static struct xtensa_frame_cache *
 833 xtensa_alloc_frame_cache (void)
 834 {
 835   xtensa_frame_cache_t *cache;
 836   int i;
 837
 838   DEBUGTRACE ("xtensa_alloc_frame_cache ()\n");
 839
 840   cache = FRAME_OBSTACK_ZALLOC (xtensa_frame_cache_t);
 841
 842   cache->base = 0;
 843   cache->pc = 0;
 844   cache->ra = 0;
 845   cache->wb = 0;
 846   cache->ps = 0;
 847   cache->callsize = -1;
 848   cache->prev_sp = 0;
 849
 850   for (i = 0; i < XTENSA_NUM_SAVED_AREGS; i++)
 851     cache->aregs[i] = -1;
 852
 853   return cache;
 854 }
 855
 856
 857 static CORE_ADDR
 858 xtensa_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
 859 {
 860   return address & ~15;
 861 }
 862
 863
 864 static CORE_ADDR
 865 xtensa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 866 {
 867   gdb_byte buf[8];
 868
 869   DEBUGTRACE ("xtensa_unwind_pc (next_frame = %p)\n", next_frame);
 870
 871   frame_unwind_register (next_frame, PC_REGNUM, buf);
 872
 873   DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int)
 874              extract_typed_address (buf, builtin_type_void_func_ptr));
 875
 876   return extract_typed_address (buf, builtin_type_void_func_ptr);
 877 }
 878
 879
 880 static struct frame_id
 881 xtensa_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
 882 {
 883   CORE_ADDR pc, fp;
 884   gdb_byte buf[4];
 885
 886   /* next_frame->prev is a dummy frame. Return a frame ID of that frame.  */
 887
 888   DEBUGTRACE ("xtensa_unwind_dummy_id ()\n");
 889
 890   pc = frame_pc_unwind (next_frame);
 891   frame_unwind_register (next_frame, A1_REGNUM, buf);
 892   fp = extract_unsigned_integer (buf, 4);
 893
 894   /* Make dummy frame ID unique by adding a constant.  */
 895   return frame_id_build (fp+SP_ALIGNMENT, pc);
 896 }
 897
 898
 899 static struct xtensa_frame_cache *
 900 xtensa_frame_cache (struct frame_info *next_frame, void **this_cache)
 901 {
 902   xtensa_frame_cache_t *cache;
 903   char buf[4];
 904   CORE_ADDR ra, wb, ws, pc, sp, ps;
 905   char op1;
 906
 907   DEBUGTRACE ("xtensa_frame_cache (next_frame %p, *this_cache %p)\n",
 908               next_frame, this_cache ? *this_cache : (void*)0xdeadbeef);
 909
 910   /* Already cached?  */
 911   if (*this_cache)
 912     return *this_cache;
 913
 914   /* Get pristine xtensa-frame.  */
 915   cache = xtensa_alloc_frame_cache ();
 916   *this_cache = cache;
 917
 918   /* Get windowbase, windowstart, ps, and pc.  */
 919   wb = frame_unwind_register_unsigned (next_frame, WB_REGNUM);
 920   ws = frame_unwind_register_unsigned (next_frame, WS_REGNUM);
 921   ps = frame_unwind_register_unsigned (next_frame, PS_REGNUM);
 922   pc = frame_unwind_register_unsigned (next_frame, PC_REGNUM);
 923
 924   op1 = read_memory_integer (pc, 1);
 925   if (XTENSA_IS_ENTRY (op1) || !windowing_enabled (ps))
 926     {
 927       int callinc = CALLINC (ps);
 928       ra = frame_unwind_register_unsigned (next_frame,
 929                                            A0_REGNUM + callinc * 4);
 930
 931       DEBUGINFO("[xtensa_frame_cache] 'entry' at 0x%08x\n (callinc = %d)",
 932                 (int)pc, callinc);
 933
 934       /* ENTRY hasn't been executed yet, therefore callsize is still 0.  */
 935       cache->callsize = 0;
 936       cache->wb = wb;
 937       cache->ws = ws;
 938       cache->prev_sp = frame_unwind_register_unsigned (next_frame, A1_REGNUM);
 939     }
 940   else
 941     {
 942       ra = frame_unwind_register_unsigned (next_frame, A0_REGNUM);
 943       cache->callsize = WINSIZE (ra);
 944       cache->wb = (wb - (cache->callsize / 4)) & ((NUM_AREGS / 4) - 1);
 945       cache->ws = ws & ~(1 << wb);
 946     }
 947
 948   cache->pc = ((frame_func_unwind (next_frame, NORMAL_FRAME) & 0xc0000000)
 949                | (ra & 0x3fffffff));
 950   cache->ps = (ps & ~PS_CALLINC_MASK) | ((WINSIZE(ra)/4) << PS_CALLINC_SHIFT);
 951
 952
 953   /* Note: We could also calculate the location on stack when we actually
 954      access the register.  However, this approach, saving the location
 955      in the cache frame, is probably easier to support the call0 ABI.  */
 956
 957   if (cache->ws == 0)
 958     {
 959       int i;
 960
 961       /* Set A0...A3.  */
 962       sp = frame_unwind_register_unsigned (next_frame, A1_REGNUM) - 16;
 963
 964       for (i = 0; i < 4; i++, sp += 4)
 965         {
 966           cache->aregs[i] = sp;
 967         }
 968
 969       if (cache->callsize > 4)
 970         {
 971           /* Set A4...A7/A11.  */
 972
 973           sp = (CORE_ADDR) read_memory_integer (sp - 12, 4);
 974           sp = (CORE_ADDR) read_memory_integer (sp - 12, 4);
 975           sp -= cache->callsize * 4;
 976
 977           for ( /* i=4  */ ; i < cache->callsize; i++, sp += 4)
 978             {
 979               cache->aregs[i] = sp;
 980             }
 981         }
 982     }
 983
 984   if (cache->prev_sp == 0)
 985     {
 986       if (cache->ws == 0)
 987         {
 988           /* Register window overflow already happened.
 989              We can read caller's frame SP from the proper spill loction.  */
 990           cache->prev_sp =
 991                   read_memory_integer (cache->aregs[1],
 992                                        register_size (current_gdbarch,
 993                                                       A1_REGNUM));
 994         }
 995       else
 996         {
 997           /* Read caller's frame SP directly from the previous window.  */
 998
 999           int regnum = AREG_NUMBER (A1_REGNUM, cache->wb);
1000
1001           cache->prev_sp = frame_unwind_register_unsigned (next_frame, regnum);
1002         }
1003     }
1004
1005   cache->base = frame_unwind_register_unsigned (next_frame,A1_REGNUM);
1006
1007   DEBUGINFO ("[xtensa_frame_cache] base 0x%08x, wb %d, "
1008              "ws 0x%08x, callsize %d, pc 0x%08x, ps 0x%08x, prev_sp 0x%08x\n",
1009              (unsigned int) cache->base, (unsigned int) cache->wb,
1010              cache->ws, cache->callsize, (unsigned int) cache->pc,
1011              (unsigned int) cache->ps, (unsigned int) cache->prev_sp);
1012
1013   return cache;
1014 }
1015
1016
1017 static void
1018 xtensa_frame_this_id (struct frame_info *next_frame,
1019                       void **this_cache,
1020                       struct frame_id *this_id)
1021 {
1022   struct xtensa_frame_cache *cache =
1023     xtensa_frame_cache (next_frame, this_cache);
1024
1025   DEBUGTRACE ("xtensa_frame_this_id (next %p, *this %p)\n",
1026               next_frame, *this_cache);
1027
1028   if (cache->prev_sp == 0)
1029     return;
1030
1031   (*this_id) = frame_id_build (cache->prev_sp, cache->pc);
1032 }
1033
1034
1035 static void
1036 xtensa_frame_prev_register (struct frame_info *next_frame,
1037                             void **this_cache,
1038                             int regnum,
1039                             int *optimizedp,
1040                             enum lval_type *lvalp,
1041                             CORE_ADDR *addrp,
1042                             int *realnump,
1043                             gdb_byte *valuep)
1044 {
1045   struct xtensa_frame_cache *cache =
1046     xtensa_frame_cache (next_frame, this_cache);
1047   CORE_ADDR saved_reg = 0;
1048   int done = 1;
1049
1050   DEBUGTRACE ("xtensa_frame_prev_register (next %p, "
1051               "*this %p, regnum %d (%s), ...)\n",
1052               next_frame,
1053               *this_cache ? *this_cache : 0, regnum,
1054               xtensa_register_name (regnum));
1055
1056   if (regnum == WS_REGNUM)
1057     {
1058       if (cache->ws != 0)
1059         saved_reg = cache->ws;
1060       else
1061         saved_reg = 1 << cache->wb;
1062     }
1063   else if (regnum == WB_REGNUM)
1064     saved_reg = cache->wb;
1065   else if (regnum == PC_REGNUM)
1066     saved_reg = cache->pc;
1067   else if (regnum == PS_REGNUM)
1068     saved_reg = cache->ps;
1069   else
1070     done = 0;
1071
1072   if (done)
1073     {
1074       *optimizedp = 0;
1075       *lvalp = not_lval;
1076       *addrp = 0;
1077       *realnump = -1;
1078       if (valuep)
1079         store_unsigned_integer (valuep, 4, saved_reg);
1080
1081       return;
1082     }
1083
1084   /* Convert Ax register numbers to ARx register numbers.  */
1085   if (regnum >= A0_REGNUM && regnum <= A15_REGNUM)
1086     regnum = AREG_NUMBER (regnum, cache->wb);
1087
1088   /* Check if ARx register has been saved to stack.  */
1089   if (regnum >= AR_BASE && regnum <= (AR_BASE + NUM_AREGS))
1090     {
1091       int areg = regnum - AR_BASE - (cache->wb * 4);
1092
1093       if (areg >= 0
1094           && areg < XTENSA_NUM_SAVED_AREGS
1095           && cache->aregs[areg] != -1)
1096         {
1097           *optimizedp = 0;
1098           *lvalp = lval_memory;
1099           *addrp = cache->aregs[areg];
1100           *realnump = -1;
1101
1102           if (valuep)
1103             read_memory (*addrp, valuep,
1104                          register_size (current_gdbarch, regnum));
1105
1106           DEBUGINFO ("[xtensa_frame_prev_register] register on stack\n");
1107           return;
1108         }
1109     }
1110
1111   /* Note: All other registers have been either saved to the dummy stack
1112      or are still alive in the processor.  */
1113
1114   *optimizedp = 0;
1115   *lvalp = lval_register;
1116   *addrp = 0;
1117   *realnump = regnum;
1118   if (valuep)
1119     frame_unwind_register (next_frame, (*realnump), valuep);
1120 }
1121
1122
1123 static const struct frame_unwind
1124 xtensa_frame_unwind =
1125 {
1126   NORMAL_FRAME,
1127   xtensa_frame_this_id,
1128   xtensa_frame_prev_register
1129 };
1130
1131 static const struct frame_unwind *
1132 xtensa_frame_sniffer (struct frame_info *next_frame)
1133 {
1134   return &xtensa_frame_unwind;
1135 }
1136
1137 static CORE_ADDR
1138 xtensa_frame_base_address (struct frame_info *next_frame, void **this_cache)
1139 {
1140   struct xtensa_frame_cache *cache =
1141     xtensa_frame_cache (next_frame, this_cache);
1142
1143   return cache->base;
1144 }
1145
1146 static const struct frame_base
1147 xtensa_frame_base =
1148 {
1149   &xtensa_frame_unwind,
1150   xtensa_frame_base_address,
1151   xtensa_frame_base_address,
1152   xtensa_frame_base_address
1153 };
1154
1155
1156 static void
1157 xtensa_extract_return_value (struct type *type,
1158                              struct regcache *regcache,
1159                              void *dst)
1160 {
1161   bfd_byte *valbuf = dst;
1162   int len = TYPE_LENGTH (type);
1163   ULONGEST pc, wb;
1164   int callsize, areg;
1165   int offset = 0;
1166
1167   DEBUGTRACE ("xtensa_extract_return_value (...)\n");
1168
1169   gdb_assert(len > 0);
1170
1171   /* First, we have to find the caller window in the register file.  */
1172   regcache_raw_read_unsigned (regcache, PC_REGNUM, &pc);
1173   callsize = extract_call_winsize (pc);
1174
1175   /* On Xtensa, we can return up to 4 words (or 2 when called by call12).  */
1176   if (len > (callsize > 8 ? 8 : 16))
1177     internal_error (__FILE__, __LINE__,
1178                     _("cannot extract return value of %d bytes long"), len);
1179
1180   /* Get the register offset of the return register (A2) in the caller
1181      window.  */
1182   regcache_raw_read_unsigned (regcache, WB_REGNUM, &wb);
1183   areg = AREG_NUMBER(A2_REGNUM + callsize, wb);
1184
1185   DEBUGINFO ("[xtensa_extract_return_value] areg %d len %d\n", areg, len);
1186
1187   if (len < 4 && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
1188     offset = 4 - len;
1189
1190   for (; len > 0; len -= 4, areg++, valbuf += 4)
1191     {
1192       if (len < 4)
1193         regcache_raw_read_part (regcache, areg, offset, len, valbuf);
1194       else
1195         regcache_raw_read (regcache, areg, valbuf);
1196     }
1197 }
1198
1199
1200 static void
1201 xtensa_store_return_value (struct type *type,
1202                            struct regcache *regcache,
1203                            const void *dst)
1204 {
1205   const bfd_byte *valbuf = dst;
1206   unsigned int areg;
1207   ULONGEST pc, wb;
1208   int callsize;
1209   int len = TYPE_LENGTH (type);
1210   int offset = 0;
1211
1212   DEBUGTRACE ("xtensa_store_return_value (...)\n");
1213
1214   regcache_raw_read_unsigned (regcache, WB_REGNUM, &wb);
1215   regcache_raw_read_unsigned (regcache, PC_REGNUM, &pc);
1216   callsize = extract_call_winsize (pc);
1217
1218   if (len > (callsize > 8 ? 8 : 16))
1219     internal_error (__FILE__, __LINE__,
1220                     _("unimplemented for this length: %d"),
1221                     TYPE_LENGTH (type));
1222
1223   DEBUGTRACE ("[xtensa_store_return_value] callsize %d wb %d\n",
1224               callsize, (int) wb);
1225
1226   if (len < 4 && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
1227     offset = 4 - len;
1228
1229   areg = AREG_NUMBER (A2_REGNUM + callsize, wb);
1230
1231   for (; len > 0; len -= 4, areg++, valbuf += 4)
1232     {
1233       if (len < 4)
1234         regcache_raw_write_part (regcache, areg, offset, len, valbuf);
1235       else
1236         regcache_raw_write (regcache, areg, valbuf);
1237     }
1238 }
1239
1240
1241 enum return_value_convention
1242 xtensa_return_value (struct gdbarch *gdbarch,
1243                      struct type *valtype,
1244                      struct regcache *regcache,
1245                      gdb_byte *readbuf,
1246                      const gdb_byte *writebuf)
1247 {
1248   /* Note: Structures up to 16 bytes are returned in registers.  */
1249
1250   int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
1251                         || TYPE_CODE (valtype) == TYPE_CODE_UNION
1252                         || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
1253                        && TYPE_LENGTH (valtype) > 16);
1254
1255   if (struct_return)
1256     return RETURN_VALUE_STRUCT_CONVENTION;
1257
1258   DEBUGTRACE ("xtensa_return_value(...)\n");
1259
1260   if (writebuf != NULL)
1261     {
1262       xtensa_store_return_value (valtype, regcache, writebuf);
1263     }
1264
1265   if (readbuf != NULL)
1266     {
1267       gdb_assert (!struct_return);
1268       xtensa_extract_return_value (valtype, regcache, readbuf);
1269     }
1270   return RETURN_VALUE_REGISTER_CONVENTION;
1271 }
1272
1273
1274 /* DUMMY FRAME */
1275
1276 static CORE_ADDR
1277 xtensa_push_dummy_call (struct gdbarch *gdbarch,
1278                         struct value *function,
1279                         struct regcache *regcache,
1280                         CORE_ADDR bp_addr,
1281                         int nargs,
1282                         struct value **args,
1283                         CORE_ADDR sp,
1284                         int struct_return,
1285                         CORE_ADDR struct_addr)
1286 {
1287   int i;
1288   int size, onstack_size;
1289   gdb_byte *buf = (gdb_byte *) alloca (16);
1290   CORE_ADDR ra, ps;
1291   struct argument_info
1292   {
1293     const bfd_byte *contents;
1294     int length;
1295     int onstack;                /* onstack == 0 => in reg */
1296     int align;                  /* alignment */
1297     union
1298     {
1299       int offset;               /* stack offset if on stack */
1300       int regno;                /* regno if in register */
1301     } u;
1302   };
1303
1304   struct argument_info *arg_info =
1305     (struct argument_info *) alloca (nargs * sizeof (struct argument_info));
1306
1307   CORE_ADDR osp = sp;
1308
1309   DEBUGTRACE ("xtensa_push_dummy_call (...)\n");
1310
1311   if (xtensa_debug_level > 3)
1312     {
1313       int i;
1314       DEBUGINFO ("[xtensa_push_dummy_call] nargs = %d\n", nargs);
1315       DEBUGINFO ("[xtensa_push_dummy_call] sp=0x%x, struct_return=%d, "
1316                  "struct_addr=0x%x\n",
1317                  (int) sp, (int) struct_return, (int) struct_addr);
1318
1319       for (i = 0; i < nargs; i++)
1320         {
1321           struct value *arg = args[i];
1322           struct type *arg_type = check_typedef (value_type (arg));
1323           fprintf_unfiltered (gdb_stdlog, "%2d: %p %3d ",
1324                               i, arg, TYPE_LENGTH (arg_type));
1325           switch (TYPE_CODE (arg_type))
1326             {
1327             case TYPE_CODE_INT:
1328               fprintf_unfiltered (gdb_stdlog, "int");
1329               break;
1330             case TYPE_CODE_STRUCT:
1331               fprintf_unfiltered (gdb_stdlog, "struct");
1332               break;
1333             default:
1334               fprintf_unfiltered (gdb_stdlog, "%3d", TYPE_CODE (arg_type));
1335               break;
1336             }
1337           fprintf_unfiltered (gdb_stdlog, " %p\n",
1338                               value_contents (arg));
1339         }
1340     }
1341
1342   /* First loop: collect information.
1343      Cast into type_long.  (This shouldn't happen often for C because
1344      GDB already does this earlier.)  It's possible that GDB could
1345      do it all the time but it's harmless to leave this code here.  */
1346
1347   size = 0;
1348   onstack_size = 0;
1349   i = 0;
1350
1351   if (struct_return)
1352     size = REGISTER_SIZE;
1353
1354   for (i = 0; i < nargs; i++)
1355     {
1356       struct argument_info *info = &arg_info[i];
1357       struct value *arg = args[i];
1358       struct type *arg_type = check_typedef (value_type (arg));
1359
1360       switch (TYPE_CODE (arg_type))
1361         {
1362         case TYPE_CODE_INT:
1363         case TYPE_CODE_BOOL:
1364         case TYPE_CODE_CHAR:
1365         case TYPE_CODE_RANGE:
1366         case TYPE_CODE_ENUM:
1367
1368           /* Cast argument to long if necessary as the mask does it too.  */
1369           if (TYPE_LENGTH (arg_type) < TYPE_LENGTH (builtin_type_long))
1370             {
1371               arg_type = builtin_type_long;
1372               arg = value_cast (arg_type, arg);
1373             }
1374           info->align = TYPE_LENGTH (builtin_type_long);
1375           break;
1376
1377         case TYPE_CODE_FLT:
1378
1379           /* Align doubles correctly.  */
1380           if (TYPE_LENGTH (arg_type) == TYPE_LENGTH (builtin_type_double))
1381             info->align = TYPE_LENGTH (builtin_type_double);
1382           else
1383             info->align = TYPE_LENGTH (builtin_type_long);
1384           break;
1385
1386         case TYPE_CODE_STRUCT:
1387         default:
1388           info->align = TYPE_LENGTH (builtin_type_long);
1389           break;
1390         }
1391       info->length = TYPE_LENGTH (arg_type);
1392       info->contents = value_contents (arg);
1393
1394       /* Align size and onstack_size.  */
1395       size = (size + info->align - 1) & ~(info->align - 1);
1396       onstack_size = (onstack_size + info->align - 1) & ~(info->align - 1);
1397
1398       if (size + info->length > REGISTER_SIZE * ARGS_NUM_REGS)
1399         {
1400           info->onstack = 1;
1401           info->u.offset = onstack_size;
1402           onstack_size += info->length;
1403         }
1404       else
1405         {
1406           info->onstack = 0;
1407           info->u.regno = ARGS_FIRST_REG + size / REGISTER_SIZE;
1408         }
1409       size += info->length;
1410     }
1411
1412   /* Adjust the stack pointer and align it.  */
1413   sp = align_down (sp - onstack_size, SP_ALIGNMENT);
1414
1415   /* Simulate MOVSP.  */
1416   if (sp != osp)
1417     {
1418       read_memory (osp - 16, buf, 16);
1419       write_memory (sp - 16, buf, 16);
1420     }
1421
1422   /* Second Loop: Load arguments.  */
1423
1424   if (struct_return)
1425     {
1426       store_unsigned_integer (buf, REGISTER_SIZE, struct_addr);
1427       regcache_cooked_write (regcache, ARGS_FIRST_REG, buf);
1428     }
1429
1430   for (i = 0; i < nargs; i++)
1431     {
1432       struct argument_info *info = &arg_info[i];
1433
1434       if (info->onstack)
1435         {
1436           int n = info->length;
1437           CORE_ADDR offset = sp + info->u.offset;
1438
1439           /* Odd-sized structs are aligned to the lower side of a memory
1440              word in big-endian mode and require a shift.  This only
1441              applies for structures smaller than one word.  */
1442
1443           if (n < REGISTER_SIZE
1444               && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
1445             offset += (REGISTER_SIZE - n);
1446
1447           write_memory (offset, info->contents, info->length);
1448
1449         }
1450       else
1451         {
1452           int n = info->length;
1453           const bfd_byte *cp = info->contents;
1454           int r = info->u.regno;
1455
1456           /* Odd-sized structs are aligned to the lower side of registers in
1457              big-endian mode and require a shift.  The odd-sized leftover will
1458              be at the end.  Note that this is only true for structures smaller
1459              than REGISTER_SIZE; for larger odd-sized structures the excess
1460              will be left-aligned in the register on both endiannesses.  */
1461
1462           if (n < REGISTER_SIZE
1463               && gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
1464             {
1465               ULONGEST v = extract_unsigned_integer (cp, REGISTER_SIZE);
1466               v = v >> ((REGISTER_SIZE - n) * TARGET_CHAR_BIT);
1467
1468               store_unsigned_integer (buf, REGISTER_SIZE, v);
1469               regcache_cooked_write (regcache, r, buf);
1470
1471               cp += REGISTER_SIZE;
1472               n -= REGISTER_SIZE;
1473               r++;
1474             }
1475           else
1476             while (n > 0)
1477               {
1478                 /* ULONGEST v = extract_unsigned_integer (cp, REGISTER_SIZE);*/
1479                 regcache_cooked_write (regcache, r, cp);
1480
1481                 /* regcache_cooked_write_unsigned (regcache, r, v); */
1482                 cp += REGISTER_SIZE;
1483                 n -= REGISTER_SIZE;
1484                 r++;
1485               }
1486         }
1487     }
1488
1489
1490   /* Set the return address of dummy frame to the dummy address.
1491      Note: The return address for the current function (in A0) is
1492      saved in the dummy frame, so we can savely overwrite A0 here.  */
1493
1494   ra = (bp_addr & 0x3fffffff) | 0x40000000;
1495   regcache_raw_read (regcache, PS_REGNUM, buf);
1496   ps = extract_unsigned_integer (buf, 4) & ~0x00030000;
1497   regcache_cooked_write_unsigned (regcache, A4_REGNUM, ra);
1498   regcache_cooked_write_unsigned (regcache, PS_REGNUM, ps | 0x00010000);
1499
1500   /* Set new stack pointer and return it.  */
1501   regcache_cooked_write_unsigned (regcache, A1_REGNUM, sp);
1502   /* Make dummy frame ID unique by adding a constant.  */
1503   return sp + SP_ALIGNMENT;
1504 }
1505
1506
1507 /* Return a breakpoint for the current location of PC.  We always use
1508    the density version if we have density instructions (regardless of the
1509    current instruction at PC), and use regular instructions otherwise.  */
1510
1511 #define BIG_BREAKPOINT { 0x00, 0x04, 0x00 }
1512 #define LITTLE_BREAKPOINT { 0x00, 0x40, 0x00 }
1513 #define DENSITY_BIG_BREAKPOINT { 0xd2, 0x0f }
1514 #define DENSITY_LITTLE_BREAKPOINT { 0x2d, 0xf0 }
1515
1516 const unsigned char *
1517 xtensa_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1518 {
1519   static unsigned char big_breakpoint[] = BIG_BREAKPOINT;
1520   static unsigned char little_breakpoint[] = LITTLE_BREAKPOINT;
1521   static unsigned char density_big_breakpoint[] = DENSITY_BIG_BREAKPOINT;
1522   static unsigned char density_little_breakpoint[] = DENSITY_LITTLE_BREAKPOINT;
1523
1524   DEBUGTRACE ("xtensa_breakpoint_from_pc (pc = 0x%08x)\n", (int) *pcptr);
1525
1526   if (ISA_USE_DENSITY_INSTRUCTIONS)
1527     {
1528       if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
1529         {
1530           *lenptr = sizeof (density_big_breakpoint);
1531           return density_big_breakpoint;
1532         }
1533       else
1534         {
1535           *lenptr = sizeof (density_little_breakpoint);
1536           return density_little_breakpoint;
1537         }
1538     }
1539   else
1540     {
1541       if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
1542         {
1543           *lenptr = sizeof (big_breakpoint);
1544           return big_breakpoint;
1545         }
1546       else
1547         {
1548           *lenptr = sizeof (little_breakpoint);
1549           return little_breakpoint;
1550         }
1551     }
1552 }
1553
1554
1555 /* Return the pc of the first real instruction.  We assume that this
1556    machine uses register windows.
1557
1558    If we have debug info ( line-number info, in particular ) we simply skip
1559    the code associated with the first function line effectively skipping
1560    the prologue code. It works even in cases like
1561
1562    int main()
1563    {    int local_var = 1;
1564         ....
1565    }
1566
1567    because, for this source code, both Xtensa compilers will generate two
1568    separate entries ( with the same line number ) in dwarf line-number
1569    section to make sure there is a boundary between the prologue code and
1570    the rest of the function.
1571
1572    If there is no debug info, we need to analyze the code. */
1573
1574 CORE_ADDR
1575 xtensa_skip_prologue (CORE_ADDR start_pc)
1576 {
1577   DEBUGTRACE ("xtensa_skip_prologue (start_pc = 0x%08x)\n", (int) start_pc);
1578
1579   if (ISA_USE_WINDOWED_REGISTERS)
1580     {
1581       unsigned char op1;
1582       struct symtab_and_line prologue_sal;
1583
1584       op1 = read_memory_integer (start_pc, 1);
1585       if (!XTENSA_IS_ENTRY (op1))
1586         return start_pc;
1587
1588       prologue_sal = find_pc_line (start_pc, 0);
1589       if (prologue_sal.line != 0)
1590         return prologue_sal.end;
1591       else
1592         return start_pc + XTENSA_ENTRY_LENGTH;
1593     }
1594   else
1595     {
1596       internal_error (__FILE__, __LINE__,
1597                       _("non-windowed configurations are not supported"));
1598       return start_pc;
1599     }
1600 }
1601
1602
1603 /* CONFIGURATION CHECK */
1604
1605 /* Verify the current configuration.  */
1606
1607 static void
1608 xtensa_verify_config (struct gdbarch *gdbarch)
1609 {
1610   struct ui_file *log;
1611   struct cleanup *cleanups;
1612   struct gdbarch_tdep *tdep;
1613   long dummy;
1614   char *buf;
1615
1616   tdep = gdbarch_tdep (gdbarch);
1617   log = mem_fileopen ();
1618   cleanups = make_cleanup_ui_file_delete (log);
1619
1620   /* Verify that we got a reasonable number of AREGS.  */
1621   if ((tdep->num_aregs & -tdep->num_aregs) != tdep->num_aregs)
1622     fprintf_unfiltered (log, "\n\tnum_aregs: Number of AR registers (%d) "
1623                         "is not a power of two!", tdep->num_aregs);
1624
1625   /* Verify that certain registers exist.  */
1626   if (tdep->pc_regnum == -1)
1627     fprintf_unfiltered (log, "\n\tpc_regnum: No PC register");
1628   if (tdep->ps_regnum == -1)
1629     fprintf_unfiltered (log, "\n\tps_regnum: No PS register");
1630   if (tdep->wb_regnum == -1)
1631     fprintf_unfiltered (log, "\n\twb_regnum: No WB register");
1632   if (tdep->ws_regnum == -1)
1633     fprintf_unfiltered (log, "\n\tws_regnum: No WS register");
1634   if (tdep->ar_base == -1)
1635     fprintf_unfiltered (log, "\n\tar_base: No AR registers");
1636   if (tdep->a0_base == -1)
1637     fprintf_unfiltered (log, "\n\ta0_base: No Ax registers");
1638
1639   buf = ui_file_xstrdup (log, &dummy);
1640   make_cleanup (xfree, buf);
1641   if (strlen (buf) > 0)
1642     internal_error (__FILE__, __LINE__,
1643                     _("the following are invalid: %s"), buf);
1644   do_cleanups (cleanups);
1645 }
1646
1647
1648 /* Module "constructor" function.  */
1649
1650 static struct gdbarch *
1651 xtensa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1652 {
1653   struct gdbarch_tdep *tdep;
1654   struct gdbarch *gdbarch;
1655   struct xtensa_abi_handler *abi_handler;
1656
1657   DEBUGTRACE ("gdbarch_init()\n");
1658
1659   /* We have to set the byte order before we call gdbarch_alloc.  */
1660   info.byte_order = xtensa_config_byte_order (&info);
1661
1662   tdep = xtensa_config_tdep (&info);
1663   gdbarch = gdbarch_alloc (&info, tdep);
1664
1665   /* Verify our configuration.  */
1666   xtensa_verify_config (gdbarch);
1667
1668   /* Pseudo-Register read/write  */
1669   set_gdbarch_pseudo_register_read (gdbarch, xtensa_pseudo_register_read);
1670   set_gdbarch_pseudo_register_write (gdbarch, xtensa_pseudo_register_write);
1671
1672   /* Set target information.  */
1673   set_gdbarch_num_regs (gdbarch, tdep->num_regs);
1674   set_gdbarch_num_pseudo_regs (gdbarch, tdep->num_pseudo_regs);
1675   set_gdbarch_sp_regnum (gdbarch, tdep->a0_base + 1);
1676   set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
1677   set_gdbarch_ps_regnum (gdbarch, tdep->ps_regnum);
1678
1679   /* Renumber registers for known formats (stab, dwarf, and dwarf2).  */
1680   set_gdbarch_stab_reg_to_regnum (gdbarch, xtensa_reg_to_regnum);
1681   set_gdbarch_dwarf_reg_to_regnum (gdbarch, xtensa_reg_to_regnum);
1682   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, xtensa_reg_to_regnum);
1683
1684   /* We provide our own function to get register information.  */
1685   set_gdbarch_register_name (gdbarch, xtensa_register_name);
1686   set_gdbarch_register_type (gdbarch, xtensa_register_type);
1687
1688   /* To call functions from GDB using dummy frame */
1689   set_gdbarch_push_dummy_call (gdbarch, xtensa_push_dummy_call);
1690
1691   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1692
1693   set_gdbarch_return_value (gdbarch, xtensa_return_value);
1694
1695   /* Advance PC across any prologue instructions to reach "real" code.  */
1696   set_gdbarch_skip_prologue (gdbarch, xtensa_skip_prologue);
1697
1698   /* Stack grows downward.  */
1699   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1700
1701   /* Set breakpoints.  */
1702   set_gdbarch_breakpoint_from_pc (gdbarch, xtensa_breakpoint_from_pc);
1703
1704   /* After breakpoint instruction or illegal instruction, pc still
1705      points at break instruction, so don't decrement.  */
1706   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1707
1708   /* We don't skip args.  */
1709   set_gdbarch_frame_args_skip (gdbarch, 0);
1710
1711   set_gdbarch_unwind_pc (gdbarch, xtensa_unwind_pc);
1712
1713   set_gdbarch_frame_align (gdbarch, xtensa_frame_align);
1714
1715   set_gdbarch_unwind_dummy_id (gdbarch, xtensa_unwind_dummy_id);
1716
1717   /* Frame handling.  */
1718   frame_base_set_default (gdbarch, &xtensa_frame_base);
1719   frame_unwind_append_sniffer (gdbarch, xtensa_frame_sniffer);
1720
1721   set_gdbarch_print_insn (gdbarch, print_insn_xtensa);
1722
1723   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
1724
1725   xtensa_add_reggroups (gdbarch);
1726   set_gdbarch_register_reggroup_p (gdbarch, xtensa_register_reggroup_p);
1727
1728   set_gdbarch_regset_from_core_section (gdbarch,
1729                                         xtensa_regset_from_core_section);
1730
1731   return gdbarch;
1732 }
1733
1734
1735 /* Dump xtensa tdep structure.  */
1736
1737 static void
1738 xtensa_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
1739 {
1740   error (_("xtensa_dump_tdep(): not implemented"));
1741 }
1742
1743
1744 void
1745 _initialize_xtensa_tdep (void)
1746 {
1747   struct cmd_list_element *c;
1748
1749   gdbarch_register (bfd_arch_xtensa, xtensa_gdbarch_init, xtensa_dump_tdep);
1750   xtensa_init_reggroups ();
1751
1752   add_setshow_zinteger_cmd ("xtensa",
1753                             class_maintenance,
1754                             &xtensa_debug_level, _("\
1755 Set Xtensa debugging."), _("\
1756 Show Xtensa debugging."), _("\
1757 When non-zero, Xtensa-specific debugging is enabled. \
1758 Can be 1, 2, 3, or 4 indicating the level of debugging."),
1759                             NULL,
1760                             NULL,
1761                             &setdebuglist, &showdebuglist);
1762 }