Delegate opcodes to select disassembler in GDB
[external/binutils.git] / gdb / xtensa-tdep.c
1 /* Target-dependent code for the Xtensa port of GDB, the GNU debugger.
2
3    Copyright (C) 2003-2017 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "frame.h"
22 #include "solib-svr4.h"
23 #include "symtab.h"
24 #include "symfile.h"
25 #include "objfiles.h"
26 #include "gdbtypes.h"
27 #include "gdbcore.h"
28 #include "value.h"
29 #include "dis-asm.h"
30 #include "inferior.h"
31 #include "osabi.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 "dwarf2.h"
39 #include "dwarf2-frame.h"
40 #include "dwarf2loc.h"
41 #include "frame-base.h"
42 #include "frame-unwind.h"
43
44 #include "arch-utils.h"
45 #include "gdbarch.h"
46 #include "remote.h"
47 #include "serial.h"
48
49 #include "command.h"
50 #include "gdbcmd.h"
51
52 #include "xtensa-isa.h"
53 #include "xtensa-tdep.h"
54 #include "xtensa-config.h"
55 #include <algorithm>
56
57
58 static unsigned int xtensa_debug_level = 0;
59
60 #define DEBUGWARN(args...) \
61   if (xtensa_debug_level > 0) \
62     fprintf_unfiltered (gdb_stdlog, "(warn ) " args)
63
64 #define DEBUGINFO(args...) \
65   if (xtensa_debug_level > 1) \
66     fprintf_unfiltered (gdb_stdlog, "(info ) " args)
67
68 #define DEBUGTRACE(args...) \
69   if (xtensa_debug_level > 2) \
70     fprintf_unfiltered (gdb_stdlog, "(trace) " args)
71
72 #define DEBUGVERB(args...) \
73   if (xtensa_debug_level > 3) \
74     fprintf_unfiltered (gdb_stdlog, "(verb ) " args)
75
76
77 /* According to the ABI, the SP must be aligned to 16-byte boundaries.  */
78 #define SP_ALIGNMENT 16
79
80
81 /* On Windowed ABI, we use a6 through a11 for passing arguments
82    to a function called by GDB because CALL4 is used.  */
83 #define ARGS_NUM_REGS           6
84 #define REGISTER_SIZE           4
85
86
87 /* Extract the call size from the return address or PS register.  */
88 #define PS_CALLINC_SHIFT        16
89 #define PS_CALLINC_MASK         0x00030000
90 #define CALLINC(ps)             (((ps) & PS_CALLINC_MASK) >> PS_CALLINC_SHIFT)
91 #define WINSIZE(ra)             (4 * (( (ra) >> 30) & 0x3))
92
93 /* On TX,  hardware can be configured without Exception Option.
94    There is no PS register in this case.  Inside XT-GDB,  let us treat
95    it as a virtual read-only register always holding the same value.  */
96 #define TX_PS                   0x20
97
98 /* ABI-independent macros.  */
99 #define ARG_NOF(gdbarch) \
100   (gdbarch_tdep (gdbarch)->call_abi \
101    == CallAbiCall0Only ? C0_NARGS : (ARGS_NUM_REGS))
102 #define ARG_1ST(gdbarch) \
103   (gdbarch_tdep (gdbarch)->call_abi  == CallAbiCall0Only \
104    ? (gdbarch_tdep (gdbarch)->a0_base + C0_ARGS) \
105    : (gdbarch_tdep (gdbarch)->a0_base + 6))
106
107 /* XTENSA_IS_ENTRY tests whether the first byte of an instruction
108    indicates that the instruction is an ENTRY instruction.  */
109
110 #define XTENSA_IS_ENTRY(gdbarch, op1) \
111   ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) \
112    ? ((op1) == 0x6c) : ((op1) == 0x36))
113
114 #define XTENSA_ENTRY_LENGTH     3
115
116 /* windowing_enabled() returns true, if windowing is enabled.
117    WOE must be set to 1; EXCM to 0.
118    Note: We assume that EXCM is always 0 for XEA1.  */
119
120 #define PS_WOE                  (1<<18)
121 #define PS_EXC                  (1<<4)
122
123 static int
124 windowing_enabled (struct gdbarch *gdbarch, unsigned int ps)
125 {
126   /* If we know CALL0 ABI is set explicitly,  say it is Call0.  */
127   if (gdbarch_tdep (gdbarch)->call_abi == CallAbiCall0Only)
128     return 0;
129
130   return ((ps & PS_EXC) == 0 && (ps & PS_WOE) != 0);
131 }
132
133 /* Convert a live A-register number to the corresponding AR-register
134    number.  */
135 static int
136 arreg_number (struct gdbarch *gdbarch, int a_regnum, ULONGEST wb)
137 {
138   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
139   int arreg;
140
141   arreg = a_regnum - tdep->a0_base;
142   arreg += (wb & ((tdep->num_aregs - 1) >> 2)) << WB_SHIFT;
143   arreg &= tdep->num_aregs - 1;
144
145   return arreg + tdep->ar_base;
146 }
147
148 /* Convert a live AR-register number to the corresponding A-register order
149    number in a range [0..15].  Return -1, if AR_REGNUM is out of WB window.  */
150 static int
151 areg_number (struct gdbarch *gdbarch, int ar_regnum, unsigned int wb)
152 {
153   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
154   int areg;
155
156   areg = ar_regnum - tdep->ar_base;
157   if (areg < 0 || areg >= tdep->num_aregs)
158     return -1;
159   areg = (areg - wb * 4) & (tdep->num_aregs - 1);
160   return (areg > 15) ? -1 : areg;
161 }
162
163 /* Read Xtensa register directly from the hardware.  */ 
164 static unsigned long
165 xtensa_read_register (int regnum)
166 {
167   ULONGEST value;
168
169   regcache_raw_read_unsigned (get_current_regcache (), regnum, &value);
170   return (unsigned long) value;
171 }
172
173 /* Write Xtensa register directly to the hardware.  */ 
174 static void
175 xtensa_write_register (int regnum, ULONGEST value)
176 {
177   regcache_raw_write_unsigned (get_current_regcache (), regnum, value);
178 }
179
180 /* Return the window size of the previous call to the function from which we
181    have just returned.
182
183    This function is used to extract the return value after a called function
184    has returned to the caller.  On Xtensa, the register that holds the return
185    value (from the perspective of the caller) depends on what call
186    instruction was used.  For now, we are assuming that the call instruction
187    precedes the current address, so we simply analyze the call instruction.
188    If we are in a dummy frame, we simply return 4 as we used a 'pseudo-call4'
189    method to call the inferior function.  */
190
191 static int
192 extract_call_winsize (struct gdbarch *gdbarch, CORE_ADDR pc)
193 {
194   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
195   int winsize = 4;
196   int insn;
197   gdb_byte buf[4];
198
199   DEBUGTRACE ("extract_call_winsize (pc = 0x%08x)\n", (int) pc);
200
201   /* Read the previous instruction (should be a call[x]{4|8|12}.  */
202   read_memory (pc-3, buf, 3);
203   insn = extract_unsigned_integer (buf, 3, byte_order);
204
205   /* Decode call instruction:
206      Little Endian
207        call{0,4,8,12}   OFFSET || {00,01,10,11} || 0101
208        callx{0,4,8,12}  OFFSET || 11 || {00,01,10,11} || 0000
209      Big Endian
210        call{0,4,8,12}   0101 || {00,01,10,11} || OFFSET
211        callx{0,4,8,12}  0000 || {00,01,10,11} || 11 || OFFSET.  */
212
213   if (byte_order == BFD_ENDIAN_LITTLE)
214     {
215       if (((insn & 0xf) == 0x5) || ((insn & 0xcf) == 0xc0))
216         winsize = (insn & 0x30) >> 2;   /* 0, 4, 8, 12.  */
217     }
218   else
219     {
220       if (((insn >> 20) == 0x5) || (((insn >> 16) & 0xf3) == 0x03))
221         winsize = (insn >> 16) & 0xc;   /* 0, 4, 8, 12.  */
222     }
223   return winsize;
224 }
225
226
227 /* REGISTER INFORMATION */
228
229 /* Find register by name.  */
230 static int
231 xtensa_find_register_by_name (struct gdbarch *gdbarch, const char *name)
232 {
233   int i;
234
235   for (i = 0; i < gdbarch_num_regs (gdbarch)
236          + gdbarch_num_pseudo_regs (gdbarch);
237        i++)
238
239     if (strcasecmp (gdbarch_tdep (gdbarch)->regmap[i].name, name) == 0)
240       return i;
241
242   return -1;
243 }
244
245 /* Returns the name of a register.  */
246 static const char *
247 xtensa_register_name (struct gdbarch *gdbarch, int regnum)
248 {
249   /* Return the name stored in the register map.  */
250   if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)
251                               + gdbarch_num_pseudo_regs (gdbarch))
252     return gdbarch_tdep (gdbarch)->regmap[regnum].name;
253
254   internal_error (__FILE__, __LINE__, _("invalid register %d"), regnum);
255   return 0;
256 }
257
258 /* Return the type of a register.  Create a new type, if necessary.  */
259
260 static struct type *
261 xtensa_register_type (struct gdbarch *gdbarch, int regnum)
262 {
263   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
264
265   /* Return signed integer for ARx and Ax registers.  */
266   if ((regnum >= tdep->ar_base
267        && regnum < tdep->ar_base + tdep->num_aregs)
268       || (regnum >= tdep->a0_base
269           && regnum < tdep->a0_base + 16))
270     return builtin_type (gdbarch)->builtin_int;
271
272   if (regnum == gdbarch_pc_regnum (gdbarch)
273       || regnum == tdep->a0_base + 1)
274     return builtin_type (gdbarch)->builtin_data_ptr;
275
276   /* Return the stored type for all other registers.  */
277   else if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch)
278                                    + gdbarch_num_pseudo_regs (gdbarch))
279     {
280       xtensa_register_t* reg = &tdep->regmap[regnum];
281
282       /* Set ctype for this register (only the first time).  */
283
284       if (reg->ctype == 0)
285         {
286           struct ctype_cache *tp;
287           int size = reg->byte_size;
288
289           /* We always use the memory representation,
290              even if the register width is smaller.  */
291           switch (size)
292             {
293             case 1:
294               reg->ctype = builtin_type (gdbarch)->builtin_uint8;
295               break;
296
297             case 2:
298               reg->ctype = builtin_type (gdbarch)->builtin_uint16;
299               break;
300
301             case 4:
302               reg->ctype = builtin_type (gdbarch)->builtin_uint32;
303               break;
304
305             case 8:
306               reg->ctype = builtin_type (gdbarch)->builtin_uint64;
307               break;
308
309             case 16:
310               reg->ctype = builtin_type (gdbarch)->builtin_uint128;
311               break;
312
313             default:
314               for (tp = tdep->type_entries; tp != NULL; tp = tp->next)
315                 if (tp->size == size)
316                   break;
317
318               if (tp == NULL)
319                 {
320                   char *name = xstrprintf ("int%d", size * 8);
321
322                   tp = XNEW (struct ctype_cache);
323                   tp->next = tdep->type_entries;
324                   tdep->type_entries = tp;
325                   tp->size = size;
326                   tp->virtual_type
327                     = arch_integer_type (gdbarch, size * 8, 1, name);
328                   xfree (name);
329                 }
330
331               reg->ctype = tp->virtual_type;
332             }
333         }
334       return reg->ctype;
335     }
336
337   internal_error (__FILE__, __LINE__, _("invalid register number %d"), regnum);
338   return 0;
339 }
340
341
342 /* Return the 'local' register number for stubs, dwarf2, etc.
343    The debugging information enumerates registers starting from 0 for A0
344    to n for An.  So, we only have to add the base number for A0.  */
345
346 static int
347 xtensa_reg_to_regnum (struct gdbarch *gdbarch, int regnum)
348 {
349   int i;
350
351   if (regnum >= 0 && regnum < 16)
352     return gdbarch_tdep (gdbarch)->a0_base + regnum;
353
354   for (i = 0;
355        i < gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
356        i++)
357     if (regnum == gdbarch_tdep (gdbarch)->regmap[i].target_number)
358       return i;
359
360   return -1;
361 }
362
363
364 /* Write the bits of a masked register to the various registers.
365    Only the masked areas of these registers are modified; the other
366    fields are untouched.  The size of masked registers is always less
367    than or equal to 32 bits.  */
368
369 static void
370 xtensa_register_write_masked (struct regcache *regcache,
371                               xtensa_register_t *reg, const gdb_byte *buffer)
372 {
373   unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
374   const xtensa_mask_t *mask = reg->mask;
375
376   int shift = 0;                /* Shift for next mask (mod 32).  */
377   int start, size;              /* Start bit and size of current mask.  */
378
379   unsigned int *ptr = value;
380   unsigned int regval, m, mem = 0;
381
382   int bytesize = reg->byte_size;
383   int bitsize = bytesize * 8;
384   int i, r;
385
386   DEBUGTRACE ("xtensa_register_write_masked ()\n");
387
388   /* Copy the masked register to host byte-order.  */
389   if (gdbarch_byte_order (get_regcache_arch (regcache)) == BFD_ENDIAN_BIG)
390     for (i = 0; i < bytesize; i++)
391       {
392         mem >>= 8;
393         mem |= (buffer[bytesize - i - 1] << 24);
394         if ((i & 3) == 3)
395           *ptr++ = mem;
396       }
397   else
398     for (i = 0; i < bytesize; i++)
399       {
400         mem >>= 8;
401         mem |= (buffer[i] << 24);
402         if ((i & 3) == 3)
403           *ptr++ = mem;
404       }
405
406   /* We might have to shift the final value:
407      bytesize & 3 == 0 -> nothing to do, we use the full 32 bits,
408      bytesize & 3 == x -> shift (4-x) * 8.  */
409
410   *ptr = mem >> (((0 - bytesize) & 3) * 8);
411   ptr = value;
412   mem = *ptr;
413
414   /* Write the bits to the masked areas of the other registers.  */
415   for (i = 0; i < mask->count; i++)
416     {
417       start = mask->mask[i].bit_start;
418       size = mask->mask[i].bit_size;
419       regval = mem >> shift;
420
421       if ((shift += size) > bitsize)
422         error (_("size of all masks is larger than the register"));
423
424       if (shift >= 32)
425         {
426           mem = *(++ptr);
427           shift -= 32;
428           bitsize -= 32;
429
430           if (shift > 0)
431             regval |= mem << (size - shift);
432         }
433
434       /* Make sure we have a valid register.  */
435       r = mask->mask[i].reg_num;
436       if (r >= 0 && size > 0)
437         {
438           /* Don't overwrite the unmasked areas.  */
439           ULONGEST old_val;
440           regcache_cooked_read_unsigned (regcache, r, &old_val);
441           m = 0xffffffff >> (32 - size) << start;
442           regval <<= start;
443           regval = (regval & m) | (old_val & ~m);
444           regcache_cooked_write_unsigned (regcache, r, regval);
445         }
446     }
447 }
448
449
450 /* Read a tie state or mapped registers.  Read the masked areas
451    of the registers and assemble them into a single value.  */
452
453 static enum register_status
454 xtensa_register_read_masked (struct regcache *regcache,
455                              xtensa_register_t *reg, gdb_byte *buffer)
456 {
457   unsigned int value[(MAX_REGISTER_SIZE + 3) / 4];
458   const xtensa_mask_t *mask = reg->mask;
459
460   int shift = 0;
461   int start, size;
462
463   unsigned int *ptr = value;
464   unsigned int regval, mem = 0;
465
466   int bytesize = reg->byte_size;
467   int bitsize = bytesize * 8;
468   int i;
469
470   DEBUGTRACE ("xtensa_register_read_masked (reg \"%s\", ...)\n",
471               reg->name == 0 ? "" : reg->name);
472
473   /* Assemble the register from the masked areas of other registers.  */
474   for (i = 0; i < mask->count; i++)
475     {
476       int r = mask->mask[i].reg_num;
477       if (r >= 0)
478         {
479           enum register_status status;
480           ULONGEST val;
481
482           status = regcache_cooked_read_unsigned (regcache, r, &val);
483           if (status != REG_VALID)
484             return status;
485           regval = (unsigned int) val;
486         }
487       else
488         regval = 0;
489
490       start = mask->mask[i].bit_start;
491       size = mask->mask[i].bit_size;
492
493       regval >>= start;
494
495       if (size < 32)
496         regval &= (0xffffffff >> (32 - size));
497
498       mem |= regval << shift;
499
500       if ((shift += size) > bitsize)
501         error (_("size of all masks is larger than the register"));
502
503       if (shift >= 32)
504         {
505           *ptr++ = mem;
506           bitsize -= 32;
507           shift -= 32;
508
509           if (shift == 0)
510             mem = 0;
511           else
512             mem = regval >> (size - shift);
513         }
514     }
515
516   if (shift > 0)
517     *ptr = mem;
518
519   /* Copy value to target byte order.  */
520   ptr = value;
521   mem = *ptr;
522
523   if (gdbarch_byte_order (get_regcache_arch (regcache)) == BFD_ENDIAN_BIG)
524     for (i = 0; i < bytesize; i++)
525       {
526         if ((i & 3) == 0)
527           mem = *ptr++;
528         buffer[bytesize - i - 1] = mem & 0xff;
529         mem >>= 8;
530       }
531   else
532     for (i = 0; i < bytesize; i++)
533       {
534         if ((i & 3) == 0)
535           mem = *ptr++;
536         buffer[i] = mem & 0xff;
537         mem >>= 8;
538       }
539
540   return REG_VALID;
541 }
542
543
544 /* Read pseudo registers.  */
545
546 static enum register_status
547 xtensa_pseudo_register_read (struct gdbarch *gdbarch,
548                              struct regcache *regcache,
549                              int regnum,
550                              gdb_byte *buffer)
551 {
552   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
553
554   DEBUGTRACE ("xtensa_pseudo_register_read (... regnum = %d (%s) ...)\n",
555               regnum, xtensa_register_name (gdbarch, regnum));
556
557   /* Read aliases a0..a15, if this is a Windowed ABI.  */
558   if (gdbarch_tdep (gdbarch)->isa_use_windowed_registers
559       && (regnum >= gdbarch_tdep (gdbarch)->a0_base)
560       && (regnum <= gdbarch_tdep (gdbarch)->a0_base + 15))
561     {
562       ULONGEST value;
563       enum register_status status;
564
565       status = regcache_raw_read_unsigned (regcache,
566                                            gdbarch_tdep (gdbarch)->wb_regnum,
567                                            &value);
568       if (status != REG_VALID)
569         return status;
570       regnum = arreg_number (gdbarch, regnum, value);
571     }
572
573   /* We can always read non-pseudo registers.  */
574   if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
575     return regcache_raw_read (regcache, regnum, buffer);
576
577   /* We have to find out how to deal with priveleged registers.
578      Let's treat them as pseudo-registers, but we cannot read/write them.  */
579      
580   else if (gdbarch_tdep (gdbarch)->call_abi == CallAbiCall0Only
581            || regnum < gdbarch_tdep (gdbarch)->a0_base)
582     {
583       buffer[0] = (gdb_byte)0;
584       buffer[1] = (gdb_byte)0;
585       buffer[2] = (gdb_byte)0;
586       buffer[3] = (gdb_byte)0;
587       return REG_VALID;
588     }
589   /* Pseudo registers.  */
590   else if (regnum >= 0
591             && regnum < gdbarch_num_regs (gdbarch)
592                         + gdbarch_num_pseudo_regs (gdbarch))
593     {
594       xtensa_register_t *reg = &gdbarch_tdep (gdbarch)->regmap[regnum];
595       xtensa_register_type_t type = reg->type;
596       int flags = gdbarch_tdep (gdbarch)->target_flags;
597
598       /* We cannot read Unknown or Unmapped registers.  */
599       if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown)
600         {
601           if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
602             {
603               warning (_("cannot read register %s"),
604                        xtensa_register_name (gdbarch, regnum));
605               return REG_VALID;
606             }
607         }
608
609       /* Some targets cannot read TIE register files.  */
610       else if (type == xtRegisterTypeTieRegfile)
611         {
612           /* Use 'fetch' to get register?  */
613           if (flags & xtTargetFlagsUseFetchStore)
614             {
615               warning (_("cannot read register"));
616               return REG_VALID;
617             }
618
619           /* On some targets (esp. simulators), we can always read the reg.  */
620           else if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
621             {
622               warning (_("cannot read register"));
623               return REG_VALID;
624             }
625         }
626
627       /* We can always read mapped registers.  */
628       else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
629         return xtensa_register_read_masked (regcache, reg, buffer);
630
631       /* Assume that we can read the register.  */
632       return regcache_raw_read (regcache, regnum, buffer);
633     }
634   else
635     internal_error (__FILE__, __LINE__,
636                     _("invalid register number %d"), regnum);
637 }
638
639
640 /* Write pseudo registers.  */
641
642 static void
643 xtensa_pseudo_register_write (struct gdbarch *gdbarch,
644                               struct regcache *regcache,
645                               int regnum,
646                               const gdb_byte *buffer)
647 {
648   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
649
650   DEBUGTRACE ("xtensa_pseudo_register_write (... regnum = %d (%s) ...)\n",
651               regnum, xtensa_register_name (gdbarch, regnum));
652
653   /* Renumber register, if aliase a0..a15 on Windowed ABI.  */
654   if (gdbarch_tdep (gdbarch)->isa_use_windowed_registers
655       && (regnum >= gdbarch_tdep (gdbarch)->a0_base)
656       && (regnum <= gdbarch_tdep (gdbarch)->a0_base + 15))
657     {
658       ULONGEST value;
659       regcache_raw_read_unsigned (regcache,
660                                   gdbarch_tdep (gdbarch)->wb_regnum, &value);
661       regnum = arreg_number (gdbarch, regnum, value);
662     }
663
664   /* We can always write 'core' registers.
665      Note: We might have converted Ax->ARy.  */
666   if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
667     regcache_raw_write (regcache, regnum, buffer);
668
669   /* We have to find out how to deal with priveleged registers.
670      Let's treat them as pseudo-registers, but we cannot read/write them.  */
671
672   else if (regnum < gdbarch_tdep (gdbarch)->a0_base)
673     {
674       return;
675     }
676   /* Pseudo registers.  */
677   else if (regnum >= 0
678            && regnum < gdbarch_num_regs (gdbarch)
679                        + gdbarch_num_pseudo_regs (gdbarch))
680     {
681       xtensa_register_t *reg = &gdbarch_tdep (gdbarch)->regmap[regnum];
682       xtensa_register_type_t type = reg->type;
683       int flags = gdbarch_tdep (gdbarch)->target_flags;
684
685       /* On most targets, we cannot write registers
686          of type "Unknown" or "Unmapped".  */
687       if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown)
688         {
689           if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
690             {
691               warning (_("cannot write register %s"),
692                        xtensa_register_name (gdbarch, regnum));
693               return;
694             }
695         }
696
697       /* Some targets cannot read TIE register files.  */
698       else if (type == xtRegisterTypeTieRegfile)
699         {
700           /* Use 'store' to get register?  */
701           if (flags & xtTargetFlagsUseFetchStore)
702             {
703               warning (_("cannot write register"));
704               return;
705             }
706
707           /* On some targets (esp. simulators), we can always write
708              the register.  */
709           else if ((flags & xtTargetFlagsNonVisibleRegs) == 0)
710             {
711               warning (_("cannot write register"));
712               return;
713             }
714         }
715
716       /* We can always write mapped registers.  */
717       else if (type == xtRegisterTypeMapped || type == xtRegisterTypeTieState)
718         {
719           xtensa_register_write_masked (regcache, reg, buffer);
720           return;
721         }
722
723       /* Assume that we can write the register.  */
724       regcache_raw_write (regcache, regnum, buffer);
725     }
726   else
727     internal_error (__FILE__, __LINE__,
728                     _("invalid register number %d"), regnum);
729 }
730
731 static struct reggroup *xtensa_ar_reggroup;
732 static struct reggroup *xtensa_user_reggroup;
733 static struct reggroup *xtensa_vectra_reggroup;
734 static struct reggroup *xtensa_cp[XTENSA_MAX_COPROCESSOR];
735
736 static void
737 xtensa_init_reggroups (void)
738 {
739   int i;
740   char cpname[] = "cp0";
741
742   xtensa_ar_reggroup = reggroup_new ("ar", USER_REGGROUP);
743   xtensa_user_reggroup = reggroup_new ("user", USER_REGGROUP);
744   xtensa_vectra_reggroup = reggroup_new ("vectra", USER_REGGROUP);
745
746   for (i = 0; i < XTENSA_MAX_COPROCESSOR; i++)
747     {
748       cpname[2] = '0' + i;
749       xtensa_cp[i] = reggroup_new (cpname, USER_REGGROUP);
750     }
751 }
752
753 static void
754 xtensa_add_reggroups (struct gdbarch *gdbarch)
755 {
756   int i;
757
758   /* Predefined groups.  */
759   reggroup_add (gdbarch, all_reggroup);
760   reggroup_add (gdbarch, save_reggroup);
761   reggroup_add (gdbarch, restore_reggroup);
762   reggroup_add (gdbarch, system_reggroup);
763   reggroup_add (gdbarch, vector_reggroup);
764   reggroup_add (gdbarch, general_reggroup);
765   reggroup_add (gdbarch, float_reggroup);
766
767   /* Xtensa-specific groups.  */
768   reggroup_add (gdbarch, xtensa_ar_reggroup);
769   reggroup_add (gdbarch, xtensa_user_reggroup);
770   reggroup_add (gdbarch, xtensa_vectra_reggroup);
771
772   for (i = 0; i < XTENSA_MAX_COPROCESSOR; i++)
773     reggroup_add (gdbarch, xtensa_cp[i]);
774 }
775
776 static int 
777 xtensa_coprocessor_register_group (struct reggroup *group)
778 {
779   int i;
780
781   for (i = 0; i < XTENSA_MAX_COPROCESSOR; i++)
782     if (group == xtensa_cp[i])
783       return i;
784
785   return -1;
786 }
787
788 #define SAVE_REST_FLAGS (XTENSA_REGISTER_FLAGS_READABLE \
789                         | XTENSA_REGISTER_FLAGS_WRITABLE \
790                         | XTENSA_REGISTER_FLAGS_VOLATILE)
791
792 #define SAVE_REST_VALID (XTENSA_REGISTER_FLAGS_READABLE \
793                         | XTENSA_REGISTER_FLAGS_WRITABLE)
794
795 static int
796 xtensa_register_reggroup_p (struct gdbarch *gdbarch,
797                             int regnum,
798                             struct reggroup *group)
799 {
800   xtensa_register_t* reg = &gdbarch_tdep (gdbarch)->regmap[regnum];
801   xtensa_register_type_t type = reg->type;
802   xtensa_register_group_t rg = reg->group;
803   int cp_number;
804
805   if (group == save_reggroup)
806     /* Every single register should be included into the list of registers
807        to be watched for changes while using -data-list-changed-registers.  */
808     return 1;
809
810   /* First, skip registers that are not visible to this target
811      (unknown and unmapped registers when not using ISS).  */
812
813   if (type == xtRegisterTypeUnmapped || type == xtRegisterTypeUnknown)
814     return 0;
815   if (group == all_reggroup)
816     return 1;
817   if (group == xtensa_ar_reggroup)
818     return rg & xtRegisterGroupAddrReg;
819   if (group == xtensa_user_reggroup)
820     return rg & xtRegisterGroupUser;
821   if (group == float_reggroup)
822     return rg & xtRegisterGroupFloat;
823   if (group == general_reggroup)
824     return rg & xtRegisterGroupGeneral;
825   if (group == system_reggroup)
826     return rg & xtRegisterGroupState;
827   if (group == vector_reggroup || group == xtensa_vectra_reggroup)
828     return rg & xtRegisterGroupVectra;
829   if (group == restore_reggroup)
830     return (regnum < gdbarch_num_regs (gdbarch)
831             && (reg->flags & SAVE_REST_FLAGS) == SAVE_REST_VALID);
832   cp_number = xtensa_coprocessor_register_group (group);
833   if (cp_number >= 0)
834     return rg & (xtRegisterGroupCP0 << cp_number);
835   else
836     return 1;
837 }
838
839
840 /* Supply register REGNUM from the buffer specified by GREGS and LEN
841    in the general-purpose register set REGSET to register cache
842    REGCACHE.  If REGNUM is -1 do this for all registers in REGSET.  */
843
844 static void
845 xtensa_supply_gregset (const struct regset *regset,
846                        struct regcache *rc,
847                        int regnum,
848                        const void *gregs,
849                        size_t len)
850 {
851   const xtensa_elf_gregset_t *regs = (const xtensa_elf_gregset_t *) gregs;
852   struct gdbarch *gdbarch = get_regcache_arch (rc);
853   int i;
854
855   DEBUGTRACE ("xtensa_supply_gregset (..., regnum==%d, ...)\n", regnum);
856
857   if (regnum == gdbarch_pc_regnum (gdbarch) || regnum == -1)
858     regcache_raw_supply (rc, gdbarch_pc_regnum (gdbarch), (char *) &regs->pc);
859   if (regnum == gdbarch_ps_regnum (gdbarch) || regnum == -1)
860     regcache_raw_supply (rc, gdbarch_ps_regnum (gdbarch), (char *) &regs->ps);
861   if (regnum == gdbarch_tdep (gdbarch)->wb_regnum || regnum == -1)
862     regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->wb_regnum,
863                          (char *) &regs->windowbase);
864   if (regnum == gdbarch_tdep (gdbarch)->ws_regnum || regnum == -1)
865     regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ws_regnum,
866                          (char *) &regs->windowstart);
867   if (regnum == gdbarch_tdep (gdbarch)->lbeg_regnum || regnum == -1)
868     regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lbeg_regnum,
869                          (char *) &regs->lbeg);
870   if (regnum == gdbarch_tdep (gdbarch)->lend_regnum || regnum == -1)
871     regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lend_regnum,
872                          (char *) &regs->lend);
873   if (regnum == gdbarch_tdep (gdbarch)->lcount_regnum || regnum == -1)
874     regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->lcount_regnum,
875                          (char *) &regs->lcount);
876   if (regnum == gdbarch_tdep (gdbarch)->sar_regnum || regnum == -1)
877     regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->sar_regnum,
878                          (char *) &regs->sar);
879   if (regnum >=gdbarch_tdep (gdbarch)->ar_base
880       && regnum < gdbarch_tdep (gdbarch)->ar_base
881                     + gdbarch_tdep (gdbarch)->num_aregs)
882     regcache_raw_supply (rc, regnum,
883                          (char *) &regs->ar[regnum - gdbarch_tdep
884                            (gdbarch)->ar_base]);
885   else if (regnum == -1)
886     {
887       for (i = 0; i < gdbarch_tdep (gdbarch)->num_aregs; ++i)
888         regcache_raw_supply (rc, gdbarch_tdep (gdbarch)->ar_base + i,
889                              (char *) &regs->ar[i]);
890     }
891 }
892
893
894 /* Xtensa register set.  */
895
896 static struct regset
897 xtensa_gregset =
898 {
899   NULL,
900   xtensa_supply_gregset
901 };
902
903
904 /* Iterate over supported core file register note sections. */
905
906 static void
907 xtensa_iterate_over_regset_sections (struct gdbarch *gdbarch,
908                                      iterate_over_regset_sections_cb *cb,
909                                      void *cb_data,
910                                      const struct regcache *regcache)
911 {
912   DEBUGTRACE ("xtensa_iterate_over_regset_sections\n");
913
914   cb (".reg", sizeof (xtensa_elf_gregset_t), &xtensa_gregset,
915       NULL, cb_data);
916 }
917
918
919 /* Handling frames.  */
920
921 /* Number of registers to save in case of Windowed ABI.  */
922 #define XTENSA_NUM_SAVED_AREGS          12
923
924 /* Frame cache part for Windowed ABI.  */
925 typedef struct xtensa_windowed_frame_cache
926 {
927   int wb;               /* WINDOWBASE of the previous frame.  */
928   int callsize;         /* Call size of this frame.  */
929   int ws;               /* WINDOWSTART of the previous frame.  It keeps track of
930                            life windows only.  If there is no bit set for the
931                            window,  that means it had been already spilled
932                            because of window overflow.  */
933
934    /* Addresses of spilled A-registers.
935       AREGS[i] == -1, if corresponding AR is alive.  */
936   CORE_ADDR aregs[XTENSA_NUM_SAVED_AREGS];
937 } xtensa_windowed_frame_cache_t;
938
939 /* Call0 ABI Definitions.  */
940
941 #define C0_MAXOPDS  3   /* Maximum number of operands for prologue
942                            analysis.  */
943 #define C0_CLESV   12   /* Callee-saved registers are here and up.  */
944 #define C0_SP       1   /* Register used as SP.  */
945 #define C0_FP      15   /* Register used as FP.  */
946 #define C0_RA       0   /* Register used as return address.  */
947 #define C0_ARGS     2   /* Register used as first arg/retval.  */
948 #define C0_NARGS    6   /* Number of A-regs for args/retvals.  */
949
950 /* Each element of xtensa_call0_frame_cache.c0_rt[] describes for each
951    A-register where the current content of the reg came from (in terms
952    of an original reg and a constant).  Negative values of c0_rt[n].fp_reg
953    mean that the orignal content of the register was saved to the stack.
954    c0_rt[n].fr.ofs is NOT the offset from the frame base because we don't 
955    know where SP will end up until the entire prologue has been analyzed.  */
956
957 #define C0_CONST   -1   /* fr_reg value if register contains a constant.  */
958 #define C0_INEXP   -2   /* fr_reg value if inexpressible as reg + offset.  */
959 #define C0_NOSTK   -1   /* to_stk value if register has not been stored.  */
960
961 extern xtensa_isa xtensa_default_isa;
962
963 typedef struct xtensa_c0reg
964 {
965   int fr_reg;  /* original register from which register content
966                   is derived, or C0_CONST, or C0_INEXP.  */
967   int fr_ofs;  /* constant offset from reg, or immediate value.  */
968   int to_stk;  /* offset from original SP to register (4-byte aligned),
969                   or C0_NOSTK if register has not been saved.  */
970 } xtensa_c0reg_t;
971
972 /* Frame cache part for Call0 ABI.  */
973 typedef struct xtensa_call0_frame_cache
974 {
975   int c0_frmsz;                    /* Stack frame size.  */
976   int c0_hasfp;                    /* Current frame uses frame pointer.  */
977   int fp_regnum;                   /* A-register used as FP.  */
978   int c0_fp;                       /* Actual value of frame pointer.  */
979   int c0_fpalign;                  /* Dinamic adjustment for the stack
980                                       pointer. It's an AND mask. Zero,
981                                       if alignment was not adjusted.  */
982   int c0_old_sp;                   /* In case of dynamic adjustment, it is
983                                       a register holding unaligned sp. 
984                                       C0_INEXP, when undefined.  */
985   int c0_sp_ofs;                   /* If "c0_old_sp" was spilled it's a
986                                       stack offset. C0_NOSTK otherwise.  */
987                                            
988   xtensa_c0reg_t c0_rt[C0_NREGS];  /* Register tracking information.  */
989 } xtensa_call0_frame_cache_t;
990
991 typedef struct xtensa_frame_cache
992 {
993   CORE_ADDR base;       /* Stack pointer of this frame.  */
994   CORE_ADDR pc;         /* PC of this frame at the function entry point.  */
995   CORE_ADDR ra;         /* The raw return address of this frame.  */
996   CORE_ADDR ps;         /* The PS register of the previous (older) frame.  */
997   CORE_ADDR prev_sp;    /* Stack Pointer of the previous (older) frame.  */
998   int call0;            /* It's a call0 framework (else windowed).  */
999   union
1000     {
1001       xtensa_windowed_frame_cache_t     wd;     /* call0 == false.  */
1002       xtensa_call0_frame_cache_t        c0;     /* call0 == true.  */
1003     };
1004 } xtensa_frame_cache_t;
1005
1006
1007 static struct xtensa_frame_cache *
1008 xtensa_alloc_frame_cache (int windowed)
1009 {
1010   xtensa_frame_cache_t *cache;
1011   int i;
1012
1013   DEBUGTRACE ("xtensa_alloc_frame_cache ()\n");
1014
1015   cache = FRAME_OBSTACK_ZALLOC (xtensa_frame_cache_t);
1016
1017   cache->base = 0;
1018   cache->pc = 0;
1019   cache->ra = 0;
1020   cache->ps = 0;
1021   cache->prev_sp = 0;
1022   cache->call0 = !windowed;
1023   if (cache->call0)
1024     {
1025       cache->c0.c0_frmsz  = -1;
1026       cache->c0.c0_hasfp  =  0;
1027       cache->c0.fp_regnum = -1;
1028       cache->c0.c0_fp     = -1;
1029       cache->c0.c0_fpalign =  0;
1030       cache->c0.c0_old_sp  =  C0_INEXP;
1031       cache->c0.c0_sp_ofs  =  C0_NOSTK;
1032
1033       for (i = 0; i < C0_NREGS; i++)
1034         {
1035           cache->c0.c0_rt[i].fr_reg = i;
1036           cache->c0.c0_rt[i].fr_ofs = 0;
1037           cache->c0.c0_rt[i].to_stk = C0_NOSTK;
1038         }
1039     }
1040   else
1041     {
1042       cache->wd.wb = 0;
1043       cache->wd.ws = 0;
1044       cache->wd.callsize = -1;
1045
1046       for (i = 0; i < XTENSA_NUM_SAVED_AREGS; i++)
1047         cache->wd.aregs[i] = -1;
1048     }
1049   return cache;
1050 }
1051
1052
1053 static CORE_ADDR
1054 xtensa_frame_align (struct gdbarch *gdbarch, CORE_ADDR address)
1055 {
1056   return address & ~15;
1057 }
1058
1059
1060 static CORE_ADDR
1061 xtensa_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1062 {
1063   gdb_byte buf[8];
1064   CORE_ADDR pc;
1065
1066   DEBUGTRACE ("xtensa_unwind_pc (next_frame = %s)\n", 
1067                 host_address_to_string (next_frame));
1068
1069   frame_unwind_register (next_frame, gdbarch_pc_regnum (gdbarch), buf);
1070   pc = extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
1071
1072   DEBUGINFO ("[xtensa_unwind_pc] pc = 0x%08x\n", (unsigned int) pc);
1073
1074   return pc;
1075 }
1076
1077
1078 static struct frame_id
1079 xtensa_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1080 {
1081   CORE_ADDR pc, fp;
1082
1083   /* THIS-FRAME is a dummy frame.  Return a frame ID of that frame.  */
1084
1085   pc = get_frame_pc (this_frame);
1086   fp = get_frame_register_unsigned
1087          (this_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
1088
1089   /* Make dummy frame ID unique by adding a constant.  */
1090   return frame_id_build (fp + SP_ALIGNMENT, pc);
1091 }
1092
1093 /* Returns true,  if instruction to execute next is unique to Xtensa Window
1094    Interrupt Handlers.  It can only be one of L32E,  S32E,  RFWO,  or RFWU.  */
1095
1096 static int
1097 xtensa_window_interrupt_insn (struct gdbarch *gdbarch, CORE_ADDR pc)
1098 {
1099   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1100   unsigned int insn = read_memory_integer (pc, 4, byte_order);
1101   unsigned int code;
1102
1103   if (byte_order == BFD_ENDIAN_BIG)
1104     {
1105       /* Check, if this is L32E or S32E.  */
1106       code = insn & 0xf000ff00;
1107       if ((code == 0x00009000) || (code == 0x00009400))
1108         return 1;
1109       /* Check, if this is RFWU or RFWO.  */
1110       code = insn & 0xffffff00;
1111       return ((code == 0x00430000) || (code == 0x00530000));
1112     }
1113   else
1114     {
1115       /* Check, if this is L32E or S32E.  */
1116       code = insn & 0x00ff000f;
1117       if ((code == 0x090000) || (code == 0x490000))
1118         return 1;
1119       /* Check, if this is RFWU or RFWO.  */
1120       code = insn & 0x00ffffff;
1121       return ((code == 0x00003400) || (code == 0x00003500));
1122     }
1123 }
1124
1125 /* Returns the best guess about which register is a frame pointer
1126    for the function containing CURRENT_PC.  */
1127
1128 #define XTENSA_ISA_BSZ          32              /* Instruction buffer size.  */
1129 #define XTENSA_ISA_BADPC        ((CORE_ADDR)0)  /* Bad PC value.  */
1130
1131 static unsigned int
1132 xtensa_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR current_pc)
1133 {
1134 #define RETURN_FP goto done
1135
1136   unsigned int fp_regnum = gdbarch_tdep (gdbarch)->a0_base + 1;
1137   CORE_ADDR start_addr;
1138   xtensa_isa isa;
1139   xtensa_insnbuf ins, slot;
1140   gdb_byte ibuf[XTENSA_ISA_BSZ];
1141   CORE_ADDR ia, bt, ba;
1142   xtensa_format ifmt;
1143   int ilen, islots, is;
1144   xtensa_opcode opc;
1145   const char *opcname;
1146
1147   find_pc_partial_function (current_pc, NULL, &start_addr, NULL);
1148   if (start_addr == 0)
1149     return fp_regnum;
1150
1151   isa = xtensa_default_isa;
1152   gdb_assert (XTENSA_ISA_BSZ >= xtensa_isa_maxlength (isa));
1153   ins = xtensa_insnbuf_alloc (isa);
1154   slot = xtensa_insnbuf_alloc (isa);
1155   ba = 0;
1156
1157   for (ia = start_addr, bt = ia; ia < current_pc ; ia += ilen)
1158     {
1159       if (ia + xtensa_isa_maxlength (isa) > bt)
1160         {
1161           ba = ia;
1162           bt = (ba + XTENSA_ISA_BSZ) < current_pc
1163             ? ba + XTENSA_ISA_BSZ : current_pc;
1164           if (target_read_memory (ba, ibuf, bt - ba) != 0)
1165             RETURN_FP;
1166         }
1167
1168       xtensa_insnbuf_from_chars (isa, ins, &ibuf[ia-ba], 0);
1169       ifmt = xtensa_format_decode (isa, ins);
1170       if (ifmt == XTENSA_UNDEFINED)
1171         RETURN_FP;
1172       ilen = xtensa_format_length (isa, ifmt);
1173       if (ilen == XTENSA_UNDEFINED)
1174         RETURN_FP;
1175       islots = xtensa_format_num_slots (isa, ifmt);
1176       if (islots == XTENSA_UNDEFINED)
1177         RETURN_FP;
1178       
1179       for (is = 0; is < islots; ++is)
1180         {
1181           if (xtensa_format_get_slot (isa, ifmt, is, ins, slot))
1182             RETURN_FP;
1183           
1184           opc = xtensa_opcode_decode (isa, ifmt, is, slot);
1185           if (opc == XTENSA_UNDEFINED) 
1186             RETURN_FP;
1187           
1188           opcname = xtensa_opcode_name (isa, opc);
1189
1190           if (strcasecmp (opcname, "mov.n") == 0
1191               || strcasecmp (opcname, "or") == 0)
1192             {
1193               unsigned int register_operand;
1194
1195               /* Possible candidate for setting frame pointer
1196                  from A1.  This is what we are looking for.  */
1197
1198               if (xtensa_operand_get_field (isa, opc, 1, ifmt, 
1199                                             is, slot, &register_operand) != 0)
1200                 RETURN_FP;
1201               if (xtensa_operand_decode (isa, opc, 1, &register_operand) != 0)
1202                 RETURN_FP;
1203               if (register_operand == 1)  /* Mov{.n} FP A1.  */
1204                 {
1205                   if (xtensa_operand_get_field (isa, opc, 0, ifmt, is, slot, 
1206                                                 &register_operand) != 0)
1207                     RETURN_FP;
1208                   if (xtensa_operand_decode (isa, opc, 0,
1209                                              &register_operand) != 0)
1210                     RETURN_FP;
1211
1212                   fp_regnum
1213                     = gdbarch_tdep (gdbarch)->a0_base + register_operand;
1214                   RETURN_FP;
1215                 }
1216             }
1217
1218           if (
1219               /* We have problems decoding the memory.  */
1220               opcname == NULL 
1221               || strcasecmp (opcname, "ill") == 0
1222               || strcasecmp (opcname, "ill.n") == 0
1223               /* Hit planted breakpoint.  */
1224               || strcasecmp (opcname, "break") == 0
1225               || strcasecmp (opcname, "break.n") == 0
1226               /* Flow control instructions finish prologue.  */
1227               || xtensa_opcode_is_branch (isa, opc) > 0
1228               || xtensa_opcode_is_jump   (isa, opc) > 0
1229               || xtensa_opcode_is_loop   (isa, opc) > 0
1230               || xtensa_opcode_is_call   (isa, opc) > 0
1231               || strcasecmp (opcname, "simcall") == 0
1232               || strcasecmp (opcname, "syscall") == 0)
1233             /* Can not continue analysis.  */
1234             RETURN_FP;
1235         }
1236     }
1237 done:
1238   xtensa_insnbuf_free(isa, slot);
1239   xtensa_insnbuf_free(isa, ins);
1240   return fp_regnum;
1241 }
1242
1243 /* The key values to identify the frame using "cache" are 
1244
1245         cache->base    = SP (or best guess about FP) of this frame;
1246         cache->pc      = entry-PC (entry point of the frame function);
1247         cache->prev_sp = SP of the previous frame.  */
1248
1249 static void
1250 call0_frame_cache (struct frame_info *this_frame,
1251                    xtensa_frame_cache_t *cache, CORE_ADDR pc);
1252
1253 static void
1254 xtensa_window_interrupt_frame_cache (struct frame_info *this_frame,
1255                                      xtensa_frame_cache_t *cache,
1256                                      CORE_ADDR pc);
1257
1258 static struct xtensa_frame_cache *
1259 xtensa_frame_cache (struct frame_info *this_frame, void **this_cache)
1260 {
1261   xtensa_frame_cache_t *cache;
1262   CORE_ADDR ra, wb, ws, pc, sp, ps;
1263   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1264   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1265   unsigned int fp_regnum;
1266   int  windowed, ps_regnum;
1267
1268   if (*this_cache)
1269     return (struct xtensa_frame_cache *) *this_cache;
1270
1271   pc = get_frame_register_unsigned (this_frame, gdbarch_pc_regnum (gdbarch));
1272   ps_regnum = gdbarch_ps_regnum (gdbarch);
1273   ps = (ps_regnum >= 0
1274         ? get_frame_register_unsigned (this_frame, ps_regnum) : TX_PS);
1275
1276   windowed = windowing_enabled (gdbarch, ps);
1277
1278   /* Get pristine xtensa-frame.  */
1279   cache = xtensa_alloc_frame_cache (windowed);
1280   *this_cache = cache;
1281
1282   if (windowed)
1283     {
1284       LONGEST op1;
1285
1286       /* Get WINDOWBASE, WINDOWSTART, and PS registers.  */
1287       wb = get_frame_register_unsigned (this_frame, 
1288                                         gdbarch_tdep (gdbarch)->wb_regnum);
1289       ws = get_frame_register_unsigned (this_frame,
1290                                         gdbarch_tdep (gdbarch)->ws_regnum);
1291
1292       if (safe_read_memory_integer (pc, 1, byte_order, &op1)
1293           && XTENSA_IS_ENTRY (gdbarch, op1))
1294         {
1295           int callinc = CALLINC (ps);
1296           ra = get_frame_register_unsigned
1297             (this_frame, gdbarch_tdep (gdbarch)->a0_base + callinc * 4);
1298           
1299           /* ENTRY hasn't been executed yet, therefore callsize is still 0.  */
1300           cache->wd.callsize = 0;
1301           cache->wd.wb = wb;
1302           cache->wd.ws = ws;
1303           cache->prev_sp = get_frame_register_unsigned
1304                              (this_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
1305
1306           /* This only can be the outermost frame since we are
1307              just about to execute ENTRY.  SP hasn't been set yet.
1308              We can assume any frame size, because it does not
1309              matter, and, let's fake frame base in cache.  */
1310           cache->base = cache->prev_sp - 16;
1311
1312           cache->pc = pc;
1313           cache->ra = (cache->pc & 0xc0000000) | (ra & 0x3fffffff);
1314           cache->ps = (ps & ~PS_CALLINC_MASK)
1315             | ((WINSIZE(ra)/4) << PS_CALLINC_SHIFT);
1316
1317           return cache;
1318         }
1319       else
1320         {
1321           fp_regnum = xtensa_scan_prologue (gdbarch, pc);
1322           ra = get_frame_register_unsigned (this_frame,
1323                                             gdbarch_tdep (gdbarch)->a0_base);
1324           cache->wd.callsize = WINSIZE (ra);
1325           cache->wd.wb = (wb - cache->wd.callsize / 4)
1326                           & (gdbarch_tdep (gdbarch)->num_aregs / 4 - 1);
1327           cache->wd.ws = ws & ~(1 << wb);
1328
1329           cache->pc = get_frame_func (this_frame);
1330           cache->ra = (pc & 0xc0000000) | (ra & 0x3fffffff);
1331           cache->ps = (ps & ~PS_CALLINC_MASK)
1332             | ((WINSIZE(ra)/4) << PS_CALLINC_SHIFT);
1333         }
1334
1335       if (cache->wd.ws == 0)
1336         {
1337           int i;
1338
1339           /* Set A0...A3.  */
1340           sp = get_frame_register_unsigned
1341             (this_frame, gdbarch_tdep (gdbarch)->a0_base + 1) - 16;
1342           
1343           for (i = 0; i < 4; i++, sp += 4)
1344             {
1345               cache->wd.aregs[i] = sp;
1346             }
1347
1348           if (cache->wd.callsize > 4)
1349             {
1350               /* Set A4...A7/A11.  */
1351               /* Get the SP of the frame previous to the previous one.
1352                  To achieve this, we have to dereference SP twice.  */
1353               sp = (CORE_ADDR) read_memory_integer (sp - 12, 4, byte_order);
1354               sp = (CORE_ADDR) read_memory_integer (sp - 12, 4, byte_order);
1355               sp -= cache->wd.callsize * 4;
1356
1357               for ( i = 4; i < cache->wd.callsize; i++, sp += 4)
1358                 {
1359                   cache->wd.aregs[i] = sp;
1360                 }
1361             }
1362         }
1363
1364       if ((cache->prev_sp == 0) && ( ra != 0 ))
1365         /* If RA is equal to 0 this frame is an outermost frame.  Leave
1366            cache->prev_sp unchanged marking the boundary of the frame stack.  */
1367         {
1368           if ((cache->wd.ws & (1 << cache->wd.wb)) == 0)
1369             {
1370               /* Register window overflow already happened.
1371                  We can read caller's SP from the proper spill loction.  */
1372               sp = get_frame_register_unsigned
1373                 (this_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
1374               cache->prev_sp = read_memory_integer (sp - 12, 4, byte_order);
1375             }
1376           else
1377             {
1378               /* Read caller's frame SP directly from the previous window.  */
1379               int regnum = arreg_number
1380                              (gdbarch, gdbarch_tdep (gdbarch)->a0_base + 1,
1381                               cache->wd.wb);
1382
1383               cache->prev_sp = xtensa_read_register (regnum);
1384             }
1385         }
1386     }
1387   else if (xtensa_window_interrupt_insn (gdbarch, pc))
1388     {
1389       /* Execution stopped inside Xtensa Window Interrupt Handler.  */
1390
1391       xtensa_window_interrupt_frame_cache (this_frame, cache, pc);
1392       /* Everything was set already,  including cache->base.  */
1393       return cache;
1394     }
1395   else  /* Call0 framework.  */
1396     {
1397       call0_frame_cache (this_frame, cache, pc);  
1398       fp_regnum = cache->c0.fp_regnum;
1399     }
1400
1401   cache->base = get_frame_register_unsigned (this_frame, fp_regnum);
1402
1403   return cache;
1404 }
1405
1406 static int xtensa_session_once_reported = 1;
1407
1408 /* Report a problem with prologue analysis while doing backtracing.
1409    But, do it only once to avoid annoyng repeated messages.  */
1410
1411 static void
1412 warning_once (void)
1413 {
1414   if (xtensa_session_once_reported == 0)
1415     warning (_("\
1416 \nUnrecognised function prologue. Stack trace cannot be resolved. \
1417 This message will not be repeated in this session.\n"));
1418
1419   xtensa_session_once_reported = 1;
1420 }
1421
1422
1423 static void
1424 xtensa_frame_this_id (struct frame_info *this_frame,
1425                       void **this_cache,
1426                       struct frame_id *this_id)
1427 {
1428   struct xtensa_frame_cache *cache =
1429     xtensa_frame_cache (this_frame, this_cache);
1430
1431   if (cache->prev_sp == 0)
1432     return;
1433
1434   (*this_id) = frame_id_build (cache->prev_sp, cache->pc);
1435 }
1436
1437 static struct value *
1438 xtensa_frame_prev_register (struct frame_info *this_frame,
1439                             void **this_cache,
1440                             int regnum)
1441 {
1442   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1443   struct xtensa_frame_cache *cache;
1444   ULONGEST saved_reg = 0;
1445   int done = 1;
1446
1447   if (*this_cache == NULL)
1448     *this_cache = xtensa_frame_cache (this_frame, this_cache);
1449   cache = (struct xtensa_frame_cache *) *this_cache;
1450
1451   if (regnum ==gdbarch_pc_regnum (gdbarch))
1452     saved_reg = cache->ra;
1453   else if (regnum == gdbarch_tdep (gdbarch)->a0_base + 1)
1454     saved_reg = cache->prev_sp;
1455   else if (!cache->call0)
1456     {
1457       if (regnum == gdbarch_tdep (gdbarch)->ws_regnum)
1458         saved_reg = cache->wd.ws;
1459       else if (regnum == gdbarch_tdep (gdbarch)->wb_regnum)
1460         saved_reg = cache->wd.wb;
1461       else if (regnum == gdbarch_ps_regnum (gdbarch))
1462         saved_reg = cache->ps;
1463       else
1464         done = 0;
1465     }
1466   else
1467     done = 0;
1468
1469   if (done)
1470     return frame_unwind_got_constant (this_frame, regnum, saved_reg);
1471
1472   if (!cache->call0) /* Windowed ABI.  */
1473     {
1474       /* Convert A-register numbers to AR-register numbers,
1475          if we deal with A-register.  */
1476       if (regnum >= gdbarch_tdep (gdbarch)->a0_base
1477           && regnum <= gdbarch_tdep (gdbarch)->a0_base + 15)
1478         regnum = arreg_number (gdbarch, regnum, cache->wd.wb);
1479
1480       /* Check, if we deal with AR-register saved on stack.  */
1481       if (regnum >= gdbarch_tdep (gdbarch)->ar_base
1482           && regnum <= (gdbarch_tdep (gdbarch)->ar_base
1483                          + gdbarch_tdep (gdbarch)->num_aregs))
1484         {
1485           int areg = areg_number (gdbarch, regnum, cache->wd.wb);
1486
1487           if (areg >= 0
1488               && areg < XTENSA_NUM_SAVED_AREGS
1489               && cache->wd.aregs[areg] != -1)
1490             return frame_unwind_got_memory (this_frame, regnum,
1491                                             cache->wd.aregs[areg]);
1492         }
1493     }
1494   else /* Call0 ABI.  */
1495     {
1496       int reg = (regnum >= gdbarch_tdep (gdbarch)->ar_base
1497                 && regnum <= (gdbarch_tdep (gdbarch)->ar_base
1498                                + C0_NREGS))
1499                   ? regnum - gdbarch_tdep (gdbarch)->ar_base : regnum;
1500
1501       if (reg < C0_NREGS)
1502         {
1503           CORE_ADDR spe;
1504           int stkofs;
1505
1506           /* If register was saved in the prologue, retrieve it.  */
1507           stkofs = cache->c0.c0_rt[reg].to_stk;
1508           if (stkofs != C0_NOSTK)
1509             {
1510               /* Determine SP on entry based on FP.  */
1511               spe = cache->c0.c0_fp
1512                 - cache->c0.c0_rt[cache->c0.fp_regnum].fr_ofs;
1513
1514               return frame_unwind_got_memory (this_frame, regnum,
1515                                               spe + stkofs);
1516             }
1517         }
1518     }
1519
1520   /* All other registers have been either saved to
1521      the stack or are still alive in the processor.  */
1522
1523   return frame_unwind_got_register (this_frame, regnum, regnum);
1524 }
1525
1526
1527 static const struct frame_unwind
1528 xtensa_unwind =
1529 {
1530   NORMAL_FRAME,
1531   default_frame_unwind_stop_reason,
1532   xtensa_frame_this_id,
1533   xtensa_frame_prev_register,
1534   NULL,
1535   default_frame_sniffer
1536 };
1537
1538 static CORE_ADDR
1539 xtensa_frame_base_address (struct frame_info *this_frame, void **this_cache)
1540 {
1541   struct xtensa_frame_cache *cache =
1542     xtensa_frame_cache (this_frame, this_cache);
1543
1544   return cache->base;
1545 }
1546
1547 static const struct frame_base
1548 xtensa_frame_base =
1549 {
1550   &xtensa_unwind,
1551   xtensa_frame_base_address,
1552   xtensa_frame_base_address,
1553   xtensa_frame_base_address
1554 };
1555
1556
1557 static void
1558 xtensa_extract_return_value (struct type *type,
1559                              struct regcache *regcache,
1560                              void *dst)
1561 {
1562   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1563   bfd_byte *valbuf = (bfd_byte *) dst;
1564   int len = TYPE_LENGTH (type);
1565   ULONGEST pc, wb;
1566   int callsize, areg;
1567   int offset = 0;
1568
1569   DEBUGTRACE ("xtensa_extract_return_value (...)\n");
1570
1571   gdb_assert(len > 0);
1572
1573   if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
1574     {
1575       /* First, we have to find the caller window in the register file.  */
1576       regcache_raw_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch), &pc);
1577       callsize = extract_call_winsize (gdbarch, pc);
1578
1579       /* On Xtensa, we can return up to 4 words (or 2 for call12).  */
1580       if (len > (callsize > 8 ? 8 : 16))
1581         internal_error (__FILE__, __LINE__,
1582                         _("cannot extract return value of %d bytes long"),
1583                         len);
1584
1585       /* Get the register offset of the return
1586          register (A2) in the caller window.  */
1587       regcache_raw_read_unsigned
1588         (regcache, gdbarch_tdep (gdbarch)->wb_regnum, &wb);
1589       areg = arreg_number (gdbarch,
1590                           gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb);
1591     }
1592   else
1593     {
1594       /* No windowing hardware - Call0 ABI.  */
1595       areg = gdbarch_tdep (gdbarch)->a0_base + C0_ARGS;
1596     }
1597
1598   DEBUGINFO ("[xtensa_extract_return_value] areg %d len %d\n", areg, len);
1599
1600   if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
1601     offset = 4 - len;
1602
1603   for (; len > 0; len -= 4, areg++, valbuf += 4)
1604     {
1605       if (len < 4)
1606         regcache_raw_read_part (regcache, areg, offset, len, valbuf);
1607       else
1608         regcache_raw_read (regcache, areg, valbuf);
1609     }
1610 }
1611
1612
1613 static void
1614 xtensa_store_return_value (struct type *type,
1615                            struct regcache *regcache,
1616                            const void *dst)
1617 {
1618   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1619   const bfd_byte *valbuf = (const bfd_byte *) dst;
1620   unsigned int areg;
1621   ULONGEST pc, wb;
1622   int callsize;
1623   int len = TYPE_LENGTH (type);
1624   int offset = 0;
1625
1626   DEBUGTRACE ("xtensa_store_return_value (...)\n");
1627
1628   if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
1629     {
1630       regcache_raw_read_unsigned 
1631         (regcache, gdbarch_tdep (gdbarch)->wb_regnum, &wb);
1632       regcache_raw_read_unsigned (regcache, gdbarch_pc_regnum (gdbarch), &pc);
1633       callsize = extract_call_winsize (gdbarch, pc);
1634
1635       if (len > (callsize > 8 ? 8 : 16))
1636         internal_error (__FILE__, __LINE__,
1637                         _("unimplemented for this length: %d"),
1638                         TYPE_LENGTH (type));
1639       areg = arreg_number (gdbarch,
1640                            gdbarch_tdep (gdbarch)->a0_base + 2 + callsize, wb);
1641
1642       DEBUGTRACE ("[xtensa_store_return_value] callsize %d wb %d\n",
1643               callsize, (int) wb);
1644     }
1645   else
1646     {
1647       areg = gdbarch_tdep (gdbarch)->a0_base + C0_ARGS;
1648     }
1649
1650   if (len < 4 && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
1651     offset = 4 - len;
1652
1653   for (; len > 0; len -= 4, areg++, valbuf += 4)
1654     {
1655       if (len < 4)
1656         regcache_raw_write_part (regcache, areg, offset, len, valbuf);
1657       else
1658         regcache_raw_write (regcache, areg, valbuf);
1659     }
1660 }
1661
1662
1663 static enum return_value_convention
1664 xtensa_return_value (struct gdbarch *gdbarch,
1665                      struct value *function,
1666                      struct type *valtype,
1667                      struct regcache *regcache,
1668                      gdb_byte *readbuf,
1669                      const gdb_byte *writebuf)
1670 {
1671   /* Structures up to 16 bytes are returned in registers.  */
1672
1673   int struct_return = ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
1674                         || TYPE_CODE (valtype) == TYPE_CODE_UNION
1675                         || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
1676                        && TYPE_LENGTH (valtype) > 16);
1677
1678   if (struct_return)
1679     return RETURN_VALUE_STRUCT_CONVENTION;
1680
1681   DEBUGTRACE ("xtensa_return_value(...)\n");
1682
1683   if (writebuf != NULL)
1684     {
1685       xtensa_store_return_value (valtype, regcache, writebuf);
1686     }
1687
1688   if (readbuf != NULL)
1689     {
1690       gdb_assert (!struct_return);
1691       xtensa_extract_return_value (valtype, regcache, readbuf);
1692     }
1693   return RETURN_VALUE_REGISTER_CONVENTION;
1694 }
1695
1696
1697 /* DUMMY FRAME */
1698
1699 static CORE_ADDR
1700 xtensa_push_dummy_call (struct gdbarch *gdbarch,
1701                         struct value *function,
1702                         struct regcache *regcache,
1703                         CORE_ADDR bp_addr,
1704                         int nargs,
1705                         struct value **args,
1706                         CORE_ADDR sp,
1707                         int struct_return,
1708                         CORE_ADDR struct_addr)
1709 {
1710   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1711   int i;
1712   int size, onstack_size;
1713   gdb_byte *buf = (gdb_byte *) alloca (16);
1714   CORE_ADDR ra, ps;
1715   struct argument_info
1716   {
1717     const bfd_byte *contents;
1718     int length;
1719     int onstack;                /* onstack == 0 => in reg */
1720     int align;                  /* alignment */
1721     union
1722     {
1723       int offset;               /* stack offset if on stack.  */
1724       int regno;                /* regno if in register.  */
1725     } u;
1726   };
1727
1728   struct argument_info *arg_info =
1729     (struct argument_info *) alloca (nargs * sizeof (struct argument_info));
1730
1731   CORE_ADDR osp = sp;
1732
1733   DEBUGTRACE ("xtensa_push_dummy_call (...)\n");
1734
1735   if (xtensa_debug_level > 3)
1736     {
1737       int i;
1738       DEBUGINFO ("[xtensa_push_dummy_call] nargs = %d\n", nargs);
1739       DEBUGINFO ("[xtensa_push_dummy_call] sp=0x%x, struct_return=%d, "
1740                  "struct_addr=0x%x\n",
1741                  (int) sp, (int) struct_return, (int) struct_addr);
1742
1743       for (i = 0; i < nargs; i++)
1744         {
1745           struct value *arg = args[i];
1746           struct type *arg_type = check_typedef (value_type (arg));
1747           fprintf_unfiltered (gdb_stdlog, "%2d: %s %3d ", i,
1748                               host_address_to_string (arg),
1749                               TYPE_LENGTH (arg_type));
1750           switch (TYPE_CODE (arg_type))
1751             {
1752             case TYPE_CODE_INT:
1753               fprintf_unfiltered (gdb_stdlog, "int");
1754               break;
1755             case TYPE_CODE_STRUCT:
1756               fprintf_unfiltered (gdb_stdlog, "struct");
1757               break;
1758             default:
1759               fprintf_unfiltered (gdb_stdlog, "%3d", TYPE_CODE (arg_type));
1760               break;
1761             }
1762           fprintf_unfiltered (gdb_stdlog, " %s\n",
1763                               host_address_to_string (value_contents (arg)));
1764         }
1765     }
1766
1767   /* First loop: collect information.
1768      Cast into type_long.  (This shouldn't happen often for C because
1769      GDB already does this earlier.)  It's possible that GDB could
1770      do it all the time but it's harmless to leave this code here.  */
1771
1772   size = 0;
1773   onstack_size = 0;
1774   i = 0;
1775
1776   if (struct_return)
1777     size = REGISTER_SIZE;
1778
1779   for (i = 0; i < nargs; i++)
1780     {
1781       struct argument_info *info = &arg_info[i];
1782       struct value *arg = args[i];
1783       struct type *arg_type = check_typedef (value_type (arg));
1784
1785       switch (TYPE_CODE (arg_type))
1786         {
1787         case TYPE_CODE_INT:
1788         case TYPE_CODE_BOOL:
1789         case TYPE_CODE_CHAR:
1790         case TYPE_CODE_RANGE:
1791         case TYPE_CODE_ENUM:
1792
1793           /* Cast argument to long if necessary as the mask does it too.  */
1794           if (TYPE_LENGTH (arg_type)
1795               < TYPE_LENGTH (builtin_type (gdbarch)->builtin_long))
1796             {
1797               arg_type = builtin_type (gdbarch)->builtin_long;
1798               arg = value_cast (arg_type, arg);
1799             }
1800           /* Aligment is equal to the type length for the basic types.  */
1801           info->align = TYPE_LENGTH (arg_type);
1802           break;
1803
1804         case TYPE_CODE_FLT:
1805
1806           /* Align doubles correctly.  */
1807           if (TYPE_LENGTH (arg_type)
1808               == TYPE_LENGTH (builtin_type (gdbarch)->builtin_double))
1809             info->align = TYPE_LENGTH (builtin_type (gdbarch)->builtin_double);
1810           else
1811             info->align = TYPE_LENGTH (builtin_type (gdbarch)->builtin_long);
1812           break;
1813
1814         case TYPE_CODE_STRUCT:
1815         default:
1816           info->align = TYPE_LENGTH (builtin_type (gdbarch)->builtin_long);
1817           break;
1818         }
1819       info->length = TYPE_LENGTH (arg_type);
1820       info->contents = value_contents (arg);
1821
1822       /* Align size and onstack_size.  */
1823       size = (size + info->align - 1) & ~(info->align - 1);
1824       onstack_size = (onstack_size + info->align - 1) & ~(info->align - 1);
1825
1826       if (size + info->length > REGISTER_SIZE * ARG_NOF (gdbarch))
1827         {
1828           info->onstack = 1;
1829           info->u.offset = onstack_size;
1830           onstack_size += info->length;
1831         }
1832       else
1833         {
1834           info->onstack = 0;
1835           info->u.regno = ARG_1ST (gdbarch) + size / REGISTER_SIZE;
1836         }
1837       size += info->length;
1838     }
1839
1840   /* Adjust the stack pointer and align it.  */
1841   sp = align_down (sp - onstack_size, SP_ALIGNMENT);
1842
1843   /* Simulate MOVSP, if Windowed ABI.  */
1844   if ((gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
1845       && (sp != osp))
1846     {
1847       read_memory (osp - 16, buf, 16);
1848       write_memory (sp - 16, buf, 16);
1849     }
1850
1851   /* Second Loop: Load arguments.  */
1852
1853   if (struct_return)
1854     {
1855       store_unsigned_integer (buf, REGISTER_SIZE, byte_order, struct_addr);
1856       regcache_cooked_write (regcache, ARG_1ST (gdbarch), buf);
1857     }
1858
1859   for (i = 0; i < nargs; i++)
1860     {
1861       struct argument_info *info = &arg_info[i];
1862
1863       if (info->onstack)
1864         {
1865           int n = info->length;
1866           CORE_ADDR offset = sp + info->u.offset;
1867
1868           /* Odd-sized structs are aligned to the lower side of a memory
1869              word in big-endian mode and require a shift.  This only
1870              applies for structures smaller than one word.  */
1871
1872           if (n < REGISTER_SIZE
1873               && gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
1874             offset += (REGISTER_SIZE - n);
1875
1876           write_memory (offset, info->contents, info->length);
1877
1878         }
1879       else
1880         {
1881           int n = info->length;
1882           const bfd_byte *cp = info->contents;
1883           int r = info->u.regno;
1884
1885           /* Odd-sized structs are aligned to the lower side of registers in
1886              big-endian mode and require a shift.  The odd-sized leftover will
1887              be at the end.  Note that this is only true for structures smaller
1888              than REGISTER_SIZE; for larger odd-sized structures the excess
1889              will be left-aligned in the register on both endiannesses.  */
1890
1891           if (n < REGISTER_SIZE && byte_order == BFD_ENDIAN_BIG)
1892             {
1893               ULONGEST v;
1894               v = extract_unsigned_integer (cp, REGISTER_SIZE, byte_order);
1895               v = v >> ((REGISTER_SIZE - n) * TARGET_CHAR_BIT);
1896
1897               store_unsigned_integer (buf, REGISTER_SIZE, byte_order, v);
1898               regcache_cooked_write (regcache, r, buf);
1899
1900               cp += REGISTER_SIZE;
1901               n -= REGISTER_SIZE;
1902               r++;
1903             }
1904           else
1905             while (n > 0)
1906               {
1907                 regcache_cooked_write (regcache, r, cp);
1908
1909                 cp += REGISTER_SIZE;
1910                 n -= REGISTER_SIZE;
1911                 r++;
1912               }
1913         }
1914     }
1915
1916   /* Set the return address of dummy frame to the dummy address.
1917      The return address for the current function (in A0) is
1918      saved in the dummy frame, so we can savely overwrite A0 here.  */
1919
1920   if (gdbarch_tdep (gdbarch)->call_abi != CallAbiCall0Only)
1921     {
1922       ULONGEST val;
1923
1924       ra = (bp_addr & 0x3fffffff) | 0x40000000;
1925       regcache_raw_read_unsigned (regcache, gdbarch_ps_regnum (gdbarch), &val);
1926       ps = (unsigned long) val & ~0x00030000;
1927       regcache_cooked_write_unsigned
1928         (regcache, gdbarch_tdep (gdbarch)->a0_base + 4, ra);
1929       regcache_cooked_write_unsigned (regcache,
1930                                       gdbarch_ps_regnum (gdbarch),
1931                                       ps | 0x00010000);
1932
1933       /* All the registers have been saved.  After executing
1934          dummy call, they all will be restored.  So it's safe
1935          to modify WINDOWSTART register to make it look like there
1936          is only one register window corresponding to WINDOWEBASE.  */
1937
1938       regcache_raw_read (regcache, gdbarch_tdep (gdbarch)->wb_regnum, buf);
1939       regcache_cooked_write_unsigned
1940         (regcache, gdbarch_tdep (gdbarch)->ws_regnum,
1941          1 << extract_unsigned_integer (buf, 4, byte_order));
1942     }
1943   else
1944     {
1945       /* Simulate CALL0: write RA into A0 register.  */
1946       regcache_cooked_write_unsigned
1947         (regcache, gdbarch_tdep (gdbarch)->a0_base, bp_addr);
1948     }
1949
1950   /* Set new stack pointer and return it.  */
1951   regcache_cooked_write_unsigned (regcache,
1952                                   gdbarch_tdep (gdbarch)->a0_base + 1, sp);
1953   /* Make dummy frame ID unique by adding a constant.  */
1954   return sp + SP_ALIGNMENT;
1955 }
1956
1957 /* Implement the breakpoint_kind_from_pc gdbarch method.  */
1958
1959 static int
1960 xtensa_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
1961 {
1962   if (gdbarch_tdep (gdbarch)->isa_use_density_instructions)
1963     return 2;
1964   else
1965     return 4;
1966 }
1967
1968 /* Return a breakpoint for the current location of PC.  We always use
1969    the density version if we have density instructions (regardless of the
1970    current instruction at PC), and use regular instructions otherwise.  */
1971
1972 #define BIG_BREAKPOINT { 0x00, 0x04, 0x00 }
1973 #define LITTLE_BREAKPOINT { 0x00, 0x40, 0x00 }
1974 #define DENSITY_BIG_BREAKPOINT { 0xd2, 0x0f }
1975 #define DENSITY_LITTLE_BREAKPOINT { 0x2d, 0xf0 }
1976
1977 /* Implement the sw_breakpoint_from_kind gdbarch method.  */
1978
1979 static const gdb_byte *
1980 xtensa_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
1981 {
1982   *size = kind;
1983
1984   if (kind == 4)
1985     {
1986       static unsigned char big_breakpoint[] = BIG_BREAKPOINT;
1987       static unsigned char little_breakpoint[] = LITTLE_BREAKPOINT;
1988
1989       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
1990         return big_breakpoint;
1991       else
1992         return little_breakpoint;
1993     }
1994   else
1995     {
1996       static unsigned char density_big_breakpoint[] = DENSITY_BIG_BREAKPOINT;
1997       static unsigned char density_little_breakpoint[]
1998         = DENSITY_LITTLE_BREAKPOINT;
1999
2000       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
2001         return density_big_breakpoint;
2002       else
2003         return density_little_breakpoint;
2004     }
2005 }
2006
2007 /* Call0 ABI support routines.  */
2008
2009 /* Return true, if PC points to "ret" or "ret.n".  */ 
2010
2011 static int
2012 call0_ret (CORE_ADDR start_pc, CORE_ADDR finish_pc)
2013 {
2014 #define RETURN_RET goto done
2015   xtensa_isa isa;
2016   xtensa_insnbuf ins, slot;
2017   gdb_byte ibuf[XTENSA_ISA_BSZ];
2018   CORE_ADDR ia, bt, ba;
2019   xtensa_format ifmt;
2020   int ilen, islots, is;
2021   xtensa_opcode opc;
2022   const char *opcname;
2023   int found_ret = 0;
2024
2025   isa = xtensa_default_isa;
2026   gdb_assert (XTENSA_ISA_BSZ >= xtensa_isa_maxlength (isa));
2027   ins = xtensa_insnbuf_alloc (isa);
2028   slot = xtensa_insnbuf_alloc (isa);
2029   ba = 0;
2030
2031   for (ia = start_pc, bt = ia; ia < finish_pc ; ia += ilen)
2032     {
2033       if (ia + xtensa_isa_maxlength (isa) > bt)
2034         {
2035           ba = ia;
2036           bt = (ba + XTENSA_ISA_BSZ) < finish_pc
2037             ? ba + XTENSA_ISA_BSZ : finish_pc;
2038           if (target_read_memory (ba, ibuf, bt - ba) != 0 )
2039             RETURN_RET;
2040         }
2041
2042       xtensa_insnbuf_from_chars (isa, ins, &ibuf[ia-ba], 0);
2043       ifmt = xtensa_format_decode (isa, ins);
2044       if (ifmt == XTENSA_UNDEFINED)
2045         RETURN_RET;
2046       ilen = xtensa_format_length (isa, ifmt);
2047       if (ilen == XTENSA_UNDEFINED)
2048         RETURN_RET;
2049       islots = xtensa_format_num_slots (isa, ifmt);
2050       if (islots == XTENSA_UNDEFINED)
2051         RETURN_RET;
2052       
2053       for (is = 0; is < islots; ++is)
2054         {
2055           if (xtensa_format_get_slot (isa, ifmt, is, ins, slot))
2056             RETURN_RET;
2057           
2058           opc = xtensa_opcode_decode (isa, ifmt, is, slot);
2059           if (opc == XTENSA_UNDEFINED) 
2060             RETURN_RET;
2061           
2062           opcname = xtensa_opcode_name (isa, opc);
2063           
2064           if ((strcasecmp (opcname, "ret.n") == 0)
2065               || (strcasecmp (opcname, "ret") == 0))
2066             {
2067               found_ret = 1;
2068               RETURN_RET;
2069             }
2070         }
2071     }
2072  done:
2073   xtensa_insnbuf_free(isa, slot);
2074   xtensa_insnbuf_free(isa, ins);
2075   return found_ret;
2076 }
2077
2078 /* Call0 opcode class.  Opcodes are preclassified according to what they
2079    mean for Call0 prologue analysis, and their number of significant operands.
2080    The purpose of this is to simplify prologue analysis by separating 
2081    instruction decoding (libisa) from the semantics of prologue analysis.  */
2082
2083 typedef enum
2084 {
2085   c0opc_illegal,       /* Unknown to libisa (invalid) or 'ill' opcode.  */
2086   c0opc_uninteresting, /* Not interesting for Call0 prologue analysis.  */
2087   c0opc_flow,          /* Flow control insn.  */
2088   c0opc_entry,         /* ENTRY indicates non-Call0 prologue.  */
2089   c0opc_break,         /* Debugger software breakpoints.  */
2090   c0opc_add,           /* Adding two registers.  */
2091   c0opc_addi,          /* Adding a register and an immediate.  */
2092   c0opc_and,           /* Bitwise "and"-ing two registers.  */
2093   c0opc_sub,           /* Subtracting a register from a register.  */
2094   c0opc_mov,           /* Moving a register to a register.  */
2095   c0opc_movi,          /* Moving an immediate to a register.  */
2096   c0opc_l32r,          /* Loading a literal.  */
2097   c0opc_s32i,          /* Storing word at fixed offset from a base register.  */
2098   c0opc_rwxsr,         /* RSR, WRS, or XSR instructions.  */
2099   c0opc_l32e,          /* L32E instruction.  */
2100   c0opc_s32e,          /* S32E instruction.  */
2101   c0opc_rfwo,          /* RFWO instruction.  */
2102   c0opc_rfwu,          /* RFWU instruction.  */
2103   c0opc_NrOf           /* Number of opcode classifications.  */
2104 } xtensa_insn_kind;
2105
2106 /* Return true,  if OPCNAME is RSR,  WRS,  or XSR instruction.  */
2107
2108 static int
2109 rwx_special_register (const char *opcname)
2110 {
2111   char ch = *opcname++;
2112   
2113   if ((ch != 'r') && (ch != 'w') && (ch != 'x'))
2114     return 0;
2115   if (*opcname++ != 's')
2116     return 0;
2117   if (*opcname++ != 'r')
2118     return 0;
2119   if (*opcname++ != '.')
2120     return 0;
2121
2122   return 1;
2123 }
2124
2125 /* Classify an opcode based on what it means for Call0 prologue analysis.  */
2126
2127 static xtensa_insn_kind
2128 call0_classify_opcode (xtensa_isa isa, xtensa_opcode opc)
2129 {
2130   const char *opcname;
2131   xtensa_insn_kind opclass = c0opc_uninteresting;
2132
2133   DEBUGTRACE ("call0_classify_opcode (..., opc = %d)\n", opc);
2134
2135   /* Get opcode name and handle special classifications.  */
2136
2137   opcname = xtensa_opcode_name (isa, opc);
2138
2139   if (opcname == NULL 
2140       || strcasecmp (opcname, "ill") == 0
2141       || strcasecmp (opcname, "ill.n") == 0)
2142     opclass = c0opc_illegal;
2143   else if (strcasecmp (opcname, "break") == 0
2144            || strcasecmp (opcname, "break.n") == 0)
2145      opclass = c0opc_break;
2146   else if (strcasecmp (opcname, "entry") == 0)
2147     opclass = c0opc_entry;
2148   else if (strcasecmp (opcname, "rfwo") == 0)
2149     opclass = c0opc_rfwo;
2150   else if (strcasecmp (opcname, "rfwu") == 0)
2151     opclass = c0opc_rfwu;
2152   else if (xtensa_opcode_is_branch (isa, opc) > 0
2153            || xtensa_opcode_is_jump   (isa, opc) > 0
2154            || xtensa_opcode_is_loop   (isa, opc) > 0
2155            || xtensa_opcode_is_call   (isa, opc) > 0
2156            || strcasecmp (opcname, "simcall") == 0
2157            || strcasecmp (opcname, "syscall") == 0)
2158     opclass = c0opc_flow;
2159
2160   /* Also, classify specific opcodes that need to be tracked.  */
2161   else if (strcasecmp (opcname, "add") == 0 
2162            || strcasecmp (opcname, "add.n") == 0)
2163     opclass = c0opc_add;
2164   else if (strcasecmp (opcname, "and") == 0)
2165     opclass = c0opc_and;
2166   else if (strcasecmp (opcname, "addi") == 0 
2167            || strcasecmp (opcname, "addi.n") == 0
2168            || strcasecmp (opcname, "addmi") == 0)
2169     opclass = c0opc_addi;
2170   else if (strcasecmp (opcname, "sub") == 0)
2171     opclass = c0opc_sub;
2172   else if (strcasecmp (opcname, "mov.n") == 0
2173            || strcasecmp (opcname, "or") == 0) /* Could be 'mov' asm macro.  */
2174     opclass = c0opc_mov;
2175   else if (strcasecmp (opcname, "movi") == 0 
2176            || strcasecmp (opcname, "movi.n") == 0)
2177     opclass = c0opc_movi;
2178   else if (strcasecmp (opcname, "l32r") == 0)
2179     opclass = c0opc_l32r;
2180   else if (strcasecmp (opcname, "s32i") == 0 
2181            || strcasecmp (opcname, "s32i.n") == 0)
2182     opclass = c0opc_s32i;
2183   else if (strcasecmp (opcname, "l32e") == 0)
2184     opclass = c0opc_l32e;
2185   else if (strcasecmp (opcname, "s32e") == 0)
2186     opclass = c0opc_s32e;
2187   else if (rwx_special_register (opcname))
2188     opclass = c0opc_rwxsr;
2189
2190   return opclass;
2191 }
2192
2193 /* Tracks register movement/mutation for a given operation, which may
2194    be within a bundle.  Updates the destination register tracking info
2195    accordingly.  The pc is needed only for pc-relative load instructions
2196    (eg. l32r).  The SP register number is needed to identify stores to
2197    the stack frame.  Returns 0, if analysis was succesfull, non-zero
2198    otherwise.  */
2199
2200 static int
2201 call0_track_op (struct gdbarch *gdbarch, xtensa_c0reg_t dst[], xtensa_c0reg_t src[],
2202                 xtensa_insn_kind opclass, int nods, unsigned odv[],
2203                 CORE_ADDR pc, int spreg, xtensa_frame_cache_t *cache)
2204 {
2205   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2206   unsigned litbase, litaddr, litval;
2207
2208   switch (opclass)
2209     {
2210     case c0opc_addi:
2211       /* 3 operands: dst, src, imm.  */
2212       gdb_assert (nods == 3);
2213       dst[odv[0]].fr_reg = src[odv[1]].fr_reg;
2214       dst[odv[0]].fr_ofs = src[odv[1]].fr_ofs + odv[2];
2215       break;
2216     case c0opc_add:
2217       /* 3 operands: dst, src1, src2.  */
2218       gdb_assert (nods == 3); 
2219       if      (src[odv[1]].fr_reg == C0_CONST)
2220         {
2221           dst[odv[0]].fr_reg = src[odv[2]].fr_reg;
2222           dst[odv[0]].fr_ofs = src[odv[2]].fr_ofs + src[odv[1]].fr_ofs;
2223         }
2224       else if (src[odv[2]].fr_reg == C0_CONST)
2225         {
2226           dst[odv[0]].fr_reg = src[odv[1]].fr_reg;
2227           dst[odv[0]].fr_ofs = src[odv[1]].fr_ofs + src[odv[2]].fr_ofs;
2228         }
2229       else dst[odv[0]].fr_reg = C0_INEXP;
2230       break;
2231     case c0opc_and:
2232       /* 3 operands:  dst, src1, src2.  */
2233       gdb_assert (nods == 3);
2234       if (cache->c0.c0_fpalign == 0)
2235         {
2236           /* Handle dynamic stack alignment.  */
2237           if ((src[odv[0]].fr_reg == spreg) && (src[odv[1]].fr_reg == spreg))
2238             {
2239               if (src[odv[2]].fr_reg == C0_CONST)
2240                 cache->c0.c0_fpalign = src[odv[2]].fr_ofs;
2241               break;
2242             }
2243           else if ((src[odv[0]].fr_reg == spreg)
2244                    && (src[odv[2]].fr_reg == spreg))
2245             {
2246               if (src[odv[1]].fr_reg == C0_CONST)
2247                 cache->c0.c0_fpalign = src[odv[1]].fr_ofs;
2248               break;
2249             }
2250           /* else fall through.  */
2251         }
2252       if      (src[odv[1]].fr_reg == C0_CONST)
2253         {
2254           dst[odv[0]].fr_reg = src[odv[2]].fr_reg;
2255           dst[odv[0]].fr_ofs = src[odv[2]].fr_ofs & src[odv[1]].fr_ofs;
2256         }
2257       else if (src[odv[2]].fr_reg == C0_CONST)
2258         {
2259           dst[odv[0]].fr_reg = src[odv[1]].fr_reg;
2260           dst[odv[0]].fr_ofs = src[odv[1]].fr_ofs & src[odv[2]].fr_ofs;
2261         }
2262       else dst[odv[0]].fr_reg = C0_INEXP;
2263       break;
2264     case c0opc_sub:
2265       /* 3 operands: dst, src1, src2.  */
2266       gdb_assert (nods == 3);
2267       if      (src[odv[2]].fr_reg == C0_CONST)
2268         {
2269           dst[odv[0]].fr_reg = src[odv[1]].fr_reg;
2270           dst[odv[0]].fr_ofs = src[odv[1]].fr_ofs - src[odv[2]].fr_ofs;
2271         }
2272       else dst[odv[0]].fr_reg = C0_INEXP;
2273       break;
2274     case c0opc_mov:
2275       /* 2 operands: dst, src [, src].  */
2276       gdb_assert (nods == 2);
2277       /* First, check if it's a special case of saving unaligned SP
2278          to a spare register in case of dynamic stack adjustment.
2279          But, only do it one time.  The second time could be initializing
2280          frame pointer.  We don't want to overwrite the first one.  */
2281       if ((odv[1] == spreg) && (cache->c0.c0_old_sp == C0_INEXP))
2282         cache->c0.c0_old_sp = odv[0];
2283
2284       dst[odv[0]].fr_reg = src[odv[1]].fr_reg;
2285       dst[odv[0]].fr_ofs = src[odv[1]].fr_ofs;
2286       break;
2287     case c0opc_movi:
2288       /* 2 operands: dst, imm.  */
2289       gdb_assert (nods == 2);
2290       dst[odv[0]].fr_reg = C0_CONST;
2291       dst[odv[0]].fr_ofs = odv[1];
2292       break;
2293     case c0opc_l32r:
2294       /* 2 operands: dst, literal offset.  */
2295       gdb_assert (nods == 2);
2296       /* litbase = xtensa_get_litbase (pc);  can be also used.  */
2297       litbase = (gdbarch_tdep (gdbarch)->litbase_regnum == -1)
2298         ? 0 : xtensa_read_register
2299                 (gdbarch_tdep (gdbarch)->litbase_regnum);
2300       litaddr = litbase & 1
2301                   ? (litbase & ~1) + (signed)odv[1]
2302                   : (pc + 3  + (signed)odv[1]) & ~3;
2303       litval = read_memory_integer (litaddr, 4, byte_order);
2304       dst[odv[0]].fr_reg = C0_CONST;
2305       dst[odv[0]].fr_ofs = litval;
2306       break;
2307     case c0opc_s32i:
2308       /* 3 operands: value, base, offset.  */
2309       gdb_assert (nods == 3 && spreg >= 0 && spreg < C0_NREGS);
2310       /* First, check if it's a spill for saved unaligned SP,
2311          when dynamic stack adjustment was applied to this frame.  */
2312       if ((cache->c0.c0_fpalign != 0)           /* Dynamic stack adjustment.  */
2313           && (odv[1] == spreg)                  /* SP usage indicates spill.  */
2314           && (odv[0] == cache->c0.c0_old_sp))   /* Old SP register spilled.  */
2315         cache->c0.c0_sp_ofs = odv[2];
2316
2317       if (src[odv[1]].fr_reg == spreg        /* Store to stack frame.  */
2318           && (src[odv[1]].fr_ofs & 3) == 0   /* Alignment preserved.  */
2319           &&  src[odv[0]].fr_reg >= 0        /* Value is from a register.  */
2320           &&  src[odv[0]].fr_ofs == 0        /* Value hasn't been modified.  */
2321           &&  src[src[odv[0]].fr_reg].to_stk == C0_NOSTK) /* First time.  */
2322         {
2323           /* ISA encoding guarantees alignment.  But, check it anyway.  */
2324           gdb_assert ((odv[2] & 3) == 0);
2325           dst[src[odv[0]].fr_reg].to_stk = src[odv[1]].fr_ofs + odv[2];
2326         }
2327       break;
2328       /* If we end up inside Window Overflow / Underflow interrupt handler
2329          report an error because these handlers should have been handled
2330          already in a different way.  */
2331     case c0opc_l32e:
2332     case c0opc_s32e:
2333     case c0opc_rfwo:
2334     case c0opc_rfwu:
2335       return 1;
2336     default:
2337       return 1;
2338     }
2339   return 0;
2340 }
2341
2342 /* Analyze prologue of the function at start address to determine if it uses
2343    the Call0 ABI, and if so track register moves and linear modifications
2344    in the prologue up to the PC or just beyond the prologue, whichever is
2345    first. An 'entry' instruction indicates non-Call0 ABI and the end of the
2346    prologue. The prologue may overlap non-prologue instructions but is
2347    guaranteed to end by the first flow-control instruction (jump, branch,
2348    call or return).  Since an optimized function may move information around
2349    and change the stack frame arbitrarily during the prologue, the information
2350    is guaranteed valid only at the point in the function indicated by the PC.
2351    May be used to skip the prologue or identify the ABI, w/o tracking.
2352
2353    Returns:   Address of first instruction after prologue, or PC (whichever 
2354               is first), or 0, if decoding failed (in libisa).
2355    Input args:
2356       start   Start address of function/prologue.
2357       pc      Program counter to stop at.  Use 0 to continue to end of prologue.
2358               If 0, avoids infinite run-on in corrupt code memory by bounding
2359               the scan to the end of the function if that can be determined.
2360       nregs   Number of general registers to track.
2361    InOut args:
2362       cache   Xtensa frame cache.
2363
2364       Note that these may produce useful results even if decoding fails
2365       because they begin with default assumptions that analysis may change.  */
2366
2367 static CORE_ADDR
2368 call0_analyze_prologue (struct gdbarch *gdbarch,
2369                         CORE_ADDR start, CORE_ADDR pc,
2370                         int nregs, xtensa_frame_cache_t *cache)
2371 {
2372   CORE_ADDR ia;             /* Current insn address in prologue.  */
2373   CORE_ADDR ba = 0;         /* Current address at base of insn buffer.  */
2374   CORE_ADDR bt;             /* Current address at top+1 of insn buffer.  */
2375   gdb_byte ibuf[XTENSA_ISA_BSZ];/* Instruction buffer for decoding prologue.  */
2376   xtensa_isa isa;           /* libisa ISA handle.  */
2377   xtensa_insnbuf ins, slot; /* libisa handle to decoded insn, slot.  */
2378   xtensa_format ifmt;       /* libisa instruction format.  */
2379   int ilen, islots, is;     /* Instruction length, nbr slots, current slot.  */
2380   xtensa_opcode opc;        /* Opcode in current slot.  */
2381   xtensa_insn_kind opclass; /* Opcode class for Call0 prologue analysis.  */
2382   int nods;                 /* Opcode number of operands.  */
2383   unsigned odv[C0_MAXOPDS]; /* Operand values in order provided by libisa.  */
2384   xtensa_c0reg_t *rtmp;     /* Register tracking info snapshot.  */
2385   int j;                    /* General loop counter.  */
2386   int fail = 0;             /* Set non-zero and exit, if decoding fails.  */
2387   CORE_ADDR body_pc;        /* The PC for the first non-prologue insn.  */
2388   CORE_ADDR end_pc;         /* The PC for the lust function insn.  */
2389
2390   struct symtab_and_line prologue_sal;
2391
2392   DEBUGTRACE ("call0_analyze_prologue (start = 0x%08x, pc = 0x%08x, ...)\n", 
2393               (int)start, (int)pc);
2394
2395   /* Try to limit the scan to the end of the function if a non-zero pc
2396      arg was not supplied to avoid probing beyond the end of valid memory.
2397      If memory is full of garbage that classifies as c0opc_uninteresting.
2398      If this fails (eg. if no symbols) pc ends up 0 as it was.
2399      Initialize the Call0 frame and register tracking info.
2400      Assume it's Call0 until an 'entry' instruction is encountered.
2401      Assume we may be in the prologue until we hit a flow control instr.  */
2402
2403   rtmp = NULL;
2404   body_pc = UINT_MAX;
2405   end_pc = 0;
2406
2407   /* Find out, if we have an information about the prologue from DWARF.  */
2408   prologue_sal = find_pc_line (start, 0);
2409   if (prologue_sal.line != 0) /* Found debug info.  */
2410     body_pc = prologue_sal.end;
2411
2412   /* If we are going to analyze the prologue in general without knowing about
2413      the current PC, make the best assumtion for the end of the prologue.  */
2414   if (pc == 0)
2415     {
2416       find_pc_partial_function (start, 0, NULL, &end_pc);
2417       body_pc = std::min (end_pc, body_pc);
2418     }
2419   else
2420     body_pc = std::min (pc, body_pc);
2421
2422   cache->call0 = 1;
2423   rtmp = (xtensa_c0reg_t*) alloca(nregs * sizeof(xtensa_c0reg_t));
2424
2425   isa = xtensa_default_isa;
2426   gdb_assert (XTENSA_ISA_BSZ >= xtensa_isa_maxlength (isa));
2427   ins = xtensa_insnbuf_alloc (isa);
2428   slot = xtensa_insnbuf_alloc (isa);
2429
2430   for (ia = start, bt = ia; ia < body_pc ; ia += ilen)
2431     {
2432       /* (Re)fill instruction buffer from memory if necessary, but do not
2433          read memory beyond PC to be sure we stay within text section
2434          (this protection only works if a non-zero pc is supplied).  */
2435
2436       if (ia + xtensa_isa_maxlength (isa) > bt)
2437         {
2438           ba = ia;
2439           bt = (ba + XTENSA_ISA_BSZ) < body_pc ? ba + XTENSA_ISA_BSZ : body_pc;
2440           if (target_read_memory (ba, ibuf, bt - ba) != 0 )
2441             error (_("Unable to read target memory ..."));
2442         }
2443
2444       /* Decode format information.  */
2445
2446       xtensa_insnbuf_from_chars (isa, ins, &ibuf[ia-ba], 0);
2447       ifmt = xtensa_format_decode (isa, ins);
2448       if (ifmt == XTENSA_UNDEFINED)
2449         {
2450           fail = 1;
2451           goto done;
2452         }
2453       ilen = xtensa_format_length (isa, ifmt);
2454       if (ilen == XTENSA_UNDEFINED)
2455         {
2456           fail = 1;
2457           goto done;
2458         }
2459       islots = xtensa_format_num_slots (isa, ifmt);
2460       if (islots == XTENSA_UNDEFINED)
2461         {
2462           fail = 1;
2463           goto done;
2464         }
2465
2466       /* Analyze a bundle or a single instruction, using a snapshot of 
2467          the register tracking info as input for the entire bundle so that
2468          register changes do not take effect within this bundle.  */
2469
2470       for (j = 0; j < nregs; ++j)
2471         rtmp[j] = cache->c0.c0_rt[j];
2472
2473       for (is = 0; is < islots; ++is)
2474         {
2475           /* Decode a slot and classify the opcode.  */
2476
2477           fail = xtensa_format_get_slot (isa, ifmt, is, ins, slot);
2478           if (fail)
2479             goto done;
2480
2481           opc = xtensa_opcode_decode (isa, ifmt, is, slot);
2482           DEBUGVERB ("[call0_analyze_prologue] instr addr = 0x%08x, opc = %d\n", 
2483                      (unsigned)ia, opc);
2484           if (opc == XTENSA_UNDEFINED) 
2485             opclass = c0opc_illegal;
2486           else
2487             opclass = call0_classify_opcode (isa, opc);
2488
2489           /* Decide whether to track this opcode, ignore it, or bail out.  */
2490
2491           switch (opclass)
2492             {
2493             case c0opc_illegal:
2494             case c0opc_break:
2495               fail = 1;
2496               goto done;
2497
2498             case c0opc_uninteresting:
2499               continue;
2500
2501             case c0opc_flow:  /* Flow control instructions stop analysis.  */
2502             case c0opc_rwxsr: /* RSR, WSR, XSR instructions stop analysis.  */
2503               goto done;
2504
2505             case c0opc_entry:
2506               cache->call0 = 0;
2507               ia += ilen;               /* Skip over 'entry' insn.  */
2508               goto done;
2509
2510             default:
2511               cache->call0 = 1;
2512             }
2513
2514           /* Only expected opcodes should get this far.  */
2515
2516           /* Extract and decode the operands.  */
2517           nods = xtensa_opcode_num_operands (isa, opc);
2518           if (nods == XTENSA_UNDEFINED)
2519             {
2520               fail = 1;
2521               goto done;
2522             }
2523
2524           for (j = 0; j < nods && j < C0_MAXOPDS; ++j)
2525             {
2526               fail = xtensa_operand_get_field (isa, opc, j, ifmt, 
2527                                                is, slot, &odv[j]);
2528               if (fail)
2529                 goto done;
2530
2531               fail = xtensa_operand_decode (isa, opc, j, &odv[j]);
2532               if (fail)
2533                 goto done;
2534             }
2535
2536           /* Check operands to verify use of 'mov' assembler macro.  */
2537           if (opclass == c0opc_mov && nods == 3)
2538             {
2539               if (odv[2] == odv[1])
2540                 {
2541                   nods = 2;
2542                   if ((odv[0] == 1) && (odv[1] != 1))
2543                     /* OR  A1, An, An  , where n != 1.
2544                        This means we are inside epilogue already.  */
2545                     goto done;
2546                 }
2547               else
2548                 {
2549                   opclass = c0opc_uninteresting;
2550                   continue;
2551                 }
2552             }
2553
2554           /* Track register movement and modification for this operation.  */
2555           fail = call0_track_op (gdbarch, cache->c0.c0_rt, rtmp,
2556                                  opclass, nods, odv, ia, 1, cache);
2557           if (fail)
2558             goto done;
2559         }
2560     }
2561 done:
2562   DEBUGVERB ("[call0_analyze_prologue] stopped at instr addr 0x%08x, %s\n",
2563              (unsigned)ia, fail ? "failed" : "succeeded");
2564   xtensa_insnbuf_free(isa, slot);
2565   xtensa_insnbuf_free(isa, ins);
2566   return fail ? XTENSA_ISA_BADPC : ia;
2567 }
2568
2569 /* Initialize frame cache for the current frame in CALL0 ABI.  */
2570
2571 static void
2572 call0_frame_cache (struct frame_info *this_frame,
2573                    xtensa_frame_cache_t *cache, CORE_ADDR pc)
2574 {
2575   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2576   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2577   CORE_ADDR start_pc;           /* The beginning of the function.  */
2578   CORE_ADDR body_pc=UINT_MAX;   /* PC, where prologue analysis stopped.  */
2579   CORE_ADDR sp, fp, ra;
2580   int fp_regnum = C0_SP, c0_hasfp = 0, c0_frmsz = 0, prev_sp = 0, to_stk;
2581  
2582   sp = get_frame_register_unsigned
2583     (this_frame, gdbarch_tdep (gdbarch)->a0_base + 1);
2584   fp = sp; /* Assume FP == SP until proven otherwise.  */
2585
2586   /* Find the beginning of the prologue of the function containing the PC
2587      and analyze it up to the PC or the end of the prologue.  */
2588
2589   if (find_pc_partial_function (pc, NULL, &start_pc, NULL))
2590     {
2591       body_pc = call0_analyze_prologue (gdbarch, start_pc, pc, C0_NREGS, cache);
2592
2593       if (body_pc == XTENSA_ISA_BADPC)
2594         {
2595           warning_once ();
2596           ra = 0;
2597           goto finish_frame_analysis;
2598         }
2599     }
2600   
2601   /* Get the frame information and FP (if used) at the current PC.
2602      If PC is in the prologue, the prologue analysis is more reliable
2603      than DWARF info.  We don't not know for sure, if PC is in the prologue,
2604      but we do know no calls have yet taken place, so we can almost
2605      certainly rely on the prologue analysis.  */
2606
2607   if (body_pc <= pc)
2608     {
2609       /* Prologue analysis was successful up to the PC.
2610          It includes the cases when PC == START_PC.  */
2611       c0_hasfp = cache->c0.c0_rt[C0_FP].fr_reg == C0_SP;
2612       /* c0_hasfp == true means there is a frame pointer because
2613          we analyzed the prologue and found that cache->c0.c0_rt[C0_FP]
2614          was derived from SP.  Otherwise, it would be C0_FP.  */
2615       fp_regnum = c0_hasfp ? C0_FP : C0_SP;
2616       c0_frmsz = - cache->c0.c0_rt[fp_regnum].fr_ofs;
2617       fp_regnum += gdbarch_tdep (gdbarch)->a0_base;
2618     }
2619   else  /* No data from the prologue analysis.  */
2620     {
2621       c0_hasfp = 0;
2622       fp_regnum = gdbarch_tdep (gdbarch)->a0_base + C0_SP;
2623       c0_frmsz = 0;
2624       start_pc = pc;
2625    }
2626
2627   if (cache->c0.c0_fpalign)
2628     {
2629       /* This frame has a special prologue with a dynamic stack adjustment
2630          to force an alignment, which is bigger than standard 16 bytes.  */
2631
2632       CORE_ADDR unaligned_sp;
2633
2634       if (cache->c0.c0_old_sp == C0_INEXP)
2635         /* This can't be.  Prologue code should be consistent.
2636            Unaligned stack pointer should be saved in a spare register.  */
2637         {
2638           warning_once ();
2639           ra = 0;
2640           goto finish_frame_analysis;
2641         }
2642
2643       if (cache->c0.c0_sp_ofs == C0_NOSTK)
2644         /* Saved unaligned value of SP is kept in a register.  */
2645         unaligned_sp = get_frame_register_unsigned
2646           (this_frame, gdbarch_tdep (gdbarch)->a0_base + cache->c0.c0_old_sp);
2647       else
2648         /* Get the value from stack.  */
2649         unaligned_sp = (CORE_ADDR)
2650           read_memory_integer (fp + cache->c0.c0_sp_ofs, 4, byte_order);
2651
2652       prev_sp = unaligned_sp + c0_frmsz;
2653     }
2654   else
2655     prev_sp = fp + c0_frmsz;
2656
2657   /* Frame size from debug info or prologue tracking does not account for 
2658      alloca() and other dynamic allocations.  Adjust frame size by FP - SP.  */
2659   if (c0_hasfp)
2660     {
2661       fp = get_frame_register_unsigned (this_frame, fp_regnum);
2662
2663       /* Update the stack frame size.  */
2664       c0_frmsz += fp - sp;
2665     }
2666
2667   /* Get the return address (RA) from the stack if saved,
2668      or try to get it from a register.  */
2669
2670   to_stk = cache->c0.c0_rt[C0_RA].to_stk;
2671   if (to_stk != C0_NOSTK)
2672     ra = (CORE_ADDR) 
2673       read_memory_integer (sp + c0_frmsz + cache->c0.c0_rt[C0_RA].to_stk,
2674                            4, byte_order);
2675
2676   else if (cache->c0.c0_rt[C0_RA].fr_reg == C0_CONST
2677            && cache->c0.c0_rt[C0_RA].fr_ofs == 0)
2678     {
2679       /* Special case for terminating backtrace at a function that wants to
2680          be seen as the outermost one.  Such a function will clear it's RA (A0)
2681          register to 0 in the prologue instead of saving its original value.  */
2682       ra = 0;
2683     }
2684   else
2685     {
2686       /* RA was copied to another register or (before any function call) may
2687          still be in the original RA register.  This is not always reliable:
2688          even in a leaf function, register tracking stops after prologue, and
2689          even in prologue, non-prologue instructions (not tracked) may overwrite
2690          RA or any register it was copied to.  If likely in prologue or before
2691          any call, use retracking info and hope for the best (compiler should
2692          have saved RA in stack if not in a leaf function).  If not in prologue,
2693          too bad.  */
2694
2695       int i;
2696       for (i = 0;
2697            (i < C0_NREGS)
2698            && (i == C0_RA || cache->c0.c0_rt[i].fr_reg != C0_RA);
2699            ++i);
2700       if (i >= C0_NREGS && cache->c0.c0_rt[C0_RA].fr_reg == C0_RA)
2701         i = C0_RA;
2702       if (i < C0_NREGS)
2703         {
2704           ra = get_frame_register_unsigned
2705             (this_frame,
2706              gdbarch_tdep (gdbarch)->a0_base + cache->c0.c0_rt[i].fr_reg);
2707         }
2708       else ra = 0;
2709     }
2710   
2711  finish_frame_analysis:
2712   cache->pc = start_pc;
2713   cache->ra = ra;
2714   /* RA == 0 marks the outermost frame.  Do not go past it.  */
2715   cache->prev_sp = (ra != 0) ?  prev_sp : 0;
2716   cache->c0.fp_regnum = fp_regnum;
2717   cache->c0.c0_frmsz = c0_frmsz;
2718   cache->c0.c0_hasfp = c0_hasfp;
2719   cache->c0.c0_fp = fp;
2720 }
2721
2722 static CORE_ADDR a0_saved;
2723 static CORE_ADDR a7_saved;
2724 static CORE_ADDR a11_saved;
2725 static int a0_was_saved;
2726 static int a7_was_saved;
2727 static int a11_was_saved;
2728
2729 /* Simulate L32E instruction:  AT <-- ref (AS + offset).  */
2730 static void
2731 execute_l32e (struct gdbarch *gdbarch, int at, int as, int offset, CORE_ADDR wb)
2732 {
2733   int atreg = arreg_number (gdbarch, gdbarch_tdep (gdbarch)->a0_base + at, wb);
2734   int asreg = arreg_number (gdbarch, gdbarch_tdep (gdbarch)->a0_base + as, wb);
2735   CORE_ADDR addr = xtensa_read_register (asreg) + offset;
2736   unsigned int spilled_value
2737     = read_memory_unsigned_integer (addr, 4, gdbarch_byte_order (gdbarch));
2738
2739   if ((at == 0) && !a0_was_saved)
2740     {
2741       a0_saved = xtensa_read_register (atreg);
2742       a0_was_saved = 1;
2743     }
2744   else if ((at == 7) && !a7_was_saved)
2745     {
2746       a7_saved = xtensa_read_register (atreg);
2747       a7_was_saved = 1;
2748     }
2749   else if ((at == 11) && !a11_was_saved)
2750     {
2751       a11_saved = xtensa_read_register (atreg);
2752       a11_was_saved = 1;
2753     }
2754
2755   xtensa_write_register (atreg, spilled_value);
2756 }
2757
2758 /* Simulate S32E instruction:  AT --> ref (AS + offset).  */
2759 static void
2760 execute_s32e (struct gdbarch *gdbarch, int at, int as, int offset, CORE_ADDR wb)
2761 {
2762   int atreg = arreg_number (gdbarch, gdbarch_tdep (gdbarch)->a0_base + at, wb);
2763   int asreg = arreg_number (gdbarch, gdbarch_tdep (gdbarch)->a0_base + as, wb);
2764   CORE_ADDR addr = xtensa_read_register (asreg) + offset;
2765   ULONGEST spilled_value = xtensa_read_register (atreg);
2766
2767   write_memory_unsigned_integer (addr, 4,
2768                                  gdbarch_byte_order (gdbarch),
2769                                  spilled_value);
2770 }
2771
2772 #define XTENSA_MAX_WINDOW_INTERRUPT_HANDLER_LEN  200
2773
2774 typedef enum
2775 {
2776   xtWindowOverflow,
2777   xtWindowUnderflow,
2778   xtNoExceptionHandler
2779 } xtensa_exception_handler_t;
2780
2781 /* Execute instruction stream from current PC until hitting RFWU or RFWO.
2782    Return type of Xtensa Window Interrupt Handler on success.  */
2783 static xtensa_exception_handler_t
2784 execute_code (struct gdbarch *gdbarch, CORE_ADDR current_pc, CORE_ADDR wb)
2785 {
2786   xtensa_isa isa;
2787   xtensa_insnbuf ins, slot;
2788   gdb_byte ibuf[XTENSA_ISA_BSZ];
2789   CORE_ADDR ia, bt, ba;
2790   xtensa_format ifmt;
2791   int ilen, islots, is;
2792   xtensa_opcode opc;
2793   int insn_num = 0;
2794   void (*func) (struct gdbarch *, int, int, int, CORE_ADDR);
2795
2796   uint32_t at, as, offset;
2797
2798   /* WindowUnderflow12 = true, when inside _WindowUnderflow12.  */ 
2799   int WindowUnderflow12 = (current_pc & 0x1ff) >= 0x140; 
2800
2801   isa = xtensa_default_isa;
2802   gdb_assert (XTENSA_ISA_BSZ >= xtensa_isa_maxlength (isa));
2803   ins = xtensa_insnbuf_alloc (isa);
2804   slot = xtensa_insnbuf_alloc (isa);
2805   ba = 0;
2806   ia = current_pc;
2807   bt = ia;
2808
2809   a0_was_saved = 0;
2810   a7_was_saved = 0;
2811   a11_was_saved = 0;
2812
2813   while (insn_num++ < XTENSA_MAX_WINDOW_INTERRUPT_HANDLER_LEN)
2814     {
2815       if (ia + xtensa_isa_maxlength (isa) > bt)
2816         {
2817           ba = ia;
2818           bt = (ba + XTENSA_ISA_BSZ);
2819           if (target_read_memory (ba, ibuf, bt - ba) != 0)
2820             return xtNoExceptionHandler;
2821         }
2822       xtensa_insnbuf_from_chars (isa, ins, &ibuf[ia-ba], 0);
2823       ifmt = xtensa_format_decode (isa, ins);
2824       if (ifmt == XTENSA_UNDEFINED)
2825         return xtNoExceptionHandler;
2826       ilen = xtensa_format_length (isa, ifmt);
2827       if (ilen == XTENSA_UNDEFINED)
2828         return xtNoExceptionHandler;
2829       islots = xtensa_format_num_slots (isa, ifmt);
2830       if (islots == XTENSA_UNDEFINED)
2831         return xtNoExceptionHandler;
2832       for (is = 0; is < islots; ++is)
2833         {
2834           if (xtensa_format_get_slot (isa, ifmt, is, ins, slot))
2835             return xtNoExceptionHandler;
2836           opc = xtensa_opcode_decode (isa, ifmt, is, slot);
2837           if (opc == XTENSA_UNDEFINED) 
2838             return xtNoExceptionHandler;
2839           switch (call0_classify_opcode (isa, opc))
2840             {
2841             case c0opc_illegal:
2842             case c0opc_flow:
2843             case c0opc_entry:
2844             case c0opc_break:
2845               /* We expect none of them here.  */
2846               return xtNoExceptionHandler;
2847             case c0opc_l32e:
2848               func = execute_l32e;
2849               break;
2850             case c0opc_s32e:
2851               func = execute_s32e;
2852               break;
2853             case c0opc_rfwo: /* RFWO.  */
2854               /* Here, we return from WindowOverflow handler and,
2855                  if we stopped at the very beginning, which means
2856                  A0 was saved, we have to restore it now.  */
2857               if (a0_was_saved)
2858                 {
2859                   int arreg = arreg_number (gdbarch,
2860                                             gdbarch_tdep (gdbarch)->a0_base,
2861                                             wb);
2862                   xtensa_write_register (arreg, a0_saved);
2863                 }
2864               return xtWindowOverflow;
2865             case c0opc_rfwu: /* RFWU.  */
2866               /* Here, we return from WindowUnderflow handler.
2867                  Let's see if either A7 or A11 has to be restored.  */
2868               if (WindowUnderflow12)
2869                 {
2870                   if (a11_was_saved)
2871                     {
2872                       int arreg = arreg_number (gdbarch,
2873                                                 gdbarch_tdep (gdbarch)->a0_base + 11,
2874                                                 wb);
2875                       xtensa_write_register (arreg, a11_saved);
2876                     }
2877                 }
2878               else if (a7_was_saved)
2879                 {
2880                   int arreg = arreg_number (gdbarch,
2881                                             gdbarch_tdep (gdbarch)->a0_base + 7,
2882                                             wb);
2883                   xtensa_write_register (arreg, a7_saved);
2884                 }
2885               return xtWindowUnderflow;
2886             default: /* Simply skip this insns.  */
2887               continue;
2888             }
2889
2890           /* Decode arguments for L32E / S32E and simulate their execution.  */
2891           if ( xtensa_opcode_num_operands (isa, opc) != 3 )
2892             return xtNoExceptionHandler;
2893           if (xtensa_operand_get_field (isa, opc, 0, ifmt, is, slot, &at))
2894             return xtNoExceptionHandler;
2895           if (xtensa_operand_decode (isa, opc, 0, &at))
2896             return xtNoExceptionHandler;
2897           if (xtensa_operand_get_field (isa, opc, 1, ifmt, is, slot, &as))
2898             return xtNoExceptionHandler;
2899           if (xtensa_operand_decode (isa, opc, 1, &as))
2900             return xtNoExceptionHandler;
2901           if (xtensa_operand_get_field (isa, opc, 2, ifmt, is, slot, &offset))
2902             return xtNoExceptionHandler;
2903           if (xtensa_operand_decode (isa, opc, 2, &offset))
2904             return xtNoExceptionHandler;
2905
2906           (*func) (gdbarch, at, as, offset, wb);
2907         }
2908
2909       ia += ilen;
2910     }
2911   return xtNoExceptionHandler;
2912 }
2913
2914 /* Handle Window Overflow / Underflow exception frames.  */
2915
2916 static void
2917 xtensa_window_interrupt_frame_cache (struct frame_info *this_frame,
2918                                      xtensa_frame_cache_t *cache,
2919                                      CORE_ADDR pc)
2920 {
2921   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2922   CORE_ADDR ps, wb, ws, ra;
2923   int epc1_regnum, i, regnum;
2924   xtensa_exception_handler_t eh_type;
2925
2926   /* Read PS, WB, and WS from the hardware. Note that PS register
2927      must be present, if Windowed ABI is supported.  */
2928   ps = xtensa_read_register (gdbarch_ps_regnum (gdbarch));
2929   wb = xtensa_read_register (gdbarch_tdep (gdbarch)->wb_regnum);
2930   ws = xtensa_read_register (gdbarch_tdep (gdbarch)->ws_regnum);
2931
2932   /* Execute all the remaining instructions from Window Interrupt Handler
2933      by simulating them on the remote protocol level.  On return, set the
2934      type of Xtensa Window Interrupt Handler, or report an error.  */
2935   eh_type = execute_code (gdbarch, pc, wb);
2936   if (eh_type == xtNoExceptionHandler)
2937     error (_("\
2938 Unable to decode Xtensa Window Interrupt Handler's code."));
2939
2940   cache->ps = ps ^ PS_EXC;      /* Clear the exception bit in PS.  */
2941   cache->call0 = 0;             /* It's Windowed ABI.  */
2942
2943   /* All registers for the cached frame will be alive.  */
2944   for (i = 0; i < XTENSA_NUM_SAVED_AREGS; i++)
2945     cache->wd.aregs[i] = -1;
2946
2947   if (eh_type == xtWindowOverflow)
2948     cache->wd.ws = ws ^ (1 << wb);
2949   else /* eh_type == xtWindowUnderflow.  */
2950     cache->wd.ws = ws | (1 << wb);
2951
2952   cache->wd.wb = (ps & 0xf00) >> 8; /* Set WB to OWB.  */
2953   regnum = arreg_number (gdbarch, gdbarch_tdep (gdbarch)->a0_base,
2954                          cache->wd.wb);
2955   ra = xtensa_read_register (regnum);
2956   cache->wd.callsize = WINSIZE (ra);
2957   cache->prev_sp = xtensa_read_register (regnum + 1);
2958   /* Set regnum to a frame pointer of the frame being cached.  */
2959   regnum = xtensa_scan_prologue (gdbarch, pc);
2960   regnum = arreg_number (gdbarch,
2961                          gdbarch_tdep (gdbarch)->a0_base + regnum,
2962                          cache->wd.wb);
2963   cache->base = get_frame_register_unsigned (this_frame, regnum);
2964
2965   /* Read PC of interrupted function from EPC1 register.  */
2966   epc1_regnum = xtensa_find_register_by_name (gdbarch,"epc1");
2967   if (epc1_regnum < 0)
2968     error(_("Unable to read Xtensa register EPC1"));
2969   cache->ra = xtensa_read_register (epc1_regnum);
2970   cache->pc = get_frame_func (this_frame);
2971 }
2972
2973
2974 /* Skip function prologue.
2975
2976    Return the pc of the first instruction after prologue.  GDB calls this to
2977    find the address of the first line of the function or (if there is no line
2978    number information) to skip the prologue for planting breakpoints on 
2979    function entries.  Use debug info (if present) or prologue analysis to skip 
2980    the prologue to achieve reliable debugging behavior.  For windowed ABI, 
2981    only the 'entry' instruction is skipped.  It is not strictly necessary to 
2982    skip the prologue (Call0) or 'entry' (Windowed) because xt-gdb knows how to
2983    backtrace at any point in the prologue, however certain potential hazards 
2984    are avoided and a more "normal" debugging experience is ensured by 
2985    skipping the prologue (can be disabled by defining DONT_SKIP_PROLOG).
2986    For example, if we don't skip the prologue:
2987    - Some args may not yet have been saved to the stack where the debug
2988      info expects to find them (true anyway when only 'entry' is skipped);
2989    - Software breakpoints ('break' instrs) may not have been unplanted 
2990      when the prologue analysis is done on initializing the frame cache, 
2991      and breaks in the prologue will throw off the analysis.
2992
2993    If we have debug info ( line-number info, in particular ) we simply skip
2994    the code associated with the first function line effectively skipping
2995    the prologue code.  It works even in cases like
2996
2997    int main()
2998    {    int local_var = 1;
2999         ....
3000    }
3001
3002    because, for this source code, both Xtensa compilers will generate two
3003    separate entries ( with the same line number ) in dwarf line-number
3004    section to make sure there is a boundary between the prologue code and
3005    the rest of the function.
3006
3007    If there is no debug info, we need to analyze the code.  */
3008
3009 /* #define DONT_SKIP_PROLOGUE  */
3010
3011 static CORE_ADDR
3012 xtensa_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
3013 {
3014   struct symtab_and_line prologue_sal;
3015   CORE_ADDR body_pc;
3016
3017   DEBUGTRACE ("xtensa_skip_prologue (start_pc = 0x%08x)\n", (int) start_pc);
3018
3019 #if DONT_SKIP_PROLOGUE
3020   return start_pc;
3021 #endif
3022
3023  /* Try to find first body line from debug info.  */
3024
3025   prologue_sal = find_pc_line (start_pc, 0);
3026   if (prologue_sal.line != 0) /* Found debug info.  */
3027     {
3028       /* In Call0,  it is possible to have a function with only one instruction
3029          ('ret') resulting from a one-line optimized function that does nothing.
3030          In that case,  prologue_sal.end may actually point to the start of the
3031          next function in the text section,  causing a breakpoint to be set at
3032          the wrong place.  Check,  if the end address is within a different
3033          function,  and if so return the start PC.  We know we have symbol
3034          information.  */
3035
3036       CORE_ADDR end_func;
3037
3038       if ((gdbarch_tdep (gdbarch)->call_abi == CallAbiCall0Only)
3039           && call0_ret (start_pc, prologue_sal.end))
3040         return start_pc;
3041
3042       find_pc_partial_function (prologue_sal.end, NULL, &end_func, NULL);
3043       if (end_func != start_pc)
3044         return start_pc;
3045
3046       return prologue_sal.end;
3047     }
3048
3049   /* No debug line info.  Analyze prologue for Call0 or simply skip ENTRY.  */
3050   body_pc = call0_analyze_prologue (gdbarch, start_pc, 0, 0,
3051                                     xtensa_alloc_frame_cache (0));
3052   return body_pc != 0 ? body_pc : start_pc;
3053 }
3054
3055 /* Verify the current configuration.  */
3056 static void
3057 xtensa_verify_config (struct gdbarch *gdbarch)
3058 {
3059   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3060   string_file log;
3061
3062   /* Verify that we got a reasonable number of AREGS.  */
3063   if ((tdep->num_aregs & -tdep->num_aregs) != tdep->num_aregs)
3064     log.printf (_("\
3065 \n\tnum_aregs: Number of AR registers (%d) is not a power of two!"),
3066                 tdep->num_aregs);
3067
3068   /* Verify that certain registers exist.  */
3069
3070   if (tdep->pc_regnum == -1)
3071     log.printf (_("\n\tpc_regnum: No PC register"));
3072   if (tdep->isa_use_exceptions && tdep->ps_regnum == -1)
3073     log.printf (_("\n\tps_regnum: No PS register"));
3074
3075   if (tdep->isa_use_windowed_registers)
3076     {
3077       if (tdep->wb_regnum == -1)
3078         log.printf (_("\n\twb_regnum: No WB register"));
3079       if (tdep->ws_regnum == -1)
3080         log.printf (_("\n\tws_regnum: No WS register"));
3081       if (tdep->ar_base == -1)
3082         log.printf (_("\n\tar_base: No AR registers"));
3083     }
3084
3085   if (tdep->a0_base == -1)
3086     log.printf (_("\n\ta0_base: No Ax registers"));
3087
3088   if (!log.empty ())
3089     internal_error (__FILE__, __LINE__,
3090                     _("the following are invalid: %s"), log.c_str ());
3091 }
3092
3093
3094 /* Derive specific register numbers from the array of registers.  */
3095
3096 static void
3097 xtensa_derive_tdep (struct gdbarch_tdep *tdep)
3098 {
3099   xtensa_register_t* rmap;
3100   int n, max_size = 4;
3101
3102   tdep->num_regs = 0;
3103   tdep->num_nopriv_regs = 0;
3104
3105 /* Special registers 0..255 (core).  */
3106 #define XTENSA_DBREGN_SREG(n)  (0x0200+(n))
3107 /* User registers 0..255.  */
3108 #define XTENSA_DBREGN_UREG(n)  (0x0300+(n))
3109
3110   for (rmap = tdep->regmap, n = 0; rmap->target_number != -1; n++, rmap++)
3111     {
3112       if (rmap->target_number == 0x0020)
3113         tdep->pc_regnum = n;
3114       else if (rmap->target_number == 0x0100)
3115         tdep->ar_base = n;
3116       else if (rmap->target_number == 0x0000)
3117         tdep->a0_base = n;
3118       else if (rmap->target_number == XTENSA_DBREGN_SREG(72))
3119         tdep->wb_regnum = n;
3120       else if (rmap->target_number == XTENSA_DBREGN_SREG(73))
3121         tdep->ws_regnum = n;
3122       else if (rmap->target_number == XTENSA_DBREGN_SREG(233))
3123         tdep->debugcause_regnum = n;
3124       else if (rmap->target_number == XTENSA_DBREGN_SREG(232))
3125         tdep->exccause_regnum = n;
3126       else if (rmap->target_number == XTENSA_DBREGN_SREG(238))
3127         tdep->excvaddr_regnum = n;
3128       else if (rmap->target_number == XTENSA_DBREGN_SREG(0))
3129         tdep->lbeg_regnum = n;
3130       else if (rmap->target_number == XTENSA_DBREGN_SREG(1))
3131         tdep->lend_regnum = n;
3132       else if (rmap->target_number == XTENSA_DBREGN_SREG(2))
3133         tdep->lcount_regnum = n;
3134       else if (rmap->target_number == XTENSA_DBREGN_SREG(3))
3135         tdep->sar_regnum = n;
3136       else if (rmap->target_number == XTENSA_DBREGN_SREG(5))
3137         tdep->litbase_regnum = n;
3138       else if (rmap->target_number == XTENSA_DBREGN_SREG(230))
3139         tdep->ps_regnum = n;
3140       else if (rmap->target_number == XTENSA_DBREGN_UREG(231))
3141         tdep->threadptr_regnum = n;
3142 #if 0
3143       else if (rmap->target_number == XTENSA_DBREGN_SREG(226))
3144         tdep->interrupt_regnum = n;
3145       else if (rmap->target_number == XTENSA_DBREGN_SREG(227))
3146         tdep->interrupt2_regnum = n;
3147       else if (rmap->target_number == XTENSA_DBREGN_SREG(224))
3148         tdep->cpenable_regnum = n;
3149 #endif
3150
3151       if (rmap->byte_size > max_size)
3152         max_size = rmap->byte_size;
3153       if (rmap->mask != 0 && tdep->num_regs == 0)
3154         tdep->num_regs = n;
3155       /* Find out out how to deal with priveleged registers.
3156
3157          if ((rmap->flags & XTENSA_REGISTER_FLAGS_PRIVILEGED) != 0
3158               && tdep->num_nopriv_regs == 0)
3159            tdep->num_nopriv_regs = n;
3160       */
3161       if ((rmap->flags & XTENSA_REGISTER_FLAGS_PRIVILEGED) != 0
3162           && tdep->num_regs == 0)
3163         tdep->num_regs = n;
3164     }
3165
3166   /* Number of pseudo registers.  */
3167   tdep->num_pseudo_regs = n - tdep->num_regs;
3168
3169   /* Empirically determined maximum sizes.  */
3170   tdep->max_register_raw_size = max_size;
3171   tdep->max_register_virtual_size = max_size;
3172 }
3173
3174 /* Module "constructor" function.  */
3175
3176 extern struct gdbarch_tdep xtensa_tdep;
3177
3178 static struct gdbarch *
3179 xtensa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
3180 {
3181   struct gdbarch_tdep *tdep;
3182   struct gdbarch *gdbarch;
3183
3184   DEBUGTRACE ("gdbarch_init()\n");
3185
3186   if (!xtensa_default_isa)
3187     xtensa_default_isa = xtensa_isa_init (0, 0);
3188
3189   /* We have to set the byte order before we call gdbarch_alloc.  */
3190   info.byte_order = XCHAL_HAVE_BE ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
3191
3192   tdep = &xtensa_tdep;
3193   gdbarch = gdbarch_alloc (&info, tdep);
3194   xtensa_derive_tdep (tdep);
3195
3196   /* Verify our configuration.  */
3197   xtensa_verify_config (gdbarch);
3198   xtensa_session_once_reported = 0;
3199
3200   set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
3201   set_gdbarch_wchar_signed (gdbarch, 0);
3202
3203   /* Pseudo-Register read/write.  */
3204   set_gdbarch_pseudo_register_read (gdbarch, xtensa_pseudo_register_read);
3205   set_gdbarch_pseudo_register_write (gdbarch, xtensa_pseudo_register_write);
3206
3207   /* Set target information.  */
3208   set_gdbarch_num_regs (gdbarch, tdep->num_regs);
3209   set_gdbarch_num_pseudo_regs (gdbarch, tdep->num_pseudo_regs);
3210   set_gdbarch_sp_regnum (gdbarch, tdep->a0_base + 1);
3211   set_gdbarch_pc_regnum (gdbarch, tdep->pc_regnum);
3212   set_gdbarch_ps_regnum (gdbarch, tdep->ps_regnum);
3213
3214   /* Renumber registers for known formats (stabs and dwarf2).  */
3215   set_gdbarch_stab_reg_to_regnum (gdbarch, xtensa_reg_to_regnum);
3216   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, xtensa_reg_to_regnum);
3217
3218   /* We provide our own function to get register information.  */
3219   set_gdbarch_register_name (gdbarch, xtensa_register_name);
3220   set_gdbarch_register_type (gdbarch, xtensa_register_type);
3221
3222   /* To call functions from GDB using dummy frame.  */
3223   set_gdbarch_push_dummy_call (gdbarch, xtensa_push_dummy_call);
3224
3225   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
3226
3227   set_gdbarch_return_value (gdbarch, xtensa_return_value);
3228
3229   /* Advance PC across any prologue instructions to reach "real" code.  */
3230   set_gdbarch_skip_prologue (gdbarch, xtensa_skip_prologue);
3231
3232   /* Stack grows downward.  */
3233   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
3234
3235   /* Set breakpoints.  */
3236   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
3237                                        xtensa_breakpoint_kind_from_pc);
3238   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
3239                                        xtensa_sw_breakpoint_from_kind);
3240
3241   /* After breakpoint instruction or illegal instruction, pc still
3242      points at break instruction, so don't decrement.  */
3243   set_gdbarch_decr_pc_after_break (gdbarch, 0);
3244
3245   /* We don't skip args.  */
3246   set_gdbarch_frame_args_skip (gdbarch, 0);
3247
3248   set_gdbarch_unwind_pc (gdbarch, xtensa_unwind_pc);
3249
3250   set_gdbarch_frame_align (gdbarch, xtensa_frame_align);
3251
3252   set_gdbarch_dummy_id (gdbarch, xtensa_dummy_id);
3253
3254   /* Frame handling.  */
3255   frame_base_set_default (gdbarch, &xtensa_frame_base);
3256   frame_unwind_append_unwinder (gdbarch, &xtensa_unwind);
3257   dwarf2_append_unwinders (gdbarch);
3258
3259   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
3260
3261   xtensa_add_reggroups (gdbarch);
3262   set_gdbarch_register_reggroup_p (gdbarch, xtensa_register_reggroup_p);
3263
3264   set_gdbarch_iterate_over_regset_sections
3265     (gdbarch, xtensa_iterate_over_regset_sections);
3266
3267   set_solib_svr4_fetch_link_map_offsets
3268     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
3269
3270   /* Hook in the ABI-specific overrides, if they have been registered.  */
3271   gdbarch_init_osabi (info, gdbarch);
3272
3273   return gdbarch;
3274 }
3275
3276 static void
3277 xtensa_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
3278 {
3279   error (_("xtensa_dump_tdep(): not implemented"));
3280 }
3281
3282 /* Provide a prototype to silence -Wmissing-prototypes.  */
3283 extern initialize_file_ftype _initialize_xtensa_tdep;
3284
3285 void
3286 _initialize_xtensa_tdep (void)
3287 {
3288   gdbarch_register (bfd_arch_xtensa, xtensa_gdbarch_init, xtensa_dump_tdep);
3289   xtensa_init_reggroups ();
3290
3291   add_setshow_zuinteger_cmd ("xtensa",
3292                              class_maintenance,
3293                              &xtensa_debug_level,
3294                             _("Set Xtensa debugging."),
3295                             _("Show Xtensa debugging."), _("\
3296 When non-zero, Xtensa-specific debugging is enabled. \
3297 Can be 1, 2, 3, or 4 indicating the level of debugging."),
3298                              NULL,
3299                              NULL,
3300                              &setdebuglist, &showdebuglist);
3301 }