[
{
"path": ".cargo/config.toml",
"content": "[build]\ntarget-dir = \"build\"\n"
},
{
"path": ".devcontainer/Dockerfile",
"content": "FROM library/node:lts-bookworm\n\nARG DEBIAN_FRONTEND=noninteractive\nRUN apt update && \\\n apt-get install -y nodejs nasm gdb unzip p7zip-full openjdk-17-jre wget python3 qemu-system-x86 git-core build-essential libc6-dev-i386-cross libc6-dev-i386 clang curl time\nRUN npm install -g jshint\nRUN curl https://sh.rustup.rs -sSf | sh -s -- -y\nRUN /root/.cargo/bin/rustup toolchain install stable && \\\n /root/.cargo/bin/rustup target add wasm32-unknown-unknown && \\\n /root/.cargo/bin/rustup component add rustfmt-preview && \\\n /root/.cargo/bin/rustup update && /root/.cargo/bin/rustup update nightly\n"
},
{
"path": ".devcontainer/devcontainer.json",
"content": "{\n\t\"name\": \"v86 dev container\",\n\t\"build\": {\n\t\t\"dockerfile\": \"Dockerfile\",\n\t\t\"args\": {\n\t\t\t\"VARIANT\": \"ubuntu\"\n\t\t}\n\t},\n\t\"features\": {\n\t\t\"ghcr.io/devcontainers-contrib/features/curl-apt-get:1\": {},\n\t\t\"ghcr.io/jungaretti/features/ripgrep:1\": {}\n\t},\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-azuretools.vscode-docker\",\n\t\t\t\t\"yzhang.markdown-all-in-one\",\n\t\t\t\t\"DavidAnson.vscode-markdownlint\",\n\t\t\t\t\"christian-kohler.npm-intellisense\",\n\t\t\t\t\"dbaeumer.vscode-eslint\",\n\t\t\t\t\"dustypomerleau.rust-syntax\",\n\t\t\t\t\"serayuzgur.crates\",\n\t\t\t\t\"ms-vscode.makefile-tools\",\n\t\t\t\t\"rust-lang.rust-analyzer\"\n\t\t\t]\n\t\t}\n\t}\n}"
},
{
"path": ".editorconfig",
"content": "root=true\n\n[*.js]\ncharset = utf-8\nindent_style = space\nindent_size = 4\n"
},
{
"path": ".gitattributes",
"content": "lib/zstd/* linguist-vendored\nlib/softfloat/* linguist-vendored\n"
},
{
"path": ".github/ISSUE_TEMPLATE/issue.md",
"content": "---\nname: Issue\nabout: Bug reports or feature requests\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n\n"
},
{
"path": ".github/workflows/ci.yml",
"content": "name: CI\n\non:\n push:\n pull_request:\n\njobs:\n eslint:\n name: eslint\n runs-on: ubuntu-latest\n steps:\n - name: Checkout repository\n uses: actions/checkout@v4\n\n - name: Run eslint\n run: sudo npm install -g eslint; make eslint\n\n test:\n runs-on: ubuntu-latest\n name: Build and test\n timeout-minutes: 60\n steps:\n - name: Checkout repository\n uses: actions/checkout@v4\n with:\n fetch-depth: 0\n filter: tree:0\n\n - name: Setup Node.js version\n uses: actions/setup-node@v4\n with:\n node-version: '20'\n check-latest: true\n registry-url: 'https://registry.npmjs.org'\n\n - name: Setup toolchain\n run: |\n rustup toolchain install stable --profile minimal\n rustup target add wasm32-unknown-unknown\n rustup component add rustfmt\n\n - name: Install APT packages\n run: |\n sudo apt-get update -y\n sudo apt-get install nasm gdb qemu-system-x86 libc6-dev-i386 -y\n\n - name: Build all-debug\n run: make all-debug\n\n - name: Build all\n run: make all\n\n - name: Build fallback\n run: make build/v86-fallback.wasm\n\n - name: rustfmt check\n run: make rustfmt\n\n - name: Fetch kvm-unit-test cache\n uses: actions/cache@v4\n id: cache-kvm-unit-test\n with:\n path: tests/kvm-unit-tests/\n key: ${{ runner.os }}-kvm-unit-test\n\n - name: Build kvm-unit-test\n if: steps.cache-kvm-unit-test.outputs.cache-hit != 'true'\n run: (cd tests/kvm-unit-tests && ./configure && make x86/realmode.flat)\n\n - name: Run kvm-unit-test\n run: tests/kvm-unit-tests/run.mjs tests/kvm-unit-tests/x86/realmode.flat\n\n - name: Fetch namsmtests cache\n uses: actions/cache@v4\n id: cache-nasmtests\n with:\n path: tests/nasm/build/\n key: ${{ runner.os }}-nasmtests\n\n - name: Run nasmtests\n run: MAX_PARALLEL_TESTS=1 make nasmtests\n\n - name: Run nasmtests-force-jit\n run: MAX_PARALLEL_TESTS=1 make nasmtests-force-jit\n\n - name: Run rust-test\n run: make rust-test\n\n - name: Fetch image cache\n uses: actions/cache@v4\n id: cache-images\n with:\n path: images/\n key: ${{ runner.os }}-images-v2\n\n - name: Download uncached images\n if: steps.cache-images.outputs.cache-hit != 'true'\n run: mkdir -p images && curl --compressed --output-dir images --remote-name-all https://i.copy.sh/{linux.iso,linux3.iso,linux4.iso,buildroot-bzimage68.bin,TinyCore-11.0.iso,oberon.img,msdos.img,openbsd-floppy.img,kolibri.img,windows101.img,os8.img,freedos722.img,mobius-fd-release5.img,msdos622.img}\n\n - name: Run api-tests\n run: make api-tests\n\n - name: Run qemutests\n run: make qemutests\n\n - name: Run qemutests-release\n run: make qemutests-release\n\n - name: Run jitpagingtests\n run: make jitpagingtests\n\n - name: Run integration tests\n run: MAX_PARALLEL_TESTS=1 make tests\n\n - name: Run devices tests\n run: make devices-test\n\n - name: Run expect tests\n run: make expect-tests\n\n - name: Update package.json version\n run: make update-package-json-version\n\n - name: Upload the artifact\n uses: actions/upload-artifact@v4\n with:\n name: v86\n path: |\n package.json\n LICENSE\n Readme.md\n build/libv86*.js\n build/libv86*.js.map\n build/v86*.wasm\n build/*.mjs\n\n upload:\n name: Upload release\n runs-on: ubuntu-latest\n needs: test\n if: github.ref == 'refs/heads/master'\n\n permissions:\n id-token: write\n contents: write\n\n steps:\n - name: Delete old release and tag\n uses: dev-drprasad/delete-tag-and-release@v1.0.1\n with:\n delete_release: true\n tag_name: latest\n github_token: ${{ secrets.GITHUB_TOKEN }}\n\n - name: Get artifacts\n uses: actions/download-artifact@v4\n with:\n name: v86\n\n - name: Display structure of downloaded files\n run: ls -R\n\n - uses: actions/setup-node@v4\n with:\n node-version: '20.x'\n registry-url: 'https://registry.npmjs.org'\n\n - name: Release to GitHub\n uses: ncipollo/release-action@v1\n with:\n name: Latest Release\n tag: latest\n commit: master\n body: ${{ github.event.head_commit.message }}\n artifacts: \"build/libv86*.js,build/libv86*.js.map,build/*.mjs,build/v86*.wasm\"\n prerelease: true\n\n - run: npm publish --provenance --access public\n env:\n NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}\n"
},
{
"path": ".gitignore",
"content": "*.swp\n*.swo\ntests/qemu/test-i386\ntests/jit-paging/test-jit\n*.map\nbuild/\nclosure-compiler/\nimages/\n*.bak\n*.orig\n*.wasm\n*.o\n*.bin\n*.img\n*.fixture\n*.fuse_hidden*\n*.DS_Store\nnode_modules/\nCargo.lock\nbuild-head\nsrc/rust/gen/interpreter.rs\nsrc/rust/gen/interpreter0f.rs\nsrc/rust/gen/analyzer.rs\nsrc/rust/gen/analyzer0f.rs\nsrc/rust/gen/jit.rs\nsrc/rust/gen/jit0f.rs\nbios/seabios\nbench-results\n"
},
{
"path": ".rustfmt.toml",
"content": "use_field_init_shorthand = true\nmatch_block_trailing_comma = true\nfn_single_line = true\nimports_indent = \"Block\"\ncontrol_brace_style = \"ClosingNextLine\"\nsingle_line_if_else_max_width = 92\n"
},
{
"path": ".vscode/tasks.json",
"content": "{\n // See https://go.microsoft.com/fwlink/?LinkId=733558\n // for the documentation about the tasks.json format\n \"version\": \"2.0.0\",\n \"tasks\": [\n {\n \"label\": \"Fetch images\",\n \"type\": \"shell\",\n \"command\": \"wget -P images/ https://i.copy.sh/{linux3.iso,linux.iso,linux4.iso,buildroot-bzimage.bin,openbsd-floppy.img,kolibri.img,windows101.img,os8.img,freedos722.img}\"\n }\n ]\n}\n"
},
{
"path": "Cargo.toml",
"content": "[package]\nname = \"v86\"\nversion = \"0.1.0\"\npublish = false\nedition = \"2021\"\n\n[features]\ndefault = []\nprofiler = []\n\n[lib]\ncrate-type = [\"cdylib\"]\npath = \"src/rust/lib.rs\"\n\n[profile.test]\nlto = false\nopt-level = 2\noverflow-checks = false\n\n[profile.dev]\nlto = true\nopt-level = 2\npanic = \"abort\"\noverflow-checks = false\n\n[profile.release]\nlto = true\nopt-level = 3\nincremental = false\npanic = \"abort\"\n"
},
{
"path": "LICENSE",
"content": "Copyright (c) 2012, The v86 contributors\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "LICENSE.MIT",
"content": "QEMU Floppy disk emulator (Intel 82078)\n\nCopyright (c) 2003, 2007 Jocelyn Mayer\nCopyright (c) 2008 Hervé Poussineau\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\nTHE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n"
},
{
"path": "Makefile",
"content": "CLOSURE_DIR=closure-compiler\nCLOSURE=$(CLOSURE_DIR)/compiler.jar\nNASM_TEST_DIR=./tests/nasm\n\nINSTRUCTION_TABLES=src/rust/gen/jit.rs src/rust/gen/jit0f.rs \\\n\t\t src/rust/gen/interpreter.rs src/rust/gen/interpreter0f.rs \\\n\t\t src/rust/gen/analyzer.rs src/rust/gen/analyzer0f.rs \\\n\n# Only the dependencies common to both generate_{jit,interpreter}.js\nGEN_DEPENDENCIES=$(filter-out gen/generate_interpreter.js gen/generate_jit.js gen/generate_analyzer.js, $(wildcard gen/*.js))\nJIT_DEPENDENCIES=$(GEN_DEPENDENCIES) gen/generate_jit.js\nINTERPRETER_DEPENDENCIES=$(GEN_DEPENDENCIES) gen/generate_interpreter.js\nANALYZER_DEPENDENCIES=$(GEN_DEPENDENCIES) gen/generate_analyzer.js\n\nSTRIP_DEBUG_FLAG=\nifeq ($(STRIP_DEBUG),true)\nSTRIP_DEBUG_FLAG=--v86-strip-debug\nendif\n\nWASM_OPT ?= false\n\ndefault: build/v86-debug.wasm\nall: build/v86_all.js build/libv86.js build/libv86.mjs build/v86.wasm\nall-debug: build/libv86-debug.js build/libv86-debug.mjs build/v86-debug.wasm\nbrowser: build/v86_all.js\n\n# Used for nodejs builds and in order to profile code.\n# `debug` gives identifiers a readable name, make sure it doesn't have any side effects.\nCLOSURE_READABLE=--formatting PRETTY_PRINT --debug\n\nCLOSURE_SOURCE_MAP=\\\n\t\t--source_map_format V3\\\n\t\t--create_source_map '%outname%.map'\n\nCLOSURE_FLAGS=\\\n\t\t--generate_exports\\\n\t\t--externs src/externs.js\\\n\t\t--warning_level VERBOSE\\\n\t\t--jscomp_error accessControls\\\n\t\t--jscomp_error checkRegExp\\\n\t\t--jscomp_error checkTypes\\\n\t\t--jscomp_error checkVars\\\n\t\t--jscomp_error conformanceViolations\\\n\t\t--jscomp_error const\\\n\t\t--jscomp_error constantProperty\\\n\t\t--jscomp_error deprecated\\\n\t\t--jscomp_error deprecatedAnnotations\\\n\t\t--jscomp_error duplicateMessage\\\n\t\t--jscomp_error es5Strict\\\n\t\t--jscomp_error externsValidation\\\n\t\t--jscomp_error globalThis\\\n\t\t--jscomp_error invalidCasts\\\n\t\t--jscomp_error misplacedTypeAnnotation\\\n\t\t--jscomp_error missingProperties\\\n\t\t--jscomp_error missingReturn\\\n\t\t--jscomp_error msgDescriptions\\\n\t\t--jscomp_error nonStandardJsDocs\\\n\t\t--jscomp_error suspiciousCode\\\n\t\t--jscomp_error strictModuleDepCheck\\\n\t\t--jscomp_error typeInvalidation\\\n\t\t--jscomp_error undefinedVars\\\n\t\t--jscomp_error unknownDefines\\\n\t\t--jscomp_error visibility\\\n\t\t--use_types_for_optimization\\\n\t\t--assume_function_wrapper\\\n\t\t--summary_detail_level 3\\\n\t\t--language_in ECMASCRIPT_2020\\\n\t\t--language_out ECMASCRIPT_2020\n\nCARGO_FLAGS_SAFE=\\\n\t\t--target wasm32-unknown-unknown \\\n\t\t-- \\\n\t\t-C linker=tools/rust-lld-wrapper \\\n\t\t-C link-args=\"--import-table --global-base=4096 $(STRIP_DEBUG_FLAG)\" \\\n\t\t-C link-args=\"build/softfloat.o\" \\\n\t\t-C link-args=\"build/zstddeclib.o\" \\\n\t\t--verbose\n\nCARGO_FLAGS=$(CARGO_FLAGS_SAFE) -C target-feature=+bulk-memory -C target-feature=+multivalue -C target-feature=+simd128\n\nCORE_FILES=cjs.js const.js io.js main.js lib.js buffer.js ide.js pci.js floppy.js \\\n\t dma.js pit.js vga.js ps2.js rtc.js uart.js \\\n\t acpi.js iso9660.js \\\n\t state.js ne2k.js sb16.js virtio.js virtio_console.js virtio_net.js virtio_balloon.js \\\n\t bus.js log.js cpu.js \\\n\t elf.js kernel.js\nLIB_FILES=9p.js filesystem.js marshall.js\nBROWSER_FILES=screen.js keyboard.js mouse.js speaker.js serial.js \\\n\t network.js starter.js worker_bus.js dummy_screen.js \\\n\t inbrowser_network.js fake_network.js wisp_network.js fetch_network.js \\\n print_stats.js filestorage.js\n\nRUST_FILES=$(shell find src/rust/ -name '*.rs') \\\n\t src/rust/gen/interpreter.rs src/rust/gen/interpreter0f.rs \\\n\t src/rust/gen/jit.rs src/rust/gen/jit0f.rs \\\n\t src/rust/gen/analyzer.rs src/rust/gen/analyzer0f.rs\n\nCORE_FILES:=$(addprefix src/,$(CORE_FILES))\nLIB_FILES:=$(addprefix lib/,$(LIB_FILES))\nBROWSER_FILES:=$(addprefix src/browser/,$(BROWSER_FILES))\n\nbuild/v86_all.js: $(CLOSURE) src/*.js src/browser/*.js lib/*.js\n\tmkdir -p build\n\t-ls -lh build/v86_all.js\n\tjava -jar $(CLOSURE) \\\n\t\t--js_output_file build/v86_all.js\\\n\t\t--define=DEBUG=false\\\n\t\t$(CLOSURE_SOURCE_MAP)\\\n\t\t$(CLOSURE_FLAGS)\\\n\t\t--compilation_level ADVANCED\\\n\t\t--js $(CORE_FILES)\\\n\t\t--js $(LIB_FILES)\\\n\t\t--js $(BROWSER_FILES)\\\n\t\t--js src/browser/main.js\n\tls -lh build/v86_all.js\n\nbuild/v86_all_debug.js: $(CLOSURE) src/*.js src/browser/*.js lib/*.js\n\tmkdir -p build\n\tjava -jar $(CLOSURE) \\\n\t\t--js_output_file build/v86_all_debug.js\\\n\t\t--define=DEBUG=true\\\n\t\t$(CLOSURE_SOURCE_MAP)\\\n\t\t$(CLOSURE_FLAGS)\\\n\t\t--compilation_level ADVANCED\\\n\t\t--js $(CORE_FILES)\\\n\t\t--js $(LIB_FILES)\\\n\t\t--js $(BROWSER_FILES)\\\n\t\t--js src/browser/main.js\n\nbuild/libv86.js: $(CLOSURE) src/*.js lib/*.js src/browser/*.js\n\tmkdir -p build\n\t-ls -lh build/libv86.js\n\tjava -jar $(CLOSURE) \\\n\t\t--js_output_file build/libv86.js\\\n\t\t--define=DEBUG=false\\\n\t\t$(CLOSURE_FLAGS)\\\n\t\t--compilation_level SIMPLE\\\n\t\t--jscomp_off=missingProperties\\\n\t\t--output_wrapper ';(function(){%output%}).call(this);'\\\n\t\t--js $(CORE_FILES)\\\n\t\t--js $(BROWSER_FILES)\\\n\t\t--js $(LIB_FILES)\n\tls -lh build/libv86.js\n\nbuild/libv86.mjs: $(CLOSURE) src/*.js lib/*.js src/browser/*.js\n\tmkdir -p build\n\t-ls -lh build/libv86.js\n\tjava -jar $(CLOSURE) \\\n\t\t--js_output_file build/libv86.mjs\\\n\t\t--define=DEBUG=false\\\n\t\t$(CLOSURE_FLAGS)\\\n\t\t--compilation_level SIMPLE\\\n\t\t--jscomp_off=missingProperties\\\n\t\t--output_wrapper ';let module = {exports:{}}; %output%; export default module.exports.V86; export let {V86, CPU} = module.exports;'\\\n\t\t--js $(CORE_FILES)\\\n\t\t--js $(BROWSER_FILES)\\\n\t\t--js $(LIB_FILES)\\\n\t\t--chunk_output_type=ES_MODULES\\\n\t\t--emit_use_strict=false\n\tls -lh build/libv86.mjs\n\nbuild/libv86-debug.js: $(CLOSURE) src/*.js lib/*.js src/browser/*.js\n\tmkdir -p build\n\tjava -jar $(CLOSURE) \\\n\t\t--js_output_file build/libv86-debug.js\\\n\t\t--define=DEBUG=true\\\n\t\t$(CLOSURE_FLAGS)\\\n\t\t$(CLOSURE_READABLE)\\\n\t\t--compilation_level SIMPLE\\\n\t\t--jscomp_off=missingProperties\\\n\t\t--output_wrapper ';(function(){%output%}).call(this);'\\\n\t\t--js $(CORE_FILES)\\\n\t\t--js $(BROWSER_FILES)\\\n\t\t--js $(LIB_FILES)\n\tls -lh build/libv86-debug.js\n\nbuild/libv86-debug.mjs: $(CLOSURE) src/*.js lib/*.js src/browser/*.js\n\tmkdir -p build\n\tjava -jar $(CLOSURE) \\\n\t\t--js_output_file build/libv86-debug.mjs\\\n\t\t--define=DEBUG=true\\\n\t\t$(CLOSURE_FLAGS)\\\n\t\t$(CLOSURE_READABLE)\\\n\t\t--compilation_level SIMPLE\\\n\t\t--jscomp_off=missingProperties\\\n\t\t--output_wrapper ';let module = {exports:{}}; %output%; export default module.exports.V86; export let {V86, CPU} = module.exports;'\\\n\t\t--js $(CORE_FILES)\\\n\t\t--js $(BROWSER_FILES)\\\n\t\t--js $(LIB_FILES)\\\n\t\t--chunk_output_type=ES_MODULES\\\n\t\t--emit_use_strict=false\n\tls -lh build/libv86-debug.mjs\n\nsrc/rust/gen/jit.rs: $(JIT_DEPENDENCIES)\n\t./gen/generate_jit.js --output-dir build/ --table jit\nsrc/rust/gen/jit0f.rs: $(JIT_DEPENDENCIES)\n\t./gen/generate_jit.js --output-dir build/ --table jit0f\n\nsrc/rust/gen/interpreter.rs: $(INTERPRETER_DEPENDENCIES)\n\t./gen/generate_interpreter.js --output-dir build/ --table interpreter\nsrc/rust/gen/interpreter0f.rs: $(INTERPRETER_DEPENDENCIES)\n\t./gen/generate_interpreter.js --output-dir build/ --table interpreter0f\n\nsrc/rust/gen/analyzer.rs: $(ANALYZER_DEPENDENCIES)\n\t./gen/generate_analyzer.js --output-dir build/ --table analyzer\nsrc/rust/gen/analyzer0f.rs: $(ANALYZER_DEPENDENCIES)\n\t./gen/generate_analyzer.js --output-dir build/ --table analyzer0f\n\nbuild/v86.wasm: $(RUST_FILES) build/softfloat.o build/zstddeclib.o Cargo.toml\n\tmkdir -p build/\n\t-BLOCK_SIZE=K ls -l build/v86.wasm\n\tcargo rustc --release $(CARGO_FLAGS)\n\tcp build/wasm32-unknown-unknown/release/v86.wasm build/v86.wasm\n\t-$(WASM_OPT) && wasm-opt -O2 --strip-debug build/v86.wasm -o build/v86.wasm\n\tBLOCK_SIZE=K ls -l build/v86.wasm\n\nbuild/v86-debug.wasm: $(RUST_FILES) build/softfloat.o build/zstddeclib.o Cargo.toml\n\tmkdir -p build/\n\t-BLOCK_SIZE=K ls -l build/v86-debug.wasm\n\tcargo rustc $(CARGO_FLAGS)\n\tcp build/wasm32-unknown-unknown/debug/v86.wasm build/v86-debug.wasm\n\tBLOCK_SIZE=K ls -l build/v86-debug.wasm\n\nbuild/v86-fallback.wasm: $(RUST_FILES) build/softfloat.o build/zstddeclib.o Cargo.toml\n\tmkdir -p build/\n\tcargo rustc --release $(CARGO_FLAGS_SAFE)\n\tcp build/wasm32-unknown-unknown/release/v86.wasm build/v86-fallback.wasm || true\n\ndebug-with-profiler: $(RUST_FILES) build/softfloat.o build/zstddeclib.o Cargo.toml\n\tmkdir -p build/\n\tcargo rustc --features profiler $(CARGO_FLAGS)\n\tcp build/wasm32-unknown-unknown/debug/v86.wasm build/v86-debug.wasm || true\n\nwith-profiler: $(RUST_FILES) build/softfloat.o build/zstddeclib.o Cargo.toml\n\tmkdir -p build/\n\tcargo rustc --release --features profiler $(CARGO_FLAGS)\n\tcp build/wasm32-unknown-unknown/release/v86.wasm build/v86.wasm || true\n\nwatch:\n\tcargo watch -x 'rustc $(CARGO_FLAGS)' -s 'cp build/wasm32-unknown-unknown/debug/v86.wasm build/v86-debug.wasm'\n\nbuild/softfloat.o: lib/softfloat/softfloat.c\n\tmkdir -p build\n\tclang -c -Wall \\\n\t --target=wasm32 -O3 -flto -nostdlib -fvisibility=hidden -ffunction-sections -fdata-sections \\\n\t -DSOFTFLOAT_FAST_INT64 -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 -DSOFTFLOAT_FAST_DIV64TO32 \\\n\t -o build/softfloat.o \\\n\t lib/softfloat/softfloat.c\n\nbuild/zstddeclib.o: lib/zstd/zstddeclib.c\n\tmkdir -p build\n\tclang -c -Wall \\\n\t --target=wasm32 -O3 -flto -nostdlib -fvisibility=hidden -ffunction-sections -fdata-sections \\\n\t -DZSTDLIB_VISIBILITY=\"\" \\\n\t -o build/zstddeclib.o \\\n\t lib/zstd/zstddeclib.c\n\nclean:\n\t-rm build/libv86.js\n\t-rm build/libv86.mjs\n\t-rm build/libv86-debug.js\n\t-rm build/libv86-debug.mjs\n\t-rm build/v86_all.js\n\t-rm build/v86.wasm\n\t-rm build/v86-debug.wasm\n\t-rm $(INSTRUCTION_TABLES)\n\t-rm build/*.map\n\t-rm build/*.wast\n\t-rm build/*.o\n\t$(MAKE) -C $(NASM_TEST_DIR) clean\n\nrun:\n\tpython3 -m http.server 2> /dev/null\n\nupdate_version:\n\tset -e ;\\\n\tCOMMIT=`git log --format=\"%h\" -n 1` ;\\\n\tDATE=`git log --date=\"format:%b %e, %Y %H:%m\" --format=\"%cd\" -n 1` ;\\\n\tSEARCH='Version: [a-f0-9]\\+ ([^(]\\+)' ;\\\n\tREPLACE='Version: '$$COMMIT' ('$$DATE')' ;\\\n\tsed -i \"s@$$SEARCH@$$REPLACE@g\" index.html ;\\\n\tSEARCH='' ;\\\n\tREPLACE='' ;\\\n\tsed -i \"s@$$SEARCH@$$REPLACE@g\" index.html ;\\\n\tgrep $$COMMIT index.html\n\n\n$(CLOSURE):\n\tmkdir -p $(CLOSURE_DIR)\n\t# don't upgrade until https://github.com/google/closure-compiler/issues/3972 is fixed\n\twget -nv -O $(CLOSURE) https://repo1.maven.org/maven2/com/google/javascript/closure-compiler/v20210601/closure-compiler-v20210601.jar\n\nbuild/integration-test-fs/fs.json: images/buildroot-bzimage68.bin\n\tmkdir -p build/integration-test-fs/flat\n\tcp images/buildroot-bzimage68.bin build/integration-test-fs/bzImage\n\ttouch build/integration-test-fs/initrd\n\tcd build/integration-test-fs && tar cfv fs.tar bzImage initrd\n\t./tools/fs2json.py build/integration-test-fs/fs.tar --out build/integration-test-fs/fs.json\n\t./tools/copy-to-sha256.py build/integration-test-fs/fs.tar build/integration-test-fs/flat\n\trm build/integration-test-fs/fs.tar build/integration-test-fs/bzImage build/integration-test-fs/initrd\n\ntests: build/v86-debug.wasm build/integration-test-fs/fs.json\n\tLOG_LEVEL=3 ./tests/full/run.js\n\ntests-release: build/libv86.js build/v86.wasm build/integration-test-fs/fs.json\n\tTEST_RELEASE_BUILD=1 ./tests/full/run.js\n\nnasmtests: build/v86-debug.wasm\n\t$(NASM_TEST_DIR)/create_tests.js\n\t$(NASM_TEST_DIR)/gen_fixtures.js\n\t$(NASM_TEST_DIR)/run.js\n\nnasmtests-force-jit: build/v86-debug.wasm\n\t$(NASM_TEST_DIR)/create_tests.js\n\t$(NASM_TEST_DIR)/gen_fixtures.js\n\t$(NASM_TEST_DIR)/run.js --force-jit\n\njitpagingtests: build/v86-debug.wasm\n\t$(MAKE) -C tests/jit-paging test-jit\n\t./tests/jit-paging/run.js\n\nqemutests: build/v86-debug.wasm\n\t$(MAKE) -C tests/qemu test-i386\n\tLOG_LEVEL=3 ./tests/qemu/run.js build/qemu-test-result\n\t./tests/qemu/run-qemu.js > build/qemu-test-reference\n\tdiff build/qemu-test-result build/qemu-test-reference\n\nqemutests-release: build/libv86.mjs build/v86.wasm\n\t$(MAKE) -C tests/qemu test-i386\n\tTEST_RELEASE_BUILD=1 time ./tests/qemu/run.js build/qemu-test-result\n\t./tests/qemu/run-qemu.js > build/qemu-test-reference\n\tdiff build/qemu-test-result build/qemu-test-reference\n\nkvm-unit-test: build/v86-debug.wasm\n\t(cd tests/kvm-unit-tests && ./configure && make x86/realmode.flat)\n\ttests/kvm-unit-tests/run.mjs tests/kvm-unit-tests/x86/realmode.flat\n\nkvm-unit-test-release: build/libv86.mjs build/v86.wasm\n\t(cd tests/kvm-unit-tests && ./configure && make x86/realmode.flat)\n\tTEST_RELEASE_BUILD=1 tests/kvm-unit-tests/run.mjs tests/kvm-unit-tests/x86/realmode.flat\n\nexpect-tests: build/v86-debug.wasm build/libwabt.cjs\n\tmake -C tests/expect/tests\n\t./tests/expect/run.js\n\ndevices-test: build/v86-debug.wasm\n\t./tests/devices/virtio_9p.js\n\t./tests/devices/virtio_console.js\n\t./tests/devices/fetch_network.js\n\tUSE_VIRTIO=1 ./tests/devices/fetch_network.js\n\t./tests/devices/wisp_network.js\n\t./tests/devices/virtio_balloon.js\n\nrust-test: $(RUST_FILES)\n\tenv RUSTFLAGS=\"-D warnings\" RUST_BACKTRACE=full RUST_TEST_THREADS=1 cargo test -- --nocapture\n\t./tests/rust/verify-wasmgen-dummy-output.js\n\nrust-test-intensive:\n\tQUICKCHECK_TESTS=100000000 make rust-test\n\napi-tests: build/v86-debug.wasm\n\t./tests/api/clean-shutdown.js\n\t./tests/api/state.js\n\t./tests/api/reset.js\n\t./tests/api/floppy.js\n\t./tests/api/cdrom-insert-eject.js\n\t./tests/api/serial.js\n\t./tests/api/reboot.js\n\t./tests/api/pic.js\n\nall-tests: eslint kvm-unit-test qemutests qemutests-release jitpagingtests api-tests nasmtests nasmtests-force-jit rust-test tests expect-tests\n\t# Skipping:\n\t# - devices-test (hangs)\n\neslint:\n\teslint src tests gen lib examples tools\n\nrustfmt: $(RUST_FILES)\n\tcargo fmt --all -- --check --config fn_single_line=true,control_brace_style=ClosingNextLine\n\nbuild/capstone-x86.min.js:\n\tmkdir -p build\n\twget -nv -P build https://github.com/AlexAltea/capstone.js/releases/download/v3.0.5-rc1/capstone-x86.min.js\n\nbuild/libwabt.cjs:\n\tmkdir -p build\n\twget -nv -P build https://github.com/WebAssembly/wabt/archive/1.0.6.zip\n\tunzip -j -d build/ build/1.0.6.zip wabt-1.0.6/demo/libwabt.js\n\tmv build/libwabt.js build/libwabt.cjs\n\trm build/1.0.6.zip\n\nbuild/xterm.js:\n\tcurl https://cdn.jsdelivr.net/npm/xterm@5.2.1/lib/xterm.min.js > build/xterm.js\n\tcurl https://cdn.jsdelivr.net/npm/xterm@5.2.1/lib/xterm.js.map > build/xterm.js.map\n\tcurl https://cdn.jsdelivr.net/npm/xterm@5.2.1/css/xterm.css > build/xterm.css\n\nupdate-package-json-version:\n\tgit describe --tags --exclude latest | sed 's/-/./' | tr - + | tee build/version\n\tjq --arg version \"$$(cat build/version)\" '.version = $$version' package.json > package.json.tmp\n\tmv package.json.tmp package.json\n"
},
{
"path": "Readme.md",
"content": "[](https://gitter.im/copy/v86) or #v86 on [irc.libera.chat](https://libera.chat/)\n\nv86 emulates an x86-compatible CPU and hardware. Machine code is translated to\nWebAssembly modules at runtime in order to achieve decent performance. Here's a\nlist of emulated hardware:\n\n- An x86-compatible CPU. The instruction set is around Pentium 4 level,\n including full SSE3 support. Some features are missing, in particular:\n - Task gates, far calls in protected mode\n - Some 16 bit protected mode features\n - Single stepping (trap flag, debug registers)\n - Some exceptions, especially floating point and SSE\n - Multicore\n - 64-bit extensions\n- A floating point unit (FPU). Calculations are done using the Berkeley\n SoftFloat library and therefore should be precise (but slow). Trigonometric\n and log functions are emulated using 64-bit floats and may be less precise.\n Not all FPU exceptions are supported.\n- A floppy disk controller (8272A).\n- An 8042 Keyboard Controller, PS2. With mouse support.\n- An 8254 Programmable Interval Timer (PIT).\n- An 8259 Programmable Interrupt Controller (PIC).\n- Partial APIC support.\n- A CMOS Real Time Clock (RTC).\n- A generic VGA card with SVGA support and Bochs VBE Extensions.\n- A PCI bus. This one is partly incomplete and not used by every device.\n- An IDE disk controller.\n - A built-in ISO 9660 CD-ROM generator.\n- An NE2000 (RTL8390) PCI network card.\n- Various virtio devices: Filesystem, network and balloon.\n- A SoundBlaster 16 sound card.\n\n## Demos\n\n[9front](https://copy.sh/v86/?profile=9front) —\n[Arch Linux](https://copy.sh/v86/?profile=archlinux) —\n[Android-x86 1.6-r2](https://copy.sh/v86?profile=android) —\n[Android-x86 4.4-r2](https://copy.sh/v86?profile=android4) —\n[BasicLinux](https://copy.sh/v86/?profile=basiclinux) —\n[Buildroot Linux](https://copy.sh/v86/?profile=buildroot) —\n[Damn Small Linux](https://copy.sh/v86/?profile=dsl) —\n[ELKS](https://copy.sh/v86/?profile=elks) —\n[FreeDOS](https://copy.sh/v86/?profile=freedos) —\n[FreeBSD](https://copy.sh/v86/?profile=freebsd) —\n[FiwixOS](https://copy.sh/v86/?profile=fiwix) —\n[Haiku](https://copy.sh/v86/?profile=haiku) —\n[SkiffOS](https://copy.sh/v86/?profile=copy/skiffos) —\n[ReactOS](https://copy.sh/v86/?profile=reactos) —\n[Windows 2000](https://copy.sh/v86/?profile=windows2000) —\n[Windows 98](https://copy.sh/v86/?profile=windows98) —\n[Windows 95](https://copy.sh/v86/?profile=windows95) —\n[Windows 1.01](https://copy.sh/v86/?profile=windows1) —\n[MS-DOS 6.22](https://copy.sh/v86/?profile=msdos) —\n[OpenBSD](https://copy.sh/v86/?profile=openbsd) —\n[Oberon](https://copy.sh/v86/?profile=oberon) —\n[KolibriOS](https://copy.sh/v86/?profile=kolibrios) —\n[SkiftOS](https://copy.sh/v86?profile=skift) —\n[QNX](https://copy.sh/v86/?profile=qnx)\n\n## Documentation\n\n[How it works](docs/how-it-works.md) —\n[Networking](docs/networking.md) —\n[Alpine Linux guest setup](tools/docker/alpine/) —\n[Arch Linux guest setup](docs/archlinux.md) —\n[Windows NT guest setup](docs/windows-nt.md) —\n[Windows 9x guest setup](docs/windows-9x.md) —\n[9p filesystem](docs/filesystem.md) —\n[Linux rootfs on 9p](docs/linux-9p-image.md) —\n[Profiling](docs/profiling.md) —\n[CPU Idling](docs/cpu-idling.md)\n\n## Compatibility\n\nHere's an overview of the operating systems supported in v86:\n\n- Linux works pretty well. 64-bit kernels are not supported.\n - [Buildroot](https://buildroot.org/) can be used to build a minimal image.\n [humphd/browser-vm](https://github.com/humphd/browser-vm) and\n [darin755/browser-buildroot](https://github.com/Darin755/browser-buildroot) have some useful scripts for building one.\n - [SkiffOS](https://github.com/skiffos/SkiffOS/tree/master/configs/browser/v86) (based on Buildroot) can cross-compile a custom image.\n - Ubuntu and other Debian derivatives works up to the latest version that supported i386 (16.04 LTS or 18.04 LTS for some variants).\n - Alpine Linux works. An image can be built from a Dockerfile, see [tools/docker/alpine/](tools/docker/alpine/).\n - Arch Linux 32 works. See [archlinux.md](docs/archlinux.md) for building an image.\n- ReactOS works.\n- FreeDOS, Windows 1.01 and MS-DOS run very well.\n- KolibriOS works.\n- Haiku works.\n- Android-x86 has been tested up to 4.4-r2.\n- Windows 1, 3.x, 95, 98, ME, NT and 2000 work reasonably well.\n - In Windows 2000 and higher the PC type has to be changed from ACPI PC to Standard PC\n - There are some known boot issues ([#250](https://github.com/copy/v86/issues/250), [#433](https://github.com/copy/v86/issues/433), [#507](https://github.com/copy/v86/issues/507), [#555](https://github.com/copy/v86/issues/555), [#620](https://github.com/copy/v86/issues/620), [#645](https://github.com/copy/v86/issues/645))\n - See [Windows 9x guest setup](docs/windows-9x.md)\n- Windows XP, Vista and 8 work under certain conditions (see [#86](https://github.com/copy/v86/issues/86), [#208](https://github.com/copy/v86/issues/208))\n - See [Windows NT guest setup](docs/windows-nt.md)\n- Many hobby operating systems work.\n- 9front works.\n- Plan 9 doesn't work.\n- QNX works.\n- OS/2 doesn't work.\n- FreeBSD works.\n- OpenBSD works with a specific boot configuration. At the `boot>` prompt type\n `boot -c`, then at the `UKC>` prompt `disable mpbios` and `exit`.\n- NetBSD works only with a custom kernel, see [#350](https://github.com/copy/v86/issues/350).\n- SerenityOS works (only 32-bit versions).\n- [SkiftOS](https://skiftos.org/) works.\n\nYou can get some information on the disk images here: https://github.com/copy/images.\n\n## How to build, run and embed?\n\nYou need:\n\n- make\n- Rust with the wasm32-unknown-unknown target\n- A version of clang compatible with Rust\n- java (for Closure Compiler, not necessary when using `debug.html`)\n- nodejs (a recent version is required, v16.11.1 is known to be working)\n- To run tests: nasm, gdb, qemu-system, gcc, libc-i386 and rustfmt\n\nSee [tools/docker/test-image/Dockerfile](tools/docker/test-image/Dockerfile)\nfor a full setup on Debian or\n[WSL](https://docs.microsoft.com/en-us/windows/wsl/install).\n\n- Run `make` to build the debug build (at `debug.html`).\n- Run `make all` to build the optimized build (at `index.html`).\n- ROM and disk images are loaded via XHR, so if you want to try out `index.html`\n locally, make sure to serve it from a local webserver. You can use `make run`\n to serve the files using Python's http module.\n- If you only want to embed v86 in a webpage you can use `libv86.js`. For usage,\n check out the [examples](examples/). You can download it from the [release section](https://github.com/copy/v86/releases).\n- For bundler-based setups (Vite/React/Next/Webpack), there is also an official npm package:\nhttps://www.npmjs.com/package/v86\n\n This package was originally maintained by [@giulioz](https://github.com/giulioz) (bundler-optimized fork) and was made \"official\" for this repo by [@basicer](https://github.com/basicer) with the author's permission.\n It is published automatically from this repository via GitHub Actions ([.github/workflows/ci.yml](.github/workflows/ci.yml), Upload release job) on pushes to `master` and uses `npm publish --provenance`.\n \n Install: `npm install v86`\n\n### Alternatively, to build using Docker\n\n- If you have Docker installed, you can run the whole system inside a container.\n- See `tools/docker/exec` to find the Dockerfile required for this.\n- You can run `docker build -f tools/docker/exec/Dockerfile -t v86:alpine-3.19 .` from the root directory to generate docker image.\n- Then you can simply run `docker run -it -p 8000:8000 v86:alpine-3.19` to start the server.\n- Check `localhost:8000` for hosted server.\n\n### Running via Dev Container\n\n- If you are using an IDE that supports Dev Containers, such as GitHub Codespaces, the Visual Studio Code Remote Container extension, or possibly others such as Jetbrains' IntelliJ IDEA, you can setup the development environment in a Dev Container.\n- Follow the instructions from your development environment to setup the container.\n- Run the Task \"Fetch images\" in order to download images for testing.\n\n## Testing\n\nThe disk images for testing are not included in this repository. You can\ndownload them directly from the website using:\n\n`curl --compressed --output-dir images/ --remote-name-all https://i.copy.sh/{linux.iso,linux3.iso,linux4.iso,buildroot-bzimage68.bin,TinyCore-11.0.iso,oberon.img,msdos.img,openbsd-floppy.img,kolibri.img,windows101.img,os8.img,freedos722.img,mobius-fd-release5.img,msdos622.img}`\n\nRun integration tests: `make tests`\n\nRun all tests: `make jshint rustfmt kvm-unit-test nasmtests nasmtests-force-jit expect-tests jitpagingtests qemutests rust-test tests`\n\nSee [tests/Readme.md](tests/Readme.md) for more information.\n\n## API examples\n\n- [Basic](examples/basic.html)\n- [Programatically using the serial terminal](examples/serial.html)\n- [A Lua interpreter](examples/lua.html)\n- [Two instances in one window](examples/two_instances.html)\n- [Networking between browser windows/tabs using the Broadcast Channel API](examples/broadcast-network.html)\n- [TCP Terminal (fetch-based networking)](examples/tcp_terminal.html)\n- [Saving and restoring emulator state](examples/save_restore.html)\n\nUsing v86 for your own purposes is as easy as:\n\n```javascript\nvar emulator = new V86({\n screen_container: document.getElementById(\"screen_container\"),\n bios: {\n url: \"../../bios/seabios.bin\",\n },\n vga_bios: {\n url: \"../../bios/vgabios.bin\",\n },\n cdrom: {\n url: \"../../images/linux.iso\",\n },\n autostart: true,\n});\n```\n\nSee [starter.js](src/browser/starter.js).\n\n## License\n\nv86 is distributed under the terms of the Simplified BSD License, see\n[LICENSE](LICENSE). The following third-party dependencies are included in the\nrepository under their own licenses:\n\n- [`lib/softfloat/softfloat.c`](lib/softfloat/softfloat.c)\n- [`lib/zstd/zstddeclib.c`](lib/zstd/zstddeclib.c)\n- [`tests/kvm-unit-tests/`](tests/kvm-unit-tests)\n- [`tests/qemutests/`](tests/qemutests)\n- [`src/floppy.js/`](src/floppy.js) contains parts ported from qemu under the MIT license, see LICENSE.MIT.\n\n## Credits\n\n- CPU test cases via [QEMU](https://wiki.qemu.org/Main_Page)\n- More tests via [kvm-unit-tests](https://www.linux-kvm.org/page/KVM-unit-tests)\n- [zstd](https://github.com/facebook/zstd) support is included for better compression of state images\n- [Berkeley SoftFloat](http://www.jhauser.us/arithmetic/SoftFloat.html) is included to precisely emulate 80-bit floating point numbers\n- [The jor1k project](https://github.com/s-macke/jor1k) for 9p, filesystem and uart drivers\n- [WinWorld](https://winworldpc.com/) sources of some old operating systems\n- [OS/2 Museum](https://www.os2museum.com/) sources of some old operating systems\n- [ArchiveOS](https://archiveos.org/) sources of several operating systems\n\n## More questions?\n\nShoot me an email to `copy@copy.sh`. Please report bugs on GitHub.\n"
},
{
"path": "bios/.gitignore",
"content": "*.gz\n"
},
{
"path": "bios/COPYING.LESSER",
"content": "\t\t GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software Foundation, Inc. \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n\n This version of the GNU Lesser General Public License incorporates\nthe terms and conditions of version 3 of the GNU General Public\nLicense, supplemented by the additional permissions listed below.\n\n 0. Additional Definitions. \n\n As used herein, \"this License\" refers to version 3 of the GNU Lesser\nGeneral Public License, and the \"GNU GPL\" refers to version 3 of the GNU\nGeneral Public License.\n\n \"The Library\" refers to a covered work governed by this License,\nother than an Application or a Combined Work as defined below.\n\n An \"Application\" is any work that makes use of an interface provided\nby the Library, but which is not otherwise based on the Library.\nDefining a subclass of a class defined by the Library is deemed a mode\nof using an interface provided by the Library.\n\n A \"Combined Work\" is a work produced by combining or linking an\nApplication with the Library. The particular version of the Library\nwith which the Combined Work was made is also called the \"Linked\nVersion\".\n\n The \"Minimal Corresponding Source\" for a Combined Work means the\nCorresponding Source for the Combined Work, excluding any source code\nfor portions of the Combined Work that, considered in isolation, are\nbased on the Application, and not on the Linked Version.\n\n The \"Corresponding Application Code\" for a Combined Work means the\nobject code and/or source code for the Application, including any data\nand utility programs needed for reproducing the Combined Work from the\nApplication, but excluding the System Libraries of the Combined Work.\n\n 1. Exception to Section 3 of the GNU GPL.\n\n You may convey a covered work under sections 3 and 4 of this License\nwithout being bound by section 3 of the GNU GPL.\n\n 2. Conveying Modified Versions.\n\n If you modify a copy of the Library, and, in your modifications, a\nfacility refers to a function or data to be supplied by an Application\nthat uses the facility (other than as an argument passed when the\nfacility is invoked), then you may convey a copy of the modified\nversion:\n\n a) under this License, provided that you make a good faith effort to\n ensure that, in the event an Application does not supply the\n function or data, the facility still operates, and performs\n whatever part of its purpose remains meaningful, or\n\n b) under the GNU GPL, with none of the additional permissions of\n this License applicable to that copy.\n\n 3. Object Code Incorporating Material from Library Header Files.\n\n The object code form of an Application may incorporate material from\na header file that is part of the Library. You may convey such object\ncode under terms of your choice, provided that, if the incorporated\nmaterial is not limited to numerical parameters, data structure\nlayouts and accessors, or small macros, inline functions and templates\n(ten or fewer lines in length), you do both of the following:\n\n a) Give prominent notice with each copy of the object code that the\n Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the object code with a copy of the GNU GPL and this license\n document.\n\n 4. Combined Works.\n\n You may convey a Combined Work under terms of your choice that,\ntaken together, effectively do not restrict modification of the\nportions of the Library contained in the Combined Work and reverse\nengineering for debugging such modifications, if you also do each of\nthe following:\n\n a) Give prominent notice with each copy of the Combined Work that\n the Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the Combined Work with a copy of the GNU GPL and this license\n document.\n\n c) For a Combined Work that displays copyright notices during\n execution, include the copyright notice for the Library among\n these notices, as well as a reference directing the user to the\n copies of the GNU GPL and this license document.\n\n d) Do one of the following:\n\n 0) Convey the Minimal Corresponding Source under the terms of this\n License, and the Corresponding Application Code in a form\n suitable for, and under terms that permit, the user to\n recombine or relink the Application with a modified version of\n the Linked Version to produce a modified Combined Work, in the\n manner specified by section 6 of the GNU GPL for conveying\n Corresponding Source.\n\n 1) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (a) uses at run time\n a copy of the Library already present on the user's computer\n system, and (b) will operate properly with a modified version\n of the Library that is interface-compatible with the Linked\n Version. \n\n e) Provide Installation Information, but only if you would otherwise\n be required to provide such information under section 6 of the\n GNU GPL, and only to the extent that such information is\n necessary to install and execute a modified version of the\n Combined Work produced by recombining or relinking the\n Application with a modified version of the Linked Version. (If\n you use option 4d0, the Installation Information must accompany\n the Minimal Corresponding Source and Corresponding Application\n Code. If you use option 4d1, you must provide the Installation\n Information in the manner specified by section 6 of the GNU GPL\n for conveying Corresponding Source.)\n\n 5. Combined Libraries.\n\n You may place library facilities that are a work based on the\nLibrary side by side in a single library together with other library\nfacilities that are not Applications and are not covered by this\nLicense, and convey such a combined library under terms of your\nchoice, if you do both of the following:\n\n a) Accompany the combined library with a copy of the same work based\n on the Library, uncombined with any other library facilities,\n conveyed under the terms of this License.\n\n b) Give prominent notice with the combined library that part of it\n is a work based on the Library, and explaining where to find the\n accompanying uncombined form of the same work.\n\n 6. Revised Versions of the GNU Lesser General Public License.\n\n The Free Software Foundation may publish revised and/or new versions\nof the GNU Lesser General Public License from time to time. Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.\n\n Each version is given a distinguishing version number. If the\nLibrary as you received it specifies that a certain numbered version\nof the GNU Lesser General Public License \"or any later version\"\napplies to it, you have the option of following the terms and\nconditions either of that published version or of any later version\npublished by the Free Software Foundation. If the Library as you\nreceived it does not specify a version number of the GNU Lesser\nGeneral Public License, you may choose any version of the GNU Lesser\nGeneral Public License ever published by the Free Software Foundation.\n\n If the Library as you received it specifies that a proxy can decide\nwhether future versions of the GNU Lesser General Public License shall\napply, that proxy's public statement of acceptance of any version is\npermanent authorization for you to choose that version for the\nLibrary.\n"
},
{
"path": "bios/fetch-and-build-seabios.sh",
"content": "set -e\ngit clone https://git.seabios.org/seabios.git || true\n(cd seabios && git checkout rel-1.16.2)\n\ncp seabios.config seabios/.config\nmake -C seabios\ncp seabios/out/bios.bin seabios.bin\ncp seabios/out/vgabios.bin vgabios.bin\n\ncp seabios-debug.config seabios/.config\nmake -C seabios\ncp seabios/out/bios.bin seabios-debug.bin\ncp seabios/out/vgabios.bin vgabios-debug.bin\n"
},
{
"path": "bios/seabios-debug.config",
"content": "#\n# Automatically generated file; DO NOT EDIT.\n# SeaBIOS Configuration\n#\n\n#\n# General Features\n#\n# CONFIG_COREBOOT is not set\nCONFIG_QEMU=y\n# CONFIG_CSM is not set\nCONFIG_QEMU_HARDWARE=y\nCONFIG_XEN=y\nCONFIG_THREADS=y\n# CONFIG_RELOCATE_INIT is not set\n# CONFIG_BOOTMENU is not set\nCONFIG_BOOTORDER=y\nCONFIG_HOST_BIOS_GEOMETRY=y\nCONFIG_ENTRY_EXTRASTACK=y\nCONFIG_MALLOC_UPPERMEMORY=y\nCONFIG_ROM_SIZE=0\n\n#\n# Hardware support\n#\nCONFIG_ATA=y\nCONFIG_ATA_DMA=y\nCONFIG_ATA_PIO32=y\nCONFIG_AHCI=y\nCONFIG_SDCARD=y\nCONFIG_VIRTIO_BLK=y\nCONFIG_VIRTIO_SCSI=y\nCONFIG_PVSCSI=y\nCONFIG_ESP_SCSI=y\nCONFIG_LSI_SCSI=y\nCONFIG_MEGASAS=y\nCONFIG_MPT_SCSI=y\nCONFIG_FLOPPY=y\nCONFIG_FLASH_FLOPPY=y\n# CONFIG_NVME is not set\nCONFIG_PS2PORT=y\n# CONFIG_USB is not set\nCONFIG_SERIAL=y\n# CONFIG_SERCON is not set\nCONFIG_LPT=y\nCONFIG_RTC_TIMER=y\nCONFIG_HARDWARE_IRQ=y\nCONFIG_USE_SMM=y\nCONFIG_CALL32_SMM=y\nCONFIG_MTRR_INIT=y\nCONFIG_PMTIMER=y\nCONFIG_TSC_TIMER=y\n\n#\n# BIOS interfaces\n#\nCONFIG_DRIVES=y\nCONFIG_CDROM_BOOT=y\nCONFIG_CDROM_EMU=y\nCONFIG_PCIBIOS=y\nCONFIG_APMBIOS=y\nCONFIG_PNPBIOS=y\nCONFIG_OPTIONROMS=y\nCONFIG_PMM=y\nCONFIG_BOOT=y\nCONFIG_KEYBOARD=y\nCONFIG_KBD_CALL_INT15_4F=y\nCONFIG_MOUSE=y\nCONFIG_S3_RESUME=y\nCONFIG_VGAHOOKS=y\n# CONFIG_DISABLE_A20 is not set\n# CONFIG_WRITABLE_UPPERMEMORY is not set\nCONFIG_TCGBIOS=y\n\n#\n# BIOS Tables\n#\nCONFIG_PIRTABLE=y\nCONFIG_MPTABLE=y\n# CONFIG_SMBIOS is not set\nCONFIG_ACPI=y\nCONFIG_ACPI_DSDT=y\nCONFIG_FW_ROMFILE_LOAD=y\nCONFIG_ACPI_PARSE=y\n\n#\n# VGA ROM\n#\n# CONFIG_NO_VGABIOS is not set\n# CONFIG_VGA_STANDARD_VGA is not set\n# CONFIG_VGA_CIRRUS is not set\n# CONFIG_VGA_ATI is not set\nCONFIG_VGA_BOCHS=y\n# CONFIG_VGA_GEODEGX2 is not set\n# CONFIG_VGA_GEODELX is not set\n# CONFIG_DISPLAY_BOCHS is not set\n# CONFIG_VGA_RAMFB is not set\nCONFIG_VGA_BOCHS_STDVGA=y\n# CONFIG_VGA_BOCHS_VMWARE is not set\n# CONFIG_VGA_BOCHS_QXL is not set\n# CONFIG_VGA_BOCHS_VIRTIO is not set\nCONFIG_BUILD_VGABIOS=y\nCONFIG_VGA_STDVGA_PORTS=y\nCONFIG_VGA_FIXUP_ASM=y\nCONFIG_VGA_ALLOCATE_EXTRA_STACK=y\nCONFIG_VGA_EXTRA_STACK_SIZE=512\nCONFIG_VGA_VBE=y\nCONFIG_VGA_PCI=y\nCONFIG_OVERRIDE_PCI_ID=y\nCONFIG_VGA_VID=0x1234\nCONFIG_VGA_DID=0x1111\n\n#\n# Debugging\n#\nCONFIG_DEBUG_LEVEL=8\n# CONFIG_DEBUG_SERIAL is not set\n# CONFIG_DEBUG_SERIAL_MMIO is not set\nCONFIG_DEBUG_IO=y\n"
},
{
"path": "bios/seabios.config",
"content": "#\n# Automatically generated file; DO NOT EDIT.\n# SeaBIOS Configuration\n#\n\n#\n# General Features\n#\n# CONFIG_COREBOOT is not set\nCONFIG_QEMU=y\n# CONFIG_CSM is not set\nCONFIG_QEMU_HARDWARE=y\nCONFIG_XEN=y\nCONFIG_THREADS=y\n# CONFIG_RELOCATE_INIT is not set\n# CONFIG_BOOTMENU is not set\nCONFIG_BOOTORDER=y\nCONFIG_HOST_BIOS_GEOMETRY=y\nCONFIG_ENTRY_EXTRASTACK=y\nCONFIG_MALLOC_UPPERMEMORY=y\nCONFIG_ROM_SIZE=0\n\n#\n# Hardware support\n#\nCONFIG_ATA=y\nCONFIG_ATA_DMA=y\nCONFIG_ATA_PIO32=y\nCONFIG_AHCI=y\nCONFIG_SDCARD=y\nCONFIG_VIRTIO_BLK=y\nCONFIG_VIRTIO_SCSI=y\nCONFIG_PVSCSI=y\nCONFIG_ESP_SCSI=y\nCONFIG_LSI_SCSI=y\nCONFIG_MEGASAS=y\nCONFIG_MPT_SCSI=y\nCONFIG_FLOPPY=y\nCONFIG_FLASH_FLOPPY=y\n# CONFIG_NVME is not set\nCONFIG_PS2PORT=y\n# CONFIG_USB is not set\nCONFIG_SERIAL=y\n# CONFIG_SERCON is not set\nCONFIG_LPT=y\nCONFIG_RTC_TIMER=y\nCONFIG_HARDWARE_IRQ=y\nCONFIG_USE_SMM=y\nCONFIG_CALL32_SMM=y\nCONFIG_MTRR_INIT=y\nCONFIG_PMTIMER=y\nCONFIG_TSC_TIMER=y\n\n#\n# BIOS interfaces\n#\nCONFIG_DRIVES=y\nCONFIG_CDROM_BOOT=y\nCONFIG_CDROM_EMU=y\nCONFIG_PCIBIOS=y\nCONFIG_APMBIOS=y\nCONFIG_PNPBIOS=y\nCONFIG_OPTIONROMS=y\nCONFIG_PMM=y\nCONFIG_BOOT=y\nCONFIG_KEYBOARD=y\nCONFIG_KBD_CALL_INT15_4F=y\nCONFIG_MOUSE=y\nCONFIG_S3_RESUME=y\nCONFIG_VGAHOOKS=y\n# CONFIG_DISABLE_A20 is not set\n# CONFIG_WRITABLE_UPPERMEMORY is not set\nCONFIG_TCGBIOS=y\n\n#\n# BIOS Tables\n#\nCONFIG_PIRTABLE=y\nCONFIG_MPTABLE=y\n# CONFIG_SMBIOS is not set\nCONFIG_ACPI=y\nCONFIG_ACPI_DSDT=y\nCONFIG_FW_ROMFILE_LOAD=y\nCONFIG_ACPI_PARSE=y\n\n#\n# VGA ROM\n#\n# CONFIG_NO_VGABIOS is not set\n# CONFIG_VGA_STANDARD_VGA is not set\n# CONFIG_VGA_CIRRUS is not set\n# CONFIG_VGA_ATI is not set\nCONFIG_VGA_BOCHS=y\n# CONFIG_VGA_GEODEGX2 is not set\n# CONFIG_VGA_GEODELX is not set\n# CONFIG_DISPLAY_BOCHS is not set\n# CONFIG_VGA_RAMFB is not set\nCONFIG_VGA_BOCHS_STDVGA=y\n# CONFIG_VGA_BOCHS_VMWARE is not set\n# CONFIG_VGA_BOCHS_QXL is not set\n# CONFIG_VGA_BOCHS_VIRTIO is not set\nCONFIG_BUILD_VGABIOS=y\nCONFIG_VGA_STDVGA_PORTS=y\nCONFIG_VGA_FIXUP_ASM=y\nCONFIG_VGA_ALLOCATE_EXTRA_STACK=y\nCONFIG_VGA_EXTRA_STACK_SIZE=512\nCONFIG_VGA_VBE=y\nCONFIG_VGA_PCI=y\nCONFIG_OVERRIDE_PCI_ID=y\nCONFIG_VGA_VID=0x1234\nCONFIG_VGA_DID=0x1111\n\n#\n# Debugging\n#\nCONFIG_DEBUG_LEVEL=0\n"
},
{
"path": "debug.html",
"content": "\n\n\nv86 (debug)\n\n\n\n\n\n\n\n\n
\n\n\n\n\n\n\n\n"
},
{
"path": "docs/.gitignore",
"content": "node_modules\n"
},
{
"path": "docs/archlinux.md",
"content": "See [Alpine setup](../tools/docker/alpine/Readme.md) for a more reliable and\nfaster way to automatically build Linux images for v86.\n\n(This document partly also applies to other Linuxes)\n\nChoosing an installer ISO\n-------------------------\n\nDownload Arch Linux 32 from https://archlinux32.org.\n\nBasic installation using QEMU\n-----------------------\n\nInstalling Arch Linux with these instructions will result in a raw disk image that can be booted by v86.\n\n```sh\n# fetch archlinux32 installer\nwget https://mirror.archlinux32.org/archisos/archlinux32-2021.12.01-i686.iso\n\n# Create a 10 gigabyte disk image. If you intend to pacstrap only 'base' then 1.5G should be fine also.\nqemu-img create arch.img 10G\n\n# Follow the normal installation process (you can add accel=kvm if your system supports it to speed up the installation)\nqemu-system-x86_64 -m 256 -drive file=arch.img,format=raw -cdrom archlinux32-2021.12.01-i686.iso\n```\n\nFor keyboard support, it is necessary to open /etc/mkinitcpio.conf and edit the following line:\n\n```sh\nMODULES=\"atkbd i8042\"\n```\n\nFor the changes to take effect, you need to regenerate the initial ramdisk with `mkinitcpio -p linux`\n\nThe resulting `arch.img` file is a bootable disk image for v86.\n\nScripting image creation for v86\n--------------------------------\n\nInstalling the ISO by hand takes a long time if you intend to recreate the image many times. There are various reasons why you might want to do this more than once. For example: because the emulator is slow you might want to compile any new software release in QEMU which is much faster and then use the resulting image in v86 instead of making the emulator compile the software. Another reason is that the build progress potentially takes long and if you want to do automated builds in parallel to find out what configurations do and don't work you can just throw more computing power at the problem in order to solve it. This example requires that you have `packer`, `qemu` and `kpartx` installed.\n\n### Creating a packer template\n\n[Packer](https://www.packer.io/docs/builders/qemu.html) is a tool that lets you boot an ISO in any of multiple emulators (so QEMU in our case) and send pre-scripted keystrokes to bootstrap an SSH server. Once the SSH connection is established a script can be started for further provisioning.\n\nCreate a template for automating the base installation:\n```sh\nmkdir -p packer\ncat > packer/template.json << 'EOF'\n{\n \"provisioners\": [\n {\n \"type\": \"shell\",\n \"override\": {\n \"qemu\": {\n \"scripts\": [\"scripts/provision.sh\"]\n }\n }\n }\n ],\n \"builders\": [\n {\n \"accelerator\": \"kvm\",\n \"type\": \"qemu\",\n \"boot_command\": [\n \"\",\n \"dhcpcd\",\n \"echo root:root | chpasswd\",\n \"systemctl start sshd\"\n ],\n \"headless\": true,\n \"boot_wait\": \"10s\",\n \"disk_size\": 1500,\n \"disk_interface\": \"ide\",\n \"iso_url\": \"https://mirror.archlinux32.org/archisos/archlinux32-2021.12.01-i686.iso\",\n \"iso_checksum\": \"90c6f5aecb095d5578f6c9970539da7c5e9324ec\",\n \"iso_checksum_type\": \"sha1\",\n \"ssh_wait_timeout\": \"120s\",\n \"ssh_pty\": true,\n \"ssh_username\": \"root\",\n \"ssh_password\": \"root\",\n \"ssh_port\": 22,\n \"format\": \"raw\",\n \"vm_name\": \"archlinux\",\n \"disk_detect_zeroes\": \"unmap\",\n \"memory\": 2048,\n \"vnc_bind_address\": \"0.0.0.0\"\n }\n ]\n}\nEOF\n```\n\nYou can tweak the options a bit to match your situation. For debugging, you can set `headless` to `false`. That will show you the VNC connection instead of running the `boot_command` in the background. For a `base` pacstrap, using a 2 GB disk image should be sufficient. The `raw` disk format is important. v86 does not read qcow2 images, only raw disk images. If your system does not support KVM (the default accelerator), you can change `\"accelerator\": \"none\"` to the settings, in macos you may use `\"accelerator\": \"hvf\"`. Other accelerator options can be found [here](https://www.packer.io/docs/builders/qemu.html#accelerator).\n\nAfter gaining SSH connectivity to the VM, packer will run the `scripts/provisioning.sh` script in the guest.\n\n### Creating the Arch Linux installation script\n\nCreate a script for your Arch Linux installation. This runs in the live Arch Linux environment, so you need to partition the disk, do a pacstrap, and install a bootloader.\n```sh\nmkdir -p packer/scripts\n### Write your own or copy paste the example below\nvim packer/scripts/provision.sh\n```\n\nAn example script to install Arch Linux with the root mounted using the 9p network filesystem:\n```sh\n#!/bin/bash\necho \"Creating a GPT partition on /dev/sda1\"\necho -e \"g\\nn\\n\\n\\n\\nw\" | fdisk /dev/sda\n\n# In case you might want to create a DOS partition instead. It doesn't really matter.\n#echo \"Creating a DOS partition on /dev/sda1\"\n#echo -e \"o\\nn\\np\\n1\\n\\n\\nw\" | fdisk /dev/sda\n\necho \"Formatting /dev/sda1 to ext4\"\nmkfs -t ext4 /dev/sda1\n\necho \"Mounting new filesystem\"\nmount -t ext4 /dev/sda1 /mnt\n\necho \"Create pacman package cache dir\"\nmkdir -p /mnt/var/cache/pacman/pkg\n\n# We don't want the pacman cache to fill up the image. After reboot whatever tarballs pacman has cached are gone.\necho \"Mount the package cache dir in memory so it doesn't fill up the image\"\nmount -t tmpfs none /mnt/var/cache/pacman/pkg\n\necho \"Updating archlinux-keyring\"\npacman -Sy archlinux-keyring --noconfirm\n\n# uncomment to remove signing if unable to resolve signing errors\nsed -i 's/SigLevel.*/SigLevel = Never/g' /etc/pacman.conf\n\n# Install the Arch Linux base system, feel free to add packages you need here\necho \"Performing pacstrap\"\npacstrap -i /mnt base linux dhcpcd curl openssh --noconfirm\n\necho \"Writing fstab\"\ngenfstab -p /mnt >> /mnt/etc/fstab\n\n# When the Linux boots we want it to automatically log in on tty1 as root\necho \"Ensuring root autologin on tty1\"\nmkdir -p /mnt/etc/systemd/system/getty@tty1.service.d\ncat << 'EOF' > /mnt/etc/systemd/system/getty@tty1.service.d/override.conf\n[Service]\nExecStart=\nExecStart=-/usr/bin/agetty --autologin root --noclear %I $TERM\nEOF\n\n# This is the tricky part. The current root will be mounted on /dev/sda1 but after we reboot\n# it will try to mount root during boot using the 9p network filesystem. This means the emulator\n# will request all files over the network using XMLHttpRequests from the server. This is great\n# because then you only need to provide the client with a saved state (the memory) and the\n# session will start instantly and load needed files on the fly. This is fast and it saves bandwidth.\necho \"Ensuring root is remounted using 9p after reboot\"\nmkdir -p /mnt/etc/initcpio/hooks\ncat << 'EOF' > /mnt/etc/initcpio/hooks/9p_root\nrun_hook() {\n mount_handler=\"mount_9p_root\"\n}\n\nmount_9p_root() {\n msg \":: mounting '$root' on real root (9p)\"\n # Note the host9p. We won't mount /dev/sda1 on root anymore,\n # instead we mount the network filesystem and the emulator will\n # retrieve the files on the fly.\n if ! mount -t 9p host9p \"$1\"; then\n echo \"You are now being dropped into an emergency shell.\"\n launch_interactive_shell\n msg \"Trying to continue (this will most likely fail) ...\"\n fi\n}\nEOF\n\necho \"Adding initcpio build hook for 9p root remount\"\nmkdir -p /mnt/etc/initcpio/install\ncat << 'EOF' > /mnt/etc/initcpio/install/9p_root\n#!/bin/bash\nbuild() {\n\tadd_runscript\n}\nEOF\n\n# We need to load some modules into the kernel for it to play nice with the emulator\n# The atkbd and i8042 modules are for keyboard input in the browser. If you do not\n# want to use the network filesystem you only need these. The 9p, 9pnet and 9pnet_virtio\n# modules are needed for being able to mount 9p network filesystems using the emulator.\necho \"Configure mkinitcpio for 9p\"\nsed -i 's/MODULES=()/MODULES=(atkbd i8042 libps2 serio serio_raw psmouse virtio_pci virtio_pci_modern_dev 9p 9pnet 9pnet_virtio fscache netfs)/g' /mnt/etc/mkinitcpio.conf\n\n# Because we want to mount the root filesystem over the network during boot, we need to\n# hook into initcpio. If you do not want to mount the root filesystem during boot but\n# only want to mount a 9p filesystem later, you can leave this out. Once the system\n# has been booted you should be able to mount 9p filesystems with mount -t 9p host9p /blabla\n# without this hook.\nsed -i 's/fsck\"/fsck 9p_root\"/g' /mnt/etc/mkinitcpio.conf\n\n# enable ssh password auth and root login\nsed -i 's/#PermitRootLogin.*/PermitRootLogin yes/g' /etc/ssh/sshd_config\nsed -i 's/#PasswordAuthentication.*/PasswordAuthentication yes/g' /etc/ssh/sshd_config\n\necho \"Writing the installation script\"\ncat << 'EOF' > /mnt/bootstrap.sh\n#!/usr/bin/bash\necho \"Re-generate initial ramdisk environment\"\nmkinitcpio -p linux\n\n# uncomment to remove signing if you are unable to resolve signing errors otherwise\nsed -i 's/SigLevel.*/SigLevel = Never/g' /etc/pacman.conf\n\npacman -S --noconfirm syslinux gptfdisk\nsyslinux-install_update -i -a -m\n\n# disabling ldconfig to speed up boot (to remove Rebuild dynamic linker cache...)\n# you may want to comment this out\necho \"Disabling ldconfig service\"\nsystemctl mask ldconfig.service\n\nsync\nEOF\n\necho \"Chrooting and bootstrapping the installation\"\narch-chroot /mnt bash bootstrap.sh\n\n\ncat << 'EOF' > /mnt/boot/syslinux/syslinux.cfg\n# Config file for Syslinux -\n# /boot/syslinux/syslinux.cfg\n#\n# Comboot modules:\n# * menu.c32 - provides a text menu\n# * vesamenu.c32 - provides a graphical menu\n# * chain.c32 - chainload MBRs, partition boot sectors, Windows bootloaders\n# * hdt.c32 - hardware detection tool\n# * reboot.c32 - reboots the system\n#\n# To Use: Copy the respective files from /usr/lib/syslinux to /boot/syslinux.\n# If /usr and /boot are on the same file system, symlink the files instead\n# of copying them.\n#\n# If you do not use a menu, a 'boot:' prompt will be shown and the system\n# will boot automatically after 5 seconds.\n#\n# Please review the wiki: https://wiki.archlinux.org/index.php/Syslinux\n# The wiki provides further configuration examples\n\nDEFAULT arch\nPROMPT 0 # Set to 1 if you always want to display the boot: prompt\nTIMEOUT 100\n\n# Menu Configuration\n# Either menu.c32 or vesamenu32.c32 must be copied to /boot/syslinux\nUI menu.c32\n#UI vesamenu.c32\n\n# Refer to http://syslinux.zytor.com/wiki/index.php/Doc/menu\nMENU TITLE Arch Linux\n#MENU BACKGROUND splash.png\nMENU COLOR border 30;44 #40ffffff #a0000000 std\nMENU COLOR title 1;36;44 #9033ccff #a0000000 std\nMENU COLOR sel 7;37;40 #e0ffffff #20ffffff all\nMENU COLOR unsel 37;44 #50ffffff #a0000000 std\nMENU COLOR help 37;40 #c0ffffff #a0000000 std\nMENU COLOR timeout_msg 37;40 #80ffffff #00000000 std\nMENU COLOR timeout 1;37;40 #c0ffffff #00000000 std\nMENU COLOR msg07 37;40 #90ffffff #a0000000 std\nMENU COLOR tabmsg 31;40 #30ffffff #00000000 std\n\n# boot sections follow\n#\n# TIP: If you want a 1024x768 framebuffer, add \"vga=773\" to your kernel line.\n#\n#-*\n\nLABEL arch\n MENU LABEL Arch Linux 9p\n LINUX ../vmlinuz-linux\n APPEND root=/dev/sda1 rw quiet\n INITRD ../initramfs-linux.img\n\nLABEL arch2\n MENU LABEL Arch Linux Disk\n LINUX ../vmlinuz-linux\n APPEND root=/dev/sda1 rw quiet disablehooks=9p_root\n INITRD ../initramfs-linux.img\n\nLABEL hdt\n MENU LABEL HDT (Hardware Detection Tool)\n COM32 hdt.c32\n\nLABEL reboot\n MENU LABEL Reboot\n COM32 reboot.c32\n\nLABEL poweroff\n MENU LABEL Poweroff\n COM32 poweroff.c32\nEOF\numount -R /mnt\n```\n\nWith the packer template and the script you have enough to create an image that can be booted by v86. But because this example script installs an Arch Linux that wants to mount root over the network with 9p, we need to host that filesystem first. If you do not want to use 9p, you can just run `(cd packer && packer build -force template.json)` to build the image.\n\n### Creating the 9p filesystem\n\nNow that we have an image that contains a filesystem, we can convert that filesystem into something we can host on the webserver together with the v86 library.\n\nTo do so, we need to mount the image once and create a json mapping of the filesystem. The following script shows how to map the filesystem in an automated fashion.\n\nCreate a script to builds the image and then creates v86 compatible artifacts:\n```sh\nvim build.sh\n```\n\nExample script:\n\n```sh\n#!/bin/sh\n\nSRC=packer\nTARGET=output\n\n# build the boxfile from the iso\n(cd $SRC && sudo PACKER_LOG=1 PACKER_LOG_PATH=\"./packer.log\" packer build -force template.json)\n\n# test if there is a boxfile where we expected it\nif [ ! -f $SRC/output-qemu/archlinux ]; then\n echo \"Looks like something went wrong building the image, maybe try again?\"\n exit 1\nfi;\n\n# clean up any previous loops and mounts\necho \"Making sure mountpoint is empty\"\nLOOP_DEV=$(sudo losetup -f)\n\nsudo umount diskmount -f || /bin/true\nsudo kpartx -d $LOOP_DEV || /bin/true\nsudo losetup -d $LOOP_DEV || /bin/true\n\n# mount the generated raw image, we do that so we can create\n# a json mapping of it and copy it to host on the webserver\nmkdir -p diskmount\necho \"Mounting the created image so we can convert it to a p9 image\"\nsudo losetup $LOOP_DEV $SRC/output-qemu/archlinux\nsudo kpartx -a $LOOP_DEV\nsudo mount /dev/mapper/$(basename $LOOP_DEV)p1 diskmount\n\n# make images dir\nmkdir -p $TARGET\nmkdir -p $TARGET/images\nmkdir -p $TARGET/images/arch\n\n# map the filesystem to json with fs2json\nsudo ./tools/fs2json.py --out $TARGET/images/fs.json diskmount\nsudo ./tools/copy-to-sha256.py diskmount $TARGET/images/arch\n\n# copy the filesystem and chown to nonroot user\necho \"Copying the filesystem to $TARGET/arch\"\nmkdir $TARGET/arch -p\nsudo rsync -q -av diskmount/ $TARGET/arch\nsudo chown -R $(whoami):$(whoami) $TARGET/arch\n\n# clean up mount\necho \"Cleaning up mounts\"\nsudo umount diskmount -f\nsudo kpartx -d $LOOP_DEV\nsudo losetup -d $LOOP_DEV\n\n# Move the image to the images dir\nsudo mv $SRC/output-qemu/archlinux $TARGET/images/arch.img\n```\n\nGiven that the packer template and provision.sh is rooted at `packer` (adjust the value of `$SRC` otherwise), run the `build.sh` at root of your `v86` repo:\n\n```\nchmod +x build.sh\n./build.sh\n```\n\nGenerated artifacts are now available for serving from `output`.\n\n### Using the created artifacts in v86\n\nNow that we have everything we need to host a server that serves an Arch Linux environment over the network.\n\nCreate a checkout of v86 and run `make build/libv86.js`.\nWe can then edit `examples/arch.html`, we have two options:\n\n1. Boot Arch Linux from the 9p filesystem (generated .bin artifacts at `/output/images/arch`):\n\n ```sh\n filesystem: {\n baseurl: \"../output/images/arch/\",\n basefs: \"../output/images/fs.json\",\n },\n\n bzimage_initrd_from_filesystem: true,\n\n cmdline: [\n \"rw\",\n \"root=host9p rootfstype=9p rootflags=trans=virtio,cache=loose\",\n ].join(\" \"),\n\n acpi: false,\n autostart: true,\n ```\n2. Boot the Arch Linux from the qemu raw disk image:\n\n ```sh\n hda: {\n url: \"../output/images/arch.img\",\n # set to true if you want to load it asynchrously during runtime (for this option we need to run a webserver that supports the Range header)\n # NOTE: async: false is slow but proved to be more realiable\n async: false,\n\n # This needs to be the size of the raw disk.\n size: 1.5 * 1024 * 1024 * 1024,\n # See the `disk_size` item in the packer template.\n },\n\n acpi: false,\n autostart: true,\n ```\n\nNext, we need a webserver that supports the Range header. For example [this extension of the SimpleHTTPServer](https://github.com/smgoller/rangehttpserver). At your `v86` root, run:\n\n```sh\nwget https://raw.githubusercontent.com/smgoller/rangehttpserver/master/RangeHTTPServer.py\npython2 RangeHTTPServer.py\n```\n\nNow that the webserver is running, point your browser to `http://localhost:8000/examples/arch.html`. Wait for the Linux to boot. When the system is up, click 'Save state to file'. Your browser will download a `v86state.bin` file. Copy that file to `/your/v86/dir/images`. You can then edit `examples/arch.html` again and add a 'state' key to the `V86` array.\n\n```sh\ninitial_state: {\n \"url\": \"http://localhost:8000/images/v86state.bin\",\n},\n```\n\nIf you refresh `http://localhost:8000/examples/arch.html` you will see that the state is restored instantly and all required files are loaded over the network on the fly.\n\n### Networking\n\nThe emulator can emulate a network card. For more information [look at the networking documentation](https://github.com/copy/v86/blob/master/docs/networking.md). To set up networking in the VM, add the following item to the `V86` array in the `examples/arch.html` file:\n```sh\nnetwork_relay_url: \"ws://localhost:8080/\",\n```\n\nThis will make the emulator try to connect to a [WebSockets proxy](https://github.com/benjamincburns/websockproxy). Running the proxy is very easy if you use the Docker container.\n\n```sh\nsudo docker run --privileged -p 8080:80 --name relay bennottelling/websockproxy\n```\n**NOTE:** original `benjamincburns/jor1k-relay:latest` has throttling built-in by default which will degrade the networking. `bennottelling/websockproxy` has this throttling removed via [websockproxy/issues/4#issuecomment-317255890](https://github.com/benjamincburns/websockproxy/issues/4#issuecomment-317255890).\n\nYou can check if the relay is running correctly by going to `http://localhost:8080/` in your browser. There you should see a message that reads `Can \"Upgrade\" only to \"Websocket\".`.\n\nNow you should be able to get network connectivity in the virtual machine. If you are restoring from a saved state, you might need to first run:\n```sh\nip link set enp0s5 down\nrmmod ne2k-pci\n```\n\nTo bring the network up, run:\n```sh\nmodprobe ne2k-pci\ndhcpcd -w4 enp0s5\n```\n\nIt might take a while for a carrier to become available on the interface. If the `dhcpcd` command fails shortly after booting, wait a bit and try again a bit later. If you are using the 9p network filesystem you can use the developer tools networking tab (in chrome) to get a sense of what is going on by looking at the files that are being downloaded.\n\nWhen the network is up you should be able to curl a website. To check, run `curl icanhazip.com`. There you should see the public IP of the machine running the proxy.\n\nYou can't do inbound traffic into the VM with the websockproxy Docker container because it uses a basic NAT. To SSH into the VM running in the browser, you can create a reverse SSH tunnel to expose the SSH port of the sshd in the VM to the outside world. You may need to start `sshd` first, it may also be reasonable to change root password:\n\n```sh\npasswd root\nsystemctl start sshd\n```\n\nthen create a reverse SSH tunnel:\n\n```sh\n# This will create a port 1122 on the example.com server\n# which forwards to the SSH in the VM\nssh root@example.com -R 1122:localhost:22\n```\n\nNow on the `example.com` server you should be able to SSH into your browser tab by running `ssh root@localhost -p 1122`.\n"
},
{
"path": "docs/cpu-idling.md",
"content": "Some operating systems don't support `hlt` instruction, because of this, the CPU spin loops instead of idling.\nHere are some solutions for different OSes:\n\n## MS-DOS (using DOSIdle)\n1. Download `DOSID251.zip` from https://www.vogons.org/viewtopic.php?p=438763#p438763\n2. Unzip DOSIDLE.EXE from archive in any location (recommended to root of C:).\n3. Run `edit C:\\autoexec.bat`\n4. Add to file: `C:\\path\\to\\dosidle.exe`\n5. Save changes (*press Alt + F and x*) and restart the VM.\n\n**Note:** To hide output when starting DOSIdle, change `C:\\path\\to\\dosidle.exe` to `C:\\path\\to\\dosidle.exe > nul` on step №4.\n\n## FreeDOS ([source](https://narkive.com/UGrcO8wU.2))\n1. Run `edit C:\\fdconfig.sys` (or `edit C:\\config.sys`)\n2. Add to file: `IDLEHALT=1`\n3. Save changes (*press Alt + F and x*) and restart FreeDOS.\n\n## Windows 9x (using AmnHLT)\n1. Download `amnhltm.zip` from http://toogam.com/software/archive/drivers/cpu/cpuidle/amnhltm.zip ([mirror](https://web.archive.org/web/20060212132151/http://www.user.cityline.ru/~maxamn/amnhltm.zip))\n2. Unzip the archive in any location.\n3. **Note**: If you have installed VBE9x, restart Windows, press F8 on boot, select *Command prompt only*, run `cd C:\\path\\to\\amnhlt\\`, and follow to the next step.\n4. Run `AMNHLT.BAT`\n5. Restart Windows, and AmnHLT will start automatically on next boot (you can safely delete archive and unpacked folder).\n\n## Windows 98+ and Unix-like\nThese systems are already supports `hlt`, no further action is required.\n"
},
{
"path": "docs/filesystem.md",
"content": "A 9p filesystem is supported by v86, using a virtio transport. There are several\nways it can be set up.\n\n### Guest mount\n\nIn all cases, the filesystem is mounted in the guest system using the `9p`\nfilesystem type and the `host9p` device tag. Typically you want to be specific\nwith the version and transport options:\n\n```sh\nmount -t 9p -o trans=virtio,version=9p2000.L host9p /mnt/9p/\n```\n\nHere are kernel arguments you can use to boot directly off the 9p filesystem:\n\n```\nrw root=host9p rootfstype=9p rootflags=trans=virtio,version=9p2000.L\n```\n\nThe `aname` option can be used to pick the directory from 9p to mount. The `rw`\nargument makes this a read-write root filesystem.\n\n\n### JSON/HTTP Filesystem\n\nThis is the standard way to setup the 9p filesystem. It loads files over\nHTTP on-demand into an in-memory filesystem in JS. This allows files to be\nexchanged with the guest OS. See `create_file` and `read_file` in\n[`starter.js`](https://github.com/copy/v86/blob/master/src/browser/starter.js).\n\nThis mode is enabled by passing the following options to `V86`:\n\n```javascript\nfilesystem: {\n basefs: \"../9p/fs.json\",\n baseurl: \"../9p/base/\",\n}\n```\n\nHere, `basefs` is a json file created using\n[fs2json.py](tools/fs2json.py) and the `baseurl` directory is created using\n[copy-to-sha256.py](tools/copy-to-sha256.py).\n\nIf `basefs` and `baseurl` are omitted, an empty 9p filesystem is created. Unless\nyou configure one of the alternative modes.\n\n\n### Function Handler\n\nYou can handle 9p messages directly in JavaScript yourself by providing a\nfunction as `handle9p` under `filesystem`:\n\n```javascript\nfilesystem: {\n handle9p: async (reqBuf, reply) => {\n // reqBuf is a Uint8Array of the entire request frame.\n // you can parse these bytes using a library or reading the 9p spec.\n // once you formulate a response, you send the reply frame as a\n // Uint8Array by passing it to reply: reply(respBuf)\n }\n}\n```\n\nThis allows you to implement a 9p server or custom proxy in JS. However, this\nfilesystem will not be cached (unless cached in the guest OS), functions like\n`create_file` and `read_file` will not be available, and you will be responsible\nfor keeping its state in sync with any machine save states.\n\n\n### WebSocket Proxy\n\nYou can also back the 9p virtio filesystem with a 9p server over WebSocket by\nproviding a WS proxy URL:\n\n```javascript\nfilesystem: {\n proxy_url: \"ws://localhost:8080/\"\n}\n```\n\nSimlar to using `handle9p`, this filesystem will not be available in JS and\nwill need to be re-mounted after restoring state.\n\nThe WS proxy just needs to hand off messages with a connection to a normal 9p\nserver. Each binary WebSocket message is the full buffer of a request or a\nreply.\n\nTo implement, request message bytes can just be sent directly to the 9p\nconnection, but the 9p reply stream needs to be buffered into a single binary\nWebSocket message. The proxy must at least parse the first 4 bytes to get the\nmessage size and use it to buffer a full message before sending over WebSocket.\n\nThe [wanix](https://github.com/tractordev/wanix) CLI has a `serve` command that\nnot only serves a directory over HTTP, but also over 9P via WebSocket. You can\nsee how it [implements a proxy][1] in Go.\n\n[1]: https://github.com/tractordev/wanix/blob/main/cmd/wanix/serve.go#L117-L177\n"
},
{
"path": "docs/how-it-works.md",
"content": "Here's an overview of v86's workings. For details, check the\n[source](https://github.com/copy/v86/tree/master/src).\n\nThe major limitations of WebAssembly are (for the purpose of making emulators with jit):\n\n- structured control flow (no arbitrary jumps)\n- no control over registers (you can't keep hardware registers in wasm locals across functions)\n- no mmap (paging needs to be fully emulated)\n- no patching\n- module generation is fairly slow, but at least it's asynchronous, so other things can keep running\n- there is some memory overhead per module, so you can't generate more than a few thousand\n\nv86 has an interpreted mode, which collects entry points (targets of function\ncalls and indirect jumps). It also measures the hotness per page, so that\ncompilation is focused on code that is often executed. Once a page is\nconsidered hot, code is generated for the entire page and up to `MAX_PAGES`\nthat are directly reachable from it.\n\nv86 generates a single function with a big switch statement (brtable), to\nensure that all functions and targets of indirect jumps are reachable from\nother modules. The remaining control flow is handled using the \"stackifier\"\nalgorithm (well-explained in\n[this blog post](https://medium.com/leaningtech/solving-the-structured-control-flow-problem-once-and-for-all-5123117b1ee2)).\nAt the moment, there is no linking of wasm modules. The current module is\nexited, and the main loop detects if a new module can be entered.\n\nIn practice, I found that browsers don't handle this structure (deep brtables,\nwith locals being used across the entire function) very well, and `MAX_PAGES`\nhas to be set to fairly low, otherwise memory usage blows up. It's likely that\nimprovements are possible (generating fewer entry points, splitting code across\nmultiple functions).\n\nCode-generation happens in two passes. The first pass finds all basic block\nboundaries, the second generates code for each basic block. Instruction\ndecoding is generated by a [set of\nscripts](https://github.com/copy/v86/tree/master/gen) from a [table of\ninstructions](https://github.com/copy/v86/blob/master/gen/x86_table.js). It's\nalso used to [generate\ntests](https://github.com/copy/v86/blob/master/tests/nasm/create_tests.js).\n\nTo handle paging, v86 generates code similar to this (see `gen_safe_read`):\n\n```\nentry <- tlb[addr >> 12 << 2]\nif entry & MASK == TLB_VALID && (addr & 0xFFF) <= 0xFFC - bytes: goto fast\nentry <- safe_read_jit_slow(addr, instruction_pointer)\nif page_fault: goto exit-with-pagefault\nfast: mem[(entry & ~0xFFF) ^ addr]\n```\n\nThere is a 4 MB cache that acts like a tlb. It contains the physical address,\nread-only bit, whether the page contains code (in order to invalidate it on\nwrite) and whether the page points to mmio. Any of those cases are handled in\nthe slow path (`safe_read_jit_slow`), as well as walking the page tables and\ntriggering page faults. The fast path is taken in the vast majority of times.\n\nThe remaining code generation is mostly a straight-forward, 1-to-1 translation\nof x86 to wasm. The only analysis done is to optimise generation of condional\njumps immediately after arithmetic instructions, e.g.:\n\n```\ncmp eax, 52\nsetb eax\n```\n\nbecomes:\n\n```\n... // code for cmp\neax <- eax < 52\n```\n\nA lazy flag mechanism is used to speed arithmetic (applies to both jit and\ninterpreted mode, see\n[`arith.rs`](https://github.com/copy/v86/blob/master/src/rust/cpu/arith.rs) and\n[`misc_instr.rs`](https://github.com/copy/v86/blob/master/src/rust/cpu/misc_instr.rs)).\nThere's a wip that tries to elide most lazy-flags updates:\nhttps://github.com/copy/v86/pull/466\n\nFPU instructions are emulated using softfloat (very slow, but unfortunately\nsome code relies on 80 bit floats).\n"
},
{
"path": "docs/linux-9p-image.md",
"content": "In order to create a Linux image that can mount the 9p file system, add the following lines to the kernel configuration:\n\n```\nCONFIG_NET_9P=y\nCONFIG_NET_9P_VIRTIO=y\nCONFIG_NET_9P_DEBUG=y\nCONFIG_VIRTIO=y\nCONFIG_VIRTIO_PCI=y\nCONFIG_9P_FS=y\nCONFIG_9P_FSCACHE=y\nCONFIG_9P_FS_POSIX_ACL=y\n```\n\nA Dockerfile for this build is here: https://github.com/ysangkok/build-v86-9p-linux\n\nUsing initcpio\n--------------\n\nThis allows you to remount the root file system using 9p. No changes are necessary if you only want to mount a 9p filesystem after booting.\n\nAdd the following files:\n\n`/etc/initcpio/hooks/9p_root`\n\n```bash\n#!/usr/bin/bash\n\nrun_hook() {\n mount_handler=\"mount_9p_root\"\n}\n\nmount_9p_root() {\n msg \":: mounting '$root' on real root (9p)\"\n if ! mount -t 9p host9p \"$1\"; then\n echo \"You are now being dropped into an emergency shell.\"\n launch_interactive_shell\n msg \"Trying to continue (this will most likely fail) ...\"\n fi\n}\n```\n\n\n\n`/etc/initcpio/install/9p_root`\n\n```bash\n#!/bin/bash\nbuild() {\n\tadd_runscript\n}\n```\n\nChange the following options in `/etc/mkinitcpio.conf`:\n\n```bash\nMODULES=\"virtio_pci 9p 9pnet 9pnet_virtio\"\nHOOKS=\"base udev autodetect modconf block filesystems keyboard fsck 9p_root\" # appended 9p_root\n```\n"
},
{
"path": "docs/networking.md",
"content": "# v86 networking\n\nUser guide to networking in v86.\n\n## Introduction\n\nOn the most basic level, networking in v86 is comprised of two components:\n\n* an emulation of the guest's [Network Interface Controller](https://en.wikipedia.org/wiki/Network_interface_controller) (NIC), and\n* a network backend which passes ethernet frames between the NIC and a virtual and/or physical [ethernet network](https://en.wikipedia.org/wiki/Ethernet).\n\nThere are two **NIC emulations** supported by v86 to chose from, either **`ne2k`** (NE2000/RTL8390-compatible NIC) or **`virtio`** ([VirtIO](http://wiki.osdev.org/Virtio)-compatible device). The right choice simply depends on the driver support in the guest OS, older OSes like FreeDOS only support NE2000, more modern ones usually support VirtIO. In case both are supported by the guest OS it's recommended to try VirtIO first and only fall back to NE2000 if that fails. In some cases it will also be necessary to manually load a driver or similar to activate the NIC and/or networking in the guest OS, yet modern systems usually auto-detect an available NIC during installation and when booting.\n\nThere are also several **network backends** to chose from which emulate the network that the virtual NIC is connected to, they differ in their requirements and in the degree of network access and services provided to guests. Some provide only limited network access, others full access to a physical network which may include a gateway to the Internet. Backends may require a specific type of proxy server to operate.\n\n### Backend URL schemes\n\nThe active network backend is configured through a user-specified **backend URL**. Each backend has at least one distinct URL scheme as specified below, where `PROXY` is the DNS hostname or IP address of a compatible proxy server, `PORT` its optional TCP port number (and its default), and `QUERY` is some HTTP query field fragment:\n\n| Backend | Backend URL scheme(s) | Example(s) |\n| :------ | :-------------------- | :--------- |\n| **[inbrowser](#the-inbrowser-backend)** | `inbrowser` | `inbrowser` |\n| **[wsproxy](#the-wsproxy-backend)** | `\"ws://\" PROXY [\":\" PORT=80] [\"/\" ...]` `\"wss://\" PROXY [\":\" PORT=443] [\"/\" ...]` | `wss://relay.widgetry.org/` |\n| **[wisp](#the-wisp-backend)** | `\"wisp://\" PROXY [\":\" PORT=80] [\"/\" ...]` `\"wisps://\" PROXY [\":\" PORT=443] [\"/\" ...]` | `wisp://localhost:12345` |\n| **[fetch](#the-fetch-backend)** | `\"fetch\" [ \"://\" PROXY [\":\" PORT] [\"/\" QUERY] ]` | `fetch` `fetch://localhost:1234/?url=` |\n\nNote that `wss://` and `wisps://` are the TLS-secured transports of `ws://` and `wisp://`, respectively.\n\n> [!TIP]\n> Since public proxy servers provide only limited bandwidth it is recommended to install and use a local, private proxy server for best results. All proxy servers allow to be executed on the local machine, in a VM running on the local machine, in a local network or even publicly on the Internet (which is generally not recommended, of course). Many proxy servers are distributed as Docker containers which is the recommended way of installing them, otherwise install into a VM.\n\n## Network setup\n\n### Web interface setup\n\nNetwork setup in the v86 web interface at **https://copy.sh/v86/** is straightforward, simply copy the backend URL into the text box named **`Networking proxy`** or select one of the presets to configure the network backend. The guest's NIC emulation (NE2000 or VirtIO) is automatically configured when selecting the guest image in the web interface.\n\n### Embedded v86 setup\n\nJavaScript applications that do not use the v86 web interface (but instead embed V86 into their architecture) setup their network by using the common `config` object that they pass to the V86 constructor. Network settings are members of the object **`config.net_device`**, all settings are optional except for `relay_url`.\n\n#### General `net_device` settings\n\nCommon options in `config.net_device`:\n\n| net_device | type | description |\n| :------------ | :--- | :--- |\n| **type** | str | The type of emulated NIC provided to the guest OS, either `ne2k` or `virtio`. Default: `ne2k`. |\n| **relay_url** | str | The network backend URL, see [Backend URL schemes](#backend-url-schemes) for details. Note that the CORS proxy server of the `fetch` backend is defined in field `cors_proxy` below. This option is required. |\n| **id** | int | Network id, all v86 network instances with the same id share the same network namespace. Default: `0`. *(TODO: class `NetworkAdapter` should also get options.net_device as an argument, at least options.net_device.id).* |\n\n#### Special `net_device` settings\n\nBackends `fetch` and `wisp` support a couple of special settings in `config.net_device` to control virtual network components emulated by the backend:\n\n| net_device | type | description |\n| :------------- | :--- | :--- |\n| **router_mac** | str | MAC address of virtual network peers (ARP, PING, DHCP, DNS, NTP, UDP echo and TCP peers) in common MAC address notation. Default `52:54:0:1:2:3`. |\n| **router_ip** | str | IP address of virtual network peers (ARP, PING, DHCP, DNS and TCP peers) in dotted IP notation. Default `192.168.86.1`. |\n| **vm_ip** | str | IP address to be assigned to the guest by DHCP in dotted IP notation. Default `192.168.86.100`. |\n| **masquerade** | bool | If `True`, announce `router_ip` as the router's and DNS server's IP addresses in generated DHCP replies, and also generate ARP replies to IPs outside the router's subnet `255.255.255.0`. Default: `True`. |\n| **dns_method** | str | DNS method to use, either `static` or `doh`. `static`: use built-in DNS server, `doh`: use [DNS-over-HTTPS](https://en.wikipedia.org/wiki/DNS_over_HTTPS) (DoH). Defaults to `static` for `fetch` and to `doh` for `wisp` backend. |\n| **doh_server** | str | Host name or IP address (and optional port number) of the DoH server if `dns_method` is `doh`. The value is expanded to the URL `https://DOH_SERVER/dns-query`. Default: `cloudflare-dns.com`. |\n| **cors_proxy** | str | CORS proxy server URL, do not use a proxy if undefined. Default: undefined (`fetch` backend only). |\n| **mtu** | int | The MTU used for the virtual network. Increasing it can improve performance. This only works if the NIC type is `virtio`. Default: `1500` |\n\n#### Example `net_device` settings\n\n* **Example 1:** Provide an emulated NE2000 NIC to the guest OS and use the `wsproxy` backend with a secure wsproxy server at public host `relay.widgetry.org` listening at default TLS port 443:\n ```javascript\n let example_1 = new V86({\n net_device: {\n relay_url: \"wss://relay.widgetry.org/\"\n },\n // ...\n });\n ```\n\n* **Example 2:** Provide a VirtIO NIC to the guest OS and use the `fetch` backend with a CORS proxy server at the local machine listening at port number 23456:\n ```javascript\n let example_2 = new V86({\n net_device: {\n type: \"virtio\",\n relay_url: \"fetch\",\n cors_proxy: \"https://localhost:23456/?url=\"\n },\n // ...\n });\n ```\n\n## Network backends\n\nOne way to compare the different network backends is how they operate on different layers of the TCP/IP Model (see [Wikipedia](https://en.wikipedia.org/wiki/OSI_model#Comparison_with_TCP/IP_model) for a comparison to the OSI model), approximately:\n\n Network Peer Backend v86 Guest\n\n [ Application ] <---- fetch ----> +-----+ [ Application ]\n [ Transport ] <---- wisp -----> | v86 | [ Transport ]\n [ Network ] | | [ Network ]\n [ Access ] <--- wsproxy ---> +-----+ <---> [ Access ]\n and inbrowser\n\n Fig. 1: Network backends in v86\n\nv86 guests strictly expect to exchange raw ethernet frames with their (emulated) network card, hence the higher the layer that a v86 network backend operates on the more virtualized the network becomes and the more work has to be done by the backend to fill in for the missing layers.\n\nIn order to facilitate this for backend implementations, v86 provides helper functions to encode/decode ethernet frames, ARP and IPv4 packets, UDP datagrams, TCP streams and HTTP requests/responses. v86 can also provide minimal but sufficient ARP, ICMP-echo, DHCP, DNS (including DoH) and NTP services to guests.\n\nThe v86 architecture is open for additional network backend implementations, for a basic example see [examples/two_instances.html](../examples/two_instances.html).\n\n### The `inbrowser` backend\n\nThis backend provides raw ethernet services for multiple v86 guests running within the same browser process (meaning within the same web page and/or in separate browser tabs). It works standalone without a proxy server, but it also does not provide any access to external networks.\n\nThe `inbrowser` backend is implemented using the browser-internal [BroadcastChannel](https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel) API, due to its simplicity it is the most efficient backend, however all VMs have to share the same browser resources.\n\n### The `wsproxy` backend\n\nA backend based on a proxy server that provides raw ethernet services to guests using the [WebSocket](https://en.wikipedia.org/wiki/WebSocket) protocol for transport. It depends on the specific proxy server what kind of network configuration it presents to guests, but usually a separate IP subnet with DHCP and DNS services and optional access to the server's physical network and possibly Internet are provided.\n\nSince this backend (including its proxy server) only forwards unmodified ethernet frames it is inherently efficient while providing full physical network emulation to guests.\n\n**Proxy server**\n\n* **[websockproxy](https://github.com/benjamincburns/websockproxy)** -- one TAP device for all clients, integrates dnsmasq for DHCP/DNS, no TLS, original server by benjamincburns\n * Docker container [`benjamincburns/jor1k-relay`](https://hub.docker.com/r/benjamincburns/jor1k-relay) is throttled, see [this comment](https://github.com/benjamincburns/websockproxy/issues/4#issuecomment-317255890)\n * Docker container [`bellenottelling/websockproxy`](https://hub.docker.com/r/bellenottelling/websockproxy) is unthrottled\n * [See here](https://github.com/copy/v86/discussions/1175#discussioncomment-11199254) for step-by-step instructions on how to unthrottle websockproxy manually.\n* **[go-websockproxy](https://github.com/gdm85/go-websockproxy)** -- one TAP device for all clients, written in Go, without integraded DHCP but with integrated TLS support\n* **[node-relay](https://github.com/krishenriksen/node-relay)** -- like websockproxy but written for NodeJS (dnsmasq/no TLS), see [New websocket ethernet switch built using Node.js #777](https://github.com/copy/v86/discussions/777)\n* **[wsnic](https://github.com/chschnell/wsnic)** -- uses a single bridge and one TAP device per client, integrates dnsmasq for DHCP/DNS and stunnel for TLS\n* **[RootlessRelay](https://github.com/obegron/rootlessRelay)** -- uses its own network stack that doesn't require TUN/TAP devices, has a built-in reverse proxy and admin interface, see [RootlessRelay #1442](https://github.com/copy/v86/discussions/1442)\n\n[See here](https://github.com/copy/v86/discussions/1199#discussioncomment-12026845) for a benchmark comparing the download performance of these proxy servers.\n\n### The `wisp` backend\n\nThe `wisp` backend implements the client side of the [WISP protocol](https://github.com/MercuryWorkshop/wisp-protocol). WISP is a client/server protocol designed to exchange messages containing UDP and TCP payloads between a WebSocket client and a WISP-compatible proxy server. Note that WISP transports only the packet payloads, not the raw UDP or TCP packets.\n\nThis backend monitors outbound traffic from guests and wraps/unwraps TCP payload data in WISP messages. A TCP state machine is included to terminate the guest's TCP stream. In addition to the TCP stream, virtual replies to ARP, DHCP, DNS, NTP, ICMP-Ping and UDP-Echo requests from guests are generated (to a certain degree). See PR [#1097](https://github.com/copy/v86/pull/1097) for additional information about this backend.\n\nv86 guests are isolated from each other when using the `wisp` backend.\n\n**WISP-compatible proxy server**\n\n* **[wisp-js](https://www.npmjs.com/package/@mercuryworkshop/wisp-js)**\n* **[epoxy-tls](https://github.com/MercuryWorkshop/epoxy-tls)**\n\n> [!NOTE]\n> The WISP protocol only supports UDP and TCP client sockets in the v86 guest, any server sockets listening in the guest are not supported.\n\n> [!NOTE]\n> This WISP implementation does not support UDP, only TCP. Once UDP is added, regular DNS over UDP will become the default (instead of DoH), and the builtin NTP and UDP-Echo servers will be removed.\n\n### The `fetch` backend\n\nThe `fetch` backend uses the browser's [`fetch()`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) API to allow guests to send HTTP requests to external HTTP servers and to receive related HTTP responses. This is however complicated by the fact that browsers add [CORS headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) to HTTP requests initiated by `fetch()`, and that they check the CORS headers of related HTTP responses to block access to external web resources not authorized to `fetch()` in the given context.\n\nThis backend is efficient and very useful in cases where CORS is not in the way, otherwise (and in general) a CORS proxy server must be used to provide access to HTTP servers on the open Internet.\n\nLike the [`wisp`](#the-wisp-backend) backend, the `fetch` backend handles DHCP and ARP requests from guests internally, and additionally monitors the guest's outbound traffic for HTTP requests which it translates into calls to `fetch()`. NTP, ICMP pings and UDP echo packets are handled to a certain degree. Note that `fetch()` performs the DNS lookup using the browser's internal DNS client. See PR [#1061](https://github.com/copy/v86/pull/1061) for additional technical details.\n\nStarting with PR [#1233](https://github.com/copy/v86/pull/1233), the TCP guest listener can be accessed from JS API, see the [examples/tcp_terminal.html](../examples/tcp_terminal.html) example.\n\nv86 guests are isolated from each other when using the `fetch` backend.\n\nv86 guests have HTTP access to the host's `localhost` using the URL `http://.external` (e.g. `1234.external` -> `localhost:1234`).\n\n**CORS proxy server**\n\n* **[cors-anywhere](https://github.com/Rob--W/cors-anywhere)** -- NodeJS\n* **[uncors](https://github.com/chschnell/uncors)** -- A simple PHP-based CORS proxy server for Apache2.\n\n> [!TIP]\n> You can pass the following flags to **chromium** to allow browsing without restrictions when using the fetch backend:\n>\n> --disable-web-security --user-data-dir=/tmp/test\n>\n> **NOTE:** This turns off the same-origin policy and should only be used temporarily!\n\n## Related topics\n\n### v86 run-time state images\n\nv86 supports saving and restoring the guest's and emulator's run-time state in **state image** files.\n\nWhen restoring a state image, v86 randomises the restored guest's MAC address to make sure that multiple VMs restored from the same state image use different MAC addresses. However, the restored guest OS is unaware that its NIC's MAC address has changed which prevents it from sending and receiving packets correctly. There are several workarounds:\n\n- Unload the network driver before saving the state. On Linux, unloading can be\n done using `rmmod ne2k-pci` or `echo 0000:00:05.0 >\n /sys/bus/pci/drivers/ne2k-pci/unbind` and loading (after the state has been\n loaded) using `modprobe ne2k-pci` or `echo 0000:00:05.0 >\n /sys/bus/pci/drivers/ne2k-pci/bind`\n- Pass `preserve_mac_from_state_image: true` to the V86 constructor. This\n causes MAC addresses to be shared between all VMs with the same state image.\n- Pass `mac_address_translation: true` to the V86 constructor. This causes v86\n to present the old MAC address to the guest OS, but translate it to a\n randomised MAC address in outgoing packets (and vice-versa for incoming\n packets). This mechanism currently only supports the ethernet, ipv4, dhcp and\n arp protcols. See `translate_mac_address` in\n [`src/ne2k.js`](https://github.com/copy/v86/blob/master/src/ne2k.js). This is\n currently used in Windows, ReactOS and SerenityOS profiles.\n- Some OSes don't cache the MAC address when the driver loads and therefore\n don't need any of the above workarounds. This seems to be the case for Haiku,\n OpenBSD and FreeBSD.\n\nNote that the same applies to IP addresses, so a DHCP client should only be run\nafter the state has been loaded.\n\n### NodeJS\n\nNetwork backends `wsproxy` and `wisp` depend on a browser-compatible `WebSocket` constructor being present which is the case since NodeJS v22, backends `inbrowser` and `fetch` should work straightaway.\n\n## Links\n\n* [`examples/two_instances.html`](../examples/two_instances.html), example code that shows how to connect two VMs in a web page with a virtual ethernet crossover cable.\n* [`examples/broadcast-network.html`](../examples/broadcast-network.html), example code that shows the raw packet API.\n* [`examples/tcp_terminal.html`](../examples/tcp_terminal.html), example code that shows how to communicate with a guest TCP port on the `fetch` backend.\n* [DC through windows OS for experimental lab #1195](https://github.com/copy/v86/discussions/1195), demonstrates how to setup a Domain Controller for two Windows VMs (XP and Server 2003) using a virtual crossover cable.\n* [Working on a new cross-platform network relay that is a full virtualized network #1064](https://github.com/copy/v86/discussions/1064) (used in [env86 #1085](https://github.com/copy/v86/discussions/1085))\n"
},
{
"path": "docs/profiling.md",
"content": "v86 has a built-in profiler, which instruments generated code to count certain\nevents and types of instructions. It can be used by building with `make\ndebug-with-profiler` and opening debug.html.\n\nFor debugging networking, packet logging is available in the UI in both debug\nand release builds. The resulting `traffic.hex` file can be loaded in Wireshark\nusing file -> import from hex -> tick direction indication, timestamp %s.%f.\n"
},
{
"path": "docs/sse-shifts.txt",
"content": " 0F F1 PSLLW \tmm \tmm/m64 \t mmx \t Shift Packed Data Left Logical\n66 0F F1 PSLLW \txmm \txmm/m128 sse2 \t Shift Packed Data Left Logical\n 0F F2 PSLLD \tmm \tmm/m64 \t mmx \t Shift Packed Data Left Logical\n66 0F F2 PSLLD \txmm \txmm/m128 sse2 \t Shift Packed Data Left Logical\n 0F F3 PSLLQ \tmm \tmm/m64 \t mmx \t Shift Packed Data Left Logical\n66 0F F3 PSLLQ \txmm \txmm/m128 sse2 \t Shift Packed Data Left Logical\n\n 0F E1 PSRAW \tmm \tmm/m64 \t mmx Shift Packed Data Right Arithmetic\n66 0F E1 PSRAW \txmm \txmm/m128 sse2\t Shift Packed Data Right Arithmetic\n 0F E2 PSRAD \tmm \tmm/m64 \t mmx\t Shift Packed Data Right Arithmetic\n66 0F E2 PSRAD \txmm \txmm/m128 sse2\t Shift Packed Data Right Arithmetic\n\n 0F D1 PSRLW \tmm \tmm/m64 \t mmx \t Shift Packed Data Right Logical\n66 0F D1 PSRLW \txmm \txmm/m128 sse2 \t Shift Packed Data Right Logical\n 0F D2 PSRLD \tmm \tmm/m64 \t mmx \t Shift Packed Data Right Logical\n66 0F D2 PSRLD \txmm \txmm/m128 sse2 \t Shift Packed Data Right Logical\n 0F D3 PSRLQ \tmm \tmm/m64 \t mmx \t Shift Packed Data Right Logical\n66 0F D3 PSRLQ \txmm \txmm/m128 sse2 \t Shift Packed Data Right Logical\n\n 0F 71 PSRLW \tmm \timm8 \t mmx \t Shift Packed Data Right Logical\n66 0F 71 PSRLW \txmm \timm8 \t sse2 \t Shift Packed Data Right Logical\n 0F 71 PSRAW \tmm \timm8 \t mmx \t Shift Packed Data Right Arithmetic\n66 0F 71 PSRAW \txmm \timm8 \t sse2 \t Shift Packed Data Right Arithmetic\n 0F 71 PSLLW \tmm \timm8 \t mmx \t Shift Packed Data Left Logical\n66 0F 71 PSLLW \txmm \timm8 \t sse2 \t Shift Packed Data Left Logical\n\n 0F 72 PSRLD \tmm \timm8 \t mmx \t Shift Double Quadword Right Logical\n66 0F 72 PSRLD \txmm \timm8 \t sse2 \t Shift Double Quadword Right Logical\n 0F 72 PSRAD \tmm \timm8 \t mmx \t Shift Packed Data Right Arithmetic\n66 0F 72 PSRAD \txmm \timm8 \t sse2 \t Shift Packed Data Right Arithmetic\n 0F 72 PSLLD \tmm \timm8 \t mmx \t Shift Packed Data Left Logical\n66 0F 72 PSLLD \txmm \timm8 \t sse2 \t Shift Packed Data Left Logical\n\n 0F 73 PSRLQ \tmm \timm8 \t mmx \t Shift Packed Data Right Logical\n66 0F 73 PSRLQ \txmm \timm8 \t sse2 \t Shift Packed Data Right Logical\n66 0F 73 PSRLDQ \txmm \timm8 \t sse2 \t Shift Double Quadword Right Logical\n 0F 73 PSLLQ \tmm \timm8 \t mmx \t Shift Packed Data Left Logical\n66 0F 73 PSLLQ \txmm \timm8 \t sse2 \t Shift Packed Data Left Logical\n66 0F 73 PSLLDQ \txmm \timm8 \t sse2 \t Shift Double Quadword Left Logical\n"
},
{
"path": "docs/windows-9x.md",
"content": "## Installing using QEMU\n\nRecommended versions:\n - Windows 95 OSR2(.5)\n - Windows 98 Second Edition (SE)\n\n-------------\n\n1. Create a disk image (up to 2 GB):\n```sh\nqemu-img create -f raw hdd.img M\n```\n2. Run QEMU with the following settings:\n```sh\nqemu-system-i386 -m 128 -M pc,acpi=off -drive file=hdd.img,format=raw\n```\n - add `-cdrom /path/to/installCD.iso`, if you use a CD version.\n - add `-fda /path/to/boot_floppy.img -boot a`, if you use a floppy version or your install CD is non-bootable.\n - (optionally) add `-device sb16` to enable sound\n - (optionally) add `-nic user,model=ne2k_pci` or `-device ne2k_pci,netdev=<...>` to enable networking\n\n3. For Windows 98: select \"Start Windows 98 Setup from CD-ROM\". For Windows 95: select \"Load NEC IDE CDROM driver\" and run `fdisk` to create partition, restart emulator, run `format c:` and `D:\\WIN95\\SETUP`.\n\n4. To change floppy disk, press *Ctrl+Alt+2* to switch to the QEMU Monitor, run `change floppy0 /path/to/new_floppy_image` and press *Ctrl+Alt+1* to switch to VGA.\n5. Follow the installation guide on the screen.\n\n> [!TIP]\n> For transfer files from host to guest, use [genisoimage](https://wiki.debian.org/genisoimage) ([UltraISO](https://www.ultraiso.com/) and [PowerISO](https://www.poweriso.com/) for Windows and Mac) for creating CD-ISO image or [dosfstools](https://github.com/dosfstools/dosfstools) ([WinImage](https://www.winimage.com/download.htm) for Windows) for creating floppy disk images, then mount the created image to QEMU.\n\n## Troubleshooting\n\n### \"Windows protection\" errors during startup\n\nApply [FIX95CPU](http://lonecrusader.x10host.com/fix95cpu.html) or [patcher9x](https://github.com/JHRobotics/patcher9x#installation).\n\n### \"VFBACKUP could no load VFD.VXD\" on startup (Windows 95)\n\n**Workaround #1**:\n*Source: [#1185](https://github.com/copy/v86/issues/1185)*\n\n1. Mount the installation CD (or `Disk 3` for the RTM version on floppy disks).\n2. Open the \"MS-DOS prompt\" and run:\n\nFor the CD version:\n```bat\nextract /a /l C:\\Windows\\System :\\WIN95\\WIN95_02.CAB vfd.vxd\n```\n\nFor the floppy version:\n```bat\nextract /a /l C:\\Windows\\System :\\WIN95_03.CAB vfd.vxd\n```\n\n**Workaround #2**:\n*Source: [#289](https://github.com/copy/v86/issues/289)*\n\n1. Open the Start menu, click on \"Run\" and run `sysedit`.\n2. Find `C:\\AUTOEXEC.BAT` and add `smartdrv` to the top of the file.\n3. Press File -> Save.\n\n## Floppy disk support\n\nCurrently, the floppy drive in v86 works only with MS-DOS compatibility mode.\n\nTo check this: open the Start menu, click on \"Control Panel\" and \"System\", select \"Performance\" tab.\nIf it says *\"Drive A is using MS-DOS compatibility mode file system\"*, the floppy drive should work properly in v86. If not, try this solution:\n\n1. Click on \"Device Manager\" in \"System Properties\".\n2. Open \"Floppy disk controllers\", select \"Standard Floppy Disk Controller\" and press \"Remove\" at the bottom.\n3. Restart Windows.\n\n## Enabling True Color (32 bpp)\n\nThe default VGA display driver only supports 640x480x4 video mode, to fix this, you can install **Universal VBE9x Video Display Driver** or **VMDisp9x**.\n\n### Universal VBE9x Video Display Driver\n\n> [!WARNING]\n> After installing, DOS Mode (and other programs and games that require it) may not work properly.\n> This is a problem in VBE9x, not v86, see [#110](https://github.com/copy/v86/issues/110).\n> Also, this driver doesn't support DirectX, DirectDraw and OpenGL.\n\n1. Download driver from https://bearwindows.zcm.com.au/vbe9x.htm and unpack into Windows.\n2. Right-click on the Desktop, click on \"Properties\".\n3. Click \"Advanced\" > \"Adapter\" > \"Change\".\n4. Press \"Next\", select \"Display a of all the drivers in a specific location...\" and press again \"Next\".\n5. Press \"Have Disk...\", click \"Browse\" and go to folder with unpacked driver. Inside the folder with driver, should be folders like `032mb`, `064mb`, `128mb`. Choose a version based on needed video memory size (for example, `032mb`), then select `vbemp.inf` inside.\n6. Select \"VBE Miniport\" adapter, press \"OK\" and \"Next\".\n7. After installing, restart Windows.\n\n### VMDisp9x (Windows 95)\n\n> [!WARNING]\n> This driver can run DOS Mode with some graphical glitches. However, DirectX and/or DirectDraw may not work properly with this driver.\n> Also, this driver doesn't support OpenGL.\n\n1. Download `vmdisp9x-<...>-driver-2d.img` from https://github.com/JHRobotics/vmdisp9x/releases.\n2. Mount as floppy image, right-click on the Desktop, click on \"Properties\".\n3. Click \"Advanced\" > \"Adapter\" > \"Change\".\n4. Press \"Have Disk...\", click \"Browse\" and go to the floppy.\n5. Select \"VESA ISA\" adapter and press \"OK\".\n6. After installing, restart Windows.\n\n## CPU idling on Windows 95\nSee about [installing AmnHLT](cpu-idling.md#windows-9x-using-amnhlt).\n\n## Enabling networking on Windows 95 (requires install CD)\n\n1. Open the Start menu, click on \"Control Panel\" and \"Add New Hardware\".\n2. Press \"Next\", select \"No\" and select next options:\n\n| Option | Value |\n|:--------------|:------------------|\n| Hardware type | Network adapters |\n| Manufacturers | Novell |\n| Models | NE2000 Compatible |\n\n3. Press \"Next\" and restart Windows.\n4. After restarting, right-click on \"My computer\", select \"Propeties\".\n5. Open \"Device Manager\" tab, select \"NE2000 Compatible\" (in \"Network adapters\") and press \"Properties\"\n6. Open \"Resources\", change values by selecting the properties and click on \"Change Setting\":\n\n| Option | Value |\n|:-------------------|:------------|\n| Interrupt Request | 10 |\n| Input/Output Range | 0300 - 031F |\n\n7. In \"Control Panel\", open \"Network\", click on \"Add\", choose \"Protocol\" and select the following options:\n\n| Option | Value |\n|:------------------|:----------|\n| Manufacturers | Microsoft |\n| Network Protocols | TCP/IP |\n\n8. (optionally) Set \"Primary Network Logon\" to `Windows Logon`.\n\n## Enabling sound manually\n\n> [!NOTE]\n> If you don't have an install CD, use the Sound Blaster 16 driver from https://web.archive.org/web/20210814023225/https://www.claunia.com/qemu/drivers/index.html (unpack `sbw9xup.exe` as a zip archive).\n\n1. Open \"Start\" menu, click on \"Control Panel\" and \"Add New Hardware\".\n2. Press \"Next\", select \"No\" and select the following options:\n\n| Option | Value |\n|:--------------|:-----------------------------------------|\n| Hardware type | Sound, video and game cotrollers |\n| Manufacturers | Creative Labs |\n| Models | Creative Labs Sound Blaster 16 or AWE-32 |\n\n3. Restart Windows.\n"
},
{
"path": "docs/windows-nt.md",
"content": "\n - [Windows NT 3.1](#windows-nt-31) / [3.51](#windows-nt-351) / [4.0](#windows-nt-40)\n - [Windows 2000/XP](#windows-2000xp)\n - [Windows Vista and newer](#windows-vista-and-newer)\n\n------------------------\n## Windows NT 3.1\n\n### Installing using QEMU\n\n1. Install MS-DOS and [Oak CD-ROM Driver](https://www.dosdays.co.uk/topics/Software/optical_downloads.php).\n2. Create 4 blank floppy disk images:\n\n - run `qemu-img create -f raw floppy.img 1440K`\n - mount (`-fda floppy.img`) and run `format A:` in a VM\n\n3. Run QEMU with the following settings for installation:\n\n```sh\nqemu-system-i386 -m 64 -drive file=hdd.img,format=raw -cpu pentium -M pc,acpi=off -cdrom InstallCD.iso\n```\n\n4. Run `xcopy /v :\\I386\\ C:\\install\\` in a VM to copy all files, disable the CD-ROM driver.\n5. Run QEMU with the following settings:\n\n```sh\nqemu-system-i386 -m 64 -drive file=hdd.img,format=raw -cpu pentium -M pc,acpi=off\n```\n\n6. Run `C:\\install\\winnt /F /C` in a VM.\n7. Follow the setup instructions. To change floppy disk, press *Ctrl+Alt+2* to switch to the QEMU Monitor, run `change floppy0 /path/to/new_floppy_image` and press *Ctrl+Alt+1* to switch to VGA.\n\n\n## Windows NT 3.51\n\n### Installing\n\n> [!NOTE]\n> In newer versions of QEMU, the Windows Setup may not work, you can use an older version of QEMU, PCem, 86Box or PCBox instead.\n\n1. If you install via MS-DOS, install [the Oak CD-ROM Driver](https://www.dosdays.co.uk/topics/Software/optical_downloads.php) and run `:\\I386\\WINNT /B`.\n2. Follow the setup instructions.\n3. After installing, download NT 3.51 SuperPack ([here](https://bearwindows.zcm.com.au/winnt351.htm#4) or [here](https://alter.org.ua/en/soft/nt_spack/nt3/)), unpack the archive into a Windows and copy files from `FAT32` (`SYS\\FAT32`) and `RENEW` (`SYS\\RENEW`) folders in `C:\\WINNT35\\system32\\drivers` with replacing.\n\n### Enabling networking\n\n1. Open \"Control Panel\" > \"Network\", install Windows NT Networking (installation CD required).\n2. In \"Network Adapter Card Detection\", press Continue three times, set `Network Adapter Card: Novell NE2000 Compatible Adapter`.\n3. Set the following settings and click Continue:\n\n```\nIRQ Level: 10\nI/O Port Address: 0x300\n```\n\n4. In \"Bus Location\", press OK. Check the boxes \"TCP/IP Transport\" and \"Enable Automatic DHCP Configuration\" in the next window.\n5. In \"TCP/IP Configuration\", check the box \"Enable Automatic DHCP Configuration\".\n6. Restart the VM.\n\n\n## Windows NT 4.0\n\nRecommended version: Windows NT 4.0 SP1\n\n### Installing using QEMU\n\n1. Run QEMU with the following settings for installation:\n\n```sh\nqemu-system-i386 -m 64 -drive file=hdd.img,format=raw -cdrom InstallCD.iso -cpu pentium -M pc,acpi=off\n```\n\n2. On setup startup, press F5 and select \"Standard PC\".\n3. Follow the setup instructions.\n\n### Running in v86\n\nDue to a problem with CPUID, you need to add `cpuid_level: 2` and `acpi: false` to the V86 constructor (not supported in the UI):\n\n```js\nvar emulator = new V86({\n ...\n cpuid_level: 2,\n acpi: false\n});\n```\n\n\n## Windows 2000/XP\n\n### Installing using QEMU\n\n1. Run QEMU with the following settings for installation:\n\n```sh\nqemu-system-i386 -m 512 -drive file=hdd.img,format=raw -cdrom InstallCD.iso\n```\n\nOptional:\n - add `-device sb16` to enable sound\n - add `-nic user,model=ne2k_pci` or `-device ne2k_pci,netdev=<...>` to enable networking\n\n2. Follow the setup instructions.\n3. This step fixes the error `Uncaught RangeError: Maximum call stack size exceeded` in Chromium during Windows 2000/XP startup in v86.\n\nAfter installation, change the computer type to \"Standard PC\" as described [here](http://web.archive.org/web/20220528021535/https://www.scm-pc-card.de/file/manual/FAQ/acpi_uninstallation_windows_xp_english.pdf):\n1. Open Start menu, right-click on \"My Computer\", select \"Manage\"\n2. Open Device Manager, open Computer, right-click on \"ACPI Uniprocessor PC\"\n3. Select \"Update Driver...\" > \"No, not this time\"\n4. Select \"Install from a list or specific location (Advanced)\" > Next > \"Don't search. I will choose the driver to install.\"\n5. Choose \"Standard PC\", press Next > Finish.\n6. Restart the VM, follow multiple \"Found New Hardware Wizard\" dialogs with default options.\n\n### Enabling True Color (for Windows 2000)\n\n> [!NOTE]\n> This driver doesn't support DirectX, DirectDraw and OpenGL.\n\n1. Download driver from https://bearwindows.zcm.com.au/vbemp.htm and unpack into Windows.\n2. Open Start menu, right-click on \"My Computer\", select \"Manage\"\n3. Open Device Manager, open Computer and right-click on \"Video Controller\".\n4. Press \"Properties\", select \"Driver\" tab and press \"Update Driver\".\n5. Select \"Display a list of the known drivers for this device...\", choose \"Display adapters\".\n5. Press \"Have Disk...\", click \"Browse\" and go to folder with unpacked driver. Go to `VBE20\\W2K\\PNP`, then select `vbemppnp.inf` inside.\n6. Select \"VBE Miniport\" adapter, press \"Yes\" and \"Next\".\n7. After installing, restart the VM.\n\n### Enabling sound\n\n*Source: [#1049](https://github.com/copy/v86/issues/1049)*\n\n1. Right-click on \"My computer\" > \"System Properties\", select \"Hardware\" tab, press \"Hardware Wizard\"\n2. Press \"Next\" > \"Add/Troubleshoot a device\" > \"Add a new device\"\n3. Select \"No, I want to select the hardware from a list\" > \"Sound, video and game controllers\"\n4. Select the following options and press \"Next\":\n\n```\nHardware type: Sound, video and game cotrollers\nManufacturers: Creative Technology Ltd.\nModels: Sound Blaster 16 or AWE32 or compatible (WDM)\n```\n\n\n## Windows Vista and newer\n\n### Installing using QEMU\n\n1. Run QEMU with the following settings for installation:\n\n```sh\nqemu-system-i386 -m 1024 -drive file=hdd.img,format=raw -cdrom InstallCD.iso\n```\n\nOptionally add `-accel kvm` (for Linux host), `-accel whpx` (for Windows host) or `-accel hvf` (for MacOS host) to use hypervisor acceleration.\n\n2. Follow the setup instructions.\n\n### Running in v86\n\nEnable ACPI and set the memory size to 512 MB or more.\n\n### Enabling networking (ne2k)\n\n*Source: https://phaq.phunsites.net/2007/05/21/vista-on-xen-using-ne2000-in-favor-to-rtl8139/*\n\n1. Download https://phaq.phunsites.net/files/2007/05/drivercd.iso_.zip, unpack the archive, mount the ISO to the VM (`-cdrom path/to/drivercd.iso` or `change ide1-cd0 path/to/drivercd.iso` in QEMU Monitor), unpack the archive from CDROM into Windows.\n2. Open Start Menu > \"Control Panel\" > \"System\" > \"Device Manager\"\n3. Right-click on \"Ethernet Controller\" > \"Update Driver Software\", press \"Browse my computer for driver software\".\n4. Click \"Browse\" and go to folder with unpacked driver, select `WIN2000` folder, press \"Install this driver software anyway\".\n"
},
{
"path": "eslint.config.mjs",
"content": "export default [\n {\n \"languageOptions\": {\n \"globals\": {\n \"process\": \"readonly\",\n \"window\": \"writable\",\n \"navigator\": \"writable\",\n \"location\": \"writable\",\n \"document\": \"readonly\",\n \"console\": \"readonly\",\n \"crypto\": \"readonly\",\n \"alert\": \"readonly\",\n \"performance\": \"readonly\",\n \"URL\": \"readonly\",\n \"WebAssembly\": \"readonly\",\n\n \"setTimeout\": \"readonly\",\n \"setInterval\": \"readonly\",\n \"clearTimeout\": \"readonly\",\n \"clearInterval\": \"readonly\",\n \"requestAnimationFrame\": \"readonly\",\n \"cancelAnimationFrame\": \"readonly\",\n\n \"Buffer\": \"readonly\",\n \"FileReader\": \"readonly\",\n \"TextEncoder\": \"readonly\",\n \"TextDecoder\": \"readonly\",\n \"fetch\": \"readonly\",\n \"Headers\": \"readonly\",\n \"Response\": \"readonly\",\n \"WebSocket\": \"readonly\",\n \"Blob\": \"readonly\",\n \"File\": \"readonly\",\n \"XMLHttpRequest\": \"readonly\",\n \"URLSearchParams\": \"readonly\",\n \"ImageData\": \"readonly\",\n \"Image\": \"readonly\",\n \"OffscreenCanvas\": \"readonly\",\n \"BroadcastChannel\": \"readonly\",\n \"HTMLElement\": \"readonly\",\n \"HTMLTextAreaElement\": \"readonly\",\n\n \"AudioContext\": \"readonly\",\n \"AudioWorkletProcessor\": \"readonly\",\n \"webkitAudioContext\": \"readonly\",\n \"AudioWorkletNode\": \"readonly\",\n \"Worker\": \"readonly\",\n \"postMessage\": \"readonly\",\n \"importScripts\": \"readonly\",\n\n \"DEBUG\": \"writable\"\n }\n },\n rules: {\n \"eol-last\": \"error\",\n //\"no-extra-parens\": \"error\",\n \"no-trailing-spaces\": \"error\",\n \"no-extra-semi\": \"error\",\n \"no-tabs\": \"error\",\n \"quotes\": [\"error\", \"double\", { \"avoidEscape\": true, \"allowTemplateLiterals\": true }],\n \"keyword-spacing\": [\"error\", { \"overrides\": {\n \"if\": { \"after\": false },\n \"for\": { \"after\": false },\n \"while\": { \"after\": false },\n \"switch\": { \"after\": false },\n \"catch\": { \"after\": false },\n } }],\n \"semi\": \"error\",\n \"no-useless-return\": \"error\",\n \"eqeqeq\": \"error\",\n \"no-multiple-empty-lines\": [\"error\", { \"max\": 2, \"maxBOF\": 0, \"maxEOF\": 0 }],\n //\"no-var\": \"error\",\n \"radix\": \"error\",\n \"comma-style\": [\"error\", \"last\"],\n //\"comma-dangle\": [\"error\", \"always-multiline\"],\n \"no-sequences\": \"error\",\n //\"one-var\": [\"error\", \"never\"],\n \"constructor-super\": \"error\",\n \"for-direction\": \"error\",\n \"getter-return\": \"error\",\n \"no-async-promise-executor\": \"error\",\n //\"no-case-declarations\": \"error\",\n \"no-class-assign\": \"error\",\n \"no-compare-neg-zero\": \"error\",\n \"no-cond-assign\": \"error\",\n \"no-const-assign\": \"error\",\n \"no-constant-binary-expression\": \"error\",\n //\"no-constant-condition\": \"error\",\n //\"no-control-regex\": \"error\",\n //\"no-debugger\": \"error\",\n \"no-delete-var\": \"error\",\n \"no-dupe-args\": \"error\",\n \"no-dupe-class-members\": \"error\",\n //\"no-dupe-else-if\": \"error\",\n \"no-dupe-keys\": \"error\",\n \"no-duplicate-case\": \"error\",\n //\"no-empty\": \"error\",\n \"no-empty-character-class\": \"error\",\n \"no-empty-pattern\": \"error\",\n \"no-empty-static-block\": \"error\",\n \"no-ex-assign\": \"error\",\n \"no-extra-boolean-cast\": \"error\",\n \"no-fallthrough\": \"error\",\n \"no-func-assign\": \"error\",\n \"no-global-assign\": \"error\",\n \"no-import-assign\": \"error\",\n \"no-invalid-regexp\": \"error\",\n \"no-irregular-whitespace\": \"error\",\n \"no-loss-of-precision\": \"error\",\n \"no-misleading-character-class\": \"error\",\n \"no-new-native-nonconstructor\": \"error\",\n \"no-nonoctal-decimal-escape\": \"error\",\n \"no-obj-calls\": \"error\",\n \"no-octal\": \"error\",\n \"no-prototype-builtins\": \"error\",\n //\"no-redeclare\": \"error\",\n \"no-regex-spaces\": \"error\",\n \"no-self-assign\": \"error\",\n \"no-setter-return\": \"error\",\n \"no-shadow-restricted-names\": \"error\",\n \"no-sparse-arrays\": \"error\",\n \"no-this-before-super\": \"error\",\n \"no-undef\": \"error\",\n \"no-unexpected-multiline\": \"error\",\n //\"no-unreachable\": \"error\",\n \"no-unsafe-finally\": \"error\",\n \"no-unsafe-negation\": \"error\",\n \"no-unsafe-optional-chaining\": \"error\",\n \"no-unused-labels\": \"error\",\n \"no-unused-private-class-members\": \"error\",\n //\"no-unused-vars\": \"error\",\n \"no-useless-backreference\": \"error\",\n \"no-useless-catch\": \"error\",\n //\"no-useless-escape\": \"error\",\n \"no-with\": \"error\",\n \"require-yield\": \"error\",\n \"use-isnan\": \"error\",\n \"valid-typeof\": \"error\",\n \"strict\": \"error\"\n }\n }\n];\n"
},
{
"path": "examples/alpine.html",
"content": "\nAlpine\n\n\n
\n \n \n
\n"
},
{
"path": "examples/arch.html",
"content": "\nArchlinux\n\n\n\n\n\nRestore from file: \n\n\n\n
\n \n \n
\n"
},
{
"path": "examples/async_load.html",
"content": "\nAsynchronous loading of disk images\n\n\n\n\n
\n# This example allows network across multiple browser tabs by using BroadcastChannels.\n\n# Configure a static IP\nifconfig eth0 up arp 10.5.0.x\n\n# Ping by IP\nping 10.5.0.x\n\n# Run a DNS server and send a query (10.5.0.x for server, 10.5.0.y for record)\necho \"anotherhost 10.5.0.y\" | dnsd -c - -v - server\nnslookup -type=a anotherhost 10.5.0.x - client\n\n# Telnet calculator\nsocat TCP-L:23,fork exec:bc\n\n# Simple HTTP server\nsocat TCP-L:80,crlf,fork system:'echo HTTP/1.1 200 OK;echo;lua /root/test.lua'\n
\n\n\n\n\n\n\n \nVersion: 98e7110c2 (Feb 16, 2021 12:02)\n\n\nEnable debug\n—\nReadme\n—\nProject on Github\n—\nCompatibility\n"
},
{
"path": "lib/9p.js",
"content": "// -------------------------------------------------\n// --------------------- 9P ------------------------\n// -------------------------------------------------\n// Implementation of the 9p filesystem device following the\n// 9P2000.L protocol ( https://code.google.com/p/diod/wiki/protocol )\n\nimport { LOG_9P } from \"./../src/const.js\";\nimport { VirtIO, VIRTIO_F_VERSION_1, VIRTIO_F_RING_EVENT_IDX, VIRTIO_F_RING_INDIRECT_DESC } from \"../src/virtio.js\";\nimport { S_IFREG, S_IFDIR, STATUS_UNLINKED } from \"./filesystem.js\";\nimport * as marshall from \"../lib/marshall.js\";\nimport { dbg_log, dbg_assert } from \"../src/log.js\";\nimport { h } from \"../src/lib.js\";\n\n// For Types Only\nimport { CPU } from \"../src/cpu.js\";\nimport { BusConnector } from \"../src/bus.js\";\nimport { FS } from \"./filesystem.js\";\n\n/**\n * @const\n * More accurate filenames in 9p debug messages at the cost of performance.\n */\nconst TRACK_FILENAMES = false;\n\n// Feature bit (bit position) for mount tag.\nconst VIRTIO_9P_F_MOUNT_TAG = 0;\n// Assumed max tag length in bytes.\nconst VIRTIO_9P_MAX_TAGLEN = 254;\n\nconst MAX_REPLYBUFFER_SIZE = 16 * 1024 * 1024;\n\n// TODO\n// flush\n\nexport const EPERM = 1; /* Operation not permitted */\nexport const ENOENT = 2; /* No such file or directory */\nexport const EEXIST = 17; /* File exists */\nexport const EINVAL = 22; /* Invalid argument */\nexport const EOPNOTSUPP = 95; /* Operation is not supported */\nexport const ENOTEMPTY = 39; /* Directory not empty */\nexport const EPROTO = 71; /* Protocol error */\n\nvar P9_SETATTR_MODE = 0x00000001;\nvar P9_SETATTR_UID = 0x00000002;\nvar P9_SETATTR_GID = 0x00000004;\nvar P9_SETATTR_SIZE = 0x00000008;\nvar P9_SETATTR_ATIME = 0x00000010;\nvar P9_SETATTR_MTIME = 0x00000020;\nvar P9_SETATTR_CTIME = 0x00000040;\nvar P9_SETATTR_ATIME_SET = 0x00000080;\nvar P9_SETATTR_MTIME_SET = 0x00000100;\n\nvar P9_STAT_MODE_DIR = 0x80000000;\nvar P9_STAT_MODE_APPEND = 0x40000000;\nvar P9_STAT_MODE_EXCL = 0x20000000;\nvar P9_STAT_MODE_MOUNT = 0x10000000;\nvar P9_STAT_MODE_AUTH = 0x08000000;\nvar P9_STAT_MODE_TMP = 0x04000000;\nvar P9_STAT_MODE_SYMLINK = 0x02000000;\nvar P9_STAT_MODE_LINK = 0x01000000;\nvar P9_STAT_MODE_DEVICE = 0x00800000;\nvar P9_STAT_MODE_NAMED_PIPE = 0x00200000;\nvar P9_STAT_MODE_SOCKET = 0x00100000;\nvar P9_STAT_MODE_SETUID = 0x00080000;\nvar P9_STAT_MODE_SETGID = 0x00040000;\nvar P9_STAT_MODE_SETVTX = 0x00010000;\n\nexport const P9_LOCK_TYPE_RDLCK = 0;\nexport const P9_LOCK_TYPE_WRLCK = 1;\nexport const P9_LOCK_TYPE_UNLCK = 2;\nconst P9_LOCK_TYPES = [\"shared\", \"exclusive\", \"unlock\"];\n\nconst P9_LOCK_FLAGS_BLOCK = 1;\nconst P9_LOCK_FLAGS_RECLAIM = 2;\n\nexport const P9_LOCK_SUCCESS = 0;\nexport const P9_LOCK_BLOCKED = 1;\nexport const P9_LOCK_ERROR = 2;\nexport const P9_LOCK_GRACE = 3;\n\nvar FID_NONE = -1;\nvar FID_INODE = 1;\nvar FID_XATTR = 2;\n\nfunction range(size)\n{\n return Array.from(Array(size).keys());\n}\n\n/**\n * @param {CPU} cpu\n * @param {Function} receive\n */\nfunction init_virtio(cpu, configspace_taglen, configspace_tagname, receive)\n{\n const virtio = new VirtIO(cpu,\n {\n name: \"virtio-9p\",\n pci_id: 0x06 << 3,\n device_id: 0x1049,\n subsystem_device_id: 9,\n common:\n {\n initial_port: 0xA800,\n queues:\n [\n {\n size_supported: 32,\n notify_offset: 0,\n },\n ],\n features:\n [\n VIRTIO_9P_F_MOUNT_TAG,\n VIRTIO_F_VERSION_1,\n VIRTIO_F_RING_EVENT_IDX,\n VIRTIO_F_RING_INDIRECT_DESC,\n ],\n on_driver_ok: () => {},\n },\n notification:\n {\n initial_port: 0xA900,\n single_handler: false,\n handlers:\n [\n (queue_id) =>\n {\n if(queue_id !== 0)\n {\n dbg_assert(false, \"Virtio9P Notified for non-existent queue: \" + queue_id +\n \" (expected queue_id of 0)\");\n return;\n }\n const virtqueue = virtio.queues[0];\n while(virtqueue.has_request())\n {\n const bufchain = virtqueue.pop_request();\n receive(bufchain);\n }\n virtqueue.notify_me_after(0);\n // Don't flush replies here: async replies are not completed yet.\n },\n ],\n },\n isr_status:\n {\n initial_port: 0xA700,\n },\n device_specific:\n {\n initial_port: 0xA600,\n struct:\n [\n {\n bytes: 2,\n name: \"mount tag length\",\n read: () => configspace_taglen,\n write: data => { /* read only */ },\n },\n ].concat(range(VIRTIO_9P_MAX_TAGLEN).map(index =>\n ({\n bytes: 1,\n name: \"mount tag name \" + index,\n // Note: configspace_tagname may have changed after set_state\n read: () => configspace_tagname[index] || 0,\n write: data => { /* read only */ },\n })\n )),\n },\n });\n return virtio;\n}\n\n/**\n * @constructor\n *\n * @param {FS} filesystem\n * @param {CPU} cpu\n */\nexport function Virtio9p(filesystem, cpu, bus) {\n /** @type {FS} */\n this.fs = filesystem;\n\n /** @const @type {BusConnector} */\n this.bus = bus;\n\n this.configspace_tagname = [0x68, 0x6F, 0x73, 0x74, 0x39, 0x70]; // \"host9p\" string\n this.configspace_taglen = this.configspace_tagname.length; // num bytes\n\n this.virtio = init_virtio(cpu, this.configspace_taglen, this.configspace_tagname, this.ReceiveRequest.bind(this));\n this.virtqueue = this.virtio.queues[0];\n\n this.VERSION = \"9P2000.L\";\n this.BLOCKSIZE = 8192; // Let's define one page.\n this.msize = 8192; // maximum message size\n this.replybuffer = new Uint8Array(this.msize*2); // Twice the msize to stay on the safe site\n this.replybuffersize = 0;\n this.fids = [];\n}\n\nVirtio9p.prototype.get_state = function()\n{\n var state = [];\n\n state[0] = this.configspace_tagname;\n state[1] = this.configspace_taglen;\n state[2] = this.virtio;\n state[3] = this.VERSION;\n state[4] = this.BLOCKSIZE;\n state[5] = this.msize;\n state[6] = this.replybuffer;\n state[7] = this.replybuffersize;\n state[8] = this.fids.map(function(f) { return [f.inodeid, f.type, f.uid, f.dbg_name]; });\n state[9] = this.fs;\n\n return state;\n};\n\nVirtio9p.prototype.set_state = function(state)\n{\n this.configspace_tagname = state[0];\n this.configspace_taglen = state[1];\n this.virtio.set_state(state[2]);\n this.virtqueue = this.virtio.queues[0];\n this.VERSION = state[3];\n this.BLOCKSIZE = state[4];\n this.msize = state[5];\n this.replybuffer = state[6];\n this.replybuffersize = state[7];\n this.fids = state[8].map(function(f)\n {\n return { inodeid: f[0], type: f[1], uid: f[2], dbg_name: f[3] };\n });\n this.fs.set_state(state[9]);\n};\n\n// Note: dbg_name is only used for debugging messages and may not be the same as the filename,\n// since it is not synchronised with renames done outside of 9p. Hard-links, linking and unlinking\n// operations also mean that having a single filename no longer makes sense.\n// Set TRACK_FILENAMES = true to sync dbg_name during 9p renames.\nVirtio9p.prototype.Createfid = function(inodeid, type, uid, dbg_name) {\n return {inodeid, type, uid, dbg_name};\n};\n\nVirtio9p.prototype.update_dbg_name = function(idx, newname)\n{\n for(const fid of this.fids)\n {\n if(fid.inodeid === idx) fid.dbg_name = newname;\n }\n};\n\nVirtio9p.prototype.reset = function()\n{\n this.fids = [];\n this.virtio.reset();\n};\n\nVirtio9p.prototype.BuildReply = function(id, tag, payloadsize) {\n dbg_assert(payloadsize >= 0, \"9P: Negative payload size\");\n marshall.Marshall([\"w\", \"b\", \"h\"], [payloadsize+7, id+1, tag], this.replybuffer, 0);\n if((payloadsize+7) >= this.replybuffer.length) {\n dbg_log(\"Error in 9p: payloadsize exceeds maximum length\", LOG_9P);\n }\n //for(var i=0; i= 0, \"9P: Negative replybuffersize\");\n bufchain.set_next_blob(this.replybuffer.subarray(0, this.replybuffersize));\n this.virtqueue.push_reply(bufchain);\n this.virtqueue.flush_replies();\n};\n\nVirtio9p.prototype.ReceiveRequest = async function (bufchain) {\n // TODO: split into header + data blobs to avoid unnecessary copying.\n const buffer = new Uint8Array(bufchain.length_readable);\n bufchain.get_next_blob(buffer);\n\n const state = { offset : 0 };\n var header = marshall.Unmarshall([\"w\", \"b\", \"h\"], buffer, state);\n var size = header[0];\n var id = header[1];\n var tag = header[2];\n //dbg_log(\"size:\" + size + \" id:\" + id + \" tag:\" + tag, LOG_9P);\n\n switch(id)\n {\n case 8: // statfs\n size = this.fs.GetTotalSize(); // size used by all files\n var space = this.fs.GetSpace();\n var req = [];\n req[0] = 0x01021997;\n req[1] = this.BLOCKSIZE; // optimal transfer block size\n req[2] = Math.floor(space/req[1]); // free blocks\n req[3] = req[2] - Math.floor(size/req[1]); // free blocks in fs\n req[4] = req[2] - Math.floor(size/req[1]); // free blocks avail to non-superuser\n req[5] = this.fs.CountUsedInodes(); // total number of inodes\n req[6] = this.fs.CountFreeInodes();\n req[7] = 0; // file system id?\n req[8] = 256; // maximum length of filenames\n\n size = marshall.Marshall([\"w\", \"w\", \"d\", \"d\", \"d\", \"d\", \"d\", \"d\", \"w\"], req, this.replybuffer, 7);\n this.BuildReply(id, tag, size);\n this.SendReply(bufchain);\n break;\n\n case 112: // topen\n case 12: // tlopen\n var req = marshall.Unmarshall([\"w\", \"w\"], buffer, state);\n var fid = req[0];\n var mode = req[1];\n dbg_log(\"[open] fid=\" + fid + \", mode=\" + mode, LOG_9P);\n var idx = this.fids[fid].inodeid;\n var inode = this.fs.GetInode(idx);\n dbg_log(\"file open \" + this.fids[fid].dbg_name + \" tag:\"+tag, LOG_9P);\n await this.fs.OpenInode(idx, mode);\n\n req = [];\n req[0] = inode.qid;\n req[1] = this.msize - 24;\n marshall.Marshall([\"Q\", \"w\"], req, this.replybuffer, 7);\n this.BuildReply(id, tag, 13+4);\n this.SendReply(bufchain);\n break;\n\n case 70: // link\n var req = marshall.Unmarshall([\"w\", \"w\", \"s\"], buffer, state);\n var dfid = req[0];\n var fid = req[1];\n var name = req[2];\n dbg_log(\"[link] dfid=\" + dfid + \", name=\" + name, LOG_9P);\n\n var ret = this.fs.Link(this.fids[dfid].inodeid, this.fids[fid].inodeid, name);\n\n if(ret < 0)\n {\n let error_message = \"\";\n if(ret === -EPERM) error_message = \"Operation not permitted\";\n else\n {\n error_message = \"Unknown error: \" + (-ret);\n dbg_assert(false, \"[link]: Unexpected error code: \" + (-ret));\n }\n this.SendError(tag, error_message, -ret);\n this.SendReply(bufchain);\n break;\n }\n\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n break;\n\n case 16: // symlink\n var req = marshall.Unmarshall([\"w\", \"s\", \"s\", \"w\"], buffer, state);\n var fid = req[0];\n var name = req[1];\n var symgt = req[2];\n var gid = req[3];\n dbg_log(\"[symlink] fid=\" + fid + \", name=\" + name + \", symgt=\" + symgt + \", gid=\" + gid, LOG_9P);\n var idx = this.fs.CreateSymlink(name, this.fids[fid].inodeid, symgt);\n var inode = this.fs.GetInode(idx);\n inode.uid = this.fids[fid].uid;\n inode.gid = gid;\n marshall.Marshall([\"Q\"], [inode.qid], this.replybuffer, 7);\n this.BuildReply(id, tag, 13);\n this.SendReply(bufchain);\n break;\n\n case 18: // mknod\n var req = marshall.Unmarshall([\"w\", \"s\", \"w\", \"w\", \"w\", \"w\"], buffer, state);\n var fid = req[0];\n var name = req[1];\n var mode = req[2];\n var major = req[3];\n var minor = req[4];\n var gid = req[5];\n dbg_log(\"[mknod] fid=\" + fid + \", name=\" + name + \", major=\" + major + \", minor=\" + minor+ \"\", LOG_9P);\n var idx = this.fs.CreateNode(name, this.fids[fid].inodeid, major, minor);\n var inode = this.fs.GetInode(idx);\n inode.mode = mode;\n //inode.mode = mode | S_IFCHR; // XXX: fails \"Mknod - fifo\" test\n inode.uid = this.fids[fid].uid;\n inode.gid = gid;\n marshall.Marshall([\"Q\"], [inode.qid], this.replybuffer, 7);\n this.BuildReply(id, tag, 13);\n this.SendReply(bufchain);\n break;\n\n\n case 22: // TREADLINK\n var req = marshall.Unmarshall([\"w\"], buffer, state);\n var fid = req[0];\n var inode = this.fs.GetInode(this.fids[fid].inodeid);\n dbg_log(\"[readlink] fid=\" + fid + \" name=\" + this.fids[fid].dbg_name + \" target=\" + inode.symlink, LOG_9P);\n size = marshall.Marshall([\"s\"], [inode.symlink], this.replybuffer, 7);\n this.BuildReply(id, tag, size);\n this.SendReply(bufchain);\n break;\n\n\n case 72: // tmkdir\n var req = marshall.Unmarshall([\"w\", \"s\", \"w\", \"w\"], buffer, state);\n var fid = req[0];\n var name = req[1];\n var mode = req[2];\n var gid = req[3];\n dbg_log(\"[mkdir] fid=\" + fid + \", name=\" + name + \", mode=\" + mode + \", gid=\" + gid, LOG_9P);\n var idx = this.fs.CreateDirectory(name, this.fids[fid].inodeid);\n var inode = this.fs.GetInode(idx);\n inode.mode = mode | S_IFDIR;\n inode.uid = this.fids[fid].uid;\n inode.gid = gid;\n marshall.Marshall([\"Q\"], [inode.qid], this.replybuffer, 7);\n this.BuildReply(id, tag, 13);\n this.SendReply(bufchain);\n break;\n\n case 14: // tlcreate\n var req = marshall.Unmarshall([\"w\", \"s\", \"w\", \"w\", \"w\"], buffer, state);\n var fid = req[0];\n var name = req[1];\n var flags = req[2];\n var mode = req[3];\n var gid = req[4];\n this.bus.send(\"9p-create\", [name, this.fids[fid].inodeid]);\n dbg_log(\"[create] fid=\" + fid + \", name=\" + name + \", flags=\" + flags + \", mode=\" + mode + \", gid=\" + gid, LOG_9P);\n var idx = this.fs.CreateFile(name, this.fids[fid].inodeid);\n this.fids[fid].inodeid = idx;\n this.fids[fid].type = FID_INODE;\n this.fids[fid].dbg_name = name;\n var inode = this.fs.GetInode(idx);\n inode.uid = this.fids[fid].uid;\n inode.gid = gid;\n inode.mode = mode | S_IFREG;\n marshall.Marshall([\"Q\", \"w\"], [inode.qid, this.msize - 24], this.replybuffer, 7);\n this.BuildReply(id, tag, 13+4);\n this.SendReply(bufchain);\n break;\n\n case 52: // lock\n var req = marshall.Unmarshall([\"w\", \"b\", \"w\", \"d\", \"d\", \"w\", \"s\"], buffer, state);\n var fid = req[0];\n var flags = req[2];\n var lock_length = req[4] === 0 ? Infinity : req[4];\n var lock_request = this.fs.DescribeLock(req[1], req[3], lock_length, req[5], req[6]);\n dbg_log(\"[lock] fid=\" + fid +\n \", type=\" + P9_LOCK_TYPES[lock_request.type] + \", start=\" + lock_request.start +\n \", length=\" + lock_request.length + \", proc_id=\" + lock_request.proc_id);\n\n var ret = this.fs.Lock(this.fids[fid].inodeid, lock_request, flags);\n\n marshall.Marshall([\"b\"], [ret], this.replybuffer, 7);\n this.BuildReply(id, tag, 1);\n this.SendReply(bufchain);\n break;\n\n case 54: // getlock\n var req = marshall.Unmarshall([\"w\", \"b\", \"d\", \"d\", \"w\", \"s\"], buffer, state);\n var fid = req[0];\n var lock_length = req[3] === 0 ? Infinity : req[3];\n var lock_request = this.fs.DescribeLock(req[1], req[2], lock_length, req[4], req[5]);\n dbg_log(\"[getlock] fid=\" + fid +\n \", type=\" + P9_LOCK_TYPES[lock_request.type] + \", start=\" + lock_request.start +\n \", length=\" + lock_request.length + \", proc_id=\" + lock_request.proc_id);\n\n var ret = this.fs.GetLock(this.fids[fid].inodeid, lock_request);\n\n if(!ret)\n {\n ret = lock_request;\n ret.type = P9_LOCK_TYPE_UNLCK;\n }\n\n var ret_length = ret.length === Infinity ? 0 : ret.length;\n\n size = marshall.Marshall([\"b\", \"d\", \"d\", \"w\", \"s\"],\n [ret.type, ret.start, ret_length, ret.proc_id, ret.client_id],\n this.replybuffer, 7);\n\n this.BuildReply(id, tag, size);\n this.SendReply(bufchain);\n break;\n\n case 24: // getattr\n var req = marshall.Unmarshall([\"w\", \"d\"], buffer, state);\n var fid = req[0];\n var inode = this.fs.GetInode(this.fids[fid].inodeid);\n dbg_log(\"[getattr]: fid=\" + fid + \" name=\" + this.fids[fid].dbg_name + \" request mask=\" + req[1], LOG_9P);\n if(!inode || inode.status === STATUS_UNLINKED)\n {\n dbg_log(\"getattr: unlinked\", LOG_9P);\n this.SendError(tag, \"No such file or directory\", ENOENT);\n this.SendReply(bufchain);\n break;\n }\n req[0] = req[1]; // request mask\n req[1] = inode.qid;\n\n req[2] = inode.mode;\n req[3] = inode.uid; // user id\n req[4] = inode.gid; // group id\n\n req[5] = inode.nlinks; // number of hard links\n req[6] = (inode.major<<8) | (inode.minor); // device id low\n req[7] = inode.size; // size low\n req[8] = this.BLOCKSIZE;\n req[9] = Math.floor(inode.size/512+1); // blk size low\n req[10] = inode.atime; // atime\n req[11] = 0x0;\n req[12] = inode.mtime; // mtime\n req[13] = 0x0;\n req[14] = inode.ctime; // ctime\n req[15] = 0x0;\n req[16] = 0x0; // btime\n req[17] = 0x0;\n req[18] = 0x0; // st_gen\n req[19] = 0x0; // data_version\n marshall.Marshall([\n \"d\", \"Q\",\n \"w\",\n \"w\", \"w\",\n \"d\", \"d\",\n \"d\", \"d\", \"d\",\n \"d\", \"d\", // atime\n \"d\", \"d\", // mtime\n \"d\", \"d\", // ctime\n \"d\", \"d\", // btime\n \"d\", \"d\",\n ], req, this.replybuffer, 7);\n this.BuildReply(id, tag, 8 + 13 + 4 + 4+ 4 + 8*15);\n this.SendReply(bufchain);\n break;\n\n case 26: // setattr\n var req = marshall.Unmarshall([\"w\", \"w\",\n \"w\", // mode\n \"w\", \"w\", // uid, gid\n \"d\", // size\n \"d\", \"d\", // atime\n \"d\", \"d\", // mtime\n ], buffer, state);\n var fid = req[0];\n var inode = this.fs.GetInode(this.fids[fid].inodeid);\n dbg_log(\"[setattr]: fid=\" + fid + \" request mask=\" + req[1] + \" name=\" + this.fids[fid].dbg_name, LOG_9P);\n if(req[1] & P9_SETATTR_MODE) {\n // XXX: check mode (S_IFREG or S_IFDIR or similar should be set)\n inode.mode = req[2];\n }\n if(req[1] & P9_SETATTR_UID) {\n inode.uid = req[3];\n }\n if(req[1] & P9_SETATTR_GID) {\n inode.gid = req[4];\n }\n if(req[1] & P9_SETATTR_ATIME) {\n inode.atime = Math.floor((new Date()).getTime()/1000);\n }\n if(req[1] & P9_SETATTR_MTIME) {\n inode.mtime = Math.floor((new Date()).getTime()/1000);\n }\n if(req[1] & P9_SETATTR_CTIME) {\n inode.ctime = Math.floor((new Date()).getTime()/1000);\n }\n if(req[1] & P9_SETATTR_ATIME_SET) {\n inode.atime = req[6];\n }\n if(req[1] & P9_SETATTR_MTIME_SET) {\n inode.mtime = req[8];\n }\n if(req[1] & P9_SETATTR_SIZE) {\n await this.fs.ChangeSize(this.fids[fid].inodeid, req[5]);\n }\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n break;\n\n case 50: // fsync\n var req = marshall.Unmarshall([\"w\", \"d\"], buffer, state);\n var fid = req[0];\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n break;\n\n case 40: // TREADDIR\n case 116: // read\n var req = marshall.Unmarshall([\"w\", \"d\", \"w\"], buffer, state);\n var fid = req[0];\n var offset = req[1];\n var count = req[2];\n var inode = this.fs.GetInode(this.fids[fid].inodeid);\n if(id === 40) dbg_log(\"[treaddir]: fid=\" + fid + \" offset=\" + offset + \" count=\" + count, LOG_9P);\n if(id === 116) dbg_log(\"[read]: fid=\" + fid + \" (\" + this.fids[fid].dbg_name + \") offset=\" + offset + \" count=\" + count + \" fidtype=\" + this.fids[fid].type, LOG_9P);\n if(!inode || inode.status === STATUS_UNLINKED)\n {\n dbg_log(\"read/treaddir: unlinked\", LOG_9P);\n this.SendError(tag, \"No such file or directory\", ENOENT);\n this.SendReply(bufchain);\n break;\n }\n if(this.fids[fid].type === FID_XATTR) {\n if(inode.caps.length < offset+count) count = inode.caps.length - offset;\n for(var i=0; i inode.size)\n {\n // offset can be greater than available - should return count of zero.\n // See http://ericvh.github.io/9p-rfc/rfc9p2000.html#anchor30\n count = 0;\n }\n\n this.bus.send(\"9p-read-start\", [this.fids[fid].dbg_name]);\n\n const data = await this.fs.Read(inodeid, offset, count);\n\n this.bus.send(\"9p-read-end\", [this.fids[fid].dbg_name, count]);\n\n if(data) {\n this.replybuffer.set(data, 7 + 4);\n }\n marshall.Marshall([\"w\"], [count], this.replybuffer, 7);\n this.BuildReply(id, tag, 4 + count);\n this.SendReply(bufchain);\n }\n break;\n\n case 118: // write\n var req = marshall.Unmarshall([\"w\", \"d\", \"w\"], buffer, state);\n var fid = req[0];\n var offset = req[1];\n var count = req[2];\n\n const filename = this.fids[fid].dbg_name;\n\n dbg_log(\"[write]: fid=\" + fid + \" (\" + filename + \") offset=\" + offset + \" count=\" + count + \" fidtype=\" + this.fids[fid].type, LOG_9P);\n if(this.fids[fid].type === FID_XATTR)\n {\n // XXX: xattr not supported yet. Ignore write.\n this.SendError(tag, \"Setxattr not supported\", EOPNOTSUPP);\n this.SendReply(bufchain);\n break;\n }\n else\n {\n // XXX: Size of the subarray is unchecked\n await this.fs.Write(this.fids[fid].inodeid, offset, count, buffer.subarray(state.offset));\n }\n\n this.bus.send(\"9p-write-end\", [filename, count]);\n\n marshall.Marshall([\"w\"], [count], this.replybuffer, 7);\n this.BuildReply(id, tag, 4);\n this.SendReply(bufchain);\n break;\n\n case 74: // RENAMEAT\n var req = marshall.Unmarshall([\"w\", \"s\", \"w\", \"s\"], buffer, state);\n var olddirfid = req[0];\n var oldname = req[1];\n var newdirfid = req[2];\n var newname = req[3];\n dbg_log(\"[renameat]: oldname=\" + oldname + \" newname=\" + newname, LOG_9P);\n var ret = await this.fs.Rename(this.fids[olddirfid].inodeid, oldname, this.fids[newdirfid].inodeid, newname);\n if(ret < 0) {\n let error_message = \"\";\n if(ret === -ENOENT) error_message = \"No such file or directory\";\n else if(ret === -EPERM) error_message = \"Operation not permitted\";\n else if(ret === -ENOTEMPTY) error_message = \"Directory not empty\";\n else\n {\n error_message = \"Unknown error: \" + (-ret);\n dbg_assert(false, \"[renameat]: Unexpected error code: \" + (-ret));\n }\n this.SendError(tag, error_message, -ret);\n this.SendReply(bufchain);\n break;\n }\n if(TRACK_FILENAMES)\n {\n const newidx = this.fs.Search(this.fids[newdirfid].inodeid, newname);\n this.update_dbg_name(newidx, newname);\n }\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n break;\n\n case 76: // TUNLINKAT\n var req = marshall.Unmarshall([\"w\", \"s\", \"w\"], buffer, state);\n var dirfd = req[0];\n var name = req[1];\n var flags = req[2];\n dbg_log(\"[unlink]: dirfd=\" + dirfd + \" name=\" + name + \" flags=\" + flags, LOG_9P);\n var fid = this.fs.Search(this.fids[dirfd].inodeid, name);\n if(fid === -1) {\n this.SendError(tag, \"No such file or directory\", ENOENT);\n this.SendReply(bufchain);\n break;\n }\n var ret = this.fs.Unlink(this.fids[dirfd].inodeid, name);\n if(ret < 0) {\n let error_message = \"\";\n if(ret === -ENOTEMPTY) error_message = \"Directory not empty\";\n else if(ret === -EPERM) error_message = \"Operation not permitted\";\n else\n {\n error_message = \"Unknown error: \" + (-ret);\n dbg_assert(false, \"[unlink]: Unexpected error code: \" + (-ret));\n }\n this.SendError(tag, error_message, -ret);\n this.SendReply(bufchain);\n break;\n }\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n break;\n\n case 100: // version\n var version = marshall.Unmarshall([\"w\", \"s\"], buffer, state);\n dbg_log(\"[version]: msize=\" + version[0] + \" version=\" + version[1], LOG_9P);\n if(this.msize !== version[0])\n {\n this.msize = version[0];\n this.replybuffer = new Uint8Array(Math.min(MAX_REPLYBUFFER_SIZE, this.msize*2));\n }\n size = marshall.Marshall([\"w\", \"s\"], [this.msize, this.VERSION], this.replybuffer, 7);\n this.BuildReply(id, tag, size);\n this.SendReply(bufchain);\n break;\n\n case 104: // attach\n // return root directorie's QID\n var req = marshall.Unmarshall([\"w\", \"w\", \"s\", \"s\", \"w\"], buffer, state);\n var fid = req[0];\n var uid = req[4];\n dbg_log(\"[attach]: fid=\" + fid + \" afid=\" + h(req[1]) + \" uname=\" + req[2] + \" aname=\" + req[3], LOG_9P);\n this.fids[fid] = this.Createfid(0, FID_INODE, uid, \"\");\n var inode = this.fs.GetInode(this.fids[fid].inodeid);\n marshall.Marshall([\"Q\"], [inode.qid], this.replybuffer, 7);\n this.BuildReply(id, tag, 13);\n this.SendReply(bufchain);\n this.bus.send(\"9p-attach\");\n break;\n\n case 108: // tflush\n var req = marshall.Unmarshall([\"h\"], buffer, state);\n var oldtag = req[0];\n dbg_log(\"[flush] \" + tag, LOG_9P);\n //marshall.Marshall([\"Q\"], [inode.qid], this.replybuffer, 7);\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n break;\n\n\n case 110: // walk\n var req = marshall.Unmarshall([\"w\", \"w\", \"h\"], buffer, state);\n var fid = req[0];\n var nwfid = req[1];\n var nwname = req[2];\n dbg_log(\"[walk]: fid=\" + req[0] + \" nwfid=\" + req[1] + \" nwname=\" + nwname, LOG_9P);\n if(nwname === 0) {\n this.fids[nwfid] = this.Createfid(this.fids[fid].inodeid, FID_INODE, this.fids[fid].uid, this.fids[fid].dbg_name);\n //this.fids[nwfid].inodeid = this.fids[fid].inodeid;\n marshall.Marshall([\"h\"], [0], this.replybuffer, 7);\n this.BuildReply(id, tag, 2);\n this.SendReply(bufchain);\n break;\n }\n var wnames = [];\n for(var i=0; i= 0) {\n await this.fs.CloseInode(this.fids[req[0]].inodeid);\n this.fids[req[0]].inodeid = -1;\n this.fids[req[0]].type = FID_NONE;\n }\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n break;\n\n case 32: // txattrcreate\n var req = marshall.Unmarshall([\"w\", \"s\", \"d\", \"w\"], buffer, state);\n var fid = req[0];\n var name = req[1];\n var attr_size = req[2];\n var flags = req[3];\n dbg_log(\"[txattrcreate]: fid=\" + fid + \" name=\" + name + \" attr_size=\" + attr_size + \" flags=\" + flags, LOG_9P);\n\n // XXX: xattr not supported yet. E.g. checks corresponding to the flags needed.\n this.fids[fid].type = FID_XATTR;\n\n this.BuildReply(id, tag, 0);\n this.SendReply(bufchain);\n //this.SendError(tag, \"Operation i not supported\", EINVAL);\n //this.SendReply(bufchain);\n break;\n\n case 30: // xattrwalk\n var req = marshall.Unmarshall([\"w\", \"w\", \"s\"], buffer, state);\n var fid = req[0];\n var newfid = req[1];\n var name = req[2];\n dbg_log(\"[xattrwalk]: fid=\" + req[0] + \" newfid=\" + req[1] + \" name=\" + req[2], LOG_9P);\n\n // Workaround for Linux restarts writes until full blocksize\n this.SendError(tag, \"Setxattr not supported\", EOPNOTSUPP);\n this.SendReply(bufchain);\n /*\n this.fids[newfid] = this.Createfid(this.fids[fid].inodeid, FID_NONE, this.fids[fid].uid, this.fids[fid].dbg_name);\n //this.fids[newfid].inodeid = this.fids[fid].inodeid;\n //this.fids[newfid].type = FID_NONE;\n var length = 0;\n if (name === \"security.capability\") {\n length = this.fs.PrepareCAPs(this.fids[fid].inodeid);\n this.fids[newfid].type = FID_XATTR;\n }\n marshall.Marshall([\"d\"], [length], this.replybuffer, 7);\n this.BuildReply(id, tag, 8);\n this.SendReply(bufchain);\n */\n break;\n\n default:\n dbg_log(\"Error in Virtio9p: Unknown id \" + id + \" received\", LOG_9P);\n dbg_assert(false);\n //this.SendError(tag, \"Operation i not supported\", EOPNOTSUPP);\n //this.SendReply(bufchain);\n break;\n }\n\n //consistency checks if there are problems with the filesystem\n //this.fs.Check();\n};\n\n/** @typedef {function(Uint8Array, function(Uint8Array):void):void} */\nlet P9Handler;\n\n/**\n * @constructor\n *\n * @param {P9Handler} handle_fn\n * @param {CPU} cpu\n */\nexport function Virtio9pHandler(handle_fn, cpu) {\n /** @type {P9Handler} */\n this.handle_fn = handle_fn;\n this.tag_bufchain = new Map();\n\n this.configspace_tagname = [0x68, 0x6F, 0x73, 0x74, 0x39, 0x70]; // \"host9p\" string\n this.configspace_taglen = this.configspace_tagname.length; // num bytes\n\n this.virtio = init_virtio(\n cpu,\n this.configspace_taglen,\n this.configspace_tagname,\n async (bufchain) => {\n // TODO: split into header + data blobs to avoid unnecessary copying.\n const reqbuf = new Uint8Array(bufchain.length_readable);\n bufchain.get_next_blob(reqbuf);\n\n var reqheader = marshall.Unmarshall([\"w\", \"b\", \"h\"], reqbuf, { offset : 0 });\n var reqtag = reqheader[2];\n\n this.tag_bufchain.set(reqtag, bufchain);\n this.handle_fn(reqbuf, (replybuf) => {\n var replyheader = marshall.Unmarshall([\"w\", \"b\", \"h\"], replybuf, { offset: 0 });\n var replytag = replyheader[2];\n\n const bufchain = this.tag_bufchain.get(replytag);\n if(!bufchain)\n {\n console.error(\"No bufchain found for tag: \" + replytag);\n return;\n }\n\n bufchain.set_next_blob(replybuf);\n this.virtqueue.push_reply(bufchain);\n this.virtqueue.flush_replies();\n\n this.tag_bufchain.delete(replytag);\n });\n }\n );\n this.virtqueue = this.virtio.queues[0];\n}\n\nVirtio9pHandler.prototype.get_state = function()\n{\n var state = [];\n\n state[0] = this.configspace_tagname;\n state[1] = this.configspace_taglen;\n state[2] = this.virtio;\n state[3] = this.tag_bufchain;\n\n return state;\n};\n\nVirtio9pHandler.prototype.set_state = function(state)\n{\n this.configspace_tagname = state[0];\n this.configspace_taglen = state[1];\n this.virtio.set_state(state[2]);\n this.virtqueue = this.virtio.queues[0];\n this.tag_bufchain = state[3];\n};\n\n\nVirtio9pHandler.prototype.reset = function()\n{\n this.virtio.reset();\n};\n\n\n/**\n * @constructor\n *\n * @param {string} url\n * @param {CPU} cpu\n */\nexport function Virtio9pProxy(url, cpu)\n{\n this.socket = undefined;\n this.cpu = cpu;\n\n // TODO: circular buffer?\n this.send_queue = [];\n this.url = url;\n\n this.reconnect_interval = 10000;\n this.last_connect_attempt = Date.now() - this.reconnect_interval;\n this.send_queue_limit = 64;\n this.destroyed = false;\n\n this.tag_bufchain = new Map();\n\n this.configspace_tagname = [0x68, 0x6F, 0x73, 0x74, 0x39, 0x70]; // \"host9p\" string\n this.configspace_taglen = this.configspace_tagname.length; // num bytes\n\n this.virtio = init_virtio(\n cpu,\n this.configspace_taglen,\n this.configspace_tagname,\n async (bufchain) => {\n // TODO: split into header + data blobs to avoid unnecessary copying.\n const reqbuf = new Uint8Array(bufchain.length_readable);\n bufchain.get_next_blob(reqbuf);\n\n const reqheader = marshall.Unmarshall([\"w\", \"b\", \"h\"], reqbuf, { offset : 0 });\n const reqtag = reqheader[2];\n\n this.tag_bufchain.set(reqtag, bufchain);\n this.send(reqbuf);\n }\n );\n this.virtqueue = this.virtio.queues[0];\n}\n\nVirtio9pProxy.prototype.get_state = function()\n{\n var state = [];\n\n state[0] = this.configspace_tagname;\n state[1] = this.configspace_taglen;\n state[2] = this.virtio;\n state[3] = this.tag_bufchain;\n\n return state;\n};\n\nVirtio9pProxy.prototype.set_state = function(state)\n{\n this.configspace_tagname = state[0];\n this.configspace_taglen = state[1];\n this.virtio.set_state(state[2]);\n this.virtqueue = this.virtio.queues[0];\n this.tag_bufchain = state[3];\n};\n\nVirtio9pProxy.prototype.reset = function() {\n this.virtio.reset();\n};\n\nVirtio9pProxy.prototype.handle_message = function(e)\n{\n const replybuf = new Uint8Array(e.data);\n const replyheader = marshall.Unmarshall([\"w\", \"b\", \"h\"], replybuf, { offset: 0 });\n const replytag = replyheader[2];\n\n const bufchain = this.tag_bufchain.get(replytag);\n if(!bufchain)\n {\n console.error(\"Virtio9pProxy: No bufchain found for tag: \" + replytag);\n return;\n }\n\n bufchain.set_next_blob(replybuf);\n this.virtqueue.push_reply(bufchain);\n this.virtqueue.flush_replies();\n\n this.tag_bufchain.delete(replytag);\n};\n\nVirtio9pProxy.prototype.handle_close = function(e)\n{\n //console.log(\"onclose\", e);\n\n if(!this.destroyed)\n {\n this.connect();\n setTimeout(this.connect.bind(this), this.reconnect_interval);\n }\n};\n\nVirtio9pProxy.prototype.handle_open = function(e)\n{\n //console.log(\"open\", e);\n\n for(var i = 0; i < this.send_queue.length; i++)\n {\n this.send(this.send_queue[i]);\n }\n\n this.send_queue = [];\n};\n\nVirtio9pProxy.prototype.handle_error = function(e)\n{\n //console.log(\"onerror\", e);\n};\n\nVirtio9pProxy.prototype.destroy = function()\n{\n this.destroyed = true;\n if(this.socket)\n {\n this.socket.close();\n }\n};\n\nVirtio9pProxy.prototype.connect = function()\n{\n if(typeof WebSocket === \"undefined\")\n {\n return;\n }\n\n if(this.socket)\n {\n var state = this.socket.readyState;\n\n if(state === 0 || state === 1)\n {\n // already or almost there\n return;\n }\n }\n\n var now = Date.now();\n\n if(this.last_connect_attempt + this.reconnect_interval > now)\n {\n return;\n }\n\n this.last_connect_attempt = Date.now();\n\n try\n {\n this.socket = new WebSocket(this.url);\n }\n catch(e)\n {\n console.error(e);\n return;\n }\n\n this.socket.binaryType = \"arraybuffer\";\n\n this.socket.onopen = this.handle_open.bind(this);\n this.socket.onmessage = this.handle_message.bind(this);\n this.socket.onclose = this.handle_close.bind(this);\n this.socket.onerror = this.handle_error.bind(this);\n};\n\nVirtio9pProxy.prototype.send = function(data)\n{\n //console.log(\"send\", data);\n\n if(!this.socket || this.socket.readyState !== 1)\n {\n this.send_queue.push(data);\n\n if(this.send_queue.length > 2 * this.send_queue_limit)\n {\n this.send_queue = this.send_queue.slice(-this.send_queue_limit);\n }\n\n this.connect();\n }\n else\n {\n this.socket.send(data);\n }\n};\n\nVirtio9pProxy.prototype.change_proxy = function(url)\n{\n this.url = url;\n\n if(this.socket)\n {\n this.socket.onclose = function() {};\n this.socket.onerror = function() {};\n this.socket.close();\n this.socket = undefined;\n }\n};\n"
},
{
"path": "lib/filesystem.js",
"content": "// -------------------------------------------------\n// ----------------- FILESYSTEM---------------------\n// -------------------------------------------------\n// Implementation of a unix filesystem in memory.\n\n\nimport { LOG_9P } from \"../src/const.js\";\nimport { h } from \"../src/lib.js\";\nimport { dbg_assert, dbg_log } from \"../src/log.js\";\nimport * as marshall from \"../lib/marshall.js\";\nimport { EEXIST, ENOTEMPTY, ENOENT, EPERM } from \"./9p.js\";\nimport { P9_LOCK_SUCCESS, P9_LOCK_BLOCKED, P9_LOCK_TYPE_UNLCK, P9_LOCK_TYPE_WRLCK, P9_LOCK_TYPE_RDLCK } from \"./9p.js\";\n\n// For Types Only\nimport { FileStorageInterface } from \"../src/browser/filestorage.js\";\n\nexport const S_IRWXUGO = 0x1FF;\nexport const S_IFMT = 0xF000;\nexport const S_IFSOCK = 0xC000;\nexport const S_IFLNK = 0xA000;\nexport const S_IFREG = 0x8000;\nexport const S_IFBLK = 0x6000;\nexport const S_IFDIR = 0x4000;\nexport const S_IFCHR = 0x2000;\n\n//var S_IFIFO 0010000\n//var S_ISUID 0004000\n//var S_ISGID 0002000\n//var S_ISVTX 0001000\n\nvar O_RDONLY = 0x0000; // open for reading only\nvar O_WRONLY = 0x0001; // open for writing only\nvar O_RDWR = 0x0002; // open for reading and writing\nvar O_ACCMODE = 0x0003; // mask for above modes\n\nexport const STATUS_INVALID = -0x1;\nexport const STATUS_OK = 0x0;\nexport const STATUS_ON_STORAGE = 0x2;\nexport const STATUS_UNLINKED = 0x4;\nexport const STATUS_FORWARDING = 0x5;\n\nconst texten = new TextEncoder();\n\n/** @const */ var JSONFS_VERSION = 3;\n\n\n/** @const */ var JSONFS_IDX_NAME = 0;\n/** @const */ var JSONFS_IDX_SIZE = 1;\n/** @const */ var JSONFS_IDX_MTIME = 2;\n/** @const */ var JSONFS_IDX_MODE = 3;\n/** @const */ var JSONFS_IDX_UID = 4;\n/** @const */ var JSONFS_IDX_GID = 5;\n/** @const */ var JSONFS_IDX_TARGET = 6;\n/** @const */ var JSONFS_IDX_SHA256 = 6;\n\n\n/**\n * @constructor\n * @param {!FileStorageInterface} storage\n * @param {{ last_qidnumber: number }=} qidcounter Another fs's qidcounter to synchronise with.\n */\nexport function FS(storage, qidcounter) {\n /** @type {Array.} */\n this.inodes = [];\n\n this.storage = storage;\n\n this.qidcounter = qidcounter || { last_qidnumber: 0 };\n\n //this.tar = new TAR(this);\n\n this.inodedata = {};\n\n this.total_size = 256 * 1024 * 1024 * 1024;\n this.used_size = 0;\n\n /** @type {!Array} */\n this.mounts = [];\n\n //RegisterMessage(\"LoadFilesystem\", this.LoadFilesystem.bind(this) );\n //RegisterMessage(\"MergeFile\", this.MergeFile.bind(this) );\n //RegisterMessage(\"tar\",\n // function(data) {\n // SendToMaster(\"tar\", this.tar.Pack(data));\n // }.bind(this)\n //);\n //RegisterMessage(\"sync\",\n // function(data) {\n // SendToMaster(\"sync\", this.tar.Pack(data));\n // }.bind(this)\n //);\n\n // root entry\n this.CreateDirectory(\"\", -1);\n}\n\nFS.prototype.get_state = function()\n{\n let state = [];\n\n state[0] = this.inodes;\n state[1] = this.qidcounter.last_qidnumber;\n state[2] = [];\n for(const [id, data] of Object.entries(this.inodedata))\n {\n if((this.inodes[id].mode & S_IFDIR) === 0)\n {\n state[2].push([id, data]);\n }\n }\n state[3] = this.total_size;\n state[4] = this.used_size;\n state = state.concat(this.mounts);\n\n return state;\n};\n\nFS.prototype.set_state = function(state)\n{\n this.inodes = state[0].map(state => { const inode = new Inode(0); inode.set_state(state); return inode; });\n this.qidcounter.last_qidnumber = state[1];\n this.inodedata = {};\n for(let [key, value] of state[2])\n {\n if(value.buffer.byteLength !== value.byteLength)\n {\n // make a copy if we didn't get one\n value = value.slice();\n }\n\n this.inodedata[key] = value;\n }\n this.total_size = state[3];\n this.used_size = state[4];\n this.mounts = state.slice(5);\n};\n\n\n// -----------------------------------------------------\n\nFS.prototype.load_from_json = function(fs)\n{\n dbg_assert(fs, \"Invalid fs passed to load_from_json\");\n\n if(fs[\"version\"] !== JSONFS_VERSION)\n {\n throw \"The filesystem JSON format has changed. Please recreate the filesystem JSON.\";\n }\n\n var fsroot = fs[\"fsroot\"];\n this.used_size = fs[\"size\"];\n\n for(var i = 0; i < fsroot.length; i++) {\n this.LoadRecursive(fsroot[i], 0);\n }\n\n //if(DEBUG)\n //{\n // this.Check();\n //}\n};\n\nFS.prototype.LoadRecursive = function(data, parentid)\n{\n var inode = this.CreateInode();\n\n const name = data[JSONFS_IDX_NAME];\n inode.size = data[JSONFS_IDX_SIZE];\n inode.mtime = data[JSONFS_IDX_MTIME];\n inode.ctime = inode.mtime;\n inode.atime = inode.mtime;\n inode.mode = data[JSONFS_IDX_MODE];\n inode.uid = data[JSONFS_IDX_UID];\n inode.gid = data[JSONFS_IDX_GID];\n\n var ifmt = inode.mode & S_IFMT;\n\n if(ifmt === S_IFDIR)\n {\n this.PushInode(inode, parentid, name);\n this.LoadDir(this.inodes.length - 1, data[JSONFS_IDX_TARGET]);\n }\n else if(ifmt === S_IFREG)\n {\n inode.status = STATUS_ON_STORAGE;\n inode.sha256sum = data[JSONFS_IDX_SHA256];\n dbg_assert(inode.sha256sum);\n this.PushInode(inode, parentid, name);\n }\n else if(ifmt === S_IFLNK)\n {\n inode.symlink = data[JSONFS_IDX_TARGET];\n this.PushInode(inode, parentid, name);\n }\n else if(ifmt === S_IFSOCK)\n {\n // socket: ignore\n }\n else\n {\n dbg_log(\"Unexpected ifmt: \" + h(ifmt) + \" (\" + name + \")\", LOG_9P);\n }\n};\n\nFS.prototype.LoadDir = function(parentid, children)\n{\n for(var i = 0; i < children.length; i++) {\n this.LoadRecursive(children[i], parentid);\n }\n};\n\n\n// -----------------------------------------------------\n\n/**\n * @private\n * @param {Inode} inode\n * @return {boolean}\n */\nFS.prototype.should_be_linked = function(inode)\n{\n // Note: Non-root forwarder inode could still have a non-forwarder parent, so don't use\n // parent inode to check.\n return !this.is_forwarder(inode) || inode.foreign_id === 0;\n};\n\n/**\n * @private\n * @param {number} parentid\n * @param {number} idx\n * @param {string} name\n */\nFS.prototype.link_under_dir = function(parentid, idx, name)\n{\n const inode = this.inodes[idx];\n const parent_inode = this.inodes[parentid];\n\n dbg_assert(!this.is_forwarder(parent_inode),\n \"Filesystem: Shouldn't link under fowarder parents\");\n dbg_assert(this.IsDirectory(parentid),\n \"Filesystem: Can't link under non-directories\");\n dbg_assert(this.should_be_linked(inode),\n \"Filesystem: Can't link across filesystems apart from their root\");\n dbg_assert(inode.nlinks >= 0,\n \"Filesystem: Found negative nlinks value of \" + inode.nlinks);\n dbg_assert(!parent_inode.direntries.has(name),\n \"Filesystem: Name '\" + name + \"' is already taken\");\n\n parent_inode.direntries.set(name, idx);\n inode.nlinks++;\n\n if(this.IsDirectory(idx))\n {\n dbg_assert(!inode.direntries.has(\"..\"),\n \"Filesystem: Cannot link a directory twice\");\n\n if(!inode.direntries.has(\".\")) inode.nlinks++;\n inode.direntries.set(\".\", idx);\n\n inode.direntries.set(\"..\", parentid);\n parent_inode.nlinks++;\n }\n};\n\n/**\n * @private\n * @param {number} parentid\n * @param {string} name\n */\nFS.prototype.unlink_from_dir = function(parentid, name)\n{\n const idx = this.Search(parentid, name);\n const inode = this.inodes[idx];\n const parent_inode = this.inodes[parentid];\n\n dbg_assert(!this.is_forwarder(parent_inode), \"Filesystem: Can't unlink from forwarders\");\n dbg_assert(this.IsDirectory(parentid), \"Filesystem: Can't unlink from non-directories\");\n\n const exists = parent_inode.direntries.delete(name);\n if(!exists)\n {\n dbg_assert(false, \"Filesystem: Can't unlink non-existent file: \" + name);\n return;\n }\n\n inode.nlinks--;\n\n if(this.IsDirectory(idx))\n {\n dbg_assert(inode.direntries.get(\"..\") === parentid,\n \"Filesystem: Found directory with bad parent id\");\n\n inode.direntries.delete(\"..\");\n parent_inode.nlinks--;\n }\n\n dbg_assert(inode.nlinks >= 0,\n \"Filesystem: Found negative nlinks value of \" + inode.nlinks);\n};\n\nFS.prototype.PushInode = function(inode, parentid, name) {\n if(parentid !== -1) {\n this.inodes.push(inode);\n inode.fid = this.inodes.length - 1;\n this.link_under_dir(parentid, inode.fid, name);\n return;\n } else {\n if(this.inodes.length === 0) { // if root directory\n this.inodes.push(inode);\n inode.direntries.set(\".\", 0);\n inode.direntries.set(\"..\", 0);\n inode.nlinks = 2;\n return;\n }\n }\n\n dbg_assert(false, \"Error in Filesystem: Pushed inode with name = \"+ name + \" has no parent\");\n};\n\n/** @constructor */\nfunction Inode(qidnumber)\n{\n this.direntries = new Map(); // maps filename to inode id\n this.status = 0;\n this.size = 0x0;\n this.uid = 0x0;\n this.gid = 0x0;\n this.fid = 0;\n this.ctime = 0;\n this.atime = 0;\n this.mtime = 0;\n this.major = 0x0;\n this.minor = 0x0;\n this.symlink = \"\";\n this.mode = 0x01ED;\n this.qid = {\n type: 0,\n version: 0,\n path: qidnumber,\n };\n this.caps = undefined;\n this.nlinks = 0;\n this.sha256sum = \"\";\n\n /** @type{!Array} */\n this.locks = []; // lock regions applied to the file, sorted by starting offset.\n\n // For forwarders:\n this.mount_id = -1; // which fs in this.mounts does this inode forward to?\n this.foreign_id = -1; // which foreign inode id does it represent?\n\n //this.qid_type = 0;\n //this.qid_version = 0;\n //this.qid_path = qidnumber;\n}\n\nInode.prototype.get_state = function()\n{\n const state = [];\n state[0] = this.mode;\n\n if((this.mode & S_IFMT) === S_IFDIR)\n {\n state[1] = [...this.direntries];\n }\n else if((this.mode & S_IFMT) === S_IFREG)\n {\n state[1] = this.sha256sum;\n }\n else if((this.mode & S_IFMT) === S_IFLNK)\n {\n state[1] = this.symlink;\n }\n else if((this.mode & S_IFMT) === S_IFSOCK)\n {\n state[1] = [this.minor, this.major];\n }\n else\n {\n state[1] = null;\n }\n\n state[2] = this.locks;\n state[3] = this.status;\n state[4] = this.size;\n state[5] = this.uid;\n state[6] = this.gid;\n state[7] = this.fid;\n state[8] = this.ctime;\n state[9] = this.atime;\n state[10] = this.mtime;\n state[11] = this.qid.version;\n state[12] = this.qid.path;\n state[13] = this.nlinks;\n\n //state[23] = this.mount_id;\n //state[24] = this.foreign_id;\n //state[25] = this.caps; // currently not writable\n return state;\n};\n\nInode.prototype.set_state = function(state)\n{\n this.mode = state[0];\n\n if((this.mode & S_IFMT) === S_IFDIR)\n {\n this.direntries = new Map();\n for(const [name, entry] of state[1])\n {\n this.direntries.set(name, entry);\n }\n }\n else if((this.mode & S_IFMT) === S_IFREG)\n {\n this.sha256sum = state[1];\n }\n else if((this.mode & S_IFMT) === S_IFLNK)\n {\n this.symlink = state[1];\n }\n else if((this.mode & S_IFMT) === S_IFSOCK)\n {\n [this.minor, this.major] = state[1];\n }\n else\n {\n // Nothing\n }\n\n this.locks = [];\n for(const lock_state of state[2])\n {\n const lock = new FSLockRegion();\n lock.set_state(lock_state);\n this.locks.push(lock);\n }\n this.status = state[3];\n this.size = state[4];\n this.uid = state[5];\n this.gid = state[6];\n this.fid = state[7];\n this.ctime = state[8];\n this.atime = state[9];\n this.mtime = state[10];\n this.qid.type = (this.mode & S_IFMT) >> 8;\n this.qid.version = state[11];\n this.qid.path = state[12];\n this.nlinks = state[13];\n\n //this.mount_id = state[23];\n //this.foreign_id = state[24];\n //this.caps = state[20];\n};\n\n/**\n * Clones given inode to new idx, effectively diverting the inode to new idx value.\n * Hence, original idx value is now free to use without losing the original information.\n * @private\n * @param {number} parentid Parent of target to divert.\n * @param {string} filename Name of target to divert.\n * @return {number} New idx of diversion.\n */\nFS.prototype.divert = function(parentid, filename)\n{\n const old_idx = this.Search(parentid, filename);\n const old_inode = this.inodes[old_idx];\n const new_inode = new Inode(-1);\n\n dbg_assert(old_inode, \"Filesystem divert: name (\" + filename + \") not found\");\n dbg_assert(this.IsDirectory(old_idx) || old_inode.nlinks <= 1,\n \"Filesystem: can't divert hardlinked file '\" + filename + \"' with nlinks=\" +\n old_inode.nlinks);\n\n // Shallow copy is alright.\n Object.assign(new_inode, old_inode);\n\n const idx = this.inodes.length;\n this.inodes.push(new_inode);\n new_inode.fid = idx;\n\n // Relink references\n if(this.is_forwarder(old_inode))\n {\n this.mounts[old_inode.mount_id].backtrack.set(old_inode.foreign_id, idx);\n }\n if(this.should_be_linked(old_inode))\n {\n this.unlink_from_dir(parentid, filename);\n this.link_under_dir(parentid, idx, filename);\n }\n\n // Update children\n if(this.IsDirectory(old_idx) && !this.is_forwarder(old_inode))\n {\n for(const [name, child_id] of new_inode.direntries)\n {\n if(name === \".\" || name === \"..\") continue;\n if(this.IsDirectory(child_id))\n {\n this.inodes[child_id].direntries.set(\"..\", idx);\n }\n }\n }\n\n // Relocate local data if any.\n this.inodedata[idx] = this.inodedata[old_idx];\n delete this.inodedata[old_idx];\n\n // Retire old reference information.\n old_inode.direntries = new Map();\n old_inode.nlinks = 0;\n\n return idx;\n};\n\n/**\n * Copy all non-redundant info.\n * References left untouched: local idx value and links\n * @private\n * @param {!Inode} src_inode\n * @param {!Inode} dest_inode\n */\nFS.prototype.copy_inode = function(src_inode, dest_inode)\n{\n Object.assign(dest_inode, src_inode, {\n fid: dest_inode.fid,\n direntries: dest_inode.direntries,\n nlinks: dest_inode.nlinks,\n });\n};\n\nFS.prototype.CreateInode = function() {\n //console.log(\"CreateInode\", Error().stack);\n const now = Math.round(Date.now() / 1000);\n const inode = new Inode(++this.qidcounter.last_qidnumber);\n inode.atime = inode.ctime = inode.mtime = now;\n return inode;\n};\n\n\n// Note: parentid = -1 for initial root directory.\nFS.prototype.CreateDirectory = function(name, parentid) {\n const parent_inode = this.inodes[parentid];\n if(parentid >= 0 && this.is_forwarder(parent_inode))\n {\n const foreign_parentid = parent_inode.foreign_id;\n const foreign_id = this.follow_fs(parent_inode).CreateDirectory(name, foreign_parentid);\n return this.create_forwarder(parent_inode.mount_id, foreign_id);\n }\n var x = this.CreateInode();\n x.mode = 0x01FF | S_IFDIR;\n if(parentid >= 0) {\n x.uid = this.inodes[parentid].uid;\n x.gid = this.inodes[parentid].gid;\n x.mode = (this.inodes[parentid].mode & 0x1FF) | S_IFDIR;\n }\n x.qid.type = S_IFDIR >> 8;\n this.PushInode(x, parentid, name);\n this.NotifyListeners(this.inodes.length-1, \"newdir\");\n return this.inodes.length-1;\n};\n\nFS.prototype.CreateFile = function(filename, parentid) {\n const parent_inode = this.inodes[parentid];\n if(this.is_forwarder(parent_inode))\n {\n const foreign_parentid = parent_inode.foreign_id;\n const foreign_id = this.follow_fs(parent_inode).CreateFile(filename, foreign_parentid);\n return this.create_forwarder(parent_inode.mount_id, foreign_id);\n }\n var x = this.CreateInode();\n x.uid = this.inodes[parentid].uid;\n x.gid = this.inodes[parentid].gid;\n x.qid.type = S_IFREG >> 8;\n x.mode = (this.inodes[parentid].mode & 0x1B6) | S_IFREG;\n this.PushInode(x, parentid, filename);\n this.NotifyListeners(this.inodes.length-1, \"newfile\");\n return this.inodes.length-1;\n};\n\n\nFS.prototype.CreateNode = function(filename, parentid, major, minor) {\n const parent_inode = this.inodes[parentid];\n if(this.is_forwarder(parent_inode))\n {\n const foreign_parentid = parent_inode.foreign_id;\n const foreign_id =\n this.follow_fs(parent_inode).CreateNode(filename, foreign_parentid, major, minor);\n return this.create_forwarder(parent_inode.mount_id, foreign_id);\n }\n var x = this.CreateInode();\n x.major = major;\n x.minor = minor;\n x.uid = this.inodes[parentid].uid;\n x.gid = this.inodes[parentid].gid;\n x.qid.type = S_IFSOCK >> 8;\n x.mode = (this.inodes[parentid].mode & 0x1B6);\n this.PushInode(x, parentid, filename);\n return this.inodes.length-1;\n};\n\nFS.prototype.CreateSymlink = function(filename, parentid, symlink) {\n const parent_inode = this.inodes[parentid];\n if(this.is_forwarder(parent_inode))\n {\n const foreign_parentid = parent_inode.foreign_id;\n const foreign_id =\n this.follow_fs(parent_inode).CreateSymlink(filename, foreign_parentid, symlink);\n return this.create_forwarder(parent_inode.mount_id, foreign_id);\n }\n var x = this.CreateInode();\n x.uid = this.inodes[parentid].uid;\n x.gid = this.inodes[parentid].gid;\n x.qid.type = S_IFLNK >> 8;\n x.symlink = symlink;\n x.mode = S_IFLNK;\n this.PushInode(x, parentid, filename);\n return this.inodes.length-1;\n};\n\nFS.prototype.CreateTextFile = async function(filename, parentid, str) {\n const parent_inode = this.inodes[parentid];\n if(this.is_forwarder(parent_inode))\n {\n const foreign_parentid = parent_inode.foreign_id;\n const foreign_id = await\n this.follow_fs(parent_inode).CreateTextFile(filename, foreign_parentid, str);\n return this.create_forwarder(parent_inode.mount_id, foreign_id);\n }\n var id = this.CreateFile(filename, parentid);\n var x = this.inodes[id];\n var data = new Uint8Array(str.length);\n x.size = str.length;\n for(var j = 0; j < str.length; j++) {\n data[j] = str.charCodeAt(j);\n }\n await this.set_data(id, data);\n return id;\n};\n\n/**\n * @param {Uint8Array} buffer\n */\nFS.prototype.CreateBinaryFile = async function(filename, parentid, buffer) {\n const parent_inode = this.inodes[parentid];\n if(this.is_forwarder(parent_inode))\n {\n const foreign_parentid = parent_inode.foreign_id;\n const foreign_id = await\n this.follow_fs(parent_inode).CreateBinaryFile(filename, foreign_parentid, buffer);\n return this.create_forwarder(parent_inode.mount_id, foreign_id);\n }\n var id = this.CreateFile(filename, parentid);\n var x = this.inodes[id];\n var data = new Uint8Array(buffer.length);\n data.set(buffer);\n await this.set_data(id, data);\n x.size = buffer.length;\n return id;\n};\n\n\nFS.prototype.OpenInode = async function(id, mode) {\n var inode = this.inodes[id];\n if(this.is_forwarder(inode))\n {\n return await this.follow_fs(inode).OpenInode(inode.foreign_id, mode);\n }\n if((inode.mode&S_IFMT) === S_IFDIR) {\n this.FillDirectory(id);\n }\n /*\n var type = \"\";\n switch(inode.mode&S_IFMT) {\n case S_IFREG: type = \"File\"; break;\n case S_IFBLK: type = \"Block Device\"; break;\n case S_IFDIR: type = \"Directory\"; break;\n case S_IFCHR: type = \"Character Device\"; break;\n }\n */\n //dbg_log(\"open:\" + this.GetFullPath(id) + \" type: \" + inode.mode + \" status:\" + inode.status, LOG_9P);\n};\n\nFS.prototype.CloseInode = async function(id) {\n //dbg_log(\"close: \" + this.GetFullPath(id), LOG_9P);\n var inode = this.inodes[id];\n if(this.is_forwarder(inode))\n {\n return await this.follow_fs(inode).CloseInode(inode.foreign_id);\n }\n if(inode.status === STATUS_ON_STORAGE)\n {\n this.storage.uncache(inode.sha256sum);\n }\n if(inode.status === STATUS_UNLINKED) {\n //dbg_log(\"Filesystem: Delete unlinked file\", LOG_9P);\n inode.status = STATUS_INVALID;\n await this.DeleteData(id);\n }\n};\n\n/**\n * @return {!Promise} 0 if success, or -errno if failured.\n */\nFS.prototype.Rename = async function(olddirid, oldname, newdirid, newname) {\n // dbg_log(\"Rename \" + oldname + \" to \" + newname, LOG_9P);\n if((olddirid === newdirid) && (oldname === newname)) {\n return 0;\n }\n var oldid = this.Search(olddirid, oldname);\n if(oldid === -1)\n {\n return -ENOENT;\n }\n\n // For event notification near end of method.\n var oldpath = this.GetFullPath(olddirid) + \"/\" + oldname;\n\n var newid = this.Search(newdirid, newname);\n if(newid !== -1) {\n const ret = this.Unlink(newdirid, newname);\n if(ret < 0) return ret;\n }\n\n var idx = oldid; // idx contains the id which we want to rename\n var inode = this.inodes[idx];\n const olddir = this.inodes[olddirid];\n const newdir = this.inodes[newdirid];\n\n if(!this.is_forwarder(olddir) && !this.is_forwarder(newdir))\n {\n // Move inode within current filesystem.\n\n this.unlink_from_dir(olddirid, oldname);\n this.link_under_dir(newdirid, idx, newname);\n\n inode.qid.version++;\n }\n else if(this.is_forwarder(olddir) && olddir.mount_id === newdir.mount_id)\n {\n // Move inode within the same child filesystem.\n\n const ret = await\n this.follow_fs(olddir).Rename(olddir.foreign_id, oldname, newdir.foreign_id, newname);\n\n if(ret < 0) return ret;\n }\n else if(this.is_a_root(idx))\n {\n // The actual inode is a root of some descendant filesystem.\n // Moving mountpoint across fs not supported - needs to update all corresponding forwarders.\n dbg_log(\"XXX: Attempted to move mountpoint (\" + oldname + \") - skipped\", LOG_9P);\n return -EPERM;\n }\n else if(!this.IsDirectory(idx) && this.GetInode(idx).nlinks > 1)\n {\n // Move hardlinked inode vertically in mount tree.\n dbg_log(\"XXX: Attempted to move hardlinked file (\" + oldname + \") \" +\n \"across filesystems - skipped\", LOG_9P);\n return -EPERM;\n }\n else\n {\n // Jump between filesystems.\n\n // Can't work with both old and new inode information without first diverting the old\n // information into a new idx value.\n const diverted_old_idx = this.divert(olddirid, oldname);\n const old_real_inode = this.GetInode(idx);\n\n const data = await this.Read(diverted_old_idx, 0, old_real_inode.size);\n\n if(this.is_forwarder(newdir))\n {\n // Create new inode.\n const foreign_fs = this.follow_fs(newdir);\n const foreign_id = this.IsDirectory(diverted_old_idx) ?\n foreign_fs.CreateDirectory(newname, newdir.foreign_id) :\n foreign_fs.CreateFile(newname, newdir.foreign_id);\n\n const new_real_inode = foreign_fs.GetInode(foreign_id);\n this.copy_inode(old_real_inode, new_real_inode);\n\n // Point to this new location.\n this.set_forwarder(idx, newdir.mount_id, foreign_id);\n }\n else\n {\n // Replace current forwarder with real inode.\n this.delete_forwarder(inode);\n this.copy_inode(old_real_inode, inode);\n\n // Link into new location in this filesystem.\n this.link_under_dir(newdirid, idx, newname);\n }\n\n // Rewrite data to newly created destination.\n await this.ChangeSize(idx, old_real_inode.size);\n if(data && data.length)\n {\n await this.Write(idx, 0, data.length, data);\n }\n\n // Move children to newly created destination.\n if(this.IsDirectory(idx))\n {\n for(const child_filename of this.GetChildren(diverted_old_idx))\n {\n const ret = await this.Rename(diverted_old_idx, child_filename, idx, child_filename);\n if(ret < 0) return ret;\n }\n }\n\n // Perform destructive changes only after migration succeeded.\n await this.DeleteData(diverted_old_idx);\n const ret = this.Unlink(olddirid, oldname);\n if(ret < 0) return ret;\n }\n\n this.NotifyListeners(idx, \"rename\", {oldpath: oldpath});\n\n return 0;\n};\n\nFS.prototype.Write = async function(id, offset, count, buffer) {\n this.NotifyListeners(id, \"write\");\n var inode = this.inodes[id];\n\n if(this.is_forwarder(inode))\n {\n const foreign_id = inode.foreign_id;\n await this.follow_fs(inode).Write(foreign_id, offset, count, buffer);\n return;\n }\n\n var data = await this.get_buffer(id);\n\n if(!data || data.length < (offset+count)) {\n await this.ChangeSize(id, Math.floor(((offset+count)*3)/2));\n inode.size = offset + count;\n data = await this.get_buffer(id);\n } else\n if(inode.size < (offset+count)) {\n inode.size = offset + count;\n }\n if(buffer)\n {\n data.set(buffer.subarray(0, count), offset);\n }\n await this.set_data(id, data);\n};\n\nFS.prototype.Read = async function(inodeid, offset, count)\n{\n const inode = this.inodes[inodeid];\n if(this.is_forwarder(inode))\n {\n const foreign_id = inode.foreign_id;\n return await this.follow_fs(inode).Read(foreign_id, offset, count);\n }\n\n return await this.get_data(inodeid, offset, count);\n};\n\nFS.prototype.Search = function(parentid, name) {\n const parent_inode = this.inodes[parentid];\n\n if(this.is_forwarder(parent_inode))\n {\n const foreign_parentid = parent_inode.foreign_id;\n const foreign_id = this.follow_fs(parent_inode).Search(foreign_parentid, name);\n if(foreign_id === -1) return -1;\n return this.get_forwarder(parent_inode.mount_id, foreign_id);\n }\n\n const childid = parent_inode.direntries.get(name);\n return childid === undefined ? -1 : childid;\n};\n\nFS.prototype.CountUsedInodes = function()\n{\n let count = this.inodes.length;\n for(const { fs, backtrack } of this.mounts)\n {\n count += fs.CountUsedInodes();\n\n // Forwarder inodes don't count.\n count -= backtrack.size;\n }\n return count;\n};\n\nFS.prototype.CountFreeInodes = function()\n{\n let count = 1024 * 1024;\n for(const { fs } of this.mounts)\n {\n count += fs.CountFreeInodes();\n }\n return count;\n};\n\nFS.prototype.GetTotalSize = function() {\n let size = this.used_size;\n for(const { fs } of this.mounts)\n {\n size += fs.GetTotalSize();\n }\n return size;\n //var size = 0;\n //for(var i=0; i} The buffer that contains the file contents, which may be larger\n * than the data itself. To ensure that any modifications done to this buffer is reflected\n * to the file, call set_data with the modified buffer.\n */\nFS.prototype.get_buffer = async function(idx)\n{\n const inode = this.inodes[idx];\n dbg_assert(inode, `Filesystem get_buffer: idx ${idx} does not point to an inode`);\n\n if(this.inodedata[idx])\n {\n return this.inodedata[idx];\n }\n else if(inode.status === STATUS_ON_STORAGE)\n {\n dbg_assert(inode.sha256sum, \"Filesystem get_data: found inode on server without sha256sum\");\n return await this.storage.read(inode.sha256sum, 0, inode.size, inode.size);\n }\n else\n {\n return null;\n }\n};\n\n/**\n * @private\n * @param {number} idx\n * @param {number} offset\n * @param {number} count\n * @return {!Promise}\n */\nFS.prototype.get_data = async function(idx, offset, count)\n{\n const inode = this.inodes[idx];\n dbg_assert(inode, `Filesystem get_data: idx ${idx} does not point to an inode`);\n\n if(this.inodedata[idx])\n {\n return this.inodedata[idx].subarray(offset, offset + count);\n }\n else if(inode.status === STATUS_ON_STORAGE)\n {\n dbg_assert(inode.sha256sum, \"Filesystem get_data: found inode on server without sha256sum\");\n return await this.storage.read(inode.sha256sum, offset, count, inode.size);\n }\n else\n {\n return null;\n }\n};\n\n/**\n * @private\n * @param {number} idx\n * @param {Uint8Array} buffer\n */\nFS.prototype.set_data = async function(idx, buffer)\n{\n // Current scheme: Save all modified buffers into local inodedata.\n this.inodedata[idx] = buffer;\n if(this.inodes[idx].status === STATUS_ON_STORAGE)\n {\n this.inodes[idx].status = STATUS_OK;\n this.storage.uncache(this.inodes[idx].sha256sum);\n }\n};\n\n/**\n * @param {number} idx\n * @return {!Inode}\n */\nFS.prototype.GetInode = function(idx)\n{\n dbg_assert(!isNaN(idx), \"Filesystem GetInode: NaN idx\");\n dbg_assert(idx >= 0 && idx < this.inodes.length, \"Filesystem GetInode: out of range idx:\" + idx);\n\n const inode = this.inodes[idx];\n if(this.is_forwarder(inode))\n {\n return this.follow_fs(inode).GetInode(inode.foreign_id);\n }\n\n return inode;\n};\n\nFS.prototype.ChangeSize = async function(idx, newsize)\n{\n var inode = this.GetInode(idx);\n var temp = await this.get_data(idx, 0, inode.size);\n //dbg_log(\"change size to: \" + newsize, LOG_9P);\n if(newsize === inode.size) return;\n var data = new Uint8Array(newsize);\n inode.size = newsize;\n if(temp)\n {\n var size = Math.min(temp.length, inode.size);\n data.set(temp.subarray(0, size), 0);\n }\n await this.set_data(idx, data);\n};\n\nFS.prototype.SearchPath = function(path) {\n //path = path.replace(/\\/\\//g, \"/\");\n path = path.replace(\"//\", \"/\");\n var walk = path.split(\"/\");\n if(walk.length > 0 && walk[walk.length - 1].length === 0) walk.pop();\n if(walk.length > 0 && walk[0].length === 0) walk.shift();\n const n = walk.length;\n\n var parentid = -1;\n var id = 0;\n let forward_path = null;\n for(var i=0; i} list\n */\nFS.prototype.GetRecursiveList = function(dirid, list) {\n if(this.is_forwarder(this.inodes[dirid]))\n {\n const foreign_fs = this.follow_fs(this.inodes[dirid]);\n const foreign_dirid = this.inodes[dirid].foreign_id;\n const mount_id = this.inodes[dirid].mount_id;\n\n const foreign_start = list.length;\n foreign_fs.GetRecursiveList(foreign_dirid, list);\n for(let i = foreign_start; i < list.length; i++)\n {\n list[i].parentid = this.get_forwarder(mount_id, list[i].parentid);\n }\n return;\n }\n for(const [name, id] of this.inodes[dirid].direntries)\n {\n if(name !== \".\" && name !== \"..\")\n {\n list.push({ parentid: dirid, name });\n if(this.IsDirectory(id))\n {\n this.GetRecursiveList(id, list);\n }\n }\n }\n};\n\nFS.prototype.RecursiveDelete = function(path) {\n var toDelete = [];\n var ids = this.SearchPath(path);\n if(ids.id === -1) return;\n\n this.GetRecursiveList(ids.id, toDelete);\n\n for(var i=toDelete.length-1; i>=0; i--)\n {\n const ret = this.Unlink(toDelete[i].parentid, toDelete[i].name);\n dbg_assert(ret === 0, \"Filesystem RecursiveDelete failed at parent=\" + toDelete[i].parentid +\n \", name='\" + toDelete[i].name + \"' with error code: \" + (-ret));\n }\n};\n\nFS.prototype.DeleteNode = function(path) {\n var ids = this.SearchPath(path);\n if(ids.id === -1) return;\n\n if((this.inodes[ids.id].mode&S_IFMT) === S_IFREG){\n const ret = this.Unlink(ids.parentid, ids.name);\n dbg_assert(ret === 0, \"Filesystem DeleteNode failed with error code: \" + (-ret));\n }\n else if((this.inodes[ids.id].mode&S_IFMT) === S_IFDIR){\n this.RecursiveDelete(path);\n const ret = this.Unlink(ids.parentid, ids.name);\n dbg_assert(ret === 0, \"Filesystem DeleteNode failed with error code: \" + (-ret));\n }\n};\n\n/** @param {*=} info */\nFS.prototype.NotifyListeners = function(id, action, info) {\n //if(info==undefined)\n // info = {};\n\n //var path = this.GetFullPath(id);\n //if (this.watchFiles[path] === true && action=='write') {\n // message.Send(\"WatchFileEvent\", path);\n //}\n //for (var directory of this.watchDirectories) {\n // if (this.watchDirectories.hasOwnProperty(directory)) {\n // var indexOf = path.indexOf(directory)\n // if(indexOf === 0 || indexOf === 1)\n // message.Send(\"WatchDirectoryEvent\", {path: path, event: action, info: info});\n // }\n //}\n};\n\n\nFS.prototype.Check = function() {\n for(var i=1; i> 12,\n name],\n data, offset);\n }\n};\n\nFS.prototype.RoundToDirentry = function(dirid, offset_target)\n{\n const data = this.inodedata[dirid];\n dbg_assert(data, `FS directory data for dirid=${dirid} should be generated`);\n dbg_assert(data.length, \"FS directory should have at least an entry\");\n\n if(offset_target >= data.length)\n {\n return data.length;\n }\n\n let offset = 0;\n while(true)\n {\n const next_offset = marshall.Unmarshall([\"Q\", \"d\"], data, { offset })[1];\n if(next_offset > offset_target) break;\n offset = next_offset;\n }\n\n return offset;\n};\n\n/**\n * @param {number} idx\n * @return {boolean}\n */\nFS.prototype.IsDirectory = function(idx)\n{\n const inode = this.inodes[idx];\n if(this.is_forwarder(inode))\n {\n return this.follow_fs(inode).IsDirectory(inode.foreign_id);\n }\n return (inode.mode & S_IFMT) === S_IFDIR;\n};\n\n/**\n * @param {number} idx\n * @return {boolean}\n */\nFS.prototype.IsEmpty = function(idx)\n{\n const inode = this.inodes[idx];\n if(this.is_forwarder(inode))\n {\n return this.follow_fs(inode).IsDirectory(inode.foreign_id);\n }\n for(const name of inode.direntries.keys())\n {\n if(name !== \".\" && name !== \"..\") return false;\n }\n return true;\n};\n\n/**\n * @param {number} idx\n * @return {!Array} List of children names\n */\nFS.prototype.GetChildren = function(idx)\n{\n dbg_assert(this.IsDirectory(idx), \"Filesystem: cannot get children of non-directory inode\");\n const inode = this.inodes[idx];\n if(this.is_forwarder(inode))\n {\n return this.follow_fs(inode).GetChildren(inode.foreign_id);\n }\n const children = [];\n for(const name of inode.direntries.keys())\n {\n if(name !== \".\" && name !== \"..\")\n {\n children.push(name);\n }\n }\n return children;\n};\n\n/**\n * @param {number} idx\n * @return {number} Local idx of parent\n */\nFS.prototype.GetParent = function(idx)\n{\n dbg_assert(this.IsDirectory(idx), \"Filesystem: cannot get parent of non-directory inode\");\n\n const inode = this.inodes[idx];\n\n if(this.should_be_linked(inode))\n {\n return inode.direntries.get(\"..\");\n }\n else\n {\n const foreign_dirid = this.follow_fs(inode).GetParent(inode.foreign_id);\n dbg_assert(foreign_dirid !== -1, \"Filesystem: should not have invalid parent ids\");\n return this.get_forwarder(inode.mount_id, foreign_dirid);\n }\n};\n\n\n// -----------------------------------------------------\n\n// only support for security.capabilities\n// should return a \"struct vfs_cap_data\" defined in\n// linux/capability for format\n// check also:\n// sys/capability.h\n// http://lxr.free-electrons.com/source/security/commoncap.c#L376\n// http://man7.org/linux/man-pages/man7/capabilities.7.html\n// http://man7.org/linux/man-pages/man8/getcap.8.html\n// http://man7.org/linux/man-pages/man3/libcap.3.html\nFS.prototype.PrepareCAPs = function(id) {\n var inode = this.GetInode(id);\n if(inode.caps) return inode.caps.length;\n inode.caps = new Uint8Array(20);\n // format is little endian\n // note: getxattr returns -EINVAL if using revision 1 format.\n // note: getxattr presents revision 3 as revision 2 when revision 3 is not needed.\n // magic_etc (revision=0x02: 20 bytes)\n inode.caps[0] = 0x00;\n inode.caps[1] = 0x00;\n inode.caps[2] = 0x00;\n inode.caps[3] = 0x02;\n\n // lower\n // permitted (first 32 capabilities)\n inode.caps[4] = 0xFF;\n inode.caps[5] = 0xFF;\n inode.caps[6] = 0xFF;\n inode.caps[7] = 0xFF;\n // inheritable (first 32 capabilities)\n inode.caps[8] = 0xFF;\n inode.caps[9] = 0xFF;\n inode.caps[10] = 0xFF;\n inode.caps[11] = 0xFF;\n\n // higher\n // permitted (last 6 capabilities)\n inode.caps[12] = 0x3F;\n inode.caps[13] = 0x00;\n inode.caps[14] = 0x00;\n inode.caps[15] = 0x00;\n // inheritable (last 6 capabilities)\n inode.caps[16] = 0x3F;\n inode.caps[17] = 0x00;\n inode.caps[18] = 0x00;\n inode.caps[19] = 0x00;\n\n return inode.caps.length;\n};\n\n// -----------------------------------------------------\n\n/**\n * @constructor\n * @param {FS} filesystem\n */\nfunction FSMountInfo(filesystem)\n{\n /** @type {FS}*/\n this.fs = filesystem;\n\n /**\n * Maps foreign inode id back to local inode id.\n * @type {!Map}\n */\n this.backtrack = new Map();\n}\n\nFSMountInfo.prototype.get_state = function()\n{\n const state = [];\n\n state[0] = this.fs;\n state[1] = [...this.backtrack];\n\n return state;\n};\n\nFSMountInfo.prototype.set_state = function(state)\n{\n this.fs = state[0];\n this.backtrack = new Map(state[1]);\n};\n\n/**\n * @private\n * @param {number} idx Local idx of inode.\n * @param {number} mount_id Mount number of the destination fs.\n * @param {number} foreign_id Foreign idx of destination inode.\n */\nFS.prototype.set_forwarder = function(idx, mount_id, foreign_id)\n{\n const inode = this.inodes[idx];\n\n dbg_assert(inode.nlinks === 0,\n \"Filesystem: attempted to convert an inode into forwarder before unlinking the inode\");\n\n if(this.is_forwarder(inode))\n {\n this.mounts[inode.mount_id].backtrack.delete(inode.foreign_id);\n }\n\n inode.status = STATUS_FORWARDING;\n inode.mount_id = mount_id;\n inode.foreign_id = foreign_id;\n\n this.mounts[mount_id].backtrack.set(foreign_id, idx);\n};\n\n/**\n * @private\n * @param {number} mount_id Mount number of the destination fs.\n * @param {number} foreign_id Foreign idx of destination inode.\n * @return {number} Local idx of newly created forwarder.\n */\nFS.prototype.create_forwarder = function(mount_id, foreign_id)\n{\n const inode = this.CreateInode();\n\n const idx = this.inodes.length;\n this.inodes.push(inode);\n inode.fid = idx;\n\n this.set_forwarder(idx, mount_id, foreign_id);\n return idx;\n};\n\n/**\n * @private\n * @param {Inode} inode\n * @return {boolean}\n */\nFS.prototype.is_forwarder = function(inode)\n{\n return inode.status === STATUS_FORWARDING;\n};\n\n/**\n * Whether the inode it points to is a root of some filesystem.\n * @private\n * @param {number} idx\n * @return {boolean}\n */\nFS.prototype.is_a_root = function(idx)\n{\n return this.GetInode(idx).fid === 0;\n};\n\n/**\n * Ensures forwarder exists, and returns such forwarder, for the described foreign inode.\n * @private\n * @param {number} mount_id\n * @param {number} foreign_id\n * @return {number} Local idx of a forwarder to described inode.\n */\nFS.prototype.get_forwarder = function(mount_id, foreign_id)\n{\n const mount = this.mounts[mount_id];\n\n dbg_assert(foreign_id >= 0, \"Filesystem get_forwarder: invalid foreign_id: \" + foreign_id);\n dbg_assert(mount, \"Filesystem get_forwarder: invalid mount number: \" + mount_id);\n\n const result = mount.backtrack.get(foreign_id);\n\n if(result === undefined)\n {\n // Create if not already exists.\n return this.create_forwarder(mount_id, foreign_id);\n }\n\n return result;\n};\n\n/**\n * @private\n * @param {Inode} inode\n */\nFS.prototype.delete_forwarder = function(inode)\n{\n dbg_assert(this.is_forwarder(inode), \"Filesystem delete_forwarder: expected forwarder\");\n\n inode.status = STATUS_INVALID;\n this.mounts[inode.mount_id].backtrack.delete(inode.foreign_id);\n};\n\n/**\n * @private\n * @param {Inode} inode\n * @return {FS}\n */\nFS.prototype.follow_fs = function(inode)\n{\n const mount = this.mounts[inode.mount_id];\n\n dbg_assert(this.is_forwarder(inode),\n \"Filesystem follow_fs: inode should be a forwarding inode\");\n dbg_assert(mount, \"Filesystem follow_fs: inode should point to valid mounted FS\");\n\n return mount.fs;\n};\n\n/**\n * Mount another filesystem to given path.\n * @param {string} path\n * @param {FS} fs\n * @return {number} inode id of mount point if successful, or -errno if mounting failed.\n */\nFS.prototype.Mount = function(path, fs)\n{\n dbg_assert(fs.qidcounter === this.qidcounter,\n \"Cannot mount filesystem whose qid numbers aren't synchronised with current filesystem.\");\n\n const path_infos = this.SearchPath(path);\n\n if(path_infos.parentid === -1)\n {\n dbg_log(\"Mount failed: parent for path not found: \" + path, LOG_9P);\n return -ENOENT;\n }\n if(path_infos.id !== -1)\n {\n dbg_log(\"Mount failed: file already exists at path: \" + path, LOG_9P);\n return -EEXIST;\n }\n if(path_infos.forward_path)\n {\n const parent = this.inodes[path_infos.parentid];\n const ret = this.follow_fs(parent).Mount(path_infos.forward_path, fs);\n if(ret < 0) return ret;\n return this.get_forwarder(parent.mount_id, ret);\n }\n\n const mount_id = this.mounts.length;\n this.mounts.push(new FSMountInfo(fs));\n\n const idx = this.create_forwarder(mount_id, 0);\n this.link_under_dir(path_infos.parentid, idx, path_infos.name);\n\n return idx;\n};\n\n/**\n * @constructor\n */\nfunction FSLockRegion()\n{\n this.type = P9_LOCK_TYPE_UNLCK;\n this.start = 0;\n this.length = Infinity;\n this.proc_id = -1;\n this.client_id = \"\";\n}\n\nFSLockRegion.prototype.get_state = function()\n{\n const state = [];\n\n state[0] = this.type;\n state[1] = this.start;\n // Infinity is not JSON.stringify-able\n state[2] = this.length === Infinity ? 0 : this.length;\n state[3] = this.proc_id;\n state[4] = this.client_id;\n\n return state;\n};\n\nFSLockRegion.prototype.set_state = function(state)\n{\n this.type = state[0];\n this.start = state[1];\n this.length = state[2] === 0 ? Infinity : state[2];\n this.proc_id = state[3];\n this.client_id = state[4];\n};\n\n/**\n * @return {FSLockRegion}\n */\nFSLockRegion.prototype.clone = function()\n{\n const new_region = new FSLockRegion();\n new_region.set_state(this.get_state());\n return new_region;\n};\n\n/**\n * @param {FSLockRegion} region\n * @return {boolean}\n */\nFSLockRegion.prototype.conflicts_with = function(region)\n{\n if(this.proc_id === region.proc_id && this.client_id === region.client_id) return false;\n if(this.type === P9_LOCK_TYPE_UNLCK || region.type === P9_LOCK_TYPE_UNLCK) return false;\n if(this.type !== P9_LOCK_TYPE_WRLCK && region.type !== P9_LOCK_TYPE_WRLCK) return false;\n if(this.start + this.length <= region.start) return false;\n if(region.start + region.length <= this.start) return false;\n return true;\n};\n\n/**\n * @param {FSLockRegion} region\n * @return {boolean}\n */\nFSLockRegion.prototype.is_alike = function(region)\n{\n return region.proc_id === this.proc_id &&\n region.client_id === this.client_id &&\n region.type === this.type;\n};\n\n/**\n * @param {FSLockRegion} region\n * @return {boolean}\n */\nFSLockRegion.prototype.may_merge_after = function(region)\n{\n return this.is_alike(region) && region.start + region.length === this.start;\n};\n\n/**\n * @param {number} type\n * @param {number} start\n * @param {number} length\n * @param {number} proc_id\n * @param {string} client_id\n * @return {!FSLockRegion}\n */\nFS.prototype.DescribeLock = function(type, start, length, proc_id, client_id)\n{\n dbg_assert(type === P9_LOCK_TYPE_RDLCK ||\n type === P9_LOCK_TYPE_WRLCK ||\n type === P9_LOCK_TYPE_UNLCK,\n \"Filesystem: Invalid lock type: \" + type);\n dbg_assert(start >= 0, \"Filesystem: Invalid negative lock starting offset: \" + start);\n dbg_assert(length > 0, \"Filesystem: Invalid non-positive lock length: \" + length);\n\n const lock = new FSLockRegion();\n lock.type = type;\n lock.start = start;\n lock.length = length;\n lock.proc_id = proc_id;\n lock.client_id = client_id;\n\n return lock;\n};\n\n/**\n * @param {number} id\n * @param {FSLockRegion} request\n * @return {FSLockRegion} The first conflicting lock found, or null if requested lock is possible.\n */\nFS.prototype.GetLock = function(id, request)\n{\n const inode = this.inodes[id];\n\n if(this.is_forwarder(inode))\n {\n const foreign_id = inode.foreign_id;\n return this.follow_fs(inode).GetLock(foreign_id, request);\n }\n\n for(const region of inode.locks)\n {\n if(request.conflicts_with(region))\n {\n return region.clone();\n }\n }\n return null;\n};\n\n/**\n * @param {number} id\n * @param {FSLockRegion} request\n * @param {number} flags\n * @return {number} One of P9_LOCK_SUCCESS / P9_LOCK_BLOCKED / P9_LOCK_ERROR / P9_LOCK_GRACE.\n */\nFS.prototype.Lock = function(id, request, flags)\n{\n const inode = this.inodes[id];\n\n if(this.is_forwarder(inode))\n {\n const foreign_id = inode.foreign_id;\n return this.follow_fs(inode).Lock(foreign_id, request, flags);\n }\n\n request = request.clone();\n\n // (1) Check whether lock is possible before any modification.\n if(request.type !== P9_LOCK_TYPE_UNLCK && this.GetLock(id, request))\n {\n return P9_LOCK_BLOCKED;\n }\n\n // (2) Subtract requested region from locks of the same owner.\n for(let i = 0; i < inode.locks.length; i++)\n {\n const region = inode.locks[i];\n\n dbg_assert(region.length > 0,\n \"Filesystem: Found non-positive lock region length: \" + region.length);\n dbg_assert(region.type === P9_LOCK_TYPE_RDLCK || region.type === P9_LOCK_TYPE_WRLCK,\n \"Filesystem: Found invalid lock type: \" + region.type);\n dbg_assert(!inode.locks[i-1] || inode.locks[i-1].start <= region.start,\n \"Filesystem: Locks should be sorted by starting offset\");\n\n // Skip to requested region.\n if(region.start + region.length <= request.start) continue;\n\n // Check whether we've skipped past the requested region.\n if(request.start + request.length <= region.start) break;\n\n // Skip over locks of different owners.\n if(region.proc_id !== request.proc_id || region.client_id !== request.client_id)\n {\n dbg_assert(!region.conflicts_with(request),\n \"Filesytem: Found conflicting lock region, despite already checked for conflicts\");\n continue;\n }\n\n // Pretend region would be split into parts 1 and 2.\n const start1 = region.start;\n const start2 = request.start + request.length;\n const length1 = request.start - start1;\n const length2 = region.start + region.length - start2;\n\n if(length1 > 0 && length2 > 0 && region.type === request.type)\n {\n // Requested region is already locked with the required type.\n // Return early - no need to modify anything.\n return P9_LOCK_SUCCESS;\n }\n\n if(length1 > 0)\n {\n // Shrink from right / first half of the split.\n region.length = length1;\n }\n\n if(length1 <= 0 && length2 > 0)\n {\n // Shrink from left.\n region.start = start2;\n region.length = length2;\n }\n else if(length2 > 0)\n {\n // Add second half of the split.\n\n // Fast-forward to correct location.\n while(i < inode.locks.length && inode.locks[i].start < start2) i++;\n\n inode.locks.splice(i, 0,\n this.DescribeLock(region.type, start2, length2, region.proc_id, region.client_id));\n }\n else if(length1 <= 0)\n {\n // Requested region completely covers this region. Delete.\n inode.locks.splice(i, 1);\n i--;\n }\n }\n\n // (3) Insert requested lock region as a whole.\n // No point in adding the requested lock region as fragmented bits in the above loop\n // and having to merge them all back into one.\n if(request.type !== P9_LOCK_TYPE_UNLCK)\n {\n let new_region = request;\n let has_merged = false;\n let i = 0;\n\n // Fast-forward to requested position, and try merging with previous region.\n for(; i < inode.locks.length; i++)\n {\n if(new_region.may_merge_after(inode.locks[i]))\n {\n inode.locks[i].length += request.length;\n new_region = inode.locks[i];\n has_merged = true;\n }\n if(request.start <= inode.locks[i].start) break;\n }\n\n if(!has_merged)\n {\n inode.locks.splice(i, 0, new_region);\n i++;\n }\n\n // Try merging with the subsequent alike region.\n for(; i < inode.locks.length; i++)\n {\n if(!inode.locks[i].is_alike(new_region)) continue;\n\n if(inode.locks[i].may_merge_after(new_region))\n {\n new_region.length += inode.locks[i].length;\n inode.locks.splice(i, 1);\n }\n\n // No more mergable regions after this.\n break;\n }\n }\n\n return P9_LOCK_SUCCESS;\n};\n\nFS.prototype.read_dir = function(path)\n{\n const p = this.SearchPath(path);\n\n if(p.id === -1)\n {\n return undefined;\n }\n\n const dir = this.GetInode(p.id);\n\n return Array.from(dir.direntries.keys()).filter(path => path !== \".\" && path !== \"..\");\n};\n\nFS.prototype.read_file = function(file)\n{\n const p = this.SearchPath(file);\n\n if(p.id === -1)\n {\n return Promise.resolve(null);\n }\n\n const inode = this.GetInode(p.id);\n\n return this.Read(p.id, 0, inode.size);\n};\n"
},
{
"path": "lib/marshall.js",
"content": "// -------------------------------------------------\n// ------------------ Marshall ---------------------\n// -------------------------------------------------\n// helper functions for virtio and 9p.\n\nimport { dbg_log } from \"./../src/log.js\";\n\nconst textde = new TextDecoder();\nconst texten = new TextEncoder();\n\n// Inserts data from an array to a byte aligned struct in memory\nexport function Marshall(typelist, input, struct, offset) {\n var item;\n var size = 0;\n for(var i=0; i < typelist.length; i++) {\n item = input[i];\n switch(typelist[i]) {\n case \"w\":\n struct[offset++] = item & 0xFF;\n struct[offset++] = (item >> 8) & 0xFF;\n struct[offset++] = (item >> 16) & 0xFF;\n struct[offset++] = (item >> 24) & 0xFF;\n size += 4;\n break;\n case \"d\": // double word\n struct[offset++] = item & 0xFF;\n struct[offset++] = (item >> 8) & 0xFF;\n struct[offset++] = (item >> 16) & 0xFF;\n struct[offset++] = (item >> 24) & 0xFF;\n struct[offset++] = 0x0;\n struct[offset++] = 0x0;\n struct[offset++] = 0x0;\n struct[offset++] = 0x0;\n size += 8;\n break;\n case \"h\":\n struct[offset++] = item & 0xFF;\n struct[offset++] = item >> 8;\n size += 2;\n break;\n case \"b\":\n struct[offset++] = item;\n size += 1;\n break;\n case \"s\":\n var lengthoffset = offset;\n var length = 0;\n struct[offset++] = 0; // set the length later\n struct[offset++] = 0;\n size += 2;\n\n var stringBytes = texten.encode(item);\n size += stringBytes.byteLength;\n length += stringBytes.byteLength;\n struct.set(stringBytes, offset);\n offset += stringBytes.byteLength;\n\n struct[lengthoffset+0] = length & 0xFF;\n struct[lengthoffset+1] = (length >> 8) & 0xFF;\n break;\n case \"Q\":\n Marshall([\"b\", \"w\", \"d\"], [item.type, item.version, item.path], struct, offset);\n offset += 13;\n size += 13;\n break;\n default:\n dbg_log(\"Marshall: Unknown type=\" + typelist[i]);\n break;\n }\n }\n return size;\n}\n\n\n// Extracts data from a byte aligned struct in memory to an array\nexport function Unmarshall(typelist, struct, state) {\n let offset = state.offset;\n var output = [];\n for(var i=0; i < typelist.length; i++) {\n switch(typelist[i]) {\n case \"w\":\n var val = struct[offset++];\n val += struct[offset++] << 8;\n val += struct[offset++] << 16;\n val += (struct[offset++] << 24) >>> 0;\n output.push(val);\n break;\n case \"d\":\n var val = struct[offset++];\n val += struct[offset++] << 8;\n val += struct[offset++] << 16;\n val += (struct[offset++] << 24) >>> 0;\n offset += 4;\n output.push(val);\n break;\n case \"h\":\n var val = struct[offset++];\n output.push(val + (struct[offset++] << 8));\n break;\n case \"b\":\n output.push(struct[offset++]);\n break;\n case \"s\":\n var len = struct[offset++];\n len += struct[offset++] << 8;\n\n var stringBytes = struct.slice(offset, offset + len);\n offset += len;\n output.push(textde.decode(stringBytes));\n break;\n case \"Q\":\n state.offset = offset;\n const qid = Unmarshall([\"b\", \"w\", \"d\"], struct, state);\n offset = state.offset;\n output.push({\n type: qid[0],\n version: qid[1],\n path: qid[2],\n });\n break;\n default:\n dbg_log(\"Error in Unmarshall: Unknown type=\" + typelist[i]);\n break;\n }\n }\n state.offset = offset;\n return output;\n}\n"
},
{
"path": "lib/softfloat/softfloat.c",
"content": "/**** start inlining ../../source/8086-SSE/softfloat_raiseFlags.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n/**** start inlining platform.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define LITTLEENDIAN 1\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#ifdef __GNUC_STDC_INLINE__\r\n#define INLINE inline\r\n#else\r\n#define INLINE extern inline\r\n#endif\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define SOFTFLOAT_BUILTIN_CLZ 1\r\n#define SOFTFLOAT_INTRINSIC_INT128 1\r\n/**** start inlining opts-GCC.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2017 The Regents of the University of California. All rights\r\nreserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#ifndef opts_GCC_h\r\n#define opts_GCC_h 1\r\n\r\n#ifdef INLINE\r\n\r\n#include \r\n/**** start inlining primitiveTypes.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#ifndef primitiveTypes_h\r\n#define primitiveTypes_h 1\r\n\r\n#include \r\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\n#ifdef LITTLEENDIAN\r\nstruct uint128 { uint64_t v0, v64; };\r\nstruct uint64_extra { uint64_t extra, v; };\r\nstruct uint128_extra { uint64_t extra; struct uint128 v; };\r\n#else\r\nstruct uint128 { uint64_t v64, v0; };\r\nstruct uint64_extra { uint64_t v, extra; };\r\nstruct uint128_extra { struct uint128 v; uint64_t extra; };\r\n#endif\r\n\r\n#endif\r\n\r\n/*----------------------------------------------------------------------------\r\n| These macros are used to isolate the differences in word order between big-\r\n| endian and little-endian platforms.\r\n*----------------------------------------------------------------------------*/\r\n#ifdef LITTLEENDIAN\r\n#define wordIncr 1\r\n#define indexWord( total, n ) (n)\r\n#define indexWordHi( total ) ((total) - 1)\r\n#define indexWordLo( total ) 0\r\n#define indexMultiword( total, m, n ) (n)\r\n#define indexMultiwordHi( total, n ) ((total) - (n))\r\n#define indexMultiwordLo( total, n ) 0\r\n#define indexMultiwordHiBut( total, n ) (n)\r\n#define indexMultiwordLoBut( total, n ) 0\r\n#define INIT_UINTM4( v3, v2, v1, v0 ) { v0, v1, v2, v3 }\r\n#else\r\n#define wordIncr -1\r\n#define indexWord( total, n ) ((total) - 1 - (n))\r\n#define indexWordHi( total ) 0\r\n#define indexWordLo( total ) ((total) - 1)\r\n#define indexMultiword( total, m, n ) ((total) - 1 - (m))\r\n#define indexMultiwordHi( total, n ) 0\r\n#define indexMultiwordLo( total, n ) ((total) - (n))\r\n#define indexMultiwordHiBut( total, n ) 0\r\n#define indexMultiwordLoBut( total, n ) (n)\r\n#define INIT_UINTM4( v3, v2, v1, v0 ) { v3, v2, v1, v0 }\r\n#endif\r\n\r\n#endif\r\n\r\n/**** ended inlining primitiveTypes.h ****/\n\r\n#ifdef SOFTFLOAT_BUILTIN_CLZ\r\n\r\nINLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )\r\n { return a ? __builtin_clz( a ) - 16 : 16; }\r\n#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16\r\n\r\nINLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )\r\n { return a ? __builtin_clz( a ) : 32; }\r\n#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32\r\n\r\nINLINE uint_fast8_t softfloat_countLeadingZeros64( uint64_t a )\r\n { return a ? __builtin_clzll( a ) : 64; }\r\n#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64\r\n\r\n#endif\r\n\r\n#ifdef SOFTFLOAT_INTRINSIC_INT128\r\n\r\nINLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )\r\n{\r\n union { unsigned __int128 ui; struct uint128 s; } uZ;\r\n uZ.ui = (unsigned __int128) a * ((uint_fast64_t) b<<32);\r\n return uZ.s;\r\n}\r\n#define softfloat_mul64ByShifted32To128 softfloat_mul64ByShifted32To128\r\n\r\nINLINE struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b )\r\n{\r\n union { unsigned __int128 ui; struct uint128 s; } uZ;\r\n uZ.ui = (unsigned __int128) a * b;\r\n return uZ.s;\r\n}\r\n#define softfloat_mul64To128 softfloat_mul64To128\r\n\r\nINLINE\r\nstruct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )\r\n{\r\n union { unsigned __int128 ui; struct uint128 s; } uZ;\r\n uZ.ui = ((unsigned __int128) a64<<64 | a0) * b;\r\n return uZ.s;\r\n}\r\n#define softfloat_mul128By32 softfloat_mul128By32\r\n\r\nINLINE\r\nvoid\r\n softfloat_mul128To256M(\r\n uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr )\r\n{\r\n unsigned __int128 z0, mid1, mid, z128;\r\n z0 = (unsigned __int128) a0 * b0;\r\n mid1 = (unsigned __int128) a64 * b0;\r\n mid = mid1 + (unsigned __int128) a0 * b64;\r\n z128 = (unsigned __int128) a64 * b64;\r\n z128 += (unsigned __int128) (mid < mid1)<<64 | mid>>64;\r\n mid <<= 64;\r\n z0 += mid;\r\n z128 += (z0 < mid);\r\n zPtr[indexWord( 4, 0 )] = z0;\r\n zPtr[indexWord( 4, 1 )] = z0>>64;\r\n zPtr[indexWord( 4, 2 )] = z128;\r\n zPtr[indexWord( 4, 3 )] = z128>>64;\r\n}\r\n#define softfloat_mul128To256M softfloat_mul128To256M\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n/**** ended inlining opts-GCC.h ****/\n\r\n/**** ended inlining platform.h ****/\n/**** start inlining softfloat.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n\r\n/*============================================================================\r\n| Note: If SoftFloat is made available as a general library for programs to\r\n| use, it is strongly recommended that a platform-specific version of this\r\n| header, \"softfloat.h\", be created that folds in \"softfloat_types.h\" and that\r\n| eliminates all dependencies on compile-time macros.\r\n*============================================================================*/\r\n\r\n\r\n#ifndef softfloat_h\r\n#define softfloat_h 1\r\n\r\n#include \r\n#include \r\n/**** start inlining softfloat_types.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#ifndef softfloat_types_h\r\n#define softfloat_types_h 1\r\n\r\n#include \r\n\r\n/*----------------------------------------------------------------------------\r\n| Types used to pass 16-bit, 32-bit, 64-bit, and 128-bit floating-point\r\n| arguments and results to/from functions. These types must be exactly\r\n| 16 bits, 32 bits, 64 bits, and 128 bits in size, respectively. Where a\r\n| platform has \"native\" support for IEEE-Standard floating-point formats,\r\n| the types below may, if desired, be defined as aliases for the native types\r\n| (typically 'float' and 'double', and possibly 'long double').\r\n*----------------------------------------------------------------------------*/\r\ntypedef struct { uint16_t v; } float16_t;\r\ntypedef struct { uint32_t v; } float32_t;\r\ntypedef struct { uint64_t v; } float64_t;\r\ntypedef struct { uint64_t v[2]; } float128_t;\r\n\r\n/*----------------------------------------------------------------------------\r\n| The format of an 80-bit extended floating-point number in memory. This\r\n| structure must contain a 16-bit field named 'signExp' and a 64-bit field\r\n| named 'signif'.\r\n*----------------------------------------------------------------------------*/\r\n#ifdef LITTLEENDIAN\r\nstruct extFloat80M { uint64_t signif; uint16_t signExp; };\r\n#else\r\nstruct extFloat80M { uint16_t signExp; uint64_t signif; };\r\n#endif\r\n\r\n/*----------------------------------------------------------------------------\r\n| The type used to pass 80-bit extended floating-point arguments and\r\n| results to/from functions. This type must have size identical to\r\n| 'struct extFloat80M'. Type 'extFloat80_t' can be defined as an alias for\r\n| 'struct extFloat80M'. Alternatively, if a platform has \"native\" support\r\n| for IEEE-Standard 80-bit extended floating-point, it may be possible,\r\n| if desired, to define 'extFloat80_t' as an alias for the native type\r\n| (presumably either 'long double' or a nonstandard compiler-intrinsic type).\r\n| In that case, the 'signif' and 'signExp' fields of 'struct extFloat80M'\r\n| must align exactly with the locations in memory of the sign, exponent, and\r\n| significand of the native type.\r\n*----------------------------------------------------------------------------*/\r\ntypedef struct extFloat80M extFloat80_t;\r\n\r\n#endif\r\n\r\n/**** ended inlining softfloat_types.h ****/\n\r\n#ifndef THREAD_LOCAL\r\n#define THREAD_LOCAL\r\n#endif\r\n\r\n/*----------------------------------------------------------------------------\r\n| Software floating-point underflow tininess-detection mode.\r\n*----------------------------------------------------------------------------*/\r\nextern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;\r\nenum {\r\n softfloat_tininess_beforeRounding = 0,\r\n softfloat_tininess_afterRounding = 1\r\n};\r\n\r\n/*----------------------------------------------------------------------------\r\n| Software floating-point rounding mode. (Mode \"odd\" is supported only if\r\n| SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.)\r\n*----------------------------------------------------------------------------*/\r\nextern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;\r\nenum {\r\n softfloat_round_near_even = 0,\r\n softfloat_round_minMag = 1,\r\n softfloat_round_min = 2,\r\n softfloat_round_max = 3,\r\n softfloat_round_near_maxMag = 4,\r\n softfloat_round_odd = 6\r\n};\r\n\r\n/*----------------------------------------------------------------------------\r\n| Software floating-point exception flags.\r\n*----------------------------------------------------------------------------*/\r\nextern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;\r\nenum {\r\n softfloat_flag_inexact = 1,\r\n softfloat_flag_underflow = 2,\r\n softfloat_flag_overflow = 4,\r\n softfloat_flag_infinite = 8,\r\n softfloat_flag_invalid = 16\r\n};\r\n\r\n/*----------------------------------------------------------------------------\r\n| Routine to raise any or all of the software floating-point exception flags.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_raiseFlags( uint_fast8_t );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Integer-to-floating-point conversion routines.\r\n*----------------------------------------------------------------------------*/\r\nfloat16_t ui32_to_f16( uint32_t );\r\nfloat32_t ui32_to_f32( uint32_t );\r\nfloat64_t ui32_to_f64( uint32_t );\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nextFloat80_t ui32_to_extF80( uint32_t );\r\nfloat128_t ui32_to_f128( uint32_t );\r\n#endif\r\nvoid ui32_to_extF80M( uint32_t, extFloat80_t * );\r\nvoid ui32_to_f128M( uint32_t, float128_t * );\r\nfloat16_t ui64_to_f16( uint64_t );\r\nfloat32_t ui64_to_f32( uint64_t );\r\nfloat64_t ui64_to_f64( uint64_t );\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nextFloat80_t ui64_to_extF80( uint64_t );\r\nfloat128_t ui64_to_f128( uint64_t );\r\n#endif\r\nvoid ui64_to_extF80M( uint64_t, extFloat80_t * );\r\nvoid ui64_to_f128M( uint64_t, float128_t * );\r\nfloat16_t i32_to_f16( int32_t );\r\nfloat32_t i32_to_f32( int32_t );\r\nfloat64_t i32_to_f64( int32_t );\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nextFloat80_t i32_to_extF80( int32_t );\r\nfloat128_t i32_to_f128( int32_t );\r\n#endif\r\nvoid i32_to_extF80M( int32_t, extFloat80_t * );\r\nvoid i32_to_f128M( int32_t, float128_t * );\r\nfloat16_t i64_to_f16( int64_t );\r\nfloat32_t i64_to_f32( int64_t );\r\nfloat64_t i64_to_f64( int64_t );\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nextFloat80_t i64_to_extF80( int64_t );\r\nfloat128_t i64_to_f128( int64_t );\r\n#endif\r\nvoid i64_to_extF80M( int64_t, extFloat80_t * );\r\nvoid i64_to_f128M( int64_t, float128_t * );\r\n\r\n/*----------------------------------------------------------------------------\r\n| 16-bit (half-precision) floating-point operations.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool );\r\nuint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool );\r\nint_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool );\r\nint_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool );\r\nuint_fast32_t f16_to_ui32_r_minMag( float16_t, bool );\r\nuint_fast64_t f16_to_ui64_r_minMag( float16_t, bool );\r\nint_fast32_t f16_to_i32_r_minMag( float16_t, bool );\r\nint_fast64_t f16_to_i64_r_minMag( float16_t, bool );\r\nfloat32_t f16_to_f32( float16_t );\r\nfloat64_t f16_to_f64( float16_t );\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nextFloat80_t f16_to_extF80( float16_t );\r\nfloat128_t f16_to_f128( float16_t );\r\n#endif\r\nvoid f16_to_extF80M( float16_t, extFloat80_t * );\r\nvoid f16_to_f128M( float16_t, float128_t * );\r\nfloat16_t f16_roundToInt( float16_t, uint_fast8_t, bool );\r\nfloat16_t f16_add( float16_t, float16_t );\r\nfloat16_t f16_sub( float16_t, float16_t );\r\nfloat16_t f16_mul( float16_t, float16_t );\r\nfloat16_t f16_mulAdd( float16_t, float16_t, float16_t );\r\nfloat16_t f16_div( float16_t, float16_t );\r\nfloat16_t f16_rem( float16_t, float16_t );\r\nfloat16_t f16_sqrt( float16_t );\r\nbool f16_eq( float16_t, float16_t );\r\nbool f16_le( float16_t, float16_t );\r\nbool f16_lt( float16_t, float16_t );\r\nbool f16_eq_signaling( float16_t, float16_t );\r\nbool f16_le_quiet( float16_t, float16_t );\r\nbool f16_lt_quiet( float16_t, float16_t );\r\nbool f16_isSignalingNaN( float16_t );\r\n\r\n/*----------------------------------------------------------------------------\r\n| 32-bit (single-precision) floating-point operations.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool );\r\nuint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool );\r\nint_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );\r\nint_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool );\r\nuint_fast32_t f32_to_ui32_r_minMag( float32_t, bool );\r\nuint_fast64_t f32_to_ui64_r_minMag( float32_t, bool );\r\nint_fast32_t f32_to_i32_r_minMag( float32_t, bool );\r\nint_fast64_t f32_to_i64_r_minMag( float32_t, bool );\r\nfloat16_t f32_to_f16( float32_t );\r\nfloat64_t f32_to_f64( float32_t );\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nextFloat80_t f32_to_extF80( float32_t );\r\nfloat128_t f32_to_f128( float32_t );\r\n#endif\r\nvoid f32_to_extF80M( float32_t, extFloat80_t * );\r\nvoid f32_to_f128M( float32_t, float128_t * );\r\nfloat32_t f32_roundToInt( float32_t, uint_fast8_t, bool );\r\nfloat32_t f32_add( float32_t, float32_t );\r\nfloat32_t f32_sub( float32_t, float32_t );\r\nfloat32_t f32_mul( float32_t, float32_t );\r\nfloat32_t f32_mulAdd( float32_t, float32_t, float32_t );\r\nfloat32_t f32_div( float32_t, float32_t );\r\nfloat32_t f32_rem( float32_t, float32_t );\r\nfloat32_t f32_sqrt( float32_t );\r\nbool f32_eq( float32_t, float32_t );\r\nbool f32_le( float32_t, float32_t );\r\nbool f32_lt( float32_t, float32_t );\r\nbool f32_eq_signaling( float32_t, float32_t );\r\nbool f32_le_quiet( float32_t, float32_t );\r\nbool f32_lt_quiet( float32_t, float32_t );\r\nbool f32_isSignalingNaN( float32_t );\r\n\r\n/*----------------------------------------------------------------------------\r\n| 64-bit (double-precision) floating-point operations.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );\r\nuint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );\r\nint_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );\r\nint_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );\r\nuint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );\r\nuint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );\r\nint_fast32_t f64_to_i32_r_minMag( float64_t, bool );\r\nint_fast64_t f64_to_i64_r_minMag( float64_t, bool );\r\nfloat16_t f64_to_f16( float64_t );\r\nfloat32_t f64_to_f32( float64_t );\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nextFloat80_t f64_to_extF80( float64_t );\r\nfloat128_t f64_to_f128( float64_t );\r\n#endif\r\nvoid f64_to_extF80M( float64_t, extFloat80_t * );\r\nvoid f64_to_f128M( float64_t, float128_t * );\r\nfloat64_t f64_roundToInt( float64_t, uint_fast8_t, bool );\r\nfloat64_t f64_add( float64_t, float64_t );\r\nfloat64_t f64_sub( float64_t, float64_t );\r\nfloat64_t f64_mul( float64_t, float64_t );\r\nfloat64_t f64_mulAdd( float64_t, float64_t, float64_t );\r\nfloat64_t f64_div( float64_t, float64_t );\r\nfloat64_t f64_rem( float64_t, float64_t );\r\nfloat64_t f64_sqrt( float64_t );\r\nbool f64_eq( float64_t, float64_t );\r\nbool f64_le( float64_t, float64_t );\r\nbool f64_lt( float64_t, float64_t );\r\nbool f64_eq_signaling( float64_t, float64_t );\r\nbool f64_le_quiet( float64_t, float64_t );\r\nbool f64_lt_quiet( float64_t, float64_t );\r\nbool f64_isSignalingNaN( float64_t );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Rounding precision for 80-bit extended double-precision floating-point.\r\n| Valid values are 32, 64, and 80.\r\n*----------------------------------------------------------------------------*/\r\nextern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;\r\n\r\n/*----------------------------------------------------------------------------\r\n| 80-bit extended double-precision floating-point operations.\r\n*----------------------------------------------------------------------------*/\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nuint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );\r\nuint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );\r\nint_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );\r\nint_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );\r\nuint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );\r\nuint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );\r\nint_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );\r\nint_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );\r\nfloat16_t extF80_to_f16( extFloat80_t );\r\nfloat32_t extF80_to_f32( extFloat80_t );\r\nfloat64_t extF80_to_f64( extFloat80_t );\r\nfloat128_t extF80_to_f128( extFloat80_t );\r\nextFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );\r\nextFloat80_t extF80_add( extFloat80_t, extFloat80_t );\r\nextFloat80_t extF80_sub( extFloat80_t, extFloat80_t );\r\nextFloat80_t extF80_mul( extFloat80_t, extFloat80_t );\r\nextFloat80_t extF80_div( extFloat80_t, extFloat80_t );\r\nextFloat80_t extF80_rem( extFloat80_t, extFloat80_t );\r\nextFloat80_t extF80_sqrt( extFloat80_t );\r\nbool extF80_eq( extFloat80_t, extFloat80_t );\r\nbool extF80_le( extFloat80_t, extFloat80_t );\r\nbool extF80_lt( extFloat80_t, extFloat80_t );\r\nbool extF80_eq_signaling( extFloat80_t, extFloat80_t );\r\nbool extF80_le_quiet( extFloat80_t, extFloat80_t );\r\nbool extF80_lt_quiet( extFloat80_t, extFloat80_t );\r\nbool extF80_isSignalingNaN( extFloat80_t );\r\n#endif\r\nuint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );\r\nuint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );\r\nint_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );\r\nint_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );\r\nuint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );\r\nuint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );\r\nint_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );\r\nint_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );\r\nfloat16_t extF80M_to_f16( const extFloat80_t * );\r\nfloat32_t extF80M_to_f32( const extFloat80_t * );\r\nfloat64_t extF80M_to_f64( const extFloat80_t * );\r\nvoid extF80M_to_f128M( const extFloat80_t *, float128_t * );\r\nvoid\r\n extF80M_roundToInt(\r\n const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );\r\nvoid extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );\r\nvoid extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );\r\nvoid extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );\r\nvoid extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );\r\nvoid extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );\r\nvoid extF80M_sqrt( const extFloat80_t *, extFloat80_t * );\r\nbool extF80M_eq( const extFloat80_t *, const extFloat80_t * );\r\nbool extF80M_le( const extFloat80_t *, const extFloat80_t * );\r\nbool extF80M_lt( const extFloat80_t *, const extFloat80_t * );\r\nbool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );\r\nbool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );\r\nbool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );\r\nbool extF80M_isSignalingNaN( const extFloat80_t * );\r\n\r\n/*----------------------------------------------------------------------------\r\n| 128-bit (quadruple-precision) floating-point operations.\r\n*----------------------------------------------------------------------------*/\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nuint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );\r\nuint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );\r\nint_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );\r\nint_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool );\r\nuint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );\r\nuint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );\r\nint_fast32_t f128_to_i32_r_minMag( float128_t, bool );\r\nint_fast64_t f128_to_i64_r_minMag( float128_t, bool );\r\nfloat16_t f128_to_f16( float128_t );\r\nfloat32_t f128_to_f32( float128_t );\r\nfloat64_t f128_to_f64( float128_t );\r\nextFloat80_t f128_to_extF80( float128_t );\r\nfloat128_t f128_roundToInt( float128_t, uint_fast8_t, bool );\r\nfloat128_t f128_add( float128_t, float128_t );\r\nfloat128_t f128_sub( float128_t, float128_t );\r\nfloat128_t f128_mul( float128_t, float128_t );\r\nfloat128_t f128_mulAdd( float128_t, float128_t, float128_t );\r\nfloat128_t f128_div( float128_t, float128_t );\r\nfloat128_t f128_rem( float128_t, float128_t );\r\nfloat128_t f128_sqrt( float128_t );\r\nbool f128_eq( float128_t, float128_t );\r\nbool f128_le( float128_t, float128_t );\r\nbool f128_lt( float128_t, float128_t );\r\nbool f128_eq_signaling( float128_t, float128_t );\r\nbool f128_le_quiet( float128_t, float128_t );\r\nbool f128_lt_quiet( float128_t, float128_t );\r\nbool f128_isSignalingNaN( float128_t );\r\n#endif\r\nuint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );\r\nuint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );\r\nint_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );\r\nint_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );\r\nuint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );\r\nuint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );\r\nint_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );\r\nint_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );\r\nfloat16_t f128M_to_f16( const float128_t * );\r\nfloat32_t f128M_to_f32( const float128_t * );\r\nfloat64_t f128M_to_f64( const float128_t * );\r\nvoid f128M_to_extF80M( const float128_t *, extFloat80_t * );\r\nvoid f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );\r\nvoid f128M_add( const float128_t *, const float128_t *, float128_t * );\r\nvoid f128M_sub( const float128_t *, const float128_t *, float128_t * );\r\nvoid f128M_mul( const float128_t *, const float128_t *, float128_t * );\r\nvoid\r\n f128M_mulAdd(\r\n const float128_t *, const float128_t *, const float128_t *, float128_t *\r\n );\r\nvoid f128M_div( const float128_t *, const float128_t *, float128_t * );\r\nvoid f128M_rem( const float128_t *, const float128_t *, float128_t * );\r\nvoid f128M_sqrt( const float128_t *, float128_t * );\r\nbool f128M_eq( const float128_t *, const float128_t * );\r\nbool f128M_le( const float128_t *, const float128_t * );\r\nbool f128M_lt( const float128_t *, const float128_t * );\r\nbool f128M_eq_signaling( const float128_t *, const float128_t * );\r\nbool f128M_le_quiet( const float128_t *, const float128_t * );\r\nbool f128M_lt_quiet( const float128_t *, const float128_t * );\r\nbool f128M_isSignalingNaN( const float128_t * );\r\n\r\n#endif\r\n\r\n/**** ended inlining softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Raises the exceptions specified by `flags'. Floating-point traps can be\r\n| defined here if desired. It is currently not possible for such a trap\r\n| to substitute a result value. If traps are not implemented, this routine\r\n| should be simply `softfloat_exceptionFlags |= flags;'.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_raiseFlags( uint_fast8_t flags )\r\n{\r\n\r\n softfloat_exceptionFlags |= flags;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/softfloat_raiseFlags.c ****/\n/**** start inlining ../../source/8086-SSE/s_f16UIToCommonNaN.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** start inlining specialize.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#ifndef specialize_h\r\n#define specialize_h 1\r\n\r\n#include \r\n#include \r\n/**** skipping file: primitiveTypes.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Default value for 'softfloat_detectTininess'.\r\n*----------------------------------------------------------------------------*/\r\n#define init_detectTininess softfloat_tininess_afterRounding\r\n\r\n/*----------------------------------------------------------------------------\r\n| The values to return on conversions to 32-bit integer formats that raise an\r\n| invalid exception.\r\n*----------------------------------------------------------------------------*/\r\n#define ui32_fromPosOverflow 0xFFFFFFFF\r\n#define ui32_fromNegOverflow 0xFFFFFFFF\r\n#define ui32_fromNaN 0xFFFFFFFF\r\n#define i32_fromPosOverflow (-0x7FFFFFFF - 1)\r\n#define i32_fromNegOverflow (-0x7FFFFFFF - 1)\r\n#define i32_fromNaN (-0x7FFFFFFF - 1)\r\n\r\n/*----------------------------------------------------------------------------\r\n| The values to return on conversions to 64-bit integer formats that raise an\r\n| invalid exception.\r\n*----------------------------------------------------------------------------*/\r\n#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )\r\n#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )\r\n#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF )\r\n#define i64_fromPosOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)\r\n#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)\r\n#define i64_fromNaN (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)\r\n\r\n/*----------------------------------------------------------------------------\r\n| \"Common NaN\" structure, used to transfer NaN representations from one format\r\n| to another.\r\n*----------------------------------------------------------------------------*/\r\nstruct commonNaN {\r\n bool sign;\r\n#ifdef LITTLEENDIAN\r\n uint64_t v0, v64;\r\n#else\r\n uint64_t v64, v0;\r\n#endif\r\n};\r\n\r\n/*----------------------------------------------------------------------------\r\n| The bit pattern for a default generated 16-bit floating-point NaN.\r\n*----------------------------------------------------------------------------*/\r\n#define defaultNaNF16UI 0xFE00\r\n\r\n/*----------------------------------------------------------------------------\r\n| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a\r\n| 16-bit floating-point signaling NaN.\r\n| Note: This macro evaluates its argument more than once.\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-\r\n| point values, at least one of which is a NaN, returns the bit pattern of\r\n| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a\r\n| signaling NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast16_t\r\n softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );\r\n\r\n/*----------------------------------------------------------------------------\r\n| The bit pattern for a default generated 32-bit floating-point NaN.\r\n*----------------------------------------------------------------------------*/\r\n#define defaultNaNF32UI 0xFFC00000\r\n\r\n/*----------------------------------------------------------------------------\r\n| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a\r\n| 32-bit floating-point signaling NaN.\r\n| Note: This macro evaluates its argument more than once.\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-\r\n| point values, at least one of which is a NaN, returns the bit pattern of\r\n| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a\r\n| signaling NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t\r\n softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );\r\n\r\n/*----------------------------------------------------------------------------\r\n| The bit pattern for a default generated 64-bit floating-point NaN.\r\n*----------------------------------------------------------------------------*/\r\n#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )\r\n\r\n/*----------------------------------------------------------------------------\r\n| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a\r\n| 64-bit floating-point signaling NaN.\r\n| Note: This macro evaluates its argument more than once.\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-\r\n| point values, at least one of which is a NaN, returns the bit pattern of\r\n| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a\r\n| signaling NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast64_t\r\n softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );\r\n\r\n/*----------------------------------------------------------------------------\r\n| The bit pattern for a default generated 80-bit extended floating-point NaN.\r\n*----------------------------------------------------------------------------*/\r\n#define defaultNaNExtF80UI64 0xFFFF\r\n#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )\r\n\r\n/*----------------------------------------------------------------------------\r\n| Returns true when the 80-bit unsigned integer formed from concatenating\r\n| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended\r\n| floating-point signaling NaN.\r\n| Note: This macro evaluates its arguments more than once.\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))\r\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\n/*----------------------------------------------------------------------------\r\n| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is\r\n| defined.\r\n*----------------------------------------------------------------------------*/\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'\r\n| has the bit pattern of an 80-bit extended floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_extF80UIToCommonNaN(\r\n uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended\r\n| floating-point NaN, and returns the bit pattern of this value as an unsigned\r\n| integer.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting the unsigned integer formed from concatenating 'uiA64' and\r\n| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting\r\n| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another\r\n| 80-bit extended floating-point value, and assuming at least on of these\r\n| floating-point values is a NaN, returns the bit pattern of the combined NaN\r\n| result. If either original floating-point value is a signaling NaN, the\r\n| invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128\r\n softfloat_propagateNaNExtF80UI(\r\n uint_fast16_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast16_t uiB64,\r\n uint_fast64_t uiB0\r\n );\r\n\r\n/*----------------------------------------------------------------------------\r\n| The bit pattern for a default generated 128-bit floating-point NaN.\r\n*----------------------------------------------------------------------------*/\r\n#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )\r\n#define defaultNaNF128UI0 UINT64_C( 0 )\r\n\r\n/*----------------------------------------------------------------------------\r\n| Returns true when the 128-bit unsigned integer formed from concatenating\r\n| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-\r\n| point signaling NaN.\r\n| Note: This macro evaluates its arguments more than once.\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'\r\n| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to\r\n| the common NaN form, and stores the resulting common NaN at the location\r\n| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception\r\n| is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_f128UIToCommonNaN(\r\n uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting the unsigned integer formed from concatenating 'uiA64' and\r\n| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the\r\n| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another\r\n| 128-bit floating-point value, and assuming at least on of these floating-\r\n| point values is a NaN, returns the bit pattern of the combined NaN result.\r\n| If either original floating-point value is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128\r\n softfloat_propagateNaNF128UI(\r\n uint_fast64_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast64_t uiB64,\r\n uint_fast64_t uiB0\r\n );\r\n\r\n#else\r\n\r\n/*----------------------------------------------------------------------------\r\n| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not\r\n| defined.\r\n*----------------------------------------------------------------------------*/\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is\r\n| a NaN, converts this NaN to the common NaN form, and stores the resulting\r\n| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling\r\n| NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_extF80MToCommonNaN(\r\n const struct extFloat80M *aSPtr, struct commonNaN *zPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended\r\n| floating-point NaN, and stores this NaN at the location pointed to by\r\n| 'zSPtr'.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_commonNaNToExtF80M(\r\n const struct commonNaN *aPtr, struct extFloat80M *zSPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming at least one of the two 80-bit extended floating-point values\r\n| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result\r\n| at the location pointed to by 'zSPtr'. If either original floating-point\r\n| value is a signaling NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_propagateNaNExtF80M(\r\n const struct extFloat80M *aSPtr,\r\n const struct extFloat80M *bSPtr,\r\n struct extFloat80M *zSPtr\r\n );\r\n\r\n/*----------------------------------------------------------------------------\r\n| The bit pattern for a default generated 128-bit floating-point NaN.\r\n*----------------------------------------------------------------------------*/\r\n#define defaultNaNF128UI96 0xFFFF8000\r\n#define defaultNaNF128UI64 0\r\n#define defaultNaNF128UI32 0\r\n#define defaultNaNF128UI0 0\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,\r\n| converts this NaN to the common NaN form, and stores the resulting common\r\n| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,\r\n| the invalid exception is raised. Argument 'aWPtr' points to an array of\r\n| four 32-bit elements that concatenate in the platform's normal endian order\r\n| to form a 128-bit floating-point value.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point\r\n| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument\r\n| 'zWPtr' points to an array of four 32-bit elements that concatenate in the\r\n| platform's normal endian order to form a 128-bit floating-point value.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );\r\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming at least one of the two 128-bit floating-point values pointed to by\r\n| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location\r\n| pointed to by 'zWPtr'. If either original floating-point value is a\r\n| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',\r\n| and 'zWPtr' points to an array of four 32-bit elements that concatenate in\r\n| the platform's normal endian order to form a 128-bit floating-point value.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_propagateNaNF128M(\r\n const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n/**** ended inlining specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )\r\n{\r\n\r\n if ( softfloat_isSigNaNF16UI( uiA ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n }\r\n zPtr->sign = uiA>>15;\r\n zPtr->v64 = (uint_fast64_t) uiA<<54;\r\n zPtr->v0 = 0;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_f16UIToCommonNaN.c ****/\n/**** start inlining ../../source/8086-SSE/s_commonNaNToF16UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: specialize.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )\r\n{\r\n\r\n return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_commonNaNToF16UI.c ****/\n/**** start inlining ../../source/8086-SSE/s_propagateNaNF16UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** start inlining internals.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#ifndef internals_h\r\n#define internals_h 1\r\n\r\n#include \r\n#include \r\n/**** start inlining primitives.h ****/\n\r\n/*============================================================================\r\n\r\nThis C header file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#ifndef primitives_h\r\n#define primitives_h 1\r\n\r\n#include \r\n#include \r\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shortShiftRightJam64\r\n#define softfloat_shortShiftRightJam64 softfloat_shortShiftRightJam64\r\n/*----------------------------------------------------------------------------\r\n| Shifts 'a' right by the number of bits given in 'dist', which must be in\r\n| the range 1 to 63. If any nonzero bits are shifted off, they are \"jammed\"\r\n| into the least-significant bit of the shifted value by setting the least-\r\n| significant bit to 1. This shifted-and-jammed value is returned.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nuint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )\r\n { return a>>dist | ((a & (((uint_fast64_t) 1<>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);\r\n}\r\n#else\r\nuint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam64\r\n#define softfloat_shiftRightJam64 softfloat_shiftRightJam64\r\n/*----------------------------------------------------------------------------\r\n| Shifts 'a' right by the number of bits given in 'dist', which must not\r\n| be zero. If any nonzero bits are shifted off, they are \"jammed\" into the\r\n| least-significant bit of the shifted value by setting the least-significant\r\n| bit to 1. This shifted-and-jammed value is returned.\r\n| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is\r\n| greater than 64, the result will be either 0 or 1, depending on whether 'a'\r\n| is zero or nonzero.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)\r\nINLINE uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )\r\n{\r\n return\r\n (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);\r\n}\r\n#else\r\nuint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist );\r\n#endif\r\n#endif\r\n\r\n/*----------------------------------------------------------------------------\r\n| A constant table that translates an 8-bit unsigned integer (the array index)\r\n| into the number of leading 0 bits before the most-significant 1 of that\r\n| integer. For integer zero (index 0), the corresponding table element is 8.\r\n*----------------------------------------------------------------------------*/\r\nextern const uint_least8_t softfloat_countLeadingZeros8[256];\r\n\r\n#ifndef softfloat_countLeadingZeros16\r\n#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16\r\n/*----------------------------------------------------------------------------\r\n| Returns the number of leading 0 bits before the most-significant 1 bit of\r\n| 'a'. If 'a' is zero, 16 is returned.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )\r\n{\r\n uint_fast8_t count = 8;\r\n if ( 0x100 <= a ) {\r\n count = 0;\r\n a >>= 8;\r\n }\r\n count += softfloat_countLeadingZeros8[a];\r\n return count;\r\n}\r\n#else\r\nuint_fast8_t softfloat_countLeadingZeros16( uint16_t a );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_countLeadingZeros32\r\n#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32\r\n/*----------------------------------------------------------------------------\r\n| Returns the number of leading 0 bits before the most-significant 1 bit of\r\n| 'a'. If 'a' is zero, 32 is returned.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)\r\nINLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )\r\n{\r\n uint_fast8_t count = 0;\r\n if ( a < 0x10000 ) {\r\n count = 16;\r\n a <<= 16;\r\n }\r\n if ( a < 0x1000000 ) {\r\n count += 8;\r\n a <<= 8;\r\n }\r\n count += softfloat_countLeadingZeros8[a>>24];\r\n return count;\r\n}\r\n#else\r\nuint_fast8_t softfloat_countLeadingZeros32( uint32_t a );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_countLeadingZeros64\r\n#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64\r\n/*----------------------------------------------------------------------------\r\n| Returns the number of leading 0 bits before the most-significant 1 bit of\r\n| 'a'. If 'a' is zero, 64 is returned.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast8_t softfloat_countLeadingZeros64( uint64_t a );\r\n#endif\r\n\r\nextern const uint16_t softfloat_approxRecip_1k0s[16];\r\nextern const uint16_t softfloat_approxRecip_1k1s[16];\r\n\r\n#ifndef softfloat_approxRecip32_1\r\n/*----------------------------------------------------------------------------\r\n| Returns an approximation to the reciprocal of the number represented by 'a',\r\n| where 'a' is interpreted as an unsigned fixed-point number with one integer\r\n| bit and 31 fraction bits. The 'a' input must be \"normalized\", meaning that\r\n| its most-significant bit (bit 31) must be 1. Thus, if A is the value of\r\n| the fixed-point interpretation of 'a', then 1 <= A < 2. The returned value\r\n| is interpreted as a pure unsigned fraction, having no integer bits and 32\r\n| fraction bits. The approximation returned is never greater than the true\r\n| reciprocal 1/A, and it differs from the true reciprocal by at most 2.006 ulp\r\n| (units in the last place).\r\n*----------------------------------------------------------------------------*/\r\n#ifdef SOFTFLOAT_FAST_DIV64TO32\r\n#define softfloat_approxRecip32_1( a ) ((uint32_t) (UINT64_C( 0x7FFFFFFFFFFFFFFF ) / (uint32_t) (a)))\r\n#else\r\nuint32_t softfloat_approxRecip32_1( uint32_t a );\r\n#endif\r\n#endif\r\n\r\nextern const uint16_t softfloat_approxRecipSqrt_1k0s[16];\r\nextern const uint16_t softfloat_approxRecipSqrt_1k1s[16];\r\n\r\n#ifndef softfloat_approxRecipSqrt32_1\r\n/*----------------------------------------------------------------------------\r\n| Returns an approximation to the reciprocal of the square root of the number\r\n| represented by 'a', where 'a' is interpreted as an unsigned fixed-point\r\n| number either with one integer bit and 31 fraction bits or with two integer\r\n| bits and 30 fraction bits. The format of 'a' is determined by 'oddExpA',\r\n| which must be either 0 or 1. If 'oddExpA' is 1, 'a' is interpreted as\r\n| having one integer bit, and if 'oddExpA' is 0, 'a' is interpreted as having\r\n| two integer bits. The 'a' input must be \"normalized\", meaning that its\r\n| most-significant bit (bit 31) must be 1. Thus, if A is the value of the\r\n| fixed-point interpretation of 'a', it follows that 1 <= A < 2 when 'oddExpA'\r\n| is 1, and 2 <= A < 4 when 'oddExpA' is 0.\r\n| The returned value is interpreted as a pure unsigned fraction, having\r\n| no integer bits and 32 fraction bits. The approximation returned is never\r\n| greater than the true reciprocal 1/sqrt(A), and it differs from the true\r\n| reciprocal by at most 2.06 ulp (units in the last place). The approximation\r\n| returned is also always within the range 0.5 to 1; thus, the most-\r\n| significant bit of the result is always set.\r\n*----------------------------------------------------------------------------*/\r\nuint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a );\r\n#endif\r\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\n/*----------------------------------------------------------------------------\r\n| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is\r\n| defined.\r\n*----------------------------------------------------------------------------*/\r\n\r\n#ifndef softfloat_eq128\r\n#define softfloat_eq128 softfloat_eq128\r\n/*----------------------------------------------------------------------------\r\n| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'\r\n| and 'a0' is equal to the 128-bit unsigned integer formed by concatenating\r\n| 'b64' and 'b0'.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)\r\nINLINE\r\nbool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n { return (a64 == b64) && (a0 == b0); }\r\n#else\r\nbool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_le128\r\n#define softfloat_le128 softfloat_le128\r\n/*----------------------------------------------------------------------------\r\n| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'\r\n| and 'a0' is less than or equal to the 128-bit unsigned integer formed by\r\n| concatenating 'b64' and 'b0'.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nbool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n { return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); }\r\n#else\r\nbool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_lt128\r\n#define softfloat_lt128 softfloat_lt128\r\n/*----------------------------------------------------------------------------\r\n| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'\r\n| and 'a0' is less than the 128-bit unsigned integer formed by concatenating\r\n| 'b64' and 'b0'.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nbool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n { return (a64 < b64) || ((a64 == b64) && (a0 < b0)); }\r\n#else\r\nbool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftLeft128\r\n#define softfloat_shortShiftLeft128 softfloat_shortShiftLeft128\r\n/*----------------------------------------------------------------------------\r\n| Shifts the 128 bits formed by concatenating 'a64' and 'a0' left by the\r\n| number of bits given in 'dist', which must be in the range 1 to 63.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint128\r\n softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )\r\n{\r\n struct uint128 z;\r\n z.v64 = a64<>(-dist & 63);\r\n z.v0 = a0<>dist;\r\n z.v0 = a64<<(-dist & 63) | a0>>dist;\r\n return z;\r\n}\r\n#else\r\nstruct uint128\r\n softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRightJam64Extra\r\n#define softfloat_shortShiftRightJam64Extra softfloat_shortShiftRightJam64Extra\r\n/*----------------------------------------------------------------------------\r\n| This function is the same as 'softfloat_shiftRightJam64Extra' (below),\r\n| except that 'dist' must be in the range 1 to 63.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint64_extra\r\n softfloat_shortShiftRightJam64Extra(\r\n uint64_t a, uint64_t extra, uint_fast8_t dist )\r\n{\r\n struct uint64_extra z;\r\n z.v = a>>dist;\r\n z.extra = a<<(-dist & 63) | (extra != 0);\r\n return z;\r\n}\r\n#else\r\nstruct uint64_extra\r\n softfloat_shortShiftRightJam64Extra(\r\n uint64_t a, uint64_t extra, uint_fast8_t dist );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRightJam128\r\n#define softfloat_shortShiftRightJam128 softfloat_shortShiftRightJam128\r\n/*----------------------------------------------------------------------------\r\n| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the\r\n| number of bits given in 'dist', which must be in the range 1 to 63. If any\r\n| nonzero bits are shifted off, they are \"jammed\" into the least-significant\r\n| bit of the shifted value by setting the least-significant bit to 1. This\r\n| shifted-and-jammed value is returned.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint128\r\n softfloat_shortShiftRightJam128(\r\n uint64_t a64, uint64_t a0, uint_fast8_t dist )\r\n{\r\n uint_fast8_t negDist = -dist;\r\n struct uint128 z;\r\n z.v64 = a64>>dist;\r\n z.v0 =\r\n a64<<(negDist & 63) | a0>>dist\r\n | ((uint64_t) (a0<<(negDist & 63)) != 0);\r\n return z;\r\n}\r\n#else\r\nstruct uint128\r\n softfloat_shortShiftRightJam128(\r\n uint64_t a64, uint64_t a0, uint_fast8_t dist );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRightJam128Extra\r\n#define softfloat_shortShiftRightJam128Extra softfloat_shortShiftRightJam128Extra\r\n/*----------------------------------------------------------------------------\r\n| This function is the same as 'softfloat_shiftRightJam128Extra' (below),\r\n| except that 'dist' must be in the range 1 to 63.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint128_extra\r\n softfloat_shortShiftRightJam128Extra(\r\n uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist )\r\n{\r\n uint_fast8_t negDist = -dist;\r\n struct uint128_extra z;\r\n z.v.v64 = a64>>dist;\r\n z.v.v0 = a64<<(negDist & 63) | a0>>dist;\r\n z.extra = a0<<(negDist & 63) | (extra != 0);\r\n return z;\r\n}\r\n#else\r\nstruct uint128_extra\r\n softfloat_shortShiftRightJam128Extra(\r\n uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam64Extra\r\n#define softfloat_shiftRightJam64Extra softfloat_shiftRightJam64Extra\r\n/*----------------------------------------------------------------------------\r\n| Shifts the 128 bits formed by concatenating 'a' and 'extra' right by 64\r\n| _plus_ the number of bits given in 'dist', which must not be zero. This\r\n| shifted value is at most 64 nonzero bits and is returned in the 'v' field\r\n| of the 'struct uint64_extra' result. The 64-bit 'extra' field of the result\r\n| contains a value formed as follows from the bits that were shifted off: The\r\n| _last_ bit shifted off is the most-significant bit of the 'extra' field, and\r\n| the other 63 bits of the 'extra' field are all zero if and only if _all_but_\r\n| _the_last_ bits shifted off were all zero.\r\n| (This function makes more sense if 'a' and 'extra' are considered to form\r\n| an unsigned fixed-point number with binary point between 'a' and 'extra'.\r\n| This fixed-point value is shifted right by the number of bits given in\r\n| 'dist', and the integer part of this shifted value is returned in the 'v'\r\n| field of the result. The fractional part of the shifted value is modified\r\n| as described above and returned in the 'extra' field of the result.)\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint64_extra\r\n softfloat_shiftRightJam64Extra(\r\n uint64_t a, uint64_t extra, uint_fast32_t dist )\r\n{\r\n struct uint64_extra z;\r\n if ( dist < 64 ) {\r\n z.v = a>>dist;\r\n z.extra = a<<(-dist & 63);\r\n } else {\r\n z.v = 0;\r\n z.extra = (dist == 64) ? a : (a != 0);\r\n }\r\n z.extra |= (extra != 0);\r\n return z;\r\n}\r\n#else\r\nstruct uint64_extra\r\n softfloat_shiftRightJam64Extra(\r\n uint64_t a, uint64_t extra, uint_fast32_t dist );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam128\r\n//#define softfloat_shiftRightJam128 softfloat_shiftRightJam128\r\n/*----------------------------------------------------------------------------\r\n| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the\r\n| number of bits given in 'dist', which must not be zero. If any nonzero bits\r\n| are shifted off, they are \"jammed\" into the least-significant bit of the\r\n| shifted value by setting the least-significant bit to 1. This shifted-and-\r\n| jammed value is returned.\r\n| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is\r\n| greater than 128, the result will be either 0 or 1, depending on whether the\r\n| original 128 bits are all zeros.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128\r\n softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist );\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam128Extra\r\n#define softfloat_shiftRightJam128Extra softfloat_shiftRightJam128Extra\r\n/*----------------------------------------------------------------------------\r\n| Shifts the 192 bits formed by concatenating 'a64', 'a0', and 'extra' right\r\n| by 64 _plus_ the number of bits given in 'dist', which must not be zero.\r\n| This shifted value is at most 128 nonzero bits and is returned in the 'v'\r\n| field of the 'struct uint128_extra' result. The 64-bit 'extra' field of the\r\n| result contains a value formed as follows from the bits that were shifted\r\n| off: The _last_ bit shifted off is the most-significant bit of the 'extra'\r\n| field, and the other 63 bits of the 'extra' field are all zero if and only\r\n| if _all_but_the_last_ bits shifted off were all zero.\r\n| (This function makes more sense if 'a64', 'a0', and 'extra' are considered\r\n| to form an unsigned fixed-point number with binary point between 'a0' and\r\n| 'extra'. This fixed-point value is shifted right by the number of bits\r\n| given in 'dist', and the integer part of this shifted value is returned\r\n| in the 'v' field of the result. The fractional part of the shifted value\r\n| is modified as described above and returned in the 'extra' field of the\r\n| result.)\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128_extra\r\n softfloat_shiftRightJam128Extra(\r\n uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist );\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam256M\r\n#define softfloat_shiftRightJam256M softfloat_shiftRightJam256M\r\n/*----------------------------------------------------------------------------\r\n| Shifts the 256-bit unsigned integer pointed to by 'aPtr' right by the number\r\n| of bits given in 'dist', which must not be zero. If any nonzero bits are\r\n| shifted off, they are \"jammed\" into the least-significant bit of the shifted\r\n| value by setting the least-significant bit to 1. This shifted-and-jammed\r\n| value is stored at the location pointed to by 'zPtr'. Each of 'aPtr' and\r\n| 'zPtr' points to an array of four 64-bit elements that concatenate in the\r\n| platform's normal endian order to form a 256-bit integer.\r\n| The value of 'dist' can be arbitrarily large. In particular, if 'dist'\r\n| is greater than 256, the stored result will be either 0 or 1, depending on\r\n| whether the original 256 bits are all zeros.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_shiftRightJam256M(\r\n const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr );\r\n#endif\r\n\r\n#ifndef softfloat_add128\r\n#define softfloat_add128 softfloat_add128\r\n/*----------------------------------------------------------------------------\r\n| Returns the sum of the 128-bit integer formed by concatenating 'a64' and\r\n| 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'. The\r\n| addition is modulo 2^128, so any carry out is lost.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint128\r\n softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n{\r\n struct uint128 z;\r\n z.v0 = a0 + b0;\r\n z.v64 = a64 + b64 + (z.v0 < a0);\r\n return z;\r\n}\r\n#else\r\nstruct uint128\r\n softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_add256M\r\n/*----------------------------------------------------------------------------\r\n| Adds the two 256-bit integers pointed to by 'aPtr' and 'bPtr'. The addition\r\n| is modulo 2^256, so any carry out is lost. The sum is stored at the\r\n| location pointed to by 'zPtr'. Each of 'aPtr', 'bPtr', and 'zPtr' points to\r\n| an array of four 64-bit elements that concatenate in the platform's normal\r\n| endian order to form a 256-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_add256M(\r\n const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );\r\n#endif\r\n\r\n#ifndef softfloat_sub128\r\n#define softfloat_sub128 softfloat_sub128\r\n/*----------------------------------------------------------------------------\r\n| Returns the difference of the 128-bit integer formed by concatenating 'a64'\r\n| and 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'.\r\n| The subtraction is modulo 2^128, so any borrow out (carry out) is lost.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint128\r\n softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n{\r\n struct uint128 z;\r\n z.v0 = a0 - b0;\r\n z.v64 = a64 - b64;\r\n z.v64 -= (a0 < b0);\r\n return z;\r\n}\r\n#else\r\nstruct uint128\r\n softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_sub256M\r\n/*----------------------------------------------------------------------------\r\n| Subtracts the 256-bit integer pointed to by 'bPtr' from the 256-bit integer\r\n| pointed to by 'aPtr'. The addition is modulo 2^256, so any borrow out\r\n| (carry out) is lost. The difference is stored at the location pointed to\r\n| by 'zPtr'. Each of 'aPtr', 'bPtr', and 'zPtr' points to an array of four\r\n| 64-bit elements that concatenate in the platform's normal endian order to\r\n| form a 256-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_sub256M(\r\n const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );\r\n#endif\r\n\r\n#ifndef softfloat_mul64ByShifted32To128\r\n/*----------------------------------------------------------------------------\r\n| Returns the 128-bit product of 'a', 'b', and 2^32.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)\r\nINLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )\r\n{\r\n uint_fast64_t mid;\r\n struct uint128 z;\r\n mid = (uint_fast64_t) (uint32_t) a * b;\r\n z.v0 = mid<<32;\r\n z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32);\r\n return z;\r\n}\r\n#else\r\nstruct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_mul64To128\r\n/*----------------------------------------------------------------------------\r\n| Returns the 128-bit product of 'a' and 'b'.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128 softfloat_mul64To128( uint64_t a, uint64_t b );\r\n#endif\r\n\r\n#ifndef softfloat_mul128By32\r\n/*----------------------------------------------------------------------------\r\n| Returns the product of the 128-bit integer formed by concatenating 'a64' and\r\n| 'a0', multiplied by 'b'. The multiplication is modulo 2^128; any overflow\r\n| bits are discarded.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)\r\nINLINE\r\nstruct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )\r\n{\r\n struct uint128 z;\r\n uint_fast64_t mid;\r\n uint_fast32_t carry;\r\n z.v0 = a0 * b;\r\n mid = (uint_fast64_t) (uint32_t) (a0>>32) * b;\r\n carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid);\r\n z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32);\r\n return z;\r\n}\r\n#else\r\nstruct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_mul128To256M\r\n/*----------------------------------------------------------------------------\r\n| Multiplies the 128-bit unsigned integer formed by concatenating 'a64' and\r\n| 'a0' by the 128-bit unsigned integer formed by concatenating 'b64' and\r\n| 'b0'. The 256-bit product is stored at the location pointed to by 'zPtr'.\r\n| Argument 'zPtr' points to an array of four 64-bit elements that concatenate\r\n| in the platform's normal endian order to form a 256-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_mul128To256M(\r\n uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr );\r\n#endif\r\n\r\n#else\r\n\r\n/*----------------------------------------------------------------------------\r\n| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not\r\n| defined.\r\n*----------------------------------------------------------------------------*/\r\n\r\n#ifndef softfloat_compare96M\r\n/*----------------------------------------------------------------------------\r\n| Compares the two 96-bit unsigned integers pointed to by 'aPtr' and 'bPtr'.\r\n| Returns -1 if the first integer (A) is less than the second (B); returns 0\r\n| if the two integers are equal; and returns +1 if the first integer (A)\r\n| is greater than the second (B). (The result is thus the signum of A - B.)\r\n| Each of 'aPtr' and 'bPtr' points to an array of three 32-bit elements that\r\n| concatenate in the platform's normal endian order to form a 96-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nint_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr );\r\n#endif\r\n\r\n#ifndef softfloat_compare128M\r\n/*----------------------------------------------------------------------------\r\n| Compares the two 128-bit unsigned integers pointed to by 'aPtr' and 'bPtr'.\r\n| Returns -1 if the first integer (A) is less than the second (B); returns 0\r\n| if the two integers are equal; and returns +1 if the first integer (A)\r\n| is greater than the second (B). (The result is thus the signum of A - B.)\r\n| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that\r\n| concatenate in the platform's normal endian order to form a 128-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nint_fast8_t\r\n softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr );\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftLeft64To96M\r\n/*----------------------------------------------------------------------------\r\n| Extends 'a' to 96 bits and shifts the value left by the number of bits given\r\n| in 'dist', which must be in the range 1 to 31. The result is stored at the\r\n| location pointed to by 'zPtr'. Argument 'zPtr' points to an array of three\r\n| 32-bit elements that concatenate in the platform's normal endian order to\r\n| form a 96-bit integer.\r\n*----------------------------------------------------------------------------*/\r\n#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)\r\nINLINE\r\nvoid\r\n softfloat_shortShiftLeft64To96M(\r\n uint64_t a, uint_fast8_t dist, uint32_t *zPtr )\r\n{\r\n zPtr[indexWord( 3, 0 )] = (uint32_t) a<>= 32 - dist;\r\n zPtr[indexWord( 3, 2 )] = a>>32;\r\n zPtr[indexWord( 3, 1 )] = a;\r\n}\r\n#else\r\nvoid\r\n softfloat_shortShiftLeft64To96M(\r\n uint64_t a, uint_fast8_t dist, uint32_t *zPtr );\r\n#endif\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftLeftM\r\n/*----------------------------------------------------------------------------\r\n| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number\r\n| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist'\r\n| must be in the range 1 to 31. Any nonzero bits shifted off are lost. The\r\n| shifted N-bit result is stored at the location pointed to by 'zPtr'. Each\r\n| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements\r\n| that concatenate in the platform's normal endian order to form an N-bit\r\n| integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_shortShiftLeftM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n uint_fast8_t dist,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftLeft96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shortShiftLeftM' with\r\n| 'size_words' = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shortShiftLeft96M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 3, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftLeft128M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shortShiftLeftM' with\r\n| 'size_words' = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shortShiftLeft128M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 4, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftLeft160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shortShiftLeftM' with\r\n| 'size_words' = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shortShiftLeft160M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 5, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shiftLeftM\r\n/*----------------------------------------------------------------------------\r\n| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number\r\n| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist'\r\n| must not be zero. Any nonzero bits shifted off are lost. The shifted\r\n| N-bit result is stored at the location pointed to by 'zPtr'. Each of 'aPtr'\r\n| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that\r\n| concatenate in the platform's normal endian order to form an N-bit integer.\r\n| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is\r\n| greater than N, the stored result will be 0.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_shiftLeftM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n uint32_t dist,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_shiftLeft96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shiftLeftM' with\r\n| 'size_words' = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shiftLeft96M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 3, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shiftLeft128M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shiftLeftM' with\r\n| 'size_words' = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shiftLeft128M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 4, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shiftLeft160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shiftLeftM' with\r\n| 'size_words' = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shiftLeft160M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 5, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRightM\r\n/*----------------------------------------------------------------------------\r\n| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number\r\n| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist'\r\n| must be in the range 1 to 31. Any nonzero bits shifted off are lost. The\r\n| shifted N-bit result is stored at the location pointed to by 'zPtr'. Each\r\n| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements\r\n| that concatenate in the platform's normal endian order to form an N-bit\r\n| integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_shortShiftRightM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n uint_fast8_t dist,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRight128M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shortShiftRightM' with\r\n| 'size_words' = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shortShiftRight128M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 4, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRight160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shortShiftRightM' with\r\n| 'size_words' = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shortShiftRight160M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 5, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRightJamM\r\n/*----------------------------------------------------------------------------\r\n| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number\r\n| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist'\r\n| must be in the range 1 to 31. If any nonzero bits are shifted off, they are\r\n| \"jammed\" into the least-significant bit of the shifted value by setting the\r\n| least-significant bit to 1. This shifted-and-jammed N-bit result is stored\r\n| at the location pointed to by 'zPtr'. Each of 'aPtr' and 'zPtr' points\r\n| to a 'size_words'-long array of 32-bit elements that concatenate in the\r\n| platform's normal endian order to form an N-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_shortShiftRightJamM(\r\n uint_fast8_t, const uint32_t *, uint_fast8_t, uint32_t * );\r\n#endif\r\n\r\n#ifndef softfloat_shortShiftRightJam160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shortShiftRightJamM' with\r\n| 'size_words' = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shortShiftRightJam160M( aPtr, dist, zPtr ) softfloat_shortShiftRightJamM( 5, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightM\r\n/*----------------------------------------------------------------------------\r\n| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number\r\n| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist'\r\n| must not be zero. Any nonzero bits shifted off are lost. The shifted\r\n| N-bit result is stored at the location pointed to by 'zPtr'. Each of 'aPtr'\r\n| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that\r\n| concatenate in the platform's normal endian order to form an N-bit integer.\r\n| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is\r\n| greater than N, the stored result will be 0.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_shiftRightM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n uint32_t dist,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_shiftRight96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shiftRightM' with\r\n| 'size_words' = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shiftRight96M( aPtr, dist, zPtr ) softfloat_shiftRightM( 3, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJamM\r\n/*----------------------------------------------------------------------------\r\n| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number\r\n| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist'\r\n| must not be zero. If any nonzero bits are shifted off, they are \"jammed\"\r\n| into the least-significant bit of the shifted value by setting the least-\r\n| significant bit to 1. This shifted-and-jammed N-bit result is stored\r\n| at the location pointed to by 'zPtr'. Each of 'aPtr' and 'zPtr' points\r\n| to a 'size_words'-long array of 32-bit elements that concatenate in the\r\n| platform's normal endian order to form an N-bit integer.\r\n| The value of 'dist' can be arbitrarily large. In particular, if 'dist'\r\n| is greater than N, the stored result will be either 0 or 1, depending on\r\n| whether the original N bits are all zeros.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_shiftRightJamM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n uint32_t dist,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shiftRightJamM' with\r\n| 'size_words' = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shiftRightJam96M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 3, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam128M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shiftRightJamM' with\r\n| 'size_words' = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shiftRightJam128M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 4, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_shiftRightJam160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_shiftRightJamM' with\r\n| 'size_words' = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_shiftRightJam160M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 5, aPtr, dist, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_addM\r\n/*----------------------------------------------------------------------------\r\n| Adds the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N =\r\n| 'size_words' * 32. The addition is modulo 2^N, so any carry out is lost.\r\n| The N-bit sum is stored at the location pointed to by 'zPtr'. Each of\r\n| 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long array of 32-bit\r\n| elements that concatenate in the platform's normal endian order to form an\r\n| N-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_addM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n const uint32_t *bPtr,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_add96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_addM' with 'size_words'\r\n| = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_add96M( aPtr, bPtr, zPtr ) softfloat_addM( 3, aPtr, bPtr, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_add128M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_addM' with 'size_words'\r\n| = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_add128M( aPtr, bPtr, zPtr ) softfloat_addM( 4, aPtr, bPtr, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_add160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_addM' with 'size_words'\r\n| = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_add160M( aPtr, bPtr, zPtr ) softfloat_addM( 5, aPtr, bPtr, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_addCarryM\r\n/*----------------------------------------------------------------------------\r\n| Adds the two N-bit unsigned integers pointed to by 'aPtr' and 'bPtr', where\r\n| N = 'size_words' * 32, plus 'carry', which must be either 0 or 1. The N-bit\r\n| sum (modulo 2^N) is stored at the location pointed to by 'zPtr', and any\r\n| carry out is returned as the result. Each of 'aPtr', 'bPtr', and 'zPtr'\r\n| points to a 'size_words'-long array of 32-bit elements that concatenate in\r\n| the platform's normal endian order to form an N-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast8_t\r\n softfloat_addCarryM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n const uint32_t *bPtr,\r\n uint_fast8_t carry,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_addComplCarryM\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_addCarryM', except that\r\n| the value of the unsigned integer pointed to by 'bPtr' is bit-wise completed\r\n| before the addition.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast8_t\r\n softfloat_addComplCarryM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n const uint32_t *bPtr,\r\n uint_fast8_t carry,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_addComplCarry96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_addComplCarryM' with\r\n| 'size_words' = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_addComplCarry96M( aPtr, bPtr, carry, zPtr ) softfloat_addComplCarryM( 3, aPtr, bPtr, carry, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_negXM\r\n/*----------------------------------------------------------------------------\r\n| Replaces the N-bit unsigned integer pointed to by 'zPtr' by the\r\n| 2s-complement of itself, where N = 'size_words' * 32. Argument 'zPtr'\r\n| points to a 'size_words'-long array of 32-bit elements that concatenate in\r\n| the platform's normal endian order to form an N-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );\r\n#endif\r\n\r\n#ifndef softfloat_negX96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_negXM' with 'size_words'\r\n| = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_negX96M( zPtr ) softfloat_negXM( 3, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_negX128M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_negXM' with 'size_words'\r\n| = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_negX128M( zPtr ) softfloat_negXM( 4, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_negX160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_negXM' with 'size_words'\r\n| = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_negX160M( zPtr ) softfloat_negXM( 5, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_negX256M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_negXM' with 'size_words'\r\n| = 8 (N = 256).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_negX256M( zPtr ) softfloat_negXM( 8, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_sub1XM\r\n/*----------------------------------------------------------------------------\r\n| Subtracts 1 from the N-bit integer pointed to by 'zPtr', where N =\r\n| 'size_words' * 32. The subtraction is modulo 2^N, so any borrow out (carry\r\n| out) is lost. Argument 'zPtr' points to a 'size_words'-long array of 32-bit\r\n| elements that concatenate in the platform's normal endian order to form an\r\n| N-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr );\r\n#endif\r\n\r\n#ifndef softfloat_sub1X96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'\r\n| = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_sub1X96M( zPtr ) softfloat_sub1XM( 3, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_sub1X160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'\r\n| = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_sub1X160M( zPtr ) softfloat_sub1XM( 5, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_subM\r\n/*----------------------------------------------------------------------------\r\n| Subtracts the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N =\r\n| 'size_words' * 32. The subtraction is modulo 2^N, so any borrow out (carry\r\n| out) is lost. The N-bit difference is stored at the location pointed to by\r\n| 'zPtr'. Each of 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long\r\n| array of 32-bit elements that concatenate in the platform's normal endian\r\n| order to form an N-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_subM(\r\n uint_fast8_t size_words,\r\n const uint32_t *aPtr,\r\n const uint32_t *bPtr,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_sub96M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_subM' with 'size_words'\r\n| = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_sub96M( aPtr, bPtr, zPtr ) softfloat_subM( 3, aPtr, bPtr, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_sub128M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_subM' with 'size_words'\r\n| = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_sub128M( aPtr, bPtr, zPtr ) softfloat_subM( 4, aPtr, bPtr, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_sub160M\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_subM' with 'size_words'\r\n| = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_sub160M( aPtr, bPtr, zPtr ) softfloat_subM( 5, aPtr, bPtr, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_mul64To128M\r\n/*----------------------------------------------------------------------------\r\n| Multiplies 'a' and 'b' and stores the 128-bit product at the location\r\n| pointed to by 'zPtr'. Argument 'zPtr' points to an array of four 32-bit\r\n| elements that concatenate in the platform's normal endian order to form a\r\n| 128-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr );\r\n#endif\r\n\r\n#ifndef softfloat_mul128MTo256M\r\n/*----------------------------------------------------------------------------\r\n| Multiplies the two 128-bit unsigned integers pointed to by 'aPtr' and\r\n| 'bPtr', and stores the 256-bit product at the location pointed to by 'zPtr'.\r\n| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that\r\n| concatenate in the platform's normal endian order to form a 128-bit integer.\r\n| Argument 'zPtr' points to an array of eight 32-bit elements that concatenate\r\n| to form a 256-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_mul128MTo256M(\r\n const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr );\r\n#endif\r\n\r\n#ifndef softfloat_remStepMBy32\r\n/*----------------------------------------------------------------------------\r\n| Performs a \"remainder reduction step\" as follows: Arguments 'remPtr' and\r\n| 'bPtr' both point to N-bit unsigned integers, where N = 'size_words' * 32.\r\n| Defining R and B as the values of those integers, the expression (R<<'dist')\r\n| - B * q is computed modulo 2^N, and the N-bit result is stored at the\r\n| location pointed to by 'zPtr'. Each of 'remPtr', 'bPtr', and 'zPtr' points\r\n| to a 'size_words'-long array of 32-bit elements that concatenate in the\r\n| platform's normal endian order to form an N-bit integer.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_remStepMBy32(\r\n uint_fast8_t size_words,\r\n const uint32_t *remPtr,\r\n uint_fast8_t dist,\r\n const uint32_t *bPtr,\r\n uint32_t q,\r\n uint32_t *zPtr\r\n );\r\n#endif\r\n\r\n#ifndef softfloat_remStep96MBy32\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_remStepMBy32' with\r\n| 'size_words' = 3 (N = 96).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_remStep96MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 3, remPtr, dist, bPtr, q, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_remStep128MBy32\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_remStepMBy32' with\r\n| 'size_words' = 4 (N = 128).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_remStep128MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 4, remPtr, dist, bPtr, q, zPtr )\r\n#endif\r\n\r\n#ifndef softfloat_remStep160MBy32\r\n/*----------------------------------------------------------------------------\r\n| This function or macro is the same as 'softfloat_remStepMBy32' with\r\n| 'size_words' = 5 (N = 160).\r\n*----------------------------------------------------------------------------*/\r\n#define softfloat_remStep160MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 5, remPtr, dist, bPtr, q, zPtr )\r\n#endif\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n/**** ended inlining primitives.h ****/\n/**** skipping file: softfloat_types.h ****/\n\r\nunion ui16_f16 { uint16_t ui; float16_t f; };\r\nunion ui32_f32 { uint32_t ui; float32_t f; };\r\nunion ui64_f64 { uint64_t ui; float64_t f; };\r\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nunion extF80M_extF80 { struct extFloat80M fM; extFloat80_t f; };\r\nunion ui128_f128 { struct uint128 ui; float128_t f; };\r\n#endif\r\n\r\nenum {\r\n softfloat_mulAdd_subC = 1,\r\n softfloat_mulAdd_subProd = 2\r\n};\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool );\r\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nuint_fast64_t\r\n softfloat_roundToUI64(\r\n bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );\r\n#else\r\nuint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool );\r\n#endif\r\n\r\nint_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );\r\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\nint_fast64_t\r\n softfloat_roundToI64(\r\n bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );\r\n#else\r\nint_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );\r\n#endif\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define signF16UI( a ) ((bool) ((uint16_t) (a)>>15))\r\n#define expF16UI( a ) ((int_fast8_t) ((a)>>10) & 0x1F)\r\n#define fracF16UI( a ) ((a) & 0x03FF)\r\n#define packToF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<10) + (sig))\r\n\r\n#define isNaNF16UI( a ) (((~(a) & 0x7C00) == 0) && ((a) & 0x03FF))\r\n\r\nstruct exp8_sig16 { int_fast8_t exp; uint_fast16_t sig; };\r\nstruct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t );\r\n\r\nfloat16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t );\r\nfloat16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t );\r\n\r\nfloat16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t );\r\nfloat16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t );\r\nfloat16_t\r\n softfloat_mulAddF16(\r\n uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t );\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define signF32UI( a ) ((bool) ((uint32_t) (a)>>31))\r\n#define expF32UI( a ) ((int_fast16_t) ((a)>>23) & 0xFF)\r\n#define fracF32UI( a ) ((a) & 0x007FFFFF)\r\n#define packToF32UI( sign, exp, sig ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig))\r\n\r\n#define isNaNF32UI( a ) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF))\r\n\r\nstruct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; };\r\nstruct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );\r\n\r\nfloat32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );\r\nfloat32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );\r\n\r\nfloat32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );\r\nfloat32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );\r\nfloat32_t\r\n softfloat_mulAddF32(\r\n uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define signF64UI( a ) ((bool) ((uint64_t) (a)>>63))\r\n#define expF64UI( a ) ((int_fast16_t) ((a)>>52) & 0x7FF)\r\n#define fracF64UI( a ) ((a) & UINT64_C( 0x000FFFFFFFFFFFFF ))\r\n#define packToF64UI( sign, exp, sig ) ((uint64_t) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<52) + (sig)))\r\n\r\n#define isNaNF64UI( a ) (((~(a) & UINT64_C( 0x7FF0000000000000 )) == 0) && ((a) & UINT64_C( 0x000FFFFFFFFFFFFF )))\r\n\r\nstruct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; };\r\nstruct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );\r\n\r\nfloat64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );\r\nfloat64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );\r\n\r\nfloat64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );\r\nfloat64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );\r\nfloat64_t\r\n softfloat_mulAddF64(\r\n uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define signExtF80UI64( a64 ) ((bool) ((uint16_t) (a64)>>15))\r\n#define expExtF80UI64( a64 ) ((a64) & 0x7FFF)\r\n#define packToExtF80UI64( sign, exp ) ((uint_fast16_t) (sign)<<15 | (exp))\r\n\r\n#define isNaNExtF80UI( a64, a0 ) ((((a64) & 0x7FFF) == 0x7FFF) && ((a0) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))\r\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n\r\nstruct exp32_sig64 { int_fast32_t exp; uint64_t sig; };\r\nstruct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t );\r\n\r\nextFloat80_t\r\n softfloat_roundPackToExtF80(\r\n bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );\r\nextFloat80_t\r\n softfloat_normRoundPackToExtF80(\r\n bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );\r\n\r\nextFloat80_t\r\n softfloat_addMagsExtF80(\r\n uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );\r\nextFloat80_t\r\n softfloat_subMagsExtF80(\r\n uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define signF128UI64( a64 ) ((bool) ((uint64_t) (a64)>>63))\r\n#define expF128UI64( a64 ) ((int_fast32_t) ((a64)>>48) & 0x7FFF)\r\n#define fracF128UI64( a64 ) ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))\r\n#define packToF128UI64( sign, exp, sig64 ) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<48) + (sig64))\r\n\r\n#define isNaNF128UI( a64, a0 ) (((~(a64) & UINT64_C( 0x7FFF000000000000 )) == 0) && (a0 || ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))))\r\n\r\nstruct exp32_sig128 { int_fast32_t exp; struct uint128 sig; };\r\nstruct exp32_sig128\r\n softfloat_normSubnormalF128Sig( uint_fast64_t, uint_fast64_t );\r\n\r\nfloat128_t\r\n softfloat_roundPackToF128(\r\n bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t );\r\nfloat128_t\r\n softfloat_normRoundPackToF128(\r\n bool, int_fast32_t, uint_fast64_t, uint_fast64_t );\r\n\r\nfloat128_t\r\n softfloat_addMagsF128(\r\n uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );\r\nfloat128_t\r\n softfloat_subMagsF128(\r\n uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );\r\nfloat128_t\r\n softfloat_mulAddF128(\r\n uint_fast64_t,\r\n uint_fast64_t,\r\n uint_fast64_t,\r\n uint_fast64_t,\r\n uint_fast64_t,\r\n uint_fast64_t,\r\n uint_fast8_t\r\n );\r\n\r\n#else\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n\r\nbool\r\n softfloat_tryPropagateNaNExtF80M(\r\n const struct extFloat80M *,\r\n const struct extFloat80M *,\r\n struct extFloat80M *\r\n );\r\nvoid softfloat_invalidExtF80M( struct extFloat80M * );\r\n\r\nint softfloat_normExtF80SigM( uint64_t * );\r\n\r\nvoid\r\n softfloat_roundPackMToExtF80M(\r\n bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );\r\nvoid\r\n softfloat_normRoundPackMToExtF80M(\r\n bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );\r\n\r\nvoid\r\n softfloat_addExtF80M(\r\n const struct extFloat80M *,\r\n const struct extFloat80M *,\r\n struct extFloat80M *,\r\n bool\r\n );\r\n\r\nint\r\n softfloat_compareNonnormExtF80M(\r\n const struct extFloat80M *, const struct extFloat80M * );\r\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\n#define signF128UI96( a96 ) ((bool) ((uint32_t) (a96)>>31))\r\n#define expF128UI96( a96 ) ((int32_t) ((a96)>>16) & 0x7FFF)\r\n#define fracF128UI96( a96 ) ((a96) & 0x0000FFFF)\r\n#define packToF128UI96( sign, exp, sig96 ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<16) + (sig96))\r\n\r\nbool softfloat_isNaNF128M( const uint32_t * );\r\n\r\nbool\r\n softfloat_tryPropagateNaNF128M(\r\n const uint32_t *, const uint32_t *, uint32_t * );\r\nvoid softfloat_invalidF128M( uint32_t * );\r\n\r\nint softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * );\r\n\r\nvoid softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );\r\nvoid softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );\r\n\r\nvoid\r\n softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool );\r\nvoid\r\n softfloat_mulAddF128M(\r\n const uint32_t *,\r\n const uint32_t *,\r\n const uint32_t *,\r\n uint32_t *,\r\n uint_fast8_t\r\n );\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n/**** ended inlining internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-\r\n| point values, at least one of which is a NaN, returns the bit pattern of\r\n| the combined NaN result. If either `uiA' or `uiB' has the pattern of a\r\n| signaling NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast16_t\r\n softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )\r\n{\r\n bool isSigNaNA;\r\n\r\n isSigNaNA = softfloat_isSigNaNF16UI( uiA );\r\n if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n if ( isSigNaNA ) return uiA | 0x0200;\r\n }\r\n return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_propagateNaNF16UI.c ****/\n/**** start inlining ../../source/8086-SSE/s_f32UIToCommonNaN.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )\r\n{\r\n\r\n if ( softfloat_isSigNaNF32UI( uiA ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n }\r\n zPtr->sign = uiA>>31;\r\n zPtr->v64 = (uint_fast64_t) uiA<<41;\r\n zPtr->v0 = 0;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_f32UIToCommonNaN.c ****/\n/**** start inlining ../../source/8086-SSE/s_commonNaNToF32UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: specialize.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )\r\n{\r\n\r\n return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_commonNaNToF32UI.c ****/\n/**** start inlining ../../source/8086-SSE/s_propagateNaNF32UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-\r\n| point values, at least one of which is a NaN, returns the bit pattern of\r\n| the combined NaN result. If either `uiA' or `uiB' has the pattern of a\r\n| signaling NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast32_t\r\n softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )\r\n{\r\n bool isSigNaNA;\r\n\r\n isSigNaNA = softfloat_isSigNaNF32UI( uiA );\r\n if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n if ( isSigNaNA ) return uiA | 0x00400000;\r\n }\r\n return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_propagateNaNF32UI.c ****/\n/**** start inlining ../../source/8086-SSE/s_f64UIToCommonNaN.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )\r\n{\r\n\r\n if ( softfloat_isSigNaNF64UI( uiA ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n }\r\n zPtr->sign = uiA>>63;\r\n zPtr->v64 = uiA<<12;\r\n zPtr->v0 = 0;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_f64UIToCommonNaN.c ****/\n/**** start inlining ../../source/8086-SSE/s_commonNaNToF64UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: specialize.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )\r\n{\r\n\r\n return\r\n (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )\r\n | aPtr->v64>>12;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_commonNaNToF64UI.c ****/\n/**** start inlining ../../source/8086-SSE/s_propagateNaNF64UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-\r\n| point values, at least one of which is a NaN, returns the bit pattern of\r\n| the combined NaN result. If either `uiA' or `uiB' has the pattern of a\r\n| signaling NaN, the invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nuint_fast64_t\r\n softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )\r\n{\r\n bool isSigNaNA;\r\n\r\n isSigNaNA = softfloat_isSigNaNF64UI( uiA );\r\n if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );\r\n }\r\n return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_propagateNaNF64UI.c ****/\n/**** start inlining ../../source/8086-SSE/extF80M_isSignalingNaN.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\nbool extF80M_isSignalingNaN( const extFloat80_t *aPtr )\r\n{\r\n const struct extFloat80M *aSPtr;\r\n uint64_t uiA0;\r\n\r\n aSPtr = (const struct extFloat80M *) aPtr;\r\n if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;\r\n uiA0 = aSPtr->signif;\r\n return\r\n ! (uiA0 & UINT64_C( 0x4000000000000000 ))\r\n && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/extF80M_isSignalingNaN.c ****/\n/**** start inlining ../../source/8086-SSE/s_extF80UIToCommonNaN.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'\r\n| has the bit pattern of an 80-bit extended floating-point NaN, converts\r\n| this NaN to the common NaN form, and stores the resulting common NaN at the\r\n| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_extF80UIToCommonNaN(\r\n uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )\r\n{\r\n\r\n if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n }\r\n zPtr->sign = uiA64>>15;\r\n zPtr->v64 = uiA0<<1;\r\n zPtr->v0 = 0;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_extF80UIToCommonNaN.c ****/\n/**** start inlining ../../source/8086-SSE/s_commonNaNToExtF80UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitives.h ****/\n/**** skipping file: specialize.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by `aPtr' into an 80-bit extended\r\n| floating-point NaN, and returns the bit pattern of this value as an unsigned\r\n| integer.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )\r\n{\r\n struct uint128 uiZ;\r\n\r\n uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;\r\n uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;\r\n return uiZ;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_commonNaNToExtF80UI.c ****/\n/**** start inlining ../../source/8086-SSE/s_propagateNaNExtF80UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting the unsigned integer formed from concatenating 'uiA64' and\r\n| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting\r\n| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another\r\n| 80-bit extended floating-point value, and assuming at least on of these\r\n| floating-point values is a NaN, returns the bit pattern of the combined NaN\r\n| result. If either original floating-point value is a signaling NaN, the\r\n| invalid exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128\r\n softfloat_propagateNaNExtF80UI(\r\n uint_fast16_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast16_t uiB64,\r\n uint_fast64_t uiB0\r\n )\r\n{\r\n bool isSigNaNA, isSigNaNB;\r\n uint_fast64_t uiNonsigA0, uiNonsigB0;\r\n uint_fast16_t uiMagA64, uiMagB64;\r\n struct uint128 uiZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );\r\n isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );\r\n /*------------------------------------------------------------------------\r\n | Make NaNs non-signaling.\r\n *------------------------------------------------------------------------*/\r\n uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );\r\n uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( isSigNaNA | isSigNaNB ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n if ( isSigNaNA ) {\r\n if ( isSigNaNB ) goto returnLargerMag;\r\n if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;\r\n goto returnA;\r\n } else {\r\n if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;\r\n goto returnB;\r\n }\r\n }\r\n returnLargerMag:\r\n uiMagA64 = uiA64 & 0x7FFF;\r\n uiMagB64 = uiB64 & 0x7FFF;\r\n if ( uiMagA64 < uiMagB64 ) goto returnB;\r\n if ( uiMagB64 < uiMagA64 ) goto returnA;\r\n if ( uiA0 < uiB0 ) goto returnB;\r\n if ( uiB0 < uiA0 ) goto returnA;\r\n if ( uiA64 < uiB64 ) goto returnA;\r\n returnB:\r\n uiZ.v64 = uiB64;\r\n uiZ.v0 = uiNonsigB0;\r\n return uiZ;\r\n returnA:\r\n uiZ.v64 = uiA64;\r\n uiZ.v0 = uiNonsigA0;\r\n return uiZ;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_propagateNaNExtF80UI.c ****/\n/**** start inlining ../../source/8086-SSE/f128M_isSignalingNaN.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitives.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n*----------------------------------------------------------------------------*/\r\nbool f128M_isSignalingNaN( const float128_t *aPtr )\r\n{\r\n const uint32_t *aWPtr;\r\n uint32_t uiA96;\r\n\r\n aWPtr = (const uint32_t *) aPtr;\r\n uiA96 = aWPtr[indexWordHi( 4 )];\r\n if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;\r\n return\r\n ((uiA96 & 0x00007FFF) != 0)\r\n || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]\r\n | aWPtr[indexWord( 4, 0 )])\r\n != 0);\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/f128M_isSignalingNaN.c ****/\n/**** start inlining ../../source/8086-SSE/s_f128UIToCommonNaN.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitives.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'\r\n| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to\r\n| the common NaN form, and stores the resulting common NaN at the location\r\n| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception\r\n| is raised.\r\n*----------------------------------------------------------------------------*/\r\nvoid\r\n softfloat_f128UIToCommonNaN(\r\n uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )\r\n{\r\n struct uint128 NaNSig;\r\n\r\n if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n }\r\n NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );\r\n zPtr->sign = uiA64>>63;\r\n zPtr->v64 = NaNSig.v64;\r\n zPtr->v0 = NaNSig.v0;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_f128UIToCommonNaN.c ****/\n/**** start inlining ../../source/8086-SSE/s_commonNaNToF128UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitives.h ****/\n/**** skipping file: specialize.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point\r\n| NaN, and returns the bit pattern of this value as an unsigned integer.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )\r\n{\r\n struct uint128 uiZ;\r\n\r\n uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );\r\n uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );\r\n return uiZ;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_commonNaNToF128UI.c ****/\n/**** start inlining ../../source/8086-SSE/s_propagateNaNF128UI.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n/*----------------------------------------------------------------------------\r\n| Interpreting the unsigned integer formed from concatenating `uiA64' and\r\n| `uiA0' as a 128-bit floating-point value, and likewise interpreting the\r\n| unsigned integer formed from concatenating `uiB64' and `uiB0' as another\r\n| 128-bit floating-point value, and assuming at least on of these floating-\r\n| point values is a NaN, returns the bit pattern of the combined NaN result.\r\n| If either original floating-point value is a signaling NaN, the invalid\r\n| exception is raised.\r\n*----------------------------------------------------------------------------*/\r\nstruct uint128\r\n softfloat_propagateNaNF128UI(\r\n uint_fast64_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast64_t uiB64,\r\n uint_fast64_t uiB0\r\n )\r\n{\r\n bool isSigNaNA;\r\n struct uint128 uiZ;\r\n\r\n isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );\r\n if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n if ( isSigNaNA ) goto returnNonsigA;\r\n }\r\n if ( isNaNF128UI( uiA64, uiA0 ) ) {\r\n returnNonsigA:\r\n uiZ.v64 = uiA64;\r\n uiZ.v0 = uiA0;\r\n } else {\r\n uiZ.v64 = uiB64;\r\n uiZ.v0 = uiB0;\r\n }\r\n uiZ.v64 |= UINT64_C( 0x0000800000000000 );\r\n return uiZ;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/8086-SSE/s_propagateNaNF128UI.c ****/\n\n/**** start inlining ../../source/s_eq128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_eq128\r\n#define softfloat_eq128 softfloat_eq128\r\n\r\nbool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n{\r\n\r\n return (a64 == b64) && (a0 == b0);\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_eq128.c ****/\n/**** start inlining ../../source/s_le128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_le128\r\n#define softfloat_le128 softfloat_le128\r\n\r\nbool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n{\r\n\r\n return (a64 < b64) || ((a64 == b64) && (a0 <= b0));\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_le128.c ****/\n/**** start inlining ../../source/s_lt128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_lt128\r\n#define softfloat_lt128 softfloat_lt128\r\n\r\nbool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n{\r\n\r\n return (a64 < b64) || ((a64 == b64) && (a0 < b0));\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_lt128.c ****/\n/**** start inlining ../../source/s_shortShiftLeft128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shortShiftLeft128\r\n#define softfloat_shortShiftLeft128 softfloat_shortShiftLeft128\r\n\r\nstruct uint128\r\n softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )\r\n{\r\n struct uint128 z;\r\n\r\n z.v64 = a64<>(-dist & 63);\r\n z.v0 = a0<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shortShiftRight128\r\n#define softfloat_shortShiftRight128 softfloat_shortShiftRight128\r\n\r\nstruct uint128\r\n softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist )\r\n{\r\n struct uint128 z;\r\n\r\n z.v64 = a64>>dist;\r\n z.v0 = a64<<(-dist & 63) | a0>>dist;\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shortShiftRight128.c ****/\n/**** start inlining ../../source/s_shortShiftRightJam64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_shortShiftRightJam64\r\n#define softfloat_shortShiftRightJam64 softfloat_shortShiftRightJam64\r\n\r\nuint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )\r\n{\r\n\r\n return a>>dist | ((a & (((uint_fast64_t) 1<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shortShiftRightJam64Extra\r\n#define softfloat_shortShiftRightJam64Extra softfloat_shortShiftRightJam64Extra\r\n\r\nstruct uint64_extra\r\n softfloat_shortShiftRightJam64Extra(\r\n uint64_t a, uint64_t extra, uint_fast8_t dist )\r\n{\r\n struct uint64_extra z;\r\n\r\n z.v = a>>dist;\r\n z.extra = a<<(-dist & 63) | (extra != 0);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shortShiftRightJam64Extra.c ****/\n/**** start inlining ../../source/s_shortShiftRightJam128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shortShiftRightJam128\r\n#define softfloat_shortShiftRightJam128 softfloat_shortShiftRightJam128\r\n\r\nstruct uint128\r\n softfloat_shortShiftRightJam128(\r\n uint64_t a64, uint64_t a0, uint_fast8_t dist )\r\n{\r\n uint_fast8_t uNegDist;\r\n struct uint128 z;\r\n\r\n uNegDist = -dist;\r\n z.v64 = a64>>dist;\r\n z.v0 =\r\n a64<<(uNegDist & 63) | a0>>dist\r\n | ((uint64_t) (a0<<(uNegDist & 63)) != 0);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shortShiftRightJam128.c ****/\n/**** start inlining ../../source/s_shortShiftRightJam128Extra.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shortShiftRightJam128Extra\r\n#define softfloat_shortShiftRightJam128Extra softfloat_shortShiftRightJam128Extra\r\n\r\nstruct uint128_extra\r\n softfloat_shortShiftRightJam128Extra(\r\n uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist )\r\n{\r\n uint_fast8_t uNegDist;\r\n struct uint128_extra z;\r\n\r\n uNegDist = -dist;\r\n z.v.v64 = a64>>dist;\r\n z.v.v0 = a64<<(uNegDist & 63) | a0>>dist;\r\n z.extra = a0<<(uNegDist & 63) | (extra != 0);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shortShiftRightJam128Extra.c ****/\n/**** start inlining ../../source/s_shiftRightJam32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_shiftRightJam32\r\n#define softfloat_shiftRightJam32 softfloat_shiftRightJam32\r\n\r\nuint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist )\r\n{\r\n\r\n return\r\n (dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shiftRightJam32.c ****/\n/**** start inlining ../../source/s_shiftRightJam64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_shiftRightJam64\r\n#define softfloat_shiftRightJam64 softfloat_shiftRightJam64\r\n\r\nuint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )\r\n{\r\n\r\n return\r\n (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shiftRightJam64.c ****/\n/**** start inlining ../../source/s_shiftRightJam64Extra.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shiftRightJam64Extra\r\n#define softfloat_shiftRightJam64Extra softfloat_shiftRightJam64Extra\r\n\r\nstruct uint64_extra\r\n softfloat_shiftRightJam64Extra(\r\n uint64_t a, uint64_t extra, uint_fast32_t dist )\r\n{\r\n struct uint64_extra z;\r\n\r\n if ( dist < 64 ) {\r\n z.v = a>>dist;\r\n z.extra = a<<(-dist & 63);\r\n } else {\r\n z.v = 0;\r\n z.extra = (dist == 64) ? a : (a != 0);\r\n }\r\n z.extra |= (extra != 0);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shiftRightJam64Extra.c ****/\n/**** start inlining ../../source/s_shiftRightJam128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shiftRightJam128\r\n\r\nstruct uint128\r\n softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist )\r\n{\r\n uint_fast8_t u8NegDist;\r\n struct uint128 z;\r\n\r\n if ( dist < 64 ) {\r\n u8NegDist = -dist;\r\n z.v64 = a64>>dist;\r\n z.v0 =\r\n a64<<(u8NegDist & 63) | a0>>dist\r\n | ((uint64_t) (a0<<(u8NegDist & 63)) != 0);\r\n } else {\r\n z.v64 = 0;\r\n z.v0 =\r\n (dist < 127)\r\n ? a64>>(dist & 63)\r\n | (((a64 & (((uint_fast64_t) 1<<(dist & 63)) - 1)) | a0)\r\n != 0)\r\n : ((a64 | a0) != 0);\r\n }\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shiftRightJam128.c ****/\n/**** start inlining ../../source/s_shiftRightJam128Extra.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shiftRightJam128Extra\r\n\r\nstruct uint128_extra\r\n softfloat_shiftRightJam128Extra(\r\n uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist )\r\n{\r\n uint_fast8_t u8NegDist;\r\n struct uint128_extra z;\r\n\r\n u8NegDist = -dist;\r\n if ( dist < 64 ) {\r\n z.v.v64 = a64>>dist;\r\n z.v.v0 = a64<<(u8NegDist & 63) | a0>>dist;\r\n z.extra = a0<<(u8NegDist & 63);\r\n } else {\r\n z.v.v64 = 0;\r\n if ( dist == 64 ) {\r\n z.v.v0 = a64;\r\n z.extra = a0;\r\n } else {\r\n extra |= a0;\r\n if ( dist < 128 ) {\r\n z.v.v0 = a64>>(dist & 63);\r\n z.extra = a64<<(u8NegDist & 63);\r\n } else {\r\n z.v.v0 = 0;\r\n z.extra = (dist == 128) ? a64 : (a64 != 0);\r\n }\r\n }\r\n }\r\n z.extra |= (extra != 0);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shiftRightJam128Extra.c ****/\n/**** start inlining ../../source/s_shiftRightJam256M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_shiftRightJam256M\r\n\r\nstatic\r\n void\r\n softfloat_shortShiftRightJamM(\r\n uint_fast8_t size_words,\r\n const uint64_t *aPtr,\r\n uint_fast8_t dist,\r\n uint64_t *zPtr\r\n )\r\n{\r\n uint_fast8_t uNegDist;\r\n unsigned int index, lastIndex;\r\n uint64_t partWordZ, wordA;\r\n\r\n uNegDist = -dist;\r\n index = indexWordLo( size_words );\r\n lastIndex = indexWordHi( size_words );\r\n wordA = aPtr[index];\r\n partWordZ = wordA>>dist;\r\n if ( partWordZ<>dist;\r\n }\r\n zPtr[index] = partWordZ;\r\n\r\n}\r\n\r\nvoid\r\n softfloat_shiftRightJam256M(\r\n const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr )\r\n{\r\n uint64_t wordJam;\r\n uint_fast32_t wordDist;\r\n uint64_t *ptr;\r\n uint_fast8_t i, innerDist;\r\n\r\n wordJam = 0;\r\n wordDist = dist>>6;\r\n if ( wordDist ) {\r\n if ( 4 < wordDist ) wordDist = 4;\r\n ptr = (uint64_t *) (aPtr + indexMultiwordLo( 4, wordDist ));\r\n i = wordDist;\r\n do {\r\n wordJam = *ptr++;\r\n if ( wordJam ) break;\r\n --i;\r\n } while ( i );\r\n ptr = zPtr;\r\n }\r\n if ( wordDist < 4 ) {\r\n aPtr += indexMultiwordHiBut( 4, wordDist );\r\n innerDist = dist & 63;\r\n if ( innerDist ) {\r\n softfloat_shortShiftRightJamM(\r\n 4 - wordDist,\r\n aPtr,\r\n innerDist,\r\n zPtr + indexMultiwordLoBut( 4, wordDist )\r\n );\r\n if ( ! wordDist ) goto wordJam;\r\n } else {\r\n aPtr += indexWordLo( 4 - wordDist );\r\n ptr = zPtr + indexWordLo( 4 );\r\n for ( i = 4 - wordDist; i; --i ) {\r\n *ptr = *aPtr;\r\n aPtr += wordIncr;\r\n ptr += wordIncr;\r\n }\r\n }\r\n ptr = zPtr + indexMultiwordHi( 4, wordDist );\r\n }\r\n do {\r\n *ptr++ = 0;\r\n --wordDist;\r\n } while ( wordDist );\r\n wordJam:\r\n if ( wordJam ) zPtr[indexWordLo( 4 )] |= 1;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_shiftRightJam256M.c ****/\n/**** start inlining ../../source/s_countLeadingZeros8.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitives.h ****/\n\r\nconst uint_least8_t softfloat_countLeadingZeros8[256] = {\r\n 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,\r\n 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\r\n 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r\n 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\r\n};\r\n\r\n/**** ended inlining ../../source/s_countLeadingZeros8.c ****/\n/**** start inlining ../../source/s_countLeadingZeros16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_countLeadingZeros16\r\n\r\n#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16\r\n/**** skipping file: primitives.h ****/\n\r\nuint_fast8_t softfloat_countLeadingZeros16( uint16_t a )\r\n{\r\n uint_fast8_t count;\r\n\r\n count = 8;\r\n if ( 0x100 <= a ) {\r\n count = 0;\r\n a >>= 8;\r\n }\r\n count += softfloat_countLeadingZeros8[a];\r\n return count;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_countLeadingZeros16.c ****/\n/**** start inlining ../../source/s_countLeadingZeros32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_countLeadingZeros32\r\n\r\n#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32\r\n/**** skipping file: primitives.h ****/\n\r\nuint_fast8_t softfloat_countLeadingZeros32( uint32_t a )\r\n{\r\n uint_fast8_t count;\r\n\r\n count = 0;\r\n if ( a < 0x10000 ) {\r\n count = 16;\r\n a <<= 16;\r\n }\r\n if ( a < 0x1000000 ) {\r\n count += 8;\r\n a <<= 8;\r\n }\r\n count += softfloat_countLeadingZeros8[a>>24];\r\n return count;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_countLeadingZeros32.c ****/\n/**** start inlining ../../source/s_countLeadingZeros64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_countLeadingZeros64\r\n\r\n#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64\r\n/**** skipping file: primitives.h ****/\n\r\nuint_fast8_t softfloat_countLeadingZeros64( uint64_t a )\r\n{\r\n uint_fast8_t count;\r\n uint32_t a32;\r\n\r\n count = 0;\r\n a32 = a>>32;\r\n if ( ! a32 ) {\r\n count = 32;\r\n a32 = a;\r\n }\r\n /*------------------------------------------------------------------------\r\n | From here, result is current count + count leading zeros of `a32'.\r\n *------------------------------------------------------------------------*/\r\n if ( a32 < 0x10000 ) {\r\n count += 16;\r\n a32 <<= 16;\r\n }\r\n if ( a32 < 0x1000000 ) {\r\n count += 8;\r\n a32 <<= 8;\r\n }\r\n count += softfloat_countLeadingZeros8[a32>>24];\r\n return count;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_countLeadingZeros64.c ****/\n/**** start inlining ../../source/s_add128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_add128\r\n\r\nstruct uint128\r\n softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n{\r\n struct uint128 z;\r\n\r\n z.v0 = a0 + b0;\r\n z.v64 = a64 + b64 + (z.v0 < a0);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_add128.c ****/\n/**** start inlining ../../source/s_add256M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_add256M\r\n\r\nvoid\r\n softfloat_add256M(\r\n const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr )\r\n{\r\n unsigned int index;\r\n uint_fast8_t carry;\r\n uint64_t wordA, wordZ;\r\n\r\n index = indexWordLo( 4 );\r\n carry = 0;\r\n for (;;) {\r\n wordA = aPtr[index];\r\n wordZ = wordA + bPtr[index] + carry;\r\n zPtr[index] = wordZ;\r\n if ( index == indexWordHi( 4 ) ) break;\r\n if ( wordZ != wordA ) carry = (wordZ < wordA);\r\n index += wordIncr;\r\n }\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_add256M.c ****/\n/**** start inlining ../../source/s_sub128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_sub128\r\n#define softfloat_sub128 softfloat_sub128\r\n\r\nstruct uint128\r\n softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )\r\n{\r\n struct uint128 z;\r\n\r\n z.v0 = a0 - b0;\r\n z.v64 = a64 - b64 - (a0 < b0);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_sub128.c ****/\n/**** start inlining ../../source/s_sub256M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_sub256M\r\n\r\nvoid\r\n softfloat_sub256M(\r\n const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr )\r\n{\r\n unsigned int index;\r\n uint_fast8_t borrow;\r\n uint64_t wordA, wordB;\r\n\r\n index = indexWordLo( 4 );\r\n borrow = 0;\r\n for (;;) {\r\n wordA = aPtr[index];\r\n wordB = bPtr[index];\r\n zPtr[index] = wordA - wordB - borrow;\r\n if ( index == indexWordHi( 4 ) ) break;\r\n borrow = borrow ? (wordA <= wordB) : (wordA < wordB);\r\n index += wordIncr;\r\n }\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_sub256M.c ****/\n/**** start inlining ../../source/s_mul64ByShifted32To128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_mul64ByShifted32To128\r\n\r\nstruct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )\r\n{\r\n uint_fast64_t mid;\r\n struct uint128 z;\r\n\r\n mid = (uint_fast64_t) (uint32_t) a * b;\r\n z.v0 = mid<<32;\r\n z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_mul64ByShifted32To128.c ****/\n/**** start inlining ../../source/s_mul64To128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_mul64To128\r\n\r\nstruct uint128 softfloat_mul64To128( uint64_t a, uint64_t b )\r\n{\r\n uint32_t a32, a0, b32, b0;\r\n struct uint128 z;\r\n uint64_t mid1, mid;\r\n\r\n a32 = a>>32;\r\n a0 = a;\r\n b32 = b>>32;\r\n b0 = b;\r\n z.v0 = (uint_fast64_t) a0 * b0;\r\n mid1 = (uint_fast64_t) a32 * b0;\r\n mid = mid1 + (uint_fast64_t) a0 * b32;\r\n z.v64 = (uint_fast64_t) a32 * b32;\r\n z.v64 += (uint_fast64_t) (mid < mid1)<<32 | mid>>32;\r\n mid <<= 32;\r\n z.v0 += mid;\r\n z.v64 += (z.v0 < mid);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_mul64To128.c ****/\n/**** start inlining ../../source/s_mul128By32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitiveTypes.h ****/\n\r\n#ifndef softfloat_mul128By32\r\n\r\nstruct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )\r\n{\r\n struct uint128 z;\r\n uint_fast64_t mid;\r\n uint_fast32_t carry;\r\n\r\n z.v0 = a0 * b;\r\n mid = (uint_fast64_t) (uint32_t) (a0>>32) * b;\r\n carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid);\r\n z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32);\r\n return z;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_mul128By32.c ****/\n/**** start inlining ../../source/s_mul128To256M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_mul128To256M\r\n\r\n#define softfloat_mul128To256M softfloat_mul128To256M\r\n/**** skipping file: primitives.h ****/\n\r\nvoid\r\n softfloat_mul128To256M(\r\n uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr )\r\n{\r\n struct uint128 p0, p64, p128;\r\n uint_fast64_t z64, z128, z192;\r\n\r\n p0 = softfloat_mul64To128( a0, b0 );\r\n zPtr[indexWord( 4, 0 )] = p0.v0;\r\n p64 = softfloat_mul64To128( a64, b0 );\r\n z64 = p64.v0 + p0.v64;\r\n z128 = p64.v64 + (z64 < p64.v0);\r\n p128 = softfloat_mul64To128( a64, b64 );\r\n z128 += p128.v0;\r\n z192 = p128.v64 + (z128 < p128.v0);\r\n p64 = softfloat_mul64To128( a0, b64 );\r\n z64 += p64.v0;\r\n zPtr[indexWord( 4, 1 )] = z64;\r\n p64.v64 += (z64 < p64.v0);\r\n z128 += p64.v64;\r\n zPtr[indexWord( 4, 2 )] = z128;\r\n zPtr[indexWord( 4, 3 )] = z192 + (z128 < p64.v64);\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_mul128To256M.c ****/\n/**** start inlining ../../source/s_approxRecip_1Ks.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitives.h ****/\n\r\nconst uint16_t softfloat_approxRecip_1k0s[16] = {\r\n 0xFFC4, 0xF0BE, 0xE363, 0xD76F, 0xCCAD, 0xC2F0, 0xBA16, 0xB201,\r\n 0xAA97, 0xA3C6, 0x9D7A, 0x97A6, 0x923C, 0x8D32, 0x887E, 0x8417\r\n};\r\nconst uint16_t softfloat_approxRecip_1k1s[16] = {\r\n 0xF0F1, 0xD62C, 0xBFA1, 0xAC77, 0x9C0A, 0x8DDB, 0x8185, 0x76BA,\r\n 0x6D3B, 0x64D4, 0x5D5C, 0x56B1, 0x50B6, 0x4B55, 0x4679, 0x4211\r\n};\r\n\r\n/**** ended inlining ../../source/s_approxRecip_1Ks.c ****/\n/**** start inlining ../../source/s_approxRecip32_1.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_approxRecip32_1\r\n\r\nextern const uint16_t softfloat_approxRecip_1k0s[16];\r\nextern const uint16_t softfloat_approxRecip_1k1s[16];\r\n\r\nuint32_t softfloat_approxRecip32_1( uint32_t a )\r\n{\r\n int index;\r\n uint16_t eps, r0;\r\n uint32_t sigma0;\r\n uint_fast32_t r;\r\n uint32_t sqrSigma0;\r\n\r\n index = a>>27 & 0xF;\r\n eps = (uint16_t) (a>>11);\r\n r0 = softfloat_approxRecip_1k0s[index]\r\n - ((softfloat_approxRecip_1k1s[index] * (uint_fast32_t) eps)>>20);\r\n sigma0 = ~(uint_fast32_t) ((r0 * (uint_fast64_t) a)>>7);\r\n r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>24);\r\n sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;\r\n r += ((uint32_t) r * (uint_fast64_t) sqrSigma0)>>48;\r\n return r;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_approxRecip32_1.c ****/\n/**** start inlining ../../source/s_approxRecipSqrt_1Ks.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: primitives.h ****/\n\r\nconst uint16_t softfloat_approxRecipSqrt_1k0s[16] = {\r\n 0xB4C9, 0xFFAB, 0xAA7D, 0xF11C, 0xA1C5, 0xE4C7, 0x9A43, 0xDA29,\r\n 0x93B5, 0xD0E5, 0x8DED, 0xC8B7, 0x88C6, 0xC16D, 0x8424, 0xBAE1\r\n};\r\nconst uint16_t softfloat_approxRecipSqrt_1k1s[16] = {\r\n 0xA5A5, 0xEA42, 0x8C21, 0xC62D, 0x788F, 0xAA7F, 0x6928, 0x94B6,\r\n 0x5CC7, 0x8335, 0x52A6, 0x74E2, 0x4A3E, 0x68FE, 0x432B, 0x5EFD\r\n};\r\n\r\n/**** ended inlining ../../source/s_approxRecipSqrt_1Ks.c ****/\n/**** start inlining ../../source/s_approxRecipSqrt32_1.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n\r\n#ifndef softfloat_approxRecipSqrt32_1\r\n\r\nextern const uint16_t softfloat_approxRecipSqrt_1k0s[];\r\nextern const uint16_t softfloat_approxRecipSqrt_1k1s[];\r\n\r\nuint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a )\r\n{\r\n int index;\r\n uint16_t eps, r0;\r\n uint_fast32_t ESqrR0;\r\n uint32_t sigma0;\r\n uint_fast32_t r;\r\n uint32_t sqrSigma0;\r\n\r\n index = (a>>27 & 0xE) + oddExpA;\r\n eps = (uint16_t) (a>>12);\r\n r0 = softfloat_approxRecipSqrt_1k0s[index]\r\n - ((softfloat_approxRecipSqrt_1k1s[index] * (uint_fast32_t) eps)\r\n >>20);\r\n ESqrR0 = (uint_fast32_t) r0 * r0;\r\n if ( ! oddExpA ) ESqrR0 <<= 1;\r\n sigma0 = ~(uint_fast32_t) (((uint32_t) ESqrR0 * (uint_fast64_t) a)>>23);\r\n r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>25);\r\n sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;\r\n r += ((uint32_t) ((r>>1) + (r>>3) - ((uint_fast32_t) r0<<14))\r\n * (uint_fast64_t) sqrSigma0)\r\n >>48;\r\n if ( ! (r & 0x80000000) ) r = 0x80000000;\r\n return r;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_approxRecipSqrt32_1.c ****/\n/**** start inlining ../../source/s_roundToUI32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nuint_fast32_t\r\n softfloat_roundToUI32(\r\n bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )\r\n{\r\n uint_fast16_t roundIncrement, roundBits;\r\n uint_fast32_t z;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n roundIncrement = 0x800;\r\n if ( \r\n (roundingMode != softfloat_round_near_maxMag) \r\n && (roundingMode != softfloat_round_near_even)\r\n ) {\r\n roundIncrement = 0;\r\n if ( sign ) {\r\n if ( !sig ) return 0;\r\n if ( roundingMode == softfloat_round_min ) goto invalid;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) goto invalid;\r\n#endif\r\n } else {\r\n if ( roundingMode == softfloat_round_max ) roundIncrement = 0xFFF;\r\n }\r\n }\r\n roundBits = sig & 0xFFF;\r\n sig += roundIncrement;\r\n if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid;\r\n z = sig>>12;\r\n if ( \r\n (roundBits == 0x800) && (roundingMode == softfloat_round_near_even)\r\n ) {\r\n z &= ~(uint_fast32_t) 1;\r\n }\r\n if ( sign && z ) goto invalid;\r\n if ( roundBits ) {\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) z |= 1;\r\n#endif\r\n if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return z;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n invalid:\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundToUI32.c ****/\n/**** start inlining ../../source/s_roundToUI64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nuint_fast64_t\r\n softfloat_roundToUI64(\r\n bool sign,\r\n uint_fast64_t sig,\r\n uint_fast64_t sigExtra,\r\n uint_fast8_t roundingMode,\r\n bool exact\r\n )\r\n{\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if (\r\n (roundingMode == softfloat_round_near_maxMag)\r\n || (roundingMode == softfloat_round_near_even)\r\n ) {\r\n if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment;\r\n } else {\r\n if ( sign ) {\r\n if ( !(sig | sigExtra) ) return 0;\r\n if ( roundingMode == softfloat_round_min ) goto invalid;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) goto invalid;\r\n#endif\r\n } else {\r\n if ( (roundingMode == softfloat_round_max) && sigExtra ) {\r\n increment:\r\n ++sig;\r\n if ( !sig ) goto invalid;\r\n if ( \r\n (sigExtra == UINT64_C( 0x8000000000000000 ))\r\n && (roundingMode == softfloat_round_near_even)\r\n ) {\r\n sig &= ~(uint_fast64_t) 1;\r\n }\r\n }\r\n }\r\n }\r\n if ( sign && sig ) goto invalid;\r\n if ( sigExtra ) {\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) sig |= 1;\r\n#endif\r\n if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return sig;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n invalid:\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundToUI64.c ****/\n/**** start inlining ../../source/s_roundToI32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nint_fast32_t\r\n softfloat_roundToI32(\r\n bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )\r\n{\r\n uint_fast16_t roundIncrement, roundBits;\r\n uint_fast32_t sig32;\r\n union { uint32_t ui; int32_t i; } uZ;\r\n int_fast32_t z;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n roundIncrement = 0x800;\r\n if (\r\n (roundingMode != softfloat_round_near_maxMag)\r\n && (roundingMode != softfloat_round_near_even)\r\n ) {\r\n roundIncrement = 0;\r\n if ( \r\n sign\r\n ? (roundingMode == softfloat_round_min)\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n || (roundingMode == softfloat_round_odd)\r\n#endif\r\n : (roundingMode == softfloat_round_max)\r\n ) {\r\n roundIncrement = 0xFFF;\r\n }\r\n }\r\n roundBits = sig & 0xFFF;\r\n sig += roundIncrement;\r\n if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid;\r\n sig32 = sig>>12;\r\n if (\r\n (roundBits == 0x800) && (roundingMode == softfloat_round_near_even)\r\n ) {\r\n sig32 &= ~(uint_fast32_t) 1;\r\n }\r\n uZ.ui = sign ? -sig32 : sig32;\r\n z = uZ.i;\r\n if ( z && ((z < 0) ^ sign) ) goto invalid;\r\n if ( roundBits ) {\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) z |= 1;\r\n#endif\r\n if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return z;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n invalid:\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return sign ? i32_fromNegOverflow : i32_fromPosOverflow;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundToI32.c ****/\n/**** start inlining ../../source/s_roundToI64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nint_fast64_t\r\n softfloat_roundToI64(\r\n bool sign,\r\n uint_fast64_t sig,\r\n uint_fast64_t sigExtra,\r\n uint_fast8_t roundingMode,\r\n bool exact\r\n )\r\n{\r\n union { uint64_t ui; int64_t i; } uZ;\r\n int_fast64_t z;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if (\r\n (roundingMode == softfloat_round_near_maxMag)\r\n || (roundingMode == softfloat_round_near_even)\r\n ) {\r\n if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment;\r\n } else {\r\n if (\r\n sigExtra\r\n && (sign\r\n ? (roundingMode == softfloat_round_min)\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n || (roundingMode == softfloat_round_odd)\r\n#endif\r\n : (roundingMode == softfloat_round_max))\r\n ) {\r\n increment:\r\n ++sig;\r\n if ( !sig ) goto invalid;\r\n if (\r\n (sigExtra == UINT64_C( 0x8000000000000000 ))\r\n && (roundingMode == softfloat_round_near_even)\r\n ) {\r\n sig &= ~(uint_fast64_t) 1;\r\n }\r\n }\r\n }\r\n uZ.ui = sign ? -sig : sig;\r\n z = uZ.i;\r\n if ( z && ((z < 0) ^ sign) ) goto invalid;\r\n if ( sigExtra ) {\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) z |= 1;\r\n#endif\r\n if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return z;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n invalid:\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return sign ? i64_fromNegOverflow : i64_fromPosOverflow;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundToI64.c ****/\n/**** start inlining ../../source/s_normSubnormalF16Sig.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nstruct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t sig )\r\n{\r\n int_fast8_t shiftDist;\r\n struct exp8_sig16 z;\r\n\r\n shiftDist = softfloat_countLeadingZeros16( sig ) - 5;\r\n z.exp = 1 - shiftDist;\r\n z.sig = sig<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t\r\n softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )\r\n{\r\n uint_fast8_t roundingMode;\r\n bool roundNearEven;\r\n uint_fast8_t roundIncrement, roundBits;\r\n bool isTiny;\r\n uint_fast16_t uiZ;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n roundingMode = softfloat_roundingMode;\r\n roundNearEven = (roundingMode == softfloat_round_near_even);\r\n roundIncrement = 0x8;\r\n if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {\r\n roundIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n ? 0xF\r\n : 0;\r\n }\r\n roundBits = sig & 0xF;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( 0x1D <= (unsigned int) exp ) {\r\n if ( exp < 0 ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n isTiny =\r\n (softfloat_detectTininess == softfloat_tininess_beforeRounding)\r\n || (exp < -1) || (sig + roundIncrement < 0x8000);\r\n sig = softfloat_shiftRightJam32( sig, -exp );\r\n exp = 0;\r\n roundBits = sig & 0xF;\r\n if ( isTiny && roundBits ) {\r\n softfloat_raiseFlags( softfloat_flag_underflow );\r\n }\r\n } else if ( (0x1D < exp) || (0x8000 <= sig + roundIncrement) ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n softfloat_raiseFlags(\r\n softfloat_flag_overflow | softfloat_flag_inexact );\r\n uiZ = packToF16UI( sign, 0x1F, 0 ) - ! roundIncrement;\r\n goto uiZ;\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sig = (sig + roundIncrement)>>4;\r\n if ( roundBits ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig |= 1;\r\n goto packReturn;\r\n }\r\n#endif\r\n }\r\n sig &= ~(uint_fast16_t) (! (roundBits ^ 8) & roundNearEven);\r\n if ( ! sig ) exp = 0;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n packReturn:\r\n uiZ = packToF16UI( sign, exp, sig );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundPackToF16.c ****/\n/**** start inlining ../../source/s_normRoundPackToF16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nfloat16_t\r\n softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )\r\n{\r\n int_fast8_t shiftDist;\r\n union ui16_f16 uZ;\r\n\r\n shiftDist = softfloat_countLeadingZeros16( sig ) - 1;\r\n exp -= shiftDist;\r\n if ( (4 <= shiftDist) && ((unsigned int) exp < 0x1D) ) {\r\n uZ.ui = packToF16UI( sign, sig ? exp : 0, sig<<(shiftDist - 4) );\r\n return uZ.f;\r\n } else {\r\n return softfloat_roundPackToF16( sign, exp, sig<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )\r\n{\r\n int_fast8_t expA;\r\n uint_fast16_t sigA;\r\n int_fast8_t expB;\r\n uint_fast16_t sigB;\r\n int_fast8_t expDiff;\r\n uint_fast16_t uiZ;\r\n bool signZ;\r\n int_fast8_t expZ;\r\n uint_fast16_t sigZ;\r\n uint_fast16_t sigX, sigY;\r\n int_fast8_t shiftDist;\r\n uint_fast32_t sig32Z;\r\n int_fast8_t roundingMode;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expF16UI( uiA );\r\n sigA = fracF16UI( uiA );\r\n expB = expF16UI( uiB );\r\n sigB = fracF16UI( uiB );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n uiZ = uiA + sigB;\r\n goto uiZ;\r\n }\r\n if ( expA == 0x1F ) {\r\n if ( sigA | sigB ) goto propagateNaN;\r\n uiZ = uiA;\r\n goto uiZ;\r\n }\r\n signZ = signF16UI( uiA );\r\n expZ = expA;\r\n sigZ = 0x0800 + sigA + sigB;\r\n if ( ! (sigZ & 1) && (expZ < 0x1E) ) {\r\n sigZ >>= 1;\r\n goto pack;\r\n }\r\n sigZ <<= 3;\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n signZ = signF16UI( uiA );\r\n if ( expDiff < 0 ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n if ( expB == 0x1F ) {\r\n if ( sigB ) goto propagateNaN;\r\n uiZ = packToF16UI( signZ, 0x1F, 0 );\r\n goto uiZ;\r\n }\r\n if ( expDiff <= -13 ) {\r\n uiZ = packToF16UI( signZ, expB, sigB );\r\n if ( expA | sigA ) goto addEpsilon;\r\n goto uiZ;\r\n }\r\n expZ = expB;\r\n sigX = sigB | 0x0400;\r\n sigY = sigA + (expA ? 0x0400 : sigA);\r\n shiftDist = 19 + expDiff;\r\n } else {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n uiZ = uiA;\r\n if ( expA == 0x1F ) {\r\n if ( sigA ) goto propagateNaN;\r\n goto uiZ;\r\n }\r\n if ( 13 <= expDiff ) {\r\n if ( expB | sigB ) goto addEpsilon;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n sigX = sigA | 0x0400;\r\n sigY = sigB + (expB ? 0x0400 : sigB);\r\n shiftDist = 19 - expDiff;\r\n }\r\n sig32Z =\r\n ((uint_fast32_t) sigX<<19) + ((uint_fast32_t) sigY<>16;\r\n if ( sig32Z & 0xFFFF ) {\r\n sigZ |= 1;\r\n } else {\r\n if ( ! (sigZ & 0xF) && (expZ < 0x1E) ) {\r\n sigZ >>= 4;\r\n goto pack;\r\n }\r\n }\r\n }\r\n return softfloat_roundPackToF16( signZ, expZ, sigZ );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF16UI( uiA, uiB );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n addEpsilon:\r\n roundingMode = softfloat_roundingMode;\r\n if ( roundingMode != softfloat_round_near_even ) {\r\n if (\r\n roundingMode\r\n == (signF16UI( uiZ ) ? softfloat_round_min\r\n : softfloat_round_max)\r\n ) {\r\n ++uiZ;\r\n if ( (uint16_t) (uiZ<<1) == 0xF800 ) {\r\n softfloat_raiseFlags(\r\n softfloat_flag_overflow | softfloat_flag_inexact );\r\n }\r\n }\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n else if ( roundingMode == softfloat_round_odd ) {\r\n uiZ |= 1;\r\n }\r\n#endif\r\n }\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n pack:\r\n uiZ = packToF16UI( signZ, expZ, sigZ );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_addMagsF16.c ****/\n/**** start inlining ../../source/s_subMagsF16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )\r\n{\r\n int_fast8_t expA;\r\n uint_fast16_t sigA;\r\n int_fast8_t expB;\r\n uint_fast16_t sigB;\r\n int_fast8_t expDiff;\r\n uint_fast16_t uiZ;\r\n int_fast16_t sigDiff;\r\n bool signZ;\r\n int_fast8_t shiftDist, expZ;\r\n uint_fast16_t sigZ, sigX, sigY;\r\n uint_fast32_t sig32Z;\r\n int_fast8_t roundingMode;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expF16UI( uiA );\r\n sigA = fracF16UI( uiA );\r\n expB = expF16UI( uiB );\r\n sigB = fracF16UI( uiB );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expA == 0x1F ) {\r\n if ( sigA | sigB ) goto propagateNaN;\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF16UI;\r\n goto uiZ;\r\n }\r\n sigDiff = sigA - sigB;\r\n if ( ! sigDiff ) {\r\n uiZ =\r\n packToF16UI(\r\n (softfloat_roundingMode == softfloat_round_min), 0, 0 );\r\n goto uiZ;\r\n }\r\n if ( expA ) --expA;\r\n signZ = signF16UI( uiA );\r\n if ( sigDiff < 0 ) {\r\n signZ = ! signZ;\r\n sigDiff = -sigDiff;\r\n }\r\n shiftDist = softfloat_countLeadingZeros16( sigDiff ) - 5;\r\n expZ = expA - shiftDist;\r\n if ( expZ < 0 ) {\r\n shiftDist = expA;\r\n expZ = 0;\r\n }\r\n sigZ = sigDiff<>16;\r\n if ( sig32Z & 0xFFFF ) {\r\n sigZ |= 1;\r\n } else {\r\n if ( ! (sigZ & 0xF) && ((unsigned int) expZ < 0x1E) ) {\r\n sigZ >>= 4;\r\n goto pack;\r\n }\r\n }\r\n return softfloat_roundPackToF16( signZ, expZ, sigZ );\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF16UI( uiA, uiB );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n subEpsilon:\r\n roundingMode = softfloat_roundingMode;\r\n if ( roundingMode != softfloat_round_near_even ) {\r\n if (\r\n (roundingMode == softfloat_round_minMag)\r\n || (roundingMode\r\n == (signF16UI( uiZ ) ? softfloat_round_max\r\n : softfloat_round_min))\r\n ) {\r\n --uiZ;\r\n }\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n else if ( roundingMode == softfloat_round_odd ) {\r\n uiZ = (uiZ - 1) | 1;\r\n }\r\n#endif\r\n }\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n pack:\r\n uiZ = packToF16UI( signZ, expZ, sigZ );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_subMagsF16.c ****/\n/**** start inlining ../../source/s_mulAddF16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t\r\n softfloat_mulAddF16(\r\n uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op )\r\n{\r\n bool signA;\r\n int_fast8_t expA;\r\n uint_fast16_t sigA;\r\n bool signB;\r\n int_fast8_t expB;\r\n uint_fast16_t sigB;\r\n bool signC;\r\n int_fast8_t expC;\r\n uint_fast16_t sigC;\r\n bool signProd;\r\n uint_fast16_t magBits, uiZ;\r\n struct exp8_sig16 normExpSig;\r\n int_fast8_t expProd;\r\n uint_fast32_t sigProd;\r\n bool signZ;\r\n int_fast8_t expZ;\r\n uint_fast16_t sigZ;\r\n int_fast8_t expDiff;\r\n uint_fast32_t sig32Z, sig32C;\r\n int_fast8_t shiftDist;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n signA = signF16UI( uiA );\r\n expA = expF16UI( uiA );\r\n sigA = fracF16UI( uiA );\r\n signB = signF16UI( uiB );\r\n expB = expF16UI( uiB );\r\n sigB = fracF16UI( uiB );\r\n signC = signF16UI( uiC ) ^ (op == softfloat_mulAdd_subC);\r\n expC = expF16UI( uiC );\r\n sigC = fracF16UI( uiC );\r\n signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd);\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0x1F ) {\r\n if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN_ABC;\r\n magBits = expB | sigB;\r\n goto infProdArg;\r\n }\r\n if ( expB == 0x1F ) {\r\n if ( sigB ) goto propagateNaN_ABC;\r\n magBits = expA | sigA;\r\n goto infProdArg;\r\n }\r\n if ( expC == 0x1F ) {\r\n if ( sigC ) {\r\n uiZ = 0;\r\n goto propagateNaN_ZC;\r\n }\r\n uiZ = uiC;\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n if ( ! sigA ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF16Sig( sigA );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n if ( ! expB ) {\r\n if ( ! sigB ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF16Sig( sigB );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expProd = expA + expB - 0xE;\r\n sigA = (sigA | 0x0400)<<4;\r\n sigB = (sigB | 0x0400)<<4;\r\n sigProd = (uint_fast32_t) sigA * sigB;\r\n if ( sigProd < 0x20000000 ) {\r\n --expProd;\r\n sigProd <<= 1;\r\n }\r\n signZ = signProd;\r\n if ( ! expC ) {\r\n if ( ! sigC ) {\r\n expZ = expProd - 1;\r\n sigZ = sigProd>>15 | ((sigProd & 0x7FFF) != 0);\r\n goto roundPack;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( sigC );\r\n expC = normExpSig.exp;\r\n sigC = normExpSig.sig;\r\n }\r\n sigC = (sigC | 0x0400)<<3;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expProd - expC;\r\n if ( signProd == signC ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff <= 0 ) {\r\n expZ = expC;\r\n sigZ = sigC + softfloat_shiftRightJam32( sigProd, 16 - expDiff );\r\n } else {\r\n expZ = expProd;\r\n sig32Z =\r\n sigProd\r\n + softfloat_shiftRightJam32(\r\n (uint_fast32_t) sigC<<16, expDiff );\r\n sigZ = sig32Z>>16 | ((sig32Z & 0xFFFF) != 0 );\r\n }\r\n if ( sigZ < 0x4000 ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n sig32C = (uint_fast32_t) sigC<<16;\r\n if ( expDiff < 0 ) {\r\n signZ = signC;\r\n expZ = expC;\r\n sig32Z = sig32C - softfloat_shiftRightJam32( sigProd, -expDiff );\r\n } else if ( ! expDiff ) {\r\n expZ = expProd;\r\n sig32Z = sigProd - sig32C;\r\n if ( ! sig32Z ) goto completeCancellation;\r\n if ( sig32Z & 0x80000000 ) {\r\n signZ = ! signZ;\r\n sig32Z = -sig32Z;\r\n }\r\n } else {\r\n expZ = expProd;\r\n sig32Z = sigProd - softfloat_shiftRightJam32( sig32C, expDiff );\r\n }\r\n shiftDist = softfloat_countLeadingZeros32( sig32Z ) - 1;\r\n expZ -= shiftDist;\r\n shiftDist -= 16;\r\n if ( shiftDist < 0 ) {\r\n sigZ =\r\n sig32Z>>(-shiftDist)\r\n | ((uint32_t) (sig32Z<<(shiftDist & 31)) != 0);\r\n } else {\r\n sigZ = (uint_fast16_t) sig32Z<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nstruct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig )\r\n{\r\n int_fast8_t shiftDist;\r\n struct exp16_sig32 z;\r\n\r\n shiftDist = softfloat_countLeadingZeros32( sig ) - 8;\r\n z.exp = 1 - shiftDist;\r\n z.sig = sig<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t\r\n softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )\r\n{\r\n uint_fast8_t roundingMode;\r\n bool roundNearEven;\r\n uint_fast8_t roundIncrement, roundBits;\r\n bool isTiny;\r\n uint_fast32_t uiZ;\r\n union ui32_f32 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n roundingMode = softfloat_roundingMode;\r\n roundNearEven = (roundingMode == softfloat_round_near_even);\r\n roundIncrement = 0x40;\r\n if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {\r\n roundIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n ? 0x7F\r\n : 0;\r\n }\r\n roundBits = sig & 0x7F;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( 0xFD <= (unsigned int) exp ) {\r\n if ( exp < 0 ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n isTiny =\r\n (softfloat_detectTininess == softfloat_tininess_beforeRounding)\r\n || (exp < -1) || (sig + roundIncrement < 0x80000000);\r\n sig = softfloat_shiftRightJam32( sig, -exp );\r\n exp = 0;\r\n roundBits = sig & 0x7F;\r\n if ( isTiny && roundBits ) {\r\n softfloat_raiseFlags( softfloat_flag_underflow );\r\n }\r\n } else if ( (0xFD < exp) || (0x80000000 <= sig + roundIncrement) ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n softfloat_raiseFlags(\r\n softfloat_flag_overflow | softfloat_flag_inexact );\r\n uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement;\r\n goto uiZ;\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sig = (sig + roundIncrement)>>7;\r\n if ( roundBits ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig |= 1;\r\n goto packReturn;\r\n }\r\n#endif\r\n }\r\n sig &= ~(uint_fast32_t) (! (roundBits ^ 0x40) & roundNearEven);\r\n if ( ! sig ) exp = 0;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n packReturn:\r\n uiZ = packToF32UI( sign, exp, sig );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundPackToF32.c ****/\n/**** start inlining ../../source/s_normRoundPackToF32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nfloat32_t\r\n softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )\r\n{\r\n int_fast8_t shiftDist;\r\n union ui32_f32 uZ;\r\n\r\n shiftDist = softfloat_countLeadingZeros32( sig ) - 1;\r\n exp -= shiftDist;\r\n if ( (7 <= shiftDist) && ((unsigned int) exp < 0xFD) ) {\r\n uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<(shiftDist - 7) );\r\n return uZ.f;\r\n } else {\r\n return softfloat_roundPackToF32( sign, exp, sig<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n\r\nfloat32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )\r\n{\r\n int_fast16_t expA;\r\n uint_fast32_t sigA;\r\n int_fast16_t expB;\r\n uint_fast32_t sigB;\r\n int_fast16_t expDiff;\r\n uint_fast32_t uiZ;\r\n bool signZ;\r\n int_fast16_t expZ;\r\n uint_fast32_t sigZ;\r\n union ui32_f32 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expF32UI( uiA );\r\n sigA = fracF32UI( uiA );\r\n expB = expF32UI( uiB );\r\n sigB = fracF32UI( uiB );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n uiZ = uiA + sigB;\r\n goto uiZ;\r\n }\r\n if ( expA == 0xFF ) {\r\n if ( sigA | sigB ) goto propagateNaN;\r\n uiZ = uiA;\r\n goto uiZ;\r\n }\r\n signZ = signF32UI( uiA );\r\n expZ = expA;\r\n sigZ = 0x01000000 + sigA + sigB;\r\n if ( ! (sigZ & 1) && (expZ < 0xFE) ) {\r\n uiZ = packToF32UI( signZ, expZ, sigZ>>1 );\r\n goto uiZ;\r\n }\r\n sigZ <<= 6;\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n signZ = signF32UI( uiA );\r\n sigA <<= 6;\r\n sigB <<= 6;\r\n if ( expDiff < 0 ) {\r\n if ( expB == 0xFF ) {\r\n if ( sigB ) goto propagateNaN;\r\n uiZ = packToF32UI( signZ, 0xFF, 0 );\r\n goto uiZ;\r\n }\r\n expZ = expB;\r\n sigA += expA ? 0x20000000 : sigA;\r\n sigA = softfloat_shiftRightJam32( sigA, -expDiff );\r\n } else {\r\n if ( expA == 0xFF ) {\r\n if ( sigA ) goto propagateNaN;\r\n uiZ = uiA;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n sigB += expB ? 0x20000000 : sigB;\r\n sigB = softfloat_shiftRightJam32( sigB, expDiff );\r\n }\r\n sigZ = 0x20000000 + sigA + sigB;\r\n if ( sigZ < 0x40000000 ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n }\r\n return softfloat_roundPackToF32( signZ, expZ, sigZ );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF32UI( uiA, uiB );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_addMagsF32.c ****/\n/**** start inlining ../../source/s_subMagsF32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )\r\n{\r\n int_fast16_t expA;\r\n uint_fast32_t sigA;\r\n int_fast16_t expB;\r\n uint_fast32_t sigB;\r\n int_fast16_t expDiff;\r\n uint_fast32_t uiZ;\r\n int_fast32_t sigDiff;\r\n bool signZ;\r\n int_fast8_t shiftDist;\r\n int_fast16_t expZ;\r\n uint_fast32_t sigX, sigY;\r\n union ui32_f32 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expF32UI( uiA );\r\n sigA = fracF32UI( uiA );\r\n expB = expF32UI( uiB );\r\n sigB = fracF32UI( uiB );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expA == 0xFF ) {\r\n if ( sigA | sigB ) goto propagateNaN;\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF32UI;\r\n goto uiZ;\r\n }\r\n sigDiff = sigA - sigB;\r\n if ( ! sigDiff ) {\r\n uiZ =\r\n packToF32UI(\r\n (softfloat_roundingMode == softfloat_round_min), 0, 0 );\r\n goto uiZ;\r\n }\r\n if ( expA ) --expA;\r\n signZ = signF32UI( uiA );\r\n if ( sigDiff < 0 ) {\r\n signZ = ! signZ;\r\n sigDiff = -sigDiff;\r\n }\r\n shiftDist = softfloat_countLeadingZeros32( sigDiff ) - 8;\r\n expZ = expA - shiftDist;\r\n if ( expZ < 0 ) {\r\n shiftDist = expA;\r\n expZ = 0;\r\n }\r\n uiZ = packToF32UI( signZ, expZ, sigDiff<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t\r\n softfloat_mulAddF32(\r\n uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op )\r\n{\r\n bool signA;\r\n int_fast16_t expA;\r\n uint_fast32_t sigA;\r\n bool signB;\r\n int_fast16_t expB;\r\n uint_fast32_t sigB;\r\n bool signC;\r\n int_fast16_t expC;\r\n uint_fast32_t sigC;\r\n bool signProd;\r\n uint_fast32_t magBits, uiZ;\r\n struct exp16_sig32 normExpSig;\r\n int_fast16_t expProd;\r\n uint_fast64_t sigProd;\r\n bool signZ;\r\n int_fast16_t expZ;\r\n uint_fast32_t sigZ;\r\n int_fast16_t expDiff;\r\n uint_fast64_t sig64Z, sig64C;\r\n int_fast8_t shiftDist;\r\n union ui32_f32 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n signA = signF32UI( uiA );\r\n expA = expF32UI( uiA );\r\n sigA = fracF32UI( uiA );\r\n signB = signF32UI( uiB );\r\n expB = expF32UI( uiB );\r\n sigB = fracF32UI( uiB );\r\n signC = signF32UI( uiC ) ^ (op == softfloat_mulAdd_subC);\r\n expC = expF32UI( uiC );\r\n sigC = fracF32UI( uiC );\r\n signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd);\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0xFF ) {\r\n if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN_ABC;\r\n magBits = expB | sigB;\r\n goto infProdArg;\r\n }\r\n if ( expB == 0xFF ) {\r\n if ( sigB ) goto propagateNaN_ABC;\r\n magBits = expA | sigA;\r\n goto infProdArg;\r\n }\r\n if ( expC == 0xFF ) {\r\n if ( sigC ) {\r\n uiZ = 0;\r\n goto propagateNaN_ZC;\r\n }\r\n uiZ = uiC;\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n if ( ! sigA ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF32Sig( sigA );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n if ( ! expB ) {\r\n if ( ! sigB ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF32Sig( sigB );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expProd = expA + expB - 0x7E;\r\n sigA = (sigA | 0x00800000)<<7;\r\n sigB = (sigB | 0x00800000)<<7;\r\n sigProd = (uint_fast64_t) sigA * sigB;\r\n if ( sigProd < UINT64_C( 0x2000000000000000 ) ) {\r\n --expProd;\r\n sigProd <<= 1;\r\n }\r\n signZ = signProd;\r\n if ( ! expC ) {\r\n if ( ! sigC ) {\r\n expZ = expProd - 1;\r\n sigZ = softfloat_shortShiftRightJam64( sigProd, 31 );\r\n goto roundPack;\r\n }\r\n normExpSig = softfloat_normSubnormalF32Sig( sigC );\r\n expC = normExpSig.exp;\r\n sigC = normExpSig.sig;\r\n }\r\n sigC = (sigC | 0x00800000)<<6;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expProd - expC;\r\n if ( signProd == signC ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff <= 0 ) {\r\n expZ = expC;\r\n sigZ = sigC + softfloat_shiftRightJam64( sigProd, 32 - expDiff );\r\n } else {\r\n expZ = expProd;\r\n sig64Z =\r\n sigProd\r\n + softfloat_shiftRightJam64(\r\n (uint_fast64_t) sigC<<32, expDiff );\r\n sigZ = softfloat_shortShiftRightJam64( sig64Z, 32 );\r\n }\r\n if ( sigZ < 0x40000000 ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n sig64C = (uint_fast64_t) sigC<<32;\r\n if ( expDiff < 0 ) {\r\n signZ = signC;\r\n expZ = expC;\r\n sig64Z = sig64C - softfloat_shiftRightJam64( sigProd, -expDiff );\r\n } else if ( ! expDiff ) {\r\n expZ = expProd;\r\n sig64Z = sigProd - sig64C;\r\n if ( ! sig64Z ) goto completeCancellation;\r\n if ( sig64Z & UINT64_C( 0x8000000000000000 ) ) {\r\n signZ = ! signZ;\r\n sig64Z = -sig64Z;\r\n }\r\n } else {\r\n expZ = expProd;\r\n sig64Z = sigProd - softfloat_shiftRightJam64( sig64C, expDiff );\r\n }\r\n shiftDist = softfloat_countLeadingZeros64( sig64Z ) - 1;\r\n expZ -= shiftDist;\r\n shiftDist -= 32;\r\n if ( shiftDist < 0 ) {\r\n sigZ = softfloat_shortShiftRightJam64( sig64Z, -shiftDist );\r\n } else {\r\n sigZ = (uint_fast32_t) sig64Z<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nstruct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t sig )\r\n{\r\n int_fast8_t shiftDist;\r\n struct exp16_sig64 z;\r\n\r\n shiftDist = softfloat_countLeadingZeros64( sig ) - 11;\r\n z.exp = 1 - shiftDist;\r\n z.sig = sig<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat64_t\r\n softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )\r\n{\r\n uint_fast8_t roundingMode;\r\n bool roundNearEven;\r\n uint_fast16_t roundIncrement, roundBits;\r\n bool isTiny;\r\n uint_fast64_t uiZ;\r\n union ui64_f64 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n roundingMode = softfloat_roundingMode;\r\n roundNearEven = (roundingMode == softfloat_round_near_even);\r\n roundIncrement = 0x200;\r\n if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {\r\n roundIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n ? 0x3FF\r\n : 0;\r\n }\r\n roundBits = sig & 0x3FF;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( 0x7FD <= (uint16_t) exp ) {\r\n if ( exp < 0 ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n isTiny =\r\n (softfloat_detectTininess == softfloat_tininess_beforeRounding)\r\n || (exp < -1)\r\n || (sig + roundIncrement < UINT64_C( 0x8000000000000000 ));\r\n sig = softfloat_shiftRightJam64( sig, -exp );\r\n exp = 0;\r\n roundBits = sig & 0x3FF;\r\n if ( isTiny && roundBits ) {\r\n softfloat_raiseFlags( softfloat_flag_underflow );\r\n }\r\n } else if (\r\n (0x7FD < exp)\r\n || (UINT64_C( 0x8000000000000000 ) <= sig + roundIncrement)\r\n ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n softfloat_raiseFlags(\r\n softfloat_flag_overflow | softfloat_flag_inexact );\r\n uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement;\r\n goto uiZ;\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sig = (sig + roundIncrement)>>10;\r\n if ( roundBits ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig |= 1;\r\n goto packReturn;\r\n }\r\n#endif\r\n }\r\n sig &= ~(uint_fast64_t) (! (roundBits ^ 0x200) & roundNearEven);\r\n if ( ! sig ) exp = 0;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n packReturn:\r\n uiZ = packToF64UI( sign, exp, sig );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundPackToF64.c ****/\n/**** start inlining ../../source/s_normRoundPackToF64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nfloat64_t\r\n softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )\r\n{\r\n int_fast8_t shiftDist;\r\n union ui64_f64 uZ;\r\n\r\n shiftDist = softfloat_countLeadingZeros64( sig ) - 1;\r\n exp -= shiftDist;\r\n if ( (10 <= shiftDist) && ((unsigned int) exp < 0x7FD) ) {\r\n uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<(shiftDist - 10) );\r\n return uZ.f;\r\n } else {\r\n return softfloat_roundPackToF64( sign, exp, sig<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n\r\nfloat64_t\r\n softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )\r\n{\r\n int_fast16_t expA;\r\n uint_fast64_t sigA;\r\n int_fast16_t expB;\r\n uint_fast64_t sigB;\r\n int_fast16_t expDiff;\r\n uint_fast64_t uiZ;\r\n int_fast16_t expZ;\r\n uint_fast64_t sigZ;\r\n union ui64_f64 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expF64UI( uiA );\r\n sigA = fracF64UI( uiA );\r\n expB = expF64UI( uiB );\r\n sigB = fracF64UI( uiB );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n uiZ = uiA + sigB;\r\n goto uiZ;\r\n }\r\n if ( expA == 0x7FF ) {\r\n if ( sigA | sigB ) goto propagateNaN;\r\n uiZ = uiA;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n sigZ = UINT64_C( 0x0020000000000000 ) + sigA + sigB;\r\n sigZ <<= 9;\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n sigA <<= 9;\r\n sigB <<= 9;\r\n if ( expDiff < 0 ) {\r\n if ( expB == 0x7FF ) {\r\n if ( sigB ) goto propagateNaN;\r\n uiZ = packToF64UI( signZ, 0x7FF, 0 );\r\n goto uiZ;\r\n }\r\n expZ = expB;\r\n if ( expA ) {\r\n sigA += UINT64_C( 0x2000000000000000 );\r\n } else {\r\n sigA <<= 1;\r\n }\r\n sigA = softfloat_shiftRightJam64( sigA, -expDiff );\r\n } else {\r\n if ( expA == 0x7FF ) {\r\n if ( sigA ) goto propagateNaN;\r\n uiZ = uiA;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n if ( expB ) {\r\n sigB += UINT64_C( 0x2000000000000000 );\r\n } else {\r\n sigB <<= 1;\r\n }\r\n sigB = softfloat_shiftRightJam64( sigB, expDiff );\r\n }\r\n sigZ = UINT64_C( 0x2000000000000000 ) + sigA + sigB;\r\n if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n }\r\n return softfloat_roundPackToF64( signZ, expZ, sigZ );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF64UI( uiA, uiB );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_addMagsF64.c ****/\n/**** start inlining ../../source/s_subMagsF64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat64_t\r\n softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )\r\n{\r\n int_fast16_t expA;\r\n uint_fast64_t sigA;\r\n int_fast16_t expB;\r\n uint_fast64_t sigB;\r\n int_fast16_t expDiff;\r\n uint_fast64_t uiZ;\r\n int_fast64_t sigDiff;\r\n int_fast8_t shiftDist;\r\n int_fast16_t expZ;\r\n uint_fast64_t sigZ;\r\n union ui64_f64 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expF64UI( uiA );\r\n sigA = fracF64UI( uiA );\r\n expB = expF64UI( uiB );\r\n sigB = fracF64UI( uiB );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expA == 0x7FF ) {\r\n if ( sigA | sigB ) goto propagateNaN;\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF64UI;\r\n goto uiZ;\r\n }\r\n sigDiff = sigA - sigB;\r\n if ( ! sigDiff ) {\r\n uiZ =\r\n packToF64UI(\r\n (softfloat_roundingMode == softfloat_round_min), 0, 0 );\r\n goto uiZ;\r\n }\r\n if ( expA ) --expA;\r\n if ( sigDiff < 0 ) {\r\n signZ = ! signZ;\r\n sigDiff = -sigDiff;\r\n }\r\n shiftDist = softfloat_countLeadingZeros64( sigDiff ) - 11;\r\n expZ = expA - shiftDist;\r\n if ( expZ < 0 ) {\r\n shiftDist = expA;\r\n expZ = 0;\r\n }\r\n uiZ = packToF64UI( signZ, expZ, sigDiff<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nfloat64_t\r\n softfloat_mulAddF64(\r\n uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )\r\n{\r\n bool signA;\r\n int_fast16_t expA;\r\n uint_fast64_t sigA;\r\n bool signB;\r\n int_fast16_t expB;\r\n uint_fast64_t sigB;\r\n bool signC;\r\n int_fast16_t expC;\r\n uint_fast64_t sigC;\r\n bool signZ;\r\n uint_fast64_t magBits, uiZ;\r\n struct exp16_sig64 normExpSig;\r\n int_fast16_t expZ;\r\n struct uint128 sig128Z;\r\n uint_fast64_t sigZ;\r\n int_fast16_t expDiff;\r\n struct uint128 sig128C;\r\n int_fast8_t shiftDist;\r\n union ui64_f64 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n signA = signF64UI( uiA );\r\n expA = expF64UI( uiA );\r\n sigA = fracF64UI( uiA );\r\n signB = signF64UI( uiB );\r\n expB = expF64UI( uiB );\r\n sigB = fracF64UI( uiB );\r\n signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC);\r\n expC = expF64UI( uiC );\r\n sigC = fracF64UI( uiC );\r\n signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0x7FF ) {\r\n if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC;\r\n magBits = expB | sigB;\r\n goto infProdArg;\r\n }\r\n if ( expB == 0x7FF ) {\r\n if ( sigB ) goto propagateNaN_ABC;\r\n magBits = expA | sigA;\r\n goto infProdArg;\r\n }\r\n if ( expC == 0x7FF ) {\r\n if ( sigC ) {\r\n uiZ = 0;\r\n goto propagateNaN_ZC;\r\n }\r\n uiZ = uiC;\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n if ( ! sigA ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF64Sig( sigA );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n if ( ! expB ) {\r\n if ( ! sigB ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF64Sig( sigB );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expZ = expA + expB - 0x3FE;\r\n sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;\r\n sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<10;\r\n sig128Z = softfloat_mul64To128( sigA, sigB );\r\n if ( sig128Z.v64 < UINT64_C( 0x2000000000000000 ) ) {\r\n --expZ;\r\n sig128Z =\r\n softfloat_add128(\r\n sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 );\r\n }\r\n if ( ! expC ) {\r\n if ( ! sigC ) {\r\n --expZ;\r\n sigZ = sig128Z.v64<<1 | (sig128Z.v0 != 0);\r\n goto roundPack;\r\n }\r\n normExpSig = softfloat_normSubnormalF64Sig( sigC );\r\n expC = normExpSig.exp;\r\n sigC = normExpSig.sig;\r\n }\r\n sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<9;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expZ - expC;\r\n if ( expDiff < 0 ) {\r\n expZ = expC;\r\n if ( (signZ == signC) || (expDiff < -1) ) {\r\n sig128Z.v64 = softfloat_shiftRightJam64( sig128Z.v64, -expDiff );\r\n } else {\r\n sig128Z =\r\n softfloat_shortShiftRightJam128( sig128Z.v64, sig128Z.v0, 1 );\r\n }\r\n } else if ( expDiff ) {\r\n sig128C = softfloat_shiftRightJam128( sigC, 0, expDiff );\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( signZ == signC ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff <= 0 ) {\r\n sigZ = (sigC + sig128Z.v64) | (sig128Z.v0 != 0);\r\n } else {\r\n sig128Z =\r\n softfloat_add128(\r\n sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 );\r\n sigZ = sig128Z.v64 | (sig128Z.v0 != 0);\r\n }\r\n if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff < 0 ) {\r\n signZ = signC;\r\n sig128Z = softfloat_sub128( sigC, 0, sig128Z.v64, sig128Z.v0 );\r\n } else if ( ! expDiff ) {\r\n sig128Z.v64 = sig128Z.v64 - sigC;\r\n if ( ! (sig128Z.v64 | sig128Z.v0) ) goto completeCancellation;\r\n if ( sig128Z.v64 & UINT64_C( 0x8000000000000000 ) ) {\r\n signZ = ! signZ;\r\n sig128Z = softfloat_sub128( 0, 0, sig128Z.v64, sig128Z.v0 );\r\n }\r\n } else {\r\n sig128Z =\r\n softfloat_sub128(\r\n sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 );\r\n }\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( ! sig128Z.v64 ) {\r\n expZ -= 64;\r\n sig128Z.v64 = sig128Z.v0;\r\n sig128Z.v0 = 0;\r\n }\r\n shiftDist = softfloat_countLeadingZeros64( sig128Z.v64 ) - 1;\r\n expZ -= shiftDist;\r\n if ( shiftDist < 0 ) {\r\n sigZ = softfloat_shortShiftRightJam64( sig128Z.v64, -shiftDist );\r\n } else {\r\n sig128Z =\r\n softfloat_shortShiftLeft128(\r\n sig128Z.v64, sig128Z.v0, shiftDist );\r\n sigZ = sig128Z.v64;\r\n }\r\n sigZ |= (sig128Z.v0 != 0);\r\n }\r\n roundPack:\r\n return softfloat_roundPackToF64( signZ, expZ, sigZ );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN_ABC:\r\n uiZ = softfloat_propagateNaNF64UI( uiA, uiB );\r\n goto propagateNaN_ZC;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n infProdArg:\r\n if ( magBits ) {\r\n uiZ = packToF64UI( signZ, 0x7FF, 0 );\r\n if ( expC != 0x7FF ) goto uiZ;\r\n if ( sigC ) goto propagateNaN_ZC;\r\n if ( signZ == signC ) goto uiZ;\r\n }\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF64UI;\r\n propagateNaN_ZC:\r\n uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n zeroProd:\r\n uiZ = uiC;\r\n if ( ! (expC | sigC) && (signZ != signC) ) {\r\n completeCancellation:\r\n uiZ =\r\n packToF64UI(\r\n (softfloat_roundingMode == softfloat_round_min), 0, 0 );\r\n }\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n#else\r\n\r\nfloat64_t\r\n softfloat_mulAddF64(\r\n uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )\r\n{\r\n bool signA;\r\n int_fast16_t expA;\r\n uint64_t sigA;\r\n bool signB;\r\n int_fast16_t expB;\r\n uint64_t sigB;\r\n bool signC;\r\n int_fast16_t expC;\r\n uint64_t sigC;\r\n bool signZ;\r\n uint64_t magBits, uiZ;\r\n struct exp16_sig64 normExpSig;\r\n int_fast16_t expZ;\r\n uint32_t sig128Z[4];\r\n uint64_t sigZ;\r\n int_fast16_t shiftDist, expDiff;\r\n uint32_t sig128C[4];\r\n union ui64_f64 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n signA = signF64UI( uiA );\r\n expA = expF64UI( uiA );\r\n sigA = fracF64UI( uiA );\r\n signB = signF64UI( uiB );\r\n expB = expF64UI( uiB );\r\n sigB = fracF64UI( uiB );\r\n signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC);\r\n expC = expF64UI( uiC );\r\n sigC = fracF64UI( uiC );\r\n signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0x7FF ) {\r\n if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC;\r\n magBits = expB | sigB;\r\n goto infProdArg;\r\n }\r\n if ( expB == 0x7FF ) {\r\n if ( sigB ) goto propagateNaN_ABC;\r\n magBits = expA | sigA;\r\n goto infProdArg;\r\n }\r\n if ( expC == 0x7FF ) {\r\n if ( sigC ) {\r\n uiZ = 0;\r\n goto propagateNaN_ZC;\r\n }\r\n uiZ = uiC;\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n if ( ! sigA ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF64Sig( sigA );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n if ( ! expB ) {\r\n if ( ! sigB ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF64Sig( sigB );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expZ = expA + expB - 0x3FE;\r\n sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;\r\n sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11;\r\n softfloat_mul64To128M( sigA, sigB, sig128Z );\r\n sigZ =\r\n (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 | sig128Z[indexWord( 4, 2 )];\r\n shiftDist = 0;\r\n if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {\r\n --expZ;\r\n shiftDist = -1;\r\n }\r\n if ( ! expC ) {\r\n if ( ! sigC ) {\r\n if ( shiftDist ) sigZ <<= 1;\r\n goto sigZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF64Sig( sigC );\r\n expC = normExpSig.exp;\r\n sigC = normExpSig.sig;\r\n }\r\n sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<10;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expZ - expC;\r\n if ( expDiff < 0 ) {\r\n expZ = expC;\r\n if ( (signZ == signC) || (expDiff < -1) ) {\r\n shiftDist -= expDiff;\r\n if ( shiftDist) {\r\n sigZ = softfloat_shiftRightJam64( sigZ, shiftDist );\r\n }\r\n } else {\r\n if ( ! shiftDist ) {\r\n softfloat_shortShiftRight128M( sig128Z, 1, sig128Z );\r\n }\r\n }\r\n } else {\r\n if ( shiftDist ) softfloat_add128M( sig128Z, sig128Z, sig128Z );\r\n if ( ! expDiff ) {\r\n sigZ =\r\n (uint64_t) sig128Z[indexWord( 4, 3 )]<<32\r\n | sig128Z[indexWord( 4, 2 )];\r\n } else {\r\n sig128C[indexWord( 4, 3 )] = sigC>>32;\r\n sig128C[indexWord( 4, 2 )] = sigC;\r\n sig128C[indexWord( 4, 1 )] = 0;\r\n sig128C[indexWord( 4, 0 )] = 0;\r\n softfloat_shiftRightJam128M( sig128C, expDiff, sig128C );\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( signZ == signC ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff <= 0 ) {\r\n sigZ += sigC;\r\n } else {\r\n softfloat_add128M( sig128Z, sig128C, sig128Z );\r\n sigZ =\r\n (uint64_t) sig128Z[indexWord( 4, 3 )]<<32\r\n | sig128Z[indexWord( 4, 2 )];\r\n }\r\n if ( sigZ & UINT64_C( 0x8000000000000000 ) ) {\r\n ++expZ;\r\n sigZ = softfloat_shortShiftRightJam64( sigZ, 1 );\r\n }\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff < 0 ) {\r\n signZ = signC;\r\n if ( expDiff < -1 ) {\r\n sigZ = sigC - sigZ;\r\n if (\r\n sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )]\r\n ) {\r\n sigZ = (sigZ - 1) | 1;\r\n }\r\n if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n goto roundPack;\r\n } else {\r\n sig128C[indexWord( 4, 3 )] = sigC>>32;\r\n sig128C[indexWord( 4, 2 )] = sigC;\r\n sig128C[indexWord( 4, 1 )] = 0;\r\n sig128C[indexWord( 4, 0 )] = 0;\r\n softfloat_sub128M( sig128C, sig128Z, sig128Z );\r\n }\r\n } else if ( ! expDiff ) {\r\n sigZ -= sigC;\r\n if (\r\n ! sigZ && ! sig128Z[indexWord( 4, 1 )]\r\n && ! sig128Z[indexWord( 4, 0 )]\r\n ) {\r\n goto completeCancellation;\r\n }\r\n sig128Z[indexWord( 4, 3 )] = sigZ>>32;\r\n sig128Z[indexWord( 4, 2 )] = sigZ;\r\n if ( sigZ & UINT64_C( 0x8000000000000000 ) ) {\r\n signZ = ! signZ;\r\n softfloat_negX128M( sig128Z );\r\n }\r\n } else {\r\n softfloat_sub128M( sig128Z, sig128C, sig128Z );\r\n if ( 1 < expDiff ) {\r\n sigZ =\r\n (uint64_t) sig128Z[indexWord( 4, 3 )]<<32\r\n | sig128Z[indexWord( 4, 2 )];\r\n if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n goto sigZ;\r\n }\r\n }\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n shiftDist = 0;\r\n sigZ =\r\n (uint64_t) sig128Z[indexWord( 4, 3 )]<<32\r\n | sig128Z[indexWord( 4, 2 )];\r\n if ( ! sigZ ) {\r\n shiftDist = 64;\r\n sigZ =\r\n (uint64_t) sig128Z[indexWord( 4, 1 )]<<32\r\n | sig128Z[indexWord( 4, 0 )];\r\n }\r\n shiftDist += softfloat_countLeadingZeros64( sigZ ) - 1;\r\n if ( shiftDist ) {\r\n expZ -= shiftDist;\r\n softfloat_shiftLeft128M( sig128Z, shiftDist, sig128Z );\r\n sigZ =\r\n (uint64_t) sig128Z[indexWord( 4, 3 )]<<32\r\n | sig128Z[indexWord( 4, 2 )];\r\n }\r\n }\r\n sigZ:\r\n if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;\r\n roundPack:\r\n return softfloat_roundPackToF64( signZ, expZ - 1, sigZ );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN_ABC:\r\n uiZ = softfloat_propagateNaNF64UI( uiA, uiB );\r\n goto propagateNaN_ZC;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n infProdArg:\r\n if ( magBits ) {\r\n uiZ = packToF64UI( signZ, 0x7FF, 0 );\r\n if ( expC != 0x7FF ) goto uiZ;\r\n if ( sigC ) goto propagateNaN_ZC;\r\n if ( signZ == signC ) goto uiZ;\r\n }\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF64UI;\r\n propagateNaN_ZC:\r\n uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n zeroProd:\r\n uiZ = uiC;\r\n if ( ! (expC | sigC) && (signZ != signC) ) {\r\n completeCancellation:\r\n uiZ =\r\n packToF64UI(\r\n (softfloat_roundingMode == softfloat_round_min), 0, 0 );\r\n }\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/s_mulAddF64.c ****/\n/**** start inlining ../../source/s_normSubnormalExtF80Sig.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nstruct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t sig )\r\n{\r\n int_fast8_t shiftDist;\r\n struct exp32_sig64 z;\r\n\r\n shiftDist = softfloat_countLeadingZeros64( sig );\r\n z.exp = -shiftDist;\r\n z.sig = sig<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t\r\n softfloat_roundPackToExtF80(\r\n bool sign,\r\n int_fast32_t exp,\r\n uint_fast64_t sig,\r\n uint_fast64_t sigExtra,\r\n uint_fast8_t roundingPrecision\r\n )\r\n{\r\n uint_fast8_t roundingMode;\r\n bool roundNearEven;\r\n uint_fast64_t roundIncrement, roundMask, roundBits;\r\n bool isTiny, doIncrement;\r\n struct uint64_extra sig64Extra;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n roundingMode = softfloat_roundingMode;\r\n roundNearEven = (roundingMode == softfloat_round_near_even);\r\n if ( roundingPrecision == 80 ) goto precision80;\r\n if ( roundingPrecision == 64 ) {\r\n roundIncrement = UINT64_C( 0x0000000000000400 );\r\n roundMask = UINT64_C( 0x00000000000007FF );\r\n } else if ( roundingPrecision == 32 ) {\r\n roundIncrement = UINT64_C( 0x0000008000000000 );\r\n roundMask = UINT64_C( 0x000000FFFFFFFFFF );\r\n } else {\r\n goto precision80;\r\n }\r\n sig |= (sigExtra != 0);\r\n if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {\r\n roundIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n ? roundMask\r\n : 0;\r\n }\r\n roundBits = sig & roundMask;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( 0x7FFD <= (uint32_t) (exp - 1) ) {\r\n if ( exp <= 0 ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n isTiny =\r\n (softfloat_detectTininess\r\n == softfloat_tininess_beforeRounding)\r\n || (exp < 0)\r\n || (sig <= (uint64_t) (sig + roundIncrement));\r\n sig = softfloat_shiftRightJam64( sig, 1 - exp );\r\n roundBits = sig & roundMask;\r\n if ( roundBits ) {\r\n if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig |= roundMask + 1;\r\n }\r\n#endif\r\n }\r\n sig += roundIncrement;\r\n exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);\r\n roundIncrement = roundMask + 1;\r\n if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {\r\n roundMask |= roundIncrement;\r\n }\r\n sig &= ~roundMask;\r\n goto packReturn;\r\n }\r\n if (\r\n (0x7FFE < exp)\r\n || ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig))\r\n ) {\r\n goto overflow;\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( roundBits ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig = (sig & ~roundMask) | (roundMask + 1);\r\n goto packReturn;\r\n }\r\n#endif\r\n }\r\n sig = (uint64_t) (sig + roundIncrement);\r\n if ( sig < roundIncrement ) {\r\n ++exp;\r\n sig = UINT64_C( 0x8000000000000000 );\r\n }\r\n roundIncrement = roundMask + 1;\r\n if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {\r\n roundMask |= roundIncrement;\r\n }\r\n sig &= ~roundMask;\r\n goto packReturn;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n precision80:\r\n doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);\r\n if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {\r\n doIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n && sigExtra;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( 0x7FFD <= (uint32_t) (exp - 1) ) {\r\n if ( exp <= 0 ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n isTiny =\r\n (softfloat_detectTininess\r\n == softfloat_tininess_beforeRounding)\r\n || (exp < 0)\r\n || ! doIncrement\r\n || (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF ));\r\n sig64Extra =\r\n softfloat_shiftRightJam64Extra( sig, sigExtra, 1 - exp );\r\n exp = 0;\r\n sig = sig64Extra.v;\r\n sigExtra = sig64Extra.extra;\r\n if ( sigExtra ) {\r\n if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig |= 1;\r\n goto packReturn;\r\n }\r\n#endif\r\n }\r\n doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);\r\n if (\r\n ! roundNearEven\r\n && (roundingMode != softfloat_round_near_maxMag)\r\n ) {\r\n doIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n && sigExtra;\r\n }\r\n if ( doIncrement ) {\r\n ++sig;\r\n sig &=\r\n ~(uint_fast64_t)\r\n (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))\r\n & roundNearEven);\r\n exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);\r\n }\r\n goto packReturn;\r\n }\r\n if (\r\n (0x7FFE < exp)\r\n || ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF ))\r\n && doIncrement)\r\n ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n roundMask = 0;\r\n overflow:\r\n softfloat_raiseFlags(\r\n softfloat_flag_overflow | softfloat_flag_inexact );\r\n if (\r\n roundNearEven\r\n || (roundingMode == softfloat_round_near_maxMag)\r\n || (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n ) {\r\n exp = 0x7FFF;\r\n sig = UINT64_C( 0x8000000000000000 );\r\n } else {\r\n exp = 0x7FFE;\r\n sig = ~roundMask;\r\n }\r\n goto packReturn;\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( sigExtra ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig |= 1;\r\n goto packReturn;\r\n }\r\n#endif\r\n }\r\n if ( doIncrement ) {\r\n ++sig;\r\n if ( ! sig ) {\r\n ++exp;\r\n sig = UINT64_C( 0x8000000000000000 );\r\n } else {\r\n sig &=\r\n ~(uint_fast64_t)\r\n (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))\r\n & roundNearEven);\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n packReturn:\r\n uZ.s.signExp = packToExtF80UI64( sign, exp );\r\n uZ.s.signif = sig;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundPackToExtF80.c ****/\n/**** start inlining ../../source/s_normRoundPackToExtF80.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nextFloat80_t\r\n softfloat_normRoundPackToExtF80(\r\n bool sign,\r\n int_fast32_t exp,\r\n uint_fast64_t sig,\r\n uint_fast64_t sigExtra,\r\n uint_fast8_t roundingPrecision\r\n )\r\n{\r\n int_fast8_t shiftDist;\r\n struct uint128 sig128;\r\n\r\n if ( ! sig ) {\r\n exp -= 64;\r\n sig = sigExtra;\r\n sigExtra = 0;\r\n }\r\n shiftDist = softfloat_countLeadingZeros64( sig );\r\n exp -= shiftDist;\r\n if ( shiftDist ) {\r\n sig128 = softfloat_shortShiftLeft128( sig, sigExtra, shiftDist );\r\n sig = sig128.v64;\r\n sigExtra = sig128.v0;\r\n }\r\n return\r\n softfloat_roundPackToExtF80(\r\n sign, exp, sig, sigExtra, roundingPrecision );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_normRoundPackToExtF80.c ****/\n/**** start inlining ../../source/s_addMagsExtF80.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t\r\n softfloat_addMagsExtF80(\r\n uint_fast16_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast16_t uiB64,\r\n uint_fast64_t uiB0,\r\n bool signZ\r\n )\r\n{\r\n int_fast32_t expA;\r\n uint_fast64_t sigA;\r\n int_fast32_t expB;\r\n uint_fast64_t sigB;\r\n int_fast32_t expDiff;\r\n uint_fast16_t uiZ64;\r\n uint_fast64_t uiZ0, sigZ, sigZExtra;\r\n struct exp32_sig64 normExpSig;\r\n int_fast32_t expZ;\r\n struct uint64_extra sig64Extra;\r\n struct uint128 uiZ;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expExtF80UI64( uiA64 );\r\n sigA = uiA0;\r\n expB = expExtF80UI64( uiB64 );\r\n sigB = uiB0;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n if ( expA == 0x7FFF ) {\r\n if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {\r\n goto propagateNaN;\r\n }\r\n uiZ64 = uiA64;\r\n uiZ0 = uiA0;\r\n goto uiZ;\r\n }\r\n sigZ = sigA + sigB;\r\n sigZExtra = 0;\r\n if ( ! expA ) {\r\n normExpSig = softfloat_normSubnormalExtF80Sig( sigZ );\r\n expZ = normExpSig.exp + 1;\r\n sigZ = normExpSig.sig;\r\n goto roundAndPack;\r\n }\r\n expZ = expA;\r\n goto shiftRight1;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expDiff < 0 ) {\r\n if ( expB == 0x7FFF ) {\r\n if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;\r\n uiZ64 = packToExtF80UI64( signZ, 0x7FFF );\r\n uiZ0 = uiB0;\r\n goto uiZ;\r\n }\r\n expZ = expB;\r\n if ( ! expA ) {\r\n ++expDiff;\r\n sigZExtra = 0;\r\n if ( ! expDiff ) goto newlyAligned;\r\n }\r\n sig64Extra = softfloat_shiftRightJam64Extra( sigA, 0, -expDiff );\r\n sigA = sig64Extra.v;\r\n sigZExtra = sig64Extra.extra;\r\n } else {\r\n if ( expA == 0x7FFF ) {\r\n if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;\r\n uiZ64 = uiA64;\r\n uiZ0 = uiA0;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n if ( ! expB ) {\r\n --expDiff;\r\n sigZExtra = 0;\r\n if ( ! expDiff ) goto newlyAligned;\r\n }\r\n sig64Extra = softfloat_shiftRightJam64Extra( sigB, 0, expDiff );\r\n sigB = sig64Extra.v;\r\n sigZExtra = sig64Extra.extra;\r\n }\r\n newlyAligned:\r\n sigZ = sigA + sigB;\r\n if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto roundAndPack;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n shiftRight1:\r\n sig64Extra = softfloat_shortShiftRightJam64Extra( sigZ, sigZExtra, 1 );\r\n sigZ = sig64Extra.v | UINT64_C( 0x8000000000000000 );\r\n sigZExtra = sig64Extra.extra;\r\n ++expZ;\r\n roundAndPack:\r\n return\r\n softfloat_roundPackToExtF80(\r\n signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );\r\n uiZ64 = uiZ.v64;\r\n uiZ0 = uiZ.v0;\r\n uiZ:\r\n uZ.s.signExp = uiZ64;\r\n uZ.s.signif = uiZ0;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_addMagsExtF80.c ****/\n/**** start inlining ../../source/s_subMagsExtF80.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t\r\n softfloat_subMagsExtF80(\r\n uint_fast16_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast16_t uiB64,\r\n uint_fast64_t uiB0,\r\n bool signZ\r\n )\r\n{\r\n int_fast32_t expA;\r\n uint_fast64_t sigA;\r\n int_fast32_t expB;\r\n uint_fast64_t sigB;\r\n int_fast32_t expDiff;\r\n uint_fast16_t uiZ64;\r\n uint_fast64_t uiZ0;\r\n int_fast32_t expZ;\r\n uint_fast64_t sigExtra;\r\n struct uint128 sig128, uiZ;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expA = expExtF80UI64( uiA64 );\r\n sigA = uiA0;\r\n expB = expExtF80UI64( uiB64 );\r\n sigB = uiB0;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expA - expB;\r\n if ( 0 < expDiff ) goto expABigger;\r\n if ( expDiff < 0 ) goto expBBigger;\r\n if ( expA == 0x7FFF ) {\r\n if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {\r\n goto propagateNaN;\r\n }\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ64 = defaultNaNExtF80UI64;\r\n uiZ0 = defaultNaNExtF80UI0;\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expZ = expA;\r\n if ( ! expZ ) expZ = 1;\r\n sigExtra = 0;\r\n if ( sigB < sigA ) goto aBigger;\r\n if ( sigA < sigB ) goto bBigger;\r\n uiZ64 =\r\n packToExtF80UI64( (softfloat_roundingMode == softfloat_round_min), 0 );\r\n uiZ0 = 0;\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expBBigger:\r\n if ( expB == 0x7FFF ) {\r\n if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;\r\n uiZ64 = packToExtF80UI64( signZ ^ 1, 0x7FFF );\r\n uiZ0 = UINT64_C( 0x8000000000000000 );\r\n goto uiZ;\r\n }\r\n if ( ! expA ) {\r\n ++expDiff;\r\n sigExtra = 0;\r\n if ( ! expDiff ) goto newlyAlignedBBigger;\r\n }\r\n sig128 = softfloat_shiftRightJam128( sigA, 0, -expDiff );\r\n sigA = sig128.v64;\r\n sigExtra = sig128.v0;\r\n newlyAlignedBBigger:\r\n expZ = expB;\r\n bBigger:\r\n signZ = ! signZ;\r\n sig128 = softfloat_sub128( sigB, 0, sigA, sigExtra );\r\n goto normRoundPack;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expABigger:\r\n if ( expA == 0x7FFF ) {\r\n if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;\r\n uiZ64 = uiA64;\r\n uiZ0 = uiA0;\r\n goto uiZ;\r\n }\r\n if ( ! expB ) {\r\n --expDiff;\r\n sigExtra = 0;\r\n if ( ! expDiff ) goto newlyAlignedABigger;\r\n }\r\n sig128 = softfloat_shiftRightJam128( sigB, 0, expDiff );\r\n sigB = sig128.v64;\r\n sigExtra = sig128.v0;\r\n newlyAlignedABigger:\r\n expZ = expA;\r\n aBigger:\r\n sig128 = softfloat_sub128( sigA, 0, sigB, sigExtra );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n normRoundPack:\r\n return\r\n softfloat_normRoundPackToExtF80(\r\n signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );\r\n uiZ64 = uiZ.v64;\r\n uiZ0 = uiZ.v0;\r\n uiZ:\r\n uZ.s.signExp = uiZ64;\r\n uZ.s.signif = uiZ0;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_subMagsExtF80.c ****/\n/**** start inlining ../../source/s_normSubnormalF128Sig.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nstruct exp32_sig128\r\n softfloat_normSubnormalF128Sig( uint_fast64_t sig64, uint_fast64_t sig0 )\r\n{\r\n int_fast8_t shiftDist;\r\n struct exp32_sig128 z;\r\n\r\n if ( ! sig64 ) {\r\n shiftDist = softfloat_countLeadingZeros64( sig0 ) - 15;\r\n z.exp = -63 - shiftDist;\r\n if ( shiftDist < 0 ) {\r\n z.sig.v64 = sig0>>-shiftDist;\r\n z.sig.v0 = sig0<<(shiftDist & 63);\r\n } else {\r\n z.sig.v64 = sig0<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t\r\n softfloat_roundPackToF128(\r\n bool sign,\r\n int_fast32_t exp,\r\n uint_fast64_t sig64,\r\n uint_fast64_t sig0,\r\n uint_fast64_t sigExtra\r\n )\r\n{\r\n uint_fast8_t roundingMode;\r\n bool roundNearEven, doIncrement, isTiny;\r\n struct uint128_extra sig128Extra;\r\n uint_fast64_t uiZ64, uiZ0;\r\n struct uint128 sig128;\r\n union ui128_f128 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n roundingMode = softfloat_roundingMode;\r\n roundNearEven = (roundingMode == softfloat_round_near_even);\r\n doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);\r\n if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {\r\n doIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n && sigExtra;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( 0x7FFD <= (uint32_t) exp ) {\r\n if ( exp < 0 ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n isTiny =\r\n (softfloat_detectTininess\r\n == softfloat_tininess_beforeRounding)\r\n || (exp < -1)\r\n || ! doIncrement\r\n || softfloat_lt128(\r\n sig64,\r\n sig0,\r\n UINT64_C( 0x0001FFFFFFFFFFFF ),\r\n UINT64_C( 0xFFFFFFFFFFFFFFFF )\r\n );\r\n sig128Extra =\r\n softfloat_shiftRightJam128Extra( sig64, sig0, sigExtra, -exp );\r\n sig64 = sig128Extra.v.v64;\r\n sig0 = sig128Extra.v.v0;\r\n sigExtra = sig128Extra.extra;\r\n exp = 0;\r\n if ( isTiny && sigExtra ) {\r\n softfloat_raiseFlags( softfloat_flag_underflow );\r\n }\r\n doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);\r\n if (\r\n ! roundNearEven\r\n && (roundingMode != softfloat_round_near_maxMag)\r\n ) {\r\n doIncrement =\r\n (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n && sigExtra;\r\n }\r\n } else if (\r\n (0x7FFD < exp)\r\n || ((exp == 0x7FFD)\r\n && softfloat_eq128( \r\n sig64,\r\n sig0,\r\n UINT64_C( 0x0001FFFFFFFFFFFF ),\r\n UINT64_C( 0xFFFFFFFFFFFFFFFF )\r\n )\r\n && doIncrement)\r\n ) {\r\n /*----------------------------------------------------------------\r\n *----------------------------------------------------------------*/\r\n softfloat_raiseFlags(\r\n softfloat_flag_overflow | softfloat_flag_inexact );\r\n if (\r\n roundNearEven\r\n || (roundingMode == softfloat_round_near_maxMag)\r\n || (roundingMode\r\n == (sign ? softfloat_round_min : softfloat_round_max))\r\n ) {\r\n uiZ64 = packToF128UI64( sign, 0x7FFF, 0 );\r\n uiZ0 = 0;\r\n } else {\r\n uiZ64 =\r\n packToF128UI64(\r\n sign, 0x7FFE, UINT64_C( 0x0000FFFFFFFFFFFF ) );\r\n uiZ0 = UINT64_C( 0xFFFFFFFFFFFFFFFF );\r\n }\r\n goto uiZ;\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( sigExtra ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) {\r\n sig0 |= 1;\r\n goto packReturn;\r\n }\r\n#endif\r\n }\r\n if ( doIncrement ) {\r\n sig128 = softfloat_add128( sig64, sig0, 0, 1 );\r\n sig64 = sig128.v64;\r\n sig0 =\r\n sig128.v0\r\n & ~(uint64_t)\r\n (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))\r\n & roundNearEven);\r\n } else {\r\n if ( ! (sig64 | sig0) ) exp = 0;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n packReturn:\r\n uiZ64 = packToF128UI64( sign, exp, sig64 );\r\n uiZ0 = sig0;\r\n uiZ:\r\n uZ.ui.v64 = uiZ64;\r\n uZ.ui.v0 = uiZ0;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_roundPackToF128.c ****/\n/**** start inlining ../../source/s_normRoundPackToF128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n\r\nfloat128_t\r\n softfloat_normRoundPackToF128(\r\n bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 )\r\n{\r\n int_fast8_t shiftDist;\r\n struct uint128 sig128;\r\n union ui128_f128 uZ;\r\n uint_fast64_t sigExtra;\r\n struct uint128_extra sig128Extra;\r\n\r\n if ( ! sig64 ) {\r\n exp -= 64;\r\n sig64 = sig0;\r\n sig0 = 0;\r\n }\r\n shiftDist = softfloat_countLeadingZeros64( sig64 ) - 15;\r\n exp -= shiftDist;\r\n if ( 0 <= shiftDist ) {\r\n if ( shiftDist ) {\r\n sig128 = softfloat_shortShiftLeft128( sig64, sig0, shiftDist );\r\n sig64 = sig128.v64;\r\n sig0 = sig128.v0;\r\n }\r\n if ( (uint32_t) exp < 0x7FFD ) {\r\n uZ.ui.v64 = packToF128UI64( sign, sig64 | sig0 ? exp : 0, sig64 );\r\n uZ.ui.v0 = sig0;\r\n return uZ.f;\r\n }\r\n sigExtra = 0;\r\n } else {\r\n sig128Extra =\r\n softfloat_shortShiftRightJam128Extra( sig64, sig0, 0, -shiftDist );\r\n sig64 = sig128Extra.v.v64;\r\n sig0 = sig128Extra.v.v0;\r\n sigExtra = sig128Extra.extra;\r\n }\r\n return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_normRoundPackToF128.c ****/\n/**** start inlining ../../source/s_addMagsF128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014 The Regents of the University of California.\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n\r\nfloat128_t\r\n softfloat_addMagsF128(\r\n uint_fast64_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast64_t uiB64,\r\n uint_fast64_t uiB0,\r\n bool signZ\r\n )\r\n{\r\n int_fast32_t expA;\r\n struct uint128 sigA;\r\n int_fast32_t expB;\r\n struct uint128 sigB;\r\n int_fast32_t expDiff;\r\n struct uint128 uiZ, sigZ;\r\n int_fast32_t expZ;\r\n uint_fast64_t sigZExtra;\r\n struct uint128_extra sig128Extra;\r\n union ui128_f128 uZ;\r\n\r\n expA = expF128UI64( uiA64 );\r\n sigA.v64 = fracF128UI64( uiA64 );\r\n sigA.v0 = uiA0;\r\n expB = expF128UI64( uiB64 );\r\n sigB.v64 = fracF128UI64( uiB64 );\r\n sigB.v0 = uiB0;\r\n expDiff = expA - expB;\r\n if ( ! expDiff ) {\r\n if ( expA == 0x7FFF ) {\r\n if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;\r\n uiZ.v64 = uiA64;\r\n uiZ.v0 = uiA0;\r\n goto uiZ;\r\n }\r\n sigZ = softfloat_add128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );\r\n if ( ! expA ) {\r\n uiZ.v64 = packToF128UI64( signZ, 0, sigZ.v64 );\r\n uiZ.v0 = sigZ.v0;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n sigZ.v64 |= UINT64_C( 0x0002000000000000 );\r\n sigZExtra = 0;\r\n goto shiftRight1;\r\n }\r\n if ( expDiff < 0 ) {\r\n if ( expB == 0x7FFF ) {\r\n if ( sigB.v64 | sigB.v0 ) goto propagateNaN;\r\n uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );\r\n uiZ.v0 = 0;\r\n goto uiZ;\r\n }\r\n expZ = expB;\r\n if ( expA ) {\r\n sigA.v64 |= UINT64_C( 0x0001000000000000 );\r\n } else {\r\n ++expDiff;\r\n sigZExtra = 0;\r\n if ( ! expDiff ) goto newlyAligned;\r\n }\r\n sig128Extra =\r\n softfloat_shiftRightJam128Extra( sigA.v64, sigA.v0, 0, -expDiff );\r\n sigA = sig128Extra.v;\r\n sigZExtra = sig128Extra.extra;\r\n } else {\r\n if ( expA == 0x7FFF ) {\r\n if ( sigA.v64 | sigA.v0 ) goto propagateNaN;\r\n uiZ.v64 = uiA64;\r\n uiZ.v0 = uiA0;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n if ( expB ) {\r\n sigB.v64 |= UINT64_C( 0x0001000000000000 );\r\n } else {\r\n --expDiff;\r\n sigZExtra = 0;\r\n if ( ! expDiff ) goto newlyAligned;\r\n }\r\n sig128Extra =\r\n softfloat_shiftRightJam128Extra( sigB.v64, sigB.v0, 0, expDiff );\r\n sigB = sig128Extra.v;\r\n sigZExtra = sig128Extra.extra;\r\n }\r\n newlyAligned:\r\n sigZ =\r\n softfloat_add128(\r\n sigA.v64 | UINT64_C( 0x0001000000000000 ),\r\n sigA.v0,\r\n sigB.v64,\r\n sigB.v0\r\n );\r\n --expZ;\r\n if ( sigZ.v64 < UINT64_C( 0x0002000000000000 ) ) goto roundAndPack;\r\n ++expZ;\r\n shiftRight1:\r\n sig128Extra =\r\n softfloat_shortShiftRightJam128Extra(\r\n sigZ.v64, sigZ.v0, sigZExtra, 1 );\r\n sigZ = sig128Extra.v;\r\n sigZExtra = sig128Extra.extra;\r\n roundAndPack:\r\n return\r\n softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_addMagsF128.c ****/\n/**** start inlining ../../source/s_subMagsF128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t\r\n softfloat_subMagsF128(\r\n uint_fast64_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast64_t uiB64,\r\n uint_fast64_t uiB0,\r\n bool signZ\r\n )\r\n{\r\n int_fast32_t expA;\r\n struct uint128 sigA;\r\n int_fast32_t expB;\r\n struct uint128 sigB, sigZ;\r\n int_fast32_t expDiff, expZ;\r\n struct uint128 uiZ;\r\n union ui128_f128 uZ;\r\n\r\n expA = expF128UI64( uiA64 );\r\n sigA.v64 = fracF128UI64( uiA64 );\r\n sigA.v0 = uiA0;\r\n expB = expF128UI64( uiB64 );\r\n sigB.v64 = fracF128UI64( uiB64 );\r\n sigB.v0 = uiB0;\r\n sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 4 );\r\n sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 4 );\r\n expDiff = expA - expB;\r\n if ( 0 < expDiff ) goto expABigger;\r\n if ( expDiff < 0 ) goto expBBigger;\r\n if ( expA == 0x7FFF ) {\r\n if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ.v64 = defaultNaNF128UI64;\r\n uiZ.v0 = defaultNaNF128UI0;\r\n goto uiZ;\r\n }\r\n expZ = expA;\r\n if ( ! expZ ) expZ = 1;\r\n if ( sigB.v64 < sigA.v64 ) goto aBigger;\r\n if ( sigA.v64 < sigB.v64 ) goto bBigger;\r\n if ( sigB.v0 < sigA.v0 ) goto aBigger;\r\n if ( sigA.v0 < sigB.v0 ) goto bBigger;\r\n uiZ.v64 =\r\n packToF128UI64(\r\n (softfloat_roundingMode == softfloat_round_min), 0, 0 );\r\n uiZ.v0 = 0;\r\n goto uiZ;\r\n expBBigger:\r\n if ( expB == 0x7FFF ) {\r\n if ( sigB.v64 | sigB.v0 ) goto propagateNaN;\r\n uiZ.v64 = packToF128UI64( signZ ^ 1, 0x7FFF, 0 );\r\n uiZ.v0 = 0;\r\n goto uiZ;\r\n }\r\n if ( expA ) {\r\n sigA.v64 |= UINT64_C( 0x0010000000000000 );\r\n } else {\r\n ++expDiff;\r\n if ( ! expDiff ) goto newlyAlignedBBigger;\r\n }\r\n sigA = softfloat_shiftRightJam128( sigA.v64, sigA.v0, -expDiff );\r\n newlyAlignedBBigger:\r\n expZ = expB;\r\n sigB.v64 |= UINT64_C( 0x0010000000000000 );\r\n bBigger:\r\n signZ = ! signZ;\r\n sigZ = softfloat_sub128( sigB.v64, sigB.v0, sigA.v64, sigA.v0 );\r\n goto normRoundPack;\r\n expABigger:\r\n if ( expA == 0x7FFF ) {\r\n if ( sigA.v64 | sigA.v0 ) goto propagateNaN;\r\n uiZ.v64 = uiA64;\r\n uiZ.v0 = uiA0;\r\n goto uiZ;\r\n }\r\n if ( expB ) {\r\n sigB.v64 |= UINT64_C( 0x0010000000000000 );\r\n } else {\r\n --expDiff;\r\n if ( ! expDiff ) goto newlyAlignedABigger;\r\n }\r\n sigB = softfloat_shiftRightJam128( sigB.v64, sigB.v0, expDiff );\r\n newlyAlignedABigger:\r\n expZ = expA;\r\n sigA.v64 |= UINT64_C( 0x0010000000000000 );\r\n aBigger:\r\n sigZ = softfloat_sub128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );\r\n normRoundPack:\r\n return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 );\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_subMagsF128.c ****/\n/**** start inlining ../../source/s_mulAddF128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t\r\n softfloat_mulAddF128(\r\n uint_fast64_t uiA64,\r\n uint_fast64_t uiA0,\r\n uint_fast64_t uiB64,\r\n uint_fast64_t uiB0,\r\n uint_fast64_t uiC64,\r\n uint_fast64_t uiC0,\r\n uint_fast8_t op\r\n )\r\n{\r\n bool signA;\r\n int_fast32_t expA;\r\n struct uint128 sigA;\r\n bool signB;\r\n int_fast32_t expB;\r\n struct uint128 sigB;\r\n bool signC;\r\n int_fast32_t expC;\r\n struct uint128 sigC;\r\n bool signZ;\r\n uint_fast64_t magBits;\r\n struct uint128 uiZ;\r\n struct exp32_sig128 normExpSig;\r\n int_fast32_t expZ;\r\n uint64_t sig256Z[4];\r\n struct uint128 sigZ;\r\n int_fast32_t shiftDist, expDiff;\r\n struct uint128 x128;\r\n uint64_t sig256C[4];\r\n static uint64_t zero256[4] = INIT_UINTM4( 0, 0, 0, 0 );\r\n uint_fast64_t sigZExtra, sig256Z0;\r\n union ui128_f128 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n signA = signF128UI64( uiA64 );\r\n expA = expF128UI64( uiA64 );\r\n sigA.v64 = fracF128UI64( uiA64 );\r\n sigA.v0 = uiA0;\r\n signB = signF128UI64( uiB64 );\r\n expB = expF128UI64( uiB64 );\r\n sigB.v64 = fracF128UI64( uiB64 );\r\n sigB.v0 = uiB0;\r\n signC = signF128UI64( uiC64 ) ^ (op == softfloat_mulAdd_subC);\r\n expC = expF128UI64( uiC64 );\r\n sigC.v64 = fracF128UI64( uiC64 );\r\n sigC.v0 = uiC0;\r\n signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0x7FFF ) {\r\n if (\r\n (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0))\r\n ) {\r\n goto propagateNaN_ABC;\r\n }\r\n magBits = expB | sigB.v64 | sigB.v0;\r\n goto infProdArg;\r\n }\r\n if ( expB == 0x7FFF ) {\r\n if ( sigB.v64 | sigB.v0 ) goto propagateNaN_ABC;\r\n magBits = expA | sigA.v64 | sigA.v0;\r\n goto infProdArg;\r\n }\r\n if ( expC == 0x7FFF ) {\r\n if ( sigC.v64 | sigC.v0 ) {\r\n uiZ.v64 = 0;\r\n uiZ.v0 = 0;\r\n goto propagateNaN_ZC;\r\n }\r\n uiZ.v64 = uiC64;\r\n uiZ.v0 = uiC0;\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n if ( ! (sigA.v64 | sigA.v0) ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n if ( ! expB ) {\r\n if ( ! (sigB.v64 | sigB.v0) ) goto zeroProd;\r\n normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expZ = expA + expB - 0x3FFE;\r\n sigA.v64 |= UINT64_C( 0x0001000000000000 );\r\n sigB.v64 |= UINT64_C( 0x0001000000000000 );\r\n sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 8 );\r\n sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 15 );\r\n softfloat_mul128To256M( sigA.v64, sigA.v0, sigB.v64, sigB.v0, sig256Z );\r\n sigZ.v64 = sig256Z[indexWord( 4, 3 )];\r\n sigZ.v0 = sig256Z[indexWord( 4, 2 )];\r\n shiftDist = 0;\r\n if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {\r\n --expZ;\r\n shiftDist = -1;\r\n }\r\n if ( ! expC ) {\r\n if ( ! (sigC.v64 | sigC.v0) ) {\r\n shiftDist += 8;\r\n goto sigZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF128Sig( sigC.v64, sigC.v0 );\r\n expC = normExpSig.exp;\r\n sigC = normExpSig.sig;\r\n }\r\n sigC.v64 |= UINT64_C( 0x0001000000000000 );\r\n sigC = softfloat_shortShiftLeft128( sigC.v64, sigC.v0, 8 );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expDiff = expZ - expC;\r\n if ( expDiff < 0 ) {\r\n expZ = expC;\r\n if ( (signZ == signC) || (expDiff < -1) ) {\r\n shiftDist -= expDiff;\r\n if ( shiftDist ) {\r\n sigZ =\r\n softfloat_shiftRightJam128( sigZ.v64, sigZ.v0, shiftDist );\r\n }\r\n } else {\r\n if ( ! shiftDist ) {\r\n x128 =\r\n softfloat_shortShiftRight128(\r\n sig256Z[indexWord( 4, 1 )], sig256Z[indexWord( 4, 0 )],\r\n 1\r\n );\r\n sig256Z[indexWord( 4, 1 )] = (sigZ.v0<<63) | x128.v64;\r\n sig256Z[indexWord( 4, 0 )] = x128.v0;\r\n sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, 1 );\r\n sig256Z[indexWord( 4, 3 )] = sigZ.v64;\r\n sig256Z[indexWord( 4, 2 )] = sigZ.v0;\r\n }\r\n }\r\n } else {\r\n if ( shiftDist ) softfloat_add256M( sig256Z, sig256Z, sig256Z );\r\n if ( ! expDiff ) {\r\n sigZ.v64 = sig256Z[indexWord( 4, 3 )];\r\n sigZ.v0 = sig256Z[indexWord( 4, 2 )];\r\n } else {\r\n sig256C[indexWord( 4, 3 )] = sigC.v64;\r\n sig256C[indexWord( 4, 2 )] = sigC.v0;\r\n sig256C[indexWord( 4, 1 )] = 0;\r\n sig256C[indexWord( 4, 0 )] = 0;\r\n softfloat_shiftRightJam256M( sig256C, expDiff, sig256C );\r\n }\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n shiftDist = 8;\r\n if ( signZ == signC ) {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff <= 0 ) {\r\n sigZ = softfloat_add128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 );\r\n } else {\r\n softfloat_add256M( sig256Z, sig256C, sig256Z );\r\n sigZ.v64 = sig256Z[indexWord( 4, 3 )];\r\n sigZ.v0 = sig256Z[indexWord( 4, 2 )];\r\n }\r\n if ( sigZ.v64 & UINT64_C( 0x0200000000000000 ) ) {\r\n ++expZ;\r\n shiftDist = 9;\r\n }\r\n } else {\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n if ( expDiff < 0 ) {\r\n signZ = signC;\r\n if ( expDiff < -1 ) {\r\n sigZ =\r\n softfloat_sub128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 );\r\n sigZExtra =\r\n sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )];\r\n if ( sigZExtra ) {\r\n sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, 0, 1 );\r\n }\r\n if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {\r\n --expZ;\r\n shiftDist = 7;\r\n }\r\n goto shiftRightRoundPack;\r\n } else {\r\n sig256C[indexWord( 4, 3 )] = sigC.v64;\r\n sig256C[indexWord( 4, 2 )] = sigC.v0;\r\n sig256C[indexWord( 4, 1 )] = 0;\r\n sig256C[indexWord( 4, 0 )] = 0;\r\n softfloat_sub256M( sig256C, sig256Z, sig256Z );\r\n }\r\n } else if ( ! expDiff ) {\r\n sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, sigC.v64, sigC.v0 );\r\n if (\r\n ! (sigZ.v64 | sigZ.v0) && ! sig256Z[indexWord( 4, 1 )]\r\n && ! sig256Z[indexWord( 4, 0 )]\r\n ) {\r\n goto completeCancellation;\r\n }\r\n sig256Z[indexWord( 4, 3 )] = sigZ.v64;\r\n sig256Z[indexWord( 4, 2 )] = sigZ.v0;\r\n if ( sigZ.v64 & UINT64_C( 0x8000000000000000 ) ) {\r\n signZ = ! signZ;\r\n softfloat_sub256M( zero256, sig256Z, sig256Z );\r\n }\r\n } else {\r\n softfloat_sub256M( sig256Z, sig256C, sig256Z );\r\n if ( 1 < expDiff ) {\r\n sigZ.v64 = sig256Z[indexWord( 4, 3 )];\r\n sigZ.v0 = sig256Z[indexWord( 4, 2 )];\r\n if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {\r\n --expZ;\r\n shiftDist = 7;\r\n }\r\n goto sigZ;\r\n }\r\n }\r\n /*--------------------------------------------------------------------\r\n *--------------------------------------------------------------------*/\r\n sigZ.v64 = sig256Z[indexWord( 4, 3 )];\r\n sigZ.v0 = sig256Z[indexWord( 4, 2 )];\r\n sigZExtra = sig256Z[indexWord( 4, 1 )];\r\n sig256Z0 = sig256Z[indexWord( 4, 0 )];\r\n if ( sigZ.v64 ) {\r\n if ( sig256Z0 ) sigZExtra |= 1;\r\n } else {\r\n expZ -= 64;\r\n sigZ.v64 = sigZ.v0;\r\n sigZ.v0 = sigZExtra;\r\n sigZExtra = sig256Z0;\r\n if ( ! sigZ.v64 ) {\r\n expZ -= 64;\r\n sigZ.v64 = sigZ.v0;\r\n sigZ.v0 = sigZExtra;\r\n sigZExtra = 0;\r\n if ( ! sigZ.v64 ) {\r\n expZ -= 64;\r\n sigZ.v64 = sigZ.v0;\r\n sigZ.v0 = 0;\r\n }\r\n }\r\n }\r\n shiftDist = softfloat_countLeadingZeros64( sigZ.v64 );\r\n expZ += 7 - shiftDist;\r\n shiftDist = 15 - shiftDist;\r\n if ( 0 < shiftDist ) goto shiftRightRoundPack;\r\n if ( shiftDist ) {\r\n shiftDist = -shiftDist;\r\n sigZ = softfloat_shortShiftLeft128( sigZ.v64, sigZ.v0, shiftDist );\r\n x128 = softfloat_shortShiftLeft128( 0, sigZExtra, shiftDist );\r\n sigZ.v0 |= x128.v64;\r\n sigZExtra = x128.v0;\r\n }\r\n goto roundPack;\r\n }\r\n sigZ:\r\n sigZExtra = sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )];\r\n shiftRightRoundPack:\r\n sigZExtra = (uint64_t) (sigZ.v0<<(64 - shiftDist)) | (sigZExtra != 0);\r\n sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, shiftDist );\r\n roundPack:\r\n return\r\n softfloat_roundPackToF128(\r\n signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN_ABC:\r\n uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );\r\n goto propagateNaN_ZC;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n infProdArg:\r\n if ( magBits ) {\r\n uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );\r\n uiZ.v0 = 0;\r\n if ( expC != 0x7FFF ) goto uiZ;\r\n if ( sigC.v64 | sigC.v0 ) goto propagateNaN_ZC;\r\n if ( signZ == signC ) goto uiZ;\r\n }\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ.v64 = defaultNaNF128UI64;\r\n uiZ.v0 = defaultNaNF128UI0;\r\n propagateNaN_ZC:\r\n uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n zeroProd:\r\n uiZ.v64 = uiC64;\r\n uiZ.v0 = uiC0;\r\n if ( ! (expC | sigC.v64 | sigC.v0) && (signZ != signC) ) {\r\n completeCancellation:\r\n uiZ.v64 =\r\n packToF128UI64(\r\n (softfloat_roundingMode == softfloat_round_min), 0, 0 );\r\n uiZ.v0 = 0;\r\n }\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/s_mulAddF128.c ****/\n/**** start inlining ../../source/softfloat_state.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifndef THREAD_LOCAL\r\n#define THREAD_LOCAL\r\n#endif\r\n\r\nTHREAD_LOCAL uint_fast8_t softfloat_roundingMode = softfloat_round_near_even;\r\nTHREAD_LOCAL uint_fast8_t softfloat_detectTininess = init_detectTininess;\r\nTHREAD_LOCAL uint_fast8_t softfloat_exceptionFlags = 0;\r\n\r\nTHREAD_LOCAL uint_fast8_t extF80_roundingPrecision = 80;\r\n\r\n/**** ended inlining ../../source/softfloat_state.c ****/\n/**** start inlining ../../source/ui32_to_f16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t ui32_to_f16( uint32_t a )\r\n{\r\n int_fast8_t shiftDist;\r\n union ui16_f16 u;\r\n uint_fast16_t sig;\r\n\r\n shiftDist = softfloat_countLeadingZeros32( a ) - 21;\r\n if ( 0 <= shiftDist ) {\r\n u.ui =\r\n a ? packToF16UI(\r\n 0, 0x18 - shiftDist, (uint_fast16_t) a<>(-shiftDist) | ((uint32_t) (a<<(shiftDist & 31)) != 0)\r\n : (uint_fast16_t) a<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t ui32_to_f32( uint32_t a )\r\n{\r\n union ui32_f32 uZ;\r\n\r\n if ( ! a ) {\r\n uZ.ui = 0;\r\n return uZ.f;\r\n }\r\n if ( a & 0x80000000 ) {\r\n return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) );\r\n } else {\r\n return softfloat_normRoundPackToF32( 0, 0x9C, a );\r\n }\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/ui32_to_f32.c ****/\n/**** start inlining ../../source/ui32_to_f64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat64_t ui32_to_f64( uint32_t a )\r\n{\r\n uint_fast64_t uiZ;\r\n int_fast8_t shiftDist;\r\n union ui64_f64 uZ;\r\n\r\n if ( ! a ) {\r\n uiZ = 0;\r\n } else {\r\n shiftDist = softfloat_countLeadingZeros32( a ) + 21;\r\n uiZ =\r\n packToF64UI( 0, 0x432 - shiftDist, (uint_fast64_t) a<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t ui32_to_extF80( uint32_t a )\r\n{\r\n uint_fast16_t uiZ64;\r\n int_fast8_t shiftDist;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n uiZ64 = 0;\r\n if ( a ) {\r\n shiftDist = softfloat_countLeadingZeros32( a );\r\n uiZ64 = 0x401E - shiftDist;\r\n a <<= shiftDist;\r\n }\r\n uZ.s.signExp = uiZ64;\r\n uZ.s.signif = (uint_fast64_t) a<<32;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/ui32_to_extF80.c ****/\n/**** start inlining ../../source/ui32_to_extF80M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )\r\n{\r\n\r\n *zPtr = ui32_to_extF80( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )\r\n{\r\n struct extFloat80M *zSPtr;\r\n uint_fast16_t uiZ64;\r\n uint64_t sigZ;\r\n int_fast8_t shiftDist;\r\n\r\n zSPtr = (struct extFloat80M *) zPtr;\r\n uiZ64 = 0;\r\n sigZ = 0;\r\n if ( a ) {\r\n shiftDist = softfloat_countLeadingZeros32( a );\r\n uiZ64 = packToExtF80UI64( 0, 0x401E - shiftDist );\r\n sigZ = (uint64_t) (a<signExp = uiZ64;\r\n zSPtr->signif = sigZ;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/ui32_to_extF80M.c ****/\n/**** start inlining ../../source/ui32_to_f128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t ui32_to_f128( uint32_t a )\r\n{\r\n uint_fast64_t uiZ64;\r\n int_fast8_t shiftDist;\r\n union ui128_f128 uZ;\r\n\r\n uiZ64 = 0;\r\n if ( a ) {\r\n shiftDist = softfloat_countLeadingZeros32( a ) + 17;\r\n uiZ64 =\r\n packToF128UI64(\r\n 0, 0x402E - shiftDist, (uint_fast64_t) a<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid ui32_to_f128M( uint32_t a, float128_t *zPtr )\r\n{\r\n\r\n *zPtr = ui32_to_f128( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid ui32_to_f128M( uint32_t a, float128_t *zPtr )\r\n{\r\n uint32_t *zWPtr, uiZ96, uiZ64;\r\n int_fast8_t shiftDist;\r\n uint64_t normA;\r\n\r\n zWPtr = (uint32_t *) zPtr;\r\n uiZ96 = 0;\r\n uiZ64 = 0;\r\n if ( a ) {\r\n shiftDist = softfloat_countLeadingZeros32( a ) + 17;\r\n normA = (uint64_t) a<>32 );\r\n uiZ64 = normA;\r\n }\r\n zWPtr[indexWord( 4, 3 )] = uiZ96;\r\n zWPtr[indexWord( 4, 2 )] = uiZ64;\r\n zWPtr[indexWord( 4, 1 )] = 0;\r\n zWPtr[indexWord( 4, 0 )] = 0;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/ui32_to_f128M.c ****/\n/**** start inlining ../../source/ui64_to_f16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t ui64_to_f16( uint64_t a )\r\n{\r\n int_fast8_t shiftDist;\r\n union ui16_f16 u;\r\n uint_fast16_t sig;\r\n\r\n shiftDist = softfloat_countLeadingZeros64( a ) - 53;\r\n if ( 0 <= shiftDist ) {\r\n u.ui =\r\n a ? packToF16UI(\r\n 0, 0x18 - shiftDist, (uint_fast16_t) a<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t ui64_to_f32( uint64_t a )\r\n{\r\n int_fast8_t shiftDist;\r\n union ui32_f32 u;\r\n uint_fast32_t sig;\r\n\r\n shiftDist = softfloat_countLeadingZeros64( a ) - 40;\r\n if ( 0 <= shiftDist ) {\r\n u.ui =\r\n a ? packToF32UI(\r\n 0, 0x95 - shiftDist, (uint_fast32_t) a<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat64_t ui64_to_f64( uint64_t a )\r\n{\r\n union ui64_f64 uZ;\r\n\r\n if ( ! a ) {\r\n uZ.ui = 0;\r\n return uZ.f;\r\n }\r\n if ( a & UINT64_C( 0x8000000000000000 ) ) {\r\n return\r\n softfloat_roundPackToF64(\r\n 0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) );\r\n } else {\r\n return softfloat_normRoundPackToF64( 0, 0x43C, a );\r\n }\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/ui64_to_f64.c ****/\n/**** start inlining ../../source/ui64_to_extF80.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t ui64_to_extF80( uint64_t a )\r\n{\r\n uint_fast16_t uiZ64;\r\n int_fast8_t shiftDist;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n uiZ64 = 0;\r\n if ( a ) {\r\n shiftDist = softfloat_countLeadingZeros64( a );\r\n uiZ64 = 0x403E - shiftDist;\r\n a <<= shiftDist;\r\n }\r\n uZ.s.signExp = uiZ64;\r\n uZ.s.signif = a;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/ui64_to_extF80.c ****/\n/**** start inlining ../../source/ui64_to_extF80M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )\r\n{\r\n\r\n *zPtr = ui64_to_extF80( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )\r\n{\r\n struct extFloat80M *zSPtr;\r\n uint_fast16_t uiZ64;\r\n uint64_t sigZ;\r\n int_fast8_t shiftDist;\r\n\r\n zSPtr = (struct extFloat80M *) zPtr;\r\n uiZ64 = 0;\r\n sigZ = 0;\r\n if ( a ) {\r\n shiftDist = softfloat_countLeadingZeros64( a );\r\n uiZ64 = packToExtF80UI64( 0, 0x403E - shiftDist );\r\n sigZ = a<signExp = uiZ64;\r\n zSPtr->signif = sigZ;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/ui64_to_extF80M.c ****/\n/**** start inlining ../../source/ui64_to_f128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t ui64_to_f128( uint64_t a )\r\n{\r\n uint_fast64_t uiZ64, uiZ0;\r\n int_fast8_t shiftDist;\r\n struct uint128 zSig;\r\n union ui128_f128 uZ;\r\n\r\n if ( ! a ) {\r\n uiZ64 = 0;\r\n uiZ0 = 0;\r\n } else {\r\n shiftDist = softfloat_countLeadingZeros64( a ) + 49;\r\n if ( 64 <= shiftDist ) {\r\n zSig.v64 = a<<(shiftDist - 64);\r\n zSig.v0 = 0;\r\n } else {\r\n zSig = softfloat_shortShiftLeft128( 0, a, shiftDist );\r\n }\r\n uiZ64 = packToF128UI64( 0, 0x406E - shiftDist, zSig.v64 );\r\n uiZ0 = zSig.v0;\r\n }\r\n uZ.ui.v64 = uiZ64;\r\n uZ.ui.v0 = uiZ0;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/ui64_to_f128.c ****/\n/**** start inlining ../../source/ui64_to_f128M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All Rights Reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid ui64_to_f128M( uint64_t a, float128_t *zPtr )\r\n{\r\n\r\n *zPtr = ui64_to_f128( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid ui64_to_f128M( uint64_t a, float128_t *zPtr )\r\n{\r\n uint32_t *zWPtr, uiZ96, uiZ64;\r\n uint_fast8_t shiftDist;\r\n uint32_t *ptr;\r\n\r\n zWPtr = (uint32_t *) zPtr;\r\n uiZ96 = 0;\r\n uiZ64 = 0;\r\n zWPtr[indexWord( 4, 1 )] = 0;\r\n zWPtr[indexWord( 4, 0 )] = 0;\r\n if ( a ) {\r\n shiftDist = softfloat_countLeadingZeros64( a ) + 17;\r\n if ( shiftDist < 32 ) {\r\n ptr = zWPtr + indexMultiwordHi( 4, 3 );\r\n ptr[indexWord( 3, 2 )] = 0;\r\n ptr[indexWord( 3, 1 )] = a>>32;\r\n ptr[indexWord( 3, 0 )] = a;\r\n softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );\r\n ptr[indexWordHi( 3 )] =\r\n packToF128UI96( 0, 0x404E - shiftDist, ptr[indexWordHi( 3 )] );\r\n return;\r\n }\r\n a <<= shiftDist - 32;\r\n uiZ96 = packToF128UI96( 0, 0x404E - shiftDist, a>>32 );\r\n uiZ64 = a;\r\n }\r\n zWPtr[indexWord( 4, 3 )] = uiZ96;\r\n zWPtr[indexWord( 4, 2 )] = uiZ64;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/ui64_to_f128M.c ****/\n/**** start inlining ../../source/i32_to_f16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t i32_to_f16( int32_t a )\r\n{\r\n bool sign;\r\n uint_fast32_t absA;\r\n int_fast8_t shiftDist;\r\n union ui16_f16 u;\r\n uint_fast16_t sig;\r\n\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;\r\n shiftDist = softfloat_countLeadingZeros32( absA ) - 21;\r\n if ( 0 <= shiftDist ) {\r\n u.ui =\r\n a ? packToF16UI(\r\n sign, 0x18 - shiftDist, (uint_fast16_t) absA<>(-shiftDist)\r\n | ((uint32_t) (absA<<(shiftDist & 31)) != 0)\r\n : (uint_fast16_t) absA<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t i32_to_f32( int32_t a )\r\n{\r\n bool sign;\r\n union ui32_f32 uZ;\r\n uint_fast32_t absA;\r\n\r\n sign = (a < 0);\r\n if ( ! (a & 0x7FFFFFFF) ) {\r\n uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0;\r\n return uZ.f;\r\n }\r\n absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;\r\n return softfloat_normRoundPackToF32( sign, 0x9C, absA );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/i32_to_f32.c ****/\n/**** start inlining ../../source/i32_to_f64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat64_t i32_to_f64( int32_t a )\r\n{\r\n uint_fast64_t uiZ;\r\n bool sign;\r\n uint_fast32_t absA;\r\n int_fast8_t shiftDist;\r\n union ui64_f64 uZ;\r\n\r\n if ( ! a ) {\r\n uiZ = 0;\r\n } else {\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;\r\n shiftDist = softfloat_countLeadingZeros32( absA ) + 21;\r\n uiZ =\r\n packToF64UI(\r\n sign, 0x432 - shiftDist, (uint_fast64_t) absA<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t i32_to_extF80( int32_t a )\r\n{\r\n uint_fast16_t uiZ64;\r\n uint_fast32_t absA;\r\n bool sign;\r\n int_fast8_t shiftDist;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n uiZ64 = 0;\r\n absA = 0;\r\n if ( a ) {\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;\r\n shiftDist = softfloat_countLeadingZeros32( absA );\r\n uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist );\r\n absA <<= shiftDist;\r\n }\r\n uZ.s.signExp = uiZ64;\r\n uZ.s.signif = (uint_fast64_t) absA<<32;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/i32_to_extF80.c ****/\n/**** start inlining ../../source/i32_to_extF80M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid i32_to_extF80M( int32_t a, extFloat80_t *zPtr )\r\n{\r\n\r\n *zPtr = i32_to_extF80( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid i32_to_extF80M( int32_t a, extFloat80_t *zPtr )\r\n{\r\n struct extFloat80M *zSPtr;\r\n uint_fast16_t uiZ64;\r\n uint64_t sigZ;\r\n bool sign;\r\n uint32_t absA;\r\n int_fast8_t shiftDist;\r\n\r\n zSPtr = (struct extFloat80M *) zPtr;\r\n uiZ64 = 0;\r\n sigZ = 0;\r\n if ( a ) {\r\n sign = (a < 0);\r\n absA = sign ? -(uint32_t) a : (uint32_t) a;\r\n shiftDist = softfloat_countLeadingZeros32( absA );\r\n uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist );\r\n sigZ = (uint64_t) (absA<signExp = uiZ64;\r\n zSPtr->signif = sigZ;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/i32_to_extF80M.c ****/\n/**** start inlining ../../source/i32_to_f128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t i32_to_f128( int32_t a )\r\n{\r\n uint_fast64_t uiZ64;\r\n bool sign;\r\n uint_fast32_t absA;\r\n int_fast8_t shiftDist;\r\n union ui128_f128 uZ;\r\n\r\n uiZ64 = 0;\r\n if ( a ) {\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;\r\n shiftDist = softfloat_countLeadingZeros32( absA ) + 17;\r\n uiZ64 =\r\n packToF128UI64(\r\n sign, 0x402E - shiftDist, (uint_fast64_t) absA<\r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid i32_to_f128M( int32_t a, float128_t *zPtr )\r\n{\r\n\r\n *zPtr = i32_to_f128( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid i32_to_f128M( int32_t a, float128_t *zPtr )\r\n{\r\n uint32_t *zWPtr;\r\n uint32_t uiZ96, uiZ64;\r\n bool sign;\r\n uint32_t absA;\r\n int_fast8_t shiftDist;\r\n uint64_t normAbsA;\r\n\r\n zWPtr = (uint32_t *) zPtr;\r\n uiZ96 = 0;\r\n uiZ64 = 0;\r\n if ( a ) {\r\n sign = (a < 0);\r\n absA = sign ? -(uint32_t) a : (uint32_t) a;\r\n shiftDist = softfloat_countLeadingZeros32( absA ) + 17;\r\n normAbsA = (uint64_t) absA<>32 );\r\n uiZ64 = normAbsA;\r\n }\r\n zWPtr[indexWord( 4, 3 )] = uiZ96;\r\n zWPtr[indexWord( 4, 2 )] = uiZ64;\r\n zWPtr[indexWord( 4, 1 )] = 0;\r\n zWPtr[indexWord( 4, 0 )] = 0;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/i32_to_f128M.c ****/\n/**** start inlining ../../source/i64_to_f16.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t i64_to_f16( int64_t a )\r\n{\r\n bool sign;\r\n uint_fast64_t absA;\r\n int_fast8_t shiftDist;\r\n union ui16_f16 u;\r\n uint_fast16_t sig;\r\n\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;\r\n shiftDist = softfloat_countLeadingZeros64( absA ) - 53;\r\n if ( 0 <= shiftDist ) {\r\n u.ui =\r\n a ? packToF16UI(\r\n sign, 0x18 - shiftDist, (uint_fast16_t) absA<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t i64_to_f32( int64_t a )\r\n{\r\n bool sign;\r\n uint_fast64_t absA;\r\n int_fast8_t shiftDist;\r\n union ui32_f32 u;\r\n uint_fast32_t sig;\r\n\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;\r\n shiftDist = softfloat_countLeadingZeros64( absA ) - 40;\r\n if ( 0 <= shiftDist ) {\r\n u.ui =\r\n a ? packToF32UI(\r\n sign, 0x95 - shiftDist, (uint_fast32_t) absA<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat64_t i64_to_f64( int64_t a )\r\n{\r\n bool sign;\r\n union ui64_f64 uZ;\r\n uint_fast64_t absA;\r\n\r\n sign = (a < 0);\r\n if ( ! (a & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {\r\n uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0;\r\n return uZ.f;\r\n }\r\n absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;\r\n return softfloat_normRoundPackToF64( sign, 0x43C, absA );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/i64_to_f64.c ****/\n/**** start inlining ../../source/i64_to_extF80.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t i64_to_extF80( int64_t a )\r\n{\r\n uint_fast16_t uiZ64;\r\n uint_fast64_t absA;\r\n bool sign;\r\n int_fast8_t shiftDist;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n uiZ64 = 0;\r\n absA = 0;\r\n if ( a ) {\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;\r\n shiftDist = softfloat_countLeadingZeros64( absA );\r\n uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist );\r\n absA <<= shiftDist;\r\n }\r\n uZ.s.signExp = uiZ64;\r\n uZ.s.signif = absA;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/i64_to_extF80.c ****/\n/**** start inlining ../../source/i64_to_extF80M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid i64_to_extF80M( int64_t a, extFloat80_t *zPtr )\r\n{\r\n\r\n *zPtr = i64_to_extF80( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid i64_to_extF80M( int64_t a, extFloat80_t *zPtr )\r\n{\r\n struct extFloat80M *zSPtr;\r\n uint_fast16_t uiZ64;\r\n uint64_t sigZ;\r\n bool sign;\r\n uint64_t absA;\r\n int_fast8_t shiftDist;\r\n\r\n zSPtr = (struct extFloat80M *) zPtr;\r\n uiZ64 = 0;\r\n sigZ = 0;\r\n if ( a ) {\r\n sign = (a < 0);\r\n absA = sign ? -(uint64_t) a : (uint64_t) a;\r\n shiftDist = softfloat_countLeadingZeros64( absA );\r\n uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist );\r\n sigZ = absA<signExp = uiZ64;\r\n zSPtr->signif = sigZ;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/i64_to_extF80M.c ****/\n/**** start inlining ../../source/i64_to_f128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t i64_to_f128( int64_t a )\r\n{\r\n uint_fast64_t uiZ64, uiZ0;\r\n bool sign;\r\n uint_fast64_t absA;\r\n int_fast8_t shiftDist;\r\n struct uint128 zSig;\r\n union ui128_f128 uZ;\r\n\r\n if ( ! a ) {\r\n uiZ64 = 0;\r\n uiZ0 = 0;\r\n } else {\r\n sign = (a < 0);\r\n absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;\r\n shiftDist = softfloat_countLeadingZeros64( absA ) + 49;\r\n if ( 64 <= shiftDist ) {\r\n zSig.v64 = absA<<(shiftDist - 64);\r\n zSig.v0 = 0;\r\n } else {\r\n zSig = softfloat_shortShiftLeft128( 0, absA, shiftDist );\r\n }\r\n uiZ64 = packToF128UI64( sign, 0x406E - shiftDist, zSig.v64 );\r\n uiZ0 = zSig.v0;\r\n }\r\n uZ.ui.v64 = uiZ64;\r\n uZ.ui.v0 = uiZ0;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/i64_to_f128.c ****/\n/**** start inlining ../../source/i64_to_f128M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid i64_to_f128M( int64_t a, float128_t *zPtr )\r\n{\r\n\r\n *zPtr = i64_to_f128( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid i64_to_f128M( int64_t a, float128_t *zPtr )\r\n{\r\n uint32_t *zWPtr;\r\n uint32_t uiZ96, uiZ64;\r\n bool sign;\r\n uint64_t absA;\r\n uint_fast8_t shiftDist;\r\n uint32_t *ptr;\r\n\r\n zWPtr = (uint32_t *) zPtr;\r\n uiZ96 = 0;\r\n uiZ64 = 0;\r\n zWPtr[indexWord( 4, 1 )] = 0;\r\n zWPtr[indexWord( 4, 0 )] = 0;\r\n if ( a ) {\r\n sign = (a < 0);\r\n absA = sign ? -(uint64_t) a : (uint64_t) a;\r\n shiftDist = softfloat_countLeadingZeros64( absA ) + 17;\r\n if ( shiftDist < 32 ) {\r\n ptr = zWPtr + indexMultiwordHi( 4, 3 );\r\n ptr[indexWord( 3, 2 )] = 0;\r\n ptr[indexWord( 3, 1 )] = absA>>32;\r\n ptr[indexWord( 3, 0 )] = absA;\r\n softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );\r\n ptr[indexWordHi( 3 )] =\r\n packToF128UI96(\r\n sign, 0x404E - shiftDist, ptr[indexWordHi( 3 )] );\r\n return;\r\n }\r\n absA <<= shiftDist - 32;\r\n uiZ96 = packToF128UI96( sign, 0x404E - shiftDist, absA>>32 );\r\n uiZ64 = absA;\r\n }\r\n zWPtr[indexWord( 4, 3 )] = uiZ96;\r\n zWPtr[indexWord( 4, 2 )] = uiZ64;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/i64_to_f128M.c ****/\n/**** start inlining ../../source/f16_to_ui32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nuint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n uint_fast32_t sig32;\r\n int_fast8_t shiftDist;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n frac ? ui32_fromNaN\r\n : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sig32 = frac;\r\n if ( exp ) {\r\n sig32 |= 0x0400;\r\n shiftDist = exp - 0x19;\r\n if ( (0 <= shiftDist) && ! sign ) {\r\n return sig32<\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nuint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n uint_fast32_t sig32;\r\n int_fast8_t shiftDist;\r\n#ifndef SOFTFLOAT_FAST_INT64\r\n uint32_t extSig[3];\r\n#endif\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n frac ? ui64_fromNaN\r\n : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sig32 = frac;\r\n if ( exp ) {\r\n sig32 |= 0x0400;\r\n shiftDist = exp - 0x19;\r\n if ( (0 <= shiftDist) && ! sign ) {\r\n return sig32<>12, (uint_fast64_t) sig32<<52, roundingMode, exact );\r\n#else\r\n extSig[indexWord( 3, 2 )] = 0;\r\n extSig[indexWord( 3, 1 )] = sig32>>12;\r\n extSig[indexWord( 3, 0 )] = sig32<<20;\r\n return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );\r\n#endif\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_ui64.c ****/\n/**** start inlining ../../source/f16_to_i32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nint_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n int_fast32_t sig32;\r\n int_fast8_t shiftDist;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n frac ? i32_fromNaN\r\n : sign ? i32_fromNegOverflow : i32_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sig32 = frac;\r\n if ( exp ) {\r\n sig32 |= 0x0400;\r\n shiftDist = exp - 0x19;\r\n if ( 0 <= shiftDist ) {\r\n sig32 <<= shiftDist;\r\n return sign ? -sig32 : sig32;\r\n }\r\n shiftDist = exp - 0x0D;\r\n if ( 0 < shiftDist ) sig32 <<= shiftDist;\r\n }\r\n return\r\n softfloat_roundToI32(\r\n sign, (uint_fast32_t) sig32, roundingMode, exact );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_i32.c ****/\n/**** start inlining ../../source/f16_to_i64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the\r\nUniversity of California. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nint_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n int_fast32_t sig32;\r\n int_fast8_t shiftDist;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n frac ? i64_fromNaN\r\n : sign ? i64_fromNegOverflow : i64_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sig32 = frac;\r\n if ( exp ) {\r\n sig32 |= 0x0400;\r\n shiftDist = exp - 0x19;\r\n if ( 0 <= shiftDist ) {\r\n sig32 <<= shiftDist;\r\n return sign ? -sig32 : sig32;\r\n }\r\n shiftDist = exp - 0x0D;\r\n if ( 0 < shiftDist ) sig32 <<= shiftDist;\r\n }\r\n return\r\n softfloat_roundToI32(\r\n sign, (uint_fast32_t) sig32, roundingMode, exact );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_i64.c ****/\n/**** start inlining ../../source/f16_to_ui32_r_minMag.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nuint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n int_fast8_t shiftDist;\r\n bool sign;\r\n uint_fast32_t alignedSig;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n shiftDist = exp - 0x0F;\r\n if ( shiftDist < 0 ) {\r\n if ( exact && (exp | frac) ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return 0;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sign = signF16UI( uiA );\r\n if ( sign || (exp == 0x1F) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n (exp == 0x1F) && frac ? ui32_fromNaN\r\n : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n alignedSig = (uint_fast32_t) (frac | 0x0400)<>10;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_ui32_r_minMag.c ****/\n/**** start inlining ../../source/f16_to_ui64_r_minMag.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nuint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n int_fast8_t shiftDist;\r\n bool sign;\r\n uint_fast32_t alignedSig;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n shiftDist = exp - 0x0F;\r\n if ( shiftDist < 0 ) {\r\n if ( exact && (exp | frac) ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return 0;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sign = signF16UI( uiA );\r\n if ( sign || (exp == 0x1F) ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n (exp == 0x1F) && frac ? ui64_fromNaN\r\n : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n alignedSig = (uint_fast32_t) (frac | 0x0400)<>10;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_ui64_r_minMag.c ****/\n/**** start inlining ../../source/f16_to_i32_r_minMag.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nint_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n int_fast8_t shiftDist;\r\n bool sign;\r\n int_fast32_t alignedSig;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n shiftDist = exp - 0x0F;\r\n if ( shiftDist < 0 ) {\r\n if ( exact && (exp | frac) ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return 0;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sign = signF16UI( uiA );\r\n if ( exp == 0x1F ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n (exp == 0x1F) && frac ? i32_fromNaN\r\n : sign ? i32_fromNegOverflow : i32_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n alignedSig = (int_fast32_t) (frac | 0x0400)<>= 10;\r\n return sign ? -alignedSig : alignedSig;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_i32_r_minMag.c ****/\n/**** start inlining ../../source/f16_to_i64_r_minMag.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nint_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n int_fast8_t shiftDist;\r\n bool sign;\r\n int_fast32_t alignedSig;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n shiftDist = exp - 0x0F;\r\n if ( shiftDist < 0 ) {\r\n if ( exact && (exp | frac) ) {\r\n softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n return 0;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n sign = signF16UI( uiA );\r\n if ( exp == 0x1F ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n return\r\n (exp == 0x1F) && frac ? i64_fromNaN\r\n : sign ? i64_fromNegOverflow : i64_fromPosOverflow;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n alignedSig = (int_fast32_t) (frac | 0x0400)<>= 10;\r\n return sign ? -alignedSig : alignedSig;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_i64_r_minMag.c ****/\n/**** start inlining ../../source/f16_to_f32.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat32_t f16_to_f32( float16_t a )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n struct commonNaN commonNaN;\r\n uint_fast32_t uiZ;\r\n struct exp8_sig16 normExpSig;\r\n union ui32_f32 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n if ( frac ) {\r\n softfloat_f16UIToCommonNaN( uiA, &commonNaN );\r\n uiZ = softfloat_commonNaNToF32UI( &commonNaN );\r\n } else {\r\n uiZ = packToF32UI( sign, 0xFF, 0 );\r\n }\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! exp ) {\r\n if ( ! frac ) {\r\n uiZ = packToF32UI( sign, 0, 0 );\r\n goto uiZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( frac );\r\n exp = normExpSig.exp - 1;\r\n frac = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uiZ = packToF32UI( sign, exp + 0x70, (uint_fast32_t) frac<<13 );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_f32.c ****/\n/**** start inlining ../../source/f16_to_f64.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat64_t f16_to_f64( float16_t a )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n struct commonNaN commonNaN;\r\n uint_fast64_t uiZ;\r\n struct exp8_sig16 normExpSig;\r\n union ui64_f64 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n if ( frac ) {\r\n softfloat_f16UIToCommonNaN( uiA, &commonNaN );\r\n uiZ = softfloat_commonNaNToF64UI( &commonNaN );\r\n } else {\r\n uiZ = packToF64UI( sign, 0x7FF, 0 );\r\n }\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! exp ) {\r\n if ( ! frac ) {\r\n uiZ = packToF64UI( sign, 0, 0 );\r\n goto uiZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( frac );\r\n exp = normExpSig.exp - 1;\r\n frac = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uiZ = packToF64UI( sign, exp + 0x3F0, (uint_fast64_t) frac<<42 );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_f64.c ****/\n/**** start inlining ../../source/f16_to_extF80.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextFloat80_t f16_to_extF80( float16_t a )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n struct commonNaN commonNaN;\r\n struct uint128 uiZ;\r\n uint_fast16_t uiZ64;\r\n uint_fast64_t uiZ0;\r\n struct exp8_sig16 normExpSig;\r\n union { struct extFloat80M s; extFloat80_t f; } uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n if ( frac ) {\r\n softfloat_f16UIToCommonNaN( uiA, &commonNaN );\r\n uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );\r\n uiZ64 = uiZ.v64;\r\n uiZ0 = uiZ.v0;\r\n } else {\r\n uiZ64 = packToExtF80UI64( sign, 0x7FFF );\r\n uiZ0 = UINT64_C( 0x8000000000000000 );\r\n }\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! exp ) {\r\n if ( ! frac ) {\r\n uiZ64 = packToExtF80UI64( sign, 0 );\r\n uiZ0 = 0;\r\n goto uiZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( frac );\r\n exp = normExpSig.exp;\r\n frac = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 );\r\n uiZ0 = (uint_fast64_t) (frac | 0x0400)<<53;\r\n uiZ:\r\n uZ.s.signExp = uiZ64;\r\n uZ.s.signif = uiZ0;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_extF80.c ****/\n/**** start inlining ../../source/f16_to_extF80M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid f16_to_extF80M( float16_t a, extFloat80_t *zPtr )\r\n{\r\n\r\n *zPtr = f16_to_extF80( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid f16_to_extF80M( float16_t a, extFloat80_t *zPtr )\r\n{\r\n struct extFloat80M *zSPtr;\r\n union ui16_f16 uA;\r\n uint16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint16_t frac;\r\n struct commonNaN commonNaN;\r\n uint_fast16_t uiZ64;\r\n uint32_t uiZ32;\r\n struct exp8_sig16 normExpSig;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n zSPtr = (struct extFloat80M *) zPtr;\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n if ( frac ) {\r\n softfloat_f16UIToCommonNaN( uiA, &commonNaN );\r\n softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );\r\n return;\r\n }\r\n uiZ64 = packToExtF80UI64( sign, 0x7FFF );\r\n uiZ32 = 0x80000000;\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! exp ) {\r\n if ( ! frac ) {\r\n uiZ64 = packToExtF80UI64( sign, 0 );\r\n uiZ32 = 0;\r\n goto uiZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( frac );\r\n exp = normExpSig.exp;\r\n frac = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 );\r\n uiZ32 = 0x80000000 | (uint32_t) frac<<21;\r\n uiZ:\r\n zSPtr->signExp = uiZ64;\r\n zSPtr->signif = (uint64_t) uiZ32<<32;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/f16_to_extF80M.c ****/\n/**** start inlining ../../source/f16_to_f128.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat128_t f16_to_f128( float16_t a )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint_fast16_t frac;\r\n struct commonNaN commonNaN;\r\n struct uint128 uiZ;\r\n struct exp8_sig16 normExpSig;\r\n union ui128_f128 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n if ( frac ) {\r\n softfloat_f16UIToCommonNaN( uiA, &commonNaN );\r\n uiZ = softfloat_commonNaNToF128UI( &commonNaN );\r\n } else {\r\n uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );\r\n uiZ.v0 = 0;\r\n }\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! exp ) {\r\n if ( ! frac ) {\r\n uiZ.v64 = packToF128UI64( sign, 0, 0 );\r\n uiZ.v0 = 0;\r\n goto uiZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( frac );\r\n exp = normExpSig.exp - 1;\r\n frac = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uiZ.v64 = packToF128UI64( sign, exp + 0x3FF0, (uint_fast64_t) frac<<38 );\r\n uiZ.v0 = 0;\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_to_f128.c ****/\n/**** start inlining ../../source/f16_to_f128M.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\n#ifdef SOFTFLOAT_FAST_INT64\r\n\r\nvoid f16_to_f128M( float16_t a, float128_t *zPtr )\r\n{\r\n\r\n *zPtr = f16_to_f128( a );\r\n\r\n}\r\n\r\n#else\r\n\r\nvoid f16_to_f128M( float16_t a, float128_t *zPtr )\r\n{\r\n uint32_t *zWPtr;\r\n union ui16_f16 uA;\r\n uint16_t uiA;\r\n bool sign;\r\n int_fast8_t exp;\r\n uint16_t frac;\r\n struct commonNaN commonNaN;\r\n uint32_t uiZ96;\r\n struct exp8_sig16 normExpSig;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n zWPtr = (uint32_t *) zPtr;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n sign = signF16UI( uiA );\r\n exp = expF16UI( uiA );\r\n frac = fracF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp == 0x1F ) {\r\n if ( frac ) {\r\n softfloat_f16UIToCommonNaN( uiA, &commonNaN );\r\n softfloat_commonNaNToF128M( &commonNaN, zWPtr );\r\n return;\r\n }\r\n uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! exp ) {\r\n if ( ! frac ) {\r\n uiZ96 = packToF128UI96( sign, 0, 0 );\r\n goto uiZ;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( frac );\r\n exp = normExpSig.exp - 1;\r\n frac = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uiZ96 = packToF128UI96( sign, exp + 0x3FF0, (uint32_t) frac<<6 );\r\n uiZ:\r\n zWPtr[indexWord( 4, 3 )] = uiZ96;\r\n zWPtr[indexWord( 4, 2 )] = 0;\r\n zWPtr[indexWord( 4, 1 )] = 0;\r\n zWPtr[indexWord( 4, 0 )] = 0;\r\n\r\n}\r\n\r\n#endif\r\n\r\n/**** ended inlining ../../source/f16_to_f128M.c ****/\n/**** start inlining ../../source/f16_roundToInt.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n int_fast8_t exp;\r\n uint_fast16_t uiZ, lastBitMask, roundBitsMask;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n exp = expF16UI( uiA );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( exp <= 0xE ) {\r\n if ( !(uint16_t) (uiA<<1) ) return a;\r\n if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n uiZ = uiA & packToF16UI( 1, 0, 0 );\r\n switch ( roundingMode ) {\r\n case softfloat_round_near_even:\r\n if ( !fracF16UI( uiA ) ) break;\r\n case softfloat_round_near_maxMag:\r\n if ( exp == 0xE ) uiZ |= packToF16UI( 0, 0xF, 0 );\r\n break;\r\n case softfloat_round_min:\r\n if ( uiZ ) uiZ = packToF16UI( 1, 0xF, 0 );\r\n break;\r\n case softfloat_round_max:\r\n if ( !uiZ ) uiZ = packToF16UI( 0, 0xF, 0 );\r\n break;\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n case softfloat_round_odd:\r\n uiZ |= packToF16UI( 0, 0xF, 0 );\r\n break;\r\n#endif\r\n }\r\n goto uiZ;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( 0x19 <= exp ) {\r\n if ( (exp == 0x1F) && fracF16UI( uiA ) ) {\r\n uiZ = softfloat_propagateNaNF16UI( uiA, 0 );\r\n goto uiZ;\r\n }\r\n return a;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uiZ = uiA;\r\n lastBitMask = (uint_fast16_t) 1<<(0x19 - exp);\r\n roundBitsMask = lastBitMask - 1;\r\n if ( roundingMode == softfloat_round_near_maxMag ) {\r\n uiZ += lastBitMask>>1;\r\n } else if ( roundingMode == softfloat_round_near_even ) {\r\n uiZ += lastBitMask>>1;\r\n if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;\r\n } else if (\r\n roundingMode\r\n == (signF16UI( uiZ ) ? softfloat_round_min : softfloat_round_max)\r\n ) {\r\n uiZ += roundBitsMask;\r\n }\r\n uiZ &= ~roundBitsMask;\r\n if ( uiZ != uiA ) {\r\n#ifdef SOFTFLOAT_ROUND_ODD\r\n if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;\r\n#endif\r\n if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;\r\n }\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_roundToInt.c ****/\n/**** start inlining ../../source/f16_add.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t f16_add( float16_t a, float16_t b )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n union ui16_f16 uB;\r\n uint_fast16_t uiB;\r\n#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)\r\n float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );\r\n#endif\r\n\r\n uA.f = a;\r\n uiA = uA.ui;\r\n uB.f = b;\r\n uiB = uB.ui;\r\n#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)\r\n if ( signF16UI( uiA ^ uiB ) ) {\r\n return softfloat_subMagsF16( uiA, uiB );\r\n } else {\r\n return softfloat_addMagsF16( uiA, uiB );\r\n }\r\n#else\r\n magsFuncPtr =\r\n signF16UI( uiA ^ uiB ) ? softfloat_subMagsF16 : softfloat_addMagsF16;\r\n return (*magsFuncPtr)( uiA, uiB );\r\n#endif\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_add.c ****/\n/**** start inlining ../../source/f16_sub.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t f16_sub( float16_t a, float16_t b )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n union ui16_f16 uB;\r\n uint_fast16_t uiB;\r\n#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)\r\n float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );\r\n#endif\r\n\r\n uA.f = a;\r\n uiA = uA.ui;\r\n uB.f = b;\r\n uiB = uB.ui;\r\n#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)\r\n if ( signF16UI( uiA ^ uiB ) ) {\r\n return softfloat_addMagsF16( uiA, uiB );\r\n } else {\r\n return softfloat_subMagsF16( uiA, uiB );\r\n }\r\n#else\r\n magsFuncPtr =\r\n signF16UI( uiA ^ uiB ) ? softfloat_addMagsF16 : softfloat_subMagsF16;\r\n return (*magsFuncPtr)( uiA, uiB );\r\n#endif\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_sub.c ****/\n/**** start inlining ../../source/f16_mul.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t f16_mul( float16_t a, float16_t b )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool signA;\r\n int_fast8_t expA;\r\n uint_fast16_t sigA;\r\n union ui16_f16 uB;\r\n uint_fast16_t uiB;\r\n bool signB;\r\n int_fast8_t expB;\r\n uint_fast16_t sigB;\r\n bool signZ;\r\n uint_fast16_t magBits;\r\n struct exp8_sig16 normExpSig;\r\n int_fast8_t expZ;\r\n uint_fast32_t sig32Z;\r\n uint_fast16_t sigZ, uiZ;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n signA = signF16UI( uiA );\r\n expA = expF16UI( uiA );\r\n sigA = fracF16UI( uiA );\r\n uB.f = b;\r\n uiB = uB.ui;\r\n signB = signF16UI( uiB );\r\n expB = expF16UI( uiB );\r\n sigB = fracF16UI( uiB );\r\n signZ = signA ^ signB;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0x1F ) {\r\n if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;\r\n magBits = expB | sigB;\r\n goto infArg;\r\n }\r\n if ( expB == 0x1F ) {\r\n if ( sigB ) goto propagateNaN;\r\n magBits = expA | sigA;\r\n goto infArg;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expA ) {\r\n if ( ! sigA ) goto zero;\r\n normExpSig = softfloat_normSubnormalF16Sig( sigA );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n if ( ! expB ) {\r\n if ( ! sigB ) goto zero;\r\n normExpSig = softfloat_normSubnormalF16Sig( sigB );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expZ = expA + expB - 0xF;\r\n sigA = (sigA | 0x0400)<<4;\r\n sigB = (sigB | 0x0400)<<5;\r\n sig32Z = (uint_fast32_t) sigA * sigB;\r\n sigZ = sig32Z>>16;\r\n if ( sig32Z & 0xFFFF ) sigZ |= 1;\r\n if ( sigZ < 0x4000 ) {\r\n --expZ;\r\n sigZ <<= 1;\r\n }\r\n return softfloat_roundPackToF16( signZ, expZ, sigZ );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF16UI( uiA, uiB );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n infArg:\r\n if ( ! magBits ) {\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF16UI;\r\n } else {\r\n uiZ = packToF16UI( signZ, 0x1F, 0 );\r\n }\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n zero:\r\n uiZ = packToF16UI( signZ, 0, 0 );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_mul.c ****/\n/**** start inlining ../../source/f16_mulAdd.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t f16_mulAdd( float16_t a, float16_t b, float16_t c )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n union ui16_f16 uB;\r\n uint_fast16_t uiB;\r\n union ui16_f16 uC;\r\n uint_fast16_t uiC;\r\n\r\n uA.f = a;\r\n uiA = uA.ui;\r\n uB.f = b;\r\n uiB = uB.ui;\r\n uC.f = c;\r\n uiC = uC.ui;\r\n return softfloat_mulAddF16( uiA, uiB, uiC, 0 );\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_mulAdd.c ****/\n/**** start inlining ../../source/f16_div.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nextern const uint16_t softfloat_approxRecip_1k0s[];\r\nextern const uint16_t softfloat_approxRecip_1k1s[];\r\n\r\nfloat16_t f16_div( float16_t a, float16_t b )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool signA;\r\n int_fast8_t expA;\r\n uint_fast16_t sigA;\r\n union ui16_f16 uB;\r\n uint_fast16_t uiB;\r\n bool signB;\r\n int_fast8_t expB;\r\n uint_fast16_t sigB;\r\n bool signZ;\r\n struct exp8_sig16 normExpSig;\r\n int_fast8_t expZ;\r\n#ifdef SOFTFLOAT_FAST_DIV32TO16\r\n uint_fast32_t sig32A;\r\n uint_fast16_t sigZ;\r\n#else\r\n int index;\r\n uint16_t r0;\r\n uint_fast16_t sigZ, rem;\r\n#endif\r\n uint_fast16_t uiZ;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n signA = signF16UI( uiA );\r\n expA = expF16UI( uiA );\r\n sigA = fracF16UI( uiA );\r\n uB.f = b;\r\n uiB = uB.ui;\r\n signB = signF16UI( uiB );\r\n expB = expF16UI( uiB );\r\n sigB = fracF16UI( uiB );\r\n signZ = signA ^ signB;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0x1F ) {\r\n if ( sigA ) goto propagateNaN;\r\n if ( expB == 0x1F ) {\r\n if ( sigB ) goto propagateNaN;\r\n goto invalid;\r\n }\r\n goto infinity;\r\n }\r\n if ( expB == 0x1F ) {\r\n if ( sigB ) goto propagateNaN;\r\n goto zero;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expB ) {\r\n if ( ! sigB ) {\r\n if ( ! (expA | sigA) ) goto invalid;\r\n softfloat_raiseFlags( softfloat_flag_infinite );\r\n goto infinity;\r\n }\r\n normExpSig = softfloat_normSubnormalF16Sig( sigB );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n if ( ! expA ) {\r\n if ( ! sigA ) goto zero;\r\n normExpSig = softfloat_normSubnormalF16Sig( sigA );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n expZ = expA - expB + 0xE;\r\n sigA |= 0x0400;\r\n sigB |= 0x0400;\r\n#ifdef SOFTFLOAT_FAST_DIV32TO16\r\n if ( sigA < sigB ) {\r\n --expZ;\r\n sig32A = (uint_fast32_t) sigA<<15;\r\n } else {\r\n sig32A = (uint_fast32_t) sigA<<14;\r\n }\r\n sigZ = sig32A / sigB;\r\n if ( ! (sigZ & 7) ) sigZ |= ((uint_fast32_t) sigB * sigZ != sig32A);\r\n#else\r\n if ( sigA < sigB ) {\r\n --expZ;\r\n sigA <<= 5;\r\n } else {\r\n sigA <<= 4;\r\n }\r\n index = sigB>>6 & 0xF;\r\n r0 = softfloat_approxRecip_1k0s[index]\r\n - (((uint_fast32_t) softfloat_approxRecip_1k1s[index]\r\n * (sigB & 0x3F))\r\n >>10);\r\n sigZ = ((uint_fast32_t) sigA * r0)>>16;\r\n rem = (sigA<<10) - sigZ * sigB;\r\n sigZ += (rem * (uint_fast32_t) r0)>>26;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n ++sigZ;\r\n if ( ! (sigZ & 7) ) {\r\n sigZ &= ~1;\r\n rem = (sigA<<10) - sigZ * sigB;\r\n if ( rem & 0x8000 ) {\r\n sigZ -= 2;\r\n } else {\r\n if ( rem ) sigZ |= 1;\r\n }\r\n }\r\n#endif\r\n return softfloat_roundPackToF16( signZ, expZ, sigZ );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF16UI( uiA, uiB );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n invalid:\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF16UI;\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n infinity:\r\n uiZ = packToF16UI( signZ, 0x1F, 0 );\r\n goto uiZ;\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n zero:\r\n uiZ = packToF16UI( signZ, 0, 0 );\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_div.c ****/\n/**** start inlining ../../source/f16_rem.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include \r\n#include \r\n/**** skipping file: platform.h ****/\n/**** skipping file: internals.h ****/\n/**** skipping file: specialize.h ****/\n/**** skipping file: softfloat.h ****/\n\r\nfloat16_t f16_rem( float16_t a, float16_t b )\r\n{\r\n union ui16_f16 uA;\r\n uint_fast16_t uiA;\r\n bool signA;\r\n int_fast8_t expA;\r\n uint_fast16_t sigA;\r\n union ui16_f16 uB;\r\n uint_fast16_t uiB;\r\n int_fast8_t expB;\r\n uint_fast16_t sigB;\r\n struct exp8_sig16 normExpSig;\r\n uint16_t rem;\r\n int_fast8_t expDiff;\r\n uint_fast16_t q;\r\n uint32_t recip32, q32;\r\n uint16_t altRem, meanRem;\r\n bool signRem;\r\n uint_fast16_t uiZ;\r\n union ui16_f16 uZ;\r\n\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n uA.f = a;\r\n uiA = uA.ui;\r\n signA = signF16UI( uiA );\r\n expA = expF16UI( uiA );\r\n sigA = fracF16UI( uiA );\r\n uB.f = b;\r\n uiB = uB.ui;\r\n expB = expF16UI( uiB );\r\n sigB = fracF16UI( uiB );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( expA == 0x1F ) {\r\n if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;\r\n goto invalid;\r\n }\r\n if ( expB == 0x1F ) {\r\n if ( sigB ) goto propagateNaN;\r\n return a;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n if ( ! expB ) {\r\n if ( ! sigB ) goto invalid;\r\n normExpSig = softfloat_normSubnormalF16Sig( sigB );\r\n expB = normExpSig.exp;\r\n sigB = normExpSig.sig;\r\n }\r\n if ( ! expA ) {\r\n if ( ! sigA ) return a;\r\n normExpSig = softfloat_normSubnormalF16Sig( sigA );\r\n expA = normExpSig.exp;\r\n sigA = normExpSig.sig;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n rem = sigA | 0x0400;\r\n sigB |= 0x0400;\r\n expDiff = expA - expB;\r\n if ( expDiff < 1 ) {\r\n if ( expDiff < -1 ) return a;\r\n sigB <<= 3;\r\n if ( expDiff ) {\r\n rem <<= 2;\r\n q = 0;\r\n } else {\r\n rem <<= 3;\r\n q = (sigB <= rem);\r\n if ( q ) rem -= sigB;\r\n }\r\n } else {\r\n recip32 = softfloat_approxRecip32_1( (uint_fast32_t) sigB<<21 );\r\n /*--------------------------------------------------------------------\r\n | Changing the shift of `rem' here requires also changing the initial\r\n | subtraction from `expDiff'.\r\n *--------------------------------------------------------------------*/\r\n rem <<= 4;\r\n expDiff -= 31;\r\n /*--------------------------------------------------------------------\r\n | The scale of `sigB' affects how many bits are obtained during each\r\n | cycle of the loop. Currently this is 29 bits per loop iteration,\r\n | which is believed to be the maximum possible.\r\n *--------------------------------------------------------------------*/\r\n sigB <<= 3;\r\n for (;;) {\r\n q32 = (rem * (uint_fast64_t) recip32)>>16;\r\n if ( expDiff < 0 ) break;\r\n rem = -((uint_fast16_t) q32 * sigB);\r\n expDiff -= 29;\r\n }\r\n /*--------------------------------------------------------------------\r\n | (`expDiff' cannot be less than -30 here.)\r\n *--------------------------------------------------------------------*/\r\n q32 >>= ~expDiff & 31;\r\n q = q32;\r\n rem = (rem<<(expDiff + 30)) - q * sigB;\r\n }\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n do {\r\n altRem = rem;\r\n ++q;\r\n rem -= sigB;\r\n } while ( ! (rem & 0x8000) );\r\n meanRem = rem + altRem;\r\n if ( (meanRem & 0x8000) || (! meanRem && (q & 1)) ) rem = altRem;\r\n signRem = signA;\r\n if ( 0x8000 <= rem ) {\r\n signRem = ! signRem;\r\n rem = -rem;\r\n }\r\n return softfloat_normRoundPackToF16( signRem, expB, rem );\r\n /*------------------------------------------------------------------------\r\n *------------------------------------------------------------------------*/\r\n propagateNaN:\r\n uiZ = softfloat_propagateNaNF16UI( uiA, uiB );\r\n goto uiZ;\r\n invalid:\r\n softfloat_raiseFlags( softfloat_flag_invalid );\r\n uiZ = defaultNaNF16UI;\r\n uiZ:\r\n uZ.ui = uiZ;\r\n return uZ.f;\r\n\r\n}\r\n\r\n/**** ended inlining ../../source/f16_rem.c ****/\n/**** start inlining ../../source/f16_sqrt.c ****/\n\r\n/*============================================================================\r\n\r\nThis C source file is part of the SoftFloat IEEE Floating-Point Arithmetic\r\nPackage, Release 3e, by John R. Hauser.\r\n\r\nCopyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of\r\nCalifornia. All rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n 1. Redistributions of source code must retain the above copyright notice,\r\n this list of conditions, and the following disclaimer.\r\n\r\n 2. Redistributions in binary form must reproduce the above copyright notice,\r\n this list of conditions, and the following disclaimer in the documentation\r\n and/or other materials provided with the distribution.\r\n\r\n 3. Neither the name of the University nor the names of its contributors may\r\n be used to endorse or promote products derived from this software without\r\n specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS \"AS IS\", AND ANY\r\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY\r\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\r\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\r\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n\r\n=============================================================================*/\r\n\r\n#include