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"
29 #include "floatformat.h"
34 #include "arch-utils.h"
38 #include "gdb_assert.h"
40 #include "i386-tdep.h"
42 /* Names of the registers. The first 10 registers match the register
43 numbering scheme used by GCC for stabs and DWARF. */
44 static char *i386_register_names
[] =
46 "eax", "ecx", "edx", "ebx",
47 "esp", "ebp", "esi", "edi",
48 "eip", "eflags", "cs", "ss",
49 "ds", "es", "fs", "gs",
50 "st0", "st1", "st2", "st3",
51 "st4", "st5", "st6", "st7",
52 "fctrl", "fstat", "ftag", "fiseg",
53 "fioff", "foseg", "fooff", "fop",
54 "xmm0", "xmm1", "xmm2", "xmm3",
55 "xmm4", "xmm5", "xmm6", "xmm7",
61 static char *i386_mmx_names
[] =
63 "mm0", "mm1", "mm2", "mm3",
64 "mm4", "mm5", "mm6", "mm7"
66 static const int mmx_num_regs
= (sizeof (i386_mmx_names
)
67 / sizeof (i386_mmx_names
[0]));
68 #define MM0_REGNUM (NUM_REGS)
71 mmx_regnum_p (int reg
)
73 return (reg
>= MM0_REGNUM
&& reg
< MM0_REGNUM
+ mmx_num_regs
);
76 /* Return the name of register REG. */
79 i386_register_name (int reg
)
83 if (mmx_regnum_p (reg
))
84 return i386_mmx_names
[reg
- MM0_REGNUM
];
85 if (reg
>= sizeof (i386_register_names
) / sizeof (*i386_register_names
))
88 return i386_register_names
[reg
];
91 /* Convert stabs register number REG to the appropriate register
92 number used by GDB. */
95 i386_stab_reg_to_regnum (int reg
)
97 /* This implements what GCC calls the "default" register map. */
98 if (reg
>= 0 && reg
<= 7)
100 /* General registers. */
103 else if (reg
>= 12 && reg
<= 19)
105 /* Floating-point registers. */
106 return reg
- 12 + FP0_REGNUM
;
108 else if (reg
>= 21 && reg
<= 28)
111 return reg
- 21 + XMM0_REGNUM
;
113 else if (reg
>= 29 && reg
<= 36)
116 /* FIXME: kettenis/2001-07-28: Should we have the MMX registers
117 as pseudo-registers? */
118 return reg
- 29 + FP0_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_bytes (REGISTER_BYTE (regnum
), regbuf
,
838 REGISTER_RAW_SIZE (regnum
));
841 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
842 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
843 write_register (SP_REGNUM
, fp
+ 8);
844 flush_cached_frames ();
848 i386_pop_frame (void)
850 generic_pop_current_frame (i386_do_pop_frame
);
854 /* Figure out where the longjmp will land. Slurp the args out of the
855 stack. We expect the first arg to be a pointer to the jmp_buf
856 structure from which we extract the address that we will land at.
857 This address is copied into PC. This routine returns true on
861 i386_get_longjmp_target (CORE_ADDR
*pc
)
864 CORE_ADDR sp
, jb_addr
;
865 int jb_pc_offset
= gdbarch_tdep (current_gdbarch
)->jb_pc_offset
;
867 /* If JB_PC_OFFSET is -1, we have no way to find out where the
868 longjmp will land. */
869 if (jb_pc_offset
== -1)
872 sp
= read_register (SP_REGNUM
);
873 if (target_read_memory (sp
+ 4, buf
, 4))
876 jb_addr
= extract_address (buf
, 4);
877 if (target_read_memory (jb_addr
+ jb_pc_offset
, buf
, 4))
880 *pc
= extract_address (buf
, 4);
886 i386_push_arguments (int nargs
, struct value
**args
, CORE_ADDR sp
,
887 int struct_return
, CORE_ADDR struct_addr
)
889 sp
= default_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
);
896 store_address (buf
, 4, struct_addr
);
897 write_memory (sp
, buf
, 4);
904 i386_store_struct_return (CORE_ADDR addr
, CORE_ADDR sp
)
906 /* Do nothing. Everything was already done by i386_push_arguments. */
909 /* These registers are used for returning integers (and on some
910 targets also for returning `struct' and `union' values when their
911 size and alignment match an integer type). */
912 #define LOW_RETURN_REGNUM 0 /* %eax */
913 #define HIGH_RETURN_REGNUM 2 /* %edx */
915 /* Extract from an array REGBUF containing the (raw) register state, a
916 function return value of TYPE, and copy that, in virtual format,
920 i386_extract_return_value (struct type
*type
, struct regcache
*regcache
,
923 int len
= TYPE_LENGTH (type
);
924 char buf
[I386_MAX_REGISTER_SIZE
];
926 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
927 && TYPE_NFIELDS (type
) == 1)
929 i386_extract_return_value (TYPE_FIELD_TYPE (type
, 0), regcache
, valbuf
);
933 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
937 warning ("Cannot find floating-point return value.");
938 memset (valbuf
, 0, len
);
942 /* Floating-point return values can be found in %st(0). Convert
943 its contents to the desired type. This is probably not
944 exactly how it would happen on the target itself, but it is
945 the best we can do. */
946 regcache_raw_read (regcache
, FP0_REGNUM
, buf
);
947 convert_typed_floating (buf
, builtin_type_i387_ext
, valbuf
, type
);
951 int low_size
= REGISTER_RAW_SIZE (LOW_RETURN_REGNUM
);
952 int high_size
= REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM
);
956 regcache_raw_read (regcache
, LOW_RETURN_REGNUM
, buf
);
957 memcpy (valbuf
, buf
, len
);
959 else if (len
<= (low_size
+ high_size
))
961 regcache_raw_read (regcache
, LOW_RETURN_REGNUM
, buf
);
962 memcpy (valbuf
, buf
, low_size
);
963 regcache_raw_read (regcache
, HIGH_RETURN_REGNUM
, buf
);
964 memcpy (valbuf
+ low_size
, buf
, len
- low_size
);
967 internal_error (__FILE__
, __LINE__
,
968 "Cannot extract return value of %d bytes long.", len
);
972 /* Write into the appropriate registers a function return value stored
973 in VALBUF of type TYPE, given in virtual format. */
976 i386_store_return_value (struct type
*type
, char *valbuf
)
978 int len
= TYPE_LENGTH (type
);
980 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
981 && TYPE_NFIELDS (type
) == 1)
983 i386_store_return_value (TYPE_FIELD_TYPE (type
, 0), valbuf
);
987 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
990 char buf
[FPU_REG_RAW_SIZE
];
994 warning ("Cannot set floating-point return value.");
998 /* Returning floating-point values is a bit tricky. Apart from
999 storing the return value in %st(0), we have to simulate the
1000 state of the FPU at function return point. */
1002 /* Convert the value found in VALBUF to the extended
1003 floating-point format used by the FPU. This is probably
1004 not exactly how it would happen on the target itself, but
1005 it is the best we can do. */
1006 convert_typed_floating (valbuf
, type
, buf
, builtin_type_i387_ext
);
1007 write_register_bytes (REGISTER_BYTE (FP0_REGNUM
), buf
,
1010 /* Set the top of the floating-point register stack to 7. The
1011 actual value doesn't really matter, but 7 is what a normal
1012 function return would end up with if the program started out
1013 with a freshly initialized FPU. */
1014 fstat
= read_register (FSTAT_REGNUM
);
1016 write_register (FSTAT_REGNUM
, fstat
);
1018 /* Mark %st(1) through %st(7) as empty. Since we set the top of
1019 the floating-point register stack to 7, the appropriate value
1020 for the tag word is 0x3fff. */
1021 write_register (FTAG_REGNUM
, 0x3fff);
1025 int low_size
= REGISTER_RAW_SIZE (LOW_RETURN_REGNUM
);
1026 int high_size
= REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM
);
1028 if (len
<= low_size
)
1029 write_register_bytes (REGISTER_BYTE (LOW_RETURN_REGNUM
), valbuf
, len
);
1030 else if (len
<= (low_size
+ high_size
))
1032 write_register_bytes (REGISTER_BYTE (LOW_RETURN_REGNUM
),
1034 write_register_bytes (REGISTER_BYTE (HIGH_RETURN_REGNUM
),
1035 valbuf
+ low_size
, len
- low_size
);
1038 internal_error (__FILE__
, __LINE__
,
1039 "Cannot store return value of %d bytes long.", len
);
1043 /* Extract from an array REGBUF containing the (raw) register state
1044 the address in which a function should return its structure value,
1048 i386_extract_struct_value_address (struct regcache
*regcache
)
1050 /* NOTE: cagney/2002-08-12: Replaced a call to
1051 regcache_raw_read_as_address() with a call to
1052 regcache_cooked_read_unsigned(). The old, ...as_address function
1053 was eventually calling extract_unsigned_integer (via
1054 extract_address) to unpack the registers value. The below is
1055 doing an unsigned extract so that it is functionally equivalent.
1056 The read needs to be cooked as, otherwise, it will never
1057 correctly return the value of a register in the [NUM_REGS
1058 .. NUM_REGS+NUM_PSEUDO_REGS) range. */
1060 regcache_cooked_read_unsigned (regcache
, LOW_RETURN_REGNUM
, &val
);
1065 /* This is the variable that is set with "set struct-convention", and
1066 its legitimate values. */
1067 static const char default_struct_convention
[] = "default";
1068 static const char pcc_struct_convention
[] = "pcc";
1069 static const char reg_struct_convention
[] = "reg";
1070 static const char *valid_conventions
[] =
1072 default_struct_convention
,
1073 pcc_struct_convention
,
1074 reg_struct_convention
,
1077 static const char *struct_convention
= default_struct_convention
;
1080 i386_use_struct_convention (int gcc_p
, struct type
*type
)
1082 enum struct_return struct_return
;
1084 if (struct_convention
== default_struct_convention
)
1085 struct_return
= gdbarch_tdep (current_gdbarch
)->struct_return
;
1086 else if (struct_convention
== pcc_struct_convention
)
1087 struct_return
= pcc_struct_return
;
1089 struct_return
= reg_struct_return
;
1091 return generic_use_struct_convention (struct_return
== reg_struct_return
,
1096 /* Return the GDB type object for the "standard" data type of data in
1097 register REGNUM. Perhaps %esi and %edi should go here, but
1098 potentially they could be used for things other than address. */
1100 static struct type
*
1101 i386_register_virtual_type (int regnum
)
1103 if (regnum
== PC_REGNUM
|| regnum
== FP_REGNUM
|| regnum
== SP_REGNUM
)
1104 return lookup_pointer_type (builtin_type_void
);
1106 if (IS_FP_REGNUM (regnum
))
1107 return builtin_type_i387_ext
;
1109 if (IS_SSE_REGNUM (regnum
))
1110 return builtin_type_vec128i
;
1112 if (mmx_regnum_p (regnum
))
1113 return builtin_type_vec64i
;
1115 return builtin_type_int
;
1118 /* Map a cooked register onto a raw register or memory. For the i386,
1119 the MMX registers need to be mapped onto floating point registers. */
1122 mmx_regnum_to_fp_regnum (struct regcache
*regcache
, int regnum
)
1128 mmxi
= regnum
- MM0_REGNUM
;
1129 regcache_raw_read_unsigned (regcache
, FSTAT_REGNUM
, &fstat
);
1130 tos
= (fstat
>> 11) & 0x7;
1131 fpi
= (mmxi
+ tos
) % 8;
1132 return (FP0_REGNUM
+ fpi
);
1136 i386_pseudo_register_read (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1137 int regnum
, void *buf
)
1139 if (mmx_regnum_p (regnum
))
1141 char *mmx_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1142 int fpnum
= mmx_regnum_to_fp_regnum (regcache
, regnum
);
1143 regcache_raw_read (regcache
, fpnum
, mmx_buf
);
1144 /* Extract (always little endian). */
1145 memcpy (buf
, mmx_buf
, REGISTER_RAW_SIZE (regnum
));
1148 regcache_raw_read (regcache
, regnum
, buf
);
1152 i386_pseudo_register_write (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
1153 int regnum
, const void *buf
)
1155 if (mmx_regnum_p (regnum
))
1157 char *mmx_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1158 int fpnum
= mmx_regnum_to_fp_regnum (regcache
, regnum
);
1160 regcache_raw_read (regcache
, fpnum
, mmx_buf
);
1161 /* ... Modify ... (always little endian). */
1162 memcpy (mmx_buf
, buf
, REGISTER_RAW_SIZE (regnum
));
1164 regcache_raw_write (regcache
, fpnum
, mmx_buf
);
1167 regcache_raw_write (regcache
, regnum
, buf
);
1170 /* Return true iff register REGNUM's virtual format is different from
1171 its raw format. Note that this definition assumes that the host
1172 supports IEEE 32-bit floats, since it doesn't say that SSE
1173 registers need conversion. Even if we can't find a counterexample,
1174 this is still sloppy. */
1177 i386_register_convertible (int regnum
)
1179 return IS_FP_REGNUM (regnum
);
1182 /* Convert data from raw format for register REGNUM in buffer FROM to
1183 virtual format with type TYPE in buffer TO. */
1186 i386_register_convert_to_virtual (int regnum
, struct type
*type
,
1187 char *from
, char *to
)
1189 gdb_assert (IS_FP_REGNUM (regnum
));
1191 /* We only support floating-point values. */
1192 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1194 warning ("Cannot convert floating-point register value "
1195 "to non-floating-point type.");
1196 memset (to
, 0, TYPE_LENGTH (type
));
1200 /* Convert to TYPE. This should be a no-op if TYPE is equivalent to
1201 the extended floating-point format used by the FPU. */
1202 convert_typed_floating (from
, builtin_type_i387_ext
, to
, type
);
1205 /* Convert data from virtual format with type TYPE in buffer FROM to
1206 raw format for register REGNUM in buffer TO. */
1209 i386_register_convert_to_raw (struct type
*type
, int regnum
,
1210 char *from
, char *to
)
1212 gdb_assert (IS_FP_REGNUM (regnum
));
1214 /* We only support floating-point values. */
1215 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
1217 warning ("Cannot convert non-floating-point type "
1218 "to floating-point register value.");
1219 memset (to
, 0, TYPE_LENGTH (type
));
1223 /* Convert from TYPE. This should be a no-op if TYPE is equivalent
1224 to the extended floating-point format used by the FPU. */
1225 convert_typed_floating (from
, type
, to
, builtin_type_i387_ext
);
1229 #ifdef STATIC_TRANSFORM_NAME
1230 /* SunPRO encodes the static variables. This is not related to C++
1231 mangling, it is done for C too. */
1234 sunpro_static_transform_name (char *name
)
1237 if (IS_STATIC_TRANSFORM_NAME (name
))
1239 /* For file-local statics there will be a period, a bunch of
1240 junk (the contents of which match a string given in the
1241 N_OPT), a period and the name. For function-local statics
1242 there will be a bunch of junk (which seems to change the
1243 second character from 'A' to 'B'), a period, the name of the
1244 function, and the name. So just skip everything before the
1246 p
= strrchr (name
, '.');
1252 #endif /* STATIC_TRANSFORM_NAME */
1255 /* Stuff for WIN32 PE style DLL's but is pretty generic really. */
1258 skip_trampoline_code (CORE_ADDR pc
, char *name
)
1260 if (pc
&& read_memory_unsigned_integer (pc
, 2) == 0x25ff) /* jmp *(dest) */
1262 unsigned long indirect
= read_memory_unsigned_integer (pc
+ 2, 4);
1263 struct minimal_symbol
*indsym
=
1264 indirect
? lookup_minimal_symbol_by_pc (indirect
) : 0;
1265 char *symname
= indsym
? SYMBOL_NAME (indsym
) : 0;
1269 if (strncmp (symname
, "__imp_", 6) == 0
1270 || strncmp (symname
, "_imp_", 5) == 0)
1271 return name
? 1 : read_memory_unsigned_integer (indirect
, 4);
1274 return 0; /* Not a trampoline. */
1278 /* Return non-zero if PC and NAME show that we are in a signal
1282 i386_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1284 return (name
&& strcmp ("_sigtramp", name
) == 0);
1288 /* We have two flavours of disassembly. The machinery on this page
1289 deals with switching between those. */
1292 gdb_print_insn_i386 (bfd_vma memaddr
, disassemble_info
*info
)
1294 if (disassembly_flavor
== att_flavor
)
1295 return print_insn_i386_att (memaddr
, info
);
1296 else if (disassembly_flavor
== intel_flavor
)
1297 return print_insn_i386_intel (memaddr
, info
);
1298 /* Never reached -- disassembly_flavour is always either att_flavor
1300 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1304 /* There are a few i386 architecture variants that differ only
1305 slightly from the generic i386 target. For now, we don't give them
1306 their own source file, but include them here. As a consequence,
1307 they'll always be included. */
1309 /* System V Release 4 (SVR4). */
1312 i386_svr4_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1314 return (name
&& (strcmp ("_sigreturn", name
) == 0
1315 || strcmp ("_sigacthandler", name
) == 0
1316 || strcmp ("sigvechandler", name
) == 0));
1319 /* Get address of the pushed ucontext (sigcontext) on the stack for
1320 all three variants of SVR4 sigtramps. */
1323 i386_svr4_sigcontext_addr (struct frame_info
*frame
)
1325 int sigcontext_offset
= -1;
1328 find_pc_partial_function (frame
->pc
, &name
, NULL
, NULL
);
1331 if (strcmp (name
, "_sigreturn") == 0)
1332 sigcontext_offset
= 132;
1333 else if (strcmp (name
, "_sigacthandler") == 0)
1334 sigcontext_offset
= 80;
1335 else if (strcmp (name
, "sigvechandler") == 0)
1336 sigcontext_offset
= 120;
1339 gdb_assert (sigcontext_offset
!= -1);
1342 return frame
->next
->frame
+ sigcontext_offset
;
1343 return read_register (SP_REGNUM
) + sigcontext_offset
;
1350 i386_go32_pc_in_sigtramp (CORE_ADDR pc
, char *name
)
1352 /* DJGPP doesn't have any special frames for signal handlers. */
1360 i386_elf_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1362 /* We typically use stabs-in-ELF with the DWARF register numbering. */
1363 set_gdbarch_stab_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1366 /* System V Release 4 (SVR4). */
1369 i386_svr4_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1371 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1373 /* System V Release 4 uses ELF. */
1374 i386_elf_init_abi (info
, gdbarch
);
1376 /* FIXME: kettenis/20020511: Why do we override this function here? */
1377 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1379 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_svr4_pc_in_sigtramp
);
1380 tdep
->sigcontext_addr
= i386_svr4_sigcontext_addr
;
1381 tdep
->sc_pc_offset
= 14 * 4;
1382 tdep
->sc_sp_offset
= 7 * 4;
1384 tdep
->jb_pc_offset
= 20;
1390 i386_go32_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1392 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1394 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_go32_pc_in_sigtramp
);
1396 tdep
->jb_pc_offset
= 36;
1402 i386_nw_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1404 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1406 /* FIXME: kettenis/20020511: Why do we override this function here? */
1407 set_gdbarch_frame_chain_valid (gdbarch
, func_frame_chain_valid
);
1409 tdep
->jb_pc_offset
= 24;
1413 static struct gdbarch
*
1414 i386_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1416 struct gdbarch_tdep
*tdep
;
1417 struct gdbarch
*gdbarch
;
1418 enum gdb_osabi osabi
= GDB_OSABI_UNKNOWN
;
1420 /* Try to determine the OS ABI of the object we're loading. */
1421 if (info
.abfd
!= NULL
)
1422 osabi
= gdbarch_lookup_osabi (info
.abfd
);
1424 /* Find a candidate among extant architectures. */
1425 for (arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1427 arches
= gdbarch_list_lookup_by_info (arches
->next
, &info
))
1429 /* Make sure the OS ABI selection matches. */
1430 tdep
= gdbarch_tdep (arches
->gdbarch
);
1431 if (tdep
&& tdep
->osabi
== osabi
)
1432 return arches
->gdbarch
;
1435 /* Allocate space for the new architecture. */
1436 tdep
= XMALLOC (struct gdbarch_tdep
);
1437 gdbarch
= gdbarch_alloc (&info
, tdep
);
1439 tdep
->osabi
= osabi
;
1441 /* The i386 default settings don't include the SSE registers.
1442 FIXME: kettenis/20020614: They do include the FPU registers for
1443 now, which probably is not quite right. */
1444 tdep
->num_xmm_regs
= 0;
1446 tdep
->jb_pc_offset
= -1;
1447 tdep
->struct_return
= pcc_struct_return
;
1448 tdep
->sigtramp_start
= 0;
1449 tdep
->sigtramp_end
= 0;
1450 tdep
->sigcontext_addr
= NULL
;
1451 tdep
->sc_pc_offset
= -1;
1452 tdep
->sc_sp_offset
= -1;
1454 /* The format used for `long double' on almost all i386 targets is
1455 the i387 extended floating-point format. In fact, of all targets
1456 in the GCC 2.95 tree, only OSF/1 does it different, and insists
1457 on having a `long double' that's not `long' at all. */
1458 set_gdbarch_long_double_format (gdbarch
, &floatformat_i387_ext
);
1460 /* Although the i386 extended floating-point has only 80 significant
1461 bits, a `long double' actually takes up 96, probably to enforce
1463 set_gdbarch_long_double_bit (gdbarch
, 96);
1465 /* NOTE: tm-i386aix.h, tm-i386bsd.h, tm-i386os9k.h, tm-ptx.h,
1466 tm-symmetry.h currently override this. Sigh. */
1467 set_gdbarch_num_regs (gdbarch
, I386_NUM_GREGS
+ I386_NUM_FREGS
);
1469 set_gdbarch_sp_regnum (gdbarch
, 4);
1470 set_gdbarch_fp_regnum (gdbarch
, 5);
1471 set_gdbarch_pc_regnum (gdbarch
, 8);
1472 set_gdbarch_ps_regnum (gdbarch
, 9);
1473 set_gdbarch_fp0_regnum (gdbarch
, 16);
1475 /* Use the "default" register numbering scheme for stabs and COFF. */
1476 set_gdbarch_stab_reg_to_regnum (gdbarch
, i386_stab_reg_to_regnum
);
1477 set_gdbarch_sdb_reg_to_regnum (gdbarch
, i386_stab_reg_to_regnum
);
1479 /* Use the DWARF register numbering scheme for DWARF and DWARF 2. */
1480 set_gdbarch_dwarf_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1481 set_gdbarch_dwarf2_reg_to_regnum (gdbarch
, i386_dwarf_reg_to_regnum
);
1483 /* We don't define ECOFF_REG_TO_REGNUM, since ECOFF doesn't seem to
1484 be in use on any of the supported i386 targets. */
1486 set_gdbarch_register_name (gdbarch
, i386_register_name
);
1487 set_gdbarch_register_size (gdbarch
, 4);
1488 set_gdbarch_register_bytes (gdbarch
, I386_SIZEOF_GREGS
+ I386_SIZEOF_FREGS
);
1489 set_gdbarch_max_register_raw_size (gdbarch
, I386_MAX_REGISTER_SIZE
);
1490 set_gdbarch_max_register_virtual_size (gdbarch
, I386_MAX_REGISTER_SIZE
);
1491 set_gdbarch_register_virtual_type (gdbarch
, i386_register_virtual_type
);
1493 set_gdbarch_get_longjmp_target (gdbarch
, i386_get_longjmp_target
);
1495 set_gdbarch_use_generic_dummy_frames (gdbarch
, 1);
1497 /* Call dummy code. */
1498 set_gdbarch_call_dummy_location (gdbarch
, AT_ENTRY_POINT
);
1499 set_gdbarch_call_dummy_address (gdbarch
, entry_point_address
);
1500 set_gdbarch_call_dummy_start_offset (gdbarch
, 0);
1501 set_gdbarch_call_dummy_breakpoint_offset (gdbarch
, 0);
1502 set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch
, 1);
1503 set_gdbarch_call_dummy_length (gdbarch
, 0);
1504 set_gdbarch_call_dummy_p (gdbarch
, 1);
1505 set_gdbarch_call_dummy_words (gdbarch
, NULL
);
1506 set_gdbarch_sizeof_call_dummy_words (gdbarch
, 0);
1507 set_gdbarch_call_dummy_stack_adjust_p (gdbarch
, 0);
1508 set_gdbarch_fix_call_dummy (gdbarch
, generic_fix_call_dummy
);
1510 set_gdbarch_register_convertible (gdbarch
, i386_register_convertible
);
1511 set_gdbarch_register_convert_to_virtual (gdbarch
,
1512 i386_register_convert_to_virtual
);
1513 set_gdbarch_register_convert_to_raw (gdbarch
, i386_register_convert_to_raw
);
1515 set_gdbarch_get_saved_register (gdbarch
, generic_unwind_get_saved_register
);
1516 set_gdbarch_push_arguments (gdbarch
, i386_push_arguments
);
1518 set_gdbarch_pc_in_call_dummy (gdbarch
, pc_in_call_dummy_at_entry_point
);
1520 /* "An argument's size is increased, if necessary, to make it a
1521 multiple of [32-bit] words. This may require tail padding,
1522 depending on the size of the argument" -- from the x86 ABI. */
1523 set_gdbarch_parm_boundary (gdbarch
, 32);
1525 set_gdbarch_extract_return_value (gdbarch
, i386_extract_return_value
);
1526 set_gdbarch_push_arguments (gdbarch
, i386_push_arguments
);
1527 set_gdbarch_push_dummy_frame (gdbarch
, generic_push_dummy_frame
);
1528 set_gdbarch_push_return_address (gdbarch
, i386_push_return_address
);
1529 set_gdbarch_pop_frame (gdbarch
, i386_pop_frame
);
1530 set_gdbarch_store_struct_return (gdbarch
, i386_store_struct_return
);
1531 set_gdbarch_store_return_value (gdbarch
, i386_store_return_value
);
1532 set_gdbarch_extract_struct_value_address (gdbarch
,
1533 i386_extract_struct_value_address
);
1534 set_gdbarch_use_struct_convention (gdbarch
, i386_use_struct_convention
);
1536 set_gdbarch_frame_init_saved_regs (gdbarch
, i386_frame_init_saved_regs
);
1537 set_gdbarch_skip_prologue (gdbarch
, i386_skip_prologue
);
1539 /* Stack grows downward. */
1540 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1542 set_gdbarch_breakpoint_from_pc (gdbarch
, i386_breakpoint_from_pc
);
1543 set_gdbarch_decr_pc_after_break (gdbarch
, 1);
1544 set_gdbarch_function_start_offset (gdbarch
, 0);
1546 /* The following redefines make backtracing through sigtramp work.
1547 They manufacture a fake sigtramp frame and obtain the saved pc in
1548 sigtramp from the sigcontext structure which is pushed by the
1549 kernel on the user stack, along with a pointer to it. */
1551 set_gdbarch_frame_args_skip (gdbarch
, 8);
1552 set_gdbarch_frameless_function_invocation (gdbarch
,
1553 i386_frameless_function_invocation
);
1554 set_gdbarch_frame_chain (gdbarch
, i386_frame_chain
);
1555 set_gdbarch_frame_chain_valid (gdbarch
, generic_file_frame_chain_valid
);
1556 set_gdbarch_frame_saved_pc (gdbarch
, i386_frame_saved_pc
);
1557 set_gdbarch_frame_args_address (gdbarch
, default_frame_address
);
1558 set_gdbarch_frame_locals_address (gdbarch
, default_frame_address
);
1559 set_gdbarch_saved_pc_after_call (gdbarch
, i386_saved_pc_after_call
);
1560 set_gdbarch_frame_num_args (gdbarch
, i386_frame_num_args
);
1561 set_gdbarch_pc_in_sigtramp (gdbarch
, i386_pc_in_sigtramp
);
1563 /* Wire in the MMX registers. */
1564 set_gdbarch_num_pseudo_regs (gdbarch
, mmx_num_regs
);
1565 set_gdbarch_pseudo_register_read (gdbarch
, i386_pseudo_register_read
);
1566 set_gdbarch_pseudo_register_write (gdbarch
, i386_pseudo_register_write
);
1568 /* Hook in ABI-specific overrides, if they have been registered. */
1569 gdbarch_init_osabi (info
, gdbarch
, osabi
);
1574 static enum gdb_osabi
1575 i386_coff_osabi_sniffer (bfd
*abfd
)
1577 if (strcmp (bfd_get_target (abfd
), "coff-go32-exe") == 0
1578 || strcmp (bfd_get_target (abfd
), "coff-go32") == 0)
1579 return GDB_OSABI_GO32
;
1581 return GDB_OSABI_UNKNOWN
;
1584 static enum gdb_osabi
1585 i386_nlm_osabi_sniffer (bfd
*abfd
)
1587 return GDB_OSABI_NETWARE
;
1591 /* Provide a prototype to silence -Wmissing-prototypes. */
1592 void _initialize_i386_tdep (void);
1595 _initialize_i386_tdep (void)
1597 register_gdbarch_init (bfd_arch_i386
, i386_gdbarch_init
);
1599 tm_print_insn
= gdb_print_insn_i386
;
1600 tm_print_insn_info
.mach
= bfd_lookup_arch (bfd_arch_i386
, 0)->mach
;
1602 /* Add the variable that controls the disassembly flavor. */
1604 struct cmd_list_element
*new_cmd
;
1606 new_cmd
= add_set_enum_cmd ("disassembly-flavor", no_class
,
1608 &disassembly_flavor
,
1610 Set the disassembly flavor, the valid values are \"att\" and \"intel\", \
1611 and the default value is \"att\".",
1613 add_show_from_set (new_cmd
, &showlist
);
1616 /* Add the variable that controls the convention for returning
1619 struct cmd_list_element
*new_cmd
;
1621 new_cmd
= add_set_enum_cmd ("struct-convention", no_class
,
1623 &struct_convention
, "\
1624 Set the convention for returning small structs, valid values \
1625 are \"default\", \"pcc\" and \"reg\", and the default value is \"default\".",
1627 add_show_from_set (new_cmd
, &showlist
);
1630 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_coff_flavour
,
1631 i386_coff_osabi_sniffer
);
1632 gdbarch_register_osabi_sniffer (bfd_arch_i386
, bfd_target_nlm_flavour
,
1633 i386_nlm_osabi_sniffer
);
1635 gdbarch_register_osabi (bfd_arch_i386
, GDB_OSABI_SVR4
,
1636 i386_svr4_init_abi
);
1637 gdbarch_register_osabi (bfd_arch_i386
, GDB_OSABI_GO32
,
1638 i386_go32_init_abi
);
1639 gdbarch_register_osabi (bfd_arch_i386
, GDB_OSABI_NETWARE
,