From patchwork Tue Jun 13 11:29:22 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yao Qi X-Patchwork-Id: 20984 Received: (qmail 104999 invoked by alias); 13 Jun 2017 11:29:27 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 104872 invoked by uid 89); 13 Jun 2017 11:29:26 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.8 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=8488, hate X-HELO: mail-it0-f52.google.com Received: from mail-it0-f52.google.com (HELO mail-it0-f52.google.com) (209.85.214.52) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 13 Jun 2017 11:29:22 +0000 Received: by mail-it0-f52.google.com with SMTP id x129so1838215ite.0 for ; Tue, 13 Jun 2017 04:29:27 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id; bh=1Tl1ck7/x2ZOlC+A6abBmIRze8YmbQlDAXpdRxlhs0k=; b=WwGk0hJXkXneVVA41OkQESbx9kjudGymno4FQEGMwy3MRcMaZerq0KFo0JtN7pslRL AMOdMs4GSbb+5sSHgRkodhNoGnqVJcSTxS1VEJgkyod3g9mbUK4JCDQmMV6skW2RhCI1 xwWmep83JI1GlIehP9bzg3L09vdA6dhKNYlG6f8/aZaivCtj/bxCzCF/u1i6mCrXNSSO gPzkwNjSJbj/G/fTh7aXP5hvAYPDswPayV5W9MXe2lEakb8V/yFaqXQGj9HmKJghWXkb bZvXeupwwYA9tHkv/Nc7R77iOVa9IpUcEgEkQI2rDdWWJpGoXnSlkMguefGorwWE1SWj pxgQ== X-Gm-Message-State: AODbwcDFaMcv+TC0Upq3a5cD606R53SK6lIu0AOW0V1kcw5jJsxsWMi9 ApPlHjH2xAsH1TWn X-Received: by 10.36.189.134 with SMTP id x128mr16174141ite.27.1497353365408; Tue, 13 Jun 2017 04:29:25 -0700 (PDT) Received: from E107787-LIN.cambridge.arm.com (static.42.136.251.148.clients.your-server.de. [148.251.136.42]) by smtp.gmail.com with ESMTPSA id m129sm6252518iom.27.2017.06.13.04.29.24 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 13 Jun 2017 04:29:25 -0700 (PDT) From: Yao Qi X-Google-Original-From: Yao Qi To: gdb-patches@sourceware.org Subject: [RFC] LONGEST and ULONGEST function template instantiation Date: Tue, 13 Jun 2017 12:29:22 +0100 Message-Id: <1497353362-14441-1-git-send-email-yao.qi@linaro.org> X-IsSubscribed: yes This patch converts functions extract_{unsigned,signed}_integer to a function template extract_integer, which has two instantiations. It also does the similar changes to store__{unsigned,signed}_integer, regcache::raw_read_{unsigned,signed}, regcache::raw_write_{unsigned,signed}, regcache::cooked_read_{unsigned,signed}, regcache::cooked_write_{unsigned,signed}. It is an RFC, because I am not sure people like it or hate it :) This patch was posted here https://sourceware.org/ml/gdb-patches/2017-05/msg00492.html but the problem was fixed in a different way. However, I think the patch is still useful to shorten the code. The patch increase the binary code size (measured on x86_64-linux), from $ size ./gdb text data bss dec hex filename 23856767 2395936 364616 26617319 19625e7 ./gdb to $ size ./gdb text data bss dec hex filename 23858667 2395936 364616 26619219 1962d53 ./gdb The patch is tested on x86_64-linux. gdb: 2017-06-13 Alan Hayward Yao Qi * defs.h (LongType): New alias. (extract_signed_integer): Remove declaration. (extract_unsigned_integer): Likewise. (extract_integer): New function template. (extract_unsigned_integer): New macro. (extract_signed_integer): New macro. (store_integer): New function template. (store_signed_integer): New macro. (store_unsigned_integer): New macro. * findvar.c (extract_signed_integer): Remove. (extract_unsigned_integer): Remove. (store_signed_integer): Remove. (store_unsigned_integer): Remove. * regcache.c (regcache_raw_read_signed): Update. (regcache::raw_read_signed): Remove. (regcache::raw_read): New function. (regcache::raw_read_unsigned): Remove. (regcache_raw_read_unsigned): Update. (regcache_raw_write_unsigned): Update. (regcache::raw_write_signed): Remove. (regcache::raw_write): New function. (regcache_cooked_read_signed): Update. (regcache::raw_write_unsigned): Remove. (regcache::cooked_read_signed): Remove. (regcache_cooked_read_unsigned): Update. (regcache::cooked_read_unsigned): Remove. (regcache_cooked_write_signed): Update. (regcache_cooked_write_unsigned): Update. * regcache.h (regcache) : Remove. : Remove. : New. : Remove. : Remove. : New. * sh64-tdep.c (sh64_pseudo_register_read): Update. (sh64_pseudo_register_write): Update. --- gdb/defs.h | 108 +++++++++++++++++++++++++++++++++++++++++++---- gdb/findvar.c | 127 +------------------------------------------------------- gdb/regcache.c | 124 +++++++++++++++++------------------------------------- gdb/regcache.h | 36 +++++++++------- gdb/sh64-tdep.c | 12 +++--- 5 files changed, 166 insertions(+), 241 deletions(-) diff --git a/gdb/defs.h b/gdb/defs.h index a1a97bb..5ef94f5 100644 --- a/gdb/defs.h +++ b/gdb/defs.h @@ -627,6 +627,11 @@ enum symbol_needs_kind SYMBOL_NEEDS_FRAME }; +template +using LongType = typename std::enable_if<(std::is_same::value + || std::is_same::value), + T>::type; + /* Dynamic target-system-dependent parameters for GDB. */ #include "gdbarch.h" @@ -637,11 +642,61 @@ enum { MAX_REGISTER_SIZE = 64 }; /* In findvar.c. */ -extern LONGEST extract_signed_integer (const gdb_byte *, int, - enum bfd_endian); +/* All 'extract' functions return a host-format integer from a target-format + integer at ADDR which is LEN bytes long. */ -extern ULONGEST extract_unsigned_integer (const gdb_byte *, int, - enum bfd_endian); +template +LongType +extract_integer (const gdb_byte *addr, int len, enum bfd_endian byte_order) +{ + T retval = 0; + const unsigned char *p; + const unsigned char *startaddr = addr; + const unsigned char *endaddr = startaddr + len; + + if (len > (int) sizeof (T)) + error (_("\ +That operation is not available on integers of more than %d bytes."), + (int) sizeof (T)); + + /* Start at the most significant end of the integer, and work towards + the least significant. */ + if (byte_order == BFD_ENDIAN_BIG) + { + p = startaddr; + if (std::is_signed::value) + { + /* Do the sign extension once at the start. */ + retval = ((LONGEST) * p ^ 0x80) - 0x80; + ++p; + } + for (; p < endaddr; ++p) + retval = (retval << 8) | *p; + } + else + { + p = endaddr - 1; + if (std::is_signed::value) + { + /* Do the sign extension once at the start. */ + retval = ((LONGEST) * p ^ 0x80) - 0x80; + --p; + } + for (; p >= startaddr; --p) + retval = (retval << 8) | *p; + } + return retval; +} + +template ULONGEST extract_integer + (const gdb_byte *addr, int len, enum bfd_endian byte_order); + +template LONGEST extract_integer + (const gdb_byte *addr, int len, enum bfd_endian byte_order); + +#define extract_unsigned_integer extract_integer + +#define extract_signed_integer extract_integer extern int extract_long_unsigned_integer (const gdb_byte *, int, enum bfd_endian, LONGEST *); @@ -649,11 +704,48 @@ extern int extract_long_unsigned_integer (const gdb_byte *, int, extern CORE_ADDR extract_typed_address (const gdb_byte *buf, struct type *type); -extern void store_signed_integer (gdb_byte *, int, - enum bfd_endian, LONGEST); +/* All 'store' functions accept a host-format integer and store a + target-format integer at ADDR which is LEN bytes long. */ -extern void store_unsigned_integer (gdb_byte *, int, - enum bfd_endian, ULONGEST); +template +typename std::enable_if<(std::is_same::value + || std::is_same::value), + void>::type +store_integer (gdb_byte *addr, int len, enum bfd_endian byte_order, + T val) +{ + gdb_byte *p; + gdb_byte *startaddr = addr; + gdb_byte *endaddr = startaddr + len; + + /* Start at the least significant end of the integer, and work towards + the most significant. */ + if (byte_order == BFD_ENDIAN_BIG) + { + for (p = endaddr - 1; p >= startaddr; --p) + { + *p = val & 0xff; + val >>= 8; + } + } + else + { + for (p = startaddr; p < endaddr; ++p) + { + *p = val & 0xff; + val >>= 8; + } + } +} + +template void store_integer (gdb_byte *addr, int len, + enum bfd_endian byte_order, ULONGEST val); +template void store_integer (gdb_byte *addr, int len, + enum bfd_endian byte_order, LONGEST val); + +#define store_signed_integer store_integer + +#define store_unsigned_integer store_integer extern void store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr); diff --git a/gdb/findvar.c b/gdb/findvar.c index 6c18e25..4caf125 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -35,9 +35,7 @@ #include "dwarf2loc.h" #include "selftest.h" -/* Basic byte-swapping routines. All 'extract' functions return a - host-format integer from a target-format integer at ADDR which is - LEN bytes long. */ +/* Basic byte-swapping routines. */ #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8 /* 8 bit characters are a pretty safe assumption these days, so we @@ -47,70 +45,6 @@ you lose #endif -LONGEST -extract_signed_integer (const gdb_byte *addr, int len, - enum bfd_endian byte_order) -{ - LONGEST retval; - const unsigned char *p; - const unsigned char *startaddr = addr; - const unsigned char *endaddr = startaddr + len; - - if (len > (int) sizeof (LONGEST)) - error (_("\ -That operation is not available on integers of more than %d bytes."), - (int) sizeof (LONGEST)); - - /* Start at the most significant end of the integer, and work towards - the least significant. */ - if (byte_order == BFD_ENDIAN_BIG) - { - p = startaddr; - /* Do the sign extension once at the start. */ - retval = ((LONGEST) * p ^ 0x80) - 0x80; - for (++p; p < endaddr; ++p) - retval = (retval << 8) | *p; - } - else - { - p = endaddr - 1; - /* Do the sign extension once at the start. */ - retval = ((LONGEST) * p ^ 0x80) - 0x80; - for (--p; p >= startaddr; --p) - retval = (retval << 8) | *p; - } - return retval; -} - -ULONGEST -extract_unsigned_integer (const gdb_byte *addr, int len, - enum bfd_endian byte_order) -{ - ULONGEST retval; - const unsigned char *p; - const unsigned char *startaddr = addr; - const unsigned char *endaddr = startaddr + len; - - if (len > (int) sizeof (ULONGEST)) - error (_("\ -That operation is not available on integers of more than %d bytes."), - (int) sizeof (ULONGEST)); - - /* Start at the most significant end of the integer, and work towards - the least significant. */ - retval = 0; - if (byte_order == BFD_ENDIAN_BIG) - { - for (p = startaddr; p < endaddr; ++p) - retval = (retval << 8) | *p; - } - else - { - for (p = endaddr - 1; p >= startaddr; --p) - retval = (retval << 8) | *p; - } - return retval; -} /* Sometimes a long long unsigned integer can be extracted as a LONGEST value. This is done so that we can print these values @@ -178,65 +112,6 @@ extract_typed_address (const gdb_byte *buf, struct type *type) return gdbarch_pointer_to_address (get_type_arch (type), type, buf); } -/* All 'store' functions accept a host-format integer and store a - target-format integer at ADDR which is LEN bytes long. */ - -void -store_signed_integer (gdb_byte *addr, int len, - enum bfd_endian byte_order, LONGEST val) -{ - gdb_byte *p; - gdb_byte *startaddr = addr; - gdb_byte *endaddr = startaddr + len; - - /* Start at the least significant end of the integer, and work towards - the most significant. */ - if (byte_order == BFD_ENDIAN_BIG) - { - for (p = endaddr - 1; p >= startaddr; --p) - { - *p = val & 0xff; - val >>= 8; - } - } - else - { - for (p = startaddr; p < endaddr; ++p) - { - *p = val & 0xff; - val >>= 8; - } - } -} - -void -store_unsigned_integer (gdb_byte *addr, int len, - enum bfd_endian byte_order, ULONGEST val) -{ - unsigned char *p; - unsigned char *startaddr = (unsigned char *) addr; - unsigned char *endaddr = startaddr + len; - - /* Start at the least significant end of the integer, and work towards - the most significant. */ - if (byte_order == BFD_ENDIAN_BIG) - { - for (p = endaddr - 1; p >= startaddr; --p) - { - *p = val & 0xff; - val >>= 8; - } - } - else - { - for (p = startaddr; p < endaddr; ++p) - { - *p = val & 0xff; - val >>= 8; - } - } -} - /* Store the address ADDR as a pointer of type TYPE at BUF, in target form. */ void diff --git a/gdb/regcache.c b/gdb/regcache.c index 43ea430..4ec33d4 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -662,11 +662,14 @@ enum register_status regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val) { gdb_assert (regcache != NULL); - return regcache->raw_read_signed (regnum, val); + return regcache->raw_read (regnum, val); } -enum register_status -regcache::raw_read_signed (int regnum, LONGEST *val) +template +typename std::enable_if<(std::is_same::value + || std::is_same::value), + enum register_status>::type +regcache::raw_read (int regnum, T *val) { gdb_byte *buf; enum register_status status; @@ -675,9 +678,9 @@ regcache::raw_read_signed (int regnum, LONGEST *val) buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); status = raw_read (regnum, buf); if (status == REG_VALID) - *val = extract_signed_integer - (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch)); + *val = extract_integer (buf, + m_descr->sizeof_register[regnum], + gdbarch_byte_order (m_descr->gdbarch)); else *val = 0; return status; @@ -688,44 +691,28 @@ regcache_raw_read_unsigned (struct regcache *regcache, int regnum, ULONGEST *val) { gdb_assert (regcache != NULL); - return regcache->raw_read_unsigned (regnum, val); -} - - -enum register_status -regcache::raw_read_unsigned (int regnum, ULONGEST *val) -{ - gdb_byte *buf; - enum register_status status; - - gdb_assert (regnum >= 0 && regnum < m_descr->nr_raw_registers); - buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); - status = raw_read (regnum, buf); - if (status == REG_VALID) - *val = extract_unsigned_integer - (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch)); - else - *val = 0; - return status; + return regcache->raw_read (regnum, val); } void regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val) { gdb_assert (regcache != NULL); - regcache->raw_write_signed (regnum, val); + regcache->raw_write (regnum, val); } -void -regcache::raw_write_signed (int regnum, LONGEST val) +template +typename std::enable_if<(std::is_same::value + || std::is_same::value), + void>::type +regcache::raw_write (int regnum, T val) { gdb_byte *buf; gdb_assert (regnum >=0 && regnum < m_descr->nr_raw_registers); buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); - store_signed_integer (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch), val); + store_integer (buf, m_descr->sizeof_register[regnum], + gdbarch_byte_order (m_descr->gdbarch), val); raw_write (regnum, buf); } @@ -734,19 +721,7 @@ regcache_raw_write_unsigned (struct regcache *regcache, int regnum, ULONGEST val) { gdb_assert (regcache != NULL); - regcache->raw_write_unsigned (regnum, val); -} - -void -regcache::raw_write_unsigned (int regnum, ULONGEST val) -{ - gdb_byte *buf; - - gdb_assert (regnum >=0 && regnum < m_descr->nr_raw_registers); - buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); - store_unsigned_integer (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch), val); - raw_write (regnum, buf); + regcache->raw_write (regnum, val); } LONGEST @@ -857,11 +832,14 @@ regcache_cooked_read_signed (struct regcache *regcache, int regnum, LONGEST *val) { gdb_assert (regcache != NULL); - return regcache->cooked_read_signed (regnum, val); + return regcache->cooked_read (regnum, val); } -enum register_status -regcache::cooked_read_signed (int regnum, LONGEST *val) +template +typename std::enable_if<(std::is_same::value + || std::is_same::value), + enum register_status>::type +regcache::cooked_read (int regnum, T *val) { enum register_status status; gdb_byte *buf; @@ -870,9 +848,8 @@ regcache::cooked_read_signed (int regnum, LONGEST *val) buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); status = cooked_read (regnum, buf); if (status == REG_VALID) - *val = extract_signed_integer - (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch)); + *val = extract_integer(buf, m_descr->sizeof_register[regnum], + gdbarch_byte_order (m_descr->gdbarch)); else *val = 0; return status; @@ -883,25 +860,7 @@ regcache_cooked_read_unsigned (struct regcache *regcache, int regnum, ULONGEST *val) { gdb_assert (regcache != NULL); - return regcache->cooked_read_unsigned (regnum, val); -} - -enum register_status -regcache::cooked_read_unsigned (int regnum, ULONGEST *val) -{ - enum register_status status; - gdb_byte *buf; - - gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers); - buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); - status = cooked_read (regnum, buf); - if (status == REG_VALID) - *val = extract_unsigned_integer - (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch)); - else - *val = 0; - return status; + return regcache->cooked_read (regnum, val); } void @@ -909,18 +868,21 @@ regcache_cooked_write_signed (struct regcache *regcache, int regnum, LONGEST val) { gdb_assert (regcache != NULL); - regcache->cooked_write_signed (regnum, val); + regcache->cooked_write (regnum, val); } -void -regcache::cooked_write_signed (int regnum, LONGEST val) +template +typename std::enable_if<(std::is_same::value + || std::is_same::value), + void>::type +regcache::cooked_write (int regnum, T val) { gdb_byte *buf; gdb_assert (regnum >=0 && regnum < m_descr->nr_cooked_registers); buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); - store_signed_integer (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch), val); + store_integer (buf, m_descr->sizeof_register[regnum], + gdbarch_byte_order (m_descr->gdbarch), val); cooked_write (regnum, buf); } @@ -929,19 +891,7 @@ regcache_cooked_write_unsigned (struct regcache *regcache, int regnum, ULONGEST val) { gdb_assert (regcache != NULL); - regcache->cooked_write_unsigned (regnum, val); -} - -void -regcache::cooked_write_unsigned (int regnum, ULONGEST val) -{ - gdb_byte *buf; - - gdb_assert (regnum >=0 && regnum < m_descr->nr_cooked_registers); - buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]); - store_unsigned_integer (buf, m_descr->sizeof_register[regnum], - gdbarch_byte_order (m_descr->gdbarch), val); - cooked_write (regnum, buf); + regcache->cooked_write (regnum, val); } /* See regcache.h. */ diff --git a/gdb/regcache.h b/gdb/regcache.h index 4cf27a0..9ba3cf8 100644 --- a/gdb/regcache.h +++ b/gdb/regcache.h @@ -282,23 +282,31 @@ public: #endif void raw_write (int regnum, const gdb_byte *buf); - enum register_status raw_read_signed (int regnum, LONGEST *val); - - void raw_write_signed (int regnum, LONGEST val); - - enum register_status raw_read_unsigned (int regnum, ULONGEST *val); - - void raw_write_unsigned (int regnum, ULONGEST val); + template + typename std::enable_if<(std::is_same::value + || std::is_same::value), + enum register_status>::type + raw_read (int regnum, T *val); + + template + typename std::enable_if<(std::is_same::value + || std::is_same::value), + void>::type + raw_write (int regnum, T val); struct value *cooked_read_value (int regnum); - enum register_status cooked_read_signed (int regnum, LONGEST *val); - - void cooked_write_signed (int regnum, LONGEST val); - - enum register_status cooked_read_unsigned (int regnum, ULONGEST *val); - - void cooked_write_unsigned (int regnum, ULONGEST val); + template + typename std::enable_if<(std::is_same::value + || std::is_same::value), + enum register_status>::type + cooked_read (int regnum, T *val); + + template + typename std::enable_if<(std::is_same::value + || std::is_same::value), + void>::type + cooked_write (int regnum, T val); void raw_update (int regnum); diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c index dd18e9f..5aeb235 100644 --- a/gdb/sh64-tdep.c +++ b/gdb/sh64-tdep.c @@ -1665,11 +1665,11 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache, */ /* *INDENT-ON* */ /* Get FPSCR as an int. */ - status = regcache->raw_read_unsigned (fpscr_base_regnum, &fpscr_value); + status = regcache->raw_read (fpscr_base_regnum, &fpscr_value); if (status != REG_VALID) return status; /* Get SR as an int. */ - status = regcache->raw_read_unsigned (sr_base_regnum, &sr_value); + status = regcache->raw_read (sr_base_regnum, &sr_value); if (status != REG_VALID) return status; /* Build the new value. */ @@ -1847,15 +1847,15 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache, fpscr_value = fpscr_c_value & fpscr_mask; sr_value = (fpscr_value & sr_mask) >> 6; - regcache->raw_read_unsigned (fpscr_base_regnum, &old_fpscr_value); + regcache->raw_read (fpscr_base_regnum, &old_fpscr_value); old_fpscr_value &= 0xfffc0002; fpscr_value |= old_fpscr_value; - regcache->raw_write_unsigned (fpscr_base_regnum, fpscr_value); + regcache->raw_write (fpscr_base_regnum, fpscr_value); - regcache->raw_read_unsigned (sr_base_regnum, &old_sr_value); + regcache->raw_read (sr_base_regnum, &old_sr_value); old_sr_value &= 0xffff8fff; sr_value |= old_sr_value; - regcache->raw_write_unsigned (sr_base_regnum, sr_value); + regcache->raw_write (sr_base_regnum, sr_value); } else if (reg_nr == FPUL_C_REGNUM)