1 /* Parameters for execution on any Hewlett-Packard PA-RISC machine. 2 3 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software 5 Foundation, Inc. 6 7 Contributed by the Center for Software Science at the 8 University of Utah (pa-gdb-bugs@cs.utah.edu). 9 10 This file is part of GDB. 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 2 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, Inc., 59 Temple Place - Suite 330, 25 Boston, MA 02111-1307, USA. */ 26 27 #include "regcache.h" 28 29 /* Wonder if this is correct? Should be using push_dummy_call(). */ 30 #define DEPRECATED_DUMMY_WRITE_SP(SP) deprecated_write_sp (SP) 31 32 #define GDB_MULTI_ARCH 1 33 34 /* Hack, get around problem with including "arch-utils.h". */ 35 struct frame_info; 36 37 /* Forward declarations of some types we use in prototypes */ 38 39 struct frame_info; 40 struct frame_saved_regs; 41 struct value; 42 struct type; 43 struct inferior_status; 44 45 /* Sequence of bytes for breakpoint instruction. */ 46 47 const unsigned char *hppa_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr); 48 #define BREAKPOINT_FROM_PC(PCPTR,LENPTR) hppa_breakpoint_from_pc ((PCPTR), (LENPTR)) 49 #define BREAKPOINT32 0x10004 50 51 extern int hppa_pc_requires_run_before_use (CORE_ADDR pc); 52 #define PC_REQUIRES_RUN_BEFORE_USE(pc) hppa_pc_requires_run_before_use (pc) 53 54 /* Register numbers of various important registers. 55 Note that some of these values are "real" register numbers, 56 and correspond to the general registers of the machine, 57 and some are "phony" register numbers which are too large 58 to be actual register numbers as far as the user is concerned 59 but do serve to get the desired values when passed to read_register. */ 60 61 #define R0_REGNUM 0 /* Doesn't actually exist, used as base for 62 other r registers. */ 63 #define FLAGS_REGNUM 0 /* Various status flags */ 64 #define RP_REGNUM 2 /* return pointer */ 65 #define SAR_REGNUM 32 /* Shift Amount Register */ 66 #define IPSW_REGNUM 41 /* Interrupt Processor Status Word */ 67 #define PCOQ_HEAD_REGNUM 33 /* instruction offset queue head */ 68 #define PCSQ_HEAD_REGNUM 34 /* instruction space queue head */ 69 #define PCOQ_TAIL_REGNUM 35 /* instruction offset queue tail */ 70 #define PCSQ_TAIL_REGNUM 36 /* instruction space queue tail */ 71 #define EIEM_REGNUM 37 /* External Interrupt Enable Mask */ 72 #define IIR_REGNUM 38 /* Interrupt Instruction Register */ 73 #define IOR_REGNUM 40 /* Interrupt Offset Register */ 74 #define SR4_REGNUM 43 /* space register 4 */ 75 #define RCR_REGNUM 51 /* Recover Counter (also known as cr0) */ 76 #define CCR_REGNUM 54 /* Coprocessor Configuration Register */ 77 #define TR0_REGNUM 57 /* Temporary Registers (cr24 -> cr31) */ 78 #define CR27_REGNUM 60 /* Base register for thread-local storage, cr27 */ 79 #define FP4_REGNUM 72 80 81 #define ARG0_REGNUM 26 /* The first argument of a callee. */ 82 #define ARG1_REGNUM 25 /* The second argument of a callee. */ 83 #define ARG2_REGNUM 24 /* The third argument of a callee. */ 84 #define ARG3_REGNUM 23 /* The fourth argument of a callee. */ 85 86 /* When fetching register values from an inferior or a core file, 87 clean them up using this macro. BUF is a char pointer to 88 the raw value of the register in the registers[] array. */ 89 90 #define DEPRECATED_CLEAN_UP_REGISTER_VALUE(regno, buf) \ 91 do { \ 92 if ((regno) == PCOQ_HEAD_REGNUM || (regno) == PCOQ_TAIL_REGNUM) \ 93 (buf)[sizeof(CORE_ADDR) -1] &= ~0x3; \ 94 } while (0) 95 96 /* Define DEPRECATED_DO_REGISTERS_INFO() to do machine-specific 97 formatting of register dumps. */ 98 99 #define DEPRECATED_DO_REGISTERS_INFO(_regnum, fp) pa_do_registers_info (_regnum, fp) 100 extern void pa_do_registers_info (int, int); 101 102 /* PA specific macro to see if the current instruction is nullified. */ 103 #ifndef INSTRUCTION_NULLIFIED 104 extern int hppa_instruction_nullified (void); 105 #define INSTRUCTION_NULLIFIED hppa_instruction_nullified () 106 #endif 107 108 #define INSTRUCTION_SIZE 4 109 110 /* This sequence of words is the instructions 111 112 ; Call stack frame has already been built by gdb. Since we could be calling 113 ; a varargs function, and we do not have the benefit of a stub to put things in 114 ; the right place, we load the first 4 word of arguments into both the general 115 ; and fp registers. 116 call_dummy 117 ldw -36(sp), arg0 118 ldw -40(sp), arg1 119 ldw -44(sp), arg2 120 ldw -48(sp), arg3 121 ldo -36(sp), r1 122 fldws 0(0, r1), fr4 123 fldds -4(0, r1), fr5 124 fldws -8(0, r1), fr6 125 fldds -12(0, r1), fr7 126 ldil 0, r22 ; FUNC_LDIL_OFFSET must point here 127 ldo 0(r22), r22 ; FUNC_LDO_OFFSET must point here 128 ldsid (0,r22), r4 129 ldil 0, r1 ; SR4EXPORT_LDIL_OFFSET must point here 130 ldo 0(r1), r1 ; SR4EXPORT_LDO_OFFSET must point here 131 ldsid (0,r1), r20 132 combt,=,n r4, r20, text_space ; If target is in data space, do a 133 ble 0(sr5, r22) ; "normal" procedure call 134 copy r31, r2 135 break 4, 8 136 mtsp r21, sr0 137 ble,n 0(sr0, r22) 138 text_space ; Otherwise, go through _sr4export, 139 ble (sr4, r1) ; which will return back here. 140 stw r31,-24(r30) 141 break 4, 8 142 mtsp r21, sr0 143 ble,n 0(sr0, r22) 144 nop ; To avoid kernel bugs 145 nop ; and keep the dummy 8 byte aligned 146 147 The dummy decides if the target is in text space or data space. If 148 it's in data space, there's no problem because the target can 149 return back to the dummy. However, if the target is in text space, 150 the dummy calls the secret, undocumented routine _sr4export, which 151 calls a function in text space and can return to any space. Instead 152 of including fake instructions to represent saved registers, we 153 know that the frame is associated with the call dummy and treat it 154 specially. 155 156 The trailing NOPs are needed to avoid a bug in HPUX, BSD and OSF1 157 kernels. If the memory at the location pointed to by the PC is 158 0xffffffff then a ptrace step call will fail (even if the instruction 159 is nullified). 160 161 The code to pop a dummy frame single steps three instructions 162 starting with the last mtsp. This includes the nullified "instruction" 163 following the ble (which is uninitialized junk). If the 164 "instruction" following the last BLE is 0xffffffff, then the ptrace 165 will fail and the dummy frame is not correctly popped. 166 167 By placing a NOP in the delay slot of the BLE instruction we can be 168 sure that we never try to execute a 0xffffffff instruction and 169 avoid the kernel bug. The second NOP is needed to keep the call 170 dummy 8 byte aligned. */ 171 172 #define CALL_DUMMY {0x4BDA3FB9, 0x4BD93FB1, 0x4BD83FA9, 0x4BD73FA1,\ 173 0x37C13FB9, 0x24201004, 0x2C391005, 0x24311006,\ 174 0x2C291007, 0x22C00000, 0x36D60000, 0x02C010A4,\ 175 0x20200000, 0x34210000, 0x002010b4, 0x82842022,\ 176 0xe6c06000, 0x081f0242, 0x00010004, 0x00151820,\ 177 0xe6c00002, 0xe4202000, 0x6bdf3fd1, 0x00010004,\ 178 0x00151820, 0xe6c00002, 0x08000240, 0x08000240} 179 180 #define REG_PARM_STACK_SPACE 16 181 182 /* If we've reached a trap instruction within the call dummy, then 183 we'll consider that to mean that we've reached the call dummy's 184 end after its successful completion. */ 185 #define DEPRECATED_CALL_DUMMY_HAS_COMPLETED(pc, sp, frame_address) \ 186 (DEPRECATED_PC_IN_CALL_DUMMY((pc), (sp), (frame_address)) && \ 187 (read_memory_integer((pc), 4) == BREAKPOINT32)) 188 189 /* Insert the specified number of args and function address into a 190 call sequence of the above form stored at DUMMYNAME. 191 192 On the hppa we need to call the stack dummy through $$dyncall. 193 Therefore our version of DEPRECATED_FIX_CALL_DUMMY takes an extra 194 argument, real_pc, which is the location where gdb should start up 195 the inferior to do the function call. */ 196 197 /* FIXME: brobecker 2002-12-26. This macro is going to cause us some 198 problems before we can go to multiarch partial as it has been 199 diverted on HPUX to return the value of the PC! */ 200 /* NOTE: cagney/2003-05-03: This has been replaced by push_dummy_code. 201 Hopefully that has all the parameters HP/UX needs. */ 202 #define DEPRECATED_FIX_CALL_DUMMY hppa_fix_call_dummy 203 extern CORE_ADDR hppa_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int, 204 struct value **, struct type *, int); 205 206 #define GDB_TARGET_IS_HPPA 207 208 /* 209 * Unwind table and descriptor. 210 */ 211 212 struct unwind_table_entry 213 { 214 CORE_ADDR region_start; 215 CORE_ADDR region_end; 216 217 unsigned int Cannot_unwind:1; /* 0 */ 218 unsigned int Millicode:1; /* 1 */ 219 unsigned int Millicode_save_sr0:1; /* 2 */ 220 unsigned int Region_description:2; /* 3..4 */ 221 unsigned int reserved1:1; /* 5 */ 222 unsigned int Entry_SR:1; /* 6 */ 223 unsigned int Entry_FR:4; /* number saved *//* 7..10 */ 224 unsigned int Entry_GR:5; /* number saved *//* 11..15 */ 225 unsigned int Args_stored:1; /* 16 */ 226 unsigned int Variable_Frame:1; /* 17 */ 227 unsigned int Separate_Package_Body:1; /* 18 */ 228 unsigned int Frame_Extension_Millicode:1; /* 19 */ 229 unsigned int Stack_Overflow_Check:1; /* 20 */ 230 unsigned int Two_Instruction_SP_Increment:1; /* 21 */ 231 unsigned int Ada_Region:1; /* 22 */ 232 unsigned int cxx_info:1; /* 23 */ 233 unsigned int cxx_try_catch:1; /* 24 */ 234 unsigned int sched_entry_seq:1; /* 25 */ 235 unsigned int reserved2:1; /* 26 */ 236 unsigned int Save_SP:1; /* 27 */ 237 unsigned int Save_RP:1; /* 28 */ 238 unsigned int Save_MRP_in_frame:1; /* 29 */ 239 unsigned int extn_ptr_defined:1; /* 30 */ 240 unsigned int Cleanup_defined:1; /* 31 */ 241 242 unsigned int MPE_XL_interrupt_marker:1; /* 0 */ 243 unsigned int HP_UX_interrupt_marker:1; /* 1 */ 244 unsigned int Large_frame:1; /* 2 */ 245 unsigned int Pseudo_SP_Set:1; /* 3 */ 246 unsigned int reserved4:1; /* 4 */ 247 unsigned int Total_frame_size:27; /* 5..31 */ 248 249 /* This is *NOT* part of an actual unwind_descriptor in an object 250 file. It is *ONLY* part of the "internalized" descriptors that 251 we create from those in a file. 252 */ 253 struct 254 { 255 unsigned int stub_type:4; /* 0..3 */ 256 unsigned int padding:28; /* 4..31 */ 257 } 258 stub_unwind; 259 }; 260 261 /* HP linkers also generate unwinds for various linker-generated stubs. 262 GDB reads in the stubs from the $UNWIND_END$ subspace, then 263 "converts" them into normal unwind entries using some of the reserved 264 fields to store the stub type. */ 265 266 /* The gaps represent linker stubs used in MPE and space for future 267 expansion. */ 268 enum unwind_stub_types 269 { 270 LONG_BRANCH = 1, 271 PARAMETER_RELOCATION = 2, 272 EXPORT = 10, 273 IMPORT = 11, 274 IMPORT_SHLIB = 12, 275 }; 276 277 /* We use the objfile->obj_private pointer for two things: 278 279 * 1. An unwind table; 280 * 281 * 2. A pointer to any associated shared library object. 282 * 283 * #defines are used to help refer to these objects. 284 */ 285 286 /* Info about the unwind table associated with an object file. 287 288 * This is hung off of the "objfile->obj_private" pointer, and 289 * is allocated in the objfile's psymbol obstack. This allows 290 * us to have unique unwind info for each executable and shared 291 * library that we are debugging. 292 */ 293 struct obj_unwind_info 294 { 295 struct unwind_table_entry *table; /* Pointer to unwind info */ 296 struct unwind_table_entry *cache; /* Pointer to last entry we found */ 297 int last; /* Index of last entry */ 298 }; 299 300 typedef struct obj_private_struct 301 { 302 struct obj_unwind_info *unwind_info; /* a pointer */ 303 struct so_list *so_info; /* a pointer */ 304 CORE_ADDR dp; 305 } 306 obj_private_data_t; 307 308 /* For a number of horrible reasons we may have to adjust the location 309 of variables on the stack. Ugh. */ 310 #define HPREAD_ADJUST_STACK_ADDRESS(ADDR) hpread_adjust_stack_address(ADDR) 311 extern int hpread_adjust_stack_address (CORE_ADDR); 312 313 /* Here's how to step off a permanent breakpoint. */ 314 #define SKIP_PERMANENT_BREAKPOINT (hppa_skip_permanent_breakpoint) 315 extern void hppa_skip_permanent_breakpoint (void); 316 317 /* On HP-UX, certain system routines (millicode) have names beginning 318 with $ or $$, e.g. $$dyncall, which handles inter-space procedure 319 calls on PA-RISC. Tell the expression parser to check for those 320 when parsing tokens that begin with "$". */ 321 #define SYMBOLS_CAN_START_WITH_DOLLAR (1) 322