From 851c7ff26de131b871bd5a64274c1a2b13d60fc3 Mon Sep 17 00:00:00 2001 From: Ting Liu Date: Mon, 8 Jul 2013 11:08:16 +0800 Subject: change layout to follow oe-core guidelines of recipes Follow the rules defined in: http://git.yoctoproject.org/cgit/cgit.cgi/poky/tree/meta/recipes.txt recipes-bsp - Anything with links to specific hardware or hardware configuration information recipes-connectivity - Libraries and applications related to communication with other devices recipes-core - What's needed to build a basic working Linux image including commonly used dependencies recipes-devtools - Tools primarily used by the build system (but can also be used on targets) recipes-extended - Applications which whilst not essential add features compared to the alternatives in core. May be needed for full tool functionality or LSB compliance. recipes-gnome - All things related to the GTK+ application framework recipes-graphics - X and other graphically related system libraries recipes-kernel - The kernel and generic applications/libraries with strong kernel dependencies recipes-lsb4 - Recipes added for the sole purpose of supporting the Linux Standard Base (LSB) 4.x recipes-multimedia - Codecs and support utilties for audio, images and video recipes-rt - Provides package and image recipes for using and testing the PREEMPT_RT kernel recipes-qt - All things related to the Qt application framework recipes-sato - The Sato demo/reference UI/UX, its associated apps and configuration recipes-support - Recipes used by other recipes but that are not directly included in images recipes-dpaa - recipes related to fsl dpaa feature recipes-virtualization - recipes related to fsl virtualization feature Signed-off-by: Ting Liu --- recipes-append/procps/procps_3.2.8.bbappend | 2 - recipes-append/sysvinit/sysvinit_2.88dsf.bbappend | 2 - recipes-append/udev/udev_182.bbappend | 2 - recipes-bsp/boot-format/boot-format_git.bb | 19 + recipes-bsp/rcw/rcw_git.bb | 39 + recipes-bsp/u-boot/u-boot_git.bb | 139 ++ recipes-core/sysvinit/sysvinit_2.88dsf.bbappend | 2 + recipes-core/udev/udev_182.bbappend | 2 + recipes-dpaa/eth-config/eth-config_git.bb | 19 + recipes-dpaa/flib/flib_git.bb | 15 + recipes-dpaa/fm-ucode/fm-ucode_git.bb | 46 + recipes-dpaa/fmc/fmc_git.bb | 53 + ...ake-the-library-install-path-configurable.patch | 43 + recipes-dpaa/fmlib/fmlib_git.bb | 43 + recipes-dpaa/usdpaa/usdpaa_git.bb | 49 + recipes-extended/cst/cst_git.bb | 29 + recipes-extended/procps/procps_3.2.8.bbappend | 2 + .../testfloat/files/SoftFloat-powerpc-1.patch | 1427 +++++++++++++++++ .../files/TestFloat-powerpc-E500v2-SPE-1.patch | 1644 ++++++++++++++++++++ .../files/Yocto-replace-COMPILE_PREFIX-gcc.patch | 67 + recipes-extended/testfloat/testfloat_2a.bb | 46 + recipes-extended/web-sysmon/web-sysmon_git.bb | 21 + recipes-kernel/skmm/skmm_git.bb | 33 + recipes-kernel/u-boot/u-boot_git.bb | 139 -- .../testfloat/files/SoftFloat-powerpc-1.patch | 1427 ----------------- .../files/TestFloat-powerpc-E500v2-SPE-1.patch | 1644 -------------------- .../files/Yocto-replace-COMPILE_PREFIX-gcc.patch | 67 - recipes-test/testfloat/testfloat_2a.bb | 46 - recipes-tools/boot-format/boot-format_git.bb | 19 - recipes-tools/cst/cst_git.bb | 29 - .../embedded-hv/files/81-fsl-embedded-hv.rules | 2 - recipes-tools/embedded-hv/hypervisor_git.bb | 90 -- recipes-tools/eth-config/eth-config_git.bb | 19 - recipes-tools/flib/flib_git.bb | 15 - recipes-tools/hv-cfg/hv-cfg_git.bb | 46 - .../mux-server/files/mux-server-1.02.tar.gz | Bin 10021 -> 0 bytes recipes-tools/mux-server/mux-server_1.02.bb | 16 - recipes-tools/rcw/rcw_git.bb | 39 - recipes-tools/skmm/skmm_git.bb | 33 - recipes-tools/usdpaa/usdpaa_git.bb | 49 - recipes-tools/web-sysmon/web-sysmon_git.bb | 21 - recipes-ucode/fm-ucode/fm-ucode_git.bb | 46 - recipes-ucode/fmc/fmc_git.bb | 53 - ...ake-the-library-install-path-configurable.patch | 43 - recipes-ucode/fmlib/fmlib_git.bb | 43 - recipes-virtualization/hv-cfg/hv-cfg_git.bb | 46 + .../hypervisor/files/81-fsl-embedded-hv.rules | 2 + .../hypervisor/hypervisor_git.bb | 90 ++ .../mux-server/files/mux-server-1.02.tar.gz | Bin 0 -> 10021 bytes .../mux-server/mux-server_1.02.bb | 16 + 50 files changed, 3892 insertions(+), 3892 deletions(-) delete mode 100644 recipes-append/procps/procps_3.2.8.bbappend delete mode 100644 recipes-append/sysvinit/sysvinit_2.88dsf.bbappend delete mode 100644 recipes-append/udev/udev_182.bbappend create mode 100644 recipes-bsp/boot-format/boot-format_git.bb create mode 100644 recipes-bsp/rcw/rcw_git.bb create mode 100644 recipes-bsp/u-boot/u-boot_git.bb create mode 100644 recipes-core/sysvinit/sysvinit_2.88dsf.bbappend create mode 100644 recipes-core/udev/udev_182.bbappend create mode 100644 recipes-dpaa/eth-config/eth-config_git.bb create mode 100644 recipes-dpaa/flib/flib_git.bb create mode 100644 recipes-dpaa/fm-ucode/fm-ucode_git.bb create mode 100644 recipes-dpaa/fmc/fmc_git.bb create mode 100644 recipes-dpaa/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch create mode 100644 recipes-dpaa/fmlib/fmlib_git.bb create mode 100644 recipes-dpaa/usdpaa/usdpaa_git.bb create mode 100644 recipes-extended/cst/cst_git.bb create mode 100644 recipes-extended/procps/procps_3.2.8.bbappend create mode 100644 recipes-extended/testfloat/files/SoftFloat-powerpc-1.patch create mode 100644 recipes-extended/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch create mode 100644 recipes-extended/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch create mode 100644 recipes-extended/testfloat/testfloat_2a.bb create mode 100644 recipes-extended/web-sysmon/web-sysmon_git.bb create mode 100644 recipes-kernel/skmm/skmm_git.bb delete mode 100644 recipes-kernel/u-boot/u-boot_git.bb delete mode 100644 recipes-test/testfloat/files/SoftFloat-powerpc-1.patch delete mode 100644 recipes-test/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch delete mode 100644 recipes-test/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch delete mode 100644 recipes-test/testfloat/testfloat_2a.bb delete mode 100644 recipes-tools/boot-format/boot-format_git.bb delete mode 100644 recipes-tools/cst/cst_git.bb delete mode 100644 recipes-tools/embedded-hv/files/81-fsl-embedded-hv.rules delete mode 100644 recipes-tools/embedded-hv/hypervisor_git.bb delete mode 100644 recipes-tools/eth-config/eth-config_git.bb delete mode 100644 recipes-tools/flib/flib_git.bb delete mode 100644 recipes-tools/hv-cfg/hv-cfg_git.bb delete mode 100644 recipes-tools/mux-server/files/mux-server-1.02.tar.gz delete mode 100644 recipes-tools/mux-server/mux-server_1.02.bb delete mode 100644 recipes-tools/rcw/rcw_git.bb delete mode 100644 recipes-tools/skmm/skmm_git.bb delete mode 100644 recipes-tools/usdpaa/usdpaa_git.bb delete mode 100644 recipes-tools/web-sysmon/web-sysmon_git.bb delete mode 100644 recipes-ucode/fm-ucode/fm-ucode_git.bb delete mode 100644 recipes-ucode/fmc/fmc_git.bb delete mode 100644 recipes-ucode/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch delete mode 100644 recipes-ucode/fmlib/fmlib_git.bb create mode 100644 recipes-virtualization/hv-cfg/hv-cfg_git.bb create mode 100644 recipes-virtualization/hypervisor/files/81-fsl-embedded-hv.rules create mode 100644 recipes-virtualization/hypervisor/hypervisor_git.bb create mode 100644 recipes-virtualization/mux-server/files/mux-server-1.02.tar.gz create mode 100644 recipes-virtualization/mux-server/mux-server_1.02.bb diff --git a/recipes-append/procps/procps_3.2.8.bbappend b/recipes-append/procps/procps_3.2.8.bbappend deleted file mode 100644 index 8445337..0000000 --- a/recipes-append/procps/procps_3.2.8.bbappend +++ /dev/null @@ -1,2 +0,0 @@ -PRINC := "${@int(PRINC) + 1}" - diff --git a/recipes-append/sysvinit/sysvinit_2.88dsf.bbappend b/recipes-append/sysvinit/sysvinit_2.88dsf.bbappend deleted file mode 100644 index 8445337..0000000 --- a/recipes-append/sysvinit/sysvinit_2.88dsf.bbappend +++ /dev/null @@ -1,2 +0,0 @@ -PRINC := "${@int(PRINC) + 1}" - diff --git a/recipes-append/udev/udev_182.bbappend b/recipes-append/udev/udev_182.bbappend deleted file mode 100644 index 8445337..0000000 --- a/recipes-append/udev/udev_182.bbappend +++ /dev/null @@ -1,2 +0,0 @@ -PRINC := "${@int(PRINC) + 1}" - diff --git a/recipes-bsp/boot-format/boot-format_git.bb b/recipes-bsp/boot-format/boot-format_git.bb new file mode 100644 index 0000000..ac1504d --- /dev/null +++ b/recipes-bsp/boot-format/boot-format_git.bb @@ -0,0 +1,19 @@ +DESCRIPTION = "Boot format utility for booting from eSDHC/eSPI" +LICENSE = "GPLv2" +PR = "r6" +LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263" + +SRC_URI = "git://git.freescale.com/ppc/sdk/boot-format.git" +SRCREV = "d9bbfaba0c9316ae33455099c47bae429479e530" + +S = "${WORKDIR}/git" +EXTRA_OEMAKE = 'CC="${CC}"' + +do_install(){ + oe_runmake DESTDIR=${D} PREFIX=${prefix} install +} + +PACKAGES =+ "${PN}-config" +FILES_${PN}-config += "${datadir}/*" + +BBCLASSEXTEND = "native nativesdk" diff --git a/recipes-bsp/rcw/rcw_git.bb b/recipes-bsp/rcw/rcw_git.bb new file mode 100644 index 0000000..c532a9d --- /dev/null +++ b/recipes-bsp/rcw/rcw_git.bb @@ -0,0 +1,39 @@ +DESCRIPTION = "Reset Control Words (RCW)" +SECTION = "rcw" +LICENSE = "BSD" +PR = "r8" + +LIC_FILES_CHKSUM = "file://rcw.py;beginline=8;endline=28;md5=9ba0b28922dd187b06b6c8ebcfdd208e" + +# this package is specific to the machine itself +INHIBIT_DEFAULT_DEPS = "1" +PACKAGE_ARCH = "${MACHINE_ARCH}" +COMPATIBLE_HOST_fslmachine = ".*" +COMPATIBLE_HOST ?= "(none)" + +inherit deploy + +SRC_URI = "git://git.freescale.com/ppc/sdk/rcw.git" +SRCREV = "5d3c819bcca6d09dcf7b52b3f2855dda304a5997" + +S = "${WORKDIR}/git" + +do_install () { + make install + + M=`echo ${MACHINE} | sed s/-64b//g` + install -d ${D}/boot/rcw + cp -r ${S}/${M}/${M}/* ${D}/boot/rcw +} + +do_deploy () { + M=`echo ${MACHINE} | sed s/-64b//g` + install -d ${DEPLOYDIR}/rcw + cp -r ${S}/${M}/${M}/* ${DEPLOYDIR}/rcw +} +addtask deploy after do_install + +PACKAGES += "${PN}-image" +FILES_${PN}-image += "/boot" + +ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-bsp/u-boot/u-boot_git.bb b/recipes-bsp/u-boot/u-boot_git.bb new file mode 100644 index 0000000..c3aa105 --- /dev/null +++ b/recipes-bsp/u-boot/u-boot_git.bb @@ -0,0 +1,139 @@ +DESCRIPTION = "U-boot bootloader" +HOMEPAGE = "http://u-boot.sf.net" +SECTION = "bootloaders" +PROVIDES = "virtual/bootloader" +LICENSE = "GPLv2" +LIC_FILES_CHKSUM = "file://COPYING;md5=1707d6db1d42237583f50183a5651ecb" + +PR = "r30" +INHIBIT_DEFAULT_DEPS = "1" +DEPENDS = "boot-format-native virtual/${TARGET_PREFIX}gcc libgcc" + +inherit deploy + +SRC_URI = "git://git.freescale.com/ppc/sdk/u-boot.git" +SRCREV = "831b30de4b768f0b3b7dbfa11739b14cea612d7e" + +python () { + ml = d.getVar("MULTILIB_VARIANTS", True) + arch = d.getVar("OVERRIDES", True) + + if ("e5500-64b:" in arch or "e6500-64b:" in arch) and not "lib32" in ml: + raise bb.parse.SkipPackage("Building the u-boot for this arch requires multilib to be enabled") +} + +DEPENDS_append_e5500-64b = " lib32-gcc-cross lib32-libgcc" +PATH_append_e5500-64b = ":${STAGING_BINDIR_NATIVE}/${DEFAULTTUNE_virtclass-multilib-lib32}${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}/" +TOOLCHAIN_OPTIONS_append_e5500-64b = "/../lib32-${MACHINE}" +TARGET_VENDOR_virtclass-multilib-lib32 ?= "-${DISTRO}mllib32" +WRAP_TARGET_PREFIX_e5500-64b = "powerpc${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}-" + +DEPENDS_append_e6500-64b = " lib32-gcc-cross lib32-libgcc" +PATH_append_e6500-64b = ":${STAGING_BINDIR_NATIVE}/${DEFAULTTUNE_virtclass-multilib-lib32}${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}/" +TOOLCHAIN_OPTIONS_append_e6500-64b = "/../lib32-${MACHINE}" +TARGET_VENDOR_virtclass-multilib-lib32 ?= "-${DISTRO}mllib32" +WRAP_TARGET_PREFIX_e6500-64b = "powerpc${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}-" + +WRAP_TARGET_PREFIX = "${TARGET_PREFIX}" +EXTRA_OEMAKE = 'CROSS_COMPILE=${WRAP_TARGET_PREFIX} CC="${WRAP_TARGET_PREFIX}gcc ${TOOLCHAIN_OPTIONS}"' + +PACKAGE_ARCH = "${MACHINE_ARCH}" + +USRC ?= "" +S = '${@base_conditional("USRC", "", "${WORKDIR}/git", "${USRC}", d)}' + +do_compile () { + unset LDFLAGS + unset CFLAGS + unset CPPFLAGS + + if [ "x${UBOOT_MACHINES}" = "x" ]; then + UBOOT_MACHINES=${UBOOT_MACHINE} + fi + + for board in ${UBOOT_MACHINES}; do + oe_runmake O=${board} distclean + oe_runmake O=${board} ${board} + oe_runmake O=${board} all + + case "${board}" in + *SDCARD*) UBOOT_TARGET="u-boot-sd";; + *SPIFLASH*) UBOOT_TARGET="u-boot-spi";; + *NAND*) UBOOT_TARGET="u-boot-nand";; + *) UBOOT_TARGET="";; + esac + + if [ "x${UBOOT_TARGET}" != "x" ]; then + if [ "${UBOOT_TARGET}" = "u-boot-sd" ]; then + cp ${S}/${board}/u-boot.bin ${S}/${board}/${UBOOT_TARGET}.bin + elif [ "${UBOOT_TARGET}" = "u-boot-nand" ];then + if [ "${DEFAULTTUNE}" = "ppce500v2" ];then + if echo $board |egrep "(P1010RDB|P1020RDB|P1021RDB|P1024RDB|P2020RDB|P1022DS|P1025RDB|BSC9131RDB|BSC9132QDS)" 2>&1 >/dev/null;then + cp ${S}/${board}/u-boot-with-spl.bin ${S}/${board}/${UBOOT_TARGET}.bin + fi + else + cp ${S}/${board}/u-boot.bin ${S}/${board}/${UBOOT_TARGET}.bin + fi + else + if [ -n "${BOOTFORMAT_CONFIG}" ];then + ${STAGING_BINDIR_NATIVE}/boot_format \ + ${STAGING_DATADIR_NATIVE}/boot_format/${BOOTFORMAT_CONFIG} \ + ${S}/${board}/u-boot.bin -spi ${S}/${board}/${UBOOT_TARGET}.bin + else + cp ${S}/${board}/u-boot.bin ${S}/${board}/${UBOOT_TARGET}.bin + fi + fi + fi + done +} + +do_install(){ + if [ "x${UBOOT_MACHINES}" = "x" ]; then + UBOOT_MACHINES=${UBOOT_MACHINE} + fi + + for board in ${UBOOT_MACHINES}; do + case "${board}" in + *SDCARD*) UBOOT_TARGET="u-boot-sd";; + *SPIFLASH*) UBOOT_TARGET="u-boot-spi";; + *NAND*) UBOOT_TARGET="u-boot-nand";; + *) UBOOT_TARGET="u-boot";; + esac + + if [ -f ${S}/${board}/${UBOOT_TARGET}.bin ]; then + mkdir -p ${D}/boot/ + install ${S}/${board}/${UBOOT_TARGET}.bin ${D}/boot/${UBOOT_TARGET}-${board}-${PV}-${PR}.bin + ln -sf ${UBOOT_TARGET}-${board}-${PV}-${PR}.bin ${D}/boot/${UBOOT_TARGET}.bin + fi + done +} + +do_deploy(){ + if [ "x${UBOOT_MACHINES}" = "x" ]; then + UBOOT_MACHINES=${UBOOT_MACHINE} + fi + + for board in ${UBOOT_MACHINES}; do + case "${board}" in + *SDCARD*) UBOOT_TARGET="u-boot-sd";; + *SPIFLASH*) UBOOT_TARGET="u-boot-spi";; + *NAND*) UBOOT_TARGET="u-boot-nand";; + *) UBOOT_TARGET="u-boot";; + esac + + if [ -f ${S}/${board}/${UBOOT_TARGET}.bin ]; then + mkdir -p ${DEPLOYDIR} + install ${S}/${board}/${UBOOT_TARGET}.bin ${DEPLOYDIR}/${UBOOT_TARGET}-${board}-${PV}-${PR}.bin + + cd ${DEPLOYDIR} + rm -f ${UBOOT_TARGET}-${board}.bin + ln -sf ${UBOOT_TARGET}-${board}-${PV}-${PR}.bin ${UBOOT_TARGET}-${board}.bin + fi + done +} +addtask deploy after do_install + +PACKAGES += "${PN}-images" +FILES_${PN}-images += "/boot" + +ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-core/sysvinit/sysvinit_2.88dsf.bbappend b/recipes-core/sysvinit/sysvinit_2.88dsf.bbappend new file mode 100644 index 0000000..8445337 --- /dev/null +++ b/recipes-core/sysvinit/sysvinit_2.88dsf.bbappend @@ -0,0 +1,2 @@ +PRINC := "${@int(PRINC) + 1}" + diff --git a/recipes-core/udev/udev_182.bbappend b/recipes-core/udev/udev_182.bbappend new file mode 100644 index 0000000..8445337 --- /dev/null +++ b/recipes-core/udev/udev_182.bbappend @@ -0,0 +1,2 @@ +PRINC := "${@int(PRINC) + 1}" + diff --git a/recipes-dpaa/eth-config/eth-config_git.bb b/recipes-dpaa/eth-config/eth-config_git.bb new file mode 100644 index 0000000..ac25013 --- /dev/null +++ b/recipes-dpaa/eth-config/eth-config_git.bb @@ -0,0 +1,19 @@ +DESCRIPTION = "Ethernet Configuration Files" +SECTION = "eth-config" +LICENSE = "Freescale-EULA" +LIC_FILES_CHKSUM = "file://COPYING;md5=cf02dc8eb5ac4a76f3812826520dea87" + +PR = "r2" + +SRC_URI = "git://git.freescale.com/ppc/sdk/eth-config.git" +SRCREV = "c255231fb606bff18390da3b26e1ee9fca55e4e6" + +S = "${WORKDIR}/git" + +do_install() { + install -d ${D}/etc/fmc/config + install -m 644 ${S}/*.xml ${D}/etc/fmc/config + install -d ${D}/etc/fmc/config/shared_mac + install -m 644 ${S}/shared_mac/*.xml ${D}/etc/fmc/config/shared_mac + install -m 644 ${S}/shared_mac/README ${D}/etc/fmc/config/shared_mac +} diff --git a/recipes-dpaa/flib/flib_git.bb b/recipes-dpaa/flib/flib_git.bb new file mode 100644 index 0000000..fb3f698 --- /dev/null +++ b/recipes-dpaa/flib/flib_git.bb @@ -0,0 +1,15 @@ +DESCRIPTION = "Foundation Library" +SECTION = "flib" +LICENSE = "BSD & GPLv2" +LIC_FILES_CHKSUM = "file://COPYING;md5=3f16fa8e677e45af3127c5c4bafc3c00" + +SRC_URI = "git://git.freescale.com/ppc/sdk/flib.git" +SRCREV = "ff692ad3c286a07717c6677177825889fe17d450" + +S = "${WORKDIR}/git" + +do_install(){ + oe_runmake install DESTDIR=${D} +} + +ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-dpaa/fm-ucode/fm-ucode_git.bb b/recipes-dpaa/fm-ucode/fm-ucode_git.bb new file mode 100644 index 0000000..76d00b9 --- /dev/null +++ b/recipes-dpaa/fm-ucode/fm-ucode_git.bb @@ -0,0 +1,46 @@ +DESCRIPTION = "Fman microcode binary" +SECTION = "fm-ucode" +LICENSE = "Freescale-EULA" +LIC_FILES_CHKSUM = "file://EULA;md5=60037ccba533a5995e8d1a838d85799c" + +PR = "r1" + +COMPATIBLE_MACHINE = "(p1023rdb|p2041rdb|p3041ds|p4080ds|p5020ds|p5040ds|p5020ds-64b|p5040ds-64b|b4420qds|b4420qds-64b|b4860qds|b4860qds-64b|t4160qds|t4160qds-64b|t4240qds|t4240qds-64b)" +inherit deploy + +SRC_URI = "git://git.freescale.com/ppc/sdk/fm-ucode.git" +SRCREV = "4ca0e41de225b34962e1517c2c75bbb31a381e1a" + +S = "${WORKDIR}/git" + +ALLOW_EMPTY_${PN} = "1" +do_install () { + case ${MACHINE} in + b4420qds|b4420qds-64b|b4860qds|b4860qds-64b) UCODE=b4860qds;; + t4240qds|t4240qds-64b|t4160qds|t4160qds-64b) UCODE=t4240qds;; + p5020ds|p5020ds-64b) UCODE=p5020ds;; + p5040ds|p5040ds-64b) UCODE=p5040ds;; + *) UCODE=${MACHINE};; + esac + UCODE=`echo $UCODE | sed -e 's,[a-zA-Z]*$,,'` + install -d ${D}/boot + install -m 644 fsl_fman_ucode_${UCODE}*.bin ${D}/boot/ +} + +do_deploy () { + case ${MACHINE} in + b4420qds|b4420qds-64b|b4860qds|b4860qds-64b) UCODE=b4860qds;; + t4240qds|t4240qds-64b|t4160qds|t4160qds-64b) UCODE=t4240qds;; + p5020ds|p5020ds-64b) UCODE=p5020ds;; + p5040ds|p5040ds-64b) UCODE=p5040ds;; + *) UCODE=${MACHINE};; + esac + UCODE=`echo $UCODE | sed -e 's,[a-zA-Z]*$,,'` + install -d ${DEPLOYDIR}/ + install -m 644 fsl_fman_ucode_${UCODE}*.bin ${DEPLOYDIR}/ +} +addtask deploy before do_build after do_install + +PACKAGES += "${PN}-image" +FILES_${PN}-image += "/boot" + diff --git a/recipes-dpaa/fmc/fmc_git.bb b/recipes-dpaa/fmc/fmc_git.bb new file mode 100644 index 0000000..20f93f6 --- /dev/null +++ b/recipes-dpaa/fmc/fmc_git.bb @@ -0,0 +1,53 @@ +DESCRIPTION = "Frame Manager Configuration tool" +SECTION = "fmc" +LICENSE = "MIT" +LIC_FILES_CHKSUM = "file://COPYING;md5=a504ab5a8ff235e67c7301214749346c" + +PR = "r2" + +SRC_URI = "git://git.freescale.com/ppc/sdk/fmc.git" +SRCREV = "f2e1a831a96f1d04d3d5a5970d2e54c38098cf39" + +DEPENDS = "libxml2 fmlib tclap" + +PACKAGE_ARCH = "${MACHINE_ARCH}" + +S = "${WORKDIR}/git" + +EXTRA_OEMAKE = 'FMD_USPACE_HEADER_PATH="${STAGING_INCDIR}/fmd" \ + FMD_USPACE_LIB_PATH="${STAGING_LIBDIR}" LIBXML2_HEADER_PATH="${STAGING_INCDIR}/libxml2" \ + TCLAP_HEADER_PATH="${STAGING_INCDIR}" ' +EXTRA_OEMAKE_virtclass-native = 'FMCHOSTMODE=1 FMD_USPACE_HEADER_PATH="${STAGING_INCDIR}/fmd" \ + FMD_USPACE_LIB_PATH="${STAGING_LIBDIR}" LIBXML2_HEADER_PATH="${STAGING_INCDIR}/libxml2" \ + TCLAP_HEADER_PATH="${STAGING_INCDIR}" ' + +PARALLEL_MAKE = "" + +do_compile () { + if [ "b4860qds" = "${MACHINE}" ] || [ "b4420qds" = "${MACHINE}" ];then + EXTRA_OEMAKE_PLATFORM="b4860qds" + elif [ "t4240qds" = "${MACHINE}" ] || [ "t4160qds" = "${MACHINE}" ];then + EXTRA_OEMAKE_PLATFORM="t4240qds" + elif [ "p1023rds" = "${MACHINE}" ];then + EXTRA_OEMAKE_PLATFORM="p1023rds" + else + EXTRA_OEMAKE_PLATFORM="" + fi + oe_runmake MACHINE=${EXTRA_OEMAKE_PLATFORM} -C source +} + +do_install () { + install -d ${D}/${bindir} + install -m 755 ${S}/source/fmc ${D}/${bindir}/fmc + + install -d ${D}/etc/fmc/config + install -m 644 ${S}/etc/fmc/config/hxs_pdl_v3.xml ${D}/etc/fmc/config + + install -d ${D}/${includedir}/fmc + install ${S}/source/fmc.h ${D}/${includedir}/fmc + + install -d ${D}/${libdir} + install ${S}/source/libfmc.a ${D}/${libdir} +} + +BBCLASSEXTEND = "native" diff --git a/recipes-dpaa/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch b/recipes-dpaa/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch new file mode 100644 index 0000000..4894ce3 --- /dev/null +++ b/recipes-dpaa/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch @@ -0,0 +1,43 @@ +From 67b539d256520f95f3c8101f4605ea6d496982df Mon Sep 17 00:00:00 2001 +From: Zhenhua Luo +Date: Thu, 18 Oct 2012 17:28:00 +0300 +Subject: [PATCH] fm-lib: make the library install path configurable + +currently library for both 32bit target and 64bit target +is installed in /usr/lib folder, add a variable to make the +install path configurable + +Signed-off-by: Zhenhua Luo +--- + Makefile | 8 +++++--- + 1 file changed, 5 insertions(+), 3 deletions(-) + +diff --git a/Makefile b/Makefile +index 06fe930..d59f44a 100644 +--- a/Makefile ++++ b/Makefile +@@ -59,6 +59,8 @@ endif + + INSTALL?=install + ++LIB_DEST_DIR?=$(PREFIX)/lib ++ + # Don't forget to increment .version before doing a new release! + FM_LIB_VERSION:=$(shell cat .version) + +@@ -118,9 +120,9 @@ archive: all .version + + install-%: %.a + @(echo "Installing...") +- @($(INSTALL) -d $(DESTDIR)$(PREFIX)/lib) +- @($(INSTALL) $< $(DESTDIR)$(PREFIX)/lib) +- @(ln -s $(DESTDIR)$(PREFIX)/lib/$< $(DESTDIR)$(PREFIX)/lib/libfm.a) ++ @($(INSTALL) -d $(DESTDIR)$(LIB_DEST_DIR)) ++ @($(INSTALL) $< $(DESTDIR)$(LIB_DEST_DIR)) ++ @(ln -s $(DESTDIR)$(LIB_DEST_DIR)/$< $(DESTDIR)$(LIB_DEST_DIR)/libfm.a) + @(cp -r -p ./include $(DESTDIR)$(PREFIX)) + @($(INSTALL) -d $(DESTDIR)$(PREFIX)/share/doc/fm-lib-$(FM_LIB_VERSION)) + @($(INSTALL) $(FM_LIB_DOCFILES) $(DESTDIR)$(PREFIX)/share/doc/fm-lib-$(FM_LIB_VERSION)) +-- +1.7.9.5 + diff --git a/recipes-dpaa/fmlib/fmlib_git.bb b/recipes-dpaa/fmlib/fmlib_git.bb new file mode 100644 index 0000000..7a7b8f2 --- /dev/null +++ b/recipes-dpaa/fmlib/fmlib_git.bb @@ -0,0 +1,43 @@ +DESCRIPTION = "Frame Manager User Space Library" +SECTION = "fman" +LICENSE = "BSD & GPLv2" +LIC_FILES_CHKSUM = "file://COPYING;md5=3f16fa8e677e45af3127c5c4bafc3c00" + +PR = "r1" + +DEPENDS = "linux-libc-headers" +DEPENDS_virtclass-native = "" + +SRC_URI = "git://git.freescale.com/ppc/sdk/fmlib.git" +SRCREV = "7d843485bdac963d98f81773c0f3cb15936e09da" + +S = "${WORKDIR}/git" + +TARGET_ARCH_FMLIB = "${DEFAULTTUNE}" +TARGET_ARCH_FMLIB_e5500 = "ppc32e5500" +TARGET_ARCH_FMLIB_e6500 = "ppc32e6500" +COMPATIBLE_HOST_fslmachine = ".*" +COMPATIBLE_HOST ?= "(none)" + +EXTRA_OEMAKE = "DESTDIR=${D} PREFIX=${prefix} LIB_DEST_DIR=${libdir} \ + CROSS_COMPILE=${TARGET_PREFIX} KERNEL_SRC=${STAGING_EXECPREFIXDIR}" + +do_compile () { + oe_runmake libfm-${TARGET_ARCH_FMLIB}.a +} + +do_compile_virtclass-native () { +} + +do_install () { + oe_runmake install-libfm-${TARGET_ARCH_FMLIB} +} + +do_install_virtclass-native () { + install -d ${D}/${includedir} + cp -rf ${S}/include/* ${D}/${includedir} +} + +ALLOW_EMPTY_${PN} = "1" + +BBCLASSEXTEND = "native" diff --git a/recipes-dpaa/usdpaa/usdpaa_git.bb b/recipes-dpaa/usdpaa/usdpaa_git.bb new file mode 100644 index 0000000..48e860f --- /dev/null +++ b/recipes-dpaa/usdpaa/usdpaa_git.bb @@ -0,0 +1,49 @@ +DESCRIPTION = "User-Space Data-Path Acceleration Architecture drivers" +LICENSE = "BSD & GPLv2" +LIC_FILES_CHKSUM = "file://Makefile;endline=30;md5=39e58bedc879163c9338596e52df5b1f" +PR = "r4" + +inherit pkgconfig + +DEPENDS = "libxml2 libedit ncurses readline flib fmc" +RDEPENDS_${PN} = "libgcc bash" + +SRC_URI = "git://git.freescale.com/ppc/sdk/usdpaa.git" +SRCREV = "97fe45d9697ef339e10a1885539b23fa7fcb113e" + +S = "${WORKDIR}/git" + +EXTRA_OEMAKE = 'CC="${CC}" LD="${LD}" AR="${AR}"' +export ARCH="${TARGET_ARCH}" + +do_compile_prepend () { + case ${MACHINE} in + b4420qds|b4420qds-64b|b4860qds|b4860qds-64b) SOC=B4860;; + t4240qds|t4240qds-64b) SOC=T4240;; + p1023rdb) SOC=P1023;; + *) SOC=P4080;; + esac + export FMC_EXTRA_CFLAGS="-I ${STAGING_INCDIR}/fmc" + export FMLIB_EXTRA_CFLAGS="-I ${STAGING_INCDIR}/fmd \ + -I ${STAGING_INCDIR}/fmd/Peripherals \ + -I ${STAGING_INCDIR}/fmd/integrations \ + -D $SOC" + + export LIBXML2_CFLAGS="$(pkg-config --cflags libxml-2.0)" + export LIBXML2_LDFLAGS="$(pkg-config --libs --static libxml-2.0)" + export LIBEDIT_CFLAGS="$(pkg-config --cflags libedit)" + export LIBEDIT_LDFLAGS="$(pkg-config --libs --static libedit)" +} + +do_install () { + oe_runmake install DESTDIR=${D} +} + +PARALLEL_MAKE_pn-${PN} = "" +FILES_${PN} += "/root/SOURCE_THIS /usr/etc/" + +PACKAGE_ARCH = "${MACHINE_ARCH}" + +COMPATIBLE_HOST_fslmachine = ".*" +COMPATIBLE_HOST ?= "(none)" + diff --git a/recipes-extended/cst/cst_git.bb b/recipes-extended/cst/cst_git.bb new file mode 100644 index 0000000..177f23c --- /dev/null +++ b/recipes-extended/cst/cst_git.bb @@ -0,0 +1,29 @@ +DESCRIPTION = "CST Tool" +SECTION = "cst" +LICENSE = "BSD" + +# TODO: fix license - this file is not a license +LIC_FILES_CHKSUM = "file://RELEASENOTES;beginline=8;endline=43;md5=5a7b22a2c96b5f94e0498c5f413aa8d3" + +DEPENDS += "openssl" + +SRC_URI = "git://git.freescale.com/ppc/sdk/cst.git" +SRCREV = "e4035cbf54ed481147c6ae65c741ef75dc9ec37f" + +S = "${WORKDIR}/git" + +EXTRA_OEMAKE = 'OPENSSL_LIB_PATH=${STAGING_LIBDIR} OPENSSL_INC_PATH=${STAGING_INCDIR} CC="${CC}" LD="${CC}" LDFLAGS="${LDFLAGS}"' + +do_install () { + install -d ${D}/${bindir}/cst + install -m 755 ${S}/gen_keys ${D}/${bindir}/cst/ + install -m 755 ${S}/gen_otpmk ${D}/${bindir}/cst/ + install -m 755 ${S}/uni_cfsign ${D}/${bindir}/cst/ + install -m 755 ${S}/uni_sign ${D}/${bindir}/cst/ + cp -rf ${S}/input_files ${D}/${bindir}/cst +} + +BBCLASSEXTEND = "native nativesdk" +PARALLEL_MAKE = "" + +FILES_${PN}-dbg += "${bindir}/cst/.debug" diff --git a/recipes-extended/procps/procps_3.2.8.bbappend b/recipes-extended/procps/procps_3.2.8.bbappend new file mode 100644 index 0000000..8445337 --- /dev/null +++ b/recipes-extended/procps/procps_3.2.8.bbappend @@ -0,0 +1,2 @@ +PRINC := "${@int(PRINC) + 1}" + diff --git a/recipes-extended/testfloat/files/SoftFloat-powerpc-1.patch b/recipes-extended/testfloat/files/SoftFloat-powerpc-1.patch new file mode 100644 index 0000000..b6db2de --- /dev/null +++ b/recipes-extended/testfloat/files/SoftFloat-powerpc-1.patch @@ -0,0 +1,1427 @@ +This patch adds PowerPC support in SoftFloat. + +Signed-off-by: Ebony Zhu +Signed-off-by: Liu Yu +--- + SoftFloat-2b/processors/powerpc-GCC.h | 87 ++++ + SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile | 26 ++ + SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h | 55 +++ + .../bits32/powerpc-GCC/softfloat-specialize | 252 ++++++++++++ + .../softfloat/bits32/powerpc-GCC/softfloat.h | 155 +++++++ + SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile | 24 ++ + SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h | 55 +++ + .../bits64/powerpc-GCC/softfloat-specialize | 422 ++++++++++++++++++++ + .../softfloat/bits64/powerpc-GCC/softfloat.h | 269 +++++++++++++ + 9 files changed, 1345 insertions(+), 0 deletions(-) + create mode 100644 SoftFloat-2b/processors/powerpc-GCC.h + create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile + create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h + create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize + create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h + create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile + create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h + create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize + create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h + +diff --git a/SoftFloat-2b/processors/powerpc-GCC.h b/SoftFloat-2b/processors/powerpc-GCC.h +new file mode 100644 +index 0000000..002a786 +--- /dev/null ++++ b/SoftFloat-2b/processors/powerpc-GCC.h +@@ -0,0 +1,87 @@ ++/* ++ * This file is derived from processors/386-gcc.h, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ * ++ * THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++ * been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++ * RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++ * AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++ * COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++ * EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++ * INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++ * OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ */ ++ ++/*---------------------------------------------------------------------------- ++| One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined. ++*----------------------------------------------------------------------------*/ ++#define BIGENDIAN ++ ++/*---------------------------------------------------------------------------- ++| The macro `BITS64' can be defined to indicate that 64-bit integer types are ++| supported by the compiler. ++*----------------------------------------------------------------------------*/ ++#define BITS32 ++ ++/*---------------------------------------------------------------------------- ++| Each of the following `typedef's defines the most convenient type that holds ++| integers of at least as many bits as specified. For example, `uint8' should ++| be the most convenient type that can hold unsigned integers of as many as ++| 8 bits. The `flag' type must be able to hold either a 0 or 1. For most ++| implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed ++| to the same as `int'. ++*----------------------------------------------------------------------------*/ ++typedef int flag; ++typedef int uint8; ++typedef int int8; ++typedef int uint16; ++typedef int int16; ++typedef unsigned int uint32; ++typedef signed int int32; ++#ifdef BITS64 ++typedef unsigned long long int uint64; ++typedef signed long long int int64; ++#endif ++ ++/*---------------------------------------------------------------------------- ++| Each of the following `typedef's defines a type that holds integers ++| of _exactly_ the number of bits specified. For instance, for most ++| implementation of C, `bits16' and `sbits16' should be `typedef'ed to ++| `unsigned short int' and `signed short int' (or `short int'), respectively. ++*----------------------------------------------------------------------------*/ ++typedef unsigned char bits8; ++typedef signed char sbits8; ++typedef unsigned short int bits16; ++typedef signed short int sbits16; ++typedef unsigned int bits32; ++typedef signed int sbits32; ++#ifdef BITS64 ++typedef unsigned long long int bits64; ++typedef signed long long int sbits64; ++#endif ++ ++#ifdef BITS64 ++/*---------------------------------------------------------------------------- ++| The `LIT64' macro takes as its argument a textual integer literal and ++| if necessary ``marks'' the literal as having a 64-bit integer type. ++| For example, the GNU C Compiler (`gcc') requires that 64-bit literals be ++| appended with the letters `LL' standing for `long long', which is `gcc's ++| name for the 64-bit integer type. Some compilers may allow `LIT64' to be ++| defined as the identity macro: `#define LIT64( a ) a'. ++*----------------------------------------------------------------------------*/ ++#define LIT64( a ) a##LL ++#endif ++ ++/*---------------------------------------------------------------------------- ++| The macro `INLINE' can be used before functions that should be inlined. If ++| a compiler does not support explicit inlining, this macro should be defined ++| to be `static'. ++*----------------------------------------------------------------------------*/ ++#define INLINE extern inline ++ +diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile +new file mode 100644 +index 0000000..28f1e33 +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile +@@ -0,0 +1,26 @@ ++ ++PROCESSOR_H = ../../../processors/powerpc-GCC.h ++SOFTFLOAT_MACROS = ../softfloat-macros ++ ++OBJ = .o ++EXE = ++INCLUDES = -I. -I.. ++COMPILE_C = $(COMPILE_PREFIX)gcc -msoft-float -c -o $@ $(INCLUDES) -I- -O2 ++LINK = $(COMPILE_PREFIX)gcc -o $@ ++ ++ALL: softfloat$(OBJ) timesoftfloat$(EXE) ++ ++milieu.h: $(PROCESSOR_H) ++ touch milieu.h ++ ++softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c ++ $(COMPILE_C) ../softfloat.c ++ ++timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c ++ $(COMPILE_C) ../timesoftfloat.c ++ ++timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ) ++ $(LINK) softfloat$(OBJ) timesoftfloat$(OBJ) ++ ++clean: ++ rm -f *.o timesoftfloat$(EXE) +diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h +new file mode 100644 +index 0000000..d8b6012 +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h +@@ -0,0 +1,55 @@ ++/* ++ * This file is derived from softfloat/bits32/386-Win32-GCC/milieu.h, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/*============================================================================ ++ ++This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic ++Package, Release 2b. ++ ++Written by John R. Hauser. This work was made possible in part by the ++International Computer Science Institute, located at Suite 600, 1947 Center ++Street, Berkeley, California 94704. Funding was partially provided by the ++National Science Foundation under grant MIP-9311980. The original version ++of this code was written as part of a project to build a fixed-point vector ++processor in collaboration with the University of California at Berkeley, ++overseen by Profs. Nelson Morgan and John Wawrzynek. More information ++is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ ++arithmetic/SoftFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) the source code for the derivative work includes prominent notice that ++the work is derivative, and (2) the source code includes prominent notice with ++these four paragraphs for those parts of this code that are retained. ++ ++=============================================================================*/ ++ ++/*---------------------------------------------------------------------------- ++| Include common integer types and flags. ++*----------------------------------------------------------------------------*/ ++#include "../../../processors/powerpc-GCC.h" ++ ++/*---------------------------------------------------------------------------- ++| Symbolic Boolean literals. ++*----------------------------------------------------------------------------*/ ++enum { ++ FALSE = 0, ++ TRUE = 1 ++}; ++ +diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize +new file mode 100644 +index 0000000..fd2caa4 +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize +@@ -0,0 +1,252 @@ ++/* ++ * This file is derived from softfloat/bits32/386-Win32-GCC/softfloat-specialize, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/*============================================================================ ++ ++This C source fragment is part of the SoftFloat IEC/IEEE Floating-point ++Arithmetic Package, Release 2b. ++ ++Written by John R. Hauser. This work was made possible in part by the ++International Computer Science Institute, located at Suite 600, 1947 Center ++Street, Berkeley, California 94704. Funding was partially provided by the ++National Science Foundation under grant MIP-9311980. The original version ++of this code was written as part of a project to build a fixed-point vector ++processor in collaboration with the University of California at Berkeley, ++overseen by Profs. Nelson Morgan and John Wawrzynek. More information ++is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ ++arithmetic/SoftFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) the source code for the derivative work includes prominent notice that ++the work is derivative, and (2) the source code includes prominent notice with ++these four paragraphs for those parts of this code that are retained. ++ ++=============================================================================*/ ++ ++/*---------------------------------------------------------------------------- ++| Underflow tininess-detection mode, statically initialized to default value. ++| (The declaration in `softfloat.h' must match the `int8' type here.) ++*----------------------------------------------------------------------------*/ ++int8 float_detect_tininess = float_tininess_after_rounding; ++ ++/*---------------------------------------------------------------------------- ++| Raises the exceptions specified by `flags'. Floating-point traps can be ++| defined here if desired. It is currently not possible for such a trap ++| to substitute a result value. If traps are not implemented, this routine ++| should be simply `float_exception_flags |= flags;'. ++*----------------------------------------------------------------------------*/ ++ ++void float_raise( int8 flags ) ++{ ++ ++ float_exception_flags |= flags; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Internal canonical NaN format. ++*----------------------------------------------------------------------------*/ ++typedef struct { ++ flag sign; ++ bits32 high, low; ++} commonNaNT; ++ ++/*---------------------------------------------------------------------------- ++| The pattern for a default generated single-precision NaN. ++*----------------------------------------------------------------------------*/ ++enum { ++ float32_default_nan = 0xFFFFFFFF ++}; ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the single-precision floating-point value `a' is a NaN; ++| otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float32_is_nan( float32 a ) ++{ ++ ++ return ( 0xFF000000 < (bits32) ( a<<1 ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the single-precision floating-point value `a' is a signaling ++| NaN; otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float32_is_signaling_nan( float32 a ) ++{ ++ ++ return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the single-precision floating-point NaN ++| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid ++| exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static commonNaNT float32ToCommonNaN( float32 a ) ++{ ++ commonNaNT z; ++ ++ if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); ++ z.sign = a>>31; ++ z.low = 0; ++ z.high = a<<9; ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the canonical NaN `a' to the single- ++| precision floating-point format. ++*----------------------------------------------------------------------------*/ ++ ++static float32 commonNaNToFloat32( commonNaNT a ) ++{ ++ ++ return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>9 ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Takes two single-precision floating-point values `a' and `b', one of which ++| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a ++| signaling NaN, the invalid exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static float32 propagateFloat32NaN( float32 a, float32 b ) ++{ ++ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; ++ ++ aIsNaN = float32_is_nan( a ); ++ aIsSignalingNaN = float32_is_signaling_nan( a ); ++ bIsNaN = float32_is_nan( b ); ++ bIsSignalingNaN = float32_is_signaling_nan( b ); ++ a |= 0x00400000; ++ b |= 0x00400000; ++ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); ++ if ( aIsNaN ) { ++ return ( aIsSignalingNaN & bIsNaN ) ? b : a; ++ } ++ else { ++ return b; ++ } ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| The pattern for a default generated double-precision NaN. The `high' and ++| `low' values hold the most- and least-significant bits, respectively. ++*----------------------------------------------------------------------------*/ ++enum { ++ float64_default_nan_high = 0xFFFFFFFF, ++ float64_default_nan_low = 0xFFFFFFFF ++}; ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the double-precision floating-point value `a' is a NaN; ++| otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float64_is_nan( float64 a ) ++{ ++ ++ return ++ ( 0xFFE00000 <= (bits32) ( a.high<<1 ) ) ++ && ( a.low || ( a.high & 0x000FFFFF ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the double-precision floating-point value `a' is a signaling ++| NaN; otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float64_is_signaling_nan( float64 a ) ++{ ++ ++ return ++ ( ( ( a.high>>19 ) & 0xFFF ) == 0xFFE ) ++ && ( a.low || ( a.high & 0x0007FFFF ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the double-precision floating-point NaN ++| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid ++| exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static commonNaNT float64ToCommonNaN( float64 a ) ++{ ++ commonNaNT z; ++ ++ if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); ++ z.sign = a.high>>31; ++ shortShift64Left( a.high, a.low, 12, &z.high, &z.low ); ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the canonical NaN `a' to the double- ++| precision floating-point format. ++*----------------------------------------------------------------------------*/ ++ ++static float64 commonNaNToFloat64( commonNaNT a ) ++{ ++ float64 z; ++ ++ shift64Right( a.high, a.low, 12, &z.high, &z.low ); ++ z.high |= ( ( (bits32) a.sign )<<31 ) | 0x7FF80000; ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Takes two double-precision floating-point values `a' and `b', one of which ++| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a ++| signaling NaN, the invalid exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static float64 propagateFloat64NaN( float64 a, float64 b ) ++{ ++ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; ++ ++ aIsNaN = float64_is_nan( a ); ++ aIsSignalingNaN = float64_is_signaling_nan( a ); ++ bIsNaN = float64_is_nan( b ); ++ bIsSignalingNaN = float64_is_signaling_nan( b ); ++ a.high |= 0x00080000; ++ b.high |= 0x00080000; ++ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); ++ if ( aIsNaN ) { ++ return ( aIsSignalingNaN & bIsNaN ) ? b : a; ++ } ++ else { ++ return b; ++ } ++ ++} ++ +diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h +new file mode 100644 +index 0000000..0015b8e +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h +@@ -0,0 +1,155 @@ ++/* ++ * This file is derived from softfloat/bits32/386-Win32-GCC/softfloat.h, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/*============================================================================ ++ ++This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic ++Package, Release 2b. ++ ++Written by John R. Hauser. This work was made possible in part by the ++International Computer Science Institute, located at Suite 600, 1947 Center ++Street, Berkeley, California 94704. Funding was partially provided by the ++National Science Foundation under grant MIP-9311980. The original version ++of this code was written as part of a project to build a fixed-point vector ++processor in collaboration with the University of California at Berkeley, ++overseen by Profs. Nelson Morgan and John Wawrzynek. More information ++is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ ++arithmetic/SoftFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) the source code for the derivative work includes prominent notice that ++the work is derivative, and (2) the source code includes prominent notice with ++these four paragraphs for those parts of this code that are retained. ++ ++=============================================================================*/ ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point types. ++*----------------------------------------------------------------------------*/ ++typedef bits32 float32; ++typedef struct { ++ bits32 high, low; ++} float64; ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point underflow tininess-detection mode. ++*----------------------------------------------------------------------------*/ ++extern int8 float_detect_tininess; ++enum { ++ float_tininess_after_rounding = 0, ++ float_tininess_before_rounding = 1 ++}; ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point rounding mode. ++*----------------------------------------------------------------------------*/ ++extern int8 float_rounding_mode; ++enum { ++ float_round_nearest_even = 0, ++ float_round_to_zero = 1, ++ float_round_up = 2, ++ float_round_down = 3 ++}; ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point exception flags. ++*----------------------------------------------------------------------------*/ ++/* ++extern int8 float_exception_flags; ++enum { ++ float_flag_inexact = 1, ++ float_flag_underflow = 2, ++ float_flag_overflow = 4, ++ float_flag_divbyzero = 8, ++ float_flag_invalid = 16 ++}; ++*/ ++ ++extern int8 float_exception_flags; ++enum { ++ float_flag_inexact = 16, ++ float_flag_underflow = 2, ++ float_flag_overflow = 1, ++ float_flag_divbyzero = 4, ++ float_flag_invalid = 8 ++}; ++ ++/*---------------------------------------------------------------------------- ++| Routine to raise any or all of the software IEC/IEEE floating-point ++| exception flags. ++*----------------------------------------------------------------------------*/ ++void float_raise( int8 ); ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE integer-to-floating-point conversion routines. ++*----------------------------------------------------------------------------*/ ++float32 int32_to_float32( int32 ); ++float64 int32_to_float64( int32 ); ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE single-precision conversion routines. ++*----------------------------------------------------------------------------*/ ++int32 float32_to_int32( float32 ); ++int32 float32_to_int32_round_to_zero( float32 ); ++float64 float32_to_float64( float32 ); ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE single-precision operations. ++*----------------------------------------------------------------------------*/ ++float32 float32_round_to_int( float32 ); ++float32 float32_add( float32, float32 ); ++float32 float32_sub( float32, float32 ); ++float32 float32_mul( float32, float32 ); ++float32 float32_div( float32, float32 ); ++float32 float32_rem( float32, float32 ); ++float32 float32_sqrt( float32 ); ++flag float32_eq( float32, float32 ); ++flag float32_le( float32, float32 ); ++flag float32_lt( float32, float32 ); ++flag float32_eq_signaling( float32, float32 ); ++flag float32_le_quiet( float32, float32 ); ++flag float32_lt_quiet( float32, float32 ); ++flag float32_is_signaling_nan( float32 ); ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE double-precision conversion routines. ++*----------------------------------------------------------------------------*/ ++int32 float64_to_int32( float64 ); ++int32 float64_to_int32_round_to_zero( float64 ); ++float32 float64_to_float32( float64 ); ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE double-precision operations. ++*----------------------------------------------------------------------------*/ ++float64 float64_round_to_int( float64 ); ++float64 float64_add( float64, float64 ); ++float64 float64_sub( float64, float64 ); ++float64 float64_mul( float64, float64 ); ++float64 float64_div( float64, float64 ); ++float64 float64_rem( float64, float64 ); ++float64 float64_sqrt( float64 ); ++flag float64_eq( float64, float64 ); ++flag float64_le( float64, float64 ); ++flag float64_lt( float64, float64 ); ++flag float64_eq_signaling( float64, float64 ); ++flag float64_le_quiet( float64, float64 ); ++flag float64_lt_quiet( float64, float64 ); ++flag float64_is_signaling_nan( float64 ); ++ +diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile +new file mode 100644 +index 0000000..a5e2cc7 +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile +@@ -0,0 +1,24 @@ ++ ++PROCESSOR_H = ../../../processors/powerpc-GCC.h ++SOFTFLOAT_MACROS = ../softfloat-macros ++ ++OBJ = .o ++EXE = ++INCLUDES = -I. -I.. ++COMPILE_C = $(COMPILE_PREFIX) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2 ++LINK = $(COMPILE_PREFIX) -o $@ ++ ++ALL: softfloat$(OBJ) timesoftfloat$(EXE) ++ ++milieu.h: $(PROCESSOR_H) ++ touch milieu.h ++ ++softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c ++ $(COMPILE_C) ../softfloat.c ++ ++timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c ++ $(COMPILE_C) ../timesoftfloat.c ++ ++timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ) ++ $(LINK) softfloat$(OBJ) timesoftfloat$(OBJ) ++ +diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h +new file mode 100644 +index 0000000..1b66490 +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h +@@ -0,0 +1,55 @@ ++/* ++ * This file is derived from softfloat/bits64/386-Win32-GCC/milieu.h, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/*============================================================================ ++ ++This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic ++Package, Release 2b. ++ ++Written by John R. Hauser. This work was made possible in part by the ++International Computer Science Institute, located at Suite 600, 1947 Center ++Street, Berkeley, California 94704. Funding was partially provided by the ++National Science Foundation under grant MIP-9311980. The original version ++of this code was written as part of a project to build a fixed-point vector ++processor in collaboration with the University of California at Berkeley, ++overseen by Profs. Nelson Morgan and John Wawrzynek. More information ++is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ ++arithmetic/SoftFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) the source code for the derivative work includes prominent notice that ++the work is derivative, and (2) the source code includes prominent notice with ++these four paragraphs for those parts of this code that are retained. ++ ++=============================================================================*/ ++ ++/*---------------------------------------------------------------------------- ++| Include common integer types and flags. ++*----------------------------------------------------------------------------*/ ++#include "../../../processors/SPARC-GCC.h" ++ ++/*---------------------------------------------------------------------------- ++| Symbolic Boolean literals. ++*----------------------------------------------------------------------------*/ ++enum { ++ FALSE = 0, ++ TRUE = 1 ++}; ++ +diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize +new file mode 100644 +index 0000000..b1d0bc8 +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize +@@ -0,0 +1,422 @@ ++/* ++ * This file is derived from softfloat/bits64/386-Win32-GCC/softfloat-specialize, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/*============================================================================ ++ ++This C source fragment is part of the SoftFloat IEC/IEEE Floating-point ++Arithmetic Package, Release 2b. ++ ++Written by John R. Hauser. This work was made possible in part by the ++International Computer Science Institute, located at Suite 600, 1947 Center ++Street, Berkeley, California 94704. Funding was partially provided by the ++National Science Foundation under grant MIP-9311980. The original version ++of this code was written as part of a project to build a fixed-point vector ++processor in collaboration with the University of California at Berkeley, ++overseen by Profs. Nelson Morgan and John Wawrzynek. More information ++is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ ++arithmetic/SoftFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) the source code for the derivative work includes prominent notice that ++the work is derivative, and (2) the source code includes prominent notice with ++these four paragraphs for those parts of this code that are retained. ++ ++=============================================================================*/ ++ ++/*---------------------------------------------------------------------------- ++| Underflow tininess-detection mode, statically initialized to default value. ++| (The declaration in `softfloat.h' must match the `int8' type here.) ++*----------------------------------------------------------------------------*/ ++int8 float_detect_tininess = float_tininess_before_rounding; ++ ++/*---------------------------------------------------------------------------- ++| Raises the exceptions specified by `flags'. Floating-point traps can be ++| defined here if desired. It is currently not possible for such a trap ++| to substitute a result value. If traps are not implemented, this routine ++| should be simply `float_exception_flags |= flags;'. ++*----------------------------------------------------------------------------*/ ++ ++void float_raise( int8 flags ) ++{ ++ ++ float_exception_flags |= flags; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Internal canonical NaN format. ++*----------------------------------------------------------------------------*/ ++typedef struct { ++ flag sign; ++ bits64 high, low; ++} commonNaNT; ++ ++/*---------------------------------------------------------------------------- ++| The pattern for a default generated single-precision NaN. ++*----------------------------------------------------------------------------*/ ++#define float32_default_nan 0x7FFFFFFF ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the single-precision floating-point value `a' is a NaN; ++| otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float32_is_nan( float32 a ) ++{ ++ ++ return ( 0xFF000000 < (bits32) ( a<<1 ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the single-precision floating-point value `a' is a signaling ++| NaN; otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float32_is_signaling_nan( float32 a ) ++{ ++ ++ return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the single-precision floating-point NaN ++| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid ++| exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static commonNaNT float32ToCommonNaN( float32 a ) ++{ ++ commonNaNT z; ++ ++ if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); ++ z.sign = a>>31; ++ z.low = 0; ++ z.high = ( (bits64) a )<<41; ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the canonical NaN `a' to the single- ++| precision floating-point format. ++*----------------------------------------------------------------------------*/ ++ ++static float32 commonNaNToFloat32( commonNaNT a ) ++{ ++ ++ return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Takes two single-precision floating-point values `a' and `b', one of which ++| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a ++| signaling NaN, the invalid exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static float32 propagateFloat32NaN( float32 a, float32 b ) ++{ ++ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; ++ ++ aIsNaN = float32_is_nan( a ); ++ aIsSignalingNaN = float32_is_signaling_nan( a ); ++ bIsNaN = float32_is_nan( b ); ++ bIsSignalingNaN = float32_is_signaling_nan( b ); ++ a |= 0x00400000; ++ b |= 0x00400000; ++ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); ++ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| The pattern for a default generated double-precision NaN. ++*----------------------------------------------------------------------------*/ ++#define float64_default_nan LIT64( 0x7FFFFFFFFFFFFFFF ) ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the double-precision floating-point value `a' is a NaN; ++| otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float64_is_nan( float64 a ) ++{ ++ ++ return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the double-precision floating-point value `a' is a signaling ++| NaN; otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float64_is_signaling_nan( float64 a ) ++{ ++ ++ return ++ ( ( ( a>>51 ) & 0xFFF ) == 0xFFE ) ++ && ( a & LIT64( 0x0007FFFFFFFFFFFF ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the double-precision floating-point NaN ++| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid ++| exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static commonNaNT float64ToCommonNaN( float64 a ) ++{ ++ commonNaNT z; ++ ++ if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); ++ z.sign = a>>63; ++ z.low = 0; ++ z.high = a<<12; ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the canonical NaN `a' to the double- ++| precision floating-point format. ++*----------------------------------------------------------------------------*/ ++ ++static float64 commonNaNToFloat64( commonNaNT a ) ++{ ++ ++ return ++ ( ( (bits64) a.sign )<<63 ) ++ | LIT64( 0x7FF8000000000000 ) ++ | ( a.high>>12 ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Takes two double-precision floating-point values `a' and `b', one of which ++| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a ++| signaling NaN, the invalid exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static float64 propagateFloat64NaN( float64 a, float64 b ) ++{ ++ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; ++ ++ aIsNaN = float64_is_nan( a ); ++ aIsSignalingNaN = float64_is_signaling_nan( a ); ++ bIsNaN = float64_is_nan( b ); ++ bIsSignalingNaN = float64_is_signaling_nan( b ); ++ a |= LIT64( 0x0008000000000000 ); ++ b |= LIT64( 0x0008000000000000 ); ++ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); ++ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; ++ ++} ++ ++#ifdef FLOATX80 ++ ++/*---------------------------------------------------------------------------- ++| The pattern for a default generated extended double-precision NaN. The ++| `high' and `low' values hold the most- and least-significant bits, ++| respectively. ++*----------------------------------------------------------------------------*/ ++#define floatx80_default_nan_high 0x7FFF ++#define floatx80_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the extended double-precision floating-point value `a' is a ++| NaN; otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag floatx80_is_nan( floatx80 a ) ++{ ++ ++ return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the extended double-precision floating-point value `a' is a ++| signaling NaN; otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag floatx80_is_signaling_nan( floatx80 a ) ++{ ++ bits64 aLow; ++ ++ aLow = a.low & ~ LIT64( 0x4000000000000000 ); ++ return ++ ( ( a.high & 0x7FFF ) == 0x7FFF ) ++ && (bits64) ( aLow<<1 ) ++ && ( a.low == aLow ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the extended double-precision floating- ++| point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the ++| invalid exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static commonNaNT floatx80ToCommonNaN( floatx80 a ) ++{ ++ commonNaNT z; ++ ++ if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); ++ z.sign = a.high>>15; ++ z.low = 0; ++ z.high = a.low<<1; ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the canonical NaN `a' to the extended ++| double-precision floating-point format. ++*----------------------------------------------------------------------------*/ ++ ++static floatx80 commonNaNToFloatx80( commonNaNT a ) ++{ ++ floatx80 z; ++ ++ z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 ); ++ z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF; ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Takes two extended double-precision floating-point values `a' and `b', one ++| of which is a NaN, and returns the appropriate NaN result. If either `a' or ++| `b' is a signaling NaN, the invalid exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b ) ++{ ++ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; ++ ++ aIsNaN = floatx80_is_nan( a ); ++ aIsSignalingNaN = floatx80_is_signaling_nan( a ); ++ bIsNaN = floatx80_is_nan( b ); ++ bIsSignalingNaN = floatx80_is_signaling_nan( b ); ++ a.low |= LIT64( 0xC000000000000000 ); ++ b.low |= LIT64( 0xC000000000000000 ); ++ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); ++ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; ++ ++} ++ ++#endif ++ ++#ifdef FLOAT128 ++ ++/*---------------------------------------------------------------------------- ++| The pattern for a default generated quadruple-precision NaN. The `high' and ++| `low' values hold the most- and least-significant bits, respectively. ++*----------------------------------------------------------------------------*/ ++#define float128_default_nan_high LIT64( 0x7FFFFFFFFFFFFFFF ) ++#define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the quadruple-precision floating-point value `a' is a NaN; ++| otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float128_is_nan( float128 a ) ++{ ++ ++ return ++ ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) ) ++ && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns 1 if the quadruple-precision floating-point value `a' is a ++| signaling NaN; otherwise returns 0. ++*----------------------------------------------------------------------------*/ ++ ++flag float128_is_signaling_nan( float128 a ) ++{ ++ ++ return ++ ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE ) ++ && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) ); ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the quadruple-precision floating-point NaN ++| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid ++| exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static commonNaNT float128ToCommonNaN( float128 a ) ++{ ++ commonNaNT z; ++ ++ if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); ++ z.sign = a.high>>63; ++ shortShift128Left( a.high, a.low, 16, &z.high, &z.low ); ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Returns the result of converting the canonical NaN `a' to the quadruple- ++| precision floating-point format. ++*----------------------------------------------------------------------------*/ ++ ++static float128 commonNaNToFloat128( commonNaNT a ) ++{ ++ float128 z; ++ ++ shift128Right( a.high, a.low, 16, &z.high, &z.low ); ++ z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 ); ++ return z; ++ ++} ++ ++/*---------------------------------------------------------------------------- ++| Takes two quadruple-precision floating-point values `a' and `b', one of ++| which is a NaN, and returns the appropriate NaN result. If either `a' or ++| `b' is a signaling NaN, the invalid exception is raised. ++*----------------------------------------------------------------------------*/ ++ ++static float128 propagateFloat128NaN( float128 a, float128 b ) ++{ ++ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; ++ ++ aIsNaN = float128_is_nan( a ); ++ aIsSignalingNaN = float128_is_signaling_nan( a ); ++ bIsNaN = float128_is_nan( b ); ++ bIsSignalingNaN = float128_is_signaling_nan( b ); ++ a.high |= LIT64( 0x0000800000000000 ); ++ b.high |= LIT64( 0x0000800000000000 ); ++ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); ++ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; ++ ++} ++ ++#endif ++ +diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h +new file mode 100644 +index 0000000..5b7cb1c +--- /dev/null ++++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h +@@ -0,0 +1,269 @@ ++/* ++ * This file is derived from softfloat/bits64/386-Win32-GCC/softfloat.h, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/*============================================================================ ++ ++This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic ++Package, Release 2b. ++ ++Written by John R. Hauser. This work was made possible in part by the ++International Computer Science Institute, located at Suite 600, 1947 Center ++Street, Berkeley, California 94704. Funding was partially provided by the ++National Science Foundation under grant MIP-9311980. The original version ++of this code was written as part of a project to build a fixed-point vector ++processor in collaboration with the University of California at Berkeley, ++overseen by Profs. Nelson Morgan and John Wawrzynek. More information ++is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ ++arithmetic/SoftFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) the source code for the derivative work includes prominent notice that ++the work is derivative, and (2) the source code includes prominent notice with ++these four paragraphs for those parts of this code that are retained. ++ ++=============================================================================*/ ++ ++/*---------------------------------------------------------------------------- ++| The macro `FLOATX80' must be defined to enable the extended double-precision ++| floating-point format `floatx80'. If this macro is not defined, the ++| `floatx80' type will not be defined, and none of the functions that either ++| input or output the `floatx80' type will be defined. The same applies to ++| the `FLOAT128' macro and the quadruple-precision format `float128'. ++*----------------------------------------------------------------------------*/ ++#define FLOATX80 ++#define FLOAT128 ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point types. ++*----------------------------------------------------------------------------*/ ++typedef unsigned int float32; ++typedef unsigned long long float64; ++#ifdef FLOATX80 ++typedef struct { ++ unsigned short high; ++ unsigned long long low; ++} floatx80; ++#endif ++#ifdef FLOAT128 ++typedef struct { ++ unsigned long long high, low; ++} float128; ++#endif ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point underflow tininess-detection mode. ++*----------------------------------------------------------------------------*/ ++extern int float_detect_tininess; ++enum { ++ float_tininess_after_rounding = 0, ++ float_tininess_before_rounding = 1 ++}; ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point rounding mode. ++*----------------------------------------------------------------------------*/ ++extern int float_rounding_mode; ++enum { ++ float_round_nearest_even = 0, ++ float_round_to_zero = 1, ++ float_round_up = 2, ++ float_round_down = 3 ++}; ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE floating-point exception flags. ++*----------------------------------------------------------------------------*/ ++extern int float_exception_flags; ++enum { ++ float_flag_inexact = 1, ++ float_flag_divbyzero = 2, ++ float_flag_underflow = 4, ++ float_flag_overflow = 8, ++ float_flag_invalid = 16 ++}; ++ ++/*---------------------------------------------------------------------------- ++| Routine to raise any or all of the software IEC/IEEE floating-point ++| exception flags. ++*----------------------------------------------------------------------------*/ ++void float_raise( int ); ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE integer-to-floating-point conversion routines. ++*----------------------------------------------------------------------------*/ ++float32 int32_to_float32( int ); ++float64 int32_to_float64( int ); ++#ifdef FLOATX80 ++floatx80 int32_to_floatx80( int ); ++#endif ++#ifdef FLOAT128 ++float128 int32_to_float128( int ); ++#endif ++float32 int64_to_float32( long long ); ++float64 int64_to_float64( long long ); ++#ifdef FLOATX80 ++floatx80 int64_to_floatx80( long long ); ++#endif ++#ifdef FLOAT128 ++float128 int64_to_float128( long long ); ++#endif ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE single-precision conversion routines. ++*----------------------------------------------------------------------------*/ ++int float32_to_int32( float32 ); ++int float32_to_int32_round_to_zero( float32 ); ++long long float32_to_int64( float32 ); ++long long float32_to_int64_round_to_zero( float32 ); ++float64 float32_to_float64( float32 ); ++#ifdef FLOATX80 ++floatx80 float32_to_floatx80( float32 ); ++#endif ++#ifdef FLOAT128 ++float128 float32_to_float128( float32 ); ++#endif ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE single-precision operations. ++*----------------------------------------------------------------------------*/ ++float32 float32_round_to_int( float32 ); ++float32 float32_add( float32, float32 ); ++float32 float32_sub( float32, float32 ); ++float32 float32_mul( float32, float32 ); ++float32 float32_div( float32, float32 ); ++float32 float32_rem( float32, float32 ); ++float32 float32_sqrt( float32 ); ++int float32_eq( float32, float32 ); ++int float32_le( float32, float32 ); ++int float32_lt( float32, float32 ); ++int float32_eq_signaling( float32, float32 ); ++int float32_le_quiet( float32, float32 ); ++int float32_lt_quiet( float32, float32 ); ++int float32_is_signaling_nan( float32 ); ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE double-precision conversion routines. ++*----------------------------------------------------------------------------*/ ++int float64_to_int32( float64 ); ++int float64_to_int32_round_to_zero( float64 ); ++long long float64_to_int64( float64 ); ++long long float64_to_int64_round_to_zero( float64 ); ++float32 float64_to_float32( float64 ); ++#ifdef FLOATX80 ++floatx80 float64_to_floatx80( float64 ); ++#endif ++#ifdef FLOAT128 ++float128 float64_to_float128( float64 ); ++#endif ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE double-precision operations. ++*----------------------------------------------------------------------------*/ ++float64 float64_round_to_int( float64 ); ++float64 float64_add( float64, float64 ); ++float64 float64_sub( float64, float64 ); ++float64 float64_mul( float64, float64 ); ++float64 float64_div( float64, float64 ); ++float64 float64_rem( float64, float64 ); ++float64 float64_sqrt( float64 ); ++int float64_eq( float64, float64 ); ++int float64_le( float64, float64 ); ++int float64_lt( float64, float64 ); ++int float64_eq_signaling( float64, float64 ); ++int float64_le_quiet( float64, float64 ); ++int float64_lt_quiet( float64, float64 ); ++int float64_is_signaling_nan( float64 ); ++ ++#ifdef FLOATX80 ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE extended double-precision conversion routines. ++*----------------------------------------------------------------------------*/ ++int floatx80_to_int32( floatx80 ); ++int floatx80_to_int32_round_to_zero( floatx80 ); ++long long floatx80_to_int64( floatx80 ); ++long long floatx80_to_int64_round_to_zero( floatx80 ); ++float32 floatx80_to_float32( floatx80 ); ++float64 floatx80_to_float64( floatx80 ); ++#ifdef FLOAT128 ++float128 floatx80_to_float128( floatx80 ); ++#endif ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE extended double-precision rounding precision. Valid ++| values are 32, 64, and 80. ++*----------------------------------------------------------------------------*/ ++extern int floatx80_rounding_precision; ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE extended double-precision operations. ++*----------------------------------------------------------------------------*/ ++floatx80 floatx80_round_to_int( floatx80 ); ++floatx80 floatx80_add( floatx80, floatx80 ); ++floatx80 floatx80_sub( floatx80, floatx80 ); ++floatx80 floatx80_mul( floatx80, floatx80 ); ++floatx80 floatx80_div( floatx80, floatx80 ); ++floatx80 floatx80_rem( floatx80, floatx80 ); ++floatx80 floatx80_sqrt( floatx80 ); ++int floatx80_eq( floatx80, floatx80 ); ++int floatx80_le( floatx80, floatx80 ); ++int floatx80_lt( floatx80, floatx80 ); ++int floatx80_eq_signaling( floatx80, floatx80 ); ++int floatx80_le_quiet( floatx80, floatx80 ); ++int floatx80_lt_quiet( floatx80, floatx80 ); ++int floatx80_is_signaling_nan( floatx80 ); ++ ++#endif ++ ++#ifdef FLOAT128 ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE quadruple-precision conversion routines. ++*----------------------------------------------------------------------------*/ ++int float128_to_int32( float128 ); ++int float128_to_int32_round_to_zero( float128 ); ++long long float128_to_int64( float128 ); ++long long float128_to_int64_round_to_zero( float128 ); ++float32 float128_to_float32( float128 ); ++float64 float128_to_float64( float128 ); ++#ifdef FLOATX80 ++floatx80 float128_to_floatx80( float128 ); ++#endif ++ ++/*---------------------------------------------------------------------------- ++| Software IEC/IEEE quadruple-precision operations. ++*----------------------------------------------------------------------------*/ ++float128 float128_round_to_int( float128 ); ++float128 float128_add( float128, float128 ); ++float128 float128_sub( float128, float128 ); ++float128 float128_mul( float128, float128 ); ++float128 float128_div( float128, float128 ); ++float128 float128_rem( float128, float128 ); ++float128 float128_sqrt( float128 ); ++int float128_eq( float128, float128 ); ++int float128_le( float128, float128 ); ++int float128_lt( float128, float128 ); ++int float128_eq_signaling( float128, float128 ); ++int float128_le_quiet( float128, float128 ); ++int float128_lt_quiet( float128, float128 ); ++int float128_is_signaling_nan( float128 ); ++ ++#endif ++ +-- +1.5.4 + diff --git a/recipes-extended/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch b/recipes-extended/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch new file mode 100644 index 0000000..c34421c --- /dev/null +++ b/recipes-extended/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch @@ -0,0 +1,1644 @@ +This patch adds PowerPC E500v2 SPE support in TestFloat. +And it disables the testing for hardware that can not trigger SPE interrupt. + +Signed-off-by: Ebony Zhu +Signed-off-by: Liu Yu +--- + processors/POWERPC-gcc.h | 99 +++++ + testfloat/powerpc-linux-gcc/Makefile | 83 +++++ + testfloat/powerpc-linux-gcc/milieu.h | 71 ++++ + testfloat/powerpc-linux-gcc/systflags.c | 107 ++++++ + testfloat/powerpc-linux-gcc/systfloat.c | 595 +++++++++++++++++++++++++++++++ + testfloat/powerpc-linux-gcc/systmodes.c | 67 ++++ + testfloat/templates/Makefile | 18 +- + testfloat/templates/milieu.h | 2 +- + testfloat/testFunction.h | 2 +- + testfloat/testLoops.c | 216 +++++++++++ + 10 files changed, 1252 insertions(+), 8 deletions(-) + create mode 100644 processors/POWERPC-gcc.h + create mode 100644 testfloat/powerpc-linux-gcc/Makefile + create mode 100644 testfloat/powerpc-linux-gcc/milieu.h + create mode 100644 testfloat/powerpc-linux-gcc/systflags.c + create mode 100644 testfloat/powerpc-linux-gcc/systfloat.c + create mode 100644 testfloat/powerpc-linux-gcc/systmodes.c + +diff --git a/processors/POWERPC-gcc.h b/processors/POWERPC-gcc.h +new file mode 100644 +index 0000000..4201faa +--- /dev/null ++++ b/processors/POWERPC-gcc.h +@@ -0,0 +1,99 @@ ++/* ++ * This file is derived from processors/i386-GCC.h, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ * ++ * THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has ++ * been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES ++ * RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS ++ * AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, ++ * COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE ++ * EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE ++ * INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR ++ * OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. ++ */ ++ ++/* ++------------------------------------------------------------------------------- ++One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined. ++------------------------------------------------------------------------------- ++*/ ++#define BIGENDIAN ++ ++/* ++------------------------------------------------------------------------------- ++The macro `BITS64' can be defined to indicate that 64-bit integer types are ++supported by the compiler. ++------------------------------------------------------------------------------- ++*/ ++#undef BITS64 ++ ++/* ++------------------------------------------------------------------------------- ++Each of the following `typedef's defines the most convenient type that holds ++integers of at least as many bits as specified. For example, `uint8' should ++be the most convenient type that can hold unsigned integers of as many as ++8 bits. The `flag' type must be able to hold either a 0 or 1. For most ++implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed ++to the same as `int'. ++------------------------------------------------------------------------------- ++*/ ++typedef int flag; ++typedef int uint8; ++typedef int int8; ++typedef int uint16; ++typedef int int16; ++typedef unsigned int uint32; ++typedef signed int int32; ++#ifdef BITS64 ++typedef unsigned long long int uint64; ++typedef signed long long int int64; ++#endif ++ ++/* ++------------------------------------------------------------------------------- ++Each of the following `typedef's defines a type that holds integers ++of _exactly_ the number of bits specified. For instance, for most ++implementation of C, `bits16' and `sbits16' should be `typedef'ed to ++`unsigned short int' and `signed short int' (or `short int'), respectively. ++------------------------------------------------------------------------------- ++*/ ++typedef unsigned char bits8; ++typedef signed char sbits8; ++typedef unsigned short int bits16; ++typedef signed short int sbits16; ++typedef unsigned int bits32; ++typedef signed int sbits32; ++#ifdef BITS64 ++typedef unsigned long long int bits64; ++typedef signed long long int sbits64; ++#endif ++ ++#ifdef BITS64 ++/* ++------------------------------------------------------------------------------- ++The `LIT64' macro takes as its argument a textual integer literal and ++if necessary ``marks'' the literal as having a 64-bit integer type. ++For example, the GNU C Compiler (`gcc') requires that 64-bit literals be ++appended with the letters `LL' standing for `long long', which is `gcc's ++name for the 64-bit integer type. Some compilers may allow `LIT64' to be ++defined as the identity macro: `#define LIT64( a ) a'. ++------------------------------------------------------------------------------- ++*/ ++#define LIT64( a ) a##LL ++#endif ++ ++/* ++------------------------------------------------------------------------------- ++The macro `INLINE' can be used before functions that should be inlined. If ++a compiler does not support explicit inlining, this macro should be defined ++to be `static'. ++------------------------------------------------------------------------------- ++*/ ++#define INLINE extern inline ++ +diff --git a/testfloat/powerpc-linux-gcc/Makefile b/testfloat/powerpc-linux-gcc/Makefile +new file mode 100644 +index 0000000..de50aad +--- /dev/null ++++ b/testfloat/powerpc-linux-gcc/Makefile +@@ -0,0 +1,83 @@ ++ ++PROCESSOR_H = ../../processors/POWERPC-gcc.h ++SOFTFLOAT_VERSION = bits32 ++TARGET = powerpc-GCC ++SOFTFLOAT_DIR = ../../SoftFloat-2b/softfloat/$(SOFTFLOAT_VERSION)/$(TARGET) ++ ++OBJ = .o ++EXE = ++INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR) ++ ++COMPILE_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS) ++ ++COMPILE_C_HARD = $(COMPILE_PREFIX)gcc -c -te500v2 -o $@ $(INCLUDES) ++ ++COMPILE_SLOWFLOAT_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O ++ ++LINK = $(COMPILE_PREFIX)gcc -lm -o $@ ++ ++SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h ++SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ) ++ ++ALL: testsoftfloat$(EXE) testfloat$(EXE) ++ ++systmodes$(OBJ): milieu.h systmodes.c ++ $(COMPILE_C) systmodes.c ++ ++systflags$(OBJ): milieu.h ../systflags.h systflags.c ++ $(COMPILE_C) systflags.c ++ ++systfloat$(OBJ): milieu.h $(SOFTFLOAT_H) ../systfloat.h systfloat.c ++ $(COMPILE_C_HARD) systfloat.c ++ ++#------------------------------------------------------------------------------ ++# Probably O.K. below here. ++#------------------------------------------------------------------------------ ++ ++milieu.h: $(PROCESSOR_H) ++ touch milieu.h ++ ++fail$(OBJ): milieu.h ../fail.h ++ $(COMPILE_C) ../fail.c ++ ++random$(OBJ): milieu.h ../random.h ++ $(COMPILE_C) ../random.c ++ ++testCases$(OBJ): milieu.h ../fail.h ../random.h $(SOFTFLOAT_H) ../testCases.h ../testCases.c ++ $(COMPILE_C) ../testCases.c ++ ++writeHex$(OBJ): milieu.h $(SOFTFLOAT_H) ../writeHex.h ../writeHex.c ++ $(COMPILE_C) ../writeHex.c ++ ++testLoops$(OBJ): milieu.h $(SOFTFLOAT_H) ../testCases.h ../writeHex.h ../testLoops.h ../testLoops.c ++ $(COMPILE_C) ../testLoops.c ++ ++slowfloat$(OBJ): milieu.h $(SOFTFLOAT_H) ../slowfloat.h ../slowfloat-32.c ../slowfloat-64.c ../slowfloat.c ++ $(COMPILE_SLOWFLOAT_C) ../slowfloat.c ++ ++testsoftfloat$(OBJ): milieu.h ../fail.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../slowfloat.h ../testsoftfloat.c ++ $(COMPILE_C) ../testsoftfloat.c ++ ++testsoftfloat$(EXE): fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) slowfloat$(OBJ) testsoftfloat$(OBJ) systflags$(OBJ) systmodes$(OBJ) ++ $(LINK) fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) slowfloat$(OBJ) testsoftfloat$(OBJ) systflags$(OBJ) systmodes$(OBJ) ++ ++testFunction$(OBJ): milieu.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../systmodes.h ../systflags.h ../systfloat.h ../testFunction.h ../testFunction.c ++ $(COMPILE_C) ../testFunction.c ++ ++testfloat$(OBJ): milieu.h ../fail.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../systflags.h ../testFunction.h ../testfloat.c ++ $(COMPILE_C) ../testfloat.c ++ ++testfloat$(EXE): fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) systmodes$(OBJ) systflags$(OBJ) systfloat$(OBJ) testFunction$(OBJ) testfloat$(OBJ) ++ $(LINK) fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) systmodes$(OBJ) systflags$(OBJ) systfloat$(OBJ) testFunction$(OBJ) testfloat$(OBJ) ++ ++$(SOFTFLOAT_OBJ): ++ make -C $(SOFTFLOAT_DIR) ++ ++cp: ALL ++ cp testsoftfloat$(EXE) ../../test_softfloat$(EXE) ++ cp testfloat$(EXE) ../../test_float$(EXE) ++ ++clean: ++ make -C $(SOFTFLOAT_DIR) clean ++ rm -f *.o testfloat$(EXE) testsoftfloat$(EXE) ++ rm -f ../../test_softfloat$(EXE) ../../test_float$(EXE) +diff --git a/testfloat/powerpc-linux-gcc/milieu.h b/testfloat/powerpc-linux-gcc/milieu.h +new file mode 100644 +index 0000000..29d2b18 +--- /dev/null ++++ b/testfloat/powerpc-linux-gcc/milieu.h +@@ -0,0 +1,71 @@ ++/* ++ * This file is derived from testfloat/386-Win32-gcc/milieu.h, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/* ++=============================================================================== ++ ++This C header file is part of TestFloat, Release 2a, a package of programs ++for testing the correctness of floating-point arithmetic complying to the ++IEC/IEEE Standard for Floating-Point. ++ ++Written by John R. Hauser. More information is available through the Web ++page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort ++has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT ++TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO ++PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY ++AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) they include prominent notice that the work is derivative, and (2) they ++include prominent notice akin to these four paragraphs for those parts of ++this code that are retained. ++ ++=============================================================================== ++*/ ++ ++/* ++------------------------------------------------------------------------------- ++Include common integer types and flags. ++------------------------------------------------------------------------------- ++*/ ++#include "../../processors/POWERPC-gcc.h" ++/* ++------------------------------------------------------------------------------- ++If the `BITS64' macro is defined by the processor header file but the ++version of SoftFloat being used/tested is the 32-bit one (`bits32'), the ++`BITS64' macro must be undefined here. ++------------------------------------------------------------------------------- ++*/ ++ ++#undef BITS64 ++/* ++------------------------------------------------------------------------------- ++The macro `LONG_DOUBLE_IS_FLOATX80' can be defined to indicate that the ++C compiler supports the type `long double' as an extended double-precision ++format. Alternatively, the macro `LONG_DOUBLE_IS_FLOAT128' can be defined ++to indicate that `long double' is a quadruple-precision format. If neither ++of these macros is defined, `long double' will be ignored. ++------------------------------------------------------------------------------- ++#define LONG_DOUBLE_IS_FLOATX80 ++*/ ++ ++/* ++------------------------------------------------------------------------------- ++Symbolic Boolean literals. ++------------------------------------------------------------------------------- ++*/ ++enum { ++ FALSE = 0, ++ TRUE = 1 ++}; ++ +diff --git a/testfloat/powerpc-linux-gcc/systflags.c b/testfloat/powerpc-linux-gcc/systflags.c +new file mode 100644 +index 0000000..c382442 +--- /dev/null ++++ b/testfloat/powerpc-linux-gcc/systflags.c +@@ -0,0 +1,107 @@ ++/* ++ * This file is derived from testfloat/386-Win32-gcc/systflags.c, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/* ++=============================================================================== ++ ++This C source file is part of TestFloat, Release 2a, a package of programs ++for testing the correctness of floating-point arithmetic complying to the ++IEC/IEEE Standard for Floating-Point. ++ ++Written by John R. Hauser. More information is available through the Web ++page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort ++has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT ++TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO ++PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY ++AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) they include prominent notice that the work is derivative, and (2) they ++include prominent notice akin to these four paragraphs for those parts of ++this code that are retained. ++ ++=============================================================================== ++*/ ++ ++#include "milieu.h" ++#include "systflags.h" ++#include ++#include ++#include ++#include ++#include ++ ++#ifdef __SPE__ ++ ++#include ++ ++ ++#define SPE_FINV_ENABLE (1UL << 5) ++#define SPE_FDBZ_ENABLE (1UL << 4) ++#define SPE_FUNF_ENABLE (1UL << 3) ++#define SPE_FOVF_ENABLE (1UL << 2) ++ ++#define SPE_FG (1UL << 13) ++#define SPE_FX (1UL << 12) ++#define SPE_FINV (1UL << 11) ++#define SPE_FDBZ (1UL << 10) ++#define SPE_FUNF (1UL << 9) ++#define SPE_FOVF (1UL << 8) ++ ++#define SPE_FG_H (1UL << 29) ++#define SPE_FX_H (1UL << 28) ++#define SPE_FINV_H (1UL << 27) ++#define SPE_FDBZ_H (1UL << 26) ++#define SPE_FUNF_H (1UL << 25) ++#define SPE_FOVF_H (1UL << 24) ++ ++static int is_soft_emu = 0; ++ ++#endif ++/* ++------------------------------------------------------------------------------- ++Clears the system's IEC/IEEE floating-point exception flags. Returns the ++previous value of the flags. ++------------------------------------------------------------------------------- ++*/ ++extern int rounding; ++unsigned int spefscr = 0; ++ ++int8 syst_float_flags_clear( void ) ++{ ++#ifdef TEST_KERNEL_EMU ++ if( (spefscr & (SPE_FINV | SPE_FINV_H)) ++ || (spefscr & (SPE_FDBZ | SPE_FDBZ_H)) ++ || (spefscr & (SPE_FUNF | SPE_FUNF_H)) ++ || (spefscr & (SPE_FOVF | SPE_FOVF_H)) ++ || (spefscr & (SPE_FX | SPE_FG | SPE_FX_H | SPE_FG_H))){ ++ is_soft_emu = 1; ++ } else { ++ is_soft_emu = 0; ++ } ++#endif ++ __builtin_spe_mtspefscr(0x3c|(rounding & 0x3)); ++ ++ return ((spefscr>>17) & 0x1f); ++} ++ ++int syst_float_is_soft_emu(void) ++{ ++ int ret = 0; ++#ifdef TEST_KERNEL_EMU ++ ret = is_soft_emu; ++#endif ++ return ret; ++} ++ ++ +diff --git a/testfloat/powerpc-linux-gcc/systfloat.c b/testfloat/powerpc-linux-gcc/systfloat.c +new file mode 100644 +index 0000000..8d06f9f +--- /dev/null ++++ b/testfloat/powerpc-linux-gcc/systfloat.c +@@ -0,0 +1,595 @@ ++/* ++ * This file is derived from testfloat/systfloat.c, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/* ++=============================================================================== ++ ++This C source file is part of TestFloat, Release 2a, a package of programs ++for testing the correctness of floating-point arithmetic complying to the ++IEC/IEEE Standard for Floating-Point. ++ ++Written by John R. Hauser. More information is available through the Web ++page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort ++has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT ++TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO ++PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY ++AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) they include prominent notice that the work is derivative, and (2) they ++include prominent notice akin to these four paragraphs for those parts of ++this code that are retained. ++ ++=============================================================================== ++*/ ++ ++#include ++#include "milieu.h" ++#include "softfloat.h" ++#include "systfloat.h" ++ ++extern unsigned int spefscr; ++ ++float32 syst_int32_to_float32( int32 a ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = a; ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float64 syst_int32_to_float64( int32 a ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = a; ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) ++ ++floatx80 syst_int32_to_floatx80( int32 a ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = a; ++ return z; ++ ++} ++ ++#endif ++ ++#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) ++ ++float128 syst_int32_to_float128( int32 a ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = a; ++ return z; ++ ++} ++ ++#endif ++ ++#ifdef BITS64 ++ ++float32 syst_int64_to_float32( int64 a ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = a; ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float64 syst_int64_to_float64( int64 a ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = a; ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) ++ ++floatx80 syst_int64_to_floatx80( int64 a ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = a; ++ return z; ++ ++} ++ ++#endif ++ ++#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) ++ ++float128 syst_int64_to_float128( int64 a ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = a; ++ return z; ++ ++} ++ ++#endif ++ ++#endif ++ ++int32 syst_float32_to_int32_round_to_zero( float32 a ) ++{ ++ int32 z = *( (float *) &a ); ++ spefscr = __builtin_spe_mfspefscr(); ++ ++ return z; ++ ++} ++ ++#ifdef BITS64 ++ ++int64 syst_float32_to_int64_round_to_zero( float32 a ) ++{ ++ int64 z = *( (float *) &a ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++#endif ++ ++float64 syst_float32_to_float64( float32 a ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = *( (float *) &a ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) ++ ++floatx80 syst_float32_to_floatx80( float32 a ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = *( (float *) &a ); ++ return z; ++ ++} ++ ++#endif ++ ++#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) ++ ++float128 syst_float32_to_float128( float32 a ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = *( (float *) &a ); ++ return z; ++ ++} ++ ++#endif ++ ++float32 syst_float32_add( float32 a, float32 b ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = *( (float *) &a ) + *( (float *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float32 syst_float32_sub( float32 a, float32 b ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = *( (float *) &a ) - *( (float *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float32 syst_float32_mul( float32 a, float32 b ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = *( (float *) &a ) * *( (float *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float32 syst_float32_div( float32 a, float32 b ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = *( (float *) &a ) / *( (float *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++flag syst_float32_eq( float32 a, float32 b ) ++{ ++ flag f = ( *( (float *) &a ) == *( (float *) &b ) ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return f; ++ ++} ++ ++flag syst_float32_le( float32 a, float32 b ) ++{ ++ flag f = ( *( (float *) &a ) <= *( (float *) &b ) ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return f; ++ ++} ++ ++flag syst_float32_lt( float32 a, float32 b ) ++{ ++ flag f = ( *( (float *) &a ) < *( (float *) &b ) ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return f; ++ ++} ++ ++int32 syst_float64_to_int32_round_to_zero( float64 a ) ++{ ++ int32 z = *( (double *) &a ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++#ifdef BITS64 ++ ++int64 syst_float64_to_int64_round_to_zero( float64 a ) ++{ ++ int64 z = *( (double *) &a ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++#endif ++ ++float32 syst_float64_to_float32( float64 a ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = *( (double *) &a ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) ++ ++floatx80 syst_float64_to_floatx80( float64 a ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = *( (double *) &a ); ++ return z; ++ ++} ++ ++#endif ++ ++#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) ++ ++float128 syst_float64_to_float128( float64 a ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = *( (double *) &a ); ++ return z; ++ ++} ++ ++#endif ++ ++float64 syst_float64_add( float64 a, float64 b ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = *( (double *) &a ) + *( (double *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float64 syst_float64_sub( float64 a, float64 b ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = *( (double *) &a ) - *( (double *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float64 syst_float64_mul( float64 a, float64 b ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = *( (double *) &a ) * *( (double *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float64 syst_float64_div( float64 a, float64 b ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = *( (double *) &a ) / *( (double *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++float64 syst_float64_sqrt( float64 a ) ++{ ++ /* Ebony ++ float64 z; ++ ++ *( (double *) &z ) = sqrt( *( (double *) &a ) ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ */ ++ ++} ++ ++flag syst_float64_eq( float64 a, float64 b ) ++{ ++ flag f = ( *( (double *) &a ) == *( (double *) &b ) ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return f; ++ ++} ++ ++flag syst_float64_le( float64 a, float64 b ) ++{ ++ flag f = ( *( (double *) &a ) <= *( (double *) &b ) ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return f; ++ ++} ++ ++flag syst_float64_lt( float64 a, float64 b ) ++{ ++ flag f = ( *( (double *) &a ) < *( (double *) &b ) ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return f; ++ ++} ++ ++#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) ++ ++int32 syst_floatx80_to_int32_round_to_zero( floatx80 a ) ++{ ++ ++ return *( (long double *) &a ); ++ ++} ++ ++#ifdef BITS64 ++ ++int64 syst_floatx80_to_int64_round_to_zero( floatx80 a ) ++{ ++ ++ return *( (long double *) &a ); ++ ++} ++ ++#endif ++ ++float32 syst_floatx80_to_float32( floatx80 a ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = *( (long double *) &a ); ++ return z; ++ ++} ++ ++float64 syst_floatx80_to_float64( floatx80 a ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = *( (long double *) &a ); ++ return z; ++ ++} ++ ++floatx80 syst_floatx80_add( floatx80 a, floatx80 b ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) + *( (long double *) &b ); ++ return z; ++ ++} ++ ++floatx80 syst_floatx80_sub( floatx80 a, floatx80 b ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) - *( (long double *) &b ); ++ return z; ++ ++} ++ ++floatx80 syst_floatx80_mul( floatx80 a, floatx80 b ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) * *( (long double *) &b ); ++ return z; ++ ++} ++ ++floatx80 syst_floatx80_div( floatx80 a, floatx80 b ) ++{ ++ floatx80 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) / *( (long double *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++flag syst_floatx80_eq( floatx80 a, floatx80 b ) ++{ ++ ++ return ( *( (long double *) &a ) == *( (long double *) &b ) ); ++ ++} ++ ++flag syst_floatx80_le( floatx80 a, floatx80 b ) ++{ ++ ++ return ( *( (long double *) &a ) <= *( (long double *) &b ) ); ++ ++} ++ ++flag syst_floatx80_lt( floatx80 a, floatx80 b ) ++{ ++ ++ return ( *( (long double *) &a ) < *( (long double *) &b ) ); ++ ++} ++ ++#endif ++ ++#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) ++ ++int32 syst_float128_to_int32_round_to_zero( float128 a ) ++{ ++ ++ return *( (long double *) &a ); ++ ++} ++ ++#ifdef BITS64 ++ ++int64 syst_float128_to_int64_round_to_zero( float128 a ) ++{ ++ ++ return *( (long double *) &a ); ++ ++} ++ ++#endif ++ ++float32 syst_float128_to_float32( float128 a ) ++{ ++ float32 z; ++ ++ *( (float *) &z ) = *( (long double *) &a ); ++ return z; ++ ++} ++ ++float64 syst_float128_to_float64( float128 a ) ++{ ++ float64 z; ++ ++ *( (double *) &z ) = *( (long double *) &a ); ++ return z; ++ ++} ++ ++float128 syst_float128_add( float128 a, float128 b ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) + *( (long double *) &b ); ++ return z; ++ ++} ++ ++float128 syst_float128_sub( float128 a, float128 b ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) - *( (long double *) &b ); ++ return z; ++ ++} ++ ++float128 syst_float128_mul( float128 a, float128 b ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) * *( (long double *) &b ); ++ return z; ++ ++} ++ ++float128 syst_float128_div( float128 a, float128 b ) ++{ ++ float128 z; ++ ++ *( (long double *) &z ) = ++ *( (long double *) &a ) / *( (long double *) &b ); ++ spefscr = __builtin_spe_mfspefscr(); ++ return z; ++ ++} ++ ++flag syst_float128_eq( float128 a, float128 b ) ++{ ++ ++ return ( *( (long double *) &a ) == *( (long double *) &b ) ); ++ ++} ++ ++flag syst_float128_le( float128 a, float128 b ) ++{ ++ ++ return ( *( (long double *) &a ) <= *( (long double *) &b ) ); ++ ++} ++ ++flag syst_float128_lt( float128 a, float128 b ) ++{ ++ ++ return ( *( (long double *) &a ) < *( (long double *) &b ) ); ++ ++} ++ ++#endif ++ +diff --git a/testfloat/powerpc-linux-gcc/systmodes.c b/testfloat/powerpc-linux-gcc/systmodes.c +new file mode 100644 +index 0000000..143cdea +--- /dev/null ++++ b/testfloat/powerpc-linux-gcc/systmodes.c +@@ -0,0 +1,67 @@ ++/* ++ * This file is derived from testfloat/386-Win32-gcc/systmodes.S, ++ * the copyright for that material belongs to the original owners. ++ * ++ * Additional material and changes where applicable is: ++ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * Author: Ebony Zhu, ++ * Yu Liu, ++ */ ++ ++/* ++=============================================================================== ++ ++This C source file is part of TestFloat, Release 2a, a package of programs ++for testing the correctness of floating-point arithmetic complying to the ++IEC/IEEE Standard for Floating-Point. ++ ++Written by John R. Hauser. More information is available through the Web ++page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. ++ ++THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort ++has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT ++TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO ++PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY ++AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. ++ ++Derivative works are acceptable, even for commercial purposes, so long as ++(1) they include prominent notice that the work is derivative, and (2) they ++include prominent notice akin to these four paragraphs for those parts of ++this code that are retained. ++ ++=============================================================================== ++*/ ++ ++#include ++#include "milieu.h" ++#include "systmodes.h" ++/* ++------------------------------------------------------------------------------- ++Sets the system's IEC/IEEE floating-point rounding mode. Also disables all ++system exception traps. ++------------------------------------------------------------------------------- ++*/ ++int rounding; ++ ++void syst_float_set_rounding_mode( int8 roundingMode ) ++{ ++ (void) fesetround ( roundingMode ); ++ rounding = roundingMode; ++} ++ ++/* ++------------------------------------------------------------------------------- ++Sets the rounding precision of subsequent extended double-precision ++operations. The `precision' argument should be one of 0, 32, 64, or 80. ++If `precision' is 32, the rounding precision is set equivalent to single ++precision; else if `precision' is 64, the rounding precision is set ++equivalent to double precision; else the rounding precision is set to full ++extended double precision. ++------------------------------------------------------------------------------- ++*/ ++void syst_float_set_rounding_precision( int8 precision ) ++{ ++ ++} ++ +diff --git a/testfloat/templates/Makefile b/testfloat/templates/Makefile +index f5f3cde..18cffe0 100644 +--- a/testfloat/templates/Makefile ++++ b/testfloat/templates/Makefile +@@ -1,15 +1,21 @@ + +-PROCESSOR_H = ../../processors/!!!processor.h ++#PROCESSOR_H = ../../processors/!!!processor.h ++PROCESSOR_H = ../../processors/POWERPC-gcc.h + SOFTFLOAT_VERSION = bits64 +-TARGET = !!!target +-SOFTFLOAT_DIR = ../../softfloat/$(SOFTFLOAT_VERSION)/$(TARGET) ++ ++#TARGET = !!!target ++TARGET = powerpc-GCC ++SOFTFLOAT_DIR = ../../../SoftFloat-2b/softfloat/$(SOFTFLOAT_VERSION)/$(TARGET) + + OBJ = .o + EXE = + INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR) +-COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2 +-COMPILE_SLOWFLOAT_C = gcc -c -o $@ $(INCLUDES) -I- -O3 +-LINK = gcc -o $@ ++#COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2 ++#COMPILE_SLOWFLOAT_C = gcc -c -o $@ $(INCLUDES) -I- -O3 ++#LINK = gcc -o $@ ++COMPILE_C = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -c -o $@ $(INCLUDES) -I- -O2 ++COMPILE_SLOWFLOAT_C = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -c -o $@ $(INCLUDES) -I- -O3 ++LINK = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -o $@ + + SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h + SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ) +diff --git a/testfloat/templates/milieu.h b/testfloat/templates/milieu.h +index 56d3ac4..3214ca8 100644 +--- a/testfloat/templates/milieu.h ++++ b/testfloat/templates/milieu.h +@@ -28,7 +28,7 @@ this code that are retained. + Include common integer types and flags. + ------------------------------------------------------------------------------- + */ +-#include "../../processors/!!!processor.h" ++#include "../../processors/SPARC-gcc.h" + + /* + ------------------------------------------------------------------------------- +diff --git a/testfloat/testFunction.h b/testfloat/testFunction.h +index 04bf856..00139a7 100644 +--- a/testfloat/testFunction.h ++++ b/testfloat/testFunction.h +@@ -126,8 +126,8 @@ extern const flag functionExists[ NUM_FUNCTIONS ]; + enum { + ROUND_NEAREST_EVEN = 1, + ROUND_TO_ZERO, +- ROUND_DOWN, + ROUND_UP, ++ ROUND_DOWN, + NUM_ROUNDINGMODES + }; + +diff --git a/testfloat/testLoops.c b/testfloat/testLoops.c +index 8ba92f3..ba05548 100644 +--- a/testfloat/testLoops.c ++++ b/testfloat/testLoops.c +@@ -488,6 +488,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -539,6 +544,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -592,6 +602,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -647,6 +662,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -702,6 +722,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -753,6 +778,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -806,6 +836,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -861,6 +896,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_int64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -916,6 +956,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -973,6 +1018,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1030,6 +1080,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1087,6 +1142,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1146,6 +1206,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1203,6 +1268,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1260,6 +1330,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32, testCases_b_float32 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1312,6 +1387,25 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float32, testCases_b_float32 ); + testFlags = testFlagsFunctionPtr(); ++ ++if(testCases_a_float32 == 0x7ffffe && testCases_b_float32 == 0x3f7ffffe) ++{ ++ ++ writeErrorFound( 10000 - count ); ++ writeInputs_ab_float32(); ++ fputs( " ", stdout ); ++ writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); ++ fflush( stdout ); ++ if (! syst_float_is_soft_emu()){ ++ exit(-1); ++ } ++} ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif ++ + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1370,6 +1464,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1427,6 +1526,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1484,6 +1588,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1541,6 +1650,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1600,6 +1714,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1657,6 +1776,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1714,6 +1838,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64, testCases_b_float64 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1766,6 +1895,13 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float64, testCases_b_float64 ); + testFlags = testFlagsFunctionPtr(); ++ ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif ++ + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1826,6 +1962,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1883,6 +2024,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1940,6 +2086,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -1995,6 +2146,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2052,6 +2208,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2109,6 +2270,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2166,6 +2332,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2218,6 +2389,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2280,6 +2456,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2337,6 +2518,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2394,6 +2580,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2449,6 +2640,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2506,6 +2702,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2563,6 +2764,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2620,6 +2826,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128, testCases_b_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +@@ -2672,6 +2883,11 @@ void + (void) testFlagsFunctionPtr(); + testZ = testFunction( testCases_a_float128, testCases_b_float128 ); + testFlags = testFlagsFunctionPtr(); ++#ifdef TEST_KERNEL_EMU ++ if (! syst_float_is_soft_emu()){ ++ continue; ++ } ++#endif + --count; + if ( count == 0 ) { + checkEarlyExit(); +-- +1.5.4 + diff --git a/recipes-extended/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch b/recipes-extended/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch new file mode 100644 index 0000000..42de56d --- /dev/null +++ b/recipes-extended/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch @@ -0,0 +1,67 @@ +From 6c7567e05c28b8cb6c7dc68c278950a32feb6f64 Mon Sep 17 00:00:00 2001 +From: Ting Liu +Date: Wed, 9 May 2012 02:42:57 -0500 +Subject: [PATCH] Yocto: replace $(COMPILE_PREFIX)gcc with $(CC) and remove -te500v2 flags + +Signed-off-by: Ting Liu +--- + SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile | 4 ++-- + SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile | 4 ++-- + testfloat/powerpc-linux-gcc/Makefile | 8 ++++---- + 3 files changed, 8 insertions(+), 8 deletions(-) + +diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile +index 28f1e33..4098048 100644 +--- a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile ++++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile +@@ -5,8 +5,8 @@ SOFTFLOAT_MACROS = ../softfloat-macros + OBJ = .o + EXE = + INCLUDES = -I. -I.. +-COMPILE_C = $(COMPILE_PREFIX)gcc -msoft-float -c -o $@ $(INCLUDES) -I- -O2 +-LINK = $(COMPILE_PREFIX)gcc -o $@ ++COMPILE_C = $(CC) -msoft-float -c -o $@ $(INCLUDES) -I- -O2 ++LINK = $(CC) -o $@ + + ALL: softfloat$(OBJ) timesoftfloat$(EXE) + +diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile +index a5e2cc7..c34e16e 100644 +--- a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile ++++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile +@@ -5,8 +5,8 @@ SOFTFLOAT_MACROS = ../softfloat-macros + OBJ = .o + EXE = + INCLUDES = -I. -I.. +-COMPILE_C = $(COMPILE_PREFIX) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2 +-LINK = $(COMPILE_PREFIX) -o $@ ++COMPILE_C = $(CC) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2 ++LINK = $(CC) -o $@ + + ALL: softfloat$(OBJ) timesoftfloat$(EXE) + +diff --git a/testfloat/powerpc-linux-gcc/Makefile b/testfloat/powerpc-linux-gcc/Makefile +index de50aad..1a8b5f7 100644 +--- a/testfloat/powerpc-linux-gcc/Makefile ++++ b/testfloat/powerpc-linux-gcc/Makefile +@@ -8,13 +8,13 @@ OBJ = .o + EXE = + INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR) + +-COMPILE_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS) ++COMPILE_C = $(CC) -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS) + +-COMPILE_C_HARD = $(COMPILE_PREFIX)gcc -c -te500v2 -o $@ $(INCLUDES) ++COMPILE_C_HARD = $(CC) -c -o $@ $(INCLUDES) + +-COMPILE_SLOWFLOAT_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O ++COMPILE_SLOWFLOAT_C = $(CC) -c -o $@ $(INCLUDES) -I- -O + +-LINK = $(COMPILE_PREFIX)gcc -lm -o $@ ++LINK = $(CC) -lm -o $@ + + SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h + SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ) +-- +1.7.3.4 + diff --git a/recipes-extended/testfloat/testfloat_2a.bb b/recipes-extended/testfloat/testfloat_2a.bb new file mode 100644 index 0000000..3fbb207 --- /dev/null +++ b/recipes-extended/testfloat/testfloat_2a.bb @@ -0,0 +1,46 @@ +DESCRIPTION = "A program for testing floating-point implementation" +SECTION = "test" +LICENSE = "Hauser TestFloat" + +LIC_FILES_CHKSUM = "file://testfloat/testfloat.txt;beginline=87;endline=95;md5=bdb2e8111838a48015c29bd97f5b6145" + +SRC_URI = " http://www.jhauser.us/arithmetic/TestFloat-2a.tar.Z;name=TestFloat \ + http://www.jhauser.us/arithmetic/SoftFloat-2b.tar.Z;name=SoftFloat \ + " +SRC_URI_append_fslmachine = " file://SoftFloat-powerpc-1.patch \ + file://TestFloat-powerpc-E500v2-SPE-1.patch \ + file://Yocto-replace-COMPILE_PREFIX-gcc.patch \ + " +SRC_URI[TestFloat.md5sum] = "4dc889319ae1e0c5381ec511f784553a" +SRC_URI[TestFloat.sha256sum] = "84d14aa42adefbda2ec9708b42946f7fa59f93689b042684bd027863481f8e4e" +SRC_URI[SoftFloat.md5sum] = "b4a58b5c941f1a2317e4c2500086e3fa" +SRC_URI[SoftFloat.sha256sum] = "89d14b55113a2ba8cbda7011443ba1d298d381c89d939515d56c5f18f2febf81" + +S = "${WORKDIR}/TestFloat-2a" + +do_unpack2(){ + mv ${WORKDIR}/SoftFloat-2b ${S}/SoftFloat-2b + cd ${S} + if [ -n "$(which fromdos)" ];then + find -type f -exec fromdos {} \; + elif [ -n "$(which dos2unix)" ];then + find -type f -exec dos2unix {} \; + else + echo -e "\nERROR: command dos2unix or fromdos not found\n" && return 1 + fi +} +addtask do_unpack2 after do_unpack before do_patch + +do_compile(){ + oe_runmake -C testfloat/powerpc-linux-gcc/ CC="${CC}" EXTRA_CFLAGS="-DTEST_KERNEL_EMU" +} + +do_install(){ + install -d ${D}/${bindir} + install testfloat/powerpc-linux-gcc/testfloat ${D}/${bindir} + install testfloat/powerpc-linux-gcc/testsoftfloat ${D}/${bindir} +} + +COMPATIBLE_HOST_e500v2 = ".*" +COMPATIBLE_HOST ?= "(none)" + diff --git a/recipes-extended/web-sysmon/web-sysmon_git.bb b/recipes-extended/web-sysmon/web-sysmon_git.bb new file mode 100644 index 0000000..1b2e070 --- /dev/null +++ b/recipes-extended/web-sysmon/web-sysmon_git.bb @@ -0,0 +1,21 @@ +DESCRIPTION = "Web System Monitor Files" +SECTION = "web-sysmon" +LICENSE = "GPLv2" +LIC_FILES_CHKSUM = "file://COPYING;md5=12f884d2ae1ff87c09e5b7ccc2c4ca7e" + +SRC_URI = "git://git.freescale.com/ppc/sdk/web-sysmon.git" +SRCREV = "40b47611378ef5c07d98f0f691bb146ae52dcdc1" + +S = "${WORKDIR}/git" + +FILES_${PN} += "/" + +RDEPENDS_${PN} = "lighttpd" + +do_install() { + install -d ${D}/etc + install -m 644 ${S}/lighttpd.conf ${D}/etc + install -d ${D}/usr/local/bin + install -m 755 ${S}/rrd/sens_update_rrd ${D}/usr/local/bin + cp -r ${S}/rrd ${D}/usr +} diff --git a/recipes-kernel/skmm/skmm_git.bb b/recipes-kernel/skmm/skmm_git.bb new file mode 100644 index 0000000..224e556 --- /dev/null +++ b/recipes-kernel/skmm/skmm_git.bb @@ -0,0 +1,33 @@ +DESCRIPTION = "SKMM application for PCIe endpoint" +SECTION = "skmm" +LICENSE = "BSD & GPLv2" +LIC_FILES_CHKSUM = "file://Makefile;endline=30;md5=39e58bedc879163c9338596e52df5b1f" + +DEPENDS = "libedit" + +SRC_URI = "git://git.freescale.com/ppc/sdk/skmm-ep.git" +SRCREV = "80d8393a2033b3b0cc8f885702d7b288956f3a37" + +COMPATIBLE_MACHINE = "(p4080ds|t4240qds)" + +S = "${WORKDIR}/git" + +EXTRA_OEMAKE = 'MACHINE=${MACHINE}' + +export LIBEDIT_CFLAGS="$(pkg-config --cflags libedit)" +export LIBEDIT_LDFLAGS="$(pkg-config --libs --static libedit)" + +do_compile () { + export ARCH=${TARGET_ARCH} + oe_runmake HOST=x86_64 clean + oe_runmake HOST=x86_64 + oe_runmake HOST=powerpc clean + oe_runmake HOST=powerpc +} + +do_install () { + oe_runmake ARCH=${TARGET_ARCH} HOST=x86_64 install DESTDIR=${D} + oe_runmake ARCH=${TARGET_ARCH} HOST=powerpc install DESTDIR=${D} +} + +FILES_${PN} += "/home/root/.skmm/*" diff --git a/recipes-kernel/u-boot/u-boot_git.bb b/recipes-kernel/u-boot/u-boot_git.bb deleted file mode 100644 index c3aa105..0000000 --- a/recipes-kernel/u-boot/u-boot_git.bb +++ /dev/null @@ -1,139 +0,0 @@ -DESCRIPTION = "U-boot bootloader" -HOMEPAGE = "http://u-boot.sf.net" -SECTION = "bootloaders" -PROVIDES = "virtual/bootloader" -LICENSE = "GPLv2" -LIC_FILES_CHKSUM = "file://COPYING;md5=1707d6db1d42237583f50183a5651ecb" - -PR = "r30" -INHIBIT_DEFAULT_DEPS = "1" -DEPENDS = "boot-format-native virtual/${TARGET_PREFIX}gcc libgcc" - -inherit deploy - -SRC_URI = "git://git.freescale.com/ppc/sdk/u-boot.git" -SRCREV = "831b30de4b768f0b3b7dbfa11739b14cea612d7e" - -python () { - ml = d.getVar("MULTILIB_VARIANTS", True) - arch = d.getVar("OVERRIDES", True) - - if ("e5500-64b:" in arch or "e6500-64b:" in arch) and not "lib32" in ml: - raise bb.parse.SkipPackage("Building the u-boot for this arch requires multilib to be enabled") -} - -DEPENDS_append_e5500-64b = " lib32-gcc-cross lib32-libgcc" -PATH_append_e5500-64b = ":${STAGING_BINDIR_NATIVE}/${DEFAULTTUNE_virtclass-multilib-lib32}${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}/" -TOOLCHAIN_OPTIONS_append_e5500-64b = "/../lib32-${MACHINE}" -TARGET_VENDOR_virtclass-multilib-lib32 ?= "-${DISTRO}mllib32" -WRAP_TARGET_PREFIX_e5500-64b = "powerpc${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}-" - -DEPENDS_append_e6500-64b = " lib32-gcc-cross lib32-libgcc" -PATH_append_e6500-64b = ":${STAGING_BINDIR_NATIVE}/${DEFAULTTUNE_virtclass-multilib-lib32}${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}/" -TOOLCHAIN_OPTIONS_append_e6500-64b = "/../lib32-${MACHINE}" -TARGET_VENDOR_virtclass-multilib-lib32 ?= "-${DISTRO}mllib32" -WRAP_TARGET_PREFIX_e6500-64b = "powerpc${TARGET_VENDOR_virtclass-multilib-lib32}-${HOST_OS}-" - -WRAP_TARGET_PREFIX = "${TARGET_PREFIX}" -EXTRA_OEMAKE = 'CROSS_COMPILE=${WRAP_TARGET_PREFIX} CC="${WRAP_TARGET_PREFIX}gcc ${TOOLCHAIN_OPTIONS}"' - -PACKAGE_ARCH = "${MACHINE_ARCH}" - -USRC ?= "" -S = '${@base_conditional("USRC", "", "${WORKDIR}/git", "${USRC}", d)}' - -do_compile () { - unset LDFLAGS - unset CFLAGS - unset CPPFLAGS - - if [ "x${UBOOT_MACHINES}" = "x" ]; then - UBOOT_MACHINES=${UBOOT_MACHINE} - fi - - for board in ${UBOOT_MACHINES}; do - oe_runmake O=${board} distclean - oe_runmake O=${board} ${board} - oe_runmake O=${board} all - - case "${board}" in - *SDCARD*) UBOOT_TARGET="u-boot-sd";; - *SPIFLASH*) UBOOT_TARGET="u-boot-spi";; - *NAND*) UBOOT_TARGET="u-boot-nand";; - *) UBOOT_TARGET="";; - esac - - if [ "x${UBOOT_TARGET}" != "x" ]; then - if [ "${UBOOT_TARGET}" = "u-boot-sd" ]; then - cp ${S}/${board}/u-boot.bin ${S}/${board}/${UBOOT_TARGET}.bin - elif [ "${UBOOT_TARGET}" = "u-boot-nand" ];then - if [ "${DEFAULTTUNE}" = "ppce500v2" ];then - if echo $board |egrep "(P1010RDB|P1020RDB|P1021RDB|P1024RDB|P2020RDB|P1022DS|P1025RDB|BSC9131RDB|BSC9132QDS)" 2>&1 >/dev/null;then - cp ${S}/${board}/u-boot-with-spl.bin ${S}/${board}/${UBOOT_TARGET}.bin - fi - else - cp ${S}/${board}/u-boot.bin ${S}/${board}/${UBOOT_TARGET}.bin - fi - else - if [ -n "${BOOTFORMAT_CONFIG}" ];then - ${STAGING_BINDIR_NATIVE}/boot_format \ - ${STAGING_DATADIR_NATIVE}/boot_format/${BOOTFORMAT_CONFIG} \ - ${S}/${board}/u-boot.bin -spi ${S}/${board}/${UBOOT_TARGET}.bin - else - cp ${S}/${board}/u-boot.bin ${S}/${board}/${UBOOT_TARGET}.bin - fi - fi - fi - done -} - -do_install(){ - if [ "x${UBOOT_MACHINES}" = "x" ]; then - UBOOT_MACHINES=${UBOOT_MACHINE} - fi - - for board in ${UBOOT_MACHINES}; do - case "${board}" in - *SDCARD*) UBOOT_TARGET="u-boot-sd";; - *SPIFLASH*) UBOOT_TARGET="u-boot-spi";; - *NAND*) UBOOT_TARGET="u-boot-nand";; - *) UBOOT_TARGET="u-boot";; - esac - - if [ -f ${S}/${board}/${UBOOT_TARGET}.bin ]; then - mkdir -p ${D}/boot/ - install ${S}/${board}/${UBOOT_TARGET}.bin ${D}/boot/${UBOOT_TARGET}-${board}-${PV}-${PR}.bin - ln -sf ${UBOOT_TARGET}-${board}-${PV}-${PR}.bin ${D}/boot/${UBOOT_TARGET}.bin - fi - done -} - -do_deploy(){ - if [ "x${UBOOT_MACHINES}" = "x" ]; then - UBOOT_MACHINES=${UBOOT_MACHINE} - fi - - for board in ${UBOOT_MACHINES}; do - case "${board}" in - *SDCARD*) UBOOT_TARGET="u-boot-sd";; - *SPIFLASH*) UBOOT_TARGET="u-boot-spi";; - *NAND*) UBOOT_TARGET="u-boot-nand";; - *) UBOOT_TARGET="u-boot";; - esac - - if [ -f ${S}/${board}/${UBOOT_TARGET}.bin ]; then - mkdir -p ${DEPLOYDIR} - install ${S}/${board}/${UBOOT_TARGET}.bin ${DEPLOYDIR}/${UBOOT_TARGET}-${board}-${PV}-${PR}.bin - - cd ${DEPLOYDIR} - rm -f ${UBOOT_TARGET}-${board}.bin - ln -sf ${UBOOT_TARGET}-${board}-${PV}-${PR}.bin ${UBOOT_TARGET}-${board}.bin - fi - done -} -addtask deploy after do_install - -PACKAGES += "${PN}-images" -FILES_${PN}-images += "/boot" - -ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-test/testfloat/files/SoftFloat-powerpc-1.patch b/recipes-test/testfloat/files/SoftFloat-powerpc-1.patch deleted file mode 100644 index b6db2de..0000000 --- a/recipes-test/testfloat/files/SoftFloat-powerpc-1.patch +++ /dev/null @@ -1,1427 +0,0 @@ -This patch adds PowerPC support in SoftFloat. - -Signed-off-by: Ebony Zhu -Signed-off-by: Liu Yu ---- - SoftFloat-2b/processors/powerpc-GCC.h | 87 ++++ - SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile | 26 ++ - SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h | 55 +++ - .../bits32/powerpc-GCC/softfloat-specialize | 252 ++++++++++++ - .../softfloat/bits32/powerpc-GCC/softfloat.h | 155 +++++++ - SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile | 24 ++ - SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h | 55 +++ - .../bits64/powerpc-GCC/softfloat-specialize | 422 ++++++++++++++++++++ - .../softfloat/bits64/powerpc-GCC/softfloat.h | 269 +++++++++++++ - 9 files changed, 1345 insertions(+), 0 deletions(-) - create mode 100644 SoftFloat-2b/processors/powerpc-GCC.h - create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile - create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h - create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize - create mode 100644 SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h - create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile - create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h - create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize - create mode 100644 SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h - -diff --git a/SoftFloat-2b/processors/powerpc-GCC.h b/SoftFloat-2b/processors/powerpc-GCC.h -new file mode 100644 -index 0000000..002a786 ---- /dev/null -+++ b/SoftFloat-2b/processors/powerpc-GCC.h -@@ -0,0 +1,87 @@ -+/* -+ * This file is derived from processors/386-gcc.h, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ * -+ * THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+ * been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+ * RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+ * AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+ * COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+ * EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+ * INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+ * OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ */ -+ -+/*---------------------------------------------------------------------------- -+| One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined. -+*----------------------------------------------------------------------------*/ -+#define BIGENDIAN -+ -+/*---------------------------------------------------------------------------- -+| The macro `BITS64' can be defined to indicate that 64-bit integer types are -+| supported by the compiler. -+*----------------------------------------------------------------------------*/ -+#define BITS32 -+ -+/*---------------------------------------------------------------------------- -+| Each of the following `typedef's defines the most convenient type that holds -+| integers of at least as many bits as specified. For example, `uint8' should -+| be the most convenient type that can hold unsigned integers of as many as -+| 8 bits. The `flag' type must be able to hold either a 0 or 1. For most -+| implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed -+| to the same as `int'. -+*----------------------------------------------------------------------------*/ -+typedef int flag; -+typedef int uint8; -+typedef int int8; -+typedef int uint16; -+typedef int int16; -+typedef unsigned int uint32; -+typedef signed int int32; -+#ifdef BITS64 -+typedef unsigned long long int uint64; -+typedef signed long long int int64; -+#endif -+ -+/*---------------------------------------------------------------------------- -+| Each of the following `typedef's defines a type that holds integers -+| of _exactly_ the number of bits specified. For instance, for most -+| implementation of C, `bits16' and `sbits16' should be `typedef'ed to -+| `unsigned short int' and `signed short int' (or `short int'), respectively. -+*----------------------------------------------------------------------------*/ -+typedef unsigned char bits8; -+typedef signed char sbits8; -+typedef unsigned short int bits16; -+typedef signed short int sbits16; -+typedef unsigned int bits32; -+typedef signed int sbits32; -+#ifdef BITS64 -+typedef unsigned long long int bits64; -+typedef signed long long int sbits64; -+#endif -+ -+#ifdef BITS64 -+/*---------------------------------------------------------------------------- -+| The `LIT64' macro takes as its argument a textual integer literal and -+| if necessary ``marks'' the literal as having a 64-bit integer type. -+| For example, the GNU C Compiler (`gcc') requires that 64-bit literals be -+| appended with the letters `LL' standing for `long long', which is `gcc's -+| name for the 64-bit integer type. Some compilers may allow `LIT64' to be -+| defined as the identity macro: `#define LIT64( a ) a'. -+*----------------------------------------------------------------------------*/ -+#define LIT64( a ) a##LL -+#endif -+ -+/*---------------------------------------------------------------------------- -+| The macro `INLINE' can be used before functions that should be inlined. If -+| a compiler does not support explicit inlining, this macro should be defined -+| to be `static'. -+*----------------------------------------------------------------------------*/ -+#define INLINE extern inline -+ -diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile -new file mode 100644 -index 0000000..28f1e33 ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile -@@ -0,0 +1,26 @@ -+ -+PROCESSOR_H = ../../../processors/powerpc-GCC.h -+SOFTFLOAT_MACROS = ../softfloat-macros -+ -+OBJ = .o -+EXE = -+INCLUDES = -I. -I.. -+COMPILE_C = $(COMPILE_PREFIX)gcc -msoft-float -c -o $@ $(INCLUDES) -I- -O2 -+LINK = $(COMPILE_PREFIX)gcc -o $@ -+ -+ALL: softfloat$(OBJ) timesoftfloat$(EXE) -+ -+milieu.h: $(PROCESSOR_H) -+ touch milieu.h -+ -+softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c -+ $(COMPILE_C) ../softfloat.c -+ -+timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c -+ $(COMPILE_C) ../timesoftfloat.c -+ -+timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ) -+ $(LINK) softfloat$(OBJ) timesoftfloat$(OBJ) -+ -+clean: -+ rm -f *.o timesoftfloat$(EXE) -diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h -new file mode 100644 -index 0000000..d8b6012 ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/milieu.h -@@ -0,0 +1,55 @@ -+/* -+ * This file is derived from softfloat/bits32/386-Win32-GCC/milieu.h, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/*============================================================================ -+ -+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic -+Package, Release 2b. -+ -+Written by John R. Hauser. This work was made possible in part by the -+International Computer Science Institute, located at Suite 600, 1947 Center -+Street, Berkeley, California 94704. Funding was partially provided by the -+National Science Foundation under grant MIP-9311980. The original version -+of this code was written as part of a project to build a fixed-point vector -+processor in collaboration with the University of California at Berkeley, -+overseen by Profs. Nelson Morgan and John Wawrzynek. More information -+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ -+arithmetic/SoftFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) the source code for the derivative work includes prominent notice that -+the work is derivative, and (2) the source code includes prominent notice with -+these four paragraphs for those parts of this code that are retained. -+ -+=============================================================================*/ -+ -+/*---------------------------------------------------------------------------- -+| Include common integer types and flags. -+*----------------------------------------------------------------------------*/ -+#include "../../../processors/powerpc-GCC.h" -+ -+/*---------------------------------------------------------------------------- -+| Symbolic Boolean literals. -+*----------------------------------------------------------------------------*/ -+enum { -+ FALSE = 0, -+ TRUE = 1 -+}; -+ -diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize -new file mode 100644 -index 0000000..fd2caa4 ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat-specialize -@@ -0,0 +1,252 @@ -+/* -+ * This file is derived from softfloat/bits32/386-Win32-GCC/softfloat-specialize, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/*============================================================================ -+ -+This C source fragment is part of the SoftFloat IEC/IEEE Floating-point -+Arithmetic Package, Release 2b. -+ -+Written by John R. Hauser. This work was made possible in part by the -+International Computer Science Institute, located at Suite 600, 1947 Center -+Street, Berkeley, California 94704. Funding was partially provided by the -+National Science Foundation under grant MIP-9311980. The original version -+of this code was written as part of a project to build a fixed-point vector -+processor in collaboration with the University of California at Berkeley, -+overseen by Profs. Nelson Morgan and John Wawrzynek. More information -+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ -+arithmetic/SoftFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) the source code for the derivative work includes prominent notice that -+the work is derivative, and (2) the source code includes prominent notice with -+these four paragraphs for those parts of this code that are retained. -+ -+=============================================================================*/ -+ -+/*---------------------------------------------------------------------------- -+| Underflow tininess-detection mode, statically initialized to default value. -+| (The declaration in `softfloat.h' must match the `int8' type here.) -+*----------------------------------------------------------------------------*/ -+int8 float_detect_tininess = float_tininess_after_rounding; -+ -+/*---------------------------------------------------------------------------- -+| Raises the exceptions specified by `flags'. Floating-point traps can be -+| defined here if desired. It is currently not possible for such a trap -+| to substitute a result value. If traps are not implemented, this routine -+| should be simply `float_exception_flags |= flags;'. -+*----------------------------------------------------------------------------*/ -+ -+void float_raise( int8 flags ) -+{ -+ -+ float_exception_flags |= flags; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Internal canonical NaN format. -+*----------------------------------------------------------------------------*/ -+typedef struct { -+ flag sign; -+ bits32 high, low; -+} commonNaNT; -+ -+/*---------------------------------------------------------------------------- -+| The pattern for a default generated single-precision NaN. -+*----------------------------------------------------------------------------*/ -+enum { -+ float32_default_nan = 0xFFFFFFFF -+}; -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the single-precision floating-point value `a' is a NaN; -+| otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float32_is_nan( float32 a ) -+{ -+ -+ return ( 0xFF000000 < (bits32) ( a<<1 ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the single-precision floating-point value `a' is a signaling -+| NaN; otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float32_is_signaling_nan( float32 a ) -+{ -+ -+ return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the single-precision floating-point NaN -+| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid -+| exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static commonNaNT float32ToCommonNaN( float32 a ) -+{ -+ commonNaNT z; -+ -+ if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); -+ z.sign = a>>31; -+ z.low = 0; -+ z.high = a<<9; -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the canonical NaN `a' to the single- -+| precision floating-point format. -+*----------------------------------------------------------------------------*/ -+ -+static float32 commonNaNToFloat32( commonNaNT a ) -+{ -+ -+ return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>9 ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Takes two single-precision floating-point values `a' and `b', one of which -+| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a -+| signaling NaN, the invalid exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static float32 propagateFloat32NaN( float32 a, float32 b ) -+{ -+ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; -+ -+ aIsNaN = float32_is_nan( a ); -+ aIsSignalingNaN = float32_is_signaling_nan( a ); -+ bIsNaN = float32_is_nan( b ); -+ bIsSignalingNaN = float32_is_signaling_nan( b ); -+ a |= 0x00400000; -+ b |= 0x00400000; -+ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); -+ if ( aIsNaN ) { -+ return ( aIsSignalingNaN & bIsNaN ) ? b : a; -+ } -+ else { -+ return b; -+ } -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| The pattern for a default generated double-precision NaN. The `high' and -+| `low' values hold the most- and least-significant bits, respectively. -+*----------------------------------------------------------------------------*/ -+enum { -+ float64_default_nan_high = 0xFFFFFFFF, -+ float64_default_nan_low = 0xFFFFFFFF -+}; -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the double-precision floating-point value `a' is a NaN; -+| otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float64_is_nan( float64 a ) -+{ -+ -+ return -+ ( 0xFFE00000 <= (bits32) ( a.high<<1 ) ) -+ && ( a.low || ( a.high & 0x000FFFFF ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the double-precision floating-point value `a' is a signaling -+| NaN; otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float64_is_signaling_nan( float64 a ) -+{ -+ -+ return -+ ( ( ( a.high>>19 ) & 0xFFF ) == 0xFFE ) -+ && ( a.low || ( a.high & 0x0007FFFF ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the double-precision floating-point NaN -+| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid -+| exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static commonNaNT float64ToCommonNaN( float64 a ) -+{ -+ commonNaNT z; -+ -+ if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); -+ z.sign = a.high>>31; -+ shortShift64Left( a.high, a.low, 12, &z.high, &z.low ); -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the canonical NaN `a' to the double- -+| precision floating-point format. -+*----------------------------------------------------------------------------*/ -+ -+static float64 commonNaNToFloat64( commonNaNT a ) -+{ -+ float64 z; -+ -+ shift64Right( a.high, a.low, 12, &z.high, &z.low ); -+ z.high |= ( ( (bits32) a.sign )<<31 ) | 0x7FF80000; -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Takes two double-precision floating-point values `a' and `b', one of which -+| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a -+| signaling NaN, the invalid exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static float64 propagateFloat64NaN( float64 a, float64 b ) -+{ -+ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; -+ -+ aIsNaN = float64_is_nan( a ); -+ aIsSignalingNaN = float64_is_signaling_nan( a ); -+ bIsNaN = float64_is_nan( b ); -+ bIsSignalingNaN = float64_is_signaling_nan( b ); -+ a.high |= 0x00080000; -+ b.high |= 0x00080000; -+ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); -+ if ( aIsNaN ) { -+ return ( aIsSignalingNaN & bIsNaN ) ? b : a; -+ } -+ else { -+ return b; -+ } -+ -+} -+ -diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h -new file mode 100644 -index 0000000..0015b8e ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/softfloat.h -@@ -0,0 +1,155 @@ -+/* -+ * This file is derived from softfloat/bits32/386-Win32-GCC/softfloat.h, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/*============================================================================ -+ -+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic -+Package, Release 2b. -+ -+Written by John R. Hauser. This work was made possible in part by the -+International Computer Science Institute, located at Suite 600, 1947 Center -+Street, Berkeley, California 94704. Funding was partially provided by the -+National Science Foundation under grant MIP-9311980. The original version -+of this code was written as part of a project to build a fixed-point vector -+processor in collaboration with the University of California at Berkeley, -+overseen by Profs. Nelson Morgan and John Wawrzynek. More information -+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ -+arithmetic/SoftFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) the source code for the derivative work includes prominent notice that -+the work is derivative, and (2) the source code includes prominent notice with -+these four paragraphs for those parts of this code that are retained. -+ -+=============================================================================*/ -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point types. -+*----------------------------------------------------------------------------*/ -+typedef bits32 float32; -+typedef struct { -+ bits32 high, low; -+} float64; -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point underflow tininess-detection mode. -+*----------------------------------------------------------------------------*/ -+extern int8 float_detect_tininess; -+enum { -+ float_tininess_after_rounding = 0, -+ float_tininess_before_rounding = 1 -+}; -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point rounding mode. -+*----------------------------------------------------------------------------*/ -+extern int8 float_rounding_mode; -+enum { -+ float_round_nearest_even = 0, -+ float_round_to_zero = 1, -+ float_round_up = 2, -+ float_round_down = 3 -+}; -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point exception flags. -+*----------------------------------------------------------------------------*/ -+/* -+extern int8 float_exception_flags; -+enum { -+ float_flag_inexact = 1, -+ float_flag_underflow = 2, -+ float_flag_overflow = 4, -+ float_flag_divbyzero = 8, -+ float_flag_invalid = 16 -+}; -+*/ -+ -+extern int8 float_exception_flags; -+enum { -+ float_flag_inexact = 16, -+ float_flag_underflow = 2, -+ float_flag_overflow = 1, -+ float_flag_divbyzero = 4, -+ float_flag_invalid = 8 -+}; -+ -+/*---------------------------------------------------------------------------- -+| Routine to raise any or all of the software IEC/IEEE floating-point -+| exception flags. -+*----------------------------------------------------------------------------*/ -+void float_raise( int8 ); -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE integer-to-floating-point conversion routines. -+*----------------------------------------------------------------------------*/ -+float32 int32_to_float32( int32 ); -+float64 int32_to_float64( int32 ); -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE single-precision conversion routines. -+*----------------------------------------------------------------------------*/ -+int32 float32_to_int32( float32 ); -+int32 float32_to_int32_round_to_zero( float32 ); -+float64 float32_to_float64( float32 ); -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE single-precision operations. -+*----------------------------------------------------------------------------*/ -+float32 float32_round_to_int( float32 ); -+float32 float32_add( float32, float32 ); -+float32 float32_sub( float32, float32 ); -+float32 float32_mul( float32, float32 ); -+float32 float32_div( float32, float32 ); -+float32 float32_rem( float32, float32 ); -+float32 float32_sqrt( float32 ); -+flag float32_eq( float32, float32 ); -+flag float32_le( float32, float32 ); -+flag float32_lt( float32, float32 ); -+flag float32_eq_signaling( float32, float32 ); -+flag float32_le_quiet( float32, float32 ); -+flag float32_lt_quiet( float32, float32 ); -+flag float32_is_signaling_nan( float32 ); -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE double-precision conversion routines. -+*----------------------------------------------------------------------------*/ -+int32 float64_to_int32( float64 ); -+int32 float64_to_int32_round_to_zero( float64 ); -+float32 float64_to_float32( float64 ); -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE double-precision operations. -+*----------------------------------------------------------------------------*/ -+float64 float64_round_to_int( float64 ); -+float64 float64_add( float64, float64 ); -+float64 float64_sub( float64, float64 ); -+float64 float64_mul( float64, float64 ); -+float64 float64_div( float64, float64 ); -+float64 float64_rem( float64, float64 ); -+float64 float64_sqrt( float64 ); -+flag float64_eq( float64, float64 ); -+flag float64_le( float64, float64 ); -+flag float64_lt( float64, float64 ); -+flag float64_eq_signaling( float64, float64 ); -+flag float64_le_quiet( float64, float64 ); -+flag float64_lt_quiet( float64, float64 ); -+flag float64_is_signaling_nan( float64 ); -+ -diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile -new file mode 100644 -index 0000000..a5e2cc7 ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile -@@ -0,0 +1,24 @@ -+ -+PROCESSOR_H = ../../../processors/powerpc-GCC.h -+SOFTFLOAT_MACROS = ../softfloat-macros -+ -+OBJ = .o -+EXE = -+INCLUDES = -I. -I.. -+COMPILE_C = $(COMPILE_PREFIX) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2 -+LINK = $(COMPILE_PREFIX) -o $@ -+ -+ALL: softfloat$(OBJ) timesoftfloat$(EXE) -+ -+milieu.h: $(PROCESSOR_H) -+ touch milieu.h -+ -+softfloat$(OBJ): milieu.h softfloat.h softfloat-specialize $(SOFTFLOAT_MACROS) ../softfloat.c -+ $(COMPILE_C) ../softfloat.c -+ -+timesoftfloat$(OBJ): milieu.h softfloat.h ../timesoftfloat.c -+ $(COMPILE_C) ../timesoftfloat.c -+ -+timesoftfloat$(EXE): softfloat$(OBJ) timesoftfloat$(OBJ) -+ $(LINK) softfloat$(OBJ) timesoftfloat$(OBJ) -+ -diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h -new file mode 100644 -index 0000000..1b66490 ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/milieu.h -@@ -0,0 +1,55 @@ -+/* -+ * This file is derived from softfloat/bits64/386-Win32-GCC/milieu.h, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/*============================================================================ -+ -+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic -+Package, Release 2b. -+ -+Written by John R. Hauser. This work was made possible in part by the -+International Computer Science Institute, located at Suite 600, 1947 Center -+Street, Berkeley, California 94704. Funding was partially provided by the -+National Science Foundation under grant MIP-9311980. The original version -+of this code was written as part of a project to build a fixed-point vector -+processor in collaboration with the University of California at Berkeley, -+overseen by Profs. Nelson Morgan and John Wawrzynek. More information -+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ -+arithmetic/SoftFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) the source code for the derivative work includes prominent notice that -+the work is derivative, and (2) the source code includes prominent notice with -+these four paragraphs for those parts of this code that are retained. -+ -+=============================================================================*/ -+ -+/*---------------------------------------------------------------------------- -+| Include common integer types and flags. -+*----------------------------------------------------------------------------*/ -+#include "../../../processors/SPARC-GCC.h" -+ -+/*---------------------------------------------------------------------------- -+| Symbolic Boolean literals. -+*----------------------------------------------------------------------------*/ -+enum { -+ FALSE = 0, -+ TRUE = 1 -+}; -+ -diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize -new file mode 100644 -index 0000000..b1d0bc8 ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat-specialize -@@ -0,0 +1,422 @@ -+/* -+ * This file is derived from softfloat/bits64/386-Win32-GCC/softfloat-specialize, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/*============================================================================ -+ -+This C source fragment is part of the SoftFloat IEC/IEEE Floating-point -+Arithmetic Package, Release 2b. -+ -+Written by John R. Hauser. This work was made possible in part by the -+International Computer Science Institute, located at Suite 600, 1947 Center -+Street, Berkeley, California 94704. Funding was partially provided by the -+National Science Foundation under grant MIP-9311980. The original version -+of this code was written as part of a project to build a fixed-point vector -+processor in collaboration with the University of California at Berkeley, -+overseen by Profs. Nelson Morgan and John Wawrzynek. More information -+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ -+arithmetic/SoftFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) the source code for the derivative work includes prominent notice that -+the work is derivative, and (2) the source code includes prominent notice with -+these four paragraphs for those parts of this code that are retained. -+ -+=============================================================================*/ -+ -+/*---------------------------------------------------------------------------- -+| Underflow tininess-detection mode, statically initialized to default value. -+| (The declaration in `softfloat.h' must match the `int8' type here.) -+*----------------------------------------------------------------------------*/ -+int8 float_detect_tininess = float_tininess_before_rounding; -+ -+/*---------------------------------------------------------------------------- -+| Raises the exceptions specified by `flags'. Floating-point traps can be -+| defined here if desired. It is currently not possible for such a trap -+| to substitute a result value. If traps are not implemented, this routine -+| should be simply `float_exception_flags |= flags;'. -+*----------------------------------------------------------------------------*/ -+ -+void float_raise( int8 flags ) -+{ -+ -+ float_exception_flags |= flags; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Internal canonical NaN format. -+*----------------------------------------------------------------------------*/ -+typedef struct { -+ flag sign; -+ bits64 high, low; -+} commonNaNT; -+ -+/*---------------------------------------------------------------------------- -+| The pattern for a default generated single-precision NaN. -+*----------------------------------------------------------------------------*/ -+#define float32_default_nan 0x7FFFFFFF -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the single-precision floating-point value `a' is a NaN; -+| otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float32_is_nan( float32 a ) -+{ -+ -+ return ( 0xFF000000 < (bits32) ( a<<1 ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the single-precision floating-point value `a' is a signaling -+| NaN; otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float32_is_signaling_nan( float32 a ) -+{ -+ -+ return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the single-precision floating-point NaN -+| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid -+| exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static commonNaNT float32ToCommonNaN( float32 a ) -+{ -+ commonNaNT z; -+ -+ if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); -+ z.sign = a>>31; -+ z.low = 0; -+ z.high = ( (bits64) a )<<41; -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the canonical NaN `a' to the single- -+| precision floating-point format. -+*----------------------------------------------------------------------------*/ -+ -+static float32 commonNaNToFloat32( commonNaNT a ) -+{ -+ -+ return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Takes two single-precision floating-point values `a' and `b', one of which -+| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a -+| signaling NaN, the invalid exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static float32 propagateFloat32NaN( float32 a, float32 b ) -+{ -+ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; -+ -+ aIsNaN = float32_is_nan( a ); -+ aIsSignalingNaN = float32_is_signaling_nan( a ); -+ bIsNaN = float32_is_nan( b ); -+ bIsSignalingNaN = float32_is_signaling_nan( b ); -+ a |= 0x00400000; -+ b |= 0x00400000; -+ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); -+ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| The pattern for a default generated double-precision NaN. -+*----------------------------------------------------------------------------*/ -+#define float64_default_nan LIT64( 0x7FFFFFFFFFFFFFFF ) -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the double-precision floating-point value `a' is a NaN; -+| otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float64_is_nan( float64 a ) -+{ -+ -+ return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the double-precision floating-point value `a' is a signaling -+| NaN; otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float64_is_signaling_nan( float64 a ) -+{ -+ -+ return -+ ( ( ( a>>51 ) & 0xFFF ) == 0xFFE ) -+ && ( a & LIT64( 0x0007FFFFFFFFFFFF ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the double-precision floating-point NaN -+| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid -+| exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static commonNaNT float64ToCommonNaN( float64 a ) -+{ -+ commonNaNT z; -+ -+ if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); -+ z.sign = a>>63; -+ z.low = 0; -+ z.high = a<<12; -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the canonical NaN `a' to the double- -+| precision floating-point format. -+*----------------------------------------------------------------------------*/ -+ -+static float64 commonNaNToFloat64( commonNaNT a ) -+{ -+ -+ return -+ ( ( (bits64) a.sign )<<63 ) -+ | LIT64( 0x7FF8000000000000 ) -+ | ( a.high>>12 ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Takes two double-precision floating-point values `a' and `b', one of which -+| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a -+| signaling NaN, the invalid exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static float64 propagateFloat64NaN( float64 a, float64 b ) -+{ -+ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; -+ -+ aIsNaN = float64_is_nan( a ); -+ aIsSignalingNaN = float64_is_signaling_nan( a ); -+ bIsNaN = float64_is_nan( b ); -+ bIsSignalingNaN = float64_is_signaling_nan( b ); -+ a |= LIT64( 0x0008000000000000 ); -+ b |= LIT64( 0x0008000000000000 ); -+ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); -+ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; -+ -+} -+ -+#ifdef FLOATX80 -+ -+/*---------------------------------------------------------------------------- -+| The pattern for a default generated extended double-precision NaN. The -+| `high' and `low' values hold the most- and least-significant bits, -+| respectively. -+*----------------------------------------------------------------------------*/ -+#define floatx80_default_nan_high 0x7FFF -+#define floatx80_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the extended double-precision floating-point value `a' is a -+| NaN; otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag floatx80_is_nan( floatx80 a ) -+{ -+ -+ return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the extended double-precision floating-point value `a' is a -+| signaling NaN; otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag floatx80_is_signaling_nan( floatx80 a ) -+{ -+ bits64 aLow; -+ -+ aLow = a.low & ~ LIT64( 0x4000000000000000 ); -+ return -+ ( ( a.high & 0x7FFF ) == 0x7FFF ) -+ && (bits64) ( aLow<<1 ) -+ && ( a.low == aLow ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the extended double-precision floating- -+| point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the -+| invalid exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static commonNaNT floatx80ToCommonNaN( floatx80 a ) -+{ -+ commonNaNT z; -+ -+ if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); -+ z.sign = a.high>>15; -+ z.low = 0; -+ z.high = a.low<<1; -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the canonical NaN `a' to the extended -+| double-precision floating-point format. -+*----------------------------------------------------------------------------*/ -+ -+static floatx80 commonNaNToFloatx80( commonNaNT a ) -+{ -+ floatx80 z; -+ -+ z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 ); -+ z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF; -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Takes two extended double-precision floating-point values `a' and `b', one -+| of which is a NaN, and returns the appropriate NaN result. If either `a' or -+| `b' is a signaling NaN, the invalid exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b ) -+{ -+ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; -+ -+ aIsNaN = floatx80_is_nan( a ); -+ aIsSignalingNaN = floatx80_is_signaling_nan( a ); -+ bIsNaN = floatx80_is_nan( b ); -+ bIsSignalingNaN = floatx80_is_signaling_nan( b ); -+ a.low |= LIT64( 0xC000000000000000 ); -+ b.low |= LIT64( 0xC000000000000000 ); -+ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); -+ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; -+ -+} -+ -+#endif -+ -+#ifdef FLOAT128 -+ -+/*---------------------------------------------------------------------------- -+| The pattern for a default generated quadruple-precision NaN. The `high' and -+| `low' values hold the most- and least-significant bits, respectively. -+*----------------------------------------------------------------------------*/ -+#define float128_default_nan_high LIT64( 0x7FFFFFFFFFFFFFFF ) -+#define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the quadruple-precision floating-point value `a' is a NaN; -+| otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float128_is_nan( float128 a ) -+{ -+ -+ return -+ ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) ) -+ && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns 1 if the quadruple-precision floating-point value `a' is a -+| signaling NaN; otherwise returns 0. -+*----------------------------------------------------------------------------*/ -+ -+flag float128_is_signaling_nan( float128 a ) -+{ -+ -+ return -+ ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE ) -+ && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) ); -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the quadruple-precision floating-point NaN -+| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid -+| exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static commonNaNT float128ToCommonNaN( float128 a ) -+{ -+ commonNaNT z; -+ -+ if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid ); -+ z.sign = a.high>>63; -+ shortShift128Left( a.high, a.low, 16, &z.high, &z.low ); -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Returns the result of converting the canonical NaN `a' to the quadruple- -+| precision floating-point format. -+*----------------------------------------------------------------------------*/ -+ -+static float128 commonNaNToFloat128( commonNaNT a ) -+{ -+ float128 z; -+ -+ shift128Right( a.high, a.low, 16, &z.high, &z.low ); -+ z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 ); -+ return z; -+ -+} -+ -+/*---------------------------------------------------------------------------- -+| Takes two quadruple-precision floating-point values `a' and `b', one of -+| which is a NaN, and returns the appropriate NaN result. If either `a' or -+| `b' is a signaling NaN, the invalid exception is raised. -+*----------------------------------------------------------------------------*/ -+ -+static float128 propagateFloat128NaN( float128 a, float128 b ) -+{ -+ flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; -+ -+ aIsNaN = float128_is_nan( a ); -+ aIsSignalingNaN = float128_is_signaling_nan( a ); -+ bIsNaN = float128_is_nan( b ); -+ bIsSignalingNaN = float128_is_signaling_nan( b ); -+ a.high |= LIT64( 0x0000800000000000 ); -+ b.high |= LIT64( 0x0000800000000000 ); -+ if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid ); -+ return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a; -+ -+} -+ -+#endif -+ -diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h -new file mode 100644 -index 0000000..5b7cb1c ---- /dev/null -+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/softfloat.h -@@ -0,0 +1,269 @@ -+/* -+ * This file is derived from softfloat/bits64/386-Win32-GCC/softfloat.h, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/*============================================================================ -+ -+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic -+Package, Release 2b. -+ -+Written by John R. Hauser. This work was made possible in part by the -+International Computer Science Institute, located at Suite 600, 1947 Center -+Street, Berkeley, California 94704. Funding was partially provided by the -+National Science Foundation under grant MIP-9311980. The original version -+of this code was written as part of a project to build a fixed-point vector -+processor in collaboration with the University of California at Berkeley, -+overseen by Profs. Nelson Morgan and John Wawrzynek. More information -+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ -+arithmetic/SoftFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) the source code for the derivative work includes prominent notice that -+the work is derivative, and (2) the source code includes prominent notice with -+these four paragraphs for those parts of this code that are retained. -+ -+=============================================================================*/ -+ -+/*---------------------------------------------------------------------------- -+| The macro `FLOATX80' must be defined to enable the extended double-precision -+| floating-point format `floatx80'. If this macro is not defined, the -+| `floatx80' type will not be defined, and none of the functions that either -+| input or output the `floatx80' type will be defined. The same applies to -+| the `FLOAT128' macro and the quadruple-precision format `float128'. -+*----------------------------------------------------------------------------*/ -+#define FLOATX80 -+#define FLOAT128 -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point types. -+*----------------------------------------------------------------------------*/ -+typedef unsigned int float32; -+typedef unsigned long long float64; -+#ifdef FLOATX80 -+typedef struct { -+ unsigned short high; -+ unsigned long long low; -+} floatx80; -+#endif -+#ifdef FLOAT128 -+typedef struct { -+ unsigned long long high, low; -+} float128; -+#endif -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point underflow tininess-detection mode. -+*----------------------------------------------------------------------------*/ -+extern int float_detect_tininess; -+enum { -+ float_tininess_after_rounding = 0, -+ float_tininess_before_rounding = 1 -+}; -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point rounding mode. -+*----------------------------------------------------------------------------*/ -+extern int float_rounding_mode; -+enum { -+ float_round_nearest_even = 0, -+ float_round_to_zero = 1, -+ float_round_up = 2, -+ float_round_down = 3 -+}; -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE floating-point exception flags. -+*----------------------------------------------------------------------------*/ -+extern int float_exception_flags; -+enum { -+ float_flag_inexact = 1, -+ float_flag_divbyzero = 2, -+ float_flag_underflow = 4, -+ float_flag_overflow = 8, -+ float_flag_invalid = 16 -+}; -+ -+/*---------------------------------------------------------------------------- -+| Routine to raise any or all of the software IEC/IEEE floating-point -+| exception flags. -+*----------------------------------------------------------------------------*/ -+void float_raise( int ); -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE integer-to-floating-point conversion routines. -+*----------------------------------------------------------------------------*/ -+float32 int32_to_float32( int ); -+float64 int32_to_float64( int ); -+#ifdef FLOATX80 -+floatx80 int32_to_floatx80( int ); -+#endif -+#ifdef FLOAT128 -+float128 int32_to_float128( int ); -+#endif -+float32 int64_to_float32( long long ); -+float64 int64_to_float64( long long ); -+#ifdef FLOATX80 -+floatx80 int64_to_floatx80( long long ); -+#endif -+#ifdef FLOAT128 -+float128 int64_to_float128( long long ); -+#endif -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE single-precision conversion routines. -+*----------------------------------------------------------------------------*/ -+int float32_to_int32( float32 ); -+int float32_to_int32_round_to_zero( float32 ); -+long long float32_to_int64( float32 ); -+long long float32_to_int64_round_to_zero( float32 ); -+float64 float32_to_float64( float32 ); -+#ifdef FLOATX80 -+floatx80 float32_to_floatx80( float32 ); -+#endif -+#ifdef FLOAT128 -+float128 float32_to_float128( float32 ); -+#endif -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE single-precision operations. -+*----------------------------------------------------------------------------*/ -+float32 float32_round_to_int( float32 ); -+float32 float32_add( float32, float32 ); -+float32 float32_sub( float32, float32 ); -+float32 float32_mul( float32, float32 ); -+float32 float32_div( float32, float32 ); -+float32 float32_rem( float32, float32 ); -+float32 float32_sqrt( float32 ); -+int float32_eq( float32, float32 ); -+int float32_le( float32, float32 ); -+int float32_lt( float32, float32 ); -+int float32_eq_signaling( float32, float32 ); -+int float32_le_quiet( float32, float32 ); -+int float32_lt_quiet( float32, float32 ); -+int float32_is_signaling_nan( float32 ); -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE double-precision conversion routines. -+*----------------------------------------------------------------------------*/ -+int float64_to_int32( float64 ); -+int float64_to_int32_round_to_zero( float64 ); -+long long float64_to_int64( float64 ); -+long long float64_to_int64_round_to_zero( float64 ); -+float32 float64_to_float32( float64 ); -+#ifdef FLOATX80 -+floatx80 float64_to_floatx80( float64 ); -+#endif -+#ifdef FLOAT128 -+float128 float64_to_float128( float64 ); -+#endif -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE double-precision operations. -+*----------------------------------------------------------------------------*/ -+float64 float64_round_to_int( float64 ); -+float64 float64_add( float64, float64 ); -+float64 float64_sub( float64, float64 ); -+float64 float64_mul( float64, float64 ); -+float64 float64_div( float64, float64 ); -+float64 float64_rem( float64, float64 ); -+float64 float64_sqrt( float64 ); -+int float64_eq( float64, float64 ); -+int float64_le( float64, float64 ); -+int float64_lt( float64, float64 ); -+int float64_eq_signaling( float64, float64 ); -+int float64_le_quiet( float64, float64 ); -+int float64_lt_quiet( float64, float64 ); -+int float64_is_signaling_nan( float64 ); -+ -+#ifdef FLOATX80 -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE extended double-precision conversion routines. -+*----------------------------------------------------------------------------*/ -+int floatx80_to_int32( floatx80 ); -+int floatx80_to_int32_round_to_zero( floatx80 ); -+long long floatx80_to_int64( floatx80 ); -+long long floatx80_to_int64_round_to_zero( floatx80 ); -+float32 floatx80_to_float32( floatx80 ); -+float64 floatx80_to_float64( floatx80 ); -+#ifdef FLOAT128 -+float128 floatx80_to_float128( floatx80 ); -+#endif -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE extended double-precision rounding precision. Valid -+| values are 32, 64, and 80. -+*----------------------------------------------------------------------------*/ -+extern int floatx80_rounding_precision; -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE extended double-precision operations. -+*----------------------------------------------------------------------------*/ -+floatx80 floatx80_round_to_int( floatx80 ); -+floatx80 floatx80_add( floatx80, floatx80 ); -+floatx80 floatx80_sub( floatx80, floatx80 ); -+floatx80 floatx80_mul( floatx80, floatx80 ); -+floatx80 floatx80_div( floatx80, floatx80 ); -+floatx80 floatx80_rem( floatx80, floatx80 ); -+floatx80 floatx80_sqrt( floatx80 ); -+int floatx80_eq( floatx80, floatx80 ); -+int floatx80_le( floatx80, floatx80 ); -+int floatx80_lt( floatx80, floatx80 ); -+int floatx80_eq_signaling( floatx80, floatx80 ); -+int floatx80_le_quiet( floatx80, floatx80 ); -+int floatx80_lt_quiet( floatx80, floatx80 ); -+int floatx80_is_signaling_nan( floatx80 ); -+ -+#endif -+ -+#ifdef FLOAT128 -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE quadruple-precision conversion routines. -+*----------------------------------------------------------------------------*/ -+int float128_to_int32( float128 ); -+int float128_to_int32_round_to_zero( float128 ); -+long long float128_to_int64( float128 ); -+long long float128_to_int64_round_to_zero( float128 ); -+float32 float128_to_float32( float128 ); -+float64 float128_to_float64( float128 ); -+#ifdef FLOATX80 -+floatx80 float128_to_floatx80( float128 ); -+#endif -+ -+/*---------------------------------------------------------------------------- -+| Software IEC/IEEE quadruple-precision operations. -+*----------------------------------------------------------------------------*/ -+float128 float128_round_to_int( float128 ); -+float128 float128_add( float128, float128 ); -+float128 float128_sub( float128, float128 ); -+float128 float128_mul( float128, float128 ); -+float128 float128_div( float128, float128 ); -+float128 float128_rem( float128, float128 ); -+float128 float128_sqrt( float128 ); -+int float128_eq( float128, float128 ); -+int float128_le( float128, float128 ); -+int float128_lt( float128, float128 ); -+int float128_eq_signaling( float128, float128 ); -+int float128_le_quiet( float128, float128 ); -+int float128_lt_quiet( float128, float128 ); -+int float128_is_signaling_nan( float128 ); -+ -+#endif -+ --- -1.5.4 - diff --git a/recipes-test/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch b/recipes-test/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch deleted file mode 100644 index c34421c..0000000 --- a/recipes-test/testfloat/files/TestFloat-powerpc-E500v2-SPE-1.patch +++ /dev/null @@ -1,1644 +0,0 @@ -This patch adds PowerPC E500v2 SPE support in TestFloat. -And it disables the testing for hardware that can not trigger SPE interrupt. - -Signed-off-by: Ebony Zhu -Signed-off-by: Liu Yu ---- - processors/POWERPC-gcc.h | 99 +++++ - testfloat/powerpc-linux-gcc/Makefile | 83 +++++ - testfloat/powerpc-linux-gcc/milieu.h | 71 ++++ - testfloat/powerpc-linux-gcc/systflags.c | 107 ++++++ - testfloat/powerpc-linux-gcc/systfloat.c | 595 +++++++++++++++++++++++++++++++ - testfloat/powerpc-linux-gcc/systmodes.c | 67 ++++ - testfloat/templates/Makefile | 18 +- - testfloat/templates/milieu.h | 2 +- - testfloat/testFunction.h | 2 +- - testfloat/testLoops.c | 216 +++++++++++ - 10 files changed, 1252 insertions(+), 8 deletions(-) - create mode 100644 processors/POWERPC-gcc.h - create mode 100644 testfloat/powerpc-linux-gcc/Makefile - create mode 100644 testfloat/powerpc-linux-gcc/milieu.h - create mode 100644 testfloat/powerpc-linux-gcc/systflags.c - create mode 100644 testfloat/powerpc-linux-gcc/systfloat.c - create mode 100644 testfloat/powerpc-linux-gcc/systmodes.c - -diff --git a/processors/POWERPC-gcc.h b/processors/POWERPC-gcc.h -new file mode 100644 -index 0000000..4201faa ---- /dev/null -+++ b/processors/POWERPC-gcc.h -@@ -0,0 +1,99 @@ -+/* -+ * This file is derived from processors/i386-GCC.h, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ * -+ * THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -+ * been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -+ * RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -+ * AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -+ * COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -+ * EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -+ * INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -+ * OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. -+ */ -+ -+/* -+------------------------------------------------------------------------------- -+One of the macros `BIGENDIAN' or `LITTLEENDIAN' must be defined. -+------------------------------------------------------------------------------- -+*/ -+#define BIGENDIAN -+ -+/* -+------------------------------------------------------------------------------- -+The macro `BITS64' can be defined to indicate that 64-bit integer types are -+supported by the compiler. -+------------------------------------------------------------------------------- -+*/ -+#undef BITS64 -+ -+/* -+------------------------------------------------------------------------------- -+Each of the following `typedef's defines the most convenient type that holds -+integers of at least as many bits as specified. For example, `uint8' should -+be the most convenient type that can hold unsigned integers of as many as -+8 bits. The `flag' type must be able to hold either a 0 or 1. For most -+implementations of C, `flag', `uint8', and `int8' should all be `typedef'ed -+to the same as `int'. -+------------------------------------------------------------------------------- -+*/ -+typedef int flag; -+typedef int uint8; -+typedef int int8; -+typedef int uint16; -+typedef int int16; -+typedef unsigned int uint32; -+typedef signed int int32; -+#ifdef BITS64 -+typedef unsigned long long int uint64; -+typedef signed long long int int64; -+#endif -+ -+/* -+------------------------------------------------------------------------------- -+Each of the following `typedef's defines a type that holds integers -+of _exactly_ the number of bits specified. For instance, for most -+implementation of C, `bits16' and `sbits16' should be `typedef'ed to -+`unsigned short int' and `signed short int' (or `short int'), respectively. -+------------------------------------------------------------------------------- -+*/ -+typedef unsigned char bits8; -+typedef signed char sbits8; -+typedef unsigned short int bits16; -+typedef signed short int sbits16; -+typedef unsigned int bits32; -+typedef signed int sbits32; -+#ifdef BITS64 -+typedef unsigned long long int bits64; -+typedef signed long long int sbits64; -+#endif -+ -+#ifdef BITS64 -+/* -+------------------------------------------------------------------------------- -+The `LIT64' macro takes as its argument a textual integer literal and -+if necessary ``marks'' the literal as having a 64-bit integer type. -+For example, the GNU C Compiler (`gcc') requires that 64-bit literals be -+appended with the letters `LL' standing for `long long', which is `gcc's -+name for the 64-bit integer type. Some compilers may allow `LIT64' to be -+defined as the identity macro: `#define LIT64( a ) a'. -+------------------------------------------------------------------------------- -+*/ -+#define LIT64( a ) a##LL -+#endif -+ -+/* -+------------------------------------------------------------------------------- -+The macro `INLINE' can be used before functions that should be inlined. If -+a compiler does not support explicit inlining, this macro should be defined -+to be `static'. -+------------------------------------------------------------------------------- -+*/ -+#define INLINE extern inline -+ -diff --git a/testfloat/powerpc-linux-gcc/Makefile b/testfloat/powerpc-linux-gcc/Makefile -new file mode 100644 -index 0000000..de50aad ---- /dev/null -+++ b/testfloat/powerpc-linux-gcc/Makefile -@@ -0,0 +1,83 @@ -+ -+PROCESSOR_H = ../../processors/POWERPC-gcc.h -+SOFTFLOAT_VERSION = bits32 -+TARGET = powerpc-GCC -+SOFTFLOAT_DIR = ../../SoftFloat-2b/softfloat/$(SOFTFLOAT_VERSION)/$(TARGET) -+ -+OBJ = .o -+EXE = -+INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR) -+ -+COMPILE_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS) -+ -+COMPILE_C_HARD = $(COMPILE_PREFIX)gcc -c -te500v2 -o $@ $(INCLUDES) -+ -+COMPILE_SLOWFLOAT_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O -+ -+LINK = $(COMPILE_PREFIX)gcc -lm -o $@ -+ -+SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h -+SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ) -+ -+ALL: testsoftfloat$(EXE) testfloat$(EXE) -+ -+systmodes$(OBJ): milieu.h systmodes.c -+ $(COMPILE_C) systmodes.c -+ -+systflags$(OBJ): milieu.h ../systflags.h systflags.c -+ $(COMPILE_C) systflags.c -+ -+systfloat$(OBJ): milieu.h $(SOFTFLOAT_H) ../systfloat.h systfloat.c -+ $(COMPILE_C_HARD) systfloat.c -+ -+#------------------------------------------------------------------------------ -+# Probably O.K. below here. -+#------------------------------------------------------------------------------ -+ -+milieu.h: $(PROCESSOR_H) -+ touch milieu.h -+ -+fail$(OBJ): milieu.h ../fail.h -+ $(COMPILE_C) ../fail.c -+ -+random$(OBJ): milieu.h ../random.h -+ $(COMPILE_C) ../random.c -+ -+testCases$(OBJ): milieu.h ../fail.h ../random.h $(SOFTFLOAT_H) ../testCases.h ../testCases.c -+ $(COMPILE_C) ../testCases.c -+ -+writeHex$(OBJ): milieu.h $(SOFTFLOAT_H) ../writeHex.h ../writeHex.c -+ $(COMPILE_C) ../writeHex.c -+ -+testLoops$(OBJ): milieu.h $(SOFTFLOAT_H) ../testCases.h ../writeHex.h ../testLoops.h ../testLoops.c -+ $(COMPILE_C) ../testLoops.c -+ -+slowfloat$(OBJ): milieu.h $(SOFTFLOAT_H) ../slowfloat.h ../slowfloat-32.c ../slowfloat-64.c ../slowfloat.c -+ $(COMPILE_SLOWFLOAT_C) ../slowfloat.c -+ -+testsoftfloat$(OBJ): milieu.h ../fail.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../slowfloat.h ../testsoftfloat.c -+ $(COMPILE_C) ../testsoftfloat.c -+ -+testsoftfloat$(EXE): fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) slowfloat$(OBJ) testsoftfloat$(OBJ) systflags$(OBJ) systmodes$(OBJ) -+ $(LINK) fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) slowfloat$(OBJ) testsoftfloat$(OBJ) systflags$(OBJ) systmodes$(OBJ) -+ -+testFunction$(OBJ): milieu.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../systmodes.h ../systflags.h ../systfloat.h ../testFunction.h ../testFunction.c -+ $(COMPILE_C) ../testFunction.c -+ -+testfloat$(OBJ): milieu.h ../fail.h $(SOFTFLOAT_H) ../testCases.h ../testLoops.h ../systflags.h ../testFunction.h ../testfloat.c -+ $(COMPILE_C) ../testfloat.c -+ -+testfloat$(EXE): fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) systmodes$(OBJ) systflags$(OBJ) systfloat$(OBJ) testFunction$(OBJ) testfloat$(OBJ) -+ $(LINK) fail$(OBJ) random$(OBJ) $(SOFTFLOAT_OBJ) testCases$(OBJ) writeHex$(OBJ) testLoops$(OBJ) systmodes$(OBJ) systflags$(OBJ) systfloat$(OBJ) testFunction$(OBJ) testfloat$(OBJ) -+ -+$(SOFTFLOAT_OBJ): -+ make -C $(SOFTFLOAT_DIR) -+ -+cp: ALL -+ cp testsoftfloat$(EXE) ../../test_softfloat$(EXE) -+ cp testfloat$(EXE) ../../test_float$(EXE) -+ -+clean: -+ make -C $(SOFTFLOAT_DIR) clean -+ rm -f *.o testfloat$(EXE) testsoftfloat$(EXE) -+ rm -f ../../test_softfloat$(EXE) ../../test_float$(EXE) -diff --git a/testfloat/powerpc-linux-gcc/milieu.h b/testfloat/powerpc-linux-gcc/milieu.h -new file mode 100644 -index 0000000..29d2b18 ---- /dev/null -+++ b/testfloat/powerpc-linux-gcc/milieu.h -@@ -0,0 +1,71 @@ -+/* -+ * This file is derived from testfloat/386-Win32-gcc/milieu.h, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/* -+=============================================================================== -+ -+This C header file is part of TestFloat, Release 2a, a package of programs -+for testing the correctness of floating-point arithmetic complying to the -+IEC/IEEE Standard for Floating-Point. -+ -+Written by John R. Hauser. More information is available through the Web -+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort -+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT -+TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO -+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY -+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) they include prominent notice that the work is derivative, and (2) they -+include prominent notice akin to these four paragraphs for those parts of -+this code that are retained. -+ -+=============================================================================== -+*/ -+ -+/* -+------------------------------------------------------------------------------- -+Include common integer types and flags. -+------------------------------------------------------------------------------- -+*/ -+#include "../../processors/POWERPC-gcc.h" -+/* -+------------------------------------------------------------------------------- -+If the `BITS64' macro is defined by the processor header file but the -+version of SoftFloat being used/tested is the 32-bit one (`bits32'), the -+`BITS64' macro must be undefined here. -+------------------------------------------------------------------------------- -+*/ -+ -+#undef BITS64 -+/* -+------------------------------------------------------------------------------- -+The macro `LONG_DOUBLE_IS_FLOATX80' can be defined to indicate that the -+C compiler supports the type `long double' as an extended double-precision -+format. Alternatively, the macro `LONG_DOUBLE_IS_FLOAT128' can be defined -+to indicate that `long double' is a quadruple-precision format. If neither -+of these macros is defined, `long double' will be ignored. -+------------------------------------------------------------------------------- -+#define LONG_DOUBLE_IS_FLOATX80 -+*/ -+ -+/* -+------------------------------------------------------------------------------- -+Symbolic Boolean literals. -+------------------------------------------------------------------------------- -+*/ -+enum { -+ FALSE = 0, -+ TRUE = 1 -+}; -+ -diff --git a/testfloat/powerpc-linux-gcc/systflags.c b/testfloat/powerpc-linux-gcc/systflags.c -new file mode 100644 -index 0000000..c382442 ---- /dev/null -+++ b/testfloat/powerpc-linux-gcc/systflags.c -@@ -0,0 +1,107 @@ -+/* -+ * This file is derived from testfloat/386-Win32-gcc/systflags.c, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/* -+=============================================================================== -+ -+This C source file is part of TestFloat, Release 2a, a package of programs -+for testing the correctness of floating-point arithmetic complying to the -+IEC/IEEE Standard for Floating-Point. -+ -+Written by John R. Hauser. More information is available through the Web -+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort -+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT -+TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO -+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY -+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) they include prominent notice that the work is derivative, and (2) they -+include prominent notice akin to these four paragraphs for those parts of -+this code that are retained. -+ -+=============================================================================== -+*/ -+ -+#include "milieu.h" -+#include "systflags.h" -+#include -+#include -+#include -+#include -+#include -+ -+#ifdef __SPE__ -+ -+#include -+ -+ -+#define SPE_FINV_ENABLE (1UL << 5) -+#define SPE_FDBZ_ENABLE (1UL << 4) -+#define SPE_FUNF_ENABLE (1UL << 3) -+#define SPE_FOVF_ENABLE (1UL << 2) -+ -+#define SPE_FG (1UL << 13) -+#define SPE_FX (1UL << 12) -+#define SPE_FINV (1UL << 11) -+#define SPE_FDBZ (1UL << 10) -+#define SPE_FUNF (1UL << 9) -+#define SPE_FOVF (1UL << 8) -+ -+#define SPE_FG_H (1UL << 29) -+#define SPE_FX_H (1UL << 28) -+#define SPE_FINV_H (1UL << 27) -+#define SPE_FDBZ_H (1UL << 26) -+#define SPE_FUNF_H (1UL << 25) -+#define SPE_FOVF_H (1UL << 24) -+ -+static int is_soft_emu = 0; -+ -+#endif -+/* -+------------------------------------------------------------------------------- -+Clears the system's IEC/IEEE floating-point exception flags. Returns the -+previous value of the flags. -+------------------------------------------------------------------------------- -+*/ -+extern int rounding; -+unsigned int spefscr = 0; -+ -+int8 syst_float_flags_clear( void ) -+{ -+#ifdef TEST_KERNEL_EMU -+ if( (spefscr & (SPE_FINV | SPE_FINV_H)) -+ || (spefscr & (SPE_FDBZ | SPE_FDBZ_H)) -+ || (spefscr & (SPE_FUNF | SPE_FUNF_H)) -+ || (spefscr & (SPE_FOVF | SPE_FOVF_H)) -+ || (spefscr & (SPE_FX | SPE_FG | SPE_FX_H | SPE_FG_H))){ -+ is_soft_emu = 1; -+ } else { -+ is_soft_emu = 0; -+ } -+#endif -+ __builtin_spe_mtspefscr(0x3c|(rounding & 0x3)); -+ -+ return ((spefscr>>17) & 0x1f); -+} -+ -+int syst_float_is_soft_emu(void) -+{ -+ int ret = 0; -+#ifdef TEST_KERNEL_EMU -+ ret = is_soft_emu; -+#endif -+ return ret; -+} -+ -+ -diff --git a/testfloat/powerpc-linux-gcc/systfloat.c b/testfloat/powerpc-linux-gcc/systfloat.c -new file mode 100644 -index 0000000..8d06f9f ---- /dev/null -+++ b/testfloat/powerpc-linux-gcc/systfloat.c -@@ -0,0 +1,595 @@ -+/* -+ * This file is derived from testfloat/systfloat.c, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/* -+=============================================================================== -+ -+This C source file is part of TestFloat, Release 2a, a package of programs -+for testing the correctness of floating-point arithmetic complying to the -+IEC/IEEE Standard for Floating-Point. -+ -+Written by John R. Hauser. More information is available through the Web -+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort -+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT -+TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO -+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY -+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) they include prominent notice that the work is derivative, and (2) they -+include prominent notice akin to these four paragraphs for those parts of -+this code that are retained. -+ -+=============================================================================== -+*/ -+ -+#include -+#include "milieu.h" -+#include "softfloat.h" -+#include "systfloat.h" -+ -+extern unsigned int spefscr; -+ -+float32 syst_int32_to_float32( int32 a ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = a; -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float64 syst_int32_to_float64( int32 a ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = a; -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) -+ -+floatx80 syst_int32_to_floatx80( int32 a ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = a; -+ return z; -+ -+} -+ -+#endif -+ -+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) -+ -+float128 syst_int32_to_float128( int32 a ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = a; -+ return z; -+ -+} -+ -+#endif -+ -+#ifdef BITS64 -+ -+float32 syst_int64_to_float32( int64 a ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = a; -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float64 syst_int64_to_float64( int64 a ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = a; -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) -+ -+floatx80 syst_int64_to_floatx80( int64 a ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = a; -+ return z; -+ -+} -+ -+#endif -+ -+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) -+ -+float128 syst_int64_to_float128( int64 a ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = a; -+ return z; -+ -+} -+ -+#endif -+ -+#endif -+ -+int32 syst_float32_to_int32_round_to_zero( float32 a ) -+{ -+ int32 z = *( (float *) &a ); -+ spefscr = __builtin_spe_mfspefscr(); -+ -+ return z; -+ -+} -+ -+#ifdef BITS64 -+ -+int64 syst_float32_to_int64_round_to_zero( float32 a ) -+{ -+ int64 z = *( (float *) &a ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+#endif -+ -+float64 syst_float32_to_float64( float32 a ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = *( (float *) &a ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) -+ -+floatx80 syst_float32_to_floatx80( float32 a ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = *( (float *) &a ); -+ return z; -+ -+} -+ -+#endif -+ -+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) -+ -+float128 syst_float32_to_float128( float32 a ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = *( (float *) &a ); -+ return z; -+ -+} -+ -+#endif -+ -+float32 syst_float32_add( float32 a, float32 b ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = *( (float *) &a ) + *( (float *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float32 syst_float32_sub( float32 a, float32 b ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = *( (float *) &a ) - *( (float *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float32 syst_float32_mul( float32 a, float32 b ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = *( (float *) &a ) * *( (float *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float32 syst_float32_div( float32 a, float32 b ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = *( (float *) &a ) / *( (float *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+flag syst_float32_eq( float32 a, float32 b ) -+{ -+ flag f = ( *( (float *) &a ) == *( (float *) &b ) ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return f; -+ -+} -+ -+flag syst_float32_le( float32 a, float32 b ) -+{ -+ flag f = ( *( (float *) &a ) <= *( (float *) &b ) ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return f; -+ -+} -+ -+flag syst_float32_lt( float32 a, float32 b ) -+{ -+ flag f = ( *( (float *) &a ) < *( (float *) &b ) ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return f; -+ -+} -+ -+int32 syst_float64_to_int32_round_to_zero( float64 a ) -+{ -+ int32 z = *( (double *) &a ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+#ifdef BITS64 -+ -+int64 syst_float64_to_int64_round_to_zero( float64 a ) -+{ -+ int64 z = *( (double *) &a ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+#endif -+ -+float32 syst_float64_to_float32( float64 a ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = *( (double *) &a ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) -+ -+floatx80 syst_float64_to_floatx80( float64 a ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = *( (double *) &a ); -+ return z; -+ -+} -+ -+#endif -+ -+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) -+ -+float128 syst_float64_to_float128( float64 a ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = *( (double *) &a ); -+ return z; -+ -+} -+ -+#endif -+ -+float64 syst_float64_add( float64 a, float64 b ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = *( (double *) &a ) + *( (double *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float64 syst_float64_sub( float64 a, float64 b ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = *( (double *) &a ) - *( (double *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float64 syst_float64_mul( float64 a, float64 b ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = *( (double *) &a ) * *( (double *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float64 syst_float64_div( float64 a, float64 b ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = *( (double *) &a ) / *( (double *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+float64 syst_float64_sqrt( float64 a ) -+{ -+ /* Ebony -+ float64 z; -+ -+ *( (double *) &z ) = sqrt( *( (double *) &a ) ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ */ -+ -+} -+ -+flag syst_float64_eq( float64 a, float64 b ) -+{ -+ flag f = ( *( (double *) &a ) == *( (double *) &b ) ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return f; -+ -+} -+ -+flag syst_float64_le( float64 a, float64 b ) -+{ -+ flag f = ( *( (double *) &a ) <= *( (double *) &b ) ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return f; -+ -+} -+ -+flag syst_float64_lt( float64 a, float64 b ) -+{ -+ flag f = ( *( (double *) &a ) < *( (double *) &b ) ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return f; -+ -+} -+ -+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 ) -+ -+int32 syst_floatx80_to_int32_round_to_zero( floatx80 a ) -+{ -+ -+ return *( (long double *) &a ); -+ -+} -+ -+#ifdef BITS64 -+ -+int64 syst_floatx80_to_int64_round_to_zero( floatx80 a ) -+{ -+ -+ return *( (long double *) &a ); -+ -+} -+ -+#endif -+ -+float32 syst_floatx80_to_float32( floatx80 a ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = *( (long double *) &a ); -+ return z; -+ -+} -+ -+float64 syst_floatx80_to_float64( floatx80 a ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = *( (long double *) &a ); -+ return z; -+ -+} -+ -+floatx80 syst_floatx80_add( floatx80 a, floatx80 b ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) + *( (long double *) &b ); -+ return z; -+ -+} -+ -+floatx80 syst_floatx80_sub( floatx80 a, floatx80 b ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) - *( (long double *) &b ); -+ return z; -+ -+} -+ -+floatx80 syst_floatx80_mul( floatx80 a, floatx80 b ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) * *( (long double *) &b ); -+ return z; -+ -+} -+ -+floatx80 syst_floatx80_div( floatx80 a, floatx80 b ) -+{ -+ floatx80 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) / *( (long double *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+flag syst_floatx80_eq( floatx80 a, floatx80 b ) -+{ -+ -+ return ( *( (long double *) &a ) == *( (long double *) &b ) ); -+ -+} -+ -+flag syst_floatx80_le( floatx80 a, floatx80 b ) -+{ -+ -+ return ( *( (long double *) &a ) <= *( (long double *) &b ) ); -+ -+} -+ -+flag syst_floatx80_lt( floatx80 a, floatx80 b ) -+{ -+ -+ return ( *( (long double *) &a ) < *( (long double *) &b ) ); -+ -+} -+ -+#endif -+ -+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 ) -+ -+int32 syst_float128_to_int32_round_to_zero( float128 a ) -+{ -+ -+ return *( (long double *) &a ); -+ -+} -+ -+#ifdef BITS64 -+ -+int64 syst_float128_to_int64_round_to_zero( float128 a ) -+{ -+ -+ return *( (long double *) &a ); -+ -+} -+ -+#endif -+ -+float32 syst_float128_to_float32( float128 a ) -+{ -+ float32 z; -+ -+ *( (float *) &z ) = *( (long double *) &a ); -+ return z; -+ -+} -+ -+float64 syst_float128_to_float64( float128 a ) -+{ -+ float64 z; -+ -+ *( (double *) &z ) = *( (long double *) &a ); -+ return z; -+ -+} -+ -+float128 syst_float128_add( float128 a, float128 b ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) + *( (long double *) &b ); -+ return z; -+ -+} -+ -+float128 syst_float128_sub( float128 a, float128 b ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) - *( (long double *) &b ); -+ return z; -+ -+} -+ -+float128 syst_float128_mul( float128 a, float128 b ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) * *( (long double *) &b ); -+ return z; -+ -+} -+ -+float128 syst_float128_div( float128 a, float128 b ) -+{ -+ float128 z; -+ -+ *( (long double *) &z ) = -+ *( (long double *) &a ) / *( (long double *) &b ); -+ spefscr = __builtin_spe_mfspefscr(); -+ return z; -+ -+} -+ -+flag syst_float128_eq( float128 a, float128 b ) -+{ -+ -+ return ( *( (long double *) &a ) == *( (long double *) &b ) ); -+ -+} -+ -+flag syst_float128_le( float128 a, float128 b ) -+{ -+ -+ return ( *( (long double *) &a ) <= *( (long double *) &b ) ); -+ -+} -+ -+flag syst_float128_lt( float128 a, float128 b ) -+{ -+ -+ return ( *( (long double *) &a ) < *( (long double *) &b ) ); -+ -+} -+ -+#endif -+ -diff --git a/testfloat/powerpc-linux-gcc/systmodes.c b/testfloat/powerpc-linux-gcc/systmodes.c -new file mode 100644 -index 0000000..143cdea ---- /dev/null -+++ b/testfloat/powerpc-linux-gcc/systmodes.c -@@ -0,0 +1,67 @@ -+/* -+ * This file is derived from testfloat/386-Win32-gcc/systmodes.S, -+ * the copyright for that material belongs to the original owners. -+ * -+ * Additional material and changes where applicable is: -+ * Copyright (C) 2008 Freescale Semiconductor, Inc. All rights reserved. -+ * -+ * Author: Ebony Zhu, -+ * Yu Liu, -+ */ -+ -+/* -+=============================================================================== -+ -+This C source file is part of TestFloat, Release 2a, a package of programs -+for testing the correctness of floating-point arithmetic complying to the -+IEC/IEEE Standard for Floating-Point. -+ -+Written by John R. Hauser. More information is available through the Web -+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'. -+ -+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort -+has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT -+TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO -+PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY -+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. -+ -+Derivative works are acceptable, even for commercial purposes, so long as -+(1) they include prominent notice that the work is derivative, and (2) they -+include prominent notice akin to these four paragraphs for those parts of -+this code that are retained. -+ -+=============================================================================== -+*/ -+ -+#include -+#include "milieu.h" -+#include "systmodes.h" -+/* -+------------------------------------------------------------------------------- -+Sets the system's IEC/IEEE floating-point rounding mode. Also disables all -+system exception traps. -+------------------------------------------------------------------------------- -+*/ -+int rounding; -+ -+void syst_float_set_rounding_mode( int8 roundingMode ) -+{ -+ (void) fesetround ( roundingMode ); -+ rounding = roundingMode; -+} -+ -+/* -+------------------------------------------------------------------------------- -+Sets the rounding precision of subsequent extended double-precision -+operations. The `precision' argument should be one of 0, 32, 64, or 80. -+If `precision' is 32, the rounding precision is set equivalent to single -+precision; else if `precision' is 64, the rounding precision is set -+equivalent to double precision; else the rounding precision is set to full -+extended double precision. -+------------------------------------------------------------------------------- -+*/ -+void syst_float_set_rounding_precision( int8 precision ) -+{ -+ -+} -+ -diff --git a/testfloat/templates/Makefile b/testfloat/templates/Makefile -index f5f3cde..18cffe0 100644 ---- a/testfloat/templates/Makefile -+++ b/testfloat/templates/Makefile -@@ -1,15 +1,21 @@ - --PROCESSOR_H = ../../processors/!!!processor.h -+#PROCESSOR_H = ../../processors/!!!processor.h -+PROCESSOR_H = ../../processors/POWERPC-gcc.h - SOFTFLOAT_VERSION = bits64 --TARGET = !!!target --SOFTFLOAT_DIR = ../../softfloat/$(SOFTFLOAT_VERSION)/$(TARGET) -+ -+#TARGET = !!!target -+TARGET = powerpc-GCC -+SOFTFLOAT_DIR = ../../../SoftFloat-2b/softfloat/$(SOFTFLOAT_VERSION)/$(TARGET) - - OBJ = .o - EXE = - INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR) --COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2 --COMPILE_SLOWFLOAT_C = gcc -c -o $@ $(INCLUDES) -I- -O3 --LINK = gcc -o $@ -+#COMPILE_C = gcc -c -o $@ $(INCLUDES) -I- -O2 -+#COMPILE_SLOWFLOAT_C = gcc -c -o $@ $(INCLUDES) -I- -O3 -+#LINK = gcc -o $@ -+COMPILE_C = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -c -o $@ $(INCLUDES) -I- -O2 -+COMPILE_SLOWFLOAT_C = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -c -o $@ $(INCLUDES) -I- -O3 -+LINK = /opt/mtwk/usr/local/gcc-3_4-e500-glibc-2.3.4-dp/powerpc-linux-gnuspe/bin/powerpc-linux-gnuspe-gcc -o $@ - - SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h - SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ) -diff --git a/testfloat/templates/milieu.h b/testfloat/templates/milieu.h -index 56d3ac4..3214ca8 100644 ---- a/testfloat/templates/milieu.h -+++ b/testfloat/templates/milieu.h -@@ -28,7 +28,7 @@ this code that are retained. - Include common integer types and flags. - ------------------------------------------------------------------------------- - */ --#include "../../processors/!!!processor.h" -+#include "../../processors/SPARC-gcc.h" - - /* - ------------------------------------------------------------------------------- -diff --git a/testfloat/testFunction.h b/testfloat/testFunction.h -index 04bf856..00139a7 100644 ---- a/testfloat/testFunction.h -+++ b/testfloat/testFunction.h -@@ -126,8 +126,8 @@ extern const flag functionExists[ NUM_FUNCTIONS ]; - enum { - ROUND_NEAREST_EVEN = 1, - ROUND_TO_ZERO, -- ROUND_DOWN, - ROUND_UP, -+ ROUND_DOWN, - NUM_ROUNDINGMODES - }; - -diff --git a/testfloat/testLoops.c b/testfloat/testLoops.c -index 8ba92f3..ba05548 100644 ---- a/testfloat/testLoops.c -+++ b/testfloat/testLoops.c -@@ -488,6 +488,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -539,6 +544,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -592,6 +602,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -647,6 +662,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -702,6 +722,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -753,6 +778,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -806,6 +836,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -861,6 +896,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_int64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -916,6 +956,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -973,6 +1018,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1030,6 +1080,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1087,6 +1142,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1146,6 +1206,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1203,6 +1268,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1260,6 +1330,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32, testCases_b_float32 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1312,6 +1387,25 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float32, testCases_b_float32 ); - testFlags = testFlagsFunctionPtr(); -+ -+if(testCases_a_float32 == 0x7ffffe && testCases_b_float32 == 0x3f7ffffe) -+{ -+ -+ writeErrorFound( 10000 - count ); -+ writeInputs_ab_float32(); -+ fputs( " ", stdout ); -+ writeOutputs_z_float32( trueZ, trueFlags, testZ, testFlags ); -+ fflush( stdout ); -+ if (! syst_float_is_soft_emu()){ -+ exit(-1); -+ } -+} -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif -+ - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1370,6 +1464,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1427,6 +1526,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1484,6 +1588,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1541,6 +1650,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1600,6 +1714,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1657,6 +1776,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1714,6 +1838,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64, testCases_b_float64 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1766,6 +1895,13 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float64, testCases_b_float64 ); - testFlags = testFlagsFunctionPtr(); -+ -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif -+ - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1826,6 +1962,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1883,6 +2024,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1940,6 +2086,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -1995,6 +2146,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2052,6 +2208,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2109,6 +2270,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2166,6 +2332,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2218,6 +2389,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_floatx80, testCases_b_floatx80 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2280,6 +2456,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2337,6 +2518,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2394,6 +2580,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2449,6 +2640,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2506,6 +2702,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2563,6 +2764,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2620,6 +2826,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128, testCases_b_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); -@@ -2672,6 +2883,11 @@ void - (void) testFlagsFunctionPtr(); - testZ = testFunction( testCases_a_float128, testCases_b_float128 ); - testFlags = testFlagsFunctionPtr(); -+#ifdef TEST_KERNEL_EMU -+ if (! syst_float_is_soft_emu()){ -+ continue; -+ } -+#endif - --count; - if ( count == 0 ) { - checkEarlyExit(); --- -1.5.4 - diff --git a/recipes-test/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch b/recipes-test/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch deleted file mode 100644 index 42de56d..0000000 --- a/recipes-test/testfloat/files/Yocto-replace-COMPILE_PREFIX-gcc.patch +++ /dev/null @@ -1,67 +0,0 @@ -From 6c7567e05c28b8cb6c7dc68c278950a32feb6f64 Mon Sep 17 00:00:00 2001 -From: Ting Liu -Date: Wed, 9 May 2012 02:42:57 -0500 -Subject: [PATCH] Yocto: replace $(COMPILE_PREFIX)gcc with $(CC) and remove -te500v2 flags - -Signed-off-by: Ting Liu ---- - SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile | 4 ++-- - SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile | 4 ++-- - testfloat/powerpc-linux-gcc/Makefile | 8 ++++---- - 3 files changed, 8 insertions(+), 8 deletions(-) - -diff --git a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile -index 28f1e33..4098048 100644 ---- a/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile -+++ b/SoftFloat-2b/softfloat/bits32/powerpc-GCC/Makefile -@@ -5,8 +5,8 @@ SOFTFLOAT_MACROS = ../softfloat-macros - OBJ = .o - EXE = - INCLUDES = -I. -I.. --COMPILE_C = $(COMPILE_PREFIX)gcc -msoft-float -c -o $@ $(INCLUDES) -I- -O2 --LINK = $(COMPILE_PREFIX)gcc -o $@ -+COMPILE_C = $(CC) -msoft-float -c -o $@ $(INCLUDES) -I- -O2 -+LINK = $(CC) -o $@ - - ALL: softfloat$(OBJ) timesoftfloat$(EXE) - -diff --git a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile -index a5e2cc7..c34e16e 100644 ---- a/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile -+++ b/SoftFloat-2b/softfloat/bits64/powerpc-GCC/Makefile -@@ -5,8 +5,8 @@ SOFTFLOAT_MACROS = ../softfloat-macros - OBJ = .o - EXE = - INCLUDES = -I. -I.. --COMPILE_C = $(COMPILE_PREFIX) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2 --LINK = $(COMPILE_PREFIX) -o $@ -+COMPILE_C = $(CC) -mcpu=8548 -mhard-float -mfloat-gprs=double -o $@ $(INCLUDES) -I- -O2 -+LINK = $(CC) -o $@ - - ALL: softfloat$(OBJ) timesoftfloat$(EXE) - -diff --git a/testfloat/powerpc-linux-gcc/Makefile b/testfloat/powerpc-linux-gcc/Makefile -index de50aad..1a8b5f7 100644 ---- a/testfloat/powerpc-linux-gcc/Makefile -+++ b/testfloat/powerpc-linux-gcc/Makefile -@@ -8,13 +8,13 @@ OBJ = .o - EXE = - INCLUDES = -I. -I.. -I$(SOFTFLOAT_DIR) - --COMPILE_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS) -+COMPILE_C = $(CC) -c -o $@ $(INCLUDES) -I- -O $(EXTRA_CFLAGS) - --COMPILE_C_HARD = $(COMPILE_PREFIX)gcc -c -te500v2 -o $@ $(INCLUDES) -+COMPILE_C_HARD = $(CC) -c -o $@ $(INCLUDES) - --COMPILE_SLOWFLOAT_C = $(COMPILE_PREFIX)gcc -c -o $@ $(INCLUDES) -I- -O -+COMPILE_SLOWFLOAT_C = $(CC) -c -o $@ $(INCLUDES) -I- -O - --LINK = $(COMPILE_PREFIX)gcc -lm -o $@ -+LINK = $(CC) -lm -o $@ - - SOFTFLOAT_H = $(SOFTFLOAT_DIR)/softfloat.h - SOFTFLOAT_OBJ = $(SOFTFLOAT_DIR)/softfloat$(OBJ) --- -1.7.3.4 - diff --git a/recipes-test/testfloat/testfloat_2a.bb b/recipes-test/testfloat/testfloat_2a.bb deleted file mode 100644 index 3fbb207..0000000 --- a/recipes-test/testfloat/testfloat_2a.bb +++ /dev/null @@ -1,46 +0,0 @@ -DESCRIPTION = "A program for testing floating-point implementation" -SECTION = "test" -LICENSE = "Hauser TestFloat" - -LIC_FILES_CHKSUM = "file://testfloat/testfloat.txt;beginline=87;endline=95;md5=bdb2e8111838a48015c29bd97f5b6145" - -SRC_URI = " http://www.jhauser.us/arithmetic/TestFloat-2a.tar.Z;name=TestFloat \ - http://www.jhauser.us/arithmetic/SoftFloat-2b.tar.Z;name=SoftFloat \ - " -SRC_URI_append_fslmachine = " file://SoftFloat-powerpc-1.patch \ - file://TestFloat-powerpc-E500v2-SPE-1.patch \ - file://Yocto-replace-COMPILE_PREFIX-gcc.patch \ - " -SRC_URI[TestFloat.md5sum] = "4dc889319ae1e0c5381ec511f784553a" -SRC_URI[TestFloat.sha256sum] = "84d14aa42adefbda2ec9708b42946f7fa59f93689b042684bd027863481f8e4e" -SRC_URI[SoftFloat.md5sum] = "b4a58b5c941f1a2317e4c2500086e3fa" -SRC_URI[SoftFloat.sha256sum] = "89d14b55113a2ba8cbda7011443ba1d298d381c89d939515d56c5f18f2febf81" - -S = "${WORKDIR}/TestFloat-2a" - -do_unpack2(){ - mv ${WORKDIR}/SoftFloat-2b ${S}/SoftFloat-2b - cd ${S} - if [ -n "$(which fromdos)" ];then - find -type f -exec fromdos {} \; - elif [ -n "$(which dos2unix)" ];then - find -type f -exec dos2unix {} \; - else - echo -e "\nERROR: command dos2unix or fromdos not found\n" && return 1 - fi -} -addtask do_unpack2 after do_unpack before do_patch - -do_compile(){ - oe_runmake -C testfloat/powerpc-linux-gcc/ CC="${CC}" EXTRA_CFLAGS="-DTEST_KERNEL_EMU" -} - -do_install(){ - install -d ${D}/${bindir} - install testfloat/powerpc-linux-gcc/testfloat ${D}/${bindir} - install testfloat/powerpc-linux-gcc/testsoftfloat ${D}/${bindir} -} - -COMPATIBLE_HOST_e500v2 = ".*" -COMPATIBLE_HOST ?= "(none)" - diff --git a/recipes-tools/boot-format/boot-format_git.bb b/recipes-tools/boot-format/boot-format_git.bb deleted file mode 100644 index ac1504d..0000000 --- a/recipes-tools/boot-format/boot-format_git.bb +++ /dev/null @@ -1,19 +0,0 @@ -DESCRIPTION = "Boot format utility for booting from eSDHC/eSPI" -LICENSE = "GPLv2" -PR = "r6" -LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263" - -SRC_URI = "git://git.freescale.com/ppc/sdk/boot-format.git" -SRCREV = "d9bbfaba0c9316ae33455099c47bae429479e530" - -S = "${WORKDIR}/git" -EXTRA_OEMAKE = 'CC="${CC}"' - -do_install(){ - oe_runmake DESTDIR=${D} PREFIX=${prefix} install -} - -PACKAGES =+ "${PN}-config" -FILES_${PN}-config += "${datadir}/*" - -BBCLASSEXTEND = "native nativesdk" diff --git a/recipes-tools/cst/cst_git.bb b/recipes-tools/cst/cst_git.bb deleted file mode 100644 index 177f23c..0000000 --- a/recipes-tools/cst/cst_git.bb +++ /dev/null @@ -1,29 +0,0 @@ -DESCRIPTION = "CST Tool" -SECTION = "cst" -LICENSE = "BSD" - -# TODO: fix license - this file is not a license -LIC_FILES_CHKSUM = "file://RELEASENOTES;beginline=8;endline=43;md5=5a7b22a2c96b5f94e0498c5f413aa8d3" - -DEPENDS += "openssl" - -SRC_URI = "git://git.freescale.com/ppc/sdk/cst.git" -SRCREV = "e4035cbf54ed481147c6ae65c741ef75dc9ec37f" - -S = "${WORKDIR}/git" - -EXTRA_OEMAKE = 'OPENSSL_LIB_PATH=${STAGING_LIBDIR} OPENSSL_INC_PATH=${STAGING_INCDIR} CC="${CC}" LD="${CC}" LDFLAGS="${LDFLAGS}"' - -do_install () { - install -d ${D}/${bindir}/cst - install -m 755 ${S}/gen_keys ${D}/${bindir}/cst/ - install -m 755 ${S}/gen_otpmk ${D}/${bindir}/cst/ - install -m 755 ${S}/uni_cfsign ${D}/${bindir}/cst/ - install -m 755 ${S}/uni_sign ${D}/${bindir}/cst/ - cp -rf ${S}/input_files ${D}/${bindir}/cst -} - -BBCLASSEXTEND = "native nativesdk" -PARALLEL_MAKE = "" - -FILES_${PN}-dbg += "${bindir}/cst/.debug" diff --git a/recipes-tools/embedded-hv/files/81-fsl-embedded-hv.rules b/recipes-tools/embedded-hv/files/81-fsl-embedded-hv.rules deleted file mode 100644 index 5edfa11..0000000 --- a/recipes-tools/embedded-hv/files/81-fsl-embedded-hv.rules +++ /dev/null @@ -1,2 +0,0 @@ -# Add rule to handle setting up device node for FSL HV mgmt driver -SUBSYSTEM=="misc", KERNEL=="fsl-hv", NAME="fsl-hv" diff --git a/recipes-tools/embedded-hv/hypervisor_git.bb b/recipes-tools/embedded-hv/hypervisor_git.bb deleted file mode 100644 index dc86406..0000000 --- a/recipes-tools/embedded-hv/hypervisor_git.bb +++ /dev/null @@ -1,90 +0,0 @@ -DESCRIPTION = "Freescale embedded hypervisor" -SECTION = "embedded-hv" -LICENSE = "BSD" -LIC_FILES_CHKSUM = "file://README;endline=22;md5=0655bbc3b7d7166c30c87208b4e23cf0" - -PR = "r3" - -DEPENDS = "u-boot-mkimage-native" - -inherit deploy - -S = "${WORKDIR}/git" - -# TODO: fix dtc to use the already built package -SRC_URI = " \ - git://git.freescale.com/ppc/sdk/hypervisor/hypervisor.git;name=hypervisor \ - git://git.freescale.com/ppc/sdk/hypervisor/kconfig.git;name=kconfig;destsuffix=git/kconfig \ - git://git.freescale.com/ppc/sdk/hypervisor/libos.git;name=libos;destsuffix=git/libos \ - git://www.jdl.com/software/dtc.git;name=dtc;destsuffix=dtc \ - git://git.freescale.com/ppc/sdk/hypertrk.git;name=hypertrk;destsuffix=git/hypertrk \ - file://81-fsl-embedded-hv.rules \ - " - -SRCREV_FORMAT="hypervisor" -SRCREV = "e6092cdf2a225c66c1ea46b1151eb828da29d139" -SRCREV_kconfig = "a56025d4da992b856796b0eccac2e410d751dbac" -SRCREV_libos = "5268371581f3ef3959be2a53235edfa6a8c6aa7c" -SRCREV_dtc = "033089f29099bdfd5c2d6986cdb9fd07b16cfde0" -SRCREV_hypertrk = "975c98b562186afbd3bbf103ae54b96cf9b3e533" - -EXTRA_OEMAKE = 'CROSS_COMPILE=${TARGET_PREFIX} CC="${TARGET_PREFIX}gcc ${TOOLCHAIN_OPTIONS}"' - -DEFCONFIG = "defconfig" -DEFCONFIG_powerpc64 = "64bit_defconfig" - -COMPATIBLE_HOST_fslmachine = ".*" -COMPATIBLE_HOST ?= "(none)" - -inherit cml1 -do_configure () { - oe_runmake ${DEFCONFIG} -} - -PKG_HV_HYPERTRK_SUPPORT = "n" -do_compile () { - if [ "${PKG_HV_HYPERTRK_SUPPORT}" = "y" ] - then - oe_runmake silentoldconfig - export HV_DIR=$PWD - cd hypertrk - oe_runmake deploy - cd .. - fi - - oe_runmake - oe_runmake partman -} - -do_install () { - install -d ${D}/${bindir} - install ${S}/output/bin/linux/partman ${D}/${bindir}/partman - - install -d ${D}${sysconfdir}/udev/rules.d - install -m 0644 ${WORKDIR}/81-fsl-embedded-hv.rules ${D}${sysconfdir}/udev/rules.d - - install -d ${D}/boot/hv - install ${S}/output/.config ${D}/boot/hv/hypervisor.config - install -m 644 ${S}/output/bin/hv ${S}/output/bin/hv.map \ - ${S}/output/bin/hv.uImage ${S}/output/bin/hv.bin \ - ${D}/boot/hv/ -} - -do_deploy () { - install -d ${DEPLOYDIR}/hv/ - install ${S}/output/.config ${DEPLOYDIR}/hv/hypervisor.config - install -m 644 ${S}/output/bin/hv ${S}/output/bin/hv.map \ - ${S}/output/bin/hv.uImage ${S}/output/bin/hv.bin \ - ${DEPLOYDIR}/hv/ -} -addtask deploy before do_build after do_install - -do_deploy_append() { - rm -f ${S}/../hv -} - -INHIBIT_PACKAGE_DEBUG_SPLIT = "1" -ALLOW_EMPTY_${PN} = "1" -PACKAGES_prepend = "${PN}-image ${PN}-partman " -FILES_${PN}-image = "/boot/" -FILES_${PN}-partman = "${bindir}/partman" diff --git a/recipes-tools/eth-config/eth-config_git.bb b/recipes-tools/eth-config/eth-config_git.bb deleted file mode 100644 index ac25013..0000000 --- a/recipes-tools/eth-config/eth-config_git.bb +++ /dev/null @@ -1,19 +0,0 @@ -DESCRIPTION = "Ethernet Configuration Files" -SECTION = "eth-config" -LICENSE = "Freescale-EULA" -LIC_FILES_CHKSUM = "file://COPYING;md5=cf02dc8eb5ac4a76f3812826520dea87" - -PR = "r2" - -SRC_URI = "git://git.freescale.com/ppc/sdk/eth-config.git" -SRCREV = "c255231fb606bff18390da3b26e1ee9fca55e4e6" - -S = "${WORKDIR}/git" - -do_install() { - install -d ${D}/etc/fmc/config - install -m 644 ${S}/*.xml ${D}/etc/fmc/config - install -d ${D}/etc/fmc/config/shared_mac - install -m 644 ${S}/shared_mac/*.xml ${D}/etc/fmc/config/shared_mac - install -m 644 ${S}/shared_mac/README ${D}/etc/fmc/config/shared_mac -} diff --git a/recipes-tools/flib/flib_git.bb b/recipes-tools/flib/flib_git.bb deleted file mode 100644 index fb3f698..0000000 --- a/recipes-tools/flib/flib_git.bb +++ /dev/null @@ -1,15 +0,0 @@ -DESCRIPTION = "Foundation Library" -SECTION = "flib" -LICENSE = "BSD & GPLv2" -LIC_FILES_CHKSUM = "file://COPYING;md5=3f16fa8e677e45af3127c5c4bafc3c00" - -SRC_URI = "git://git.freescale.com/ppc/sdk/flib.git" -SRCREV = "ff692ad3c286a07717c6677177825889fe17d450" - -S = "${WORKDIR}/git" - -do_install(){ - oe_runmake install DESTDIR=${D} -} - -ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-tools/hv-cfg/hv-cfg_git.bb b/recipes-tools/hv-cfg/hv-cfg_git.bb deleted file mode 100644 index 2c6bb85..0000000 --- a/recipes-tools/hv-cfg/hv-cfg_git.bb +++ /dev/null @@ -1,46 +0,0 @@ -DESCRIPTION = "Hypervisor Config" -SECTION = "hv-cfg" -LICENSE = "BSD" -PR = "r6" - -LIC_FILES_CHKSUM = " \ - file://p2041rdb/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ - file://p3041ds/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ - file://p4080ds/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ - file://p5020ds/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ -" - -DEPENDS += "dtc-native" - -# this package is specific to the machine itself -INHIBIT_DEFAULT_DEPS = "1" -PACKAGE_ARCH = "${MACHINE_ARCH}" -COMPATIBLE_HOST_fslmachine = ".*" -COMPATIBLE_HOST ?= "(none)" - -inherit deploy - -SRCREV = "d037ab9d5b9ecd58e10a7dac2b601d781ed9b5bf" -SRC_URI = "git://git.freescale.com/ppc/sdk/hv-cfg.git" - -S = "${WORKDIR}/git" - -do_install () { - make install - - M=`echo ${MACHINE} | sed s/-64b//g` - install -d ${D}/boot/hv-cfg - cp -r ${S}/${M}/${M}/* ${D}/boot/hv-cfg -} - -do_deploy () { - M=`echo ${MACHINE} | sed s/-64b//g` - install -d ${DEPLOYDIR}/hv-cfg - cp -r ${S}/${M}/${M}/* ${DEPLOYDIR}/hv-cfg -} -addtask deploy after do_install - -PACKAGES += "${PN}-image" -FILES_${PN}-image += "/boot" - -ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-tools/mux-server/files/mux-server-1.02.tar.gz b/recipes-tools/mux-server/files/mux-server-1.02.tar.gz deleted file mode 100644 index d8f2014..0000000 Binary files a/recipes-tools/mux-server/files/mux-server-1.02.tar.gz and /dev/null differ diff --git a/recipes-tools/mux-server/mux-server_1.02.bb b/recipes-tools/mux-server/mux-server_1.02.bb deleted file mode 100644 index ab9cce1..0000000 --- a/recipes-tools/mux-server/mux-server_1.02.bb +++ /dev/null @@ -1,16 +0,0 @@ -DESCRIPTION = "A Linux-based utility supporting console multiplexing and demultiplexing" -SECTION = "mux-server" -LICENSE = "LGPL-2.1" -# TODO: add a dedicated COPYING file -LIC_FILES_CHKSUM = "file://mux_server.c;endline=9;md5=e59eeb0812bb88b7af2d932f2dc22aed" - -SRC_URI = "file://mux-server-${PV}.tar.gz;name=mux_server" - -EXTRA_OEMAKE='HOSTCC="${CC}"' - -do_install () { - install -d ${D}${bindir} - install -m 755 mux_server ${D}${bindir} -} - -BBCLASSEXTEND = "native nativesdk" diff --git a/recipes-tools/rcw/rcw_git.bb b/recipes-tools/rcw/rcw_git.bb deleted file mode 100644 index c532a9d..0000000 --- a/recipes-tools/rcw/rcw_git.bb +++ /dev/null @@ -1,39 +0,0 @@ -DESCRIPTION = "Reset Control Words (RCW)" -SECTION = "rcw" -LICENSE = "BSD" -PR = "r8" - -LIC_FILES_CHKSUM = "file://rcw.py;beginline=8;endline=28;md5=9ba0b28922dd187b06b6c8ebcfdd208e" - -# this package is specific to the machine itself -INHIBIT_DEFAULT_DEPS = "1" -PACKAGE_ARCH = "${MACHINE_ARCH}" -COMPATIBLE_HOST_fslmachine = ".*" -COMPATIBLE_HOST ?= "(none)" - -inherit deploy - -SRC_URI = "git://git.freescale.com/ppc/sdk/rcw.git" -SRCREV = "5d3c819bcca6d09dcf7b52b3f2855dda304a5997" - -S = "${WORKDIR}/git" - -do_install () { - make install - - M=`echo ${MACHINE} | sed s/-64b//g` - install -d ${D}/boot/rcw - cp -r ${S}/${M}/${M}/* ${D}/boot/rcw -} - -do_deploy () { - M=`echo ${MACHINE} | sed s/-64b//g` - install -d ${DEPLOYDIR}/rcw - cp -r ${S}/${M}/${M}/* ${DEPLOYDIR}/rcw -} -addtask deploy after do_install - -PACKAGES += "${PN}-image" -FILES_${PN}-image += "/boot" - -ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-tools/skmm/skmm_git.bb b/recipes-tools/skmm/skmm_git.bb deleted file mode 100644 index 224e556..0000000 --- a/recipes-tools/skmm/skmm_git.bb +++ /dev/null @@ -1,33 +0,0 @@ -DESCRIPTION = "SKMM application for PCIe endpoint" -SECTION = "skmm" -LICENSE = "BSD & GPLv2" -LIC_FILES_CHKSUM = "file://Makefile;endline=30;md5=39e58bedc879163c9338596e52df5b1f" - -DEPENDS = "libedit" - -SRC_URI = "git://git.freescale.com/ppc/sdk/skmm-ep.git" -SRCREV = "80d8393a2033b3b0cc8f885702d7b288956f3a37" - -COMPATIBLE_MACHINE = "(p4080ds|t4240qds)" - -S = "${WORKDIR}/git" - -EXTRA_OEMAKE = 'MACHINE=${MACHINE}' - -export LIBEDIT_CFLAGS="$(pkg-config --cflags libedit)" -export LIBEDIT_LDFLAGS="$(pkg-config --libs --static libedit)" - -do_compile () { - export ARCH=${TARGET_ARCH} - oe_runmake HOST=x86_64 clean - oe_runmake HOST=x86_64 - oe_runmake HOST=powerpc clean - oe_runmake HOST=powerpc -} - -do_install () { - oe_runmake ARCH=${TARGET_ARCH} HOST=x86_64 install DESTDIR=${D} - oe_runmake ARCH=${TARGET_ARCH} HOST=powerpc install DESTDIR=${D} -} - -FILES_${PN} += "/home/root/.skmm/*" diff --git a/recipes-tools/usdpaa/usdpaa_git.bb b/recipes-tools/usdpaa/usdpaa_git.bb deleted file mode 100644 index 48e860f..0000000 --- a/recipes-tools/usdpaa/usdpaa_git.bb +++ /dev/null @@ -1,49 +0,0 @@ -DESCRIPTION = "User-Space Data-Path Acceleration Architecture drivers" -LICENSE = "BSD & GPLv2" -LIC_FILES_CHKSUM = "file://Makefile;endline=30;md5=39e58bedc879163c9338596e52df5b1f" -PR = "r4" - -inherit pkgconfig - -DEPENDS = "libxml2 libedit ncurses readline flib fmc" -RDEPENDS_${PN} = "libgcc bash" - -SRC_URI = "git://git.freescale.com/ppc/sdk/usdpaa.git" -SRCREV = "97fe45d9697ef339e10a1885539b23fa7fcb113e" - -S = "${WORKDIR}/git" - -EXTRA_OEMAKE = 'CC="${CC}" LD="${LD}" AR="${AR}"' -export ARCH="${TARGET_ARCH}" - -do_compile_prepend () { - case ${MACHINE} in - b4420qds|b4420qds-64b|b4860qds|b4860qds-64b) SOC=B4860;; - t4240qds|t4240qds-64b) SOC=T4240;; - p1023rdb) SOC=P1023;; - *) SOC=P4080;; - esac - export FMC_EXTRA_CFLAGS="-I ${STAGING_INCDIR}/fmc" - export FMLIB_EXTRA_CFLAGS="-I ${STAGING_INCDIR}/fmd \ - -I ${STAGING_INCDIR}/fmd/Peripherals \ - -I ${STAGING_INCDIR}/fmd/integrations \ - -D $SOC" - - export LIBXML2_CFLAGS="$(pkg-config --cflags libxml-2.0)" - export LIBXML2_LDFLAGS="$(pkg-config --libs --static libxml-2.0)" - export LIBEDIT_CFLAGS="$(pkg-config --cflags libedit)" - export LIBEDIT_LDFLAGS="$(pkg-config --libs --static libedit)" -} - -do_install () { - oe_runmake install DESTDIR=${D} -} - -PARALLEL_MAKE_pn-${PN} = "" -FILES_${PN} += "/root/SOURCE_THIS /usr/etc/" - -PACKAGE_ARCH = "${MACHINE_ARCH}" - -COMPATIBLE_HOST_fslmachine = ".*" -COMPATIBLE_HOST ?= "(none)" - diff --git a/recipes-tools/web-sysmon/web-sysmon_git.bb b/recipes-tools/web-sysmon/web-sysmon_git.bb deleted file mode 100644 index 1b2e070..0000000 --- a/recipes-tools/web-sysmon/web-sysmon_git.bb +++ /dev/null @@ -1,21 +0,0 @@ -DESCRIPTION = "Web System Monitor Files" -SECTION = "web-sysmon" -LICENSE = "GPLv2" -LIC_FILES_CHKSUM = "file://COPYING;md5=12f884d2ae1ff87c09e5b7ccc2c4ca7e" - -SRC_URI = "git://git.freescale.com/ppc/sdk/web-sysmon.git" -SRCREV = "40b47611378ef5c07d98f0f691bb146ae52dcdc1" - -S = "${WORKDIR}/git" - -FILES_${PN} += "/" - -RDEPENDS_${PN} = "lighttpd" - -do_install() { - install -d ${D}/etc - install -m 644 ${S}/lighttpd.conf ${D}/etc - install -d ${D}/usr/local/bin - install -m 755 ${S}/rrd/sens_update_rrd ${D}/usr/local/bin - cp -r ${S}/rrd ${D}/usr -} diff --git a/recipes-ucode/fm-ucode/fm-ucode_git.bb b/recipes-ucode/fm-ucode/fm-ucode_git.bb deleted file mode 100644 index 76d00b9..0000000 --- a/recipes-ucode/fm-ucode/fm-ucode_git.bb +++ /dev/null @@ -1,46 +0,0 @@ -DESCRIPTION = "Fman microcode binary" -SECTION = "fm-ucode" -LICENSE = "Freescale-EULA" -LIC_FILES_CHKSUM = "file://EULA;md5=60037ccba533a5995e8d1a838d85799c" - -PR = "r1" - -COMPATIBLE_MACHINE = "(p1023rdb|p2041rdb|p3041ds|p4080ds|p5020ds|p5040ds|p5020ds-64b|p5040ds-64b|b4420qds|b4420qds-64b|b4860qds|b4860qds-64b|t4160qds|t4160qds-64b|t4240qds|t4240qds-64b)" -inherit deploy - -SRC_URI = "git://git.freescale.com/ppc/sdk/fm-ucode.git" -SRCREV = "4ca0e41de225b34962e1517c2c75bbb31a381e1a" - -S = "${WORKDIR}/git" - -ALLOW_EMPTY_${PN} = "1" -do_install () { - case ${MACHINE} in - b4420qds|b4420qds-64b|b4860qds|b4860qds-64b) UCODE=b4860qds;; - t4240qds|t4240qds-64b|t4160qds|t4160qds-64b) UCODE=t4240qds;; - p5020ds|p5020ds-64b) UCODE=p5020ds;; - p5040ds|p5040ds-64b) UCODE=p5040ds;; - *) UCODE=${MACHINE};; - esac - UCODE=`echo $UCODE | sed -e 's,[a-zA-Z]*$,,'` - install -d ${D}/boot - install -m 644 fsl_fman_ucode_${UCODE}*.bin ${D}/boot/ -} - -do_deploy () { - case ${MACHINE} in - b4420qds|b4420qds-64b|b4860qds|b4860qds-64b) UCODE=b4860qds;; - t4240qds|t4240qds-64b|t4160qds|t4160qds-64b) UCODE=t4240qds;; - p5020ds|p5020ds-64b) UCODE=p5020ds;; - p5040ds|p5040ds-64b) UCODE=p5040ds;; - *) UCODE=${MACHINE};; - esac - UCODE=`echo $UCODE | sed -e 's,[a-zA-Z]*$,,'` - install -d ${DEPLOYDIR}/ - install -m 644 fsl_fman_ucode_${UCODE}*.bin ${DEPLOYDIR}/ -} -addtask deploy before do_build after do_install - -PACKAGES += "${PN}-image" -FILES_${PN}-image += "/boot" - diff --git a/recipes-ucode/fmc/fmc_git.bb b/recipes-ucode/fmc/fmc_git.bb deleted file mode 100644 index 20f93f6..0000000 --- a/recipes-ucode/fmc/fmc_git.bb +++ /dev/null @@ -1,53 +0,0 @@ -DESCRIPTION = "Frame Manager Configuration tool" -SECTION = "fmc" -LICENSE = "MIT" -LIC_FILES_CHKSUM = "file://COPYING;md5=a504ab5a8ff235e67c7301214749346c" - -PR = "r2" - -SRC_URI = "git://git.freescale.com/ppc/sdk/fmc.git" -SRCREV = "f2e1a831a96f1d04d3d5a5970d2e54c38098cf39" - -DEPENDS = "libxml2 fmlib tclap" - -PACKAGE_ARCH = "${MACHINE_ARCH}" - -S = "${WORKDIR}/git" - -EXTRA_OEMAKE = 'FMD_USPACE_HEADER_PATH="${STAGING_INCDIR}/fmd" \ - FMD_USPACE_LIB_PATH="${STAGING_LIBDIR}" LIBXML2_HEADER_PATH="${STAGING_INCDIR}/libxml2" \ - TCLAP_HEADER_PATH="${STAGING_INCDIR}" ' -EXTRA_OEMAKE_virtclass-native = 'FMCHOSTMODE=1 FMD_USPACE_HEADER_PATH="${STAGING_INCDIR}/fmd" \ - FMD_USPACE_LIB_PATH="${STAGING_LIBDIR}" LIBXML2_HEADER_PATH="${STAGING_INCDIR}/libxml2" \ - TCLAP_HEADER_PATH="${STAGING_INCDIR}" ' - -PARALLEL_MAKE = "" - -do_compile () { - if [ "b4860qds" = "${MACHINE}" ] || [ "b4420qds" = "${MACHINE}" ];then - EXTRA_OEMAKE_PLATFORM="b4860qds" - elif [ "t4240qds" = "${MACHINE}" ] || [ "t4160qds" = "${MACHINE}" ];then - EXTRA_OEMAKE_PLATFORM="t4240qds" - elif [ "p1023rds" = "${MACHINE}" ];then - EXTRA_OEMAKE_PLATFORM="p1023rds" - else - EXTRA_OEMAKE_PLATFORM="" - fi - oe_runmake MACHINE=${EXTRA_OEMAKE_PLATFORM} -C source -} - -do_install () { - install -d ${D}/${bindir} - install -m 755 ${S}/source/fmc ${D}/${bindir}/fmc - - install -d ${D}/etc/fmc/config - install -m 644 ${S}/etc/fmc/config/hxs_pdl_v3.xml ${D}/etc/fmc/config - - install -d ${D}/${includedir}/fmc - install ${S}/source/fmc.h ${D}/${includedir}/fmc - - install -d ${D}/${libdir} - install ${S}/source/libfmc.a ${D}/${libdir} -} - -BBCLASSEXTEND = "native" diff --git a/recipes-ucode/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch b/recipes-ucode/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch deleted file mode 100644 index 4894ce3..0000000 --- a/recipes-ucode/fmlib/files/0001-fm-lib-make-the-library-install-path-configurable.patch +++ /dev/null @@ -1,43 +0,0 @@ -From 67b539d256520f95f3c8101f4605ea6d496982df Mon Sep 17 00:00:00 2001 -From: Zhenhua Luo -Date: Thu, 18 Oct 2012 17:28:00 +0300 -Subject: [PATCH] fm-lib: make the library install path configurable - -currently library for both 32bit target and 64bit target -is installed in /usr/lib folder, add a variable to make the -install path configurable - -Signed-off-by: Zhenhua Luo ---- - Makefile | 8 +++++--- - 1 file changed, 5 insertions(+), 3 deletions(-) - -diff --git a/Makefile b/Makefile -index 06fe930..d59f44a 100644 ---- a/Makefile -+++ b/Makefile -@@ -59,6 +59,8 @@ endif - - INSTALL?=install - -+LIB_DEST_DIR?=$(PREFIX)/lib -+ - # Don't forget to increment .version before doing a new release! - FM_LIB_VERSION:=$(shell cat .version) - -@@ -118,9 +120,9 @@ archive: all .version - - install-%: %.a - @(echo "Installing...") -- @($(INSTALL) -d $(DESTDIR)$(PREFIX)/lib) -- @($(INSTALL) $< $(DESTDIR)$(PREFIX)/lib) -- @(ln -s $(DESTDIR)$(PREFIX)/lib/$< $(DESTDIR)$(PREFIX)/lib/libfm.a) -+ @($(INSTALL) -d $(DESTDIR)$(LIB_DEST_DIR)) -+ @($(INSTALL) $< $(DESTDIR)$(LIB_DEST_DIR)) -+ @(ln -s $(DESTDIR)$(LIB_DEST_DIR)/$< $(DESTDIR)$(LIB_DEST_DIR)/libfm.a) - @(cp -r -p ./include $(DESTDIR)$(PREFIX)) - @($(INSTALL) -d $(DESTDIR)$(PREFIX)/share/doc/fm-lib-$(FM_LIB_VERSION)) - @($(INSTALL) $(FM_LIB_DOCFILES) $(DESTDIR)$(PREFIX)/share/doc/fm-lib-$(FM_LIB_VERSION)) --- -1.7.9.5 - diff --git a/recipes-ucode/fmlib/fmlib_git.bb b/recipes-ucode/fmlib/fmlib_git.bb deleted file mode 100644 index 7a7b8f2..0000000 --- a/recipes-ucode/fmlib/fmlib_git.bb +++ /dev/null @@ -1,43 +0,0 @@ -DESCRIPTION = "Frame Manager User Space Library" -SECTION = "fman" -LICENSE = "BSD & GPLv2" -LIC_FILES_CHKSUM = "file://COPYING;md5=3f16fa8e677e45af3127c5c4bafc3c00" - -PR = "r1" - -DEPENDS = "linux-libc-headers" -DEPENDS_virtclass-native = "" - -SRC_URI = "git://git.freescale.com/ppc/sdk/fmlib.git" -SRCREV = "7d843485bdac963d98f81773c0f3cb15936e09da" - -S = "${WORKDIR}/git" - -TARGET_ARCH_FMLIB = "${DEFAULTTUNE}" -TARGET_ARCH_FMLIB_e5500 = "ppc32e5500" -TARGET_ARCH_FMLIB_e6500 = "ppc32e6500" -COMPATIBLE_HOST_fslmachine = ".*" -COMPATIBLE_HOST ?= "(none)" - -EXTRA_OEMAKE = "DESTDIR=${D} PREFIX=${prefix} LIB_DEST_DIR=${libdir} \ - CROSS_COMPILE=${TARGET_PREFIX} KERNEL_SRC=${STAGING_EXECPREFIXDIR}" - -do_compile () { - oe_runmake libfm-${TARGET_ARCH_FMLIB}.a -} - -do_compile_virtclass-native () { -} - -do_install () { - oe_runmake install-libfm-${TARGET_ARCH_FMLIB} -} - -do_install_virtclass-native () { - install -d ${D}/${includedir} - cp -rf ${S}/include/* ${D}/${includedir} -} - -ALLOW_EMPTY_${PN} = "1" - -BBCLASSEXTEND = "native" diff --git a/recipes-virtualization/hv-cfg/hv-cfg_git.bb b/recipes-virtualization/hv-cfg/hv-cfg_git.bb new file mode 100644 index 0000000..2c6bb85 --- /dev/null +++ b/recipes-virtualization/hv-cfg/hv-cfg_git.bb @@ -0,0 +1,46 @@ +DESCRIPTION = "Hypervisor Config" +SECTION = "hv-cfg" +LICENSE = "BSD" +PR = "r6" + +LIC_FILES_CHKSUM = " \ + file://p2041rdb/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ + file://p3041ds/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ + file://p4080ds/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ + file://p5020ds/LICENSE;md5=96dd72f26e9bb861de5c76c60e35e1bc \ +" + +DEPENDS += "dtc-native" + +# this package is specific to the machine itself +INHIBIT_DEFAULT_DEPS = "1" +PACKAGE_ARCH = "${MACHINE_ARCH}" +COMPATIBLE_HOST_fslmachine = ".*" +COMPATIBLE_HOST ?= "(none)" + +inherit deploy + +SRCREV = "d037ab9d5b9ecd58e10a7dac2b601d781ed9b5bf" +SRC_URI = "git://git.freescale.com/ppc/sdk/hv-cfg.git" + +S = "${WORKDIR}/git" + +do_install () { + make install + + M=`echo ${MACHINE} | sed s/-64b//g` + install -d ${D}/boot/hv-cfg + cp -r ${S}/${M}/${M}/* ${D}/boot/hv-cfg +} + +do_deploy () { + M=`echo ${MACHINE} | sed s/-64b//g` + install -d ${DEPLOYDIR}/hv-cfg + cp -r ${S}/${M}/${M}/* ${DEPLOYDIR}/hv-cfg +} +addtask deploy after do_install + +PACKAGES += "${PN}-image" +FILES_${PN}-image += "/boot" + +ALLOW_EMPTY_${PN} = "1" diff --git a/recipes-virtualization/hypervisor/files/81-fsl-embedded-hv.rules b/recipes-virtualization/hypervisor/files/81-fsl-embedded-hv.rules new file mode 100644 index 0000000..5edfa11 --- /dev/null +++ b/recipes-virtualization/hypervisor/files/81-fsl-embedded-hv.rules @@ -0,0 +1,2 @@ +# Add rule to handle setting up device node for FSL HV mgmt driver +SUBSYSTEM=="misc", KERNEL=="fsl-hv", NAME="fsl-hv" diff --git a/recipes-virtualization/hypervisor/hypervisor_git.bb b/recipes-virtualization/hypervisor/hypervisor_git.bb new file mode 100644 index 0000000..dc86406 --- /dev/null +++ b/recipes-virtualization/hypervisor/hypervisor_git.bb @@ -0,0 +1,90 @@ +DESCRIPTION = "Freescale embedded hypervisor" +SECTION = "embedded-hv" +LICENSE = "BSD" +LIC_FILES_CHKSUM = "file://README;endline=22;md5=0655bbc3b7d7166c30c87208b4e23cf0" + +PR = "r3" + +DEPENDS = "u-boot-mkimage-native" + +inherit deploy + +S = "${WORKDIR}/git" + +# TODO: fix dtc to use the already built package +SRC_URI = " \ + git://git.freescale.com/ppc/sdk/hypervisor/hypervisor.git;name=hypervisor \ + git://git.freescale.com/ppc/sdk/hypervisor/kconfig.git;name=kconfig;destsuffix=git/kconfig \ + git://git.freescale.com/ppc/sdk/hypervisor/libos.git;name=libos;destsuffix=git/libos \ + git://www.jdl.com/software/dtc.git;name=dtc;destsuffix=dtc \ + git://git.freescale.com/ppc/sdk/hypertrk.git;name=hypertrk;destsuffix=git/hypertrk \ + file://81-fsl-embedded-hv.rules \ + " + +SRCREV_FORMAT="hypervisor" +SRCREV = "e6092cdf2a225c66c1ea46b1151eb828da29d139" +SRCREV_kconfig = "a56025d4da992b856796b0eccac2e410d751dbac" +SRCREV_libos = "5268371581f3ef3959be2a53235edfa6a8c6aa7c" +SRCREV_dtc = "033089f29099bdfd5c2d6986cdb9fd07b16cfde0" +SRCREV_hypertrk = "975c98b562186afbd3bbf103ae54b96cf9b3e533" + +EXTRA_OEMAKE = 'CROSS_COMPILE=${TARGET_PREFIX} CC="${TARGET_PREFIX}gcc ${TOOLCHAIN_OPTIONS}"' + +DEFCONFIG = "defconfig" +DEFCONFIG_powerpc64 = "64bit_defconfig" + +COMPATIBLE_HOST_fslmachine = ".*" +COMPATIBLE_HOST ?= "(none)" + +inherit cml1 +do_configure () { + oe_runmake ${DEFCONFIG} +} + +PKG_HV_HYPERTRK_SUPPORT = "n" +do_compile () { + if [ "${PKG_HV_HYPERTRK_SUPPORT}" = "y" ] + then + oe_runmake silentoldconfig + export HV_DIR=$PWD + cd hypertrk + oe_runmake deploy + cd .. + fi + + oe_runmake + oe_runmake partman +} + +do_install () { + install -d ${D}/${bindir} + install ${S}/output/bin/linux/partman ${D}/${bindir}/partman + + install -d ${D}${sysconfdir}/udev/rules.d + install -m 0644 ${WORKDIR}/81-fsl-embedded-hv.rules ${D}${sysconfdir}/udev/rules.d + + install -d ${D}/boot/hv + install ${S}/output/.config ${D}/boot/hv/hypervisor.config + install -m 644 ${S}/output/bin/hv ${S}/output/bin/hv.map \ + ${S}/output/bin/hv.uImage ${S}/output/bin/hv.bin \ + ${D}/boot/hv/ +} + +do_deploy () { + install -d ${DEPLOYDIR}/hv/ + install ${S}/output/.config ${DEPLOYDIR}/hv/hypervisor.config + install -m 644 ${S}/output/bin/hv ${S}/output/bin/hv.map \ + ${S}/output/bin/hv.uImage ${S}/output/bin/hv.bin \ + ${DEPLOYDIR}/hv/ +} +addtask deploy before do_build after do_install + +do_deploy_append() { + rm -f ${S}/../hv +} + +INHIBIT_PACKAGE_DEBUG_SPLIT = "1" +ALLOW_EMPTY_${PN} = "1" +PACKAGES_prepend = "${PN}-image ${PN}-partman " +FILES_${PN}-image = "/boot/" +FILES_${PN}-partman = "${bindir}/partman" diff --git a/recipes-virtualization/mux-server/files/mux-server-1.02.tar.gz b/recipes-virtualization/mux-server/files/mux-server-1.02.tar.gz new file mode 100644 index 0000000..d8f2014 Binary files /dev/null and b/recipes-virtualization/mux-server/files/mux-server-1.02.tar.gz differ diff --git a/recipes-virtualization/mux-server/mux-server_1.02.bb b/recipes-virtualization/mux-server/mux-server_1.02.bb new file mode 100644 index 0000000..ab9cce1 --- /dev/null +++ b/recipes-virtualization/mux-server/mux-server_1.02.bb @@ -0,0 +1,16 @@ +DESCRIPTION = "A Linux-based utility supporting console multiplexing and demultiplexing" +SECTION = "mux-server" +LICENSE = "LGPL-2.1" +# TODO: add a dedicated COPYING file +LIC_FILES_CHKSUM = "file://mux_server.c;endline=9;md5=e59eeb0812bb88b7af2d932f2dc22aed" + +SRC_URI = "file://mux-server-${PV}.tar.gz;name=mux_server" + +EXTRA_OEMAKE='HOSTCC="${CC}"' + +do_install () { + install -d ${D}${bindir} + install -m 755 mux_server ${D}${bindir} +} + +BBCLASSEXTEND = "native nativesdk" -- cgit v1.2.3-54-g00ecf