OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [config/] [rs6000/] [tm-rs6000.h] - Blame information for rev 106

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/* Parameters for target execution on an RS6000, for GDB, the GNU debugger.
2
   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1997
3
   Free Software Foundation, Inc.
4
   Contributed by IBM Corporation.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 2 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 59 Temple Place - Suite 330,
21
   Boston, MA 02111-1307, USA.  */
22
 
23
/* Forward decls for prototypes */
24
struct frame_info;
25
struct type;
26
struct value;
27
 
28
/* Minimum possible text address in AIX */
29
 
30
#define TEXT_SEGMENT_BASE       0x10000000
31
 
32
/* Load segment of a given pc value. */
33
 
34
#define PC_LOAD_SEGMENT(PC)     pc_load_segment_name(PC)
35
extern char *pc_load_segment_name PARAMS ((CORE_ADDR));
36
 
37
/* AIX cc seems to get this right.  */
38
 
39
#define BELIEVE_PCC_PROMOTION 1
40
 
41
/* return true if a given `pc' value is in `call dummy' function. */
42
/* FIXME: This just checks for the end of the stack, which is broken
43
   for things like stepping through gcc nested function stubs.  */
44
#define PC_IN_CALL_DUMMY(STOP_PC, STOP_SP, STOP_FRAME_ADDR)     \
45
        (STOP_SP < STOP_PC && STOP_PC < STACK_END_ADDR)
46
 
47
#if 0
48
extern unsigned int text_start, data_start;
49
extern char *corefile;
50
#endif
51
extern int inferior_pid;
52
 
53
/* We are missing register descriptions in the system header files. Sigh! */
54
 
55
struct regs
56
  {
57
    int gregs[32];              /* general purpose registers */
58
    int pc;                     /* program conter       */
59
    int ps;                     /* processor status, or machine state */
60
  };
61
 
62
struct fp_status
63
  {
64
    double fpregs[32];          /* floating GP registers */
65
  };
66
 
67
 
68
/* To be used by skip_prologue. */
69
 
70
struct rs6000_framedata
71
  {
72
    int offset;                 /* total size of frame --- the distance
73
                                   by which we decrement sp to allocate
74
                                   the frame */
75
    int saved_gpr;              /* smallest # of saved gpr */
76
    int saved_fpr;              /* smallest # of saved fpr */
77
    int alloca_reg;             /* alloca register number (frame ptr) */
78
    char frameless;             /* true if frameless functions. */
79
    char nosavedpc;             /* true if pc not saved. */
80
    int gpr_offset;             /* offset of saved gprs from prev sp */
81
    int fpr_offset;             /* offset of saved fprs from prev sp */
82
    int lr_offset;              /* offset of saved lr */
83
    int cr_offset;              /* offset of saved cr */
84
  };
85
 
86
/* Define the byte order of the machine.  */
87
 
88
#define TARGET_BYTE_ORDER_DEFAULT       BIG_ENDIAN
89
 
90
/* AIX's assembler doesn't grok dollar signs in identifiers.
91
   So we use dots instead.  This item must be coordinated with G++. */
92
#undef CPLUS_MARKER
93
#define CPLUS_MARKER '.'
94
 
95
/* Offset from address of function to start of its code.
96
   Zero on most machines.  */
97
 
98
#define FUNCTION_START_OFFSET 0
99
 
100
/* Advance PC across any function entry prologue instructions
101
   to reach some "real" code.  */
102
 
103
extern CORE_ADDR rs6000_skip_prologue PARAMS ((CORE_ADDR));
104
#define SKIP_PROLOGUE(pc) (rs6000_skip_prologue (pc))
105
 
106
extern CORE_ADDR skip_prologue PARAMS ((CORE_ADDR, struct rs6000_framedata *));
107
 
108
 
109
/* If PC is in some function-call trampoline code, return the PC
110
   where the function itself actually starts.  If not, return NULL.  */
111
 
112
#define SKIP_TRAMPOLINE_CODE(pc)        skip_trampoline_code (pc)
113
extern CORE_ADDR skip_trampoline_code PARAMS ((CORE_ADDR));
114
 
115
/* Number of trap signals we need to skip over, once the inferior process
116
   starts running. */
117
 
118
#define START_INFERIOR_TRAPS_EXPECTED   2
119
 
120
/* AIX has a couple of strange returns from wait().  */
121
 
122
#define CHILD_SPECIAL_WAITSTATUS(ourstatus, hoststatus) ( \
123
  /* "stop after load" status.  */ \
124
  (hoststatus) == 0x57c ? (ourstatus)->kind = TARGET_WAITKIND_LOADED, 1 : \
125
  \
126
  /* signal 0. I have no idea why wait(2) returns with this status word.  */ \
127
  /* It looks harmless. */ \
128
  (hoststatus) == 0x7f ? (ourstatus)->kind = TARGET_WAITKIND_SPURIOUS, 1 : \
129
  \
130
  /* A normal waitstatus.  Let the usual macros deal with it.  */ \
131
  0)
132
 
133
/* In xcoff, we cannot process line numbers when we see them. This is
134
   mainly because we don't know the boundaries of the include files. So,
135
   we postpone that, and then enter and sort(?) the whole line table at
136
   once, when we are closing the current symbol table in end_symtab(). */
137
 
138
#define PROCESS_LINENUMBER_HOOK()       aix_process_linenos ()
139
extern void aix_process_linenos PARAMS ((void));
140
 
141
/* Immediately after a function call, return the saved pc.
142
   Can't go through the frames for this because on some machines
143
   the new frame is not set up until the new function executes
144
   some instructions.  */
145
 
146
#define SAVED_PC_AFTER_CALL(frame) read_register (LR_REGNUM)
147
 
148
/* Address of end of stack space.  */
149
 
150
#define STACK_END_ADDR 0x2ff80000
151
 
152
/* Stack grows downward.  */
153
 
154
#define INNER_THAN(lhs,rhs) ((lhs) < (rhs))
155
 
156
/* This is how arguments pushed onto stack or passed in registers.
157
   Stack must be aligned on 64-bit boundaries when synthesizing
158
   function calls.  We don't need STACK_ALIGN, PUSH_ARGUMENTS will
159
   handle it. */
160
 
161
#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
162
  (rs6000_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
163
extern CORE_ADDR rs6000_push_arguments PARAMS ((int, struct value **, CORE_ADDR, int, CORE_ADDR));
164
 
165
/* BREAKPOINT_FROM_PC uses the program counter value to determine the
166
   breakpoint that should be used */
167
extern breakpoint_from_pc_fn rs6000_breakpoint_from_pc;
168
#define BREAKPOINT_FROM_PC(pcptr, lenptr) rs6000_breakpoint_from_pc (pcptr, lenptr)
169
 
170
/* Amount PC must be decremented by after a breakpoint.
171
   This is often the number of bytes in BREAKPOINT
172
   but not always.  */
173
 
174
#define DECR_PC_AFTER_BREAK 0
175
 
176
/* Say how long (ordinary) registers are.  This is a piece of bogosity
177
   used in push_word and a few other places; REGISTER_RAW_SIZE is the
178
   real way to know how big a register is.  */
179
#define REGISTER_SIZE 4
180
 
181
 
182
/* Return the name of register number REG.  This may return "" to
183
   indicate a register number that's not used on this variant.
184
   (Register numbers may be sparse for consistency between variants.)  */
185
#define REGISTER_NAME(reg) (rs6000_register_name(reg))
186
extern char *rs6000_register_name (int reg);
187
 
188
/* Number of machine registers */
189
#define NUM_REGS 183
190
 
191
/* Register numbers of various important registers.
192
   Note that some of these values are "real" register numbers,
193
   and correspond to the general registers of the machine,
194
   and some are "phony" register numbers which are too large
195
   to be actual register numbers as far as the user is concerned
196
   but do serve to get the desired values when passed to read_register.  */
197
 
198
#define FP_REGNUM 1             /* Contains address of executing stack frame */
199
#define SP_REGNUM 1             /* Contains address of top of stack */
200
#define TOC_REGNUM 2            /* TOC register */
201
#define FP0_REGNUM 32           /* Floating point register 0 */
202
#define GP0_REGNUM 0            /* GPR register 0 */
203
#define FP0_REGNUM 32           /* FPR (Floating point) register 0 */
204
#define FPLAST_REGNUM 63        /* Last floating point register */
205
 
206
/* Special purpose registers... */
207
/* P.S. keep these in the same order as in /usr/mstsave.h `mstsave'
208
   structure, for easier processing */
209
 
210
#define PC_REGNUM 64            /* Program counter (instruction address %iar) */
211
#define PS_REGNUM 65            /* Processor (or machine) status (%msr) */
212
#define CR_REGNUM 66            /* Condition register */
213
#define LR_REGNUM 67            /* Link register */
214
#define CTR_REGNUM 68           /* Count register */
215
#define XER_REGNUM 69           /* Fixed point exception registers */
216
#define MQ_REGNUM 70            /* Multiply/quotient register */
217
 
218
/* These #defines are used to parse core files and talk to ptrace, so they
219
   must remain fixed.  */
220
#define FIRST_UISA_SP_REGNUM 64 /* first special register number */
221
#define LAST_UISA_SP_REGNUM  70 /* last special register number */
222
 
223
/* This is the offset in REG_NAMES at which the `set processor'
224
   command starts plugging in its names.  */
225
#define FIRST_VARIANT_REGISTER 66
226
 
227
/* Total amount of space needed to store our copies of the machine's
228
   register state, the array `registers'.
229
   32 4-byte gpr's
230
   32 8-byte fpr's
231
   7  4-byte UISA special purpose registers,
232
   16 4-byte segment registers,
233
   32 4-byte standard OEA special-purpose registers,
234
   and up to 64 4-byte non-standard OEA special purpose regs.
235
   total: (+ (* 32 4) (* 32 8) (* 7 4) (* 16 4) (* 32 4) (* 64 4)) 860 bytes
236
   Keep some extra space for now, in case to add more. */
237
#define REGISTER_BYTES 880
238
 
239
 
240
/* Index within `registers' of the first byte of the space for
241
   register N.  */
242
 
243
#define REGISTER_BYTE(N)  \
244
 (                                                              \
245
  ((N) > FPLAST_REGNUM) ? ((((N) - FPLAST_REGNUM -1) * 4) + 384)\
246
  :((N) >= FP0_REGNUM) ? ((((N) - FP0_REGNUM) * 8) + 128)       \
247
  :((N) * 4) )
248
 
249
/* Number of bytes of storage in the actual machine representation
250
   for register N. */
251
/* Note that the unsigned cast here forces the result of the
252
   subtraction to very high positive values if N < FP0_REGNUM */
253
 
254
#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
255
 
256
/* Number of bytes of storage in the program's representation
257
   for register N.  On the RS6000, all regs are 4 bytes
258
   except the floating point regs which are 8-byte doubles.  */
259
 
260
#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 32 ? 8 : 4)
261
 
262
/* Largest value REGISTER_RAW_SIZE can have.  */
263
 
264
#define MAX_REGISTER_RAW_SIZE 8
265
 
266
/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
267
 
268
#define MAX_REGISTER_VIRTUAL_SIZE 8
269
 
270
/* convert a dbx stab register number (from `r' declaration) to a gdb REGNUM */
271
 
272
#define STAB_REG_TO_REGNUM(value)       (value)
273
 
274
/* Nonzero if register N requires conversion
275
   from raw format to virtual format.
276
   The register format for rs6000 floating point registers is always
277
   double, we need a conversion if the memory format is float.  */
278
 
279
#define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM && (N) <= FPLAST_REGNUM)
280
 
281
/* Convert data from raw format for register REGNUM in buffer FROM
282
   to virtual format with type TYPE in buffer TO.  */
283
 
284
#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,TYPE,FROM,TO) \
285
{ \
286
  if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
287
    { \
288
      double val = extract_floating ((FROM), REGISTER_RAW_SIZE (REGNUM)); \
289
      store_floating ((TO), TYPE_LENGTH (TYPE), val); \
290
    } \
291
  else \
292
    memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
293
}
294
 
295
/* Convert data from virtual format with type TYPE in buffer FROM
296
   to raw format for register REGNUM in buffer TO.  */
297
 
298
#define REGISTER_CONVERT_TO_RAW(TYPE,REGNUM,FROM,TO)    \
299
{ \
300
  if (TYPE_LENGTH (TYPE) != REGISTER_RAW_SIZE (REGNUM)) \
301
    { \
302
      double val = extract_floating ((FROM), TYPE_LENGTH (TYPE)); \
303
      store_floating ((TO), REGISTER_RAW_SIZE (REGNUM), val); \
304
    } \
305
  else \
306
    memcpy ((TO), (FROM), REGISTER_RAW_SIZE (REGNUM)); \
307
}
308
 
309
/* Return the GDB type object for the "standard" data type
310
   of data in register N.  */
311
 
312
#define REGISTER_VIRTUAL_TYPE(N) \
313
 (((unsigned)(N) - FP0_REGNUM) < 32 ? builtin_type_double : builtin_type_int)
314
 
315
/* Store the address of the place in which to copy the structure the
316
   subroutine will return.  This is called from call_function. */
317
/* in RS6000, struct return addresses are passed as an extra parameter in r3.
318
   In function return, callee is not responsible of returning this address back.
319
   Since gdb needs to find it, we will store in a designated variable
320
   `rs6000_struct_return_address'. */
321
 
322
extern CORE_ADDR rs6000_struct_return_address;
323
 
324
#define STORE_STRUCT_RETURN(ADDR, SP)   \
325
  { write_register (3, (ADDR));         \
326
    rs6000_struct_return_address = (ADDR); }
327
 
328
/* Extract from an array REGBUF containing the (raw) register state
329
   a function return value of type TYPE, and copy that, in virtual format,
330
   into VALBUF.  */
331
 
332
/* #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
333
   memcpy (VALBUF, REGBUF, TYPE_LENGTH (TYPE)) */
334
 
335
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
336
  extract_return_value(TYPE,REGBUF,VALBUF)
337
extern void extract_return_value PARAMS ((struct type *, char[], char *));
338
 
339
/* Write into appropriate registers a function return value
340
   of type TYPE, given in virtual format.  */
341
 
342
#define STORE_RETURN_VALUE(TYPE,VALBUF) \
343
  {                                                                     \
344
    if (TYPE_CODE (TYPE) == TYPE_CODE_FLT)                              \
345
                                                                        \
346
     /* Floating point values are returned starting from FPR1 and up.   \
347
        Say a double_double_double type could be returned in            \
348
        FPR1/FPR2/FPR3 triple. */                                       \
349
                                                                        \
350
      write_register_bytes (REGISTER_BYTE (FP0_REGNUM+1), (VALBUF),     \
351
                                                TYPE_LENGTH (TYPE));    \
352
    else                                                                \
353
      /* Everything else is returned in GPR3 and up. */                 \
354
      write_register_bytes (REGISTER_BYTE (GP0_REGNUM+3), (VALBUF),     \
355
                                                TYPE_LENGTH (TYPE));    \
356
  }
357
 
358
 
359
/* Extract from an array REGBUF containing the (raw) register state
360
   the address in which a function should return its structure value,
361
   as a CORE_ADDR (or an expression that can be used as one).  */
362
 
363
#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF)    rs6000_struct_return_address
364
 
365
/* Describe the pointer in each stack frame to the previous stack frame
366
   (its caller).  */
367
 
368
/* FRAME_CHAIN takes a frame's nominal address
369
   and produces the frame's chain-pointer. */
370
 
371
/* In the case of the RS6000, the frame's nominal address
372
   is the address of a 4-byte word containing the calling frame's address.  */
373
 
374
#define FRAME_CHAIN(thisframe) rs6000_frame_chain (thisframe)
375
CORE_ADDR rs6000_frame_chain PARAMS ((struct frame_info *));
376
 
377
/* Define other aspects of the stack frame.  */
378
 
379
/* A macro that tells us whether the function invocation represented
380
   by FI does not have a frame on the stack associated with it.  If it
381
   does not, FRAMELESS is set to 1, else 0.  */
382
 
383
extern int rs6000_frameless_function_invocation (struct frame_info *);
384
#define FRAMELESS_FUNCTION_INVOCATION(FI) \
385
  (rs6000_frameless_function_invocation (FI))
386
 
387
#define INIT_FRAME_PC_FIRST(fromleaf, prev) \
388
  prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
389
              prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
390
#define INIT_FRAME_PC(fromleaf, prev)   /* nothing */
391
extern void rs6000_init_extra_frame_info (int fromleaf, struct frame_info *);
392
#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) rs6000_init_extra_frame_info (fromleaf, fi)
393
 
394
/* If the kernel has to deliver a signal, it pushes a sigcontext
395
   structure on the stack and then calls the signal handler, passing
396
   the address of the sigcontext in an argument register. Usually
397
   the signal handler doesn't save this register, so we have to
398
   access the sigcontext structure via an offset from the signal handler
399
   frame.
400
   The following constants were determined by experimentation on AIX 3.2.  */
401
#define SIG_FRAME_PC_OFFSET 96
402
#define SIG_FRAME_LR_OFFSET 108
403
#define SIG_FRAME_FP_OFFSET 284
404
 
405
/* Default offset from SP where the LR is stored */
406
#define DEFAULT_LR_SAVE 8
407
 
408
/* Return saved PC from a frame */
409
#define FRAME_SAVED_PC(FRAME)  rs6000_frame_saved_pc (FRAME)
410
 
411
extern unsigned long rs6000_frame_saved_pc (struct frame_info *);
412
 
413
extern CORE_ADDR rs6000_frame_args_address PARAMS ((struct frame_info *));
414
#define FRAME_ARGS_ADDRESS(FI) rs6000_frame_args_address (FI)
415
 
416
#define FRAME_LOCALS_ADDRESS(FI)        FRAME_ARGS_ADDRESS(FI)
417
 
418
 
419
/* Set VAL to the number of args passed to frame described by FI.
420
   Can set VAL to -1, meaning no way to tell.  */
421
 
422
/* We can't tell how many args there are
423
   now that the C compiler delays popping them.  */
424
 
425
#define FRAME_NUM_ARGS(fi) (-1)
426
 
427
/* Return number of bytes at start of arglist that are not really args.  */
428
 
429
#define FRAME_ARGS_SKIP 8       /* Not sure on this. FIXMEmgo */
430
 
431
/* Put here the code to store, into a struct frame_saved_regs,
432
   the addresses of the saved registers of frame described by FRAME_INFO.
433
   This includes special registers such as pc and fp saved in special
434
   ways in the stack frame.  sp is even more special:
435
   the address we return for it IS the sp for the next frame.  */
436
/* In the following implementation for RS6000, we did *not* save sp. I am
437
   not sure if it will be needed. The following macro takes care of gpr's
438
   and fpr's only. */
439
 
440
extern void rs6000_frame_init_saved_regs PARAMS ((struct frame_info *));
441
#define FRAME_INIT_SAVED_REGS(FI) rs6000_frame_init_saved_regs (FI)
442
 
443
/* Things needed for making the inferior call functions.  */
444
 
445
/* Push an empty stack frame, to record the current PC, etc.  */
446
/* Change these names into rs6k_{push, pop}_frame(). FIXMEmgo. */
447
 
448
#define PUSH_DUMMY_FRAME        push_dummy_frame ()
449
extern void push_dummy_frame PARAMS ((void));
450
 
451
/* Discard from the stack the innermost frame,
452
   restoring all saved registers.  */
453
 
454
#define POP_FRAME       pop_frame ()
455
extern void pop_frame PARAMS ((void));
456
 
457
/* This sequence of words is the instructions:
458
 
459
   mflr r0              // 0x7c0802a6
460
   // save fpr's
461
   stfd r?, num(r1)     // 0xd8010000 there should be 32 of this??
462
   // save gpr's
463
   stm  r0, num(r1)     // 0xbc010000
464
   stu  r1, num(r1)     // 0x94210000
465
 
466
   // the function we want to branch might be in a different load
467
   // segment. reset the toc register. Note that the actual toc address
468
   // will be fix by fix_call_dummy () along with function address.
469
 
470
   st   r2, 0x14(r1)    // 0x90410014 save toc register
471
   liu  r2, 0x1234      // 0x3c401234 reset a new toc value 0x12345678
472
   oril r2, r2,0x5678   // 0x60425678
473
 
474
   // load absolute address 0x12345678 to r0
475
   liu  r0, 0x1234      // 0x3c001234
476
   oril r0, r0,0x5678   // 0x60005678
477
   mtctr        r0              // 0x7c0903a6 ctr <- r0
478
   bctrl                        // 0x4e800421 jump subroutine 0x12345678 (%ctr)
479
   cror 0xf, 0xf, 0xf   // 0x4def7b82
480
   brpt                 // 0x7d821008, breakpoint
481
   cror 0xf, 0xf, 0xf   // 0x4def7b82 (for 8 byte alignment)
482
 
483
 
484
   We actually start executing by saving the toc register first, since the pushing
485
   of the registers is done by PUSH_DUMMY_FRAME.  If this were real code,
486
   the arguments for the function called by the `bctrl' would be pushed
487
   between the `stu' and the `bctrl', and we could allow it to execute through.
488
   But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
489
   and we cannot allow to push the registers again.
490
 */
491
 
492
#define CALL_DUMMY {0x7c0802a6, 0xd8010000, 0xbc010000, 0x94210000, \
493
                    0x90410014, 0x3c401234, 0x60425678,             \
494
                    0x3c001234, 0x60005678, 0x7c0903a6, 0x4e800421, \
495
                    0x4def7b82, 0x7d821008, 0x4def7b82 }
496
 
497
 
498
/* keep this as multiple of 8 (%sp requires 8 byte alignment) */
499
#define CALL_DUMMY_LENGTH 56
500
 
501
#define CALL_DUMMY_START_OFFSET 16
502
 
503
/* Insert the specified number of args and function address into a
504
   call sequence of the above form stored at DUMMYNAME.  */
505
 
506
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
507
  rs6000_fix_call_dummy (dummyname, pc, fun, nargs, args, type, gcc_p)
508
extern void rs6000_fix_call_dummy PARAMS ((char *, CORE_ADDR, CORE_ADDR,
509
                                           int, struct value **,
510
                                           struct type *, int));
511
 
512
/* Hook in rs6000-tdep.c for determining the TOC address when
513
   calling functions in the inferior.  */
514
extern
515
CORE_ADDR (*find_toc_address_hook) PARAMS ((CORE_ADDR));
516
 
517
/* xcoffread.c provides a function to determine the TOC offset
518
   for a given object file.
519
   It is used under native AIX configurations for determining the
520
   TOC address when calling functions in the inferior.  */
521
 
522
struct objfile;
523
extern CORE_ADDR get_toc_offset PARAMS ((struct objfile *));
524
 
525
/* Usually a function pointer's representation is simply the address
526
   of the function. On the RS/6000 however, a function pointer is
527
   represented by a pointer to a TOC entry. This TOC entry contains
528
   three words, the first word is the address of the function, the
529
   second word is the TOC pointer (r2), and the third word is the
530
   static chain value.  Throughout GDB it is currently assumed that a
531
   function pointer contains the address of the function, which is not
532
   easy to fix.  In addition, the conversion of a function address to
533
   a function pointer would require allocation of a TOC entry in the
534
   inferior's memory space, with all its drawbacks.  To be able to
535
   call C++ virtual methods in the inferior (which are called via
536
   function pointers), find_function_addr uses this macro to get the
537
   function address from a function pointer.  */
538
 
539
#define CONVERT_FROM_FUNC_PTR_ADDR(ADDR) \
540
  (is_magic_function_pointer (ADDR) ? read_memory_integer (ADDR, 4) : (ADDR))
541
     extern int is_magic_function_pointer PARAMS ((CORE_ADDR));
542
 
543
/* Flag for machine-specific stuff in shared files.  FIXME */
544
#define IBM6000_TARGET
545
 
546
/* RS6000/AIX does not support PT_STEP.  Has to be simulated.  */
547
 
548
#define SOFTWARE_SINGLE_STEP_P 1
549
     extern void rs6000_software_single_step PARAMS ((unsigned int, int));
550
#define SOFTWARE_SINGLE_STEP(sig,bp_p) rs6000_software_single_step (sig, bp_p)
551
 
552
/* If the current gcc for for this target does not produce correct debugging
553
   information for float parameters, both prototyped and unprototyped, then
554
   define this macro.  This forces gdb to  always assume that floats are
555
   passed as doubles and then converted in the callee.
556
 
557
   For the PowerPC, it appears that the debug info marks the parameters as
558
   floats regardless of whether the function is prototyped, but the actual
559
   values are always passed in as doubles.  Thus by setting this to 1, both
560
   types of calls will work. */
561
 
562
#define COERCE_FLOAT_TO_DOUBLE(formal, actual) (1)

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.