path: root/gdb/config/a29k/tm-a29k.h

/* OBSOLETE /* Parameters for target machine AMD 29000, for GDB, the GNU debugger. */
/* OBSOLETE    Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, */
/* OBSOLETE    2001 Free Software Foundation, Inc. */
/* OBSOLETE    Contributed by Cygnus Support.  Written by Jim Kingdon. */
/* OBSOLETE  */
/* OBSOLETE    This file is part of GDB. */
/* OBSOLETE  */
/* OBSOLETE    This program is free software; you can redistribute it and/or modify */
/* OBSOLETE    it under the terms of the GNU General Public License as published by */
/* OBSOLETE    the Free Software Foundation; either version 2 of the License, or */
/* OBSOLETE    (at your option) any later version. */
/* OBSOLETE  */
/* OBSOLETE    This program is distributed in the hope that it will be useful, */
/* OBSOLETE    but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* OBSOLETE    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
/* OBSOLETE    GNU General Public License for more details. */
/* OBSOLETE  */
/* OBSOLETE    You should have received a copy of the GNU General Public License */
/* OBSOLETE    along with this program; if not, write to the Free Software */
/* OBSOLETE    Foundation, Inc., 59 Temple Place - Suite 330, */
/* OBSOLETE    Boston, MA 02111-1307, USA.  */ */
/* OBSOLETE  */
/* OBSOLETE #include "regcache.h" */
/* OBSOLETE  */
/* OBSOLETE /* Parameters for an EB29K (a board which plugs into a PC and is */
/* OBSOLETE    accessed through EBMON software running on the PC, which we */
/* OBSOLETE    use as we'd use a remote stub (see remote-eb.c). */
/* OBSOLETE  */
/* OBSOLETE    If gdb is ported to other a29k machines/systems, the */
/* OBSOLETE    machine/system-specific parts should be removed from this file (a */
/* OBSOLETE    la tm-m68k.h).  */ */
/* OBSOLETE  */
/* OBSOLETE /* Byte order is configurable, but this machine runs big-endian.  */ */
/* OBSOLETE #define TARGET_BYTE_ORDER BFD_ENDIAN_BIG */
/* OBSOLETE  */
/* OBSOLETE /* Floating point uses IEEE representations.  */ */
/* OBSOLETE #define IEEE_FLOAT (1) */
/* OBSOLETE  */
/* OBSOLETE /* Recognize our magic number.  */ */
/* OBSOLETE #define BADMAG(x) ((x).f_magic != 0572) */
/* OBSOLETE  */
/* OBSOLETE /* Offset from address of function to start of its code. */
/* OBSOLETE    Zero on most machines.  */ */
/* OBSOLETE  */
/* OBSOLETE #define FUNCTION_START_OFFSET 0 */
/* OBSOLETE  */
/* OBSOLETE /* Advance PC across any function entry prologue instructions */
/* OBSOLETE    to reach some "real" code.  */ */
/* OBSOLETE  */
/* OBSOLETE #define SKIP_PROLOGUE(pc) (a29k_skip_prologue (pc)) */
/* OBSOLETE CORE_ADDR a29k_skip_prologue (); */
/* OBSOLETE  */
/* OBSOLETE /* Immediately after a function call, return the saved pc. */
/* OBSOLETE    Can't go through the frames for this because on some machines */
/* OBSOLETE    the new frame is not set up until the new function executes */
/* OBSOLETE    some instructions.  */ */
/* OBSOLETE  */
/* OBSOLETE #define SAVED_PC_AFTER_CALL(frame) ((frame->flags & TRANSPARENT_FRAME) \ */
/* OBSOLETE 				    ? read_register (TPC_REGNUM) \ */
/* OBSOLETE 				    : read_register (LR0_REGNUM)) */
/* OBSOLETE  */
/* OBSOLETE /* Stack grows downward.  */ */
/* OBSOLETE  */
/* OBSOLETE #define INNER_THAN(lhs,rhs) ((lhs) < (rhs)) */
/* OBSOLETE  */
/* OBSOLETE /* Stack must be aligned on 32-bit boundaries when synthesizing */
/* OBSOLETE    function calls. */ */
/* OBSOLETE  */
/* OBSOLETE #define STACK_ALIGN(ADDR) (((ADDR) + 3) & ~3) */
/* OBSOLETE  */
/* OBSOLETE /* Sequence of bytes for breakpoint instruction.  */ */
/* OBSOLETE /* ASNEQ 0x50, gr1, gr1 */
/* OBSOLETE    The trap number 0x50 is chosen arbitrarily. */
/* OBSOLETE    We let the command line (or previously included files) override this */
/* OBSOLETE    setting.  */ */
/* OBSOLETE #ifndef BREAKPOINT */
/* OBSOLETE #if TARGET_BYTE_ORDER == BFD_ENDIAN_BIG */
/* OBSOLETE #define BREAKPOINT {0x72, 0x50, 0x01, 0x01} */
/* OBSOLETE #else /* Target is little-endian.  */ */
/* OBSOLETE #define BREAKPOINT {0x01, 0x01, 0x50, 0x72} */
/* OBSOLETE #endif /* Target is little-endian.  */ */
/* OBSOLETE #endif /* BREAKPOINT */ */
/* OBSOLETE  */
/* OBSOLETE /* Amount PC must be decremented by after a breakpoint. */
/* OBSOLETE    This is often the number of bytes in BREAKPOINT */
/* OBSOLETE    but not always.  */ */
/* OBSOLETE  */
/* OBSOLETE #define DECR_PC_AFTER_BREAK 0 */
/* OBSOLETE  */
/* OBSOLETE /* Say how long (ordinary) registers are.  This is a piece of bogosity */
/* OBSOLETE    used in push_word and a few other places; REGISTER_RAW_SIZE is the */
/* OBSOLETE    real way to know how big a register is.  */ */
/* OBSOLETE  */
/* OBSOLETE #define REGISTER_SIZE 4 */
/* OBSOLETE  */
/* OBSOLETE /* Allow the register declarations here to be overridden for remote */
/* OBSOLETE    kernel debugging.  */ */
/* OBSOLETE #if !defined (REGISTER_NAMES) */
/* OBSOLETE  */
/* OBSOLETE /* Number of machine registers */ */
/* OBSOLETE  */
/* OBSOLETE #define NUM_REGS 205 */
/* OBSOLETE  */
/* OBSOLETE /* Initializer for an array of names of registers. */
/* OBSOLETE    There should be NUM_REGS strings in this initializer. */
/* OBSOLETE  */
/* OBSOLETE    FIXME, add floating point registers and support here. */
/* OBSOLETE  */
/* OBSOLETE    Also note that this list does not attempt to deal with kernel */
/* OBSOLETE    debugging (in which the first 32 registers are gr64-gr95).  */ */
/* OBSOLETE  */
/* OBSOLETE #define REGISTER_NAMES \ */
/* OBSOLETE {"gr96", "gr97", "gr98", "gr99", "gr100", "gr101", "gr102", "gr103", "gr104", \ */
/* OBSOLETE  "gr105", "gr106", "gr107", "gr108", "gr109", "gr110", "gr111", "gr112", \ */
/* OBSOLETE  "gr113", "gr114", "gr115", "gr116", "gr117", "gr118", "gr119", "gr120", \ */
/* OBSOLETE  "gr121", "gr122", "gr123", "gr124", "gr125", "gr126", "gr127",		 \ */
/* OBSOLETE  "lr0", "lr1", "lr2", "lr3", "lr4", "lr5", "lr6", "lr7", "lr8", "lr9",   \ */
/* OBSOLETE  "lr10", "lr11", "lr12", "lr13", "lr14", "lr15", "lr16", "lr17", "lr18", \ */
/* OBSOLETE  "lr19", "lr20", "lr21", "lr22", "lr23", "lr24", "lr25", "lr26", "lr27", \ */
/* OBSOLETE  "lr28", "lr29", "lr30", "lr31", "lr32", "lr33", "lr34", "lr35", "lr36", \ */
/* OBSOLETE  "lr37", "lr38", "lr39", "lr40", "lr41", "lr42", "lr43", "lr44", "lr45", \ */
/* OBSOLETE  "lr46", "lr47", "lr48", "lr49", "lr50", "lr51", "lr52", "lr53", "lr54", \ */
/* OBSOLETE  "lr55", "lr56", "lr57", "lr58", "lr59", "lr60", "lr61", "lr62", "lr63", \ */
/* OBSOLETE  "lr64", "lr65", "lr66", "lr67", "lr68", "lr69", "lr70", "lr71", "lr72", \ */
/* OBSOLETE  "lr73", "lr74", "lr75", "lr76", "lr77", "lr78", "lr79", "lr80", "lr81", \ */
/* OBSOLETE  "lr82", "lr83", "lr84", "lr85", "lr86", "lr87", "lr88", "lr89", "lr90", \ */
/* OBSOLETE  "lr91", "lr92", "lr93", "lr94", "lr95", "lr96", "lr97", "lr98", "lr99", \ */
/* OBSOLETE  "lr100", "lr101", "lr102", "lr103", "lr104", "lr105", "lr106", "lr107", \ */
/* OBSOLETE  "lr108", "lr109", "lr110", "lr111", "lr112", "lr113", "lr114", "lr115", \ */
/* OBSOLETE  "lr116", "lr117", "lr118", "lr119", "lr120", "lr121", "lr122", "lr123", \ */
/* OBSOLETE  "lr124", "lr125", "lr126", "lr127",					 \ */
/* OBSOLETE   "AI0", "AI1", "AI2", "AI3", "AI4", "AI5", "AI6", "AI7", "AI8", "AI9",  \ */
/* OBSOLETE   "AI10", "AI11", "AI12", "AI13", "AI14", "AI15", "FP",			 \ */
/* OBSOLETE   "bp", "fc", "cr", "q",						 \ */
/* OBSOLETE   "vab", "ops", "cps", "cfg", "cha", "chd", "chc", "rbp", "tmc", "tmr",	 \ */
/* OBSOLETE   "pc0", "pc1", "pc2", "mmu", "lru", "fpe", "inte", "fps", "exo", "gr1",  \ */
/* OBSOLETE   "alu", "ipc", "ipa", "ipb" } */
/* OBSOLETE  */
/* OBSOLETE /* */
/* OBSOLETE  * Converts an sdb register number to an internal gdb register number. */
/* OBSOLETE  * Currently under epi, gr96->0...gr127->31...lr0->32...lr127->159, or... */
/* OBSOLETE  *                      gr64->0...gr95->31, lr0->32...lr127->159. */
/* OBSOLETE  */ */
/* OBSOLETE #define SDB_REG_TO_REGNUM(value) \ */
/* OBSOLETE   (((value) >= 96 && (value) <= 127) ? ((value) - 96) : \ */
/* OBSOLETE    ((value) >= 128 && (value) <=  255) ? ((value) - 128 + LR0_REGNUM) : \ */
/* OBSOLETE    (value)) */
/* OBSOLETE  */
/* OBSOLETE /* */
/* OBSOLETE  * Provide the processor register numbers of some registers that are */
/* OBSOLETE  * expected/written in instructions that might change under different */
/* OBSOLETE  * register sets.  Namely, gcc can compile (-mkernel-registers) so that */
/* OBSOLETE  * it uses gr64-gr95 in stead of gr96-gr127. */
/* OBSOLETE  */ */
/* OBSOLETE #define MSP_HW_REGNUM	125	/* gr125 */ */
/* OBSOLETE #define RAB_HW_REGNUM	126	/* gr126 */ */
/* OBSOLETE  */
/* OBSOLETE /* Convert Processor Special register #x to REGISTER_NAMES register # */ */
/* OBSOLETE #define SR_REGNUM(x) \ */
/* OBSOLETE   ((x) < 15  ? VAB_REGNUM + (x)					 \ */
/* OBSOLETE    : (x) >= 128 && (x) < 131 ? IPC_REGNUM + (x) - 128		 \ */
/* OBSOLETE    : (x) == 131 ? Q_REGNUM					 \ */
/* OBSOLETE    : (x) == 132 ? ALU_REGNUM					 \ */
/* OBSOLETE    : (x) >= 133 && (x) < 136 ? BP_REGNUM + (x) - 133		 \ */
/* OBSOLETE    : (x) >= 160 && (x) < 163 ? FPE_REGNUM + (x) - 160		 \ */
/* OBSOLETE    : (x) == 164 ? EXO_REGNUM                                     \ */
/* OBSOLETE    : (error ("Internal error in SR_REGNUM"), 0)) */
/* OBSOLETE #define GR96_REGNUM 0 */
/* OBSOLETE  */
/* OBSOLETE /* Define the return register separately, so it can be overridden for */
/* OBSOLETE    kernel procedure calling conventions. */ */
/* OBSOLETE #define	RETURN_REGNUM	GR96_REGNUM */
/* OBSOLETE #define GR1_REGNUM 200 */
/* OBSOLETE /* This needs to be the memory stack pointer, not the register stack pointer, */
/* OBSOLETE    to make call_function work right.  */ */
/* OBSOLETE #define SP_REGNUM MSP_REGNUM */
/* OBSOLETE #define FP_REGNUM 33		/* lr1 */ */
/* OBSOLETE  */
/* OBSOLETE /* Return register for transparent calling convention (gr122).  */ */
/* OBSOLETE #define TPC_REGNUM (122 - 96 + GR96_REGNUM) */
/* OBSOLETE  */
/* OBSOLETE /* Large Return Pointer (gr123).  */ */
/* OBSOLETE #define LRP_REGNUM (123 - 96 + GR96_REGNUM) */
/* OBSOLETE  */
/* OBSOLETE /* Static link pointer (gr124).  */ */
/* OBSOLETE #define SLP_REGNUM (124 - 96 + GR96_REGNUM) */
/* OBSOLETE  */
/* OBSOLETE /* Memory Stack Pointer (gr125).  */ */
/* OBSOLETE #define MSP_REGNUM (125 - 96 + GR96_REGNUM) */
/* OBSOLETE  */
/* OBSOLETE /* Register allocate bound (gr126).  */ */
/* OBSOLETE #define RAB_REGNUM (126 - 96 + GR96_REGNUM) */
/* OBSOLETE  */
/* OBSOLETE /* Register Free Bound (gr127).  */ */
/* OBSOLETE #define RFB_REGNUM (127 - 96 + GR96_REGNUM) */
/* OBSOLETE  */
/* OBSOLETE /* Register Stack Pointer.  */ */
/* OBSOLETE #define RSP_REGNUM GR1_REGNUM */
/* OBSOLETE #define LR0_REGNUM 32 */
/* OBSOLETE #define BP_REGNUM 177 */
/* OBSOLETE #define FC_REGNUM 178 */
/* OBSOLETE #define CR_REGNUM 179 */
/* OBSOLETE #define Q_REGNUM 180 */
/* OBSOLETE #define VAB_REGNUM 181 */
/* OBSOLETE #define OPS_REGNUM (VAB_REGNUM + 1) */
/* OBSOLETE #define CPS_REGNUM (VAB_REGNUM + 2) */
/* OBSOLETE #define CFG_REGNUM (VAB_REGNUM + 3) */
/* OBSOLETE #define CHA_REGNUM (VAB_REGNUM + 4) */
/* OBSOLETE #define CHD_REGNUM (VAB_REGNUM + 5) */
/* OBSOLETE #define CHC_REGNUM (VAB_REGNUM + 6) */
/* OBSOLETE #define RBP_REGNUM (VAB_REGNUM + 7) */
/* OBSOLETE #define TMC_REGNUM (VAB_REGNUM + 8) */
/* OBSOLETE #define TMR_REGNUM (VAB_REGNUM + 9) */
/* OBSOLETE #define NPC_REGNUM (VAB_REGNUM + 10)	/* pc0 */ */
/* OBSOLETE #define PC_REGNUM  (VAB_REGNUM + 11)	/* pc1 */ */
/* OBSOLETE #define PC2_REGNUM (VAB_REGNUM + 12) */
/* OBSOLETE #define MMU_REGNUM (VAB_REGNUM + 13) */
/* OBSOLETE #define LRU_REGNUM (VAB_REGNUM + 14) */
/* OBSOLETE #define FPE_REGNUM (VAB_REGNUM + 15) */
/* OBSOLETE #define INTE_REGNUM (VAB_REGNUM + 16) */
/* OBSOLETE #define FPS_REGNUM (VAB_REGNUM + 17) */
/* OBSOLETE #define EXO_REGNUM (VAB_REGNUM + 18) */
/* OBSOLETE /* gr1 is defined above as 200 = VAB_REGNUM + 19 */ */
/* OBSOLETE #define ALU_REGNUM (VAB_REGNUM + 20) */
/* OBSOLETE #define PS_REGNUM  ALU_REGNUM */
/* OBSOLETE #define IPC_REGNUM (VAB_REGNUM + 21) */
/* OBSOLETE #define IPA_REGNUM (VAB_REGNUM + 22) */
/* OBSOLETE #define IPB_REGNUM (VAB_REGNUM + 23) */
/* OBSOLETE  */
/* OBSOLETE #endif /* !defined(REGISTER_NAMES) */ */
/* OBSOLETE  */
/* OBSOLETE /* Total amount of space needed to store our copies of the machine's */
/* OBSOLETE    register state, the array `registers'.  */ */
/* OBSOLETE #define REGISTER_BYTES (NUM_REGS * 4) */
/* OBSOLETE  */
/* OBSOLETE /* Index within `registers' of the first byte of the space for */
/* OBSOLETE    register N.  */ */
/* OBSOLETE #define REGISTER_BYTE(N)  ((N)*4) */
/* OBSOLETE  */
/* OBSOLETE /* Number of bytes of storage in the actual machine representation */
/* OBSOLETE    for register N.  */ */
/* OBSOLETE  */
/* OBSOLETE /* All regs are 4 bytes.  */ */
/* OBSOLETE  */
/* OBSOLETE #define REGISTER_RAW_SIZE(N) (4) */
/* OBSOLETE  */
/* OBSOLETE /* Number of bytes of storage in the program's representation */
/* OBSOLETE    for register N.  */ */
/* OBSOLETE  */
/* OBSOLETE /* All regs are 4 bytes.  */ */
/* OBSOLETE  */
/* OBSOLETE #define REGISTER_VIRTUAL_SIZE(N) (4) */
/* OBSOLETE  */
/* OBSOLETE /* Largest value REGISTER_RAW_SIZE can have.  */ */
/* OBSOLETE  */
/* OBSOLETE #define MAX_REGISTER_RAW_SIZE (4) */
/* OBSOLETE  */
/* OBSOLETE /* Largest value REGISTER_VIRTUAL_SIZE can have.  */ */
/* OBSOLETE  */
/* OBSOLETE #define MAX_REGISTER_VIRTUAL_SIZE (4) */
/* OBSOLETE  */
/* OBSOLETE /* Return the GDB type object for the "standard" data type */
/* OBSOLETE    of data in register N.  */ */
/* OBSOLETE  */
/* OBSOLETE #define REGISTER_VIRTUAL_TYPE(N) \ */
/* OBSOLETE   (((N) == PC_REGNUM || (N) == LRP_REGNUM || (N) == SLP_REGNUM         \ */
/* OBSOLETE     || (N) == MSP_REGNUM || (N) == RAB_REGNUM || (N) == RFB_REGNUM     \ */
/* OBSOLETE     || (N) == GR1_REGNUM || (N) == FP_REGNUM || (N) == LR0_REGNUM       \ */
/* OBSOLETE     || (N) == NPC_REGNUM || (N) == PC2_REGNUM)                           \ */
/* OBSOLETE    ? lookup_pointer_type (builtin_type_void) : builtin_type_int) */
/* OBSOLETE  */
/* OBSOLETE /* Store the address of the place in which to copy the structure the */
/* OBSOLETE    subroutine will return.  This is called from call_function. */ */
/* OBSOLETE /* On the a29k the LRP points to the part of the structure beyond the first */
/* OBSOLETE    16 words.  */ */
/* OBSOLETE #define STORE_STRUCT_RETURN(ADDR, SP) \ */
/* OBSOLETE   write_register (LRP_REGNUM, (ADDR) + 16 * 4); */
/* OBSOLETE  */
/* OBSOLETE /* Should call_function allocate stack space for a struct return?  */ */
/* OBSOLETE /* On the a29k objects over 16 words require the caller to allocate space.  */ */
/* OBSOLETE extern use_struct_convention_fn a29k_use_struct_convention; */
/* OBSOLETE #define USE_STRUCT_CONVENTION(gcc_p, type) a29k_use_struct_convention (gcc_p, type) */
/* OBSOLETE  */
/* OBSOLETE /* Extract from an array REGBUF containing the (raw) register state */
/* OBSOLETE    a function return value of type TYPE, and copy that, in virtual format, */
/* OBSOLETE    into VALBUF.  */ */
/* OBSOLETE  */
/* OBSOLETE #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF)	      \ */
/* OBSOLETE   {    	       	       	       	       	       	       	       	       	   \ */
/* OBSOLETE     int reg_length = TYPE_LENGTH (TYPE);				   \ */
/* OBSOLETE     if (reg_length > 16 * 4)						   \ */
/* OBSOLETE       {									   \ */
/* OBSOLETE 	reg_length = 16 * 4;						   \ */
/* OBSOLETE 	read_memory (*((int *)(REGBUF) + LRP_REGNUM), (VALBUF) + 16 * 4,   \ */
/* OBSOLETE 		     TYPE_LENGTH (TYPE) - 16 * 4);			   \ */
/* OBSOLETE       }									   \ */
/* OBSOLETE     memcpy ((VALBUF), ((int *)(REGBUF))+RETURN_REGNUM, reg_length);	   \ */
/* OBSOLETE   } */
/* OBSOLETE  */
/* OBSOLETE /* Write into appropriate registers a function return value */
/* OBSOLETE    of type TYPE, given in virtual format.  */ */
/* OBSOLETE  */
/* OBSOLETE #define STORE_RETURN_VALUE(TYPE,VALBUF) \ */
/* OBSOLETE   {									  \ */
/* OBSOLETE     int reg_length = TYPE_LENGTH (TYPE);				  \ */
/* OBSOLETE     if (reg_length > 16 * 4)						  \ */
/* OBSOLETE       {									  \ */
/* OBSOLETE         reg_length = 16 * 4;						  \ */
/* OBSOLETE         write_memory (read_register (LRP_REGNUM),			  \ */
/* OBSOLETE 		      (char *)(VALBUF) + 16 * 4,			  \ */
/* OBSOLETE 		      TYPE_LENGTH (TYPE) - 16 * 4);			  \ */
/* OBSOLETE       }									  \ */
/* OBSOLETE     write_register_bytes (REGISTER_BYTE (RETURN_REGNUM), (char *)(VALBUF),  \ */
/* OBSOLETE 			  TYPE_LENGTH (TYPE));				  \ */
/* OBSOLETE   } */
/* OBSOLETE /* *INDENT-OFF* */ */
/* OBSOLETE /* The a29k user's guide documents well what the stacks look like. */
/* OBSOLETE    But what isn't so clear there is how this interracts with the */
/* OBSOLETE    symbols, or with GDB. */
/* OBSOLETE    In the following saved_msp, saved memory stack pointer (which functions */
/* OBSOLETE    as a memory frame pointer), means either */
/* OBSOLETE    a register containing the memory frame pointer or, in the case of */
/* OBSOLETE    functions with fixed size memory frames (i.e. those who don't use */
/* OBSOLETE    alloca()), the result of the calculation msp + msize. */
/* OBSOLETE  */
/* OBSOLETE    LOC_ARG, LOC_LOCAL - For GCC, these are relative to saved_msp. */
/* OBSOLETE    For high C, these are relative to msp (making alloca impossible). */
/* OBSOLETE    LOC_REGISTER, LOC_REGPARM - The register number is the number at the */
/* OBSOLETE    time the function is running (after the prologue), or in the case */
/* OBSOLETE    of LOC_REGPARM, may be a register number in the range 160-175. */
/* OBSOLETE  */
/* OBSOLETE    The compilers do things like store an argument into memory, and then put out */
/* OBSOLETE    a LOC_ARG for it, or put it into global registers and put out a */
/* OBSOLETE    LOC_REGPARM.  Thus is it important to execute the first line of */
/* OBSOLETE    code (i.e. the line of the open brace, i.e. the prologue) of a function */
/* OBSOLETE    before trying to print arguments or anything. */
/* OBSOLETE  */
/* OBSOLETE    The following diagram attempts to depict what is going on in memory */
/* OBSOLETE    (see also the _a29k user's guide_) and also how that interacts with */
/* OBSOLETE    GDB frames.  We arbitrarily pick fci->frame to point the same place */
/* OBSOLETE    as the register stack pointer; since we set it ourself in */
/* OBSOLETE    INIT_EXTRA_FRAME_INFO, and access it only through the FRAME_* */
/* OBSOLETE    macros, it doesn't really matter exactly how we */
/* OBSOLETE    do it.  However, note that FRAME_FP is used in two ways in GDB: */
/* OBSOLETE    (1) as a "magic cookie" which uniquely identifies frames (even over */
/* OBSOLETE    calls to the inferior), (2) (in PC_IN_CALL_DUMMY [ON_STACK]) */
/* OBSOLETE    as the value of SP_REGNUM before the dummy frame was pushed.  These */
/* OBSOLETE    two meanings would be incompatible for the a29k if we defined */
/* OBSOLETE    CALL_DUMMY_LOCATION == ON_STACK (but we don't, so don't worry about it). */
/* OBSOLETE    Also note that "lr1" below, while called a frame pointer */
/* OBSOLETE    in the user's guide, has only one function:  To determine whether */
/* OBSOLETE    registers need to be filled in the function epilogue. */
/* OBSOLETE  */
/* OBSOLETE    Consider the code: */
/* OBSOLETE    < call bar> */
/* OBSOLETE    loc1: . . . */
/* OBSOLETE    bar:  sub gr1,gr1,rsize_b */
/* OBSOLETE    . . . */
/* OBSOLETE    add mfp,msp,0 */
/* OBSOLETE    sub msp,msp,msize_b */
/* OBSOLETE    . . . */
/* OBSOLETE    < call foo > */
/* OBSOLETE    loc2: . . . */
/* OBSOLETE    foo:  sub gr1,gr1,rsize_f */
/* OBSOLETE    . . . */
/* OBSOLETE    add mfp,msp,0 */
/* OBSOLETE    sub msp,msp,msize_f */
/* OBSOLETE    . . . */
/* OBSOLETE    loc3: < suppose the inferior stops here > */
/* OBSOLETE  */
/* OBSOLETE    memory stack      register stack */
/* OBSOLETE    |           |     |____________| */
/* OBSOLETE    |           |     |____loc1____| */
/* OBSOLETE    +------->|___________|     |            |   ^ */
/* OBSOLETE    |        | ^         |     |  locals_b  |   | */
/* OBSOLETE    |        | |         |     |____________|   | */
/* OBSOLETE    |        | |         |     |            |   | rsize_b */
/* OBSOLETE    |        | | msize_b |     | args_to_f  |   | */
/* OBSOLETE    |        | |         |     |____________|   | */
/* OBSOLETE    |        | |         |     |____lr1_____|   V */
/* OBSOLETE    |        | V         |     |____loc2____|<----------------+ */
/* OBSOLETE    |   +--->|___________|<---------mfp     |   ^             | */
/* OBSOLETE    |   |    | ^         |     |  locals_f  |   |             | */
/* OBSOLETE    |   |    | | msize_f |     |____________|   |             | */
/* OBSOLETE    |   |    | |         |     |            |   | rsize_f     | */
/* OBSOLETE    |   |    | V         |     |   args     |   |             | */
/* OBSOLETE    |   |    |___________|<msp |____________|   |             | */
/* OBSOLETE    |   |                      |_____lr1____|   V             | */
/* OBSOLETE    |   |                      |___garbage__| <- gr1 <----+   | */
/* OBSOLETE    |   |                                                |   | */
/* OBSOLETE    |   |                                                |   | */
/* OBSOLETE    |   |                             pc=loc3                    |   | */
/* OBSOLETE    |   |                                                |   | */
/* OBSOLETE    |   |                                                |   | */
/* OBSOLETE    |   |            frame cache                         |   | */
/* OBSOLETE    |   |       |_________________|                      |   | */
/* OBSOLETE    |   |       |rsize=rsize_b    |                      |   | */
/* OBSOLETE    |   |       |msize=msize_b    |                      |   | */
/* OBSOLETE    +---|--------saved_msp        |                      |   | */
/* OBSOLETE    |       |frame------------------------------------|---+ */
/* OBSOLETE    |       |pc=loc2          |                       | */
/* OBSOLETE    |       |_________________|                       | */
/* OBSOLETE    |       |rsize=rsize_f    |                       | */
/* OBSOLETE    |       |msize=msize_f    |                       | */
/* OBSOLETE    +--------saved_msp        |                       | */
/* OBSOLETE    |frame------------------------------------+ */
/* OBSOLETE    |pc=loc3          | */
/* OBSOLETE    |_________________| */
/* OBSOLETE  */
/* OBSOLETE    So, is that sufficiently confusing?  Welcome to the 29000. */
/* OBSOLETE    Notes: */
/* OBSOLETE    * The frame for foo uses a memory frame pointer but the frame for */
/* OBSOLETE    bar does not.  In the latter case the saved_msp is */
/* OBSOLETE    computed by adding msize to the saved_msp of the */
/* OBSOLETE    next frame. */
/* OBSOLETE    * msize is in the frame cache only for high C's sake.  */ */
/* OBSOLETE /* *INDENT-ON* */ */
/* OBSOLETE  */
/* OBSOLETE  */
/* OBSOLETE void read_register_stack (); */
/* OBSOLETE long read_register_stack_integer (); */
/* OBSOLETE  */
/* OBSOLETE #define FRAME_INIT_SAVED_REGS(fi)	/*no-op */ */
/* OBSOLETE  */
/* OBSOLETE #define EXTRA_FRAME_INFO  \ */
/* OBSOLETE   CORE_ADDR saved_msp;    \ */
/* OBSOLETE   unsigned int rsize;     \ */
/* OBSOLETE   unsigned int msize;	  \ */
/* OBSOLETE   unsigned char flags; */
/* OBSOLETE  */
/* OBSOLETE /* Bits for flags in EXTRA_FRAME_INFO */ */
/* OBSOLETE #define TRANSPARENT_FRAME	0x1	/* This is a transparent frame */ */
/* OBSOLETE #define MFP_USED		0x2	/* A memory frame pointer is used */ */
/* OBSOLETE  */
/* OBSOLETE /* Because INIT_FRAME_PC gets passed fromleaf, that's where we init */
/* OBSOLETE    not only ->pc and ->frame, but all the extra stuff, when called from */
/* OBSOLETE    get_prev_frame, that is.  */ */
/* OBSOLETE #define INIT_EXTRA_FRAME_INFO(fromleaf, fci)  init_extra_frame_info(fci) */
/* OBSOLETE void init_extra_frame_info (); */
/* OBSOLETE  */
/* OBSOLETE #define INIT_FRAME_PC(fromleaf, fci) init_frame_pc(fromleaf, fci) */
/* OBSOLETE void init_frame_pc (); */
/* OBSOLETE  */
/* OBSOLETE  */
/* OBSOLETE /* FRAME_CHAIN takes a FRAME */
/* OBSOLETE    and produces the frame's chain-pointer. */
/* OBSOLETE  */
/* OBSOLETE    However, if FRAME_CHAIN_VALID returns zero, */
/* OBSOLETE    it means the given frame is the outermost one and has no caller.  */ */
/* OBSOLETE  */
/* OBSOLETE /* On the a29k, the nominal address of a frame is the address on the */
/* OBSOLETE    register stack of the return address (the one next to the incoming */
/* OBSOLETE    arguments, not down at the bottom so nominal address == stack pointer). */
/* OBSOLETE  */
/* OBSOLETE    GDB expects "nominal address" to equal contents of FP_REGNUM, */
/* OBSOLETE    at least when it comes time to create the innermost frame. */
/* OBSOLETE    However, that doesn't work for us, so when creating the innermost */
/* OBSOLETE    frame we set ->frame ourselves in INIT_EXTRA_FRAME_INFO.  */ */
/* OBSOLETE  */
/* OBSOLETE /* These are mostly dummies for the a29k because INIT_FRAME_PC */
/* OBSOLETE    sets prev->frame instead.  */ */
/* OBSOLETE /* If rsize is zero, we must be at end of stack (or otherwise hosed). */
/* OBSOLETE    If we don't check rsize, we loop forever if we see rsize == 0.  */ */
/* OBSOLETE #define FRAME_CHAIN(thisframe) \ */
/* OBSOLETE   ((thisframe)->rsize == 0 \ */
/* OBSOLETE    ? 0 \ */
/* OBSOLETE    : (thisframe)->frame + (thisframe)->rsize) */
/* OBSOLETE  */
/* OBSOLETE /* Determine if the frame has a 'previous' and back-traceable frame. */ */
/* OBSOLETE #define FRAME_IS_UNCHAINED(frame)	((frame)->flags & TRANSPARENT_FRAME) */
/* OBSOLETE  */
/* OBSOLETE /* Find the previous frame of a transparent routine. */
/* OBSOLETE  * For now lets not try and trace through a transparent routine (we might  */
/* OBSOLETE  * have to assume that all transparent routines are traps). */
/* OBSOLETE  */ */
/* OBSOLETE #define FIND_PREV_UNCHAINED_FRAME(frame)	0 */
/* OBSOLETE  */
/* OBSOLETE /* Define other aspects of the stack frame.  */ */
/* OBSOLETE  */
/* OBSOLETE /* An expression that tells us whether the function invocation represented */
/* OBSOLETE    by FI does not have a frame on the stack associated with it. */ */
/* OBSOLETE #define FRAMELESS_FUNCTION_INVOCATION(FI) \ */
/* OBSOLETE   (frameless_look_for_prologue (FI)) */
/* OBSOLETE  */
/* OBSOLETE /* Saved pc (i.e. return address).  */ */
/* OBSOLETE #define FRAME_SAVED_PC(fraim) \ */
/* OBSOLETE   (read_register_stack_integer ((fraim)->frame + (fraim)->rsize, 4)) */
/* OBSOLETE  */
/* OBSOLETE /* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their */
/* OBSOLETE    offsets being relative to the memory stack pointer (high C) or */
/* OBSOLETE    saved_msp (gcc).  */ */
/* OBSOLETE  */
/* OBSOLETE #define FRAME_LOCALS_ADDRESS(fi) frame_locals_address (fi) */
/* OBSOLETE extern CORE_ADDR frame_locals_address (); */
/* OBSOLETE  */
/* OBSOLETE /* Return number of args passed to a frame. */
/* OBSOLETE    Can return -1, meaning no way to tell.  */ */
/* OBSOLETE /* We tried going to the effort of finding the tags word and getting */
/* OBSOLETE    the argcount field from it, to support debugging assembler code. */
/* OBSOLETE    Problem was, the "argcount" field never did hold the argument */
/* OBSOLETE    count.  */ */
/* OBSOLETE #define	FRAME_NUM_ARGS(fi) (-1) */
/* OBSOLETE  */
/* OBSOLETE #define FRAME_ARGS_ADDRESS(fi) FRAME_LOCALS_ADDRESS (fi) */
/* OBSOLETE  */
/* OBSOLETE /* Return number of bytes at start of arglist that are not really args.  */ */
/* OBSOLETE  */
/* OBSOLETE #define FRAME_ARGS_SKIP 0 */
/* OBSOLETE  */
/* OBSOLETE /* Provide our own get_saved_register.  HAVE_REGISTER_WINDOWS is insufficient */
/* OBSOLETE    because registers get renumbered on the a29k without getting saved.  */ */
/* OBSOLETE  */
/* OBSOLETE struct frame_info; */
/* OBSOLETE void a29k_get_saved_register (char *raw_buffer, int *optimized, */
/* OBSOLETE 			      CORE_ADDR * addrp, struct frame_info *frame, */
/* OBSOLETE 			      int regnum, enum lval_type *lvalp); */
/* OBSOLETE #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \ */
/* OBSOLETE       a29k_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval) */
/* OBSOLETE  */
/* OBSOLETE /* Call function stuff.  */ */
/* OBSOLETE /* *INDENT-OFF* */ */
/* OBSOLETE /* The dummy frame looks like this (see also the general frame picture */
/* OBSOLETE    above): */
/* OBSOLETE  */
/* OBSOLETE 					register stack */
/* OBSOLETE  */
/* OBSOLETE 	                	      |                |  frame for function */
/* OBSOLETE                	                      |   locals_sproc |  executing at time */
/* OBSOLETE                                       |________________|  of call_function. */
/* OBSOLETE                      		      |	               |  We must not disturb */
/* OBSOLETE                      		      |	args_out_sproc |  it. */
/* OBSOLETE         memory stack 		      |________________| */
/* OBSOLETE                      		      |____lr1_sproc___|<-+ */
/* OBSOLETE        |            |		      |__retaddr_sproc_|  | <-- gr1 (at start) */
/* OBSOLETE        |____________|<-msp 0 <-----------mfp_dummy_____|  | */
/* OBSOLETE        |            |  (at start)     |  save regs     |  | */
/* OBSOLETE        | arg_slop   |		      |  pc0,pc1       |  | */
/* OBSOLETE        |            |		      |  pc2,lr0 sproc |  | */
/* OBSOLETE        | (16 words) |		      | gr96-gr124     |  | */
/* OBSOLETE        |____________|<-msp 1--after   | sr160-sr162    |  | */
/* OBSOLETE        |            | PUSH_DUMMY_FRAME| sr128-sr135    |  | */
/* OBSOLETE        | struct ret |                 |________________|  | */
/* OBSOLETE        | 17+        |                 |                |  |  */
/* OBSOLETE        |____________|<- lrp           | args_out_dummy |  | */
/* OBSOLETE        | struct ret |		      |  (16 words)    |  | */
/* OBSOLETE        | 16         |		      |________________|  | */
/* OBSOLETE        | (16 words) |                 |____lr1_dummy___|--+ */
/* OBSOLETE        |____________|<- msp 2--after  |_retaddr_dummy__|<- gr1 after */
/* OBSOLETE        |            | struct ret      |                |   PUSH_DUMMY_FRAME */
/* OBSOLETE        | margs17+   | area allocated  |  locals_inf    | */
/* OBSOLETE        |            |                 |________________|    called */
/* OBSOLETE        |____________|<- msp 4--when   |                |    function's */
/* OBSOLETE        |            |   inf called    | args_out_inf   |    frame (set up */
/* OBSOLETE        | margs16    |                 |________________|    by called */
/* OBSOLETE        | (16 words) |                 |_____lr1_inf____|    function). */
/* OBSOLETE        |____________|<- msp 3--after  |       .        | */
/* OBSOLETE        |            |   args pushed   |       .        | */
/* OBSOLETE        |            |	              |       .        | */
/* OBSOLETE                                       |                | */
/* OBSOLETE  */
/* OBSOLETE    arg_slop: This area is so that when the call dummy adds 16 words to */
/* OBSOLETE       the msp, it won't end up larger than mfp_dummy (it is needed in the */
/* OBSOLETE       case where margs and struct_ret do not add up to at least 16 words). */
/* OBSOLETE    struct ret:  This area is allocated by GDB if the return value is more */
/* OBSOLETE       than 16 words.  struct ret_16 is not used on the a29k. */
/* OBSOLETE    margs:  Pushed by GDB.  The call dummy copies the first 16 words to */
/* OBSOLETE       args_out_dummy. */
/* OBSOLETE    retaddr_sproc:  Contains the PC at the time we call the function. */
/* OBSOLETE       set by PUSH_DUMMY_FRAME and read by POP_FRAME. */
/* OBSOLETE    retaddr_dummy:  This points to a breakpoint instruction in the dummy.  */ */
/* OBSOLETE /* *INDENT-ON* */ */
/* OBSOLETE  */
/* OBSOLETE  */
/* OBSOLETE  */
/* OBSOLETE /* Rsize for dummy frame, in bytes.  */ */
/* OBSOLETE  */
/* OBSOLETE /* Bytes for outgoing args, lr1, and retaddr.  */ */
/* OBSOLETE #define DUMMY_ARG (2 * 4 + 16 * 4) */
/* OBSOLETE  */
/* OBSOLETE /* Number of special registers (sr128-) to save.  */ */
/* OBSOLETE #define DUMMY_SAVE_SR128 8 */
/* OBSOLETE /* Number of special registers (sr160-) to save.  */ */
/* OBSOLETE #define DUMMY_SAVE_SR160 3 */
/* OBSOLETE /* Number of general (gr96- or gr64-) registers to save.  */ */
/* OBSOLETE #define DUMMY_SAVE_GREGS 29 */
/* OBSOLETE  */
/* OBSOLETE #define DUMMY_FRAME_RSIZE \ */
/* OBSOLETE (4 /* mfp_dummy */     	  \ */
/* OBSOLETE  + 4 * 4  /* pc0, pc1, pc2, lr0 */  \ */
/* OBSOLETE  + DUMMY_SAVE_GREGS * 4   \ */
/* OBSOLETE  + DUMMY_SAVE_SR160 * 4	  \ */
/* OBSOLETE  + DUMMY_SAVE_SR128 * 4	  \ */
/* OBSOLETE  + DUMMY_ARG		  \ */
/* OBSOLETE  + 4 /* pad to doubleword */ ) */
/* OBSOLETE  */
/* OBSOLETE /* Push an empty stack frame, to record the current PC, etc.  */ */
/* OBSOLETE  */
/* OBSOLETE #define PUSH_DUMMY_FRAME push_dummy_frame() */
/* OBSOLETE extern void push_dummy_frame (); */
/* OBSOLETE  */
/* OBSOLETE /* Discard from the stack the innermost frame, */
/* OBSOLETE    restoring all saved registers.  */ */
/* OBSOLETE  */
/* OBSOLETE #define POP_FRAME pop_frame() */
/* OBSOLETE extern void pop_frame (); */
/* OBSOLETE  */
/* OBSOLETE /* This sequence of words is the instructions */
/* OBSOLETE    mtsrim cr, 15 */
/* OBSOLETE    loadm 0, 0, lr2, msp     ; load first 16 words of arguments into registers */
/* OBSOLETE    add msp, msp, 16 * 4     ; point to the remaining arguments */
/* OBSOLETE    CONST_INSN: */
/* OBSOLETE    const lr0,inf                ; (replaced by       half of target addr) */
/* OBSOLETE    consth lr0,inf               ; (replaced by other half of target addr) */
/* OBSOLETE    calli lr0, lr0  */
/* OBSOLETE    aseq 0x40,gr1,gr1   ; nop */
/* OBSOLETE    BREAKPT_INSN: */
/* OBSOLETE    asneq 0x50,gr1,gr1  ; breakpoint     (replaced by local breakpoint insn) */
/* OBSOLETE  */ */
/* OBSOLETE  */
/* OBSOLETE #error "This file is broken.  GDB does not define HOST_BYTE_ORDER." */
/* OBSOLETE #if TARGET_BYTE_ORDER == HOST_BYTE_ORDER */
/* OBSOLETE #define BS(const)	const */
/* OBSOLETE #else */
/* OBSOLETE #define	BS(const)	(((const) & 0xff) << 24) |	\ */
/* OBSOLETE 			(((const) & 0xff00) << 8) |	\ */
/* OBSOLETE 			(((const) & 0xff0000) >> 8) |	\ */
/* OBSOLETE 			(((const) & 0xff000000) >> 24) */
/* OBSOLETE #endif */
/* OBSOLETE  */
/* OBSOLETE /* Position of the "const" and blkt instructions within CALL_DUMMY in bytes. */ */
/* OBSOLETE #define CONST_INSN (3 * 4) */
/* OBSOLETE #define BREAKPT_INSN (7 * 4) */
/* OBSOLETE #define CALL_DUMMY {	\ */
/* OBSOLETE 		BS(0x0400870f),\ */
/* OBSOLETE 		BS(0x36008200|(MSP_HW_REGNUM)), \ */
/* OBSOLETE 		BS(0x15000040|(MSP_HW_REGNUM<<8)|(MSP_HW_REGNUM<<16)), \ */
/* OBSOLETE 		BS(0x03ff80ff),	\ */
/* OBSOLETE 		BS(0x02ff80ff),	\ */
/* OBSOLETE 		BS(0xc8008080),	\ */
/* OBSOLETE 		BS(0x70400101),	\ */
/* OBSOLETE 		BS(0x72500101)} */
/* OBSOLETE #define CALL_DUMMY_LENGTH (8 * 4) */
/* OBSOLETE  */
/* OBSOLETE #define CALL_DUMMY_START_OFFSET 0	/* Start execution at beginning of dummy */ */
/* OBSOLETE  */
/* OBSOLETE /* Helper macro for FIX_CALL_DUMMY.  WORDP is a long * which points to a */
/* OBSOLETE    word in target byte order; bits 0-7 and 16-23 of *WORDP are replaced with */
/* OBSOLETE    bits 0-7 and 8-15 of DATA (which is in host byte order).  */ */
/* OBSOLETE  */
/* OBSOLETE #if TARGET_BYTE_ORDER == BFD_ENDIAN_BIG */
/* OBSOLETE #define STUFF_I16(WORDP, DATA) \ */
/* OBSOLETE   { \ */
/* OBSOLETE     *((char *)(WORDP) + 3) = ((DATA) & 0xff);\ */
/* OBSOLETE     *((char *)(WORDP) + 1) = (((DATA) >> 8) & 0xff);\ */
/* OBSOLETE   } */
/* OBSOLETE #else /* Target is little endian.  */ */
/* OBSOLETE #define STUFF_I16(WORDP, DATA) \ */
/* OBSOLETE   { */
/* OBSOLETE *(char *) (WORDP) = ((DATA) & 0xff); */
/* OBSOLETE *((char *) (WORDP) + 2) = (((DATA) >> 8) & 0xff); */
/* OBSOLETE } */
/* OBSOLETE #endif /* Target is little endian.  */ */
/* OBSOLETE  */
/* OBSOLETE /* Insert the specified number of args and function address */
/* OBSOLETE    into a call sequence of the above form stored at DUMMYNAME.  */ */
/* OBSOLETE  */
/* OBSOLETE /* Currently this stuffs in the address of the function that we are calling. */
/* OBSOLETE    Since different a29k systems use different breakpoint instructions, it */
/* OBSOLETE    also stuffs BREAKPOINT in the right place (to avoid having to */
/* OBSOLETE    duplicate CALL_DUMMY in each tm-*.h file).  */ */
/* OBSOLETE  */
/* OBSOLETE #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p)   \ */
/* OBSOLETE   {\ */
/* OBSOLETE     STUFF_I16((char *)dummyname + CONST_INSN, fun);		\ */
/* OBSOLETE     STUFF_I16((char *)dummyname + CONST_INSN + 4, fun >> 16);	\ */
/* OBSOLETE   /* FIXME  memcpy ((char *)(dummyname) + BREAKPT_INSN, break_insn, 4); */ \ */
/* OBSOLETE   } */
/* OBSOLETE  */
/* OBSOLETE /* a29k architecture has separate data & instruction memories -- wired to */
/* OBSOLETE    different pins on the chip -- and can't execute the data memory. */
/* OBSOLETE    Also, there should be space after text_end; */
/* OBSOLETE    we won't get a SIGSEGV or scribble on data space.  */ */
/* OBSOLETE  */
/* OBSOLETE #define CALL_DUMMY_LOCATION AFTER_TEXT_END */
/* OBSOLETE  */
/* OBSOLETE /* Because of this, we need (as a kludge) to know the addresses of the */
/* OBSOLETE    text section.  */ */
/* OBSOLETE  */
/* OBSOLETE #define	NEED_TEXT_START_END 1 */
/* OBSOLETE  */
/* OBSOLETE /* How to translate register numbers in the .stab's into gdb's internal register */
/* OBSOLETE    numbers.  We don't translate them, but we warn if an invalid register */
/* OBSOLETE    number is seen.  Note that FIXME, we use the value "sym" as an implicit */
/* OBSOLETE    argument in printing the error message.  It happens to be available where */
/* OBSOLETE    this macro is used.  (This macro definition appeared in a late revision */
/* OBSOLETE    of gdb-3.91.6 and is not well tested.  Also, it should be a "complaint".) */ */
/* OBSOLETE  */
/* OBSOLETE #define	STAB_REG_TO_REGNUM(num) \ */
/* OBSOLETE 	(((num) > LR0_REGNUM + 127) \ */
/* OBSOLETE 	   ? fprintf(stderr, 	\ */
/* OBSOLETE 		"Invalid register number %d in symbol table entry for %s\n", \ */
/* OBSOLETE 	         (num), SYMBOL_SOURCE_NAME (sym)), (num)	\ */
/* OBSOLETE 	   : (num)) */
/* OBSOLETE  */
/* OBSOLETE extern enum a29k_processor_types */
/* OBSOLETE { */
/* OBSOLETE   a29k_unknown, */
/* OBSOLETE  */
/* OBSOLETE   /* Bit 0x400 of the CPS does *not* identify freeze mode, i.e. 29000, */
/* OBSOLETE      29030, etc.  */ */
/* OBSOLETE   a29k_no_freeze_mode, */
/* OBSOLETE  */
/* OBSOLETE   /* Bit 0x400 of the CPS does identify freeze mode, i.e. 29050.  */ */
/* OBSOLETE   a29k_freeze_mode */
/* OBSOLETE } */
/* OBSOLETE processor_type; */
/* OBSOLETE  */
/* OBSOLETE /* We need three arguments for a general frame specification for the */
/* OBSOLETE    "frame" or "info frame" command.  */ */
/* OBSOLETE  */
/* OBSOLETE #define SETUP_ARBITRARY_FRAME(argc, argv) setup_arbitrary_frame (argc, argv) */
/* OBSOLETE extern struct frame_info *setup_arbitrary_frame (int, CORE_ADDR *); */