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"
41 #include "i386-tdep.h"
42 #include "i387-tdep.h"
44 /* Names of the registers. The first 10 registers match the register
45 numbering scheme used by GCC for stabs and DWARF. */
46 static char *i386_register_names
[] =
48 "eax", "ecx", "edx", "ebx",
49 "esp", "ebp", "esi", "edi",
50 "eip", "eflags", "cs", "ss",
51 "ds", "es", "fs", "gs",
52 "st0", "st1", "st2", "st3",
53 "st4", "st5", "st6", "st7",
54 "fctrl", "fstat", "ftag", "fiseg",
55 "fioff", "foseg", "fooff", "fop",
56 "xmm0", "xmm1", "xmm2", "xmm3",
57 "xmm4", "xmm5", "xmm6", "xmm7",
63 static char *i386_mmx_names
[] =
65 "mm0", "mm1", "mm2", "mm3",
66 "mm4", "mm5", "mm6", "mm7"
68 static const int mmx_num_regs
= (sizeof (i386_mmx_names
)
69 / sizeof (i386_mmx_names
[0]));
70 #define MM0_REGNUM (NUM_REGS)
73 mmx_regnum_p (int reg
)
75 return (reg
>= MM0_REGNUM
&& reg
< MM0_REGNUM
+ mmx_num_regs
);
78 /* Return the name of register REG. */
81 i386_register_name (int reg
)
85 if (mmx_regnum_p (reg
))
86 return i386_mmx_names
[reg
- MM0_REGNUM
];
87 if (reg
>= sizeof (i386_register_names
) / sizeof (*i386_register_names
))
90 return i386_register_names
[reg
];
93 /* Convert stabs register number REG to the appropriate register
94 number used by GDB. */
97 i386_stab_reg_to_regnum (int reg
)
99 /* This implements what GCC calls the "default" register map. */
100 if (reg
>= 0 && reg
<= 7)
102 /* General registers. */
105 else if (reg
>= 12 && reg
<= 19)
107 /* Floating-point registers. */
108 return reg
- 12 + FP0_REGNUM
;
110 else if (reg
>= 21 && reg
<= 28)
113 return reg
- 21 + XMM0_REGNUM
;
115 else if (reg
>= 29 && reg
<= 36)
118 return reg
- 29 + MM0_REGNUM
;
121 /* This will hopefully provoke a warning. */
122 return NUM_REGS
+ NUM_PSEUDO_REGS
;
125 /* Convert DWARF register number REG to the appropriate register
126 number used by GDB. */
129 i386_dwarf_reg_to_regnum (int reg
)
131 /* The DWARF register numbering includes %eip and %eflags, and
132 numbers the floating point registers differently. */
133 if (reg
>= 0 && reg
<= 9)
135 /* General registers. */
138 else if (reg
>= 11 && reg
<= 18)
140 /* Floating-point registers. */
141 return reg
- 11 + FP0_REGNUM
;
145 /* The SSE and MMX registers have identical numbers as in stabs. */
146 return i386_stab_reg_to_regnum (reg
);
149 /* This will hopefully provoke a warning. */
150 return NUM_REGS
+ NUM_PSEUDO_REGS
;
154 /* This is the variable that is set with "set disassembly-flavor", and
155 its legitimate values. */
156 static const char att_flavor
[] = "att";
157 static const char intel_flavor
[] = "intel";
158 static const char *valid_flavors
[] =
164 static const char *disassembly_flavor
= att_flavor
;
166 /* Stdio style buffering was used to minimize calls to ptrace, but
167 this buffering did not take into account that the code section
168 being accessed may not be an even number of buffers long (even if
169 the buffer is only sizeof(int) long). In cases where the code
170 section size happened to be a non-integral number of buffers long,
171 attempting to read the last buffer would fail. Simply using
172 target_read_memory and ignoring errors, rather than read_memory, is
173 not the correct solution, since legitimate access errors would then
174 be totally ignored. To properly handle this situation and continue
175 to use buffering would require that this code be able to determine
176 the minimum code section size granularity (not the alignment of the
177 section itself, since the actual failing case that pointed out this
178 problem had a section alignment of 4 but was not a multiple of 4
179 bytes long), on a target by target basis, and then adjust it's
180 buffer size accordingly. This is messy, but potentially feasible.
181 It probably needs the bfd library's help and support. For now, the
182 buffer size is set to 1. (FIXME -fnf) */
184 #define CODESTREAM_BUFSIZ 1 /* Was sizeof(int), see note above. */
185 static CORE_ADDR codestream_next_addr
;
186 static CORE_ADDR codestream_addr
;
187 static unsigned char codestream_buf
[CODESTREAM_BUFSIZ
];
188 static int codestream_off
;
189 static int codestream_cnt
;
191 #define codestream_tell() (codestream_addr + codestream_off)
192 #define codestream_peek() \
193 (codestream_cnt == 0 ? \
194 codestream_fill(1) : codestream_buf[codestream_off])
195 #define codestream_get() \
196 (codestream_cnt-- == 0 ? \
197 codestream_fill(0) : codestream_buf[codestream_off++])
200 codestream_fill (int peek_flag
)
202 codestream_addr
= codestream_next_addr
;
203 codestream_next_addr
+= CODESTREAM_BUFSIZ
;
205 codestream_cnt
= CODESTREAM_BUFSIZ
;
206 read_memory (codestream_addr
, (char *) codestream_buf
, CODESTREAM_BUFSIZ
);
209 return (codestream_peek ());
211 return (codestream_get ());
215 codestream_seek (CORE_ADDR place
)
217 codestream_next_addr
= place
/ CODESTREAM_BUFSIZ
;
218 codestream_next_addr
*= CODESTREAM_BUFSIZ
;
221 while (codestream_tell () != place
)
226 codestream_read (unsigned char *buf
, int count
)
231 for (i
= 0; i
< count
; i
++)
232 *p
++ = codestream_get ();
236 /* If the next instruction is a jump, move to its target. */
239 i386_follow_jump (void)
241 unsigned char buf
[4];
247 pos
= codestream_tell ();
250 if (codestream_peek () == 0x66)
256 switch (codestream_get ())
259 /* Relative jump: if data16 == 0, disp32, else disp16. */
262 codestream_read (buf
, 2);
263 delta
= extract_signed_integer (buf
, 2);
265 /* Include the size of the jmp instruction (including the
271 codestream_read (buf
, 4);
272 delta
= extract_signed_integer (buf
, 4);
278 /* Relative jump, disp8 (ignore data16). */
279 codestream_read (buf
, 1);
280 /* Sign-extend it. */
281 delta
= extract_signed_integer (buf
, 1);
286 codestream_seek (pos
);
289 /* Find & return the amount a local space allocated, and advance the
290 codestream to the first register push (if any).
292 If the entry sequence doesn't make sense, return -1, and leave
293 codestream pointer at a random spot. */
296 i386_get_frame_setup (CORE_ADDR pc
)
300 codestream_seek (pc
);
304 op
= codestream_get ();
306 if (op
== 0x58) /* popl %eax */
308 /* This function must start with
311 xchgl %eax, (%esp) 0x87 0x04 0x24
312 or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
314 (the System V compiler puts out the second `xchg'
315 instruction, and the assembler doesn't try to optimize it, so
316 the 'sib' form gets generated). This sequence is used to get
317 the address of the return buffer for a function that returns
320 unsigned char buf
[4];
321 static unsigned char proto1
[3] = { 0x87, 0x04, 0x24 };
322 static unsigned char proto2
[4] = { 0x87, 0x44, 0x24, 0x00 };
324 pos
= codestream_tell ();
325 codestream_read (buf
, 4);
326 if (memcmp (buf
, proto1
, 3) == 0)
328 else if (memcmp (buf
, proto2
, 4) == 0)
331 codestream_seek (pos
);
332 op
= codestream_get (); /* Update next opcode. */
335 if (op
== 0x68 || op
== 0x6a)
337 /* This function may start with
349 unsigned char buf
[8];
351 /* Skip past the `pushl' instruction; it has either a one-byte
352 or a four-byte operand, depending on the opcode. */
353 pos
= codestream_tell ();
358 codestream_seek (pos
);
360 /* Read the following 8 bytes, which should be "call _probe" (6
361 bytes) followed by "addl $4,%esp" (2 bytes). */
362 codestream_read (buf
, sizeof (buf
));
363 if (buf
[0] == 0xe8 && buf
[6] == 0xc4 && buf
[7] == 0x4)
365 codestream_seek (pos
);
366 op
= codestream_get (); /* Update next opcode. */
369 if (op
== 0x55) /* pushl %ebp */
371 /* Check for "movl %esp, %ebp" -- can be written in two ways. */
372 switch (codestream_get ())
375 if (codestream_get () != 0xec)
379 if (codestream_get () != 0xe5)
385 /* Check for stack adjustment
389 NOTE: You can't subtract a 16 bit immediate from a 32 bit
390 reg, so we don't have to worry about a data16 prefix. */
391 op
= codestream_peek ();
394 /* `subl' with 8 bit immediate. */
396 if (codestream_get () != 0xec)
397 /* Some instruction starting with 0x83 other than `subl'. */
399 codestream_seek (codestream_tell () - 2);
402 /* `subl' with signed byte immediate (though it wouldn't
403 make sense to be negative). */
404 return (codestream_get ());
409 /* Maybe it is `subl' with a 32 bit immedediate. */
411 if (codestream_get () != 0xec)
412 /* Some instruction starting with 0x81 other than `subl'. */
414 codestream_seek (codestream_tell () - 2);
417 /* It is `subl' with a 32 bit immediate. */
418 codestream_read ((unsigned char *) buf
, 4);
419 return extract_signed_integer (buf
, 4);
429 /* `enter' with 16 bit unsigned immediate. */
430 codestream_read ((unsigned char *) buf
, 2);
431 codestream_get (); /* Flush final byte of enter instruction. */
432 return extract_unsigned_integer (buf
, 2);
437 /* Signal trampolines don't have a meaningful frame. The frame
438 pointer value we use is actually the frame pointer of the calling
439 frame -- that is, the frame which was in progress when the signal
440 trampoline was entered. GDB mostly treats this frame pointer value
441 as a magic cookie. We detect the case of a signal trampoline by
442 looking at the SIGNAL_HANDLER_CALLER field, which is set based on
445 When a signal trampoline is invoked from a frameless function, we
446 essentially have two frameless functions in a row. In this case,
447 we use the same magic cookie for three frames in a row. We detect
448 this case by seeing whether the next frame has
449 SIGNAL_HANDLER_CALLER set, and, if it does, checking whether the
450 current frame is actually frameless. In this case, we need to get
451 the PC by looking at the SP register value stored in the signal
454 This should work in most cases except in horrible situations where
455 a signal occurs just as we enter a function but before the frame
456 has been set up. Incidentally, that's just what happens when we
457 call a function from GDB with a signal pending (there's a test in
458 the testsuite that makes this happen). Therefore we pretend that
459 we have a frameless function if we're stopped at the start of a
462 /* Return non-zero if we're dealing with a frameless signal, that is,
463 a signal trampoline invoked from a frameless function. */
466 i386_frameless_signal_p (struct frame_info
*frame
)
468 return (frame
->next
&& frame
->next
->signal_handler_caller
469 && (frameless_look_for_prologue (frame
)
470 || frame
->pc
== get_pc_function_start (frame
->pc
)));
473 /* Return the chain-pointer for FRAME. In the case of the i386, the
474 frame's nominal address is the address of a 4-byte word containing
475 the calling frame's address. */
478 i386_frame_chain (struct frame_info
*frame
)
480 if (PC_IN_CALL_DUMMY (frame
->pc
, 0, 0))
483 if (frame
->signal_handler_caller
484 || i386_frameless_signal_p (frame
))
487 if (! inside_entry_file (frame
->pc
))
488 return read_memory_unsigned_integer (frame
->frame
, 4);
493 /* Determine whether the function invocation represented by FRAME does
494 not have a from on the stack associated with it. If it does not,
495 return non-zero, otherwise return zero. */
498 i386_frameless_function_invocation (struct frame_info
*frame
)
500 if (frame
->signal_handler_caller
)
503 return frameless_look_for_prologue (frame
);
506 /* Assuming FRAME is for a sigtramp routine, return the saved program
510 i386_sigtramp_saved_pc (struct frame_info
*frame
)
512 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
515 addr
= tdep
->sigcontext_addr (frame
);
516 return read_memory_unsigned_integer (addr
+ tdep
->sc_pc_offset
, 4);
519 /* Assuming FRAME is for a sigtramp routine, return the saved stack
523 i386_sigtramp_saved_sp (struct frame_info
*frame
)
525 struct gdbarch_tdep
*tdep
= gdbarch_tdep (current_gdbarch
);
528 addr
= tdep
->sigcontext_addr (frame
);
529 return read_memory_unsigned_integer (addr
+ tdep
->sc_sp_offset
, 4);
532 /* Return the saved program counter for FRAME. */
535 i386_frame_saved_pc (struct frame_info
*frame
)
537 if (PC_IN_CALL_DUMMY (frame
->pc
, 0, 0))
538 return generic_read_register_dummy (frame
->pc
, frame
->frame
,
541 if (frame
->signal_handler_caller
)
542 return i386_sigtramp_saved_pc (frame
);
544 if (i386_frameless_signal_p (frame
))
546 CORE_ADDR sp
= i386_sigtramp_saved_sp (frame
->next
);
547 return read_memory_unsigned_integer (sp
, 4);
550 return read_memory_unsigned_integer (frame
->frame
+ 4, 4);
553 /* Immediately after a function call, return the saved pc. */
556 i386_saved_pc_after_call (struct frame_info
*frame
)
558 if (frame
->signal_handler_caller
)
559 return i386_sigtramp_saved_pc (frame
);
561 return read_memory_unsigned_integer (read_register (SP_REGNUM
), 4);
564 /* Return number of args passed to a frame.
565 Can return -1, meaning no way to tell. */
568 i386_frame_num_args (struct frame_info
*fi
)
573 /* This loses because not only might the compiler not be popping the
574 args right after the function call, it might be popping args from
575 both this call and a previous one, and we would say there are
576 more args than there really are. */
580 struct frame_info
*pfi
;
582 /* On the i386, the instruction following the call could be:
584 addl $imm, %esp - imm/4 args; imm may be 8 or 32 bits
585 anything else - zero args. */
589 frameless
= FRAMELESS_FUNCTION_INVOCATION (fi
);
591 /* In the absence of a frame pointer, GDB doesn't get correct
592 values for nameless arguments. Return -1, so it doesn't print
593 any nameless arguments. */
596 pfi
= get_prev_frame (fi
);
599 /* NOTE: This can happen if we are looking at the frame for
600 main, because FRAME_CHAIN_VALID won't let us go into start.
601 If we have debugging symbols, that's not really a big deal;
602 it just means it will only show as many arguments to main as
609 op
= read_memory_integer (retpc
, 1);
610 if (op
== 0x59) /* pop %ecx */
614 op
= read_memory_integer (retpc
+ 1, 1);
616 /* addl $<signed imm 8 bits>, %esp */
617 return (read_memory_integer (retpc
+ 2, 1) & 0xff) / 4;
621 else if (op
== 0x81) /* `add' with 32 bit immediate. */
623 op
= read_memory_integer (retpc
+ 1, 1);
625 /* addl $<imm 32>, %esp */
626 return read_memory_integer (retpc
+ 2, 4) / 4;
638 /* Parse the first few instructions the function to see what registers
641 We handle these cases:
643 The startup sequence can be at the start of the function, or the
644 function can start with a branch to startup code at the end.
646 %ebp can be set up with either the 'enter' instruction, or "pushl
647 %ebp, movl %esp, %ebp" (`enter' is too slow to be useful, but was
648 once used in the System V compiler).
650 Local space is allocated just below the saved %ebp by either the
651 'enter' instruction, or by "subl $<size>, %esp". 'enter' has a 16
652 bit unsigned argument for space to allocate, and the 'addl'
653 instruction could have either a signed byte, or 32 bit immediate.
655 Next, the registers used by this function are pushed. With the
656 System V compiler they will always be in the order: %edi, %esi,
657 %ebx (and sometimes a harmless bug causes it to also save but not
658 restore %eax); however, the code below is willing to see the pushes
659 in any order, and will handle up to 8 of them.
661 If the setup sequence is at the end of the function, then the next
662 instruction will be a branch back to the start. */
665 i386_frame_init_saved_regs (struct frame_info
*fip
)
676 frame_saved_regs_zalloc (fip
);
678 pc
= get_pc_function_start (fip
->pc
);
680 locals
= i386_get_frame_setup (pc
);
684 addr
= fip
->frame
- 4 - locals
;
685 for (i
= 0; i
< 8; i
++)
687 op
= codestream_get ();
688 if (op
< 0x50 || op
> 0x57)
690 #ifdef I386_REGNO_TO_SYMMETRY
691 /* Dynix uses different internal numbering. Ick. */
692 fip
->saved_regs
[I386_REGNO_TO_SYMMETRY (op
- 0x50)] = addr
;
694 fip
->saved_regs
[op
- 0x50] = addr
;
700 fip
->saved_regs
[PC_REGNUM
] = fip
->frame
+ 4;
701 fip
->saved_regs
[FP_REGNUM
] = fip
->frame
;
704 /* Return PC of first real instruction. */
707 i386_skip_prologue (CORE_ADDR pc
)
711 static unsigned char pic_pat
[6] =
712 { 0xe8, 0, 0, 0, 0, /* call 0x0 */
713 0x5b, /* popl %ebx */
717 if (i386_get_frame_setup (pc
) < 0)
720 /* Found valid frame setup -- codestream now points to start of push
721 instructions for saving registers. */
723 /* Skip over register saves. */
724 for (i
= 0; i
< 8; i
++)
726 op
= codestream_peek ();
727 /* Break if not `pushl' instrunction. */
728 if (op
< 0x50 || op
> 0x57)
733 /* The native cc on SVR4 in -K PIC mode inserts the following code
734 to get the address of the global offset table (GOT) into register
739 movl %ebx,x(%ebp) (optional)
742 This code is with the rest of the prologue (at the end of the
743 function), so we have to skip it to get to the first real
744 instruction at the start of the function. */
746 pos
= codestream_tell ();
747 for (i
= 0; i
< 6; i
++)
749 op
= codestream_get ();
750 if (pic_pat
[i
] != op
)
755 unsigned char buf
[4];
758 op
= codestream_get ();
759 if (op
== 0x89) /* movl %ebx, x(%ebp) */
761 op
= codestream_get ();
762 if (op
== 0x5d) /* One byte offset from %ebp. */
765 codestream_read (buf
, 1);
767 else if (op
== 0x9d) /* Four byte offset from %ebp. */
770 codestream_read (buf
, 4);
772 else /* Unexpected instruction. */
774 op
= codestream_get ();
777 if (delta
> 0 && op
== 0x81 && codestream_get () == 0xc3)
782 codestream_seek (pos
);
786 return (codestream_tell ());
789 /* Use the program counter to determine the contents and size of a
790 breakpoint instruction. Return a pointer to a string of bytes that
791 encode a breakpoint instruction, store the length of the string in
792 *LEN and optionally adjust *PC to point to the correct memory
793 location for inserting the breakpoint.
795 On the i386 we have a single breakpoint that fits in a single byte
796 and can be inserted anywhere. */
798 static const unsigned char *
799 i386_breakpoint_from_pc (CORE_ADDR
*pc
, int *len
)
801 static unsigned char break_insn
[] = { 0xcc }; /* int 3 */
803 *len
= sizeof (break_insn
);
807 /* Push the return address (pointing to the call dummy) onto the stack
808 and return the new value for the stack pointer. */
811 i386_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
815 store_unsigned_integer (buf
, 4, CALL_DUMMY_ADDRESS ());
816 write_memory (sp
- 4, buf
, 4);
821 i386_do_pop_frame (struct frame_info
*frame
)
825 char regbuf
[I386_MAX_REGISTER_SIZE
];
827 fp
= FRAME_FP (frame
);
828 i386_frame_init_saved_regs (frame
);
830 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
833 addr
= frame
->saved_regs
[regnum
];
836 read_memory (addr
, regbuf
, REGISTER_RAW_SIZE (regnum
));
837 write_register_gen (regnum
, regbuf
);
840 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
841 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
842 write_register (SP_REGNUM
, fp
+ 8);
843 flush_cached_frames ();
847 i386_pop_frame (void)
849 generic_pop_current_frame (i386_do_pop_frame
);
853 /* Figure out where the longjmp will land. Slurp the args out of the
854 stack. We expect the first arg to be a pointer to the jmp_buf
855 structure from which we extract the address that we will land at.
856 This address is copied into PC. This routine returns true on
860 i386_get_longjmp_target (CORE_ADDR
*pc
)
863 CORE_ADDR sp
, jb_addr
;
864 int jb_pc_offset
= gdbarch_tdep (current_gdbarch
)->jb_pc_offset
;
866 /* If JB_PC_OFFSET is -1, we have no way to find out where the
867 longjmp will land. */
868 if (jb_pc_offset
== -1)
871 sp
= read_register (SP_REGNUM
);
872 if (target_read_memory (sp
+ 4, buf
, 4))
875 jb_addr
= extract_address (buf
, 4);
876 if (target_read_memory (jb_addr
+ jb_pc_offset
, buf
, 4))
879 *pc
= extract_address (buf
, 4);
885 i386_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
886 int struct_return
, CORE_ADDR struct_addr
)
888 sp
= default_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
895 store_address (buf
, 4, struct_addr
);
896 write_memory (sp
, buf
, 4);
903 i386_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
905 /* Do nothing. Everything was already done by i386_push_arguments. */
908 /* These registers are used for returning integers (and on some
909 targets also for returning `struct' and `union' values when their
910 size and alignment match an integer type). */
911 #define LOW_RETURN_REGNUM 0 /* %eax */
912 #define HIGH_RETURN_REGNUM 2 /* %edx */
914 /* Extract from an array REGBUF containing the (raw) register state, a
915 function return value of TYPE, and copy that, in virtual format,
919 i386_extract_return_value (struct type
*type
, struct regcache
*regcache
,
922 int len
= TYPE_LENGTH (type
);
923 char buf
[I386_MAX_REGISTER_SIZE
];
925 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
926 && TYPE_NFIELDS (type
) == 1)
928 i386_extract_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
932 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
936 warning ("Cannot find floating-point return value.");
937 memset (valbuf
, 0, len
);
941 /* Floating-point return values can be found in %st(0). Convert
942 its contents to the desired type. This is probably not
943 exactly how it would happen on the target itself, but it is
944 the best we can do. */
945 regcache_raw_read (regcache
, FP0_REGNUM
, buf
);
946 convert_typed_floating (buf
, builtin_type_i387_ext
, valbuf
, type
);
950 int low_size
= REGISTER_RAW_SIZE (LOW_RETURN_REGNUM
);
951 int high_size
= REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM
);
955 regcache_raw_read (regcache
, LOW_RETURN_REGNUM
, buf
);
956 memcpy (valbuf
, buf
, len
);
958 else if (len
<= (low_size
+ high_size
))
960 regcache_raw_read (regcache
, LOW_RETURN_REGNUM
, buf
);
961 memcpy (valbuf
, buf
, low_size
);
962 regcache_raw_read (regcache
, HIGH_RETURN_REGNUM
, buf
);
963 memcpy (valbuf
+ low_size
, buf
, len
- low_size
);
966 internal_error (__FILE__
, __LINE__
,
967 "Cannot extract return value of %d bytes long.", len
);
971 /* Write into the appropriate registers a function return value stored
972 in VALBUF of type TYPE, given in virtual format. */
975 i386_store_return_value (struct type
*type
, char *valbuf
)
977 int len
= TYPE_LENGTH (type
);
979 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
980 && TYPE_NFIELDS (type
) == 1)
982 i386_store_return_value (TYPE_FIELD_TYPE (type
, 0), valbuf
);
986 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
989 char buf
[FPU_REG_RAW_SIZE
];
993 warning ("Cannot set floating-point return value.");
997 /* Returning floating-point values is a bit tricky. Apart from
998 storing the return value in %st(0), we have to simulate the
999 state of the FPU at function return point. */
1001 /* Convert the value found in VALBUF to the extended
1002 floating-point format used by the FPU. This is probably
1003 not exactly how it would happen on the target itself, but
1004 it is the best we can do. */
1005 convert_typed_floating (valbuf
, type
, buf
, builtin_type_i387_ext
);
1006 write_register_gen (FP0_REGNUM
, buf
);
1008 /* Set the top of the floating-point register stack to 7. The
1009 actual value doesn't really matter, but 7 is what a normal
1010 function return would end up with if the program started out
1011 with a freshly initialized FPU. */
1012 fstat
= read_register (FSTAT_REGNUM
);
1014 write_register (FSTAT_REGNUM
, fstat
);
1016 /* Mark %st(1) through %st(7) as empty. Since we set the top of
1017 the floating-point register stack to 7, the appropriate value
1018 for the tag word is 0x3fff. */
1019 write_register (FTAG_REGNUM
, 0x3fff);
1023 int low_size
= REGISTER_RAW_SIZE (LOW_RETURN_REGNUM
);
1024 int high_size
= REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM
);
1026 if (len
<= low_size
)
1027 write_register_bytes (REGISTER_BYTE (LOW_RETURN_REGNUM
), valbuf
, len
);
1028 else if (len
<= (low_size
+ high_size
))
1030 write_register_bytes (REGISTER_BYTE (LOW_RETURN_REGNUM
),
1032 write_register_bytes (REGISTER_BYTE (HIGH_RETURN_REGNUM
),
1033 valbuf
+ low_size
, len
- low_size
);
1036 internal_error (__FILE__
, __LINE__
,
1037 "Cannot store return value of %d bytes long.", len
);
1041 /* Extract from an array REGBUF containing the (raw) register state
1042 the address in which a function should return its structure value,
1046 i386_extract_struct_value_address (struct regcache
*regcache
)
1048 /* NOTE: cagney/2002-08-12: Replaced a call to
1049 regcache_raw_read_as_address() with a call to
1050 regcache_cooked_read_unsigned(). The old, ...as_address function
1051 was eventually calling extract_unsigned_integer (via
1052 extract_address) to unpack the registers value. The below is
1053 doing an unsigned extract so that it is functionally equivalent.
1054 The read needs to be cooked as, otherwise, it will never
1055 correctly return the value of a register in the [NUM_REGS
1056 .. NUM_REGS+NUM_PSEUDO_REGS) range. */
1058 regcache_cooked_read_unsigned (regcache
, LOW_RETURN_REGNUM
, &val
);
1063 /* This is the variable that is set with "set struct-convention", and
1064 its legitimate values. */
1065 static const char default_struct_convention
[] = "default";
1066 static const char pcc_struct_convention
[] = "pcc";
1067 static const char reg_struct_convention
[] = "reg";
1068 static const char *valid_conventions
[] =
1070 default_struct_convention
,
1071 pcc_struct_convention
,
1072 reg_struct_convention
,
1075 static const char *struct_convention
= default_struct_convention
;
1078 i386_use_struct_convention (int gcc_p
, struct type
*type
)
1080 enum struct_return struct_return
;
1082 if (struct_convention
== default_struct_convention
)
1083 struct_return
= gdbarch_tdep (current_gdbarch
)->struct_return
;
1084 else if (struct_convention
== pcc_struct_convention
)
1085 struct_return
= pcc_struct_return
;
1087 struct_return
= reg_struct_return
;
1089 return generic_use_struct_convention (struct_return
== reg_struct_return
,
1094 /* Return the GDB type object for the "standard" data type of data in
1095 register REGNUM. Perhaps %esi and %edi should go here, but
1096 potentially they could be used for things other than address. */
1098 static struct type
*
1099 i386_register_virtual_type (int regnum
)
1101 if (regnum
== PC_REGNUM
|| regnum
== FP_REGNUM
|| regnum
== SP_REGNUM
)
1102 return lookup_pointer_type (builtin_type_void
);
1104 if (IS_FP_REGNUM (regnum
))
1105 return builtin_type_i387_ext
;
1107 if (IS_SSE_REGNUM (regnum
))
1108 return builtin_type_vec128i
;
1110 if (mmx_regnum_p (regnum
))
1111 return builtin_type_vec64i
;
1113 return builtin_type_int
;
1116 /* Map a cooked register onto a raw register or memory. For the i386,
1117 the MMX registers need to be mapped onto floating point registers. */
1120 mmx_regnum_to_fp_regnum (struct regcache
*regcache
, int regnum
)
1126 mmxi
= regnum
- MM0_REGNUM
;
1127 regcache_raw_read_unsigned (regcache
, FSTAT_REGNUM
, &fstat
);
1128 tos
= (fstat
>> 11) & 0x7;
1129 fpi
= (mmxi
+ tos
) % 8;
1130 return (FP0_REGNUM
+ fpi
);
1134 i386_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1135 int regnum
, void *buf
)
1137 if (mmx_regnum_p (regnum
))
1139 char *mmx_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1140 int fpnum
= mmx_regnum_to_fp_regnum (regcache
, regnum
);
1141 regcache_raw_read (regcache
, fpnum
, mmx_buf
);
1142 /* Extract (always little endian). */
1143 memcpy (buf
, mmx_buf
, REGISTER_RAW_SIZE (regnum
));
1146 regcache_raw_read (regcache
, regnum
, buf
);
1150 i386_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1151 int regnum
, const void *buf
)
1153 if (mmx_regnum_p (regnum
))
1155 char *mmx_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1156 int fpnum
= mmx_regnum_to_fp_regnum (regcache
, regnum
);
1158 regcache_raw_read (regcache
, fpnum
, mmx_buf
);
1159 /* ... Modify ... (always little endian). */
1160 memcpy (mmx_buf
, buf
, REGISTER_RAW_SIZE (regnum
));
1162 regcache_raw_write (regcache
, fpnum
, mmx_buf
);
1165 regcache_raw_write (regcache
, regnum
, buf
);
1168 /* Return true iff register REGNUM's virtual format is different from
1169 its raw format. Note that this definition assumes that the host
1170 supports IEEE 32-bit floats, since it doesn't say that SSE
1171 registers need conversion. Even if we can't find a counterexample,
1172 this is still sloppy. */
1175 i386_register_convertible (int regnum
)
1177 return IS_FP_REGNUM (regnum
);
1180 /* Convert data from raw format for register REGNUM in buffer FROM to
1181 virtual format with type TYPE in buffer TO. */
1184 i386_register_convert_to_virtual (int regnum
, struct type
*type
,
1185 char *from
, char *to
)
1187 gdb_assert (IS_FP_REGNUM (regnum
));
1189 /* We only support floating-point values. */
1190 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1192 warning ("Cannot convert floating-point register value "
1193 "to non-floating-point type.");
1194 memset (to
, 0, TYPE_LENGTH (type
));
1198 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
1199 the extended floating-point format used by the FPU. */
1200 convert_typed_floating (from
, builtin_type_i387_ext
, to
, type
);
1203 /* Convert data from virtual format with type TYPE in buffer FROM to
1204 raw format for register REGNUM in buffer TO. */
1207 i386_register_convert_to_raw (struct type
*type
, int regnum
,
1208 char *from
, char *to
)
1210 gdb_assert (IS_FP_REGNUM (regnum
));
1212 /* We only support floating-point values. */
1213 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1215 warning ("Cannot convert non-floating-point type "
1216 "to floating-point register value.");
1217 memset (to
, 0, TYPE_LENGTH (type
));
1221 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
1222 to the extended floating-point format used by the FPU. */
1223 convert_typed_floating (from
, type
, to
, builtin_type_i387_ext
);
1227 #ifdef STATIC_TRANSFORM_NAME
1228 /* SunPRO encodes the static variables. This is not related to C++
1229 mangling, it is done for C too. */
1232 sunpro_static_transform_name (char *name
)
1235 if (IS_STATIC_TRANSFORM_NAME (name
))
1237 /* For file-local statics there will be a period, a bunch of
1238 junk (the contents of which match a string given in the
1239 N_OPT), a period and the name. For function-local statics
1240 there will be a bunch of junk (which seems to change the
1241 second character from 'A' to 'B'), a period, the name of the
1242 function, and the name. So just skip everything before the
1244 p
= strrchr (name
, '.');
1250 #endif /* STATIC_TRANSFORM_NAME */
1253 /* Stuff for WIN32 PE style DLL's but is pretty generic really. */
1256 i386_pe_skip_trampoline_code (CORE_ADDR pc
, char *name
)
1258 if (pc
&& read_memory_unsigned_integer (pc
, 2) == 0x25ff) /* jmp *(dest) */
1260 unsigned long indirect
= read_memory_unsigned_integer (pc
+ 2, 4);
1261 struct minimal_symbol
*indsym
=
1262 indirect
? lookup_minimal_symbol_by_pc (indirect
) : 0;
1263 char *symname
= indsym
? SYMBOL_NAME (indsym
) : 0;
1267 if (strncmp (symname
, "__imp_", 6) == 0
1268 || strncmp (symname
, "_imp_", 5) == 0)
1269 return name
? 1 : read_memory_unsigned_integer (indirect
, 4);
1272 return 0; /* Not a trampoline. */
1276 /* Return non-zero if PC and NAME show that we are in a signal
1280 i386_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1282 return (name
&& strcmp ("_sigtramp", name
) == 0);
1286 /* We have two flavours of disassembly. The machinery on this page
1287 deals with switching between those. */
1290 gdb_print_insn_i386 (bfd_vma memaddr
, disassemble_info
*info
)
1292 if (disassembly_flavor
== att_flavor
)
1293 return print_insn_i386_att (memaddr
, info
);
1294 else if (disassembly_flavor
== intel_flavor
)
1295 return print_insn_i386_intel (memaddr
, info
);
1296 /* Never reached -- disassembly_flavour is always either att_flavor
1298 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1302 /* There are a few i386 architecture variants that differ only
1303 slightly from the generic i386 target. For now, we don't give them
1304 their own source file, but include them here. As a consequence,
1305 they'll always be included. */
1307 /* System V Release 4 (SVR4). */
1310 i386_svr4_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1312 return (name
&& (strcmp ("_sigreturn", name
) == 0
1313 || strcmp ("_sigacthandler", name
) == 0
1314 || strcmp ("sigvechandler", name
) == 0));
1317 /* Get address of the pushed ucontext (sigcontext) on the stack for
1318 all three variants of SVR4 sigtramps. */
1321 i386_svr4_sigcontext_addr (struct frame_info
*frame
)
1323 int sigcontext_offset
= -1;
1326 find_pc_partial_function (frame
->pc
, &name
, NULL
, NULL
);
1329 if (strcmp (name
, "_sigreturn") == 0)
1330 sigcontext_offset
= 132;
1331 else if (strcmp (name
, "_sigacthandler") == 0)
1332 sigcontext_offset
= 80;
1333 else if (strcmp (name
, "sigvechandler") == 0)
1334 sigcontext_offset
= 120;
1337 gdb_assert (sigcontext_offset
!= -1);
1340 return frame
->next
->frame
+ sigcontext_offset
;
1341 return read_register (SP_REGNUM
) + sigcontext_offset
;
1348 i386_go32_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1350 /* DJGPP doesn't have any special frames for signal handlers. */
1358 i386_elf_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1360 /* We typically use stabs-in-ELF with the DWARF register numbering. */
1361 set_gdbarch_stab_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1364 /* System V Release 4 (SVR4). */
1367 i386_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1369 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1371 /* System V Release 4 uses ELF. */
1372 i386_elf_init_abi (info
, gdbarch
);
1374 /* System V Release 4 has shared libraries. */
1375 set_gdbarch_in_solib_call_trampoline (gdbarch
, in_plt_section
);
1376 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1378 /* FIXME: kettenis/20020511: Why do we override this function here? */
1379 set_gdbarch_frame_chain_valid (gdbarch
, generic_func_frame_chain_valid
);
1381 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_svr4_pc_in_sigtramp
);
1382 tdep
->sigcontext_addr
= i386_svr4_sigcontext_addr
;
1383 tdep
->sc_pc_offset
= 14 * 4;
1384 tdep
->sc_sp_offset
= 7 * 4;
1386 tdep
->jb_pc_offset
= 20;
1392 i386_go32_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1394 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1396 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_go32_pc_in_sigtramp
);
1398 tdep
->jb_pc_offset
= 36;
1404 i386_nw_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1406 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1408 /* FIXME: kettenis/20020511: Why do we override this function here? */
1409 set_gdbarch_frame_chain_valid (gdbarch
, generic_func_frame_chain_valid
);
1411 tdep
->jb_pc_offset
= 24;
1415 static struct gdbarch
*
1416 i386_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1418 struct gdbarch_tdep
*tdep
;
1419 struct gdbarch
*gdbarch
;
1420 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
1422 /* Try to determine the OS ABI of the object we're loading. */
1423 if (info
.abfd
!= NULL
)
1424 osabi
= gdbarch_lookup_osabi (info
.abfd
);
1426 /* Find a candidate among extant architectures. */
1427 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1429 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
1431 /* Make sure the OS ABI selection matches. */
1432 tdep
= gdbarch_tdep (arches
->gdbarch
);
1433 if (tdep
&& tdep
->osabi
== osabi
)
1434 return arches
->gdbarch
;
1437 /* Allocate space for the new architecture. */
1438 tdep
= XMALLOC (struct gdbarch_tdep
);
1439 gdbarch
= gdbarch_alloc (&info
, tdep
);
1441 tdep
->osabi
= osabi
;
1443 /* The i386 default settings don't include the SSE registers.
1444 FIXME: kettenis/20020614: They do include the FPU registers for
1445 now, which probably is not quite right. */
1446 tdep
->num_xmm_regs
= 0;
1448 tdep
->jb_pc_offset
= -1;
1449 tdep
->struct_return
= pcc_struct_return
;
1450 tdep
->sigtramp_start
= 0;
1451 tdep
->sigtramp_end
= 0;
1452 tdep
->sigcontext_addr
= NULL
;
1453 tdep
->sc_pc_offset
= -1;
1454 tdep
->sc_sp_offset
= -1;
1456 /* The format used for `long double' on almost all i386 targets is
1457 the i387 extended floating-point format. In fact, of all targets
1458 in the GCC 2.95 tree, only OSF/1 does it different, and insists
1459 on having a `long double' that's not `long' at all. */
1460 set_gdbarch_long_double_format (gdbarch
, &floatformat_i387_ext
);
1462 /* Although the i386 extended floating-point has only 80 significant
1463 bits, a `long double' actually takes up 96, probably to enforce
1465 set_gdbarch_long_double_bit (gdbarch
, 96);
1467 /* NOTE: tm-i386aix.h, tm-i386bsd.h, tm-i386os9k.h, tm-ptx.h,
1468 tm-symmetry.h currently override this. Sigh. */
1469 set_gdbarch_num_regs (gdbarch
, I386_NUM_GREGS
+ I386_NUM_FREGS
);
1471 set_gdbarch_sp_regnum (gdbarch
, 4);
1472 set_gdbarch_fp_regnum (gdbarch
, 5);
1473 set_gdbarch_pc_regnum (gdbarch
, 8);
1474 set_gdbarch_ps_regnum (gdbarch
, 9);
1475 set_gdbarch_fp0_regnum (gdbarch
, 16);
1477 /* Use the "default" register numbering scheme for stabs and COFF. */
1478 set_gdbarch_stab_reg_to_regnum (gdbarch
, i386_stab_reg_to_regnum
);
1479 set_gdbarch_sdb_reg_to_regnum (gdbarch
, i386_stab_reg_to_regnum
);
1481 /* Use the DWARF register numbering scheme for DWARF and DWARF 2. */
1482 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1483 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1485 /* We don't define ECOFF_REG_TO_REGNUM, since ECOFF doesn't seem to
1486 be in use on any of the supported i386 targets. */
1488 set_gdbarch_register_name (gdbarch
, i386_register_name
);
1489 set_gdbarch_register_size (gdbarch
, 4);
1490 set_gdbarch_register_bytes (gdbarch
, I386_SIZEOF_GREGS
+ I386_SIZEOF_FREGS
);
1491 set_gdbarch_max_register_raw_size (gdbarch
, I386_MAX_REGISTER_SIZE
);
1492 set_gdbarch_max_register_virtual_size (gdbarch
, I386_MAX_REGISTER_SIZE
);
1493 set_gdbarch_register_virtual_type (gdbarch
, i386_register_virtual_type
);
1495 set_gdbarch_print_float_info (gdbarch
, i387_print_float_info
);
1497 set_gdbarch_get_longjmp_target (gdbarch
, i386_get_longjmp_target
);
1499 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1501 /* Call dummy code. */
1502 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1503 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1504 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1505 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1506 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1507 set_gdbarch_call_dummy_length (gdbarch
, 0);
1508 set_gdbarch_call_dummy_p (gdbarch
, 1);
1509 set_gdbarch_call_dummy_words (gdbarch
, NULL
);
1510 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
1511 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1512 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1514 set_gdbarch_register_convertible (gdbarch
, i386_register_convertible
);
1515 set_gdbarch_register_convert_to_virtual (gdbarch
,
1516 i386_register_convert_to_virtual
);
1517 set_gdbarch_register_convert_to_raw (gdbarch
, i386_register_convert_to_raw
);
1519 set_gdbarch_get_saved_register (gdbarch
, generic_unwind_get_saved_register
);
1520 set_gdbarch_push_arguments (gdbarch
, i386_push_arguments
);
1522 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
1524 /* "An argument's size is increased, if necessary, to make it a
1525 multiple of [32-bit] words. This may require tail padding,
1526 depending on the size of the argument" -- from the x86 ABI. */
1527 set_gdbarch_parm_boundary (gdbarch
, 32);
1529 set_gdbarch_extract_return_value (gdbarch
, i386_extract_return_value
);
1530 set_gdbarch_push_arguments (gdbarch
, i386_push_arguments
);
1531 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1532 set_gdbarch_push_return_address (gdbarch
, i386_push_return_address
);
1533 set_gdbarch_pop_frame (gdbarch
, i386_pop_frame
);
1534 set_gdbarch_store_struct_return (gdbarch
, i386_store_struct_return
);
1535 set_gdbarch_store_return_value (gdbarch
, i386_store_return_value
);
1536 set_gdbarch_extract_struct_value_address (gdbarch
,
1537 i386_extract_struct_value_address
);
1538 set_gdbarch_use_struct_convention (gdbarch
, i386_use_struct_convention
);
1540 set_gdbarch_frame_init_saved_regs (gdbarch
, i386_frame_init_saved_regs
);
1541 set_gdbarch_skip_prologue (gdbarch
, i386_skip_prologue
);
1543 /* Stack grows downward. */
1544 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1546 set_gdbarch_breakpoint_from_pc (gdbarch
, i386_breakpoint_from_pc
);
1547 set_gdbarch_decr_pc_after_break (gdbarch
, 1);
1548 set_gdbarch_function_start_offset (gdbarch
, 0);
1550 /* The following redefines make backtracing through sigtramp work.
1551 They manufacture a fake sigtramp frame and obtain the saved pc in
1552 sigtramp from the sigcontext structure which is pushed by the
1553 kernel on the user stack, along with a pointer to it. */
1555 set_gdbarch_frame_args_skip (gdbarch
, 8);
1556 set_gdbarch_frameless_function_invocation (gdbarch
,
1557 i386_frameless_function_invocation
);
1558 set_gdbarch_frame_chain (gdbarch
, i386_frame_chain
);
1559 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1560 set_gdbarch_frame_saved_pc (gdbarch
, i386_frame_saved_pc
);
1561 set_gdbarch_frame_args_address (gdbarch
, default_frame_address
);
1562 set_gdbarch_frame_locals_address (gdbarch
, default_frame_address
);
1563 set_gdbarch_saved_pc_after_call (gdbarch
, i386_saved_pc_after_call
);
1564 set_gdbarch_frame_num_args (gdbarch
, i386_frame_num_args
);
1565 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_pc_in_sigtramp
);
1567 /* Wire in the MMX registers. */
1568 set_gdbarch_num_pseudo_regs (gdbarch
, mmx_num_regs
);
1569 set_gdbarch_pseudo_register_read (gdbarch
, i386_pseudo_register_read
);
1570 set_gdbarch_pseudo_register_write (gdbarch
, i386_pseudo_register_write
);
1572 /* Hook in ABI-specific overrides, if they have been registered. */
1573 gdbarch_init_osabi (info
, gdbarch
, osabi
);
1578 static enum gdb_osabi
1579 i386_coff_osabi_sniffer (bfd
*abfd
)
1581 if (strcmp (bfd_get_target (abfd
), "coff-go32-exe") == 0
1582 || strcmp (bfd_get_target (abfd
), "coff-go32") == 0)
1583 return GDB_OSABI_GO32
;
1585 return GDB_OSABI_UNKNOWN
;
1588 static enum gdb_osabi
1589 i386_nlm_osabi_sniffer (bfd
*abfd
)
1591 return GDB_OSABI_NETWARE
;
1595 /* Provide a prototype to silence -Wmissing-prototypes. */
1596 void _initialize_i386_tdep (void);
1599 _initialize_i386_tdep (void)
1601 register_gdbarch_init (bfd_arch_i386
, i386_gdbarch_init
);
1603 tm_print_insn
= gdb_print_insn_i386
;
1604 tm_print_insn_info
.mach
= bfd_lookup_arch (bfd_arch_i386
, 0)->mach
;
1606 /* Add the variable that controls the disassembly flavor. */
1608 struct cmd_list_element
*new_cmd
;
1610 new_cmd
= add_set_enum_cmd ("disassembly-flavor", no_class
,
1612 &disassembly_flavor
,
1614 Set the disassembly flavor, the valid values are \"att\" and \"intel\", \
1615 and the default value is \"att\".",
1617 add_show_from_set (new_cmd
, &showlist
);
1620 /* Add the variable that controls the convention for returning
1623 struct cmd_list_element
*new_cmd
;
1625 new_cmd
= add_set_enum_cmd ("struct-convention", no_class
,
1627 &struct_convention
, "\
1628 Set the convention for returning small structs, valid values \
1629 are \"default\", \"pcc\" and \"reg\", and the default value is \"default\".",
1631 add_show_from_set (new_cmd
, &showlist
);
1634 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_coff_flavour
,
1635 i386_coff_osabi_sniffer
);
1636 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_nlm_flavour
,
1637 i386_nlm_osabi_sniffer
);
1639 gdbarch_register_osabi (bfd_arch_i386
, GDB_OSABI_SVR4
,
1640 i386_svr4_init_abi
);
1641 gdbarch_register_osabi (bfd_arch_i386
, GDB_OSABI_GO32
,
1642 i386_go32_init_abi
);
1643 gdbarch_register_osabi (bfd_arch_i386
, GDB_OSABI_NETWARE
,