| /uspace/trunk/softfloat/include/sftypes.h |
|---|
| 0,0 → 1,102 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __SFTYPES_H__ |
| #define __SFTYPES_H__ |
| #include <types.h> |
| #include <arch.h> |
| typedef union { |
| float f; |
| __u32 binary; |
| struct { |
| #ifdef __BIG_ENDIAN__ |
| __u32 sign:1; |
| __u32 exp:8; |
| __u32 fraction:23; |
| #elif defined __LITTLE_ENDIAN__ |
| __u32 fraction:23; |
| __u32 exp:8; |
| __u32 sign:1; |
| #else |
| #error "Unknown endians." |
| #endif |
| } parts __attribute__ ((packed)); |
| } float32; |
| typedef union { |
| double d; |
| __u64 binary; |
| struct { |
| #ifdef __BIG_ENDIAN__ |
| __u64 sign:1; |
| __u64 exp:11; |
| __u64 fraction:52; |
| #elif defined __LITTLE_ENDIAN__ |
| __u64 fraction:52; |
| __u64 exp:11; |
| __u64 sign:1; |
| #else |
| #error "Unknown endians." |
| #endif |
| } parts __attribute__ ((packed)); |
| } float64; |
| #define FLOAT32_MAX 0x7f800000 |
| #define FLOAT32_MIN 0xff800000 |
| #define FLOAT64_MAX |
| #define FLOAT64_MIN |
| /* For recognizing NaNs or infinity use isFloat32NaN and is Float32Inf, comparing with this constants is not sufficient */ |
| #define FLOAT32_NAN 0x7FC00001 |
| #define FLOAT32_SIGNAN 0x7F800001 |
| #define FLOAT32_INF 0x7F800000 |
| #define FLOAT64_NAN 0x7FF8000000000001ll |
| #define FLOAT64_SIGNAN 0x7FF0000000000001ll |
| #define FLOAT64_INF 0x7FF0000000000000ll |
| #define FLOAT32_FRACTION_SIZE 23 |
| #define FLOAT64_FRACTION_SIZE 52 |
| #define FLOAT32_HIDDEN_BIT_MASK 0x800000 |
| #define FLOAT64_HIDDEN_BIT_MASK 0x10000000000000ll |
| #define FLOAT32_MAX_EXPONENT 0xFF |
| #define FLOAT64_MAX_EXPONENT 0x7FF |
| #define FLOAT32_BIAS 0x7F |
| #define FLOAT64_BIAS 0x3FF |
| #define FLOAT80_BIAS 0x3FFF |
| #endif |
| /uspace/trunk/softfloat/include/softfloat.h |
|---|
| 0,0 → 1,162 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __SOFTFLOAT_H__ |
| #define __SOFTFLOAT_H__ |
| float __addsf3(float a, float b); |
| double __adddf3(double a, double b); |
| long double __addtf3(long double a, long double b); |
| long double __addxf3(long double a, long double b); |
| float __subsf3(float a, float b); |
| double __subdf3(double a, double b); |
| long double __subtf3(long double a, long double b); |
| long double __subxf3(long double a, long double b); |
| float __mulsf3(float a, float b); |
| double __muldf3(double a, double b); |
| long double __multf3(long double a, long double b); |
| long double __mulxf3(long double a, long double b); |
| float __divsf3(float a, float b); |
| double __divdf3(double a, double b); |
| long double __divtf3(long double a, long double b); |
| long double __divxf3(long double a, long double b); |
| float __negsf2(float a); |
| double __negdf2(double a); |
| long double __negtf2(long double a); |
| long double __negxf2(long double a); |
| double __extendsfdf2(float a); |
| long double __extendsftf2(float a); |
| long double __extendsfxf2(float a); |
| long double __extenddftf2(double a); |
| long double __extenddfxf2(double a); |
| double __truncxfdf2(long double a); |
| double __trunctfdf2(long double a); |
| float __truncxfsf2(long double a); |
| float __trunctfsf2(long double a); |
| float __truncdfsf2(double a); |
| int __fixsfsi(float a); |
| int __fixdfsi(double a); |
| int __fixtfsi(long double a); |
| int __fixxfsi(long double a); |
| long __fixsfdi(float a); |
| long __fixdfdi(double a); |
| long __fixtfdi(long double a); |
| long __fixxfdi(long double a); |
| long long __fixsfti(float a); |
| long long __fixdfti(double a); |
| long long __fixtfti(long double a); |
| long long __fixxfti(long double a); |
| unsigned int __fixunssfsi(float a); |
| unsigned int __fixunsdfsi(double a); |
| unsigned int __fixunstfsi(long double a); |
| unsigned int __fixunsxfsi(long double a); |
| unsigned long __fixunssfdi(float a); |
| unsigned long __fixunsdfdi(double a); |
| unsigned long __fixunstfdi(long double a); |
| unsigned long __fixunsxfdi(long double a); |
| unsigned long long __fixunssfti(float a); |
| unsigned long long __fixunsdfti(double a); |
| unsigned long long __fixunstfti(long double a); |
| unsigned long long __fixunsxfti(long double a); |
| float __floatsisf(int i); |
| double __floatsidf(int i); |
| long double __floatsitf(int i); |
| long double __floatsixf(int i); |
| float __floatdisf(long i); |
| double __floatdidf(long i); |
| long double __floatditf(long i); |
| long double __floatdixf(long i); |
| float __floattisf(long long i); |
| double __floattidf(long long i); |
| long double __floattitf(long long i); |
| long double __floattixf(long long i); |
| float __floatunsisf(unsigned int i); |
| double __floatunsidf(unsigned int i); |
| long double __floatunsitf(unsigned int i); |
| long double __floatunsixf(unsigned int i); |
| float __floatundisf(unsigned long i); |
| double __floatundidf(unsigned long i); |
| long double __floatunditf(unsigned long i); |
| long double __floatundixf(unsigned long i); |
| float __floatuntisf(unsigned long long i); |
| double __floatuntidf(unsigned long long i); |
| long double __floatuntitf(unsigned long long i); |
| long double __floatuntixf(unsigned long long i); |
| int __cmpsf2(float a, float b); |
| int __cmpdf2(double a, double b); |
| int __cmptf2(long double a, long double b); |
| int __unordsf2(float a, float b); |
| int __unorddf2(double a, double b); |
| int __unordtf2(long double a, long double b); |
| int __eqsf2(float a, float b); |
| int __eqdf2(double a, double b); |
| int __eqtf2(long double a, long double b); |
| int __nesf2(float a, float b); |
| int __nedf2(double a, double b); |
| int __netf2(long double a, long double b); |
| int __gesf2(float a, float b); |
| int __gedf2(double a, double b); |
| int __getf2(long double a, long double b); |
| int __ltsf2(float a, float b); |
| int __ltdf2(double a, double b); |
| int __lttf2(long double a, long double b); |
| int __lesf2(float a, float b); |
| int __ledf2(double a, double b); |
| int __letf2(long double a, long double b); |
| int __gtsf2(float a, float b); |
| int __gtdf2(double a, double b); |
| int __gttf2(long double a, long double b); |
| #endif |
| /uspace/trunk/softfloat/include/div.h |
|---|
| 0,0 → 1,38 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __DIV_H__ |
| #define __DIV_H__ |
| float32 divFloat32(float32 a, float32 b); |
| float64 divFloat64(float64 a, float64 b); |
| __u64 divFloat64estim(__u64 a, __u64 b); |
| #endif |
| /uspace/trunk/softfloat/include/common.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __COMMON_H__ |
| #define __COMMON_H__ |
| #include<sftypes.h> |
| float64 finishFloat64(__s32 cexp, __u64 cfrac, char sign); |
| #endif |
| /uspace/trunk/softfloat/include/mul.h |
|---|
| 0,0 → 1,39 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __MUL_H__ |
| #define __MUL_H__ |
| float32 mulFloat32(float32 a, float32 b); |
| float64 mulFloat64(float64 a, float64 b); |
| void mul64integers(__u64 a,__u64 b, __u64 *lo, __u64 *hi); |
| #endif |
| /uspace/trunk/softfloat/include/sub.h |
|---|
| 0,0 → 1,37 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __SUB_H__ |
| #define __SUB_H__ |
| float32 subFloat32(float32 a, float32 b); |
| float64 subFloat64(float64 a, float64 b); |
| #endif |
| /uspace/trunk/softfloat/include/add.h |
|---|
| 0,0 → 1,37 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __ADD_H__ |
| #define __ADD_H__ |
| float32 addFloat32(float32 a, float32 b); |
| float64 addFloat64(float64 a, float64 b); |
| #endif |
| /uspace/trunk/softfloat/include/comparison.h |
|---|
| 0,0 → 1,49 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __COMPARISON_H__ |
| #define __COMPARISON_H__ |
| inline int isFloat32NaN(float32 f); |
| inline int isFloat32SigNaN(float32 f); |
| inline int isFloat32Infinity(float32 f); |
| inline int isFloat32Zero(float32 f); |
| inline int isFloat64NaN(float64 d); |
| inline int isFloat64SigNaN(float64 d); |
| inline int isFloat64Infinity(float64 d); |
| inline int isFloat64Zero(float64 d); |
| inline int isFloat32eq(float32 a, float32 b); |
| inline int isFloat32lt(float32 a, float32 b); |
| inline int isFloat32gt(float32 a, float32 b); |
| #endif |
| /uspace/trunk/softfloat/include/conversion.h |
|---|
| 0,0 → 1,37 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __CONVERSION_H__ |
| #define __CONVERSION_H__ |
| float64 convertFloat32ToFloat64(float32 a); |
| float32 convertFloat64ToFloat32(float64 a); |
| #endif |
| /uspace/trunk/softfloat/include/other.h |
|---|
| 0,0 → 1,33 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #ifndef __OTHER_H__ |
| #define __OTHER_H__ |
| #endif |
| /uspace/trunk/softfloat/generic/softfloat.c |
|---|
| 0,0 → 1,416 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include<softfloat.h> |
| #include<sftypes.h> |
| #include<add.h> |
| #include<sub.h> |
| #include<mul.h> |
| #include<div.h> |
| #include<conversion.h> |
| #include<comparison.h> |
| #include<other.h> |
| #include<arch.h> |
| #include<types.h> |
| #include<functions.h> |
| /* Arithmetic functions */ |
| float __addsf3(float a, float b) |
| { |
| 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) |
| { |
| 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; |
| } |
| float __subsf3(float a, float b) |
| { |
| 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) |
| { |
| 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; |
| } |
| 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; |
| } |
| 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; |
| } |
| float __negsf2(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| fa.parts.sign = !fa.parts.sign; |
| return fa.f; |
| } |
| double __negdf2(double a) |
| { |
| float64 fa; |
| fa.d = a; |
| fa.parts.sign = !fa.parts.sign; |
| return fa.d; |
| } |
| /* Conversion functions */ |
| double __extendsfdf2(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return convertFloat32ToFloat64(fa).d; |
| } |
| float __truncdfsf2(double a) |
| { |
| float64 da; |
| da.d = a; |
| return convertFloat64ToFloat32(da).f; |
| } |
| int __fixsfsi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_int(fa); |
| } |
| int __fixdfsi(double a) |
| { |
| } |
| long __fixsfdi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_long(fa); |
| } |
| long __fixdfdi(double a) |
| { |
| } |
| long long __fixsfti(float a) |
| { |
| } |
| long long __fixdfti(double a) |
| { |
| } |
| unsigned int __fixunssfsi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_uint(fa); |
| } |
| unsigned int __fixunsdfsi(double a) |
| { |
| } |
| unsigned long __fixunssfdi(float a) |
| { |
| float32 fa; |
| fa.f = a; |
| return float32_to_long(fa); |
| } |
| unsigned long __fixunsdfdi(double a) |
| { |
| } |
| unsigned long long __fixunssfti(float a) |
| { |
| } |
| unsigned long long __fixunsdfti(double a) |
| { |
| } |
| float __floatsisf(int i) |
| { |
| } |
| double __floatsidf(int i) |
| { |
| } |
| float __floatdisf(long i) |
| { |
| } |
| double __floatdidf(long i) |
| { |
| } |
| float __floattisf(long long i) |
| { |
| } |
| double __floattidf(long long i) |
| { |
| } |
| float __floatunsisf(unsigned int i) |
| { |
| } |
| double __floatunsidf(unsigned int i) |
| { |
| } |
| float __floatundisf(unsigned long i) |
| { |
| } |
| double __floatundidf(unsigned long i) |
| { |
| } |
| float __floatuntisf(unsigned long long i) |
| { |
| } |
| double __floatuntidf(unsigned long long i) |
| { |
| } |
| /* Comparison functions */ |
| /* Comparison functions */ |
| /* a<b .. -1 |
| * a=b .. 0 |
| * a>b .. 1 |
| * */ |
| int __cmpsf2(float a, float b) |
| { |
| 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; |
| } |
| int __unordsf2(float a, float b) |
| { |
| float32 fa, fb; |
| fa.f = a; |
| fb.f = b; |
| return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ); |
| } |
| /** |
| * @return zero, if neither argument is a NaN and are equal |
| * */ |
| 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; |
| } |
| /* strange behavior, but it was in gcc documentation */ |
| int __nesf2(float a, float b) |
| { |
| return __eqsf2(a, b); |
| } |
| /* return value >= 0 if a>=b and neither is NaN */ |
| int __gesf2(float a, float b) |
| { |
| 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; |
| } |
| /** Return negative value, if a<b and neither is NaN*/ |
| int __ltsf2(float a, float b) |
| { |
| 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; |
| } |
| /* return value <= 0 if a<=b and neither is NaN */ |
| int __lesf2(float a, float b) |
| { |
| 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; |
| } |
| /** Return positive value, if a>b and neither is NaN*/ |
| int __gtsf2(float a, float b) |
| { |
| 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; |
| } |
| /* Other functions */ |
| float __powisf2(float a, int b) |
| { |
| /* TODO: */ |
| } |
| float __mulsc3(float a, float b, float c, float d) |
| { |
| /* TODO: */ |
| } |
| float __divsc3(float a, float b, float c, float d) |
| { |
| /* TODO: */ |
| } |
| /uspace/trunk/softfloat/generic/conversion.c |
|---|
| 0,0 → 1,210 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include "sftypes.h" |
| #include "conversion.h" |
| #include "comparison.h" |
| float64 convertFloat32ToFloat64(float32 a) |
| { |
| float64 result; |
| __u64 frac; |
| result.parts.sign = a.parts.sign; |
| result.parts.fraction = a.parts.fraction; |
| result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE ); |
| if ((isFloat32Infinity(a))||(isFloat32NaN(a))) { |
| result.parts.exp = 0x7FF; |
| /* TODO; check if its correct for SigNaNs*/ |
| return result; |
| }; |
| result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS ); |
| if (a.parts.exp == 0) { |
| /* normalize denormalized numbers */ |
| if (result.parts.fraction == 0ll) { /* fix zero */ |
| result.parts.exp = 0ll; |
| return result; |
| } |
| frac = result.parts.fraction; |
| while (!(frac & (0x10000000000000ll))) { |
| frac <<= 1; |
| --result.parts.exp; |
| }; |
| ++result.parts.exp; |
| result.parts.fraction = frac; |
| }; |
| return result; |
| } |
| float32 convertFloat64ToFloat32(float64 a) |
| { |
| float32 result; |
| __s32 exp; |
| __u64 frac; |
| result.parts.sign = a.parts.sign; |
| if (isFloat64NaN(a)) { |
| result.parts.exp = 0xFF; |
| if (isFloat64SigNaN(a)) { |
| result.parts.fraction = 0x800000; /* set first bit of fraction nonzero */ |
| return result; |
| } |
| result.parts.fraction = 0x1; /* fraction nonzero but its first bit is zero */ |
| return result; |
| }; |
| if (isFloat64Infinity(a)) { |
| result.parts.fraction = 0; |
| result.parts.exp = 0xFF; |
| return result; |
| }; |
| exp = (int)a.parts.exp - FLOAT64_BIAS + FLOAT32_BIAS; |
| if (exp >= 0xFF) { |
| /*FIXME: overflow*/ |
| result.parts.fraction = 0; |
| result.parts.exp = 0xFF; |
| return result; |
| } else if (exp <= 0 ) { |
| /* underflow or denormalized */ |
| result.parts.exp = 0; |
| exp *= -1; |
| if (exp > FLOAT32_FRACTION_SIZE ) { |
| /* FIXME: underflow */ |
| result.parts.fraction = 0; |
| return result; |
| }; |
| /* denormalized */ |
| frac = a.parts.fraction; |
| frac |= 0x10000000000000ll; /* denormalize and set hidden bit */ |
| frac >>= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE + 1); |
| while (exp > 0) { |
| --exp; |
| frac >>= 1; |
| }; |
| result.parts.fraction = frac; |
| return result; |
| }; |
| result.parts.exp = exp; |
| result.parts.fraction = a.parts.fraction >> (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE); |
| return result; |
| } |
| /** Helping procedure for converting float32 to uint32 |
| * @param a floating point number in normalized form (no NaNs or Inf are checked ) |
| * @return unsigned integer |
| */ |
| static __u32 _float32_to_uint32_helper(float32 a) |
| { |
| __u32 frac; |
| if (a.parts.exp < FLOAT32_BIAS) { |
| /*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 <<= 32 - FLOAT32_FRACTION_SIZE - 1; |
| frac >>= 32 - (a.parts.exp - FLOAT32_BIAS) - 1; |
| if ((a.parts.sign == 1) && (frac != 0)) { |
| frac = ~frac; |
| ++frac; |
| } |
| return frac; |
| } |
| /* Convert float to unsigned int32 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| __u32 float32_to_uint32(float32 a) |
| { |
| if (isFloat32NaN(a)) { |
| return MAX_UINT32; |
| } |
| if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_UINT32; |
| } |
| return MAX_UINT32; |
| } |
| return _float32_to_uint32_helper(a); |
| } |
| /* Convert float to signed int32 |
| * FIXME: Im not sure what to return if overflow/underflow happens |
| * - now its the biggest or the smallest int |
| */ |
| __s32 float32_to_int32(float32 a) |
| { |
| if (isFloat32NaN(a)) { |
| return MAX_INT32; |
| } |
| if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) { |
| if (a.parts.sign) { |
| return MIN_INT32; |
| } |
| return MAX_INT32; |
| } |
| return _float32_to_uint32_helper(a); |
| } |
| /uspace/trunk/softfloat/generic/div.c |
|---|
| 0,0 → 1,356 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include<sftypes.h> |
| #include<add.h> |
| #include<div.h> |
| #include<comparison.h> |
| #include<mul.h> |
| #include<common.h> |
| float32 divFloat32(float32 a, float32 b) |
| { |
| float32 result; |
| __s32 aexp, bexp, cexp; |
| __u64 afrac, bfrac, cfrac; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat32NaN(a)) { |
| if (isFloat32SigNaN(a)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return a; |
| } |
| if (isFloat32NaN(b)) { |
| if (isFloat32SigNaN(b)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return b; |
| } |
| if (isFloat32Infinity(a)) { |
| if (isFloat32Infinity(b)) { |
| /*FIXME: inf / inf */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| /* inf / num */ |
| result.parts.exp = a.parts.exp; |
| result.parts.fraction = a.parts.fraction; |
| return result; |
| } |
| if (isFloat32Infinity(b)) { |
| if (isFloat32Zero(a)) { |
| /* FIXME 0 / inf */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* FIXME: num / inf*/ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| if (isFloat32Zero(b)) { |
| if (isFloat32Zero(a)) { |
| /*FIXME: 0 / 0*/ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| /* FIXME: division by zero */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| afrac = a.parts.fraction; |
| aexp = a.parts.exp; |
| bfrac = b.parts.fraction; |
| bexp = b.parts.exp; |
| /* denormalized numbers */ |
| if (aexp == 0) { |
| if (afrac == 0) { |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* normalize it*/ |
| afrac <<= 1; |
| /* afrac is nonzero => it must stop */ |
| while (! (afrac & FLOAT32_HIDDEN_BIT_MASK) ) { |
| afrac <<= 1; |
| aexp--; |
| } |
| } |
| if (bexp == 0) { |
| bfrac <<= 1; |
| /* bfrac is nonzero => it must stop */ |
| while (! (bfrac & FLOAT32_HIDDEN_BIT_MASK) ) { |
| bfrac <<= 1; |
| bexp--; |
| } |
| } |
| 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; |
| aexp++; |
| } |
| cexp = aexp - bexp + FLOAT32_BIAS - 2; |
| cfrac = (afrac << 32) / bfrac; |
| if (( cfrac & 0x3F ) == 0) { |
| cfrac |= ( bfrac * cfrac != afrac << 32 ); |
| } |
| /* pack and round */ |
| /* find first nonzero digit and shift result and detect possibly underflow */ |
| while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7 )))) { |
| cexp--; |
| cfrac <<= 1; |
| /* TODO: fix underflow */ |
| }; |
| cfrac += (0x1 << 6); /* FIXME: 7 is not sure*/ |
| if (cfrac & (FLOAT32_HIDDEN_BIT_MASK << 7)) { |
| ++cexp; |
| cfrac >>= 1; |
| } |
| /* check overflow */ |
| if (cexp >= FLOAT32_MAX_EXPONENT ) { |
| /* FIXME: overflow, return infinity */ |
| result.parts.exp = FLOAT32_MAX_EXPONENT; |
| result.parts.fraction = 0; |
| return result; |
| } |
| if (cexp < 0) { |
| /* FIXME: underflow */ |
| result.parts.exp = 0; |
| if ((cexp + FLOAT32_FRACTION_SIZE) < 0) { |
| result.parts.fraction = 0; |
| return result; |
| } |
| cfrac >>= 1; |
| while (cexp < 0) { |
| cexp ++; |
| cfrac >>= 1; |
| } |
| } else { |
| result.parts.exp = (__u32)cexp; |
| } |
| result.parts.fraction = ((cfrac >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); |
| return result; |
| } |
| float64 divFloat64(float64 a, float64 b) |
| { |
| float64 result; |
| __s64 aexp, bexp, cexp; |
| __u64 afrac, bfrac, cfrac; |
| __u64 remlo, remhi; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat64NaN(a)) { |
| if (isFloat64SigNaN(b)) { |
| /*FIXME: SigNaN*/ |
| return b; |
| } |
| if (isFloat64SigNaN(a)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return a; |
| } |
| if (isFloat64NaN(b)) { |
| if (isFloat64SigNaN(b)) { |
| /*FIXME: SigNaN*/ |
| } |
| /*NaN*/ |
| return b; |
| } |
| if (isFloat64Infinity(a)) { |
| if (isFloat64Infinity(b) || isFloat64Zero(b)) { |
| /*FIXME: inf / inf */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| /* inf / num */ |
| result.parts.exp = a.parts.exp; |
| result.parts.fraction = a.parts.fraction; |
| return result; |
| } |
| if (isFloat64Infinity(b)) { |
| if (isFloat64Zero(a)) { |
| /* FIXME 0 / inf */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* FIXME: num / inf*/ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| if (isFloat64Zero(b)) { |
| if (isFloat64Zero(a)) { |
| /*FIXME: 0 / 0*/ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| /* FIXME: division by zero */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| afrac = a.parts.fraction; |
| aexp = a.parts.exp; |
| bfrac = b.parts.fraction; |
| bexp = b.parts.exp; |
| /* denormalized numbers */ |
| if (aexp == 0) { |
| if (afrac == 0) { |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| } |
| /* normalize it*/ |
| aexp++; |
| /* afrac is nonzero => it must stop */ |
| while (! (afrac & FLOAT64_HIDDEN_BIT_MASK) ) { |
| afrac <<= 1; |
| aexp--; |
| } |
| } |
| if (bexp == 0) { |
| bexp++; |
| /* bfrac is nonzero => it must stop */ |
| while (! (bfrac & FLOAT64_HIDDEN_BIT_MASK) ) { |
| bfrac <<= 1; |
| bexp--; |
| } |
| } |
| 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; |
| aexp++; |
| } |
| cexp = aexp - bexp + FLOAT64_BIAS - 2; |
| cfrac = divFloat64estim(afrac, bfrac); |
| if (( cfrac & 0x1FF ) <= 2) { /*FIXME:?? */ |
| mul64integers( bfrac, cfrac, &remlo, &remhi); |
| /* (__u128)afrac << 64 - ( ((__u128)remhi<<64) + (__u128)remlo )*/ |
| remhi = afrac - remhi - ( remlo > 0); |
| remlo = - remlo; |
| while ((__s64) remhi < 0) { |
| cfrac--; |
| remlo += bfrac; |
| remhi += ( remlo < bfrac ); |
| } |
| cfrac |= ( remlo != 0 ); |
| } |
| /* round and shift */ |
| result = finishFloat64(cexp, cfrac, result.parts.sign); |
| return result; |
| } |
| __u64 divFloat64estim(__u64 a, __u64 b) |
| { |
| __u64 bhi; |
| __u64 remhi, remlo; |
| __u64 result; |
| if ( b <= a ) { |
| return 0xFFFFFFFFFFFFFFFFull; |
| } |
| bhi = b >> 32; |
| result = ((bhi << 32) <= a) ?( 0xFFFFFFFFull << 32) : ( a / bhi) << 32; |
| mul64integers(b, result, &remlo, &remhi); |
| remhi = a - remhi - (remlo > 0); |
| remlo = - remlo; |
| b <<= 32; |
| while ( (__s64) remhi < 0 ) { |
| result -= 0x1ll << 32; |
| remlo += b; |
| remhi += bhi + ( remlo < b ); |
| } |
| remhi = (remhi << 32) | (remlo >> 32); |
| if (( bhi << 32) <= remhi) { |
| result |= 0xFFFFFFFF; |
| } else { |
| result |= remhi / bhi; |
| } |
| return result; |
| } |
| /uspace/trunk/softfloat/generic/common.c |
|---|
| 0,0 → 1,95 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include<sftypes.h> |
| #include<common.h> |
| /** Take fraction shifted by 10 bits to left, round it, normalize it and detect exceptions |
| * @param exp exponent with bias |
| * @param cfrac fraction shifted 10 places left with added hidden bit |
| * @return valied float64 |
| */ |
| float64 finishFloat64(__s32 cexp, __u64 cfrac, char sign) |
| { |
| float64 result; |
| result.parts.sign = sign; |
| /* find first nonzero digit and shift result and detect possibly underflow */ |
| while ((cexp > 0) && (cfrac) && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ) )))) { |
| cexp--; |
| cfrac <<= 1; |
| /* TODO: fix underflow */ |
| }; |
| if ((cexp < 0) || ( cexp == 0 && (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1)))))) { |
| /* FIXME: underflow */ |
| result.parts.exp = 0; |
| if ((cexp + FLOAT64_FRACTION_SIZE + 1) < 0) { /* +1 is place for rounding */ |
| result.parts.fraction = 0; |
| return result; |
| } |
| while (cexp < 0) { |
| cexp++; |
| cfrac >>= 1; |
| } |
| cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); |
| if (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_HIDDEN_BIT_MASK - 1)))) { |
| result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2) ) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| return result; |
| } |
| } else { |
| cfrac += (0x1 << (64 - FLOAT64_FRACTION_SIZE - 3)); |
| } |
| ++cexp; |
| if (cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1 ))) { |
| ++cexp; |
| cfrac >>= 1; |
| } |
| /* check overflow */ |
| if (cexp >= FLOAT64_MAX_EXPONENT ) { |
| /* FIXME: overflow, return infinity */ |
| result.parts.exp = FLOAT64_MAX_EXPONENT; |
| result.parts.fraction = 0; |
| return result; |
| } |
| result.parts.exp = (__u32)cexp; |
| result.parts.fraction = ((cfrac >>(64 - FLOAT64_FRACTION_SIZE - 2 ) ) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| return result; |
| } |
| /uspace/trunk/softfloat/generic/add.c |
|---|
| 0,0 → 1,252 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include<sftypes.h> |
| #include<add.h> |
| #include<comparison.h> |
| /** Add two Float32 numbers with same signs |
| */ |
| float32 addFloat32(float32 a, float32 b) |
| { |
| int expdiff; |
| __u32 exp1, exp2,frac1, frac2; |
| expdiff = a.parts.exp - b.parts.exp; |
| if (expdiff < 0) { |
| if (isFloat32NaN(b)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat32SigNaN(b)) { |
| }; |
| return b; |
| }; |
| if (b.parts.exp == FLOAT32_MAX_EXPONENT) { |
| return b; |
| } |
| frac1 = b.parts.fraction; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| if ((isFloat32NaN(a)) || (isFloat32NaN(b))) { |
| /* TODO: fix SigNaN */ |
| if (isFloat32SigNaN(a) || isFloat32SigNaN(b)) { |
| }; |
| return (isFloat32NaN(a)?a:b); |
| }; |
| if (a.parts.exp == FLOAT32_MAX_EXPONENT) { |
| return a; |
| } |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| frac1 += frac2; |
| if (frac1 & FLOAT32_HIDDEN_BIT_MASK ) { |
| /* result is not denormalized */ |
| a.parts.exp = 1; |
| }; |
| a.parts.fraction = frac1; |
| return a; |
| }; |
| frac1 |= FLOAT32_HIDDEN_BIT_MASK; /* add hidden bit */ |
| if (exp2 == 0) { |
| /* second operand is denormalized */ |
| --expdiff; |
| } else { |
| /* add hidden bit to second operand */ |
| frac2 |= FLOAT32_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| if (expdiff < (FLOAT32_FRACTION_SIZE + 2) ) { |
| frac2 >>= expdiff; |
| frac1 += frac2; |
| } else { |
| a.parts.exp = exp1; |
| a.parts.fraction = (frac1 >> 6) & (~(FLOAT32_HIDDEN_BIT_MASK)); |
| return a; |
| } |
| if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += (0x1 << 5); |
| if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { |
| /* rounding overflow */ |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| if ((exp1 == FLOAT32_MAX_EXPONENT ) || (exp2 > exp1)) { |
| /* overflow - set infinity as result */ |
| a.parts.exp = FLOAT32_MAX_EXPONENT; |
| a.parts.fraction = 0; |
| return a; |
| } |
| a.parts.exp = exp1; |
| /*Clear hidden bit and shift */ |
| a.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)) ; |
| return a; |
| } |
| /** Add two Float64 numbers with same signs |
| */ |
| float64 addFloat64(float64 a, float64 b) |
| { |
| int expdiff; |
| __u32 exp1, exp2; |
| __u64 frac1, frac2; |
| expdiff = ((int )a.parts.exp) - b.parts.exp; |
| if (expdiff < 0) { |
| 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; |
| } |
| frac1 = b.parts.fraction; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| if (isFloat64NaN(a)) { |
| /* TODO: fix SigNaN */ |
| if (isFloat64SigNaN(a) || isFloat64SigNaN(b)) { |
| }; |
| return a; |
| }; |
| /* a is infinity and b not */ |
| if (a.parts.exp == FLOAT64_MAX_EXPONENT ) { |
| return a; |
| } |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| frac1 += frac2; |
| if (frac1 & FLOAT64_HIDDEN_BIT_MASK) { |
| /* result is not denormalized */ |
| a.parts.exp = 1; |
| }; |
| a.parts.fraction = frac1; |
| return a; |
| }; |
| /* add hidden bit - frac1 is sure not denormalized */ |
| frac1 |= FLOAT64_HIDDEN_BIT_MASK; |
| /* second operand ... */ |
| if (exp2 == 0) { |
| /* ... is denormalized */ |
| --expdiff; |
| } else { |
| /* is not denormalized */ |
| frac2 |= FLOAT64_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| if (expdiff < (FLOAT64_FRACTION_SIZE + 2) ) { |
| frac2 >>= expdiff; |
| frac1 += frac2; |
| } else { |
| a.parts.exp = exp1; |
| a.parts.fraction = (frac1 >> 6) & (~(FLOAT64_HIDDEN_BIT_MASK)); |
| return a; |
| } |
| if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7) ) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += (0x1 << 5); |
| if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { |
| /* rounding overflow */ |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| if ((exp1 == FLOAT64_MAX_EXPONENT ) || (exp2 > exp1)) { |
| /* overflow - set infinity as result */ |
| a.parts.exp = FLOAT64_MAX_EXPONENT; |
| a.parts.fraction = 0; |
| return a; |
| } |
| a.parts.exp = exp1; |
| /*Clear hidden bit and shift */ |
| a.parts.fraction = ( (frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| return a; |
| } |
| /uspace/trunk/softfloat/generic/mul.c |
|---|
| 0,0 → 1,287 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include<sftypes.h> |
| #include<mul.h> |
| #include<comparison.h> |
| #include<common.h> |
| /** Multiply two 32 bit float numbers |
| * |
| */ |
| float32 mulFloat32(float32 a, float32 b) |
| { |
| float32 result; |
| __u64 frac1, frac2; |
| __s32 exp; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat32NaN(a) || isFloat32NaN(b) ) { |
| /* TODO: fix SigNaNs */ |
| if (isFloat32SigNaN(a)) { |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| }; |
| if (isFloat32SigNaN(b)) { /* TODO: fix SigNaN */ |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| return result; |
| }; |
| /* set NaN as result */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| }; |
| if (isFloat32Infinity(a)) { |
| if (isFloat32Zero(b)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| } |
| if (isFloat32Infinity(b)) { |
| if (isFloat32Zero(a)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT32_NAN; |
| return result; |
| } |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| return result; |
| } |
| /* exp is signed so we can easy detect underflow */ |
| exp = a.parts.exp + b.parts.exp; |
| exp -= FLOAT32_BIAS; |
| if (exp >= FLOAT32_MAX_EXPONENT) { |
| /* FIXME: overflow */ |
| /* set infinity as result */ |
| result.binary = FLOAT32_INF; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| return result; |
| }; |
| if (exp < 0) { |
| /* FIXME: underflow */ |
| /* return signed zero */ |
| result.parts.fraction = 0x0; |
| result.parts.exp = 0x0; |
| return result; |
| }; |
| frac1 = a.parts.fraction; |
| if (a.parts.exp > 0) { |
| frac1 |= FLOAT32_HIDDEN_BIT_MASK; |
| } else { |
| ++exp; |
| }; |
| frac2 = b.parts.fraction; |
| if (b.parts.exp > 0) { |
| frac2 |= FLOAT32_HIDDEN_BIT_MASK; |
| } else { |
| ++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)))) { |
| /* 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)))) { |
| ++exp; |
| frac1 >>= 1; |
| }; |
| if (exp >= FLOAT32_MAX_EXPONENT ) { |
| /* TODO: fix overflow */ |
| /* return infinity*/ |
| result.parts.exp = FLOAT32_MAX_EXPONENT; |
| result.parts.fraction = 0x0; |
| return result; |
| } |
| exp -= FLOAT32_FRACTION_SIZE; |
| if (exp <= FLOAT32_FRACTION_SIZE) { |
| /* denormalized number */ |
| frac1 >>= 1; /* denormalize */ |
| while ((frac1 > 0) && (exp < 0)) { |
| frac1 >>= 1; |
| ++exp; |
| }; |
| if (frac1 == 0) { |
| /* FIXME : underflow */ |
| result.parts.exp = 0; |
| result.parts.fraction = 0; |
| return result; |
| }; |
| }; |
| result.parts.exp = exp; |
| result.parts.fraction = frac1 & ( (1 << FLOAT32_FRACTION_SIZE) - 1); |
| return result; |
| } |
| /** Multiply two 64 bit float numbers |
| * |
| */ |
| float64 mulFloat64(float64 a, float64 b) |
| { |
| float64 result; |
| __u64 frac1, frac2; |
| __s32 exp; |
| result.parts.sign = a.parts.sign ^ b.parts.sign; |
| if (isFloat64NaN(a) || isFloat64NaN(b) ) { |
| /* TODO: fix SigNaNs */ |
| if (isFloat64SigNaN(a)) { |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| }; |
| if (isFloat64SigNaN(b)) { /* TODO: fix SigNaN */ |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| return result; |
| }; |
| /* set NaN as result */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| }; |
| if (isFloat64Infinity(a)) { |
| if (isFloat64Zero(b)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| result.parts.fraction = a.parts.fraction; |
| result.parts.exp = a.parts.exp; |
| return result; |
| } |
| if (isFloat64Infinity(b)) { |
| if (isFloat64Zero(a)) { |
| /* FIXME: zero * infinity */ |
| result.binary = FLOAT64_NAN; |
| return result; |
| } |
| result.parts.fraction = b.parts.fraction; |
| result.parts.exp = b.parts.exp; |
| 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; |
| } else { |
| ++exp; |
| }; |
| frac2 = b.parts.fraction; |
| if (b.parts.exp > 0) { |
| frac2 |= FLOAT64_HIDDEN_BIT_MASK; |
| } else { |
| ++exp; |
| }; |
| frac1 <<= (64 - FLOAT64_FRACTION_SIZE - 1); |
| frac2 <<= (64 - FLOAT64_FRACTION_SIZE - 2); |
| mul64integers(frac1, frac2, &frac1, &frac2); |
| frac2 |= (frac1 != 0); |
| if (frac2 & (0x1ll << 62)) { |
| frac2 <<= 1; |
| exp--; |
| } |
| result = finishFloat64(exp, frac2, result.parts.sign); |
| return result; |
| } |
| /** Multiply two 64 bit numbers and return result in two parts |
| * @param a first operand |
| * @param b second operand |
| * @param lo lower part from result |
| * @param hi higher part of result |
| */ |
| void mul64integers(__u64 a,__u64 b, __u64 *lo, __u64 *hi) |
| { |
| __u64 low, high, middle1, middle2; |
| __u32 alow, blow; |
| alow = a & 0xFFFFFFFF; |
| blow = b & 0xFFFFFFFF; |
| a >>= 32; |
| b >>= 32; |
| low = ((__u64)alow) * blow; |
| middle1 = a * blow; |
| middle2 = alow * b; |
| high = a * b; |
| middle1 += middle2; |
| high += (((__u64)(middle1 < middle2)) << 32) + (middle1 >> 32); |
| middle1 <<= 32; |
| low += middle1; |
| high += (low < middle1); |
| *lo = low; |
| *hi = high; |
| return; |
| } |
| /uspace/trunk/softfloat/generic/sub.c |
|---|
| 0,0 → 1,255 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include<sftypes.h> |
| #include<sub.h> |
| #include<comparison.h> |
| /** Subtract two float32 numbers with same signs |
| */ |
| float32 subFloat32(float32 a, float32 b) |
| { |
| int expdiff; |
| __u32 exp1, exp2, frac1, frac2; |
| float32 result; |
| result.f = 0; |
| expdiff = a.parts.exp - b.parts.exp; |
| 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; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| 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.binary = FLOAT32_NAN; |
| return result; |
| }; |
| return a; |
| } |
| result.parts.sign = a.parts.sign; |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| result.parts.fraction = frac1-frac2; |
| if (result.parts.fraction > frac1) { |
| /* TODO: underflow exception */ |
| return result; |
| }; |
| result.parts.exp = 0; |
| return result; |
| }; |
| /* add hidden bit */ |
| frac1 |= FLOAT32_HIDDEN_BIT_MASK; |
| if (exp2 == 0) { |
| /* denormalized */ |
| --expdiff; |
| } else { |
| /* normalized */ |
| frac2 |= FLOAT32_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| 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 */ |
| while ((exp1 > 0) && (!(frac1 & (FLOAT32_HIDDEN_BIT_MASK << 6 )))) { |
| --exp1; |
| frac1 <<= 1; |
| /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += 0x20; |
| if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /*Clear hidden bit and shift */ |
| result.parts.fraction = ((frac1 >> 6) & (~FLOAT32_HIDDEN_BIT_MASK)); |
| result.parts.exp = exp1; |
| return result; |
| } |
| /** Subtract two float64 numbers with same signs |
| */ |
| float64 subFloat64(float64 a, float64 b) |
| { |
| int expdiff; |
| __u32 exp1, exp2; |
| __u64 frac1, frac2; |
| float64 result; |
| result.d = 0; |
| expdiff = a.parts.exp - b.parts.exp; |
| 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; |
| exp1 = b.parts.exp; |
| frac2 = a.parts.fraction; |
| exp2 = a.parts.exp; |
| expdiff *= -1; |
| } else { |
| 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.binary = FLOAT64_NAN; |
| return result; |
| }; |
| return a; |
| } |
| result.parts.sign = a.parts.sign; |
| frac1 = a.parts.fraction; |
| exp1 = a.parts.exp; |
| frac2 = b.parts.fraction; |
| exp2 = b.parts.exp; |
| }; |
| if (exp1 == 0) { |
| /* both are denormalized */ |
| result.parts.fraction = frac1 - frac2; |
| if (result.parts.fraction > frac1) { |
| /* TODO: underflow exception */ |
| return result; |
| }; |
| result.parts.exp = 0; |
| return result; |
| }; |
| /* add hidden bit */ |
| frac1 |= FLOAT64_HIDDEN_BIT_MASK; |
| if (exp2 == 0) { |
| /* denormalized */ |
| --expdiff; |
| } else { |
| /* normalized */ |
| frac2 |= FLOAT64_HIDDEN_BIT_MASK; |
| }; |
| /* create some space for rounding */ |
| frac1 <<= 6; |
| frac2 <<= 6; |
| 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 */ |
| while ((exp1 > 0) && (!(frac1 & (FLOAT64_HIDDEN_BIT_MASK << 6 )))) { |
| --exp1; |
| frac1 <<= 1; |
| /* TODO: fix underflow - frac1 == 0 does not necessary means underflow... */ |
| }; |
| /* rounding - if first bit after fraction is set then round up */ |
| frac1 += 0x20; |
| if (frac1 & (FLOAT64_HIDDEN_BIT_MASK << 7)) { |
| ++exp1; |
| frac1 >>= 1; |
| }; |
| /*Clear hidden bit and shift */ |
| result.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK)); |
| result.parts.exp = exp1; |
| return result; |
| } |
| /uspace/trunk/softfloat/generic/comparison.c |
|---|
| 0,0 → 1,123 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| #include<sftypes.h> |
| #include<comparison.h> |
| inline int isFloat32NaN(float32 f) |
| { /* NaN : exp = 0xff and nonzero fraction */ |
| return ((f.parts.exp==0xFF)&&(f.parts.fraction)); |
| }; |
| inline int isFloat64NaN(float64 d) |
| { /* NaN : exp = 0x7ff and nonzero fraction */ |
| return ((d.parts.exp==0x7FF)&&(d.parts.fraction)); |
| }; |
| inline int isFloat32SigNaN(float32 f) |
| { /* SigNaN : exp = 0xff fraction = 0xxxxx..x (binary), where at least one x is nonzero */ |
| return ((f.parts.exp==0xFF)&&(f.parts.fraction<0x400000)&&(f.parts.fraction)); |
| }; |
| inline int isFloat64SigNaN(float64 d) |
| { /* SigNaN : exp = 0x7ff fraction = 0xxxxx..x (binary), where at least one x is nonzero */ |
| return ((d.parts.exp==0x7FF)&&(d.parts.fraction)&&(d.parts.fraction<0x8000000000000ll)); |
| }; |
| inline int isFloat32Infinity(float32 f) |
| { |
| return ((f.parts.exp==0xFF)&&(f.parts.fraction==0x0)); |
| }; |
| inline int isFloat64Infinity(float64 d) |
| { |
| return ((d.parts.exp==0x7FF)&&(d.parts.fraction==0x0)); |
| }; |
| inline int isFloat32Zero(float32 f) |
| { |
| return (((f.binary) & 0x7FFFFFFF) == 0); |
| } |
| inline int isFloat64Zero(float64 d) |
| { |
| return (((d.binary) & 0x7FFFFFFFFFFFFFFFll) == 0); |
| } |
| /** |
| * @return 1, if both floats are equal - but NaNs are not recognized |
| */ |
| inline int isFloat32eq(float32 a, float32 b) |
| { |
| return ((a.binary==b.binary)||(((a.binary| b.binary)&0x7FFFFFFF)==0)); /* a equals to b or both are zeros (with any sign) */ |
| } |
| /** |
| * @return 1, if a<b - but NaNs are not recognized |
| */ |
| inline 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.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); |
| } |
| /** |
| * @return 1, if a>b - but NaNs are not recognized |
| */ |
| inline 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.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); |
| } |
| /uspace/trunk/softfloat/generic/other.c |
|---|
| 0,0 → 1,29 |
| /* |
| * Copyright (C) 2005 Josef Cejka |
| * 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. |
| */ |
| /uspace/trunk/softfloat/arch/ia32/include/arch.h |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (C) 2006 Josef Cejka |
| * 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. |
| */ |
| #ifndef __ia32_ARCH_H__ |
| #define __ia32_ARCH_H__ |
| #define __LITTLE_ENDIAN__ |
| #endif |
| /uspace/trunk/softfloat/arch/ia32/include/types.h |
|---|
| 0,0 → 1,57 |
| /* |
| * Copyright (C) 2006 Josef Cejka |
| * 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. |
| */ |
| #ifndef __ia32_TYPES_H__ |
| #define __ia32_TYPES_H__ |
| typedef char __s8; |
| typedef short __s16; |
| typedef long __s32; |
| typedef long long __s64; |
| typedef unsigned char __u8; |
| typedef unsigned short __u16; |
| typedef unsigned long __u32; |
| typedef unsigned long long __u64; |
| #define MAX_INT32 (0x7FFFFFFF) |
| #define MIN_INT32 (0x80000000) |
| #define MAX_UINT32 (0xFFFFFFFF) |
| #define MIN_UINT32 (0) |
| #define MAX_INT64 (0x7FFFFFFFFFFFFFFFll) |
| #define MIN_INT64 (0x8000000000000000ll) |
| #define MAX_UINT64 (0xFFFFFFFFFFFFFFFll) |
| #define MIN_UINT64 (0ll) |
| #endif |
| /uspace/trunk/softfloat/arch/ia32/include/functions.h |
|---|
| 0,0 → 1,44 |
| /* |
| * Copyright (C) 2006 Josef Cejka |
| * 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. |
| */ |
| #ifndef __ia32_FUNCTIONS_H__ |
| #define __ia32_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 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); |
| #endif |
| /uspace/trunk/softfloat/Makefile |
|---|
| 0,0 → 1,3 |
| all: |
| clean: |
| /uspace/trunk/uspace.config |
|---|
| 0,0 → 1,14 |
| ## General configuration directives |
| # Architecture |
| @ "ia32" Intel IA-32 |
| @ "amd64" AMD64/Intel EM64T |
| @ "mips32" MIPS 32-bit Little Endian |
| @ "mips32eb" MIPS 32-bit Big Endian |
| ! ARCH (choice) |
| # IA32 Compiler |
| @ "cross" Cross-compiler |
| @ "native" Native |
| ! [ARCH=ia32] IA32_COMPILER (choice) |
| % [ARCH=ia32] SAVEAS IA32_COMPILER COMPILER |
| /uspace/trunk/libc/arch/mips32eb/Makefile.inc |
|---|
| 0,0 → 1,36 |
| # |
| # Copyright (C) 2005 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. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = mips-sgi-irix5 |
| TOOLCHAIN_DIR = /usr/local/mips/bin |
| CFLAGS += -mno-abicalls -mips3 |
| ARCH_SOURCES += arch/$(ARCH)/src/syscall.c |
| /uspace/trunk/libc/arch/mips32eb/_link.ld.in |
|---|
| 0,0 → 1,0 |
| link ../mips32/_link.ld.in |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /uspace/trunk/libc/arch/mips32eb/include |
|---|
| 0,0 → 1,0 |
| link ../mips32/include |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /uspace/trunk/libc/arch/mips32eb/src |
|---|
| 0,0 → 1,0 |
| link ../mips32/src |
| Property changes: |
| Added: svn:special |
| +* |
| \ No newline at end of property |
| /uspace/trunk/libc/arch/amd64/_link.ld.in |
|---|
| 0,0 → 1,8 |
| OUTPUT_FORMAT(binary) |
| STARTUP(../libc/arch/ARCH/src/entry.o) |
| ENTRY(__entry) |
| SECTIONS { |
| .text 0x00001000 : { |
| } |
| } |
| /uspace/trunk/libc/arch/amd64/include/types.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (C) 2006 Ondrej Palkovsky |
| * 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. |
| */ |
| #ifndef __LIBC__TYPES_H__ |
| #define __LIBC__TYPES_H__ |
| typedef unsigned long long sysarg_t; |
| typedef unsigned int size_t; |
| typedef signed int ssize_t; |
| #endif |
| /uspace/trunk/libc/arch/amd64/Makefile.inc |
|---|
| 0,0 → 1,35 |
| # |
| # Copyright (C) 2005 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. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = amd64-linux-gnu |
| TOOLCHAIN_DIR = /usr/local/amd64/bin |
| ARCH_SOURCES += arch/$(ARCH)/src/syscall.S |
| /uspace/trunk/libc/arch/amd64/src/entry.s |
|---|
| 0,0 → 1,42 |
| # |
| # Copyright (C) 2006 Ondrej Palkovsky |
| # 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 |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # |
| __entry: |
| call main |
| call __exit |
| .end __entry |
| /uspace/trunk/libc/arch/amd64/src/syscall.S |
|---|
| 0,0 → 1,40 |
| # |
| # Copyright (C) 2006 Ondrej Palkovsky |
| # 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 |
| .globl __syscall |
| __syscall: |
| # rcx gets rewritten on syscall |
| movq %rcx, %r9 |
| syscall |
| ret |
| .end __syscall |
| /uspace/trunk/libc/arch/mips32/Makefile.inc |
|---|
| 0,0 → 1,36 |
| # |
| # Copyright (C) 2005 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. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = mipsel-linux-gnu |
| TOOLCHAIN_DIR = /usr/local/mipsel/bin |
| CFLAGS += -mno-abicalls -mips3 |
| ARCH_SOURCES += arch/$(ARCH)/src/syscall.c |
| /uspace/trunk/libc/arch/mips32/_link.ld.in |
|---|
| 0,0 → 1,8 |
| OUTPUT_FORMAT(binary) |
| STARTUP(../libc/arch/ARCH/src/entry.o) |
| ENTRY(__entry) |
| SECTIONS { |
| .text 0x00004000 : { |
| } |
| } |
| /uspace/trunk/libc/arch/mips32/src/syscall.c |
|---|
| 0,0 → 1,49 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #include <libc.h> |
| sysarg_t __syscall(const syscall_t id, const sysarg_t p1, const sysarg_t p2, const sysarg_t p3) |
| { |
| register sysarg_t __mips_reg_a0 asm("$4") = p1; |
| register sysarg_t __mips_reg_a1 asm("$5") = p2; |
| register sysarg_t __mips_reg_a2 asm("$6") = p3; |
| register sysarg_t __mips_reg_a3 asm("$7") = id; |
| register sysarg_t __mips_reg_v0 asm("$2"); |
| asm volatile ( |
| "syscall\n" |
| : "=r" (__mips_reg_v0) |
| : "r" (__mips_reg_a0), |
| "r" (__mips_reg_a1), |
| "r" (__mips_reg_a2), |
| "r" (__mips_reg_a3) |
| ); |
| return __mips_reg_v0; |
| } |
| /uspace/trunk/libc/arch/mips32/src/entry.s |
|---|
| 0,0 → 1,46 |
| # |
| # Copyright (C) 2005 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 |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # |
| __entry: |
| jal main |
| nop |
| jal __exit |
| nop |
| .end __entry |
| /uspace/trunk/libc/arch/mips32/include/types.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #ifndef __LIBC__TYPES_H__ |
| #define __LIBC__TYPES_H__ |
| typedef unsigned int sysarg_t; |
| typedef unsigned int size_t; |
| typedef signed int ssize_t; |
| #endif |
| /uspace/trunk/libc/arch/ia32/Makefile.inc |
|---|
| 0,0 → 1,35 |
| # |
| # Copyright (C) 2005 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. |
| # |
| ## Toolchain configuration |
| # |
| TARGET = i686-pc-linux-gnu |
| TOOLCHAIN_DIR = /usr/local/i686/bin |
| ARCH_SOURCES += arch/$(ARCH)/src/syscall.c |
| /uspace/trunk/libc/arch/ia32/_link.ld.in |
|---|
| 0,0 → 1,8 |
| OUTPUT_FORMAT(binary) |
| STARTUP(../libc/arch/ARCH/src/entry.o) |
| ENTRY(__entry) |
| SECTIONS { |
| .text 0x00001000 : { |
| } |
| } |
| /uspace/trunk/libc/arch/ia32/src/entry.s |
|---|
| 0,0 → 1,48 |
| # |
| # Copyright (C) 2005 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 |
| .org 0 |
| .globl __entry |
| ## User-space task entry point |
| # |
| # |
| __entry: |
| mov %ss, %ax |
| mov %ax, %ds |
| mov %ax, %es |
| mov %ax, %fs |
| mov %ax, %gs |
| call main |
| call __exit |
| .end __entry |
| /uspace/trunk/libc/arch/ia32/src/syscall.c |
|---|
| 0,0 → 1,45 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #include <libc.h> |
| sysarg_t __syscall(const syscall_t id, const sysarg_t p1, const sysarg_t p2, const sysarg_t p3) |
| { |
| sysarg_t ret; |
| asm volatile ( |
| "int $0x30\n" |
| : "=a" (ret) |
| : "a" (id), |
| "b" (p1), |
| "c" (p2), |
| "d" (p3) |
| ); |
| return ret; |
| } |
| /uspace/trunk/libc/arch/ia32/include/types.h |
|---|
| 0,0 → 1,36 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #ifndef __LIBC__TYPES_H__ |
| #define __LIBC__TYPES_H__ |
| typedef unsigned int sysarg_t; |
| typedef unsigned int size_t; |
| typedef signed int ssize_t; |
| #endif |
| /uspace/trunk/libc/Makefile |
|---|
| 0,0 → 1,78 |
| # |
| # Copyright (C) 2005 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. |
| # |
| ## Common compiler flags |
| # |
| LIBC_PREFIX = . |
| ## Setup toolchain |
| # |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| ## Sources |
| # |
| GENERIC_SOURCES = \ |
| generic/libc.c \ |
| generic/io.c |
| ARCH_SOURCES += \ |
| arch/$(ARCH)/src/entry.s |
| GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES))) |
| ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES))) |
| .PHONY: all clean depend |
| all: libc.a arch/$(ARCH)/_link.ld |
| -include Makefile.depend |
| clean: |
| -rm -f libc.a arch/$(ARCH)/_link.ld Makefile.depend |
| find generic/ arch/$(ARCH)/ -name '*.o' -follow -exec rm \{\} \; |
| depend: |
| $(CC) $(DEFS) $(CFLAGS) -M $(ARCH_SOURCES) $(GENERIC_SOURCES) > Makefile.depend |
| libc.a: depend $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| $(AR) rc libc.a $(ARCH_OBJECTS) $(GENERIC_OBJECTS) |
| arch/$(ARCH)/_link.ld: arch/$(ARCH)/_link.ld.in |
| $(CC) $(DEFS) $(CFLAGS) -E -x c $< | grep -v "^\#" > $@ |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.s |
| $(AS) $(AFLAGS) $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /uspace/trunk/libc/Makefile.toolchain |
|---|
| 0,0 → 1,56 |
| # |
| # Copyright (C) 2005 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. |
| # |
| DEFS = -DARCH=$(ARCH) |
| CFLAGS = -fno-builtin -Werror-implicit-function-declaration -Wmissing-prototypes -Werror -O3 -nostdlib -nostdinc -I$(LIBC_PREFIX)/include -I$(LIBC_PREFIX)/arch/$(ARCH)/include |
| LFLAGS = -M |
| AFLAGS = |
| ## Setup platform configuration |
| # |
| include $(LIBC_PREFIX)/arch/$(ARCH)/Makefile.inc |
| ## Toolchain configuration |
| # |
| ifeq ($(COMPILER),native) |
| CC = gcc |
| AS = as |
| LD = ld |
| AR = ar |
| OBJCOPY = objcopy |
| OBJDUMP = objdump |
| else |
| CC = $(TOOLCHAIN_DIR)/$(TARGET)-gcc |
| AS = $(TOOLCHAIN_DIR)/$(TARGET)-as |
| LD = $(TOOLCHAIN_DIR)/$(TARGET)-ld |
| AR = $(TOOLCHAIN_DIR)/$(TARGET)-ar |
| OBJCOPY = $(TOOLCHAIN_DIR)/$(TARGET)-objcopy |
| OBJDUMP = $(TOOLCHAIN_DIR)/$(TARGET)-objdump |
| endif |
| /uspace/trunk/libc/include/libc.h |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #ifndef __LIBC__LIBC_H__ |
| #define __LIBC__LIBC_H__ |
| #include <types.h> |
| #define __SYSCALL0(id) __syscall(id, 0, 0, 0) |
| #define __SYSCALL1(id, p1) __syscall(id, p1, 0, 0) |
| #define __SYSCALL2(id, p1, p2) __syscall(id, p1, p2, 0) |
| typedef enum { |
| SYS_CTL = 0, |
| SYS_IO = 1 |
| } syscall_t; |
| extern void __main(void); |
| extern void __exit(void); |
| extern sysarg_t __syscall(const syscall_t id, const sysarg_t p1, const sysarg_t p2, const sysarg_t p3); |
| #endif |
| /uspace/trunk/libc/include/unistd.h |
|---|
| 0,0 → 1,39 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #ifndef __LIBC__UNISTD_H__ |
| #define __LIBC__UNISTD_H__ |
| #include <types.h> |
| #define NULL 0 |
| extern ssize_t write(int fd, const void * buf, size_t count); |
| extern void _exit(int status); |
| #endif |
| /uspace/trunk/libc/include/stdio.h |
|---|
| 0,0 → 1,38 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #ifndef __LIBC__STDIO_H__ |
| #define __LIBC__STDIO_H__ |
| #include <types.h> |
| #define EOF -1 |
| extern int puts(const char * str); |
| #endif |
| /uspace/trunk/libc/generic/io.c |
|---|
| 0,0 → 1,51 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #include <libc.h> |
| #include <unistd.h> |
| #include <stdio.h> |
| static char nl = '\n'; |
| int puts(const char * str) |
| { |
| size_t count; |
| for (count = 0; str[count] != 0; count++); |
| if (write(1, (void * ) str, count) == count) { |
| if (write(1, &nl, 1) == 1) |
| return 0; |
| } |
| return EOF; |
| } |
| ssize_t write(int fd, const void * buf, size_t count) |
| { |
| return (ssize_t) __syscall(SYS_IO, (sysarg_t) fd, (sysarg_t) buf, (sysarg_t) count); |
| } |
| /uspace/trunk/libc/generic/libc.c |
|---|
| 0,0 → 1,41 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #include <libc.h> |
| #include <unistd.h> |
| void _exit(int status) { |
| __SYSCALL0(SYS_CTL); |
| } |
| void __main(void) { |
| } |
| void __exit(void) { |
| _exit(0); |
| } |
| /uspace/trunk/init/Makefile |
|---|
| 0,0 → 1,67 |
| # |
| # Copyright (C) 2005 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. |
| # |
| ## Setup toolchain |
| # |
| LIBC_PREFIX = ../libc |
| include $(LIBC_PREFIX)/Makefile.toolchain |
| ## Sources |
| # |
| OUTPUT = init |
| SOURCES = \ |
| init.c \ |
| version.c |
| OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) |
| .PHONY: all clean depend |
| all: $(OUTPUT) |
| -include Makefile.depend |
| clean: |
| -rm -f $(OUTPUT) $(OUTPUT).map Makefile.depend |
| depend: |
| $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend |
| $(OUTPUT): $(OBJECTS) |
| $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(LFLAGS) $(OBJECTS) $(LIBC_PREFIX)/libc.a -o $@ -Map $(OUTPUT).map |
| %.o: %.S |
| $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ |
| %.o: %.s |
| $(AS) $(AFLAGS) $< -o $@ |
| %.o: %.c |
| $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ |
| /uspace/trunk/init/init.c |
|---|
| 0,0 → 1,35 |
| /* |
| * Copyright (C) 2005 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. |
| */ |
| #include "version.h" |
| int main(int argc, char *argv[]) |
| { |
| version_print(); |
| return 0; |
| } |
| /uspace/trunk/init/version.c |
|---|
| 0,0 → 1,38 |
| /* |
| * Copyright (C) 2006 Jakub Jermar |
| * 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. |
| */ |
| #include <unistd.h> |
| #include <stdio.h> |
| #include "version.h" |
| /** Print version information. */ |
| void version_print(void) |
| { |
| puts("HelenOS init"); |
| puts("Copyright (C) 2006 HelenOS project"); |
| } |
| /uspace/trunk/init/init.h |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (C) 2006 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. |
| */ |
| #ifndef __INIT_H__ |
| #define __INIT_H__ |
| #include "version.h" |
| #endif |
| /uspace/trunk/init/version.h |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright (C) 2006 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. |
| */ |
| #ifndef __VERSION_H__ |
| #define __VERSION_H__ |
| extern void version_print(void); |
| #endif |
| /uspace/trunk/Makefile |
|---|
| 0,0 → 1,63 |
| # |
| # Copyright (C) 2005 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. |
| # |
| ## Include configuration |
| # |
| -include Makefile.config |
| DIRS = \ |
| libc \ |
| init \ |
| softfloat |
| BUILDS := $(addsuffix .build,$(DIRS)) |
| CLEANS := $(addsuffix .clean,$(DIRS)) |
| .PHONY: all config build $(BUILDS) $(CLEANS) clean distclean |
| all: |
| tools/config.py default $(ARCH) |
| $(MAKE) -C . build |
| config: |
| tools/config.py |
| build: $(BUILDS) |
| clean: $(CLEANS) |
| find $(SOURCES) -name '*.o' -follow -exec rm \{\} \; |
| distclean: clean |
| -rm Makefile.config |
| $(CLEANS): |
| $(MAKE) -C $(basename $@) clean ARCH=$(ARCH) |
| $(BUILDS): |
| $(MAKE) -C $(basename $@) all ARCH=$(ARCH) COMPILER=$(COMPILER) |
| /uspace/trunk/tools/config.py |
|---|
| 0,0 → 1,480 |
| #!/usr/bin/env python |
| """ |
| user space configuration script |
| """ |
| import sys |
| import os |
| import re |
| import commands |
| INPUT = 'uspace.config' |
| OUTPUT = 'Makefile.config' |
| TMPOUTPUT = 'Makefile.config.tmp' |
| class DefaultDialog: |
| "Wrapper dialog that tries to return default values" |
| def __init__(self, dlg): |
| self.dlg = dlg |
| def set_title(self,text): |
| self.dlg.set_title(text) |
| def yesno(self, text, default=None): |
| if default is not None: |
| return default |
| return self.dlg.yesno(text, default) |
| def noyes(self, text, default=None): |
| if default is not None: |
| return default |
| return self.dlg.noyes(text, default) |
| def choice(self, text, choices, defopt=None): |
| if defopt is not None: |
| return choices[defopt][0] |
| return self.dlg.choice(text, choices, defopt) |
| class NoDialog: |
| def __init__(self): |
| self.printed = None |
| self.title = 'HelenOS Configuration' |
| def print_title(self): |
| if not self.printed: |
| sys.stdout.write("\n*** %s ***\n" % self.title) |
| self.printed = True |
| def set_title(self, text): |
| self.title = text |
| self.printed = False |
| def noyes(self, text, default=None): |
| if not default: |
| default = 'n' |
| return self.yesno(text, default) |
| def yesno(self, text, default=None): |
| self.print_title() |
| if default != 'n': |
| default = 'y' |
| while 1: |
| sys.stdout.write("%s (y/n)[%s]: " % (text,default)) |
| inp = sys.stdin.readline() |
| if not inp: |
| raise EOFError |
| inp = inp.strip().lower() |
| if not inp: |
| return default |
| if inp == 'y': |
| return 'y' |
| elif inp == 'n': |
| return 'n' |
| def _print_choice(self, text, choices, defopt): |
| sys.stdout.write('%s:\n' % text) |
| for i,(text,descr) in enumerate(choices): |
| sys.stdout.write('\t%2d. %s\n' % (i, descr)) |
| if defopt is not None: |
| sys.stdout.write('Enter choice number[%d]: ' % defopt) |
| else: |
| sys.stdout.write('Enter choice number: ') |
| def menu(self, text, choices, button, defopt=None): |
| self.title = 'Main menu' |
| menu = [] |
| for key, descr in choices: |
| txt = key + (45-len(key))*' ' + ': ' + descr |
| menu.append((key, txt)) |
| return self.choice(text, [button] + menu) |
| def choice(self, text, choices, defopt=None): |
| self.print_title() |
| while 1: |
| self._print_choice(text, choices, defopt) |
| inp = sys.stdin.readline() |
| if not inp: |
| raise EOFError |
| if not inp.strip(): |
| if defopt is not None: |
| return choices[defopt][0] |
| continue |
| try: |
| number = int(inp.strip()) |
| except ValueError: |
| continue |
| if number < 0 or number >= len(choices): |
| continue |
| return choices[number][0] |
| class Dialog(NoDialog): |
| def __init__(self): |
| NoDialog.__init__(self) |
| self.dlgcmd = os.environ.get('DIALOG','dialog') |
| self.title = '' |
| self.backtitle = 'HelenOS User Space Configuration' |
| if os.system('%s --print-maxsize >/dev/null 2>&1' % self.dlgcmd) != 0: |
| raise NotImplementedError |
| def set_title(self,text): |
| self.title = text |
| def calldlg(self,*args,**kw): |
| "Wrapper for calling 'dialog' program" |
| indesc, outdesc = os.pipe() |
| pid = os.fork() |
| if not pid: |
| os.close(2) |
| os.dup(outdesc) |
| os.close(indesc) |
| dlgargs = [self.dlgcmd,'--title',self.title, |
| '--backtitle', self.backtitle] |
| for key,val in kw.items(): |
| dlgargs.append('--'+key) |
| dlgargs.append(val) |
| dlgargs += args |
| os.execlp(self.dlgcmd,*dlgargs) |
| os.close(outdesc) |
| try: |
| errout = os.fdopen(indesc,'r') |
| data = errout.read() |
| errout.close() |
| pid,status = os.wait() |
| except: |
| os.system('reset') # Reset terminal |
| raise |
| if not os.WIFEXITED(status): |
| os.system('reset') # Reset terminal |
| raise EOFError |
| status = os.WEXITSTATUS(status) |
| if status == 255: |
| raise EOFError |
| return status,data |
| def yesno(self, text, default=None): |
| if text[-1] not in ('?',':'): |
| text = text + ':' |
| width = '50' |
| height = '5' |
| if len(text) < 48: |
| text = ' '*int(((48-len(text))/2)) + text |
| else: |
| width = '0' |
| height = '0' |
| if default == 'n': |
| res,data = self.calldlg('--defaultno','--yesno',text,height,width) |
| else: |
| res,data = self.calldlg('--yesno',text,height,width) |
| if res == 0: |
| return 'y' |
| return 'n' |
| def menu(self, text, choices, button, defopt=None): |
| self.title = 'Main menu' |
| text = text + ':' |
| width = '70' |
| height = str(8 + len(choices)) |
| args = [] |
| for key,val in choices: |
| args.append(key) |
| args.append(val) |
| kw = {} |
| if defopt: |
| kw['default-item'] = choices[defopt][0] |
| res,data = self.calldlg('--ok-label','Change', |
| '--extra-label',button[1], |
| '--extra-button', |
| '--menu',text,height,width, |
| str(len(choices)),*args,**kw) |
| if res == 3: |
| return button[0] |
| if res == 1: # Cancel |
| sys.exit(1) |
| elif res: |
| print data |
| raise EOFError |
| return data |
| def choice(self, text, choices, defopt=None): |
| text = text + ':' |
| width = '50' |
| height = str(8 + len(choices)) |
| args = [] |
| for key,val in choices: |
| args.append(key) |
| args.append(val) |
| kw = {} |
| if defopt: |
| kw['default-item'] = choices[defopt][0] |
| res,data = self.calldlg('--nocancel','--menu',text,height,width, |
| str(len(choices)),*args, **kw) |
| if res: |
| print data |
| raise EOFError |
| return data |
| def read_defaults(fname,defaults): |
| "Read saved values from last configuration run" |
| f = file(fname,'r') |
| for line in f: |
| res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line) |
| if res: |
| defaults[res.group(1)] = res.group(2) |
| f.close() |
| def check_condition(text, defaults, asked_names): |
| seen_vars = [ x[0] for x in asked_names ] |
| ctype = 'cnf' |
| if ')|' in text or '|(' in text: |
| ctype = 'dnf' |
| if ctype == 'cnf': |
| conds = text.split('&') |
| else: |
| conds = text.split('|') |
| for cond in conds: |
| if cond.startswith('(') and cond.endswith(')'): |
| cond = cond[1:-1] |
| inside = check_inside(cond, defaults, ctype, seen_vars) |
| if ctype == 'cnf' and not inside: |
| return False |
| if ctype == 'dnf' and inside: |
| return True |
| if ctype == 'cnf': |
| return True |
| return False |
| def check_inside(text, defaults, ctype, seen_vars): |
| """ |
| Check that the condition specified on input line is True |
| only CNF is supported |
| """ |
| if ctype == 'cnf': |
| conds = text.split('|') |
| else: |
| conds = text.split('&') |
| for cond in conds: |
| res = re.match(r'^(.*?)(!?=)(.*)$', cond) |
| if not res: |
| raise RuntimeError("Invalid condition: %s" % cond) |
| condname = res.group(1) |
| oper = res.group(2) |
| condval = res.group(3) |
| if condname not in seen_vars: |
| varval = '' |
| ## raise RuntimeError("Variable %s not defined before being asked." %\ |
| ## condname) |
| elif not defaults.has_key(condname): |
| raise RuntimeError("Condition var %s does not exist: %s" % \ |
| (condname,text)) |
| else: |
| varval = defaults[condname] |
| if ctype == 'cnf': |
| if oper == '=' and condval == varval: |
| return True |
| if oper == '!=' and condval != varval: |
| return True |
| else: |
| if oper== '=' and condval != varval: |
| return False |
| if oper== '!=' and condval == varval: |
| return False |
| if ctype=='cnf': |
| return False |
| return True |
| def parse_config(input, output, dlg, defaults={}, askonly=None): |
| "Parse configuration file and create Makefile.config on the fly" |
| def ask_the_question(dialog): |
| "Ask question based on the type of variables to ask" |
| # This is quite a hack, this thingy is written just to |
| # have access to local variables.. |
| if vartype == 'y/n': |
| return dialog.yesno(comment, default) |
| elif vartype == 'n/y': |
| return dialog.noyes(comment, default) |
| elif vartype == 'choice': |
| defopt = None |
| if default is not None: |
| for i,(key,val) in enumerate(choices): |
| if key == default: |
| defopt = i |
| break |
| return dialog.choice(comment, choices, defopt) |
| else: |
| raise RuntimeError("Bad method: %s" % vartype) |
| f = file(input, 'r') |
| outf = file(output, 'w') |
| outf.write('#########################################\n') |
| outf.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n') |
| outf.write('#########################################\n\n') |
| asked_names = [] |
| comment = '' |
| default = None |
| choices = [] |
| for line in f: |
| if line.startswith('%'): |
| res = re.match(r'^%\s*(?:\[(.*?)\])?\s*(.*)$', line) |
| if not res: |
| raise RuntimeError('Invalid command: %s' % line) |
| if res.group(1): |
| if not check_condition(res.group(1), defaults, |
| asked_names): |
| continue |
| args = res.group(2).strip().split(' ') |
| cmd = args[0].lower() |
| args = args[1:] |
| if cmd == 'saveas': |
| outf.write('%s = %s\n' % (args[1],defaults[args[0]])) |
| elif cmd == 'shellcmd': |
| varname = args[0] |
| args = args[1:] |
| for i,arg in enumerate(args): |
| if arg.startswith('$'): |
| args[i] = defaults[arg[1:]] |
| data,status = commands.getstatusoutput(' '.join(args)) |
| if status: |
| raise RuntimeError('Error running: %s' % ' '.join(args)) |
| outf.write('%s = %s\n' % (varname,data.strip())) |
| continue |
| if line.startswith('!'): |
| # Ask a question |
| res = re.search(r'!\s*(?:\[(.*?)\])?\s*([^\s]+)\s*\((.*)\)\s*$', line) |
| if not res: |
| raise RuntimeError("Weird line: %s" % line) |
| varname = res.group(2) |
| vartype = res.group(3) |
| default = defaults.get(varname,None) |
| if res.group(1): |
| if not check_condition(res.group(1), defaults, |
| asked_names): |
| if default is not None: |
| outf.write('#!# %s = %s\n' % (varname, default)) |
| # Clear cumulated values |
| comment = '' |
| default = None |
| choices = [] |
| continue |
| asked_names.append((varname,comment)) |
| if default is None or not askonly or askonly == varname: |
| default = ask_the_question(dlg) |
| else: |
| default = ask_the_question(DefaultDialog(dlg)) |
| outf.write('%s = %s\n' % (varname, default)) |
| # Remeber the selected value |
| defaults[varname] = default |
| # Clear cumulated values |
| comment = '' |
| default = None |
| choices = [] |
| continue |
| if line.startswith('@'): |
| # Add new line into the 'choice array' |
| res = re.match(r'@\s*(?:\[(.*?)\])?\s*"(.*?)"\s*(.*)$', line) |
| if not res: |
| raise RuntimeError("Bad line: %s" % line) |
| if res.group(1): |
| if not check_condition(res.group(1),defaults, |
| asked_names): |
| continue |
| choices.append((res.group(2), res.group(3))) |
| continue |
| # All other things print to output file |
| outf.write(line) |
| if re.match(r'^#[^#]', line): |
| # Last comment before question will be displayed to the user |
| comment = line[1:].strip() |
| elif line.startswith('## '): |
| # Set title of the dialog window |
| dlg.set_title(line[2:].strip()) |
| outf.write('\n') |
| outf.write('REVISION = %s\n' % commands.getoutput('svnversion . 2> /dev/null')) |
| outf.write('TIMESTAMP = %s\n' % commands.getoutput('date "+%Y-%m-%d %H:%M:%S"')) |
| outf.close() |
| f.close() |
| return asked_names |
| def main(): |
| defaults = {} |
| try: |
| dlg = Dialog() |
| except NotImplementedError: |
| dlg = NoDialog() |
| if len(sys.argv) >= 2 and sys.argv[1]=='default': |
| defmode = True |
| else: |
| defmode = False |
| # Default run will update the configuration file |
| # with newest options |
| if os.path.exists(OUTPUT): |
| read_defaults(OUTPUT, defaults) |
| # Get ARCH from command line if specified |
| if len(sys.argv) >= 3: |
| defaults['ARCH'] = sys.argv[2] |
| # Dry run only with defaults |
| varnames = parse_config(INPUT, TMPOUTPUT, DefaultDialog(dlg), defaults) |
| # If not in default mode, present selection of all possibilities |
| if not defmode: |
| defopt = 0 |
| while 1: |
| # varnames contains variable names that were in the |
| # last question set |
| choices = [ (x[1],defaults[x[0]]) for x in varnames ] |
| res = dlg.menu('Configuration',choices,('save','Save'),defopt) |
| if res == 'save': |
| parse_config(INPUT, TMPOUTPUT, DefaultDialog(dlg), defaults) |
| break |
| # transfer description back to varname |
| for i,(vname,descr) in enumerate(varnames): |
| if res == descr: |
| defopt = i |
| break |
| # Ask the user a simple question, produce output |
| # as if the user answered all the other questions |
| # with default answer |
| varnames = parse_config(INPUT, TMPOUTPUT, dlg, defaults, |
| askonly=varnames[i][0]) |
| if os.path.exists(OUTPUT): |
| os.unlink(OUTPUT) |
| os.rename(TMPOUTPUT, OUTPUT) |
| if not defmode and dlg.yesno('Rebuild user space?') == 'y': |
| os.execlp('make','make','clean','build') |
| if __name__ == '__main__': |
| main() |
| Property changes: |
| Added: svn:executable |
| +* |
| \ No newline at end of property |