X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fi387-tdep.c;h=ff5a843a448daacd89ef9209264070a9d1bcb00e;hb=2bd7c093f663139ad9e57ddc748ade12f6bfbe01;hp=ef4add68361179ebc29adb6c1ca9fa7d6baea814;hpb=8a3fe4f86c51d363e10efed1046ebcbdc853ae99;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i387-tdep.c b/gdb/i387-tdep.c index ef4add6836..ff5a843a44 100644 --- a/gdb/i387-tdep.c +++ b/gdb/i387-tdep.c @@ -1,13 +1,13 @@ /* Intel 387 floating point stuff. - Copyright 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000, - 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994, 1998, 1999, 2000, 2001, + 2002, 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,9 +16,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "doublest.h" @@ -36,13 +34,10 @@ #include "i386-tdep.h" #include "i387-tdep.h" -/* Implement the `info float' layout based on the register definitions - in `tm-i386.h'. */ - /* Print the floating point number specified by RAW. */ static void -print_i387_value (char *raw, struct ui_file *file) +print_i387_value (const gdb_byte *raw, struct ui_file *file) { DOUBLEST value; @@ -66,7 +61,7 @@ print_i387_value (char *raw, struct ui_file *file) /* Print the classification for the register contents RAW. */ static void -print_i387_ext (unsigned char *raw, struct ui_file *file) +print_i387_ext (const gdb_byte *raw, struct ui_file *file) { int sign; int integer; @@ -206,7 +201,7 @@ i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, const char *args) { struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (frame)); - char buf[4]; + gdb_byte buf[4]; ULONGEST fctrl; ULONGEST fstat; ULONGEST ftag; @@ -220,24 +215,20 @@ i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, gdb_assert (gdbarch == get_frame_arch (frame)); - /* Define I387_ST0_REGNUM such that we use the proper definitions - for FRAME's architecture. */ -#define I387_ST0_REGNUM tdep->st0_regnum - - fctrl = get_frame_register_unsigned (frame, I387_FCTRL_REGNUM); - fstat = get_frame_register_unsigned (frame, I387_FSTAT_REGNUM); - ftag = get_frame_register_unsigned (frame, I387_FTAG_REGNUM); - fiseg = get_frame_register_unsigned (frame, I387_FISEG_REGNUM); - fioff = get_frame_register_unsigned (frame, I387_FIOFF_REGNUM); - foseg = get_frame_register_unsigned (frame, I387_FOSEG_REGNUM); - fooff = get_frame_register_unsigned (frame, I387_FOOFF_REGNUM); - fop = get_frame_register_unsigned (frame, I387_FOP_REGNUM); + fctrl = get_frame_register_unsigned (frame, I387_FCTRL_REGNUM (tdep)); + fstat = get_frame_register_unsigned (frame, I387_FSTAT_REGNUM (tdep)); + ftag = get_frame_register_unsigned (frame, I387_FTAG_REGNUM (tdep)); + fiseg = get_frame_register_unsigned (frame, I387_FISEG_REGNUM (tdep)); + fioff = get_frame_register_unsigned (frame, I387_FIOFF_REGNUM (tdep)); + foseg = get_frame_register_unsigned (frame, I387_FOSEG_REGNUM (tdep)); + fooff = get_frame_register_unsigned (frame, I387_FOOFF_REGNUM (tdep)); + fop = get_frame_register_unsigned (frame, I387_FOP_REGNUM (tdep)); top = ((fstat >> 11) & 7); for (fpreg = 7; fpreg >= 0; fpreg--) { - unsigned char raw[I386_MAX_REGISTER_SIZE]; + gdb_byte raw[I386_MAX_REGISTER_SIZE]; int tag = (ftag >> (fpreg * 2)) & 3; int i; @@ -259,7 +250,8 @@ i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, break; } - get_frame_register (frame, (fpreg + 8 - top) % 8 + I387_ST0_REGNUM, raw); + get_frame_register (frame, (fpreg + 8 - top) % 8 + I387_ST0_REGNUM (tdep), + raw); fputs_filtered ("0x", file); for (i = 9; i >= 0; i--) @@ -285,21 +277,38 @@ i387_print_float_info (struct gdbarch *gdbarch, struct ui_file *file, fprintf_filtered (file, "%s\n", hex_string_custom (fooff, 8)); fprintf_filtered (file, "Opcode: %s\n", hex_string_custom (fop ? (fop | 0xd800) : 0, 4)); - -#undef I387_ST0_REGNUM } +/* Return nonzero if a value of type TYPE stored in register REGNUM + needs any special handling. */ + +int +i387_convert_register_p (struct gdbarch *gdbarch, int regnum, struct type *type) +{ + if (i386_fp_regnum_p (gdbarch, regnum)) + { + /* Floating point registers must be converted unless we are + accessing them in their hardware type. */ + if (type == builtin_type_i387_ext) + return 0; + else + return 1; + } + + return 0; +} + /* Read a value of type TYPE from register REGNUM in frame FRAME, and return its contents in TO. */ void i387_register_to_value (struct frame_info *frame, int regnum, - struct type *type, void *to) + struct type *type, gdb_byte *to) { - char from[I386_MAX_REGISTER_SIZE]; + gdb_byte from[I386_MAX_REGISTER_SIZE]; - gdb_assert (i386_fp_regnum_p (regnum)); + gdb_assert (i386_fp_regnum_p (get_frame_arch (frame), regnum)); /* We only support floating-point values. */ if (TYPE_CODE (type) != TYPE_CODE_FLT) @@ -309,8 +318,7 @@ i387_register_to_value (struct frame_info *frame, int regnum, return; } - /* Convert to TYPE. This should be a no-op if TYPE is equivalent to - the extended floating-point format used by the FPU. */ + /* Convert to TYPE. */ get_frame_register (frame, regnum, from); convert_typed_floating (from, builtin_type_i387_ext, to, type); } @@ -320,11 +328,11 @@ i387_register_to_value (struct frame_info *frame, int regnum, void i387_value_to_register (struct frame_info *frame, int regnum, - struct type *type, const void *from) + struct type *type, const gdb_byte *from) { - char to[I386_MAX_REGISTER_SIZE]; + gdb_byte to[I386_MAX_REGISTER_SIZE]; - gdb_assert (i386_fp_regnum_p (regnum)); + gdb_assert (i386_fp_regnum_p (get_frame_arch (frame), regnum)); /* We only support floating-point values. */ if (TYPE_CODE (type) != TYPE_CODE_FLT) @@ -334,8 +342,7 @@ i387_value_to_register (struct frame_info *frame, int regnum, return; } - /* Convert from TYPE. This should be a no-op if TYPE is equivalent - to the extended floating-point format used by the FPU. */ + /* Convert from TYPE. */ convert_typed_floating (from, type, to, builtin_type_i387_ext); put_frame_register (frame, regnum, to); } @@ -343,12 +350,6 @@ i387_value_to_register (struct frame_info *frame, int regnum, /* Handle FSAVE and FXSAVE formats. */ -/* FIXME: kettenis/20030927: The functions below should accept a - `regcache' argument, but I don't want to change the function - signature just yet. There's some band-aid in the functions below - in the form of the `regcache' local variables. This will ease the - transition later on. */ - /* At fsave_offset[REGNUM] you'll find the offset to the location in the data structure used by the "fsave" instruction where GDB register REGNUM is stored. */ @@ -373,8 +374,8 @@ static int fsave_offset[] = 18 /* `fop' (bottom 11 bits). */ }; -#define FSAVE_ADDR(fsave, regnum) \ - (fsave + fsave_offset[regnum - I387_ST0_REGNUM]) +#define FSAVE_ADDR(tdep, fsave, regnum) \ + (fsave + fsave_offset[regnum - I387_ST0_REGNUM (tdep)]) /* Fill register REGNUM in REGCACHE with the appropriate value from @@ -385,18 +386,12 @@ void i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave) { struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); - const char *regs = fsave; + const gdb_byte *regs = fsave; int i; gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM); - /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the - proper definitions for REGCACHE's architecture. */ - -#define I387_ST0_REGNUM tdep->st0_regnum -#define I387_NUM_XMM_REGS tdep->num_xmm_regs - - for (i = I387_ST0_REGNUM; i < I387_XMM0_REGNUM; i++) + for (i = I387_ST0_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++) if (regnum == -1 || regnum == i) { if (fsave == NULL) @@ -407,35 +402,32 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave) /* Most of the FPU control registers occupy only 16 bits in the fsave area. Give those a special treatment. */ - if (i >= I387_FCTRL_REGNUM - && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM) + if (i >= I387_FCTRL_REGNUM (tdep) + && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep)) { - unsigned char val[4]; + gdb_byte val[4]; - memcpy (val, FSAVE_ADDR (regs, i), 2); + memcpy (val, FSAVE_ADDR (tdep, regs, i), 2); val[2] = val[3] = 0; - if (i == I387_FOP_REGNUM) + if (i == I387_FOP_REGNUM (tdep)) val[1] &= ((1 << 3) - 1); regcache_raw_supply (regcache, i, val); } else - regcache_raw_supply (regcache, i, FSAVE_ADDR (regs, i)); + regcache_raw_supply (regcache, i, FSAVE_ADDR (tdep, regs, i)); } /* Provide dummy values for the SSE registers. */ - for (i = I387_XMM0_REGNUM; i < I387_MXCSR_REGNUM; i++) + for (i = I387_XMM0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++) if (regnum == -1 || regnum == i) regcache_raw_supply (regcache, i, NULL); - if (regnum == -1 || regnum == I387_MXCSR_REGNUM) + if (regnum == -1 || regnum == I387_MXCSR_REGNUM (tdep)) { - char buf[4]; + gdb_byte buf[4]; store_unsigned_integer (buf, 4, 0x1f80); - regcache_raw_supply (regcache, I387_MXCSR_REGNUM, buf); + regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), buf); } - -#undef I387_ST0_REGNUM -#undef I387_NUM_XMM_REGS } /* Fill register REGNUM (if it is a floating-point register) in *FSAVE @@ -446,52 +438,36 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave) void i387_collect_fsave (const struct regcache *regcache, int regnum, void *fsave) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - char *regs = fsave; + struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + gdb_byte *regs = fsave; int i; gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM); - /* Define I387_ST0_REGNUM such that we use the proper definitions - for REGCACHE's architecture. */ -#define I387_ST0_REGNUM tdep->st0_regnum - - for (i = I387_ST0_REGNUM; i < I387_XMM0_REGNUM; i++) + for (i = I387_ST0_REGNUM (tdep); i < I387_XMM0_REGNUM (tdep); i++) if (regnum == -1 || regnum == i) { /* Most of the FPU control registers occupy only 16 bits in the fsave area. Give those a special treatment. */ - if (i >= I387_FCTRL_REGNUM - && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM) + if (i >= I387_FCTRL_REGNUM (tdep) + && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep)) { - unsigned char buf[4]; + gdb_byte buf[4]; regcache_raw_collect (regcache, i, buf); - if (i == I387_FOP_REGNUM) + if (i == I387_FOP_REGNUM (tdep)) { /* The opcode occupies only 11 bits. Make sure we don't touch the other bits. */ buf[1] &= ((1 << 3) - 1); - buf[1] |= ((FSAVE_ADDR (regs, i))[1] & ~((1 << 3) - 1)); + buf[1] |= ((FSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1)); } - memcpy (FSAVE_ADDR (regs, i), buf, 2); + memcpy (FSAVE_ADDR (tdep, regs, i), buf, 2); } else - regcache_raw_collect (regcache, i, FSAVE_ADDR (regs, i)); + regcache_raw_collect (regcache, i, FSAVE_ADDR (tdep, regs, i)); } -#undef I387_ST0_REGNUM -} - -/* Fill register REGNUM (if it is a floating-point register) in *FSAVE - with the value in GDB's register cache. If REGNUM is -1, do this - for all registers. This function doesn't touch any of the reserved - bits in *FSAVE. */ - -void -i387_fill_fsave (void *fsave, int regnum) -{ - i387_collect_fsave (current_regcache, regnum, fsave); } @@ -535,8 +511,8 @@ static int fxsave_offset[] = 160 + 15 * 16, /* ... %xmm15 (128 bits each). */ }; -#define FXSAVE_ADDR(fxsave, regnum) \ - (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM]) +#define FXSAVE_ADDR(tdep, fxsave, regnum) \ + (fxsave + fxsave_offset[regnum - I387_ST0_REGNUM (tdep)]) /* We made an unfortunate choice in putting %mxcsr after the SSE registers %xmm0-%xmm7 instead of before, since it makes supporting @@ -545,7 +521,7 @@ static int fxsave_offset[] = #define FXSAVE_MXCSR_ADDR(fxsave) (fxsave + 24) -static int i387_tag (const unsigned char *raw); +static int i387_tag (const gdb_byte *raw); /* Fill register REGNUM in REGCACHE with the appropriate @@ -556,19 +532,13 @@ void i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave) { struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); - const char *regs = fxsave; + const gdb_byte *regs = fxsave; int i; gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM); gdb_assert (tdep->num_xmm_regs > 0); - /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the - proper definitions for REGCACHE's architecture. */ - -#define I387_ST0_REGNUM tdep->st0_regnum -#define I387_NUM_XMM_REGS tdep->num_xmm_regs - - for (i = I387_ST0_REGNUM; i < I387_MXCSR_REGNUM; i++) + for (i = I387_ST0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++) if (regnum == -1 || regnum == i) { if (regs == NULL) @@ -579,16 +549,16 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave) /* Most of the FPU control registers occupy only 16 bits in the fxsave area. Give those a special treatment. */ - if (i >= I387_FCTRL_REGNUM && i < I387_XMM0_REGNUM - && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM) + if (i >= I387_FCTRL_REGNUM (tdep) && i < I387_XMM0_REGNUM (tdep) + && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep)) { - unsigned char val[4]; + gdb_byte val[4]; - memcpy (val, FXSAVE_ADDR (regs, i), 2); + memcpy (val, FXSAVE_ADDR (tdep, regs, i), 2); val[2] = val[3] = 0; - if (i == I387_FOP_REGNUM) + if (i == I387_FOP_REGNUM (tdep)) val[1] &= ((1 << 3) - 1); - else if (i== I387_FTAG_REGNUM) + else if (i== I387_FTAG_REGNUM (tdep)) { /* The fxsave area contains a simplified version of the tag word. We have to look at the actual 80-bit @@ -598,7 +568,8 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave) int fpreg; int top; - top = ((FXSAVE_ADDR (regs, I387_FSTAT_REGNUM))[1] >> 3); + top = ((FXSAVE_ADDR (tdep, regs, + I387_FSTAT_REGNUM (tdep)))[1] >> 3); top &= 0x7; for (fpreg = 7; fpreg >= 0; fpreg--) @@ -607,8 +578,9 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave) if (val[0] & (1 << fpreg)) { - int regnum = (fpreg + 8 - top) % 8 + I387_ST0_REGNUM; - tag = i387_tag (FXSAVE_ADDR (regs, regnum)); + int regnum = (fpreg + 8 - top) % 8 + + I387_ST0_REGNUM (tdep); + tag = i387_tag (FXSAVE_ADDR (tdep, regs, regnum)); } else tag = 3; /* Empty */ @@ -621,20 +593,17 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave) regcache_raw_supply (regcache, i, val); } else - regcache_raw_supply (regcache, i, FXSAVE_ADDR (regs, i)); + regcache_raw_supply (regcache, i, FXSAVE_ADDR (tdep, regs, i)); } - if (regnum == I387_MXCSR_REGNUM || regnum == -1) + if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1) { if (regs == NULL) - regcache_raw_supply (regcache, I387_MXCSR_REGNUM, NULL); + regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), NULL); else - regcache_raw_supply (regcache, I387_MXCSR_REGNUM, + regcache_raw_supply (regcache, I387_MXCSR_REGNUM (tdep), FXSAVE_MXCSR_ADDR (regs)); } - -#undef I387_ST0_REGNUM -#undef I387_NUM_XMM_REGS } /* Fill register REGNUM (if it is a floating-point or SSE register) in @@ -645,39 +614,33 @@ i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave) void i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave) { - struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); - char *regs = fxsave; + struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + gdb_byte *regs = fxsave; int i; gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM); gdb_assert (tdep->num_xmm_regs > 0); - /* Define I387_ST0_REGNUM and I387_NUM_XMM_REGS such that we use the - proper definitions for REGCACHE's architecture. */ - -#define I387_ST0_REGNUM tdep->st0_regnum -#define I387_NUM_XMM_REGS tdep->num_xmm_regs - - for (i = I387_ST0_REGNUM; i < I387_MXCSR_REGNUM; i++) + for (i = I387_ST0_REGNUM (tdep); i < I387_MXCSR_REGNUM (tdep); i++) if (regnum == -1 || regnum == i) { /* Most of the FPU control registers occupy only 16 bits in the fxsave area. Give those a special treatment. */ - if (i >= I387_FCTRL_REGNUM && i < I387_XMM0_REGNUM - && i != I387_FIOFF_REGNUM && i != I387_FOOFF_REGNUM) + if (i >= I387_FCTRL_REGNUM (tdep) && i < I387_XMM0_REGNUM (tdep) + && i != I387_FIOFF_REGNUM (tdep) && i != I387_FOOFF_REGNUM (tdep)) { - unsigned char buf[4]; + gdb_byte buf[4]; regcache_raw_collect (regcache, i, buf); - if (i == I387_FOP_REGNUM) + if (i == I387_FOP_REGNUM (tdep)) { /* The opcode occupies only 11 bits. Make sure we don't touch the other bits. */ buf[1] &= ((1 << 3) - 1); - buf[1] |= ((FXSAVE_ADDR (regs, i))[1] & ~((1 << 3) - 1)); + buf[1] |= ((FXSAVE_ADDR (tdep, regs, i))[1] & ~((1 << 3) - 1)); } - else if (i == I387_FTAG_REGNUM) + else if (i == I387_FTAG_REGNUM (tdep)) { /* Converting back is much easier. */ @@ -696,36 +659,22 @@ i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave) buf[0] |= (1 << fpreg); } } - memcpy (FXSAVE_ADDR (regs, i), buf, 2); + memcpy (FXSAVE_ADDR (tdep, regs, i), buf, 2); } else - regcache_raw_collect (regcache, i, FXSAVE_ADDR (regs, i)); + regcache_raw_collect (regcache, i, FXSAVE_ADDR (tdep, regs, i)); } - if (regnum == I387_MXCSR_REGNUM || regnum == -1) - regcache_raw_collect (regcache, I387_MXCSR_REGNUM, + if (regnum == I387_MXCSR_REGNUM (tdep) || regnum == -1) + regcache_raw_collect (regcache, I387_MXCSR_REGNUM (tdep), FXSAVE_MXCSR_ADDR (regs)); - -#undef I387_ST0_REGNUM -#undef I387_NUM_XMM_REGS -} - -/* Fill register REGNUM (if it is a floating-point or SSE register) in - *FXSAVE with the value in GDB's register cache. If REGNUM is -1, do - this for all registers. This function doesn't touch any of the - reserved bits in *FXSAVE. */ - -void -i387_fill_fxsave (void *fxsave, int regnum) -{ - i387_collect_fxsave (current_regcache, regnum, fxsave); } /* Recreate the FTW (tag word) valid bits from the 80-bit FP data in *RAW. */ static int -i387_tag (const unsigned char *raw) +i387_tag (const gdb_byte *raw) { int integer; unsigned int exponent; @@ -778,22 +727,17 @@ i387_return_value (struct gdbarch *gdbarch, struct regcache *regcache) struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); ULONGEST fstat; - /* Define I387_ST0_REGNUM such that we use the proper - definitions for the architecture. */ -#define I387_ST0_REGNUM tdep->st0_regnum - /* Set the top of the floating-point register stack to 7. The actual value doesn't really matter, but 7 is what a normal function return would end up with if the program started out with a freshly initialized FPU. */ - regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM, &fstat); + regcache_raw_read_unsigned (regcache, I387_FSTAT_REGNUM (tdep), &fstat); fstat |= (7 << 11); - regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM, fstat); + regcache_raw_write_unsigned (regcache, I387_FSTAT_REGNUM (tdep), fstat); /* Mark %st(1) through %st(7) as empty. Since we set the top of the floating-point register stack to 7, the appropriate value for the tag word is 0x3fff. */ - regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM, 0x3fff); + regcache_raw_write_unsigned (regcache, I387_FTAG_REGNUM (tdep), 0x3fff); -#undef I387_ST0_REGNUM }