Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset c127e1c in mainline


Ignore:
Timestamp:
2012-04-11T15:37:01Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
49a736e2
Parents:
3a01483 (diff), d11a181 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Mainline changes.

Files:
2 added
10 deleted
54 edited
3 moved

Legend:

Unmodified
Added
Removed
  • boot/arch/arm32/Makefile.inc

    r3a01483 rc127e1c  
    4949BITS = 32
    5050ENDIANESS = LE
     51EXTRA_CFLAGS = -march=armv4
    5152
    5253ifeq ($(MACHINE), gta02)
     
    7374SOURCES = \
    7475        arch/$(BARCH)/src/asm.S \
     76        arch/$(BARCH)/src/eabi.S \
    7577        arch/$(BARCH)/src/main.c \
    7678        arch/$(BARCH)/src/mm.c \
  • boot/arch/arm32/src/asm.S

    r3a01483 rc127e1c  
    6060        # before passing control to the copied code.
    6161        #
    62         bx r0
     62        mov pc, r0
  • boot/genarch/include/division.h

    r3a01483 rc127e1c  
    3333#define BOOT_DIVISION_H_
    3434
    35 /* 32bit integer division */
    3635extern int __divsi3(int, int);
    37 
    38 /* 64bit integer division */
    3936extern long long __divdi3(long long, long long);
    4037
    41 /* 32bit unsigned integer division */
    4238extern unsigned int __udivsi3(unsigned int, unsigned int);
    43 
    44 /* 64bit unsigned integer division */
    4539extern unsigned long long __udivdi3(unsigned long long, unsigned long long);
    4640
    47 /* 32bit remainder of the signed division */
    4841extern int __modsi3(int, int);
    49 
    50 /* 64bit remainder of the signed division */
    5142extern long long __moddi3(long long, long long);
    5243
    53 /* 32bit remainder of the unsigned division */
    5444extern unsigned int __umodsi3(unsigned int, unsigned int);
    55 
    56 /* 64bit remainder of the unsigned division */
    5745extern unsigned long long __umoddi3(unsigned long long, unsigned long long);
    5846
     47extern int __divmodsi3(int, int, int *);
     48extern unsigned int __udivmodsi3(unsigned int, unsigned int, unsigned int *);
     49
     50extern long long __divmoddi3(long long, long long, long long *);
    5951extern unsigned long long __udivmoddi3(unsigned long long, unsigned long long,
    6052    unsigned long long *);
  • boot/genarch/src/division.c

    r3a01483 rc127e1c  
    7373{
    7474        unsigned long long result;
    75         int steps = sizeof(unsigned long long) * 8; 
     75        int steps = sizeof(unsigned long long) * 8;
    7676       
    7777        *remainder = 0;
     
    104104
    105105/* 32bit integer division */
    106 int __divsi3(int a, int b) 
     106int __divsi3(int a, int b)
    107107{
    108108        unsigned int rem;
     
    116116
    117117/* 64bit integer division */
    118 long long __divdi3(long long a, long long b) 
     118long long __divdi3(long long a, long long b)
    119119{
    120120        unsigned long long rem;
     
    155155
    156156/* 64bit remainder of the signed division */
    157 long long __moddi3(long long a,long long b)
     157long long __moddi3(long long a, long long b)
    158158{
    159159        unsigned long long rem;
     
    183183}
    184184
     185int __divmodsi3(int a, int b, int *c)
     186{
     187        unsigned int rem;
     188        int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
     189       
     190        if (SGN(a) == SGN(b)) {
     191                *c = rem;
     192                return result;
     193        }
     194       
     195        *c = -rem;
     196        return -result;
     197}
     198
     199unsigned int __udivmodsi3(unsigned int a, unsigned int b,
     200    unsigned int *c)
     201{
     202        return divandmod32(a, b, c);
     203}
     204
     205long long __divmoddi3(long long a, long long b, long long *c)
     206{
     207        unsigned long long rem;
     208        long long result = (int) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
     209       
     210        if (SGN(a) == SGN(b)) {
     211                *c = rem;
     212                return result;
     213        }
     214       
     215        *c = -rem;
     216        return -result;
     217}
     218
    185219unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b,
    186220    unsigned long long *c)
  • boot/generic/src/str.c

    r3a01483 rc127e1c  
    100100#include <str.h>
    101101#include <errno.h>
     102
     103/** Check the condition if wchar_t is signed */
     104#ifdef WCHAR_IS_UNSIGNED
     105        #define WCHAR_SIGNED_CHECK(cond)  (true)
     106#else
     107        #define WCHAR_SIGNED_CHECK(cond)  (cond)
     108#endif
    102109
    103110/** Byte mask consisting of lowest @n bits (out of 8) */
     
    198205 *         code was invalid.
    199206 */
    200 int chr_encode(wchar_t ch, char *str, size_t *offset, size_t size)
     207int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
    201208{
    202209        if (*offset >= size)
     
    325332bool ascii_check(wchar_t ch)
    326333{
    327         if ((ch >= 0) && (ch <= 127))
     334        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
    328335                return true;
    329336       
     
    338345bool chr_check(wchar_t ch)
    339346{
    340         if ((ch >= 0) && (ch <= 1114111))
     347        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
    341348                return true;
    342349       
  • kernel/arch/arm32/Makefile.inc

    r3a01483 rc127e1c  
    3333ATSIGN = %
    3434
    35 GCC_CFLAGS += -fno-zero-initialized-in-bss -mapcs-frame
     35GCC_CFLAGS += -march=armv4
    3636
    3737BITS = 32
     
    4141        arch/$(KARCH)/src/start.S \
    4242        arch/$(KARCH)/src/asm.S \
     43        arch/$(KARCH)/src/eabi.S \
    4344        arch/$(KARCH)/src/exc_handler.S \
    4445        arch/$(KARCH)/src/arm32.c \
  • kernel/arch/arm32/src/mach/testarm/testarm.c

    r3a01483 rc127e1c  
    121121                }
    122122        }
    123 
     123       
    124124        /*
    125125         * This is the necessary evil until the userspace driver is entirely
     
    172172        clock();
    173173        spinlock_lock(&irq->lock);
    174 
     174       
    175175        /* acknowledge tick */
    176176        *((uint32_t *) (gxemul_rtc + GXEMUL_RTC_ACK_OFFSET))
     
    181181static void gxemul_timer_irq_init(void)
    182182{
    183         irq_initialize(&gxemul_timer_irq);
    184         gxemul_timer_irq.devno = device_assign_devno();
    185         gxemul_timer_irq.inr = GXEMUL_TIMER_IRQ;
    186         gxemul_timer_irq.claim = gxemul_timer_claim;
    187         gxemul_timer_irq.handler = gxemul_timer_irq_handler;
    188 
    189         irq_register(&gxemul_timer_irq);
     183        irq_initialize(&gxemul_timer_irq);
     184        gxemul_timer_irq.devno = device_assign_devno();
     185        gxemul_timer_irq.inr = GXEMUL_TIMER_IRQ;
     186        gxemul_timer_irq.claim = gxemul_timer_claim;
     187        gxemul_timer_irq.handler = gxemul_timer_irq_handler;
     188       
     189        irq_register(&gxemul_timer_irq);
    190190}
    191191
     
    198198void gxemul_timer_irq_start(void)
    199199{
    200         gxemul_timer_irq_init();
    201         gxemul_timer_start(GXEMUL_TIMER_FREQ);
     200        gxemul_timer_irq_init();
     201        gxemul_timer_start(GXEMUL_TIMER_FREQ);
    202202}
    203203
     
    227227        uint32_t sources = gxemul_irqc_get_sources();
    228228        unsigned int i;
    229 
     229       
    230230        for (i = 0; i < GXEMUL_IRQ_COUNT; i++) {
    231231                if (sources & (1 << i)) {
  • kernel/genarch/include/softint/division.h

    r3a01483 rc127e1c  
    3636#define KERN_DIVISION_H_
    3737
    38 /* 32bit integer division */
    39 int __divsi3(int a, int b);
     38extern int __divsi3(int, int);
     39extern long long __divdi3(long long, long long);
    4040
    41 /* 64bit integer division */
    42 long long __divdi3(long long a, long long b);
     41extern unsigned int __udivsi3(unsigned int, unsigned int);
     42extern unsigned long long __udivdi3(unsigned long long, unsigned long long);
    4343
    44 /* 32bit unsigned integer division */
    45 unsigned int __udivsi3(unsigned int a, unsigned int b);
     44extern int __modsi3(int, int);
     45extern long long __moddi3(long long, long long);
    4646
    47 /* 64bit unsigned integer division */
    48 unsigned long long __udivdi3(unsigned long long a, unsigned long long b);
     47extern unsigned int __umodsi3(unsigned int, unsigned int);
     48extern unsigned long long __umoddi3(unsigned long long, unsigned long long);
    4949
    50 /* 32bit remainder of the signed division */
    51 int __modsi3(int a, int b);
     50extern int __divmodsi3(int, int, int *);
     51extern unsigned int __udivmodsi3(unsigned int, unsigned int, unsigned int *);
    5252
    53 /* 64bit remainder of the signed division */
    54 long long __moddi3(long long a, long long b);
    55 
    56 /* 32bit remainder of the unsigned division */
    57 unsigned int __umodsi3(unsigned int a, unsigned int b);
    58 
    59 /* 64bit remainder of the unsigned division */
    60 unsigned long long __umoddi3(unsigned long long a, unsigned long long b);
    61 
    62 unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b, unsigned long long *c);
     53extern long long __divmoddi3(long long, long long, long long *);
     54extern unsigned long long __udivmoddi3(unsigned long long, unsigned long long,
     55    unsigned long long *);
    6356
    6457#endif
  • kernel/genarch/include/softint/multiplication.h

    r3a01483 rc127e1c  
    2929/** @addtogroup genarch
    3030 * @{
    31  */ 
     31 */
    3232/**
    3333 * @file
    3434 */
    3535
    36 #ifndef __SOFTINT_MULTIPLICATION_H__
    37 #define __SOFTINT_MULTIPLICATION_H__
     36#ifndef KERN_MULTIPLICATION_H_
     37#define KERN_MULTIPLICATION_H_
    3838
    3939/* 64 bit multiplication */
    40 long long __muldi3(long long a, long long b);
     40extern long long __muldi3(long long, long long);
    4141
    4242#endif
     
    4444/** @}
    4545 */
    46 
    47 
  • kernel/genarch/src/softint/division.c

    r3a01483 rc127e1c  
    2727 */
    2828
    29 /** @addtogroup genarch 
     29/** @addtogroup genarch
    3030 * @{
    3131 */
     
    3535#include <genarch/softint/division.h>
    3636
    37 #define ABSVAL(x) ((x) > 0 ? (x) : -(x))
    38 #define SGN(x) ((x) >= 0 ? 1 : 0)
    39                                      
     37#define ABSVAL(x)  ((x) > 0 ? (x) : -(x))
     38#define SGN(x)     ((x) >= 0 ? 1 : 0)
     39
    4040static unsigned int divandmod32(unsigned int a, unsigned int b,
    4141    unsigned int *remainder)
     
    5656                return 0;
    5757        }
    58 
     58       
    5959        for (; steps > 0; steps--) {
    6060                /* shift one bit to remainder */
     
    6868                a <<= 1;
    6969        }
    70 
     70       
    7171        return result;
    7272}
    73 
    7473
    7574static unsigned long long divandmod64(unsigned long long a,
     
    7776{
    7877        unsigned long long result;
    79         int steps = sizeof(unsigned long long) * 8; 
     78        int steps = sizeof(unsigned long long) * 8;
    8079       
    8180        *remainder = 0;
     
    9190                return 0;
    9291        }
    93 
     92       
    9493        for (; steps > 0; steps--) {
    9594                /* shift one bit to remainder */
     
    103102                a <<= 1;
    104103        }
    105 
     104       
    106105        return result;
    107106}
    108107
    109108/* 32bit integer division */
    110 int __divsi3(int a, int b)
    111 {
    112         unsigned int rem;
    113         int result;
    114        
    115         result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
    116 
     109int __divsi3(int a, int b)
     110{
     111        unsigned int rem;
     112        int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
     113       
    117114        if (SGN(a) == SGN(b))
    118115                return result;
     116       
    119117        return -result;
    120118}
    121119
    122120/* 64bit integer division */
    123 long long __divdi3(long long a, long long b)
    124 {
    125         unsigned long long rem;
    126         long long result;
    127        
    128         result = (long long) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
    129 
     121long long __divdi3(long long a, long long b)
     122{
     123        unsigned long long rem;
     124        long long result = (long long) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
     125       
    130126        if (SGN(a) == SGN(b))
    131127                return result;
     128       
    132129        return -result;
    133130}
     
    143140unsigned long long __udivdi3(unsigned long long a, unsigned long long b)
    144141{
    145         unsigned long long  rem;
     142        unsigned long long rem;
    146143        return divandmod64(a, b, &rem);
    147144}
     
    154151       
    155152        /* if divident is negative, remainder must be too */
    156         if (!(SGN(a))) {
     153        if (!(SGN(a)))
    157154                return -((int) rem);
    158         }
    159155       
    160156        return (int) rem;
     
    162158
    163159/* 64bit remainder of the signed division */
    164 long long __moddi3(long long a,long long b)
     160long long __moddi3(long long a, long long b)
    165161{
    166162        unsigned long long rem;
     
    168164       
    169165        /* if divident is negative, remainder must be too */
    170         if (!(SGN(a))) {
     166        if (!(SGN(a)))
    171167                return -((long long) rem);
    172         }
    173168       
    174169        return (long long) rem;
     
    191186}
    192187
     188int __divmodsi3(int a, int b, int *c)
     189{
     190        unsigned int rem;
     191        int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
     192       
     193        if (SGN(a) == SGN(b)) {
     194                *c = rem;
     195                return result;
     196        }
     197       
     198        *c = -rem;
     199        return -result;
     200}
     201
     202unsigned int __udivmodsi3(unsigned int a, unsigned int b,
     203    unsigned int *c)
     204{
     205        return divandmod32(a, b, c);
     206}
     207
     208long long __divmoddi3(long long a, long long b, long long *c)
     209{
     210        unsigned long long rem;
     211        long long result = (int) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
     212       
     213        if (SGN(a) == SGN(b)) {
     214                *c = rem;
     215                return result;
     216        }
     217       
     218        *c = -rem;
     219        return -result;
     220}
     221
    193222unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b,
    194223    unsigned long long *c)
  • kernel/genarch/src/softint/multiplication.c

    r3a01483 rc127e1c  
    2929/** @addtogroup genarch
    3030 * @{
    31  */ 
     31 */
    3232/**
    3333 * @file
     
    130130
    131131        return result;
    132 }       
     132}
    133133
    134134/** @}
  • kernel/generic/src/console/console.c

    r3a01483 rc127e1c  
    5757
    5858/** Kernel log cyclic buffer */
    59 static wchar_t klog[KLOG_LENGTH] __attribute__ ((aligned (PAGE_SIZE)));
     59wchar_t klog[KLOG_LENGTH] __attribute__((aligned(PAGE_SIZE)));
    6060
    6161/** Kernel log initialized */
  • kernel/generic/src/lib/str.c

    r3a01483 rc127e1c  
    111111#include <debug.h>
    112112#include <macros.h>
     113
     114/** Check the condition if wchar_t is signed */
     115#ifdef WCHAR_IS_UNSIGNED
     116        #define WCHAR_SIGNED_CHECK(cond)  (true)
     117#else
     118        #define WCHAR_SIGNED_CHECK(cond)  (cond)
     119#endif
    113120
    114121/** Byte mask consisting of lowest @n bits (out of 8) */
     
    206213 *
    207214 * @return EOK if the character was encoded successfully, EOVERFLOW if there
    208  *         was not enough space in the output buffer or EINVAL if the character
    209  *         code was invalid.
    210  */
    211 int chr_encode(wchar_t ch, char *str, size_t *offset, size_t size)
     215 *         was not enough space in the output buffer or EINVAL if the character
     216 *         code was invalid.
     217 */
     218int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
    212219{
    213220        if (*offset >= size)
     
    427434bool ascii_check(wchar_t ch)
    428435{
    429         if ((ch >= 0) && (ch <= 127))
     436        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
    430437                return true;
    431438       
     
    440447bool chr_check(wchar_t ch)
    441448{
    442         if ((ch >= 0) && (ch <= 1114111))
     449        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
    443450                return true;
    444451       
  • tools/autotool.py

    r3a01483 rc127e1c  
    4949
    5050PACKAGE_BINUTILS = "usually part of binutils"
    51 PACKAGE_GCC = "preferably version 4.5.1 or newer"
     51PACKAGE_GCC = "preferably version 4.7.0 or newer"
    5252PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
    5353
     
    6666
    6767#define DECLARE_BUILTIN_TYPE(tag, type) \\
    68         AUTOTOOL_DECLARE("builtin", "", tag, STRING(type), "", "", sizeof(type));
     68        AUTOTOOL_DECLARE("builtin_size", "", tag, STRING(type), "", "", sizeof(type)); \\
     69        AUTOTOOL_DECLARE("builtin_sign", "unsigned long long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long long int)); \\
     70        AUTOTOOL_DECLARE("builtin_sign", "unsigned long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long int)); \\
     71        AUTOTOOL_DECLARE("builtin_sign", "unsigned int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned int)); \\
     72        AUTOTOOL_DECLARE("builtin_sign", "unsigned short int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned short int)); \\
     73        AUTOTOOL_DECLARE("builtin_sign", "unsigned char", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned char)); \\
     74        AUTOTOOL_DECLARE("builtin_sign", "signed long long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long long int)); \\
     75        AUTOTOOL_DECLARE("builtin_sign", "signed long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long int)); \\
     76        AUTOTOOL_DECLARE("builtin_sign", "signed int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed int)); \\
     77        AUTOTOOL_DECLARE("builtin_sign", "signed short int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed short int)); \\
     78        AUTOTOOL_DECLARE("builtin_sign", "signed char", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed char));
    6979
    7080#define DECLARE_INTSIZE(tag, type, strc, conc) \\
    7181        AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, strc, conc, sizeof(unsigned type)); \\
    7282        AUTOTOOL_DECLARE("intsize", "signed", tag, #type, strc, conc, sizeof(signed type));
     83
     84#define DECLARE_FLOATSIZE(tag, type) \\
     85        AUTOTOOL_DECLARE("floatsize", "", tag, #type, "", "", sizeof(type));
    7386
    7487int main(int argc, char *argv[])
     
    262275        return int(value, base)
    263276
    264 def probe_compiler(common, sizes):
     277def probe_compiler(common, intsizes, floatsizes):
    265278        "Generate, compile and parse probing source"
    266279       
     
    270283        outf.write(PROBE_HEAD)
    271284       
    272         for typedef in sizes:
     285        for typedef in intsizes:
    273286                outf.write("\tDECLARE_INTSIZE(\"%s\", %s, %s, %s);\n" % (typedef['tag'], typedef['type'], typedef['strc'], typedef['conc']))
     287       
     288        for typedef in floatsizes:
     289                outf.write("\nDECLARE_FLOATSIZE(\"%s\", %s);\n" % (typedef['tag'], typedef['type']))
    274290       
    275291        outf.write(PROBE_TAIL)
     
    315331        signed_concs = {}
    316332       
    317         builtins = {}
     333        float_tags = {}
     334       
     335        builtin_sizes = {}
     336        builtin_signs = {}
    318337       
    319338        for j in range(len(lines)):
     
    352371                                                print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_OUTPUT, j), COMPILER_FAIL])
    353372                               
    354                                 if (category == "builtin"):
     373                                if (category == "floatsize"):
    355374                                        try:
    356375                                                value_int = decode_value(value)
     
    358377                                                print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    359378                                       
    360                                         builtins[tag] = {'name': name, 'value': value_int}
    361        
    362         return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs, 'builtins': builtins}
    363 
    364 def detect_uints(probe, bytes, tags):
    365         "Detect correct types for fixed-size integer types"
     379                                        float_tags[tag] = value_int
     380                               
     381                                if (category == "builtin_size"):
     382                                        try:
     383                                                value_int = decode_value(value)
     384                                        except:
     385                                                print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
     386                                       
     387                                        builtin_sizes[tag] = {'name': name, 'value': value_int}
     388                               
     389                                if (category == "builtin_sign"):
     390                                        try:
     391                                                value_int = decode_value(value)
     392                                        except:
     393                                                print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
     394                                       
     395                                        if (value_int == 1):
     396                                                if (not tag in builtin_signs):
     397                                                        builtin_signs[tag] = strc;
     398                                                elif (builtin_signs[tag] != strc):
     399                                                        print_error(["Inconsistent builtin type detection in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
     400       
     401        return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs, 'float_tags': float_tags, 'builtin_sizes': builtin_sizes, 'builtin_signs': builtin_signs}
     402
     403def detect_sizes(probe, bytes, inttags, floattags):
     404        "Detect correct types for fixed-size types"
    366405       
    367406        macros = []
     
    370409        for b in bytes:
    371410                if (not b in probe['unsigned_sizes']):
    372                         print_error(['Unable to find appropriate unsigned integer type for %u bytes' % b,
     411                        print_error(['Unable to find appropriate unsigned integer type for %u bytes.' % b,
    373412                                     COMPILER_FAIL])
    374413               
    375414                if (not b in probe['signed_sizes']):
    376                         print_error(['Unable to find appropriate signed integer type for %u bytes' % b,
     415                        print_error(['Unable to find appropriate signed integer type for %u bytes.' % b,
    377416                                     COMPILER_FAIL])
    378417               
    379418                if (not b in probe['unsigned_strcs']):
    380                         print_error(['Unable to find appropriate unsigned printf formatter for %u bytes' % b,
     419                        print_error(['Unable to find appropriate unsigned printf formatter for %u bytes.' % b,
    381420                                     COMPILER_FAIL])
    382421               
    383422                if (not b in probe['signed_strcs']):
    384                         print_error(['Unable to find appropriate signed printf formatter for %u bytes' % b,
     423                        print_error(['Unable to find appropriate signed printf formatter for %u bytes.' % b,
    385424                                     COMPILER_FAIL])
    386425               
    387426                if (not b in probe['unsigned_concs']):
    388                         print_error(['Unable to find appropriate unsigned literal macro for %u bytes' % b,
     427                        print_error(['Unable to find appropriate unsigned literal macro for %u bytes.' % b,
    389428                                     COMPILER_FAIL])
    390429               
    391430                if (not b in probe['signed_concs']):
    392                         print_error(['Unable to find appropriate signed literal macro for %u bytes' % b,
     431                        print_error(['Unable to find appropriate signed literal macro for %u bytes.' % b,
    393432                                     COMPILER_FAIL])
    394433               
     
    417456                        macros.append({'oldmacro': "c ## %s" % name, 'newmacro': "INT%u_C(c)" % (b * 8)})
    418457       
    419         for tag in tags:
     458        for tag in inttags:
    420459                newmacro = "U%s" % tag
    421460                if (not tag in probe['unsigned_tags']):
    422                         print_error(['Unable to find appropriate size macro for %s' % newmacro,
     461                        print_error(['Unable to find appropriate size macro for %s.' % newmacro,
    423462                                     COMPILER_FAIL])
    424463               
     
    426465                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
    427466                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
     467                macros.append({'oldmacro': "1", 'newmacro': 'U%s_SIZE_%s' % (tag, probe['unsigned_tags'][tag] * 8)})
    428468               
    429469                newmacro = tag
    430                 if (not tag in probe['unsigned_tags']):
     470                if (not tag in probe['signed_tags']):
    431471                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
    432472                                     COMPILER_FAIL])
     
    435475                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
    436476                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
     477                macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['signed_tags'][tag] * 8)})
     478       
     479        for tag in floattags:
     480                if (not tag in probe['float_tags']):
     481                        print_error(['Unable to find appropriate size macro for %s' % tag,
     482                                     COMPILER_FAIL])
     483               
     484                macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['float_tags'][tag] * 8)})
     485       
     486        if (not 'size' in probe['builtin_signs']):
     487                print_error(['Unable to determine whether size_t is signed or unsigned.',
     488                             COMPILER_FAIL])
     489       
     490        if (probe['builtin_signs']['size'] != 'unsigned'):
     491                print_error(['The type size_t is not unsigned.',
     492                             COMPILER_FAIL])
    437493       
    438494        fnd = True
    439495       
    440         if (not 'wchar' in probe['builtins']):
     496        if (not 'wchar' in probe['builtin_sizes']):
    441497                print_warning(['The compiler does not provide the macro __WCHAR_TYPE__',
    442498                               'for defining the compiler-native type wchar_t. We are',
     
    445501                fnd = False
    446502       
    447         if (probe['builtins']['wchar']['value'] != 4):
     503        if (probe['builtin_sizes']['wchar']['value'] != 4):
    448504                print_warning(['The compiler provided macro __WCHAR_TYPE__ for defining',
    449505                               'the compiler-native type wchar_t is not compliant with',
     
    458514                macros.append({'oldmacro': "__WCHAR_TYPE__", 'newmacro': "wchar_t"})
    459515       
     516        if (not 'wchar' in probe['builtin_signs']):
     517                print_error(['Unable to determine whether wchar_t is signed or unsigned.',
     518                             COMPILER_FAIL])
     519       
     520        if (probe['builtin_signs']['wchar'] == 'unsigned'):
     521                macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_UNSIGNED'})
     522        if (probe['builtin_signs']['wchar'] == 'signed'):
     523                macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_SIGNED'})
     524       
    460525        fnd = True
    461526       
    462         if (not 'wint' in probe['builtins']):
     527        if (not 'wint' in probe['builtin_sizes']):
    463528                print_warning(['The compiler does not provide the macro __WINT_TYPE__',
    464529                               'for defining the compiler-native type wint_t. We are',
     
    467532                fnd = False
    468533       
    469         if (probe['builtins']['wint']['value'] != 4):
     534        if (probe['builtin_sizes']['wint']['value'] != 4):
    470535                print_warning(['The compiler provided macro __WINT_TYPE__ for defining',
    471536                               'the compiler-native type wint_t is not compliant with',
     
    479544        else:
    480545                macros.append({'oldmacro': "__WINT_TYPE__", 'newmacro': "wint_t"})
     546       
     547        if (not 'wint' in probe['builtin_signs']):
     548                print_error(['Unable to determine whether wint_t is signed or unsigned.',
     549                             COMPILER_FAIL])
     550       
     551        if (probe['builtin_signs']['wint'] == 'unsigned'):
     552                macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_UNSIGNED'})
     553        if (probe['builtin_signs']['wint'] == 'signed'):
     554                macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_SIGNED'})
    481555       
    482556        return {'macros': macros, 'typedefs': typedefs}
     
    571645                               
    572646                                if (config['CROSS_TARGET'] == "arm32"):
    573                                         gnu_target = "arm-linux-gnu"
     647                                        gnu_target = "arm-linux-gnueabi"
    574648                               
    575649                                if (config['CROSS_TARGET'] == "ia32"):
     
    586660                        if (config['PLATFORM'] == "arm32"):
    587661                                target = config['PLATFORM']
    588                                 gnu_target = "arm-linux-gnu"
     662                                gnu_target = "arm-linux-gnueabi"
    589663                       
    590664                        if (config['PLATFORM'] == "ia32"):
     
    669743                                {'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
    670744                                {'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'}
     745                        ],
     746                        [
     747                                {'type': 'long double', 'tag': 'LONG_DOUBLE'},
     748                                {'type': 'double', 'tag': 'DOUBLE'},
     749                                {'type': 'float', 'tag': 'FLOAT'}
    671750                        ]
    672751                )
    673752               
    674                 maps = detect_uints(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'])
     753                maps = detect_sizes(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'], ['LONG_DOUBLE', 'DOUBLE', 'FLOAT'])
    675754               
    676755        finally:
  • tools/toolchain.sh

    r3a01483 rc127e1c  
    5555BINUTILS_VERSION="2.22"
    5656BINUTILS_RELEASE=""
    57 GCC_VERSION="4.6.3"
     57GCC_VERSION="4.7.0"
    5858GDB_VERSION="7.4"
    5959
    6060BASEDIR="`pwd`"
    6161BINUTILS="binutils-${BINUTILS_VERSION}${BINUTILS_RELEASE}.tar.bz2"
    62 GCC_CORE="gcc-core-${GCC_VERSION}.tar.bz2"
    63 GCC_OBJC="gcc-objc-${GCC_VERSION}.tar.bz2"
    64 GCC_CPP="gcc-g++-${GCC_VERSION}.tar.bz2"
     62GCC="gcc-${GCC_VERSION}.tar.bz2"
    6563GDB="gdb-${GDB_VERSION}.tar.bz2"
    6664
     
    275273       
    276274        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "ee0f10756c84979622b992a4a61ea3f5"
    277         download_fetch "${GCC_SOURCE}" "${GCC_CORE}" "766091220c6a14fcaa2c06dd573e3758"
    278         download_fetch "${GCC_SOURCE}" "${GCC_OBJC}" "48ba23770c34b1cb468f72618b4452c5"
    279         download_fetch "${GCC_SOURCE}" "${GCC_CPP}" "37515158a0fb3d0800ec41a08c05e69e"
     275        download_fetch "${GCC_SOURCE}" "${GCC}" "2a0f1d99fda235c29d40b561f81d9a77"
    280276        download_fetch "${GDB_SOURCE}" "${GDB}" "95a9a8305fed4d30a30a6dc28ff9d060"
    281277}
     
    299295        echo ">>> Downloading tarballs"
    300296        source_check "${BASEDIR}/${BINUTILS}"
    301         source_check "${BASEDIR}/${GCC_CORE}"
    302         source_check "${BASEDIR}/${GCC_OBJC}"
    303         source_check "${BASEDIR}/${GCC_CPP}"
     297        source_check "${BASEDIR}/${GCC}"
    304298        source_check "${BASEDIR}/${GDB}"
    305299       
     
    316310       
    317311        unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
    318         unpack_tarball "${BASEDIR}/${GCC_CORE}" "GCC Core"
    319         unpack_tarball "${BASEDIR}/${GCC_OBJC}" "Objective C"
    320         unpack_tarball "${BASEDIR}/${GCC_CPP}" "C++"
     312        unpack_tarball "${BASEDIR}/${GCC}" "GCC"
    321313        unpack_tarball "${BASEDIR}/${GDB}" "GDB"
    322314       
     
    378370        "arm32")
    379371                prepare
    380                 build_target "arm32" "arm-linux-gnu"
     372                build_target "arm32" "arm-linux-gnueabi"
    381373                ;;
    382374        "ia32")
     
    415407                prepare
    416408                build_target "amd64" "amd64-linux-gnu"
    417                 build_target "arm32" "arm-linux-gnu"
     409                build_target "arm32" "arm-linux-gnueabi"
    418410                build_target "ia32" "i686-pc-linux-gnu"
    419411                build_target "ia64" "ia64-pc-linux-gnu"
     
    428420                prepare
    429421                build_target "amd64" "amd64-linux-gnu" &
    430                 build_target "arm32" "arm-linux-gnu" &
     422                build_target "arm32" "arm-linux-gnueabi" &
    431423                build_target "ia32" "i686-pc-linux-gnu" &
    432424                build_target "ia64" "ia64-pc-linux-gnu" &
  • uspace/Makefile.common

    r3a01483 rc127e1c  
    149149endif
    150150
    151 ifeq ($(STATIC_BUILD), y)
    152 BASE_LIBS = $(LIBC_PREFIX)/libc.a $(LIBSOFTINT_PREFIX)/libsoftint.a
    153 LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld
    154 else
    155 BASE_LIBS = $(LIBC_PREFIX)/libc.so0 $(LIBSOFTINT_PREFIX)/libsofti.so0
    156 LFLAGS = -Bdynamic
    157 LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
     151ifeq ($(STATIC_BUILD),y)
     152        BASE_LIBS = $(LIBC_PREFIX)/libc.a $(LIBSOFTINT_PREFIX)/libsoftint.a
     153        LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld
     154else
     155        BASE_LIBS = $(LIBC_PREFIX)/libc.so0 $(LIBSOFTINT_PREFIX)/libsofti.so0
     156        LFLAGS = -Bdynamic
     157        LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
    158158endif
    159159
  • uspace/app/binutils/Makefile

    r3a01483 rc127e1c  
    112112endif
    113113ifeq ($(PLATFORM),arm32)
    114 TARGET = arm-linux-gnu
     114TARGET = arm-linux-gnueabi
    115115endif
    116116ifeq ($(PLATFORM),ia32)
  • uspace/app/sbi/src/run_texpr.c

    r3a01483 rc127e1c  
    9898{
    9999        stree_symbol_t *sym;
    100         tdata_item_t *targ_i;
    101         tdata_item_t *titem;
     100        tdata_item_t *targ_i = NULL;
     101        tdata_item_t *titem = NULL;;
    102102        tdata_object_t *tobject;
    103103        tdata_deleg_t *tdeleg;
     
    139139                return;
    140140        }
    141 
    142         /* Make compiler happy. */
    143         titem = NULL;
    144141
    145142        switch (sym->sc) {
     
    222219    stree_tindex_t *tindex, tdata_item_t **res)
    223220{
    224         tdata_item_t *base_ti;
     221        tdata_item_t *base_ti = NULL;
    225222        tdata_item_t *titem;
    226223        tdata_array_t *tarray;
  • uspace/app/tester/fault/fault2.c

    r3a01483 rc127e1c  
    3535const char *test_fault2(void)
    3636{
    37         volatile long long var;
    38         volatile int var1;
    39        
    40         var1 = *((aliasing_int *) (((char *) (&var)) + 1));
     37        volatile long long var = 0;
     38        volatile int var1 = *((aliasing_int *) (((char *) (&var)) + 1));
    4139        printf("Read %d\n", var1);
    4240       
  • uspace/app/websrv/websrv.c

    r3a01483 rc127e1c  
    200200{
    201201        if (str_cmp(uri, "/") == 0)
    202                 uri = "/index.htm";
     202                uri = "/index.html";
    203203       
    204204        char *fname;
  • uspace/dist/data/web/index.html

    r3a01483 rc127e1c  
    1313        </p>
    1414        <p>
    15             Now <a href="foo.htm">go to page foo</a> or <a href="bar.htm">go
     15            Now <a href="foo.html">go to page foo</a> or <a href="bar.html">go
    1616            to bar</a>.
    1717        </p>
  • uspace/drv/bus/usb/ehci/res.c

    r3a01483 rc127e1c  
    237237{
    238238        assert(device);
     239        usb_log_debug("Disabling EHCI legacy support.\n");
    239240
    240241#define CHECK_RET_RETURN(ret, message...) \
     
    249250        CHECK_RET_RETURN(ret, "Failed to map registers %p: %s.\n",
    250251            (void *) reg_base, str_error(ret));
     252
     253        usb_log_debug2("Registers mapped at: %p.\n", regs);
    251254
    252255        const uint32_t hcc_params =
     
    286289        if (*usbcmd & USBCMD_RUN) {
    287290                *usbsts = 0x3f; /* ack all interrupts */
    288                 *usbint = 0; /* disable all interrutps */
    289                 *usbconf = 0; /* relase control of RH ports */
     291                *usbint = 0; /* disable all interrupts */
     292                *usbconf = 0; /* release control of RH ports */
    290293
    291294                *usbcmd = 0;
     
    297300        }
    298301        usb_log_debug("Registers: \n"
    299             "\t USBCMD: %x(0x00080000 = at least 1ms between interrupts)\n"
    300             "\t USBSTS: %x(0x00001000 = HC halted)\n"
    301             "\t USBINT: %x(0x0 = no interrupts).\n"
    302             "\t CONFIG: %x(0x0 = ports controlled by companion hc).\n",
    303             *usbcmd, *usbsts, *usbint, *usbconf);
     302            "\t USBCMD(%p): %x(0x00080000 = at least 1ms between interrupts)\n"
     303            "\t USBSTS(%p): %x(0x00001000 = HC halted)\n"
     304            "\t USBINT(%p): %x(0x0 = no interrupts).\n"
     305            "\t CONFIG(%p): %x(0x0 = ports controlled by companion hc).\n",
     306            usbcmd, *usbcmd, usbsts, *usbsts, usbint, *usbint, usbconf,*usbconf);
    304307
    305308        return ret;
  • uspace/drv/char/ns8250/ns8250.c

    r3a01483 rc127e1c  
    7474#define DLAB_MASK (1 << 7)
    7575
     76/** Interrupt Enable Register definition. */
     77#define NS8250_IER_RXREADY      (1 << 0)
     78#define NS8250_IER_THRE         (1 << 1)
     79#define NS8250_IER_RXSTATUS     (1 << 2)
     80#define NS8250_IER_MODEM_STATUS (1 << 3)
     81
     82/** Interrupt ID Register definition. */
     83#define NS8250_IID_ACTIVE       (1 << 0)
     84
     85/** FIFO Control Register definition. */
     86#define NS8250_FCR_FIFOENABLE   (1 << 0)
     87#define NS8250_FCR_RXFIFORESET  (1 << 1)
     88#define NS8250_FCR_TXFIFORESET  (1 << 2)
     89#define NS8250_FCR_DMAMODE      (1 << 3)
     90#define NS8250_FCR_RXTRIGGERLOW (1 << 6)
     91#define NS8250_FCR_RXTRIGGERHI  (1 << 7)
     92
     93/** Line Control Register definition. */
     94#define NS8250_LCR_STOPBITS     (1 << 2)
     95#define NS8250_LCR_PARITY       (1 << 3)
     96#define NS8250_LCR_SENDBREAK    (1 << 6)
     97#define NS8250_LCR_DLAB         (1 << 7)
     98
     99/** Modem Control Register definition. */
     100#define NS8250_MCR_DTR          (1 << 0)
     101#define NS8250_MCR_RTS          (1 << 1)
     102#define NS8250_MCR_OUT1         (1 << 2)
     103#define NS8250_MCR_OUT2         (1 << 3)
     104#define NS8250_MCR_LOOPBACK     (1 << 4)
     105#define NS8250_MCR_ALL          (0x1f)
     106
     107/** Line Status Register definition. */
     108#define NS8250_LSR_RXREADY      (1 << 0)
     109#define NS8250_LSR_OE           (1 << 1)
     110#define NS8250_LSR_PE           (1 << 2)
     111#define NS8250_LSR_FE           (1 << 3)
     112#define NS8250_LSR_BREAK        (1 << 4)
     113#define NS8250_LSR_THRE         (1 << 5)
     114#define NS8250_LSR_TSE          (1 << 6)
     115
     116/** Modem Status Register definition. */
     117#define NS8250_MSR_DELTACTS     (1 << 0)
     118#define NS8250_MSR_DELTADSR     (1 << 1)
     119#define NS8250_MSR_RITRAILING   (1 << 2)
     120#define NS8250_MSR_DELTADCD     (1 << 3)
     121#define NS8250_MSR_CTS          (1 << 4)
     122#define NS8250_MSR_DSR          (1 << 5)
     123#define NS8250_MSR_RI           (1 << 6)
     124#define NS8250_MSR_DCD          (1 << 7)
     125#define NS8250_MSR_SIGNALS      (NS8250_MSR_CTS | NS8250_MSR_DSR \
     126    | NS8250_MSR_RI | NS8250_MSR_DCD)
     127
    76128/** Obtain soft-state structure from function node */
    77129#define NS8250(fnode) ((ns8250_t *) ((fnode)->dev->driver_data))
     
    96148} stop_bit_t;
    97149
     150/** 8250 UART registers layout. */
     151typedef struct {
     152        ioport8_t data;         /**< Data register. */
     153        ioport8_t ier;          /**< Interrupt Enable Reg. */
     154        ioport8_t iid;          /**< Interrupt ID Reg. */
     155        ioport8_t lcr;          /**< Line Control Reg. */
     156        ioport8_t mcr;          /**< Modem Control Reg. */
     157        ioport8_t lsr;          /**< Line Status Reg. */
     158        ioport8_t msr;          /**< Modem Status Reg. */
     159} ns8250_regs_t;
     160
    98161/** The driver data for the serial port devices. */
    99162typedef struct ns8250 {
     
    102165        /** DDF function node */
    103166        ddf_fun_t *fun;
     167        /** I/O registers **/
     168        ns8250_regs_t *regs;
    104169        /** Is there any client conntected to the device? */
    105170        bool client_connected;
     
    124189 *                      otherwise.
    125190 */
    126 static bool ns8250_received(ioport8_t *port)
    127 {
    128         return (pio_read_8(port + 5) & 1) != 0;
     191static bool ns8250_received(ns8250_regs_t *regs)
     192{
     193        return (pio_read_8(&regs->lsr) & NS8250_LSR_RXREADY) != 0;
    129194}
    130195
     
    134199 * @return              The data read.
    135200 */
    136 static uint8_t ns8250_read_8(ioport8_t *port)
    137 {
    138         return pio_read_8(port);
     201static uint8_t ns8250_read_8(ns8250_regs_t *regs)
     202{
     203        return pio_read_8(&regs->data);
    139204}
    140205
     
    143208 * @param port          The base address of the serial port device's ports.
    144209 */
    145 static bool is_transmit_empty(ioport8_t *port)
    146 {
    147         return (pio_read_8(port + 5) & 0x20) != 0;
     210static bool is_transmit_empty(ns8250_regs_t *regs)
     211{
     212        return (pio_read_8(&regs->lsr) & NS8250_LSR_THRE) != 0;
    148213}
    149214
     
    153218 * @param c             The character to be written to the serial port device.
    154219 */
    155 static void ns8250_write_8(ioport8_t *port, uint8_t c)
    156 {
    157         while (!is_transmit_empty(port))
     220static void ns8250_write_8(ns8250_regs_t *regs, uint8_t c)
     221{
     222        while (!is_transmit_empty(regs))
    158223                ;
    159224       
    160         pio_write_8(port, c);
     225        pio_write_8(&regs->data, c);
    161226}
    162227
     
    193258{
    194259        fibril_mutex_lock(&ns->mutex);
    195         ns8250_write_8(ns->port, c);
     260        ns8250_write_8(ns->regs, c);
    196261        fibril_mutex_unlock(&ns->mutex);
    197262}
     
    212277                ns8250_putchar(ns, (uint8_t) buf[idx]);
    213278       
    214         return 0;
     279        return count;
    215280}
    216281
     
    266331                return false;
    267332        }
     333
     334        ns->regs = (ns8250_regs_t *)ns->port;
    268335       
    269336        return true;
     
    279346        ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ns->dev->name);
    280347       
    281         ioport8_t *port_addr = ns->port;
    282348        bool res = true;
    283349        uint8_t olddata;
    284350       
    285         olddata = pio_read_8(port_addr + 4);
    286        
    287         pio_write_8(port_addr + 4, 0x10);
    288         if (pio_read_8(port_addr + 6) & 0xf0)
     351        olddata = pio_read_8(&ns->regs->mcr);
     352       
     353        pio_write_8(&ns->regs->mcr, NS8250_MCR_LOOPBACK);
     354        if (pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS)
    289355                res = false;
    290356       
    291         pio_write_8(port_addr + 4, 0x1f);
    292         if ((pio_read_8(port_addr + 6) & 0xf0) != 0xf0)
     357        pio_write_8(&ns->regs->mcr, NS8250_MCR_ALL);
     358        if ((pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS)
     359            != NS8250_MSR_SIGNALS)
    293360                res = false;
    294361       
    295         pio_write_8(port_addr + 4, olddata);
     362        pio_write_8(&ns->regs->mcr, olddata);
    296363       
    297364        if (!res) {
     
    390457 * @param port          The base address of the serial port device's ports.
    391458 */
    392 static inline void ns8250_port_interrupts_enable(ioport8_t *port)
    393 {
    394         pio_write_8(port + 1, 0x1);     /* Interrupt when data received. */
    395         pio_write_8(port + 4, 0xB);
     459static inline void ns8250_port_interrupts_enable(ns8250_regs_t *regs)
     460{
     461        /* Interrupt when data received. */
     462        pio_write_8(&regs->ier, NS8250_IER_RXREADY);
     463        pio_write_8(&regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS
     464            | NS8250_MCR_OUT2);
    396465}
    397466
     
    400469 * @param port          The base address of the serial port device's ports
    401470 */
    402 static inline void ns8250_port_interrupts_disable(ioport8_t *port)
    403 {
    404         pio_write_8(port + 1, 0x0);     /* Disable all interrupts. */
     471static inline void ns8250_port_interrupts_disable(ns8250_regs_t *regs)
     472{
     473        pio_write_8(&regs->ier, 0x0);   /* Disable all interrupts. */
    405474}
    406475
     
    431500
    432501        /* Enable interrupt on the serial port. */
    433         ns8250_port_interrupts_enable(ns->port);
     502        ns8250_port_interrupts_enable(ns->regs);
    434503       
    435504        return EOK;
     
    443512 * @param port          The base address of the serial port device's ports.
    444513 */
    445 static inline void enable_dlab(ioport8_t *port)
    446 {
    447         uint8_t val = pio_read_8(port + 3);
    448         pio_write_8(port + 3, val | DLAB_MASK);
     514static inline void enable_dlab(ns8250_regs_t *regs)
     515{
     516        uint8_t val = pio_read_8(&regs->lcr);
     517        pio_write_8(&regs->lcr, val | NS8250_LCR_DLAB);
    449518}
    450519
     
    453522 * @param port          The base address of the serial port device's ports.
    454523 */
    455 static inline void clear_dlab(ioport8_t *port)
    456 {
    457         uint8_t val = pio_read_8(port + 3);
    458         pio_write_8(port + 3, val & (~DLAB_MASK));
     524static inline void clear_dlab(ns8250_regs_t *regs)
     525{
     526        uint8_t val = pio_read_8(&regs->lcr);
     527        pio_write_8(&regs->lcr, val & (~NS8250_LCR_DLAB));
    459528}
    460529
     
    466535 *                      if the specified baud_rate is not valid).
    467536 */
    468 static int ns8250_port_set_baud_rate(ioport8_t *port, unsigned int baud_rate)
     537static int ns8250_port_set_baud_rate(ns8250_regs_t *regs, unsigned int baud_rate)
    469538{
    470539        uint16_t divisor;
     
    482551       
    483552        /* Enable DLAB to be able to access baud rate divisor. */
    484         enable_dlab(port);
     553        enable_dlab(regs);
    485554       
    486555        /* Set divisor low byte. */
    487         pio_write_8(port + 0, div_low);
     556        pio_write_8(&regs->data, div_low);
    488557        /* Set divisor high byte. */
    489         pio_write_8(port + 1, div_high);
    490        
    491         clear_dlab(port);
     558        pio_write_8(&regs->ier, div_high);
     559       
     560        clear_dlab(regs);
    492561       
    493562        return EOK;
     
    499568 * @param baud_rate     The ouput parameter to which the baud rate is stored.
    500569 */
    501 static unsigned int ns8250_port_get_baud_rate(ioport8_t *port)
     570static unsigned int ns8250_port_get_baud_rate(ns8250_regs_t *regs)
    502571{
    503572        uint16_t divisor;
     
    505574       
    506575        /* Enable DLAB to be able to access baud rate divisor. */
    507         enable_dlab(port);
     576        enable_dlab(regs);
    508577       
    509578        /* Get divisor low byte. */
    510         div_low = pio_read_8(port + 0);
     579        div_low = pio_read_8(&regs->data);
    511580        /* Get divisor high byte. */
    512         div_high = pio_read_8(port + 1);
    513        
    514         clear_dlab(port);
     581        div_high = pio_read_8(&regs->ier);
     582       
     583        clear_dlab(regs);
    515584       
    516585        divisor = (div_high << 8) | div_low;
     
    525594 * @param stop_bits     The number of stop bits used (one or two).
    526595 */
    527 static void ns8250_port_get_com_props(ioport8_t *port, unsigned int *parity,
     596static void ns8250_port_get_com_props(ns8250_regs_t *regs, unsigned int *parity,
    528597    unsigned int *word_length, unsigned int *stop_bits)
    529598{
    530599        uint8_t val;
    531600       
    532         val = pio_read_8(port + 3);
    533         *parity = ((val >> 3) & 7);
     601        val = pio_read_8(&regs->lcr);
     602        *parity = ((val >> NS8250_LCR_PARITY) & 7);
    534603       
    535604        switch (val & 3) {
     
    548617        }
    549618       
    550         if ((val >> 2) & 1)
     619        if ((val >> NS8250_LCR_STOPBITS) & 1)
    551620                *stop_bits = 2;
    552621        else
     
    562631 *                      is invalid.
    563632 */
    564 static int ns8250_port_set_com_props(ioport8_t *port, unsigned int parity,
     633static int ns8250_port_set_com_props(ns8250_regs_t *regs, unsigned int parity,
    565634    unsigned int word_length, unsigned int stop_bits)
    566635{
     
    586655        switch (stop_bits) {
    587656        case 1:
    588                 val |= ONE_STOP_BIT << 2;
     657                val |= ONE_STOP_BIT << NS8250_LCR_STOPBITS;
    589658                break;
    590659        case 2:
    591                 val |= TWO_STOP_BITS << 2;
     660                val |= TWO_STOP_BITS << NS8250_LCR_STOPBITS;
    592661                break;
    593662        default:
     
    601670        case SERIAL_MARK_PARITY:
    602671        case SERIAL_SPACE_PARITY:
    603                 val |= parity << 3;
     672                val |= parity << NS8250_LCR_PARITY;
    604673                break;
    605674        default:
     
    607676        }
    608677       
    609         pio_write_8(port + 3, val);
     678        pio_write_8(&regs->lcr, val);
    610679       
    611680        return EOK;
     
    620689static void ns8250_initialize_port(ns8250_t *ns)
    621690{
    622         ioport8_t *port = ns->port;
    623        
    624691        /* Disable interrupts. */
    625         ns8250_port_interrupts_disable(port);
     692        ns8250_port_interrupts_disable(ns->regs);
    626693        /* Set baud rate. */
    627         ns8250_port_set_baud_rate(port, 38400);
     694        ns8250_port_set_baud_rate(ns->regs, 38400);
    628695        /* 8 bits, no parity, two stop bits. */
    629         ns8250_port_set_com_props(port, SERIAL_NO_PARITY, 8, 2);
     696        ns8250_port_set_com_props(ns->regs, SERIAL_NO_PARITY, 8, 2);
    630697        /* Enable FIFO, clear them, with 14-byte threshold. */
    631         pio_write_8(port + 2, 0xC7);
     698        pio_write_8(&ns->regs->iid, NS8250_FCR_FIFOENABLE
     699            | NS8250_FCR_RXFIFORESET | NS8250_FCR_TXFIFORESET
     700            | NS8250_FCR_RXTRIGGERLOW | NS8250_FCR_RXTRIGGERHI);
    632701        /*
    633702         * RTS/DSR set (Request to Send and Data Terminal Ready lines enabled),
    634703         * Aux Output2 set - needed for interrupts.
    635704         */
    636         pio_write_8(port + 4, 0x0B);
     705        pio_write_8(&ns->regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS
     706            | NS8250_MCR_OUT2);
    637707}
    638708
     
    644714{
    645715        /* Disable FIFO */
    646         pio_write_8(ns->port + 2, 0x00);
     716        pio_write_8(&ns->regs->iid, 0x00);
    647717        /* Disable DTR, RTS, OUT1, OUT2 (int. enable) */
    648         pio_write_8(ns->port + 4, 0x00);
     718        pio_write_8(&ns->regs->mcr, 0x00);
    649719        /* Disable all interrupts from the port */
    650         ns8250_port_interrupts_disable(ns->port);
     720        ns8250_port_interrupts_disable(ns->regs);
    651721}
    652722
     
    658728static void ns8250_read_from_device(ns8250_t *ns)
    659729{
    660         ioport8_t *port = ns->port;
     730        ns8250_regs_t *regs = ns->regs;
    661731        bool cont = true;
    662732       
     
    664734                fibril_mutex_lock(&ns->mutex);
    665735               
    666                 cont = ns8250_received(port);
     736                cont = ns8250_received(regs);
    667737                if (cont) {
    668                         uint8_t val = ns8250_read_8(port);
     738                        uint8_t val = ns8250_read_8(regs);
    669739                       
    670740                        if (ns->client_connected) {
     
    896966{
    897967        ns8250_t *data = (ns8250_t *) dev->driver_data;
    898         ioport8_t *port = data->port;
     968        ns8250_regs_t *regs = data->regs;
    899969       
    900970        fibril_mutex_lock(&data->mutex);
    901         ns8250_port_interrupts_disable(port);
    902         *baud_rate = ns8250_port_get_baud_rate(port);
    903         ns8250_port_get_com_props(port, parity, word_length, stop_bits);
    904         ns8250_port_interrupts_enable(port);
     971        ns8250_port_interrupts_disable(regs);
     972        *baud_rate = ns8250_port_get_baud_rate(regs);
     973        ns8250_port_get_com_props(regs, parity, word_length, stop_bits);
     974        ns8250_port_interrupts_enable(regs);
    905975        fibril_mutex_unlock(&data->mutex);
    906976       
     
    927997       
    928998        ns8250_t *data = (ns8250_t *) dev->driver_data;
    929         ioport8_t *port = data->port;
     999        ns8250_regs_t *regs = data->regs;
    9301000        int ret;
    9311001       
    9321002        fibril_mutex_lock(&data->mutex);
    933         ns8250_port_interrupts_disable(port);
    934         ret = ns8250_port_set_baud_rate(port, baud_rate);
     1003        ns8250_port_interrupts_disable(regs);
     1004        ret = ns8250_port_set_baud_rate(regs, baud_rate);
    9351005        if (ret == EOK)
    936                 ret = ns8250_port_set_com_props(port, parity, word_length, stop_bits);
    937         ns8250_port_interrupts_enable(port);
     1006                ret = ns8250_port_set_com_props(regs, parity, word_length, stop_bits);
     1007        ns8250_port_interrupts_enable(regs);
    9381008        fibril_mutex_unlock(&data->mutex);
    9391009       
  • uspace/lib/c/arch/arm32/Makefile.common

    r3a01483 rc127e1c  
    2828#
    2929
    30 GCC_CFLAGS += -ffixed-r9 -mtp=soft -mapcs-frame -fno-omit-frame-pointer
     30GCC_CFLAGS += -ffixed-r9 -mtp=soft -fno-omit-frame-pointer -march=armv4
    3131
    3232ENDIANESS = LE
  • uspace/lib/c/arch/arm32/src/eabi.S

    r3a01483 rc127e1c  
    11#
    2 # Copyright (c) 2007 Pavel Jancik
     2# Copyright (c) 2012 Martin Decky
    33# All rights reserved.
    44#
     
    3131.global __aeabi_read_tp
    3232
     33.global __aeabi_idiv
     34.global __aeabi_uidiv
     35
     36.global __aeabi_idivmod
     37.global __aeabi_uidivmod
     38
     39.global __aeabi_ldivmod
     40.global __aeabi_uldivmod
     41
    3342__aeabi_read_tp:
    3443        mov r0, r9
    3544        mov pc, lr
     45
     46__aeabi_idiv:
     47        push {lr}
     48        bl __divsi3
     49        pop {lr}
     50        mov pc, lr
     51
     52__aeabi_uidiv:
     53        push {lr}
     54        bl __udivsi3
     55        pop {lr}
     56        mov pc, lr
     57
     58__aeabi_idivmod:
     59        push {lr}
     60        sub sp, sp, #12
     61        add r2, sp, #4
     62        bl __udivmodsi3
     63        ldr r1, [sp, #4]
     64        add sp, sp, #12
     65        pop {lr}
     66        mov pc, lr
     67
     68__aeabi_uidivmod:
     69        push {lr}
     70        sub sp, sp, #12
     71        add r2, sp, #4
     72        bl __udivmodsi3
     73        ldr r1, [sp, #4]
     74        add sp, sp, #12
     75        pop {lr}
     76        mov pc, lr
     77
     78__aeabi_ldivmod:
     79        push {lr}
     80        sub sp, sp, #24
     81        push {sp}
     82        bl __divmoddi3
     83        add sp, sp, #4
     84        pop {r2, r3}
     85        add sp, sp, #16
     86        pop {lr}
     87        mov pc, lr
     88
     89__aeabi_uldivmod:
     90        push {lr}
     91        sub sp, sp, #24
     92        push {sp}
     93        bl __udivmoddi3
     94        add sp, sp, #4
     95        pop {r2, r3}
     96        add sp, sp, #16
     97        pop {lr}
     98        mov pc, lr
  • uspace/lib/c/generic/str.c

    r3a01483 rc127e1c  
    4646#include <mem.h>
    4747#include <str.h>
     48
     49/** Check the condition if wchar_t is signed */
     50#ifdef WCHAR_IS_UNSIGNED
     51        #define WCHAR_SIGNED_CHECK(cond)  (true)
     52#else
     53        #define WCHAR_SIGNED_CHECK(cond)  (cond)
     54#endif
    4855
    4956/** Byte mask consisting of lowest @n bits (out of 8) */
     
    399406bool ascii_check(wchar_t ch)
    400407{
    401         if ((ch >= 0) && (ch <= 127))
     408        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
    402409                return true;
    403410       
     
    412419bool chr_check(wchar_t ch)
    413420{
    414         if ((ch >= 0) && (ch <= 1114111))
     421        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
    415422                return true;
    416423       
     
    513520 * @param count Size of the destination buffer (must be > 0).
    514521 * @param src   Source string.
     522 *
    515523 */
    516524void str_cpy(char *dest, size_t size, const char *src)
     
    545553 * @param src   Source string.
    546554 * @param n     Maximum number of bytes to read from @a src.
     555 *
    547556 */
    548557void str_ncpy(char *dest, size_t size, const char *src, size_t n)
  • uspace/lib/softfloat/Makefile

    r3a01483 rc127e1c  
    2929
    3030USPACE_PREFIX = ../..
    31 EXTRA_CFLAGS = -Iinclude -Iarch/$(UARCH)/include/
     31EXTRA_CFLAGS = -Iinclude
    3232LIBRARY = libsoftfloat
    3333
  • uspace/lib/softfloat/generic/add.c

    r3a01483 rc127e1c  
    3939#include <common.h>
    4040
    41 /**
    42  * Add two single-precision floats with the same signs.
     41/** Add two single-precision floats with the same sign.
    4342 *
    4443 * @param a First input operand.
     
    4645 * @return Result of addition.
    4746 */
    48 float32 addFloat32(float32 a, float32 b)
     47float32 add_float32(float32 a, float32 b)
    4948{
    5049        int expdiff;
     
    5352        expdiff = a.parts.exp - b.parts.exp;
    5453        if (expdiff < 0) {
    55                 if (isFloat32NaN(b)) {
    56                         /* TODO: fix SigNaN */
    57                         if (isFloat32SigNaN(b)) {
     54                if (is_float32_nan(b)) {
     55                        /* TODO: fix SigNaN */
     56                        if (is_float32_signan(b)) {
    5857                        }
    5958
     
    7170                expdiff *= -1;
    7271        } else {
    73                 if ((isFloat32NaN(a)) || (isFloat32NaN(b))) {
    74                         /* TODO: fix SigNaN */
    75                         if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
    76                         }
    77                         return (isFloat32NaN(a) ? a : b);
     72                if ((is_float32_nan(a)) || (is_float32_nan(b))) {
     73                        /* TODO: fix SigNaN */
     74                        if (is_float32_signan(a) || is_float32_signan(b)) {
     75                        }
     76                        return (is_float32_nan(a) ? a : b);
    7877                }
    7978               
     
    150149}
    151150
    152 /**
    153  * Add two double-precision floats with the same signs.
     151/** Add two double-precision floats with the same sign.
    154152 *
    155153 * @param a First input operand.
     
    157155 * @return Result of addition.
    158156 */
    159 float64 addFloat64(float64 a, float64 b)
     157float64 add_float64(float64 a, float64 b)
    160158{
    161159        int expdiff;
     
    165163        expdiff = ((int) a.parts.exp) - b.parts.exp;
    166164        if (expdiff < 0) {
    167                 if (isFloat64NaN(b)) {
    168                         /* TODO: fix SigNaN */
    169                         if (isFloat64SigNaN(b)) {
    170                         }
    171 
    172                         return b;
    173                 }
    174                
    175                 /* b is infinity and a not */   
    176                 if (b.parts.exp == FLOAT64_MAX_EXPONENT) { 
     165                if (is_float64_nan(b)) {
     166                        /* TODO: fix SigNaN */
     167                        if (is_float64_signan(b)) {
     168                        }
     169
     170                        return b;
     171                }
     172               
     173                /* b is infinity and a not */
     174                if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
    177175                        return b;
    178176                }
     
    184182                expdiff *= -1;
    185183        } else {
    186                 if (isFloat64NaN(a)) {
    187                         /* TODO: fix SigNaN */
    188                         if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
     184                if (is_float64_nan(a)) {
     185                        /* TODO: fix SigNaN */
     186                        if (is_float64_signan(a) || is_float64_signan(b)) {
    189187                        }
    190188                        return a;
     
    265263}
    266264
    267 /**
    268  * Add two quadruple-precision floats with the same signs.
     265/** Add two quadruple-precision floats with the same sign.
    269266 *
    270267 * @param a First input operand.
     
    272269 * @return Result of addition.
    273270 */
    274 float128 addFloat128(float128 a, float128 b)
     271float128 add_float128(float128 a, float128 b)
    275272{
    276273        int expdiff;
     
    280277        expdiff = ((int) a.parts.exp) - b.parts.exp;
    281278        if (expdiff < 0) {
    282                 if (isFloat128NaN(b)) {
    283                         /* TODO: fix SigNaN */
    284                         if (isFloat128SigNaN(b)) {
     279                if (is_float128_nan(b)) {
     280                        /* TODO: fix SigNaN */
     281                        if (is_float128_signan(b)) {
    285282                        }
    286283
     
    301298                expdiff *= -1;
    302299        } else {
    303                 if (isFloat128NaN(a)) {
    304                         /* TODO: fix SigNaN */
    305                         if (isFloat128SigNaN(a) || isFloat128SigNaN(b)) {
     300                if (is_float128_nan(a)) {
     301                        /* TODO: fix SigNaN */
     302                        if (is_float128_signan(a) || is_float128_signan(b)) {
    306303                        }
    307304                        return a;
  • uspace/lib/softfloat/generic/common.c

    r3a01483 rc127e1c  
    6666 * @return Finished double-precision float.
    6767 */
    68 float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign)
     68float64 finish_float64(int32_t cexp, uint64_t cfrac, char sign)
    6969{
    7070        float64 result;
     
    140140 * @return Finished quadruple-precision float.
    141141 */
    142 float128 finishFloat128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo,
     142float128 finish_float128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo,
    143143    char sign, uint64_t shift_out)
    144144{
     
    238238 * @return Number of detected leading zeroes.
    239239 */
    240 int countZeroes8(uint8_t i)
     240int count_zeroes8(uint8_t i)
    241241{
    242242        return zeroTable[i];
     
    249249 * @return Number of detected leading zeroes.
    250250 */
    251 int countZeroes32(uint32_t i)
     251int count_zeroes32(uint32_t i)
    252252{
    253253        int j;
    254254        for (j = 0; j < 32; j += 8) {
    255255                if (i & (0xFF << (24 - j))) {
    256                         return (j + countZeroes8(i >> (24 - j)));
     256                        return (j + count_zeroes8(i >> (24 - j)));
    257257                }
    258258        }
     
    267267 * @return Number of detected leading zeroes.
    268268 */
    269 int countZeroes64(uint64_t i)
     269int count_zeroes64(uint64_t i)
    270270{
    271271        int j;
    272272        for (j = 0; j < 64; j += 8) {
    273273                if (i & (0xFFll << (56 - j))) {
    274                         return (j + countZeroes8(i >> (56 - j)));
     274                        return (j + count_zeroes8(i >> (56 - j)));
    275275                }
    276276        }
     
    286286 * @param fraction Fraction with hidden bit shifted to 30th bit.
    287287 */
    288 void roundFloat32(int32_t *exp, uint32_t *fraction)
     288void round_float32(int32_t *exp, uint32_t *fraction)
    289289{
    290290        /* rounding - if first bit after fraction is set then round up */
     
    312312 * @param fraction Fraction with hidden bit shifted to 62nd bit.
    313313 */
    314 void roundFloat64(int32_t *exp, uint64_t *fraction)
     314void round_float64(int32_t *exp, uint64_t *fraction)
    315315{
    316316        /* rounding - if first bit after fraction is set then round up */
     
    339339 * @param frac_lo Low part of fraction part with hidden bit shifted to 126th bit.
    340340 */
    341 void roundFloat128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo)
     341void round_float128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo)
    342342{
    343343        uint64_t tmp_hi, tmp_lo;
  • uspace/lib/softfloat/generic/comparison.c

    r3a01483 rc127e1c  
    4545 * @return 1 if float is NaN, 0 otherwise.
    4646 */
    47 int isFloat32NaN(float32 f)
     47int is_float32_nan(float32 f)
    4848{
    4949        /* NaN : exp = 0xff and nonzero fraction */
     
    5858 * @return 1 if float is NaN, 0 otherwise.
    5959 */
    60 int isFloat64NaN(float64 d)
     60int is_float64_nan(float64 d)
    6161{
    6262        /* NaN : exp = 0x7ff and nonzero fraction */
     
    7171 * @return 1 if float is NaN, 0 otherwise.
    7272 */
    73 int isFloat128NaN(float128 ld)
     73int is_float128_nan(float128 ld)
    7474{
    7575        /* NaN : exp = 0x7fff and nonzero fraction */
     
    8484 * @return 1 if float is signalling NaN, 0 otherwise.
    8585 */
    86 int isFloat32SigNaN(float32 f)
     86int is_float32_signan(float32 f)
    8787{
    8888        /* SigNaN : exp = 0xff and fraction = 0xxxxx..x (binary),
     
    9898 * @return 1 if float is signalling NaN, 0 otherwise.
    9999 */
    100 int isFloat64SigNaN(float64 d)
     100int is_float64_signan(float64 d)
    101101{
    102102        /* SigNaN : exp = 0x7ff and fraction = 0xxxxx..x (binary),
     
    112112 * @return 1 if float is signalling NaN, 0 otherwise.
    113113 */
    114 int isFloat128SigNaN(float128 ld)
     114int is_float128_signan(float128 ld)
    115115{
    116116        /* SigNaN : exp = 0x7fff and fraction = 0xxxxx..x (binary),
     
    128128 * @return 1 if float is infinite, 0 otherwise.
    129129 */
    130 int isFloat32Infinity(float32 f)
     130int is_float32_infinity(float32 f)
    131131{
    132132        /* NaN : exp = 0x7ff and zero fraction */
     
    140140 * @return 1 if float is infinite, 0 otherwise.
    141141 */
    142 int isFloat64Infinity(float64 d)
     142int is_float64_infinity(float64 d)
    143143{
    144144        /* NaN : exp = 0x7ff and zero fraction */
     
    152152 * @return 1 if float is infinite, 0 otherwise.
    153153 */
    154 int isFloat128Infinity(float128 ld)
     154int is_float128_infinity(float128 ld)
    155155{
    156156        /* NaN : exp = 0x7fff and zero fraction */
     
    165165 * @return 1 if float is zero, 0 otherwise.
    166166 */
    167 int isFloat32Zero(float32 f)
    168 {
    169         return (((f.binary) & 0x7FFFFFFF) == 0);
     167int is_float32_zero(float32 f)
     168{
     169        return (((f.bin) & 0x7FFFFFFF) == 0);
    170170}
    171171
     
    176176 * @return 1 if float is zero, 0 otherwise.
    177177 */
    178 int isFloat64Zero(float64 d)
    179 {
    180         return (((d.binary) & 0x7FFFFFFFFFFFFFFFll) == 0);
     178int is_float64_zero(float64 d)
     179{
     180        return (((d.bin) & 0x7FFFFFFFFFFFFFFFll) == 0);
    181181}
    182182
     
    187187 * @return 1 if float is zero, 0 otherwise.
    188188 */
    189 int isFloat128Zero(float128 ld)
     189int is_float128_zero(float128 ld)
    190190{
    191191        uint64_t tmp_hi;
    192192        uint64_t tmp_lo;
    193 
    194         and128(ld.binary.hi, ld.binary.lo,
     193       
     194        and128(ld.bin.hi, ld.bin.lo,
    195195            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    196 
     196       
    197197        return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    198198}
     
    205205 * @return 1 if both floats are equal, 0 otherwise.
    206206 */
    207 int isFloat32eq(float32 a, float32 b)
     207int is_float32_eq(float32 a, float32 b)
    208208{
    209209        /* a equals to b or both are zeros (with any sign) */
    210         return ((a.binary == b.binary) ||
    211             (((a.binary | b.binary) & 0x7FFFFFFF) == 0));
     210        return ((a.bin == b.bin) ||
     211            (((a.bin | b.bin) & 0x7FFFFFFF) == 0));
    212212}
    213213
     
    219219 * @return 1 if both floats are equal, 0 otherwise.
    220220 */
    221 int isFloat64eq(float64 a, float64 b)
     221int is_float64_eq(float64 a, float64 b)
    222222{
    223223        /* a equals to b or both are zeros (with any sign) */
    224         return ((a.binary == b.binary) ||
    225             (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0));
     224        return ((a.bin == b.bin) ||
     225            (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0));
    226226}
    227227
     
    233233 * @return 1 if both floats are equal, 0 otherwise.
    234234 */
    235 int isFloat128eq(float128 a, float128 b)
     235int is_float128_eq(float128 a, float128 b)
    236236{
    237237        uint64_t tmp_hi;
    238238        uint64_t tmp_lo;
    239 
     239       
    240240        /* both are zeros (with any sign) */
    241         or128(a.binary.hi, a.binary.lo,
    242             b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
     241        or128(a.bin.hi, a.bin.lo,
     242            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    243243        and128(tmp_hi, tmp_lo,
    244244            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
     
    246246       
    247247        /* a equals to b */
    248         int are_equal = eq128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
    249 
     248        int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
     249       
    250250        return are_equal || both_zero;
    251251}
     
    258258 * @return 1 if a is lower than b, 0 otherwise.
    259259 */
    260 int isFloat32lt(float32 a, float32 b)
    261 {
    262         if (((a.binary | b.binary) & 0x7FFFFFFF) == 0) {
    263                 return 0; /* +- zeroes */
     260int is_float32_lt(float32 a, float32 b)
     261{
     262        if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
     263                /* +- zeroes */
     264                return 0;
    264265        }
    265266       
    266267        if ((a.parts.sign) && (b.parts.sign)) {
    267268                /* if both are negative, smaller is that with greater binary value */
    268                 return (a.binary > b.binary);
    269         }
    270        
    271         /* lets negate signs - now will be positive numbers allways bigger than
    272          * negative (first bit will be set for unsigned integer comparison) */
    273         a.parts.sign = !a.parts.sign;
    274         b.parts.sign = !b.parts.sign;
    275         return (a.binary < b.binary);
     269                return (a.bin > b.bin);
     270        }
     271       
     272        /*
     273         * lets negate signs - now will be positive numbers always
     274         * bigger than negative (first bit will be set for unsigned
     275         * integer comparison)
     276         */
     277        a.parts.sign = !a.parts.sign;
     278        b.parts.sign = !b.parts.sign;
     279        return (a.bin < b.bin);
    276280}
    277281
     
    283287 * @return 1 if a is lower than b, 0 otherwise.
    284288 */
    285 int isFloat64lt(float64 a, float64 b)
    286 {
    287         if (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0) {
    288                 return 0; /* +- zeroes */
    289         }
    290 
     289int is_float64_lt(float64 a, float64 b)
     290{
     291        if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) {
     292                /* +- zeroes */
     293                return 0;
     294        }
     295       
    291296        if ((a.parts.sign) && (b.parts.sign)) {
    292297                /* if both are negative, smaller is that with greater binary value */
    293                 return (a.binary > b.binary);
    294         }
    295 
    296         /* lets negate signs - now will be positive numbers allways bigger than
    297          * negative (first bit will be set for unsigned integer comparison) */
    298         a.parts.sign = !a.parts.sign;
    299         b.parts.sign = !b.parts.sign;
    300         return (a.binary < b.binary);
     298                return (a.bin > b.bin);
     299        }
     300       
     301        /*
     302         * lets negate signs - now will be positive numbers always
     303         * bigger than negative (first bit will be set for unsigned
     304         * integer comparison)
     305         */
     306        a.parts.sign = !a.parts.sign;
     307        b.parts.sign = !b.parts.sign;
     308        return (a.bin < b.bin);
    301309}
    302310
     
    308316 * @return 1 if a is lower than b, 0 otherwise.
    309317 */
    310 int isFloat128lt(float128 a, float128 b)
     318int is_float128_lt(float128 a, float128 b)
    311319{
    312320        uint64_t tmp_hi;
    313321        uint64_t tmp_lo;
    314 
    315         or128(a.binary.hi, a.binary.lo,
    316             b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
     322       
     323        or128(a.bin.hi, a.bin.lo,
     324            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    317325        and128(tmp_hi, tmp_lo,
    318326            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    319327        if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) {
    320                 return 0; /* +- zeroes */
    321         }
    322 
     328                /* +- zeroes */
     329                return 0;
     330        }
     331       
    323332        if ((a.parts.sign) && (b.parts.sign)) {
    324333                /* if both are negative, smaller is that with greater binary value */
    325                 return lt128(b.binary.hi, b.binary.lo, a.binary.hi, a.binary.lo);
    326         }
    327 
    328         /* lets negate signs - now will be positive numbers allways bigger than
    329          * negative (first bit will be set for unsigned integer comparison) */
    330         a.parts.sign = !a.parts.sign;
    331         b.parts.sign = !b.parts.sign;
    332         return lt128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
     334                return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
     335        }
     336       
     337        /*
     338         * lets negate signs - now will be positive numbers always
     339         * bigger than negative (first bit will be set for unsigned
     340         * integer comparison)
     341         */
     342        a.parts.sign = !a.parts.sign;
     343        b.parts.sign = !b.parts.sign;
     344        return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    333345}
    334346
     
    340352 * @return 1 if a is greater than b, 0 otherwise.
    341353 */
    342 int isFloat32gt(float32 a, float32 b)
    343 {
    344         if (((a.binary | b.binary) & 0x7FFFFFFF) == 0) {
    345                 return 0; /* zeroes are equal with any sign */
     354int is_float32_gt(float32 a, float32 b)
     355{
     356        if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
     357                /* zeroes are equal with any sign */
     358                return 0;
    346359        }
    347360       
    348361        if ((a.parts.sign) && (b.parts.sign)) {
    349362                /* if both are negative, greater is that with smaller binary value */
    350                 return (a.binary < b.binary);
    351         }
    352        
    353         /* lets negate signs - now will be positive numbers allways bigger than
    354          *  negative (first bit will be set for unsigned integer comparison) */
    355         a.parts.sign = !a.parts.sign;
    356         b.parts.sign = !b.parts.sign;
    357         return (a.binary > b.binary);
     363                return (a.bin < b.bin);
     364        }
     365       
     366        /*
     367         * lets negate signs - now will be positive numbers always
     368         * bigger than negative (first bit will be set for unsigned
     369         * integer comparison)
     370         */
     371        a.parts.sign = !a.parts.sign;
     372        b.parts.sign = !b.parts.sign;
     373        return (a.bin > b.bin);
    358374}
    359375
     
    365381 * @return 1 if a is greater than b, 0 otherwise.
    366382 */
    367 int isFloat64gt(float64 a, float64 b)
    368 {
    369         if (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0) {
    370                 return 0; /* zeroes are equal with any sign */
    371         }
    372 
     383int is_float64_gt(float64 a, float64 b)
     384{
     385        if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) {
     386                /* zeroes are equal with any sign */
     387                return 0;
     388        }
     389       
    373390        if ((a.parts.sign) && (b.parts.sign)) {
    374391                /* if both are negative, greater is that with smaller binary value */
    375                 return (a.binary < b.binary);
    376         }
    377 
    378         /* lets negate signs - now will be positive numbers allways bigger than
    379          *  negative (first bit will be set for unsigned integer comparison) */
    380         a.parts.sign = !a.parts.sign;
    381         b.parts.sign = !b.parts.sign;
    382         return (a.binary > b.binary);
     392                return (a.bin < b.bin);
     393        }
     394       
     395        /*
     396         * lets negate signs - now will be positive numbers always
     397         * bigger than negative (first bit will be set for unsigned
     398         * integer comparison)
     399         */
     400        a.parts.sign = !a.parts.sign;
     401        b.parts.sign = !b.parts.sign;
     402        return (a.bin > b.bin);
    383403}
    384404
     
    390410 * @return 1 if a is greater than b, 0 otherwise.
    391411 */
    392 int isFloat128gt(float128 a, float128 b)
     412int is_float128_gt(float128 a, float128 b)
    393413{
    394414        uint64_t tmp_hi;
    395415        uint64_t tmp_lo;
    396 
    397         or128(a.binary.hi, a.binary.lo,
    398             b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
     416       
     417        or128(a.bin.hi, a.bin.lo,
     418            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    399419        and128(tmp_hi, tmp_lo,
    400420            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    401421        if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) {
    402                 return 0; /* zeroes are equal with any sign */
    403         }
    404 
     422                /* zeroes are equal with any sign */
     423                return 0;
     424        }
     425       
    405426        if ((a.parts.sign) && (b.parts.sign)) {
    406427                /* if both are negative, greater is that with smaller binary value */
    407                 return lt128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
    408         }
    409 
    410         /* lets negate signs - now will be positive numbers allways bigger than
    411          *  negative (first bit will be set for unsigned integer comparison) */
    412         a.parts.sign = !a.parts.sign;
    413         b.parts.sign = !b.parts.sign;
    414         return lt128(b.binary.hi, b.binary.lo, a.binary.hi, a.binary.lo);
     428                return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
     429        }
     430       
     431        /*
     432         * lets negate signs - now will be positive numbers always
     433         * bigger than negative (first bit will be set for unsigned
     434         * integer comparison)
     435         */
     436        a.parts.sign = !a.parts.sign;
     437        b.parts.sign = !b.parts.sign;
     438        return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
    415439}
    416440
  • uspace/lib/softfloat/generic/conversion.c

    r3a01483 rc127e1c  
    3939#include <common.h>
    4040
    41 float64 convertFloat32ToFloat64(float32 a)
     41float64 float32_to_float64(float32 a)
    4242{
    4343        float64 result;
     
    4848        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
    4949       
    50         if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
     50        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    5151                result.parts.exp = FLOAT64_MAX_EXPONENT;
    52                 /* TODO; check if its correct for SigNaNs*/
     52                // TODO; check if its correct for SigNaNs
    5353                return result;
    5454        }
     
    5757        if (a.parts.exp == 0) {
    5858                /* normalize denormalized numbers */
    59 
     59               
    6060                if (result.parts.fraction == 0) { /* fix zero */
    6161                        result.parts.exp = 0;
     
    7777}
    7878
    79 float128 convertFloat32ToFloat128(float32 a)
     79float128 float32_to_float128(float32 a)
    8080{
    8181        float128 result;
    8282        uint64_t frac_hi, frac_lo;
    8383        uint64_t tmp_hi, tmp_lo;
    84 
     84       
    8585        result.parts.sign = a.parts.sign;
    8686        result.parts.frac_hi = 0;
     
    9191        result.parts.frac_hi = frac_hi;
    9292        result.parts.frac_lo = frac_lo;
    93 
    94         if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
     93       
     94        if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
    9595                result.parts.exp = FLOAT128_MAX_EXPONENT;
    96                 /* TODO; check if its correct for SigNaNs*/
    97                 return result;
    98         }
    99 
     96                // TODO; check if its correct for SigNaNs
     97                return result;
     98        }
     99       
    100100        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS);
    101101        if (a.parts.exp == 0) {
    102102                /* normalize denormalized numbers */
    103 
     103               
    104104                if (eq128(result.parts.frac_hi,
    105105                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
     
    107107                        return result;
    108108                }
    109 
     109               
    110110                frac_hi = result.parts.frac_hi;
    111111                frac_lo = result.parts.frac_lo;
    112 
     112               
    113113                and128(frac_hi, frac_lo,
    114114                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    118118                        --result.parts.exp;
    119119                }
    120 
     120               
    121121                ++result.parts.exp;
    122122                result.parts.frac_hi = frac_hi;
    123123                result.parts.frac_lo = frac_lo;
    124124        }
    125 
    126         return result;
    127 }
    128 
    129 float128 convertFloat64ToFloat128(float64 a)
     125       
     126        return result;
     127}
     128
     129float128 float64_to_float128(float64 a)
    130130{
    131131        float128 result;
    132132        uint64_t frac_hi, frac_lo;
    133133        uint64_t tmp_hi, tmp_lo;
    134 
     134       
    135135        result.parts.sign = a.parts.sign;
    136136        result.parts.frac_hi = 0;
     
    141141        result.parts.frac_hi = frac_hi;
    142142        result.parts.frac_lo = frac_lo;
    143 
    144         if ((isFloat64Infinity(a)) || (isFloat64NaN(a))) {
     143       
     144        if ((is_float64_infinity(a)) || (is_float64_nan(a))) {
    145145                result.parts.exp = FLOAT128_MAX_EXPONENT;
    146                 /* TODO; check if its correct for SigNaNs*/
    147                 return result;
    148         }
    149 
     146                // TODO; check if its correct for SigNaNs
     147                return result;
     148        }
     149       
    150150        result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS);
    151151        if (a.parts.exp == 0) {
    152152                /* normalize denormalized numbers */
    153 
     153               
    154154                if (eq128(result.parts.frac_hi,
    155155                    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
     
    157157                        return result;
    158158                }
    159 
     159               
    160160                frac_hi = result.parts.frac_hi;
    161161                frac_lo = result.parts.frac_lo;
    162 
     162               
    163163                and128(frac_hi, frac_lo,
    164164                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    168168                        --result.parts.exp;
    169169                }
    170 
     170               
    171171                ++result.parts.exp;
    172172                result.parts.frac_hi = frac_hi;
    173173                result.parts.frac_lo = frac_lo;
    174174        }
    175 
    176         return result;
    177 }
    178 
    179 float32 convertFloat64ToFloat32(float64 a)
     175       
     176        return result;
     177}
     178
     179float32 float64_to_float32(float64 a)
    180180{
    181181        float32 result;
     
    185185        result.parts.sign = a.parts.sign;
    186186       
    187         if (isFloat64NaN(a)) {
     187        if (is_float64_nan(a)) {
    188188                result.parts.exp = FLOAT32_MAX_EXPONENT;
    189189               
    190                 if (isFloat64SigNaN(a)) {
     190                if (is_float64_signan(a)) {
    191191                        /* set first bit of fraction nonzero */
    192192                        result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
    193193                        return result;
    194194                }
    195 
     195               
    196196                /* fraction nonzero but its first bit is zero */
    197197                result.parts.fraction = 0x1;
    198198                return result;
    199199        }
    200 
    201         if (isFloat64Infinity(a)) {
     200       
     201        if (is_float64_infinity(a)) {
    202202                result.parts.fraction = 0;
    203203                result.parts.exp = FLOAT32_MAX_EXPONENT;
    204204                return result;
    205205        }
    206 
     206       
    207207        exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
    208208       
     
    239239                return result;
    240240        }
    241 
     241       
    242242        result.parts.exp = exp;
    243243        result.parts.fraction =
     
    246246}
    247247
    248 float32 convertFloat128ToFloat32(float128 a)
     248float32 float128_to_float32(float128 a)
    249249{
    250250        float32 result;
    251251        int32_t exp;
    252252        uint64_t frac_hi, frac_lo;
    253 
     253       
    254254        result.parts.sign = a.parts.sign;
    255 
    256         if (isFloat128NaN(a)) {
     255       
     256        if (is_float128_nan(a)) {
    257257                result.parts.exp = FLOAT32_MAX_EXPONENT;
    258 
    259                 if (isFloat128SigNaN(a)) {
     258               
     259                if (is_float128_signan(a)) {
    260260                        /* set first bit of fraction nonzero */
    261261                        result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
    262262                        return result;
    263263                }
    264 
     264               
    265265                /* fraction nonzero but its first bit is zero */
    266266                result.parts.fraction = 0x1;
    267267                return result;
    268268        }
    269 
    270         if (isFloat128Infinity(a)) {
     269       
     270        if (is_float128_infinity(a)) {
    271271                result.parts.fraction = 0;
    272272                result.parts.exp = FLOAT32_MAX_EXPONENT;
    273273                return result;
    274274        }
    275 
     275       
    276276        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS;
    277 
     277       
    278278        if (exp >= FLOAT32_MAX_EXPONENT) {
    279279                /* FIXME: overflow */
     
    283283        } else if (exp <= 0) {
    284284                /* underflow or denormalized */
    285 
     285               
    286286                result.parts.exp = 0;
    287 
     287               
    288288                exp *= -1;
    289289                if (exp > FLOAT32_FRACTION_SIZE) {
     
    292292                        return result;
    293293                }
    294 
     294               
    295295                /* denormalized */
    296 
     296               
    297297                frac_hi = a.parts.frac_hi;
    298298                frac_lo = a.parts.frac_lo;
    299 
     299               
    300300                /* denormalize and set hidden bit */
    301301                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    302 
     302               
    303303                rshift128(frac_hi, frac_lo,
    304304                    (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1),
    305305                    &frac_hi, &frac_lo);
    306 
     306               
    307307                while (exp > 0) {
    308308                        --exp;
     
    310310                }
    311311                result.parts.fraction = frac_lo;
    312 
    313                 return result;
    314         }
    315 
     312               
     313                return result;
     314        }
     315       
    316316        result.parts.exp = exp;
    317317        frac_hi = a.parts.frac_hi;
     
    324324}
    325325
    326 float64 convertFloat128ToFloat64(float128 a)
     326float64 float128_to_float64(float128 a)
    327327{
    328328        float64 result;
    329329        int32_t exp;
    330330        uint64_t frac_hi, frac_lo;
    331 
     331       
    332332        result.parts.sign = a.parts.sign;
    333 
    334         if (isFloat128NaN(a)) {
     333       
     334        if (is_float128_nan(a)) {
    335335                result.parts.exp = FLOAT64_MAX_EXPONENT;
    336 
    337                 if (isFloat128SigNaN(a)) {
     336               
     337                if (is_float128_signan(a)) {
    338338                        /* set first bit of fraction nonzero */
    339339                        result.parts.fraction = FLOAT64_HIDDEN_BIT_MASK >> 1;
    340340                        return result;
    341341                }
    342 
     342               
    343343                /* fraction nonzero but its first bit is zero */
    344344                result.parts.fraction = 0x1;
    345345                return result;
    346346        }
    347 
    348         if (isFloat128Infinity(a)) {
     347       
     348        if (is_float128_infinity(a)) {
    349349                result.parts.fraction = 0;
    350350                result.parts.exp = FLOAT64_MAX_EXPONENT;
    351351                return result;
    352352        }
    353 
     353       
    354354        exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS;
    355 
     355       
    356356        if (exp >= FLOAT64_MAX_EXPONENT) {
    357357                /* FIXME: overflow */
     
    361361        } else if (exp <= 0) {
    362362                /* underflow or denormalized */
    363 
     363               
    364364                result.parts.exp = 0;
    365 
     365               
    366366                exp *= -1;
    367367                if (exp > FLOAT64_FRACTION_SIZE) {
     
    370370                        return result;
    371371                }
    372 
     372               
    373373                /* denormalized */
    374 
     374               
    375375                frac_hi = a.parts.frac_hi;
    376376                frac_lo = a.parts.frac_lo;
    377 
     377               
    378378                /* denormalize and set hidden bit */
    379379                frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    380 
     380               
    381381                rshift128(frac_hi, frac_lo,
    382382                    (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1),
    383383                    &frac_hi, &frac_lo);
    384 
     384               
    385385                while (exp > 0) {
    386386                        --exp;
     
    388388                }
    389389                result.parts.fraction = frac_lo;
    390 
    391                 return result;
    392         }
    393 
     390               
     391                return result;
     392        }
     393       
    394394        result.parts.exp = exp;
    395395        frac_hi = a.parts.frac_hi;
     
    402402}
    403403
    404 
    405 /**
    406  * Helping procedure for converting float32 to uint32.
     404/** Helper procedure for converting float32 to uint32.
    407405 *
    408406 * @param a Floating point number in normalized form
     
    424422        /* shift fraction to left so hidden bit will be the most significant bit */
    425423        frac <<= 32 - FLOAT32_FRACTION_SIZE - 1;
    426 
     424       
    427425        frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
    428426        if ((a.parts.sign == 1) && (frac != 0)) {
     
    434432}
    435433
    436 /* 
    437  * FIXME: Im not sure what to return if overflow/underflow happens 
    438  *      - now its the biggest or the smallest int
    439  */ 
     434/*
     435 * FIXME: Im not sure what to return if overflow/underflow happens
     436 *  - now its the biggest or the smallest int
     437 */
    440438uint32_t float32_to_uint32(float32 a)
    441439{
    442         if (isFloat32NaN(a))
     440        if (is_float32_nan(a))
    443441                return UINT32_MAX;
    444442       
    445         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     443        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    446444                if (a.parts.sign)
    447445                        return UINT32_MIN;
     
    453451}
    454452
    455 /* 
    456  * FIXME: Im not sure what to return if overflow/underflow happens 
    457  *      - now its the biggest or the smallest int
    458  */ 
     453/*
     454 * FIXME: Im not sure what to return if overflow/underflow happens
     455 *  - now its the biggest or the smallest int
     456 */
    459457int32_t float32_to_int32(float32 a)
    460458{
    461         if (isFloat32NaN(a))
     459        if (is_float32_nan(a))
    462460                return INT32_MAX;
    463461       
    464         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     462        if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
    465463                if (a.parts.sign)
    466464                        return INT32_MIN;
     
    472470}
    473471
    474 
    475 /**
    476  * Helping procedure for converting float32 to uint64.
     472/** Helper procedure for converting float32 to uint64.
    477473 *
    478474 * @param a Floating point number in normalized form
     
    483479{
    484480        uint64_t frac;
    485 
     481       
    486482        if (a.parts.exp < FLOAT32_BIAS) {
    487                 /*TODO: rounding*/
     483                // TODO: rounding
    488484                return 0;
    489485        }
    490 
     486       
    491487        frac = a.parts.fraction;
    492 
     488       
    493489        frac |= FLOAT32_HIDDEN_BIT_MASK;
    494490        /* shift fraction to left so hidden bit will be the most significant bit */
    495491        frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
    496 
     492       
    497493        frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
    498494        if ((a.parts.sign == 1) && (frac != 0)) {
     
    500496                ++frac;
    501497        }
    502 
     498       
    503499        return frac;
    504500}
    505501
    506 /* 
     502/*
    507503 * FIXME: Im not sure what to return if overflow/underflow happens
    508  *      - now its the biggest or the smallest int
     504 *  - now its the biggest or the smallest int
    509505 */
    510506uint64_t float32_to_uint64(float32 a)
    511507{
    512         if (isFloat32NaN(a))
     508        if (is_float32_nan(a))
    513509                return UINT64_MAX;
    514 
    515 
    516         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     510       
     511        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    517512                if (a.parts.sign)
    518513                        return UINT64_MIN;
    519 
     514               
    520515                return UINT64_MAX;
    521516        }
    522 
     517       
    523518        return _float32_to_uint64_helper(a);
    524519}
    525520
    526 /* 
     521/*
    527522 * FIXME: Im not sure what to return if overflow/underflow happens
    528  *      - now its the biggest or the smallest int
     523 *  - now its the biggest or the smallest int
    529524 */
    530525int64_t float32_to_int64(float32 a)
    531526{
    532         if (isFloat32NaN(a))
     527        if (is_float32_nan(a))
    533528                return INT64_MAX;
    534 
    535         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     529       
     530        if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
    536531                if (a.parts.sign)
    537532                        return INT64_MIN;
    538 
     533               
    539534                return INT64_MAX;
    540535        }
    541 
     536       
    542537        return _float32_to_uint64_helper(a);
    543538}
    544539
    545 
    546 /**
    547  * Helping procedure for converting float64 to uint64.
     540/** Helper procedure for converting float64 to uint64.
    548541 *
    549542 * @param a Floating point number in normalized form
     
    554547{
    555548        uint64_t frac;
    556 
     549       
    557550        if (a.parts.exp < FLOAT64_BIAS) {
    558                 /*TODO: rounding*/
     551                // TODO: rounding
    559552                return 0;
    560553        }
    561 
     554       
    562555        frac = a.parts.fraction;
    563 
     556       
    564557        frac |= FLOAT64_HIDDEN_BIT_MASK;
    565558        /* shift fraction to left so hidden bit will be the most significant bit */
    566559        frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
    567 
     560       
    568561        frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
    569562        if ((a.parts.sign == 1) && (frac != 0)) {
     
    571564                ++frac;
    572565        }
    573 
     566       
    574567        return frac;
    575568}
     
    577570/*
    578571 * FIXME: Im not sure what to return if overflow/underflow happens
    579  *      - now its the biggest or the smallest int
     572 *  - now its the biggest or the smallest int
    580573 */
    581574uint32_t float64_to_uint32(float64 a)
    582575{
    583         if (isFloat64NaN(a))
     576        if (is_float64_nan(a))
    584577                return UINT32_MAX;
    585 
    586         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     578       
     579        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    587580                if (a.parts.sign)
    588581                        return UINT32_MIN;
    589 
     582               
    590583                return UINT32_MAX;
    591584        }
    592 
     585       
    593586        return (uint32_t) _float64_to_uint64_helper(a);
    594587}
     
    596589/*
    597590 * FIXME: Im not sure what to return if overflow/underflow happens
    598  *      - now its the biggest or the smallest int
     591 *  - now its the biggest or the smallest int
    599592 */
    600593int32_t float64_to_int32(float64 a)
    601594{
    602         if (isFloat64NaN(a))
     595        if (is_float64_nan(a))
    603596                return INT32_MAX;
    604 
    605         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     597       
     598        if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
    606599                if (a.parts.sign)
    607600                        return INT32_MIN;
    608 
     601               
    609602                return INT32_MAX;
    610603        }
    611 
     604       
    612605        return (int32_t) _float64_to_uint64_helper(a);
    613606}
    614607
    615 
    616 /*
     608/*
    617609 * FIXME: Im not sure what to return if overflow/underflow happens
    618  *      - now its the biggest or the smallest int
    619  */ 
     610 *  - now its the biggest or the smallest int
     611 */
    620612uint64_t float64_to_uint64(float64 a)
    621613{
    622         if (isFloat64NaN(a))
     614        if (is_float64_nan(a))
    623615                return UINT64_MAX;
    624616       
    625         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     617        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    626618                if (a.parts.sign)
    627619                        return UINT64_MIN;
     
    633625}
    634626
    635 /* 
     627/*
    636628 * FIXME: Im not sure what to return if overflow/underflow happens
    637  *      - now its the biggest or the smallest int
    638  */ 
     629 *  - now its the biggest or the smallest int
     630 */
    639631int64_t float64_to_int64(float64 a)
    640632{
    641         if (isFloat64NaN(a))
     633        if (is_float64_nan(a))
    642634                return INT64_MAX;
    643635       
    644         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     636        if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
    645637                if (a.parts.sign)
    646638                        return INT64_MIN;
     
    652644}
    653645
    654 
    655 /**
    656  * Helping procedure for converting float128 to uint64.
     646/** Helper procedure for converting float128 to uint64.
    657647 *
    658648 * @param a Floating point number in normalized form
     
    663653{
    664654        uint64_t frac_hi, frac_lo;
    665 
     655       
    666656        if (a.parts.exp < FLOAT128_BIAS) {
    667                 /*TODO: rounding*/
     657                // TODO: rounding
    668658                return 0;
    669659        }
    670 
     660       
    671661        frac_hi = a.parts.frac_hi;
    672662        frac_lo = a.parts.frac_lo;
    673 
     663       
    674664        frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
    675665        /* shift fraction to left so hidden bit will be the most significant bit */
    676666        lshift128(frac_hi, frac_lo,
    677667            (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo);
    678 
     668       
    679669        rshift128(frac_hi, frac_lo,
    680670            (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo);
     
    683673                add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo);
    684674        }
    685 
     675       
    686676        return frac_lo;
    687677}
     
    689679/*
    690680 * FIXME: Im not sure what to return if overflow/underflow happens
    691  *      - now its the biggest or the smallest int
     681 *  - now its the biggest or the smallest int
    692682 */
    693683uint32_t float128_to_uint32(float128 a)
    694684{
    695         if (isFloat128NaN(a))
     685        if (is_float128_nan(a))
    696686                return UINT32_MAX;
    697 
    698         if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
     687       
     688        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    699689                if (a.parts.sign)
    700690                        return UINT32_MIN;
    701 
     691               
    702692                return UINT32_MAX;
    703693        }
    704 
     694       
    705695        return (uint32_t) _float128_to_uint64_helper(a);
    706696}
     
    708698/*
    709699 * FIXME: Im not sure what to return if overflow/underflow happens
    710  *      - now its the biggest or the smallest int
     700 *  - now its the biggest or the smallest int
    711701 */
    712702int32_t float128_to_int32(float128 a)
    713703{
    714         if (isFloat128NaN(a))
     704        if (is_float128_nan(a))
    715705                return INT32_MAX;
    716 
    717         if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
     706       
     707        if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
    718708                if (a.parts.sign)
    719709                        return INT32_MIN;
    720 
     710               
    721711                return INT32_MAX;
    722712        }
    723 
     713       
    724714        return (int32_t) _float128_to_uint64_helper(a);
    725715}
    726716
    727 
    728717/*
    729718 * FIXME: Im not sure what to return if overflow/underflow happens
    730  *      - now its the biggest or the smallest int
     719 *  - now its the biggest or the smallest int
    731720 */
    732721uint64_t float128_to_uint64(float128 a)
    733722{
    734         if (isFloat128NaN(a))
     723        if (is_float128_nan(a))
    735724                return UINT64_MAX;
    736 
    737         if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
     725       
     726        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    738727                if (a.parts.sign)
    739728                        return UINT64_MIN;
    740 
     729               
    741730                return UINT64_MAX;
    742731        }
    743 
     732       
    744733        return _float128_to_uint64_helper(a);
    745734}
     
    747736/*
    748737 * FIXME: Im not sure what to return if overflow/underflow happens
    749  *      - now its the biggest or the smallest int
     738 *  - now its the biggest or the smallest int
    750739 */
    751740int64_t float128_to_int64(float128 a)
    752741{
    753         if (isFloat128NaN(a))
     742        if (is_float128_nan(a))
    754743                return INT64_MAX;
    755 
    756         if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
     744       
     745        if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
    757746                if (a.parts.sign)
    758747                        return INT64_MIN;
    759 
     748               
    760749                return INT64_MAX;
    761750        }
    762 
     751       
    763752        return _float128_to_uint64_helper(a);
    764753}
    765 
    766754
    767755float32 uint32_to_float32(uint32_t i)
     
    773761        result.parts.sign = 0;
    774762        result.parts.fraction = 0;
    775 
    776         counter = countZeroes32(i);
    777 
     763       
     764        counter = count_zeroes32(i);
     765       
    778766        exp = FLOAT32_BIAS + 32 - counter - 1;
    779767       
    780768        if (counter == 32) {
    781                 result.binary = 0;
     769                result.bin = 0;
    782770                return result;
    783771        }
     
    788776                i >>= 1;
    789777        }
    790 
    791         roundFloat32(&exp, &i);
    792 
     778       
     779        round_float32(&exp, &i);
     780       
    793781        result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2);
    794782        result.parts.exp = exp;
    795 
    796         return result;
    797 }
    798 
    799 float32 int32_to_float32(int32_t i) 
     783       
     784        return result;
     785}
     786
     787float32 int32_to_float32(int32_t i)
    800788{
    801789        float32 result;
    802 
    803         if (i < 0) {
     790       
     791        if (i < 0)
    804792                result = uint32_to_float32((uint32_t) (-i));
    805         } else {
     793        else
    806794                result = uint32_to_float32((uint32_t) i);
    807         }
    808795       
    809796        result.parts.sign = i < 0;
    810 
    811         return result;
    812 }
    813 
    814 
    815 float32 uint64_to_float32(uint64_t i)
     797       
     798        return result;
     799}
     800
     801float32 uint64_to_float32(uint64_t i)
    816802{
    817803        int counter;
     
    822808        result.parts.sign = 0;
    823809        result.parts.fraction = 0;
    824 
    825         counter = countZeroes64(i);
    826 
     810       
     811        counter = count_zeroes64(i);
     812       
    827813        exp = FLOAT32_BIAS + 64 - counter - 1;
    828814       
    829815        if (counter == 64) {
    830                 result.binary = 0;
     816                result.bin = 0;
    831817                return result;
    832818        }
     
    840826       
    841827        j = (uint32_t) i;
    842         roundFloat32(&exp, &j);
    843 
     828        round_float32(&exp, &j);
     829       
    844830        result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2);
    845831        result.parts.exp = exp;
     
    847833}
    848834
    849 float32 int64_to_float32(int64_t i) 
     835float32 int64_to_float32(int64_t i)
    850836{
    851837        float32 result;
    852 
    853         if (i < 0) {
     838       
     839        if (i < 0)
    854840                result = uint64_to_float32((uint64_t) (-i));
    855         } else {
     841        else
    856842                result = uint64_to_float32((uint64_t) i);
    857         }
    858843       
    859844        result.parts.sign = i < 0;
    860 
    861         return result;
     845       
     846        return result;
    862847}
    863848
     
    871856        result.parts.sign = 0;
    872857        result.parts.fraction = 0;
    873 
    874         counter = countZeroes32(i);
    875 
     858       
     859        counter = count_zeroes32(i);
     860       
    876861        exp = FLOAT64_BIAS + 32 - counter - 1;
    877862       
    878863        if (counter == 32) {
    879                 result.binary = 0;
     864                result.bin = 0;
    880865                return result;
    881866        }
    882867       
    883868        frac = i;
    884         frac <<= counter + 32 - 1; 
    885 
    886         roundFloat64(&exp, &frac);
    887 
     869        frac <<= counter + 32 - 1;
     870       
     871        round_float64(&exp, &frac);
     872       
    888873        result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2);
    889874        result.parts.exp = exp;
    890 
    891         return result;
    892 }
    893 
    894 float64 int32_to_float64(int32_t i) 
     875       
     876        return result;
     877}
     878
     879float64 int32_to_float64(int32_t i)
    895880{
    896881        float64 result;
    897 
    898         if (i < 0) {
     882       
     883        if (i < 0)
    899884                result = uint32_to_float64((uint32_t) (-i));
    900         } else {
     885        else
    901886                result = uint32_to_float64((uint32_t) i);
    902         }
    903887       
    904888        result.parts.sign = i < 0;
    905 
    906         return result;
    907 }
    908 
    909 
    910 float64 uint64_to_float64(uint64_t i) 
     889       
     890        return result;
     891}
     892
     893
     894float64 uint64_to_float64(uint64_t i)
    911895{
    912896        int counter;
     
    916900        result.parts.sign = 0;
    917901        result.parts.fraction = 0;
    918 
    919         counter = countZeroes64(i);
    920 
     902       
     903        counter = count_zeroes64(i);
     904       
    921905        exp = FLOAT64_BIAS + 64 - counter - 1;
    922906       
    923907        if (counter == 64) {
    924                 result.binary = 0;
     908                result.bin = 0;
    925909                return result;
    926910        }
     
    931915                i >>= 1;
    932916        }
    933 
    934         roundFloat64(&exp, &i);
    935 
     917       
     918        round_float64(&exp, &i);
     919       
    936920        result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2);
    937921        result.parts.exp = exp;
     
    939923}
    940924
    941 float64 int64_to_float64(int64_t i) 
     925float64 int64_to_float64(int64_t i)
    942926{
    943927        float64 result;
    944 
    945         if (i < 0) {
     928       
     929        if (i < 0)
    946930                result = uint64_to_float64((uint64_t) (-i));
    947         } else {
     931        else
    948932                result = uint64_to_float64((uint64_t) i);
    949         }
    950933       
    951934        result.parts.sign = i < 0;
    952 
    953         return result;
    954 }
    955 
     935       
     936        return result;
     937}
    956938
    957939float128 uint32_to_float128(uint32_t i)
     
    961943        float128 result;
    962944        uint64_t frac_hi, frac_lo;
    963 
     945       
    964946        result.parts.sign = 0;
    965947        result.parts.frac_hi = 0;
    966948        result.parts.frac_lo = 0;
    967 
    968         counter = countZeroes32(i);
    969 
     949       
     950        counter = count_zeroes32(i);
     951       
    970952        exp = FLOAT128_BIAS + 32 - counter - 1;
    971 
     953       
    972954        if (counter == 32) {
    973                 result.binary.hi = 0;
    974                 result.binary.lo = 0;
    975                 return result;
    976         }
    977 
     955                result.bin.hi = 0;
     956                result.bin.lo = 0;
     957                return result;
     958        }
     959       
    978960        frac_hi = 0;
    979961        frac_lo = i;
    980962        lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo);
    981 
    982         roundFloat128(&exp, &frac_hi, &frac_lo);
    983 
     963       
     964        round_float128(&exp, &frac_hi, &frac_lo);
     965       
    984966        rshift128(frac_hi, frac_lo,
    985967            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
     
    987969        result.parts.frac_lo = frac_lo;
    988970        result.parts.exp = exp;
    989 
     971       
    990972        return result;
    991973}
     
    994976{
    995977        float128 result;
    996 
    997         if (i < 0) {
     978       
     979        if (i < 0)
    998980                result = uint32_to_float128((uint32_t) (-i));
    999         } else {
     981        else
    1000982                result = uint32_to_float128((uint32_t) i);
    1001         }
    1002 
     983       
    1003984        result.parts.sign = i < 0;
    1004 
    1005         return result;
     985       
     986        return result;
    1006987}
    1007988
     
    1013994        float128 result;
    1014995        uint64_t frac_hi, frac_lo;
    1015 
     996       
    1016997        result.parts.sign = 0;
    1017998        result.parts.frac_hi = 0;
    1018999        result.parts.frac_lo = 0;
    1019 
    1020         counter = countZeroes64(i);
    1021 
     1000       
     1001        counter = count_zeroes64(i);
     1002       
    10221003        exp = FLOAT128_BIAS + 64 - counter - 1;
    1023 
     1004       
    10241005        if (counter == 64) {
    1025                 result.binary.hi = 0;
    1026                 result.binary.lo = 0;
    1027                 return result;
    1028         }
    1029 
     1006                result.bin.hi = 0;
     1007                result.bin.lo = 0;
     1008                return result;
     1009        }
     1010       
    10301011        frac_hi = 0;
    10311012        frac_lo = i;
    10321013        lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo);
    1033 
    1034         roundFloat128(&exp, &frac_hi, &frac_lo);
    1035 
     1014       
     1015        round_float128(&exp, &frac_hi, &frac_lo);
     1016       
    10361017        rshift128(frac_hi, frac_lo,
    10371018            (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
     
    10391020        result.parts.frac_lo = frac_lo;
    10401021        result.parts.exp = exp;
    1041 
     1022       
    10421023        return result;
    10431024}
     
    10461027{
    10471028        float128 result;
    1048 
    1049         if (i < 0) {
     1029       
     1030        if (i < 0)
    10501031                result = uint64_to_float128((uint64_t) (-i));
    1051         } else {
     1032        else
    10521033                result = uint64_to_float128((uint64_t) i);
    1053         }
    1054 
     1034       
    10551035        result.parts.sign = i < 0;
    1056 
    1057         return result;
     1036       
     1037        return result;
    10581038}
    10591039
  • uspace/lib/softfloat/generic/div.c

    r3a01483 rc127e1c  
    4141#include <common.h>
    4242
    43 /**
    44  * Divide two single-precision floats.
    45  *
     43/** Divide two single-precision floats.
     44 *
    4645 * @param a Nominator.
    4746 * @param b Denominator.
     47 *
    4848 * @return Result of division.
    49  */
    50 float32 divFloat32(float32 a, float32 b)
     49 *
     50 */
     51float32 div_float32(float32 a, float32 b)
    5152{
    5253        float32 result;
     
    5657        result.parts.sign = a.parts.sign ^ b.parts.sign;
    5758       
    58         if (isFloat32NaN(a)) {
    59                 if (isFloat32SigNaN(a)) {
    60                         /*FIXME: SigNaN*/
    61                 }
    62                 /*NaN*/
     59        if (is_float32_nan(a)) {
     60                if (is_float32_signan(a)) {
     61                        // FIXME: SigNaN
     62                }
     63                /* NaN */
    6364                return a;
    6465        }
    6566       
    66         if (isFloat32NaN(b)) {
    67                 if (isFloat32SigNaN(b)) {
    68                         /*FIXME: SigNaN*/
    69                 }
    70                 /*NaN*/
     67        if (is_float32_nan(b)) {
     68                if (is_float32_signan(b)) {
     69                        // FIXME: SigNaN
     70                }
     71                /* NaN */
    7172                return b;
    7273        }
    7374       
    74         if (isFloat32Infinity(a)) {
    75                 if (isFloat32Infinity(b)) {
     75        if (is_float32_infinity(a)) {
     76                if (is_float32_infinity(b)) {
    7677                        /*FIXME: inf / inf */
    77                         result.binary = FLOAT32_NAN;
     78                        result.bin = FLOAT32_NAN;
    7879                        return result;
    7980                }
     
    8384                return result;
    8485        }
    85 
    86         if (isFloat32Infinity(b)) {
    87                 if (isFloat32Zero(a)) {
     86       
     87        if (is_float32_infinity(b)) {
     88                if (is_float32_zero(a)) {
    8889                        /* FIXME 0 / inf */
    8990                        result.parts.exp = 0;
     
    9798        }
    9899       
    99         if (isFloat32Zero(b)) {
    100                 if (isFloat32Zero(a)) {
     100        if (is_float32_zero(b)) {
     101                if (is_float32_zero(a)) {
    101102                        /*FIXME: 0 / 0*/
    102                         result.binary = FLOAT32_NAN;
     103                        result.bin = FLOAT32_NAN;
    103104                        return result;
    104105                }
     
    121122                        return result;
    122123                }
    123 
     124               
    124125                /* normalize it*/
    125126                afrac <<= 1;
    126                 /* afrac is nonzero => it must stop */ 
     127                /* afrac is nonzero => it must stop */
    127128                while (!(afrac & FLOAT32_HIDDEN_BIT_MASK)) {
    128129                        afrac <<= 1;
     
    130131                }
    131132        }
    132 
     133       
    133134        if (bexp == 0) {
    134135                bfrac <<= 1;
    135                 /* bfrac is nonzero => it must stop */ 
     136                /* bfrac is nonzero => it must stop */
    136137                while (!(bfrac & FLOAT32_HIDDEN_BIT_MASK)) {
    137138                        bfrac <<= 1;
     
    139140                }
    140141        }
    141 
    142         afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
    143         bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
    144 
     142       
     143        afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
     144        bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
     145       
    145146        if (bfrac <= (afrac << 1)) {
    146147                afrac >>= 1;
     
    169170                ++cexp;
    170171                cfrac >>= 1;
    171         }       
    172 
     172        }
     173       
    173174        /* check overflow */
    174175        if (cexp >= FLOAT32_MAX_EXPONENT) {
     
    178179                return result;
    179180        }
    180 
     181       
    181182        if (cexp < 0) {
    182183                /* FIXME: underflow */
     
    190191                        cexp++;
    191192                        cfrac >>= 1;
    192                 }       
     193                }
    193194        } else {
    194195                result.parts.exp = (uint32_t) cexp;
     
    197198        result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
    198199       
    199         return result; 
     200        return result;
    200201}
    201202
    202 /**
    203  * Divide two double-precision floats.
     203/** Divide two double-precision floats.
    204204 *
    205205 * @param a Nominator.
    206206 * @param b Denominator.
     207 *
    207208 * @return Result of division.
    208  */
    209 float64 divFloat64(float64 a, float64 b)
     209 *
     210 */
     211float64 div_float64(float64 a, float64 b)
    210212{
    211213        float64 result;
     
    217219        result.parts.sign = a.parts.sign ^ b.parts.sign;
    218220       
    219         if (isFloat64NaN(a)) {
    220                 if (isFloat64SigNaN(b)) {
    221                         /*FIXME: SigNaN*/
     221        if (is_float64_nan(a)) {
     222                if (is_float64_signan(b)) {
     223                        // FIXME: SigNaN
    222224                        return b;
    223225                }
    224226               
    225                 if (isFloat64SigNaN(a)) {
    226                         /*FIXME: SigNaN*/
    227                 }
    228                 /*NaN*/
     227                if (is_float64_signan(a)) {
     228                        // FIXME: SigNaN
     229                }
     230                /* NaN */
    229231                return a;
    230232        }
    231233       
    232         if (isFloat64NaN(b)) {
    233                 if (isFloat64SigNaN(b)) {
    234                         /*FIXME: SigNaN*/
    235                 }
    236                 /*NaN*/
     234        if (is_float64_nan(b)) {
     235                if (is_float64_signan(b)) {
     236                        // FIXME: SigNaN
     237                }
     238                /* NaN */
    237239                return b;
    238240        }
    239241       
    240         if (isFloat64Infinity(a)) {
    241                 if (isFloat64Infinity(b) || isFloat64Zero(b)) {
    242                         /*FIXME: inf / inf */
    243                         result.binary = FLOAT64_NAN;
     242        if (is_float64_infinity(a)) {
     243                if (is_float64_infinity(b) || is_float64_zero(b)) {
     244                        // FIXME: inf / inf
     245                        result.bin = FLOAT64_NAN;
    244246                        return result;
    245247                }
     
    249251                return result;
    250252        }
    251 
    252         if (isFloat64Infinity(b)) {
    253                 if (isFloat64Zero(a)) {
     253       
     254        if (is_float64_infinity(b)) {
     255                if (is_float64_zero(a)) {
    254256                        /* FIXME 0 / inf */
    255257                        result.parts.exp = 0;
     
    263265        }
    264266       
    265         if (isFloat64Zero(b)) {
    266                 if (isFloat64Zero(a)) {
     267        if (is_float64_zero(b)) {
     268                if (is_float64_zero(a)) {
    267269                        /*FIXME: 0 / 0*/
    268                         result.binary = FLOAT64_NAN;
     270                        result.bin = FLOAT64_NAN;
    269271                        return result;
    270272                }
     
    274276                return result;
    275277        }
    276 
     278       
    277279        afrac = a.parts.fraction;
    278280        aexp = a.parts.exp;
     
    287289                        return result;
    288290                }
    289 
     291               
    290292                /* normalize it*/
    291293                aexp++;
     
    296298                }
    297299        }
    298 
     300       
    299301        if (bexp == 0) {
    300302                bexp++;
     
    305307                }
    306308        }
    307 
    308         afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
    309         bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
    310 
     309       
     310        afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
     311        bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
     312       
    311313        if (bfrac <= (afrac << 1)) {
    312314                afrac >>= 1;
     
    330332       
    331333        /* round and shift */
    332         result = finishFloat64(cexp, cfrac, result.parts.sign);
     334        result = finish_float64(cexp, cfrac, result.parts.sign);
    333335        return result;
    334336}
    335337
    336 /**
    337  * Divide two quadruple-precision floats.
     338/** Divide two quadruple-precision floats.
    338339 *
    339340 * @param a Nominator.
    340341 * @param b Denominator.
     342 *
    341343 * @return Result of division.
    342  */
    343 float128 divFloat128(float128 a, float128 b)
     344 *
     345 */
     346float128 div_float128(float128 a, float128 b)
    344347{
    345348        float128 result;
     
    349352        uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo;
    350353        uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo;
    351 
     354       
    352355        result.parts.sign = a.parts.sign ^ b.parts.sign;
    353 
    354         if (isFloat128NaN(a)) {
    355                 if (isFloat128SigNaN(b)) {
    356                         /*FIXME: SigNaN*/
     356       
     357        if (is_float128_nan(a)) {
     358                if (is_float128_signan(b)) {
     359                        // FIXME: SigNaN
    357360                        return b;
    358361                }
    359 
    360                 if (isFloat128SigNaN(a)) {
    361                         /*FIXME: SigNaN*/
    362                 }
    363                 /*NaN*/
     362               
     363                if (is_float128_signan(a)) {
     364                        // FIXME: SigNaN
     365                }
     366                /* NaN */
    364367                return a;
    365368        }
    366 
    367         if (isFloat128NaN(b)) {
    368                 if (isFloat128SigNaN(b)) {
    369                         /*FIXME: SigNaN*/
    370                 }
    371                 /*NaN*/
     369       
     370        if (is_float128_nan(b)) {
     371                if (is_float128_signan(b)) {
     372                        // FIXME: SigNaN
     373                }
     374                /* NaN */
    372375                return b;
    373376        }
    374 
    375         if (isFloat128Infinity(a)) {
    376                 if (isFloat128Infinity(b) || isFloat128Zero(b)) {
    377                         /*FIXME: inf / inf */
    378                         result.binary.hi = FLOAT128_NAN_HI;
    379                         result.binary.lo = FLOAT128_NAN_LO;
     377       
     378        if (is_float128_infinity(a)) {
     379                if (is_float128_infinity(b) || is_float128_zero(b)) {
     380                        // FIXME: inf / inf
     381                        result.bin.hi = FLOAT128_NAN_HI;
     382                        result.bin.lo = FLOAT128_NAN_LO;
    380383                        return result;
    381384                }
     
    386389                return result;
    387390        }
    388 
    389         if (isFloat128Infinity(b)) {
    390                 if (isFloat128Zero(a)) {
    391                         /* FIXME 0 / inf */
     391       
     392        if (is_float128_infinity(b)) {
     393                if (is_float128_zero(a)) {
     394                        // FIXME 0 / inf
    392395                        result.parts.exp = 0;
    393396                        result.parts.frac_hi = 0;
     
    395398                        return result;
    396399                }
    397                 /* FIXME: num / inf*/
     400                // FIXME: num / inf
    398401                result.parts.exp = 0;
    399402                result.parts.frac_hi = 0;
     
    401404                return result;
    402405        }
    403 
    404         if (isFloat128Zero(b)) {
    405                 if (isFloat128Zero(a)) {
    406                         /*FIXME: 0 / 0*/
    407                         result.binary.hi = FLOAT128_NAN_HI;
    408                         result.binary.lo = FLOAT128_NAN_LO;
    409                         return result;
    410                 }
    411                 /* FIXME: division by zero */
     406       
     407        if (is_float128_zero(b)) {
     408                if (is_float128_zero(a)) {
     409                        // FIXME: 0 / 0
     410                        result.bin.hi = FLOAT128_NAN_HI;
     411                        result.bin.lo = FLOAT128_NAN_LO;
     412                        return result;
     413                }
     414                // FIXME: division by zero
    412415                result.parts.exp = 0;
    413416                result.parts.frac_hi = 0;
     
    415418                return result;
    416419        }
    417 
     420       
    418421        afrac_hi = a.parts.frac_hi;
    419422        afrac_lo = a.parts.frac_lo;
     
    422425        bfrac_lo = b.parts.frac_lo;
    423426        bexp = b.parts.exp;
    424 
     427       
    425428        /* denormalized numbers */
    426429        if (aexp == 0) {
     
    431434                        return result;
    432435                }
    433 
     436               
    434437                /* normalize it*/
    435438                aexp++;
     
    443446                }
    444447        }
    445 
     448       
    446449        if (bexp == 0) {
    447450                bexp++;
     
    455458                }
    456459        }
    457 
     460       
    458461        or128(afrac_hi, afrac_lo,
    459462            FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     
    466469        lshift128(bfrac_hi, bfrac_lo,
    467470            (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo);
    468 
     471       
    469472        if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) {
    470473                rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo);
    471474                aexp++;
    472475        }
    473 
     476       
    474477        cexp = aexp - bexp + FLOAT128_BIAS - 2;
    475 
     478       
    476479        cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi);
    477 
     480       
    478481        mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi,
    479482            &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi);
    480 
    481         /* sub192(afrac_hi, afrac_lo, 0, 
     483       
     484        /* sub192(afrac_hi, afrac_lo, 0,
    482485         *     tmp_hihi, tmp_hilo, tmp_lohi
    483486         *     &rem_hihi, &rem_hilo, &rem_lohi); */
     
    487490        }
    488491        rem_lohi = -tmp_lohi;
    489 
     492       
    490493        while ((int64_t) rem_hihi < 0) {
    491494                --cfrac_hi;
    492                 /* add192(rem_hihi, rem_hilo, rem_lohi, 
     495                /* add192(rem_hihi, rem_hilo, rem_lohi,
    493496                 *     0, bfrac_hi, bfrac_lo,
    494497                 *     &rem_hihi, &rem_hilo, &rem_lohi); */
     
    498501                }
    499502        }
    500 
     503       
    501504        cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo);
    502 
     505       
    503506        if ((cfrac_lo & 0x3FFF) <= 4) {
    504507                mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo,
    505                 &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
    506 
     508                    &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
     509               
    507510                /* sub192(rem_hilo, rem_lohi, 0,
    508511                 *     tmp_hilo, tmp_lohi, tmp_lolo,
     
    513516                }
    514517                rem_lolo = -tmp_lolo;
    515 
     518               
    516519                while ((int64_t) rem_hilo < 0) {
    517520                        --cfrac_lo;
     
    524527                        }
    525528                }
    526 
     529               
    527530                cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 );
    528531        }
    529 
     532       
    530533        shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1));
    531534        rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1),
    532535            &cfrac_hi, &cfrac_lo);
    533 
    534         result = finishFloat128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
     536       
     537        result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
    535538        return result;
    536539}
  • uspace/lib/softfloat/generic/mul.c

    r3a01483 rc127e1c  
    3939#include <common.h>
    4040
    41 /**
    42  * Multiply two single-precision floats.
     41/** Multiply two single-precision floats.
    4342 *
    4443 * @param a First input operand.
    4544 * @param b Second input operand.
     45 *
    4646 * @return Result of multiplication.
    47  */
    48 float32 mulFloat32(float32 a, float32 b)
     47 *
     48 */
     49float32 mul_float32(float32 a, float32 b)
    4950{
    5051        float32 result;
    5152        uint64_t frac1, frac2;
    5253        int32_t exp;
    53 
     54       
    5455        result.parts.sign = a.parts.sign ^ b.parts.sign;
    5556       
    56         if (isFloat32NaN(a) || isFloat32NaN(b)) {
     57        if (is_float32_nan(a) || is_float32_nan(b)) {
    5758                /* TODO: fix SigNaNs */
    58                 if (isFloat32SigNaN(a)) {
     59                if (is_float32_signan(a)) {
    5960                        result.parts.fraction = a.parts.fraction;
    6061                        result.parts.exp = a.parts.exp;
    6162                        return result;
    6263                }
    63                 if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
     64                if (is_float32_signan(b)) { /* TODO: fix SigNaN */
    6465                        result.parts.fraction = b.parts.fraction;
    6566                        result.parts.exp = b.parts.exp;
     
    6768                }
    6869                /* set NaN as result */
    69                 result.binary = FLOAT32_NAN;
    70                 return result;
    71         }
    72                
    73         if (isFloat32Infinity(a)) {
    74                 if (isFloat32Zero(b)) {
    75                         /* FIXME: zero * infinity */
    76                         result.binary = FLOAT32_NAN;
     70                result.bin = FLOAT32_NAN;
     71                return result;
     72        }
     73       
     74        if (is_float32_infinity(a)) {
     75                if (is_float32_zero(b)) {
     76                        /* FIXME: zero * infinity */
     77                        result.bin = FLOAT32_NAN;
    7778                        return result;
    7879                }
     
    8182                return result;
    8283        }
    83 
    84         if (isFloat32Infinity(b)) {
    85                 if (isFloat32Zero(a)) {
    86                         /* FIXME: zero * infinity */
    87                         result.binary = FLOAT32_NAN;
     84       
     85        if (is_float32_infinity(b)) {
     86                if (is_float32_zero(a)) {
     87                        /* FIXME: zero * infinity */
     88                        result.bin = FLOAT32_NAN;
    8889                        return result;
    8990                }
     
    9293                return result;
    9394        }
    94 
     95       
    9596        /* exp is signed so we can easy detect underflow */
    9697        exp = a.parts.exp + b.parts.exp;
     
    100101                /* FIXME: overflow */
    101102                /* set infinity as result */
    102                 result.binary = FLOAT32_INF;
     103                result.bin = FLOAT32_INF;
    103104                result.parts.sign = a.parts.sign ^ b.parts.sign;
    104105                return result;
     
    121122       
    122123        frac2 = b.parts.fraction;
    123 
     124       
    124125        if (b.parts.exp > 0) {
    125126                frac2 |= FLOAT32_HIDDEN_BIT_MASK;
     
    127128                ++exp;
    128129        }
    129 
     130       
    130131        frac1 <<= 1; /* one bit space for rounding */
    131 
     132       
    132133        frac1 = frac1 * frac2;
    133 
     134       
    134135        /* round and return */
    135         while ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
     136        while ((exp < FLOAT32_MAX_EXPONENT) &&
     137            (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
    136138                /* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left) */
    137139                ++exp;
    138140                frac1 >>= 1;
    139141        }
    140 
     142       
    141143        /* rounding */
    142144        /* ++frac1; FIXME: not works - without it is ok */
    143145        frac1 >>= 1; /* shift off rounding space */
    144146       
    145         if ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
     147        if ((exp < FLOAT32_MAX_EXPONENT) &&
     148            (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
    146149                ++exp;
    147150                frac1 >>= 1;
    148151        }
    149 
    150         if (exp >= FLOAT32_MAX_EXPONENT) {     
     152       
     153        if (exp >= FLOAT32_MAX_EXPONENT) {
    151154                /* TODO: fix overflow */
    152155                /* return infinity*/
     
    157160       
    158161        exp -= FLOAT32_FRACTION_SIZE;
    159 
    160         if (exp <= FLOAT32_FRACTION_SIZE) { 
     162       
     163        if (exp <= FLOAT32_FRACTION_SIZE) {
    161164                /* denormalized number */
    162165                frac1 >>= 1; /* denormalize */
     
    175178        result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
    176179       
    177         return result; 
     180        return result;
    178181}
    179182
    180 /**
    181  * Multiply two double-precision floats.
     183/** Multiply two double-precision floats.
    182184 *
    183185 * @param a First input operand.
    184186 * @param b Second input operand.
     187 *
    185188 * @return Result of multiplication.
    186  */
    187 float64 mulFloat64(float64 a, float64 b)
     189 *
     190 */
     191float64 mul_float64(float64 a, float64 b)
    188192{
    189193        float64 result;
    190194        uint64_t frac1, frac2;
    191195        int32_t exp;
    192 
     196       
    193197        result.parts.sign = a.parts.sign ^ b.parts.sign;
    194198       
    195         if (isFloat64NaN(a) || isFloat64NaN(b)) {
     199        if (is_float64_nan(a) || is_float64_nan(b)) {
    196200                /* TODO: fix SigNaNs */
    197                 if (isFloat64SigNaN(a)) {
     201                if (is_float64_signan(a)) {
    198202                        result.parts.fraction = a.parts.fraction;
    199203                        result.parts.exp = a.parts.exp;
    200204                        return result;
    201205                }
    202                 if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */
     206                if (is_float64_signan(b)) { /* TODO: fix SigNaN */
    203207                        result.parts.fraction = b.parts.fraction;
    204208                        result.parts.exp = b.parts.exp;
     
    206210                }
    207211                /* set NaN as result */
    208                 result.binary = FLOAT64_NAN;
    209                 return result;
    210         }
    211                
    212         if (isFloat64Infinity(a)) {
    213                 if (isFloat64Zero(b)) {
    214                         /* FIXME: zero * infinity */
    215                         result.binary = FLOAT64_NAN;
     212                result.bin = FLOAT64_NAN;
     213                return result;
     214        }
     215       
     216        if (is_float64_infinity(a)) {
     217                if (is_float64_zero(b)) {
     218                        /* FIXME: zero * infinity */
     219                        result.bin = FLOAT64_NAN;
    216220                        return result;
    217221                }
     
    220224                return result;
    221225        }
    222 
    223         if (isFloat64Infinity(b)) {
    224                 if (isFloat64Zero(a)) {
    225                         /* FIXME: zero * infinity */
    226                         result.binary = FLOAT64_NAN;
     226       
     227        if (is_float64_infinity(b)) {
     228                if (is_float64_zero(a)) {
     229                        /* FIXME: zero * infinity */
     230                        result.bin = FLOAT64_NAN;
    227231                        return result;
    228232                }
     
    231235                return result;
    232236        }
    233 
     237       
    234238        /* exp is signed so we can easy detect underflow */
    235239        exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS;
    236240       
    237241        frac1 = a.parts.fraction;
    238 
     242       
    239243        if (a.parts.exp > 0) {
    240244                frac1 |= FLOAT64_HIDDEN_BIT_MASK;
     
    244248       
    245249        frac2 = b.parts.fraction;
    246 
     250       
    247251        if (b.parts.exp > 0) {
    248252                frac2 |= FLOAT64_HIDDEN_BIT_MASK;
     
    250254                ++exp;
    251255        }
    252 
     256       
    253257        frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1);
    254258        frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2);
    255 
     259       
    256260        mul64(frac1, frac2, &frac1, &frac2);
    257 
     261       
    258262        frac1 |= (frac2 != 0);
    259263        if (frac1 & (0x1ll << 62)) {
     
    261265                exp--;
    262266        }
    263 
    264         result = finishFloat64(exp, frac1, result.parts.sign);
     267       
     268        result = finish_float64(exp, frac1, result.parts.sign);
    265269        return result;
    266270}
    267271
    268 /**
    269  * Multiply two quadruple-precision floats.
     272/** Multiply two quadruple-precision floats.
    270273 *
    271274 * @param a First input operand.
    272275 * @param b Second input operand.
     276 *
    273277 * @return Result of multiplication.
    274  */
    275 float128 mulFloat128(float128 a, float128 b)
     278 *
     279 */
     280float128 mul_float128(float128 a, float128 b)
    276281{
    277282        float128 result;
    278283        uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
    279284        int32_t exp;
    280 
     285       
    281286        result.parts.sign = a.parts.sign ^ b.parts.sign;
    282 
    283         if (isFloat128NaN(a) || isFloat128NaN(b)) {
     287       
     288        if (is_float128_nan(a) || is_float128_nan(b)) {
    284289                /* TODO: fix SigNaNs */
    285                 if (isFloat128SigNaN(a)) {
     290                if (is_float128_signan(a)) {
    286291                        result.parts.frac_hi = a.parts.frac_hi;
    287292                        result.parts.frac_lo = a.parts.frac_lo;
     
    289294                        return result;
    290295                }
    291                 if (isFloat128SigNaN(b)) { /* TODO: fix SigNaN */
     296                if (is_float128_signan(b)) { /* TODO: fix SigNaN */
    292297                        result.parts.frac_hi = b.parts.frac_hi;
    293298                        result.parts.frac_lo = b.parts.frac_lo;
     
    296301                }
    297302                /* set NaN as result */
    298                 result.binary.hi = FLOAT128_NAN_HI;
    299                 result.binary.lo = FLOAT128_NAN_LO;
    300                 return result;
    301         }
    302 
    303         if (isFloat128Infinity(a)) {
    304                 if (isFloat128Zero(b)) {
    305                         /* FIXME: zero * infinity */
    306                         result.binary.hi = FLOAT128_NAN_HI;
    307                         result.binary.lo = FLOAT128_NAN_LO;
     303                result.bin.hi = FLOAT128_NAN_HI;
     304                result.bin.lo = FLOAT128_NAN_LO;
     305                return result;
     306        }
     307       
     308        if (is_float128_infinity(a)) {
     309                if (is_float128_zero(b)) {
     310                        /* FIXME: zero * infinity */
     311                        result.bin.hi = FLOAT128_NAN_HI;
     312                        result.bin.lo = FLOAT128_NAN_LO;
    308313                        return result;
    309314                }
     
    313318                return result;
    314319        }
    315 
    316         if (isFloat128Infinity(b)) {
    317                 if (isFloat128Zero(a)) {
    318                         /* FIXME: zero * infinity */
    319                         result.binary.hi = FLOAT128_NAN_HI;
    320                         result.binary.lo = FLOAT128_NAN_LO;
     320       
     321        if (is_float128_infinity(b)) {
     322                if (is_float128_zero(a)) {
     323                        /* FIXME: zero * infinity */
     324                        result.bin.hi = FLOAT128_NAN_HI;
     325                        result.bin.lo = FLOAT128_NAN_LO;
    321326                        return result;
    322327                }
     
    326331                return result;
    327332        }
    328 
     333       
    329334        /* exp is signed so we can easy detect underflow */
    330335        exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1;
    331 
     336       
    332337        frac1_hi = a.parts.frac_hi;
    333338        frac1_lo = a.parts.frac_lo;
    334 
     339       
    335340        if (a.parts.exp > 0) {
    336341                or128(frac1_hi, frac1_lo,
    337                 FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
    338                 &frac1_hi, &frac1_lo);
    339         } else {
    340                 ++exp;
    341         }
    342 
     342                    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
     343                    &frac1_hi, &frac1_lo);
     344        } else {
     345                ++exp;
     346        }
     347       
    343348        frac2_hi = b.parts.frac_hi;
    344349        frac2_lo = b.parts.frac_lo;
    345 
     350       
    346351        if (b.parts.exp > 0) {
    347352                or128(frac2_hi, frac2_lo,
     
    351356                ++exp;
    352357        }
    353 
     358       
    354359        lshift128(frac2_hi, frac2_lo,
    355360            128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo);
    356 
     361       
    357362        tmp_hi = frac1_hi;
    358363        tmp_lo = frac1_lo;
     
    361366        add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
    362367        frac2_hi |= (frac2_lo != 0x0ll);
    363 
     368       
    364369        if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) {
    365370                frac2_hi >>= 1;
     
    370375                ++exp;
    371376        }
    372 
    373         result = finishFloat128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
     377       
     378        result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
    374379        return result;
    375380}
  • uspace/lib/softfloat/generic/softfloat.c

    r3a01483 rc127e1c  
    4848#include <other.h>
    4949
    50 #include <functions.h>
    51 
    5250/* Arithmetic functions */
    5351
    5452float __addsf3(float a, float b)
    5553{
    56         float32 fa, fb;
    57         fa.f = a;
    58         fb.f = b;
    59         if (fa.parts.sign != fb.parts.sign) {
    60                 if (fa.parts.sign) {
    61                         fa.parts.sign = 0;
    62                         return subFloat32(fb, fa).f;
    63                 };
    64                 fb.parts.sign = 0;
    65                 return subFloat32(fa, fb).f;
    66         }
    67         return addFloat32(fa, fb).f;
     54        float_t fa;
     55        float_t fb;
     56        float_t res;
     57       
     58        fa.val = a;
     59        fb.val = b;
     60       
     61        if (fa.data.parts.sign != fb.data.parts.sign) {
     62                if (fa.data.parts.sign) {
     63                        fa.data.parts.sign = 0;
     64                        res.data = sub_float(fb.data, fa.data);
     65                       
     66                        return res.val;
     67                }
     68               
     69                fb.data.parts.sign = 0;
     70                res.data = sub_float(fa.data, fb.data);
     71               
     72                return res.val;
     73        }
     74       
     75        res.data = add_float(fa.data, fb.data);
     76        return res.val;
    6877}
    6978
    7079double __adddf3(double a, double b)
    7180{
    72         float64 da, db;
    73         da.d = a;
    74         db.d = b;
    75         if (da.parts.sign != db.parts.sign) {
    76                 if (da.parts.sign) {
    77                         da.parts.sign = 0;
    78                         return subFloat64(db, da).d;
    79                 };
    80                 db.parts.sign = 0;
    81                 return subFloat64(da, db).d;
    82         }
    83         return addFloat64(da, db).d;
     81        double_t da;
     82        double_t db;
     83        double_t res;
     84       
     85        da.val = a;
     86        db.val = b;
     87       
     88        if (da.data.parts.sign != db.data.parts.sign) {
     89                if (da.data.parts.sign) {
     90                        da.data.parts.sign = 0;
     91                        res.data = sub_double(db.data, da.data);
     92                       
     93                        return res.val;
     94                }
     95               
     96                db.data.parts.sign = 0;
     97                res.data = sub_double(da.data, db.data);
     98               
     99                return res.val;
     100        }
     101       
     102        res.data = add_double(da.data, db.data);
     103        return res.val;
    84104}
    85105
    86106long double __addtf3(long double a, long double b)
    87107{
    88         float128 ta, tb;
    89         ta.ld = a;
    90         tb.ld = b;
    91         if (ta.parts.sign != tb.parts.sign) {
    92                 if (ta.parts.sign) {
    93                         ta.parts.sign = 0;
    94                         return subFloat128(tb, ta).ld;
    95                 };
    96                 tb.parts.sign = 0;
    97                 return subFloat128(ta, tb).ld;
    98         }
    99         return addFloat128(ta, tb).ld;
     108        long_double_t ta;
     109        long_double_t tb;
     110        long_double_t res;
     111       
     112        ta.val = a;
     113        tb.val = b;
     114       
     115        if (ta.data.parts.sign != tb.data.parts.sign) {
     116                if (ta.data.parts.sign) {
     117                        ta.data.parts.sign = 0;
     118                        res.data = sub_long_double(tb.data, ta.data);
     119                       
     120                        return res.val;
     121                }
     122               
     123                tb.data.parts.sign = 0;
     124                res.data = sub_long_double(ta.data, tb.data);
     125               
     126                return res.val;
     127        }
     128       
     129        res.data = add_long_double(ta.data, tb.data);
     130        return res.val;
    100131}
    101132
    102133float __subsf3(float a, float b)
    103134{
    104         float32 fa, fb;
    105         fa.f = a;
    106         fb.f = b;
    107         if (fa.parts.sign != fb.parts.sign) {
    108                 fb.parts.sign = !fb.parts.sign;
    109                 return addFloat32(fa, fb).f;
    110         }
    111         return subFloat32(fa, fb).f;
     135        float_t fa;
     136        float_t fb;
     137        float_t res;
     138       
     139        fa.val = a;
     140        fb.val = b;
     141       
     142        if (fa.data.parts.sign != fb.data.parts.sign) {
     143                fb.data.parts.sign = !fb.data.parts.sign;
     144                res.data = add_float(fa.data, fb.data);
     145               
     146                return res.val;
     147        }
     148       
     149        res.data = sub_float(fa.data, fb.data);
     150        return res.val;
    112151}
    113152
    114153double __subdf3(double a, double b)
    115154{
    116         float64 da, db;
    117         da.d = a;
    118         db.d = b;
    119         if (da.parts.sign != db.parts.sign) {
    120                 db.parts.sign = !db.parts.sign;
    121                 return addFloat64(da, db).d;
    122         }
    123         return subFloat64(da, db).d;
     155        double_t da;
     156        double_t db;
     157        double_t res;
     158       
     159        da.val = a;
     160        db.val = b;
     161       
     162        if (da.data.parts.sign != db.data.parts.sign) {
     163                db.data.parts.sign = !db.data.parts.sign;
     164                res.data = add_double(da.data, db.data);
     165               
     166                return res.val;
     167        }
     168       
     169        res.data = sub_double(da.data, db.data);
     170        return res.val;
    124171}
    125172
    126173long double __subtf3(long double a, long double b)
    127174{
    128         float128 ta, tb;
    129         ta.ld = a;
    130         tb.ld = b;
    131         if (ta.parts.sign != tb.parts.sign) {
    132                 tb.parts.sign = !tb.parts.sign;
    133                 return addFloat128(ta, tb).ld;
    134         }
    135         return subFloat128(ta, tb).ld;
    136 }
    137 
    138 float __mulsf3(float a, float b)
    139 {
    140         float32 fa, fb;
    141         fa.f = a;
    142         fb.f = b;
    143         return  mulFloat32(fa, fb).f;
    144 }
    145 
    146 double __muldf3(double a, double b)
    147 {
    148         float64 da, db;
    149         da.d = a;
    150         db.d = b;
    151         return  mulFloat64(da, db).d;
     175        long_double_t ta;
     176        long_double_t tb;
     177        long_double_t res;
     178       
     179        ta.val = a;
     180        tb.val = b;
     181       
     182        if (ta.data.parts.sign != tb.data.parts.sign) {
     183                tb.data.parts.sign = !tb.data.parts.sign;
     184                res.data = add_long_double(ta.data, tb.data);
     185               
     186                return res.val;
     187        }
     188       
     189        res.data = sub_long_double(ta.data, tb.data);
     190        return res.val;
     191}
     192
     193float __mulsf3(float a, float b)
     194{
     195        float_t fa;
     196        float_t fb;
     197        float_t res;
     198       
     199        fa.val = a;
     200        fb.val = b;
     201       
     202        res.data = mul_float(fa.data, fb.data);
     203        return res.val;
     204}
     205
     206double __muldf3(double a, double b)
     207{
     208        double_t da;
     209        double_t db;
     210        double_t res;
     211       
     212        da.val = a;
     213        db.val = b;
     214       
     215        res.data = mul_double(da.data, db.data);
     216        return res.val;
    152217}
    153218
    154219long double __multf3(long double a, long double b)
    155220{
    156         float128 ta, tb;
    157         ta.ld = a;
    158         tb.ld = b;
    159         return  mulFloat128(ta, tb).ld;
    160 }
    161 
    162 float __divsf3(float a, float b)
    163 {
    164         float32 fa, fb;
    165         fa.f = a;
    166         fb.f = b;
    167         return  divFloat32(fa, fb).f;
    168 }
    169 
    170 double __divdf3(double a, double b)
    171 {
    172         float64 da, db;
    173         da.d = a;
    174         db.d = b;
    175         return  divFloat64(da, db).d;
     221        long_double_t ta;
     222        long_double_t tb;
     223        long_double_t res;
     224       
     225        ta.val = a;
     226        tb.val = b;
     227       
     228        res.data = mul_long_double(ta.data, tb.data);
     229        return res.val;
     230}
     231
     232float __divsf3(float a, float b)
     233{
     234        float_t fa;
     235        float_t fb;
     236        float_t res;
     237       
     238        fa.val = a;
     239        fb.val = b;
     240       
     241        res.data = div_float(fa.data, fb.data);
     242        return res.val;
     243}
     244
     245double __divdf3(double a, double b)
     246{
     247        double_t da;
     248        double_t db;
     249        double_t res;
     250       
     251        da.val = a;
     252        db.val = b;
     253       
     254        res.data = div_double(da.data, db.data);
     255        return res.val;
    176256}
    177257
    178258long double __divtf3(long double a, long double b)
    179259{
    180         float128 ta, tb;
    181         ta.ld = a;
    182         tb.ld = b;
    183         return  divFloat128(ta, tb).ld;
     260        long_double_t ta;
     261        long_double_t tb;
     262        long_double_t res;
     263       
     264        ta.val = a;
     265        tb.val = b;
     266       
     267        res.data = div_long_double(ta.data, tb.data);
     268        return res.val;
    184269}
    185270
    186271float __negsf2(float a)
    187272{
    188         float32 fa;
    189         fa.f = a;
    190         fa.parts.sign = !fa.parts.sign;
    191         return fa.f;
     273        float_t fa;
     274       
     275        fa.val = a;
     276        fa.data.parts.sign = !fa.data.parts.sign;
     277       
     278        return fa.val;
    192279}
    193280
    194281double __negdf2(double a)
    195282{
    196         float64 da;
    197         da.d = a;
    198         da.parts.sign = !da.parts.sign;
    199         return da.d;
     283        double_t da;
     284       
     285        da.val = a;
     286        da.data.parts.sign = !da.data.parts.sign;
     287       
     288        return da.val;
    200289}
    201290
    202291long double __negtf2(long double a)
    203292{
    204         float128 ta;
    205         ta.ld = a;
    206         ta.parts.sign = !ta.parts.sign;
    207         return ta.ld;
     293        long_double_t ta;
     294       
     295        ta.val = a;
     296        ta.data.parts.sign = !ta.data.parts.sign;
     297       
     298        return ta.val;
    208299}
    209300
    210301/* Conversion functions */
    211302
    212 double __extendsfdf2(float a)
    213 {
    214         float32 fa;
    215         fa.f = a;
    216         return convertFloat32ToFloat64(fa).d;
     303double __extendsfdf2(float a)
     304{
     305        float_t fa;
     306        double_t res;
     307       
     308        fa.val = a;
     309        res.data = float_to_double(fa.data);
     310       
     311        return res.val;
    217312}
    218313
    219314long double __extendsftf2(float a)
    220315{
    221         float32 fa;
    222         fa.f = a;
    223         return convertFloat32ToFloat128(fa).ld;
     316        float_t fa;
     317        long_double_t res;
     318       
     319        fa.val = a;
     320        res.data = float_to_long_double(fa.data);
     321       
     322        return res.val;
    224323}
    225324
    226325long double __extenddftf2(double a)
    227326{
    228         float64 da;
    229         da.d = a;
    230         return convertFloat64ToFloat128(da).ld;
    231 }
    232 
    233 float __truncdfsf2(double a)
    234 {
    235         float64 da;
    236         da.d = a;
    237         return convertFloat64ToFloat32(da).f;
     327        double_t da;
     328        long_double_t res;
     329       
     330        da.val = a;
     331        res.data = double_to_long_double(da.data);
     332       
     333        return res.val;
     334}
     335
     336float __truncdfsf2(double a)
     337{
     338        double_t da;
     339        float_t res;
     340       
     341        da.val = a;
     342        res.data = double_to_float(da.data);
     343       
     344        return res.val;
    238345}
    239346
    240347float __trunctfsf2(long double a)
    241348{
    242         float128 ta;
    243         ta.ld = a;
    244         return convertFloat128ToFloat32(ta).f;
     349        long_double_t ta;
     350        float_t res;
     351       
     352        ta.val = a;
     353        res.data = long_double_to_float(ta.data);
     354       
     355        return res.val;
    245356}
    246357
    247358double __trunctfdf2(long double a)
    248359{
    249         float128 ta;
    250         ta.ld = a;
    251         return convertFloat128ToFloat64(ta).d;
     360        long_double_t ta;
     361        double_t res;
     362       
     363        ta.val = a;
     364        res.data = long_double_to_double(ta.data);
     365       
     366        return res.val;
    252367}
    253368
    254369int __fixsfsi(float a)
    255370{
    256         float32 fa;
    257         fa.f = a;
    258        
    259         return float32_to_int(fa);
     371        float_t fa;
     372       
     373        fa.val = a;
     374        return float_to_int(fa.data);
    260375}
    261376
    262377int __fixdfsi(double a)
    263378{
    264         float64 da;
    265         da.d = a;
    266        
    267         return float64_to_int(da);
     379        double_t da;
     380       
     381        da.val = a;
     382        return double_to_int(da.data);
    268383}
    269384
    270385int __fixtfsi(long double a)
    271386{
    272         float128 ta;
    273         ta.ld = a;
    274 
    275         return float128_to_int(ta);
     387        long_double_t ta;
     388       
     389        ta.val = a;
     390        return long_double_to_int(ta.data);
    276391}
    277392 
    278393long __fixsfdi(float a)
    279394{
    280         float32 fa;
    281         fa.f = a;
    282        
    283         return float32_to_long(fa);
     395        float_t fa;
     396       
     397        fa.val = a;
     398        return float_to_long(fa.data);
    284399}
    285400
    286401long __fixdfdi(double a)
    287402{
    288         float64 da;
    289         da.d = a;
    290        
    291         return float64_to_long(da);
     403        double_t da;
     404       
     405        da.val = a;
     406        return double_to_long(da.data);
    292407}
    293408
    294409long __fixtfdi(long double a)
    295410{
    296         float128 ta;
    297         ta.ld = a;
    298 
    299         return float128_to_long(ta);
     411        long_double_t ta;
     412       
     413        ta.val = a;
     414        return long_double_to_long(ta.data);
    300415}
    301416 
    302417long long __fixsfti(float a)
    303418{
    304         float32 fa;
    305         fa.f = a;
    306        
    307         return float32_to_longlong(fa);
     419        float_t fa;
     420       
     421        fa.val = a;
     422        return float_to_llong(fa.data);
    308423}
    309424
    310425long long __fixdfti(double a)
    311426{
    312         float64 da;
    313         da.d = a;
    314        
    315         return float64_to_longlong(da);
     427        double_t da;
     428       
     429        da.val = a;
     430        return double_to_llong(da.data);
    316431}
    317432
    318433long long __fixtfti(long double a)
    319434{
    320         float128 ta;
    321         ta.ld = a;
    322 
    323         return float128_to_longlong(ta);
     435        long_double_t ta;
     436       
     437        ta.val = a;
     438        return long_double_to_llong(ta.data);
    324439}
    325440
    326441unsigned int __fixunssfsi(float a)
    327442{
    328         float32 fa;
    329         fa.f = a;
    330        
    331         return float32_to_uint(fa);
     443        float_t fa;
     444       
     445        fa.val = a;
     446        return float_to_uint(fa.data);
    332447}
    333448
    334449unsigned int __fixunsdfsi(double a)
    335450{
    336         float64 da;
    337         da.d = a;
    338        
    339         return float64_to_uint(da);
     451        double_t da;
     452       
     453        da.val = a;
     454        return double_to_uint(da.data);
    340455}
    341456
    342457unsigned int __fixunstfsi(long double a)
    343458{
    344         float128 ta;
    345         ta.ld = a;
    346 
    347         return float128_to_uint(ta);
     459        long_double_t ta;
     460       
     461        ta.val = a;
     462        return long_double_to_uint(ta.data);
    348463}
    349464 
    350465unsigned long __fixunssfdi(float a)
    351466{
    352         float32 fa;
    353         fa.f = a;
    354        
    355         return float32_to_ulong(fa);
     467        float_t fa;
     468       
     469        fa.val = a;
     470        return float_to_ulong(fa.data);
    356471}
    357472
    358473unsigned long __fixunsdfdi(double a)
    359474{
    360         float64 da;
    361         da.d = a;
    362        
    363         return float64_to_ulong(da);
     475        double_t da;
     476       
     477        da.val = a;
     478        return double_to_ulong(da.data);
    364479}
    365480
    366481unsigned long __fixunstfdi(long double a)
    367482{
    368         float128 ta;
    369         ta.ld = a;
    370 
    371         return float128_to_ulong(ta);
     483        long_double_t ta;
     484       
     485        ta.val = a;
     486        return long_double_to_ulong(ta.data);
    372487}
    373488 
    374489unsigned long long __fixunssfti(float a)
    375490{
    376         float32 fa;
    377         fa.f = a;
    378        
    379         return float32_to_ulonglong(fa);
     491        float_t fa;
     492       
     493        fa.val = a;
     494        return float_to_ullong(fa.data);
    380495}
    381496
    382497unsigned long long __fixunsdfti(double a)
    383498{
    384         float64 da;
    385         da.d = a;
    386        
    387         return float64_to_ulonglong(da);
     499        double_t da;
     500       
     501        da.val = a;
     502        return double_to_ullong(da.data);
    388503}
    389504
    390505unsigned long long __fixunstfti(long double a)
    391506{
    392         float128 ta;
    393         ta.ld = a;
    394 
    395         return float128_to_ulonglong(ta);
     507        long_double_t ta;
     508       
     509        ta.val = a;
     510        return long_double_to_ullong(ta.data);
    396511}
    397512 
    398513float __floatsisf(int i)
    399514{
    400         float32 fa;
    401        
    402         fa = int_to_float32(i);
    403         return fa.f;
     515        float_t res;