1 /* Intel 386 target-dependent stuff.
3 Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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. */
24 #include "gdb_string.h"
30 #include "floatformat.h"
35 #include "arch-utils.h"
39 #include "gdb_assert.h"
40 #include "reggroups.h"
41 #include "dummy-frame.h"
43 #include "i386-tdep.h"
44 #include "i387-tdep.h"
46 /* Names of the registers. The first 10 registers match the register
47 numbering scheme used by GCC for stabs and DWARF. */
48 static char *i386_register_names
[] =
50 "eax", "ecx", "edx", "ebx",
51 "esp", "ebp", "esi", "edi",
52 "eip", "eflags", "cs", "ss",
53 "ds", "es", "fs", "gs",
54 "st0", "st1", "st2", "st3",
55 "st4", "st5", "st6", "st7",
56 "fctrl", "fstat", "ftag", "fiseg",
57 "fioff", "foseg", "fooff", "fop",
58 "xmm0", "xmm1", "xmm2", "xmm3",
59 "xmm4", "xmm5", "xmm6", "xmm7",
65 static char *i386_mmx_names
[] =
67 "mm0", "mm1", "mm2", "mm3",
68 "mm4", "mm5", "mm6", "mm7"
70 static const int mmx_num_regs
= (sizeof (i386_mmx_names
)
71 / sizeof (i386_mmx_names
[0]));
72 #define MM0_REGNUM (NUM_REGS)
75 i386_mmx_regnum_p (int reg
)
77 return (reg
>= MM0_REGNUM
&& reg
< MM0_REGNUM
+ mmx_num_regs
);
83 i386_fp_regnum_p (int regnum
)
85 return (regnum
< NUM_REGS
86 && (FP0_REGNUM
&& FP0_REGNUM
<= (regnum
) && (regnum
) < FPC_REGNUM
));
90 i386_fpc_regnum_p (int regnum
)
92 return (regnum
< NUM_REGS
93 && (FPC_REGNUM
<= (regnum
) && (regnum
) < XMM0_REGNUM
));
99 i386_sse_regnum_p (int regnum
)
101 return (regnum
< NUM_REGS
102 && (XMM0_REGNUM
<= (regnum
) && (regnum
) < MXCSR_REGNUM
));
106 i386_mxcsr_regnum_p (int regnum
)
108 return (regnum
< NUM_REGS
109 && (regnum
== MXCSR_REGNUM
));
112 /* Return the name of register REG. */
115 i386_register_name (int reg
)
119 if (i386_mmx_regnum_p (reg
))
120 return i386_mmx_names
[reg
- MM0_REGNUM
];
121 if (reg
>= sizeof (i386_register_names
) / sizeof (*i386_register_names
))
124 return i386_register_names
[reg
];
127 /* Convert stabs register number REG to the appropriate register
128 number used by GDB. */
131 i386_stab_reg_to_regnum (int reg
)
133 /* This implements what GCC calls the "default" register map. */
134 if (reg
>= 0 && reg
<= 7)
136 /* General registers. */
139 else if (reg
>= 12 && reg
<= 19)
141 /* Floating-point registers. */
142 return reg
- 12 + FP0_REGNUM
;
144 else if (reg
>= 21 && reg
<= 28)
147 return reg
- 21 + XMM0_REGNUM
;
149 else if (reg
>= 29 && reg
<= 36)
152 return reg
- 29 + MM0_REGNUM
;
155 /* This will hopefully provoke a warning. */
156 return NUM_REGS
+ NUM_PSEUDO_REGS
;
159 /* Convert DWARF register number REG to the appropriate register
160 number used by GDB. */
163 i386_dwarf_reg_to_regnum (int reg
)
165 /* The DWARF register numbering includes %eip and %eflags, and
166 numbers the floating point registers differently. */
167 if (reg
>= 0 && reg
<= 9)
169 /* General registers. */
172 else if (reg
>= 11 && reg
<= 18)
174 /* Floating-point registers. */
175 return reg
- 11 + FP0_REGNUM
;
179 /* The SSE and MMX registers have identical numbers as in stabs. */
180 return i386_stab_reg_to_regnum (reg
);
183 /* This will hopefully provoke a warning. */
184 return NUM_REGS
+ NUM_PSEUDO_REGS
;
188 /* This is the variable that is set with "set disassembly-flavor", and
189 its legitimate values. */
190 static const char att_flavor
[] = "att";
191 static const char intel_flavor
[] = "intel";
192 static const char *valid_flavors
[] =
198 static const char *disassembly_flavor
= att_flavor
;
200 /* Stdio style buffering was used to minimize calls to ptrace, but
201 this buffering did not take into account that the code section
202 being accessed may not be an even number of buffers long (even if
203 the buffer is only sizeof(int) long). In cases where the code
204 section size happened to be a non-integral number of buffers long,
205 attempting to read the last buffer would fail. Simply using
206 target_read_memory and ignoring errors, rather than read_memory, is
207 not the correct solution, since legitimate access errors would then
208 be totally ignored. To properly handle this situation and continue
209 to use buffering would require that this code be able to determine
210 the minimum code section size granularity (not the alignment of the
211 section itself, since the actual failing case that pointed out this
212 problem had a section alignment of 4 but was not a multiple of 4
213 bytes long), on a target by target basis, and then adjust it's
214 buffer size accordingly. This is messy, but potentially feasible.
215 It probably needs the bfd library's help and support. For now, the
216 buffer size is set to 1. (FIXME -fnf) */
218 #define CODESTREAM_BUFSIZ 1 /* Was sizeof(int), see note above. */
219 static CORE_ADDR codestream_next_addr
;
220 static CORE_ADDR codestream_addr
;
221 static unsigned char codestream_buf
[CODESTREAM_BUFSIZ
];
222 static int codestream_off
;
223 static int codestream_cnt
;
225 #define codestream_tell() (codestream_addr + codestream_off)
226 #define codestream_peek() \
227 (codestream_cnt == 0 ? \
228 codestream_fill(1) : codestream_buf[codestream_off])
229 #define codestream_get() \
230 (codestream_cnt-- == 0 ? \
231 codestream_fill(0) : codestream_buf[codestream_off++])
234 codestream_fill (int peek_flag
)
236 codestream_addr
= codestream_next_addr
;
237 codestream_next_addr
+= CODESTREAM_BUFSIZ
;
239 codestream_cnt
= CODESTREAM_BUFSIZ
;
240 read_memory (codestream_addr
, (char *) codestream_buf
, CODESTREAM_BUFSIZ
);
243 return (codestream_peek ());
245 return (codestream_get ());
249 codestream_seek (CORE_ADDR place
)
251 codestream_next_addr
= place
/ CODESTREAM_BUFSIZ
;
252 codestream_next_addr
*= CODESTREAM_BUFSIZ
;
255 while (codestream_tell () != place
)
260 codestream_read (unsigned char *buf
, int count
)
265 for (i
= 0; i
< count
; i
++)
266 *p
++ = codestream_get ();
270 /* If the next instruction is a jump, move to its target. */
273 i386_follow_jump (void)
275 unsigned char buf
[4];
281 pos
= codestream_tell ();
284 if (codestream_peek () == 0x66)
290 switch (codestream_get ())
293 /* Relative jump: if data16 == 0, disp32, else disp16. */
296 codestream_read (buf
, 2);
297 delta
= extract_signed_integer (buf
, 2);
299 /* Include the size of the jmp instruction (including the
305 codestream_read (buf
, 4);
306 delta
= extract_signed_integer (buf
, 4);
312 /* Relative jump, disp8 (ignore data16). */
313 codestream_read (buf
, 1);
314 /* Sign-extend it. */
315 delta
= extract_signed_integer (buf
, 1);
320 codestream_seek (pos
);
323 /* Find & return the amount a local space allocated, and advance the
324 codestream to the first register push (if any).
326 If the entry sequence doesn't make sense, return -1, and leave
327 codestream pointer at a random spot. */
330 i386_get_frame_setup (CORE_ADDR pc
)
334 codestream_seek (pc
);
338 op
= codestream_get ();
340 if (op
== 0x58) /* popl %eax */
342 /* This function must start with
345 xchgl %eax, (%esp) 0x87 0x04 0x24
346 or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
348 (the System V compiler puts out the second `xchg'
349 instruction, and the assembler doesn't try to optimize it, so
350 the 'sib' form gets generated). This sequence is used to get
351 the address of the return buffer for a function that returns
354 unsigned char buf
[4];
355 static unsigned char proto1
[3] = { 0x87, 0x04, 0x24 };
356 static unsigned char proto2
[4] = { 0x87, 0x44, 0x24, 0x00 };
358 pos
= codestream_tell ();
359 codestream_read (buf
, 4);
360 if (memcmp (buf
, proto1
, 3) == 0)
362 else if (memcmp (buf
, proto2
, 4) == 0)
365 codestream_seek (pos
);
366 op
= codestream_get (); /* Update next opcode. */
369 if (op
== 0x68 || op
== 0x6a)
371 /* This function may start with
383 unsigned char buf
[8];
385 /* Skip past the `pushl' instruction; it has either a one-byte
386 or a four-byte operand, depending on the opcode. */
387 pos
= codestream_tell ();
392 codestream_seek (pos
);
394 /* Read the following 8 bytes, which should be "call _probe" (6
395 bytes) followed by "addl $4,%esp" (2 bytes). */
396 codestream_read (buf
, sizeof (buf
));
397 if (buf
[0] == 0xe8 && buf
[6] == 0xc4 && buf
[7] == 0x4)
399 codestream_seek (pos
);
400 op
= codestream_get (); /* Update next opcode. */
403 if (op
== 0x55) /* pushl %ebp */
405 /* Check for "movl %esp, %ebp" -- can be written in two ways. */
406 switch (codestream_get ())
409 if (codestream_get () != 0xec)
413 if (codestream_get () != 0xe5)
419 /* Check for stack adjustment
423 NOTE: You can't subtract a 16 bit immediate from a 32 bit
424 reg, so we don't have to worry about a data16 prefix. */
425 op
= codestream_peek ();
428 /* `subl' with 8 bit immediate. */
430 if (codestream_get () != 0xec)
431 /* Some instruction starting with 0x83 other than `subl'. */
433 codestream_seek (codestream_tell () - 2);
436 /* `subl' with signed byte immediate (though it wouldn't
437 make sense to be negative). */
438 return (codestream_get ());
443 /* Maybe it is `subl' with a 32 bit immedediate. */
445 if (codestream_get () != 0xec)
446 /* Some instruction starting with 0x81 other than `subl'. */
448 codestream_seek (codestream_tell () - 2);
451 /* It is `subl' with a 32 bit immediate. */
452 codestream_read ((unsigned char *) buf
, 4);
453 return extract_signed_integer (buf
, 4);
463 /* `enter' with 16 bit unsigned immediate. */
464 codestream_read ((unsigned char *) buf
, 2);
465 codestream_get (); /* Flush final byte of enter instruction. */
466 return extract_unsigned_integer (buf
, 2);
471 /* Signal trampolines don't have a meaningful frame. The frame
472 pointer value we use is actually the frame pointer of the calling
473 frame -- that is, the frame which was in progress when the signal
474 trampoline was entered. GDB mostly treats this frame pointer value
475 as a magic cookie. We detect the case of a signal trampoline by
476 testing for get_frame_type() == SIGTRAMP_FRAME, which is set based
479 When a signal trampoline is invoked from a frameless function, we
480 essentially have two frameless functions in a row. In this case,
481 we use the same magic cookie for three frames in a row. We detect
482 this case by seeing whether the next frame is a SIGTRAMP_FRAME,
483 and, if it does, checking whether the current frame is actually
484 frameless. In this case, we need to get the PC by looking at the
485 SP register value stored in the signal context.
487 This should work in most cases except in horrible situations where
488 a signal occurs just as we enter a function but before the frame
489 has been set up. Incidentally, that's just what happens when we
490 call a function from GDB with a signal pending (there's a test in
491 the testsuite that makes this happen). Therefore we pretend that
492 we have a frameless function if we're stopped at the start of a
495 /* Return non-zero if we're dealing with a frameless signal, that is,
496 a signal trampoline invoked from a frameless function. */
499 i386_frameless_signal_p (struct frame_info
*frame
)
501 return (frame
->next
&& get_frame_type (frame
->next
) == SIGTRAMP_FRAME
502 && (frameless_look_for_prologue (frame
)
503 || frame
->pc
== get_pc_function_start (frame
->pc
)));
506 /* Return the chain-pointer for FRAME. In the case of the i386, the
507 frame's nominal address is the address of a 4-byte word containing
508 the calling frame's address. */
511 i386_frame_chain (struct frame_info
*frame
)
513 if (pc_in_dummy_frame (frame
->pc
))
516 if (get_frame_type (frame
) == SIGTRAMP_FRAME
517 || i386_frameless_signal_p (frame
))
520 if (! inside_entry_file (frame
->pc
))
521 return read_memory_unsigned_integer (frame
->frame
, 4);
526 /* Determine whether the function invocation represented by FRAME does
527 not have a from on the stack associated with it. If it does not,
528 return non-zero, otherwise return zero. */
531 i386_frameless_function_invocation (struct frame_info
*frame
)
533 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
536 return frameless_look_for_prologue (frame
);
539 /* Assuming FRAME is for a sigtramp routine, return the saved program
543 i386_sigtramp_saved_pc (struct frame_info
*frame
)
545 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
548 addr
= tdep
->sigcontext_addr (frame
);
549 return read_memory_unsigned_integer (addr
+ tdep
->sc_pc_offset
, 4);
552 /* Assuming FRAME is for a sigtramp routine, return the saved stack
556 i386_sigtramp_saved_sp (struct frame_info
*frame
)
558 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
561 addr
= tdep
->sigcontext_addr (frame
);
562 return read_memory_unsigned_integer (addr
+ tdep
->sc_sp_offset
, 4);
565 /* Return the saved program counter for FRAME. */
568 i386_frame_saved_pc (struct frame_info
*frame
)
570 if (pc_in_dummy_frame (frame
->pc
))
574 frame_unwind_unsigned_register (frame
, PC_REGNUM
, &pc
);
578 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
579 return i386_sigtramp_saved_pc (frame
);
581 if (i386_frameless_signal_p (frame
))
583 CORE_ADDR sp
= i386_sigtramp_saved_sp (frame
->next
);
584 return read_memory_unsigned_integer (sp
, 4);
587 return read_memory_unsigned_integer (frame
->frame
+ 4, 4);
590 /* Immediately after a function call, return the saved pc. */
593 i386_saved_pc_after_call (struct frame_info
*frame
)
595 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
596 return i386_sigtramp_saved_pc (frame
);
598 return read_memory_unsigned_integer (read_register (SP_REGNUM
), 4);
601 /* Return number of args passed to a frame.
602 Can return -1, meaning no way to tell. */
605 i386_frame_num_args (struct frame_info
*fi
)
610 /* This loses because not only might the compiler not be popping the
611 args right after the function call, it might be popping args from
612 both this call and a previous one, and we would say there are
613 more args than there really are. */
617 struct frame_info
*pfi
;
619 /* On the i386, the instruction following the call could be:
621 addl $imm, %esp - imm/4 args; imm may be 8 or 32 bits
622 anything else - zero args. */
626 frameless
= FRAMELESS_FUNCTION_INVOCATION (fi
);
628 /* In the absence of a frame pointer, GDB doesn't get correct
629 values for nameless arguments. Return -1, so it doesn't print
630 any nameless arguments. */
633 pfi
= get_prev_frame (fi
);
636 /* NOTE: This can happen if we are looking at the frame for
637 main, because FRAME_CHAIN_VALID won't let us go into start.
638 If we have debugging symbols, that's not really a big deal;
639 it just means it will only show as many arguments to main as
646 op
= read_memory_integer (retpc
, 1);
647 if (op
== 0x59) /* pop %ecx */
651 op
= read_memory_integer (retpc
+ 1, 1);
653 /* addl $<signed imm 8 bits>, %esp */
654 return (read_memory_integer (retpc
+ 2, 1) & 0xff) / 4;
658 else if (op
== 0x81) /* `add' with 32 bit immediate. */
660 op
= read_memory_integer (retpc
+ 1, 1);
662 /* addl $<imm 32>, %esp */
663 return read_memory_integer (retpc
+ 2, 4) / 4;
675 /* Parse the first few instructions the function to see what registers
678 We handle these cases:
680 The startup sequence can be at the start of the function, or the
681 function can start with a branch to startup code at the end.
683 %ebp can be set up with either the 'enter' instruction, or "pushl
684 %ebp, movl %esp, %ebp" (`enter' is too slow to be useful, but was
685 once used in the System V compiler).
687 Local space is allocated just below the saved %ebp by either the
688 'enter' instruction, or by "subl $<size>, %esp". 'enter' has a 16
689 bit unsigned argument for space to allocate, and the 'addl'
690 instruction could have either a signed byte, or 32 bit immediate.
692 Next, the registers used by this function are pushed. With the
693 System V compiler they will always be in the order: %edi, %esi,
694 %ebx (and sometimes a harmless bug causes it to also save but not
695 restore %eax); however, the code below is willing to see the pushes
696 in any order, and will handle up to 8 of them.
698 If the setup sequence is at the end of the function, then the next
699 instruction will be a branch back to the start. */
702 i386_frame_init_saved_regs (struct frame_info
*fip
)
713 frame_saved_regs_zalloc (fip
);
715 pc
= get_pc_function_start (fip
->pc
);
717 locals
= i386_get_frame_setup (pc
);
721 addr
= fip
->frame
- 4 - locals
;
722 for (i
= 0; i
< 8; i
++)
724 op
= codestream_get ();
725 if (op
< 0x50 || op
> 0x57)
727 #ifdef I386_REGNO_TO_SYMMETRY
728 /* Dynix uses different internal numbering. Ick. */
729 fip
->saved_regs
[I386_REGNO_TO_SYMMETRY (op
- 0x50)] = addr
;
731 fip
->saved_regs
[op
- 0x50] = addr
;
737 fip
->saved_regs
[PC_REGNUM
] = fip
->frame
+ 4;
738 fip
->saved_regs
[FP_REGNUM
] = fip
->frame
;
741 /* Return PC of first real instruction. */
744 i386_skip_prologue (CORE_ADDR pc
)
748 static unsigned char pic_pat
[6] =
749 { 0xe8, 0, 0, 0, 0, /* call 0x0 */
750 0x5b, /* popl %ebx */
754 if (i386_get_frame_setup (pc
) < 0)
757 /* Found valid frame setup -- codestream now points to start of push
758 instructions for saving registers. */
760 /* Skip over register saves. */
761 for (i
= 0; i
< 8; i
++)
763 op
= codestream_peek ();
764 /* Break if not `pushl' instrunction. */
765 if (op
< 0x50 || op
> 0x57)
770 /* The native cc on SVR4 in -K PIC mode inserts the following code
771 to get the address of the global offset table (GOT) into register
776 movl %ebx,x(%ebp) (optional)
779 This code is with the rest of the prologue (at the end of the
780 function), so we have to skip it to get to the first real
781 instruction at the start of the function. */
783 pos
= codestream_tell ();
784 for (i
= 0; i
< 6; i
++)
786 op
= codestream_get ();
787 if (pic_pat
[i
] != op
)
792 unsigned char buf
[4];
795 op
= codestream_get ();
796 if (op
== 0x89) /* movl %ebx, x(%ebp) */
798 op
= codestream_get ();
799 if (op
== 0x5d) /* One byte offset from %ebp. */
802 codestream_read (buf
, 1);
804 else if (op
== 0x9d) /* Four byte offset from %ebp. */
807 codestream_read (buf
, 4);
809 else /* Unexpected instruction. */
811 op
= codestream_get ();
814 if (delta
> 0 && op
== 0x81 && codestream_get () == 0xc3)
819 codestream_seek (pos
);
823 return (codestream_tell ());
826 /* Use the program counter to determine the contents and size of a
827 breakpoint instruction. Return a pointer to a string of bytes that
828 encode a breakpoint instruction, store the length of the string in
829 *LEN and optionally adjust *PC to point to the correct memory
830 location for inserting the breakpoint.
832 On the i386 we have a single breakpoint that fits in a single byte
833 and can be inserted anywhere. */
835 static const unsigned char *
836 i386_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
838 static unsigned char break_insn
[] = { 0xcc }; /* int 3 */
840 *len
= sizeof (break_insn
);
844 /* Push the return address (pointing to the call dummy) onto the stack
845 and return the new value for the stack pointer. */
848 i386_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
852 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
853 write_memory (sp
- 4, buf
, 4);
858 i386_do_pop_frame (struct frame_info
*frame
)
862 char regbuf
[I386_MAX_REGISTER_SIZE
];
864 fp
= get_frame_base (frame
);
865 i386_frame_init_saved_regs (frame
);
867 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
870 addr
= frame
->saved_regs
[regnum
];
873 read_memory (addr
, regbuf
, REGISTER_RAW_SIZE (regnum
));
874 deprecated_write_register_gen (regnum
, regbuf
);
877 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
878 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
879 write_register (SP_REGNUM
, fp
+ 8);
880 flush_cached_frames ();
884 i386_pop_frame (void)
886 generic_pop_current_frame (i386_do_pop_frame
);
890 /* Figure out where the longjmp will land. Slurp the args out of the
891 stack. We expect the first arg to be a pointer to the jmp_buf
892 structure from which we extract the address that we will land at.
893 This address is copied into PC. This routine returns true on
897 i386_get_longjmp_target (CORE_ADDR
*pc
)
900 CORE_ADDR sp
, jb_addr
;
901 int jb_pc_offset
= gdbarch_tdep (current_gdbarch
)->jb_pc_offset
;
903 /* If JB_PC_OFFSET is -1, we have no way to find out where the
904 longjmp will land. */
905 if (jb_pc_offset
== -1)
908 sp
= read_register (SP_REGNUM
);
909 if (target_read_memory (sp
+ 4, buf
, 4))
912 jb_addr
= extract_address (buf
, 4);
913 if (target_read_memory (jb_addr
+ jb_pc_offset
, buf
, 4))
916 *pc
= extract_address (buf
, 4);
922 i386_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
923 int struct_return
, CORE_ADDR struct_addr
)
925 sp
= default_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
932 store_address (buf
, 4, struct_addr
);
933 write_memory (sp
, buf
, 4);
940 i386_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
942 /* Do nothing. Everything was already done by i386_push_arguments. */
945 /* These registers are used for returning integers (and on some
946 targets also for returning `struct' and `union' values when their
947 size and alignment match an integer type). */
948 #define LOW_RETURN_REGNUM 0 /* %eax */
949 #define HIGH_RETURN_REGNUM 2 /* %edx */
951 /* Extract from an array REGBUF containing the (raw) register state, a
952 function return value of TYPE, and copy that, in virtual format,
956 i386_extract_return_value (struct type
*type
, struct regcache
*regcache
,
959 bfd_byte
*valbuf
= dst
;
960 int len
= TYPE_LENGTH (type
);
961 char buf
[I386_MAX_REGISTER_SIZE
];
963 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
964 && TYPE_NFIELDS (type
) == 1)
966 i386_extract_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
970 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
974 warning ("Cannot find floating-point return value.");
975 memset (valbuf
, 0, len
);
979 /* Floating-point return values can be found in %st(0). Convert
980 its contents to the desired type. This is probably not
981 exactly how it would happen on the target itself, but it is
982 the best we can do. */
983 regcache_raw_read (regcache
, FP0_REGNUM
, buf
);
984 convert_typed_floating (buf
, builtin_type_i387_ext
, valbuf
, type
);
988 int low_size
= REGISTER_RAW_SIZE (LOW_RETURN_REGNUM
);
989 int high_size
= REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM
);
993 regcache_raw_read (regcache
, LOW_RETURN_REGNUM
, buf
);
994 memcpy (valbuf
, buf
, len
);
996 else if (len
<= (low_size
+ high_size
))
998 regcache_raw_read (regcache
, LOW_RETURN_REGNUM
, buf
);
999 memcpy (valbuf
, buf
, low_size
);
1000 regcache_raw_read (regcache
, HIGH_RETURN_REGNUM
, buf
);
1001 memcpy (valbuf
+ low_size
, buf
, len
- low_size
);
1004 internal_error (__FILE__
, __LINE__
,
1005 "Cannot extract return value of %d bytes long.", len
);
1009 /* Write into the appropriate registers a function return value stored
1010 in VALBUF of type TYPE, given in virtual format. */
1013 i386_store_return_value (struct type
*type
, struct regcache
*regcache
,
1016 int len
= TYPE_LENGTH (type
);
1018 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1019 && TYPE_NFIELDS (type
) == 1)
1021 i386_store_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
1025 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1028 char buf
[FPU_REG_RAW_SIZE
];
1030 if (FP0_REGNUM
== 0)
1032 warning ("Cannot set floating-point return value.");
1036 /* Returning floating-point values is a bit tricky. Apart from
1037 storing the return value in %st(0), we have to simulate the
1038 state of the FPU at function return point. */
1040 /* Convert the value found in VALBUF to the extended
1041 floating-point format used by the FPU. This is probably
1042 not exactly how it would happen on the target itself, but
1043 it is the best we can do. */
1044 convert_typed_floating (valbuf
, type
, buf
, builtin_type_i387_ext
);
1045 regcache_raw_write (regcache
, FP0_REGNUM
, buf
);
1047 /* Set the top of the floating-point register stack to 7. The
1048 actual value doesn't really matter, but 7 is what a normal
1049 function return would end up with if the program started out
1050 with a freshly initialized FPU. */
1051 regcache_raw_read_unsigned (regcache
, FSTAT_REGNUM
, &fstat
);
1053 regcache_raw_write_unsigned (regcache
, FSTAT_REGNUM
, fstat
);
1055 /* Mark %st(1) through %st(7) as empty. Since we set the top of
1056 the floating-point register stack to 7, the appropriate value
1057 for the tag word is 0x3fff. */
1058 regcache_raw_write_unsigned (regcache
, FTAG_REGNUM
, 0x3fff);
1062 int low_size
= REGISTER_RAW_SIZE (LOW_RETURN_REGNUM
);
1063 int high_size
= REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM
);
1065 if (len
<= low_size
)
1066 regcache_raw_write_part (regcache
, LOW_RETURN_REGNUM
, 0, len
, valbuf
);
1067 else if (len
<= (low_size
+ high_size
))
1069 regcache_raw_write (regcache
, LOW_RETURN_REGNUM
, valbuf
);
1070 regcache_raw_write_part (regcache
, HIGH_RETURN_REGNUM
, 0,
1071 len
- low_size
, (char *) valbuf
+ low_size
);
1074 internal_error (__FILE__
, __LINE__
,
1075 "Cannot store return value of %d bytes long.", len
);
1079 /* Extract from REGCACHE, which contains the (raw) register state, the
1080 address in which a function should return its structure value, as a
1084 i386_extract_struct_value_address (struct regcache
*regcache
)
1088 regcache_raw_read_unsigned (regcache
, LOW_RETURN_REGNUM
, &addr
);
1093 /* This is the variable that is set with "set struct-convention", and
1094 its legitimate values. */
1095 static const char default_struct_convention
[] = "default";
1096 static const char pcc_struct_convention
[] = "pcc";
1097 static const char reg_struct_convention
[] = "reg";
1098 static const char *valid_conventions
[] =
1100 default_struct_convention
,
1101 pcc_struct_convention
,
1102 reg_struct_convention
,
1105 static const char *struct_convention
= default_struct_convention
;
1108 i386_use_struct_convention (int gcc_p
, struct type
*type
)
1110 enum struct_return struct_return
;
1112 if (struct_convention
== default_struct_convention
)
1113 struct_return
= gdbarch_tdep (current_gdbarch
)->struct_return
;
1114 else if (struct_convention
== pcc_struct_convention
)
1115 struct_return
= pcc_struct_return
;
1117 struct_return
= reg_struct_return
;
1119 return generic_use_struct_convention (struct_return
== reg_struct_return
,
1124 /* Return the GDB type object for the "standard" data type of data in
1125 register REGNUM. Perhaps %esi and %edi should go here, but
1126 potentially they could be used for things other than address. */
1128 static struct type
*
1129 i386_register_virtual_type (int regnum
)
1131 if (regnum
== PC_REGNUM
|| regnum
== FP_REGNUM
|| regnum
== SP_REGNUM
)
1132 return lookup_pointer_type (builtin_type_void
);
1134 if (i386_fp_regnum_p (regnum
))
1135 return builtin_type_i387_ext
;
1137 if (i386_sse_regnum_p (regnum
))
1138 return builtin_type_vec128i
;
1140 if (i386_mmx_regnum_p (regnum
))
1141 return builtin_type_vec64i
;
1143 return builtin_type_int
;
1146 /* Map a cooked register onto a raw register or memory. For the i386,
1147 the MMX registers need to be mapped onto floating point registers. */
1150 mmx_regnum_to_fp_regnum (struct regcache
*regcache
, int regnum
)
1156 mmxi
= regnum
- MM0_REGNUM
;
1157 regcache_raw_read_unsigned (regcache
, FSTAT_REGNUM
, &fstat
);
1158 tos
= (fstat
>> 11) & 0x7;
1159 fpi
= (mmxi
+ tos
) % 8;
1160 return (FP0_REGNUM
+ fpi
);
1164 i386_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1165 int regnum
, void *buf
)
1167 if (i386_mmx_regnum_p (regnum
))
1169 char *mmx_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1170 int fpnum
= mmx_regnum_to_fp_regnum (regcache
, regnum
);
1171 regcache_raw_read (regcache
, fpnum
, mmx_buf
);
1172 /* Extract (always little endian). */
1173 memcpy (buf
, mmx_buf
, REGISTER_RAW_SIZE (regnum
));
1176 regcache_raw_read (regcache
, regnum
, buf
);
1180 i386_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1181 int regnum
, const void *buf
)
1183 if (i386_mmx_regnum_p (regnum
))
1185 char *mmx_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1186 int fpnum
= mmx_regnum_to_fp_regnum (regcache
, regnum
);
1188 regcache_raw_read (regcache
, fpnum
, mmx_buf
);
1189 /* ... Modify ... (always little endian). */
1190 memcpy (mmx_buf
, buf
, REGISTER_RAW_SIZE (regnum
));
1192 regcache_raw_write (regcache
, fpnum
, mmx_buf
);
1195 regcache_raw_write (regcache
, regnum
, buf
);
1198 /* Return true iff register REGNUM's virtual format is different from
1199 its raw format. Note that this definition assumes that the host
1200 supports IEEE 32-bit floats, since it doesn't say that SSE
1201 registers need conversion. Even if we can't find a counterexample,
1202 this is still sloppy. */
1205 i386_register_convertible (int regnum
)
1207 return i386_fp_regnum_p (regnum
);
1210 /* Convert data from raw format for register REGNUM in buffer FROM to
1211 virtual format with type TYPE in buffer TO. */
1214 i386_register_convert_to_virtual (int regnum
, struct type
*type
,
1215 char *from
, char *to
)
1217 gdb_assert (i386_fp_regnum_p (regnum
));
1219 /* We only support floating-point values. */
1220 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1222 warning ("Cannot convert floating-point register value "
1223 "to non-floating-point type.");
1224 memset (to
, 0, TYPE_LENGTH (type
));
1228 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
1229 the extended floating-point format used by the FPU. */
1230 convert_typed_floating (from
, builtin_type_i387_ext
, to
, type
);
1233 /* Convert data from virtual format with type TYPE in buffer FROM to
1234 raw format for register REGNUM in buffer TO. */
1237 i386_register_convert_to_raw (struct type
*type
, int regnum
,
1238 char *from
, char *to
)
1240 gdb_assert (i386_fp_regnum_p (regnum
));
1242 /* We only support floating-point values. */
1243 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1245 warning ("Cannot convert non-floating-point type "
1246 "to floating-point register value.");
1247 memset (to
, 0, TYPE_LENGTH (type
));
1251 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
1252 to the extended floating-point format used by the FPU. */
1253 convert_typed_floating (from
, type
, to
, builtin_type_i387_ext
);
1257 #ifdef STATIC_TRANSFORM_NAME
1258 /* SunPRO encodes the static variables. This is not related to C++
1259 mangling, it is done for C too. */
1262 sunpro_static_transform_name (char *name
)
1265 if (IS_STATIC_TRANSFORM_NAME (name
))
1267 /* For file-local statics there will be a period, a bunch of
1268 junk (the contents of which match a string given in the
1269 N_OPT), a period and the name. For function-local statics
1270 there will be a bunch of junk (which seems to change the
1271 second character from 'A' to 'B'), a period, the name of the
1272 function, and the name. So just skip everything before the
1274 p
= strrchr (name
, '.');
1280 #endif /* STATIC_TRANSFORM_NAME */
1283 /* Stuff for WIN32 PE style DLL's but is pretty generic really. */
1286 i386_pe_skip_trampoline_code (CORE_ADDR pc
, char *name
)
1288 if (pc
&& read_memory_unsigned_integer (pc
, 2) == 0x25ff) /* jmp *(dest) */
1290 unsigned long indirect
= read_memory_unsigned_integer (pc
+ 2, 4);
1291 struct minimal_symbol
*indsym
=
1292 indirect
? lookup_minimal_symbol_by_pc (indirect
) : 0;
1293 char *symname
= indsym
? SYMBOL_NAME (indsym
) : 0;
1297 if (strncmp (symname
, "__imp_", 6) == 0
1298 || strncmp (symname
, "_imp_", 5) == 0)
1299 return name
? 1 : read_memory_unsigned_integer (indirect
, 4);
1302 return 0; /* Not a trampoline. */
1306 /* Return non-zero if PC and NAME show that we are in a signal
1310 i386_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1312 return (name
&& strcmp ("_sigtramp", name
) == 0);
1316 /* We have two flavours of disassembly. The machinery on this page
1317 deals with switching between those. */
1320 i386_print_insn (bfd_vma pc
, disassemble_info
*info
)
1322 gdb_assert (disassembly_flavor
== att_flavor
1323 || disassembly_flavor
== intel_flavor
);
1325 /* FIXME: kettenis/20020915: Until disassembler_options is properly
1326 constified, cast to prevent a compiler warning. */
1327 info
->disassembler_options
= (char *) disassembly_flavor
;
1328 info
->mach
= gdbarch_bfd_arch_info (current_gdbarch
)->mach
;
1330 return print_insn_i386 (pc
, info
);
1334 /* There are a few i386 architecture variants that differ only
1335 slightly from the generic i386 target. For now, we don't give them
1336 their own source file, but include them here. As a consequence,
1337 they'll always be included. */
1339 /* System V Release 4 (SVR4). */
1342 i386_svr4_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1344 return (name
&& (strcmp ("_sigreturn", name
) == 0
1345 || strcmp ("_sigacthandler", name
) == 0
1346 || strcmp ("sigvechandler", name
) == 0));
1349 /* Get address of the pushed ucontext (sigcontext) on the stack for
1350 all three variants of SVR4 sigtramps. */
1353 i386_svr4_sigcontext_addr (struct frame_info
*frame
)
1355 int sigcontext_offset
= -1;
1358 find_pc_partial_function (frame
->pc
, &name
, NULL
, NULL
);
1361 if (strcmp (name
, "_sigreturn") == 0)
1362 sigcontext_offset
= 132;
1363 else if (strcmp (name
, "_sigacthandler") == 0)
1364 sigcontext_offset
= 80;
1365 else if (strcmp (name
, "sigvechandler") == 0)
1366 sigcontext_offset
= 120;
1369 gdb_assert (sigcontext_offset
!= -1);
1372 return frame
->next
->frame
+ sigcontext_offset
;
1373 return read_register (SP_REGNUM
) + sigcontext_offset
;
1380 i386_go32_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1382 /* DJGPP doesn't have any special frames for signal handlers. */
1390 i386_elf_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1392 /* We typically use stabs-in-ELF with the DWARF register numbering. */
1393 set_gdbarch_stab_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1396 /* System V Release 4 (SVR4). */
1399 i386_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1401 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1403 /* System V Release 4 uses ELF. */
1404 i386_elf_init_abi (info
, gdbarch
);
1406 /* System V Release 4 has shared libraries. */
1407 set_gdbarch_in_solib_call_trampoline (gdbarch
, in_plt_section
);
1408 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1410 /* FIXME: kettenis/20020511: Why do we override this function here? */
1411 set_gdbarch_frame_chain_valid (gdbarch
, generic_func_frame_chain_valid
);
1413 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_svr4_pc_in_sigtramp
);
1414 tdep
->sigcontext_addr
= i386_svr4_sigcontext_addr
;
1415 tdep
->sc_pc_offset
= 14 * 4;
1416 tdep
->sc_sp_offset
= 7 * 4;
1418 tdep
->jb_pc_offset
= 20;
1424 i386_go32_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1426 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1428 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_go32_pc_in_sigtramp
);
1430 tdep
->jb_pc_offset
= 36;
1436 i386_nw_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1438 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1440 /* FIXME: kettenis/20020511: Why do we override this function here? */
1441 set_gdbarch_frame_chain_valid (gdbarch
, generic_func_frame_chain_valid
);
1443 tdep
->jb_pc_offset
= 24;
1447 /* i386 register groups. In addition to the normal groups, add "mmx"
1450 static struct reggroup
*i386_sse_reggroup
;
1451 static struct reggroup
*i386_mmx_reggroup
;
1454 i386_init_reggroups (void)
1456 i386_sse_reggroup
= reggroup_new ("sse", USER_REGGROUP
);
1457 i386_mmx_reggroup
= reggroup_new ("mmx", USER_REGGROUP
);
1461 i386_add_reggroups (struct gdbarch
*gdbarch
)
1463 reggroup_add (gdbarch
, i386_sse_reggroup
);
1464 reggroup_add (gdbarch
, i386_mmx_reggroup
);
1465 reggroup_add (gdbarch
, general_reggroup
);
1466 reggroup_add (gdbarch
, float_reggroup
);
1467 reggroup_add (gdbarch
, all_reggroup
);
1468 reggroup_add (gdbarch
, save_reggroup
);
1469 reggroup_add (gdbarch
, restore_reggroup
);
1470 reggroup_add (gdbarch
, vector_reggroup
);
1471 reggroup_add (gdbarch
, system_reggroup
);
1475 i386_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
1476 struct reggroup
*group
)
1478 int sse_regnum_p
= (i386_sse_regnum_p (regnum
)
1479 || i386_mxcsr_regnum_p (regnum
));
1480 int fp_regnum_p
= (i386_fp_regnum_p (regnum
)
1481 || i386_fpc_regnum_p (regnum
));
1482 int mmx_regnum_p
= (i386_mmx_regnum_p (regnum
));
1483 if (group
== i386_mmx_reggroup
)
1484 return mmx_regnum_p
;
1485 if (group
== i386_sse_reggroup
)
1486 return sse_regnum_p
;
1487 if (group
== vector_reggroup
)
1488 return (mmx_regnum_p
|| sse_regnum_p
);
1489 if (group
== float_reggroup
)
1491 if (group
== general_reggroup
)
1492 return (!fp_regnum_p
&& !mmx_regnum_p
&& !sse_regnum_p
);
1493 return default_register_reggroup_p (gdbarch
, regnum
, group
);
1497 static struct gdbarch
*
1498 i386_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1500 struct gdbarch_tdep
*tdep
;
1501 struct gdbarch
*gdbarch
;
1502 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
1504 /* Try to determine the OS ABI of the object we're loading. */
1505 if (info
.abfd
!= NULL
)
1506 osabi
= gdbarch_lookup_osabi (info
.abfd
);
1508 /* Find a candidate among extant architectures. */
1509 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1511 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
1513 /* Make sure the OS ABI selection matches. */
1514 tdep
= gdbarch_tdep (arches
->gdbarch
);
1515 if (tdep
&& tdep
->osabi
== osabi
)
1516 return arches
->gdbarch
;
1519 /* Allocate space for the new architecture. */
1520 tdep
= XMALLOC (struct gdbarch_tdep
);
1521 gdbarch
= gdbarch_alloc (&info
, tdep
);
1523 /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1524 ready to unwind the PC first (see frame.c:get_prev_frame()). */
1525 set_gdbarch_deprecated_init_frame_pc (gdbarch
, init_frame_pc_default
);
1527 tdep
->osabi
= osabi
;
1529 /* The i386 default settings don't include the SSE registers.
1530 FIXME: kettenis/20020614: They do include the FPU registers for
1531 now, which probably is not quite right. */
1532 tdep
->num_xmm_regs
= 0;
1534 tdep
->jb_pc_offset
= -1;
1535 tdep
->struct_return
= pcc_struct_return
;
1536 tdep
->sigtramp_start
= 0;
1537 tdep
->sigtramp_end
= 0;
1538 tdep
->sigcontext_addr
= NULL
;
1539 tdep
->sc_pc_offset
= -1;
1540 tdep
->sc_sp_offset
= -1;
1542 /* The format used for `long double' on almost all i386 targets is
1543 the i387 extended floating-point format. In fact, of all targets
1544 in the GCC 2.95 tree, only OSF/1 does it different, and insists
1545 on having a `long double' that's not `long' at all. */
1546 set_gdbarch_long_double_format (gdbarch
, &floatformat_i387_ext
);
1548 /* Although the i387 extended floating-point has only 80 significant
1549 bits, a `long double' actually takes up 96, probably to enforce
1551 set_gdbarch_long_double_bit (gdbarch
, 96);
1553 /* NOTE: tm-i386aix.h, tm-i386bsd.h, tm-i386os9k.h, tm-ptx.h,
1554 tm-symmetry.h currently override this. Sigh. */
1555 set_gdbarch_num_regs (gdbarch
, I386_NUM_GREGS
+ I386_NUM_FREGS
);
1557 set_gdbarch_sp_regnum (gdbarch
, 4); /* %esp */
1558 set_gdbarch_fp_regnum (gdbarch
, 5); /* %ebp */
1559 set_gdbarch_pc_regnum (gdbarch
, 8); /* %eip */
1560 set_gdbarch_ps_regnum (gdbarch
, 9); /* %eflags */
1561 set_gdbarch_fp0_regnum (gdbarch
, 16); /* %st(0) */
1563 /* Use the "default" register numbering scheme for stabs and COFF. */
1564 set_gdbarch_stab_reg_to_regnum (gdbarch
, i386_stab_reg_to_regnum
);
1565 set_gdbarch_sdb_reg_to_regnum (gdbarch
, i386_stab_reg_to_regnum
);
1567 /* Use the DWARF register numbering scheme for DWARF and DWARF 2. */
1568 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1569 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1571 /* We don't define ECOFF_REG_TO_REGNUM, since ECOFF doesn't seem to
1572 be in use on any of the supported i386 targets. */
1574 set_gdbarch_register_name (gdbarch
, i386_register_name
);
1575 set_gdbarch_register_size (gdbarch
, 4);
1576 set_gdbarch_register_bytes (gdbarch
, I386_SIZEOF_GREGS
+ I386_SIZEOF_FREGS
);
1577 set_gdbarch_max_register_raw_size (gdbarch
, I386_MAX_REGISTER_SIZE
);
1578 set_gdbarch_max_register_virtual_size (gdbarch
, I386_MAX_REGISTER_SIZE
);
1579 set_gdbarch_register_virtual_type (gdbarch
, i386_register_virtual_type
);
1581 set_gdbarch_print_float_info (gdbarch
, i387_print_float_info
);
1583 set_gdbarch_get_longjmp_target (gdbarch
, i386_get_longjmp_target
);
1585 /* Call dummy code. */
1586 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1587 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1588 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1589 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1590 set_gdbarch_call_dummy_length (gdbarch
, 0);
1591 set_gdbarch_call_dummy_p (gdbarch
, 1);
1592 set_gdbarch_call_dummy_words (gdbarch
, NULL
);
1593 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
1594 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1595 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1597 set_gdbarch_register_convertible (gdbarch
, i386_register_convertible
);
1598 set_gdbarch_register_convert_to_virtual (gdbarch
,
1599 i386_register_convert_to_virtual
);
1600 set_gdbarch_register_convert_to_raw (gdbarch
, i386_register_convert_to_raw
);
1602 /* "An argument's size is increased, if necessary, to make it a
1603 multiple of [32-bit] words. This may require tail padding,
1604 depending on the size of the argument" -- from the x86 ABI. */
1605 set_gdbarch_parm_boundary (gdbarch
, 32);
1607 set_gdbarch_extract_return_value (gdbarch
, i386_extract_return_value
);
1608 set_gdbarch_push_arguments (gdbarch
, i386_push_arguments
);
1609 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1610 set_gdbarch_push_return_address (gdbarch
, i386_push_return_address
);
1611 set_gdbarch_pop_frame (gdbarch
, i386_pop_frame
);
1612 set_gdbarch_store_struct_return (gdbarch
, i386_store_struct_return
);
1613 set_gdbarch_store_return_value (gdbarch
, i386_store_return_value
);
1614 set_gdbarch_extract_struct_value_address (gdbarch
,
1615 i386_extract_struct_value_address
);
1616 set_gdbarch_use_struct_convention (gdbarch
, i386_use_struct_convention
);
1618 set_gdbarch_frame_init_saved_regs (gdbarch
, i386_frame_init_saved_regs
);
1619 set_gdbarch_skip_prologue (gdbarch
, i386_skip_prologue
);
1621 /* Stack grows downward. */
1622 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1624 set_gdbarch_breakpoint_from_pc (gdbarch
, i386_breakpoint_from_pc
);
1625 set_gdbarch_decr_pc_after_break (gdbarch
, 1);
1626 set_gdbarch_function_start_offset (gdbarch
, 0);
1628 /* The following redefines make backtracing through sigtramp work.
1629 They manufacture a fake sigtramp frame and obtain the saved pc in
1630 sigtramp from the sigcontext structure which is pushed by the
1631 kernel on the user stack, along with a pointer to it. */
1633 set_gdbarch_frame_args_skip (gdbarch
, 8);
1634 set_gdbarch_frameless_function_invocation (gdbarch
,
1635 i386_frameless_function_invocation
);
1636 set_gdbarch_frame_chain (gdbarch
, i386_frame_chain
);
1637 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1638 set_gdbarch_frame_saved_pc (gdbarch
, i386_frame_saved_pc
);
1639 set_gdbarch_saved_pc_after_call (gdbarch
, i386_saved_pc_after_call
);
1640 set_gdbarch_frame_num_args (gdbarch
, i386_frame_num_args
);
1641 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_pc_in_sigtramp
);
1643 /* Wire in the MMX registers. */
1644 set_gdbarch_num_pseudo_regs (gdbarch
, mmx_num_regs
);
1645 set_gdbarch_pseudo_register_read (gdbarch
, i386_pseudo_register_read
);
1646 set_gdbarch_pseudo_register_write (gdbarch
, i386_pseudo_register_write
);
1648 set_gdbarch_print_insn (gdbarch
, i386_print_insn
);
1650 /* Add the i386 register groups. */
1651 i386_add_reggroups (gdbarch
);
1652 set_gdbarch_register_reggroup_p (gdbarch
, i386_register_reggroup_p
);
1654 /* Hook in ABI-specific overrides, if they have been registered. */
1655 gdbarch_init_osabi (info
, gdbarch
, osabi
);
1660 static enum gdb_osabi
1661 i386_coff_osabi_sniffer (bfd
*abfd
)
1663 if (strcmp (bfd_get_target (abfd
), "coff-go32-exe") == 0
1664 || strcmp (bfd_get_target (abfd
), "coff-go32") == 0)
1665 return GDB_OSABI_GO32
;
1667 return GDB_OSABI_UNKNOWN
;
1670 static enum gdb_osabi
1671 i386_nlm_osabi_sniffer (bfd
*abfd
)
1673 return GDB_OSABI_NETWARE
;
1677 /* Provide a prototype to silence -Wmissing-prototypes. */
1678 void _initialize_i386_tdep (void);
1681 _initialize_i386_tdep (void)
1683 register_gdbarch_init (bfd_arch_i386
, i386_gdbarch_init
);
1685 /* Add the variable that controls the disassembly flavor. */
1687 struct cmd_list_element
*new_cmd
;
1689 new_cmd
= add_set_enum_cmd ("disassembly-flavor", no_class
,
1691 &disassembly_flavor
,
1693 Set the disassembly flavor, the valid values are \"att\" and \"intel\", \
1694 and the default value is \"att\".",
1696 add_show_from_set (new_cmd
, &showlist
);
1699 /* Add the variable that controls the convention for returning
1702 struct cmd_list_element
*new_cmd
;
1704 new_cmd
= add_set_enum_cmd ("struct-convention", no_class
,
1706 &struct_convention
, "\
1707 Set the convention for returning small structs, valid values \
1708 are \"default\", \"pcc\" and \"reg\", and the default value is \"default\".",
1710 add_show_from_set (new_cmd
, &showlist
);
1713 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_coff_flavour
,
1714 i386_coff_osabi_sniffer
);
1715 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_nlm_flavour
,
1716 i386_nlm_osabi_sniffer
);
1718 gdbarch_register_osabi (bfd_arch_i386
, 0, GDB_OSABI_SVR4
,
1719 i386_svr4_init_abi
);
1720 gdbarch_register_osabi (bfd_arch_i386
, 0, GDB_OSABI_GO32
,
1721 i386_go32_init_abi
);
1722 gdbarch_register_osabi (bfd_arch_i386
, 0, GDB_OSABI_NETWARE
,
1725 /* Initialize the i386 specific register groups. */
1726 i386_init_reggroups ();