Index: boot/arch/arm32/Makefile.inc
===================================================================
--- boot/arch/arm32/Makefile.inc	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ boot/arch/arm32/Makefile.inc	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -49,5 +49,4 @@
 SOURCES = \
 	arch/$(BARCH)/src/asm.S \
-	arch/$(BARCH)/src/eabi.S \
 	arch/$(BARCH)/src/main.c \
 	arch/$(BARCH)/src/mm.c \
Index: ot/arch/arm32/src/eabi.S
===================================================================
--- boot/arch/arm32/src/eabi.S	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ 	(revision )
@@ -1,88 +1,0 @@
-#
-# Copyright (c) 2012 Martin Decky
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# - Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-# - Redistributions in binary form must reproduce the above copyright
-#   notice, this list of conditions and the following disclaimer in the
-#   documentation and/or other materials provided with the distribution.
-# - The name of the author may not be used to endorse or promote products
-#   derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-
-.text
-
-.global __aeabi_idiv
-.global __aeabi_uidiv
-
-.global __aeabi_idivmod
-.global __aeabi_uidivmod
-
-.global __aeabi_ldivmod
-.global __aeabi_uldivmod
-
-__aeabi_idiv:
-	push {sp, lr}
-	bl __divsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	bx lr
-
-__aeabi_uidiv:
-	push {sp, lr}
-	bl __udivsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	bx lr
-
-__aeabi_idivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __divmodsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r1, r2}
-	bx lr
-
-__aeabi_uidivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __udivmodsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r1, r2}
-	bx lr
-
-__aeabi_ldivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __divmoddi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r2, r3}
-	bx lr
-
-__aeabi_uldivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __udivmoddi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r2, r3}
-	bx lr
Index: boot/genarch/include/division.h
===================================================================
--- boot/genarch/include/division.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ boot/genarch/include/division.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -33,20 +33,28 @@
 #define BOOT_DIVISION_H_
 
+/* 32bit integer division */
 extern int __divsi3(int, int);
+
+/* 64bit integer division */
 extern long long __divdi3(long long, long long);
 
+/* 32bit unsigned integer division */
 extern unsigned int __udivsi3(unsigned int, unsigned int);
+
+/* 64bit unsigned integer division */
 extern unsigned long long __udivdi3(unsigned long long, unsigned long long);
 
+/* 32bit remainder of the signed division */
 extern int __modsi3(int, int);
+
+/* 64bit remainder of the signed division */
 extern long long __moddi3(long long, long long);
 
+/* 32bit remainder of the unsigned division */
 extern unsigned int __umodsi3(unsigned int, unsigned int);
+
+/* 64bit remainder of the unsigned division */
 extern unsigned long long __umoddi3(unsigned long long, unsigned long long);
 
-extern int __divmodsi3(int, int, int *);
-extern unsigned int __udivmodsi3(unsigned int, unsigned int, unsigned int *);
-
-extern long long __divmoddi3(long long, long long, long long *);
 extern unsigned long long __udivmoddi3(unsigned long long, unsigned long long,
     unsigned long long *);
Index: boot/genarch/src/division.c
===================================================================
--- boot/genarch/src/division.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ boot/genarch/src/division.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -73,5 +73,5 @@
 {
 	unsigned long long result;
-	int steps = sizeof(unsigned long long) * 8;
+	int steps = sizeof(unsigned long long) * 8; 
 	
 	*remainder = 0;
@@ -104,5 +104,5 @@
 
 /* 32bit integer division */
-int __divsi3(int a, int b)
+int __divsi3(int a, int b) 
 {
 	unsigned int rem;
@@ -116,5 +116,5 @@
 
 /* 64bit integer division */
-long long __divdi3(long long a, long long b)
+long long __divdi3(long long a, long long b) 
 {
 	unsigned long long rem;
@@ -155,5 +155,5 @@
 
 /* 64bit remainder of the signed division */
-long long __moddi3(long long a, long long b)
+long long __moddi3(long long a,long  long b)
 {
 	unsigned long long rem;
@@ -183,38 +183,4 @@
 }
 
-int __divmodsi3(int a, int b, int *c)
-{
-	unsigned int rem;
-	int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
-	
-	if (SGN(a) == SGN(b)) {
-		*c = rem;
-		return result;
-	}
-	
-	*c = -rem;
-	return -result;
-}
-
-unsigned int __udivmodsi3(unsigned int a, unsigned int b,
-    unsigned int *c)
-{
-	return divandmod32(a, b, c);
-}
-
-long long __divmoddi3(long long a, long long b, long long *c)
-{
-	unsigned long long rem;
-	long long result = (int) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
-	
-	if (SGN(a) == SGN(b)) {
-		*c = rem;
-		return result;
-	}
-	
-	*c = -rem;
-	return -result;
-}
-
 unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b,
     unsigned long long *c)
Index: boot/generic/src/str.c
===================================================================
--- boot/generic/src/str.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ boot/generic/src/str.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -100,11 +100,4 @@
 #include <str.h>
 #include <errno.h>
-
-/** Check the condition if wchar_t is signed */
-#ifdef WCHAR_IS_UNSIGNED
-	#define WCHAR_SIGNED_CHECK(cond)  (true)
-#else
-	#define WCHAR_SIGNED_CHECK(cond)  (cond)
-#endif
 
 /** Byte mask consisting of lowest @n bits (out of 8) */
@@ -205,5 +198,5 @@
  *         code was invalid.
  */
-int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
+int chr_encode(wchar_t ch, char *str, size_t *offset, size_t size)
 {
 	if (*offset >= size)
@@ -332,5 +325,5 @@
 bool ascii_check(wchar_t ch)
 {
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
+	if ((ch >= 0) && (ch <= 127))
 		return true;
 	
@@ -345,5 +338,5 @@
 bool chr_check(wchar_t ch)
 {
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
+	if ((ch >= 0) && (ch <= 1114111))
 		return true;
 	
Index: kernel/arch/arm32/Makefile.inc
===================================================================
--- kernel/arch/arm32/Makefile.inc	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ kernel/arch/arm32/Makefile.inc	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -41,5 +41,4 @@
 	arch/$(KARCH)/src/start.S \
 	arch/$(KARCH)/src/asm.S \
-	arch/$(KARCH)/src/eabi.S \
 	arch/$(KARCH)/src/exc_handler.S \
 	arch/$(KARCH)/src/arm32.c \
Index: rnel/arch/arm32/src/eabi.S
===================================================================
--- kernel/arch/arm32/src/eabi.S	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ 	(revision )
@@ -1,88 +1,0 @@
-#
-# Copyright (c) 2012 Martin Decky
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# - Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-# - Redistributions in binary form must reproduce the above copyright
-#   notice, this list of conditions and the following disclaimer in the
-#   documentation and/or other materials provided with the distribution.
-# - The name of the author may not be used to endorse or promote products
-#   derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-
-.text
-
-.global __aeabi_idiv
-.global __aeabi_uidiv
-
-.global __aeabi_idivmod
-.global __aeabi_uidivmod
-
-.global __aeabi_ldivmod
-.global __aeabi_uldivmod
-
-__aeabi_idiv:
-	push {sp, lr}
-	bl __divsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	bx lr
-
-__aeabi_uidiv:
-	push {sp, lr}
-	bl __udivsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	bx lr
-
-__aeabi_idivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __divmodsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r1, r2}
-	bx lr
-
-__aeabi_uidivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __udivmodsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r1, r2}
-	bx lr
-
-__aeabi_ldivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __divmoddi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r2, r3}
-	bx lr
-
-__aeabi_uldivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __udivmoddi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r2, r3}
-	bx lr
Index: kernel/genarch/include/softint/division.h
===================================================================
--- kernel/genarch/include/softint/division.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ kernel/genarch/include/softint/division.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -36,22 +36,29 @@
 #define KERN_DIVISION_H_
 
-extern int __divsi3(int, int);
-extern long long __divdi3(long long, long long);
+/* 32bit integer division */
+int __divsi3(int a, int b);
 
-extern unsigned int __udivsi3(unsigned int, unsigned int);
-extern unsigned long long __udivdi3(unsigned long long, unsigned long long);
+/* 64bit integer division */
+long long __divdi3(long long a, long long b);
 
-extern int __modsi3(int, int);
-extern long long __moddi3(long long, long long);
+/* 32bit unsigned integer division */
+unsigned int __udivsi3(unsigned int a, unsigned int b);
 
-extern unsigned int __umodsi3(unsigned int, unsigned int);
-extern unsigned long long __umoddi3(unsigned long long, unsigned long long);
+/* 64bit unsigned integer division */
+unsigned long long __udivdi3(unsigned long long a, unsigned long long b);
 
-extern int __divmodsi3(int, int, int *);
-extern unsigned int __udivmodsi3(unsigned int, unsigned int, unsigned int *);
+/* 32bit remainder of the signed division */
+int __modsi3(int a, int b);
 
-extern long long __divmoddi3(long long, long long, long long *);
-extern unsigned long long __udivmoddi3(unsigned long long, unsigned long long,
-    unsigned long long *);
+/* 64bit remainder of the signed division */
+long long __moddi3(long long a, long long b);
+
+/* 32bit remainder of the unsigned division */
+unsigned int __umodsi3(unsigned int a, unsigned int b);
+
+/* 64bit remainder of the unsigned division */
+unsigned long long __umoddi3(unsigned long long a, unsigned long long b);
+
+unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b, unsigned long long *c); 
 
 #endif
Index: kernel/genarch/include/softint/multiplication.h
===================================================================
--- kernel/genarch/include/softint/multiplication.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ kernel/genarch/include/softint/multiplication.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -29,14 +29,14 @@
 /** @addtogroup genarch
  * @{
- */
+ */ 
 /**
  * @file
  */
 
-#ifndef KERN_MULTIPLICATION_H_
-#define KERN_MULTIPLICATION_H_
+#ifndef __SOFTINT_MULTIPLICATION_H__
+#define __SOFTINT_MULTIPLICATION_H__
 
 /* 64 bit multiplication */
-extern long long __muldi3(long long, long long);
+long long __muldi3(long long a, long long b);
 
 #endif
@@ -44,2 +44,4 @@
 /** @}
  */
+
+
Index: kernel/genarch/src/softint/division.c
===================================================================
--- kernel/genarch/src/softint/division.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ kernel/genarch/src/softint/division.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup genarch
+/** @addtogroup genarch	
  * @{
  */
@@ -35,7 +35,7 @@
 #include <genarch/softint/division.h>
 
-#define ABSVAL(x)  ((x) > 0 ? (x) : -(x))
-#define SGN(x)     ((x) >= 0 ? 1 : 0)
-
+#define ABSVAL(x) ((x) > 0 ? (x) : -(x))
+#define SGN(x) ((x) >= 0 ? 1 : 0)
+				      
 static unsigned int divandmod32(unsigned int a, unsigned int b,
     unsigned int *remainder)
@@ -56,5 +56,5 @@
 		return 0;
 	}
-	
+
 	for (; steps > 0; steps--) {
 		/* shift one bit to remainder */
@@ -68,7 +68,8 @@
 		a <<= 1;
 	}
-	
+
 	return result;
 }
+
 
 static unsigned long long divandmod64(unsigned long long a,
@@ -76,5 +77,5 @@
 {
 	unsigned long long result;
-	int steps = sizeof(unsigned long long) * 8;
+	int steps = sizeof(unsigned long long) * 8; 
 	
 	*remainder = 0;
@@ -90,5 +91,5 @@
 		return 0;
 	}
-	
+
 	for (; steps > 0; steps--) {
 		/* shift one bit to remainder */
@@ -102,29 +103,31 @@
 		a <<= 1;
 	}
-	
+
 	return result;
 }
 
 /* 32bit integer division */
-int __divsi3(int a, int b)
-{
-	unsigned int rem;
-	int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
-	
+int __divsi3(int a, int b) 
+{
+	unsigned int rem;
+	int result;
+	
+	result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
+
 	if (SGN(a) == SGN(b))
 		return result;
-	
 	return -result;
 }
 
 /* 64bit integer division */
-long long __divdi3(long long a, long long b)
+long long __divdi3(long long a, long long b) 
 {
 	unsigned long long rem;
-	long long result = (long long) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
-	
+	long long result;
+	
+	result = (long long) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
+
 	if (SGN(a) == SGN(b))
 		return result;
-	
 	return -result;
 }
@@ -140,5 +143,5 @@
 unsigned long long __udivdi3(unsigned long long a, unsigned long long b)
 {
-	unsigned long long rem;
+	unsigned long long  rem;
 	return divandmod64(a, b, &rem);
 }
@@ -151,6 +154,7 @@
 	
 	/* if divident is negative, remainder must be too */
-	if (!(SGN(a)))
+	if (!(SGN(a))) {
 		return -((int) rem);
+	}
 	
 	return (int) rem;
@@ -158,5 +162,5 @@
 
 /* 64bit remainder of the signed division */
-long long __moddi3(long long a, long long b)
+long long __moddi3(long long a,long  long b)
 {
 	unsigned long long rem;
@@ -164,6 +168,7 @@
 	
 	/* if divident is negative, remainder must be too */
-	if (!(SGN(a)))
+	if (!(SGN(a))) {
 		return -((long long) rem);
+	}
 	
 	return (long long) rem;
@@ -186,38 +191,4 @@
 }
 
-int __divmodsi3(int a, int b, int *c)
-{
-	unsigned int rem;
-	int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
-	
-	if (SGN(a) == SGN(b)) {
-		*c = rem;
-		return result;
-	}
-	
-	*c = -rem;
-	return -result;
-}
-
-unsigned int __udivmodsi3(unsigned int a, unsigned int b,
-    unsigned int *c)
-{
-	return divandmod32(a, b, c);
-}
-
-long long __divmoddi3(long long a, long long b, long long *c)
-{
-	unsigned long long rem;
-	long long result = (int) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
-	
-	if (SGN(a) == SGN(b)) {
-		*c = rem;
-		return result;
-	}
-	
-	*c = -rem;
-	return -result;
-}
-
 unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b,
     unsigned long long *c)
Index: kernel/genarch/src/softint/multiplication.c
===================================================================
--- kernel/genarch/src/softint/multiplication.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ kernel/genarch/src/softint/multiplication.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -29,5 +29,5 @@
 /** @addtogroup genarch
  * @{
- */
+ */ 
 /**
  * @file
@@ -130,5 +130,5 @@
 
 	return result;
-}
+}	
 
 /** @}
Index: kernel/generic/src/lib/str.c
===================================================================
--- kernel/generic/src/lib/str.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ kernel/generic/src/lib/str.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -111,11 +111,4 @@
 #include <debug.h>
 #include <macros.h>
-
-/** Check the condition if wchar_t is signed */
-#ifdef WCHAR_IS_UNSIGNED
-	#define WCHAR_SIGNED_CHECK(cond)  (true)
-#else
-	#define WCHAR_SIGNED_CHECK(cond)  (cond)
-#endif
 
 /** Byte mask consisting of lowest @n bits (out of 8) */
@@ -213,8 +206,8 @@
  *
  * @return EOK if the character was encoded successfully, EOVERFLOW if there
- *         was not enough space in the output buffer or EINVAL if the character
- *         code was invalid.
- */
-int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
+ *	   was not enough space in the output buffer or EINVAL if the character
+ *	   code was invalid.
+ */
+int chr_encode(wchar_t ch, char *str, size_t *offset, size_t size)
 {
 	if (*offset >= size)
@@ -434,5 +427,5 @@
 bool ascii_check(wchar_t ch)
 {
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
+	if ((ch >= 0) && (ch <= 127))
 		return true;
 	
@@ -447,5 +440,5 @@
 bool chr_check(wchar_t ch)
 {
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
+	if ((ch >= 0) && (ch <= 1114111))
 		return true;
 	
Index: tools/autotool.py
===================================================================
--- tools/autotool.py	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ tools/autotool.py	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -49,5 +49,5 @@
 
 PACKAGE_BINUTILS = "usually part of binutils"
-PACKAGE_GCC = "preferably version 4.7.0 or newer"
+PACKAGE_GCC = "preferably version 4.5.1 or newer"
 PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
 
@@ -66,22 +66,9 @@
 
 #define DECLARE_BUILTIN_TYPE(tag, type) \\
-	AUTOTOOL_DECLARE("builtin_size", "", tag, STRING(type), "", "", sizeof(type)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "unsigned long long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long long int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "unsigned long int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned long int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "unsigned int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "unsigned short int", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned short int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "unsigned char", tag, STRING(type), "unsigned", "", __builtin_types_compatible_p(type, unsigned char)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "signed long long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long long int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "signed long int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed long int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "signed int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "signed short int", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed short int)); \\
-	AUTOTOOL_DECLARE("builtin_sign", "signed char", tag, STRING(type), "signed", "", __builtin_types_compatible_p(type, signed char));
+	AUTOTOOL_DECLARE("builtin", "", tag, STRING(type), "", "", sizeof(type));
 
 #define DECLARE_INTSIZE(tag, type, strc, conc) \\
 	AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, strc, conc, sizeof(unsigned type)); \\
 	AUTOTOOL_DECLARE("intsize", "signed", tag, #type, strc, conc, sizeof(signed type));
-
-#define DECLARE_FLOATSIZE(tag, type) \\
-	AUTOTOOL_DECLARE("floatsize", "", tag, #type, "", "", sizeof(type));
 
 int main(int argc, char *argv[])
@@ -275,5 +262,5 @@
 	return int(value, base)
 
-def probe_compiler(common, intsizes, floatsizes):
+def probe_compiler(common, sizes):
 	"Generate, compile and parse probing source"
 	
@@ -283,9 +270,6 @@
 	outf.write(PROBE_HEAD)
 	
-	for typedef in intsizes:
+	for typedef in sizes:
 		outf.write("\tDECLARE_INTSIZE(\"%s\", %s, %s, %s);\n" % (typedef['tag'], typedef['type'], typedef['strc'], typedef['conc']))
-	
-	for typedef in floatsizes:
-		outf.write("\nDECLARE_FLOATSIZE(\"%s\", %s);\n" % (typedef['tag'], typedef['type']))
 	
 	outf.write(PROBE_TAIL)
@@ -331,8 +315,5 @@
 	signed_concs = {}
 	
-	float_tags = {}
-	
-	builtin_sizes = {}
-	builtin_signs = {}
+	builtins = {}
 	
 	for j in range(len(lines)):
@@ -371,5 +352,5 @@
 						print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_OUTPUT, j), COMPILER_FAIL])
 				
-				if (category == "floatsize"):
+				if (category == "builtin"):
 					try:
 						value_int = decode_value(value)
@@ -377,30 +358,10 @@
 						print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
 					
-					float_tags[tag] = value_int
-				
-				if (category == "builtin_size"):
-					try:
-						value_int = decode_value(value)
-					except:
-						print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
-					
-					builtin_sizes[tag] = {'name': name, 'value': value_int}
-				
-				if (category == "builtin_sign"):
-					try:
-						value_int = decode_value(value)
-					except:
-						print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
-					
-					if (value_int == 1):
-						if (not tag in builtin_signs):
-							builtin_signs[tag] = strc;
-						elif (builtin_signs[tag] != strc):
-							print_error(["Inconsistent builtin type detection in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
-	
-	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}
-
-def detect_sizes(probe, bytes, inttags, floattags):
-	"Detect correct types for fixed-size types"
+					builtins[tag] = {'name': name, 'value': value_int}
+	
+	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}
+
+def detect_uints(probe, bytes, tags):
+	"Detect correct types for fixed-size integer types"
 	
 	macros = []
@@ -409,25 +370,25 @@
 	for b in bytes:
 		if (not b in probe['unsigned_sizes']):
-			print_error(['Unable to find appropriate unsigned integer type for %u bytes.' % b,
+			print_error(['Unable to find appropriate unsigned integer type for %u bytes' % b,
 			             COMPILER_FAIL])
 		
 		if (not b in probe['signed_sizes']):
-			print_error(['Unable to find appropriate signed integer type for %u bytes.' % b,
+			print_error(['Unable to find appropriate signed integer type for %u bytes' % b,
 			             COMPILER_FAIL])
 		
 		if (not b in probe['unsigned_strcs']):
-			print_error(['Unable to find appropriate unsigned printf formatter for %u bytes.' % b,
+			print_error(['Unable to find appropriate unsigned printf formatter for %u bytes' % b,
 			             COMPILER_FAIL])
 		
 		if (not b in probe['signed_strcs']):
-			print_error(['Unable to find appropriate signed printf formatter for %u bytes.' % b,
+			print_error(['Unable to find appropriate signed printf formatter for %u bytes' % b,
 			             COMPILER_FAIL])
 		
 		if (not b in probe['unsigned_concs']):
-			print_error(['Unable to find appropriate unsigned literal macro for %u bytes.' % b,
+			print_error(['Unable to find appropriate unsigned literal macro for %u bytes' % b,
 			             COMPILER_FAIL])
 		
 		if (not b in probe['signed_concs']):
-			print_error(['Unable to find appropriate signed literal macro for %u bytes.' % b,
+			print_error(['Unable to find appropriate signed literal macro for %u bytes' % b,
 			             COMPILER_FAIL])
 		
@@ -456,8 +417,8 @@
 			macros.append({'oldmacro': "c ## %s" % name, 'newmacro': "INT%u_C(c)" % (b * 8)})
 	
-	for tag in inttags:
+	for tag in tags:
 		newmacro = "U%s" % tag
 		if (not tag in probe['unsigned_tags']):
-			print_error(['Unable to find appropriate size macro for %s.' % newmacro,
+			print_error(['Unable to find appropriate size macro for %s' % newmacro,
 			             COMPILER_FAIL])
 		
@@ -465,8 +426,7 @@
 		macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
 		macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
-		macros.append({'oldmacro': "1", 'newmacro': 'U%s_SIZE_%s' % (tag, probe['unsigned_tags'][tag] * 8)})
 		
 		newmacro = tag
-		if (not tag in probe['signed_tags']):
+		if (not tag in probe['unsigned_tags']):
 			print_error(['Unable to find appropriate size macro for %s' % newmacro,
 			             COMPILER_FAIL])
@@ -475,24 +435,8 @@
 		macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
 		macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
-		macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['signed_tags'][tag] * 8)})
-	
-	for tag in floattags:
-		if (not tag in probe['float_tags']):
-			print_error(['Unable to find appropriate size macro for %s' % tag,
-			             COMPILER_FAIL])
-		
-		macros.append({'oldmacro': "1", 'newmacro': '%s_SIZE_%s' % (tag, probe['float_tags'][tag] * 8)})
-	
-	if (not 'size' in probe['builtin_signs']):
-		print_error(['Unable to determine whether size_t is signed or unsigned.',
-		             COMPILER_FAIL])
-	
-	if (probe['builtin_signs']['size'] != 'unsigned'):
-		print_error(['The type size_t is not unsigned.',
-		             COMPILER_FAIL])
 	
 	fnd = True
 	
-	if (not 'wchar' in probe['builtin_sizes']):
+	if (not 'wchar' in probe['builtins']):
 		print_warning(['The compiler does not provide the macro __WCHAR_TYPE__',
 		               'for defining the compiler-native type wchar_t. We are',
@@ -501,5 +445,5 @@
 		fnd = False
 	
-	if (probe['builtin_sizes']['wchar']['value'] != 4):
+	if (probe['builtins']['wchar']['value'] != 4):
 		print_warning(['The compiler provided macro __WCHAR_TYPE__ for defining',
 		               'the compiler-native type wchar_t is not compliant with',
@@ -514,16 +458,7 @@
 		macros.append({'oldmacro': "__WCHAR_TYPE__", 'newmacro': "wchar_t"})
 	
-	if (not 'wchar' in probe['builtin_signs']):
-		print_error(['Unable to determine whether wchar_t is signed or unsigned.',
-		             COMPILER_FAIL])
-	
-	if (probe['builtin_signs']['wchar'] == 'unsigned'):
-		macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_UNSIGNED'})
-	if (probe['builtin_signs']['wchar'] == 'signed'):
-		macros.append({'oldmacro': "1", 'newmacro': 'WCHAR_IS_SIGNED'})
-	
 	fnd = True
 	
-	if (not 'wint' in probe['builtin_sizes']):
+	if (not 'wint' in probe['builtins']):
 		print_warning(['The compiler does not provide the macro __WINT_TYPE__',
 		               'for defining the compiler-native type wint_t. We are',
@@ -532,5 +467,5 @@
 		fnd = False
 	
-	if (probe['builtin_sizes']['wint']['value'] != 4):
+	if (probe['builtins']['wint']['value'] != 4):
 		print_warning(['The compiler provided macro __WINT_TYPE__ for defining',
 		               'the compiler-native type wint_t is not compliant with',
@@ -544,13 +479,4 @@
 	else:
 		macros.append({'oldmacro': "__WINT_TYPE__", 'newmacro': "wint_t"})
-	
-	if (not 'wint' in probe['builtin_signs']):
-		print_error(['Unable to determine whether wint_t is signed or unsigned.',
-		             COMPILER_FAIL])
-	
-	if (probe['builtin_signs']['wint'] == 'unsigned'):
-		macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_UNSIGNED'})
-	if (probe['builtin_signs']['wint'] == 'signed'):
-		macros.append({'oldmacro': "1", 'newmacro': 'WINT_IS_SIGNED'})
 	
 	return {'macros': macros, 'typedefs': typedefs}
@@ -645,5 +571,5 @@
 				
 				if (config['CROSS_TARGET'] == "arm32"):
-					gnu_target = "arm-linux-gnueabi"
+					gnu_target = "arm-linux-gnu"
 				
 				if (config['CROSS_TARGET'] == "ia32"):
@@ -660,5 +586,5 @@
 			if (config['PLATFORM'] == "arm32"):
 				target = config['PLATFORM']
-				gnu_target = "arm-linux-gnueabi"
+				gnu_target = "arm-linux-gnu"
 			
 			if (config['PLATFORM'] == "ia32"):
@@ -743,13 +669,8 @@
 				{'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
 				{'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'}
-			],
-			[
-				{'type': 'long double', 'tag': 'LONG_DOUBLE'},
-				{'type': 'double', 'tag': 'DOUBLE'},
-				{'type': 'float', 'tag': 'FLOAT'}
 			]
 		)
 		
-		maps = detect_sizes(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'], ['LONG_DOUBLE', 'DOUBLE', 'FLOAT'])
+		maps = detect_uints(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'])
 		
 	finally:
Index: tools/toolchain.sh
===================================================================
--- tools/toolchain.sh	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ tools/toolchain.sh	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -55,10 +55,12 @@
 BINUTILS_VERSION="2.22"
 BINUTILS_RELEASE=""
-GCC_VERSION="4.7.0"
+GCC_VERSION="4.6.3"
 GDB_VERSION="7.4"
 
 BASEDIR="`pwd`"
 BINUTILS="binutils-${BINUTILS_VERSION}${BINUTILS_RELEASE}.tar.bz2"
-GCC="gcc-${GCC_VERSION}.tar.bz2"
+GCC_CORE="gcc-core-${GCC_VERSION}.tar.bz2"
+GCC_OBJC="gcc-objc-${GCC_VERSION}.tar.bz2"
+GCC_CPP="gcc-g++-${GCC_VERSION}.tar.bz2"
 GDB="gdb-${GDB_VERSION}.tar.bz2"
 
@@ -273,5 +275,7 @@
 	
 	download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "ee0f10756c84979622b992a4a61ea3f5"
-	download_fetch "${GCC_SOURCE}" "${GCC}" "2a0f1d99fda235c29d40b561f81d9a77"
+	download_fetch "${GCC_SOURCE}" "${GCC_CORE}" "766091220c6a14fcaa2c06dd573e3758"
+	download_fetch "${GCC_SOURCE}" "${GCC_OBJC}" "48ba23770c34b1cb468f72618b4452c5"
+	download_fetch "${GCC_SOURCE}" "${GCC_CPP}" "37515158a0fb3d0800ec41a08c05e69e"
 	download_fetch "${GDB_SOURCE}" "${GDB}" "95a9a8305fed4d30a30a6dc28ff9d060"
 }
@@ -295,5 +299,7 @@
 	echo ">>> Downloading tarballs"
 	source_check "${BASEDIR}/${BINUTILS}"
-	source_check "${BASEDIR}/${GCC}"
+	source_check "${BASEDIR}/${GCC_CORE}"
+	source_check "${BASEDIR}/${GCC_OBJC}"
+	source_check "${BASEDIR}/${GCC_CPP}"
 	source_check "${BASEDIR}/${GDB}"
 	
@@ -310,5 +316,7 @@
 	
 	unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
-	unpack_tarball "${BASEDIR}/${GCC}" "GCC"
+	unpack_tarball "${BASEDIR}/${GCC_CORE}" "GCC Core"
+	unpack_tarball "${BASEDIR}/${GCC_OBJC}" "Objective C"
+	unpack_tarball "${BASEDIR}/${GCC_CPP}" "C++"
 	unpack_tarball "${BASEDIR}/${GDB}" "GDB"
 	
@@ -370,5 +378,5 @@
 	"arm32")
 		prepare
-		build_target "arm32" "arm-linux-gnueabi"
+		build_target "arm32" "arm-linux-gnu"
 		;;
 	"ia32")
@@ -407,5 +415,5 @@
 		prepare
 		build_target "amd64" "amd64-linux-gnu"
-		build_target "arm32" "arm-linux-gnueabi"
+		build_target "arm32" "arm-linux-gnu"
 		build_target "ia32" "i686-pc-linux-gnu"
 		build_target "ia64" "ia64-pc-linux-gnu"
@@ -420,5 +428,5 @@
 		prepare
 		build_target "amd64" "amd64-linux-gnu" &
-		build_target "arm32" "arm-linux-gnueabi" &
+		build_target "arm32" "arm-linux-gnu" &
 		build_target "ia32" "i686-pc-linux-gnu" &
 		build_target "ia64" "ia64-pc-linux-gnu" &
Index: uspace/Makefile.common
===================================================================
--- uspace/Makefile.common	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/Makefile.common	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -149,11 +149,11 @@
 endif
 
-ifeq ($(STATIC_BUILD),y)
-	BASE_LIBS = $(LIBC_PREFIX)/libc.a $(LIBSOFTINT_PREFIX)/libsoftint.a
-	LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld
-else
-	BASE_LIBS = $(LIBC_PREFIX)/libc.so0 $(LIBSOFTINT_PREFIX)/libsofti.so0
-	LFLAGS = -Bdynamic
-	LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
+ifeq ($(STATIC_BUILD), y)
+BASE_LIBS = $(LIBC_PREFIX)/libc.a $(LIBSOFTINT_PREFIX)/libsoftint.a
+LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld
+else
+BASE_LIBS = $(LIBC_PREFIX)/libc.so0 $(LIBSOFTINT_PREFIX)/libsofti.so0
+LFLAGS = -Bdynamic
+LINKER_SCRIPT ?= $(LIBC_PREFIX)/arch/$(UARCH)/_link-dlexe.ld
 endif
 
Index: uspace/app/binutils/Makefile
===================================================================
--- uspace/app/binutils/Makefile	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/app/binutils/Makefile	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -112,5 +112,5 @@
 endif
 ifeq ($(PLATFORM),arm32)
-TARGET = arm-linux-gnueabi
+TARGET = arm-linux-gnu
 endif
 ifeq ($(PLATFORM),ia32)
Index: uspace/app/sbi/src/run_texpr.c
===================================================================
--- uspace/app/sbi/src/run_texpr.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/app/sbi/src/run_texpr.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -98,6 +98,6 @@
 {
 	stree_symbol_t *sym;
-	tdata_item_t *targ_i = NULL;
-	tdata_item_t *titem = NULL;;
+	tdata_item_t *targ_i;
+	tdata_item_t *titem;
 	tdata_object_t *tobject;
 	tdata_deleg_t *tdeleg;
@@ -139,4 +139,7 @@
 		return;
 	}
+
+	/* Make compiler happy. */
+	titem = NULL;
 
 	switch (sym->sc) {
@@ -219,5 +222,5 @@
     stree_tindex_t *tindex, tdata_item_t **res)
 {
-	tdata_item_t *base_ti = NULL;
+	tdata_item_t *base_ti;
 	tdata_item_t *titem;
 	tdata_array_t *tarray;
Index: uspace/app/tester/fault/fault2.c
===================================================================
--- uspace/app/tester/fault/fault2.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/app/tester/fault/fault2.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -35,6 +35,8 @@
 const char *test_fault2(void)
 {
-	volatile long long var = 0;
-	volatile int var1 = *((aliasing_int *) (((char *) (&var)) + 1));
+	volatile long long var;
+	volatile int var1;
+	
+	var1 = *((aliasing_int *) (((char *) (&var)) + 1));
 	printf("Read %d\n", var1);
 	
Index: uspace/lib/c/arch/arm32/src/eabi.S
===================================================================
--- uspace/lib/c/arch/arm32/src/eabi.S	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/c/arch/arm32/src/eabi.S	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -1,4 +1,4 @@
 #
-# Copyright (c) 2012 Martin Decky
+# Copyright (c) 2007 Pavel Jancik
 # All rights reserved.
 #
@@ -31,64 +31,5 @@
 .global __aeabi_read_tp
 
-.global __aeabi_idiv
-.global __aeabi_uidiv
-
-.global __aeabi_idivmod
-.global __aeabi_uidivmod
-
-.global __aeabi_ldivmod
-.global __aeabi_uldivmod
-
 __aeabi_read_tp:
 	mov r0, r9
 	mov pc, lr
-
-__aeabi_idiv:
-	push {sp, lr}
-	bl __divsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	bx lr
-
-__aeabi_uidiv:
-	push {sp, lr}
-	bl __udivsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	bx lr
-
-__aeabi_idivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __divmodsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r1, r2}
-	bx lr
-
-__aeabi_uidivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __udivmodsi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r1, r2}
-	bx lr
-
-__aeabi_ldivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __divmoddi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r2, r3}
-	bx lr
-
-__aeabi_uldivmod:
-	sub sp, sp, #8
-	push {sp, lr}
-	bl __udivmoddi3
-	ldr lr, [sp, #4]
-	add sp, sp, #8
-	pop {r2, r3}
-	bx lr
Index: uspace/lib/c/generic/str.c
===================================================================
--- uspace/lib/c/generic/str.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/c/generic/str.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -46,11 +46,4 @@
 #include <mem.h>
 #include <str.h>
-
-/** Check the condition if wchar_t is signed */
-#ifdef WCHAR_IS_UNSIGNED
-	#define WCHAR_SIGNED_CHECK(cond)  (true)
-#else
-	#define WCHAR_SIGNED_CHECK(cond)  (cond)
-#endif
 
 /** Byte mask consisting of lowest @n bits (out of 8) */
@@ -406,5 +399,5 @@
 bool ascii_check(wchar_t ch)
 {
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
+	if ((ch >= 0) && (ch <= 127))
 		return true;
 	
@@ -419,5 +412,5 @@
 bool chr_check(wchar_t ch)
 {
-	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
+	if ((ch >= 0) && (ch <= 1114111))
 		return true;
 	
@@ -520,5 +513,4 @@
  * @param count Size of the destination buffer (must be > 0).
  * @param src   Source string.
- *
  */
 void str_cpy(char *dest, size_t size, const char *src)
@@ -553,5 +545,4 @@
  * @param src   Source string.
  * @param n     Maximum number of bytes to read from @a src.
- *
  */
 void str_ncpy(char *dest, size_t size, const char *src, size_t n)
Index: uspace/lib/softfloat/Makefile
===================================================================
--- uspace/lib/softfloat/Makefile	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/Makefile	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -29,5 +29,5 @@
 
 USPACE_PREFIX = ../..
-EXTRA_CFLAGS = -Iinclude
+EXTRA_CFLAGS = -Iinclude -Iarch/$(UARCH)/include/
 LIBRARY = libsoftfloat
 
Index: uspace/lib/softfloat/arch/abs32le/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/abs32le/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/abs32le/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2010 Martin Decky
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup softfloatabs32le abs32le
+ * @ingroup sfl
+ * @brief softfloat architecture dependent definitions
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int32(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int32(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int32(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint32(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint32(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint32(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int32_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int32_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int32_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint32_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint32_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint32_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/softfloat/arch/amd64/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/amd64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/amd64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup softfloatamd64 amd64	
+ * @ingroup sfl 
+ * @brief softfloat architecture dependent definitions 
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int64(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int64(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int64(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint64(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint64(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint64(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int64_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int64_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int64_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint64_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint64_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint64_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/softfloat/arch/arm32/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/arm32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/arm32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup softfloatarm32 arm32	
+ * @ingroup sfl
+ * @brief Softfloat architecture dependent definitions.
+ * @{
+ */
+/** @file 
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int32(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int32(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int32(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint32(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint32(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint32(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int32_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int32_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int32_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint32_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint32_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint32_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/softfloat/arch/ia32/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/ia32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/ia32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup softfloatia32 ia32	
+ * @ingroup sfl
+ * @brief softfloat architecture dependent definitions 
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int32(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int32(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int32(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint32(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint32(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint32(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int32_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int32_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int32_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint32_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint32_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint32_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/softfloat/arch/ia64/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/ia64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/ia64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+ /** @addtogroup softfloatia64 ia64
+ * @ingroup sfl 
+ * @brief softfloat architecture dependent definitions 
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int64(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int64(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int64(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint64(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint64(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint64(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int64_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int64_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int64_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint64_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint64_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint64_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+ /** @}
+ */
Index: uspace/lib/softfloat/arch/mips32/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/mips32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/mips32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup softfloatmips32 mips32
+ * @ingroup sfl
+ * @brief softfloat architecture dependent definitions 
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int32(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int32(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int32(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint32(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint32(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint32(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int32_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int32_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int32_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint32_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint32_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint32_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/softfloat/arch/mips32eb/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/mips32eb/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/mips32eb/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+ /** @addtogroup softfloatmipseb32 mipseb32	
+ * @ingroup sfl
+ * @brief softfloat architecture dependent definitions 
+ * * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int32(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int32(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int32(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint32(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint32(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint32(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int32_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int32_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int32_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint32_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint32_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint32_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+ /** @}
+ */
Index: uspace/lib/softfloat/arch/mips64/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/mips64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/mips64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup softfloatmips64 mips64
+ * @ingroup sfl
+ * @brief softfloat architecture dependent definitions
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int64(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int64(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int64(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint64(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint64(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint64(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int64_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int64_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int64_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint64_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint64_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint64_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/softfloat/arch/ppc32/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/ppc32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/ppc32/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+ /** @addtogroup softfloatppc32 ppc32	
+ * @ingroup sfl
+ * @brief softfloat architecture dependent definitions 
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int32(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int32(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int32(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint32(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint32(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint32(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int32_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int32_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int32_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint32_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint32_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint32_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+ /** @}
+ */
Index: uspace/lib/softfloat/arch/sparc64/include/functions.h
===================================================================
--- uspace/lib/softfloat/arch/sparc64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
+++ uspace/lib/softfloat/arch/sparc64/include/functions.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2011 Petr Koupy
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+ /** @addtogroup softfloatsparc64 sparc64	
+ * @ingroup sfl
+ * @brief softfloat architecture dependent definitions 
+ * @{
+ */
+/** @file
+ */
+
+#ifndef __SOFTFLOAT_FUNCTIONS_H__
+#define __SOFTFLOAT_FUNCTIONS_H__
+
+#define SPARC_SOFTFLOAT
+
+#define float32_to_int(X) float32_to_int32(X);
+#define float32_to_long(X) float32_to_int64(X);
+#define float32_to_longlong(X) float32_to_int64(X);
+
+#define float64_to_int(X) float64_to_int32(X);
+#define float64_to_long(X) float64_to_int64(X);
+#define float64_to_longlong(X) float64_to_int64(X);
+
+#define float128_to_int(X) float128_to_int32(X);
+#define float128_to_long(X) float128_to_int64(X);
+#define float128_to_longlong(X) float128_to_int64(X);
+
+#define float32_to_uint(X) float32_to_uint32(X);
+#define float32_to_ulong(X) float32_to_uint64(X);
+#define float32_to_ulonglong(X) float32_to_uint64(X);
+
+#define float64_to_uint(X) float64_to_uint32(X);
+#define float64_to_ulong(X) float64_to_uint64(X);
+#define float64_to_ulonglong(X) float64_to_uint64(X);
+
+#define float128_to_uint(X) float128_to_uint32(X);
+#define float128_to_ulong(X) float128_to_uint64(X);
+#define float128_to_ulonglong(X) float128_to_uint64(X);
+
+#define int_to_float32(X) int32_to_float32(X);
+#define long_to_float32(X) int64_to_float32(X);
+#define longlong_to_float32(X) int64_to_float32(X);
+
+#define int_to_float64(X) int32_to_float64(X);
+#define long_to_float64(X) int64_to_float64(X);
+#define longlong_to_float64(X) int64_to_float64(X);
+
+#define int_to_float128(X) int32_to_float128(X);
+#define long_to_float128(X) int64_to_float128(X);
+#define longlong_to_float128(X) int64_to_float128(X);
+
+#define uint_to_float32(X) uint32_to_float32(X);
+#define ulong_to_float32(X) uint64_to_float32(X);
+#define ulonglong_to_float32(X) uint64_to_float32(X);
+
+#define uint_to_float64(X) uint32_to_float64(X);
+#define ulong_to_float64(X) uint64_to_float64(X);
+#define ulonglong_to_float64(X) uint64_to_float64(X);
+
+#define uint_to_float128(X) uint32_to_float128(X);
+#define ulong_to_float128(X) uint64_to_float128(X);
+#define ulonglong_to_float128(X) uint64_to_float128(X);
+
+#endif
+
+ /** @}
+ */
Index: uspace/lib/softfloat/generic/add.c
===================================================================
--- uspace/lib/softfloat/generic/add.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/add.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -39,5 +39,6 @@
 #include <common.h>
 
-/** Add two single-precision floats with the same sign.
+/**
+ * Add two single-precision floats with the same signs.
  *
  * @param a First input operand.
@@ -45,5 +46,5 @@
  * @return Result of addition.
  */
-float32 add_float32(float32 a, float32 b)
+float32 addFloat32(float32 a, float32 b)
 {
 	int expdiff;
@@ -52,7 +53,7 @@
 	expdiff = a.parts.exp - b.parts.exp;
 	if (expdiff < 0) {
-		if (is_float32_nan(b)) {
-			/* TODO: fix SigNaN */
-			if (is_float32_signan(b)) {
+		if (isFloat32NaN(b)) {
+			/* TODO: fix SigNaN */
+			if (isFloat32SigNaN(b)) {
 			}
 
@@ -70,9 +71,9 @@
 		expdiff *= -1;
 	} else {
-		if ((is_float32_nan(a)) || (is_float32_nan(b))) {
-			/* TODO: fix SigNaN */
-			if (is_float32_signan(a) || is_float32_signan(b)) {
-			}
-			return (is_float32_nan(a) ? a : b);
+		if ((isFloat32NaN(a)) || (isFloat32NaN(b))) {
+			/* TODO: fix SigNaN */
+			if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
+			}
+			return (isFloat32NaN(a) ? a : b);
 		}
 		
@@ -149,5 +150,6 @@
 }
 
-/** Add two double-precision floats with the same sign.
+/**
+ * Add two double-precision floats with the same signs.
  *
  * @param a First input operand.
@@ -155,5 +157,5 @@
  * @return Result of addition.
  */
-float64 add_float64(float64 a, float64 b)
+float64 addFloat64(float64 a, float64 b)
 {
 	int expdiff;
@@ -163,14 +165,14 @@
 	expdiff = ((int) a.parts.exp) - b.parts.exp;
 	if (expdiff < 0) {
-		if (is_float64_nan(b)) {
-			/* TODO: fix SigNaN */
-			if (is_float64_signan(b)) {
-			}
-
-			return b;
-		}
-		
-		/* b is infinity and a not */
-		if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
+		if (isFloat64NaN(b)) {
+			/* TODO: fix SigNaN */
+			if (isFloat64SigNaN(b)) {
+			}
+
+			return b;
+		}
+		
+		/* b is infinity and a not */	
+		if (b.parts.exp == FLOAT64_MAX_EXPONENT) { 
 			return b;
 		}
@@ -182,7 +184,7 @@
 		expdiff *= -1;
 	} else {
-		if (is_float64_nan(a)) {
-			/* TODO: fix SigNaN */
-			if (is_float64_signan(a) || is_float64_signan(b)) {
+		if (isFloat64NaN(a)) {
+			/* TODO: fix SigNaN */
+			if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
 			}
 			return a;
@@ -263,5 +265,6 @@
 }
 
-/** Add two quadruple-precision floats with the same sign.
+/**
+ * Add two quadruple-precision floats with the same signs.
  *
  * @param a First input operand.
@@ -269,5 +272,5 @@
  * @return Result of addition.
  */
-float128 add_float128(float128 a, float128 b)
+float128 addFloat128(float128 a, float128 b)
 {
 	int expdiff;
@@ -277,7 +280,7 @@
 	expdiff = ((int) a.parts.exp) - b.parts.exp;
 	if (expdiff < 0) {
-		if (is_float128_nan(b)) {
-			/* TODO: fix SigNaN */
-			if (is_float128_signan(b)) {
+		if (isFloat128NaN(b)) {
+			/* TODO: fix SigNaN */
+			if (isFloat128SigNaN(b)) {
 			}
 
@@ -298,7 +301,7 @@
 		expdiff *= -1;
 	} else {
-		if (is_float128_nan(a)) {
-			/* TODO: fix SigNaN */
-			if (is_float128_signan(a) || is_float128_signan(b)) {
+		if (isFloat128NaN(a)) {
+			/* TODO: fix SigNaN */
+			if (isFloat128SigNaN(a) || isFloat128SigNaN(b)) {
 			}
 			return a;
Index: uspace/lib/softfloat/generic/common.c
===================================================================
--- uspace/lib/softfloat/generic/common.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/common.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -66,5 +66,5 @@
  * @return Finished double-precision float.
  */
-float64 finish_float64(int32_t cexp, uint64_t cfrac, char sign)
+float64 finishFloat64(int32_t cexp, uint64_t cfrac, char sign)
 {
 	float64 result;
@@ -140,5 +140,5 @@
  * @return Finished quadruple-precision float.
  */
-float128 finish_float128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo, 
+float128 finishFloat128(int32_t cexp, uint64_t cfrac_hi, uint64_t cfrac_lo, 
     char sign, uint64_t shift_out)
 {
@@ -238,5 +238,5 @@
  * @return Number of detected leading zeroes.
  */
-int count_zeroes8(uint8_t i)
+int countZeroes8(uint8_t i)
 {
 	return zeroTable[i];
@@ -249,10 +249,10 @@
  * @return Number of detected leading zeroes.
  */
-int count_zeroes32(uint32_t i)
+int countZeroes32(uint32_t i)
 {
 	int j;
 	for (j = 0; j < 32; j += 8) {
 		if (i & (0xFF << (24 - j))) {
-			return (j + count_zeroes8(i >> (24 - j)));
+			return (j + countZeroes8(i >> (24 - j)));
 		}
 	}
@@ -267,10 +267,10 @@
  * @return Number of detected leading zeroes.
  */
-int count_zeroes64(uint64_t i)
+int countZeroes64(uint64_t i)
 {
 	int j;
 	for (j = 0; j < 64; j += 8) {
 		if (i & (0xFFll << (56 - j))) {
-			return (j + count_zeroes8(i >> (56 - j)));
+			return (j + countZeroes8(i >> (56 - j)));
 		}
 	}
@@ -286,5 +286,5 @@
  * @param fraction Fraction with hidden bit shifted to 30th bit.
  */
-void round_float32(int32_t *exp, uint32_t *fraction)
+void roundFloat32(int32_t *exp, uint32_t *fraction)
 {
 	/* rounding - if first bit after fraction is set then round up */
@@ -312,5 +312,5 @@
  * @param fraction Fraction with hidden bit shifted to 62nd bit.
  */
-void round_float64(int32_t *exp, uint64_t *fraction)
+void roundFloat64(int32_t *exp, uint64_t *fraction)
 {
 	/* rounding - if first bit after fraction is set then round up */
@@ -339,5 +339,5 @@
  * @param frac_lo Low part of fraction part with hidden bit shifted to 126th bit.
  */
-void round_float128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo)
+void roundFloat128(int32_t *exp, uint64_t *frac_hi, uint64_t *frac_lo)
 {
 	uint64_t tmp_hi, tmp_lo;
Index: uspace/lib/softfloat/generic/comparison.c
===================================================================
--- uspace/lib/softfloat/generic/comparison.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/comparison.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -45,5 +45,5 @@
  * @return 1 if float is NaN, 0 otherwise.
  */
-int is_float32_nan(float32 f)
+int isFloat32NaN(float32 f)
 {
 	/* NaN : exp = 0xff and nonzero fraction */
@@ -58,5 +58,5 @@
  * @return 1 if float is NaN, 0 otherwise.
  */
-int is_float64_nan(float64 d)
+int isFloat64NaN(float64 d)
 {
 	/* NaN : exp = 0x7ff and nonzero fraction */
@@ -71,5 +71,5 @@
  * @return 1 if float is NaN, 0 otherwise.
  */
-int is_float128_nan(float128 ld)
+int isFloat128NaN(float128 ld)
 {
 	/* NaN : exp = 0x7fff and nonzero fraction */
@@ -84,5 +84,5 @@
  * @return 1 if float is signalling NaN, 0 otherwise.
  */
-int is_float32_signan(float32 f)
+int isFloat32SigNaN(float32 f)
 {
 	/* SigNaN : exp = 0xff and fraction = 0xxxxx..x (binary),
@@ -98,5 +98,5 @@
  * @return 1 if float is signalling NaN, 0 otherwise.
  */
-int is_float64_signan(float64 d)
+int isFloat64SigNaN(float64 d)
 {
 	/* SigNaN : exp = 0x7ff and fraction = 0xxxxx..x (binary),
@@ -112,5 +112,5 @@
  * @return 1 if float is signalling NaN, 0 otherwise.
  */
-int is_float128_signan(float128 ld)
+int isFloat128SigNaN(float128 ld)
 {
 	/* SigNaN : exp = 0x7fff and fraction = 0xxxxx..x (binary),
@@ -128,5 +128,5 @@
  * @return 1 if float is infinite, 0 otherwise.
  */
-int is_float32_infinity(float32 f)
+int isFloat32Infinity(float32 f)
 {
 	/* NaN : exp = 0x7ff and zero fraction */
@@ -140,5 +140,5 @@
  * @return 1 if float is infinite, 0 otherwise.
  */
-int is_float64_infinity(float64 d)
+int isFloat64Infinity(float64 d) 
 {
 	/* NaN : exp = 0x7ff and zero fraction */
@@ -152,5 +152,5 @@
  * @return 1 if float is infinite, 0 otherwise.
  */
-int is_float128_infinity(float128 ld)
+int isFloat128Infinity(float128 ld)
 {
 	/* NaN : exp = 0x7fff and zero fraction */
@@ -165,7 +165,7 @@
  * @return 1 if float is zero, 0 otherwise.
  */
-int is_float32_zero(float32 f)
-{
-	return (((f.bin) & 0x7FFFFFFF) == 0);
+int isFloat32Zero(float32 f)
+{
+	return (((f.binary) & 0x7FFFFFFF) == 0);
 }
 
@@ -176,7 +176,7 @@
  * @return 1 if float is zero, 0 otherwise.
  */
-int is_float64_zero(float64 d)
-{
-	return (((d.bin) & 0x7FFFFFFFFFFFFFFFll) == 0);
+int isFloat64Zero(float64 d)
+{
+	return (((d.binary) & 0x7FFFFFFFFFFFFFFFll) == 0);
 }
 
@@ -187,12 +187,12 @@
  * @return 1 if float is zero, 0 otherwise.
  */
-int is_float128_zero(float128 ld)
+int isFloat128Zero(float128 ld)
 {
 	uint64_t tmp_hi;
 	uint64_t tmp_lo;
-	
-	and128(ld.bin.hi, ld.bin.lo,
+
+	and128(ld.binary.hi, ld.binary.lo,
 	    0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
-	
+
 	return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
 }
@@ -205,9 +205,9 @@
  * @return 1 if both floats are equal, 0 otherwise.
  */
-int is_float32_eq(float32 a, float32 b)
+int isFloat32eq(float32 a, float32 b)
 {
 	/* a equals to b or both are zeros (with any sign) */
-	return ((a.bin == b.bin) ||
-	    (((a.bin | b.bin) & 0x7FFFFFFF) == 0));
+	return ((a.binary == b.binary) ||
+	    (((a.binary | b.binary) & 0x7FFFFFFF) == 0));
 }
 
@@ -219,9 +219,9 @@
  * @return 1 if both floats are equal, 0 otherwise.
  */
-int is_float64_eq(float64 a, float64 b)
+int isFloat64eq(float64 a, float64 b)
 {
 	/* a equals to b or both are zeros (with any sign) */
-	return ((a.bin == b.bin) ||
-	    (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0));
+	return ((a.binary == b.binary) ||
+	    (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0));
 }
 
@@ -233,12 +233,12 @@
  * @return 1 if both floats are equal, 0 otherwise.
  */
-int is_float128_eq(float128 a, float128 b)
+int isFloat128eq(float128 a, float128 b)
 {
 	uint64_t tmp_hi;
 	uint64_t tmp_lo;
-	
+
 	/* both are zeros (with any sign) */
-	or128(a.bin.hi, a.bin.lo,
-	    b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
+	or128(a.binary.hi, a.binary.lo,
+	    b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
 	and128(tmp_hi, tmp_lo,
 	    0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
@@ -246,6 +246,6 @@
 	
 	/* a equals to b */
-	int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
-	
+	int are_equal = eq128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
+
 	return are_equal || both_zero;
 }
@@ -258,24 +258,20 @@
  * @return 1 if a is lower than b, 0 otherwise.
  */
-int is_float32_lt(float32 a, float32 b) 
-{
-	if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
-		/* +- zeroes */
-		return 0;
+int isFloat32lt(float32 a, float32 b) 
+{
+	if (((a.binary | b.binary) & 0x7FFFFFFF) == 0) {
+		return 0; /* +- zeroes */
 	}
 	
 	if ((a.parts.sign) && (b.parts.sign)) {
 		/* if both are negative, smaller is that with greater binary value */
-		return (a.bin > b.bin);
+		return (a.binary > b.binary);
 	}
 	
-	/*
-	 * lets negate signs - now will be positive numbers always
-	 * bigger than negative (first bit will be set for unsigned
-	 * integer comparison)
-	 */
-	a.parts.sign = !a.parts.sign;
-	b.parts.sign = !b.parts.sign;
-	return (a.bin < b.bin);
+	/* lets negate signs - now will be positive numbers allways bigger than
+	 * negative (first bit will be set for unsigned integer comparison) */
+	a.parts.sign = !a.parts.sign;
+	b.parts.sign = !b.parts.sign;
+	return (a.binary < b.binary);
 }
 
@@ -287,24 +283,20 @@
  * @return 1 if a is lower than b, 0 otherwise.
  */
-int is_float64_lt(float64 a, float64 b)
-{
-	if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) {
-		/* +- zeroes */
-		return 0;
-	}
-	
+int isFloat64lt(float64 a, float64 b)
+{
+	if (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0) {
+		return 0; /* +- zeroes */
+	}
+
 	if ((a.parts.sign) && (b.parts.sign)) {
 		/* if both are negative, smaller is that with greater binary value */
-		return (a.bin > b.bin);
-	}
-	
-	/*
-	 * lets negate signs - now will be positive numbers always
-	 * bigger than negative (first bit will be set for unsigned
-	 * integer comparison)
-	 */
-	a.parts.sign = !a.parts.sign;
-	b.parts.sign = !b.parts.sign;
-	return (a.bin < b.bin);
+		return (a.binary > b.binary);
+	}
+
+	/* lets negate signs - now will be positive numbers allways bigger than
+	 * negative (first bit will be set for unsigned integer comparison) */
+	a.parts.sign = !a.parts.sign;
+	b.parts.sign = !b.parts.sign;
+	return (a.binary < b.binary);
 }
 
@@ -316,31 +308,27 @@
  * @return 1 if a is lower than b, 0 otherwise.
  */
-int is_float128_lt(float128 a, float128 b)
+int isFloat128lt(float128 a, float128 b)
 {
 	uint64_t tmp_hi;
 	uint64_t tmp_lo;
-	
-	or128(a.bin.hi, a.bin.lo,
-	    b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
+
+	or128(a.binary.hi, a.binary.lo,
+	    b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
 	and128(tmp_hi, tmp_lo,
 	    0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
 	if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) {
-		/* +- zeroes */
-		return 0;
-	}
-	
+		return 0; /* +- zeroes */
+	}
+
 	if ((a.parts.sign) && (b.parts.sign)) {
 		/* if both are negative, smaller is that with greater binary value */
-		return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
-	}
-	
-	/*
-	 * lets negate signs - now will be positive numbers always
-	 * bigger than negative (first bit will be set for unsigned
-	 * integer comparison)
-	 */
-	a.parts.sign = !a.parts.sign;
-	b.parts.sign = !b.parts.sign;
-	return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
+		return lt128(b.binary.hi, b.binary.lo, a.binary.hi, a.binary.lo);
+	}
+
+	/* lets negate signs - now will be positive numbers allways bigger than
+	 * negative (first bit will be set for unsigned integer comparison) */
+	a.parts.sign = !a.parts.sign;
+	b.parts.sign = !b.parts.sign;
+	return lt128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
 }
 
@@ -352,24 +340,20 @@
  * @return 1 if a is greater than b, 0 otherwise.
  */
-int is_float32_gt(float32 a, float32 b) 
-{
-	if (((a.bin | b.bin) & 0x7FFFFFFF) == 0) {
-		/* zeroes are equal with any sign */
-		return 0;
+int isFloat32gt(float32 a, float32 b) 
+{
+	if (((a.binary | b.binary) & 0x7FFFFFFF) == 0) {
+		return 0; /* zeroes are equal with any sign */
 	}
 	
 	if ((a.parts.sign) && (b.parts.sign)) {
 		/* if both are negative, greater is that with smaller binary value */
-		return (a.bin < b.bin);
+		return (a.binary < b.binary);
 	}
 	
-	/*
-	 * lets negate signs - now will be positive numbers always
-	 * bigger than negative (first bit will be set for unsigned
-	 * integer comparison)
-	 */
-	a.parts.sign = !a.parts.sign;
-	b.parts.sign = !b.parts.sign;
-	return (a.bin > b.bin);
+	/* lets negate signs - now will be positive numbers allways bigger than
+	 *  negative (first bit will be set for unsigned integer comparison) */
+	a.parts.sign = !a.parts.sign;
+	b.parts.sign = !b.parts.sign;
+	return (a.binary > b.binary);
 }
 
@@ -381,24 +365,20 @@
  * @return 1 if a is greater than b, 0 otherwise.
  */
-int is_float64_gt(float64 a, float64 b)
-{
-	if (((a.bin | b.bin) & 0x7FFFFFFFFFFFFFFFll) == 0) {
-		/* zeroes are equal with any sign */
-		return 0;
-	}
-	
+int isFloat64gt(float64 a, float64 b)
+{
+	if (((a.binary | b.binary) & 0x7FFFFFFFFFFFFFFFll) == 0) {
+		return 0; /* zeroes are equal with any sign */
+	}
+
 	if ((a.parts.sign) && (b.parts.sign)) {
 		/* if both are negative, greater is that with smaller binary value */
-		return (a.bin < b.bin);
-	}
-	
-	/*
-	 * lets negate signs - now will be positive numbers always
-	 * bigger than negative (first bit will be set for unsigned
-	 * integer comparison)
-	 */
-	a.parts.sign = !a.parts.sign;
-	b.parts.sign = !b.parts.sign;
-	return (a.bin > b.bin);
+		return (a.binary < b.binary);
+	}
+
+	/* lets negate signs - now will be positive numbers allways bigger than
+	 *  negative (first bit will be set for unsigned integer comparison) */
+	a.parts.sign = !a.parts.sign;
+	b.parts.sign = !b.parts.sign;
+	return (a.binary > b.binary);
 }
 
@@ -410,31 +390,27 @@
  * @return 1 if a is greater than b, 0 otherwise.
  */
-int is_float128_gt(float128 a, float128 b)
+int isFloat128gt(float128 a, float128 b)
 {
 	uint64_t tmp_hi;
 	uint64_t tmp_lo;
-	
-	or128(a.bin.hi, a.bin.lo,
-	    b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
+
+	or128(a.binary.hi, a.binary.lo,
+	    b.binary.hi, b.binary.lo, &tmp_hi, &tmp_lo);
 	and128(tmp_hi, tmp_lo,
 	    0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
 	if (eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll)) {
-		/* zeroes are equal with any sign */
-		return 0;
-	}
-	
+		return 0; /* zeroes are equal with any sign */
+	}
+
 	if ((a.parts.sign) && (b.parts.sign)) {
 		/* if both are negative, greater is that with smaller binary value */
-		return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
-	}
-	
-	/*
-	 * lets negate signs - now will be positive numbers always
-	 * bigger than negative (first bit will be set for unsigned
-	 * integer comparison)
-	 */
-	a.parts.sign = !a.parts.sign;
-	b.parts.sign = !b.parts.sign;
-	return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
+		return lt128(a.binary.hi, a.binary.lo, b.binary.hi, b.binary.lo);
+	}
+
+	/* lets negate signs - now will be positive numbers allways bigger than
+	 *  negative (first bit will be set for unsigned integer comparison) */
+	a.parts.sign = !a.parts.sign;
+	b.parts.sign = !b.parts.sign;
+	return lt128(b.binary.hi, b.binary.lo, a.binary.hi, a.binary.lo);
 }
 
Index: uspace/lib/softfloat/generic/conversion.c
===================================================================
--- uspace/lib/softfloat/generic/conversion.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/conversion.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -39,5 +39,5 @@
 #include <common.h>
 
-float64 float32_to_float64(float32 a)
+float64 convertFloat32ToFloat64(float32 a) 
 {
 	float64 result;
@@ -48,7 +48,7 @@
 	result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
 	
-	if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
+	if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
 		result.parts.exp = FLOAT64_MAX_EXPONENT;
-		// TODO; check if its correct for SigNaNs
+		/* TODO; check if its correct for SigNaNs*/
 		return result;
 	}
@@ -57,5 +57,5 @@
 	if (a.parts.exp == 0) {
 		/* normalize denormalized numbers */
-		
+
 		if (result.parts.fraction == 0) { /* fix zero */
 			result.parts.exp = 0;
@@ -77,10 +77,10 @@
 }
 
-float128 float32_to_float128(float32 a)
+float128 convertFloat32ToFloat128(float32 a)
 {
 	float128 result;
 	uint64_t frac_hi, frac_lo;
 	uint64_t tmp_hi, tmp_lo;
-	
+
 	result.parts.sign = a.parts.sign;
 	result.parts.frac_hi = 0;
@@ -91,15 +91,15 @@
 	result.parts.frac_hi = frac_hi;
 	result.parts.frac_lo = frac_lo;
-	
-	if ((is_float32_infinity(a)) || (is_float32_nan(a))) {
+
+	if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
 		result.parts.exp = FLOAT128_MAX_EXPONENT;
-		// TODO; check if its correct for SigNaNs
-		return result;
-	}
-	
+		/* TODO; check if its correct for SigNaNs*/
+		return result;
+	}
+
 	result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT32_BIAS);
 	if (a.parts.exp == 0) {
 		/* normalize denormalized numbers */
-		
+
 		if (eq128(result.parts.frac_hi,
 		    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
@@ -107,8 +107,8 @@
 			return result;
 		}
-		
+
 		frac_hi = result.parts.frac_hi;
 		frac_lo = result.parts.frac_lo;
-		
+
 		and128(frac_hi, frac_lo,
 		    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
@@ -118,19 +118,19 @@
 			--result.parts.exp;
 		}
-		
+
 		++result.parts.exp;
 		result.parts.frac_hi = frac_hi;
 		result.parts.frac_lo = frac_lo;
 	}
-	
-	return result;
-}
-
-float128 float64_to_float128(float64 a)
+
+	return result;
+}
+
+float128 convertFloat64ToFloat128(float64 a)
 {
 	float128 result;
 	uint64_t frac_hi, frac_lo;
 	uint64_t tmp_hi, tmp_lo;
-	
+
 	result.parts.sign = a.parts.sign;
 	result.parts.frac_hi = 0;
@@ -141,15 +141,15 @@
 	result.parts.frac_hi = frac_hi;
 	result.parts.frac_lo = frac_lo;
-	
-	if ((is_float64_infinity(a)) || (is_float64_nan(a))) {
+
+	if ((isFloat64Infinity(a)) || (isFloat64NaN(a))) {
 		result.parts.exp = FLOAT128_MAX_EXPONENT;
-		// TODO; check if its correct for SigNaNs
-		return result;
-	}
-	
+		/* TODO; check if its correct for SigNaNs*/
+		return result;
+	}
+
 	result.parts.exp = a.parts.exp + ((int) FLOAT128_BIAS - FLOAT64_BIAS);
 	if (a.parts.exp == 0) {
 		/* normalize denormalized numbers */
-		
+
 		if (eq128(result.parts.frac_hi,
 		    result.parts.frac_lo, 0x0ll, 0x0ll)) { /* fix zero */
@@ -157,8 +157,8 @@
 			return result;
 		}
-		
+
 		frac_hi = result.parts.frac_hi;
 		frac_lo = result.parts.frac_lo;
-		
+
 		and128(frac_hi, frac_lo,
 		    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
@@ -168,14 +168,14 @@
 			--result.parts.exp;
 		}
-		
+
 		++result.parts.exp;
 		result.parts.frac_hi = frac_hi;
 		result.parts.frac_lo = frac_lo;
 	}
-	
-	return result;
-}
-
-float32 float64_to_float32(float64 a)
+
+	return result;
+}
+
+float32 convertFloat64ToFloat32(float64 a) 
 {
 	float32 result;
@@ -185,24 +185,24 @@
 	result.parts.sign = a.parts.sign;
 	
-	if (is_float64_nan(a)) {
+	if (isFloat64NaN(a)) {
 		result.parts.exp = FLOAT32_MAX_EXPONENT;
 		
-		if (is_float64_signan(a)) {
+		if (isFloat64SigNaN(a)) {
 			/* set first bit of fraction nonzero */
 			result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
 			return result;
 		}
-		
+
 		/* fraction nonzero but its first bit is zero */
 		result.parts.fraction = 0x1;
 		return result;
 	}
-	
-	if (is_float64_infinity(a)) {
+
+	if (isFloat64Infinity(a)) {
 		result.parts.fraction = 0;
 		result.parts.exp = FLOAT32_MAX_EXPONENT;
 		return result;
 	}
-	
+
 	exp = (int) a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS;
 	
@@ -239,5 +239,5 @@
 		return result;
 	}
-	
+
 	result.parts.exp = exp;
 	result.parts.fraction =
@@ -246,34 +246,34 @@
 }
 
-float32 float128_to_float32(float128 a)
+float32 convertFloat128ToFloat32(float128 a)
 {
 	float32 result;
 	int32_t exp;
 	uint64_t frac_hi, frac_lo;
-	
+
 	result.parts.sign = a.parts.sign;
-	
-	if (is_float128_nan(a)) {
+
+	if (isFloat128NaN(a)) {
 		result.parts.exp = FLOAT32_MAX_EXPONENT;
-		
-		if (is_float128_signan(a)) {
+
+		if (isFloat128SigNaN(a)) {
 			/* set first bit of fraction nonzero */
 			result.parts.fraction = FLOAT32_HIDDEN_BIT_MASK >> 1;
 			return result;
 		}
-		
+
 		/* fraction nonzero but its first bit is zero */
 		result.parts.fraction = 0x1;
 		return result;
 	}
-	
-	if (is_float128_infinity(a)) {
+
+	if (isFloat128Infinity(a)) {
 		result.parts.fraction = 0;
 		result.parts.exp = FLOAT32_MAX_EXPONENT;
 		return result;
 	}
-	
+
 	exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT32_BIAS;
-	
+
 	if (exp >= FLOAT32_MAX_EXPONENT) {
 		/* FIXME: overflow */
@@ -283,7 +283,7 @@
 	} else if (exp <= 0) {
 		/* underflow or denormalized */
-		
+
 		result.parts.exp = 0;
-		
+
 		exp *= -1;
 		if (exp > FLOAT32_FRACTION_SIZE) {
@@ -292,17 +292,17 @@
 			return result;
 		}
-		
+
 		/* denormalized */
-		
+
 		frac_hi = a.parts.frac_hi;
 		frac_lo = a.parts.frac_lo;
-		
+
 		/* denormalize and set hidden bit */
 		frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
-		
+
 		rshift128(frac_hi, frac_lo,
 		    (FLOAT128_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1),
 		    &frac_hi, &frac_lo);
-		
+
 		while (exp > 0) {
 			--exp;
@@ -310,8 +310,8 @@
 		}
 		result.parts.fraction = frac_lo;
-		
-		return result;
-	}
-	
+
+		return result;
+	}
+
 	result.parts.exp = exp;
 	frac_hi = a.parts.frac_hi;
@@ -324,34 +324,34 @@
 }
 
-float64 float128_to_float64(float128 a)
+float64 convertFloat128ToFloat64(float128 a)
 {
 	float64 result;
 	int32_t exp;
 	uint64_t frac_hi, frac_lo;
-	
+
 	result.parts.sign = a.parts.sign;
-	
-	if (is_float128_nan(a)) {
+
+	if (isFloat128NaN(a)) {
 		result.parts.exp = FLOAT64_MAX_EXPONENT;
-		
-		if (is_float128_signan(a)) {
+
+		if (isFloat128SigNaN(a)) {
 			/* set first bit of fraction nonzero */
 			result.parts.fraction = FLOAT64_HIDDEN_BIT_MASK >> 1;
 			return result;
 		}
-		
+
 		/* fraction nonzero but its first bit is zero */
 		result.parts.fraction = 0x1;
 		return result;
 	}
-	
-	if (is_float128_infinity(a)) {
+
+	if (isFloat128Infinity(a)) {
 		result.parts.fraction = 0;
 		result.parts.exp = FLOAT64_MAX_EXPONENT;
 		return result;
 	}
-	
+
 	exp = (int) a.parts.exp - FLOAT128_BIAS + FLOAT64_BIAS;
-	
+
 	if (exp >= FLOAT64_MAX_EXPONENT) {
 		/* FIXME: overflow */
@@ -361,7 +361,7 @@
 	} else if (exp <= 0) {
 		/* underflow or denormalized */
-		
+
 		result.parts.exp = 0;
-		
+
 		exp *= -1;
 		if (exp > FLOAT64_FRACTION_SIZE) {
@@ -370,17 +370,17 @@
 			return result;
 		}
-		
+
 		/* denormalized */
-		
+
 		frac_hi = a.parts.frac_hi;
 		frac_lo = a.parts.frac_lo;
-		
+
 		/* denormalize and set hidden bit */
 		frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
-		
+
 		rshift128(frac_hi, frac_lo,
 		    (FLOAT128_FRACTION_SIZE - FLOAT64_FRACTION_SIZE + 1),
 		    &frac_hi, &frac_lo);
-		
+
 		while (exp > 0) {
 			--exp;
@@ -388,8 +388,8 @@
 		}
 		result.parts.fraction = frac_lo;
-		
-		return result;
-	}
-	
+
+		return result;
+	}
+
 	result.parts.exp = exp;
 	frac_hi = a.parts.frac_hi;
@@ -402,5 +402,7 @@
 }
 
-/** Helper procedure for converting float32 to uint32.
+
+/** 
+ * Helping procedure for converting float32 to uint32.
  *
  * @param a Floating point number in normalized form
@@ -422,5 +424,5 @@
 	/* shift fraction to left so hidden bit will be the most significant bit */
 	frac <<= 32 - FLOAT32_FRACTION_SIZE - 1; 
-	
+
 	frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1;
 	if ((a.parts.sign == 1) && (frac != 0)) {
@@ -432,14 +434,14 @@
 }
 
-/*
- * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
- */
+/* 
+ * FIXME: Im not sure what to return if overflow/underflow happens 
+ * 	- now its the biggest or the smallest int
+ */ 
 uint32_t float32_to_uint32(float32 a)
 {
-	if (is_float32_nan(a))
+	if (isFloat32NaN(a))
 		return UINT32_MAX;
 	
-	if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
+	if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
 		if (a.parts.sign)
 			return UINT32_MIN;
@@ -451,14 +453,14 @@
 }
 
-/*
- * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
- */
+/* 
+ * FIXME: Im not sure what to return if overflow/underflow happens 
+ * 	- now its the biggest or the smallest int
+ */ 
 int32_t float32_to_int32(float32 a)
 {
-	if (is_float32_nan(a))
+	if (isFloat32NaN(a))
 		return INT32_MAX;
 	
-	if (is_float32_infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
+	if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
 		if (a.parts.sign)
 			return INT32_MIN;
@@ -470,5 +472,7 @@
 }
 
-/** Helper procedure for converting float32 to uint64.
+
+/**
+ * Helping procedure for converting float32 to uint64.
  *
  * @param a Floating point number in normalized form
@@ -479,16 +483,16 @@
 {
 	uint64_t frac;
-	
+
 	if (a.parts.exp < FLOAT32_BIAS) {
-		// TODO: rounding
+		/*TODO: rounding*/
 		return 0;
 	}
-	
+
 	frac = a.parts.fraction;
-	
+
 	frac |= FLOAT32_HIDDEN_BIT_MASK;
 	/* shift fraction to left so hidden bit will be the most significant bit */
 	frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
-	
+
 	frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
 	if ((a.parts.sign == 1) && (frac != 0)) {
@@ -496,47 +500,50 @@
 		++frac;
 	}
-	
+
 	return frac;
 }
 
-/*
+/* 
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 uint64_t float32_to_uint64(float32 a)
 {
-	if (is_float32_nan(a))
+	if (isFloat32NaN(a))
 		return UINT64_MAX;
-	
-	if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
+
+
+	if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
 		if (a.parts.sign)
 			return UINT64_MIN;
-		
+
 		return UINT64_MAX;
 	}
-	
+
 	return _float32_to_uint64_helper(a);
 }
 
-/*
+/* 
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 int64_t float32_to_int64(float32 a)
 {
-	if (is_float32_nan(a))
+	if (isFloat32NaN(a))
 		return INT64_MAX;
-	
-	if (is_float32_infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
+
+	if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
 		if (a.parts.sign)
 			return INT64_MIN;
-		
+
 		return INT64_MAX;
 	}
-	
+
 	return _float32_to_uint64_helper(a);
 }
 
-/** Helper procedure for converting float64 to uint64.
+
+/**
+ * Helping procedure for converting float64 to uint64.
  *
  * @param a Floating point number in normalized form
@@ -547,16 +554,16 @@
 {
 	uint64_t frac;
-	
+
 	if (a.parts.exp < FLOAT64_BIAS) {
-		// TODO: rounding
+		/*TODO: rounding*/
 		return 0;
 	}
-	
+
 	frac = a.parts.fraction;
-	
+
 	frac |= FLOAT64_HIDDEN_BIT_MASK;
 	/* shift fraction to left so hidden bit will be the most significant bit */
 	frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
-	
+
 	frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
 	if ((a.parts.sign == 1) && (frac != 0)) {
@@ -564,5 +571,5 @@
 		++frac;
 	}
-	
+
 	return frac;
 }
@@ -570,18 +577,18 @@
 /*
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 uint32_t float64_to_uint32(float64 a)
 {
-	if (is_float64_nan(a))
+	if (isFloat64NaN(a))
 		return UINT32_MAX;
-	
-	if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
+
+	if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
 		if (a.parts.sign)
 			return UINT32_MIN;
-		
+
 		return UINT32_MAX;
 	}
-	
+
 	return (uint32_t) _float64_to_uint64_helper(a);
 }
@@ -589,31 +596,32 @@
 /*
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 int32_t float64_to_int32(float64 a)
 {
-	if (is_float64_nan(a))
+	if (isFloat64NaN(a))
 		return INT32_MAX;
-	
-	if (is_float64_infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
+
+	if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
 		if (a.parts.sign)
 			return INT32_MIN;
-		
+
 		return INT32_MAX;
 	}
-	
+
 	return (int32_t) _float64_to_uint64_helper(a);
 }
 
-/*
+
+/* 
  * FIXME: Im not sure what to return if overflow/underflow happens 
- *  - now its the biggest or the smallest int
- */
+ * 	- now its the biggest or the smallest int
+ */ 
 uint64_t float64_to_uint64(float64 a)
 {
-	if (is_float64_nan(a))
+	if (isFloat64NaN(a))
 		return UINT64_MAX;
 	
-	if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
+	if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
 		if (a.parts.sign)
 			return UINT64_MIN;
@@ -625,14 +633,14 @@
 }
 
-/*
+/* 
  * FIXME: Im not sure what to return if overflow/underflow happens 
- *  - now its the biggest or the smallest int
- */
+ * 	- now its the biggest or the smallest int
+ */ 
 int64_t float64_to_int64(float64 a)
 {
-	if (is_float64_nan(a))
+	if (isFloat64NaN(a))
 		return INT64_MAX;
 	
-	if (is_float64_infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
+	if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
 		if (a.parts.sign)
 			return INT64_MIN;
@@ -644,5 +652,7 @@
 }
 
-/** Helper procedure for converting float128 to uint64.
+
+/**
+ * Helping procedure for converting float128 to uint64.
  *
  * @param a Floating point number in normalized form
@@ -653,18 +663,18 @@
 {
 	uint64_t frac_hi, frac_lo;
-	
+
 	if (a.parts.exp < FLOAT128_BIAS) {
-		// TODO: rounding
+		/*TODO: rounding*/
 		return 0;
 	}
-	
+
 	frac_hi = a.parts.frac_hi;
 	frac_lo = a.parts.frac_lo;
-	
+
 	frac_hi |= FLOAT128_HIDDEN_BIT_MASK_HI;
 	/* shift fraction to left so hidden bit will be the most significant bit */
 	lshift128(frac_hi, frac_lo,
 	    (128 - FLOAT128_FRACTION_SIZE - 1), &frac_hi, &frac_lo);
-	
+
 	rshift128(frac_hi, frac_lo,
 	    (128 - (a.parts.exp - FLOAT128_BIAS) - 1), &frac_hi, &frac_lo);
@@ -673,5 +683,5 @@
 		add128(frac_hi, frac_lo, 0x0ll, 0x1ll, &frac_hi, &frac_lo);
 	}
-	
+
 	return frac_lo;
 }
@@ -679,18 +689,18 @@
 /*
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 uint32_t float128_to_uint32(float128 a)
 {
-	if (is_float128_nan(a))
+	if (isFloat128NaN(a))
 		return UINT32_MAX;
-	
-	if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
+
+	if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
 		if (a.parts.sign)
 			return UINT32_MIN;
-		
+
 		return UINT32_MAX;
 	}
-	
+
 	return (uint32_t) _float128_to_uint64_helper(a);
 }
@@ -698,37 +708,38 @@
 /*
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 int32_t float128_to_int32(float128 a)
 {
-	if (is_float128_nan(a))
+	if (isFloat128NaN(a))
 		return INT32_MAX;
-	
-	if (is_float128_infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
+
+	if (isFloat128Infinity(a) || (a.parts.exp >= (32 + FLOAT128_BIAS))) {
 		if (a.parts.sign)
 			return INT32_MIN;
-		
+
 		return INT32_MAX;
 	}
-	
+
 	return (int32_t) _float128_to_uint64_helper(a);
 }
+
 
 /*
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 uint64_t float128_to_uint64(float128 a)
 {
-	if (is_float128_nan(a))
+	if (isFloat128NaN(a))
 		return UINT64_MAX;
-	
-	if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
+
+	if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
 		if (a.parts.sign)
 			return UINT64_MIN;
-		
+
 		return UINT64_MAX;
 	}
-	
+
 	return _float128_to_uint64_helper(a);
 }
@@ -736,20 +747,21 @@
 /*
  * FIXME: Im not sure what to return if overflow/underflow happens
- *  - now its the biggest or the smallest int
+ * 	- now its the biggest or the smallest int
  */
 int64_t float128_to_int64(float128 a)
 {
-	if (is_float128_nan(a))
+	if (isFloat128NaN(a))
 		return INT64_MAX;
-	
-	if (is_float128_infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
+
+	if (isFloat128Infinity(a) || (a.parts.exp >= (64 + FLOAT128_BIAS))) {
 		if (a.parts.sign)
 			return INT64_MIN;
-		
+
 		return INT64_MAX;
 	}
-	
+
 	return _float128_to_uint64_helper(a);
 }
+
 
 float32 uint32_to_float32(uint32_t i)
@@ -761,11 +773,11 @@
 	result.parts.sign = 0;
 	result.parts.fraction = 0;
-	
-	counter = count_zeroes32(i);
-	
+
+	counter = countZeroes32(i);
+
 	exp = FLOAT32_BIAS + 32 - counter - 1;
 	
 	if (counter == 32) {
-		result.bin = 0;
+		result.binary = 0;
 		return result;
 	}
@@ -776,28 +788,30 @@
 		i >>= 1;
 	}
-	
-	round_float32(&exp, &i);
-	
+
+	roundFloat32(&exp, &i);
+
 	result.parts.fraction = i >> (32 - FLOAT32_FRACTION_SIZE - 2);
 	result.parts.exp = exp;
-	
-	return result;
-}
-
-float32 int32_to_float32(int32_t i)
+
+	return result;
+}
+
+float32 int32_to_float32(int32_t i) 
 {
 	float32 result;
-	
-	if (i < 0)
+
+	if (i < 0) {
 		result = uint32_to_float32((uint32_t) (-i));
-	else
+	} else {
 		result = uint32_to_float32((uint32_t) i);
+	}
 	
 	result.parts.sign = i < 0;
-	
-	return result;
-}
-
-float32 uint64_to_float32(uint64_t i)
+
+ 	return result;
+}
+
+
+float32 uint64_to_float32(uint64_t i) 
 {
 	int counter;
@@ -808,11 +822,11 @@
 	result.parts.sign = 0;
 	result.parts.fraction = 0;
-	
-	counter = count_zeroes64(i);
-	
+
+	counter = countZeroes64(i);
+
 	exp = FLOAT32_BIAS + 64 - counter - 1;
 	
 	if (counter == 64) {
-		result.bin = 0;
+		result.binary = 0;
 		return result;
 	}
@@ -826,6 +840,6 @@
 	
 	j = (uint32_t) i;
-	round_float32(&exp, &j);
-	
+	roundFloat32(&exp, &j);
+
 	result.parts.fraction = j >> (32 - FLOAT32_FRACTION_SIZE - 2);
 	result.parts.exp = exp;
@@ -833,16 +847,17 @@
 }
 
-float32 int64_to_float32(int64_t i)
+float32 int64_to_float32(int64_t i) 
 {
 	float32 result;
-	
-	if (i < 0)
+
+	if (i < 0) {
 		result = uint64_to_float32((uint64_t) (-i));
-	else
+	} else {
 		result = uint64_to_float32((uint64_t) i);
+	}
 	
 	result.parts.sign = i < 0;
-	
-	return result;
+
+ 	return result;
 }
 
@@ -856,41 +871,42 @@
 	result.parts.sign = 0;
 	result.parts.fraction = 0;
-	
-	counter = count_zeroes32(i);
-	
+
+	counter = countZeroes32(i);
+
 	exp = FLOAT64_BIAS + 32 - counter - 1;
 	
 	if (counter == 32) {
-		result.bin = 0;
+		result.binary = 0;
 		return result;
 	}
 	
 	frac = i;
-	frac <<= counter + 32 - 1;
-	
-	round_float64(&exp, &frac);
-	
+	frac <<= counter + 32 - 1; 
+
+	roundFloat64(&exp, &frac);
+
 	result.parts.fraction = frac >> (64 - FLOAT64_FRACTION_SIZE - 2);
 	result.parts.exp = exp;
-	
-	return result;
-}
-
-float64 int32_to_float64(int32_t i)
+
+	return result;
+}
+
+float64 int32_to_float64(int32_t i) 
 {
 	float64 result;
-	
-	if (i < 0)
+
+	if (i < 0) {
 		result = uint32_to_float64((uint32_t) (-i));
-	else
+	} else {
 		result = uint32_to_float64((uint32_t) i);
+	}
 	
 	result.parts.sign = i < 0;
-	
-	return result;
-}
-
-
-float64 uint64_to_float64(uint64_t i)
+
+ 	return result;
+}
+
+
+float64 uint64_to_float64(uint64_t i) 
 {
 	int counter;
@@ -900,11 +916,11 @@
 	result.parts.sign = 0;
 	result.parts.fraction = 0;
-	
-	counter = count_zeroes64(i);
-	
+
+	counter = countZeroes64(i);
+
 	exp = FLOAT64_BIAS + 64 - counter - 1;
 	
 	if (counter == 64) {
-		result.bin = 0;
+		result.binary = 0;
 		return result;
 	}
@@ -915,7 +931,7 @@
 		i >>= 1;
 	}
-	
-	round_float64(&exp, &i);
-	
+
+	roundFloat64(&exp, &i);
+
 	result.parts.fraction = i >> (64 - FLOAT64_FRACTION_SIZE - 2);
 	result.parts.exp = exp;
@@ -923,17 +939,19 @@
 }
 
-float64 int64_to_float64(int64_t i)
+float64 int64_to_float64(int64_t i) 
 {
 	float64 result;
-	
-	if (i < 0)
+
+	if (i < 0) {
 		result = uint64_to_float64((uint64_t) (-i));
-	else
+	} else {
 		result = uint64_to_float64((uint64_t) i);
+	}
 	
 	result.parts.sign = i < 0;
-	
-	return result;
-}
+
+ 	return result;
+}
+
 
 float128 uint32_to_float128(uint32_t i)
@@ -943,25 +961,25 @@
 	float128 result;
 	uint64_t frac_hi, frac_lo;
-	
+
 	result.parts.sign = 0;
 	result.parts.frac_hi = 0;
 	result.parts.frac_lo = 0;
-	
-	counter = count_zeroes32(i);
-	
+
+	counter = countZeroes32(i);
+
 	exp = FLOAT128_BIAS + 32 - counter - 1;
-	
+
 	if (counter == 32) {
-		result.bin.hi = 0;
-		result.bin.lo = 0;
-		return result;
-	}
-	
+		result.binary.hi = 0;
+		result.binary.lo = 0;
+		return result;
+	}
+
 	frac_hi = 0;
 	frac_lo = i;
 	lshift128(frac_hi, frac_lo, (counter + 96 - 1), &frac_hi, &frac_lo);
-	
-	round_float128(&exp, &frac_hi, &frac_lo);
-	
+
+	roundFloat128(&exp, &frac_hi, &frac_lo);
+
 	rshift128(frac_hi, frac_lo,
 	    (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
@@ -969,5 +987,5 @@
 	result.parts.frac_lo = frac_lo;
 	result.parts.exp = exp;
-	
+
 	return result;
 }
@@ -976,13 +994,14 @@
 {
 	float128 result;
-	
-	if (i < 0)
+
+	if (i < 0) {
 		result = uint32_to_float128((uint32_t) (-i));
-	else
+	} else {
 		result = uint32_to_float128((uint32_t) i);
-	
+	}
+
 	result.parts.sign = i < 0;
-	
-	return result;
+
+ 	return result;
 }
 
@@ -994,25 +1013,25 @@
 	float128 result;
 	uint64_t frac_hi, frac_lo;
-	
+
 	result.parts.sign = 0;
 	result.parts.frac_hi = 0;
 	result.parts.frac_lo = 0;
-	
-	counter = count_zeroes64(i);
-	
+
+	counter = countZeroes64(i);
+
 	exp = FLOAT128_BIAS + 64 - counter - 1;
-	
+
 	if (counter == 64) {
-		result.bin.hi = 0;
-		result.bin.lo = 0;
-		return result;
-	}
-	
+		result.binary.hi = 0;
+		result.binary.lo = 0;
+		return result;
+	}
+
 	frac_hi = 0;
 	frac_lo = i;
 	lshift128(frac_hi, frac_lo, (counter + 64 - 1), &frac_hi, &frac_lo);
-	
-	round_float128(&exp, &frac_hi, &frac_lo);
-	
+
+	roundFloat128(&exp, &frac_hi, &frac_lo);
+
 	rshift128(frac_hi, frac_lo,
 	    (128 - FLOAT128_FRACTION_SIZE - 2), &frac_hi, &frac_lo);
@@ -1020,5 +1039,5 @@
 	result.parts.frac_lo = frac_lo;
 	result.parts.exp = exp;
-	
+
 	return result;
 }
@@ -1027,13 +1046,14 @@
 {
 	float128 result;
-	
-	if (i < 0)
+
+	if (i < 0) {
 		result = uint64_to_float128((uint64_t) (-i));
-	else
+	} else {
 		result = uint64_to_float128((uint64_t) i);
-	
+	}
+
 	result.parts.sign = i < 0;
-	
-	return result;
+
+ 	return result;
 }
 
Index: uspace/lib/softfloat/generic/div.c
===================================================================
--- uspace/lib/softfloat/generic/div.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/div.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -41,13 +41,12 @@
 #include <common.h>
 
-/** Divide two single-precision floats.
- *
+/**
+ * Divide two single-precision floats.
+ * 
  * @param a Nominator.
  * @param b Denominator.
- *
  * @return Result of division.
- *
- */
-float32 div_float32(float32 a, float32 b)
+ */
+float32 divFloat32(float32 a, float32 b) 
 {
 	float32 result;
@@ -57,24 +56,24 @@
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
 	
-	if (is_float32_nan(a)) {
-		if (is_float32_signan(a)) {
-			// FIXME: SigNaN
-		}
-		/* NaN */
+	if (isFloat32NaN(a)) {
+		if (isFloat32SigNaN(a)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
 		return a;
 	}
 	
-	if (is_float32_nan(b)) {
-		if (is_float32_signan(b)) {
-			// FIXME: SigNaN
-		}
-		/* NaN */
+	if (isFloat32NaN(b)) {
+		if (isFloat32SigNaN(b)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
 		return b;
 	}
 	
-	if (is_float32_infinity(a)) {
-		if (is_float32_infinity(b)) {
+	if (isFloat32Infinity(a)) {
+		if (isFloat32Infinity(b)) {
 			/*FIXME: inf / inf */
-			result.bin = FLOAT32_NAN;
+			result.binary = FLOAT32_NAN;
 			return result;
 		}
@@ -84,7 +83,7 @@
 		return result;
 	}
-	
-	if (is_float32_infinity(b)) {
-		if (is_float32_zero(a)) {
+
+	if (isFloat32Infinity(b)) {
+		if (isFloat32Zero(a)) {
 			/* FIXME 0 / inf */
 			result.parts.exp = 0;
@@ -98,8 +97,8 @@
 	}
 	
-	if (is_float32_zero(b)) {
-		if (is_float32_zero(a)) {
+	if (isFloat32Zero(b)) {
+		if (isFloat32Zero(a)) {
 			/*FIXME: 0 / 0*/
-			result.bin = FLOAT32_NAN;
+			result.binary = FLOAT32_NAN;
 			return result;
 		}
@@ -122,8 +121,8 @@
 			return result;
 		}
-		
+
 		/* normalize it*/
 		afrac <<= 1;
-		/* afrac is nonzero => it must stop */
+		/* afrac is nonzero => it must stop */	
 		while (!(afrac & FLOAT32_HIDDEN_BIT_MASK)) {
 			afrac <<= 1;
@@ -131,8 +130,8 @@
 		}
 	}
-	
+
 	if (bexp == 0) {
 		bfrac <<= 1;
-		/* bfrac is nonzero => it must stop */
+		/* bfrac is nonzero => it must stop */	
 		while (!(bfrac & FLOAT32_HIDDEN_BIT_MASK)) {
 			bfrac <<= 1;
@@ -140,8 +139,8 @@
 		}
 	}
-	
-	afrac = (afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
-	bfrac = (bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
-	
+
+	afrac =	(afrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE - 1);
+	bfrac =	(bfrac | FLOAT32_HIDDEN_BIT_MASK) << (32 - FLOAT32_FRACTION_SIZE);
+
 	if (bfrac <= (afrac << 1)) {
 		afrac >>= 1;
@@ -170,6 +169,6 @@
 		++cexp;
 		cfrac >>= 1;
-	}
-	
+	}	
+
 	/* check overflow */
 	if (cexp >= FLOAT32_MAX_EXPONENT) {
@@ -179,5 +178,5 @@
 		return result;
 	}
-	
+
 	if (cexp < 0) {
 		/* FIXME: underflow */
@@ -191,5 +190,5 @@
 			cexp++;
 			cfrac >>= 1;
-		}
+		}	
 	} else {
 		result.parts.exp = (uint32_t) cexp;
@@ -198,16 +197,15 @@
 	result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
 	
-	return result;
+	return result;	
 }
 
-/** Divide two double-precision floats.
+/**
+ * Divide two double-precision floats.
  *
  * @param a Nominator.
  * @param b Denominator.
- *
  * @return Result of division.
- *
- */
-float64 div_float64(float64 a, float64 b) 
+ */
+float64 divFloat64(float64 a, float64 b) 
 {
 	float64 result;
@@ -219,29 +217,29 @@
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
 	
-	if (is_float64_nan(a)) {
-		if (is_float64_signan(b)) {
-			// FIXME: SigNaN
+	if (isFloat64NaN(a)) {
+		if (isFloat64SigNaN(b)) {
+			/*FIXME: SigNaN*/
 			return b;
 		}
 		
-		if (is_float64_signan(a)) {
-			// FIXME: SigNaN
-		}
-		/* NaN */
+		if (isFloat64SigNaN(a)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
 		return a;
 	}
 	
-	if (is_float64_nan(b)) {
-		if (is_float64_signan(b)) {
-			// FIXME: SigNaN
-		}
-		/* NaN */
+	if (isFloat64NaN(b)) {
+		if (isFloat64SigNaN(b)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
 		return b;
 	}
 	
-	if (is_float64_infinity(a)) {
-		if (is_float64_infinity(b) || is_float64_zero(b)) {
-			// FIXME: inf / inf
-			result.bin = FLOAT64_NAN;
+	if (isFloat64Infinity(a)) {
+		if (isFloat64Infinity(b) || isFloat64Zero(b)) {
+			/*FIXME: inf / inf */
+			result.binary = FLOAT64_NAN;
 			return result;
 		}
@@ -251,7 +249,7 @@
 		return result;
 	}
-	
-	if (is_float64_infinity(b)) {
-		if (is_float64_zero(a)) {
+
+	if (isFloat64Infinity(b)) {
+		if (isFloat64Zero(a)) {
 			/* FIXME 0 / inf */
 			result.parts.exp = 0;
@@ -265,8 +263,8 @@
 	}
 	
-	if (is_float64_zero(b)) {
-		if (is_float64_zero(a)) {
+	if (isFloat64Zero(b)) {
+		if (isFloat64Zero(a)) {
 			/*FIXME: 0 / 0*/
-			result.bin = FLOAT64_NAN;
+			result.binary = FLOAT64_NAN;
 			return result;
 		}
@@ -276,5 +274,5 @@
 		return result;
 	}
-	
+
 	afrac = a.parts.fraction;
 	aexp = a.parts.exp;
@@ -289,5 +287,5 @@
 			return result;
 		}
-		
+
 		/* normalize it*/
 		aexp++;
@@ -298,5 +296,5 @@
 		}
 	}
-	
+
 	if (bexp == 0) {
 		bexp++;
@@ -307,8 +305,8 @@
 		}
 	}
-	
-	afrac = (afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
-	bfrac = (bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
-	
+
+	afrac =	(afrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 2);
+	bfrac =	(bfrac | FLOAT64_HIDDEN_BIT_MASK) << (64 - FLOAT64_FRACTION_SIZE - 1);
+
 	if (bfrac <= (afrac << 1)) {
 		afrac >>= 1;
@@ -332,17 +330,16 @@
 	
 	/* round and shift */
-	result = finish_float64(cexp, cfrac, result.parts.sign);
+	result = finishFloat64(cexp, cfrac, result.parts.sign);
 	return result;
 }
 
-/** Divide two quadruple-precision floats.
+/**
+ * Divide two quadruple-precision floats.
  *
  * @param a Nominator.
  * @param b Denominator.
- *
  * @return Result of division.
- *
- */
-float128 div_float128(float128 a, float128 b)
+ */
+float128 divFloat128(float128 a, float128 b)
 {
 	float128 result;
@@ -352,33 +349,33 @@
 	uint64_t rem_hihi, rem_hilo, rem_lohi, rem_lolo;
 	uint64_t tmp_hihi, tmp_hilo, tmp_lohi, tmp_lolo;
-	
+
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
-	
-	if (is_float128_nan(a)) {
-		if (is_float128_signan(b)) {
-			// FIXME: SigNaN
+
+	if (isFloat128NaN(a)) {
+		if (isFloat128SigNaN(b)) {
+			/*FIXME: SigNaN*/
 			return b;
 		}
-		
-		if (is_float128_signan(a)) {
-			// FIXME: SigNaN
-		}
-		/* NaN */
+
+		if (isFloat128SigNaN(a)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
 		return a;
 	}
-	
-	if (is_float128_nan(b)) {
-		if (is_float128_signan(b)) {
-			// FIXME: SigNaN
-		}
-		/* NaN */
+
+	if (isFloat128NaN(b)) {
+		if (isFloat128SigNaN(b)) {
+			/*FIXME: SigNaN*/
+		}
+		/*NaN*/
 		return b;
 	}
-	
-	if (is_float128_infinity(a)) {
-		if (is_float128_infinity(b) || is_float128_zero(b)) {
-			// FIXME: inf / inf
-			result.bin.hi = FLOAT128_NAN_HI;
-			result.bin.lo = FLOAT128_NAN_LO;
+
+	if (isFloat128Infinity(a)) {
+		if (isFloat128Infinity(b) || isFloat128Zero(b)) {
+			/*FIXME: inf / inf */
+			result.binary.hi = FLOAT128_NAN_HI;
+			result.binary.lo = FLOAT128_NAN_LO;
 			return result;
 		}
@@ -389,8 +386,8 @@
 		return result;
 	}
-	
-	if (is_float128_infinity(b)) {
-		if (is_float128_zero(a)) {
-			// FIXME 0 / inf
+
+	if (isFloat128Infinity(b)) {
+		if (isFloat128Zero(a)) {
+			/* FIXME 0 / inf */
 			result.parts.exp = 0;
 			result.parts.frac_hi = 0;
@@ -398,5 +395,5 @@
 			return result;
 		}
-		// FIXME: num / inf
+		/* FIXME: num / inf*/
 		result.parts.exp = 0;
 		result.parts.frac_hi = 0;
@@ -404,13 +401,13 @@
 		return result;
 	}
-	
-	if (is_float128_zero(b)) {
-		if (is_float128_zero(a)) {
-			// FIXME: 0 / 0
-			result.bin.hi = FLOAT128_NAN_HI;
-			result.bin.lo = FLOAT128_NAN_LO;
-			return result;
-		}
-		// FIXME: division by zero
+
+	if (isFloat128Zero(b)) {
+		if (isFloat128Zero(a)) {
+			/*FIXME: 0 / 0*/
+			result.binary.hi = FLOAT128_NAN_HI;
+			result.binary.lo = FLOAT128_NAN_LO;
+			return result;
+		}
+		/* FIXME: division by zero */
 		result.parts.exp = 0;
 		result.parts.frac_hi = 0;
@@ -418,5 +415,5 @@
 		return result;
 	}
-	
+
 	afrac_hi = a.parts.frac_hi;
 	afrac_lo = a.parts.frac_lo;
@@ -425,5 +422,5 @@
 	bfrac_lo = b.parts.frac_lo;
 	bexp = b.parts.exp;
-	
+
 	/* denormalized numbers */
 	if (aexp == 0) {
@@ -434,5 +431,5 @@
 			return result;
 		}
-		
+
 		/* normalize it*/
 		aexp++;
@@ -446,5 +443,5 @@
 		}
 	}
-	
+
 	if (bexp == 0) {
 		bexp++;
@@ -458,5 +455,5 @@
 		}
 	}
-	
+
 	or128(afrac_hi, afrac_lo,
 	    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
@@ -469,18 +466,18 @@
 	lshift128(bfrac_hi, bfrac_lo,
 	    (128 - FLOAT128_FRACTION_SIZE - 1), &bfrac_hi, &bfrac_lo);
-	
+
 	if (le128(bfrac_hi, bfrac_lo, afrac_hi, afrac_lo)) {
 		rshift128(afrac_hi, afrac_lo, 1, &afrac_hi, &afrac_lo);
 		aexp++;
 	}
-	
+
 	cexp = aexp - bexp + FLOAT128_BIAS - 2;
-	
+
 	cfrac_hi = div128est(afrac_hi, afrac_lo, bfrac_hi);
-	
+
 	mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_hi,
 	    &tmp_lolo /* dummy */, &tmp_hihi, &tmp_hilo, &tmp_lohi);
-	
-	/* sub192(afrac_hi, afrac_lo, 0,
+
+	/* sub192(afrac_hi, afrac_lo, 0, 
 	 *     tmp_hihi, tmp_hilo, tmp_lohi
 	 *     &rem_hihi, &rem_hilo, &rem_lohi); */
@@ -490,8 +487,8 @@
 	}
 	rem_lohi = -tmp_lohi;
-	
+
 	while ((int64_t) rem_hihi < 0) {
 		--cfrac_hi;
-		/* add192(rem_hihi, rem_hilo, rem_lohi,
+		/* add192(rem_hihi, rem_hilo, rem_lohi, 
 		 *     0, bfrac_hi, bfrac_lo,
 		 *     &rem_hihi, &rem_hilo, &rem_lohi); */
@@ -501,11 +498,11 @@
 		}
 	}
-	
+
 	cfrac_lo = div128est(rem_hilo, rem_lohi, bfrac_lo);
-	
+
 	if ((cfrac_lo & 0x3FFF) <= 4) {
 		mul128(bfrac_hi, bfrac_lo, 0x0ll, cfrac_lo,
-		    &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
-		
+	        &tmp_hihi /* dummy */, &tmp_hilo, &tmp_lohi, &tmp_lolo);
+
 		/* sub192(rem_hilo, rem_lohi, 0,
 		 *     tmp_hilo, tmp_lohi, tmp_lolo,
@@ -516,5 +513,5 @@
 		}
 		rem_lolo = -tmp_lolo;
-		
+
 		while ((int64_t) rem_hilo < 0) {
 			--cfrac_lo;
@@ -527,13 +524,13 @@
 			}
 		}
-		
+
 		cfrac_lo |= ((rem_hilo | rem_lohi | rem_lolo) != 0 );
 	}
-	
+
 	shift_out = cfrac_lo << (64 - (128 - FLOAT128_FRACTION_SIZE - 1));
 	rshift128(cfrac_hi, cfrac_lo, (128 - FLOAT128_FRACTION_SIZE - 1),
 	    &cfrac_hi, &cfrac_lo);
-	
-	result = finish_float128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
+
+	result = finishFloat128(cexp, cfrac_hi, cfrac_lo, result.parts.sign, shift_out);
 	return result;
 }
Index: uspace/lib/softfloat/generic/mul.c
===================================================================
--- uspace/lib/softfloat/generic/mul.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/mul.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -39,28 +39,27 @@
 #include <common.h>
 
-/** Multiply two single-precision floats.
+/**
+ * Multiply two single-precision floats.
  *
  * @param a First input operand.
  * @param b Second input operand.
- *
  * @return Result of multiplication.
- *
- */
-float32 mul_float32(float32 a, float32 b)
+ */
+float32 mulFloat32(float32 a, float32 b)
 {
 	float32 result;
 	uint64_t frac1, frac2;
 	int32_t exp;
-	
+
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
 	
-	if (is_float32_nan(a) || is_float32_nan(b)) {
+	if (isFloat32NaN(a) || isFloat32NaN(b)) {
 		/* TODO: fix SigNaNs */
-		if (is_float32_signan(a)) {
+		if (isFloat32SigNaN(a)) {
 			result.parts.fraction = a.parts.fraction;
 			result.parts.exp = a.parts.exp;
 			return result;
 		}
-		if (is_float32_signan(b)) { /* TODO: fix SigNaN */
+		if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */
 			result.parts.fraction = b.parts.fraction;
 			result.parts.exp = b.parts.exp;
@@ -68,12 +67,12 @@
 		}
 		/* set NaN as result */
-		result.bin = FLOAT32_NAN;
-		return result;
-	}
-	
-	if (is_float32_infinity(a)) {
-		if (is_float32_zero(b)) {
-			/* FIXME: zero * infinity */
-			result.bin = FLOAT32_NAN;
+		result.binary = FLOAT32_NAN;
+		return result;
+	}
+		
+	if (isFloat32Infinity(a)) { 
+		if (isFloat32Zero(b)) {
+			/* FIXME: zero * infinity */
+			result.binary = FLOAT32_NAN;
 			return result;
 		}
@@ -82,9 +81,9 @@
 		return result;
 	}
-	
-	if (is_float32_infinity(b)) {
-		if (is_float32_zero(a)) {
-			/* FIXME: zero * infinity */
-			result.bin = FLOAT32_NAN;
+
+	if (isFloat32Infinity(b)) { 
+		if (isFloat32Zero(a)) {
+			/* FIXME: zero * infinity */
+			result.binary = FLOAT32_NAN;
 			return result;
 		}
@@ -93,5 +92,5 @@
 		return result;
 	}
-	
+
 	/* exp is signed so we can easy detect underflow */
 	exp = a.parts.exp + b.parts.exp;
@@ -101,5 +100,5 @@
 		/* FIXME: overflow */
 		/* set infinity as result */
-		result.bin = FLOAT32_INF;
+		result.binary = FLOAT32_INF;
 		result.parts.sign = a.parts.sign ^ b.parts.sign;
 		return result;
@@ -122,5 +121,5 @@
 	
 	frac2 = b.parts.fraction;
-	
+
 	if (b.parts.exp > 0) {
 		frac2 |= FLOAT32_HIDDEN_BIT_MASK;
@@ -128,28 +127,26 @@
 		++exp;
 	}
-	
+
 	frac1 <<= 1; /* one bit space for rounding */
-	
+
 	frac1 = frac1 * frac2;
-	
+
 	/* round and return */
-	while ((exp < FLOAT32_MAX_EXPONENT) &&
-	    (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) {
+	while ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 2)))) { 
 		/* 23 bits of fraction + one more for hidden bit (all shifted 1 bit left) */
 		++exp;
 		frac1 >>= 1;
 	}
-	
+
 	/* rounding */
 	/* ++frac1; FIXME: not works - without it is ok */
 	frac1 >>= 1; /* shift off rounding space */
 	
-	if ((exp < FLOAT32_MAX_EXPONENT) &&
-	    (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
+	if ((exp < FLOAT32_MAX_EXPONENT) && (frac1 >= (1 << (FLOAT32_FRACTION_SIZE + 1)))) {
 		++exp;
 		frac1 >>= 1;
 	}
-	
-	if (exp >= FLOAT32_MAX_EXPONENT) {
+
+	if (exp >= FLOAT32_MAX_EXPONENT) {	
 		/* TODO: fix overflow */
 		/* return infinity*/
@@ -160,6 +157,6 @@
 	
 	exp -= FLOAT32_FRACTION_SIZE;
-	
-	if (exp <= FLOAT32_FRACTION_SIZE) {
+
+	if (exp <= FLOAT32_FRACTION_SIZE) { 
 		/* denormalized number */
 		frac1 >>= 1; /* denormalize */
@@ -178,31 +175,30 @@
 	result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
 	
-	return result;
+	return result;	
 }
 
-/** Multiply two double-precision floats.
+/**
+ * Multiply two double-precision floats.
  *
  * @param a First input operand.
  * @param b Second input operand.
- *
  * @return Result of multiplication.
- *
- */
-float64 mul_float64(float64 a, float64 b)
+ */
+float64 mulFloat64(float64 a, float64 b)
 {
 	float64 result;
 	uint64_t frac1, frac2;
 	int32_t exp;
-	
+
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
 	
-	if (is_float64_nan(a) || is_float64_nan(b)) {
+	if (isFloat64NaN(a) || isFloat64NaN(b)) {
 		/* TODO: fix SigNaNs */
-		if (is_float64_signan(a)) {
+		if (isFloat64SigNaN(a)) {
 			result.parts.fraction = a.parts.fraction;
 			result.parts.exp = a.parts.exp;
 			return result;
 		}
-		if (is_float64_signan(b)) { /* TODO: fix SigNaN */
+		if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */
 			result.parts.fraction = b.parts.fraction;
 			result.parts.exp = b.parts.exp;
@@ -210,12 +206,12 @@
 		}
 		/* set NaN as result */
-		result.bin = FLOAT64_NAN;
-		return result;
-	}
-	
-	if (is_float64_infinity(a)) {
-		if (is_float64_zero(b)) {
-			/* FIXME: zero * infinity */
-			result.bin = FLOAT64_NAN;
+		result.binary = FLOAT64_NAN;
+		return result;
+	}
+		
+	if (isFloat64Infinity(a)) { 
+		if (isFloat64Zero(b)) {
+			/* FIXME: zero * infinity */
+			result.binary = FLOAT64_NAN;
 			return result;
 		}
@@ -224,9 +220,9 @@
 		return result;
 	}
-	
-	if (is_float64_infinity(b)) {
-		if (is_float64_zero(a)) {
-			/* FIXME: zero * infinity */
-			result.bin = FLOAT64_NAN;
+
+	if (isFloat64Infinity(b)) { 
+		if (isFloat64Zero(a)) {
+			/* FIXME: zero * infinity */
+			result.binary = FLOAT64_NAN;
 			return result;
 		}
@@ -235,10 +231,10 @@
 		return result;
 	}
-	
+
 	/* exp is signed so we can easy detect underflow */
 	exp = a.parts.exp + b.parts.exp - FLOAT64_BIAS;
 	
 	frac1 = a.parts.fraction;
-	
+
 	if (a.parts.exp > 0) {
 		frac1 |= FLOAT64_HIDDEN_BIT_MASK;
@@ -248,5 +244,5 @@
 	
 	frac2 = b.parts.fraction;
-	
+
 	if (b.parts.exp > 0) {
 		frac2 |= FLOAT64_HIDDEN_BIT_MASK;
@@ -254,10 +250,10 @@
 		++exp;
 	}
-	
+
 	frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1);
 	frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2);
-	
+
 	mul64(frac1, frac2, &frac1, &frac2);
-	
+
 	frac1 |= (frac2 != 0);
 	if (frac1 & (0x1ll << 62)) {
@@ -265,28 +261,27 @@
 		exp--;
 	}
-	
-	result = finish_float64(exp, frac1, result.parts.sign);
+
+	result = finishFloat64(exp, frac1, result.parts.sign);
 	return result;
 }
 
-/** Multiply two quadruple-precision floats.
+/**
+ * Multiply two quadruple-precision floats.
  *
  * @param a First input operand.
  * @param b Second input operand.
- *
  * @return Result of multiplication.
- *
- */
-float128 mul_float128(float128 a, float128 b)
+ */
+float128 mulFloat128(float128 a, float128 b)
 {
 	float128 result;
 	uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
 	int32_t exp;
-	
+
 	result.parts.sign = a.parts.sign ^ b.parts.sign;
-	
-	if (is_float128_nan(a) || is_float128_nan(b)) {
+
+	if (isFloat128NaN(a) || isFloat128NaN(b)) {
 		/* TODO: fix SigNaNs */
-		if (is_float128_signan(a)) {
+		if (isFloat128SigNaN(a)) {
 			result.parts.frac_hi = a.parts.frac_hi;
 			result.parts.frac_lo = a.parts.frac_lo;
@@ -294,5 +289,5 @@
 			return result;
 		}
-		if (is_float128_signan(b)) { /* TODO: fix SigNaN */
+		if (isFloat128SigNaN(b)) { /* TODO: fix SigNaN */
 			result.parts.frac_hi = b.parts.frac_hi;
 			result.parts.frac_lo = b.parts.frac_lo;
@@ -301,14 +296,14 @@
 		}
 		/* set NaN as result */
-		result.bin.hi = FLOAT128_NAN_HI;
-		result.bin.lo = FLOAT128_NAN_LO;
-		return result;
-	}
-	
-	if (is_float128_infinity(a)) {
-		if (is_float128_zero(b)) {
-			/* FIXME: zero * infinity */
-			result.bin.hi = FLOAT128_NAN_HI;
-			result.bin.lo = FLOAT128_NAN_LO;
+		result.binary.hi = FLOAT128_NAN_HI;
+		result.binary.lo = FLOAT128_NAN_LO;
+		return result;
+	}
+
+	if (isFloat128Infinity(a)) {
+		if (isFloat128Zero(b)) {
+			/* FIXME: zero * infinity */
+			result.binary.hi = FLOAT128_NAN_HI;
+			result.binary.lo = FLOAT128_NAN_LO;
 			return result;
 		}
@@ -318,10 +313,10 @@
 		return result;
 	}
-	
-	if (is_float128_infinity(b)) {
-		if (is_float128_zero(a)) {
-			/* FIXME: zero * infinity */
-			result.bin.hi = FLOAT128_NAN_HI;
-			result.bin.lo = FLOAT128_NAN_LO;
+
+	if (isFloat128Infinity(b)) {
+		if (isFloat128Zero(a)) {
+			/* FIXME: zero * infinity */
+			result.binary.hi = FLOAT128_NAN_HI;
+			result.binary.lo = FLOAT128_NAN_LO;
 			return result;
 		}
@@ -331,22 +326,22 @@
 		return result;
 	}
-	
+
 	/* exp is signed so we can easy detect underflow */
 	exp = a.parts.exp + b.parts.exp - FLOAT128_BIAS - 1;
-	
+
 	frac1_hi = a.parts.frac_hi;
 	frac1_lo = a.parts.frac_lo;
-	
+
 	if (a.parts.exp > 0) {
 		or128(frac1_hi, frac1_lo,
-		    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
-		    &frac1_hi, &frac1_lo);
-	} else {
-		++exp;
-	}
-	
+	        FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
+	        &frac1_hi, &frac1_lo);
+	} else {
+		++exp;
+	}
+
 	frac2_hi = b.parts.frac_hi;
 	frac2_lo = b.parts.frac_lo;
-	
+
 	if (b.parts.exp > 0) {
 		or128(frac2_hi, frac2_lo,
@@ -356,8 +351,8 @@
 		++exp;
 	}
-	
+
 	lshift128(frac2_hi, frac2_lo,
 	    128 - FLOAT128_FRACTION_SIZE, &frac2_hi, &frac2_lo);
-	
+
 	tmp_hi = frac1_hi;
 	tmp_lo = frac1_lo;
@@ -366,5 +361,5 @@
 	add128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
 	frac2_hi |= (frac2_lo != 0x0ll);
-	
+
 	if ((FLOAT128_HIDDEN_BIT_MASK_HI << 1) <= frac1_hi) {
 		frac2_hi >>= 1;
@@ -375,6 +370,6 @@
 		++exp;
 	}
-	
-	result = finish_float128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
+
+	result = finishFloat128(exp, frac1_hi, frac1_lo, result.parts.sign, frac2_hi);
 	return result;
 }
Index: uspace/lib/softfloat/generic/softfloat.c
===================================================================
--- uspace/lib/softfloat/generic/softfloat.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/softfloat.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -48,609 +48,494 @@
 #include <other.h>
 
+#include <functions.h>
+
 /* Arithmetic functions */
 
 float __addsf3(float a, float b)
 {
-	float_t fa;
-	float_t fb;
-	float_t res;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if (fa.data.parts.sign != fb.data.parts.sign) {
-		if (fa.data.parts.sign) {
-			fa.data.parts.sign = 0;
-			res.data = sub_float(fb.data, fa.data);
-			
-			return res.val;
-		}
-		
-		fb.data.parts.sign = 0;
-		res.data = sub_float(fa.data, fb.data);
-		
-		return res.val;
-	}
-	
-	res.data = add_float(fa.data, fb.data);
-	return res.val;
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if (fa.parts.sign != fb.parts.sign) {
+		if (fa.parts.sign) {
+			fa.parts.sign = 0;
+			return subFloat32(fb, fa).f;
+		};
+		fb.parts.sign = 0;
+		return subFloat32(fa, fb).f;
+	}
+	return addFloat32(fa, fb).f;
 }
 
 double __adddf3(double a, double b)
 {
-	double_t da;
-	double_t db;
-	double_t res;
-	
-	da.val = a;
-	db.val = b;
-	
-	if (da.data.parts.sign != db.data.parts.sign) {
-		if (da.data.parts.sign) {
-			da.data.parts.sign = 0;
-			res.data = sub_double(db.data, da.data);
-			
-			return res.val;
-		}
-		
-		db.data.parts.sign = 0;
-		res.data = sub_double(da.data, db.data);
-		
-		return res.val;
-	}
-	
-	res.data = add_double(da.data, db.data);
-	return res.val;
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+	if (da.parts.sign != db.parts.sign) {
+		if (da.parts.sign) {
+			da.parts.sign = 0;
+			return subFloat64(db, da).d;
+		};
+		db.parts.sign = 0;
+		return subFloat64(da, db).d;
+	}
+	return addFloat64(da, db).d;
 }
 
 long double __addtf3(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	long_double_t res;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if (ta.data.parts.sign != tb.data.parts.sign) {
-		if (ta.data.parts.sign) {
-			ta.data.parts.sign = 0;
-			res.data = sub_long_double(tb.data, ta.data);
-			
-			return res.val;
-		}
-		
-		tb.data.parts.sign = 0;
-		res.data = sub_long_double(ta.data, tb.data);
-		
-		return res.val;
-	}
-	
-	res.data = add_long_double(ta.data, tb.data);
-	return res.val;
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+	if (ta.parts.sign != tb.parts.sign) {
+		if (ta.parts.sign) {
+			ta.parts.sign = 0;
+			return subFloat128(tb, ta).ld;
+		};
+		tb.parts.sign = 0;
+		return subFloat128(ta, tb).ld;
+	}
+	return addFloat128(ta, tb).ld;
 }
 
 float __subsf3(float a, float b)
 {
-	float_t fa;
-	float_t fb;
-	float_t res;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if (fa.data.parts.sign != fb.data.parts.sign) {
-		fb.data.parts.sign = !fb.data.parts.sign;
-		res.data = add_float(fa.data, fb.data);
-		
-		return res.val;
-	}
-	
-	res.data = sub_float(fa.data, fb.data);
-	return res.val;
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if (fa.parts.sign != fb.parts.sign) {
+		fb.parts.sign = !fb.parts.sign;
+		return addFloat32(fa, fb).f;
+	}
+	return subFloat32(fa, fb).f;
 }
 
 double __subdf3(double a, double b)
 {
-	double_t da;
-	double_t db;
-	double_t res;
-	
-	da.val = a;
-	db.val = b;
-	
-	if (da.data.parts.sign != db.data.parts.sign) {
-		db.data.parts.sign = !db.data.parts.sign;
-		res.data = add_double(da.data, db.data);
-		
-		return res.val;
-	}
-	
-	res.data = sub_double(da.data, db.data);
-	return res.val;
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+	if (da.parts.sign != db.parts.sign) {
+		db.parts.sign = !db.parts.sign;
+		return addFloat64(da, db).d;
+	}
+	return subFloat64(da, db).d;
 }
 
 long double __subtf3(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	long_double_t res;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if (ta.data.parts.sign != tb.data.parts.sign) {
-		tb.data.parts.sign = !tb.data.parts.sign;
-		res.data = add_long_double(ta.data, tb.data);
-		
-		return res.val;
-	}
-	
-	res.data = sub_long_double(ta.data, tb.data);
-	return res.val;
-}
-
-float __mulsf3(float a, float b)
-{
-	float_t fa;
-	float_t fb;
-	float_t res;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	res.data = mul_float(fa.data, fb.data);
-	return res.val;
-}
-
-double __muldf3(double a, double b)
-{
-	double_t da;
-	double_t db;
-	double_t res;
-	
-	da.val = a;
-	db.val = b;
-	
-	res.data = mul_double(da.data, db.data);
-	return res.val;
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+	if (ta.parts.sign != tb.parts.sign) {
+		tb.parts.sign = !tb.parts.sign;
+		return addFloat128(ta, tb).ld;
+	}
+	return subFloat128(ta, tb).ld;
+}
+
+float __mulsf3(float a, float b) 
+{
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	return 	mulFloat32(fa, fb).f;
+}
+
+double __muldf3(double a, double b) 
+{
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+	return 	mulFloat64(da, db).d;
 }
 
 long double __multf3(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	long_double_t res;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	res.data = mul_long_double(ta.data, tb.data);
-	return res.val;
-}
-
-float __divsf3(float a, float b)
-{
-	float_t fa;
-	float_t fb;
-	float_t res;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	res.data = div_float(fa.data, fb.data);
-	return res.val;
-}
-
-double __divdf3(double a, double b)
-{
-	double_t da;
-	double_t db;
-	double_t res;
-	
-	da.val = a;
-	db.val = b;
-	
-	res.data = div_double(da.data, db.data);
-	return res.val;
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+	return 	mulFloat128(ta, tb).ld;
+}
+
+float __divsf3(float a, float b) 
+{
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	return 	divFloat32(fa, fb).f;
+}
+
+double __divdf3(double a, double b) 
+{
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+	return 	divFloat64(da, db).d;
 }
 
 long double __divtf3(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	long_double_t res;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	res.data = div_long_double(ta.data, tb.data);
-	return res.val;
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+	return 	divFloat128(ta, tb).ld;
 }
 
 float __negsf2(float a)
 {
-	float_t fa;
-	
-	fa.val = a;
-	fa.data.parts.sign = !fa.data.parts.sign;
-	
-	return fa.val;
+	float32 fa;
+	fa.f = a;
+	fa.parts.sign = !fa.parts.sign;
+	return fa.f;
 }
 
 double __negdf2(double a)
 {
-	double_t da;
-	
-	da.val = a;
-	da.data.parts.sign = !da.data.parts.sign;
-	
-	return da.val;
+	float64 da;
+	da.d = a;
+	da.parts.sign = !da.parts.sign;
+	return da.d;
 }
 
 long double __negtf2(long double a)
 {
-	long_double_t ta;
-	
-	ta.val = a;
-	ta.data.parts.sign = !ta.data.parts.sign;
-	
-	return ta.val;
+	float128 ta;
+	ta.ld = a;
+	ta.parts.sign = !ta.parts.sign;
+	return ta.ld;
 }
 
 /* Conversion functions */
 
-double __extendsfdf2(float a)
-{
-	float_t fa;
-	double_t res;
-	
-	fa.val = a;
-	res.data = float_to_double(fa.data);
-	
-	return res.val;
+double __extendsfdf2(float a) 
+{
+	float32 fa;
+	fa.f = a;
+	return convertFloat32ToFloat64(fa).d;
 }
 
 long double __extendsftf2(float a)
 {
-	float_t fa;
-	long_double_t res;
-	
-	fa.val = a;
-	res.data = float_to_long_double(fa.data);
-	
-	return res.val;
+	float32 fa;
+	fa.f = a;
+	return convertFloat32ToFloat128(fa).ld;
 }
 
 long double __extenddftf2(double a)
 {
-	double_t da;
-	long_double_t res;
-	
-	da.val = a;
-	res.data = double_to_long_double(da.data);
-	
-	return res.val;
-}
-
-float __truncdfsf2(double a)
-{
-	double_t da;
-	float_t res;
-	
-	da.val = a;
-	res.data = double_to_float(da.data);
-	
-	return res.val;
+	float64 da;
+	da.d = a;
+	return convertFloat64ToFloat128(da).ld;
+}
+
+float __truncdfsf2(double a) 
+{
+	float64 da;
+	da.d = a;
+	return convertFloat64ToFloat32(da).f;
 }
 
 float __trunctfsf2(long double a)
 {
-	long_double_t ta;
-	float_t res;
-	
-	ta.val = a;
-	res.data = long_double_to_float(ta.data);
-	
-	return res.val;
+	float128 ta;
+	ta.ld = a;
+	return convertFloat128ToFloat32(ta).f;
 }
 
 double __trunctfdf2(long double a)
 {
-	long_double_t ta;
-	double_t res;
-	
-	ta.val = a;
-	res.data = long_double_to_double(ta.data);
-	
-	return res.val;
+	float128 ta;
+	ta.ld = a;
+	return convertFloat128ToFloat64(ta).d;
 }
 
 int __fixsfsi(float a)
 {
-	float_t fa;
-	
-	fa.val = a;
-	return float_to_int(fa.data);
+	float32 fa;
+	fa.f = a;
+	
+	return float32_to_int(fa);
 }
 
 int __fixdfsi(double a)
 {
-	double_t da;
-	
-	da.val = a;
-	return double_to_int(da.data);
+	float64 da;
+	da.d = a;
+	
+	return float64_to_int(da);
 }
 
 int __fixtfsi(long double a)
 {
-	long_double_t ta;
-	
-	ta.val = a;
-	return long_double_to_int(ta.data);
+	float128 ta;
+	ta.ld = a;
+
+	return float128_to_int(ta);
 }
  
 long __fixsfdi(float a)
 {
-	float_t fa;
-	
-	fa.val = a;
-	return float_to_long(fa.data);
+	float32 fa;
+	fa.f = a;
+	
+	return float32_to_long(fa);
 }
 
 long __fixdfdi(double a)
 {
-	double_t da;
-	
-	da.val = a;
-	return double_to_long(da.data);
+	float64 da;
+	da.d = a;
+	
+	return float64_to_long(da);
 }
 
 long __fixtfdi(long double a)
 {
-	long_double_t ta;
-	
-	ta.val = a;
-	return long_double_to_long(ta.data);
+	float128 ta;
+	ta.ld = a;
+
+	return float128_to_long(ta);
 }
  
 long long __fixsfti(float a)
 {
-	float_t fa;
-	
-	fa.val = a;
-	return float_to_llong(fa.data);
+	float32 fa;
+	fa.f = a;
+	
+	return float32_to_longlong(fa);
 }
 
 long long __fixdfti(double a)
 {
-	double_t da;
-	
-	da.val = a;
-	return double_to_llong(da.data);
+	float64 da;
+	da.d = a;
+	
+	return float64_to_longlong(da);
 }
 
 long long __fixtfti(long double a)
 {
-	long_double_t ta;
-	
-	ta.val = a;
-	return long_double_to_llong(ta.data);
+	float128 ta;
+	ta.ld = a;
+
+	return float128_to_longlong(ta);
 }
 
 unsigned int __fixunssfsi(float a)
 {
-	float_t fa;
-	
-	fa.val = a;
-	return float_to_uint(fa.data);
+	float32 fa;
+	fa.f = a;
+	
+	return float32_to_uint(fa);
 }
 
 unsigned int __fixunsdfsi(double a)
 {
-	double_t da;
-	
-	da.val = a;
-	return double_to_uint(da.data);
+	float64 da;
+	da.d = a;
+	
+	return float64_to_uint(da);
 }
 
 unsigned int __fixunstfsi(long double a)
 {
-	long_double_t ta;
-	
-	ta.val = a;
-	return long_double_to_uint(ta.data);
+	float128 ta;
+	ta.ld = a;
+
+	return float128_to_uint(ta);
 }
  
 unsigned long __fixunssfdi(float a)
 {
-	float_t fa;
-	
-	fa.val = a;
-	return float_to_ulong(fa.data);
+	float32 fa;
+	fa.f = a;
+	
+	return float32_to_ulong(fa);
 }
 
 unsigned long __fixunsdfdi(double a)
 {
-	double_t da;
-	
-	da.val = a;
-	return double_to_ulong(da.data);
+	float64 da;
+	da.d = a;
+	
+	return float64_to_ulong(da);
 }
 
 unsigned long __fixunstfdi(long double a)
 {
-	long_double_t ta;
-	
-	ta.val = a;
-	return long_double_to_ulong(ta.data);
+	float128 ta;
+	ta.ld = a;
+
+	return float128_to_ulong(ta);
 }
  
 unsigned long long __fixunssfti(float a)
 {
-	float_t fa;
-	
-	fa.val = a;
-	return float_to_ullong(fa.data);
+	float32 fa;
+	fa.f = a;
+	
+	return float32_to_ulonglong(fa);
 }
 
 unsigned long long __fixunsdfti(double a)
 {
-	double_t da;
-	
-	da.val = a;
-	return double_to_ullong(da.data);
+	float64 da;
+	da.d = a;
+	
+	return float64_to_ulonglong(da);
 }
 
 unsigned long long __fixunstfti(long double a)
 {
-	long_double_t ta;
-	
-	ta.val = a;
-	return long_double_to_ullong(ta.data);
+	float128 ta;
+	ta.ld = a;
+
+	return float128_to_ulonglong(ta);
 }
  
 float __floatsisf(int i)
 {
-	float_t res;
-	
-	res.data = int_to_float(i);
-	return res.val;
+	float32 fa;
+	
+	fa = int_to_float32(i);
+	return fa.f;
 }
 
 double __floatsidf(int i)
 {
-	double_t res;
-	
-	res.data = int_to_double(i);
-	return res.val;
+	float64 da;
+	
+	da = int_to_float64(i);
+	return da.d;
 }
 
 long double __floatsitf(int i)
 {
-	long_double_t res;
-	
-	res.data = int_to_long_double(i);
-	return res.val;
+	float128 ta;
+
+	ta = int_to_float128(i);
+	return ta.ld;
 }
  
 float __floatdisf(long i)
 {
-	float_t res;
-	
-	res.data = long_to_float(i);
-	return res.val;
+	float32 fa;
+	
+	fa = long_to_float32(i);
+	return fa.f;
 }
 
 double __floatdidf(long i)
 {
-	double_t res;
-	
-	res.data = long_to_double(i);
-	return res.val;
+	float64 da;
+	
+	da = long_to_float64(i);
+	return da.d;
 }
 
 long double __floatditf(long i)
 {
-	long_double_t res;
-	
-	res.data = long_to_long_double(i);
-	return res.val;
-}
-
+	float128 ta;
+
+	ta = long_to_float128(i);
+	return ta.ld;
+}
+ 
 float __floattisf(long long i)
 {
-	float_t res;
-	
-	res.data = llong_to_float(i);
-	return res.val;
+	float32 fa;
+	
+	fa = longlong_to_float32(i);
+	return fa.f;
 }
 
 double __floattidf(long long i)
 {
-	double_t res;
-	
-	res.data = llong_to_double(i);
-	return res.val;
+	float64 da;
+	
+	da = longlong_to_float64(i);
+	return da.d;
 }
 
 long double __floattitf(long long i)
 {
-	long_double_t res;
-	
-	res.data = llong_to_long_double(i);
-	return res.val;
+	float128 ta;
+
+	ta = longlong_to_float128(i);
+	return ta.ld;
 }
 
 float __floatunsisf(unsigned int i)
 {
-	float_t res;
-	
-	res.data = uint_to_float(i);
-	return res.val;
+	float32 fa;
+	
+	fa = uint_to_float32(i);
+	return fa.f;
 }
 
 double __floatunsidf(unsigned int i)
 {
-	double_t res;
-	
-	res.data = uint_to_double(i);
-	return res.val;
+	float64 da;
+	
+	da = uint_to_float64(i);
+	return da.d;
 }
 
 long double __floatunsitf(unsigned int i)
 {
-	long_double_t res;
-	
-	res.data = uint_to_long_double(i);
-	return res.val;
+	float128 ta;
+
+	ta = uint_to_float128(i);
+	return ta.ld;
 }
  
 float __floatundisf(unsigned long i)
 {
-	float_t res;
-	
-	res.data = ulong_to_float(i);
-	return res.val;
+	float32 fa;
+	
+	fa = ulong_to_float32(i);
+	return fa.f;
 }
 
 double __floatundidf(unsigned long i)
 {
-	double_t res;
-	
-	res.data = ulong_to_double(i);
-	return res.val;
+	float64 da;
+	
+	da = ulong_to_float64(i);
+	return da.d;
 }
 
 long double __floatunditf(unsigned long i)
 {
-	long_double_t res;
-	
-	res.data = ulong_to_long_double(i);
-	return res.val;
+	float128 ta;
+
+	ta = ulong_to_float128(i);
+	return ta.ld;
 }
  
 float __floatuntisf(unsigned long long i)
 {
-	float_t res;
-	
-	res.data = ullong_to_float(i);
-	return res.val;
+	float32 fa;
+	
+	fa = ulonglong_to_float32(i);
+	return fa.f;
 }
 
 double __floatuntidf(unsigned long long i)
 {
-	double_t res;
-	
-	res.data = ullong_to_double(i);
-	return res.val;
+	float64 da;
+	
+	da = ulonglong_to_float64(i);
+	return da.d;
 }
 
 long double __floatuntitf(unsigned long long i)
 {
-	long_double_t res;
-	
-	res.data = ullong_to_long_double(i);
-	return res.val;
+	float128 ta;
+
+	ta = ulonglong_to_float128(i);
+	return ta.ld;
 }
 
@@ -659,21 +544,20 @@
 int __cmpsf2(float a, float b) 
 {
-	float_t fa;
-	float_t fb;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
-		/* no special constant for unordered - maybe signaled? */
-		return 1;
-	}
-	
-	if (is_float_eq(fa.data, fb.data))
-		return 0;
-	
-	if (is_float_lt(fa.data, fb.data))
-		return -1;
-	
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+
+	if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
+		return 1; /* no special constant for unordered - maybe signaled? */
+	}
+	
+	if (isFloat32eq(fa, fb)) {
+		return 0;
+	}
+	
+	if (isFloat32lt(fa, fb)) {
+		return -1;
+	}
+
 	return 1;
 }
@@ -681,21 +565,20 @@
 int __cmpdf2(double a, double b)
 {
-	double_t da;
-	double_t db;
-	
-	da.val = a;
-	db.val = b;
-	
-	if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
-		/* no special constant for unordered - maybe signaled? */
-		return 1;
-	}
-	
-	if (is_double_eq(da.data, db.data))
-		return 0;
-	
-	if (is_double_lt(da.data, db.data))
-		return -1;
-	
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+
+	if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
+		return 1; /* no special constant for unordered - maybe signaled? */
+	}
+
+	if (isFloat64eq(da, db)) {
+		return 0;
+	}
+
+	if (isFloat64lt(da, db)) {
+		return -1;
+	}
+
 	return 1;
 }
@@ -703,106 +586,84 @@
 int __cmptf2(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
-		/* no special constant for unordered - maybe signaled? */
-		return 1;
-	}
-	
-	if (is_long_double_eq(ta.data, tb.data))
-		return 0;
-	
-	if (is_long_double_lt(ta.data, tb.data))
-		return -1;
-	
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		return 1; /* no special constant for unordered - maybe signaled? */
+	}
+
+	if (isFloat128eq(ta, tb)) {
+		return 0;
+	}
+
+	if (isFloat128lt(ta, tb)) {
+		return -1;
+	}
+
 	return 1;
 }
 
-int __unordsf2(float a, float b)
-{
-	float_t fa;
-	float_t fb;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	return ((is_float_nan(fa.data)) || (is_float_nan(fb.data)));
+int __unordsf2(float a, float b) 
+{
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	return ((isFloat32NaN(fa)) || (isFloat32NaN(fb)));
 }
 
 int __unorddf2(double a, double b)
 {
-	double_t da;
-	double_t db;
-	
-	da.val = a;
-	db.val = b;
-	
-	return ((is_double_nan(da.data)) || (is_double_nan(db.data)));
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+	return ((isFloat64NaN(da)) || (isFloat64NaN(db)));
 }
 
 int __unordtf2(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	return ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)));
-}
-
-int __eqsf2(float a, float b)
-{
-	float_t fa;
-	float_t fb;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	return is_float_eq(fa.data, fb.data) - 1;
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+	return ((isFloat128NaN(ta)) || (isFloat128NaN(tb)));
+}
+
+int __eqsf2(float a, float b) 
+{
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+	if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+	return isFloat32eq(fa, fb) - 1;
 }
 
 int __eqdf2(double a, double b)
 {
-	double_t da;
-	double_t db;
-	
-	da.val = a;
-	db.val = b;
-	
-	if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	return is_double_eq(da.data, db.data) - 1;
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+	if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+	return isFloat64eq(da, db) - 1;
 }
 
 int __eqtf2(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	return is_long_double_eq(ta.data, tb.data) - 1;
-}
-
-int __nesf2(float a, float b)
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+	return isFloat128eq(ta, tb) - 1;
+}
+
+int __nesf2(float a, float b) 
 {
 	/* strange behavior, but it was in gcc documentation */
@@ -824,20 +685,20 @@
 int __gesf2(float a, float b)
 {
-	float_t fa;
-	float_t fb;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
-		// TODO: sigNaNs
-		return -1;
-	}
-	
-	if (is_float_eq(fa.data, fb.data))
-		return 0;
-	
-	if (is_float_gt(fa.data, fb.data))
-		return 1;
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+
+	if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
+		/* TODO: sigNaNs */
+		return -1;
+	}
+	
+	if (isFloat32eq(fa, fb)) {
+		return 0;
+	}
+	
+	if (isFloat32gt(fa, fb)) {
+		return 1;
+	}
 	
 	return -1;
@@ -846,21 +707,21 @@
 int __gedf2(double a, double b)
 {
-	double_t da;
-	double_t db;
-	
-	da.val = a;
-	db.val = b;
-	
-	if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
-		// TODO: sigNaNs
-		return -1;
-	}
-	
-	if (is_double_eq(da.data, db.data))
-		return 0;
-	
-	if (is_double_gt(da.data, db.data))
-		return 1;
-	
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+
+	if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
+		/* TODO: sigNaNs */
+		return -1;
+	}
+
+	if (isFloat64eq(da, db)) {
+		return 0;
+	}
+
+	if (isFloat64gt(da, db)) {
+		return 1;
+	}
+
 	return -1;
 }
@@ -868,21 +729,21 @@
 int __getf2(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
-		// TODO: sigNaNs
-		return -1;
-	}
-	
-	if (is_long_double_eq(ta.data, tb.data))
-		return 0;
-	
-	if (is_long_double_gt(ta.data, tb.data))
-		return 1;
-	
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		/* TODO: sigNaNs */
+		return -1;
+	}
+
+	if (isFloat128eq(ta, tb)) {
+		return 0;
+	}
+
+	if (isFloat128gt(ta, tb)) {
+		return 1;
+	}
+
 	return -1;
 }
@@ -890,18 +751,17 @@
 int __ltsf2(float a, float b)
 {
-	float_t fa;
-	float_t fb;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	if (is_float_lt(fa.data, fb.data))
-		return -1;
-	
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+
+	if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+
+	if (isFloat32lt(fa, fb)) {
+		return -1;
+	}
+
 	return 0;
 }
@@ -909,18 +769,17 @@
 int __ltdf2(double a, double b)
 {
-	double_t da;
-	double_t db;
-	
-	da.val = a;
-	db.val = b;
-	
-	if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	if (is_double_lt(da.data, db.data))
-		return -1;
-	
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+
+	if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+
+	if (isFloat64lt(da, db)) {
+		return -1;
+	}
+
 	return 0;
 }
@@ -928,18 +787,17 @@
 int __lttf2(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	if (is_long_double_lt(ta.data, tb.data))
-		return -1;
-	
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+
+	if (isFloat128lt(ta, tb)) {
+		return -1;
+	}
+
 	return 0;
 }
@@ -947,20 +805,20 @@
 int __lesf2(float a, float b)
 {
-	float_t fa;
-	float_t fb;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	if (is_float_eq(fa.data, fb.data))
-		return 0;
-	
-	if (is_float_lt(fa.data, fb.data))
-		return -1;
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+
+	if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+	
+	if (isFloat32eq(fa, fb)) {
+		return 0;
+	}
+	
+	if (isFloat32lt(fa, fb)) {
+		return -1;
+	}
 	
 	return 1;
@@ -969,21 +827,21 @@
 int __ledf2(double a, double b)
 {
-	double_t da;
-	double_t db;
-	
-	da.val = a;
-	db.val = b;
-	
-	if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	if (is_double_eq(da.data, db.data))
-		return 0;
-	
-	if (is_double_lt(da.data, db.data))
-		return -1;
-	
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+
+	if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+
+	if (isFloat64eq(da, db)) {
+		return 0;
+	}
+
+	if (isFloat64lt(da, db)) {
+		return -1;
+	}
+
 	return 1;
 }
@@ -991,21 +849,21 @@
 int __letf2(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
-		// TODO: sigNaNs
-		return 1;
-	}
-	
-	if (is_long_double_eq(ta.data, tb.data))
-		return 0;
-	
-	if (is_long_double_lt(ta.data, tb.data))
-		return -1;
-	
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		/* TODO: sigNaNs */
+		return 1;
+	}
+
+	if (isFloat128eq(ta, tb)) {
+		return 0;
+	}
+
+	if (isFloat128lt(ta, tb)) {
+		return -1;
+	}
+
 	return 1;
 }
@@ -1013,18 +871,17 @@
 int __gtsf2(float a, float b)
 {
-	float_t fa;
-	float_t fb;
-	
-	fa.val = a;
-	fb.val = b;
-	
-	if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
-		// TODO: sigNaNs
-		return -1;
-	}
-	
-	if (is_float_gt(fa.data, fb.data))
-		return 1;
-	
+	float32 fa, fb;
+	fa.f = a;
+	fb.f = b;
+
+	if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
+		/* TODO: sigNaNs */
+		return -1;
+	}
+
+	if (isFloat32gt(fa, fb)) {
+		return 1;
+	}
+
 	return 0;
 }
@@ -1032,18 +889,17 @@
 int __gtdf2(double a, double b)
 {
-	double_t da;
-	double_t db;
-	
-	da.val = a;
-	db.val = b;
-	
-	if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
-		// TODO: sigNaNs
-		return -1;
-	}
-	
-	if (is_double_gt(da.data, db.data))
-		return 1;
-	
+	float64 da, db;
+	da.d = a;
+	db.d = b;
+
+	if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
+		/* TODO: sigNaNs */
+		return -1;
+	}
+
+	if (isFloat64gt(da, db)) {
+		return 1;
+	}
+
 	return 0;
 }
@@ -1051,21 +907,24 @@
 int __gttf2(long double a, long double b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = a;
-	tb.val = b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
-		// TODO: sigNaNs
-		return -1;
-	}
-	
-	if (is_long_double_gt(ta.data, tb.data))
-		return 1;
-	
+	float128 ta, tb;
+	ta.ld = a;
+	tb.ld = b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		/* TODO: sigNaNs */
+		return -1;
+	}
+
+	if (isFloat128gt(ta, tb)) {
+		return 1;
+	}
+
 	return 0;
 }
 
+
+
+#ifdef SPARC_SOFTFLOAT
+
 /* SPARC quadruple-precision wrappers */
 
@@ -1157,19 +1016,20 @@
 int _Qp_cmp(long double *a, long double *b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = *a;
-	tb.val = *b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
+	float128 ta, tb;
+	ta.ld = *a;
+	tb.ld = *b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
 		return 3;
-	
-	if (is_long_double_eq(ta.data, tb.data))
-		return 0;
-	
-	if (is_long_double_lt(ta.data, tb.data))
-		return 1;
-	
+	}
+
+	if (isFloat128eq(ta, tb)) {
+		return 0;
+	}
+
+	if (isFloat128lt(ta, tb)) {
+		return 1;
+	}
+
 	return 2;
 }
@@ -1183,87 +1043,81 @@
 int _Qp_feq(long double *a, long double *b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = *a;
-	tb.val = *b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
-		return 0;
-	
-	return is_long_double_eq(ta.data, tb.data);
+	float128 ta, tb;
+	ta.ld = *a;
+	tb.ld = *b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		return 0;
+	}
+
+	return isFloat128eq(ta, tb);
 }
 
 int _Qp_fge(long double *a, long double *b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = *a;
-	tb.val = *b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
-		return 0;
-	
-	return is_long_double_eq(ta.data, tb.data) ||
-	    is_long_double_gt(ta.data, tb.data);
+	float128 ta, tb;
+	ta.ld = *a;
+	tb.ld = *b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		return 0;
+	}
+
+	return isFloat128eq(ta, tb) || isFloat128gt(ta, tb);
 }
 
 int _Qp_fgt(long double *a, long double *b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = *a;
-	tb.val = *b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
-		return 0;
-	
-	return is_long_double_gt(ta.data, tb.data);
+	float128 ta, tb;
+	ta.ld = *a;
+	tb.ld = *b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		return 0;
+	}
+
+	return isFloat128gt(ta, tb);
 }
 
 int _Qp_fle(long double*a, long double *b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = *a;
-	tb.val = *b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
-		return 0;
-	
-	return is_long_double_eq(ta.data, tb.data) ||
-	    is_long_double_lt(ta.data, tb.data);
+	float128 ta, tb;
+	ta.ld = *a;
+	tb.ld = *b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		return 0;
+	}
+
+	return isFloat128eq(ta, tb) || isFloat128lt(ta, tb);
 }
 
 int _Qp_flt(long double *a, long double *b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = *a;
-	tb.val = *b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
-		return 0;
-	
-	return is_long_double_lt(ta.data, tb.data);
+	float128 ta, tb;
+	ta.ld = *a;
+	tb.ld = *b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		return 0;
+	}
+
+	return isFloat128lt(ta, tb);
 }
 
 int _Qp_fne(long double *a, long double *b)
 {
-	long_double_t ta;
-	long_double_t tb;
-	
-	ta.val = *a;
-	tb.val = *b;
-	
-	if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
-		return 0;
-	
-	return !is_long_double_eq(ta.data, tb.data);
-}
+	float128 ta, tb;
+	ta.ld = *a;
+	tb.ld = *b;
+
+	if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
+		return 1;
+	}
+
+	return !isFloat128eq(ta, tb);
+}
+
+#endif
 
 /** @}
Index: uspace/lib/softfloat/generic/sub.c
===================================================================
--- uspace/lib/softfloat/generic/sub.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/generic/sub.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -39,38 +39,34 @@
 #include <common.h>
 
-/** Subtract two single-precision floats with the same sign.
+/**
+ * Subtract two single-precision floats with the same signs.
  *
  * @param a First input operand.
  * @param b Second input operand.
- *
  * @return Result of substraction.
- *
- */
-float32 sub_float32(float32 a, float32 b)
+ */
+float32 subFloat32(float32 a, float32 b)
 {
 	int expdiff;
 	uint32_t exp1, exp2, frac1, frac2;
 	float32 result;
-	
-	result.bin = 0;
+
+	result.f = 0;
 	
 	expdiff = a.parts.exp - b.parts.exp;
-	if ((expdiff < 0 ) || ((expdiff == 0) &&
-	    (a.parts.fraction < b.parts.fraction))) {
-		if (is_float32_nan(b)) {
-			if (is_float32_signan(b)) {
-				// TODO: fix SigNaN
-			}
-			
-			return b;
-		}
-		
-		if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
-			/* num -(+-inf) = -+inf */
-			b.parts.sign = !b.parts.sign;
-			return b;
-		}
-		
-		result.parts.sign = !a.parts.sign;
+	if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
+		if (isFloat32NaN(b)) {
+			/* TODO: fix SigNaN */
+			if (isFloat32SigNaN(b)) {
+			}
+			return b;
+		}
+		
+		if (b.parts.exp == FLOAT32_MAX_EXPONENT) { 
+			b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
+			return b;
+		}
+		
+		result.parts.sign = !a.parts.sign; 
 		
 		frac1 = b.parts.fraction;
@@ -80,20 +76,18 @@
 		expdiff *= -1;
 	} else {
-		if (is_float32_nan(a)) {
-			if ((is_float32_signan(a)) || (is_float32_signan(b))) {
-				// TODO: fix SigNaN
-			}
-			
-			return a;
-		}
-		
-		if (a.parts.exp == FLOAT32_MAX_EXPONENT) {
+		if (isFloat32NaN(a)) {
+			/* TODO: fix SigNaN */
+			if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) {
+			}
+			return a;
+		}
+		
+		if (a.parts.exp == FLOAT32_MAX_EXPONENT) { 
 			if (b.parts.exp == FLOAT32_MAX_EXPONENT) {
 				/* inf - inf => nan */
-				// TODO: fix exception
-				result.bin = FLOAT32_NAN;
+				/* TODO: fix exception */
+				result.binary = FLOAT32_NAN;
 				return result;
 			}
-			
 			return a;
 		}
@@ -104,5 +98,5 @@
 		exp1 = a.parts.exp;
 		frac2 = b.parts.fraction;
-		exp2 = b.parts.exp;
+		exp2 = b.parts.exp;	
 	}
 	
@@ -111,18 +105,17 @@
 		result.parts.fraction = frac1 - frac2;
 		if (result.parts.fraction > frac1) {
-			// TODO: underflow exception
+			/* TODO: underflow exception */
 			return result;
 		}
-		
 		result.parts.exp = 0;
 		return result;
 	}
-	
+
 	/* add hidden bit */
-	frac1 |= FLOAT32_HIDDEN_BIT_MASK;
+	frac1 |= FLOAT32_HIDDEN_BIT_MASK; 
 	
 	if (exp2 == 0) {
 		/* denormalized */
-		--expdiff;
+		--expdiff;	
 	} else {
 		/* normalized */
@@ -134,9 +127,10 @@
 	frac2 <<= 6;
 	
-	if (expdiff > FLOAT32_FRACTION_SIZE + 1)
+	if (expdiff > FLOAT32_FRACTION_SIZE + 1) {
 		goto done;
+	}
 	
 	frac1 = frac1 - (frac2 >> expdiff);
-	
+
 done:
 	/* TODO: find first nonzero digit and shift result and detect possibly underflow */
@@ -149,5 +143,5 @@
 	/* rounding - if first bit after fraction is set then round up */
 	frac1 += 0x20;
-	
+
 	if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
 		++exp1;
@@ -156,5 +150,5 @@
 	
 	/* Clear hidden bit and shift */
-	result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK));
+	result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); 
 	result.parts.exp = exp1;
 	
@@ -162,13 +156,12 @@
 }
 
-/** Subtract two double-precision floats with the same sign.
+/**
+ * Subtract two double-precision floats with the same signs.
  *
  * @param a First input operand.
  * @param b Second input operand.
- *
  * @return Result of substraction.
- *
- */
-float64 sub_float64(float64 a, float64 b)
+ */
+float64 subFloat64(float64 a, float64 b)
 {
 	int expdiff;
@@ -176,25 +169,22 @@
 	uint64_t frac1, frac2;
 	float64 result;
-	
-	result.bin = 0;
+
+	result.d = 0;
 	
 	expdiff = a.parts.exp - b.parts.exp;
-	if ((expdiff < 0 ) ||
-	    ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
-		if (is_float64_nan(b)) {
-			if (is_float64_signan(b)) {
-				// TODO: fix SigNaN
-			}
-			
-			return b;
-		}
-		
-		if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
-			/* num -(+-inf) = -+inf */
-			b.parts.sign = !b.parts.sign;
-			return b;
-		}
-		
-		result.parts.sign = !a.parts.sign;
+	if ((expdiff < 0 ) || ((expdiff == 0) && (a.parts.fraction < b.parts.fraction))) {
+		if (isFloat64NaN(b)) {
+			/* TODO: fix SigNaN */
+			if (isFloat64SigNaN(b)) {
+			}
+			return b;
+		}
+		
+		if (b.parts.exp == FLOAT64_MAX_EXPONENT) { 
+			b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
+			return b;
+		}
+		
+		result.parts.sign = !a.parts.sign; 
 		
 		frac1 = b.parts.fraction;
@@ -204,20 +194,18 @@
 		expdiff *= -1;
 	} else {
-		if (is_float64_nan(a)) {
-			if (is_float64_signan(a) || is_float64_signan(b)) {
-				// TODO: fix SigNaN
-			}
-			
-			return a;
-		}
-		
-		if (a.parts.exp == FLOAT64_MAX_EXPONENT) {
+		if (isFloat64NaN(a)) {
+			/* TODO: fix SigNaN */
+			if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) {
+			}
+			return a;
+		}
+		
+		if (a.parts.exp == FLOAT64_MAX_EXPONENT) { 
 			if (b.parts.exp == FLOAT64_MAX_EXPONENT) {
 				/* inf - inf => nan */
-				// TODO: fix exception
-				result.bin = FLOAT64_NAN;
+				/* TODO: fix exception */
+				result.binary = FLOAT64_NAN;
 				return result;
 			}
-			
 			return a;
 		}
@@ -228,5 +216,5 @@
 		exp1 = a.parts.exp;
 		frac2 = b.parts.fraction;
-		exp2 = b.parts.exp;
+		exp2 = b.parts.exp;	
 	}
 	
@@ -235,18 +223,17 @@
 		result.parts.fraction = frac1 - frac2;
 		if (result.parts.fraction > frac1) {
-			// TODO: underflow exception
+			/* TODO: underflow exception */
 			return result;
 		}
-		
 		result.parts.exp = 0;
 		return result;
 	}
-	
+
 	/* add hidden bit */
-	frac1 |= FLOAT64_HIDDEN_BIT_MASK;
+	frac1 |= FLOAT64_HIDDEN_BIT_MASK; 
 	
 	if (exp2 == 0) {
 		/* denormalized */
-		--expdiff;
+		--expdiff;	
 	} else {
 		/* normalized */
@@ -258,9 +245,10 @@
 	frac2 <<= 6;
 	
-	if (expdiff > FLOAT64_FRACTION_SIZE + 1)
+	if (expdiff > FLOAT64_FRACTION_SIZE + 1) {
 		goto done;
+	}
 	
 	frac1 = frac1 - (frac2 >> expdiff);
-	
+
 done:
 	/* TODO: find first nonzero digit and shift result and detect possibly underflow */
@@ -273,5 +261,5 @@
 	/* rounding - if first bit after fraction is set then round up */
 	frac1 += 0x20;
-	
+
 	if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) {
 		++exp1;
@@ -280,5 +268,5 @@
 	
 	/* Clear hidden bit and shift */
-	result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK));
+	result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); 
 	result.parts.exp = exp1;
 	
@@ -286,13 +274,12 @@
 }
 
-/** Subtract two quadruple-precision floats with the same sign.
+/**
+ * Subtract two quadruple-precision floats with the same signs.
  *
  * @param a First input operand.
  * @param b Second input operand.
- *
  * @return Result of substraction.
- *
- */
-float128 sub_float128(float128 a, float128 b)
+ */
+float128 subFloat128(float128 a, float128 b)
 {
 	int expdiff;
@@ -300,27 +287,25 @@
 	uint64_t frac1_hi, frac1_lo, frac2_hi, frac2_lo, tmp_hi, tmp_lo;
 	float128 result;
-	
-	result.bin.hi = 0;
-	result.bin.lo = 0;
-	
+
+	result.binary.hi = 0;
+	result.binary.lo = 0;
+
 	expdiff = a.parts.exp - b.parts.exp;
 	if ((expdiff < 0 ) || ((expdiff == 0) &&
 	    lt128(a.parts.frac_hi, a.parts.frac_lo, b.parts.frac_hi, b.parts.frac_lo))) {
-		if (is_float128_nan(b)) {
-			if (is_float128_signan(b)) {
-				// TODO: fix SigNaN
-			}
-			
-			return b;
-		}
-		
+		if (isFloat128NaN(b)) {
+			/* TODO: fix SigNaN */
+			if (isFloat128SigNaN(b)) {
+			}
+			return b;
+		}
+
 		if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
-			/* num -(+-inf) = -+inf */
-			b.parts.sign = !b.parts.sign;
-			return b;
-		}
-		
+			b.parts.sign = !b.parts.sign; /* num -(+-inf) = -+inf */
+			return b;
+		}
+
 		result.parts.sign = !a.parts.sign;
-		
+
 		frac1_hi = b.parts.frac_hi;
 		frac1_lo = b.parts.frac_lo;
@@ -331,25 +316,24 @@
 		expdiff *= -1;
 	} else {
-		if (is_float128_nan(a)) {
-			if (is_float128_signan(a) || is_float128_signan(b)) {
-				// TODO: fix SigNaN
-			}
-			
-			return a;
-		}
-		
+		if (isFloat128NaN(a)) {
+			/* TODO: fix SigNaN */
+			if (isFloat128SigNaN(a) || isFloat128SigNaN(b)) {
+			}
+			return a;
+		}
+
 		if (a.parts.exp == FLOAT128_MAX_EXPONENT) {
 			if (b.parts.exp == FLOAT128_MAX_EXPONENT) {
 				/* inf - inf => nan */
-				// TODO: fix exception
-				result.bin.hi = FLOAT128_NAN_HI;
-				result.bin.lo = FLOAT128_NAN_LO;
+				/* TODO: fix exception */
+				result.binary.hi = FLOAT128_NAN_HI;
+				result.binary.lo = FLOAT128_NAN_LO;
 				return result;
 			}
 			return a;
 		}
-		
+
 		result.parts.sign = a.parts.sign;
-		
+
 		frac1_hi = a.parts.frac_hi;
 		frac1_lo = a.parts.frac_lo;
@@ -359,5 +343,5 @@
 		exp2 = b.parts.exp;
 	}
-	
+
 	if (exp1 == 0) {
 		/* both are denormalized */
@@ -366,17 +350,16 @@
 		result.parts.frac_lo = tmp_lo;
 		if (lt128(frac1_hi, frac1_lo, result.parts.frac_hi, result.parts.frac_lo)) {
-			// TODO: underflow exception
+			/* TODO: underflow exception */
 			return result;
 		}
-		
 		result.parts.exp = 0;
 		return result;
 	}
-	
+
 	/* add hidden bit */
 	or128(frac1_hi, frac1_lo,
 	    FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO,
 	    &frac1_hi, &frac1_lo);
-	
+
 	if (exp2 == 0) {
 		/* denormalized */
@@ -388,15 +371,16 @@
 		    &frac2_hi, &frac2_lo);
 	}
-	
+
 	/* create some space for rounding */
 	lshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
 	lshift128(frac2_hi, frac2_lo, 6, &frac2_hi, &frac2_lo);
-	
-	if (expdiff > FLOAT128_FRACTION_SIZE + 1)
+
+	if (expdiff > FLOAT128_FRACTION_SIZE + 1) {
 		goto done;
-	
+	}
+
 	rshift128(frac2_hi, frac2_lo, expdiff, &tmp_hi, &tmp_lo);
 	sub128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &frac1_hi, &frac1_lo);
-	
+
 done:
 	/* TODO: find first nonzero digit and shift result and detect possibly underflow */
@@ -408,13 +392,13 @@
 		lshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);
 		/* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */
-		
+
 		lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 6,
 		    &tmp_hi, &tmp_lo);
 		and128(frac1_hi, frac1_lo, tmp_hi, tmp_lo, &tmp_hi, &tmp_lo);
 	}
-	
+
 	/* rounding - if first bit after fraction is set then round up */
 	add128(frac1_hi, frac1_lo, 0x0ll, 0x20ll, &frac1_hi, &frac1_lo);
-	
+
 	lshift128(FLOAT128_HIDDEN_BIT_MASK_HI, FLOAT128_HIDDEN_BIT_MASK_LO, 7,
 	   &tmp_hi, &tmp_lo);
@@ -424,5 +408,5 @@
 		rshift128(frac1_hi, frac1_lo, 1, &frac1_hi, &frac1_lo);
 	}
-	
+
 	/* Clear hidden bit and shift */
 	rshift128(frac1_hi, frac1_lo, 6, &frac1_hi, &frac1_lo);
@@ -432,7 +416,7 @@
 	result.parts.frac_hi = tmp_hi;
 	result.parts.frac_lo = tmp_lo;
-	
+
 	result.parts.exp = exp1;
-	
+
 	return result;
 }
Index: uspace/lib/softfloat/include/add.h
===================================================================
--- uspace/lib/softfloat/include/add.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/add.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -37,8 +37,7 @@
 #define __ADD_H__
 
-extern float32 add_float32(float32, float32);
-extern float64 add_float64(float64, float64);
-extern float96 add_float96(float96, float96);
-extern float128 add_float128(float128, float128);
+extern float32 addFloat32(float32, float32);
+extern float64 addFloat64(float64, float64);
+extern float128 addFloat128(float128, float128);
 
 #endif
Index: uspace/lib/softfloat/include/common.h
===================================================================
--- uspace/lib/softfloat/include/common.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/common.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -39,14 +39,14 @@
 #include <sftypes.h>
 
-extern float64 finish_float64(int32_t, uint64_t, char);
-extern float128 finish_float128(int32_t, uint64_t, uint64_t, char, uint64_t);
+extern float64 finishFloat64(int32_t, uint64_t, char);
+extern float128 finishFloat128(int32_t, uint64_t, uint64_t, char, uint64_t);
 
-extern int count_zeroes8(uint8_t);
-extern int count_zeroes32(uint32_t);
-extern int count_zeroes64(uint64_t);
+extern int countZeroes8(uint8_t);
+extern int countZeroes32(uint32_t);
+extern int countZeroes64(uint64_t);
 
-extern void round_float32(int32_t *, uint32_t *);
-extern void round_float64(int32_t *, uint64_t *);
-extern void round_float128(int32_t *, uint64_t *, uint64_t *);
+extern void roundFloat32(int32_t *, uint32_t *);
+extern void roundFloat64(int32_t *, uint64_t *);
+extern void roundFloat128(int32_t *, uint64_t *, uint64_t *);
 
 extern void lshift128(uint64_t, uint64_t, int, uint64_t *, uint64_t *);
Index: uspace/lib/softfloat/include/comparison.h
===================================================================
--- uspace/lib/softfloat/include/comparison.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/comparison.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -37,43 +37,33 @@
 #define __COMPARISON_H__
 
-extern int is_float32_nan(float32);
-extern int is_float32_signan(float32);
+extern int isFloat32NaN(float32);
+extern int isFloat32SigNaN(float32);
 
-extern int is_float32_infinity(float32);
-extern int is_float32_zero(float32);
+extern int isFloat32Infinity(float32);
+extern int isFloat32Zero(float32);
 
-extern int is_float32_eq(float32, float32);
-extern int is_float32_lt(float32, float32);
-extern int is_float32_gt(float32, float32);
+extern int isFloat32eq(float32, float32);
+extern int isFloat32lt(float32, float32);
+extern int isFloat32gt(float32, float32);
 
-extern int is_float64_nan(float64);
-extern int is_float64_signan(float64);
+extern int isFloat64NaN(float64);
+extern int isFloat64SigNaN(float64);
 
-extern int is_float64_infinity(float64);
-extern int is_float64_zero(float64);
+extern int isFloat64Infinity(float64);
+extern int isFloat64Zero(float64);
 
-extern int is_float64_eq(float64, float64);
-extern int is_float64_lt(float64, float64);
-extern int is_float64_gt(float64, float64);
+extern int isFloat64eq(float64, float64);
+extern int isFloat64lt(float64, float64);
+extern int isFloat64gt(float64, float64);
 
-extern int is_float96_nan(float96);
-extern int is_float96_signan(float96);
+extern int isFloat128NaN(float128);
+extern int isFloat128SigNaN(float128);
 
-extern int is_float96_infinity(float96);
-extern int is_float96_zero(float96);
+extern int isFloat128Infinity(float128);
+extern int isFloat128Zero(float128);
 
-extern int is_float96_eq(float96, float96);
-extern int is_float96_lt(float96, float96);
-extern int is_float96_gt(float96, float96);
-
-extern int is_float128_nan(float128);
-extern int is_float128_signan(float128);
-
-extern int is_float128_infinity(float128);
-extern int is_float128_zero(float128);
-
-extern int is_float128_eq(float128, float128);
-extern int is_float128_lt(float128, float128);
-extern int is_float128_gt(float128, float128);
+extern int isFloat128eq(float128, float128);
+extern int isFloat128lt(float128, float128);
+extern int isFloat128gt(float128, float128);
 
 #endif
Index: uspace/lib/softfloat/include/conversion.h
===================================================================
--- uspace/lib/softfloat/include/conversion.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/conversion.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -37,17 +37,13 @@
 #define __CONVERSION_H__
 
-extern float64 float32_to_float64(float32);
-extern float96 float32_to_float96(float32);
-extern float128 float32_to_float128(float32);
-extern float96 float64_to_float96(float64);
-extern float128 float64_to_float128(float64);
-extern float128 float96_to_float128(float96);
+extern float64 convertFloat32ToFloat64(float32);
+extern float128 convertFloat32ToFloat128(float32);
+extern float128 convertFloat64ToFloat128(float64);
 
-extern float32 float64_to_float32(float64);
-extern float32 float96_to_float32(float96);
-extern float64 float96_to_float64(float96);
-extern float32 float128_to_float32(float128);
-extern float64 float128_to_float64(float128);
-extern float96 float128_to_float96(float128);
+
+extern float32 convertFloat64ToFloat32(float64);
+extern float32 convertFloat128ToFloat32(float128);
+extern float64 convertFloat128ToFloat64(float128);
+
 
 extern uint32_t float32_to_uint32(float32);
@@ -63,10 +59,4 @@
 extern int64_t float64_to_int64(float64);
 
-extern uint32_t float96_to_uint32(float96);
-extern int32_t float96_to_int32(float96);
-
-extern uint64_t float96_to_uint64(float96);
-extern int64_t float96_to_int64(float96);
-
 extern uint32_t float128_to_uint32(float128);
 extern int32_t float128_to_int32(float128);
@@ -74,4 +64,5 @@
 extern uint64_t float128_to_uint64(float128);
 extern int64_t float128_to_int64(float128);
+
 
 extern float32 uint32_to_float32(uint32_t);
@@ -87,10 +78,4 @@
 extern float64 int64_to_float64(int64_t);
 
-extern float96 uint32_to_float96(uint32_t);
-extern float96 int32_to_float96(int32_t);
-
-extern float96 uint64_to_float96(uint64_t);
-extern float96 int64_to_float96(int64_t);
-
 extern float128 uint32_to_float128(uint32_t);
 extern float128 int32_to_float128(int32_t);
Index: uspace/lib/softfloat/include/div.h
===================================================================
--- uspace/lib/softfloat/include/div.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/div.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -37,8 +37,7 @@
 #define __DIV_H__
 
-extern float32 div_float32(float32, float32);
-extern float64 div_float64(float64, float64);
-extern float96 div_float96(float96, float96);
-extern float128 div_float128(float128, float128);
+extern float32 divFloat32(float32, float32);
+extern float64 divFloat64(float64, float64);
+extern float128 divFloat128(float128, float128);
 
 #endif
Index: uspace/lib/softfloat/include/mul.h
===================================================================
--- uspace/lib/softfloat/include/mul.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/mul.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -37,8 +37,7 @@
 #define __MUL_H__
 
-extern float32 mul_float32(float32, float32);
-extern float64 mul_float64(float64, float64);
-extern float96 mul_float96(float96, float96);
-extern float128 mul_float128(float128, float128);
+extern float32 mulFloat32(float32, float32);
+extern float64 mulFloat64(float64, float64);
+extern float128 mulFloat128(float128, float128);
 
 #endif
Index: uspace/lib/softfloat/include/sftypes.h
===================================================================
--- uspace/lib/softfloat/include/sftypes.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/sftypes.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -40,566 +40,112 @@
 #include <stdint.h>
 
-/*
- * For recognizing NaNs or infinity use specialized comparison
- * functions, comparing with these constants is not sufficient.
- */
-
-#define FLOAT32_NAN     UINT32_C(0x7FC00001)
-#define FLOAT32_SIGNAN  UINT32_C(0x7F800001)
-#define FLOAT32_INF     UINT32_C(0x7F800000)
-
-#define FLOAT64_NAN     UINT64_C(0x7FF8000000000001)
-#define FLOAT64_SIGNAN  UINT64_C(0x7FF0000000000001)
-#define FLOAT64_INF     UINT64_C(0x7FF0000000000000)
-
-#define FLOAT96_NAN_HI     UINT64_C(0x7FFF80000000)
-#define FLOAT96_NAN_LO     UINT32_C(0x00010000)
-#define FLOAT96_SIGNAN_HI  UINT64_C(0x7FFF00000000)
-#define FLOAT96_SIGNAN_LO  UINT32_C(0x00010000)
-
-#define FLOAT128_NAN_HI     UINT64_C(0x7FFF800000000000)
-#define FLOAT128_NAN_LO     UINT64_C(0x0000000000000001)
-#define FLOAT128_SIGNAN_HI  UINT64_C(0x7FFF000000000000)
-#define FLOAT128_SIGNAN_LO  UINT64_C(0x0000000000000001)
-#define FLOAT128_INF_HI     UINT64_C(0x7FFF000000000000)
-#define FLOAT128_INF_LO     UINT64_C(0x0000000000000000)
-
-#define FLOAT32_FRACTION_SIZE   23
-#define FLOAT64_FRACTION_SIZE   52
-#define FLOAT96_FRACTION_SIZE   64
-#define FLOAT128_FRACTION_SIZE  112
-#define FLOAT128_FRAC_HI_SIZE   48
-#define FLOAT128_FRAC_LO_SIZE   64
-
-#define FLOAT32_HIDDEN_BIT_MASK      UINT32_C(0x800000)
-#define FLOAT64_HIDDEN_BIT_MASK      UINT64_C(0x10000000000000)
-#define FLOAT128_HIDDEN_BIT_MASK_HI  UINT64_C(0x1000000000000)
-#define FLOAT128_HIDDEN_BIT_MASK_LO  UINT64_C(0x0000000000000000)
-
-#define FLOAT32_MAX_EXPONENT   0xFF
-#define FLOAT64_MAX_EXPONENT   0x7FF
-#define FLOAT96_MAX_EXPONENT   0x7FFF
-#define FLOAT128_MAX_EXPONENT  0x7FFF
-
-#define FLOAT32_BIAS   0x7F
-#define FLOAT64_BIAS   0x3FF
-#define FLOAT96_BIAS   0x3FFF
-#define FLOAT128_BIAS  0x3FFF
-
-#if defined(__BE__)
-
 typedef union {
-	uint32_t bin;
+	float f;
+	uint32_t binary;
 	
 	struct {
+#if defined(__BE__)
 		uint32_t sign : 1;
 		uint32_t exp : 8;
 		uint32_t fraction : 23;
-	} parts __attribute__((packed));
+#elif defined(__LE__)
+		uint32_t fraction : 23;
+		uint32_t exp : 8;
+		uint32_t sign : 1;
+#else
+	#error Unknown endianess
+#endif
+	} parts __attribute__ ((packed));
 } float32;
 
 typedef union {
-	uint64_t bin;
+	double d;
+	uint64_t binary;
 	
 	struct {
+#if defined(__BE__)
 		uint64_t sign : 1;
 		uint64_t exp : 11;
 		uint64_t fraction : 52;
-	} parts __attribute__((packed));
+#elif defined(__LE__)
+		uint64_t fraction : 52;
+		uint64_t exp : 11;
+		uint64_t sign : 1;
+#else
+	#error Unknown endianess
+#endif
+	} parts __attribute__ ((packed));
 } float64;
 
 typedef union {
+	long double ld;
 	struct {
-		uint64_t hi;
-		uint32_t lo;
-	} bin __attribute__((packed));
-	
-	struct {
-		uint64_t padding : 16;
-		uint64_t sign : 1;
-		uint64_t exp : 15;
-		uint64_t fraction : 64;
-	} parts __attribute__((packed));
-} float96;
-
-typedef union {
-	struct {
+#if defined(__BE__)
 		uint64_t hi;
 		uint64_t lo;
-	} bin __attribute__((packed));
-	
+#elif defined(__LE__)
+		uint64_t lo;
+		uint64_t hi;
+#else
+	#error Unknown endianess
+#endif
+	} binary;
+
 	struct {
+#if defined(__BE__)
 		uint64_t sign : 1;
 		uint64_t exp : 15;
 		uint64_t frac_hi : 48;
 		uint64_t frac_lo : 64;
-	} parts __attribute__((packed));
-} float128;
-
 #elif defined(__LE__)
-
-typedef union {
-	uint32_t bin;
-	
-	struct {
-		uint32_t fraction : 23;
-		uint32_t exp : 8;
-		uint32_t sign : 1;
-	} parts __attribute__((packed));
-} float32;
-
-typedef union {
-	uint64_t bin;
-	
-	struct {
-		uint64_t fraction : 52;
-		uint64_t exp : 11;
-		uint64_t sign : 1;
-	} parts __attribute__((packed));
-} float64;
-
-typedef union {
-	struct {
-		uint32_t lo;
-		uint64_t hi;
-	} bin __attribute__((packed));
-	
-	struct {
-		uint64_t fraction : 64;
-		uint64_t exp : 15;
-		uint64_t sign : 1;
-		uint64_t padding : 16;
-	} parts __attribute__((packed));
-} float96;
-
-typedef union {
-	struct {
-		uint64_t lo;
-		uint64_t hi;
-	} bin __attribute__((packed));
-	
-	struct {
 		uint64_t frac_lo : 64;
 		uint64_t frac_hi : 48;
 		uint64_t exp : 15;
 		uint64_t sign : 1;
-	} parts __attribute__((packed));
-} float128;
-
 #else
 	#error Unknown endianess
 #endif
+	} parts __attribute__ ((packed));
+} float128;
 
-typedef union {
-	float val;
-	
-#if defined(FLOAT_SIZE_32)
-	float32 data;
-#elif defined(FLOAT_SIZE_64)
-	float64 data;
-#elif defined(FLOAT_SIZE_96)
-	float96 data;
-#elif defined(FLOAT_SIZE_128)
-	float128 data;
-#else
-	#error Unsupported float size
-#endif
-} float_t;
+/*
+ * For recognizing NaNs or infinity use specialized comparison functions,
+ * comparing with these constants is not sufficient.
+ */
 
-typedef union {
-	double val;
-	
-#if defined(DOUBLE_SIZE_32)
-	float32 data;
-#elif defined(DOUBLE_SIZE_64)
-	float64 data;
-#elif defined(DOUBLE_SIZE_96)
-	float96 data;
-#elif defined(DOUBLE_SIZE_128)
-	float128 data;
-#else
-	#error Unsupported double size
-#endif
-} double_t;
+#define FLOAT32_NAN     0x7FC00001
+#define FLOAT32_SIGNAN  0x7F800001
+#define FLOAT32_INF     0x7F800000
 
-typedef union {
-	long double val;
-	
-#if defined(LONG_DOUBLE_SIZE_32)
-	float32 data;
-#elif defined(LONG_DOUBLE_SIZE_64)
-	float64 data;
-#elif defined(LONG_DOUBLE_SIZE_96)
-	float96 data;
-#elif defined(LONG_DOUBLE_SIZE_128)
-	float128 data;
-#else
-	#error Unsupported long double size
-#endif
-} long_double_t;
+#define FLOAT64_NAN     0x7FF8000000000001ll
+#define FLOAT64_SIGNAN  0x7FF0000000000001ll
+#define FLOAT64_INF     0x7FF0000000000000ll
 
+#define FLOAT128_NAN_HI     0x7FFF800000000000ll
+#define FLOAT128_NAN_LO     0x0000000000000001ll
+#define FLOAT128_SIGNAN_HI  0x7FFF000000000000ll
+#define FLOAT128_SIGNAN_LO  0x0000000000000001ll
+#define FLOAT128_INF_HI     0x7FFF000000000000ll
+#define FLOAT128_INF_LO     0x0000000000000000ll
 
-#if defined(INT_SIZE_8)
+#define FLOAT32_FRACTION_SIZE   23
+#define FLOAT64_FRACTION_SIZE   52
+#define FLOAT128_FRACTION_SIZE 112
+#define FLOAT128_FRAC_HI_SIZE   48
+#define FLOAT128_FRAC_LO_SIZE   64
 
-#define _to_int   _to_int8
-#define from_int  int8
+#define FLOAT32_HIDDEN_BIT_MASK      0x800000
+#define FLOAT64_HIDDEN_BIT_MASK      0x10000000000000ll
+#define FLOAT128_HIDDEN_BIT_MASK_HI  0x1000000000000ll
+#define FLOAT128_HIDDEN_BIT_MASK_LO  0x0000000000000000ll
 
-#elif defined(INT_SIZE_16)
+#define FLOAT32_MAX_EXPONENT  0xFF
+#define FLOAT64_MAX_EXPONENT  0x7FF
+#define FLOAT128_MAX_EXPONENT 0x7FFF
 
-#define _to_int   _to_int16
-#define from_int  int16
-
-#elif defined(INT_SIZE_32)
-
-#define _to_int   _to_int32
-#define from_int  int32
-
-#elif defined(INT_SIZE_64)
-
-#define _to_int   _to_int64
-#define from_int  int64
-
-#endif
-
-
-#if defined(UINT_SIZE_8)
-
-#define _to_uint   _to_uint8
-#define from_uint  uint8
-
-#elif defined(UINT_SIZE_16)
-
-#define _to_uint   _to_uint16
-#define from_uint  uint16
-
-#elif defined(UINT_SIZE_32)
-
-#define _to_uint   _to_uint32
-#define from_uint  uint32
-
-#elif defined(UINT_SIZE_64)
-
-#define _to_uint   _to_uint64
-#define from_uint  uint64
-
-#endif
-
-
-#if defined(LONG_SIZE_8)
-
-#define _to_long   _to_int8
-#define from_long  int8
-
-#elif defined(LONG_SIZE_16)
-
-#define _to_long   _to_int16
-#define from_long  int16
-
-#elif defined(LONG_SIZE_32)
-
-#define _to_long   _to_int32
-#define from_long  int32
-
-#elif defined(LONG_SIZE_64)
-
-#define _to_long   _to_int64
-#define from_long  int64
-
-#endif
-
-
-#if defined(ULONG_SIZE_8)
-
-#define _to_ulong   _to_uint8
-#define from_ulong  uint8
-
-#elif defined(ULONG_SIZE_16)
-
-#define _to_ulong   _to_uint16
-#define from_ulong  uint16
-
-#elif defined(ULONG_SIZE_32)
-
-#define _to_ulong   _to_uint32
-#define from_ulong  uint32
-
-#elif defined(ULONG_SIZE_64)
-
-#define _to_ulong   _to_uint64
-#define from_ulong  uint64
-
-#endif
-
-
-#if defined(LLONG_SIZE_8)
-
-#define _to_llong   _to_int8
-#define from_llong  int8
-
-#elif defined(LLONG_SIZE_16)
-
-#define _to_llong   _to_int16
-#define from_llong  int16
-
-#elif defined(LLONG_SIZE_32)
-
-#define _to_llong   _to_int32
-#define from_llong  int32
-
-#elif defined(LLONG_SIZE_64)
-
-#define _to_llong   _to_int64
-#define from_llong  int64
-
-#endif
-
-
-#if defined(ULLONG_SIZE_8)
-
-#define _to_ullong   _to_uint8
-#define from_ullong  uint8
-
-#elif defined(ULLONG_SIZE_16)
-
-#define _to_ullong   _to_uint16
-#define from_ullong  uint16
-
-#elif defined(ULLONG_SIZE_32)
-
-#define _to_ullong   _to_uint32
-#define from_ullong  uint32
-
-#elif defined(ULLONG_SIZE_64)
-
-#define _to_ullong   _to_uint64
-#define from_ullong  uint64
-
-#endif
-
-
-#if defined(FLOAT_SIZE_32)
-
-#define add_float     add_float32
-#define sub_float     sub_float32
-#define mul_float     mul_float32
-#define div_float     div_float32
-#define _to_float     _to_float32
-#define from_float    float32
-#define is_float_nan  is_float32_nan
-#define is_float_eq   is_float32_eq
-#define is_float_lt   is_float32_lt
-#define is_float_gt   is_float32_gt
-
-#elif defined(FLOAT_SIZE_64)
-
-#define add_float     add_float64
-#define sub_float     sub_float64
-#define mul_float     mul_float64
-#define div_float     div_float64
-#define _to_float     _to_float64
-#define from_float    float64
-#define is_float_nan  is_float64_nan
-#define is_float_eq   is_float64_eq
-#define is_float_lt   is_float64_lt
-#define is_float_gt   is_float64_gt
-
-#elif defined(FLOAT_SIZE_96)
-
-#define add_float     add_float96
-#define sub_float     sub_float96
-#define mul_float     mul_float96
-#define div_float     div_float96
-#define _to_float     _to_float96
-#define from_float    float96
-#define is_float_nan  is_float96_nan
-#define is_float_eq   is_float96_eq
-#define is_float_lt   is_float96_lt
-#define is_float_gt   is_float96_gt
-
-#elif defined(FLOAT_SIZE_128)
-
-#define add_float     add_float128
-#define sub_float     sub_float128
-#define mul_float     mul_float128
-#define div_float     div_float128
-#define _to_float     _to_float128
-#define from_float    float128
-#define is_float_nan  is_float128_nan
-#define is_float_eq   is_float128_eq
-#define is_float_lt   is_float128_lt
-#define is_float_gt   is_float128_gt
-
-#endif
-
-
-#if defined(DOUBLE_SIZE_32)
-
-#define add_double     add_float32
-#define sub_double     sub_float32
-#define mul_double     mul_float32
-#define div_double     div_float32
-#define _to_double     _to_float32
-#define from_double    float32
-#define is_double_nan  is_float32_nan
-#define is_double_eq   is_float32_eq
-#define is_double_lt   is_float32_lt
-#define is_double_gt   is_float32_gt
-
-#elif defined(DOUBLE_SIZE_64)
-
-#define add_double     add_float64
-#define sub_double     sub_float64
-#define mul_double     mul_float64
-#define div_double     div_float64
-#define _to_double     _to_float64
-#define from_double    float64
-#define is_double_nan  is_float64_nan
-#define is_double_eq   is_float64_eq
-#define is_double_lt   is_float64_lt
-#define is_double_gt   is_float64_gt
-
-#elif defined(DOUBLE_SIZE_96)
-
-#define add_double     add_float96
-#define sub_double     sub_float96
-#define mul_double     mul_float96
-#define div_double     div_float96
-#define _to_double     _to_float96
-#define from_double    float96
-#define is_double_nan  is_float96_nan
-#define is_double_eq   is_float96_eq
-#define is_double_lt   is_float96_lt
-#define is_double_gt   is_float96_gt
-
-#elif defined(DOUBLE_SIZE_128)
-
-#define add_double     add_float128
-#define sub_double     sub_float128
-#define mul_double     mul_float128
-#define div_double     div_float128
-#define _to_double     _to_float128
-#define from_double    float128
-#define is_double_nan  is_float128_nan
-#define is_double_eq   is_float128_eq
-#define is_double_lt   is_float128_lt
-#define is_double_gt   is_float128_gt
-
-#endif
-
-
-#if defined(LONG_DOUBLE_SIZE_32)
-
-#define add_long_double     add_float32
-#define sub_long_double     sub_float32
-#define mul_long_double     mul_float32
-#define div_long_double     div_float32
-#define _to_long_double     _to_float32
-#define from_long_double    float32
-#define is_long_double_nan  is_float32_nan
-#define is_long_double_eq   is_float32_eq
-#define is_long_double_lt   is_float32_lt
-#define is_long_double_gt   is_float32_gt
-
-#elif defined(LONG_DOUBLE_SIZE_64)
-
-#define add_long_double     add_float64
-#define sub_long_double     sub_float64
-#define mul_long_double     mul_float64
-#define div_long_double     div_float64
-#define _to_long_double     _to_float64
-#define from_long_double    float64
-#define is_long_double_nan  is_float64_nan
-#define is_long_double_eq   is_float64_eq
-#define is_long_double_lt   is_float64_lt
-#define is_long_double_gt   is_float64_gt
-
-#elif defined(LONG_DOUBLE_SIZE_96)
-
-#define add_long_double     add_float96
-#define sub_long_double     sub_float96
-#define mul_long_double     mul_float96
-#define div_long_double     div_float96
-#define _to_long_double     _to_float96
-#define from_long_double    float96
-#define is_long_double_nan  is_float96_nan
-#define is_long_double_eq   is_float96_eq
-#define is_long_double_lt   is_float96_lt
-#define is_long_double_gt   is_float96_gt
-
-#elif defined(LONG_DOUBLE_SIZE_128)
-
-#define add_long_double     add_float128
-#define sub_long_double     sub_float128
-#define mul_long_double     mul_float128
-#define div_long_double     div_float128
-#define _to_long_double     _to_float128
-#define from_long_double    float128
-#define is_long_double_nan  is_float128_nan
-#define is_long_double_eq   is_float128_eq
-#define is_long_double_lt   is_float128_lt
-#define is_long_double_gt   is_float128_gt
-
-#endif
-
-
-#define CONCAT(a, b)       CONCAT_ARGS(a, b)
-#define CONCAT_ARGS(a, b)  a ## b
-
-#define float32_to_float32(arg)    (arg)
-#define float64_to_float64(arg)    (arg)
-#define float96_to_float96(arg)    (arg)
-#define float128_to_float128(arg)  (arg)
-
-#define float_to_double       CONCAT(from_float, _to_double)
-#define float_to_long_double  CONCAT(from_float, _to_long_double)
-#define float_to_int          CONCAT(from_float, _to_int)
-#define float_to_uint         CONCAT(from_float, _to_uint)
-#define float_to_long         CONCAT(from_float, _to_long)
-#define float_to_ulong        CONCAT(from_float, _to_ulong)
-#define float_to_llong        CONCAT(from_float, _to_llong)
-#define float_to_ullong       CONCAT(from_float, _to_ullong)
-
-#define double_to_float        CONCAT(from_double, _to_float)
-#define double_to_long_double  CONCAT(from_double, _to_long_double)
-#define double_to_int          CONCAT(from_double, _to_int)
-#define double_to_uint         CONCAT(from_double, _to_uint)
-#define double_to_long         CONCAT(from_double, _to_long)
-#define double_to_ulong        CONCAT(from_double, _to_ulong)
-#define double_to_llong        CONCAT(from_double, _to_llong)
-#define double_to_ullong       CONCAT(from_double, _to_ullong)
-
-#define long_double_to_float   CONCAT(from_long_double, _to_float)
-#define long_double_to_double  CONCAT(from_long_double, _to_double)
-#define long_double_to_int     CONCAT(from_long_double, _to_int)
-#define long_double_to_uint    CONCAT(from_long_double, _to_uint)
-#define long_double_to_long    CONCAT(from_long_double, _to_long)
-#define long_double_to_ulong   CONCAT(from_long_double, _to_ulong)
-#define long_double_to_llong   CONCAT(from_long_double, _to_llong)
-#define long_double_to_ullong  CONCAT(from_long_double, _to_ullong)
-
-#define int_to_float        CONCAT(from_int, _to_float)
-#define int_to_double       CONCAT(from_int, _to_double)
-#define int_to_long_double  CONCAT(from_int, _to_long_double)
-
-#define uint_to_float        CONCAT(from_uint, _to_float)
-#define uint_to_double       CONCAT(from_uint, _to_double)
-#define uint_to_long_double  CONCAT(from_uint, _to_long_double)
-
-#define long_to_float        CONCAT(from_long, _to_float)
-#define long_to_double       CONCAT(from_long, _to_double)
-#define long_to_long_double  CONCAT(from_long, _to_long_double)
-
-#define ulong_to_float        CONCAT(from_ulong, _to_float)
-#define ulong_to_double       CONCAT(from_ulong, _to_double)
-#define ulong_to_long_double  CONCAT(from_ulong, _to_long_double)
-
-#define llong_to_float        CONCAT(from_llong, _to_float)
-#define llong_to_double       CONCAT(from_llong, _to_double)
-#define llong_to_long_double  CONCAT(from_llong, _to_long_double)
-
-#define ullong_to_float        CONCAT(from_ullong, _to_float)
-#define ullong_to_double       CONCAT(from_ullong, _to_double)
-#define ullong_to_long_double  CONCAT(from_ullong, _to_long_double)
-
+#define FLOAT32_BIAS  0x7F
+#define FLOAT64_BIAS  0x3FF
+#define FLOAT80_BIAS  0x3FFF
+#define FLOAT128_BIAS 0x3FFF
 
 #endif
Index: uspace/lib/softfloat/include/softfloat.h
===================================================================
--- uspace/lib/softfloat/include/softfloat.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/softfloat.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -169,6 +169,8 @@
 extern float __powisf2(float, int);
 extern double __powidf2 (double, int);
-extern long double __powitf2(long double, int);
-extern long double __powixf2(long double, int);
+extern long double __powitf2 (long double, int);
+extern long double __powixf2 (long double, int);
+
+
 
 /* SPARC quadruple-precision wrappers */
Index: uspace/lib/softfloat/include/sub.h
===================================================================
--- uspace/lib/softfloat/include/sub.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softfloat/include/sub.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -37,8 +37,7 @@
 #define __SUB_H__
 
-extern float32 sub_float32(float32, float32);
-extern float64 sub_float64(float64, float64);
-extern float96 sub_float96(float96, float96);
-extern float128 sub_float128(float128, float128);
+extern float32 subFloat32(float32, float32);
+extern float64 subFloat64(float64, float64);
+extern float128 subFloat128(float128, float128);
 
 #endif
Index: uspace/lib/softint/generic/division.c
===================================================================
--- uspace/lib/softint/generic/division.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softint/generic/division.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -37,9 +37,8 @@
 #include <division.h>
 
-#define ABSVAL(x)  ((x) > 0 ? (x) : -(x))
-#define SGN(x)     ((x) >= 0 ? 1 : 0)
-
-static unsigned int divandmod32(unsigned int a, unsigned int b,
-    unsigned int *remainder)
+#define ABSVAL(x) ( (x) > 0 ? (x) : -(x))
+#define SGN(x) ( (x) >= 0 ? 1 : 0 )
+				      
+static unsigned int divandmod32(unsigned int a, unsigned int b, unsigned int *remainder)
 {
 	unsigned int result;
@@ -54,29 +53,29 @@
 	}
 	
-	if (a < b) {
+	if ( a < b) {
 		*remainder = a;
 		return 0;
 	}
-	
-	for (; steps > 0; steps--) {
+
+	for ( ; steps > 0; steps--) {
 		/* shift one bit to remainder */
-		*remainder = ((*remainder) << 1) | (( a >> 31) & 0x1);
+		*remainder = ( (*remainder) << 1) | (( a >> 31) & 0x1);
 		result <<= 1;
 		
 		if (*remainder >= b) {
-			*remainder -= b;
-			result |= 0x1;
+				*remainder -= b;
+				result |= 0x1;
 		}
 		a <<= 1;
 	}
-	
+
 	return result;
 }
 
-static unsigned long long divandmod64(unsigned long long a,
-    unsigned long long b, unsigned long long *remainder)
+
+static unsigned long long divandmod64(unsigned long long a, unsigned long long b, unsigned long long *remainder)
 {
 	unsigned long long result;
-	int steps = sizeof(unsigned long long) * 8;
+	int steps = sizeof(unsigned long long) * 8; 
 	
 	*remainder = 0;
@@ -88,45 +87,45 @@
 	}
 	
-	if (a < b) {
+	if ( a < b) {
 		*remainder = a;
 		return 0;
 	}
-	
-	for (; steps > 0; steps--) {
+
+	for ( ; steps > 0; steps--) {
 		/* shift one bit to remainder */
-		*remainder = ((*remainder) << 1) | ((a >> 63) & 0x1);
+		*remainder = ( (*remainder) << 1) | ((a >> 63) & 0x1);
 		result <<= 1;
 		
 		if (*remainder >= b) {
-			*remainder -= b;
-			result |= 0x1;
+				*remainder -= b;
+				result |= 0x1;
 		}
 		a <<= 1;
 	}
-	
+
 	return result;
 }
 
 /* 32bit integer division */
-int __divsi3(int a, int b)
+int __divsi3(int a, int b) 
 {
 	unsigned int rem;
-	int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
+	int result;
 	
-	if (SGN(a) == SGN(b))
-		return result;
-	
+	result = (int)divandmod32(ABSVAL(a), ABSVAL(b), &rem);
+
+	if ( SGN(a) == SGN(b)) return result;
 	return -result;
 }
 
 /* 64bit integer division */
-long long __divdi3(long long a, long long b)
+long long __divdi3(long long a, long long b) 
 {
 	unsigned long long rem;
-	long long result = (long long) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
+	long long result;
 	
-	if (SGN(a) == SGN(b))
-		return result;
-	
+	result = (long long)divandmod64(ABSVAL(a), ABSVAL(b), &rem);
+
+	if ( SGN(a) == SGN(b)) return result;
 	return -result;
 }
@@ -142,5 +141,5 @@
 unsigned long long __udivdi3(unsigned long long a, unsigned long long b)
 {
-	unsigned long long rem;
+	unsigned long long  rem;
 	return divandmod64(a, b, &rem);
 }
@@ -153,12 +152,13 @@
 	
 	/* if divident is negative, remainder must be too */
-	if (!(SGN(a)))
-		return -((int) rem);
+	if (!(SGN(a))) {
+		return -((int)rem);
+	}
 	
-	return (int) rem;
+	return (int)rem;
 }
 
 /* 64bit remainder of the signed division */
-long long __moddi3(long long a, long long b)
+long long __moddi3(long long a,long  long b)
 {
 	unsigned long long rem;
@@ -166,8 +166,9 @@
 	
 	/* if divident is negative, remainder must be too */
-	if (!(SGN(a)))
-		return -((long long) rem);
+	if (!(SGN(a))) {
+		return -((long long)rem);
+	}
 	
-	return (long long) rem;
+	return (long long)rem;
 }
 
@@ -188,40 +189,5 @@
 }
 
-int __divmodsi3(int a, int b, int *c)
-{
-	unsigned int rem;
-	int result = (int) divandmod32(ABSVAL(a), ABSVAL(b), &rem);
-	
-	if (SGN(a) == SGN(b)) {
-		*c = rem;
-		return result;
-	}
-	
-	*c = -rem;
-	return -result;
-}
-
-unsigned int __udivmodsi3(unsigned int a, unsigned int b,
-    unsigned int *c)
-{
-	return divandmod32(a, b, c);
-}
-
-long long __divmoddi3(long long a, long long b, long long *c)
-{
-	unsigned long long rem;
-	long long result = (int) divandmod64(ABSVAL(a), ABSVAL(b), &rem);
-	
-	if (SGN(a) == SGN(b)) {
-		*c = rem;
-		return result;
-	}
-	
-	*c = -rem;
-	return -result;
-}
-
-unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b,
-    unsigned long long *c)
+unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b, unsigned long long *c)
 {
 	return divandmod64(a, b, c);
Index: uspace/lib/softint/include/comparison.h
===================================================================
--- uspace/lib/softint/include/comparison.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softint/include/comparison.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -38,8 +38,8 @@
 
 /* Signed comparison (a < b => 0, a == b => 1, a > b => 2). */
-extern int __cmpdi2(long long, long long);
+int __cmpdi2 (long long a, long long b);
 
 /* Unsigned comparison (a < b => 0, a == b => 1, a > b => 2). */
-extern int __ucmpdi2(unsigned long long, unsigned long long);
+int __ucmpdi2 (unsigned long long a, unsigned long long b);
 
 #endif
Index: uspace/lib/softint/include/division.h
===================================================================
--- uspace/lib/softint/include/division.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softint/include/division.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -29,5 +29,5 @@
 /** @addtogroup softint
  * @{
- */
+ */ 
 /**
  * @file
@@ -37,22 +37,30 @@
 #define __SOFTINT_DIVISION_H__
 
-extern int __divsi3(int, int);
-extern long long __divdi3(long long, long long);
 
-extern unsigned int __udivsi3(unsigned int, unsigned int);
-extern unsigned long long __udivdi3(unsigned long long, unsigned long long);
+/* 32bit integer division */
+int __divsi3(int a, int b);
 
-extern int __modsi3(int, int);
-extern long long __moddi3(long long, long long);
+/* 64bit integer division */
+long long __divdi3(long long a, long long b);
 
-extern unsigned int __umodsi3(unsigned int, unsigned int);
-extern unsigned long long __umoddi3(unsigned long long, unsigned long long);
+/* 32bit unsigned integer division */
+unsigned int __udivsi3(unsigned int a, unsigned int b);
 
-extern int __divmodsi3(int, int, int *);
-extern unsigned int __udivmodsi3(unsigned int, unsigned int, unsigned int *);
+/* 64bit unsigned integer division */
+unsigned long long __udivdi3(unsigned long long a, unsigned long long b);
 
-extern long long __divmoddi3(long long, long long, long long *);
-extern unsigned long long __udivmoddi3(unsigned long long, unsigned long long,
-    unsigned long long *);
+/* 32bit remainder of the signed division */
+int __modsi3(int a, int b);
+
+/* 64bit remainder of the signed division */
+long long __moddi3(long long a, long long b);
+
+/* 32bit remainder of the unsigned division */
+unsigned int __umodsi3(unsigned int a, unsigned int b);
+
+/* 64bit remainder of the unsigned division */
+unsigned long long __umoddi3(unsigned long long a, unsigned long long b);
+
+unsigned long long __udivmoddi3(unsigned long long a, unsigned long long b, unsigned long long *c); 
 
 #endif
@@ -60,2 +68,3 @@
 /** @}
  */
+
Index: uspace/lib/softint/include/lltype.h
===================================================================
--- uspace/lib/softint/include/lltype.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softint/include/lltype.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -39,6 +39,6 @@
 #include <stdint.h>
 
-#define HALF_BIT_CNT   (sizeof(int32_t) * sizeof(char))
-#define WHOLE_BIT_CNT  (sizeof(int64_t) * sizeof(char))
+#define HALF_BIT_CNT (sizeof(int32_t) * sizeof(char))
+#define WHOLE_BIT_CNT (sizeof(int64_t) * sizeof(char))
 
 #ifdef __BE__
Index: uspace/lib/softint/include/multiplication.h
===================================================================
--- uspace/lib/softint/include/multiplication.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softint/include/multiplication.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -29,5 +29,5 @@
 /** @addtogroup softint
  * @{
- */
+ */ 
 /**
  * @file
@@ -38,5 +38,5 @@
 
 /* 64 bit multiplication */
-extern long long __muldi3(long long, long long);
+long long __muldi3(long long a, long long b);
 
 #endif
Index: uspace/lib/softint/include/shift.h
===================================================================
--- uspace/lib/softint/include/shift.h	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/lib/softint/include/shift.h	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -38,11 +38,11 @@
 
 /* Arithmetic/logical shift left. */
-extern long long __ashldi3(long long, int);
+long long __ashldi3 (long long val, int shift);
 
 /* Arithmetic shift right. */
-extern long long __ashrdi3(long long, int);
+long long __ashrdi3 (long long val, int shift);
 
 /* Logical shift right. */
-extern long long __lshrdi3(long long, int);
+long long __lshrdi3 (long long val, int shift);
 
 #endif
Index: uspace/srv/fs/exfat/exfat_fat.c
===================================================================
--- uspace/srv/fs/exfat/exfat_fat.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/srv/fs/exfat/exfat_fat.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -127,5 +127,5 @@
 {
 	exfat_cluster_t firstc = nodep->firstc;
-	exfat_cluster_t currc = 0;
+	exfat_cluster_t currc;
 	aoff64_t relbn = bn;
 	int rc;
Index: uspace/srv/hid/fb/port/ega.c
===================================================================
--- uspace/srv/hid/fb/port/ega.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/srv/hid/fb/port/ega.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -117,5 +117,5 @@
 	uint8_t glyph;
 	
-	if (ascii_check(field->ch))
+	if ((field->ch >= 0) && (field->ch < 128))
 		glyph = field->ch;
 	else
Index: uspace/srv/hid/fb/port/kchar.c
===================================================================
--- uspace/srv/hid/fb/port/kchar.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/srv/hid/fb/port/kchar.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -48,5 +48,5 @@
 static void kchar_putchar(wchar_t ch)
 {
-	if (ascii_check(ch))
+	if ((ch >= 0) && (ch < 128))
 		*kchar.addr = ch;
 	else
Index: uspace/srv/hid/fb/port/kfb.c
===================================================================
--- uspace/srv/hid/fb/port/kfb.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/srv/hid/fb/port/kfb.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -409,6 +409,6 @@
 	charfield_t *field = screenbuffer_field_at(vp->backbuf, col, row);
 	
-	pixel_t bgcolor = 0;
-	pixel_t fgcolor = 0;
+	pixel_t bgcolor;
+	pixel_t fgcolor;
 	attrs_rgb(field->attrs, &bgcolor, &fgcolor);
 	
@@ -525,6 +525,6 @@
 	}
 	
-	pixel_t bgcolor = 0;
-	pixel_t fgcolor = 0;
+	pixel_t bgcolor;
+	pixel_t fgcolor;
 	attrs_rgb(vp->attrs, &bgcolor, &fgcolor);
 	
Index: uspace/srv/hid/fb/port/niagara.c
===================================================================
--- uspace/srv/hid/fb/port/niagara.c	(revision 41455a2252d8399fc1db67b56337cc546b45a936)
+++ uspace/srv/hid/fb/port/niagara.c	(revision 6bb169b5888edb060801d4ac1ed89a86670dd67a)
@@ -68,5 +68,5 @@
 static void niagara_putchar(wchar_t ch)
 {
-	if (ascii_check(ch))
+	if ((ch >= 0) && (ch < 128))
 		niagara_putc(ch);
 	else
