1 /* Intel 386 target-dependent stuff.
2 Copyright (C) 1988, 1989, 1991, 1994, 1995, 1996, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
28 #include "floatformat.h"
32 #include "arch-utils.h"
34 static long i386_get_frame_setup (CORE_ADDR
);
36 static void i386_follow_jump (void);
38 static void codestream_read (unsigned char *, int);
40 static void codestream_seek (CORE_ADDR
);
42 static unsigned char codestream_fill (int);
44 CORE_ADDR
skip_trampoline_code (CORE_ADDR
, char *);
46 static int gdb_print_insn_i386 (bfd_vma
, disassemble_info
*);
48 void _initialize_i386_tdep (void);
50 /* i386_register_byte[i] is the offset into the register file of the
51 start of register number i. We initialize this from
52 i386_register_raw_size. */
53 int i386_register_byte
[MAX_NUM_REGS
];
55 /* i386_register_raw_size[i] is the number of bytes of storage in
56 GDB's register array occupied by register i. */
57 int i386_register_raw_size
[MAX_NUM_REGS
] = {
71 /* i386_register_virtual_size[i] is the size in bytes of the virtual
72 type of register i. */
73 int i386_register_virtual_size
[MAX_NUM_REGS
];
76 /* This is the variable the is set with "set disassembly-flavor",
77 and its legitimate values. */
78 static char att_flavor
[] = "att";
79 static char intel_flavor
[] = "intel";
80 static char *valid_flavors
[] =
86 static char *disassembly_flavor
= att_flavor
;
88 static void i386_print_register (char *, int, int);
90 /* This is used to keep the bfd arch_info in sync with the disassembly flavor. */
91 static void set_disassembly_flavor_sfunc (char *, int,
92 struct cmd_list_element
*);
93 static void set_disassembly_flavor (void);
95 /* Stdio style buffering was used to minimize calls to ptrace, but this
96 buffering did not take into account that the code section being accessed
97 may not be an even number of buffers long (even if the buffer is only
98 sizeof(int) long). In cases where the code section size happened to
99 be a non-integral number of buffers long, attempting to read the last
100 buffer would fail. Simply using target_read_memory and ignoring errors,
101 rather than read_memory, is not the correct solution, since legitimate
102 access errors would then be totally ignored. To properly handle this
103 situation and continue to use buffering would require that this code
104 be able to determine the minimum code section size granularity (not the
105 alignment of the section itself, since the actual failing case that
106 pointed out this problem had a section alignment of 4 but was not a
107 multiple of 4 bytes long), on a target by target basis, and then
108 adjust it's buffer size accordingly. This is messy, but potentially
109 feasible. It probably needs the bfd library's help and support. For
110 now, the buffer size is set to 1. (FIXME -fnf) */
112 #define CODESTREAM_BUFSIZ 1 /* Was sizeof(int), see note above. */
113 static CORE_ADDR codestream_next_addr
;
114 static CORE_ADDR codestream_addr
;
115 static unsigned char codestream_buf
[CODESTREAM_BUFSIZ
];
116 static int codestream_off
;
117 static int codestream_cnt
;
119 #define codestream_tell() (codestream_addr + codestream_off)
120 #define codestream_peek() (codestream_cnt == 0 ? \
121 codestream_fill(1): codestream_buf[codestream_off])
122 #define codestream_get() (codestream_cnt-- == 0 ? \
123 codestream_fill(0) : codestream_buf[codestream_off++])
126 codestream_fill (peek_flag
)
129 codestream_addr
= codestream_next_addr
;
130 codestream_next_addr
+= CODESTREAM_BUFSIZ
;
132 codestream_cnt
= CODESTREAM_BUFSIZ
;
133 read_memory (codestream_addr
, (char *) codestream_buf
, CODESTREAM_BUFSIZ
);
136 return (codestream_peek ());
138 return (codestream_get ());
142 codestream_seek (place
)
145 codestream_next_addr
= place
/ CODESTREAM_BUFSIZ
;
146 codestream_next_addr
*= CODESTREAM_BUFSIZ
;
149 while (codestream_tell () != place
)
154 codestream_read (buf
, count
)
161 for (i
= 0; i
< count
; i
++)
162 *p
++ = codestream_get ();
165 /* next instruction is a jump, move to target */
170 unsigned char buf
[4];
176 pos
= codestream_tell ();
179 if (codestream_peek () == 0x66)
185 switch (codestream_get ())
188 /* relative jump: if data16 == 0, disp32, else disp16 */
191 codestream_read (buf
, 2);
192 delta
= extract_signed_integer (buf
, 2);
194 /* include size of jmp inst (including the 0x66 prefix). */
199 codestream_read (buf
, 4);
200 delta
= extract_signed_integer (buf
, 4);
206 /* relative jump, disp8 (ignore data16) */
207 codestream_read (buf
, 1);
208 /* Sign-extend it. */
209 delta
= extract_signed_integer (buf
, 1);
214 codestream_seek (pos
);
218 * find & return amound a local space allocated, and advance codestream to
219 * first register push (if any)
221 * if entry sequence doesn't make sense, return -1, and leave
222 * codestream pointer random
226 i386_get_frame_setup (pc
)
231 codestream_seek (pc
);
235 op
= codestream_get ();
237 if (op
== 0x58) /* popl %eax */
240 * this function must start with
243 * xchgl %eax, (%esp) 0x87 0x04 0x24
244 * or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00
246 * (the system 5 compiler puts out the second xchg
247 * inst, and the assembler doesn't try to optimize it,
248 * so the 'sib' form gets generated)
250 * this sequence is used to get the address of the return
251 * buffer for a function that returns a structure
254 unsigned char buf
[4];
255 static unsigned char proto1
[3] =
257 static unsigned char proto2
[4] =
258 {0x87, 0x44, 0x24, 0x00};
259 pos
= codestream_tell ();
260 codestream_read (buf
, 4);
261 if (memcmp (buf
, proto1
, 3) == 0)
263 else if (memcmp (buf
, proto2
, 4) == 0)
266 codestream_seek (pos
);
267 op
= codestream_get (); /* update next opcode */
270 if (op
== 0x68 || op
== 0x6a)
273 * this function may start with
283 unsigned char buf
[8];
285 /* Skip past the pushl instruction; it has either a one-byte
286 or a four-byte operand, depending on the opcode. */
287 pos
= codestream_tell ();
292 codestream_seek (pos
);
294 /* Read the following 8 bytes, which should be "call _probe" (6 bytes)
295 followed by "addl $4,%esp" (2 bytes). */
296 codestream_read (buf
, sizeof (buf
));
297 if (buf
[0] == 0xe8 && buf
[6] == 0xc4 && buf
[7] == 0x4)
299 codestream_seek (pos
);
300 op
= codestream_get (); /* update next opcode */
303 if (op
== 0x55) /* pushl %ebp */
305 /* check for movl %esp, %ebp - can be written two ways */
306 switch (codestream_get ())
309 if (codestream_get () != 0xec)
313 if (codestream_get () != 0xe5)
319 /* check for stack adjustment
323 * note: you can't subtract a 16 bit immediate
324 * from a 32 bit reg, so we don't have to worry
325 * about a data16 prefix
327 op
= codestream_peek ();
330 /* subl with 8 bit immed */
332 if (codestream_get () != 0xec)
333 /* Some instruction starting with 0x83 other than subl. */
335 codestream_seek (codestream_tell () - 2);
338 /* subl with signed byte immediate
339 * (though it wouldn't make sense to be negative)
341 return (codestream_get ());
346 /* Maybe it is subl with 32 bit immedediate. */
348 if (codestream_get () != 0xec)
349 /* Some instruction starting with 0x81 other than subl. */
351 codestream_seek (codestream_tell () - 2);
354 /* It is subl with 32 bit immediate. */
355 codestream_read ((unsigned char *) buf
, 4);
356 return extract_signed_integer (buf
, 4);
366 /* enter instruction: arg is 16 bit unsigned immed */
367 codestream_read ((unsigned char *) buf
, 2);
368 codestream_get (); /* flush final byte of enter instruction */
369 return extract_unsigned_integer (buf
, 2);
374 /* Return number of args passed to a frame.
375 Can return -1, meaning no way to tell. */
378 i386_frame_num_args (fi
)
379 struct frame_info
*fi
;
384 /* This loses because not only might the compiler not be popping the
385 args right after the function call, it might be popping args from both
386 this call and a previous one, and we would say there are more args
387 than there really are. */
391 struct frame_info
*pfi
;
393 /* on the 386, the instruction following the call could be:
395 addl $imm, %esp - imm/4 args; imm may be 8 or 32 bits
396 anything else - zero args */
400 frameless
= FRAMELESS_FUNCTION_INVOCATION (fi
);
402 /* In the absence of a frame pointer, GDB doesn't get correct values
403 for nameless arguments. Return -1, so it doesn't print any
404 nameless arguments. */
407 pfi
= get_prev_frame (fi
);
410 /* Note: this can happen if we are looking at the frame for
411 main, because FRAME_CHAIN_VALID won't let us go into
412 start. If we have debugging symbols, that's not really
413 a big deal; it just means it will only show as many arguments
414 to main as are declared. */
420 op
= read_memory_integer (retpc
, 1);
426 op
= read_memory_integer (retpc
+ 1, 1);
428 /* addl $<signed imm 8 bits>, %esp */
429 return (read_memory_integer (retpc
+ 2, 1) & 0xff) / 4;
434 { /* add with 32 bit immediate */
435 op
= read_memory_integer (retpc
+ 1, 1);
437 /* addl $<imm 32>, %esp */
438 return read_memory_integer (retpc
+ 2, 4) / 4;
451 * parse the first few instructions of the function to see
452 * what registers were stored.
454 * We handle these cases:
456 * The startup sequence can be at the start of the function,
457 * or the function can start with a branch to startup code at the end.
459 * %ebp can be set up with either the 'enter' instruction, or
460 * 'pushl %ebp, movl %esp, %ebp' (enter is too slow to be useful,
461 * but was once used in the sys5 compiler)
463 * Local space is allocated just below the saved %ebp by either the
464 * 'enter' instruction, or by 'subl $<size>, %esp'. 'enter' has
465 * a 16 bit unsigned argument for space to allocate, and the
466 * 'addl' instruction could have either a signed byte, or
469 * Next, the registers used by this function are pushed. In
470 * the sys5 compiler they will always be in the order: %edi, %esi, %ebx
471 * (and sometimes a harmless bug causes it to also save but not restore %eax);
472 * however, the code below is willing to see the pushes in any order,
473 * and will handle up to 8 of them.
475 * If the setup sequence is at the end of the function, then the
476 * next instruction will be a branch back to the start.
480 i386_frame_init_saved_regs (fip
)
481 struct frame_info
*fip
;
485 CORE_ADDR dummy_bottom
;
493 frame_saved_regs_zalloc (fip
);
495 /* if frame is the end of a dummy, compute where the
498 dummy_bottom
= fip
->frame
- 4 - REGISTER_BYTES
- CALL_DUMMY_LENGTH
;
500 /* check if the PC is in the stack, in a dummy frame */
501 if (dummy_bottom
<= fip
->pc
&& fip
->pc
<= fip
->frame
)
503 /* all regs were saved by push_call_dummy () */
505 for (i
= 0; i
< NUM_REGS
; i
++)
507 adr
-= REGISTER_RAW_SIZE (i
);
508 fip
->saved_regs
[i
] = adr
;
513 pc
= get_pc_function_start (fip
->pc
);
515 locals
= i386_get_frame_setup (pc
);
519 adr
= fip
->frame
- 4 - locals
;
520 for (i
= 0; i
< 8; i
++)
522 op
= codestream_get ();
523 if (op
< 0x50 || op
> 0x57)
525 #ifdef I386_REGNO_TO_SYMMETRY
526 /* Dynix uses different internal numbering. Ick. */
527 fip
->saved_regs
[I386_REGNO_TO_SYMMETRY (op
- 0x50)] = adr
;
529 fip
->saved_regs
[op
- 0x50] = adr
;
535 fip
->saved_regs
[PC_REGNUM
] = fip
->frame
+ 4;
536 fip
->saved_regs
[FP_REGNUM
] = fip
->frame
;
539 /* return pc of first real instruction */
542 i386_skip_prologue (pc
)
547 static unsigned char pic_pat
[6] =
548 {0xe8, 0, 0, 0, 0, /* call 0x0 */
549 0x5b, /* popl %ebx */
553 if (i386_get_frame_setup (pc
) < 0)
556 /* found valid frame setup - codestream now points to
557 * start of push instructions for saving registers
560 /* skip over register saves */
561 for (i
= 0; i
< 8; i
++)
563 op
= codestream_peek ();
564 /* break if not pushl inst */
565 if (op
< 0x50 || op
> 0x57)
570 /* The native cc on SVR4 in -K PIC mode inserts the following code to get
571 the address of the global offset table (GOT) into register %ebx.
574 movl %ebx,x(%ebp) (optional)
576 This code is with the rest of the prologue (at the end of the
577 function), so we have to skip it to get to the first real
578 instruction at the start of the function. */
580 pos
= codestream_tell ();
581 for (i
= 0; i
< 6; i
++)
583 op
= codestream_get ();
584 if (pic_pat
[i
] != op
)
589 unsigned char buf
[4];
592 op
= codestream_get ();
593 if (op
== 0x89) /* movl %ebx, x(%ebp) */
595 op
= codestream_get ();
596 if (op
== 0x5d) /* one byte offset from %ebp */
599 codestream_read (buf
, 1);
601 else if (op
== 0x9d) /* four byte offset from %ebp */
604 codestream_read (buf
, 4);
606 else /* unexpected instruction */
608 op
= codestream_get ();
611 if (delta
> 0 && op
== 0x81 && codestream_get () == 0xc3)
616 codestream_seek (pos
);
620 return (codestream_tell ());
624 i386_push_dummy_frame ()
626 CORE_ADDR sp
= read_register (SP_REGNUM
);
628 char regbuf
[MAX_REGISTER_RAW_SIZE
];
630 sp
= push_word (sp
, read_register (PC_REGNUM
));
631 sp
= push_word (sp
, read_register (FP_REGNUM
));
632 write_register (FP_REGNUM
, sp
);
633 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
635 read_register_gen (regnum
, regbuf
);
636 sp
= push_bytes (sp
, regbuf
, REGISTER_RAW_SIZE (regnum
));
638 write_register (SP_REGNUM
, sp
);
644 struct frame_info
*frame
= get_current_frame ();
647 char regbuf
[MAX_REGISTER_RAW_SIZE
];
649 fp
= FRAME_FP (frame
);
650 i386_frame_init_saved_regs (frame
);
652 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
655 adr
= frame
->saved_regs
[regnum
];
658 read_memory (adr
, regbuf
, REGISTER_RAW_SIZE (regnum
));
659 write_register_bytes (REGISTER_BYTE (regnum
), regbuf
,
660 REGISTER_RAW_SIZE (regnum
));
663 write_register (FP_REGNUM
, read_memory_integer (fp
, 4));
664 write_register (PC_REGNUM
, read_memory_integer (fp
+ 4, 4));
665 write_register (SP_REGNUM
, fp
+ 8);
666 flush_cached_frames ();
669 #ifdef GET_LONGJMP_TARGET
671 /* Figure out where the longjmp will land. Slurp the args out of the stack.
672 We expect the first arg to be a pointer to the jmp_buf structure from which
673 we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
674 This routine returns true on success. */
677 get_longjmp_target (pc
)
680 char buf
[TARGET_PTR_BIT
/ TARGET_CHAR_BIT
];
681 CORE_ADDR sp
, jb_addr
;
683 sp
= read_register (SP_REGNUM
);
685 if (target_read_memory (sp
+ SP_ARG0
, /* Offset of first arg on stack */
687 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
690 jb_addr
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
692 if (target_read_memory (jb_addr
+ JB_PC
* JB_ELEMENT_SIZE
, buf
,
693 TARGET_PTR_BIT
/ TARGET_CHAR_BIT
))
696 *pc
= extract_address (buf
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
701 #endif /* GET_LONGJMP_TARGET */
703 /* These registers are used for returning integers (and on some
704 targets also for returning `struct' and `union' values when their
705 size and alignment match an integer type. */
706 #define LOW_RETURN_REGNUM 0 /* %eax */
707 #define HIGH_RETURN_REGNUM 2 /* %edx */
709 /* Extract from an array REGBUF containing the (raw) register state, a
710 function return value of TYPE, and copy that, in virtual format,
714 i386_extract_return_value (struct type
*type
, char *regbuf
, char *valbuf
)
716 int len
= TYPE_LENGTH (type
);
718 if (TYPE_CODE_FLT
== TYPE_CODE (type
))
722 warning ("Cannot find floating-point return value.");
723 memset (valbuf
, 0, len
);
726 /* Floating-point return values can be found in %st(0). */
727 if (len
== TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
728 && TARGET_LONG_DOUBLE_FORMAT
== &floatformat_i387_ext
)
730 /* Copy straight over, but take care of the padding. */
731 memcpy (valbuf
, ®buf
[REGISTER_BYTE (FP0_REGNUM
)],
733 memset (valbuf
+ FPU_REG_RAW_SIZE
, 0, len
- FPU_REG_RAW_SIZE
);
737 /* Convert the extended floating-point number found in
738 %st(0) to the desired type. This is probably not exactly
739 how it would happen on the target itself, but it is the
742 floatformat_to_doublest (&floatformat_i387_ext
,
743 ®buf
[REGISTER_BYTE (FP0_REGNUM
)], &val
);
744 store_floating (valbuf
, TYPE_LENGTH (type
), val
);
749 int low_size
= REGISTER_RAW_SIZE (LOW_RETURN_REGNUM
);
750 int high_size
= REGISTER_RAW_SIZE (HIGH_RETURN_REGNUM
);
753 memcpy (valbuf
, ®buf
[REGISTER_BYTE (LOW_RETURN_REGNUM
)], len
);
754 else if (len
<= (low_size
+ high_size
))
757 ®buf
[REGISTER_BYTE (LOW_RETURN_REGNUM
)], low_size
);
758 memcpy (valbuf
+ low_size
,
759 ®buf
[REGISTER_BYTE (HIGH_RETURN_REGNUM
)], len
- low_size
);
762 internal_error ("Cannot extract return value of %d bytes long.", len
);
766 /* Convert data from raw format for register REGNUM in buffer FROM to
767 virtual format with type TYPE in buffer TO. In principle both
768 formats are identical except that the virtual format has two extra
769 bytes appended that aren't used. We set these to zero. */
772 i386_register_convert_to_virtual (int regnum
, struct type
*type
,
773 char *from
, char *to
)
775 /* Copy straight over, but take care of the padding. */
776 memcpy (to
, from
, FPU_REG_RAW_SIZE
);
777 memset (to
+ FPU_REG_RAW_SIZE
, 0, TYPE_LENGTH (type
) - FPU_REG_RAW_SIZE
);
780 /* Convert data from virtual format with type TYPE in buffer FROM to
781 raw format for register REGNUM in buffer TO. Simply omit the two
785 i386_register_convert_to_raw (struct type
*type
, int regnum
,
786 char *from
, char *to
)
788 memcpy (to
, from
, FPU_REG_RAW_SIZE
);
792 #ifdef I386V4_SIGTRAMP_SAVED_PC
793 /* Get saved user PC for sigtramp from the pushed ucontext on the stack
794 for all three variants of SVR4 sigtramps. */
797 i386v4_sigtramp_saved_pc (frame
)
798 struct frame_info
*frame
;
800 CORE_ADDR saved_pc_offset
= 4;
803 find_pc_partial_function (frame
->pc
, &name
, NULL
, NULL
);
806 if (STREQ (name
, "_sigreturn"))
807 saved_pc_offset
= 132 + 14 * 4;
808 else if (STREQ (name
, "_sigacthandler"))
809 saved_pc_offset
= 80 + 14 * 4;
810 else if (STREQ (name
, "sigvechandler"))
811 saved_pc_offset
= 120 + 14 * 4;
815 return read_memory_integer (frame
->next
->frame
+ saved_pc_offset
, 4);
816 return read_memory_integer (read_register (SP_REGNUM
) + saved_pc_offset
, 4);
818 #endif /* I386V4_SIGTRAMP_SAVED_PC */
821 #ifdef STATIC_TRANSFORM_NAME
822 /* SunPRO encodes the static variables. This is not related to C++ mangling,
823 it is done for C too. */
826 sunpro_static_transform_name (name
)
830 if (IS_STATIC_TRANSFORM_NAME (name
))
832 /* For file-local statics there will be a period, a bunch
833 of junk (the contents of which match a string given in the
834 N_OPT), a period and the name. For function-local statics
835 there will be a bunch of junk (which seems to change the
836 second character from 'A' to 'B'), a period, the name of the
837 function, and the name. So just skip everything before the
839 p
= strrchr (name
, '.');
845 #endif /* STATIC_TRANSFORM_NAME */
849 /* Stuff for WIN32 PE style DLL's but is pretty generic really. */
852 skip_trampoline_code (pc
, name
)
856 if (pc
&& read_memory_unsigned_integer (pc
, 2) == 0x25ff) /* jmp *(dest) */
858 unsigned long indirect
= read_memory_unsigned_integer (pc
+ 2, 4);
859 struct minimal_symbol
*indsym
=
860 indirect
? lookup_minimal_symbol_by_pc (indirect
) : 0;
861 char *symname
= indsym
? SYMBOL_NAME (indsym
) : 0;
865 if (strncmp (symname
, "__imp_", 6) == 0
866 || strncmp (symname
, "_imp_", 5) == 0)
867 return name
? 1 : read_memory_unsigned_integer (indirect
, 4);
870 return 0; /* not a trampoline */
874 gdb_print_insn_i386 (memaddr
, info
)
876 disassemble_info
*info
;
878 if (disassembly_flavor
== att_flavor
)
879 return print_insn_i386_att (memaddr
, info
);
880 else if (disassembly_flavor
== intel_flavor
)
881 return print_insn_i386_intel (memaddr
, info
);
882 /* Never reached - disassembly_flavour is always either att_flavor
887 /* If the disassembly mode is intel, we have to also switch the
888 bfd mach_type. This function is run in the set disassembly_flavor
889 command, and does that. */
892 set_disassembly_flavor_sfunc (args
, from_tty
, c
)
895 struct cmd_list_element
*c
;
897 set_disassembly_flavor ();
901 set_disassembly_flavor ()
903 if (disassembly_flavor
== att_flavor
)
904 set_architecture_from_arch_mach (bfd_arch_i386
, bfd_mach_i386_i386
);
905 else if (disassembly_flavor
== intel_flavor
)
906 set_architecture_from_arch_mach (bfd_arch_i386
, bfd_mach_i386_i386_intel_syntax
);
911 _initialize_i386_tdep ()
913 /* Initialize the table saying where each register starts in the
919 for (i
= 0; i
< MAX_NUM_REGS
; i
++)
921 i386_register_byte
[i
] = offset
;
922 offset
+= i386_register_raw_size
[i
];
926 /* Initialize the table of virtual register sizes. */
930 for (i
= 0; i
< MAX_NUM_REGS
; i
++)
931 i386_register_virtual_size
[i
] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i
));
934 tm_print_insn
= gdb_print_insn_i386
;
935 tm_print_insn_info
.mach
= bfd_lookup_arch (bfd_arch_i386
, 0)->mach
;
937 /* Add the variable that controls the disassembly flavor */
939 struct cmd_list_element
*new_cmd
;
941 new_cmd
= add_set_enum_cmd ("disassembly-flavor", no_class
,
944 "Set the disassembly flavor, the valid values are \"att\" and \"intel\", \
945 and the default value is \"att\".",
947 new_cmd
->function
.sfunc
= set_disassembly_flavor_sfunc
;
948 add_show_from_set (new_cmd
, &showlist
);
951 /* Finally, initialize the disassembly flavor to the default given
952 in the disassembly_flavor variable */
954 set_disassembly_flavor ();