]> Git Repo - binutils.git/blob - gdb/avr-tdep.c
gdb: remove SYMBOL_CLASS macro, add getter
[binutils.git] / gdb / avr-tdep.c
1 /* Target-dependent code for Atmel AVR, for GDB.
2
3    Copyright (C) 1996-2022 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 /* Contributed by Theodore A. Roth, [email protected] */
21
22 /* Portions of this file were taken from the original gdb-4.18 patch developed
23    by Denis Chertykov, [email protected] */
24
25 #include "defs.h"
26 #include "frame.h"
27 #include "frame-unwind.h"
28 #include "frame-base.h"
29 #include "trad-frame.h"
30 #include "gdbcmd.h"
31 #include "gdbcore.h"
32 #include "gdbtypes.h"
33 #include "inferior.h"
34 #include "symfile.h"
35 #include "arch-utils.h"
36 #include "regcache.h"
37 #include "dis-asm.h"
38 #include "objfiles.h"
39 #include <algorithm>
40 #include "gdbarch.h"
41
42 /* AVR Background:
43
44    (AVR micros are pure Harvard Architecture processors.)
45
46    The AVR family of microcontrollers have three distinctly different memory
47    spaces: flash, sram and eeprom.  The flash is 16 bits wide and is used for
48    the most part to store program instructions.  The sram is 8 bits wide and is
49    used for the stack and the heap.  Some devices lack sram and some can have
50    an additional external sram added on as a peripheral.
51
52    The eeprom is 8 bits wide and is used to store data when the device is
53    powered down.  Eeprom is not directly accessible, it can only be accessed
54    via io-registers using a special algorithm.  Accessing eeprom via gdb's
55    remote serial protocol ('m' or 'M' packets) looks difficult to do and is
56    not included at this time.
57
58    [The eeprom could be read manually via ``x/b <eaddr + AVR_EMEM_START>'' or
59    written using ``set {unsigned char}<eaddr + AVR_EMEM_START>''.  For this to
60    work, the remote target must be able to handle eeprom accesses and perform
61    the address translation.]
62
63    All three memory spaces have physical addresses beginning at 0x0.  In
64    addition, the flash is addressed by gcc/binutils/gdb with respect to 8 bit
65    bytes instead of the 16 bit wide words used by the real device for the
66    Program Counter.
67
68    In order for remote targets to work correctly, extra bits must be added to
69    addresses before they are send to the target or received from the target
70    via the remote serial protocol.  The extra bits are the MSBs and are used to
71    decode which memory space the address is referring to.  */
72
73 /* Constants: prefixed with AVR_ to avoid name space clashes */
74
75 /* Address space flags */
76
77 /* We are assigning the TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1 to the flash address
78    space.  */
79
80 #define AVR_TYPE_ADDRESS_CLASS_FLASH TYPE_ADDRESS_CLASS_1
81 #define AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH  \
82   TYPE_INSTANCE_FLAG_ADDRESS_CLASS_1
83
84
85 enum
86 {
87   AVR_REG_W = 24,
88   AVR_REG_X = 26,
89   AVR_REG_Y = 28,
90   AVR_FP_REGNUM = 28,
91   AVR_REG_Z = 30,
92
93   AVR_SREG_REGNUM = 32,
94   AVR_SP_REGNUM = 33,
95   AVR_PC_REGNUM = 34,
96
97   AVR_NUM_REGS = 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
98   AVR_NUM_REG_BYTES = 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
99
100   /* Pseudo registers.  */
101   AVR_PSEUDO_PC_REGNUM = 35,
102   AVR_NUM_PSEUDO_REGS = 1,
103
104   AVR_PC_REG_INDEX = 35,        /* index into array of registers */
105
106   AVR_MAX_PROLOGUE_SIZE = 64,   /* bytes */
107
108   /* Count of pushed registers.  From r2 to r17 (inclusively), r28, r29 */
109   AVR_MAX_PUSHES = 18,
110
111   /* Number of the last pushed register.  r17 for current avr-gcc */
112   AVR_LAST_PUSHED_REGNUM = 17,
113
114   AVR_ARG1_REGNUM = 24,         /* Single byte argument */
115   AVR_ARGN_REGNUM = 25,         /* Multi byte argments */
116   AVR_LAST_ARG_REGNUM = 8,      /* Last argument register */
117
118   AVR_RET1_REGNUM = 24,         /* Single byte return value */
119   AVR_RETN_REGNUM = 25,         /* Multi byte return value */
120
121   /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
122      bits?  Do these have to match the bfd vma values?  It sure would make
123      things easier in the future if they didn't need to match.
124
125      Note: I chose these values so as to be consistent with bfd vma
126      addresses.
127
128      TRoth/2002-04-08: There is already a conflict with very large programs
129      in the mega128.  The mega128 has 128K instruction bytes (64K words),
130      thus the Most Significant Bit is 0x10000 which gets masked off my
131      AVR_MEM_MASK.
132
133      The problem manifests itself when trying to set a breakpoint in a
134      function which resides in the upper half of the instruction space and
135      thus requires a 17-bit address.
136
137      For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
138      from 0x00ff0000 to 0x00f00000.  Eeprom is not accessible from gdb yet,
139      but could be for some remote targets by just adding the correct offset
140      to the address and letting the remote target handle the low-level
141      details of actually accessing the eeprom.  */
142
143   AVR_IMEM_START = 0x00000000,  /* INSN memory */
144   AVR_SMEM_START = 0x00800000,  /* SRAM memory */
145 #if 1
146   /* No eeprom mask defined */
147   AVR_MEM_MASK = 0x00f00000,    /* mask to determine memory space */
148 #else
149   AVR_EMEM_START = 0x00810000,  /* EEPROM memory */
150   AVR_MEM_MASK = 0x00ff0000,    /* mask to determine memory space */
151 #endif
152 };
153
154 /* Prologue types:
155
156    NORMAL and CALL are the typical types (the -mcall-prologues gcc option
157    causes the generation of the CALL type prologues).  */
158
159 enum {
160     AVR_PROLOGUE_NONE,              /* No prologue */
161     AVR_PROLOGUE_NORMAL,
162     AVR_PROLOGUE_CALL,              /* -mcall-prologues */
163     AVR_PROLOGUE_MAIN,
164     AVR_PROLOGUE_INTR,              /* interrupt handler */
165     AVR_PROLOGUE_SIG,               /* signal handler */
166 };
167
168 /* Any function with a frame looks like this
169    .......    <-SP POINTS HERE
170    LOCALS1    <-FP POINTS HERE
171    LOCALS0
172    SAVED FP
173    SAVED R3
174    SAVED R2
175    RET PC
176    FIRST ARG
177    SECOND ARG */
178
179 struct avr_unwind_cache
180 {
181   /* The previous frame's inner most stack address.  Used as this
182      frame ID's stack_addr.  */
183   CORE_ADDR prev_sp;
184   /* The frame's base, optionally used by the high-level debug info.  */
185   CORE_ADDR base;
186   int size;
187   int prologue_type;
188   /* Table indicating the location of each and every register.  */
189   trad_frame_saved_reg *saved_regs;
190 };
191
192 struct avr_gdbarch_tdep : gdbarch_tdep
193 {
194   /* Number of bytes stored to the stack by call instructions.
195      2 bytes for avr1-5 and avrxmega1-5, 3 bytes for avr6 and avrxmega6-7.  */
196   int call_length = 0;
197
198   /* Type for void.  */
199   struct type *void_type = nullptr;
200   /* Type for a function returning void.  */
201   struct type *func_void_type = nullptr;
202   /* Type for a pointer to a function.  Used for the type of PC.  */
203   struct type *pc_type = nullptr;
204 };
205
206 /* Lookup the name of a register given it's number.  */
207
208 static const char *
209 avr_register_name (struct gdbarch *gdbarch, int regnum)
210 {
211   static const char * const register_names[] = {
212     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
213     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
214     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
215     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
216     "SREG", "SP", "PC2",
217     "pc"
218   };
219   if (regnum < 0)
220     return NULL;
221   if (regnum >= (sizeof (register_names) / sizeof (*register_names)))
222     return NULL;
223   return register_names[regnum];
224 }
225
226 /* Return the GDB type object for the "standard" data type
227    of data in register N.  */
228
229 static struct type *
230 avr_register_type (struct gdbarch *gdbarch, int reg_nr)
231 {
232   if (reg_nr == AVR_PC_REGNUM)
233     return builtin_type (gdbarch)->builtin_uint32;
234
235   avr_gdbarch_tdep *tdep = (avr_gdbarch_tdep *) gdbarch_tdep (gdbarch);
236   if (reg_nr == AVR_PSEUDO_PC_REGNUM)
237     return tdep->pc_type;
238
239   if (reg_nr == AVR_SP_REGNUM)
240     return builtin_type (gdbarch)->builtin_data_ptr;
241
242   return builtin_type (gdbarch)->builtin_uint8;
243 }
244
245 /* Instruction address checks and convertions.  */
246
247 static CORE_ADDR
248 avr_make_iaddr (CORE_ADDR x)
249 {
250   return ((x) | AVR_IMEM_START);
251 }
252
253 /* FIXME: TRoth: Really need to use a larger mask for instructions.  Some
254    devices are already up to 128KBytes of flash space.
255
256    TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined.  */
257
258 static CORE_ADDR
259 avr_convert_iaddr_to_raw (CORE_ADDR x)
260 {
261   return ((x) & 0xffffffff);
262 }
263
264 /* SRAM address checks and convertions.  */
265
266 static CORE_ADDR
267 avr_make_saddr (CORE_ADDR x)
268 {
269   /* Return 0 for NULL.  */
270   if (x == 0)
271     return 0;
272
273   return ((x) | AVR_SMEM_START);
274 }
275
276 static CORE_ADDR
277 avr_convert_saddr_to_raw (CORE_ADDR x)
278 {
279   return ((x) & 0xffffffff);
280 }
281
282 /* EEPROM address checks and convertions.  I don't know if these will ever
283    actually be used, but I've added them just the same.  TRoth */
284
285 /* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
286    programs in the mega128.  */
287
288 /*  static CORE_ADDR */
289 /*  avr_make_eaddr (CORE_ADDR x) */
290 /*  { */
291 /*    return ((x) | AVR_EMEM_START); */
292 /*  } */
293
294 /*  static int */
295 /*  avr_eaddr_p (CORE_ADDR x) */
296 /*  { */
297 /*    return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
298 /*  } */
299
300 /*  static CORE_ADDR */
301 /*  avr_convert_eaddr_to_raw (CORE_ADDR x) */
302 /*  { */
303 /*    return ((x) & 0xffffffff); */
304 /*  } */
305
306 /* Convert from address to pointer and vice-versa.  */
307
308 static void
309 avr_address_to_pointer (struct gdbarch *gdbarch,
310                         struct type *type, gdb_byte *buf, CORE_ADDR addr)
311 {
312   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
313
314   /* Is it a data address in flash?  */
315   if (AVR_TYPE_ADDRESS_CLASS_FLASH (type))
316     {
317       /* A data pointer in flash is byte addressed.  */
318       store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
319                               avr_convert_iaddr_to_raw (addr));
320     }
321   /* Is it a code address?  */
322   else if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC
323            || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_METHOD)
324     {
325       /* A code pointer is word (16 bits) addressed.  We shift the address down
326          by 1 bit to convert it to a pointer.  */
327       store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
328                               avr_convert_iaddr_to_raw (addr >> 1));
329     }
330   else
331     {
332       /* Strip off any upper segment bits.  */
333       store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
334                               avr_convert_saddr_to_raw (addr));
335     }
336 }
337
338 static CORE_ADDR
339 avr_pointer_to_address (struct gdbarch *gdbarch,
340                         struct type *type, const gdb_byte *buf)
341 {
342   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
343   CORE_ADDR addr
344     = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
345
346   /* Is it a data address in flash?  */
347   if (AVR_TYPE_ADDRESS_CLASS_FLASH (type))
348     {
349       /* A data pointer in flash is already byte addressed.  */
350       return avr_make_iaddr (addr);
351     }
352   /* Is it a code address?  */
353   else if (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_FUNC
354            || TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_METHOD
355            || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
356     {
357       /* A code pointer is word (16 bits) addressed so we shift it up
358          by 1 bit to convert it to an address.  */
359       return avr_make_iaddr (addr << 1);
360     }
361   else
362     return avr_make_saddr (addr);
363 }
364
365 static CORE_ADDR
366 avr_integer_to_address (struct gdbarch *gdbarch,
367                         struct type *type, const gdb_byte *buf)
368 {
369   ULONGEST addr = unpack_long (type, buf);
370
371   if (TYPE_DATA_SPACE (type))
372     return avr_make_saddr (addr);
373   else
374     return avr_make_iaddr (addr);
375 }
376
377 static CORE_ADDR
378 avr_read_pc (readable_regcache *regcache)
379 {
380   ULONGEST pc;
381
382   regcache->cooked_read (AVR_PC_REGNUM, &pc);
383   return avr_make_iaddr (pc);
384 }
385
386 static void
387 avr_write_pc (struct regcache *regcache, CORE_ADDR val)
388 {
389   regcache_cooked_write_unsigned (regcache, AVR_PC_REGNUM,
390                                   avr_convert_iaddr_to_raw (val));
391 }
392
393 static enum register_status
394 avr_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
395                           int regnum, gdb_byte *buf)
396 {
397   ULONGEST val;
398   enum register_status status;
399
400   switch (regnum)
401     {
402     case AVR_PSEUDO_PC_REGNUM:
403       status = regcache->raw_read (AVR_PC_REGNUM, &val);
404       if (status != REG_VALID)
405         return status;
406       val >>= 1;
407       store_unsigned_integer (buf, 4, gdbarch_byte_order (gdbarch), val);
408       return status;
409     default:
410       internal_error (__FILE__, __LINE__, _("invalid regnum"));
411     }
412 }
413
414 static void
415 avr_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
416                            int regnum, const gdb_byte *buf)
417 {
418   ULONGEST val;
419
420   switch (regnum)
421     {
422     case AVR_PSEUDO_PC_REGNUM:
423       val = extract_unsigned_integer (buf, 4, gdbarch_byte_order (gdbarch));
424       val <<= 1;
425       regcache_raw_write_unsigned (regcache, AVR_PC_REGNUM, val);
426       break;
427     default:
428       internal_error (__FILE__, __LINE__, _("invalid regnum"));
429     }
430 }
431
432 /* Function: avr_scan_prologue
433
434    This function decodes an AVR function prologue to determine:
435      1) the size of the stack frame
436      2) which registers are saved on it
437      3) the offsets of saved regs
438    This information is stored in the avr_unwind_cache structure.
439
440    Some devices lack the sbiw instruction, so on those replace this:
441         sbiw    r28, XX
442    with this:
443         subi    r28,lo8(XX)
444         sbci    r29,hi8(XX)
445
446    A typical AVR function prologue with a frame pointer might look like this:
447         push    rXX        ; saved regs
448         ...
449         push    r28
450         push    r29
451         in      r28,__SP_L__
452         in      r29,__SP_H__
453         sbiw    r28,<LOCALS_SIZE>
454         in      __tmp_reg__,__SREG__
455         cli
456         out     __SP_H__,r29
457         out     __SREG__,__tmp_reg__
458         out     __SP_L__,r28
459
460    A typical AVR function prologue without a frame pointer might look like
461    this:
462         push    rXX        ; saved regs
463         ...
464
465    A main function prologue looks like this:
466         ldi     r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
467         ldi     r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
468         out     __SP_H__,r29
469         out     __SP_L__,r28
470
471    A signal handler prologue looks like this:
472         push    __zero_reg__
473         push    __tmp_reg__
474         in      __tmp_reg__, __SREG__
475         push    __tmp_reg__
476         clr     __zero_reg__
477         push    rXX             ; save registers r18:r27, r30:r31
478         ...
479         push    r28             ; save frame pointer
480         push    r29
481         in      r28, __SP_L__
482         in      r29, __SP_H__
483         sbiw    r28, <LOCALS_SIZE>
484         out     __SP_H__, r29
485         out     __SP_L__, r28
486         
487    A interrupt handler prologue looks like this:
488         sei
489         push    __zero_reg__
490         push    __tmp_reg__
491         in      __tmp_reg__, __SREG__
492         push    __tmp_reg__
493         clr     __zero_reg__
494         push    rXX             ; save registers r18:r27, r30:r31
495         ...
496         push    r28             ; save frame pointer
497         push    r29
498         in      r28, __SP_L__
499         in      r29, __SP_H__
500         sbiw    r28, <LOCALS_SIZE>
501         cli
502         out     __SP_H__, r29
503         sei     
504         out     __SP_L__, r28
505
506    A `-mcall-prologues' prologue looks like this (Note that the megas use a
507    jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
508    32 bit insn and rjmp is a 16 bit insn):
509         ldi     r26,lo8(<LOCALS_SIZE>)
510         ldi     r27,hi8(<LOCALS_SIZE>)
511         ldi     r30,pm_lo8(.L_foo_body)
512         ldi     r31,pm_hi8(.L_foo_body)
513         rjmp    __prologue_saves__+RRR
514         .L_foo_body:  */
515
516 /* Not really part of a prologue, but still need to scan for it, is when a
517    function prologue moves values passed via registers as arguments to new
518    registers.  In this case, all local variables live in registers, so there
519    may be some register saves.  This is what it looks like:
520         movw    rMM, rNN
521         ...
522
523    There could be multiple movw's.  If the target doesn't have a movw insn, it
524    will use two mov insns.  This could be done after any of the above prologue
525    types.  */
526
527 static CORE_ADDR
528 avr_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR pc_beg, CORE_ADDR pc_end,
529                    struct avr_unwind_cache *info)
530 {
531   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
532   int i;
533   unsigned short insn;
534   int scan_stage = 0;
535   struct bound_minimal_symbol msymbol;
536   unsigned char prologue[AVR_MAX_PROLOGUE_SIZE];
537   int vpc = 0;
538   int len;
539
540   len = pc_end - pc_beg;
541   if (len > AVR_MAX_PROLOGUE_SIZE)
542     len = AVR_MAX_PROLOGUE_SIZE;
543
544   /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
545      reading in the bytes of the prologue.  The problem is that the figuring
546      out where the end of the prologue is is a bit difficult.  The old code 
547      tried to do that, but failed quite often.  */
548   read_memory (pc_beg, prologue, len);
549
550   /* Scanning main()'s prologue
551      ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
552      ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
553      out __SP_H__,r29
554      out __SP_L__,r28 */
555
556   if (len >= 4)
557     {
558       CORE_ADDR locals;
559       static const unsigned char img[] = {
560         0xde, 0xbf,             /* out __SP_H__,r29 */
561         0xcd, 0xbf              /* out __SP_L__,r28 */
562       };
563
564       insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
565       /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
566       if ((insn & 0xf0f0) == 0xe0c0)
567         {
568           locals = (insn & 0xf) | ((insn & 0x0f00) >> 4);
569           insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
570           /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
571           if ((insn & 0xf0f0) == 0xe0d0)
572             {
573               locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
574               if (vpc + 4 + sizeof (img) < len
575                   && memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
576                 {
577                   info->prologue_type = AVR_PROLOGUE_MAIN;
578                   info->base = locals;
579                   return pc_beg + 4;
580                 }
581             }
582         }
583     }
584
585   /* Scanning `-mcall-prologues' prologue
586      Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
587
588   while (1)     /* Using a while to avoid many goto's */
589     {
590       int loc_size;
591       int body_addr;
592       unsigned num_pushes;
593       int pc_offset = 0;
594
595       /* At least the fifth instruction must have been executed to
596          modify frame shape.  */
597       if (len < 10)
598         break;
599
600       insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
601       /* ldi r26,<LOCALS_SIZE> */
602       if ((insn & 0xf0f0) != 0xe0a0)
603         break;
604       loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4);
605       pc_offset += 2;
606
607       insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
608       /* ldi r27,<LOCALS_SIZE> / 256 */
609       if ((insn & 0xf0f0) != 0xe0b0)
610         break;
611       loc_size |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
612       pc_offset += 2;
613
614       insn = extract_unsigned_integer (&prologue[vpc + 4], 2, byte_order);
615       /* ldi r30,pm_lo8(.L_foo_body) */
616       if ((insn & 0xf0f0) != 0xe0e0)
617         break;
618       body_addr = (insn & 0xf) | ((insn & 0x0f00) >> 4);
619       pc_offset += 2;
620
621       insn = extract_unsigned_integer (&prologue[vpc + 6], 2, byte_order);
622       /* ldi r31,pm_hi8(.L_foo_body) */
623       if ((insn & 0xf0f0) != 0xe0f0)
624         break;
625       body_addr |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
626       pc_offset += 2;
627
628       msymbol = lookup_minimal_symbol ("__prologue_saves__", NULL, NULL);
629       if (!msymbol.minsym)
630         break;
631
632       insn = extract_unsigned_integer (&prologue[vpc + 8], 2, byte_order);
633       /* rjmp __prologue_saves__+RRR */
634       if ((insn & 0xf000) == 0xc000)
635         {
636           /* Extract PC relative offset from RJMP */
637           i = (insn & 0xfff) | (insn & 0x800 ? (-1 ^ 0xfff) : 0);
638           /* Convert offset to byte addressable mode */
639           i *= 2;
640           /* Destination address */
641           i += pc_beg + 10;
642
643           if (body_addr != (pc_beg + 10)/2)
644             break;
645
646           pc_offset += 2;
647         }
648       else if ((insn & 0xfe0e) == 0x940c)
649         {
650           /* Extract absolute PC address from JMP */
651           i = (((insn & 0x1) | ((insn & 0x1f0) >> 3) << 16)
652                | (extract_unsigned_integer (&prologue[vpc + 10], 2, byte_order)
653                   & 0xffff));
654           /* Convert address to byte addressable mode */
655           i *= 2;
656
657           if (body_addr != (pc_beg + 12)/2)
658             break;
659
660           pc_offset += 4;
661         }
662       else
663         break;
664
665       /* Resolve offset (in words) from __prologue_saves__ symbol.
666          Which is a pushes count in `-mcall-prologues' mode */
667       num_pushes = AVR_MAX_PUSHES - (i - BMSYMBOL_VALUE_ADDRESS (msymbol)) / 2;
668
669       if (num_pushes > AVR_MAX_PUSHES)
670         {
671           fprintf_unfiltered (gdb_stderr, _("Num pushes too large: %d\n"),
672                               num_pushes);
673           num_pushes = 0;
674         }
675
676       if (num_pushes)
677         {
678           int from;
679
680           info->saved_regs[AVR_FP_REGNUM + 1].set_addr (num_pushes);
681           if (num_pushes >= 2)
682             info->saved_regs[AVR_FP_REGNUM].set_addr (num_pushes - 1);
683
684           i = 0;
685           for (from = AVR_LAST_PUSHED_REGNUM + 1 - (num_pushes - 2);
686                from <= AVR_LAST_PUSHED_REGNUM; ++from)
687             info->saved_regs [from].set_addr (++i);
688         }
689       info->size = loc_size + num_pushes;
690       info->prologue_type = AVR_PROLOGUE_CALL;
691
692       return pc_beg + pc_offset;
693     }
694
695   /* Scan for the beginning of the prologue for an interrupt or signal
696      function.  Note that we have to set the prologue type here since the
697      third stage of the prologue may not be present (e.g. no saved registered
698      or changing of the SP register).  */
699
700   if (1)
701     {
702       static const unsigned char img[] = {
703         0x78, 0x94,             /* sei */
704         0x1f, 0x92,             /* push r1 */
705         0x0f, 0x92,             /* push r0 */
706         0x0f, 0xb6,             /* in r0,0x3f SREG */
707         0x0f, 0x92,             /* push r0 */
708         0x11, 0x24              /* clr r1 */
709       };
710       if (len >= sizeof (img)
711           && memcmp (prologue, img, sizeof (img)) == 0)
712         {
713           info->prologue_type = AVR_PROLOGUE_INTR;
714           vpc += sizeof (img);
715           info->saved_regs[AVR_SREG_REGNUM].set_addr (3);
716           info->saved_regs[0].set_addr (2);
717           info->saved_regs[1].set_addr (1);
718           info->size += 3;
719         }
720       else if (len >= sizeof (img) - 2
721                && memcmp (img + 2, prologue, sizeof (img) - 2) == 0)
722         {
723           info->prologue_type = AVR_PROLOGUE_SIG;
724           vpc += sizeof (img) - 2;
725           info->saved_regs[AVR_SREG_REGNUM].set_addr (3);
726           info->saved_regs[0].set_addr (2);
727           info->saved_regs[1].set_addr (1);
728           info->size += 2;
729         }
730     }
731
732   /* First stage of the prologue scanning.
733      Scan pushes (saved registers) */
734
735   for (; vpc < len; vpc += 2)
736     {
737       insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
738       if ((insn & 0xfe0f) == 0x920f)    /* push rXX */
739         {
740           /* Bits 4-9 contain a mask for registers R0-R32.  */
741           int regno = (insn & 0x1f0) >> 4;
742           info->size++;
743           info->saved_regs[regno].set_addr (info->size);
744           scan_stage = 1;
745         }
746       else
747         break;
748     }
749
750   gdb_assert (vpc < AVR_MAX_PROLOGUE_SIZE);
751
752   /* Handle static small stack allocation using rcall or push.  */
753   avr_gdbarch_tdep *tdep = (avr_gdbarch_tdep *) gdbarch_tdep (gdbarch);
754   while (scan_stage == 1 && vpc < len)
755     {
756       insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
757       if (insn == 0xd000)       /* rcall .+0 */
758         {
759           info->size += tdep->call_length;
760           vpc += 2;
761         }
762       else if (insn == 0x920f || insn == 0x921f)  /* push r0 or push r1 */
763         {
764           info->size += 1;
765           vpc += 2;
766         }
767       else
768         break;
769     }
770
771   /* Second stage of the prologue scanning.
772      Scan:
773      in r28,__SP_L__
774      in r29,__SP_H__ */
775
776   if (scan_stage == 1 && vpc < len)
777     {
778       static const unsigned char img[] = {
779         0xcd, 0xb7,             /* in r28,__SP_L__ */
780         0xde, 0xb7              /* in r29,__SP_H__ */
781       };
782
783       if (vpc + sizeof (img) < len
784           && memcmp (prologue + vpc, img, sizeof (img)) == 0)
785         {
786           vpc += 4;
787           scan_stage = 2;
788         }
789     }
790
791   /* Third stage of the prologue scanning.  (Really two stages).
792      Scan for:
793      sbiw r28,XX or subi r28,lo8(XX)
794                     sbci r29,hi8(XX)
795      in __tmp_reg__,__SREG__
796      cli
797      out __SP_H__,r29
798      out __SREG__,__tmp_reg__
799      out __SP_L__,r28 */
800
801   if (scan_stage == 2 && vpc < len)
802     {
803       int locals_size = 0;
804       static const unsigned char img[] = {
805         0x0f, 0xb6,             /* in r0,0x3f */
806         0xf8, 0x94,             /* cli */
807         0xde, 0xbf,             /* out 0x3e,r29 ; SPH */
808         0x0f, 0xbe,             /* out 0x3f,r0  ; SREG */
809         0xcd, 0xbf              /* out 0x3d,r28 ; SPL */
810       };
811       static const unsigned char img_sig[] = {
812         0xde, 0xbf,             /* out 0x3e,r29 ; SPH */
813         0xcd, 0xbf              /* out 0x3d,r28 ; SPL */
814       };
815       static const unsigned char img_int[] = {
816         0xf8, 0x94,             /* cli */
817         0xde, 0xbf,             /* out 0x3e,r29 ; SPH */
818         0x78, 0x94,             /* sei */
819         0xcd, 0xbf              /* out 0x3d,r28 ; SPL */
820       };
821
822       insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
823       if ((insn & 0xff30) == 0x9720)    /* sbiw r28,XXX */
824         {
825           locals_size = (insn & 0xf) | ((insn & 0xc0) >> 2);
826           vpc += 2;
827         }
828       else if ((insn & 0xf0f0) == 0x50c0)       /* subi r28,lo8(XX) */
829         {
830           locals_size = (insn & 0xf) | ((insn & 0xf00) >> 4);
831           vpc += 2;
832           insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
833           vpc += 2;
834           locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4)) << 8;
835         }
836       else
837         return pc_beg + vpc;
838
839       /* Scan the last part of the prologue.  May not be present for interrupt
840          or signal handler functions, which is why we set the prologue type
841          when we saw the beginning of the prologue previously.  */
842
843       if (vpc + sizeof (img_sig) < len
844           && memcmp (prologue + vpc, img_sig, sizeof (img_sig)) == 0)
845         {
846           vpc += sizeof (img_sig);
847         }
848       else if (vpc + sizeof (img_int) < len 
849                && memcmp (prologue + vpc, img_int, sizeof (img_int)) == 0)
850         {
851           vpc += sizeof (img_int);
852         }
853       if (vpc + sizeof (img) < len
854           && memcmp (prologue + vpc, img, sizeof (img)) == 0)
855         {
856           info->prologue_type = AVR_PROLOGUE_NORMAL;
857           vpc += sizeof (img);
858         }
859
860       info->size += locals_size;
861
862       /* Fall through.  */
863     }
864
865   /* If we got this far, we could not scan the prologue, so just return the pc
866      of the frame plus an adjustment for argument move insns.  */
867
868   for (; vpc < len; vpc += 2)
869     {
870       insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
871       if ((insn & 0xff00) == 0x0100)    /* movw rXX, rYY */
872         continue;
873       else if ((insn & 0xfc00) == 0x2c00) /* mov rXX, rYY */
874         continue;
875       else
876           break;
877     }
878     
879   return pc_beg + vpc;
880 }
881
882 static CORE_ADDR
883 avr_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
884 {
885   CORE_ADDR func_addr, func_end;
886   CORE_ADDR post_prologue_pc;
887
888   /* See what the symbol table says */
889
890   if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
891     return pc;
892
893   post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr);
894   if (post_prologue_pc != 0)
895     return std::max (pc, post_prologue_pc);
896
897   {
898     CORE_ADDR prologue_end = pc;
899     struct avr_unwind_cache info = {0};
900     trad_frame_saved_reg saved_regs[AVR_NUM_REGS];
901
902     info.saved_regs = saved_regs;
903     
904     /* Need to run the prologue scanner to figure out if the function has a
905        prologue and possibly skip over moving arguments passed via registers
906        to other registers.  */
907     
908     prologue_end = avr_scan_prologue (gdbarch, func_addr, func_end, &info);
909     
910     if (info.prologue_type != AVR_PROLOGUE_NONE)
911       return prologue_end;
912   }
913
914   /* Either we didn't find the start of this function (nothing we can do),
915      or there's no line info, or the line after the prologue is after
916      the end of the function (there probably isn't a prologue).  */
917
918   return pc;
919 }
920
921 /* Not all avr devices support the BREAK insn.  Those that don't should treat
922    it as a NOP.  Thus, it should be ok.  Since the avr is currently a remote
923    only target, this shouldn't be a problem (I hope).  TRoth/2003-05-14  */
924
925 constexpr gdb_byte avr_break_insn [] = { 0x98, 0x95 };
926
927 typedef BP_MANIPULATION (avr_break_insn) avr_breakpoint;
928
929 /* Determine, for architecture GDBARCH, how a return value of TYPE
930    should be returned.  If it is supposed to be returned in registers,
931    and READBUF is non-zero, read the appropriate value from REGCACHE,
932    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
933    from WRITEBUF into REGCACHE.  */
934
935 static enum return_value_convention
936 avr_return_value (struct gdbarch *gdbarch, struct value *function,
937                   struct type *valtype, struct regcache *regcache,
938                   gdb_byte *readbuf, const gdb_byte *writebuf)
939 {
940   int i;
941   /* Single byte are returned in r24.
942      Otherwise, the MSB of the return value is always in r25, calculate which
943      register holds the LSB.  */
944   int lsb_reg;
945
946   if ((valtype->code () == TYPE_CODE_STRUCT
947        || valtype->code () == TYPE_CODE_UNION
948        || valtype->code () == TYPE_CODE_ARRAY)
949       && TYPE_LENGTH (valtype) > 8)
950     return RETURN_VALUE_STRUCT_CONVENTION;
951
952   if (TYPE_LENGTH (valtype) <= 2)
953     lsb_reg = 24;
954   else if (TYPE_LENGTH (valtype) <= 4)
955     lsb_reg = 22;
956   else if (TYPE_LENGTH (valtype) <= 8)
957     lsb_reg = 18;
958   else
959     gdb_assert_not_reached ("unexpected type length");
960
961   if (writebuf != NULL)
962     {
963       for (i = 0; i < TYPE_LENGTH (valtype); i++)
964         regcache->cooked_write (lsb_reg + i, writebuf + i);
965     }
966
967   if (readbuf != NULL)
968     {
969       for (i = 0; i < TYPE_LENGTH (valtype); i++)
970         regcache->cooked_read (lsb_reg + i, readbuf + i);
971     }
972
973   return RETURN_VALUE_REGISTER_CONVENTION;
974 }
975
976
977 /* Put here the code to store, into fi->saved_regs, the addresses of
978    the saved registers of frame described by FRAME_INFO.  This
979    includes special registers such as pc and fp saved in special ways
980    in the stack frame.  sp is even more special: the address we return
981    for it IS the sp for the next frame.  */
982
983 static struct avr_unwind_cache *
984 avr_frame_unwind_cache (struct frame_info *this_frame,
985                         void **this_prologue_cache)
986 {
987   CORE_ADDR start_pc, current_pc;
988   ULONGEST prev_sp;
989   ULONGEST this_base;
990   struct avr_unwind_cache *info;
991   struct gdbarch *gdbarch;
992   int i;
993
994   if (*this_prologue_cache)
995     return (struct avr_unwind_cache *) *this_prologue_cache;
996
997   info = FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache);
998   *this_prologue_cache = info;
999   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1000
1001   info->size = 0;
1002   info->prologue_type = AVR_PROLOGUE_NONE;
1003
1004   start_pc = get_frame_func (this_frame);
1005   current_pc = get_frame_pc (this_frame);
1006   if ((start_pc > 0) && (start_pc <= current_pc))
1007     avr_scan_prologue (get_frame_arch (this_frame),
1008                        start_pc, current_pc, info);
1009
1010   if ((info->prologue_type != AVR_PROLOGUE_NONE)
1011       && (info->prologue_type != AVR_PROLOGUE_MAIN))
1012     {
1013       ULONGEST high_base;       /* High byte of FP */
1014
1015       /* The SP was moved to the FP.  This indicates that a new frame
1016          was created.  Get THIS frame's FP value by unwinding it from
1017          the next frame.  */
1018       this_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM);
1019       high_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM + 1);
1020       this_base += (high_base << 8);
1021       
1022       /* The FP points at the last saved register.  Adjust the FP back
1023          to before the first saved register giving the SP.  */
1024       prev_sp = this_base + info->size; 
1025    }
1026   else
1027     {
1028       /* Assume that the FP is this frame's SP but with that pushed
1029          stack space added back.  */
1030       this_base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM);
1031       prev_sp = this_base + info->size;
1032     }
1033
1034   /* Add 1 here to adjust for the post-decrement nature of the push
1035      instruction.*/
1036   info->prev_sp = avr_make_saddr (prev_sp + 1);
1037   info->base = avr_make_saddr (this_base);
1038
1039   gdbarch = get_frame_arch (this_frame);
1040
1041   /* Adjust all the saved registers so that they contain addresses and not
1042      offsets.  */
1043   for (i = 0; i < gdbarch_num_regs (gdbarch) - 1; i++)
1044     if (info->saved_regs[i].is_addr ())
1045       info->saved_regs[i].set_addr (info->prev_sp
1046                                     - info->saved_regs[i].addr ());
1047
1048   /* Except for the main and startup code, the return PC is always saved on
1049      the stack and is at the base of the frame.  */
1050
1051   if (info->prologue_type != AVR_PROLOGUE_MAIN)
1052     info->saved_regs[AVR_PC_REGNUM].set_addr (info->prev_sp);
1053
1054   /* The previous frame's SP needed to be computed.  Save the computed
1055      value.  */
1056   avr_gdbarch_tdep *tdep = (avr_gdbarch_tdep *) gdbarch_tdep (gdbarch);
1057   info->saved_regs[AVR_SP_REGNUM].set_value (info->prev_sp
1058                                              - 1 + tdep->call_length);
1059
1060   return info;
1061 }
1062
1063 static CORE_ADDR
1064 avr_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1065 {
1066   ULONGEST pc;
1067
1068   pc = frame_unwind_register_unsigned (next_frame, AVR_PC_REGNUM);
1069
1070   return avr_make_iaddr (pc);
1071 }
1072
1073 static CORE_ADDR
1074 avr_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1075 {
1076   ULONGEST sp;
1077
1078   sp = frame_unwind_register_unsigned (next_frame, AVR_SP_REGNUM);
1079
1080   return avr_make_saddr (sp);
1081 }
1082
1083 /* Given a GDB frame, determine the address of the calling function's
1084    frame.  This will be used to create a new GDB frame struct.  */
1085
1086 static void
1087 avr_frame_this_id (struct frame_info *this_frame,
1088                    void **this_prologue_cache,
1089                    struct frame_id *this_id)
1090 {
1091   struct avr_unwind_cache *info
1092     = avr_frame_unwind_cache (this_frame, this_prologue_cache);
1093   CORE_ADDR base;
1094   CORE_ADDR func;
1095   struct frame_id id;
1096
1097   /* The FUNC is easy.  */
1098   func = get_frame_func (this_frame);
1099
1100   /* Hopefully the prologue analysis either correctly determined the
1101      frame's base (which is the SP from the previous frame), or set
1102      that base to "NULL".  */
1103   base = info->prev_sp;
1104   if (base == 0)
1105     return;
1106
1107   id = frame_id_build (base, func);
1108   (*this_id) = id;
1109 }
1110
1111 static struct value *
1112 avr_frame_prev_register (struct frame_info *this_frame,
1113                          void **this_prologue_cache, int regnum)
1114 {
1115   struct avr_unwind_cache *info
1116     = avr_frame_unwind_cache (this_frame, this_prologue_cache);
1117
1118   if (regnum == AVR_PC_REGNUM || regnum == AVR_PSEUDO_PC_REGNUM)
1119     {
1120       if (info->saved_regs[AVR_PC_REGNUM].is_addr ())
1121         {
1122           /* Reading the return PC from the PC register is slightly
1123              abnormal.  register_size(AVR_PC_REGNUM) says it is 4 bytes,
1124              but in reality, only two bytes (3 in upcoming mega256) are
1125              stored on the stack.
1126
1127              Also, note that the value on the stack is an addr to a word
1128              not a byte, so we will need to multiply it by two at some
1129              point. 
1130
1131              And to confuse matters even more, the return address stored
1132              on the stack is in big endian byte order, even though most
1133              everything else about the avr is little endian.  Ick!  */
1134           ULONGEST pc;
1135           int i;
1136           gdb_byte buf[3];
1137           struct gdbarch *gdbarch = get_frame_arch (this_frame);
1138           avr_gdbarch_tdep *tdep = (avr_gdbarch_tdep *) gdbarch_tdep (gdbarch);
1139
1140           read_memory (info->saved_regs[AVR_PC_REGNUM].addr (),
1141                        buf, tdep->call_length);
1142
1143           /* Extract the PC read from memory as a big-endian.  */
1144           pc = 0;
1145           for (i = 0; i < tdep->call_length; i++)
1146             pc = (pc << 8) | buf[i];
1147
1148           if (regnum == AVR_PC_REGNUM)
1149             pc <<= 1;
1150
1151           return frame_unwind_got_constant (this_frame, regnum, pc);
1152         }
1153
1154       return frame_unwind_got_optimized (this_frame, regnum);
1155     }
1156
1157   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1158 }
1159
1160 static const struct frame_unwind avr_frame_unwind = {
1161   "avr prologue",
1162   NORMAL_FRAME,
1163   default_frame_unwind_stop_reason,
1164   avr_frame_this_id,
1165   avr_frame_prev_register,
1166   NULL,
1167   default_frame_sniffer
1168 };
1169
1170 static CORE_ADDR
1171 avr_frame_base_address (struct frame_info *this_frame, void **this_cache)
1172 {
1173   struct avr_unwind_cache *info
1174     = avr_frame_unwind_cache (this_frame, this_cache);
1175
1176   return info->base;
1177 }
1178
1179 static const struct frame_base avr_frame_base = {
1180   &avr_frame_unwind,
1181   avr_frame_base_address,
1182   avr_frame_base_address,
1183   avr_frame_base_address
1184 };
1185
1186 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1187    frame.  The frame ID's base needs to match the TOS value saved by
1188    save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint.  */
1189
1190 static struct frame_id
1191 avr_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1192 {
1193   ULONGEST base;
1194
1195   base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM);
1196   return frame_id_build (avr_make_saddr (base), get_frame_pc (this_frame));
1197 }
1198
1199 /* When arguments must be pushed onto the stack, they go on in reverse
1200    order.  The below implements a FILO (stack) to do this.  */
1201
1202 struct stack_item
1203 {
1204   int len;
1205   struct stack_item *prev;
1206   gdb_byte *data;
1207 };
1208
1209 static struct stack_item *
1210 push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len)
1211 {
1212   struct stack_item *si;
1213   si = XNEW (struct stack_item);
1214   si->data = (gdb_byte *) xmalloc (len);
1215   si->len = len;
1216   si->prev = prev;
1217   memcpy (si->data, contents, len);
1218   return si;
1219 }
1220
1221 static struct stack_item *pop_stack_item (struct stack_item *si);
1222 static struct stack_item *
1223 pop_stack_item (struct stack_item *si)
1224 {
1225   struct stack_item *dead = si;
1226   si = si->prev;
1227   xfree (dead->data);
1228   xfree (dead);
1229   return si;
1230 }
1231
1232 /* Setup the function arguments for calling a function in the inferior.
1233
1234    On the AVR architecture, there are 18 registers (R25 to R8) which are
1235    dedicated for passing function arguments.  Up to the first 18 arguments
1236    (depending on size) may go into these registers.  The rest go on the stack.
1237
1238    All arguments are aligned to start in even-numbered registers (odd-sized
1239    arguments, including char, have one free register above them).  For example,
1240    an int in arg1 and a char in arg2 would be passed as such:
1241
1242       arg1 -> r25:r24
1243       arg2 -> r22
1244
1245    Arguments that are larger than 2 bytes will be split between two or more
1246    registers as available, but will NOT be split between a register and the
1247    stack.  Arguments that go onto the stack are pushed last arg first (this is
1248    similar to the d10v).  */
1249
1250 /* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1251    inaccurate.
1252
1253    An exceptional case exists for struct arguments (and possibly other
1254    aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1255    not a multiple of WORDSIZE bytes.  In this case the argument is never split
1256    between the registers and the stack, but instead is copied in its entirety
1257    onto the stack, AND also copied into as many registers as there is room
1258    for.  In other words, space in registers permitting, two copies of the same
1259    argument are passed in.  As far as I can tell, only the one on the stack is
1260    used, although that may be a function of the level of compiler
1261    optimization.  I suspect this is a compiler bug.  Arguments of these odd
1262    sizes are left-justified within the word (as opposed to arguments smaller
1263    than WORDSIZE bytes, which are right-justified).
1264  
1265    If the function is to return an aggregate type such as a struct, the caller
1266    must allocate space into which the callee will copy the return value.  In
1267    this case, a pointer to the return value location is passed into the callee
1268    in register R0, which displaces one of the other arguments passed in via
1269    registers R0 to R2.  */
1270
1271 static CORE_ADDR
1272 avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1273                      struct regcache *regcache, CORE_ADDR bp_addr,
1274                      int nargs, struct value **args, CORE_ADDR sp,
1275                      function_call_return_method return_method,
1276                      CORE_ADDR struct_addr)
1277 {
1278   int i;
1279   gdb_byte buf[3];
1280   avr_gdbarch_tdep *tdep = (avr_gdbarch_tdep *) gdbarch_tdep (gdbarch);
1281   int call_length = tdep->call_length;
1282   CORE_ADDR return_pc = avr_convert_iaddr_to_raw (bp_addr);
1283   int regnum = AVR_ARGN_REGNUM;
1284   struct stack_item *si = NULL;
1285
1286   if (return_method == return_method_struct)
1287     {
1288       regcache_cooked_write_unsigned
1289         (regcache, regnum--, (struct_addr >> 8) & 0xff);
1290       regcache_cooked_write_unsigned
1291         (regcache, regnum--, struct_addr & 0xff);
1292       /* SP being post decremented, we need to reserve one byte so that the
1293          return address won't overwrite the result (or vice-versa).  */
1294       if (sp == struct_addr)
1295         sp--;
1296     }
1297
1298   for (i = 0; i < nargs; i++)
1299     {
1300       int last_regnum;
1301       int j;
1302       struct value *arg = args[i];
1303       struct type *type = check_typedef (value_type (arg));
1304       const bfd_byte *contents = value_contents (arg).data ();
1305       int len = TYPE_LENGTH (type);
1306
1307       /* Calculate the potential last register needed.
1308          E.g. For length 2, registers regnum and regnum-1 (say 25 and 24)
1309          shall be used. So, last needed register will be regnum-1(24).  */
1310       last_regnum = regnum - (len + (len & 1)) + 1;
1311
1312       /* If there are registers available, use them.  Once we start putting
1313          stuff on the stack, all subsequent args go on stack.  */
1314       if ((si == NULL) && (last_regnum >= AVR_LAST_ARG_REGNUM))
1315         {
1316           /* Skip a register for odd length args.  */
1317           if (len & 1)
1318             regnum--;
1319
1320           /* Write MSB of argument into register and subsequent bytes in
1321              decreasing register numbers.  */
1322           for (j = 0; j < len; j++)
1323             regcache_cooked_write_unsigned
1324               (regcache, regnum--, contents[len - j - 1]);
1325         }
1326       /* No registers available, push the args onto the stack.  */
1327       else
1328         {
1329           /* From here on, we don't care about regnum.  */
1330           si = push_stack_item (si, contents, len);
1331         }
1332     }
1333
1334   /* Push args onto the stack.  */
1335   while (si)
1336     {
1337       sp -= si->len;
1338       /* Add 1 to sp here to account for post decr nature of pushes.  */
1339       write_memory (sp + 1, si->data, si->len);
1340       si = pop_stack_item (si);
1341     }
1342
1343   /* Set the return address.  For the avr, the return address is the BP_ADDR.
1344      Need to push the return address onto the stack noting that it needs to be
1345      in big-endian order on the stack.  */
1346   for (i = 1; i <= call_length; i++)
1347     {
1348       buf[call_length - i] = return_pc & 0xff;
1349       return_pc >>= 8;
1350     }
1351
1352   sp -= call_length;
1353   /* Use 'sp + 1' since pushes are post decr ops.  */
1354   write_memory (sp + 1, buf, call_length);
1355
1356   /* Finally, update the SP register.  */
1357   regcache_cooked_write_unsigned (regcache, AVR_SP_REGNUM,
1358                                   avr_convert_saddr_to_raw (sp));
1359
1360   /* Return SP value for the dummy frame, where the return address hasn't been
1361      pushed.  */
1362   return sp + call_length;
1363 }
1364
1365 /* Unfortunately dwarf2 register for SP is 32.  */
1366
1367 static int
1368 avr_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
1369 {
1370   if (reg >= 0 && reg < 32)
1371     return reg;
1372   if (reg == 32)
1373     return AVR_SP_REGNUM;
1374   return -1;
1375 }
1376
1377 /* Implementation of `address_class_type_flags' gdbarch method.
1378
1379    This method maps DW_AT_address_class attributes to a
1380    type_instance_flag_value.  */
1381
1382 static type_instance_flags
1383 avr_address_class_type_flags (int byte_size, int dwarf2_addr_class)
1384 {
1385   /* The value 1 of the DW_AT_address_class attribute corresponds to the
1386      __flash qualifier.  Note that this attribute is only valid with
1387      pointer types and therefore the flag is set to the pointer type and
1388      not its target type.  */
1389   if (dwarf2_addr_class == 1 && byte_size == 2)
1390     return AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH;
1391   return 0;
1392 }
1393
1394 /* Implementation of `address_class_type_flags_to_name' gdbarch method.
1395
1396    Convert a type_instance_flag_value to an address space qualifier.  */
1397
1398 static const char*
1399 avr_address_class_type_flags_to_name (struct gdbarch *gdbarch,
1400                                       type_instance_flags type_flags)
1401 {
1402   if (type_flags & AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH)
1403     return "flash";
1404   else
1405     return NULL;
1406 }
1407
1408 /* Implementation of `address_class_name_to_type_flags' gdbarch method.
1409
1410    Convert an address space qualifier to a type_instance_flag_value.  */
1411
1412 static bool
1413 avr_address_class_name_to_type_flags (struct gdbarch *gdbarch,
1414                                       const char* name,
1415                                       type_instance_flags *type_flags_ptr)
1416 {
1417   if (strcmp (name, "flash") == 0)
1418     {
1419       *type_flags_ptr = AVR_TYPE_INSTANCE_FLAG_ADDRESS_CLASS_FLASH;
1420       return true;
1421     }
1422   else
1423     return false;
1424 }
1425
1426 /* Initialize the gdbarch structure for the AVR's.  */
1427
1428 static struct gdbarch *
1429 avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1430 {
1431   struct gdbarch *gdbarch;
1432   struct gdbarch_list *best_arch;
1433   int call_length;
1434
1435   /* Avr-6 call instructions save 3 bytes.  */
1436   switch (info.bfd_arch_info->mach)
1437     {
1438     case bfd_mach_avr1:
1439     case bfd_mach_avrxmega1:
1440     case bfd_mach_avr2:
1441     case bfd_mach_avrxmega2:
1442     case bfd_mach_avr3:
1443     case bfd_mach_avrxmega3:
1444     case bfd_mach_avr4:
1445     case bfd_mach_avrxmega4:
1446     case bfd_mach_avr5:
1447     case bfd_mach_avrxmega5:
1448     default:
1449       call_length = 2;
1450       break;
1451     case bfd_mach_avr6:
1452     case bfd_mach_avrxmega6:
1453     case bfd_mach_avrxmega7:
1454       call_length = 3;
1455       break;
1456     }
1457
1458   /* If there is already a candidate, use it.  */
1459   for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1460        best_arch != NULL;
1461        best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1462     {
1463       avr_gdbarch_tdep *tdep
1464         = (avr_gdbarch_tdep *) gdbarch_tdep (best_arch->gdbarch);
1465
1466       if (tdep->call_length == call_length)
1467         return best_arch->gdbarch;
1468     }
1469
1470   /* None found, create a new architecture from the information provided.  */
1471   avr_gdbarch_tdep *tdep = new avr_gdbarch_tdep;
1472   gdbarch = gdbarch_alloc (&info, tdep);
1473   
1474   tdep->call_length = call_length;
1475
1476   /* Create a type for PC.  We can't use builtin types here, as they may not
1477      be defined.  */
1478   tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT,
1479                                "void");
1480   tdep->func_void_type = make_function_type (tdep->void_type, NULL);
1481   tdep->pc_type = arch_pointer_type (gdbarch, 4 * TARGET_CHAR_BIT, NULL,
1482                                      tdep->func_void_type);
1483
1484   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1485   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1486   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1487   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1488   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1489   set_gdbarch_addr_bit (gdbarch, 32);
1490
1491   set_gdbarch_wchar_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1492   set_gdbarch_wchar_signed (gdbarch, 1);
1493
1494   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1495   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1496   set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1497
1498   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1499   set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
1500   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);
1501
1502   set_gdbarch_read_pc (gdbarch, avr_read_pc);
1503   set_gdbarch_write_pc (gdbarch, avr_write_pc);
1504
1505   set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS);
1506
1507   set_gdbarch_sp_regnum (gdbarch, AVR_SP_REGNUM);
1508   set_gdbarch_pc_regnum (gdbarch, AVR_PC_REGNUM);
1509
1510   set_gdbarch_register_name (gdbarch, avr_register_name);
1511   set_gdbarch_register_type (gdbarch, avr_register_type);
1512
1513   set_gdbarch_num_pseudo_regs (gdbarch, AVR_NUM_PSEUDO_REGS);
1514   set_gdbarch_pseudo_register_read (gdbarch, avr_pseudo_register_read);
1515   set_gdbarch_pseudo_register_write (gdbarch, avr_pseudo_register_write);
1516
1517   set_gdbarch_return_value (gdbarch, avr_return_value);
1518
1519   set_gdbarch_push_dummy_call (gdbarch, avr_push_dummy_call);
1520
1521   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, avr_dwarf_reg_to_regnum);
1522
1523   set_gdbarch_address_to_pointer (gdbarch, avr_address_to_pointer);
1524   set_gdbarch_pointer_to_address (gdbarch, avr_pointer_to_address);
1525   set_gdbarch_integer_to_address (gdbarch, avr_integer_to_address);
1526
1527   set_gdbarch_skip_prologue (gdbarch, avr_skip_prologue);
1528   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1529
1530   set_gdbarch_breakpoint_kind_from_pc (gdbarch, avr_breakpoint::kind_from_pc);
1531   set_gdbarch_sw_breakpoint_from_kind (gdbarch, avr_breakpoint::bp_from_kind);
1532
1533   frame_unwind_append_unwinder (gdbarch, &avr_frame_unwind);
1534   frame_base_set_default (gdbarch, &avr_frame_base);
1535
1536   set_gdbarch_dummy_id (gdbarch, avr_dummy_id);
1537
1538   set_gdbarch_unwind_pc (gdbarch, avr_unwind_pc);
1539   set_gdbarch_unwind_sp (gdbarch, avr_unwind_sp);
1540
1541   set_gdbarch_address_class_type_flags (gdbarch, avr_address_class_type_flags);
1542   set_gdbarch_address_class_name_to_type_flags
1543     (gdbarch, avr_address_class_name_to_type_flags);
1544   set_gdbarch_address_class_type_flags_to_name
1545     (gdbarch, avr_address_class_type_flags_to_name);
1546
1547   return gdbarch;
1548 }
1549
1550 /* Send a query request to the avr remote target asking for values of the io
1551    registers.  If args parameter is not NULL, then the user has requested info
1552    on a specific io register [This still needs implemented and is ignored for
1553    now].  The query string should be one of these forms:
1554
1555    "Ravr.io_reg" -> reply is "NN" number of io registers
1556
1557    "Ravr.io_reg:addr,len" where addr is first register and len is number of
1558    registers to be read.  The reply should be "<NAME>,VV;" for each io register
1559    where, <NAME> is a string, and VV is the hex value of the register.
1560
1561    All io registers are 8-bit.  */
1562
1563 static void
1564 avr_io_reg_read_command (const char *args, int from_tty)
1565 {
1566   char query[400];
1567   unsigned int nreg = 0;
1568   unsigned int val;
1569
1570   /* Find out how many io registers the target has.  */
1571   gdb::optional<gdb::byte_vector> buf
1572     = target_read_alloc (current_inferior ()->top_target (),
1573                          TARGET_OBJECT_AVR, "avr.io_reg");
1574
1575   if (!buf)
1576     {
1577       fprintf_unfiltered (gdb_stderr,
1578                           _("ERR: info io_registers NOT supported "
1579                             "by current target\n"));
1580       return;
1581     }
1582
1583   const char *bufstr = (const char *) buf->data ();
1584
1585   if (sscanf (bufstr, "%x", &nreg) != 1)
1586     {
1587       fprintf_unfiltered (gdb_stderr,
1588                           _("Error fetching number of io registers\n"));
1589       return;
1590     }
1591
1592   printf_filtered (_("Target has %u io registers:\n\n"), nreg);
1593
1594   /* only fetch up to 8 registers at a time to keep the buffer small */
1595   int step = 8;
1596
1597   for (int i = 0; i < nreg; i += step)
1598     {
1599       /* how many registers this round? */
1600       int j = step;
1601       if ((i+j) >= nreg)
1602         j = nreg - i;           /* last block is less than 8 registers */
1603
1604       snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j);
1605       buf = target_read_alloc (current_inferior ()->top_target (),
1606                                TARGET_OBJECT_AVR, query);
1607
1608       if (!buf)
1609         {
1610           fprintf_unfiltered (gdb_stderr,
1611                               _("ERR: error reading avr.io_reg:%x,%x\n"),
1612                               i, j);
1613           return;
1614         }
1615
1616       const char *p = (const char *) buf->data ();
1617       for (int k = i; k < (i + j); k++)
1618         {
1619           if (sscanf (p, "%[^,],%x;", query, &val) == 2)
1620             {
1621               printf_filtered ("[%02x] %-15s : %02x\n", k, query, val);
1622               while ((*p != ';') && (*p != '\0'))
1623                 p++;
1624               p++;              /* skip over ';' */
1625               if (*p == '\0')
1626                 break;
1627             }
1628         }
1629     }
1630 }
1631
1632 void _initialize_avr_tdep ();
1633 void
1634 _initialize_avr_tdep ()
1635 {
1636   register_gdbarch_init (bfd_arch_avr, avr_gdbarch_init);
1637
1638   /* Add a new command to allow the user to query the avr remote target for
1639      the values of the io space registers in a saner way than just using
1640      `x/NNNb ADDR`.  */
1641
1642   /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1643      io_registers' to signify it is not available on other platforms.  */
1644
1645   add_info ("io_registers", avr_io_reg_read_command,
1646             _("Query remote AVR target for I/O space register values."));
1647 }
This page took 0.116309 seconds and 4 git commands to generate.