2444d5c1e212e03d6ba598896416d80ec7045711
1 /* Intel 387 floating point stuff.
3 Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004, 2005, 2007, 2008, 2009 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 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "floatformat.h"
31 #include "gdb_assert.h"
32 #include "gdb_string.h"
34 #include "i386-tdep.h"
35 #include "i387-tdep.h"
37 /* Print the floating point number specified by RAW. */
40 print_i387_value (struct gdbarch
*gdbarch
,
41 const gdb_byte
*raw
, struct ui_file
*file
)
45 /* Using extract_typed_floating here might affect the representation
46 of certain numbers such as NaNs, even if GDB is running natively.
47 This is fine since our caller already detects such special
48 numbers and we print the hexadecimal representation anyway. */
49 value
= extract_typed_floating (raw
, i387_ext_type (gdbarch
));
51 /* We try to print 19 digits. The last digit may or may not contain
52 garbage, but we'd better print one too many. We need enough room
53 to print the value, 1 position for the sign, 1 for the decimal
54 point, 19 for the digits and 6 for the exponent adds up to 27. */
55 #ifdef PRINTF_HAS_LONG_DOUBLE
56 fprintf_filtered (file
, " %-+27.19Lg", (long double) value
);
58 fprintf_filtered (file
, " %-+27.19g", (double) value
);
62 /* Print the classification for the register contents RAW. */
65 print_i387_ext (struct gdbarch
*gdbarch
,
66 const gdb_byte
*raw
, struct ui_file
*file
)
70 unsigned int exponent
;
71 unsigned long fraction
[2];
74 integer
= raw
[7] & 0x80;
75 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
76 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
77 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
78 | (raw
[5] << 8) | raw
[4]);
80 if (exponent
== 0x7fff && integer
)
82 if (fraction
[0] == 0x00000000 && fraction
[1] == 0x00000000)
84 fprintf_filtered (file
, " %cInf", (sign
? '-' : '+'));
85 else if (sign
&& fraction
[0] == 0x00000000 && fraction
[1] == 0x40000000)
86 /* Real Indefinite (QNaN). */
87 fputs_unfiltered (" Real Indefinite (QNaN)", file
);
88 else if (fraction
[1] & 0x40000000)
90 fputs_filtered (" QNaN", file
);
93 fputs_filtered (" SNaN", file
);
95 else if (exponent
< 0x7fff && exponent
> 0x0000 && integer
)
97 print_i387_value (gdbarch
, raw
, file
);
98 else if (exponent
== 0x0000)
100 /* Denormal or zero. */
101 print_i387_value (gdbarch
, raw
, file
);
104 /* Pseudo-denormal. */
105 fputs_filtered (" Pseudo-denormal", file
);
106 else if (fraction
[0] || fraction
[1])
108 fputs_filtered (" Denormal", file
);
112 fputs_filtered (" Unsupported", file
);
115 /* Print the status word STATUS. */
118 print_i387_status_word (unsigned int status
, struct ui_file
*file
)
120 fprintf_filtered (file
, "Status Word: %s",
121 hex_string_custom (status
, 4));
122 fputs_filtered (" ", file
);
123 fprintf_filtered (file
, " %s", (status
& 0x0001) ? "IE" : " ");
124 fprintf_filtered (file
, " %s", (status
& 0x0002) ? "DE" : " ");
125 fprintf_filtered (file
, " %s", (status
& 0x0004) ? "ZE" : " ");
126 fprintf_filtered (file
, " %s", (status
& 0x0008) ? "OE" : " ");
127 fprintf_filtered (file
, " %s", (status
& 0x0010) ? "UE" : " ");
128 fprintf_filtered (file
, " %s", (status
& 0x0020) ? "PE" : " ");
129 fputs_filtered (" ", file
);
130 fprintf_filtered (file
, " %s", (status
& 0x0080) ? "ES" : " ");
131 fputs_filtered (" ", file
);
132 fprintf_filtered (file
, " %s", (status
& 0x0040) ? "SF" : " ");
133 fputs_filtered (" ", file
);
134 fprintf_filtered (file
, " %s", (status
& 0x0100) ? "C0" : " ");
135 fprintf_filtered (file
, " %s", (status
& 0x0200) ? "C1" : " ");
136 fprintf_filtered (file
, " %s", (status
& 0x0400) ? "C2" : " ");
137 fprintf_filtered (file
, " %s", (status
& 0x4000) ? "C3" : " ");
139 fputs_filtered ("\n", file
);
141 fprintf_filtered (file
,
142 " TOP: %d\n", ((status
>> 11) & 7));
145 /* Print the control word CONTROL. */
148 print_i387_control_word (unsigned int control
, struct ui_file
*file
)
150 fprintf_filtered (file
, "Control Word: %s",
151 hex_string_custom (control
, 4));
152 fputs_filtered (" ", file
);
153 fprintf_filtered (file
, " %s", (control
& 0x0001) ? "IM" : " ");
154 fprintf_filtered (file
, " %s", (control
& 0x0002) ? "DM" : " ");
155 fprintf_filtered (file
, " %s", (control
& 0x0004) ? "ZM" : " ");
156 fprintf_filtered (file
, " %s", (control
& 0x0008) ? "OM" : " ");
157 fprintf_filtered (file
, " %s", (control
& 0x0010) ? "UM" : " ");
158 fprintf_filtered (file
, " %s", (control
& 0x0020) ? "PM" : " ");
160 fputs_filtered ("\n", file
);
162 fputs_filtered (" PC: ", file
);
163 switch ((control
>> 8) & 3)
166 fputs_filtered ("Single Precision (24-bits)\n", file
);
169 fputs_filtered ("Reserved\n", file
);
172 fputs_filtered ("Double Precision (53-bits)\n", file
);
175 fputs_filtered ("Extended Precision (64-bits)\n", file
);
179 fputs_filtered (" RC: ", file
);
180 switch ((control
>> 10) & 3)
183 fputs_filtered ("Round to nearest\n", file
);
186 fputs_filtered ("Round down\n", file
);
189 fputs_filtered ("Round up\n", file
);
192 fputs_filtered ("Round toward zero\n", file
);
197 /* Print out the i387 floating point state. Note that we ignore FRAME
198 in the code below. That's OK since floating-point registers are
199 never saved on the stack. */
202 i387_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
203 struct frame_info
*frame
, const char *args
)
205 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_frame_arch (frame
));
218 gdb_assert (gdbarch
== get_frame_arch (frame
));
220 fctrl
= get_frame_register_unsigned (frame
, I387_FCTRL_REGNUM (tdep
));
221 fstat
= get_frame_register_unsigned (frame
, I387_FSTAT_REGNUM (tdep
));
222 ftag
= get_frame_register_unsigned (frame
, I387_FTAG_REGNUM (tdep
));
223 fiseg
= get_frame_register_unsigned (frame
, I387_FISEG_REGNUM (tdep
));
224 fioff
= get_frame_register_unsigned (frame
, I387_FIOFF_REGNUM (tdep
));
225 foseg
= get_frame_register_unsigned (frame
, I387_FOSEG_REGNUM (tdep
));
226 fooff
= get_frame_register_unsigned (frame
, I387_FOOFF_REGNUM (tdep
));
227 fop
= get_frame_register_unsigned (frame
, I387_FOP_REGNUM (tdep
));
229 top
= ((fstat
>> 11) & 7);
231 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
233 gdb_byte raw
[I386_MAX_REGISTER_SIZE
];
234 int tag
= (ftag
>> (fpreg
* 2)) & 3;
237 fprintf_filtered (file
, "%sR%d: ", fpreg
== top
? "=>" : " ", fpreg
);
242 fputs_filtered ("Valid ", file
);
245 fputs_filtered ("Zero ", file
);
248 fputs_filtered ("Special ", file
);
251 fputs_filtered ("Empty ", file
);
255 get_frame_register (frame
, (fpreg
+ 8 - top
) % 8 + I387_ST0_REGNUM (tdep
),
258 fputs_filtered ("0x", file
);
259 for (i
= 9; i
>= 0; i
--)
260 fprintf_filtered (file
, "%02x", raw
[i
]);
263 print_i387_ext (gdbarch
, raw
, file
);
265 fputs_filtered ("\n", file
);
268 fputs_filtered ("\n", file
);
270 print_i387_status_word (fstat
, file
);
271 print_i387_control_word (fctrl
, file
);
272 fprintf_filtered (file
, "Tag Word: %s\n",
273 hex_string_custom (ftag
, 4));
274 fprintf_filtered (file
, "Instruction Pointer: %s:",
275 hex_string_custom (fiseg
, 2));
276 fprintf_filtered (file
, "%s\n", hex_string_custom (fioff
, 8));
277 fprintf_filtered (file
, "Operand Pointer: %s:",
278 hex_string_custom (foseg
, 2));
279 fprintf_filtered (file
, "%s\n", hex_string_custom (fooff
, 8));
280 fprintf_filtered (file
, "Opcode: %s\n",
281 hex_string_custom (fop
? (fop
| 0xd800) : 0, 4));
285 /* Return nonzero if a value of type TYPE stored in register REGNUM
286 needs any special handling. */
289 i387_convert_register_p (struct gdbarch
*gdbarch
, int regnum
, struct type
*type
)
291 if (i386_fp_regnum_p (gdbarch
, regnum
))
293 /* Floating point registers must be converted unless we are
294 accessing them in their hardware type. */
295 if (type
== i387_ext_type (gdbarch
))
304 /* Read a value of type TYPE from register REGNUM in frame FRAME, and
305 return its contents in TO. */
308 i387_register_to_value (struct frame_info
*frame
, int regnum
,
309 struct type
*type
, gdb_byte
*to
)
311 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
312 gdb_byte from
[I386_MAX_REGISTER_SIZE
];
314 gdb_assert (i386_fp_regnum_p (gdbarch
, regnum
));
316 /* We only support floating-point values. */
317 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
319 warning (_("Cannot convert floating-point register value "
320 "to non-floating-point type."));
324 /* Convert to TYPE. */
325 get_frame_register (frame
, regnum
, from
);
326 convert_typed_floating (from
, i387_ext_type (gdbarch
), to
, type
);
329 /* Write the contents FROM of a value of type TYPE into register
330 REGNUM in frame FRAME. */
333 i387_value_to_register (struct frame_info
*frame
, int regnum
,
334 struct type
*type
, const gdb_byte
*from
)
336 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
337 gdb_byte to
[I386_MAX_REGISTER_SIZE
];
339 gdb_assert (i386_fp_regnum_p (gdbarch
, regnum
));
341 /* We only support floating-point values. */
342 if (TYPE_CODE (type
) != TYPE_CODE_FLT
)
344 warning (_("Cannot convert non-floating-point type "
345 "to floating-point register value."));
349 /* Convert from TYPE. */
350 convert_typed_floating (from
, type
, to
, i387_ext_type (gdbarch
));
351 put_frame_register (frame
, regnum
, to
);
355 /* Handle FSAVE and FXSAVE formats. */
357 /* At fsave_offset[REGNUM] you'll find the offset to the location in
358 the data structure used by the "fsave" instruction where GDB
359 register REGNUM is stored. */
361 static int fsave_offset
[] =
363 28 + 0 * 10, /* %st(0) ... */
370 28 + 7 * 10, /* ... %st(7). */
371 0, /* `fctrl' (16 bits). */
372 4, /* `fstat' (16 bits). */
373 8, /* `ftag' (16 bits). */
374 16, /* `fiseg' (16 bits). */
376 24, /* `foseg' (16 bits). */
378 18 /* `fop' (bottom 11 bits). */
381 #define FSAVE_ADDR(tdep, fsave, regnum) \
382 (fsave + fsave_offset[regnum - I387_ST0_REGNUM (tdep)])
385 /* Fill register REGNUM in REGCACHE with the appropriate value from
386 *FSAVE. This function masks off any of the reserved bits in
390 i387_supply_fsave (struct regcache
*regcache
, int regnum
, const void *fsave
)
392 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
393 const gdb_byte
*regs
= fsave
;
396 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
398 for (i
= I387_ST0_REGNUM (tdep
); i
< I387_XMM0_REGNUM (tdep
); i
++)
399 if (regnum
== -1 || regnum
== i
)
403 regcache_raw_supply (regcache
, i
, NULL
);
407 /* Most of the FPU control registers occupy only 16 bits in the
408 fsave area. Give those a special treatment. */
409 if (i
>= I387_FCTRL_REGNUM (tdep
)
410 && i
!= I387_FIOFF_REGNUM (tdep
) && i
!= I387_FOOFF_REGNUM (tdep
))
414 memcpy (val
, FSAVE_ADDR (tdep
, regs
, i
), 2);
416 if (i
== I387_FOP_REGNUM (tdep
))
417 val
[1] &= ((1 << 3) - 1);
418 regcache_raw_supply (regcache
, i
, val
);
421 regcache_raw_supply (regcache
, i
, FSAVE_ADDR (tdep
, regs
, i
));
424 /* Provide dummy values for the SSE registers. */
425 for (i
= I387_XMM0_REGNUM (tdep
); i
< I387_MXCSR_REGNUM (tdep
); i
++)
426 if (regnum
== -1 || regnum
== i
)
427 regcache_raw_supply (regcache
, i
, NULL
);
428 if (regnum
== -1 || regnum
== I387_MXCSR_REGNUM (tdep
))
432 store_unsigned_integer (buf
, 4, 0x1f80);
433 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM (tdep
), buf
);
437 /* Fill register REGNUM (if it is a floating-point register) in *FSAVE
438 with the value from REGCACHE. If REGNUM is -1, do this for all
439 registers. This function doesn't touch any of the reserved bits in
443 i387_collect_fsave (const struct regcache
*regcache
, int regnum
, void *fsave
)
445 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
446 gdb_byte
*regs
= fsave
;
449 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
451 for (i
= I387_ST0_REGNUM (tdep
); i
< I387_XMM0_REGNUM (tdep
); i
++)
452 if (regnum
== -1 || regnum
== i
)
454 /* Most of the FPU control registers occupy only 16 bits in
455 the fsave area. Give those a special treatment. */
456 if (i
>= I387_FCTRL_REGNUM (tdep
)
457 && i
!= I387_FIOFF_REGNUM (tdep
) && i
!= I387_FOOFF_REGNUM (tdep
))
461 regcache_raw_collect (regcache
, i
, buf
);
463 if (i
== I387_FOP_REGNUM (tdep
))
465 /* The opcode occupies only 11 bits. Make sure we
466 don't touch the other bits. */
467 buf
[1] &= ((1 << 3) - 1);
468 buf
[1] |= ((FSAVE_ADDR (tdep
, regs
, i
))[1] & ~((1 << 3) - 1));
470 memcpy (FSAVE_ADDR (tdep
, regs
, i
), buf
, 2);
473 regcache_raw_collect (regcache
, i
, FSAVE_ADDR (tdep
, regs
, i
));
478 /* At fxsave_offset[REGNUM] you'll find the offset to the location in
479 the data structure used by the "fxsave" instruction where GDB
480 register REGNUM is stored. */
482 static int fxsave_offset
[] =
484 32, /* %st(0) through ... */
491 144, /* ... %st(7) (80 bits each). */
492 0, /* `fctrl' (16 bits). */
493 2, /* `fstat' (16 bits). */
494 4, /* `ftag' (16 bits). */
495 12, /* `fiseg' (16 bits). */
497 20, /* `foseg' (16 bits). */
499 6, /* `fop' (bottom 11 bits). */
500 160 + 0 * 16, /* %xmm0 through ... */
515 160 + 15 * 16, /* ... %xmm15 (128 bits each). */
518 #define FXSAVE_ADDR(tdep, fxsave, regnum) \
519 (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM (tdep)])
521 /* We made an unfortunate choice in putting %mxcsr after the SSE
522 registers %xmm0-%xmm7 instead of before, since it makes supporting
523 the registers %xmm8-%xmm15 on AMD64 a bit involved. Therefore we
524 don't include the offset for %mxcsr here above. */
526 #define FXSAVE_MXCSR_ADDR(fxsave) (fxsave + 24)
528 static int i387_tag (const gdb_byte
*raw
);
531 /* Fill register REGNUM in REGCACHE with the appropriate
532 floating-point or SSE register value from *FXSAVE. This function
533 masks off any of the reserved bits in *FXSAVE. */
536 i387_supply_fxsave (struct regcache
*regcache
, int regnum
, const void *fxsave
)
538 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
539 const gdb_byte
*regs
= fxsave
;
542 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
543 gdb_assert (tdep
->num_xmm_regs
> 0);
545 for (i
= I387_ST0_REGNUM (tdep
); i
< I387_MXCSR_REGNUM (tdep
); i
++)
546 if (regnum
== -1 || regnum
== i
)
550 regcache_raw_supply (regcache
, i
, NULL
);
554 /* Most of the FPU control registers occupy only 16 bits in
555 the fxsave area. Give those a special treatment. */
556 if (i
>= I387_FCTRL_REGNUM (tdep
) && i
< I387_XMM0_REGNUM (tdep
)
557 && i
!= I387_FIOFF_REGNUM (tdep
) && i
!= I387_FOOFF_REGNUM (tdep
))
561 memcpy (val
, FXSAVE_ADDR (tdep
, regs
, i
), 2);
563 if (i
== I387_FOP_REGNUM (tdep
))
564 val
[1] &= ((1 << 3) - 1);
565 else if (i
== I387_FTAG_REGNUM (tdep
))
567 /* The fxsave area contains a simplified version of
568 the tag word. We have to look at the actual 80-bit
569 FP data to recreate the traditional i387 tag word. */
571 unsigned long ftag
= 0;
575 top
= ((FXSAVE_ADDR (tdep
, regs
,
576 I387_FSTAT_REGNUM (tdep
)))[1] >> 3);
579 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
583 if (val
[0] & (1 << fpreg
))
585 int regnum
= (fpreg
+ 8 - top
) % 8
586 + I387_ST0_REGNUM (tdep
);
587 tag
= i387_tag (FXSAVE_ADDR (tdep
, regs
, regnum
));
592 ftag
|= tag
<< (2 * fpreg
);
594 val
[0] = ftag
& 0xff;
595 val
[1] = (ftag
>> 8) & 0xff;
597 regcache_raw_supply (regcache
, i
, val
);
600 regcache_raw_supply (regcache
, i
, FXSAVE_ADDR (tdep
, regs
, i
));
603 if (regnum
== I387_MXCSR_REGNUM (tdep
) || regnum
== -1)
606 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM (tdep
), NULL
);
608 regcache_raw_supply (regcache
, I387_MXCSR_REGNUM (tdep
),
609 FXSAVE_MXCSR_ADDR (regs
));
613 /* Fill register REGNUM (if it is a floating-point or SSE register) in
614 *FXSAVE with the value from REGCACHE. If REGNUM is -1, do this for
615 all registers. This function doesn't touch any of the reserved
619 i387_collect_fxsave (const struct regcache
*regcache
, int regnum
, void *fxsave
)
621 struct gdbarch_tdep
*tdep
= gdbarch_tdep (get_regcache_arch (regcache
));
622 gdb_byte
*regs
= fxsave
;
625 gdb_assert (tdep
->st0_regnum
>= I386_ST0_REGNUM
);
626 gdb_assert (tdep
->num_xmm_regs
> 0);
628 for (i
= I387_ST0_REGNUM (tdep
); i
< I387_MXCSR_REGNUM (tdep
); i
++)
629 if (regnum
== -1 || regnum
== i
)
631 /* Most of the FPU control registers occupy only 16 bits in
632 the fxsave area. Give those a special treatment. */
633 if (i
>= I387_FCTRL_REGNUM (tdep
) && i
< I387_XMM0_REGNUM (tdep
)
634 && i
!= I387_FIOFF_REGNUM (tdep
) && i
!= I387_FOOFF_REGNUM (tdep
))
638 regcache_raw_collect (regcache
, i
, buf
);
640 if (i
== I387_FOP_REGNUM (tdep
))
642 /* The opcode occupies only 11 bits. Make sure we
643 don't touch the other bits. */
644 buf
[1] &= ((1 << 3) - 1);
645 buf
[1] |= ((FXSAVE_ADDR (tdep
, regs
, i
))[1] & ~((1 << 3) - 1));
647 else if (i
== I387_FTAG_REGNUM (tdep
))
649 /* Converting back is much easier. */
654 ftag
= (buf
[1] << 8) | buf
[0];
658 for (fpreg
= 7; fpreg
>= 0; fpreg
--)
660 int tag
= (ftag
>> (fpreg
* 2)) & 3;
663 buf
[0] |= (1 << fpreg
);
666 memcpy (FXSAVE_ADDR (tdep
, regs
, i
), buf
, 2);
669 regcache_raw_collect (regcache
, i
, FXSAVE_ADDR (tdep
, regs
, i
));
672 if (regnum
== I387_MXCSR_REGNUM (tdep
) || regnum
== -1)
673 regcache_raw_collect (regcache
, I387_MXCSR_REGNUM (tdep
),
674 FXSAVE_MXCSR_ADDR (regs
));
677 /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in
681 i387_tag (const gdb_byte
*raw
)
684 unsigned int exponent
;
685 unsigned long fraction
[2];
687 integer
= raw
[7] & 0x80;
688 exponent
= (((raw
[9] & 0x7f) << 8) | raw
[8]);
689 fraction
[0] = ((raw
[3] << 24) | (raw
[2] << 16) | (raw
[1] << 8) | raw
[0]);
690 fraction
[1] = (((raw
[7] & 0x7f) << 24) | (raw
[6] << 16)
691 | (raw
[5] << 8) | raw
[4]);
693 if (exponent
== 0x7fff)
698 else if (exponent
== 0x0000)
700 if (fraction
[0] == 0x0000 && fraction
[1] == 0x0000 && !integer
)
726 /* Prepare the FPU stack in REGCACHE for a function return. */
729 i387_return_value (struct gdbarch
*gdbarch
, struct regcache
*regcache
)
731 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
734 /* Set the top of the floating-point register stack to 7. The
735 actual value doesn't really matter, but 7 is what a normal
736 function return would end up with if the program started out with
737 a freshly initialized FPU. */
738 regcache_raw_read_unsigned (regcache
, I387_FSTAT_REGNUM (tdep
), &fstat
);
740 regcache_raw_write_unsigned (regcache
, I387_FSTAT_REGNUM (tdep
), fstat
);
742 /* Mark %st(1) through %st(7) as empty. Since we set the top of the
743 floating-point register stack to 7, the appropriate value for the
744 tag word is 0x3fff. */
745 regcache_raw_write_unsigned (regcache
, I387_FTAG_REGNUM (tdep
), 0x3fff);