projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* hppa.c (hppa_object_setup): Get rid of all knowledge of stabs
[deliverable/binutils-gdb.git] / gdb / tm-hppa.h
CommitLineData
9f739abd
SG		 1/* Parameters for execution on a Hewlett-Packard PA-RISC machine, running
2 HPUX or BSD.
5140562f
JG		 3 Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
4
5 Contributed by the Center for Software Science at the
6 University of Utah (pa-gdb-bugs@cs.utah.edu).
7
8This file is part of GDB.
9
10This program is free software; you can redistribute it and/or modify
11it under the terms of the GNU General Public License as published by
12the Free Software Foundation; either version 2 of the License, or
13(at your option) any later version.
14
15This program is distributed in the hope that it will be useful,
16but WITHOUT ANY WARRANTY; without even the implied warranty of
17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18GNU General Public License for more details.
19
20You should have received a copy of the GNU General Public License
21along with this program; if not, write to the Free Software
22Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
23
24/* Target system byte order. */
25
26#define TARGET_BYTE_ORDER BIG_ENDIAN
27
28/* Get at various relevent fields of an instruction word. */
29
30#define MASK_5 0x1f
31#define MASK_11 0x7ff
32#define MASK_14 0x3fff
33#define MASK_21 0x1fffff
34
35/* This macro gets bit fields using HP's numbering (MSB = 0) */
36
37#define GET_FIELD(X, FROM, TO) \
38 ((X) >> 31 - (TO) & (1 << ((TO) - (FROM) + 1)) - 1)
39
40/* Watch out for NaNs */
41
42#define IEEE_FLOAT
43
44/* Groan */
45
46#define ARGS_GROW_DOWN
47
48/* Define this if the C compiler puts an underscore at the front
49 of external names before giving them to the linker. */
50
51/* #define NAMES_HAVE_UNDERSCORE */
52
53/* Offset from address of function to start of its code.
54 Zero on most machines. */
55
56#define FUNCTION_START_OFFSET 0
57
58/* Advance PC across any function entry prologue instructions
59 to reach some "real" code. */
60
61/* skip (stw rp, -20(0,sp)); copy 4,1; copy sp, 4; stwm 1,framesize(sp)
62 for gcc, or (stw rp, -20(0,sp); stwm 1, framesize(sp) for hcc */
63
64#define SKIP_PROLOGUE(pc) \
65{ if (read_memory_integer ((pc), 4) == 0x6BC23FD9) \
66 { if (read_memory_integer ((pc) + 4, 4) == 0x8040241) \
67 (pc) += 16; \
68 else if ((read_memory_integer (pc + 4, 4) & ~MASK_14) == 0x68810000) \
69 (pc) += 8;} \
70 else if (read_memory_integer ((pc), 4) == 0x8040241) \
71 (pc) += 12; \
72 else if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000) \
73 (pc) += 4;}
74
9f739abd
SG		 75/* If PC is in some function-call trampoline code, return the PC
76 where the function itself actually starts. If not, return NULL. */
77
b5c10493 78#define SKIP_TRAMPOLINE_CODE(pc) skip_trampoline_code (pc, NULL)
9f739abd
SG		 79
80/* Return non-zero if we are in some sort of a trampoline. */
81
b5c10493 82#define IN_SOLIB_TRAMPOLINE(pc, name) skip_trampoline_code (pc, name)
9f739abd 83
5140562f
JG		 84/* Immediately after a function call, return the saved pc.
85 Can't go through the frames for this because on some machines
86 the new frame is not set up until the new function executes
87 some instructions. */
88
89#define SAVED_PC_AFTER_CALL(frame) (read_register (RP_REGNUM) & ~3)
90
91/* Address of end of stack space. Who knows. */
92
93#define STACK_END_ADDR 0x80000000
94
95/* Stack grows upward */
96
97#define INNER_THAN >
98
99
100/* Sequence of bytes for breakpoint instruction. */
101
102/*#define BREAKPOINT {0x00, 0x00, 0x00, 0x00}*/
103#ifdef KERNELDEBUG /* XXX */
104#define BREAKPOINT {0x00, 0x00, 0xa0, 0x00}
105#else
106#define BREAKPOINT {0x00, 0x01, 0x00, 0x04}
107#endif
108
109/* Amount PC must be decremented by after a breakpoint.
110 This is often the number of bytes in BREAKPOINT
111 but not always.
112
113 Not on the PA-RISC */
114
115#define DECR_PC_AFTER_BREAK 0
116
117/* return instruction is bv r0(rp) */
118
119#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 4) == 0xE840C000)
120
121/* Return 1 if P points to an invalid floating point value. */
122
123#define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */
124
125/* Largest integer type */
126#define LONGEST long
127
128/* Name of the builtin type for the LONGEST type above. */
129#define BUILTIN_TYPE_LONGEST builtin_type_long
130
131/* Say how long (ordinary) registers are. */
132
133#define REGISTER_TYPE long
134
135/* Number of machine registers */
136
137#define NUM_REGS 100
138
139/* Initializer for an array of names of registers.
140 There should be NUM_REGS strings in this initializer. */
141
142#define REGISTER_NAMES \
143 {"flags", "r1", "rp", "r3", "r4", "r5", "r6", "r7", "r8", "r9", \
144 "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", \
145 "r20", "r21", "r22", "arg3", "arg2", "arg1", "arg0", "dp", "ret0", "ret1", \
146 "sp", "r31", "sar", "pcoqh", "pcsqh", "pcoqt", "pcsqt", \
147 "eiem", "iir", "isr", "ior", "ipsw", "goto", "sr4", "sr0", "sr1", "sr2", \
148 "sr3", "sr5", "sr6", "sr7", "cr0", "cr8", "cr9", "ccr", "cr12", "cr13", \
149 "cr24", "cr25", "cr26", "mpsfu_high", "mpsfu_low", "mpsfu_ovflo", "pad", \
150 "fpsr", "fpe1", "fpe2", "fpe3", "fpe4", "fpe5", "fpe6", "fpe7", \
151 "fp4", "fp5", "fp6", "fp7", "fp8", \
152 "fp9", "fp10", "fp11", "fp12", "fp13", "fp14", "fp15", \
153 "fp16", "fp17", "fp18", "fp19", "fp20", "fp21", "fp22", "fp23", \
154 "fp24", "fp25", "fp26", "fp27", "fp28", "fp29", "fp30", "fp31"}
155
156/* Register numbers of various important registers.
157 Note that some of these values are "real" register numbers,
158 and correspond to the general registers of the machine,
159 and some are "phony" register numbers which are too large
160 to be actual register numbers as far as the user is concerned
161 but do serve to get the desired values when passed to read_register. */
162
9f739abd 163#define FLAGS_REGNUM 0 /* Various status flags */
5140562f
JG		 164#define RP_REGNUM 2 /* return pointer */
165#define FP_REGNUM 4 /* Contains address of executing stack */
166 /* frame */
167#define SP_REGNUM 30 /* Contains address of top of stack */
168#define SAR_REGNUM 32 /* shift amount register */
169#define IPSW_REGNUM 41 /* processor status word. ? */
170#define PCOQ_HEAD_REGNUM 33 /* instruction offset queue head */
171#define PCSQ_HEAD_REGNUM 34 /* instruction space queue head */
172#define PCOQ_TAIL_REGNUM 35 /* instruction offset queue tail */
173#define PCSQ_TAIL_REGNUM 36 /* instruction space queue tail */
174#define FP0_REGNUM 64 /* floating point reg. 0 */
175#define FP4_REGNUM 72
176
177/* compatibility with the rest of gdb. */
178#define PC_REGNUM PCOQ_HEAD_REGNUM
179#define NPC_REGNUM PCOQ_TAIL_REGNUM
180
e0ba1d14
JG		 181/* When fetching register values from an inferior or a core file,
182 clean them up using this macro. BUF is a char pointer to
183 the raw value of the register in the registers[] array. */
184
185#define CLEAN_UP_REGISTER_VALUE(regno, buf) \
186 do { \
187 if ((regno) == PCOQ_HEAD_REGNUM || (regno) == PCOQ_TAIL_REGNUM) \
188 (buf)[3] &= ~0x3; \
189 } while (0)
190
5140562f
JG		 191/* Define DO_REGISTERS_INFO() to do machine-specific formatting
192 of register dumps. */
193
194#define DO_REGISTERS_INFO(_regnum, fp) pa_do_registers_info (_regnum, fp)
195
196/* PA specific macro to see if the current instruction is nullified. */
197#define INSTRUCTION_NULLIFIED ((int)read_register (IPSW_REGNUM) & 0x00200000)
198
199/* Total amount of space needed to store our copies of the machine's
200 register state, the array `registers'. */
201#define REGISTER_BYTES (32 * 4 + 11 * 4 + 8 * 4 + 12 * 4 + 4 + 32 * 8)
202
203/* Index within `registers' of the first byte of the space for
204 register N. */
205
206#define REGISTER_BYTE(N) \
207 ((N) >= FP4_REGNUM ? ((N) - FP4_REGNUM) * 8 + 288 : (N) * 4)
208
209/* Number of bytes of storage in the actual machine representation
210 for register N. On the PA-RISC, all regs are 4 bytes
211 except the floating point regs which are 8 bytes. */
212
213#define REGISTER_RAW_SIZE(N) ((N) < FP4_REGNUM ? 4 : 8)
214
215/* Number of bytes of storage in the program's representation
216 for register N. */
217
218#define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N)
219
220/* Largest value REGISTER_RAW_SIZE can have. */
221
222#define MAX_REGISTER_RAW_SIZE 8
223
224/* Largest value REGISTER_VIRTUAL_SIZE can have. */
225
226#define MAX_REGISTER_VIRTUAL_SIZE 8
227
228/* Nonzero if register N requires conversion
229 from raw format to virtual format. */
230
231#define REGISTER_CONVERTIBLE(N) 0
232
233/* Convert data from raw format for register REGNUM
234 to virtual format for register REGNUM. */
235
9f739abd
SG		 236#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM, FROM, TO) \
237{ memcpy ((TO), (FROM), (REGNUM) < FP4_REGNUM ? 4 : 8); }
5140562f
JG		 238
239/* Convert data from virtual format for register REGNUM
240 to raw format for register REGNUM. */
241
9f739abd
SG		 242#define REGISTER_CONVERT_TO_RAW(REGNUM, FROM, TO) \
243{ memcpy ((TO), (FROM), (REGNUM) < FP4_REGNUM ? 4 : 8); }
5140562f
JG		 244
245/* Return the GDB type object for the "standard" data type
246 of data in register N. */
247
248#define REGISTER_VIRTUAL_TYPE(N) \
249 ((N) < FP4_REGNUM ? builtin_type_int : builtin_type_double)
250
251/* Store the address of the place in which to copy the structure the
252 subroutine will return. This is called from call_function. */
253
254#define STORE_STRUCT_RETURN(ADDR, SP) {write_register (28, (ADDR)); }
255
256/* Extract from an array REGBUF containing the (raw) register state
257 a function return value of type TYPE, and copy that, in virtual format,
258 into VALBUF. */
259
260#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
261 bcopy ((REGBUF) + REGISTER_BYTE(TYPE_LENGTH(TYPE) > 4 ? \
262 FP4_REGNUM :28), VALBUF, TYPE_LENGTH (TYPE))
263
264/* Write into appropriate registers a function return value
265 of type TYPE, given in virtual format. */
266
267#define STORE_RETURN_VALUE(TYPE,VALBUF) \
268 write_register_bytes (TYPE_LENGTH(TYPE) > 4 ? FP4_REGNUM :28, \
269 VALBUF, TYPE_LENGTH (TYPE))
270
271/* Extract from an array REGBUF containing the (raw) register state
272 the address in which a function should return its structure value,
273 as a CORE_ADDR (or an expression that can be used as one). */
274
275#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)((REGBUF) + 28))
276
9f739abd
SG		 277/*
278 * This macro defines the register numbers (from REGISTER_NAMES) that
279 * are effectively unavailable to the user through ptrace(). It allows
280 * us to include the whole register set in REGISTER_NAMES (inorder to
281 * better support remote debugging). If it is used in
282 * fetch/store_inferior_registers() gdb will not complain about I/O errors
283 * on fetching these registers. If all registers in REGISTER_NAMES
284 * are available, then return false (0).
285 */
286
287#define CANNOT_STORE_REGISTER(regno) \
288 ((regno) == 0) || \
289 ((regno) == PCSQ_HEAD_REGNUM) || \
290 ((regno) >= PCSQ_TAIL_REGNUM && (regno) < IPSW_REGNUM) || \
291 ((regno) > IPSW_REGNUM && (regno) < FP4_REGNUM)
292
b5c10493 293#define INIT_EXTRA_FRAME_INFO(fromleaf, frame) init_extra_frame_info (fromleaf, frame)
5140562f
JG		 294
295/* Describe the pointer in each stack frame to the previous stack frame
296 (its caller). */
297
298/* FRAME_CHAIN takes a frame's nominal address
299 and produces the frame's chain-pointer.
300
301 FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
302 and produces the nominal address of the caller frame.
303
304 However, if FRAME_CHAIN_VALID returns zero,
305 it means the given frame is the outermost one and has no caller.
306 In that case, FRAME_CHAIN_COMBINE is not used. */
307
308/* In the case of the PA-RISC, the frame's nominal address
309 is the address of a 4-byte word containing the calling frame's
310 address (previous FP). */
311
b5c10493 312#define FRAME_CHAIN(thisframe) frame_chain (thisframe)
5140562f 313
b5c10493 314#if 0
5140562f
JG		 315#define FRAME_CHAIN_VALID(chain, thisframe) \
316 frame_chain_valid (chain, thisframe)
b5c10493 317#endif
5140562f
JG		 318
319#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
320
321/* Define other aspects of the stack frame. */
322
323/* A macro that tells us whether the function invocation represented
324 by FI does not have a frame on the stack associated with it. If it
325 does not, FRAMELESS is set to 1, else 0. */
326#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
327 (FRAMELESS) = frameless_look_for_prologue(FI)
328
329#define FRAME_SAVED_PC(FRAME) frame_saved_pc (FRAME)
330
331#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
332
333#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
334/* Set VAL to the number of args passed to frame described by FI.
335 Can set VAL to -1, meaning no way to tell. */
336
337/* We can't tell how many args there are
338 now that the C compiler delays popping them. */
339#define FRAME_NUM_ARGS(val,fi) (val = -1)
340
341/* Return number of bytes at start of arglist that are not really args. */
342
343#define FRAME_ARGS_SKIP 0
344
345/* Put here the code to store, into a struct frame_saved_regs,
346 the addresses of the saved registers of frame described by FRAME_INFO.
347 This includes special registers such as pc and fp saved in special
348 ways in the stack frame. sp is even more special:
349 the address we return for it IS the sp for the next frame. */
350
351/* Deal with dummy functions later. */
352
353#define STW_P(INSN) (((INSN) & 0xfc000000) == 0x68000000)
354#define ADDIL_P(INSN) (((INSN) & 0xfc000000) == 0x28000000)
355#define LDO_P(INSN) (((INSN) & 0xfc00c000) == 0x34000000)
356
5140562f
JG		 357#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
358{ register int regnum; \
359 register CORE_ADDR next_addr; \
360 register CORE_ADDR pc; \
361 unsigned this_insn; \
362 unsigned address; \
363 \
364 bzero (&frame_saved_regs, sizeof frame_saved_regs); \
9f739abd
SG		 365 if ((frame_info->pc >= (frame_info)->frame \
366 && (frame_info)->pc <= ((frame_info)->frame + CALL_DUMMY_LENGTH \
367 + 32 * 4 + (NUM_REGS - FP0_REGNUM) * 8 \
368 + 6 * 4))) \
5140562f
JG		 369 find_dummy_frame_regs ((frame_info), &(frame_saved_regs)); \
370 else \
371 { pc = get_pc_function_start ((frame_info)->pc); \
372 if (read_memory_integer (pc, 4) == 0x6BC23FD9) \
373 { (frame_saved_regs).regs[RP_REGNUM] = (frame_info)->frame - 20;\
374 pc = pc + 4; \
375 } \
376 if (read_memory_integer (pc, 4) != 0x8040241) goto lose; \
377 pc += 8; /* skip "copy 4,1; copy 30, 4" */ \
378 /* skip either "stw 1,0(4);addil L'fsize,30;ldo R'fsize(1),30" \
379 or "stwm 1,fsize(30)" */ \
380 if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000) \
381 pc += 12; \
382 else \
383 pc += 4; \
384 while (1) \
385 { this_insn = read_memory_integer(pc, 4); \
386 if (STW_P (this_insn)) /* stw */ \
387 { regnum = GET_FIELD (this_insn, 11, 15); \
388 if (!regnum) goto lose; \
389 (frame_saved_regs).regs[regnum] = (frame_info)->frame + \
390 extract_14 (this_insn); \
391 pc += 4; \
392 } \
393 else if (ADDIL_P (this_insn)) /* addil */ \
394 { int next_insn; \
395 next_insn = read_memory_integer(pc + 4, 4); \
396 if (STW_P (next_insn)) /* stw */ \
397 { regnum = GET_FIELD (this_insn, 6, 10); \
398 if (!regnum) goto lose; \
399 (frame_saved_regs).regs[regnum] = (frame_info)->frame +\
400 (extract_21 (this_insn) << 11) + extract_14 (next_insn);\
401 pc += 8; \
402 } \
403 else \
404 break; \
405 } \
406 else \
407 { pc += 4; \
408 break; \
409 } \
410 } \
411 this_insn = read_memory_integer (pc, 4); \
412 if (LDO_P (this_insn)) \
413 { next_addr = (frame_info)->frame + extract_14 (this_insn); \
414 pc += 4; \
415 } \
416 else if (ADDIL_P (this_insn)) \
417 { next_addr = (frame_info)->frame + (extract_21 (this_insn) << 11)\
418 + extract_14 (read_memory_integer (pc + 4, 4)); \
419 pc += 8; \
420 } \
421 while (1) \
422 { this_insn = read_memory_integer (pc, 4); \
423 if ((this_insn & 0xfc001fe0) == 0x2c001220) /* fstds,ma */ \
424 { regnum = GET_FIELD (this_insn, 27, 31); \
425 (frame_saved_regs).regs[regnum + FP0_REGNUM] = next_addr; \
426 next_addr += 8; \
9f739abd 427 pc += 4; \
5140562f
JG		 428 } \
429 else \
430 break; \
431 } \
432 lose: \
433 (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame; \
434 (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame -4; \
435 }}
436\f
437/* Things needed for making the inferior call functions. */
438
439/* Push an empty stack frame, to record the current PC, etc. */
440
9f739abd 441#define PUSH_DUMMY_FRAME push_dummy_frame ()
5140562f
JG		 442
443/* Discard from the stack the innermost frame,
444 restoring all saved registers. */
9f739abd 445#define POP_FRAME hp_pop_frame ()
5140562f
JG		 446
447/* This sequence of words is the instructions
448
449; Call stack frame has already been built by gdb. Since we could be calling
450; a varargs function, and we do not have the benefit of a stub to put things in
451; the right place, we load the first 4 word of arguments into both the general
452; and fp registers.
453call_dummy
454 ldw -36(sp), arg0
455 ldw -40(sp), arg1
456 ldw -44(sp), arg2
457 ldw -48(sp), arg3
458 ldo -36(sp), r1
459 fldws 0(0, r1), fr4
460 fldds -4(0, r1), fr5
461 fldws -8(0, r1), fr6
462 fldds -12(0, r1), fr7
463 ldil 0, r22 ; target will be placed here.
464 ldo 0(r22), r22
465 ldsid (0,r22), r3
466 ldil 0, r1 ; _sr4export will be placed here.
467 ldo 0(r1), r1
9f739abd
SG		 468 ldsid (0,r1), r19
469 combt,=,n r3, r19, text_space ; If target is in data space, do a
5140562f
JG		 470 ble 0(sr5, r22) ; "normal" procedure call
471 copy r31, r2
472 break 4, 8
9f739abd
SG		 473 mtsp r21, sr0
474 ble,n 0(sr0, r22)
5140562f
JG		 475text_space ; Otherwise, go through _sr4export,
476 ble (sr4, r1) ; which will return back here.
477 stw 31,-24(r30)
478 break 4, 8
9f739abd
SG		 479 mtsp r21, sr0
480 ble,n 0(sr0, r22)
5140562f
JG		 481
482 The dummy decides if the target is in text space or data space. If
483 it's in data space, there's no problem because the target can
484 return back to the dummy. However, if the target is in text space,
485 the dummy calls the secret, undocumented routine _sr4export, which
486 calls a function in text space and can return to any space. Instead
487 of including fake instructions to represent saved registers, we
488 know that the frame is associated with the call dummy and treat it
489 specially. */
490
9f739abd
SG		 491#define CALL_DUMMY {0x4BDA3FB9, 0x4BD93FB1, 0x4BD83FA9, 0x4BD73FA1,\
492 0x37C13FB9, 0x24201004, 0x2C391005, 0x24311006,\
493 0x2C291007, 0x22C00000, 0x36D60000, 0x02C010A3,\
494 0x20200000, 0x34210000, 0x002010b3, 0x82632022,\
495 0xe6c06000, 0x081f0242, 0x00010004, 0x00151820,\
496 0xe6c00002, 0xe4202000, 0x6bdf3fd1, 0x00010004,\
497 0x00151820, 0xe6c00002}
5140562f 498
9f739abd 499#define CALL_DUMMY_LENGTH 104
5140562f 500#define CALL_DUMMY_START_OFFSET 0
9f739abd
SG		 501
502/*
503 * Insert the specified number of args and function address
504 * into a call sequence of the above form stored at DUMMYNAME.
505 *
506 * On the hppa we need to call the stack dummy through $$dyncall.
507 * Therefore our version of FIX_CALL_DUMMY takes an extra argument,
508 * real_pc, which is the location where gdb should start up the
509 * inferior to do the function call.
510 */
511
512#define FIX_CALL_DUMMY(dummyname, pc, real_pc, fun, nargs, args, type, gcc_p) \
513{ \
514 CORE_ADDR dyncall_addr = 0, sr4export_addr = 0; \
515 \
516 if (!dyncall_addr) \
517 { \
5140562f 518 struct minimal_symbol *msymbol; \
9f739abd 519 msymbol = lookup_minimal_symbol ("$$dyncall", (struct objfile *) NULL);\
b8ef8163
SG		 520 if (msymbol == NULL) \
521 error ("Can't find an address for $$dyncall trampoline"); \
9f739abd 522 else \
b8ef8163 523 dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol); \
5140562f 524 msymbol = lookup_minimal_symbol ("_sr4export", (struct objfile *) NULL);\
b8ef8163 525 if (msymbol == NULL) \
9f739abd
SG		 526 error ("Can't find an address for _sr4export trampoline"); \
527 else \
b8ef8163 528 sr4export_addr = SYMBOL_VALUE_ADDRESS (msymbol); \
9f739abd
SG		 529 } \
530 dummyname[9] = deposit_21 (fun >> 11, dummyname[9]); \
531 dummyname[10] = deposit_14 (fun & MASK_11, dummyname[10]); \
532 dummyname[12] = deposit_21 (sr4export_addr >> 11, \
533 dummyname[12]); \
534 dummyname[13] = deposit_14 (sr4export_addr & MASK_11, \
535 dummyname[13]); \
536 write_register (22, pc); \
537 real_pc = dyncall_addr; \
5140562f
JG		 538}
539
e0ba1d14
JG		 540#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
541 sp = hp_push_arguments(nargs, args, sp, struct_return, struct_addr)
542
e0ba1d14
JG		 543/* Symbol files have two symbol tables. Rather than do this right,
544 like the ELF symbol reading code, massive hackery was added
545 to dbxread.c and partial-stab.h. This flag turns on that
546 hackery, which should all go away FIXME FIXME FIXME FIXME now. */
547
548#define GDB_TARGET_IS_HPPA
9f739abd
SG		 549
550/*
551 * Unwind table and descriptor.
552 */
553
554struct unwind_table_entry {
555 unsigned int region_start;
556 unsigned int region_end;
557
558 unsigned int Cannot_unwind : 1;
559 unsigned int Millicode : 1;
560 unsigned int Millicode_save_sr0 : 1;
561 unsigned int Region_description : 2;
562 unsigned int reserverd1 : 1;
563 unsigned int Entry_SR : 1;
564 unsigned int Entry_FR : 4; /* number saved */
565 unsigned int Entry_GR : 5; /* number saved */
566 unsigned int Args_stored : 1;
567 unsigned int Variable_Frame : 1;
568 unsigned int Separate_Package_Body : 1;
569 unsigned int Frame_Extension_Millicode:1;
570 unsigned int Stack_Overflow_Check : 1;
571 unsigned int Two_Instruction_SP_Increment:1;
572 unsigned int Ada_Region : 1;
573 unsigned int reserved2 : 4;
574 unsigned int Save_SP : 1;
575 unsigned int Save_RP : 1;
576 unsigned int Save_MRP_in_frame : 1;
577 unsigned int extn_ptr_defined : 1;
578 unsigned int Cleanup_defined : 1;
579
580 unsigned int MPE_XL_interrupt_marker: 1;
581 unsigned int HP_UX_interrupt_marker: 1;
582 unsigned int Large_frame : 1;
583 unsigned int reserved4 : 2;
584 unsigned int Total_frame_size : 27;
585};
GDB Binutils - Deliverables
This page took 0.06625 seconds and 4 git commands to generate.