tm-hppa.h

早期freebsd实现

  (inside_entry_file ((thisframe)->pc) ? \
   read_memory_integer ((thisframe)->frame, 4) :\
   0)

#define FRAME_CHAIN_VALID(chain, thisframe) \
  frame_chain_valid (chain, thisframe)

#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)

/* Define other aspects of the stack frame.  */

/* A macro that tells us whether the function invocation represented
   by FI does not have a frame on the stack associated with it.  If it
   does not, FRAMELESS is set to 1, else 0.  */
#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
  (FRAMELESS) = frameless_look_for_prologue(FI)

#define FRAME_SAVED_PC(FRAME) frame_saved_pc (FRAME)

#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)

#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
/* Set VAL to the number of args passed to frame described by FI.
   Can set VAL to -1, meaning no way to tell.  */

/* We can't tell how many args there are
   now that the C compiler delays popping them.  */
#define FRAME_NUM_ARGS(val,fi) (val = -1)

/* Return number of bytes at start of arglist that are not really args.  */

#define FRAME_ARGS_SKIP 0

/* Put here the code to store, into a struct frame_saved_regs,
   the addresses of the saved registers of frame described by FRAME_INFO.
   This includes special registers such as pc and fp saved in special
   ways in the stack frame.  sp is even more special:
   the address we return for it IS the sp for the next frame.  */

/* Deal with dummy functions later. */

#define STW_P(INSN) (((INSN) & 0xfc000000) == 0x68000000)
#define ADDIL_P(INSN) (((INSN) & 0xfc000000) == 0x28000000)
#define LDO_P(INSN) (((INSN) & 0xfc00c000) == 0x34000000)


#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs)		\
{ register int regnum;							\
  register CORE_ADDR next_addr;						\
  register CORE_ADDR pc;						\
  unsigned this_insn;							\
  unsigned address;							\
									\
  bzero (&frame_saved_regs, sizeof frame_saved_regs);			\
  if ((frame_info)->pc <= ((frame_info)->frame - CALL_DUMMY_LENGTH -	\
			   FP_REGNUM * 4 - 16 * 8)			\
      && (frame_info)->pc > (frame_info)->frame)			\
    find_dummy_frame_regs ((frame_info), &(frame_saved_regs));		\
  else									\
    { pc = get_pc_function_start ((frame_info)->pc);			\
      if (read_memory_integer (pc, 4) == 0x6BC23FD9)			\
	{ (frame_saved_regs).regs[RP_REGNUM] = (frame_info)->frame - 20;\
	  pc = pc + 4;							\
	}								\
      if (read_memory_integer (pc, 4) != 0x8040241) goto lose;		\
      pc += 8;			/* skip "copy 4,1; copy 30, 4" */	\
      /* skip either "stw 1,0(4);addil L'fsize,30;ldo R'fsize(1),30"	\
	 or "stwm 1,fsize(30)" */					\
      if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000)	\
	pc += 12;							\
      else								\
	pc += 4;							\
      while (1)								\
	{ this_insn = read_memory_integer(pc, 4);			\
	  if (STW_P (this_insn)) /* stw */				\
	    { regnum = GET_FIELD (this_insn, 11, 15);			\
	      if (!regnum) goto lose;					\
	      (frame_saved_regs).regs[regnum] = (frame_info)->frame +	\
		extract_14 (this_insn);					\
	      pc += 4;							\
	    }								\
	  else if (ADDIL_P (this_insn)) /* addil */			\
	    { int next_insn;						\
	      next_insn = read_memory_integer(pc + 4, 4);		\
	      if (STW_P (next_insn)) /* stw */				\
		{ regnum = GET_FIELD (this_insn, 6, 10);		\
		  if (!regnum) goto lose;				\
		  (frame_saved_regs).regs[regnum] = (frame_info)->frame +\
		    (extract_21 (this_insn) << 11) + extract_14 (next_insn);\
		  pc += 8;						\
		}							\
	      else							\
		break;							\
	    }								\
	  else								\
	    { pc += 4;							\
	      break;							\
	    }								\
	}								\
      this_insn = read_memory_integer (pc, 4);				\
      if (LDO_P (this_insn))						\
	{ next_addr = (frame_info)->frame + extract_14 (this_insn);	\
	  pc += 4;							\
	}								\
      else if (ADDIL_P (this_insn))					\
	{ next_addr = (frame_info)->frame + (extract_21 (this_insn) << 11)\
	    + extract_14 (read_memory_integer (pc + 4, 4));		\
	    pc += 8;							\
	  }								\
      while (1)								\
	{ this_insn = read_memory_integer (pc, 4);			\
	  if ((this_insn & 0xfc001fe0) == 0x2c001220) /* fstds,ma */	\
	    { regnum = GET_FIELD (this_insn, 27, 31);			\
	      (frame_saved_regs).regs[regnum + FP0_REGNUM] = next_addr;	\
	      next_addr += 8;						\
	    }								\
	  else								\
	    break;							\
	}								\
    lose:								\
      (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame;		\
      (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame -4;	\
    }}

/* Things needed for making the inferior call functions.  */

/* Push an empty stack frame, to record the current PC, etc. */

#define PUSH_DUMMY_FRAME \
{ register CORE_ADDR sp = read_register (SP_REGNUM);			\
  register int regnum;							\
  int int_buffer;							\
  double freg_buffer;							\
  /* Space for "arguments"; the RP goes in here. */			\
  sp += 48;								\
  int_buffer = read_register (RP_REGNUM) | 0x3;				\
  write_memory (sp - 20, &int_buffer, 4);				\
  int_buffer = read_register (FP_REGNUM);				\
  write_memory (sp, &int_buffer, 4);					\
  write_register (FP_REGNUM, sp);					\
  sp += 4;								\
  for (regnum = 1; regnum < 31; regnum++)				\
    if (regnum != RP_REGNUM && regnum != FP_REGNUM)			\
      sp = push_word (sp, read_register (regnum));			\
  for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)		\
    { read_register_bytes (REGISTER_BYTE (regnum), &freg_buffer, 8);	\
      sp = push_bytes (sp, &freg_buffer, 8);}				\
  sp = push_word (sp, read_register (IPSW_REGNUM));			\
  sp = push_word (sp, read_register (SAR_REGNUM));			\
  sp = push_word (sp, read_register (PCOQ_TAIL_REGNUM));		\
  sp = push_word (sp, read_register (PCSQ_TAIL_REGNUM));		\
  write_register (SP_REGNUM, sp);}

/* Discard from the stack the innermost frame, 
   restoring all saved registers.  */
#define POP_FRAME  \
{ register FRAME frame = get_current_frame ();				\
  register CORE_ADDR fp;						\
  register int regnum;						 	\
  struct frame_saved_regs fsr;					 	\
  struct frame_info *fi;					 	\
  double freg_buffer;						 	\
  fi = get_frame_info (frame);					 	\
  fp = fi->frame;						 	\
  get_frame_saved_regs (fi, &fsr);				 	\
  for (regnum = 31; regnum > 0; regnum--)			 	\
    if (fsr.regs[regnum])					 	\
      write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \
  for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM ; regnum--) 	 	\
    if (fsr.regs[regnum])					 	\
      { read_memory (fsr.regs[regnum], &freg_buffer, 8);	 	\
        write_register_bytes (REGISTER_BYTE (regnum), &freg_buffer, 8); }\
  if (fsr.regs[IPSW_REGNUM])					 	\
    write_register (IPSW_REGNUM,				 	\
		    read_memory_integer (fsr.regs[IPSW_REGNUM], 4)); 	\
  if (fsr.regs[SAR_REGNUM])					 	\
    write_register (SAR_REGNUM,						\
		    read_memory_integer (fsr.regs[SAR_REGNUM], 4));	\
  if (fsr.regs[PCOQ_TAIL_REGNUM])					\
    write_register (PCOQ_TAIL_REGNUM,					\
		    read_memory_integer (fsr.regs[PCOQ_TAIL_REGNUM], 4));\
  if (fsr.regs[PCSQ_TAIL_REGNUM])					\
    write_register (PCSQ_TAIL_REGNUM,					\
		    read_memory_integer (fsr.regs[PCSQ_TAIL_REGNUM], 4));\
  write_register (FP_REGNUM, read_memory_integer (fp, 4));	 \
  write_register (SP_REGNUM, fp + 8);				 \
  flush_cached_frames ();					 \
  set_current_frame (create_new_frame (read_register (FP_REGNUM),\
					read_pc ())); }

/* This sequence of words is the instructions

; Call stack frame has already been built by gdb. Since we could be calling 
; a varargs function, and we do not have the benefit of a stub to put things in
; the right place, we load the first 4 word of arguments into both the general
; and fp registers.
call_dummy
	ldw -36(sp), arg0
	ldw -40(sp), arg1
	ldw -44(sp), arg2
	ldw -48(sp), arg3
	ldo -36(sp), r1
	fldws 0(0, r1), fr4
	fldds -4(0, r1), fr5
	fldws -8(0, r1), fr6
	fldds -12(0, r1), fr7
	ldil 0, r22			; target will be placed here.
	ldo 0(r22), r22
	ldsid (0,r22), r3
	ldil 0, r1			; _sr4export will be placed here.
	ldo 0(r1), r1
	ldsid (0,r1), r4
	combt,=,n r3, r4, text_space	; If target is in data space, do a
	ble 0(sr5, r22)			; "normal" procedure call
	copy r31, r2
	break 4, 8 
text_space				; Otherwise, go through _sr4export,
	ble (sr4, r1)			; which will return back here.
	stw 31,-24(r30)
	break 4, 8

   The dummy decides if the target is in text space or data space. If
   it's in data space, there's no problem because the target can
   return back to the dummy. However, if the target is in text space,
   the dummy calls the secret, undocumented routine _sr4export, which
   calls a function in text space and can return to any space. Instead
   of including fake instructions to represent saved registers, we
   know that the frame is associated with the call dummy and treat it
   specially. */ 

#define CALL_DUMMY { 0x4bda3fb9, 0x4bd93fb1, 0x4bd83fa9, 0x4bd73fa1,	\
		     0x37c13fb9, 0x24201004, 0x2c391005, 0x24311006,	\
		     0x2c291007, 0x22c00000, 0x36d60000, 0x02c010a3,	\
		     0x20200000, 0x34210000, 0x002010a4, 0x80832012,	\
		     0xe6c06000, 0x081f0242, 0x00010004, 0xe4202000,	\
		     0x6bdf3fd1, 0x00010004}

#define CALL_DUMMY_LENGTH 88
#define CALL_DUMMY_START_OFFSET 0
/* Insert the specified number of args and function address
   into a call sequence of the above form stored at DUMMYNAME.  */
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
{ static CORE_ADDR sr4export_address = 0;				\
  									\
  if (!sr4export_address)						\
    {									\
      struct minimal_symbol *msymbol;                                   \
      msymbol = lookup_minimal_symbol ("_sr4export", (struct objfile *) NULL);\
      if (msymbol = NULL)                                               \
	error ("Can't find an address for _sr4export trampoline");	\
      else								\
	sr4export_address = msymbol -> address;                 	\
    }									\
  dummyname[9] = deposit_21 (fun >> 11, dummyname[9]);			\
  dummyname[10] = deposit_14 (fun & MASK_11, dummyname[10]);		\
  dummyname[12] = deposit_21 (sr4export_address >> 11, dummyname[12]);	\
  dummyname[13] = deposit_14 (sr4export_address & MASK_11, dummyname[13]);\
}


#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
    sp = hp_push_arguments(nargs, args, sp, struct_return, struct_addr)

/* Write the PC to a random value.
   On PA-RISC, we need to be sure that the PC space queue is correct. */

#define WRITE_PC(addr) \
{ int space_reg, space = ((addr) >> 30);		\
  int space_val;					\
  if (space == 0)					\
    space_reg = 43;		/* Space reg sr4 */	\
  else if (space == 1)					\
    space_reg = 48;		/* Space reg sr5*/	\
  else							\
    error ("pc = %x is in illegal space.", addr);	\
  space_val = read_register (space_reg);		\
  write_register (PCOQ_HEAD_REGNUM, addr);		\
  write_register (PCSQ_HEAD_REGNUM, space_val);		\
  write_register (PCOQ_TAIL_REGNUM, addr);		\
  write_register (PCSQ_TAIL_REGNUM, space_val);}

/* Symbol files have two symbol tables.  Rather than do this right,
   like the ELF symbol reading code, massive hackery was added
   to dbxread.c and partial-stab.h.  This flag turns on that
   hackery, which should all go away FIXME FIXME FIXME FIXME now.  */

#define	GDB_TARGET_IS_HPPA