home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / GDB / GDB-4.13 / GDB-4 / gdb-4.13 / gdb / config / m88k / tm-m88k.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-17  |  20.3 KB  |  626 lines
  1. /* Target machine description for generic Motorola 88000, for GDB.
  2.    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1993
  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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /* g++ support is not yet included.  */
  22.  
  23. /* Define the bit, byte, and word ordering of the machine.  */
  24. #define TARGET_BYTE_ORDER BIG_ENDIAN
  25.  
  26. /* We cache information about saved registers in the frame structure,
  27.    to save us from having to re-scan function prologues every time
  28.    a register in a non-current frame is accessed.  */
  29.  
  30. #define EXTRA_FRAME_INFO     \
  31.     struct frame_saved_regs *fsr;    \
  32.     CORE_ADDR locals_pointer;    \
  33.     CORE_ADDR args_pointer;
  34.  
  35. /* Zero the frame_saved_regs pointer when the frame is initialized,
  36.    so that FRAME_FIND_SAVED_REGS () will know to allocate and
  37.    initialize a frame_saved_regs struct the first time it is called.
  38.    Set the arg_pointer to -1, which is not valid; 0 and other values
  39.    indicate real, cached values.  */
  40.  
  41. #define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
  42.     init_extra_frame_info (fromleaf, fi)
  43. extern void init_extra_frame_info ();
  44.  
  45. #define IEEE_FLOAT
  46.  
  47. /* Offset from address of function to start of its code.
  48.    Zero on most machines.  */
  49.  
  50. #define FUNCTION_START_OFFSET 0
  51.  
  52. /* Advance PC across any function entry prologue instructions
  53.    to reach some "real" code.  */
  54.  
  55. #define SKIP_PROLOGUE(frompc)   \
  56.     { (frompc) = skip_prologue (frompc); }
  57. extern CORE_ADDR skip_prologue ();
  58.  
  59. /* The m88k kernel aligns all instructions on 4-byte boundaries.  The
  60.    kernel also uses the least significant two bits for its own hocus
  61.    pocus.  When gdb receives an address from the kernel, it needs to
  62.    preserve those right-most two bits, but gdb also needs to be careful
  63.    to realize that those two bits are not really a part of the address
  64.    of an instruction.  Shrug.  */
  65.  
  66. #define ADDR_BITS_REMOVE(addr) ((addr) & ~3)
  67.  
  68. /* Immediately after a function call, return the saved pc.
  69.    Can't always go through the frames for this because on some machines
  70.    the new frame is not set up until the new function executes
  71.    some instructions.  */
  72.  
  73. #define SAVED_PC_AFTER_CALL(frame) \
  74.   (ADDR_BITS_REMOVE (read_register (SRP_REGNUM)))
  75.  
  76. /* Stack grows downward.  */
  77.  
  78. #define INNER_THAN <
  79.  
  80. /* Sequence of bytes for breakpoint instruction.  */
  81.  
  82. /* instruction 0xF000D1FF is 'tb0 0,r0,511'
  83.    If Bit bit 0 of r0 is clear (always true),
  84.    initiate exception processing (trap).
  85.  */
  86. #define BREAKPOINT {0xF0, 0x00, 0xD1, 0xFF}
  87.  
  88. /* Amount PC must be decremented by after a breakpoint.
  89.    This is often the number of bytes in BREAKPOINT
  90.    but not always.  */
  91.  
  92. #define DECR_PC_AFTER_BREAK 0
  93.  
  94. /* Nonzero if instruction at PC is a return instruction.  */
  95. /* 'jmp r1' or 'jmp.n r1' is used to return from a subroutine. */
  96.  
  97. #define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0xF800)
  98.  
  99. /* This is taken care of in print_floating [IEEE_FLOAT].  */
  100.  
  101. #define INVALID_FLOAT(p,len) 0
  102.  
  103. /* Say how long (ordinary) registers are.  This is a piece of bogosity
  104.    used in push_word and a few other places; REGISTER_RAW_SIZE is the
  105.    real way to know how big a register is.  */
  106.  
  107. #define REGISTER_SIZE 4
  108.  
  109. /* Number of machine registers */
  110.  
  111. #define GP_REGS (38)
  112. #define FP_REGS (32)
  113. #define NUM_REGS (GP_REGS + FP_REGS)
  114.  
  115. /* Initializer for an array of names of registers.
  116.    There should be NUM_REGS strings in this initializer.  */
  117.  
  118. #define REGISTER_NAMES {\
  119.               "r0",\
  120.               "r1",\
  121.               "r2",\
  122.               "r3",\
  123.               "r4",\
  124.               "r5",\
  125.               "r6",\
  126.               "r7",\
  127.               "r8",\
  128.               "r9",\
  129.               "r10",\
  130.               "r11",\
  131.               "r12",\
  132.               "r13",\
  133.               "r14",\
  134.               "r15",\
  135.               "r16",\
  136.               "r17",\
  137.               "r18",\
  138.               "r19",\
  139.               "r20",\
  140.               "r21",\
  141.               "r22",\
  142.               "r23",\
  143.               "r24",\
  144.               "r25",\
  145.               "r26",\
  146.               "r27",\
  147.               "r28",\
  148.               "r29",\
  149.               "r30",\
  150.               "r31",\
  151.               "psr",\
  152.               "fpsr",\
  153.               "fpcr",\
  154.               "sxip",\
  155.               "snip",\
  156.               "sfip",\
  157.               "x0",\
  158.               "x1",\
  159.               "x2",\
  160.               "x3",\
  161.               "x4",\
  162.               "x5",\
  163.               "x6",\
  164.               "x7",\
  165.               "x8",\
  166.               "x9",\
  167.               "x10",\
  168.               "x11",\
  169.               "x12",\
  170.               "x13",\
  171.               "x14",\
  172.               "x15",\
  173.               "x16",\
  174.               "x17",\
  175.               "x18",\
  176.               "x19",\
  177.               "x20",\
  178.               "x21",\
  179.               "x22",\
  180.               "x23",\
  181.               "x24",\
  182.               "x25",\
  183.               "x26",\
  184.               "x27",\
  185.               "x28",\
  186.               "x29",\
  187.               "x30",\
  188.               "x31",\
  189.               "vbr",\
  190.               "dmt0",\
  191.               "dmd0",\
  192.               "dma0",\
  193.               "dmt1",\
  194.               "dmd1",\
  195.               "dma1",\
  196.               "dmt2",\
  197.               "dmd2",\
  198.               "dma2",\
  199.               "sr0",\
  200.               "sr1",\
  201.               "sr2",\
  202.               "sr3",\
  203.               "fpecr",\
  204.               "fphs1",\
  205.               "fpls1",\
  206.               "fphs2",\
  207.               "fpls2",\
  208.               "fppt",\
  209.               "fprh",\
  210.               "fprl",\
  211.               "fpit",\
  212.               "fpsr",\
  213.               "fpcr",\
  214.               }
  215.  
  216.  
  217. /* Register numbers of various important registers.
  218.    Note that some of these values are "real" register numbers,
  219.    and correspond to the general registers of the machine,
  220.    and some are "phony" register numbers which are too large
  221.    to be actual register numbers as far as the user is concerned
  222.    but do serve to get the desired values when passed to read_register.  */
  223.  
  224. #define R0_REGNUM 0        /* Contains the constant zero */
  225. #define SRP_REGNUM 1        /* Contains subroutine return pointer */
  226. #define RV_REGNUM 2        /* Contains simple return values */
  227. #define SRA_REGNUM 12        /* Contains address of struct return values */
  228. #define SP_REGNUM 31        /* Contains address of top of stack */
  229.  
  230. /* Instruction pointer notes...
  231.  
  232.    On the m88100:
  233.  
  234.    * cr04 = sxip.  On exception, contains the excepting pc (probably).
  235.    On rte, is ignored.
  236.  
  237.    * cr05 = snip.  On exception, contains the NPC (next pc).  On rte,
  238.    pc is loaded from here.
  239.  
  240.    * cr06 = sfip.  On exception, contains the NNPC (next next pc).  On
  241.    rte, the NPC is loaded from here.
  242.  
  243.    * lower two bits of each are flag bits.  Bit 1 is V means address
  244.    is valid.  If address is not valid, bit 0 is ignored.  Otherwise,
  245.    bit 0 is E and asks for an exception to be taken if this
  246.    instruction is executed.
  247.  
  248.    On the m88110:
  249.  
  250.    * cr04 = exip.  On exception, contains the address of the excepting
  251.    pc (always).  On rte, pc is loaded from here.  Bit 0, aka the D
  252.    bit, is a flag saying that the offending instruction was in a
  253.    branch delay slot.  If set, then cr05 contains the NPC.
  254.  
  255.    * cr05 = enip.  On exception, if the instruction pointed to by cr04
  256.    was in a delay slot as indicated by the bit 0 of cr04, aka the D
  257.    bit, the cr05 contains the NPC.  Otherwise ignored.
  258.  
  259.    * cr06 is invalid  */
  260.  
  261. /* Note that the Harris Unix kernels emulate the m88100's behavior on
  262.    the m88110.  */
  263.  
  264. #define SXIP_REGNUM 35        /* On m88100, Contains Shadow Execute
  265.                    Instruction Pointer.  */
  266. #define SNIP_REGNUM 36        /* On m88100, Contains Shadow Next
  267.                    Instruction Pointer.  */
  268. #define SFIP_REGNUM 37        /* On m88100, Contains Shadow Fetched
  269.                    Intruction pointer.  */
  270.  
  271. #define EXIP_REGNUM 35        /* On m88110, Contains Exception
  272.                    Executing Instruction Pointer.  */
  273. #define ENIP_REGNUM 36        /* On m88110, Contains the Exception
  274.                    Next Instruction Pointer.  */
  275.  
  276. #define PC_REGNUM SXIP_REGNUM    /* Program Counter */
  277. #define NPC_REGNUM SNIP_REGNUM    /* Next Program Counter */
  278. #define NNPC_REGNUM SFIP_REGNUM /* Next Next Program Counter */
  279.  
  280. #define PSR_REGNUM 32           /* Processor Status Register */
  281. #define FPSR_REGNUM 33        /* Floating Point Status Register */
  282. #define FPCR_REGNUM 34        /* Floating Point Control Register */
  283. #define XFP_REGNUM 38        /* First Extended Float Register */
  284. #define X0_REGNUM XFP_REGNUM    /* Which also contains the constant zero */
  285.  
  286. /* This is rather a confusing lie.  Our m88k port using a stack pointer value
  287.    for the frame address.  Hence, the frame address and the frame pointer are
  288.    only indirectly related.  The value of this macro is the register number
  289.    fetched by the machine "independent" portions of gdb when they want to know
  290.    about a frame address.  Thus, we lie here and claim that FP_REGNUM is
  291.    SP_REGNUM.  */
  292. #define FP_REGNUM SP_REGNUM    /* Reg fetched to locate frame when pgm stops */
  293. #define ACTUAL_FP_REGNUM 30
  294.  
  295. /* PSR status bit definitions.  */
  296.  
  297. #define PSR_MODE        0x80000000
  298. #define PSR_BYTE_ORDER        0x40000000
  299. #define PSR_SERIAL_MODE        0x20000000
  300. #define PSR_CARRY        0x10000000
  301. #define PSR_SFU_DISABLE        0x000003f0
  302. #define PSR_SFU1_DISABLE    0x00000008
  303. #define PSR_MXM            0x00000004
  304. #define PSR_IND            0x00000002
  305. #define PSR_SFRZ        0x00000001
  306.  
  307.  
  308.  
  309. /* The following two comments come from the days prior to the m88110
  310.    port.  The m88110 handles the instruction pointers differently.  I
  311.    do not know what any m88110 kernels do as the m88110 port I'm
  312.    working with is for an embedded system.  rich@cygnus.com
  313.    13-sept-93.  */
  314.  
  315. /* BCS requires that the SXIP_REGNUM (or PC_REGNUM) contain the
  316.    address of the next instr to be executed when a breakpoint occurs.
  317.    Because the kernel gets the next instr (SNIP_REGNUM), the instr in
  318.    SNIP needs to be put back into SFIP, and the instr in SXIP should
  319.    be shifted to SNIP */
  320.  
  321. /* Are you sitting down?  It turns out that the 88K BCS (binary
  322.    compatibility standard) folks originally felt that the debugger
  323.    should be responsible for backing up the IPs, not the kernel (as is
  324.    usually done).  Well, they have reversed their decision, and in
  325.    future releases our kernel will be handling the backing up of the
  326.    IPs.  So, eventually, we won't need to do the SHIFT_INST_REGS
  327.    stuff.  But, for now, since there are 88K systems out there that do
  328.    need the debugger to do the IP shifting, and since there will be
  329.    systems where the kernel does the shifting, the code is a little
  330.    more complex than perhaps it needs to be (we still go inside
  331.    SHIFT_INST_REGS, and if the shifting hasn't occurred then gdb goes
  332.    ahead and shifts).  */
  333.  
  334. extern int target_is_m88110;
  335. #define SHIFT_INST_REGS() \
  336. if (!target_is_m88110) \
  337. { \
  338.     CORE_ADDR pc = read_register (PC_REGNUM); \
  339.     CORE_ADDR npc = read_register (NPC_REGNUM); \
  340.     if (pc != npc) \
  341.     { \
  342.     write_register (NNPC_REGNUM, npc); \
  343.     write_register (NPC_REGNUM, pc); \
  344.     } \
  345. }
  346.  
  347.     /* Storing the following registers is a no-op. */
  348. #define CANNOT_STORE_REGISTER(regno)    (((regno) == R0_REGNUM) \
  349.                      || ((regno) == X0_REGNUM))
  350.  
  351.   /* Number of bytes of storage in the actual machine representation
  352.      for register N.  On the m88k,  the general purpose registers are 4
  353.      bytes and the 88110 extended registers are 10 bytes. */
  354.  
  355. #define REGISTER_RAW_SIZE(N) ((N) < XFP_REGNUM ? 4 : 10)
  356.  
  357.   /* Total amount of space needed to store our copies of the machine's
  358.      register state, the array `registers'.  */
  359.  
  360. #define REGISTER_BYTES ((GP_REGS * REGISTER_RAW_SIZE(0)) \
  361.             + (FP_REGS * REGISTER_RAW_SIZE(XFP_REGNUM)))
  362.  
  363.   /* Index within `registers' of the first byte of the space for
  364.      register N.  */
  365.  
  366. #define REGISTER_BYTE(N) (((N) * REGISTER_RAW_SIZE(0)) \
  367.               + ((N) >= XFP_REGNUM \
  368.                  ? (((N) - XFP_REGNUM) \
  369.                 * REGISTER_RAW_SIZE(XFP_REGNUM)) \
  370.                  : 0))
  371.  
  372.   /* Number of bytes of storage in the program's representation for
  373.      register N.  On the m88k, all registers are 4 bytes excepting the
  374.      m88110 extended registers which are 8 byte doubles. */
  375.  
  376. #define REGISTER_VIRTUAL_SIZE(N) ((N) < XFP_REGNUM ? 4 : 8)
  377.  
  378.   /* Largest value REGISTER_RAW_SIZE can have.  */
  379.  
  380. #define MAX_REGISTER_RAW_SIZE (REGISTER_RAW_SIZE(XFP_REGNUM))
  381.  
  382.   /* Largest value REGISTER_VIRTUAL_SIZE can have.
  383.      Are FPS1, FPS2, FPR "virtual" regisers? */
  384.  
  385. #define MAX_REGISTER_VIRTUAL_SIZE (REGISTER_RAW_SIZE(XFP_REGNUM))
  386.  
  387.   /* Nonzero if register N requires conversion
  388.      from raw format to virtual format.  */
  389.  
  390. #define REGISTER_CONVERTIBLE(N) ((N) >= XFP_REGNUM)
  391.  
  392. #include "floatformat.h"
  393.  
  394. /* Convert data from raw format for register REGNUM in buffer FROM
  395.    to virtual format with type TYPE in buffer TO.  */
  396.  
  397. #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \
  398. { \
  399.   double val; \
  400.   floatformat_to_double (&floatformat_m88110_ext, (FROM), &val); \
  401.   store_floating ((TO), TYPE_LENGTH (TYPE), val); \
  402. }
  403.  
  404. /* Convert data from virtual format with type TYPE in buffer FROM
  405.    to raw format for register REGNUM in buffer TO.  */
  406.  
  407. #define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO)    \
  408. { \
  409.   double val = extract_floating ((FROM), TYPE_LENGTH (TYPE)); \
  410.   floatformat_from_double (&floatformat_m88110_ext, &val, (TO)); \
  411. }
  412.  
  413. /* Return the GDB type object for the "standard" data type
  414.    of data in register N.  */
  415.  
  416. #define REGISTER_VIRTUAL_TYPE(N) \
  417. ((N) >= XFP_REGNUM \
  418.  ? builtin_type_double \
  419.  : ((N) == PC_REGNUM || (N) == FP_REGNUM || (N) == SP_REGNUM \
  420.     ? lookup_pointer_type (builtin_type_void) : builtin_type_int))
  421.  
  422. /* The 88k call/return conventions call for "small" values to be returned
  423.    into consecutive registers starting from r2.  */
  424.  
  425. #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
  426.   memcpy ((VALBUF), &(((char *)REGBUF)[REGISTER_BYTE(RV_REGNUM)]), TYPE_LENGTH (TYPE))
  427.  
  428. #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
  429.  
  430. /* Write into appropriate registers a function return value
  431.    of type TYPE, given in virtual format.  */
  432.  
  433. #define STORE_RETURN_VALUE(TYPE,VALBUF) \
  434.   write_register_bytes (2*REGISTER_RAW_SIZE(0), (VALBUF), TYPE_LENGTH (TYPE))
  435.  
  436. /* In COFF, if PCC says a parameter is a short or a char, do not
  437.    change it to int (it seems the convention is to change it). */
  438.  
  439. #define BELIEVE_PCC_PROMOTION 1
  440.  
  441. /* Describe the pointer in each stack frame to the previous stack frame
  442.    (its caller).  */
  443.  
  444. /* FRAME_CHAIN takes a frame's nominal address
  445.    and produces the frame's chain-pointer.
  446.  
  447.    However, if FRAME_CHAIN_VALID returns zero,
  448.    it means the given frame is the outermost one and has no caller.  */
  449.  
  450. extern CORE_ADDR frame_chain ();
  451. extern int frame_chain_valid ();
  452. extern int frameless_function_invocation ();
  453.  
  454. #define FRAME_CHAIN(thisframe) \
  455.     frame_chain (thisframe)
  456.  
  457. #define    FRAMELESS_FUNCTION_INVOCATION(frame, fromleaf)    \
  458.     fromleaf = frameless_function_invocation (frame)
  459.  
  460. /* Define other aspects of the stack frame.  */
  461.  
  462. #define FRAME_SAVED_PC(FRAME)    \
  463.     frame_saved_pc (FRAME)
  464. extern CORE_ADDR frame_saved_pc ();
  465.  
  466. #define FRAME_ARGS_ADDRESS(fi)    \
  467.     frame_args_address (fi)
  468. extern CORE_ADDR frame_args_address ();
  469.  
  470. #define FRAME_LOCALS_ADDRESS(fi) \
  471.     frame_locals_address (fi)
  472. extern CORE_ADDR frame_locals_address ();
  473.  
  474. /* Return number of args passed to a frame.
  475.    Can return -1, meaning no way to tell.  */
  476.  
  477. #define FRAME_NUM_ARGS(numargs, fi)  ((numargs) = -1)
  478.  
  479. /* Return number of bytes at start of arglist that are not really args.  */
  480.  
  481. #define FRAME_ARGS_SKIP 0
  482.  
  483. /* Put here the code to store, into a struct frame_saved_regs,
  484.    the addresses of the saved registers of frame described by FRAME_INFO.
  485.    This includes special registers such as pc and fp saved in special
  486.    ways in the stack frame.  sp is even more special:
  487.    the address we return for it IS the sp for the next frame.  */
  488.  
  489. /* On the 88k, parameter registers get stored into the so called "homing"
  490.    area.  This *always* happens when you compiled with GCC and use -g.
  491.    Also, (with GCC and -g) the saving of the parameter register values
  492.    always happens right within the function prologue code, so these register
  493.    values can generally be relied upon to be already copied into their
  494.    respective homing slots by the time you will normally try to look at
  495.    them (we hope).
  496.  
  497.    Note that homing area stack slots are always at *positive* offsets from
  498.    the frame pointer.  Thus, the homing area stack slots for the parameter
  499.    registers (passed values) for a given function are actually part of the
  500.    frame area of the caller.  This is unusual, but it should not present
  501.    any special problems for GDB.
  502.  
  503.    Note also that on the 88k, we are only interested in finding the
  504.    registers that might have been saved in memory.  This is a subset of
  505.    the whole set of registers because the standard calling sequence allows
  506.    the called routine to clobber many registers.
  507.  
  508.    We could manage to locate values for all of the so called "preserved"
  509.    registers (some of which may get saved within any particular frame) but
  510.    that would require decoding all of the tdesc information.  That would be
  511.    nice information for GDB to have, but it is not strictly manditory if we
  512.    can live without the ability to look at values within (or backup to)
  513.    previous frames.
  514. */
  515.  
  516. struct frame_saved_regs;
  517. struct frame_info;
  518.  
  519. void frame_find_saved_regs PARAMS((struct frame_info *fi,
  520.                    struct frame_saved_regs *fsr));
  521.  
  522. #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
  523.         frame_find_saved_regs (frame_info, &frame_saved_regs)
  524.  
  525.  
  526. #define POP_FRAME pop_frame ()
  527. extern void pop_frame ();
  528.  
  529. /* Call function stuff contributed by Kevin Buettner of Motorola.  */
  530.  
  531. #define CALL_DUMMY_LOCATION AFTER_TEXT_END
  532.  
  533. extern void m88k_push_dummy_frame();
  534. #define PUSH_DUMMY_FRAME    m88k_push_dummy_frame()
  535.  
  536. #define CALL_DUMMY {                 \
  537. 0x67ff00c0,    /*   0:   subu    #sp,#sp,0xc0 */ \
  538. 0x243f0004,    /*   4:   st    #r1,#sp,0x4 */ \
  539. 0x245f0008,    /*   8:   st    #r2,#sp,0x8 */ \
  540. 0x247f000c,    /*   c:   st    #r3,#sp,0xc */ \
  541. 0x249f0010,    /*  10:   st    #r4,#sp,0x10 */ \
  542. 0x24bf0014,    /*  14:   st    #r5,#sp,0x14 */ \
  543. 0x24df0018,    /*  18:   st    #r6,#sp,0x18 */ \
  544. 0x24ff001c,    /*  1c:   st    #r7,#sp,0x1c */ \
  545. 0x251f0020,    /*  20:   st    #r8,#sp,0x20 */ \
  546. 0x253f0024,    /*  24:   st    #r9,#sp,0x24 */ \
  547. 0x255f0028,    /*  28:   st    #r10,#sp,0x28 */ \
  548. 0x257f002c,    /*  2c:   st    #r11,#sp,0x2c */ \
  549. 0x259f0030,    /*  30:   st    #r12,#sp,0x30 */ \
  550. 0x25bf0034,    /*  34:   st    #r13,#sp,0x34 */ \
  551. 0x25df0038,    /*  38:   st    #r14,#sp,0x38 */ \
  552. 0x25ff003c,    /*  3c:   st    #r15,#sp,0x3c */ \
  553. 0x261f0040,    /*  40:   st    #r16,#sp,0x40 */ \
  554. 0x263f0044,    /*  44:   st    #r17,#sp,0x44 */ \
  555. 0x265f0048,    /*  48:   st    #r18,#sp,0x48 */ \
  556. 0x267f004c,    /*  4c:   st    #r19,#sp,0x4c */ \
  557. 0x269f0050,    /*  50:   st    #r20,#sp,0x50 */ \
  558. 0x26bf0054,    /*  54:   st    #r21,#sp,0x54 */ \
  559. 0x26df0058,    /*  58:   st    #r22,#sp,0x58 */ \
  560. 0x26ff005c,    /*  5c:   st    #r23,#sp,0x5c */ \
  561. 0x271f0060,    /*  60:   st    #r24,#sp,0x60 */ \
  562. 0x273f0064,    /*  64:   st    #r25,#sp,0x64 */ \
  563. 0x275f0068,    /*  68:   st    #r26,#sp,0x68 */ \
  564. 0x277f006c,    /*  6c:   st    #r27,#sp,0x6c */ \
  565. 0x279f0070,    /*  70:   st    #r28,#sp,0x70 */ \
  566. 0x27bf0074,    /*  74:   st    #r29,#sp,0x74 */ \
  567. 0x27df0078,    /*  78:   st    #r30,#sp,0x78 */ \
  568. 0x63df0000,    /*  7c:   addu    #r30,#sp,0x0 */ \
  569. 0x145f0000,    /*  80:   ld    #r2,#sp,0x0 */ \
  570. 0x147f0004,    /*  84:   ld    #r3,#sp,0x4 */ \
  571. 0x149f0008,    /*  88:   ld    #r4,#sp,0x8 */ \
  572. 0x14bf000c,    /*  8c:   ld    #r5,#sp,0xc */ \
  573. 0x14df0010,    /*  90:   ld    #r6,#sp,0x10 */ \
  574. 0x14ff0014,    /*  94:   ld    #r7,#sp,0x14 */ \
  575. 0x151f0018,    /*  98:   ld    #r8,#sp,0x18 */ \
  576. 0x153f001c,    /*  9c:   ld    #r9,#sp,0x1c */ \
  577. 0x5c200000,    /*  a0:   or.u    #r1,#r0,0x0 */ \
  578. 0x58210000,    /*  a4:   or    #r1,#r1,0x0 */ \
  579. 0xf400c801,    /*  a8:   jsr    #r1 */ \
  580. 0xf000d1ff    /*  ac:   tb0    0x0,#r0,0x1ff */ \
  581. }
  582.  
  583. #define CALL_DUMMY_START_OFFSET 0x80
  584. #define CALL_DUMMY_LENGTH 0xb0
  585.  
  586. /* FIXME: byteswapping.  */
  587. #define FIX_CALL_DUMMY(dummy, pc, fun, nargs, args, type, gcc_p)    \
  588. {                                     \
  589.   *(unsigned long *)((char *) (dummy) + 0xa0) |=            \
  590.     (((unsigned long) (fun)) >> 16);                \
  591.   *(unsigned long *)((char *) (dummy) + 0xa4) |=            \
  592.     (((unsigned long) (fun)) & 0xffff);                \
  593.   pc = text_end;                            \
  594. }
  595.  
  596. #define STACK_ALIGN(addr) (((addr)+7) & -8)
  597.  
  598. #define STORE_STRUCT_RETURN(addr, sp) \
  599.     write_register (SRA_REGNUM, (addr))
  600.  
  601. #define NEED_TEXT_START_END 1
  602.  
  603. /* According to the MC88100 RISC Microprocessor User's Manual, section
  604.    6.4.3.1.2:
  605.  
  606.        ... can be made to return to a particular instruction by placing a
  607.     valid instruction address in the SNIP and the next sequential
  608.     instruction address in the SFIP (with V bits set and E bits clear).
  609.     The rte resumes execution at the instruction pointed to by the 
  610.     SNIP, then the SFIP.
  611.  
  612.    The E bit is the least significant bit (bit 0).  The V (valid) bit is
  613.    bit 1.  This is why we logical or 2 into the values we are writing
  614.    below.  It turns out that SXIP plays no role when returning from an
  615.    exception so nothing special has to be done with it.  We could even
  616.    (presumably) give it a totally bogus value.
  617.  
  618.    -- Kevin Buettner
  619. */
  620.  
  621. #define TARGET_WRITE_PC(val, pid) { \
  622.   write_register_pid(SXIP_REGNUM, (long) val, pid); \
  623.   write_register_pid(SNIP_REGNUM, (long) val | 2, pid); \
  624.   write_register_pid(SFIP_REGNUM, ((long) val | 2) + 4, pid); \
  625. }
  626.