gdb/avr-tdep.c

   1 /* Target-dependent code for Atmel AVR, for GDB.
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /* Contributed by Theodore A. Roth, troth@verinet.com */
  23
  24 /* Portions of this file were taken from the original gdb-4.18 patch developed
  25    by Denis Chertykov, denisc@overta.ru */
  26
  27 #include "defs.h"
  28 #include "gdbcmd.h"
  29 #include "gdbcore.h"
  30 #include "inferior.h"
  31 #include "symfile.h"
  32 #include "arch-utils.h"
  33 #include "regcache.h"
  34 #include "gdb_string.h"
  35
  36 /* AVR Background:
  37
  38    (AVR micros are pure Harvard Architecture processors.)
  39
  40    The AVR family of microcontrollers have three distinctly different memory
  41    spaces: flash, sram and eeprom. The flash is 16 bits wide and is used for
  42    the most part to store program instructions. The sram is 8 bits wide and is
  43    used for the stack and the heap. Some devices lack sram and some can have
  44    an additional external sram added on as a peripheral.
  45
  46    The eeprom is 8 bits wide and is used to store data when the device is
  47    powered down. Eeprom is not directly accessible, it can only be accessed
  48    via io-registers using a special algorithm. Accessing eeprom via gdb's
  49    remote serial protocol ('m' or 'M' packets) looks difficult to do and is
  50    not included at this time.
  51
  52    [The eeprom could be read manually via ``x/b <eaddr + AVR_EMEM_START>'' or
  53    written using ``set {unsigned char}<eaddr + AVR_EMEM_START>''.  For this to
  54    work, the remote target must be able to handle eeprom accesses and perform
  55    the address translation.]
  56
  57    All three memory spaces have physical addresses beginning at 0x0. In
  58    addition, the flash is addressed by gcc/binutils/gdb with respect to 8 bit
  59    bytes instead of the 16 bit wide words used by the real device for the
  60    Program Counter.
  61
  62    In order for remote targets to work correctly, extra bits must be added to
  63    addresses before they are send to the target or received from the target
  64    via the remote serial protocol. The extra bits are the MSBs and are used to
  65    decode which memory space the address is referring to. */
  66
  67 #undef XMALLOC
  68 #define XMALLOC(TYPE) ((TYPE*) xmalloc (sizeof (TYPE)))
  69
  70 #undef EXTRACT_INSN
  71 #define EXTRACT_INSN(addr) extract_unsigned_integer(addr,2)
  72
  73 /* Constants: prefixed with AVR_ to avoid name space clashes */
  74
  75 enum
  76 {
  77   AVR_REG_W = 24,
  78   AVR_REG_X = 26,
  79   AVR_REG_Y = 28,
  80   AVR_FP_REGNUM = 28,
  81   AVR_REG_Z = 30,
  82
  83   AVR_SREG_REGNUM = 32,
  84   AVR_SP_REGNUM = 33,
  85   AVR_PC_REGNUM = 34,
  86
  87   AVR_NUM_REGS = 32 + 1 /*SREG*/ + 1 /*SP*/ + 1 /*PC*/,
  88   AVR_NUM_REG_BYTES = 32 + 1 /*SREG*/ + 2 /*SP*/ + 4 /*PC*/,
  89
  90   AVR_PC_REG_INDEX = 35,        /* index into array of registers */
  91
  92   AVR_MAX_PROLOGUE_SIZE = 56,   /* bytes */
  93
  94   /* Count of pushed registers. From r2 to r17 (inclusively), r28, r29 */
  95   AVR_MAX_PUSHES = 18,
  96
  97   /* Number of the last pushed register. r17 for current avr-gcc */
  98   AVR_LAST_PUSHED_REGNUM = 17,
  99
 100   /* FIXME: TRoth/2002-01-??: Can we shift all these memory masks left 8
 101      bits? Do these have to match the bfd vma values?. It sure would make
 102      things easier in the future if they didn't need to match.
 103
 104      Note: I chose these values so as to be consistent with bfd vma
 105      addresses.
 106
 107      TRoth/2002-04-08: There is already a conflict with very large programs
 108      in the mega128. The mega128 has 128K instruction bytes (64K words),
 109      thus the Most Significant Bit is 0x10000 which gets masked off my
 110      AVR_MEM_MASK.
 111
 112      The problem manifests itself when trying to set a breakpoint in a
 113      function which resides in the upper half of the instruction space and
 114      thus requires a 17-bit address.
 115
 116      For now, I've just removed the EEPROM mask and changed AVR_MEM_MASK
 117      from 0x00ff0000 to 0x00f00000. Eeprom is not accessible from gdb yet,
 118      but could be for some remote targets by just adding the correct offset
 119      to the address and letting the remote target handle the low-level
 120      details of actually accessing the eeprom. */
 121
 122   AVR_IMEM_START = 0x00000000,  /* INSN memory */
 123   AVR_SMEM_START = 0x00800000,  /* SRAM memory */
 124 #if 1
 125   /* No eeprom mask defined */
 126   AVR_MEM_MASK = 0x00f00000,    /* mask to determine memory space */
 127 #else
 128   AVR_EMEM_START = 0x00810000,  /* EEPROM memory */
 129   AVR_MEM_MASK = 0x00ff0000,    /* mask to determine memory space */
 130 #endif
 131 };
 132
 133 /* Any function with a frame looks like this
 134    .......    <-SP POINTS HERE
 135    LOCALS1    <-FP POINTS HERE
 136    LOCALS0
 137    SAVED FP
 138    SAVED R3
 139    SAVED R2
 140    RET PC
 141    FIRST ARG
 142    SECOND ARG */
 143
 144 struct frame_extra_info
 145 {
 146   CORE_ADDR return_pc;
 147   CORE_ADDR args_pointer;
 148   int locals_size;
 149   int framereg;
 150   int framesize;
 151   int is_main;
 152 };
 153
 154 struct gdbarch_tdep
 155 {
 156   /* FIXME: TRoth: is there anything to put here? */
 157   int foo;
 158 };
 159
 160 /* Lookup the name of a register given it's number. */
 161
 162 static const char *
 163 avr_register_name (int regnum)
 164 {
 165   static char *register_names[] = {
 166     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 167     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 168     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 169     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 170     "SREG", "SP", "PC"
 171   };
 172   if (regnum < 0)
 173     return NULL;
 174   if (regnum >= (sizeof (register_names) / sizeof (*register_names)))
 175     return NULL;
 176   return register_names[regnum];
 177 }
 178
 179 /* Index within `registers' of the first byte of the space for
 180    register REGNUM.  */
 181
 182 static int
 183 avr_register_byte (int regnum)
 184 {
 185   if (regnum < AVR_PC_REGNUM)
 186     return regnum;
 187   else
 188     return AVR_PC_REG_INDEX;
 189 }
 190
 191 /* Number of bytes of storage in the actual machine representation for
 192    register REGNUM.  */
 193
 194 static int
 195 avr_register_raw_size (int regnum)
 196 {
 197   switch (regnum)
 198     {
 199     case AVR_PC_REGNUM:
 200       return 4;
 201     case AVR_SP_REGNUM:
 202     case AVR_FP_REGNUM:
 203       return 2;
 204     default:
 205       return 1;
 206     }
 207 }
 208
 209 /* Number of bytes of storage in the program's representation
 210    for register N.  */
 211
 212 static int
 213 avr_register_virtual_size (int regnum)
 214 {
 215   return TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum));
 216 }
 217
 218 /* Return the GDB type object for the "standard" data type
 219    of data in register N.  */
 220
 221 static struct type *
 222 avr_register_virtual_type (int regnum)
 223 {
 224   switch (regnum)
 225     {
 226     case AVR_PC_REGNUM:
 227       return builtin_type_unsigned_long;
 228     case AVR_SP_REGNUM:
 229       return builtin_type_unsigned_short;
 230     default:
 231       return builtin_type_unsigned_char;
 232     }
 233 }
 234
 235 /* Instruction address checks and convertions. */
 236
 237 static CORE_ADDR
 238 avr_make_iaddr (CORE_ADDR x)
 239 {
 240   return ((x) | AVR_IMEM_START);
 241 }
 242
 243 static int
 244 avr_iaddr_p (CORE_ADDR x)
 245 {
 246   return (((x) & AVR_MEM_MASK) == AVR_IMEM_START);
 247 }
 248
 249 /* FIXME: TRoth: Really need to use a larger mask for instructions. Some
 250    devices are already up to 128KBytes of flash space.
 251
 252    TRoth/2002-04-8: See comment above where AVR_IMEM_START is defined. */
 253
 254 static CORE_ADDR
 255 avr_convert_iaddr_to_raw (CORE_ADDR x)
 256 {
 257   return ((x) & 0xffffffff);
 258 }
 259
 260 /* SRAM address checks and convertions. */
 261
 262 static CORE_ADDR
 263 avr_make_saddr (CORE_ADDR x)
 264 {
 265   return ((x) | AVR_SMEM_START);
 266 }
 267
 268 static int
 269 avr_saddr_p (CORE_ADDR x)
 270 {
 271   return (((x) & AVR_MEM_MASK) == AVR_SMEM_START);
 272 }
 273
 274 static CORE_ADDR
 275 avr_convert_saddr_to_raw (CORE_ADDR x)
 276 {
 277   return ((x) & 0xffffffff);
 278 }
 279
 280 /* EEPROM address checks and convertions. I don't know if these will ever
 281    actually be used, but I've added them just the same. TRoth */
 282
 283 /* TRoth/2002-04-08: Commented out for now to allow fix for problem with large
 284    programs in the mega128. */
 285
 286 /*  static CORE_ADDR */
 287 /*  avr_make_eaddr (CORE_ADDR x) */
 288 /*  { */
 289 /*    return ((x) | AVR_EMEM_START); */
 290 /*  } */
 291
 292 /*  static int */
 293 /*  avr_eaddr_p (CORE_ADDR x) */
 294 /*  { */
 295 /*    return (((x) & AVR_MEM_MASK) == AVR_EMEM_START); */
 296 /*  } */
 297
 298 /*  static CORE_ADDR */
 299 /*  avr_convert_eaddr_to_raw (CORE_ADDR x) */
 300 /*  { */
 301 /*    return ((x) & 0xffffffff); */
 302 /*  } */
 303
 304 /* Convert from address to pointer and vice-versa. */
 305
 306 static void
 307 avr_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 308 {
 309   /* Is it a code address?  */
 310   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
 311       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
 312     {
 313       store_unsigned_integer (buf, TYPE_LENGTH (type),
 314                               avr_convert_iaddr_to_raw (addr));
 315     }
 316   else
 317     {
 318       /* Strip off any upper segment bits.  */
 319       store_unsigned_integer (buf, TYPE_LENGTH (type),
 320                               avr_convert_saddr_to_raw (addr));
 321     }
 322 }
 323
 324 static CORE_ADDR
 325 avr_pointer_to_address (struct type *type, void *buf)
 326 {
 327   CORE_ADDR addr = extract_address (buf, TYPE_LENGTH (type));
 328
 329   if (TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
 330     {
 331       fprintf_unfiltered (gdb_stderr, "CODE_SPACE ---->> ptr->addr: 0x%lx\n",
 332                           addr);
 333       fprintf_unfiltered (gdb_stderr,
 334                           "+++ If you see this, please send me an email <troth@verinet.com>\n");
 335     }
 336
 337   /* Is it a code address?  */
 338   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
 339       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
 340       || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
 341     return avr_make_iaddr (addr);
 342   else
 343     return avr_make_saddr (addr);
 344 }
 345
 346 static CORE_ADDR
 347 avr_read_pc (ptid_t ptid)
 348 {
 349   ptid_t save_ptid;
 350   CORE_ADDR pc;
 351   CORE_ADDR retval;
 352
 353   save_ptid = inferior_ptid;
 354   inferior_ptid = ptid;
 355   pc = (int) read_register (AVR_PC_REGNUM);
 356   inferior_ptid = save_ptid;
 357   retval = avr_make_iaddr (pc);
 358   return retval;
 359 }
 360
 361 static void
 362 avr_write_pc (CORE_ADDR val, ptid_t ptid)
 363 {
 364   ptid_t save_ptid;
 365
 366   save_ptid = inferior_ptid;
 367   inferior_ptid = ptid;
 368   write_register (AVR_PC_REGNUM, avr_convert_iaddr_to_raw (val));
 369   inferior_ptid = save_ptid;
 370 }
 371
 372 static CORE_ADDR
 373 avr_read_sp (void)
 374 {
 375   return (avr_make_saddr (read_register (AVR_SP_REGNUM)));
 376 }
 377
 378 static void
 379 avr_write_sp (CORE_ADDR val)
 380 {
 381   write_register (AVR_SP_REGNUM, avr_convert_saddr_to_raw (val));
 382 }
 383
 384 static CORE_ADDR
 385 avr_read_fp (void)
 386 {
 387   return (avr_make_saddr (read_register (AVR_FP_REGNUM)));
 388 }
 389
 390 /* Translate a GDB virtual ADDR/LEN into a format the remote target
 391    understands.  Returns number of bytes that can be transfered
 392    starting at TARG_ADDR.  Return ZERO if no bytes can be transfered
 393    (segmentation fault).
 394
 395    TRoth/2002-04-08: Could this be used to check for dereferencing an invalid
 396    pointer? */
 397
 398 static void
 399 avr_remote_translate_xfer_address (CORE_ADDR memaddr, int nr_bytes,
 400                                    CORE_ADDR *targ_addr, int *targ_len)
 401 {
 402   long out_addr;
 403   long out_len;
 404
 405   /* FIXME: TRoth: Do nothing for now. Will need to examine memaddr at this
 406      point and see if the high bit are set with the masks that we want. */
 407
 408   *targ_addr = memaddr;
 409   *targ_len = nr_bytes;
 410 }
 411
 412 /* Function pointers obtained from the target are half of what gdb expects so
 413    multiply by 2. */
 414
 415 static CORE_ADDR
 416 avr_convert_from_func_ptr_addr (CORE_ADDR addr)
 417 {
 418   return addr * 2;
 419 }
 420
 421 /* avr_scan_prologue is also used as the frame_init_saved_regs().
 422
 423    Put here the code to store, into fi->saved_regs, the addresses of
 424    the saved registers of frame described by FRAME_INFO.  This
 425    includes special registers such as pc and fp saved in special ways
 426    in the stack frame.  sp is even more special: the address we return
 427    for it IS the sp for the next frame. */
 428
 429 /* Function: avr_scan_prologue (helper function for avr_init_extra_frame_info)
 430    This function decodes a AVR function prologue to determine:
 431      1) the size of the stack frame
 432      2) which registers are saved on it
 433      3) the offsets of saved regs
 434    This information is stored in the "extra_info" field of the frame_info.
 435
 436    A typical AVR function prologue might look like this:
 437         push rXX
 438         push r28
 439         push r29
 440         in r28,__SP_L__
 441         in r29,__SP_H__
 442         sbiw r28,<LOCALS_SIZE>
 443         in __tmp_reg__,__SREG__
 444         cli
 445         out __SP_L__,r28
 446         out __SREG__,__tmp_reg__
 447         out __SP_H__,r29
 448
 449   A `-mcall-prologues' prologue look like this:
 450         ldi r26,<LOCALS_SIZE>
 451         ldi r27,<LOCALS_SIZE>/265
 452         ldi r30,pm_lo8(.L_foo_body)
 453         ldi r31,pm_hi8(.L_foo_body)
 454         rjmp __prologue_saves__+RRR
 455   .L_foo_body:  */
 456
 457 static void
 458 avr_scan_prologue (struct frame_info *fi)
 459 {
 460   CORE_ADDR prologue_start;
 461   CORE_ADDR prologue_end;
 462   int i;
 463   unsigned short insn;
 464   int regno;
 465   int scan_stage = 0;
 466   char *name;
 467   struct minimal_symbol *msymbol;
 468   int prologue_len;
 469   unsigned char prologue[AVR_MAX_PROLOGUE_SIZE];
 470   int vpc = 0;
 471
 472   fi->extra_info->framereg = AVR_SP_REGNUM;
 473
 474   if (find_pc_partial_function
 475       (fi->pc, &name, &prologue_start, &prologue_end))
 476     {
 477       struct symtab_and_line sal = find_pc_line (prologue_start, 0);
 478
 479       if (sal.line == 0)        /* no line info, use current PC */
 480         prologue_end = fi->pc;
 481       else if (sal.end < prologue_end)  /* next line begins after fn end */
 482         prologue_end = sal.end; /* (probably means no prologue)  */
 483     }
 484   else
 485     /* We're in the boondocks: allow for */
 486     /* 19 pushes, an add, and "mv fp,sp" */
 487     prologue_end = prologue_start + AVR_MAX_PROLOGUE_SIZE;
 488
 489   prologue_end = min (prologue_end, fi->pc);
 490
 491   /* Search the prologue looking for instructions that set up the
 492      frame pointer, adjust the stack pointer, and save registers.  */
 493
 494   fi->extra_info->framesize = 0;
 495   prologue_len = prologue_end - prologue_start;
 496   read_memory (prologue_start, prologue, prologue_len);
 497
 498   /* Scanning main()'s prologue
 499      ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>)
 500      ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>)
 501      out __SP_H__,r29
 502      out __SP_L__,r28 */
 503
 504   if (name && strcmp ("main", name) == 0 && prologue_len == 8)
 505     {
 506       CORE_ADDR locals;
 507       unsigned char img[] = {
 508         0xde, 0xbf,             /* out __SP_H__,r29 */
 509         0xcd, 0xbf              /* out __SP_L__,r28 */
 510       };
 511
 512       fi->extra_info->framereg = AVR_FP_REGNUM;
 513       insn = EXTRACT_INSN (&prologue[vpc]);
 514       /* ldi r28,lo8(<RAM_ADDR> - <LOCALS_SIZE>) */
 515       if ((insn & 0xf0f0) == 0xe0c0)
 516         {
 517           locals = (insn & 0xf) | ((insn & 0x0f00) >> 4);
 518           insn = EXTRACT_INSN (&prologue[vpc + 2]);
 519           /* ldi r29,hi8(<RAM_ADDR> - <LOCALS_SIZE>) */
 520           if ((insn & 0xf0f0) == 0xe0d0)
 521             {
 522               locals |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
 523               if (memcmp (prologue + vpc + 4, img, sizeof (img)) == 0)
 524                 {
 525                   fi->frame = locals;
 526
 527                   /* TRoth: Does -1 mean we're in main? */
 528                   fi->extra_info->is_main = 1;
 529                   return;
 530                 }
 531             }
 532         }
 533     }
 534
 535   /* Scanning `-mcall-prologues' prologue
 536      FIXME: mega prologue have a 12 bytes long */
 537
 538   while (prologue_len <= 12)    /* I'm use while to avoit many goto's */
 539     {
 540       int loc_size;
 541       int body_addr;
 542       unsigned num_pushes;
 543
 544       insn = EXTRACT_INSN (&prologue[vpc]);
 545       /* ldi r26,<LOCALS_SIZE> */
 546       if ((insn & 0xf0f0) != 0xe0a0)
 547         break;
 548       loc_size = (insn & 0xf) | ((insn & 0x0f00) >> 4);
 549
 550       insn = EXTRACT_INSN (&prologue[vpc + 2]);
 551       /* ldi r27,<LOCALS_SIZE> / 256 */
 552       if ((insn & 0xf0f0) != 0xe0b0)
 553         break;
 554       loc_size |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
 555
 556       insn = EXTRACT_INSN (&prologue[vpc + 4]);
 557       /* ldi r30,pm_lo8(.L_foo_body) */
 558       if ((insn & 0xf0f0) != 0xe0e0)
 559         break;
 560       body_addr = (insn & 0xf) | ((insn & 0x0f00) >> 4);
 561
 562       insn = EXTRACT_INSN (&prologue[vpc + 6]);
 563       /* ldi r31,pm_hi8(.L_foo_body) */
 564       if ((insn & 0xf0f0) != 0xe0f0)
 565         break;
 566       body_addr |= ((insn & 0xf) | ((insn & 0x0f00) >> 4)) << 8;
 567
 568       if (body_addr != (prologue_start + 10) / 2)
 569         break;
 570
 571       msymbol = lookup_minimal_symbol ("__prologue_saves__", NULL, NULL);
 572       if (!msymbol)
 573         break;
 574
 575       /* FIXME: prologue for mega have a JMP instead of RJMP */
 576       insn = EXTRACT_INSN (&prologue[vpc + 8]);
 577       /* rjmp __prologue_saves__+RRR */
 578       if ((insn & 0xf000) != 0xc000)
 579         break;
 580
 581       /* Extract PC relative offset from RJMP */
 582       i = (insn & 0xfff) | (insn & 0x800 ? (-1 ^ 0xfff) : 0);
 583       /* Convert offset to byte addressable mode */
 584       i *= 2;
 585       /* Destination address */
 586       i += vpc + prologue_start + 10;
 587       /* Resovle offset (in words) from __prologue_saves__ symbol.
 588          Which is a pushes count in `-mcall-prologues' mode */
 589       num_pushes = AVR_MAX_PUSHES - (i - SYMBOL_VALUE_ADDRESS (msymbol)) / 2;
 590
 591       if (num_pushes > AVR_MAX_PUSHES)
 592         num_pushes = 0;
 593
 594       if (num_pushes)
 595         {
 596           int from;
 597           fi->saved_regs[AVR_FP_REGNUM + 1] = num_pushes;
 598           if (num_pushes >= 2)
 599             fi->saved_regs[AVR_FP_REGNUM] = num_pushes - 1;
 600           i = 0;
 601           for (from = AVR_LAST_PUSHED_REGNUM + 1 - (num_pushes - 2);
 602                from <= AVR_LAST_PUSHED_REGNUM; ++from)
 603             fi->saved_regs[from] = ++i;
 604         }
 605       fi->extra_info->locals_size = loc_size;
 606       fi->extra_info->framesize = loc_size + num_pushes;
 607       fi->extra_info->framereg = AVR_FP_REGNUM;
 608       return;
 609     }
 610
 611   /* Scan interrupt or signal function */
 612
 613   if (prologue_len >= 12)
 614     {
 615       unsigned char img[] = {
 616         0x78, 0x94,             /* sei */
 617         0x1f, 0x92,             /* push r1 */
 618         0x0f, 0x92,             /* push r0 */
 619         0x0f, 0xb6,             /* in r0,0x3f SREG */
 620         0x0f, 0x92,             /* push r0 */
 621         0x11, 0x24              /* clr r1 */
 622       };
 623       if (memcmp (prologue, img, sizeof (img)) == 0)
 624         {
 625           vpc += sizeof (img);
 626           fi->saved_regs[0] = 2;
 627           fi->saved_regs[1] = 1;
 628           fi->extra_info->framesize += 3;
 629         }
 630       else if (memcmp (img + 1, prologue, sizeof (img) - 1) == 0)
 631         {
 632           vpc += sizeof (img) - 1;
 633           fi->saved_regs[0] = 2;
 634           fi->saved_regs[1] = 1;
 635           fi->extra_info->framesize += 3;
 636         }
 637     }
 638
 639   /* First stage of the prologue scanning.
 640      Scan pushes */
 641
 642   for (; vpc <= prologue_len; vpc += 2)
 643     {
 644       insn = EXTRACT_INSN (&prologue[vpc]);
 645       if ((insn & 0xfe0f) == 0x920f)    /* push rXX */
 646         {
 647           /* Bits 4-9 contain a mask for registers R0-R32. */
 648           regno = (insn & 0x1f0) >> 4;
 649           ++fi->extra_info->framesize;
 650           fi->saved_regs[regno] = fi->extra_info->framesize;
 651           scan_stage = 1;
 652         }
 653       else
 654         break;
 655     }
 656
 657   /* Second stage of the prologue scanning.
 658      Scan:
 659      in r28,__SP_L__
 660      in r29,__SP_H__ */
 661
 662   if (scan_stage == 1 && vpc + 4 <= prologue_len)
 663     {
 664       unsigned char img[] = {
 665         0xcd, 0xb7,             /* in r28,__SP_L__ */
 666         0xde, 0xb7              /* in r29,__SP_H__ */
 667       };
 668       unsigned short insn1;
 669
 670       if (memcmp (prologue + vpc, img, sizeof (img)) == 0)
 671         {
 672           vpc += 4;
 673           fi->extra_info->framereg = AVR_FP_REGNUM;
 674           scan_stage = 2;
 675         }
 676     }
 677
 678   /* Third stage of the prologue scanning. (Really two stages)
 679      Scan for:
 680      sbiw r28,XX or subi r28,lo8(XX)
 681      sbci r29,hi8(XX)
 682      in __tmp_reg__,__SREG__
 683      cli
 684      out __SP_L__,r28
 685      out __SREG__,__tmp_reg__
 686      out __SP_H__,r29 */
 687
 688   if (scan_stage == 2 && vpc + 12 <= prologue_len)
 689     {
 690       int locals_size = 0;
 691       unsigned char img[] = {
 692         0x0f, 0xb6,             /* in r0,0x3f */
 693         0xf8, 0x94,             /* cli */
 694         0xcd, 0xbf,             /* out 0x3d,r28 ; SPL */
 695         0x0f, 0xbe,             /* out 0x3f,r0  ; SREG */
 696         0xde, 0xbf              /* out 0x3e,r29 ; SPH */
 697       };
 698       unsigned char img_sig[] = {
 699         0xcd, 0xbf,             /* out 0x3d,r28 ; SPL */
 700         0xde, 0xbf              /* out 0x3e,r29 ; SPH */
 701       };
 702       unsigned char img_int[] = {
 703         0xf8, 0x94,             /* cli */
 704         0xcd, 0xbf,             /* out 0x3d,r28 ; SPL */
 705         0x78, 0x94,             /* sei */
 706         0xde, 0xbf              /* out 0x3e,r29 ; SPH */
 707       };
 708
 709       insn = EXTRACT_INSN (&prologue[vpc]);
 710       vpc += 2;
 711       if ((insn & 0xff30) == 0x9720)    /* sbiw r28,XXX */
 712         locals_size = (insn & 0xf) | ((insn & 0xc0) >> 2);
 713       else if ((insn & 0xf0f0) == 0x50c0)       /* subi r28,lo8(XX) */
 714         {
 715           locals_size = (insn & 0xf) | ((insn & 0xf00) >> 4);
 716           insn = EXTRACT_INSN (&prologue[vpc]);
 717           vpc += 2;
 718           locals_size += ((insn & 0xf) | ((insn & 0xf00) >> 4) << 8);
 719         }
 720       else
 721         return;
 722       fi->extra_info->locals_size = locals_size;
 723       fi->extra_info->framesize += locals_size;
 724     }
 725 }
 726
 727 /* This function actually figures out the frame address for a given pc and
 728    sp.  This is tricky  because we sometimes don't use an explicit
 729    frame pointer, and the previous stack pointer isn't necessarily recorded
 730    on the stack.  The only reliable way to get this info is to
 731    examine the prologue.  */
 732
 733 static void
 734 avr_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 735 {
 736   int reg;
 737
 738   if (fi->next)
 739     fi->pc = FRAME_SAVED_PC (fi->next);
 740
 741   fi->extra_info = (struct frame_extra_info *)
 742     frame_obstack_alloc (sizeof (struct frame_extra_info));
 743   frame_saved_regs_zalloc (fi);
 744
 745   fi->extra_info->return_pc = 0;
 746   fi->extra_info->args_pointer = 0;
 747   fi->extra_info->locals_size = 0;
 748   fi->extra_info->framereg = 0;
 749   fi->extra_info->framesize = 0;
 750   fi->extra_info->is_main = 0;
 751
 752   avr_scan_prologue (fi);
 753
 754   if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 755     {
 756       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
 757          by assuming it's always FP.  */
 758       fi->frame = generic_read_register_dummy (fi->pc, fi->frame, fi->frame);
 759     }
 760   else if (!fi->next)           /* this is the innermost frame? */
 761     fi->frame = read_register (fi->extra_info->framereg);
 762   else if (fi->extra_info->is_main != 1)        /* not the innermost frame, not `main' */
 763     /* If we have an next frame,  the callee saved it. */
 764     {
 765       struct frame_info *next_fi = fi->next;
 766       if (fi->extra_info->framereg == AVR_SP_REGNUM)
 767         fi->frame =
 768           next_fi->frame + 2 /* ret addr */  + next_fi->extra_info->framesize;
 769       /* FIXME: I don't analyse va_args functions  */
 770       else
 771         {
 772           CORE_ADDR fp = 0;
 773           CORE_ADDR fp1 = 0;
 774           unsigned int fp_low, fp_high;
 775
 776           /* Scan all frames */
 777           for (; next_fi; next_fi = next_fi->next)
 778             {
 779               /* look for saved AVR_FP_REGNUM */
 780               if (next_fi->saved_regs[AVR_FP_REGNUM] && !fp)
 781                 fp = next_fi->saved_regs[AVR_FP_REGNUM];
 782               /* look for saved AVR_FP_REGNUM + 1 */
 783               if (next_fi->saved_regs[AVR_FP_REGNUM + 1] && !fp1)
 784                 fp1 = next_fi->saved_regs[AVR_FP_REGNUM + 1];
 785             }
 786           fp_low = (fp ? read_memory_unsigned_integer (avr_make_saddr (fp), 1)
 787                     : read_register (AVR_FP_REGNUM)) & 0xff;
 788           fp_high =
 789             (fp1 ? read_memory_unsigned_integer (avr_make_saddr (fp1), 1) :
 790              read_register (AVR_FP_REGNUM + 1)) & 0xff;
 791           fi->frame = fp_low | (fp_high << 8);
 792         }
 793     }
 794
 795   /* TRoth: Do we want to do this if we are in main? I don't think we should
 796      since return_pc makes no sense when we are in main. */
 797
 798   if ((fi->pc) && (fi->extra_info->is_main == 0))       /* We are not in CALL_DUMMY */
 799     {
 800       CORE_ADDR addr;
 801       int i;
 802
 803       addr = fi->frame + fi->extra_info->framesize + 1;
 804
 805       /* Return address in stack in different endianness */
 806
 807       fi->extra_info->return_pc =
 808         read_memory_unsigned_integer (avr_make_saddr (addr), 1) << 8;
 809       fi->extra_info->return_pc |=
 810         read_memory_unsigned_integer (avr_make_saddr (addr + 1), 1);
 811
 812       /* This return address in words,
 813          must be converted to the bytes address */
 814       fi->extra_info->return_pc *= 2;
 815
 816       /* Resolve a pushed registers addresses */
 817       for (i = 0; i < NUM_REGS; i++)
 818         {
 819           if (fi->saved_regs[i])
 820             fi->saved_regs[i] = addr - fi->saved_regs[i];
 821         }
 822     }
 823 }
 824
 825 /* Restore the machine to the state it had before the current frame was
 826    created.  Usually used either by the "RETURN" command, or by
 827    call_function_by_hand after the dummy_frame is finished. */
 828
 829 static void
 830 avr_pop_frame (void)
 831 {
 832   unsigned regnum;
 833   CORE_ADDR saddr;
 834   struct frame_info *frame = get_current_frame ();
 835
 836   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 837     {
 838       generic_pop_dummy_frame ();
 839     }
 840   else
 841     {
 842       /* TRoth: Why only loop over 8 registers? */
 843
 844       for (regnum = 0; regnum < 8; regnum++)
 845         {
 846           /* Don't forget AVR_SP_REGNUM in a frame_saved_regs struct is the
 847              actual value we want, not the address of the value we want.  */
 848           if (frame->saved_regs[regnum] && regnum != AVR_SP_REGNUM)
 849             {
 850               saddr = avr_make_saddr (frame->saved_regs[regnum]);
 851               write_register (regnum,
 852                               read_memory_unsigned_integer (saddr, 1));
 853             }
 854           else if (frame->saved_regs[regnum] && regnum == AVR_SP_REGNUM)
 855             write_register (regnum, frame->frame + 2);
 856         }
 857
 858       /* Don't forget the update the PC too!  */
 859       write_pc (frame->extra_info->return_pc);
 860     }
 861   flush_cached_frames ();
 862 }
 863
 864 /* Return the saved PC from this frame. */
 865
 866 static CORE_ADDR
 867 avr_frame_saved_pc (struct frame_info *frame)
 868 {
 869   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 870     return generic_read_register_dummy (frame->pc, frame->frame,
 871                                         AVR_PC_REGNUM);
 872   else
 873     return frame->extra_info->return_pc;
 874 }
 875
 876 static CORE_ADDR
 877 avr_saved_pc_after_call (struct frame_info *frame)
 878 {
 879   unsigned char m1, m2;
 880   unsigned int sp = read_register (AVR_SP_REGNUM);
 881   m1 = read_memory_unsigned_integer (avr_make_saddr (sp + 1), 1);
 882   m2 = read_memory_unsigned_integer (avr_make_saddr (sp + 2), 1);
 883   return (m2 | (m1 << 8)) * 2;
 884 }
 885
 886 /* Figure out where in REGBUF the called function has left its return value.
 887    Copy that into VALBUF. */
 888
 889 static void
 890 avr_extract_return_value (struct type *type, char *regbuf, char *valbuf)
 891 {
 892   int wordsize, len;
 893
 894   wordsize = 2;
 895
 896   len = TYPE_LENGTH (type);
 897
 898   switch (len)
 899     {
 900     case 1:                     /* (char) */
 901     case 2:                     /* (short), (int) */
 902       memcpy (valbuf, regbuf + REGISTER_BYTE (24), 2);
 903       break;
 904     case 4:                     /* (long), (float) */
 905       memcpy (valbuf, regbuf + REGISTER_BYTE (22), 4);
 906       break;
 907     case 8:                     /* (double) (doesn't seem to happen, which is good,
 908                                    because this almost certainly isn't right.  */
 909       error ("I don't know how a double is returned.");
 910       break;
 911     }
 912 }
 913
 914 /* Returns the return address for a dummy. */
 915
 916 static CORE_ADDR
 917 avr_call_dummy_address (void)
 918 {
 919   return entry_point_address ();
 920 }
 921
 922 /* Place the appropriate value in the appropriate registers.
 923    Primarily used by the RETURN command.  */
 924
 925 static void
 926 avr_store_return_value (struct type *type, char *valbuf)
 927 {
 928   int wordsize, len, regval;
 929
 930   wordsize = 2;
 931
 932   len = TYPE_LENGTH (type);
 933   switch (len)
 934     {
 935     case 1:                     /* char */
 936     case 2:                     /* short, int */
 937       regval = extract_address (valbuf, len);
 938       write_register (0, regval);
 939       break;
 940     case 4:                     /* long, float */
 941       regval = extract_address (valbuf, len);
 942       write_register (0, regval >> 16);
 943       write_register (1, regval & 0xffff);
 944       break;
 945     case 8:                     /* presumeably double, but doesn't seem to happen */
 946       error ("I don't know how to return a double.");
 947       break;
 948     }
 949 }
 950
 951 /* Setup the return address for a dummy frame, as called by
 952    call_function_by_hand.  Only necessary when you are using an empty
 953    CALL_DUMMY. */
 954
 955 static CORE_ADDR
 956 avr_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 957 {
 958   unsigned char buf[2];
 959   int wordsize = 2;
 960   struct minimal_symbol *msymbol;
 961   CORE_ADDR mon_brk;
 962
 963   fprintf_unfiltered (gdb_stderr, "avr_push_return_address() was called\n");
 964
 965   buf[0] = 0;
 966   buf[1] = 0;
 967   sp -= wordsize;
 968   write_memory (sp + 1, buf, 2);
 969
 970 #if 0
 971   /* FIXME: TRoth/2002-02-18: This should probably be removed since it's a
 972      left-over from Denis' original patch which used avr-mon for the target
 973      instead of the generic remote target. */
 974   if ((strcmp (target_shortname, "avr-mon") == 0)
 975       && (msymbol = lookup_minimal_symbol ("gdb_break", NULL, NULL)))
 976     {
 977       mon_brk = SYMBOL_VALUE_ADDRESS (msymbol);
 978       store_unsigned_integer (buf, wordsize, mon_brk / 2);
 979       sp -= wordsize;
 980       write_memory (sp + 1, buf + 1, 1);
 981       write_memory (sp + 2, buf, 1);
 982     }
 983 #endif
 984   return sp;
 985 }
 986
 987 static CORE_ADDR
 988 avr_skip_prologue (CORE_ADDR pc)
 989 {
 990   CORE_ADDR func_addr, func_end;
 991   struct symtab_and_line sal;
 992
 993   /* See what the symbol table says */
 994
 995   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 996     {
 997       sal = find_pc_line (func_addr, 0);
 998
 999       /* troth/2002-08-05: For some very simple functions, gcc doesn't
1000          generate a prologue and the sal.end ends up being the 2-byte ``ret''
1001          instruction at the end of the function, but func_end ends up being
1002          the address of the first instruction of the _next_ function. By
1003          adjusting func_end by 2 bytes, we can catch these functions and not
1004          return sal.end if it is the ``ret'' instruction. */
1005
1006       if (sal.line != 0 && sal.end < (func_end-2))
1007         return sal.end;
1008     }
1009
1010 /* Either we didn't find the start of this function (nothing we can do),
1011    or there's no line info, or the line after the prologue is after
1012    the end of the function (there probably isn't a prologue). */
1013
1014   return pc;
1015 }
1016
1017 static CORE_ADDR
1018 avr_frame_address (struct frame_info *fi)
1019 {
1020   return avr_make_saddr (fi->frame);
1021 }
1022
1023 /* Given a GDB frame, determine the address of the calling function's frame.
1024    This will be used to create a new GDB frame struct, and then
1025    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
1026
1027    For us, the frame address is its stack pointer value, so we look up
1028    the function prologue to determine the caller's sp value, and return it.  */
1029
1030 static CORE_ADDR
1031 avr_frame_chain (struct frame_info *frame)
1032 {
1033   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
1034     {
1035       /* initialize the return_pc now */
1036       frame->extra_info->return_pc = generic_read_register_dummy (frame->pc,
1037                                                                   frame->
1038                                                                   frame,
1039                                                                   AVR_PC_REGNUM);
1040       return frame->frame;
1041     }
1042   return (frame->extra_info->is_main ? 0
1043           : frame->frame + frame->extra_info->framesize + 2 /* ret addr */ );
1044 }
1045
1046 /* Store the address of the place in which to copy the structure the
1047    subroutine will return.  This is called from call_function.
1048
1049    We store structs through a pointer passed in the first Argument
1050    register. */
1051
1052 static void
1053 avr_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1054 {
1055   write_register (0, addr);
1056 }
1057
1058 /* Extract from an array REGBUF containing the (raw) register state
1059    the address in which a function should return its structure value,
1060    as a CORE_ADDR (or an expression that can be used as one). */
1061
1062 static CORE_ADDR
1063 avr_extract_struct_value_address (char *regbuf)
1064 {
1065   return (extract_address ((regbuf) + REGISTER_BYTE (0),
1066                            REGISTER_RAW_SIZE (0)) | AVR_SMEM_START);
1067 }
1068
1069 /* Setup the function arguments for calling a function in the inferior.
1070
1071    On the AVR architecture, there are 18 registers (R25 to R8) which are
1072    dedicated for passing function arguments.  Up to the first 18 arguments
1073    (depending on size) may go into these registers.  The rest go on the stack.
1074
1075    Arguments that are larger than WORDSIZE bytes will be split between two or
1076    more registers as available, but will NOT be split between a register and
1077    the stack.
1078
1079    An exceptional case exists for struct arguments (and possibly other
1080    aggregates such as arrays) -- if the size is larger than WORDSIZE bytes but
1081    not a multiple of WORDSIZE bytes.  In this case the argument is never split
1082    between the registers and the stack, but instead is copied in its entirety
1083    onto the stack, AND also copied into as many registers as there is room
1084    for.  In other words, space in registers permitting, two copies of the same
1085    argument are passed in.  As far as I can tell, only the one on the stack is
1086    used, although that may be a function of the level of compiler
1087    optimization.  I suspect this is a compiler bug.  Arguments of these odd
1088    sizes are left-justified within the word (as opposed to arguments smaller
1089    than WORDSIZE bytes, which are right-justified).
1090
1091    If the function is to return an aggregate type such as a struct, the caller
1092    must allocate space into which the callee will copy the return value.  In
1093    this case, a pointer to the return value location is passed into the callee
1094    in register R0, which displaces one of the other arguments passed in via
1095    registers R0 to R2. */
1096
1097 static CORE_ADDR
1098 avr_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1099                     int struct_return, CORE_ADDR struct_addr)
1100 {
1101   int stack_alloc, stack_offset;
1102   int wordsize;
1103   int argreg;
1104   int argnum;
1105   struct type *type;
1106   CORE_ADDR regval;
1107   char *val;
1108   char valbuf[4];
1109   int len;
1110
1111   wordsize = 1;
1112 #if 0
1113   /* Now make sure there's space on the stack */
1114   for (argnum = 0, stack_alloc = 0; argnum < nargs; argnum++)
1115     stack_alloc += TYPE_LENGTH (VALUE_TYPE (args[argnum]));
1116   sp -= stack_alloc;            /* make room on stack for args */
1117   /* we may over-allocate a little here, but that won't hurt anything */
1118 #endif
1119   argreg = 25;
1120   if (struct_return)            /* "struct return" pointer takes up one argreg */
1121     {
1122       write_register (--argreg, struct_addr);
1123     }
1124
1125   /* Now load as many as possible of the first arguments into registers, and
1126      push the rest onto the stack.  There are 3N bytes in three registers
1127      available.  Loop thru args from first to last.  */
1128
1129   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
1130     {
1131       type = VALUE_TYPE (args[argnum]);
1132       len = TYPE_LENGTH (type);
1133       val = (char *) VALUE_CONTENTS (args[argnum]);
1134
1135       /* NOTE WELL!!!!!  This is not an "else if" clause!!!  That's because
1136          some *&^%$ things get passed on the stack AND in the registers!  */
1137       while (len > 0)
1138         {                       /* there's room in registers */
1139           len -= wordsize;
1140           regval = extract_address (val + len, wordsize);
1141           write_register (argreg--, regval);
1142         }
1143     }
1144   return sp;
1145 }
1146
1147 /* Initialize the gdbarch structure for the AVR's. */
1148
1149 static struct gdbarch *
1150 avr_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1151 {
1152   /* FIXME: TRoth/2002-02-18: I have no idea if avr_call_dummy_words[] should
1153      be bigger or not. Initial testing seems to show that `call my_func()`
1154      works and backtrace from a breakpoint within the call looks correct.
1155      Admittedly, I haven't tested with more than a very simple program. */
1156   static LONGEST avr_call_dummy_words[] = { 0 };
1157
1158   struct gdbarch *gdbarch;
1159   struct gdbarch_tdep *tdep;
1160
1161   /* Find a candidate among the list of pre-declared architectures. */
1162   arches = gdbarch_list_lookup_by_info (arches, &info);
1163   if (arches != NULL)
1164     return arches->gdbarch;
1165
1166   /* None found, create a new architecture from the information provided. */
1167   tdep = XMALLOC (struct gdbarch_tdep);
1168   gdbarch = gdbarch_alloc (&info, tdep);
1169
1170   /* If we ever need to differentiate the device types, do it here. */
1171   switch (info.bfd_arch_info->mach)
1172     {
1173     case bfd_mach_avr1:
1174     case bfd_mach_avr2:
1175     case bfd_mach_avr3:
1176     case bfd_mach_avr4:
1177     case bfd_mach_avr5:
1178       break;
1179     }
1180
1181   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1182   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1183   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1184   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1185   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1186   set_gdbarch_addr_bit (gdbarch, 32);
1187   set_gdbarch_bfd_vma_bit (gdbarch, 32);        /* FIXME: TRoth/2002-02-18: Is this needed? */
1188
1189   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1190   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1191   set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1192
1193   set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little);
1194   set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little);
1195   set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_single_little);
1196
1197   set_gdbarch_read_pc (gdbarch, avr_read_pc);
1198   set_gdbarch_write_pc (gdbarch, avr_write_pc);
1199   set_gdbarch_read_fp (gdbarch, avr_read_fp);
1200   set_gdbarch_read_sp (gdbarch, avr_read_sp);
1201   set_gdbarch_write_sp (gdbarch, avr_write_sp);
1202
1203   set_gdbarch_num_regs (gdbarch, AVR_NUM_REGS);
1204
1205   set_gdbarch_sp_regnum (gdbarch, AVR_SP_REGNUM);
1206   set_gdbarch_fp_regnum (gdbarch, AVR_FP_REGNUM);
1207   set_gdbarch_pc_regnum (gdbarch, AVR_PC_REGNUM);
1208
1209   set_gdbarch_register_name (gdbarch, avr_register_name);
1210   set_gdbarch_register_size (gdbarch, 1);
1211   set_gdbarch_register_bytes (gdbarch, AVR_NUM_REG_BYTES);
1212   set_gdbarch_register_byte (gdbarch, avr_register_byte);
1213   set_gdbarch_register_raw_size (gdbarch, avr_register_raw_size);
1214   set_gdbarch_max_register_raw_size (gdbarch, 4);
1215   set_gdbarch_register_virtual_size (gdbarch, avr_register_virtual_size);
1216   set_gdbarch_max_register_virtual_size (gdbarch, 4);
1217   set_gdbarch_register_virtual_type (gdbarch, avr_register_virtual_type);
1218
1219   /* We might need to define our own here or define FRAME_INIT_SAVED_REGS */
1220   set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
1221
1222   set_gdbarch_print_insn (gdbarch, print_insn_avr);
1223
1224   set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
1225   set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
1226   set_gdbarch_call_dummy_address (gdbarch, avr_call_dummy_address);
1227   set_gdbarch_call_dummy_start_offset (gdbarch, 0);
1228   set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
1229   set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
1230   set_gdbarch_call_dummy_length (gdbarch, 0);
1231   set_gdbarch_pc_in_call_dummy (gdbarch, generic_pc_in_call_dummy);
1232   set_gdbarch_call_dummy_p (gdbarch, 1);
1233   set_gdbarch_call_dummy_words (gdbarch, avr_call_dummy_words);
1234   set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
1235   set_gdbarch_fix_call_dummy (gdbarch, generic_fix_call_dummy);
1236
1237 /*    set_gdbarch_believe_pcc_promotion (gdbarch, 1); // TRoth: should this be set? */
1238
1239   set_gdbarch_address_to_pointer (gdbarch, avr_address_to_pointer);
1240   set_gdbarch_pointer_to_address (gdbarch, avr_pointer_to_address);
1241   set_gdbarch_deprecated_extract_return_value (gdbarch, avr_extract_return_value);
1242   set_gdbarch_push_arguments (gdbarch, avr_push_arguments);
1243   set_gdbarch_push_dummy_frame (gdbarch, generic_push_dummy_frame);
1244 /*    set_gdbarch_push_return_address (gdbarch, avr_push_return_address); */
1245   set_gdbarch_pop_frame (gdbarch, avr_pop_frame);
1246
1247   set_gdbarch_store_return_value (gdbarch, avr_store_return_value);
1248
1249   set_gdbarch_use_struct_convention (gdbarch, generic_use_struct_convention);
1250   set_gdbarch_store_struct_return (gdbarch, avr_store_struct_return);
1251   set_gdbarch_deprecated_extract_struct_value_address
1252     (gdbarch, avr_extract_struct_value_address);
1253
1254   set_gdbarch_frame_init_saved_regs (gdbarch, avr_scan_prologue);
1255   set_gdbarch_init_extra_frame_info (gdbarch, avr_init_extra_frame_info);
1256   set_gdbarch_skip_prologue (gdbarch, avr_skip_prologue);
1257 /*    set_gdbarch_prologue_frameless_p (gdbarch, avr_prologue_frameless_p); */
1258   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1259
1260   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1261
1262   set_gdbarch_function_start_offset (gdbarch, 0);
1263   set_gdbarch_remote_translate_xfer_address (gdbarch,
1264                                              avr_remote_translate_xfer_address);
1265   set_gdbarch_frame_args_skip (gdbarch, 0);
1266   set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);     /* ??? */
1267   set_gdbarch_frame_chain (gdbarch, avr_frame_chain);
1268   set_gdbarch_frame_chain_valid (gdbarch, generic_func_frame_chain_valid);
1269   set_gdbarch_frame_saved_pc (gdbarch, avr_frame_saved_pc);
1270   set_gdbarch_frame_args_address (gdbarch, avr_frame_address);
1271   set_gdbarch_frame_locals_address (gdbarch, avr_frame_address);
1272   set_gdbarch_saved_pc_after_call (gdbarch, avr_saved_pc_after_call);
1273   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1274
1275   set_gdbarch_convert_from_func_ptr_addr (gdbarch,
1276                                           avr_convert_from_func_ptr_addr);
1277
1278   return gdbarch;
1279 }
1280
1281 /* Send a query request to the avr remote target asking for values of the io
1282    registers. If args parameter is not NULL, then the user has requested info
1283    on a specific io register [This still needs implemented and is ignored for
1284    now]. The query string should be one of these forms:
1285
1286    "Ravr.io_reg" -> reply is "NN" number of io registers
1287
1288    "Ravr.io_reg:addr,len" where addr is first register and len is number of
1289    registers to be read. The reply should be "<NAME>,VV;" for each io register
1290    where, <NAME> is a string, and VV is the hex value of the register.
1291
1292    All io registers are 8-bit. */
1293
1294 static void
1295 avr_io_reg_read_command (char *args, int from_tty)
1296 {
1297   int bufsiz = 0;
1298   char buf[400];
1299   char query[400];
1300   char *p;
1301   unsigned int nreg = 0;
1302   unsigned int val;
1303   int i, j, k, step;
1304
1305 /*    fprintf_unfiltered (gdb_stderr, "DEBUG: avr_io_reg_read_command (\"%s\", %d)\n", */
1306 /*             args, from_tty); */
1307
1308   if (!current_target.to_query)
1309     {
1310       fprintf_unfiltered (gdb_stderr,
1311                           "ERR: info io_registers NOT supported by current target\n");
1312       return;
1313     }
1314
1315   /* Just get the maximum buffer size. */
1316   target_query ((int) 'R', 0, 0, &bufsiz);
1317   if (bufsiz > sizeof (buf))
1318     bufsiz = sizeof (buf);
1319
1320   /* Find out how many io registers the target has. */
1321   strcpy (query, "avr.io_reg");
1322   target_query ((int) 'R', query, buf, &bufsiz);
1323
1324   if (strncmp (buf, "", bufsiz) == 0)
1325     {
1326       fprintf_unfiltered (gdb_stderr,
1327                           "info io_registers NOT supported by target\n");
1328       return;
1329     }
1330
1331   if (sscanf (buf, "%x", &nreg) != 1)
1332     {
1333       fprintf_unfiltered (gdb_stderr,
1334                           "Error fetching number of io registers\n");
1335       return;
1336     }
1337
1338   reinitialize_more_filter ();
1339
1340   printf_unfiltered ("Target has %u io registers:\n\n", nreg);
1341
1342   /* only fetch up to 8 registers at a time to keep the buffer small */
1343   step = 8;
1344
1345   for (i = 0; i < nreg; i += step)
1346     {
1347       j = step - (nreg % step); /* how many registers this round? */
1348
1349       snprintf (query, sizeof (query) - 1, "avr.io_reg:%x,%x", i, j);
1350       target_query ((int) 'R', query, buf, &bufsiz);
1351
1352       p = buf;
1353       for (k = i; k < (i + j); k++)
1354         {
1355           if (sscanf (p, "%[^,],%x;", query, &val) == 2)
1356             {
1357               printf_filtered ("[%02x] %-15s : %02x\n", k, query, val);
1358               while ((*p != ';') && (*p != '\0'))
1359                 p++;
1360               p++;              /* skip over ';' */
1361               if (*p == '\0')
1362                 break;
1363             }
1364         }
1365     }
1366 }
1367
1368 void
1369 _initialize_avr_tdep (void)
1370 {
1371   register_gdbarch_init (bfd_arch_avr, avr_gdbarch_init);
1372
1373   /* Add a new command to allow the user to query the avr remote target for
1374      the values of the io space registers in a saner way than just using
1375      `x/NNNb ADDR`. */
1376
1377   /* FIXME: TRoth/2002-02-18: This should probably be changed to 'info avr
1378      io_registers' to signify it is not available on other platforms. */
1379
1380   add_cmd ("io_registers", class_info, avr_io_reg_read_command,
1381            "query remote avr target for io space register values", &infolist);
1382 }