Tests for validate symbol file using build-id.
[gdb/archer.git] / gdb / avr-tdep.c
blobb14bf83612e24c1ec6c3f6e376b9070e41e99d85
1 /* Target-dependent code for Atmel AVR, for GDB.
3 Copyright (C) 1996-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 /* Contributed by Theodore A. Roth, troth@openavr.org */
22 /* Portions of this file were taken from the original gdb-4.18 patch developed
23 by Denis Chertykov, denisc@overta.ru */
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 "gdb_string.h"
38 #include "dis-asm.h"
40 /* AVR Background:
42 (AVR micros are pure Harvard Architecture processors.)
44 The AVR family of microcontrollers have three distinctly different memory
45 spaces: flash, sram and eeprom. The flash is 16 bits wide and is used for
46 the most part to store program instructions. The sram is 8 bits wide and is
47 used for the stack and the heap. Some devices lack sram and some can have
48 an additional external sram added on as a peripheral.
50 The eeprom is 8 bits wide and is used to store data when the device is
51 powered down. Eeprom is not directly accessible, it can only be accessed
52 via io-registers using a special algorithm. Accessing eeprom via gdb's
53 remote serial protocol ('m' or 'M' packets) looks difficult to do and is
54 not included at this time.
56 [The eeprom could be read manually via ``x/b <eaddr + AVR_EMEM_START>'' or
57 written using ``set {unsigned char}<eaddr + AVR_EMEM_START>''. For this to
58 work, the remote target must be able to handle eeprom accesses and perform
59 the address translation.]
61 All three memory spaces have physical addresses beginning at 0x0. In
62 addition, the flash is addressed by gcc/binutils/gdb with respect to 8 bit
63 bytes instead of the 16 bit wide words used by the real device for the
64 Program Counter.
66 In order for remote targets to work correctly, extra bits must be added to
67 addresses before they are send to the target or received from the target
68 via the remote serial protocol. The extra bits are the MSBs and are used to
69 decode which memory space the address is referring to. */
71 #undef XMALLOC
72 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
74 /* Constants: prefixed with AVR_ to avoid name space clashes */
76 enum
78 AVR_REG_W = 24,
79 AVR_REG_X = 26,
80 AVR_REG_Y = 28,
81 AVR_FP_REGNUM = 28,
82 AVR_REG_Z = 30,
84 AVR_SREG_REGNUM = 32,
85 AVR_SP_REGNUM = 33,
86 AVR_PC_REGNUM = 34,
88 AVR_NUM_REGS = 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
89 AVR_NUM_REG_BYTES = 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
91 /* Pseudo registers. */
92 AVR_PSEUDO_PC_REGNUM = 35,
93 AVR_NUM_PSEUDO_REGS = 1,
95 AVR_PC_REG_INDEX = 35, /* index into array of registers */
97 AVR_MAX_PROLOGUE_SIZE = 64, /* bytes */
99 /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
100 AVR_MAX_PUSHES = 18,
102 /* Number of the last pushed register. r17 for current avr-gcc */
103 AVR_LAST_PUSHED_REGNUM = 17,
105 AVR_ARG1_REGNUM = 24, /* Single byte argument */
106 AVR_ARGN_REGNUM = 25, /* Multi byte argments */
108 AVR_RET1_REGNUM = 24, /* Single byte return value */
109 AVR_RETN_REGNUM = 25, /* Multi byte return value */
111 /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
112 bits? Do these have to match the bfd vma values? It sure would make
113 things easier in the future if they didn't need to match.
115 Note: I chose these values so as to be consistent with bfd vma
116 addresses.
118 TRoth/2002-04-08: There is already a conflict with very large programs
119 in the mega128. The mega128 has 128K instruction bytes (64K words),
120 thus the Most Significant Bit is 0x10000 which gets masked off my
121 AVR_MEM_MASK.
123 The problem manifests itself when trying to set a breakpoint in a
124 function which resides in the upper half of the instruction space and
125 thus requires a 17-bit address.
127 For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
128 from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
129 but could be for some remote targets by just adding the correct offset
130 to the address and letting the remote target handle the low-level
131 details of actually accessing the eeprom. */
133 AVR_IMEM_START = 0x00000000, /* INSN memory */
134 AVR_SMEM_START = 0x00800000, /* SRAM memory */
135 #if 1
136 /* No eeprom mask defined */
137 AVR_MEM_MASK = 0x00f00000, /* mask to determine memory space */
138 #else
139 AVR_EMEM_START = 0x00810000, /* EEPROM memory */
140 AVR_MEM_MASK = 0x00ff0000, /* mask to determine memory space */
141 #endif
144 /* Prologue types:
146 NORMAL and CALL are the typical types (the -mcall-prologues gcc option
147 causes the generation of the CALL type prologues). */
149 enum {
150 AVR_PROLOGUE_NONE, /* No prologue */
151 AVR_PROLOGUE_NORMAL,
152 AVR_PROLOGUE_CALL, /* -mcall-prologues */
153 AVR_PROLOGUE_MAIN,
154 AVR_PROLOGUE_INTR, /* interrupt handler */
155 AVR_PROLOGUE_SIG, /* signal handler */
158 /* Any function with a frame looks like this
159 ....... <-SP POINTS HERE
160 LOCALS1 <-FP POINTS HERE
161 LOCALS0
162 SAVED FP
163 SAVED R3
164 SAVED R2
165 RET PC
166 FIRST ARG
167 SECOND ARG */
169 struct avr_unwind_cache
171 /* The previous frame's inner most stack address. Used as this
172 frame ID's stack_addr. */
173 CORE_ADDR prev_sp;
174 /* The frame's base, optionally used by the high-level debug info. */
175 CORE_ADDR base;
176 int size;
177 int prologue_type;
178 /* Table indicating the location of each and every register. */
179 struct trad_frame_saved_reg *saved_regs;
182 struct gdbarch_tdep
184 /* Number of bytes stored to the stack by call instructions.
185 2 bytes for avr1-5, 3 bytes for avr6. */
186 int call_length;
188 /* Type for void. */
189 struct type *void_type;
190 /* Type for a function returning void. */
191 struct type *func_void_type;
192 /* Type for a pointer to a function. Used for the type of PC. */
193 struct type *pc_type;
196 /* Lookup the name of a register given it's number. */
198 static const char *
199 avr_register_name (struct gdbarch *gdbarch, int regnum)
201 static const char * const register_names[] = {
202 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
203 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
204 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
205 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
206 "SREG", "SP", "PC2",
207 "pc"
209 if (regnum < 0)
210 return NULL;
211 if (regnum >= (sizeof (register_names) / sizeof (*register_names)))
212 return NULL;
213 return register_names[regnum];
216 /* Return the GDB type object for the "standard" data type
217 of data in register N. */
219 static struct type *
220 avr_register_type (struct gdbarch *gdbarch, int reg_nr)
222 if (reg_nr == AVR_PC_REGNUM)
223 return builtin_type (gdbarch)->builtin_uint32;
224 if (reg_nr == AVR_PSEUDO_PC_REGNUM)
225 return gdbarch_tdep (gdbarch)->pc_type;
226 if (reg_nr == AVR_SP_REGNUM)
227 return builtin_type (gdbarch)->builtin_data_ptr;
228 return builtin_type (gdbarch)->builtin_uint8;
231 /* Instruction address checks and convertions. */
233 static CORE_ADDR
234 avr_make_iaddr (CORE_ADDR x)
236 return ((x) | AVR_IMEM_START);
239 /* FIXME: TRoth: Really need to use a larger mask for instructions. Some
240 devices are already up to 128KBytes of flash space.
242 TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined. */
244 static CORE_ADDR
245 avr_convert_iaddr_to_raw (CORE_ADDR x)
247 return ((x) & 0xffffffff);
250 /* SRAM address checks and convertions. */
252 static CORE_ADDR
253 avr_make_saddr (CORE_ADDR x)
255 /* Return 0 for NULL. */
256 if (x == 0)
257 return 0;
259 return ((x) | AVR_SMEM_START);
262 static CORE_ADDR
263 avr_convert_saddr_to_raw (CORE_ADDR x)
265 return ((x) & 0xffffffff);
268 /* EEPROM address checks and convertions. I don't know if these will ever
269 actually be used, but I've added them just the same. TRoth */
271 /* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
272 programs in the mega128. */
274 /* static CORE_ADDR */
275 /* avr_make_eaddr (CORE_ADDR x) */
276 /* { */
277 /* return ((x) | AVR_EMEM_START); */
278 /* } */
280 /* static int */
281 /* avr_eaddr_p (CORE_ADDR x) */
282 /* { */
283 /* return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
284 /* } */
286 /* static CORE_ADDR */
287 /* avr_convert_eaddr_to_raw (CORE_ADDR x) */
288 /* { */
289 /* return ((x) & 0xffffffff); */
290 /* } */
292 /* Convert from address to pointer and vice-versa. */
294 static void
295 avr_address_to_pointer (struct gdbarch *gdbarch,
296 struct type *type, gdb_byte *buf, CORE_ADDR addr)
298 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
300 /* Is it a code address? */
301 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
302 || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
304 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
305 avr_convert_iaddr_to_raw (addr >> 1));
307 else
309 /* Strip off any upper segment bits. */
310 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order,
311 avr_convert_saddr_to_raw (addr));
315 static CORE_ADDR
316 avr_pointer_to_address (struct gdbarch *gdbarch,
317 struct type *type, const gdb_byte *buf)
319 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
320 CORE_ADDR addr
321 = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
323 /* Is it a code address? */
324 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
325 || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
326 || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
327 return avr_make_iaddr (addr << 1);
328 else
329 return avr_make_saddr (addr);
332 static CORE_ADDR
333 avr_integer_to_address (struct gdbarch *gdbarch,
334 struct type *type, const gdb_byte *buf)
336 ULONGEST addr = unpack_long (type, buf);
338 return avr_make_saddr (addr);
341 static CORE_ADDR
342 avr_read_pc (struct regcache *regcache)
344 ULONGEST pc;
345 regcache_cooked_read_unsigned (regcache, AVR_PC_REGNUM, &pc);
346 return avr_make_iaddr (pc);
349 static void
350 avr_write_pc (struct regcache *regcache, CORE_ADDR val)
352 regcache_cooked_write_unsigned (regcache, AVR_PC_REGNUM,
353 avr_convert_iaddr_to_raw (val));
356 static enum register_status
357 avr_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
358 int regnum, gdb_byte *buf)
360 ULONGEST val;
361 enum register_status status;
363 switch (regnum)
365 case AVR_PSEUDO_PC_REGNUM:
366 status = regcache_raw_read_unsigned (regcache, AVR_PC_REGNUM, &val);
367 if (status != REG_VALID)
368 return status;
369 val >>= 1;
370 store_unsigned_integer (buf, 4, gdbarch_byte_order (gdbarch), val);
371 return status;
372 default:
373 internal_error (__FILE__, __LINE__, _("invalid regnum"));
377 static void
378 avr_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
379 int regnum, const gdb_byte *buf)
381 ULONGEST val;
383 switch (regnum)
385 case AVR_PSEUDO_PC_REGNUM:
386 val = extract_unsigned_integer (buf, 4, gdbarch_byte_order (gdbarch));
387 val <<= 1;
388 regcache_raw_write_unsigned (regcache, AVR_PC_REGNUM, val);
389 break;
390 default:
391 internal_error (__FILE__, __LINE__, _("invalid regnum"));
395 /* Function: avr_scan_prologue
397 This function decodes an AVR function prologue to determine:
398 1) the size of the stack frame
399 2) which registers are saved on it
400 3) the offsets of saved regs
401 This information is stored in the avr_unwind_cache structure.
403 Some devices lack the sbiw instruction, so on those replace this:
404 sbiw r28, XX
405 with this:
406 subi r28,lo8(XX)
407 sbci r29,hi8(XX)
409 A typical AVR function prologue with a frame pointer might look like this:
410 push rXX ; saved regs
412 push r28
413 push r29
414 in r28,__SP_L__
415 in r29,__SP_H__
416 sbiw r28,<LOCALS_SIZE>
417 in __tmp_reg__,__SREG__
419 out __SP_H__,r29
420 out __SREG__,__tmp_reg__
421 out __SP_L__,r28
423 A typical AVR function prologue without a frame pointer might look like
424 this:
425 push rXX ; saved regs
428 A main function prologue looks like this:
429 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
430 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
431 out __SP_H__,r29
432 out __SP_L__,r28
434 A signal handler prologue looks like this:
435 push __zero_reg__
436 push __tmp_reg__
437 in __tmp_reg__, __SREG__
438 push __tmp_reg__
439 clr __zero_reg__
440 push rXX ; save registers r18:r27, r30:r31
442 push r28 ; save frame pointer
443 push r29
444 in r28, __SP_L__
445 in r29, __SP_H__
446 sbiw r28, <LOCALS_SIZE>
447 out __SP_H__, r29
448 out __SP_L__, r28
450 A interrupt handler prologue looks like this:
452 push __zero_reg__
453 push __tmp_reg__
454 in __tmp_reg__, __SREG__
455 push __tmp_reg__
456 clr __zero_reg__
457 push rXX ; save registers r18:r27, r30:r31
459 push r28 ; save frame pointer
460 push r29
461 in r28, __SP_L__
462 in r29, __SP_H__
463 sbiw r28, <LOCALS_SIZE>
465 out __SP_H__, r29
466 sei
467 out __SP_L__, r28
469 A `-mcall-prologues' prologue looks like this (Note that the megas use a
470 jmp instead of a rjmp, thus the prologue is one word larger since jmp is a
471 32 bit insn and rjmp is a 16 bit insn):
472 ldi r26,lo8(<LOCALS_SIZE>)
473 ldi r27,hi8(<LOCALS_SIZE>)
474 ldi r30,pm_lo8(.L_foo_body)
475 ldi r31,pm_hi8(.L_foo_body)
476 rjmp __prologue_saves__+RRR
477 .L_foo_body: */
479 /* Not really part of a prologue, but still need to scan for it, is when a
480 function prologue moves values passed via registers as arguments to new
481 registers. In this case, all local variables live in registers, so there
482 may be some register saves. This is what it looks like:
483 movw rMM, rNN
486 There could be multiple movw's. If the target doesn't have a movw insn, it
487 will use two mov insns. This could be done after any of the above prologue
488 types. */
490 static CORE_ADDR
491 avr_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR pc_beg, CORE_ADDR pc_end,
492 struct avr_unwind_cache *info)
494 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
495 int i;
496 unsigned short insn;
497 int scan_stage = 0;
498 struct minimal_symbol *msymbol;
499 unsigned char prologue[AVR_MAX_PROLOGUE_SIZE];
500 int vpc = 0;
501 int len;
503 len = pc_end - pc_beg;
504 if (len > AVR_MAX_PROLOGUE_SIZE)
505 len = AVR_MAX_PROLOGUE_SIZE;
507 /* FIXME: TRoth/2003-06-11: This could be made more efficient by only
508 reading in the bytes of the prologue. The problem is that the figuring
509 out where the end of the prologue is is a bit difficult. The old code
510 tried to do that, but failed quite often. */
511 read_memory (pc_beg, prologue, len);
513 /* Scanning main()'s prologue
514 ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
515 ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
516 out __SP_H__,r29
517 out __SP_L__,r28 */
519 if (len >= 4)
521 CORE_ADDR locals;
522 static const unsigned char img[] = {
523 0xde, 0xbf, /* out __SP_H__,r29 */
524 0xcd, 0xbf /* out __SP_L__,r28 */
527 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
528 /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
529 if ((insn & 0xf0f0) == 0xe0c0)
531 locals = (insn & 0xf) | ((insn & 0x0f00) >> 4);
532 insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
533 /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
534 if ((insn & 0xf0f0) == 0xe0d0)
536 locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
537 if (vpc + 4 + sizeof (img) < len
538 && memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
540 info->prologue_type = AVR_PROLOGUE_MAIN;
541 info->base = locals;
542 return pc_beg + 4;
548 /* Scanning `-mcall-prologues' prologue
549 Classic prologue is 10 bytes, mega prologue is a 12 bytes long */
551 while (1) /* Using a while to avoid many goto's */
553 int loc_size;
554 int body_addr;
555 unsigned num_pushes;
556 int pc_offset = 0;
558 /* At least the fifth instruction must have been executed to
559 modify frame shape. */
560 if (len < 10)
561 break;
563 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
564 /* ldi r26,<LOCALS_SIZE> */
565 if ((insn & 0xf0f0) != 0xe0a0)
566 break;
567 loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4);
568 pc_offset += 2;
570 insn = extract_unsigned_integer (&prologue[vpc + 2], 2, byte_order);
571 /* ldi r27,<LOCALS_SIZE> / 256 */
572 if ((insn & 0xf0f0) != 0xe0b0)
573 break;
574 loc_size |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
575 pc_offset += 2;
577 insn = extract_unsigned_integer (&prologue[vpc + 4], 2, byte_order);
578 /* ldi r30,pm_lo8(.L_foo_body) */
579 if ((insn & 0xf0f0) != 0xe0e0)
580 break;
581 body_addr = (insn & 0xf) | ((insn & 0x0f00) >> 4);
582 pc_offset += 2;
584 insn = extract_unsigned_integer (&prologue[vpc + 6], 2, byte_order);
585 /* ldi r31,pm_hi8(.L_foo_body) */
586 if ((insn & 0xf0f0) != 0xe0f0)
587 break;
588 body_addr |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
589 pc_offset += 2;
591 msymbol = lookup_minimal_symbol ("__prologue_saves__", NULL, NULL);
592 if (!msymbol)
593 break;
595 insn = extract_unsigned_integer (&prologue[vpc + 8], 2, byte_order);
596 /* rjmp __prologue_saves__+RRR */
597 if ((insn & 0xf000) == 0xc000)
599 /* Extract PC relative offset from RJMP */
600 i = (insn & 0xfff) | (insn & 0x800 ? (-1 ^ 0xfff) : 0);
601 /* Convert offset to byte addressable mode */
602 i *= 2;
603 /* Destination address */
604 i += pc_beg + 10;
606 if (body_addr != (pc_beg + 10)/2)
607 break;
609 pc_offset += 2;
611 else if ((insn & 0xfe0e) == 0x940c)
613 /* Extract absolute PC address from JMP */
614 i = (((insn & 0x1) | ((insn & 0x1f0) >> 3) << 16)
615 | (extract_unsigned_integer (&prologue[vpc + 10], 2, byte_order)
616 & 0xffff));
617 /* Convert address to byte addressable mode */
618 i *= 2;
620 if (body_addr != (pc_beg + 12)/2)
621 break;
623 pc_offset += 4;
625 else
626 break;
628 /* Resolve offset (in words) from __prologue_saves__ symbol.
629 Which is a pushes count in `-mcall-prologues' mode */
630 num_pushes = AVR_MAX_PUSHES - (i - SYMBOL_VALUE_ADDRESS (msymbol)) / 2;
632 if (num_pushes > AVR_MAX_PUSHES)
634 fprintf_unfiltered (gdb_stderr, _("Num pushes too large: %d\n"),
635 num_pushes);
636 num_pushes = 0;
639 if (num_pushes)
641 int from;
643 info->saved_regs[AVR_FP_REGNUM + 1].addr = num_pushes;
644 if (num_pushes >= 2)
645 info->saved_regs[AVR_FP_REGNUM].addr = num_pushes - 1;
647 i = 0;
648 for (from = AVR_LAST_PUSHED_REGNUM + 1 - (num_pushes - 2);
649 from <= AVR_LAST_PUSHED_REGNUM; ++from)
650 info->saved_regs [from].addr = ++i;
652 info->size = loc_size + num_pushes;
653 info->prologue_type = AVR_PROLOGUE_CALL;
655 return pc_beg + pc_offset;
658 /* Scan for the beginning of the prologue for an interrupt or signal
659 function. Note that we have to set the prologue type here since the
660 third stage of the prologue may not be present (e.g. no saved registered
661 or changing of the SP register). */
663 if (1)
665 static const unsigned char img[] = {
666 0x78, 0x94, /* sei */
667 0x1f, 0x92, /* push r1 */
668 0x0f, 0x92, /* push r0 */
669 0x0f, 0xb6, /* in r0,0x3f SREG */
670 0x0f, 0x92, /* push r0 */
671 0x11, 0x24 /* clr r1 */
673 if (len >= sizeof (img)
674 && memcmp (prologue, img, sizeof (img)) == 0)
676 info->prologue_type = AVR_PROLOGUE_INTR;
677 vpc += sizeof (img);
678 info->saved_regs[AVR_SREG_REGNUM].addr = 3;
679 info->saved_regs[0].addr = 2;
680 info->saved_regs[1].addr = 1;
681 info->size += 3;
683 else if (len >= sizeof (img) - 2
684 && memcmp (img + 2, prologue, sizeof (img) - 2) == 0)
686 info->prologue_type = AVR_PROLOGUE_SIG;
687 vpc += sizeof (img) - 2;
688 info->saved_regs[AVR_SREG_REGNUM].addr = 3;
689 info->saved_regs[0].addr = 2;
690 info->saved_regs[1].addr = 1;
691 info->size += 2;
695 /* First stage of the prologue scanning.
696 Scan pushes (saved registers) */
698 for (; vpc < len; vpc += 2)
700 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
701 if ((insn & 0xfe0f) == 0x920f) /* push rXX */
703 /* Bits 4-9 contain a mask for registers R0-R32. */
704 int regno = (insn & 0x1f0) >> 4;
705 info->size++;
706 info->saved_regs[regno].addr = info->size;
707 scan_stage = 1;
709 else
710 break;
713 gdb_assert (vpc < AVR_MAX_PROLOGUE_SIZE);
715 /* Handle static small stack allocation using rcall or push. */
717 while (scan_stage == 1 && vpc < len)
719 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
720 if (insn == 0xd000) /* rcall .+0 */
722 info->size += gdbarch_tdep (gdbarch)->call_length;
723 vpc += 2;
725 else if (insn == 0x920f) /* push r0 */
727 info->size += 1;
728 vpc += 2;
730 else
731 break;
734 /* Second stage of the prologue scanning.
735 Scan:
736 in r28,__SP_L__
737 in r29,__SP_H__ */
739 if (scan_stage == 1 && vpc < len)
741 static const unsigned char img[] = {
742 0xcd, 0xb7, /* in r28,__SP_L__ */
743 0xde, 0xb7 /* in r29,__SP_H__ */
746 if (vpc + sizeof (img) < len
747 && memcmp (prologue + vpc, img, sizeof (img)) == 0)
749 vpc += 4;
750 scan_stage = 2;
754 /* Third stage of the prologue scanning. (Really two stages).
755 Scan for:
756 sbiw r28,XX or subi r28,lo8(XX)
757 sbci r29,hi8(XX)
758 in __tmp_reg__,__SREG__
760 out __SP_H__,r29
761 out __SREG__,__tmp_reg__
762 out __SP_L__,r28 */
764 if (scan_stage == 2 && vpc < len)
766 int locals_size = 0;
767 static const unsigned char img[] = {
768 0x0f, 0xb6, /* in r0,0x3f */
769 0xf8, 0x94, /* cli */
770 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
771 0x0f, 0xbe, /* out 0x3f,r0 ; SREG */
772 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
774 static const unsigned char img_sig[] = {
775 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
776 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
778 static const unsigned char img_int[] = {
779 0xf8, 0x94, /* cli */
780 0xde, 0xbf, /* out 0x3e,r29 ; SPH */
781 0x78, 0x94, /* sei */
782 0xcd, 0xbf /* out 0x3d,r28 ; SPL */
785 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
786 if ((insn & 0xff30) == 0x9720) /* sbiw r28,XXX */
788 locals_size = (insn & 0xf) | ((insn & 0xc0) >> 2);
789 vpc += 2;
791 else if ((insn & 0xf0f0) == 0x50c0) /* subi r28,lo8(XX) */
793 locals_size = (insn & 0xf) | ((insn & 0xf00) >> 4);
794 vpc += 2;
795 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
796 vpc += 2;
797 locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4)) << 8;
799 else
800 return pc_beg + vpc;
802 /* Scan the last part of the prologue. May not be present for interrupt
803 or signal handler functions, which is why we set the prologue type
804 when we saw the beginning of the prologue previously. */
806 if (vpc + sizeof (img_sig) < len
807 && memcmp (prologue + vpc, img_sig, sizeof (img_sig)) == 0)
809 vpc += sizeof (img_sig);
811 else if (vpc + sizeof (img_int) < len
812 && memcmp (prologue + vpc, img_int, sizeof (img_int)) == 0)
814 vpc += sizeof (img_int);
816 if (vpc + sizeof (img) < len
817 && memcmp (prologue + vpc, img, sizeof (img)) == 0)
819 info->prologue_type = AVR_PROLOGUE_NORMAL;
820 vpc += sizeof (img);
823 info->size += locals_size;
825 /* Fall through. */
828 /* If we got this far, we could not scan the prologue, so just return the pc
829 of the frame plus an adjustment for argument move insns. */
831 for (; vpc < len; vpc += 2)
833 insn = extract_unsigned_integer (&prologue[vpc], 2, byte_order);
834 if ((insn & 0xff00) == 0x0100) /* movw rXX, rYY */
835 continue;
836 else if ((insn & 0xfc00) == 0x2c00) /* mov rXX, rYY */
837 continue;
838 else
839 break;
842 return pc_beg + vpc;
845 static CORE_ADDR
846 avr_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
848 CORE_ADDR func_addr, func_end;
849 CORE_ADDR post_prologue_pc;
851 /* See what the symbol table says */
853 if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
854 return pc;
856 post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr);
857 if (post_prologue_pc != 0)
858 return max (pc, post_prologue_pc);
861 CORE_ADDR prologue_end = pc;
862 struct avr_unwind_cache info = {0};
863 struct trad_frame_saved_reg saved_regs[AVR_NUM_REGS];
865 info.saved_regs = saved_regs;
867 /* Need to run the prologue scanner to figure out if the function has a
868 prologue and possibly skip over moving arguments passed via registers
869 to other registers. */
871 prologue_end = avr_scan_prologue (gdbarch, func_addr, func_end, &info);
873 if (info.prologue_type != AVR_PROLOGUE_NONE)
874 return prologue_end;
877 /* Either we didn't find the start of this function (nothing we can do),
878 or there's no line info, or the line after the prologue is after
879 the end of the function (there probably isn't a prologue). */
881 return pc;
884 /* Not all avr devices support the BREAK insn. Those that don't should treat
885 it as a NOP. Thus, it should be ok. Since the avr is currently a remote
886 only target, this shouldn't be a problem (I hope). TRoth/2003-05-14 */
888 static const unsigned char *
889 avr_breakpoint_from_pc (struct gdbarch *gdbarch,
890 CORE_ADDR *pcptr, int *lenptr)
892 static const unsigned char avr_break_insn [] = { 0x98, 0x95 };
893 *lenptr = sizeof (avr_break_insn);
894 return avr_break_insn;
897 /* Determine, for architecture GDBARCH, how a return value of TYPE
898 should be returned. If it is supposed to be returned in registers,
899 and READBUF is non-zero, read the appropriate value from REGCACHE,
900 and copy it into READBUF. If WRITEBUF is non-zero, write the value
901 from WRITEBUF into REGCACHE. */
903 static enum return_value_convention
904 avr_return_value (struct gdbarch *gdbarch, struct value *function,
905 struct type *valtype, struct regcache *regcache,
906 gdb_byte *readbuf, const gdb_byte *writebuf)
908 int i;
909 /* Single byte are returned in r24.
910 Otherwise, the MSB of the return value is always in r25, calculate which
911 register holds the LSB. */
912 int lsb_reg;
914 if ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
915 || TYPE_CODE (valtype) == TYPE_CODE_UNION
916 || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
917 && TYPE_LENGTH (valtype) > 8)
918 return RETURN_VALUE_STRUCT_CONVENTION;
920 if (TYPE_LENGTH (valtype) <= 2)
921 lsb_reg = 24;
922 else if (TYPE_LENGTH (valtype) <= 4)
923 lsb_reg = 22;
924 else if (TYPE_LENGTH (valtype) <= 8)
925 lsb_reg = 18;
926 else
927 gdb_assert_not_reached ("unexpected type length");
929 if (writebuf != NULL)
931 for (i = 0; i < TYPE_LENGTH (valtype); i++)
932 regcache_cooked_write (regcache, lsb_reg + i, writebuf + i);
935 if (readbuf != NULL)
937 for (i = 0; i < TYPE_LENGTH (valtype); i++)
938 regcache_cooked_read (regcache, lsb_reg + i, readbuf + i);
941 return RETURN_VALUE_REGISTER_CONVENTION;
945 /* Put here the code to store, into fi->saved_regs, the addresses of
946 the saved registers of frame described by FRAME_INFO. This
947 includes special registers such as pc and fp saved in special ways
948 in the stack frame. sp is even more special: the address we return
949 for it IS the sp for the next frame. */
951 static struct avr_unwind_cache *
952 avr_frame_unwind_cache (struct frame_info *this_frame,
953 void **this_prologue_cache)
955 CORE_ADDR start_pc, current_pc;
956 ULONGEST prev_sp;
957 ULONGEST this_base;
958 struct avr_unwind_cache *info;
959 struct gdbarch *gdbarch;
960 struct gdbarch_tdep *tdep;
961 int i;
963 if (*this_prologue_cache)
964 return *this_prologue_cache;
966 info = FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache);
967 *this_prologue_cache = info;
968 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
970 info->size = 0;
971 info->prologue_type = AVR_PROLOGUE_NONE;
973 start_pc = get_frame_func (this_frame);
974 current_pc = get_frame_pc (this_frame);
975 if ((start_pc > 0) && (start_pc <= current_pc))
976 avr_scan_prologue (get_frame_arch (this_frame),
977 start_pc, current_pc, info);
979 if ((info->prologue_type != AVR_PROLOGUE_NONE)
980 && (info->prologue_type != AVR_PROLOGUE_MAIN))
982 ULONGEST high_base; /* High byte of FP */
984 /* The SP was moved to the FP. This indicates that a new frame
985 was created. Get THIS frame's FP value by unwinding it from
986 the next frame. */
987 this_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM);
988 high_base = get_frame_register_unsigned (this_frame, AVR_FP_REGNUM + 1);
989 this_base += (high_base << 8);
991 /* The FP points at the last saved register. Adjust the FP back
992 to before the first saved register giving the SP. */
993 prev_sp = this_base + info->size;
995 else
997 /* Assume that the FP is this frame's SP but with that pushed
998 stack space added back. */
999 this_base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM);
1000 prev_sp = this_base + info->size;
1003 /* Add 1 here to adjust for the post-decrement nature of the push
1004 instruction.*/
1005 info->prev_sp = avr_make_saddr (prev_sp + 1);
1006 info->base = avr_make_saddr (this_base);
1008 gdbarch = get_frame_arch (this_frame);
1010 /* Adjust all the saved registers so that they contain addresses and not
1011 offsets. */
1012 for (i = 0; i < gdbarch_num_regs (gdbarch) - 1; i++)
1013 if (info->saved_regs[i].addr > 0)
1014 info->saved_regs[i].addr = info->prev_sp - info->saved_regs[i].addr;
1016 /* Except for the main and startup code, the return PC is always saved on
1017 the stack and is at the base of the frame. */
1019 if (info->prologue_type != AVR_PROLOGUE_MAIN)
1020 info->saved_regs[AVR_PC_REGNUM].addr = info->prev_sp;
1022 /* The previous frame's SP needed to be computed. Save the computed
1023 value. */
1024 tdep = gdbarch_tdep (gdbarch);
1025 trad_frame_set_value (info->saved_regs, AVR_SP_REGNUM,
1026 info->prev_sp - 1 + tdep->call_length);
1028 return info;
1031 static CORE_ADDR
1032 avr_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1034 ULONGEST pc;
1036 pc = frame_unwind_register_unsigned (next_frame, AVR_PC_REGNUM);
1038 return avr_make_iaddr (pc);
1041 static CORE_ADDR
1042 avr_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1044 ULONGEST sp;
1046 sp = frame_unwind_register_unsigned (next_frame, AVR_SP_REGNUM);
1048 return avr_make_saddr (sp);
1051 /* Given a GDB frame, determine the address of the calling function's
1052 frame. This will be used to create a new GDB frame struct. */
1054 static void
1055 avr_frame_this_id (struct frame_info *this_frame,
1056 void **this_prologue_cache,
1057 struct frame_id *this_id)
1059 struct avr_unwind_cache *info
1060 = avr_frame_unwind_cache (this_frame, this_prologue_cache);
1061 CORE_ADDR base;
1062 CORE_ADDR func;
1063 struct frame_id id;
1065 /* The FUNC is easy. */
1066 func = get_frame_func (this_frame);
1068 /* Hopefully the prologue analysis either correctly determined the
1069 frame's base (which is the SP from the previous frame), or set
1070 that base to "NULL". */
1071 base = info->prev_sp;
1072 if (base == 0)
1073 return;
1075 id = frame_id_build (base, func);
1076 (*this_id) = id;
1079 static struct value *
1080 avr_frame_prev_register (struct frame_info *this_frame,
1081 void **this_prologue_cache, int regnum)
1083 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1084 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1085 struct avr_unwind_cache *info
1086 = avr_frame_unwind_cache (this_frame, this_prologue_cache);
1088 if (regnum == AVR_PC_REGNUM || regnum == AVR_PSEUDO_PC_REGNUM)
1090 if (trad_frame_addr_p (info->saved_regs, AVR_PC_REGNUM))
1092 /* Reading the return PC from the PC register is slightly
1093 abnormal. register_size(AVR_PC_REGNUM) says it is 4 bytes,
1094 but in reality, only two bytes (3 in upcoming mega256) are
1095 stored on the stack.
1097 Also, note that the value on the stack is an addr to a word
1098 not a byte, so we will need to multiply it by two at some
1099 point.
1101 And to confuse matters even more, the return address stored
1102 on the stack is in big endian byte order, even though most
1103 everything else about the avr is little endian. Ick! */
1104 ULONGEST pc;
1105 int i;
1106 gdb_byte buf[3];
1107 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1108 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1110 read_memory (info->saved_regs[AVR_PC_REGNUM].addr,
1111 buf, tdep->call_length);
1113 /* Extract the PC read from memory as a big-endian. */
1114 pc = 0;
1115 for (i = 0; i < tdep->call_length; i++)
1116 pc = (pc << 8) | buf[i];
1118 if (regnum == AVR_PC_REGNUM)
1119 pc <<= 1;
1121 return frame_unwind_got_constant (this_frame, regnum, pc);
1124 return frame_unwind_got_optimized (this_frame, regnum);
1127 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1130 static const struct frame_unwind avr_frame_unwind = {
1131 NORMAL_FRAME,
1132 default_frame_unwind_stop_reason,
1133 avr_frame_this_id,
1134 avr_frame_prev_register,
1135 NULL,
1136 default_frame_sniffer
1139 static CORE_ADDR
1140 avr_frame_base_address (struct frame_info *this_frame, void **this_cache)
1142 struct avr_unwind_cache *info
1143 = avr_frame_unwind_cache (this_frame, this_cache);
1145 return info->base;
1148 static const struct frame_base avr_frame_base = {
1149 &avr_frame_unwind,
1150 avr_frame_base_address,
1151 avr_frame_base_address,
1152 avr_frame_base_address
1155 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1156 frame. The frame ID's base needs to match the TOS value saved by
1157 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1159 static struct frame_id
1160 avr_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1162 ULONGEST base;
1164 base = get_frame_register_unsigned (this_frame, AVR_SP_REGNUM);
1165 return frame_id_build (avr_make_saddr (base), get_frame_pc (this_frame));
1168 /* When arguments must be pushed onto the stack, they go on in reverse
1169 order. The below implements a FILO (stack) to do this. */
1171 struct stack_item
1173 int len;
1174 struct stack_item *prev;
1175 void *data;
1178 static struct stack_item *
1179 push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len)
1181 struct stack_item *si;
1182 si = xmalloc (sizeof (struct stack_item));
1183 si->data = xmalloc (len);
1184 si->len = len;
1185 si->prev = prev;
1186 memcpy (si->data, contents, len);
1187 return si;
1190 static struct stack_item *pop_stack_item (struct stack_item *si);
1191 static struct stack_item *
1192 pop_stack_item (struct stack_item *si)
1194 struct stack_item *dead = si;
1195 si = si->prev;
1196 xfree (dead->data);
1197 xfree (dead);
1198 return si;
1201 /* Setup the function arguments for calling a function in the inferior.
1203 On the AVR architecture, there are 18 registers (R25 to R8) which are
1204 dedicated for passing function arguments. Up to the first 18 arguments
1205 (depending on size) may go into these registers. The rest go on the stack.
1207 All arguments are aligned to start in even-numbered registers (odd-sized
1208 arguments, including char, have one free register above them). For example,
1209 an int in arg1 and a char in arg2 would be passed as such:
1211 arg1 -> r25:r24
1212 arg2 -> r22
1214 Arguments that are larger than 2 bytes will be split between two or more
1215 registers as available, but will NOT be split between a register and the
1216 stack. Arguments that go onto the stack are pushed last arg first (this is
1217 similar to the d10v). */
1219 /* NOTE: TRoth/2003-06-17: The rest of this comment is old looks to be
1220 inaccurate.
1222 An exceptional case exists for struct arguments (and possibly other
1223 aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1224 not a multiple of WORDSIZE bytes. In this case the argument is never split
1225 between the registers and the stack, but instead is copied in its entirety
1226 onto the stack, AND also copied into as many registers as there is room
1227 for. In other words, space in registers permitting, two copies of the same
1228 argument are passed in. As far as I can tell, only the one on the stack is
1229 used, although that may be a function of the level of compiler
1230 optimization. I suspect this is a compiler bug. Arguments of these odd
1231 sizes are left-justified within the word (as opposed to arguments smaller
1232 than WORDSIZE bytes, which are right-justified).
1234 If the function is to return an aggregate type such as a struct, the caller
1235 must allocate space into which the callee will copy the return value. In
1236 this case, a pointer to the return value location is passed into the callee
1237 in register R0, which displaces one of the other arguments passed in via
1238 registers R0 to R2. */
1240 static CORE_ADDR
1241 avr_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1242 struct regcache *regcache, CORE_ADDR bp_addr,
1243 int nargs, struct value **args, CORE_ADDR sp,
1244 int struct_return, CORE_ADDR struct_addr)
1246 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1247 int i;
1248 gdb_byte buf[3];
1249 int call_length = gdbarch_tdep (gdbarch)->call_length;
1250 CORE_ADDR return_pc = avr_convert_iaddr_to_raw (bp_addr);
1251 int regnum = AVR_ARGN_REGNUM;
1252 struct stack_item *si = NULL;
1254 if (struct_return)
1256 regcache_cooked_write_unsigned
1257 (regcache, regnum--, (struct_addr >> 8) & 0xff);
1258 regcache_cooked_write_unsigned
1259 (regcache, regnum--, struct_addr & 0xff);
1260 /* SP being post decremented, we need to reserve one byte so that the
1261 return address won't overwrite the result (or vice-versa). */
1262 if (sp == struct_addr)
1263 sp--;
1266 for (i = 0; i < nargs; i++)
1268 int last_regnum;
1269 int j;
1270 struct value *arg = args[i];
1271 struct type *type = check_typedef (value_type (arg));
1272 const bfd_byte *contents = value_contents (arg);
1273 int len = TYPE_LENGTH (type);
1275 /* Calculate the potential last register needed. */
1276 last_regnum = regnum - (len + (len & 1));
1278 /* If there are registers available, use them. Once we start putting
1279 stuff on the stack, all subsequent args go on stack. */
1280 if ((si == NULL) && (last_regnum >= 8))
1282 ULONGEST val;
1284 /* Skip a register for odd length args. */
1285 if (len & 1)
1286 regnum--;
1288 val = extract_unsigned_integer (contents, len, byte_order);
1289 for (j = 0; j < len; j++)
1290 regcache_cooked_write_unsigned
1291 (regcache, regnum--, val >> (8 * (len - j - 1)));
1293 /* No registers available, push the args onto the stack. */
1294 else
1296 /* From here on, we don't care about regnum. */
1297 si = push_stack_item (si, contents, len);
1301 /* Push args onto the stack. */
1302 while (si)
1304 sp -= si->len;
1305 /* Add 1 to sp here to account for post decr nature of pushes. */
1306 write_memory (sp + 1, si->data, si->len);
1307 si = pop_stack_item (si);
1310 /* Set the return address. For the avr, the return address is the BP_ADDR.
1311 Need to push the return address onto the stack noting that it needs to be
1312 in big-endian order on the stack. */
1313 for (i = 1; i <= call_length; i++)
1315 buf[call_length - i] = return_pc & 0xff;
1316 return_pc >>= 8;
1319 sp -= call_length;
1320 /* Use 'sp + 1' since pushes are post decr ops. */
1321 write_memory (sp + 1, buf, call_length);
1323 /* Finally, update the SP register. */
1324 regcache_cooked_write_unsigned (regcache, AVR_SP_REGNUM,
1325 avr_convert_saddr_to_raw (sp));
1327 /* Return SP value for the dummy frame, where the return address hasn't been
1328 pushed. */
1329 return sp + call_length;
1332 /* Unfortunately dwarf2 register for SP is 32. */
1334 static int
1335 avr_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
1337 if (reg >= 0 && reg < 32)
1338 return reg;
1339 if (reg == 32)
1340 return AVR_SP_REGNUM;
1342 warning (_("Unmapped DWARF Register #%d encountered."), reg);
1344 return -1;
1347 /* Initialize the gdbarch structure for the AVR's. */
1349 static struct gdbarch *
1350 avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1352 struct gdbarch *gdbarch;
1353 struct gdbarch_tdep *tdep;
1354 struct gdbarch_list *best_arch;
1355 int call_length;
1357 /* Avr-6 call instructions save 3 bytes. */
1358 switch (info.bfd_arch_info->mach)
1360 case bfd_mach_avr1:
1361 case bfd_mach_avr2:
1362 case bfd_mach_avr3:
1363 case bfd_mach_avr4:
1364 case bfd_mach_avr5:
1365 default:
1366 call_length = 2;
1367 break;
1368 case bfd_mach_avr6:
1369 call_length = 3;
1370 break;
1373 /* If there is already a candidate, use it. */
1374 for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
1375 best_arch != NULL;
1376 best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
1378 if (gdbarch_tdep (best_arch->gdbarch)->call_length == call_length)
1379 return best_arch->gdbarch;
1382 /* None found, create a new architecture from the information provided. */
1383 tdep = XMALLOC (struct gdbarch_tdep);
1384 gdbarch = gdbarch_alloc (&info, tdep);
1386 tdep->call_length = call_length;
1388 /* Create a type for PC. We can't use builtin types here, as they may not
1389 be defined. */
1390 tdep->void_type = arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
1391 tdep->func_void_type = make_function_type (tdep->void_type, NULL);
1392 tdep->pc_type = arch_type (gdbarch, TYPE_CODE_PTR, 4, NULL);
1393 TYPE_TARGET_TYPE (tdep->pc_type) = tdep->func_void_type;
1394 TYPE_UNSIGNED (tdep->pc_type) = 1;
1396 set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1397 set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1398 set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1399 set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1400 set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1401 set_gdbarch_addr_bit (gdbarch, 32);
1403 set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1404 set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1405 set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1407 set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1408 set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
1409 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);
1411 set_gdbarch_read_pc (gdbarch, avr_read_pc);
1412 set_gdbarch_write_pc (gdbarch, avr_write_pc);
1414 set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS);
1416 set_gdbarch_sp_regnum (gdbarch, AVR_SP_REGNUM);
1417 set_gdbarch_pc_regnum (gdbarch, AVR_PC_REGNUM);
1419 set_gdbarch_register_name (gdbarch, avr_register_name);
1420 set_gdbarch_register_type (gdbarch, avr_register_type);
1422 set_gdbarch_num_pseudo_regs (gdbarch, AVR_NUM_PSEUDO_REGS);
1423 set_gdbarch_pseudo_register_read (gdbarch, avr_pseudo_register_read);
1424 set_gdbarch_pseudo_register_write (gdbarch, avr_pseudo_register_write);
1426 set_gdbarch_return_value (gdbarch, avr_return_value);
1427 set_gdbarch_print_insn (gdbarch, print_insn_avr);
1429 set_gdbarch_push_dummy_call (gdbarch, avr_push_dummy_call);
1431 set_gdbarch_dwarf2_reg_to_regnum (gdbarch, avr_dwarf_reg_to_regnum);
1433 set_gdbarch_address_to_pointer (gdbarch, avr_address_to_pointer);
1434 set_gdbarch_pointer_to_address (gdbarch, avr_pointer_to_address);
1435 set_gdbarch_integer_to_address (gdbarch, avr_integer_to_address);
1437 set_gdbarch_skip_prologue (gdbarch, avr_skip_prologue);
1438 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1440 set_gdbarch_breakpoint_from_pc (gdbarch, avr_breakpoint_from_pc);
1442 frame_unwind_append_unwinder (gdbarch, &avr_frame_unwind);
1443 frame_base_set_default (gdbarch, &avr_frame_base);
1445 set_gdbarch_dummy_id (gdbarch, avr_dummy_id);
1447 set_gdbarch_unwind_pc (gdbarch, avr_unwind_pc);
1448 set_gdbarch_unwind_sp (gdbarch, avr_unwind_sp);
1450 return gdbarch;
1453 /* Send a query request to the avr remote target asking for values of the io
1454 registers. If args parameter is not NULL, then the user has requested info
1455 on a specific io register [This still needs implemented and is ignored for
1456 now]. The query string should be one of these forms:
1458 "Ravr.io_reg" -> reply is "NN" number of io registers
1460 "Ravr.io_reg:addr,len" where addr is first register and len is number of
1461 registers to be read. The reply should be "<NAME>,VV;" for each io register
1462 where, <NAME> is a string, and VV is the hex value of the register.
1464 All io registers are 8-bit. */
1466 static void
1467 avr_io_reg_read_command (char *args, int from_tty)
1469 LONGEST bufsiz = 0;
1470 gdb_byte *buf;
1471 char query[400];
1472 char *p;
1473 unsigned int nreg = 0;
1474 unsigned int val;
1475 int i, j, k, step;
1477 /* Find out how many io registers the target has. */
1478 bufsiz = target_read_alloc (&current_target, TARGET_OBJECT_AVR,
1479 "avr.io_reg", &buf);
1481 if (bufsiz <= 0)
1483 fprintf_unfiltered (gdb_stderr,
1484 _("ERR: info io_registers NOT supported "
1485 "by current target\n"));
1486 return;
1489 if (sscanf (buf, "%x", &nreg) != 1)
1491 fprintf_unfiltered (gdb_stderr,
1492 _("Error fetching number of io registers\n"));
1493 xfree (buf);
1494 return;
1497 xfree (buf);
1499 reinitialize_more_filter ();
1501 printf_unfiltered (_("Target has %u io registers:\n\n"), nreg);
1503 /* only fetch up to 8 registers at a time to keep the buffer small */
1504 step = 8;
1506 for (i = 0; i < nreg; i += step)
1508 /* how many registers this round? */
1509 j = step;
1510 if ((i+j) >= nreg)
1511 j = nreg - i; /* last block is less than 8 registers */
1513 snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j);
1514 bufsiz = target_read_alloc (&current_target, TARGET_OBJECT_AVR,
1515 query, &buf);
1517 p = buf;
1518 for (k = i; k < (i + j); k++)
1520 if (sscanf (p, "%[^,],%x;", query, &val) == 2)
1522 printf_filtered ("[%02x] %-15s : %02x\n", k, query, val);
1523 while ((*p != ';') && (*p != '\0'))
1524 p++;
1525 p++; /* skip over ';' */
1526 if (*p == '\0')
1527 break;
1531 xfree (buf);
1535 extern initialize_file_ftype _initialize_avr_tdep; /* -Wmissing-prototypes */
1537 void
1538 _initialize_avr_tdep (void)
1540 register_gdbarch_init (bfd_arch_avr, avr_gdbarch_init);
1542 /* Add a new command to allow the user to query the avr remote target for
1543 the values of the io space registers in a saner way than just using
1544 `x/NNNb ADDR`. */
1546 /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1547 io_registers' to signify it is not available on other platforms. */
1549 add_cmd ("io_registers", class_info, avr_io_reg_read_command,
1550 _("query remote avr target for io space register values"),
1551 &infolist);