.circleci/config.yml

@@ -0,0 +1,169 @@
+version: 2
+
+jobs:
+  # the first half of the jobs are in this test
+  short-tests-0:
+    # TODO: Create a small custom docker image with all the dependencies we need
+    #       preinstalled to reduce installation time.
+    docker:
+      - image: fbopensource/zstd-circleci-primary:0.0.1
+    steps:
+      - checkout
+      - run:
+          name: Test
+          command: |
+            ./tests/test-license.py
+            cc -v; CFLAGS="-O0 -Werror -pedantic" make all && make clean
+            make c99build         ; make clean
+            make c11build         ; make clean
+            make aarch64build     ; make clean
+            make -j regressiontest; make clean
+            make shortest         ; make clean
+            make cxxtest          ; make clean
+  # the second half of the jobs are in this test
+  short-tests-1:
+    docker:
+      - image: fbopensource/zstd-circleci-primary:0.0.1
+    steps:
+      - checkout
+      - run:
+          name: Test
+          command: |
+            make gnu90build; make clean
+            make gnu99build; make clean
+            make ppc64build; make clean
+            make ppcbuild  ; make clean
+            make armbuild  ; make clean
+            make -C tests test-legacy test-longmatch; make clean
+            make -C lib libzstd-nomt; make clean
+  # This step is only run on release tags.
+  # It publishes the source tarball as artifacts and if the GITHUB_TOKEN
+  # environment variable is set it will publish the source tarball to the
+  # tagged release.
+  publish-github-release:
+    docker:
+      - image: fbopensource/zstd-circleci-primary:0.0.1
+    environment:
+      CIRCLE_ARTIFACTS: /tmp/circleci-artifacts
+    steps:
+      - checkout
+      - run:
+          name: Publish
+          command: |
+            export VERSION=$(echo $CIRCLE_TAG | tail -c +2)
+            export ZSTD_VERSION=zstd-$VERSION
+            git archive $CIRCLE_TAG --prefix $ZSTD_VERSION/ --format tar \
+                        -o $ZSTD_VERSION.tar
+            sha256sum $ZSTD_VERSION.tar > $ZSTD_VERSION.tar.sha256
+            zstd -19 $ZSTD_VERSION.tar
+            sha256sum $ZSTD_VERSION.tar.zst > $ZSTD_VERSION.tar.zst.sha256
+            gzip -k -9 $ZSTD_VERSION.tar
+            sha256sum $ZSTD_VERSION.tar.gz > $ZSTD_VERSION.tar.gz.sha256
+            mkdir -p $CIRCLE_ARTIFACTS
+            cp $ZSTD_VERSION.tar* $CIRCLE_ARTIFACTS
+      - store_artifacts:
+          path: /tmp/circleci-artifacts
+  # This step should only be run in a cron job
+  regression-test:
+    docker:
+      - image: fbopensource/zstd-circleci-primary:0.0.1
+    environment:
+      CIRCLE_ARTIFACTS: /tmp/circleci-artifacts
+    steps:
+      - checkout
+      # Restore the cached resources.
+      - restore_cache:
+          # We try our best to bust the cache when the data changes by hashing
+          # data.c. If that doesn't work, simply update the version number here
+          # and below. If we fail to bust the cache, the regression testing will
+          # still work, since it has its own stamp, but will need to redownload
+          # everything.
+          keys:
+            - regression-cache-{{ checksum "tests/regression/data.c" }}-v0
+      - run:
+          name: Regression Test
+          command: |
+            make -C programs zstd
+            make -C tests/regression test
+            mkdir -p $CIRCLE_ARTIFACTS
+            ./tests/regression/test                     \
+                --cache  tests/regression/cache         \
+                --output $CIRCLE_ARTIFACTS/results.csv  \
+                --zstd   programs/zstd
+            echo "NOTE: The new results.csv is uploaded as an artifact to this job"
+            echo "      If this fails, go to the Artifacts pane in CircleCI, "
+            echo "      download /tmp/circleci-artifacts/results.csv, and if they "
+            echo "      are still good, copy it into the repo and commit it."
+            echo "> diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv"
+            diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv
+      # Only save the cache on success (default), since if the failure happened
+      # before we stamp the data cache, we will have a bad cache for this key.
+      - save_cache:
+          key: regression-cache-{{ checksum "tests/regression/data.c" }}-v0
+          paths:
+            - tests/regression/cache
+      - store_artifacts:
+          path: /tmp/circleci-artifacts
+
+
+workflows:
+  version: 2
+  commit:
+    jobs:
+      # Run the tests in parallel
+      - short-tests-0:
+          filters:
+            tags:
+              only: /.*/
+      - short-tests-1:
+          filters:
+            tags:
+              only: /.*/
+      # Create a branch called regression and set it to dev to force a
+      # regression test run
+      - regression-test:
+          filters:
+            branches:
+              only:
+                - regression
+      # Only run on release tags.
+      - publish-github-release:
+          requires:
+            - short-tests-0
+            - short-tests-1
+          filters:
+            branches:
+              ignore: /.*/
+            tags:
+              only: /^v\d+\.\d+\.\d+$/
+  nightly:
+    triggers:
+      - schedule:
+          cron: "0 0 * * *"
+          filters:
+            branches:
+              only:
+                - master
+                - dev
+    jobs:
+      # Run daily long regression tests
+      - regression-test
+
+
+
+  # Longer tests
+    #- make -C tests test-zstd-nolegacy && make clean
+    #- pyenv global 3.4.4; make -C tests versionsTest && make clean
+    #- make zlibwrapper         && make clean
+    #- gcc -v; make -C tests test32 MOREFLAGS="-I/usr/include/x86_64-linux-gnu" && make clean
+    #- make uasan               && make clean
+    #- make asan32              && make clean
+    #- make -C tests test32 CC=clang MOREFLAGS="-g -fsanitize=address -I/usr/include/x86_64-linux-gnu"
+  # Valgrind tests
+    #- CFLAGS="-O1 -g" make -C zlibWrapper valgrindTest && make clean
+    #- make -C tests valgrindTest && make clean
+  # ARM, AArch64, PowerPC, PowerPC64 tests
+    #- make ppctest             && make clean
+    #- make ppc64test           && make clean
+    #- make armtest             && make clean
+    #- make aarch64test         && make clean

.circleci/images/primary/Dockerfile

@@ -0,0 +1,9 @@
+FROM circleci/buildpack-deps:bionic
+
+RUN sudo dpkg --add-architecture i386
+RUN sudo apt-get -y -qq update
+RUN sudo apt-get -y install \
+    gcc-multilib-powerpc-linux-gnu gcc-arm-linux-gnueabi \
+    libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross \
+    libc6-dev-ppc64-powerpc-cross zstd gzip coreutils \
+    libcurl4-openssl-dev

.cirrus.yml

@@ -1,9 +1,11 @@
 task:
-  name: FreeBSD (make check)
+  name: FreeBSD (shortest)
   freebsd_instance:
     matrix:
-      image_family: freebsd-14-2
+      image_family: freebsd-12-1
+      # The stable 11.3 image causes "Agent is not responding" so use a snapshot
+      image_family: freebsd-11-3-snap
   install_script: pkg install -y gmake coreutils
   script: |
     MOREFLAGS="-Werror" gmake -j all
-    gmake check
+    gmake shortest

.github/ISSUE_TEMPLATE/bug_report.md

@@ -26,8 +26,8 @@ If applicable, add screenshots and charts to help explain your problem.
 **Desktop (please complete the following information):**
  - OS: [e.g. Mac]
  - Version [e.g. 22]
- - Compiler [e.g. gcc]
- - Flags [e.g. O2]
+ - Compiler [e.g gcc]
+ - Flags [e.g O2]
  - Other relevant hardware specs [e.g. Dual-core]
  - Build system [e.g. Makefile]
 

.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/android-ndk-build.yml

@@ -1,39 +0,0 @@
-name: Android NDK Build
-
-on:
-  pull_request:
-    branches: [ dev, release, actionsTest ]
-  push:
-    branches: [ actionsTest, '*ndk*' ]
-
-permissions: read-all
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-
-    - name: Set up JDK 17
-      uses: actions/setup-java@c5195efecf7bdfc987ee8bae7a71cb8b11521c00 # v4.7.1
-      with:
-        java-version: '17'
-        distribution: 'temurin'
-
-    - name: Setup Android SDK
-      uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407 # v3.2.2
-
-    - name: Install Android NDK
-      run: |
-        sdkmanager --install "ndk;27.0.12077973"
-        echo "ANDROID_NDK_HOME=$ANDROID_SDK_ROOT/ndk/27.0.12077973" >> $GITHUB_ENV
-
-    - name: Build with NDK
-      run: |
-        export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH
-        make CC=aarch64-linux-android21-clang \
-             AR=llvm-ar \
-             RANLIB=llvm-ranlib \
-             STRIP=llvm-strip
-

.github/workflows/cmake-tests.yml

@@ -1,153 +0,0 @@
-name: cmake-tests
-# CMake-specific build and test workflows
-# This workflow validates zstd builds across different CMake configurations,
-# platforms, and edge cases to ensure broad compatibility.
-
-concurrency:
-  group: cmake-${{ github.ref }}
-  cancel-in-progress: true
-
-on:
-  pull_request:
-    branches: [ dev, release, actionsTest ]
-
-permissions: read-all
-
-env:
-  # Centralized test timeouts for consistency
-  QUICK_TEST_TIME: "30s"
-  STANDARD_TEST_TIME: "1mn"
-  # Common CMake flags
-  COMMON_CMAKE_FLAGS: "-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON"
-
-jobs:
-  # Ubuntu-based cmake build using make wrapper
-  # This test uses the make-driven cmake build to ensure compatibility
-  # with the existing build system integration
-  cmake-ubuntu-basic:
-    name: "CMake Ubuntu Basic Build"
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Install dependencies
-      run: |
-        sudo apt install liblzma-dev  # Required for compression algorithms
-    - name: CMake build and test via make
-      run: |
-        # Use make wrapper for cmake build with quick test timeouts
-        FUZZERTEST=-T${{ env.STANDARD_TEST_TIME }} ZSTREAM_TESTTIME=-T${{ env.STANDARD_TEST_TIME }} make cmakebuild V=1
-
-  # Cross-platform cmake build with edge case: source paths containing spaces
-  # This test ensures cmake handles filesystem paths with spaces correctly
-  # across different operating systems and build generators
-  cmake-cross-platform-spaces:
-    name: "CMake Cross-Platform (Spaces in Path)"
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            generator: "Unix Makefiles"
-            name: "Linux"
-          - os: windows-latest
-            generator: "NMake Makefiles"
-            name: "Windows NMake"
-          - os: macos-latest
-            generator: "Unix Makefiles"
-            name: "macOS"
-    env:
-      SRC_DIR: "source directory with spaces"
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      with:
-        path: "${{ env.SRC_DIR }}"
-    - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1.13.0
-      if: ${{ matrix.generator == 'NMake Makefiles' }}
-    - name: "CMake build and install (${{ matrix.name }})"
-      run: |
-        # Test Release build with installation to verify packaging
-        cmake -S "${{ env.SRC_DIR }}/build/cmake" -B build -DBUILD_TESTING=ON -G "${{ matrix.generator }}" -DCMAKE_BUILD_TYPE=Release --install-prefix "${{ runner.temp }}/install"
-        cmake --build build --config Release
-        cmake --install build --config Release
-
-  # Windows-specific cmake testing with Visual Studio 2022
-  # Tests multiple generators and toolchains to ensure broad Windows compatibility
-  # including MSVC (x64, Win32, ARM64), MinGW, and Clang-CL with various architectures and optimizations
-  cmake-windows-comprehensive:
-    name: "CMake Windows VS2022 (${{ matrix.name }})"
-    runs-on: ${{ matrix.runner }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - generator: "Visual Studio 17 2022"
-            flags: "-A x64"
-            name: "MSVC x64"
-            runner: "windows-2022"
-            cmake_extra_flags: "-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON"
-          - generator: "Visual Studio 17 2022"
-            flags: "-A Win32"
-            name: "MSVC Win32"
-            runner: "windows-2022"
-            cmake_extra_flags: "-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON"
-          - generator: "Visual Studio 17 2022"
-            flags: "-A x64"
-            name: "MSVC x64 (No ZSTD_BUILD_TESTS)"
-            runner: "windows-2022"
-            # Intentionally omit ZSTD_BUILD_TESTS to reproduce the CXX language configuration bug
-            cmake_extra_flags: "-DCMAKE_COMPILE_WARNING_AS_ERROR=ON"
-          # - generator: "Visual Studio 17 2022"
-          #   flags: "-A ARM64"
-          #   name: "MSVC ARM64"
-          #   runner: "windows-2022-arm64"  # Disabled due to very long queue times
-          - generator: "MinGW Makefiles"
-            flags: ""
-            name: "MinGW"
-            runner: "windows-2022"
-            cmake_extra_flags: "-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON"
-          - generator: "Visual Studio 17 2022"
-            flags: "-T ClangCL"
-            name: "Clang-CL"
-            runner: "windows-2022"
-            cmake_extra_flags: "-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON"
-          - generator: "Visual Studio 17 2022"
-            flags: "-T ClangCL -A x64 -DCMAKE_C_FLAGS=/arch:AVX2"
-            name: "Clang-CL AVX2"
-            runner: "windows-2022"
-            cmake_extra_flags: "-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON"
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Add MSBuild to PATH
-      uses: microsoft/setup-msbuild@6fb02220983dee41ce7ae257b6f4d8f9bf5ed4ce # tag=v2.0.0
-    - name: "Configure CMake (${{ matrix.name }})"
-      run: |
-        cd build\cmake
-        mkdir build
-        cd build
-        cmake.exe -G "${{matrix.generator}}" ${{matrix.flags}} -DCMAKE_BUILD_TYPE=Debug ${{ matrix.cmake_extra_flags }} -DZSTD_ZSTREAM_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FUZZER_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FULLBENCH_FLAGS=-i0 ..
-    - name: "Build (${{ matrix.name }})"
-      run: |
-        cd build\cmake\build
-        cmake.exe --build .
-    - name: "Test (${{ matrix.name }})"
-      run: |
-        cd build\cmake\build
-        ctest.exe -V -C Debug
-
-  # macOS ARM64 (Apple Silicon) specific cmake testing
-  # Validates zstd builds and runs correctly on Apple Silicon architecture
-  # Uses native ARM64 hardware for optimal performance and compatibility testing
-  cmake-macos-arm64:
-    name: "CMake macOS ARM64 (Apple Silicon)"
-    runs-on: macos-14  # ARM64 runner
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: "CMake build and test (ARM64)"
-      run: |
-        # Configure and build with ARM64-specific optimizations
-        cd build/cmake
-        mkdir build
-        cd build
-        cmake -DCMAKE_BUILD_TYPE=Release ${{ env.COMMON_CMAKE_FLAGS }} -DZSTD_ZSTREAM_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FUZZER_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FULLBENCH_FLAGS=-i1 ..
-        make -j$(sysctl -n hw.ncpu)
-        ctest -V

.github/workflows/commit.yml

@@ -1,104 +0,0 @@
-name: facebook/zstd/commit
-on:
-  push:
-    branches:
-    - dev
-  pull_request:
-    branches:
-    - dev
-
-permissions: read-all
-
-jobs:
-  short-tests-0:
-    runs-on: ubuntu-latest
-    services:
-      docker:
-        image: fbopensource/zstd-circleci-primary:0.0.1
-        options: --entrypoint /bin/bash
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install Dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install libcurl4-gnutls-dev
-    - name: Test
-      run: |
-        ./tests/test-license.py
-        cc -v
-        CFLAGS="-O0 -Werror -pedantic" make allmost; make clean
-        make c99build; make clean
-        make c11build; make clean
-        make -j regressiontest; make clean
-        make check; make clean
-        make cxxtest; make clean
-
-  short-tests-1:
-    runs-on: ubuntu-latest
-    services:
-      docker:
-        image: fbopensource/zstd-circleci-primary:0.0.1
-        options: --entrypoint /bin/bash
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install Dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install gcc-powerpc-linux-gnu gcc-arm-linux-gnueabi gcc-aarch64-linux-gnu libc6-dev-ppc64-powerpc-cross libcurl4-gnutls-dev lib64gcc-13-dev-powerpc-cross
-    - name: gnu90 build
-      run: make gnu90build && make clean
-    - name: gnu99 build
-      run: make gnu99build && make clean
-    - name: ppc64 build
-      run: make ppc64build V=1 && make clean
-    - name: ppc build
-      run: make ppcbuild V=1 && make clean
-    - name: arm build
-      run: make armbuild V=1 && make clean
-    - name: aarch64 build
-      run: make aarch64build V=1 && make clean
-    - name: test-legacy
-      run: make -C tests test-legacy V=1 && make clean
-    - name: test-longmatch
-      run: make -C tests test-longmatch V=1 && make clean
-    - name: libzstd-nomt build
-      run: make -C lib libzstd-nomt V=1 && make clean
-
-  regression-test:
-    runs-on: ubuntu-latest
-    services:
-      docker:
-        image: fbopensource/zstd-circleci-primary:0.0.1
-        options: --entrypoint /bin/bash
-    env:
-      CIRCLE_ARTIFACTS: "/tmp/circleci-artifacts"
-    steps:
-    - uses: actions/checkout@v4
-    - name: restore_cache
-      uses: actions/cache@v4
-      with:
-        key: regression-cache-{{ checksum "tests/regression/data.c" }}-v0
-        path: tests/regression/cache
-        restore-keys: regression-cache-{{ checksum "tests/regression/data.c" }}-v0
-    - name: Install Dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install libcurl4-gnutls-dev
-    - name: Regression Test
-      run: |
-        make -C programs zstd
-        make -C tests/regression test
-        mkdir -p $CIRCLE_ARTIFACTS
-        ./tests/regression/test                     \
-            --cache  tests/regression/cache         \
-            --output $CIRCLE_ARTIFACTS/results.csv  \
-            --zstd   programs/zstd
-        echo "NOTE: The new results.csv is uploaded as an artifact to this job"
-        echo "      If this fails, go to the Artifacts pane in CircleCI, "
-        echo "      download /tmp/circleci-artifacts/results.csv, and if they "
-        echo "      are still good, copy it into the repo and commit it."
-        echo "> diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv"
-        diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv
-    - uses: actions/upload-artifact@v4
-      with:
-        path: "/tmp/circleci-artifacts"

.github/workflows/dev-long-tests.yml

@@ -1,324 +0,0 @@
-name: dev-long-tests
-# Tests generally longer than 10mn
-
-concurrency:
-  group: long-${{ github.ref }}
-  cancel-in-progress: true
-
-on:
-  pull_request:
-    branches: [ dev, release, actionsTest ]
-
-permissions: read-all
-
-jobs:
-  # lasts ~7mn
-  make-all:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make all
-      run: make all
-
-  # lasts ~19mn
-  make-test:
-    runs-on: ubuntu-latest
-    env:
-      DEVNULLRIGHTS: 1
-      READFROMBLOCKDEVICE: 1
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make test
-      run: |
-        make test
-        make -j zstd
-        ./tests/test_process_substitution.bash ./zstd
-
-  # lasts ~16mn
-  make-test-macos:
-    runs-on: macos-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make test on macos
-      run: make test
-
-  # lasts ~10mn
-  make-test-32bit:
-    runs-on: ubuntu-latest
-    env:
-      DEVNULLRIGHTS: 1
-      READFROMBLOCKDEVICE: 1
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make test # note: `make -j test success` seems to require a clean state
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        make clean
-        CFLAGS="-m32 -O2" make -j test V=1
-
-  # lasts ~7mn
-  test-largeDictionary:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: largeDictionary
-      run: |
-        CFLAGS="-Werror -O3" make -j -C tests test-largeDictionary
-
-  # lasts ~9mn
-  no-intrinsics-fuzztest:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: no intrinsics fuzztest
-      run: MOREFLAGS="-DZSTD_NO_INTRINSICS" make -C tests fuzztest
-
-  # lasts ~8mn
-  tsan-zstreamtest:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: thread sanitizer zstreamtest
-      run: CC=clang ZSTREAM_TESTTIME=-T3mn make tsan-test-zstream
-
-  uasan-zstreamtest:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: ub + address sanitizer on zstreamtest
-      run: CC=clang make uasan-test-zstream
-
-  # lasts ~11mn
-  tsan-fuzztest:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: thread sanitizer fuzztest
-      run: CC=clang make tsan-fuzztest
-
-  big-tests-zstreamtest32:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: zstream tests in 32bit mode, with big tests
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        CC=clang make -C tests test-zstream32 FUZZER_FLAGS="--big-tests"
-
-  # lasts ~13mn
-  gcc-8-asan-ubsan-testzstd:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: gcc-8 + ASan + UBSan + Test Zstd
-      # See https://askubuntu.com/a/1428822
-      run: |
-        echo "deb [arch=amd64] http://archive.ubuntu.com/ubuntu focal main universe" | sudo tee -a /etc/apt/sources.list
-        sudo apt-get -qqq update
-        make gcc8install
-        CC=gcc-8 make -j uasan-test-zstd </dev/null V=1
-
-  clang-asan-ubsan-testzstd:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: clang + ASan + UBSan + Test Zstd
-      run: CC=clang make -j uasan-test-zstd </dev/null V=1
-
-  gcc-asan-ubsan-testzstd-32bit:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: ASan + UBSan + Test Zstd, 32bit mode
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        make -j uasan-test-zstd32 V=1
-
-    # Note : external libraries must be turned off when using MSAN tests,
-    # because they are not msan-instrumented,
-    # so any data coming from these libraries is always considered "uninitialized"
-
-  gcc-8-asan-ubsan-fuzz:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: gcc-8 + ASan + UBSan + Fuzz Test
-      # See https://askubuntu.com/a/1428822
-      run: |
-        echo "deb [arch=amd64] http://archive.ubuntu.com/ubuntu focal main universe" | sudo tee -a /etc/apt/sources.list
-        sudo apt-get -qqq update
-        make gcc8install
-        CC=gcc-8 FUZZER_FLAGS="--long-tests" make clean uasan-fuzztest
-
-  clang-asan-ubsan-fuzz:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: clang + ASan + UBSan + Fuzz Test
-      run: CC=clang FUZZER_FLAGS="--long-tests" make clean uasan-fuzztest
-
-  gcc-asan-ubsan-fuzz32:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: ASan + UBSan + Fuzz Test 32bit
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        CFLAGS="-O3 -m32" FUZZER_FLAGS="--long-tests" make uasan-fuzztest
-
-  clang-asan-fuzz32:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: clang + ASan + Fuzz Test 32bit
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        CC=clang CFLAGS="-O3 -m32" FUZZER_FLAGS="--long-tests" make asan-fuzztest
-
-# The following test seems to have issues on github CI specifically,
-# it does not provide the `__mulodi4` instruction emulation
-# required for signed 64-bit multiplication.
-# Replaced by asan-only test (above)
-#
-#  clang-asan-ubsan-fuzz32:
-#    runs-on: ubuntu-20.04
-#    steps:
-#    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-#    - name: clang + ASan + UBSan + Fuzz Test 32bit
-#      run: |
-#        sudo apt-get -qqq update
-#        make libc6install
-#        CC=clang CFLAGS="-O3 -m32" FUZZER_FLAGS="--long-tests" make uasan-fuzztest
-
-  asan-ubsan-regression:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: ASan + UBSan + Regression Test
-      run: make -j uasanregressiontest
-
-  clang-asan-ubsan-regression:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: clang + ASan + UBSan + Regression Test
-      run: CC=clang make -j uasanregressiontest
-
-  msan-regression:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: MSan + Regression Test
-      run: make -j msanregressiontest
-
-  clang-msan-fuzz-unoptimized:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: clang + MSan + Fuzz Test
-        run: |
-          sudo apt-get -qqq update
-          sudo apt-get install clang
-          CC=clang MOREFLAGS="-O0" make clean msan-fuzztest
-
-  clang-msan-fuzz:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: clang + MSan + Fuzz Test
-      run: |
-        sudo apt-get -qqq update
-        sudo apt-get install clang
-        CC=clang FUZZER_FLAGS="--long-tests" make clean msan-fuzztest
-
-  clang-msan-testzstd:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: clang + MSan + Test Zstd
-      run: |
-        CC=clang make -j msan-test-zstd HAVE_ZLIB=0 HAVE_LZ4=0 HAVE_LZMA=0 V=1
-
-  armfuzz:
-      runs-on: ubuntu-latest
-      steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: Qemu ARM emulation + Fuzz Test
-        run: |
-          sudo apt-get -qqq update
-          make arminstall
-          make armfuzz
-
-  valgrind-fuzz-test:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: valgrind + fuzz test stack mode    # ~ 7mn
-      shell: 'script -q -e -c "bash {0}"'
-      run: |
-        sudo apt-get -qqq update
-        make valgrindinstall
-        make -C tests test-valgrind
-        make clean
-        make -C tests test-fuzzer-stackmode
-
-  mingw-long-test:
-    runs-on: windows-latest
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - uses: msys2/setup-msys2@40677d36a502eb2cf0fb808cc9dec31bf6152638 # tag=v2.28.0
-      with:
-        msystem: MINGW64
-        install: make
-        update: true
-    # Based on https://ariya.io/2020/07/on-github-actions-with-msys2
-    - name: install mingw gcc
-      run: pacman --noconfirm -S gcc
-    - name: MINGW64 gcc fuzztest
-      run: |
-        export CC="gcc"
-        export CXX="g++"
-        export FUZZERTEST="-T2mn"
-        export ZSTREAM_TESTTIME="-T2mn"
-        echo "Testing $CC $CXX MINGW64"
-        make -v
-        $CC --version
-        $CXX --version
-        make -C tests fuzztest
-
-  # lasts ~20mn
-  oss-fuzz:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        sanitizer: [address, undefined, memory]
-    steps:
-    - name: Build Fuzzers (${{ matrix.sanitizer }})
-      id: build
-      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
-      with:
-        oss-fuzz-project-name: 'zstd'
-        dry-run: false
-        sanitizer: ${{ matrix.sanitizer }}
-    - name: Run Fuzzers (${{ matrix.sanitizer }})
-      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
-      with:
-        oss-fuzz-project-name: 'zstd'
-        fuzz-seconds: 600
-        dry-run: false
-        sanitizer: ${{ matrix.sanitizer }}
-    - name: Upload Crash
-      uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # tag=v4.3.1
-      if: failure() && steps.build.outcome == 'success'
-      with:
-        name: ${{ matrix.sanitizer }}-artifacts
-        path: ./out/artifacts

.github/workflows/dev-short-tests.yml

@@ -1,678 +0,0 @@
-name: dev-short-tests
-# Faster tests: mostly build tests, along with some other
-# misc tests
-
-concurrency:
-  group: fast-${{ github.ref }}
-  cancel-in-progress: true
-
-on:
-  pull_request:
-    branches: [ dev, release, actionsTest ]
-
-permissions: read-all
-
-jobs:
-  linux-kernel:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: linux kernel, library + build + test
-      run: make -C contrib/linux-kernel test CFLAGS="-Werror -Wunused-const-variable -Wunused-but-set-variable"
-
-  benchmarking:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make benchmarking
-      run: make benchmarking
-
-  check-32bit: # designed to catch https://github.com/facebook/zstd/issues/2428
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make check on 32-bit
-      run: |
-        sudo apt update
-        APT_PACKAGES="gcc-multilib" make apt-install
-        CFLAGS="-m32 -O1 -fstack-protector" make check V=1
-        CFLAGS="-m32 -O1 -fstack-protector" make V=1 -C tests test-cli-tests
-
-  build-c89:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: ensure zstd can be built with c89/c90 compilers (+ long long support + variadic macros)
-      run: |
-        make c89build V=1
-
-  build-zstd-dll:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: build zstd bin against a dynamic lib (debuglevel for more dependencies)
-      run: |
-        make -C lib lib-mt-release
-        DEBUGLEVEL=2 make -C programs zstd-dll
-
-  gcc-7-libzstd:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: gcc-7 + libzstdmt compilation
-      # See https://askubuntu.com/a/1428822
-      run: |
-        echo "deb [arch=amd64] http://archive.ubuntu.com/ubuntu focal main universe" | sudo tee -a /etc/apt/sources.list
-        sudo apt-get -qqq update
-        make gcc7install
-        CC=gcc-7 CFLAGS=-Werror make -j all
-        make clean
-        LDFLAGS=-Wl,--no-undefined make -C lib libzstd-mt
-
-    # candidate test (for discussion) : underlink test
-    # LDFLAGS=-Wl,--no-undefined : will make the linker fail if dll is underlinked
-
-  cpp-gnu90-c99-compatibility:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: C++, gnu90 and c99 compatibility
-      run: |
-        make cxxtest
-        make clean
-        make gnu90build
-        make clean
-        make c99build
-        make clean
-        make travis-install   # just ensures `make install` works
-
-  mingw-cross-compilation:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: mingw cross-compilation
-      run: |
-        # sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix; (doesn't work)
-        sudo apt-get -qqq update
-        sudo apt-get install gcc-mingw-w64
-        CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++ CFLAGS="-Werror -O1" make zstd
-
-  armbuild:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: ARM Build Test
-      run: |
-        sudo apt-get -qqq update
-        make arminstall
-        make armbuild
-
-  bourne-shell:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Bourne shell compatibility (shellcheck)
-      run: |
-        wget https://github.com/koalaman/shellcheck/releases/download/v0.7.1/shellcheck-v0.7.1.linux.x86_64.tar.xz
-        tar -xf shellcheck-v0.7.1.linux.x86_64.tar.xz
-        shellcheck-v0.7.1/shellcheck --shell=sh --severity=warning --exclude=SC2010 tests/playTests.sh
-
-  zlib-wrapper:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: install valgrind
-      run: |
-        sudo apt-get -qqq update
-        make valgrindinstall V=1
-    - name: zlib wrapper test
-      run: make -C zlibWrapper test V=1
-    - name: zlib wrapper test under valgrind
-      run: make -C zlibWrapper test-valgrind V=1
-
-  lz4-threadpool-libs:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: LZ4, thread pool, and libs build testslib wrapper test
-      run: |
-        make -C tests test-lz4
-        make check < /dev/null | tee   # mess with lz4 console detection
-        make clean
-        make -C tests test-pool
-        make clean
-        bash tests/libzstd_builds.sh
-
-  gcc-make-all-avx2:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Make all, with AVX2
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        CFLAGS="-Werror -mavx2" make -j all
-
-  gcc-make-all-32bit:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Make all, 32bit mode
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        CFLAGS="-Werror -m32" make -j all32
-
-  gcc-make-all-32bit-avx2:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Make all, 32bit + AVX2 mode
-      run: |
-        sudo apt-get -qqq update
-        make libc6install
-        CPPFLAGS="-DSTATIC_BMI2=1" CFLAGS="-Werror -m32 -mavx2 -mbmi2" make -j all32
-
-
-  gcc-8-make:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: gcc-8 build
-        # See https://askubuntu.com/a/1428822
-        run: |
-          echo "deb [arch=amd64] http://archive.ubuntu.com/ubuntu focal main universe" | sudo tee -a /etc/apt/sources.list
-          sudo apt-get -qqq update
-          make gcc8install
-          CC=gcc-8 CFLAGS="-Werror" make -j all
-
-  make-external-compressors:
-    strategy:
-      matrix:
-        include:
-          - name: "no external compressors"
-            flags: "HAVE_ZLIB=0 HAVE_LZ4=0 HAVE_LZMA=0"
-          - name: "only zlib"
-            flags: "HAVE_ZLIB=1 HAVE_LZ4=0 HAVE_LZMA=0"
-          - name: "only lz4"
-            flags: "HAVE_ZLIB=0 HAVE_LZ4=1 HAVE_LZMA=0"
-          - name: "only lzma"
-            flags: "HAVE_ZLIB=0 HAVE_LZ4=0 HAVE_LZMA=1"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: Build with ${{matrix.name}}
-        run: |
-          sudo apt install liblzma-dev
-          ${{matrix.flags}} make zstd
-
-
-  implicit-fall-through:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: -Wimplicit-fallthrough build
-        run: |
-          make clean
-          CC=gcc MOREFLAGS="-Werror -Wimplicit-fallthrough=2 -O0" make -C lib -j libzstd.a ZSTD_LEGACY_SUPPORT=0
-          make clean
-          CC=clang MOREFLAGS="-Werror -Wimplicit-fallthrough -O0" make -C lib -j libzstd.a ZSTD_LEGACY_SUPPORT=0
-
-  meson-linux:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: Install packages
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install build-essential python3-pip ninja-build liblz4-dev liblzma-dev
-          pip install --pre meson
-      - name: Build with Meson
-        run: |
-          meson setup \
-            --buildtype=debugoptimized \
-            -Db_lundef=false \
-            -Dauto_features=enabled \
-            -Dbin_programs=true \
-            -Dbin_tests=true \
-            -Dbin_contrib=true \
-            -Ddefault_library=both \
-            build/meson mesonBuild
-          ninja -C mesonBuild/
-          meson test -C mesonBuild/ --print-errorlogs
-          meson install -C mesonBuild --destdir staging/
-
-  meson-mingw-cross-compilation:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: Install packages
-        run: |
-          sudo apt-get -qqq update
-          sudo apt-get -y install build-essential python3-pip ninja-build {gcc,g++}-mingw-w64-x86-64
-          pip install --pre meson
-      - name: Build with Meson
-        run: |
-          cat > cross.ini <<EOF
-          [binaries]
-          ar = 'x86_64-w64-mingw32-ar'
-          c = 'x86_64-w64-mingw32-gcc'
-          cpp = 'x86_64-w64-mingw32-g++'
-          ld = 'x86_64-w64-mingw32-ld'
-          objcopy = 'x86_64-w64-mingw32-objcopy'
-          objdump = 'x86_64-w64-mingw32-objdump'
-          strip = 'x86_64-w64-mingw32-strip'
-          windres = 'x86_64-w64-mingw32-windres'
-
-          [host_machine]
-          system = 'windows'
-          endian = 'little'
-          cpu_family = 'x86_64'
-          cpu = 'x86_64'
-          EOF
-
-          # pzstd doesn't build; skip -Dbin_contrib=true
-          meson setup \
-            --buildtype=debugoptimized \
-            --cross-file=cross.ini \
-            -Db_lundef=false \
-            -Dbin_programs=true \
-            -Dbin_tests=true \
-            -Ddefault_library=both \
-            build/meson builddir
-          ninja -C builddir/
-          if grep -- -pthread builddir/meson-private/libzstd.pc; then
-            echo "Error: found stray pthread dependency"
-            exit 1
-          fi
-
-  meson-windows:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: Install packages
-        run: pip install --pre meson
-      - name: Configure with Meson
-        run: |
-          meson setup --vsenv build/meson/ builddir -Dbin_tests=true -Dbin_programs=true -Dbin_contrib=true
-      - name: Build with Meson
-        run: |
-          meson compile -C builddir/
-      - name: Test with Meson
-        run: |
-          meson test -C builddir/ --print-errorlogs
-      - name: Install with Meson
-        run: |
-          meson install -C builddir --destdir staging/
-
-  msbuild-visual-studio:
-    strategy:
-      fail-fast: false  # 'false' means Don't stop matrix workflows even if some matrix failed.
-      matrix:
-        include: [
-          { name: "VS 2022 x64 Debug", platform: x64, configuration: Debug, toolset: v143, runner: "windows-2022", arch: "" },
-          { name: "VS 2022 Win32 Debug", platform: Win32, configuration: Debug, toolset: v143, runner: "windows-2022", arch: "" },
-          { name: "VS 2022 x64 Release", platform: x64, configuration: Release, toolset: v143, runner: "windows-2022", arch: ""},
-          { name: "VS 2022 Win32 Release", platform: Win32, configuration: Release, toolset: v143, runner: "windows-2022", arch: ""},
-          { name: "VS 2019 x64 Release", platform: Win32, configuration: Release, toolset: v142, runner: "windows-2019", arch: ""},
-          { name: "VS 2019 Win32 Release", platform: x64, configuration: Release, toolset: v142, runner: "windows-2019", arch: ""},
-          { name: "VS 2022 x64 Release AVX2", platform: x64, configuration: Release, toolset: v143, runner: "windows-2022", arch: "AdvancedVectorExtensions2" },
-        ]
-    runs-on: ${{matrix.runner}}
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Add MSBuild to PATH
-      uses: microsoft/setup-msbuild@6fb02220983dee41ce7ae257b6f4d8f9bf5ed4ce # tag=v2.0.0
-    - name: Build ${{matrix.name}}
-      working-directory: ${{env.GITHUB_WORKSPACE}}
-      # See https://docs.microsoft.com/visualstudio/msbuild/msbuild-command-line-reference
-      if: ${{ matrix.arch == '' }}
-      run: >
-        msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=${{matrix.toolset}}
-        /t:Clean,Build /p:Platform=${{matrix.platform}} /p:Configuration=${{matrix.configuration}} /warnaserror
-    - name: Build ${{matrix.name}}
-      working-directory: ${{env.GITHUB_WORKSPACE}}
-      # See https://docs.microsoft.com/visualstudio/msbuild/msbuild-command-line-reference
-      if: ${{ matrix.arch != '' }}
-      run: >
-        msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=${{matrix.toolset}}
-        /t:Clean,Build /p:Platform=${{matrix.platform}} /p:Configuration=${{matrix.configuration}} /warnaserror
-        /p:InstructionSet=${{matrix.arch}}
-
-  # This tests that we don't accidentally grow the size too much.
-  # If the size grows intentionally, you can raise these numbers.
-  # But we do need to think about binary size, since it is a concern.
-  libzstd-size:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: libzstd size test
-      run: |
-        make clean && make -j -C lib libzstd && ./tests/check_size.py lib/libzstd.so 1100000
-        make clean && make -j -C lib libzstd ZSTD_LIB_COMPRESSION=0 ZSTD_LIB_DICTBUILDER=0 && ./tests/check_size.py lib/libzstd.so 400000
-        make clean && make -j -C lib libzstd ZSTD_LIB_MINIFY=1 && ./tests/check_size.py lib/libzstd.so 300000
-        make clean && make -j -C lib libzstd ZSTD_LIB_MINIFY=1 ZSTD_LIB_COMPRESSION=0 ZSTD_LIB_DICTBUILDER=0 && ./tests/check_size.py lib/libzstd.so 80000
-
-  minimal-decompressor-macros:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: minimal decompressor macros
-      run: |
-        make clean && make -j all ZSTD_LIB_MINIFY=1 MOREFLAGS="-Werror"
-        make clean && make check ZSTD_LIB_MINIFY=1 MOREFLAGS="-Werror"
-        make clean && make -j all MOREFLAGS="-Werror -DHUF_FORCE_DECOMPRESS_X1 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT"
-        make clean && make check MOREFLAGS="-Werror -DHUF_FORCE_DECOMPRESS_X1 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT"
-        make clean && make -j all MOREFLAGS="-Werror -DHUF_FORCE_DECOMPRESS_X2 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG"
-        make clean && make check MOREFLAGS="-Werror -DHUF_FORCE_DECOMPRESS_X2 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG"
-        make clean && make -j all MOREFLAGS="-Werror -DZSTD_NO_INLINE -DZSTD_STRIP_ERROR_STRINGS"
-        make clean && make check MOREFLAGS="-Werror -DZSTD_NO_INLINE -DZSTD_STRIP_ERROR_STRINGS"
-        make clean && make check ZSTD_LIB_EXCLUDE_COMPRESSORS_DFAST_AND_UP=1 MOREFLAGS="-Werror"
-        make clean && make check ZSTD_LIB_EXCLUDE_COMPRESSORS_GREEDY_AND_UP=1 MOREFLAGS="-Werror"
-
-  dynamic-bmi2:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: dynamic bmi2 tests
-      run: |
-        make clean && make -j check MOREFLAGS="-O0 -Werror -mbmi2"
-        make clean && make -j check MOREFLAGS="-O0 -Werror -DDYNAMIC_BMI2=1"
-        make clean && make -j check MOREFLAGS="-O0 -Werror -DDYNAMIC_BMI2=1 -mbmi2"
-        make clean && make -j check MOREFLAGS="-O0 -Werror -DDYNAMIC_BMI2=0"
-        make clean && make -j check MOREFLAGS="-O0 -Werror -DDYNAMIC_BMI2=0 -mbmi2"
-
-  test-variants:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make all variants & validate
-      run: |
-        make -j -C programs allVariants MOREFLAGS=-O0
-        ./tests/test-variants.sh
-
-  qemu-consistency:
-    name: QEMU ${{ matrix.name }}
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false  # 'false' means Don't stop matrix workflows even if some matrix failed.
-      matrix:
-        include: [
-          { name: ARM,      xcc_pkg: gcc-arm-linux-gnueabi,     xcc: arm-linux-gnueabi-gcc,     xemu_pkg: qemu-system-arm,    xemu: qemu-arm-static     },
-          { name: ARM64,    xcc_pkg: gcc-aarch64-linux-gnu,     xcc: aarch64-linux-gnu-gcc,     xemu_pkg: qemu-system-aarch64,xemu: qemu-aarch64-static },
-          { name: PPC,      xcc_pkg: gcc-powerpc-linux-gnu,     xcc: powerpc-linux-gnu-gcc,     xemu_pkg: qemu-system-ppc,    xemu: qemu-ppc-static     },
-          { name: PPC64LE,  xcc_pkg: gcc-powerpc64le-linux-gnu, xcc: powerpc64le-linux-gnu-gcc, xemu_pkg: qemu-system-ppc,    xemu: qemu-ppc64le-static },
-          { name: S390X,    xcc_pkg: gcc-s390x-linux-gnu,       xcc: s390x-linux-gnu-gcc,       xemu_pkg: qemu-system-s390x,  xemu: qemu-s390x-static   },
-          { name: MIPS,     xcc_pkg: gcc-mips-linux-gnu,        xcc: mips-linux-gnu-gcc,        xemu_pkg: qemu-system-mips,   xemu: qemu-mips-static    },
-          { name: RISC-V,   xcc_pkg: gcc-riscv64-linux-gnu,     xcc: riscv64-linux-gnu-gcc,     xemu_pkg: qemu-system-riscv64,xemu: qemu-riscv64-static },
-          { name: M68K,     xcc_pkg: gcc-m68k-linux-gnu,        xcc: m68k-linux-gnu-gcc,        xemu_pkg: qemu-system-m68k,   xemu: qemu-m68k-static    },
-          { name: SPARC,    xcc_pkg: gcc-sparc64-linux-gnu,     xcc: sparc64-linux-gnu-gcc,     xemu_pkg: qemu-system-sparc,  xemu: qemu-sparc64-static },
-        ]
-    env:                        # Set environment variables
-      XCC: ${{ matrix.xcc }}
-      XEMU: ${{ matrix.xemu }}
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: apt update & install
-      run: |
-        sudo apt-get update
-        sudo apt-get install gcc-multilib g++-multilib qemu-utils qemu-user-static
-        sudo apt-get install ${{ matrix.xcc_pkg }} ${{ matrix.xemu_pkg }}
-    - name: Environment info
-      run: |
-        echo && which $XCC
-        echo && $XCC --version
-        echo && $XCC -v  # Show built-in specs
-        echo && which $XEMU
-        echo && $XEMU --version
-    - name: ARM
-      if: ${{ matrix.name == 'ARM' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-    - name: ARM64
-      if: ${{ matrix.name == 'ARM64' }}
-      run: |
-        make clean
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make -j check
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make -j -C tests test-cli-tests
-        CFLAGS="-march=armv8.2-a+sve2" LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make -j check
-        CFLAGS="-march=armv8.2-a+sve2" LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make -j -C tests test-cli-tests
-# This test is only compatible with standard libraries that support BTI (Branch Target Identification).
-# Unfortunately, the standard library provided on Ubuntu 24.04 does not have this feature enabled.
-#        make clean
-#        LDFLAGS="-static -z force-bti" MOREFLAGS="-mbranch-protection=standard" CC=$XCC QEMU_SYS=$XEMU make check V=1
-    - name: PPC
-      if: ${{ matrix.name == 'PPC' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-    - name: PPC64LE
-      if: ${{ matrix.name == 'PPC64LE' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-    - name: S390X
-      if: ${{ matrix.name == 'S390X' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-    - name: MIPS
-      if: ${{ matrix.name == 'MIPS' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-    - name: RISC-V
-      if: ${{ matrix.name == 'RISC-V' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-    - name: M68K
-      if: ${{ matrix.name == 'M68K' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-    - name: SPARC
-      if: ${{ matrix.name == 'SPARC' }}
-      run: |
-        LDFLAGS="-static" CC=$XCC QEMU_SYS=$XEMU make clean check
-
-  mingw-short-test:
-    runs-on: windows-latest
-    strategy:
-      fail-fast: false  # 'false' means Don't stop matrix workflows even if some matrix failed.
-      matrix:
-        include: [
-          { compiler: gcc, msystem: MINGW32, cflags: "-Werror"},
-          { compiler: gcc, msystem: MINGW64, cflags: "-Werror"},
-          { compiler: clang, msystem: MINGW64, cflags: "--target=x86_64-w64-mingw32 -Werror -Wconversion -Wno-sign-conversion -Wno-unused-command-line-argument"},
-        ]
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - uses: msys2/setup-msys2@40677d36a502eb2cf0fb808cc9dec31bf6152638 # tag=v2.28.0
-      with:
-        msystem: ${{ matrix.msystem }}
-        install: make diffutils
-        update: true
-    # Based on https://ariya.io/2020/07/on-github-actions-with-msys2
-    - name: install mingw gcc i686
-      if: ${{ (matrix.msystem == 'MINGW32') && (matrix.compiler == 'gcc') }}
-      run: pacman --noconfirm -S mingw-w64-i686-gcc
-    - name: install mingw gcc x86_64
-      if: ${{ (matrix.msystem == 'MINGW64') && (matrix.compiler == 'gcc') }}
-      run: pacman --noconfirm -S mingw-w64-x86_64-gcc
-    - name: install mingw clang i686
-      if: ${{ (matrix.msystem == 'MINGW32') && (matrix.compiler == 'clang') }}
-      run: pacman --noconfirm -S mingw-w64-i686-clang
-    - name: install mingw clang x86_64
-      if: ${{ (matrix.msystem == 'MINGW64') && (matrix.compiler == 'clang') }}
-      run: pacman --noconfirm -S mingw-w64-x86_64-clang
-    - name: run mingw tests
-      run: |
-        make -v
-        export CC=${{ matrix.compiler }}
-        $CC --version
-        CFLAGS="${{ matrix.cflags }}" make -j allzstd
-        echo "Testing $CC ${{ matrix.msystem }}"
-        make clean
-        MSYS="" make check
-
-  visual-runtime-tests:
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        platform: [x64, Win32]
-        configuration: [Release]
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Add MSBuild to PATH
-      uses: microsoft/setup-msbuild@6fb02220983dee41ce7ae257b6f4d8f9bf5ed4ce # tag=v2.0.0
-    - name: Build and run tests
-      working-directory: ${{env.GITHUB_WORKSPACE}}
-      env:
-        ZSTD_BIN: ./zstd.exe
-        DATAGEN_BIN: ./datagen.exe
-      # See https://docs.microsoft.com/visualstudio/msbuild/msbuild-command-line-reference
-      run: |
-        msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v142 /t:Clean,Build /p:Platform=${{matrix.platform}} /p:Configuration=${{matrix.configuration}}
-        COPY build\VS2010\bin\${{matrix.platform}}_${{matrix.configuration}}\*.exe tests\
-        CD tests
-        sh -e playTests.sh
-        .\fuzzer.exe -T2m
-
-  # Following instructions at: https://github.com/marketplace/actions/install-cygwin-action
-  cygwin-tests:
-    runs-on: windows-latest
-    steps:
-    - run: git config --global core.autocrlf input
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - uses: cygwin/cygwin-install-action@f61179d72284ceddc397ed07ddb444d82bf9e559 # tag=v5
-      with:
-        platform: x86_64
-        packages: >-
-          autoconf,
-          automake,
-          gcc-g++,
-          make,
-          mingw64-x86_64-gcc-g++,
-          patch,
-          perl
-    - name: cygwin tests
-      shell: C:\cygwin\bin\bash.exe --noprofile --norc -eo pipefail '{0}'
-      run: >-
-        export PATH=/usr/bin:$(cygpath ${SYSTEMROOT})/system32 &&
-        export CFLAGS="-Werror -O1" &&
-        ls &&
-        make -j allzstd &&
-        make -C tests fuzzer &&
-        ./tests/fuzzer.exe -v -T1m
-    - name: cygwin install test
-      shell: C:\cygwin\bin\bash.exe --noprofile --norc -eo pipefail '{0}'
-      run: >-
-        make -j &&
-        make install
-
-  pkg-config:
-    runs-on: ubuntu-latest
-    container:
-      image: debian:testing
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: Install dependencies
-        run: |
-          apt -y update
-          apt -y install --no-install-recommends gcc libc6-dev make pkg-config
-      - name: Build and install
-        run: make -C lib install
-      - name: Test pkg-config
-        run: |
-          cc -Wall -Wextra -Wpedantic -Werror -o simple examples/simple_compression.c $(pkg-config --cflags --libs libzstd)
-          ./simple LICENSE
-
-  versions-compatibility:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Versions Compatibility Test
-      run: |
-        make -C tests versionsTest
-
-  clangbuild:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make clangbuild
-      run: |
-        make clangbuild
-
-  gcc-pgo:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Build PGO Zstd with GCC
-      env:
-        CC: gcc
-      run: |
-        make -C programs zstd-pgo
-        ./programs/zstd -b
-
-  clang-pgo:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Build PGO Zstd with Clang
-      env:
-        CC: clang
-      run: |
-        sudo apt install -y llvm
-        llvm-profdata --version
-        make -C programs zstd-pgo
-        ./programs/zstd -b
-
-  musl-build:
-    runs-on: ubuntu-22.04
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-      - name: Install musl-tools
-        run: |
-          sudo apt install -y musl-tools
-      - name: Compile with musl-gcc and test-zstd
-        run: |
-          CC=musl-gcc CFLAGS="-Werror -O3" CPPFLAGS=-DZDICT_QSORT=ZDICT_QSORT_C90 make -j -C tests test-zstd V=1
-
-  intel-cet-compatibility:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: Build Zstd
-      run: |
-        make -j zstd V=1
-        readelf -n zstd
-    - name: Get Intel SDE
-      run: |
-        curl -LO https://downloadmirror.intel.com/813591/sde-external-9.33.0-2024-01-07-lin.tar.xz
-        tar xJvf sde-external-9.33.0-2024-01-07-lin.tar.xz
-    - name: Configure Permissions
-      run: |
-        echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
-    - name: Run Under SDE
-      run: |
-        sde-external-9.33.0-2024-01-07-lin/sde -cet -cet-raise 0 -cet-endbr-exe -cet-stderr -cet-abort -- ./zstd -b3
-
-  icx:
-    # install instructions: https://www.intel.com/content/www/us/en/docs/oneapi/installation-guide-linux/2025-0/apt-005.html
-    name: icx-check
-    runs-on: ubuntu-latest
-    steps:
-    - name: install icx
-      run: |
-        # download the key to system keyring
-        wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB \
-        | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
-
-        # add signed entry to apt sources and configure the APT client to use Intel repository:
-        echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list
-        sudo apt-get update
-        sudo apt-get install -y intel-basekit intel-hpckit
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - name: make check
-      run: |
-        source /opt/intel/oneapi/setvars.sh
-        make CC=icx check
-        make CC=icx -C tests test-cli-tests

.github/workflows/main.yml

@@ -0,0 +1,23 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Build Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'zstd'
+        dry-run: false
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'zstd'
+        fuzz-seconds: 600
+        dry-run: false
+    - name: Upload Crash
+      uses: actions/upload-artifact@v1
+      if: failure()
+      with:
+        name: artifacts
+        path: ./out/artifacts

.github/workflows/nightly.yml

@@ -1,38 +0,0 @@
-name: facebook/zstd/nightly
-on:
-  schedule:
-    - cron: '0 0 * * *'
-  push:
-    branches:
-      - release
-      - dev
-      - '*nightly*'
-permissions: read-all
-jobs:
-  regression-test:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install dependencies
-      run: sudo apt-get update && sudo apt-get install -y libcurl4-openssl-dev
-    - name: Regression Test
-      run: |
-        make -C programs zstd
-        make -C tests/regression test
-
-# Longer tests
-  #- make -C tests test-zstd-nolegacy && make clean
-  #- pyenv global 3.4.4; make -C tests versionsTest && make clean
-  #- make zlibwrapper         && make clean
-  #- gcc -v; make -C tests test32 MOREFLAGS="-I/usr/include/x86_64-linux-gnu" && make clean
-  #- make uasan               && make clean
-  #- make asan32              && make clean
-  #- make -C tests test32 CC=clang MOREFLAGS="-g -fsanitize=address -I/usr/include/x86_64-linux-gnu"
-# Valgrind tests
-  #- CFLAGS="-O1 -g" make -C zlibWrapper valgrindTest && make clean
-  #- make -C tests valgrindTest && make clean
-# ARM, AArch64, PowerPC, PowerPC64 tests
-  #- make ppctest             && make clean
-  #- make ppc64test           && make clean
-  #- make armtest             && make clean
-  #- make aarch64test         && make clean

.github/workflows/publish-release-artifacts.yml

@@ -1,73 +0,0 @@
-name: publish-release-artifacts
-
-on:
-  release:
-    types:
-      - published
-
-permissions: read-all
-
-jobs:
-  publish-release-artifacts:
-    permissions:
-      contents: write # to fetch code and upload artifacts
-
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-
-      - name: Archive
-        env:
-          RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}
-          RELEASE_SIGNING_KEY_PASSPHRASE: ${{ secrets.RELEASE_SIGNING_KEY_PASSPHRASE }}
-        run: |
-          # compute file name
-          export TAG="$(echo "$GITHUB_REF" | sed -n 's_^refs/tags/__p')"
-          if [ -z "$TAG" ]; then
-            echo "action must be run on a tag. GITHUB_REF is not a tag: $GITHUB_REF"
-            exit 1
-          fi
-          # Attempt to extract "1.2.3" from "v1.2.3" to maintain artifact name backwards compat.
-          # Otherwise, degrade to using full tag.
-          export VERSION="$(echo "$TAG" | sed 's_^v\([0-9]\+\.[0-9]\+\.[0-9]\+\)$_\1_')"
-          export ZSTD_VERSION="zstd-$VERSION"
-
-          # archive
-          git archive $TAG \
-              --prefix $ZSTD_VERSION/ \
-              --format tar \
-              -o $ZSTD_VERSION.tar
-
-          # Do the rest of the work in a sub-dir so we can glob everything we want to publish.
-          mkdir artifacts/
-          mv $ZSTD_VERSION.tar artifacts/
-          cd artifacts/
-
-          # compress
-          zstd -k -19 $ZSTD_VERSION.tar
-          gzip -k  -9 $ZSTD_VERSION.tar
-
-          # we only publish the compressed tarballs
-          rm $ZSTD_VERSION.tar
-
-          # hash
-          sha256sum $ZSTD_VERSION.tar.zst > $ZSTD_VERSION.tar.zst.sha256
-          sha256sum $ZSTD_VERSION.tar.gz  > $ZSTD_VERSION.tar.gz.sha256
-
-          # sign
-          if [ -n "$RELEASE_SIGNING_KEY" ]; then
-            export GPG_BATCH_OPTS="--batch --no-use-agent --pinentry-mode loopback --no-tty --yes"
-            echo "$RELEASE_SIGNING_KEY" | gpg $GPG_BATCH_OPTS --import
-            gpg $GPG_BATCH_OPTS --armor --sign --sign-with signing@zstd.net --detach-sig --passphrase "$RELEASE_SIGNING_KEY_PASSPHRASE" --output $ZSTD_VERSION.tar.zst.sig $ZSTD_VERSION.tar.zst
-            gpg $GPG_BATCH_OPTS --armor --sign --sign-with signing@zstd.net --detach-sig --passphrase "$RELEASE_SIGNING_KEY_PASSPHRASE" --output $ZSTD_VERSION.tar.gz.sig  $ZSTD_VERSION.tar.gz
-          fi
-
-      - name: Publish
-        uses: skx/github-action-publish-binaries@b9ca5643b2f1d7371a6cba7f35333f1461bbc703 # tag=release-2.0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          args: artifacts/*

.github/workflows/release_check.yml

@@ -1,64 +0,0 @@
-name: release_checks
-
-on:
-  push:
-    branches:
-      - release
-  pull_request:
-    branches:
-      - release
-
-permissions: read-all
-
-jobs:
-  verify-manual:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v4
-
-      - name: Save current manual
-        run: mv doc/zstd_manual.html doc/zstd_manual_saved.html
-
-      - name: Generate new manual
-        run: make manual
-
-      - name: Compare manuals
-        run: |
-          if ! cmp -s doc/zstd_manual.html doc/zstd_manual_saved.html; then
-            echo "The API manual was not updated before release !"
-            exit 1
-          fi
-
-  verify-man-pages:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ruby ruby-dev
-          sudo gem install ronn
-
-      - name: Display ronn version
-        run: ronn --version
-
-      - name: Save current man pages
-        run: |
-          mv programs/zstd.1 programs/zstd.1.saved
-          mv programs/zstdgrep.1 programs/zstdgrep.1.saved
-          mv programs/zstdless.1 programs/zstdless.1.saved
-
-      - name: Generate new manual pages
-        run: make -C programs man
-
-      - name: Compare man pages
-        run: |
-          for file in zstd.1 zstdgrep.1 zstdless.1; do
-            if ! cmp -s programs/$file programs/$file.saved; then
-              echo "The man page $file should have been updated."
-              exit 1
-            fi
-          done

.github/workflows/scorecards.yml

@@ -1,64 +0,0 @@
-name: Scorecards supply-chain security
-on:
-  # Only the default branch is supported.
-  branch_protection_rule:
-  schedule:
-    - cron: '22 21 * * 2'
-  push:
-    # TODO: Add release branch when supported?
-    branches: [ "dev" ]
-
-# Declare default permissions as read only.
-permissions: read-all
-
-jobs:
-  analysis:
-    name: Scorecards analysis
-    if: github.repository == 'facebook/zstd'
-    runs-on: ubuntu-latest
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Used to receive a badge.
-      id-token: write
-      # Needs for private repositories.
-      contents: read
-      actions: read
-
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-        with:
-          persist-credentials: false
-
-      - name: "Run analysis"
-        uses: ossf/scorecard-action@f49aabe0b5af0936a0987cfb85d86b75731b0186 # tag=v2.4.1
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          # (Optional) Read-only PAT token. Uncomment the `repo_token` line below if:
-          # - you want to enable the Branch-Protection check on a *public* repository, or
-          # - you are installing Scorecards on a *private* repository
-          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-pat.
-          # repo_token: ${{ secrets.SCORECARD_READ_TOKEN }}
-
-          # Publish the results for public repositories to enable scorecard badges. For more details, see
-          # https://github.com/ossf/scorecard-action#publishing-results.
-          # For private repositories, `publish_results` will automatically be set to `false`, regardless
-          # of the value entered here.
-          publish_results: true
-
-      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
-      # format to the repository Actions tab.
-      - name: "Upload artifact"
-        uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # tag=v4.3.1
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      # Upload the results to GitHub's code scanning dashboard.
-      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@9e8d0789d4a0fa9ceb6b1738f7e269594bdd67f0 # tag=v3.28.9
-        with:
-          sarif_file: results.sarif

.github/workflows/windows-artifacts.yml

@@ -1,81 +0,0 @@
-name: windows-artifacts
-
-on:
-  push:
-    branches: [ test_artifacts, win_artifacts, release ]
-  release:
-    types:
-      - published
-
-permissions: read-all
-
-jobs:
-  windows-artifacts:
-    permissions:
-      contents: write # to fetch code and upload artifacts
-    # see https://ariya.io/2020/07/on-github-actions-with-msys2
-    runs-on: windows-latest
-    # see https://github.com/msys2/setup-msys2
-    strategy:
-      matrix:
-        include:
-          - { msystem: mingw64, env: x86_64, ziparch: win64 }
-          - { msystem: mingw32, env: i686, ziparch: win32 }
-    defaults:
-      run:
-        shell: msys2 {0}
-    steps:
-    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2
-    - uses: msys2/setup-msys2@40677d36a502eb2cf0fb808cc9dec31bf6152638 # tag=v2.28.0
-      with:
-        msystem: ${{ matrix.msystem }}
-        install: make p7zip git mingw-w64-${{matrix.env}}-gcc
-        update: true
-
-    - name: display versions
-      run: |
-        make -v
-        cc -v
-
-    - name: Building zlib to static link
-      run: |
-        git clone --depth 1 --branch v1.3.1 https://github.com/madler/zlib
-        make -C zlib -f win32/Makefile.gcc libz.a
-
-    - name: Building lz4 to static link
-      run: |
-        git clone --depth 1 --branch v1.10.0 https://github.com/lz4/lz4
-        # ensure both libraries use the same version of libxxhash
-        cp lib/common/xxhash.* lz4/lib
-        CPPFLAGS=-DXXH_NAMESPACE=LZ4_ make -C lz4/lib liblz4.a V=1
-
-    - name: Building zstd programs
-      run: |
-        CPPFLAGS="-I../zlib -I../lz4/lib" LDFLAGS=-static make -j allzstd V=1 HAVE_ZLIB=1 HAVE_LZ4=1 HAVE_LZMA=0 LDLIBS="../zlib/libz.a ../lz4/lib/liblz4.a"
-
-    - name: Create artifacts
-      run: |
-        ./lib/dll/example/build_package.bat || exit 1
-        mv bin/ zstd-${{ github.ref_name }}-${{matrix.ziparch}}/
-
-    - name: Publish zstd-$VERSION-${{matrix.ziparch}}.zip for manual inspection
-      uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # tag=v4.3.1
-      with:
-        compression-level: 9  # maximum compression
-        if-no-files-found: error # defaults to `warn`
-        path: ${{ github.workspace }}/zstd-${{ github.ref_name }}-${{matrix.ziparch}}/
-        name: zstd-${{ github.ref_name }}-${{matrix.ziparch}}
-
-    - name: Package artifact for upload
-      run: |
-        7z a -tzip -mx9 "$(cygpath -u '${{ github.workspace }}/zstd-${{ github.ref_name }}-${{ matrix.ziparch }}.zip')" "$(cygpath -u '${{ github.workspace }}/zstd-${{ github.ref_name }}-${{ matrix.ziparch }}')"
-
-    - name: Upload release asset
-      if: github.event_name == 'release'
-      shell: pwsh
-      env:
-        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        gh release upload "${{ github.ref_name }}" "$env:GITHUB_WORKSPACE/zstd-${{ github.ref_name }}-${{ matrix.ziparch }}.zip" --clobber
-
-

.gitignore

@@ -12,8 +12,6 @@
 *.so
 *.so.*
 *.dylib
-*.framework
-*.xcframework
 
 # Executables
 /zstd
@@ -24,32 +22,22 @@ zstdmt
 
 # Test artefacts
 tmp*
-*.zst
-*.zstd
 dictionary.
 dictionary
 NUL
-cmakebuild/
-install/
 
 # Build artefacts
-contrib/linux-kernel/linux/
 projects/
 bin/
 .buckd/
 buck-out/
 build-*
-*.gcda
-
-# IDE
-.clang_complete
-compile_flags.txt
-.clang-format
 
 # Other files
 .directory
 _codelite/
 _zstdbench/
+.clang_complete
 *.idea
 *.swp
 .DS_Store
@@ -59,5 +47,3 @@ googletest/
 *.code-workspace
 compile_commands.json
 .clangd
-perf.data
-perf.data.old

.travis.yml

@@ -0,0 +1,280 @@
+# Medium Tests: Run on all commits/PRs to dev branch
+
+language: c
+
+git:
+  depth: 1
+
+branches:
+  only:
+  - dev
+  - master
+  - travisTest
+
+addons:
+  apt:
+    update: true
+
+env:
+  global:
+    - FUZZERTEST=-T2mn
+      ZSTREAM_TESTTIME=-T2mn
+      DECODECORPUS_TESTTIME=-T1mn
+
+
+matrix:
+  fast_finish: true
+  include:
+    - name: icc
+      compiler: icc
+      env:
+      - C_COMPILER=icc
+      - CXX_COMPILER=icpc
+      install:
+      - source /opt/intel/inteloneapi/compiler/latest/env/vars.sh
+      addons:
+        apt:
+          sources:
+          - sourceline: 'deb https://apt.repos.intel.com/oneapi all main'
+            key_url: 'https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB'
+          packages:
+          - intel-oneapi-icc
+      script: make check
+
+    - name: arm64    # ~2.5 mn
+      os: linux
+      arch: arm64
+      script:
+        - make check
+
+    - name: make benchmarking
+      script:
+        - make benchmarking
+
+    - name: make test (complete)
+      script:
+        # DEVNULLRIGHTS : will request sudo rights to test permissions on /dev/null
+        - DEVNULLRIGHTS=test make test
+
+    - name: gcc-6 + gcc-7 + libzstdmt compilation   # ~ 6mn
+      script:
+        - make gcc6install gcc7install
+        - CC=gcc-6 CFLAGS=-Werror make -j all
+        - make clean
+        - CC=gcc-7 CFLAGS=-Werror make -j all
+        - make clean
+        - LDFLAGS=-Wl,--no-undefined make -C lib libzstd-mt
+        - make -C tests zbufftest-dll
+        # LDFLAGS=-Wl,--no-undefined : will make the linker fail if dll is underlinked
+        # zbufftest-dll : test that a user program can link to multi-threaded libzstd without specifying -pthread
+
+    - name: gcc-8 + ASan + UBSan + Test Zstd   # ~6.5mn
+      script:
+        - make gcc8install
+        - CC=gcc-8 CFLAGS="-Werror" make -j all
+        - make clean
+        - CC=gcc-8 make -j uasan-test-zstd </dev/null   # test when stdin is not a tty
+
+    - name: gcc-6 + ASan + UBSan + Test Zstd, 32bit mode    # ~4mn
+      script:
+        - make gcc6install libc6install
+        - CC=gcc-6 CFLAGS="-Werror -m32" make -j all32
+        - make clean
+        - CC=gcc-6 make -j uasan-test-zstd32   # note : can complain about pointer overflow
+
+    - name: clang-3.8 + MSan + Test Zstd    # ~3.5mn
+      script:
+        - make clang38install
+        # External libraries must be turned off when using MSAN tests,
+        # because they are not msan-instrumented,
+        # so any data coming from these libraries is always considered "uninitialized"
+        - CC=clang-3.8 make clean msan-test-zstd HAVE_ZLIB=0 HAVE_LZ4=0 HAVE_LZMA=0
+
+    - name: Minimal Decompressor Macros    # ~5mn
+      script:
+        - make clean
+        - make -j all check ZSTD_LIB_MINIFY=1 MOREFLAGS="-Werror"
+        - make clean
+        - make -j all check MOREFLAGS="-Werror -DHUF_FORCE_DECOMPRESS_X1 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT"
+        - make clean
+        - make -j all check MOREFLAGS="-Werror -DHUF_FORCE_DECOMPRESS_X2 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG"
+        - make clean
+        - make -j all check MOREFLAGS="-Werror -DZSTD_NO_INLINE -DZSTD_STRIP_ERROR_STRINGS"
+
+    - name: cmake build and test check    # ~6mn
+      script:
+        - make cmakebuild
+
+    - name: static analyzer scanbuild    # ~26mn
+      dist: trusty  # note : it's important to pin down a version of static analyzer, since different versions report different false positives
+      script:
+        - make staticAnalyze
+
+    - name: gcc-8 + ASan + UBSan + Fuzz Test    # ~19mn
+      script:
+        - make gcc8install
+        - CC=gcc-8 make clean uasan-fuzztest
+
+    - name: gcc-6 + ASan + UBSan + Fuzz Test 32bit    # ~15.5mn
+      script:
+        - make gcc6install libc6install
+        - CC=gcc-6 CFLAGS="-O2 -m32" make uasan-fuzztest   # can complain about pointer overflow
+
+    - name: clang-3.8 + MSan + Fuzz Test     # ~14.5mn
+      script:
+        - make clang38install
+        - CC=clang-3.8 make clean msan-fuzztest
+
+    - name: ASan + UBSan + MSan + Regression Test    # ~ 4.5mn
+      script:
+        - make -j uasanregressiontest
+        - make clean
+        - make -j msanregressiontest
+
+    - name: C++, gnu90 and c99 compatibility   # ~3mn
+      script:
+        - make cxxtest
+        - make clean
+        - make gnu90build
+        - make clean
+        - make c99build
+        - make clean
+        - make travis-install    # just ensures `make install` works
+
+    - name: mingw cross-compilation
+      script :
+        - sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix;
+        - CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++ CFLAGS="-Werror -O1" make zstd
+
+    - name: Valgrind + Fuzz Test Stack Mode    # ~ 7mn
+      script:
+        - make valgrindinstall
+        - make -C tests clean valgrindTest
+        - make clean
+        - make -C tests test-fuzzer-stackmode
+
+    - name: Qemu ARM emulation + Fuzz Test    # ~13.5mn
+      script:
+        - make arminstall
+        - make armfuzz
+
+    # Introduced to check compat with old toolchains, to prevent e.g. #1872
+    - name: ARM Build Test (on Trusty)
+      dist: trusty
+      script:
+        - make arminstall
+        - make armbuild
+
+    - name: Qemu PPC + Fuzz Test    # ~13mn
+      dist: trusty   # it seems ppc cross-compilation fails on "current"
+      script:
+        - make ppcinstall
+        - make ppcfuzz
+
+    # check release number (release only)
+    - name: Tag-Specific Test
+      if: tag =~ ^v[0-9]\.[0-9]
+      script:
+        - make -C tests checkTag
+        - tests/checkTag "$TRAVIS_BRANCH"
+
+    # tests for master branch and cron job only
+    - name: OS-X    # ~13mn
+      if: branch = master
+      os: osx
+      script:
+        - make test
+        - make -C lib all
+
+    - name: zbuff test
+      if: branch = master
+      script:
+        - make -C tests test-zbuff
+
+    - name: Versions Compatibility Test   # 11.5mn
+      if: branch = master
+      script:
+        - make -C tests versionsTest
+
+    - name: thread sanitizer   # ~29mn
+      if: branch = master
+      script:
+        - make clang38install
+        - CC=clang-3.8 make tsan-test-zstream
+        - CC=clang-3.8 make tsan-fuzztest
+
+    - name: PPC64LE + Fuzz test  # ~13mn
+      if: branch = master
+      arch: ppc64le
+      script:
+        - cat /proc/cpuinfo
+        - make test
+
+    - name: Qemu PPC64 + Fuzz test  # ~13mn, presumed Big-Endian (?)
+      dist: trusty  # note : PPC64 cross-compilation for Qemu tests seems broken on Xenial
+      if: branch = master
+      script:
+        - make ppcinstall
+        - make ppc64fuzz
+
+    # note : we already have aarch64 tests on hardware
+    - name: Qemu aarch64 + Fuzz Test (on Xenial)    # ~14mn
+      if: branch = master
+      dist: xenial
+      script:
+        - make arminstall
+        - make aarch64fuzz
+
+    - name: zlib wrapper test    # ~7.5mn
+      if: branch = master
+      script:
+        - make gpp6install valgrindinstall
+        - make -C zlibWrapper test
+        - make -C zlibWrapper valgrindTest
+
+    - name: LZ4, thread pool, and partial libs tests    # ~2mn
+      if: branch = master
+      script:
+        - make lz4install
+        - make -C tests test-lz4
+        - make clean
+        - make -C tests test-pool
+        - make clean
+        - bash tests/libzstd_partial_builds.sh
+
+    # meson dedicated test
+    - name: Xenial (Meson + clang)    # ~15mn
+      if: branch = master
+      dist: xenial
+      language: cpp
+      compiler: clang
+      install:
+        - sudo apt-get install -qq liblz4-dev valgrind tree
+        - |
+          travis_retry curl -o ~/ninja.zip -L 'https://github.com/ninja-build/ninja/releases/download/v1.9.0/ninja-linux.zip' &&
+          unzip ~/ninja.zip -d ~/.local/bin
+        - |
+          travis_retry curl -o ~/get-pip.py -L 'https://bootstrap.pypa.io/get-pip.py' &&
+          python3 ~/get-pip.py --user &&
+          pip3 install --user meson
+      script:
+        - |
+          meson setup \
+            --buildtype=debugoptimized \
+            -Db_lundef=false \
+            -Dauto_features=enabled \
+            -Dbin_programs=true \
+            -Dbin_tests=true \
+            -Dbin_contrib=true \
+            -Ddefault_library=both \
+             build/meson builddir
+        - pushd builddir
+        - ninja
+        - meson test --verbose --no-rebuild
+        - DESTDIR=./staging ninja install
+        - tree ./staging
+      after_failure:
+        - cat "$TRAVIS_BUILD_DIR"/builddir/meson-logs/testlog.txt
+
+  allow_failures:
+    - env: ALLOW_FAILURES=true

CHANGELOG

@@ -1,312 +1,4 @@
-V1.5.7 (Feb 2025)
-fix: compression bug in 32-bit mode associated with long-lasting sessions
-api: new method `ZSTD_compressSequencesAndLiterals()` (#4217, #4232)
-api: `ZSTD_getFrameHeader()` works on skippable frames (#4228)
-perf: substantial compression speed improvements (up to +30%) on small data, by @TocarIP (#4144) and @cyan4973 (#4165)
-perf: improved compression speed (~+5%) for dictionary compression at low levels (#4170)
-perf: much faster speed for `--patch-from` at high compression levels (#4276)
-perf: higher `--patch-from` compression ratios, notably at high levels (#4288)
-perf: better speed for binaries on Windows (@pps83) and when compiled with Visual Studio (@MessyHack)
-perf: slight compression ratio improvement thanks to better block boundaries (#4136, #4176, #4178)
-perf: slight compression ratio improvement for `dfast`, aka levels 3 and 4 (#4171)
-perf: runtime bmi2 detection enabled on x86 32-bit mode (#4251)
-cli: multi-threading as default CLI setting, by @daniellerozenblit
-cli: new `--max` command (#4290)
-build: improve `msbuild` version autodetection, support VS2022, by @ManuelBlanc
-build: fix `meson` build by @artem and @Victor-C-Zhang, and on Windows by @bgilbert
-build: compatibility with Apple Framework, by @Treata11
-build: improve icc/icx compatibility, by @josepho0918 and @luau-project
-build: improve compatibility with Android NDK, by Adenilson Cavalcanti
-portability: linux kernel branch, with improved support for Sequence producers (@embg, @gcabiddu, @cyan4973)
-portability: improved qnx compatibility, suggested by @rainbowball
-portability: improved install script for FreeBSD, by @sunpoet
-portability: fixed test suite compatibility with gnu hurd, by @diegonc
-doc: clarify specification, by @elasota
-misc: improved tests/decodecorpus validation tool (#4102), by antmicro
-
-V1.5.6 (Mar 2024)
-api: Promote `ZSTD_c_targetCBlockSize` to Stable API by @felixhandte
-api: new `ZSTD_d_maxBlockSize` experimental parameter, to reduce streaming decompression memory, by @terrelln
-perf: improve performance of param `ZSTD_c_targetCBlockSize`, by @Cyan4973
-perf: improved compression of arrays of integers at high compression, by @Cyan4973
-lib: reduce binary size with selective build-time exclusion, by @felixhandte
-lib: improved huffman speed on small data and linux kernel, by @terrelln
-lib: accept dictionaries with partial literal tables, by @terrelln
-lib: fix CCtx size estimation with external sequence producer, by @embg
-lib: fix corner case decoder behaviors, by @Cyan4973 and @aimuz
-lib: fix zdict prototype mismatch in static_only mode, by @ldv-alt
-lib: fix several bugs in magicless-format decoding, by @embg
-cli: add common compressed file types to `--exclude-compressed`` by @daniellerozenblit
-cli: fix mixing `-c` and `-o` commands with `--rm`, by @Cyan4973
-cli: fix erroneous exclusion of hidden files with `--output-dir-mirror` by @felixhandte
-cli: improved time accuracy on BSD, by @felixhandte
-cli: better errors on argument parsing, by @KapJI
-tests: better compatibility with older versions of `grep`, by @Cyan4973
-tests: lorem ipsum generator as default backup content, by @Cyan4973
-build: cmake improvements by @terrelln, @sighingnow, @gjasny, @JohanMabille, @Saverio976, @gruenich, @teo-tsirpanis
-build: bazel support, by @jondo2010
-build: fix cross-compiling for AArch64 with lld by @jcelerier
-build: fix Apple platform compatibility, by @nidhijaju
-build: fix Visual 2012 and lower compatibility, by @Cyan4973
-build: improve win32 support, by @DimitriPapadopoulos
-build: better C90 compliance for zlibWrapper, by @emaste
-port: make: fat binaries on macos, by @mredig
-port: ARM64EC compatibility for Windows, by @dunhor
-port: QNX support by @klausholstjacobsen
-port: MSYS2 and Cygwin makefile installation and test support, by @QBos07
-port: risc-v support validation in CI, by @Cyan4973
-port: sparc64 support validation in CI, by @Cyan4973
-port: AIX compatibility, by @likema
-port: HP-UX compatibility, by @likema
-doc: Improved specification accuracy, by @elasota
-bug: Fix and deprecate ZSTD_generateSequences (#3981)
-
-v1.5.5 (Apr 2023)
-fix: fix rare corruption bug affecting the high compression mode, reported by @danlark1 (#3517, @terrelln)
-perf: improve mid-level compression speed (#3529, #3533, #3543, @yoniko and #3552, @terrelln)
-lib: deprecated bufferless block-level API (#3534) by @terrelln
-cli: mmap large dictionaries to save memory, by @daniellerozenblit
-cli: improve speed of --patch-from mode (~+50%) (#3545) by @daniellerozenblit
-cli: improve i/o speed (~+10%) when processing lots of small files (#3479) by @felixhandte
-cli: zstd no longer crashes when requested to write into write-protected directory (#3541) by @felixhandte
-cli: fix decompression into block device using -o, reported by @georgmu (#3583)
-build: fix zstd CLI compiled with lzma support but not zlib support (#3494) by @Hello71
-build: fix cmake does no longer require 3.18 as minimum version (#3510) by @kou
-build: fix MSVC+ClangCL linking issue (#3569) by @tru
-build: fix zstd-dll, version of zstd CLI that links to the dynamic library (#3496) by @yoniko
-build: fix MSVC warnings (#3495) by @embg
-doc: updated zstd specification to clarify corner cases, by @Cyan4973
-doc: document how to create fat binaries for macos (#3568) by @rickmark
-misc: improve seekable format ingestion speed (~+100%) for very small chunk sizes (#3544) by @Cyan4973
-misc: tests/fullbench can benchmark multiple files (#3516) by @dloidolt
-
-v1.5.4 (Feb 2023)
-perf: +20% faster huffman decompression for targets that can't compile x64 assembly (#3449, @terrelln)
-perf: up to +10% faster streaming compression at levels 1-2 (#3114, @embg)
-perf: +4-13% for levels 5-12 by optimizing function generation (#3295, @terrelln)
-pref: +3-11% compression speed for `arm` target (#3199, #3164, #3145, #3141, #3138, @JunHe77 and #3139, #3160, @danlark1)
-perf: +5-30% faster dictionary compression at levels 1-4 (#3086, #3114, #3152, @embg)
-perf: +10-20% cold dict compression speed by prefetching CDict tables (#3177, @embg)
-perf: +1% faster compression by removing a branch in ZSTD_fast_noDict (#3129, @felixhandte)
-perf: Small compression ratio improvements in high compression mode (#2983, #3391, @Cyan4973 and #3285, #3302, @daniellerozenblit)
-perf: small speed improvement by better detecting `STATIC_BMI2` for `clang` (#3080, @TocarIP)
-perf: Improved streaming performance when `ZSTD_c_stableInBuffer` is set (#2974, @Cyan4973)
-cli: Asynchronous I/O for improved cli speed (#2975, #2985, #3021, #3022, @yoniko)
-cli: Change `zstdless` behavior to align with `zless` (#2909, @binhdvo)
-cli: Keep original file if `-c` or `--stdout` is given (#3052, @dirkmueller)
-cli: Keep original files when result is concatenated into a single output with `-o` (#3450, @Cyan4973)
-cli: Preserve Permissions and Ownership of regular files (#3432, @felixhandte)
-cli: Print zlib/lz4/lzma library versions with `-vv` (#3030, @terrelln)
-cli: Print checksum value for single frame files with `-lv`  (#3332, @Cyan4973)
-cli: Print `dictID` when present with `-lv` (#3184, @htnhan)
-cli: when `stderr` is *not* the console, disable status updates, but preserve final summary (#3458, @Cyan4973)
-cli: support `--best` and `--no-name` in `gzip` compatibility mode (#3059, @dirkmueller)
-cli: support for `posix` high resolution timer `clock_gettime()`, for improved benchmark accuracy (#3423, @Cyan4973)
-cli: improved help/usage (`-h`,  `-H`) formatting (#3094, @dirkmueller and #3385, @jonpalmisc)
-cli: Fix better handling of bogus numeric values (#3268, @ctkhanhly)
-cli: Fix input consists of multiple files _and_ `stdin` (#3222, @yoniko)
-cli: Fix tiny files passthrough (#3215, @cgbur)
-cli: Fix for `-r` on empty directory (#3027, @brailovich)
-cli: Fix empty string as argument for `--output-dir-*` (#3220, @embg)
-cli: Fix decompression memory usage reported by `-vv --long` (#3042, @u1f35c, and #3232, @zengyijing)
-cli: Fix infinite loop when empty input is passed to trainer (#3081, @terrelln)
-cli: Fix `--adapt` doesn't work when `--no-progress` is also set (#3354, @terrelln)
-api: Support for Block-Level Sequence Producer (#3333, @embg)
-api: Support for in-place decompression (#3432, @terrelln)
-api: New  `ZSTD_CCtx_setCParams()`  function, set all parameters defined in a  `ZSTD_compressionParameters`  structure (#3403, @Cyan4973)
-api: Streaming decompression detects incorrect header ID sooner (#3175, @Cyan4973)
-api: Window size resizing optimization for edge case (#3345, @daniellerozenblit)
-api: More accurate error codes for busy-loop scenarios (#3413, #3455, @Cyan4973)
-api: Fix limit overflow in `compressBound` and `decompressBound` (#3362, #3373, Cyan4973) reported by @nigeltao
-api: Deprecate several advanced experimental functions: streaming (#3408, @embg), copy (#3196, @mileshu)
-bug: Fix corruption that rarely occurs in 32-bit mode with wlog=25 (#3361, @terrelln)
-bug: Fix for block-splitter (#3033, @Cyan4973)
-bug: Fixes for Sequence Compression API (#3023, #3040, @Cyan4973)
-bug: Fix leaking thread handles on Windows (#3147, @animalize)
-bug: Fix timing issues with cmake/meson builds (#3166, #3167, #3170, @Cyan4973)
-build: Allow user to select legacy level for cmake (#3050, @shadchin)
-build: Enable legacy support by default in cmake (#3079, @niamster)
-build: Meson build script improvements (#3039, #3120, #3122, #3327, #3357, @eli-schwartz and #3276, @neheb)
-build: Add aarch64 to supported architectures for zstd_trace (#3054, @ooosssososos)
-build: support AIX architecture (#3219, @qiongsiwu)
-build: Fix `ZSTD_LIB_MINIFY` build macro, which now reduces static library size by half (#3366, @terrelln)
-build: Fix Windows issues with Multithreading translation layer (#3364, #3380, @yoniko) and ARM64 target (#3320, @cwoffenden)
-build: Fix `cmake` script (#3382, #3392, @terrelln and #3252 @Tachi107 and #3167 @Cyan4973)
-doc: Updated man page, providing more details for `--train` mode (#3112, @Cyan4973)
-doc: Add decompressor errata document (#3092, @terrelln)
-misc: Enable Intel CET (#2992, #2994, @hjl-tools)
-misc: Fix `contrib/` seekable format (#3058, @yhoogstrate and #3346, @daniellerozenblit)
-misc: Improve speed of the one-file library generator (#3241, @wahern and #3005, @cwoffenden)
-
-v1.5.3 (dev version, unpublished)
-
-v1.5.2 (Jan, 2022)
-perf: Regain Minimal memset()-ing During Reuse of Compression Contexts (@Cyan4973, #2969)
-build: Build Zstd with `noexecstack` on All Architectures (@felixhandte, #2964)
-doc: Clarify Licensing (@terrelln, #2981)
-
-v1.5.1 (Dec, 2021)
-perf: rebalanced compression levels, to better match the intended speed/level curve, by @senhuang42
-perf: faster huffman decoder, using x64 assembly, by @terrelln
-perf: slightly faster high speed modes (strategies fast & dfast), by @felixhandte
-perf: improved binary size and faster compilation times, by @terrelln
-perf: new row64 mode, used notably in level 12, by @senhuang42
-perf: faster mid-level compression speed in presence of highly repetitive patterns, by @senhuang42
-perf: minor compression ratio improvements for small data at high levels, by @cyan4973
-perf: reduced stack usage (mostly useful for Linux Kernel), by @terrelln
-perf: faster compression speed on incompressible data, by @bindhvo
-perf: on-demand reduced ZSTD_DCtx state size, using build macro ZSTD_DECODER_INTERNAL_BUFFER, at a small cost of performance, by @bindhvo
-build: allows hiding static symbols in the dynamic library, using build macro, by @skitt
-build: support for m68k (Motorola 68000's), by @cyan4973
-build: improved AIX support, by @Helflym
-build: improved meson unofficial build, by @eli-schwartz
-cli : custom memory limit when training dictionary (#2925), by @embg
-cli : report advanced parameters information when compressing in very verbose mode (`-vv`), by @Svetlitski-FB
-
-v1.5.0  (May 11, 2021)
-api: Various functions promoted from experimental to stable API: (#2579-2581, @senhuang42)
-  `ZSTD_defaultCLevel()`
-  `ZSTD_getDictID_fromCDict()`
-api: Several experimental functions have been deprecated and will emit a compiler warning (#2582, @senhuang42)
-  `ZSTD_compress_advanced()`
-  `ZSTD_compress_usingCDict_advanced()`
-  `ZSTD_compressBegin_advanced()`
-  `ZSTD_compressBegin_usingCDict_advanced()`
-  `ZSTD_initCStream_srcSize()`
-  `ZSTD_initCStream_usingDict()`
-  `ZSTD_initCStream_usingCDict()`
-  `ZSTD_initCStream_advanced()`
-  `ZSTD_initCStream_usingCDict_advanced()`
-  `ZSTD_resetCStream()`
-api: ZSTDMT_NBWORKERS_MAX reduced to 64 for 32-bit environments (@Cyan4973)
-perf: Significant speed improvements for middle compression levels (#2494, @senhuang42 @terrelln)
-perf: Block splitter to improve compression ratio, enabled by default for high compression levels (#2447, @senhuang42)
-perf: Decompression loop refactor, speed improvements on `clang` and for `--long` modes (#2614 #2630, @Cyan4973)
-perf: Reduced stack usage during compression and decompression entropy stage (#2522 #2524, @terrelln)
-bug: Improve setting permissions of created files (#2525, @felixhandte)
-bug: Fix large dictionary non-determinism (#2607, @terrelln)
-bug: Fix non-determinism test failures on Linux i686 (#2606, @terrelln)
-bug: Fix various dedicated dictionary search bugs (#2540 #2586, @senhuang42 @felixhandte)
-bug: Ensure `ZSTD_estimateCCtxSize*() `monotonically increases with compression level (#2538, @senhuang42)
-bug: Fix --patch-from mode parameter bound bug with small files (#2637, @occivink)
-bug: Fix UBSAN error in decompression (#2625, @terrelln)
-bug: Fix superblock compression divide by zero bug (#2592, @senhuang42)
-bug: Make the number of physical CPU cores detection more robust (#2517, @PaulBone)
-doc: Improve `zdict.h` dictionary training API documentation (#2622, @terrelln)
-doc: Note that public `ZSTD_free*()` functions accept NULL pointers (#2521, @animalize)
-doc: Add style guide docs for open source contributors (#2626, @Cyan4973)
-tests: Better regression test coverage for different dictionary modes (#2559, @senhuang42)
-tests: Better test coverage of index reduction (#2603, @terrelln)
-tests: OSS-Fuzz coverage for seekable format (#2617, @senhuang42)
-tests: Test coverage for ZSTD threadpool API (#2604, @senhuang42)
-build: Dynamic library built multithreaded by default (#2584, @senhuang42)
-build: Move  `zstd_errors.h`  and  `zdict.h`  to  `lib/`  root (#2597, @terrelln)
-build: Allow `ZSTDMT_JOBSIZE_MIN` to be configured at compile-time, reduce default to 512KB (#2611, @Cyan4973)
-build: Single file library build script moved to `build/` directory (#2618, @felixhandte)
-build: `ZBUFF_*()` is no longer built by default (#2583, @senhuang42)
-build: Fixed Meson build (#2548, @SupervisedThinking @kloczek)
-build: Fix excessive compiler warnings with clang-cl and CMake (#2600, @nickhutchinson)
-build: Detect presence of `md5` on Darwin (#2609, @felixhandte)
-build: Avoid SIGBUS on armv6 (#2633, @bmwiedmann)
-cli: `--progress` flag added to always display progress bar (#2595, @senhuang42)
-cli: Allow reading from block devices with `--force` (#2613, @felixhandte)
-cli: Fix CLI filesize display bug (#2550, @Cyan4973)
-cli: Fix windows CLI `--filelist` end-of-line bug (#2620, @Cyan4973)
-contrib: Various fixes for linux kernel patch (#2539, @terrelln)
-contrib: Seekable format - Decompression hanging edge case fix (#2516, @senhuang42)
-contrib: Seekable format - New seek table-only API  (#2113 #2518, @mdittmer @Cyan4973)
-contrib: Seekable format - Fix seek table descriptor check when loading (#2534, @foxeng)
-contrib: Seekable format - Decompression fix for large offsets, (#2594, @azat)
-misc: Automatically published release tarballs available on Github (#2535, @felixhandte)
-
-v1.4.9  (Mar 1, 2021)
-bug: Use `umask()` to Constrain Created File Permissions (#2495, @felixhandte)
-bug: Make Simple Single-Pass Functions Ignore Advanced Parameters (#2498, @terrelln)
-api: Add (De)Compression Tracing Functionality (#2482, @terrelln)
-api: Support References to Multiple DDicts (#2446, @senhuang42)
-api: Add Function to Generate Skippable Frame (#2439, @senhuang42)
-perf: New Algorithms for the Long Distance Matcher (#2483, @mpu)
-perf: Performance Improvements for Long Distance Matcher (#2464, @mpu)
-perf: Don't Shrink Window Log when Streaming with a Dictionary (#2451, @terrelln)
-cli: Fix `--output-dir-mirror` rejection of `..` -containing paths (#2512, @felixhandte)
-cli: Allow Input From Console When `-f`/`--force` is Passed (#2466, @felixhandte)
-cli: Improve Help Message (#2500, @senhuang42)
-tests: Remove Flaky Tests (#2455, #2486, #2445, @Cyan4973)
-tests: Correctly Invoke md5 Utility on NetBSD (#2492, @niacat)
-tests: Avoid Using `stat -c` on NetBSD (#2513, @felixhandte)
-build: Zstd CLI Can Now be Linked to Dynamic `libzstd` (#2457, #2454 @Cyan4973)
-build: Hide and Avoid Using Static-Only Symbols (#2501, #2504, @skitt)
-build: CMake: Enable Only C for lib/ and programs/ Projects (#2498, @concatime)
-build: CMake: Use `configure_file()` to Create the `.pc` File (#2462, @lazka)
-build: Fix Fuzzer Compiler Detection & Update UBSAN Flags (#2503, @terrelln)
-build: Add Guards for `_LARGEFILE_SOURCE` and `_LARGEFILE64_SOURCE` (#2444, @indygreg)
-build: Improve `zlibwrapper` Makefile (#2437, @Cyan4973)
-contrib: Add `recover_directory` Program (#2473, @terrelln)
-doc: Change License Year to 2021 (#2452 & #2465, @terrelln & @senhuang42)
-doc: Fix Typos (#2459, @ThomasWaldmann)
-
-v1.4.8  (Dec 18, 2020)
-hotfix: wrong alignment of an internal buffer
-
-v1.4.7  (Dec 16, 2020)
-perf: stronger --long mode at high compression levels, by @senhuang42
-perf: stronger --patch-from at high compression levels, thanks to --long improvements
-perf: faster dictionary compression at medium compression levels, by @felixhandte
-perf: small speed & memory usage improvements for ZSTD_compress2(), by @terrelln
-perf: improved fast compression speeds with Visual Studio, by @animalize
-cli : Set nb of threads with environment variable ZSTD_NBTHREADS, by @senhuang42
-cli : accept decompressing files with *.zstd suffix
-cli : provide a condensed summary by default when processing multiple files
-cli : fix : stdin input no longer confused as user prompt
-cli : improve accuracy of several error messages
-api : new sequence ingestion API, by @senhuang42
-api : shared thread pool: control total nb of threads used by multiple compression jobs, by @marxin
-api : new ZSTD_getDictID_fromCDict(), by @LuAPi
-api : zlibWrapper only uses public API, and is compatible with dynamic library, by @terrelln
-api : fix : multithreaded compression has predictable output even in special cases (see #2327) (issue not accessible from cli)
-api : fix : dictionary compression correctly respects dictionary compression level (see #2303) (issue not accessible from cli)
-build: fix cmake script when using path with spaces, by @terrelln
-build: improved compile-time detection of aarch64/neon platforms, by @bsdimp
-build: Fix building on AIX 5.1, by @likema
-build: compile paramgrill with cmake on Windows, requested by @mirh
-doc : clarify repcode updates in format specification, by @felixhandte
-
-v1.4.6
-fix : Always return dstSize_tooSmall when that is the case
-fix : Fix ZSTD_initCStream_advanced() with static allocation and no dictionary
-perf: Improve small block decompression speed by 20%+, by @terrelln
-perf: Reduce compression stack usage by 1 KB, by @terrelln
-perf: Improve decompression speed by improving ZSTD_wildcopy, by @helloguo (#2252, #2256)
-perf: Improve histogram construction, by @cyan4973 (#2253)
-cli : Add --output-dir-mirror option, by @xxie24 (#2219)
-cli : Warn when (de)compressing multiple files into a single output, by @senhuang42 (#2279)
-cli : Improved progress bar and status summary when (de)compressing multiple files, by @senhuang42 (#2283)
-cli : Call stat less often, by @felixhandte (#2262)
-cli : Allow --patch-from XXX and --filelist XXX in addition to --patch-from=XXX and --filelist=XXX, by @cyan4973 (#2250)
-cli : Allow --patch-from to compress stdin with --stream-size, by @bimbashrestha (#2206)
-api : Do not install zbuff.h, since it has long been deprecated, by @cyan4973 (#2166).
-api : Fix ZSTD_CCtx_setParameter() with ZSTD_c_compressionLevel to make 0 mean default level, by @i-do-cpp (#2291)
-api : Rename ZSTDMT_NBTHREADS_MAX to ZSTDMT_NBWORKERS_MAX, by @marxin (#2228).
-build: Install pkg-config file with CMake and MinGW, by @tonytheodore (#2183)
-build: Install DLL with CMake on Windows, by @BioDataAnalysis (#2221)
-build: Fix DLL install location with CMake, by @xantares and @bimbashrestha (#2186)
-build: Add ZSTD_NO_UNUSED_FUNCTIONS macro to hide unused functions
-build: Add ZSTD_NO_INTRINSICS macro to avoid explicit intrinsics
-build: Add STATIC_BMI2 macro for compile time detection of BMI2 on MSVC, by @Niadb (#2258)
-build: Fix -Wcomma warnings, by @cwoffenden
-build: Remove distutils requirement for meson build, by @neheb (#2197)
-build: Fix cli compilation with uclibc
-build: Fix cli compilation without st_mtime, by @ffontaine (#2246)
-build: Fix shadowing warnings in library
-build: Fix single file library compilation with Enscripten, by @yoshihitoh (#2227)
-misc: Improve single file library and include dictBuilder, by @cwoffenden
-misc: Allow compression dictionaries with missing symbols
-misc: Add freestanding translation script in contrib/freestanding_lib
-misc: Collect all of zstd's libc dependencies into zstd_deps.h
-doc : Add ZSTD_versionString() to manual, by @animalize
-doc : Fix documentation for ZSTD_CCtxParams_setParameter(), by @felixhandte (#2270)
-
-v1.4.5  (May 22, 2020)
+v1.4.5
 fix : Compression ratio regression on huge files (> 3 GB) using high levels (--ultra) and multithreading, by @terrelln
 perf: Improved decompression speed: x64 : +10% (clang) / +5% (gcc); ARM : from +15% to +50%, depending on SoC, by @terrelln
 perf: Automatically downsizes ZSTD_DCtx when too large for too long (#2069, by @bimbashreshta)
@@ -332,7 +24,7 @@ misc: Edit-distance match finder in contrib/
 doc : Improved beginner CONTRIBUTING.md docs
 doc : New issue templates for zstd
 
-v1.4.4  (Nov 6, 2019)
+v1.4.4
 perf: Improved decompression speed, by > 10%, by @terrelln
 perf: Better compression speed when re-using a context, by @felixhandte
 perf: Fix compression ratio when compressing large files with small dictionary, by @senhuang42
@@ -359,18 +51,18 @@ pack: modified pkgconfig, for better integration into openwrt, requested by @neh
 misc: Improved documentation : ZSTD_CLEVEL, DYNAMIC_BMI2, ZSTD_CDict, function deprecation, zstd format
 misc: fixed educational decoder : accept larger literals section, and removed UNALIGNED() macro
 
-v1.4.3  (Aug 20, 2019)
+v1.4.3
 bug: Fix Dictionary Compression Ratio Regression by @cyan4973 (#1709)
 bug: Fix Buffer Overflow in legacy v0.3 decompression by @felixhandte (#1722)
 build: Add support for IAR C/C++ Compiler for Arm by @joseph0918 (#1705)
 
-v1.4.2  (Jul 26, 2019)
+v1.4.2
 bug: Fix bug in zstd-0.5 decoder by @terrelln (#1696)
 bug: Fix seekable decompression in-memory API by @iburinoc (#1695)
 misc: Validate blocks are smaller than size limit by @vivekmg (#1685)
 misc: Restructure source files by @ephiepark (#1679)
 
-v1.4.1  (Jul 20, 2019)
+v1.4.1
 bug: Fix data corruption in niche use cases by @terrelln (#1659)
 bug: Fuzz legacy modes, fix uncovered bugs by @terrelln (#1593, #1594, #1595)
 bug: Fix out of bounds read by @terrelln (#1590)
@@ -400,7 +92,7 @@ build: Visual Studio: fix linking by @absotively (#1639)
 build: Fix MinGW-W64 build by @myzhang1029 (#1600)
 misc: Expand decodecorpus coverage by @ephiepark (#1664)
 
-v1.4.0  (Apr 17, 2019)
+v1.4.0
 perf: Improve level 1 compression speed in most scenarios by 6% by @gbtucker and @terrelln
 api: Move the advanced API, including all functions in the staging section, to the stable section
 api: Make ZSTD_e_flush and ZSTD_e_end block for maximum forward progress
@@ -437,7 +129,7 @@ misc: Optimize dictionary memory usage in corner cases
 misc: Improve the dictionary builder on small or homogeneous data
 misc: Fix spelling across the repo by @jsoref
 
-v1.3.8  (Dec 28, 2018)
+v1.3.8
 perf: better decompression speed on large files (+7%) and cold dictionaries (+15%)
 perf: slightly better compression ratio at high compression modes
 api : finalized advanced API, last stage before "stable" status
@@ -459,14 +151,14 @@ doc : clarified zstd_compression_format.md, by @ulikunitz
 misc: fixed zstdgrep, returns 1 on failure, by @lzutao
 misc: NEWS renamed as CHANGELOG, in accordance with fboss
 
-v1.3.7  (Oct 20, 2018)
+v1.3.7
 perf: slightly better decompression speed on clang (depending on hardware target)
 fix : performance of dictionary compression for small input < 4 KB at levels 9 and 10
 build: no longer build backtrace by default in release mode; restrict further automatic mode
 build: control backtrace support through build macro BACKTRACE
 misc: added man pages for zstdless and zstdgrep, by @samrussell
 
-v1.3.6  (Oct 6, 2018)
+v1.3.6
 perf: much faster dictionary builder, by @jenniferliu
 perf: faster dictionary compression on small data when using multiple contexts, by @felixhandte
 perf: faster dictionary decompression when using a very large number of dictionaries simultaneously
@@ -480,7 +172,7 @@ build: Read Legacy format is limited to v0.5+ by default. Can be changed at comp
 doc : zstd_compression_format.md updated to match wording in IETF RFC 8478
 misc: tests/paramgrill, a parameter optimizer, by @GeorgeLu97
 
-v1.3.5  (Jun 29, 2018)
+v1.3.5
 perf: much faster dictionary compression, by @felixhandte
 perf: small quality improvement for dictionary generation, by @terrelln
 perf: slightly improved high compression levels (notably level 19)
@@ -495,7 +187,7 @@ build: make and make all are compatible with -j
 doc : clarify zstd_compression_format.md, updated for IETF RFC process
 misc: pzstd compatible with reproducible compilation, by @lamby
 
-v1.3.4  (Mar 27, 2018)
+v1.3.4
 perf: faster speed (especially decoding speed) on recent cpus (haswell+)
 perf: much better performance associating --long with multi-threading, by @terrelln
 perf: better compression at levels 13-15
@@ -513,9 +205,9 @@ build: VS2017 scripts, by @HaydnTrigg
 misc: all /contrib projects fixed
 misc: added /contrib/docker script by @gyscos
 
-v1.3.3  (Dec 21, 2017)
+v1.3.3
 perf: faster zstd_opt strategy (levels 16-19)
-fix : bug #944 : multithreading with shared dictionary and large data, reported by @gsliepen
+fix : bug #944 : multithreading with shared ditionary and large data, reported by @gsliepen
 cli : fix : content size written in header by default
 cli : fix : improved LZ4 format support, by @felixhandte
 cli : new : hidden command `-S`, to benchmark multiple files while generating one result per file
@@ -525,7 +217,7 @@ api : change : when setting `pledgedSrcSize`, use `ZSTD_CONTENTSIZE_UNKNOWN` mac
 build: fix : compilation under rhel6 and centos6, reported by @pixelb
 build: added `check` target
 
-v1.3.2  (Oct 10, 2017)
+v1.3.2
 new : long range mode, using --long command, by Stella Lau (@stellamplau)
 new : ability to generate and decode magicless frames (#591)
 changed : maximum nb of threads reduced to 200, to avoid address space exhaustion in 32-bits mode
@@ -548,7 +240,7 @@ example : added streaming_memory_usage
 license : changed /examples license to BSD + GPLv2
 license : fix a few header files to reflect new license (#825)
 
-v1.3.1  (Aug 21, 2017)
+v1.3.1
 New license : BSD + GPLv2
 perf: substantially decreased memory usage in Multi-threading mode, thanks to reports by Tino Reichardt (@mcmilk)
 perf: Multi-threading supports up to 256 threads. Cap at 256 when more are requested (#760)
@@ -563,7 +255,7 @@ new : contrib/adaptive-compression, I/O driven compression strength, by Paul Cru
 new : contrib/long_distance_matching, statistics by Stella Lau (@stellamplau)
 updated : contrib/linux-kernel, by Nick Terrell (@terrelln)
 
-v1.3.0  (Jul 6, 2017)
+v1.3.0
 cli : new : `--list` command, by Paul Cruz
 cli : changed : xz/lzma support enabled by default
 cli : changed : `-t *` continue processing list after a decompression error
@@ -578,7 +270,7 @@ tools : decodecorpus can generate random dictionary-compressed samples, by Paul
 new : contrib/seekable_format, demo and API, by Sean Purcell
 changed : contrib/linux-kernel, updated version and license, by Nick Terrell
 
-v1.2.0  (May 5, 2017)
+v1.2.0
 cli : changed : Multithreading enabled by default (use target zstd-nomt or HAVE_THREAD=0 to disable)
 cli : new : command -T0 means "detect and use nb of cores", by Sean Purcell
 cli : new : zstdmt symlink hardwired to `zstd -T0`
@@ -600,7 +292,7 @@ build: enabled Multi-threading support for *BSD, by Baptiste Daroussin
 tools: updated Paramgrill. Command -O# provides best parameters for sample and speed target.
 new : contrib/linux-kernel version, by Nick Terrell
 
-v1.1.4  (Mar 18, 2017)
+v1.1.4
 cli : new : can compress in *.gz format, using --format=gzip command, by Przemyslaw Skibinski
 cli : new : advanced benchmark command --priority=rt
 cli : fix : write on sparse-enabled file systems in 32-bits mode, by @ds77
@@ -616,7 +308,7 @@ build : improved cmake script, by @Majlen
 build : added -Wformat-security flag, as recommended by Padraig Brady
 doc : new : educational decoder, by Sean Purcell
 
-v1.1.3  (Feb 7, 2017)
+v1.1.3
 cli : zstd can decompress .gz files (can be disabled with `make zstd-nogz` or `make HAVE_ZLIB=0`)
 cli : new : experimental target `make zstdmt`, with multi-threading support
 cli : new : improved dictionary builder "cover" (experimental), by Nick Terrell, based on prior work by Giuseppe Ottaviano.
@@ -632,7 +324,7 @@ API : fix : all symbols properly exposed in libzstd, by Nick Terrell
 build : support for Solaris target, by Przemyslaw Skibinski
 doc : clarified specification, by Sean Purcell
 
-v1.1.2  (Dec 15, 2016)
+v1.1.2
 API : streaming : decompression : changed : automatic implicit reset when chain-decoding new frames without init
 API : experimental : added : dictID retrieval functions, and ZSTD_initCStream_srcSize()
 API : zbuff : changed : prototypes now generate deprecation warnings
@@ -649,7 +341,7 @@ zlib_wrapper : added support for gz* functions, by Przemyslaw Skibinski
 install : better compatibility with FreeBSD, by Dimitry Andric
 source tree : changed : zbuff source files moved to lib/deprecated
 
-v1.1.1  (Nov 2, 2016)
+v1.1.1
 New : command -M#, --memory=, --memlimit=, --memlimit-decompress= to limit allowed memory consumption
 New : doc/zstd_manual.html, by Przemyslaw Skibinski
 Improved : slightly better compression ratio at --ultra levels (>= 20)
@@ -660,7 +352,7 @@ Changed : zstd_errors.h is now installed within /include (and replaces errors_pu
 Updated man page
 Fixed : zstd-small, zstd-compress and zstd-decompress compilation targets
 
-v1.1.0  (Sep 28, 2016)
+v1.1.0
 New : contrib/pzstd, parallel version of zstd, by Nick Terrell
 added : NetBSD install target (#338)
 Improved : speed for batches of small files
@@ -674,7 +366,7 @@ Fixed : compatibility with OpenBSD, reported by Juan Francisco Cantero Hurtado (
 Fixed : compatibility with Hurd, by Przemyslaw Skibinski (#365)
 Fixed : zstd-pgo, reported by octoploid (#329)
 
-v1.0.0  (Sep 1, 2016)
+v1.0.0
 Change Licensing, all project is now BSD, Copyright Facebook
 Small decompression speed improvement
 API : Streaming API supports legacy format
@@ -683,7 +375,7 @@ CLI supports legacy formats v0.4+
 Fixed : compression fails on certain huge files, reported by Jesse McGrew
 Enhanced documentation, by Przemyslaw Skibinski
 
-v0.8.1  (Aug 18, 2016)
+v0.8.1
 New streaming API
 Changed : --ultra now enables levels beyond 19
 Changed : -i# now selects benchmark time in second
@@ -692,7 +384,7 @@ Fixed : speed regression on specific patterns (#272)
 Fixed : support for Z_SYNC_FLUSH, by Dmitry Krot (#291)
 Fixed : ICC compilation, by Przemyslaw Skibinski
 
-v0.8.0  (Aug 2, 2016)
+v0.8.0
 Improved : better speed on clang and gcc -O2, thanks to Eric Biggers
 New : Build on FreeBSD and DragonFly, thanks to JrMarino
 Changed : modified API : ZSTD_compressEnd()
@@ -705,17 +397,17 @@ Modified : minor compression level adaptations
 Updated : compression format specification to v0.2.0
 changed : zstd.h moved to /lib directory
 
-v0.7.5  (Aug 1, 2016)
+v0.7.5
 Transition version, supporting decoding of v0.8.x
 
-v0.7.4  (Jul 17, 2016)
+v0.7.4
 Added : homebrew for Mac, by Daniel Cade
 Added : more examples
 Fixed : segfault when using small dictionaries, reported by Felix Handte
 Modified : default compression level for CLI is now 3
 Updated : specification, to v0.1.1
 
-v0.7.3  (Jul 9, 2016)
+v0.7.3
 New : compression format specification
 New : `--` separator, stating that all following arguments are file names. Suggested by Chip Turner.
 New : `ZSTD_getDecompressedSize()`
@@ -727,18 +419,18 @@ fixed : multi-blocks decoding with intermediate uncompressed blocks, reported by
 modified : removed "mem.h" and "error_public.h" dependencies from "zstd.h" (experimental section)
 modified : legacy functions no longer need magic number
 
-v0.7.2  (Jul 4, 2016)
+v0.7.2
 fixed : ZSTD_decompressBlock() using multiple consecutive blocks. Reported by Greg Slazinski.
 fixed : potential segfault on very large files (many gigabytes). Reported by Chip Turner.
 fixed : CLI displays system error message when destination file cannot be created (#231). Reported by Chip Turner.
 
-v0.7.1  (Jun 23, 2016)
+v0.7.1
 fixed : ZBUFF_compressEnd() called multiple times with too small `dst` buffer, reported by Christophe Chevalier
 fixed : dictBuilder fails if first sample is too small, reported by Руслан Ковалёв
 fixed : corruption issue, reported by cj
 modified : checksum enabled by default in command line mode
 
-v0.7.0  (Jun 17, 2016)
+v0.7.0
 New : Support for directory compression, using `-r`, thanks to Przemyslaw Skibinski
 New : Command `--rm`, to remove source file after successful de/compression
 New : Visual build scripts, by Christophe Chevalier
@@ -751,7 +443,7 @@ API : support for custom malloc/free functions
 New : controllable Dictionary ID
 New : Support for skippable frames
 
-v0.6.1  (May 13, 2016)
+v0.6.1
 New : zlib wrapper API, thanks to Przemyslaw Skibinski
 New : Ability to compile compressor / decompressor separately
 Changed : new lib directory structure
@@ -761,103 +453,103 @@ Fixed : null-string roundtrip (#176)
 New : benchmark mode can select directory as input
 Experimental : midipix support, VMS support
 
-v0.6.0  (Apr 13, 2016)
+v0.6.0
 Stronger high compression modes, thanks to Przemyslaw Skibinski
 API : ZSTD_getFrameParams() provides size of decompressed content
 New : highest compression modes require `--ultra` command to fully unleash their capacity
 Fixed : zstd cli return error code > 0 and removes dst file artifact when decompression fails, thanks to Chip Turner
 
-v0.5.1  (Feb 18, 2016)
+v0.5.1
 New : Optimal parsing => Very high compression modes, thanks to Przemyslaw Skibinski
 Changed : Dictionary builder integrated into libzstd and zstd cli
 Changed (!) : zstd cli now uses "multiple input files" as default mode. See `zstd -h`.
 Fix : high compression modes for big-endian platforms
 New : zstd cli : `-t` | `--test` command
 
-v0.5.0  (Feb 5, 2016)
+v0.5.0
 New : dictionary builder utility
 Changed : streaming & dictionary API
 Improved : better compression of small data
 
-v0.4.7  (Jan 22, 2016)
+v0.4.7
 Improved : small compression speed improvement in HC mode
 Changed : `zstd_decompress.c` has ZSTD_LEGACY_SUPPORT to 0 by default
 fix : bt search bug
 
-v0.4.6  (Jan 13, 2016)
+v0.4.6
 fix : fast compression mode on Windows
 New : cmake configuration file, thanks to Artyom Dymchenko
 Improved : high compression mode on repetitive data
 New : block-level API
 New : ZSTD_duplicateCCtx()
 
-v0.4.5  (Dec 18, 2015)
+v0.4.5
 new : -m/--multiple : compress/decompress multiple files
 
-v0.4.4  (Dec 14, 2015)
+v0.4.4
 Fixed : high compression modes for Windows 32 bits
 new : external dictionary API extended to buffered mode and accessible through command line
 new : windows DLL project, thanks to Christophe Chevalier
 
-v0.4.3  (Dec 7, 2015)
+v0.4.3 :
 new : external dictionary API
 new : zstd-frugal
 
-v0.4.2  (Dec 2, 2015)
+v0.4.2 :
 Generic minor improvements for small blocks
 Fixed : big-endian compatibility, by Peter Harris (#85)
 
-v0.4.1  (Dec 1, 2015)
+v0.4.1
 Fixed : ZSTD_LEGACY_SUPPORT=0 build mode (reported by Luben)
 removed `zstd.c`
 
-v0.4.0  (Nov 29, 2015)
+v0.4.0
 Command line utility compatible with high compression levels
 Removed zstdhc => merged into zstd
 Added : ZBUFF API (see zstd_buffered.h)
 Rolling buffer support
 
-v0.3.6  (Nov 10, 2015)
+v0.3.6
 small blocks params
 
-v0.3.5  (Nov 9, 2015)
+v0.3.5
 minor generic compression improvements
 
-v0.3.4  (Nov 6, 2015)
+v0.3.4
 Faster fast cLevels
 
-v0.3.3  (Nov 5, 2015)
+v0.3.3
 Small compression ratio improvement
 
-v0.3.2  (Nov 2, 2015)
+v0.3.2
 Fixed Visual Studio
 
-v0.3.1  (Nov 2, 2015)
+v0.3.1 :
 Small compression ratio improvement
 
-v0.3  (Oct 30, 2015)
+v0.3
 HC mode : compression levels 2-26
 
-v0.2.2  (Oct 28, 2015)
+v0.2.2
 Fix : Visual Studio 2013 & 2015 release compilation, by Christophe Chevalier
 
-v0.2.1  (Oct 24, 2015)
+v0.2.1
 Fix : Read errors, advanced fuzzer tests, by Hanno Böck
 
-v0.2.0  (Oct 22, 2015)
+v0.2.0
 **Breaking format change**
 Faster decompression speed
 Can still decode v0.1 format
 
-v0.1.3  (Oct 15, 2015)
+v0.1.3
 fix uninitialization warning, reported by Evan Nemerson
 
-v0.1.2  (Sep 11, 2015)
+v0.1.2
 frame concatenation support
 
-v0.1.1  (Aug 27, 2015)
+v0.1.1
 fix compression bug
 detects write-flush errors
 
-v0.1.0  (Aug 25, 2015)
+v0.1.0
 first release

CONTRIBUTING.md

@@ -5,9 +5,9 @@ possible.
 ## Our Development Process
 New versions are being developed in the "dev" branch,
 or in their own feature branch.
-When they are deemed ready for a release, they are merged into "release".
+When they are deemed ready for a release, they are merged into "master".
 
-As a consequence, all contributions must stage first through "dev"
+As a consequences, all contributions must stage first through "dev"
 or their own feature branch.
 
 ## Pull Requests
@@ -47,7 +47,7 @@ Our contribution process works in three main stages:
     * Topic and development:
         * Make a new branch on your fork about the topic you're developing for
         ```
-        # branch names should be concise but sufficiently informative
+        # branch names should be consise but sufficiently informative
         git checkout -b <branch-name>
         git push origin <branch-name>
         ```
@@ -60,7 +60,7 @@ Our contribution process works in three main stages:
         * Note: run local tests to ensure that your changes didn't break existing functionality
             * Quick check
             ```
-            make check
+            make shortest
             ```
             * Longer check
             ```
@@ -68,8 +68,8 @@ Our contribution process works in three main stages:
             ```
 2. Code Review and CI tests
     * Ensure CI tests pass:
-        * Before sharing anything to the community, create a pull request in your own fork against the dev branch
-        and make sure that all GitHub Actions CI tests pass. See the Continuous Integration section below for more information.
+        * Before sharing anything to the community, make sure that all CI tests pass on your local fork.
+        See our section on setting up your CI environment for more information on how to do this.
         * Ensure that static analysis passes on your development machine. See the Static Analysis section
         below to see how to do this.
     * Create a pull request:
@@ -104,7 +104,7 @@ Our contribution process works in three main stages:
         issue at hand, then please indicate this by requesting that an issue be closed by commenting.
         * Just because your changes have been merged does not mean the topic or larger issue is complete. Remember
         that the change must make it to an official zstd release for it to be meaningful. We recommend
-        that contributors track the activity on their pull request and corresponding issue(s) page(s) until
+        that contributers track the activity on their pull request and corresponding issue(s) page(s) until
         their change makes it to the next release of zstd. Users will often discover bugs in your code or
         suggest ways to refine and improve your initial changes even after the pull request is merged.
 
@@ -126,56 +126,6 @@ just `contrib/largeNbDicts` and nothing else, you can run:
 scan-build make -C contrib/largeNbDicts largeNbDicts
 ```
 
-### Pitfalls of static analysis
-`scan-build` is part of our regular CI suite. Other static analyzers are not.
-
-It can be useful to look at additional static analyzers once in a while (and we do), but it's not a good idea to multiply the nb of analyzers run continuously at each commit and PR. The reasons are :
-
-- Static analyzers are full of false positive. The signal to noise ratio is actually pretty low.
-- A good CI policy is "zero-warning tolerance". That means that all issues must be solved, including false positives. This quickly becomes a tedious workload.
-- Multiple static analyzers will feature multiple kind of false positives, sometimes applying to the same code but in different ways leading to :
-   + tortuous code, trying to please multiple constraints, hurting readability and therefore maintenance. Sometimes, such complexity introduce other more subtle bugs, that are just out of scope of the analyzers.
-   + sometimes, these constraints are mutually exclusive : if one try to solve one, the other static analyzer will complain, they can't be both happy at the same time.
-- As if that was not enough, the list of false positives change with each version. It's hard enough to follow one static analyzer, but multiple ones with their own update agenda, this quickly becomes a massive velocity reducer.
-
-This is different from running a static analyzer once in a while, looking at the output, and __cherry picking__ a few warnings that seem helpful, either because they detected a genuine risk of bug, or because it helps expressing the code in a way which is more readable or more difficult to misuse. These kinds of reports can be useful, and are accepted.
-
-## Continuous Integration
-CI tests run every time a pull request (PR) is created or updated. The exact tests
-that get run will depend on the destination branch you specify. Some tests take
-longer to run than others. Currently, our CI is set up to run a short
-series of tests when creating a PR to the dev branch and a longer series of tests
-when creating a PR to the release branch. You can look in the configuration files
-of the respective CI platform for more information on what gets run when.
-
-Most people will just want to create a PR with the destination set to their local dev
-branch of zstd. You can then find the status of the tests on the PR's page. You can also
-re-run tests and cancel running tests from the PR page or from the respective CI's dashboard.
-
-Almost all of zstd's CI runs on GitHub Actions (configured at `.github/workflows`), which will automatically run on PRs to your
-own fork. A small number of tests run on other services (e.g. Travis CI, Circle CI, Appveyor).
-These require work to set up on your local fork, and (at least for Travis CI) cost money.
-Therefore, if the PR on your local fork passes GitHub Actions, feel free to submit a PR
-against the main repo.
-
-### Third-party CI
-A small number of tests cannot run on GitHub Actions, or have yet to be migrated.
-For these, we use a variety of third-party services (listed below). It is not necessary to set
-these up on your fork in order to contribute to zstd; however, we do link to instructions for those
-who want earlier signal.
-
-| Service   | Purpose                                                                                                    | Setup Links                                                                                                                                            | Config Path            |
-|-----------|------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------|
-| Travis CI | Used for testing on non-x86 architectures such as PowerPC                                                  | https://docs.travis-ci.com/user/tutorial/#to-get-started-with-travis-ci-using-github <br> https://github.com/marketplace/travis-ci                     | `.travis.yml`          |
-| AppVeyor  | Used for some Windows testing (e.g. cygwin, mingw)                                                         | https://www.appveyor.com/blog/2018/10/02/github-apps-integration/ <br> https://github.com/marketplace/appveyor                                         | `appveyor.yml`         |
-| Cirrus CI | Used for testing on FreeBSD                                                                                | https://github.com/marketplace/cirrus-ci/                                                                                                              | `.cirrus.yml`          |
-| Circle CI | Historically was used to provide faster signal,<br/> but we may be able to migrate these to Github Actions | https://circleci.com/docs/2.0/getting-started/#setting-up-circleci <br> https://youtu.be/Js3hMUsSZ2c <br> https://circleci.com/docs/2.0/enable-checks/ | `.circleci/config.yml` |
-
-Note: the instructions linked above mostly cover how to set up a repository with CI from scratch.
-The general idea should be the same for setting up CI on your fork of zstd, but you may have to
-follow slightly different steps. In particular, please ignore any instructions related to setting up
-config files (since zstd already has configs for each of these services).
-
 ## Performance
 Performance is extremely important for zstd and we only merge pull requests whose performance
 landscape and corresponding trade-offs have been adequately analyzed, reproduced, and presented.
@@ -197,7 +147,7 @@ something subtle merged is extensive benchmarking. You will be doing us a great
 take the time to run extensive, long-duration, and potentially cross-(os, platform, process, etc)
 benchmarks on your end before submitting a PR. Of course, you will not be able to benchmark
 your changes on every single processor and os out there (and neither will we) but do that best
-you can:) We've added some things to think about when benchmarking below in the Benchmarking
+you can:) We've adding some things to think about when benchmarking below in the Benchmarking
 Performance section which might be helpful for you.
 3. Optimizing performance for a certain OS, processor vendor, compiler, or network system is a perfectly
 legitimate thing to do as long as it does not harm the overall performance health of Zstd.
@@ -216,7 +166,7 @@ will typically not be stable enough to obtain reliable benchmark results. If you
 hands on a desktop, this is usually a better scenario.
 
 Of course, benchmarking can be done on non-hyper-stable machines as well. You will just have to
-do a little more work to ensure that you are in fact measuring the changes you've made and not
+do a little more work to ensure that you are in fact measuring the changes you've made not and
 noise. Here are some things you can do to make your benchmarks more stable:
 
 1. The most simple thing you can do to drastically improve the stability of your benchmark is
@@ -273,7 +223,7 @@ for that options you have just provided. If you want to look at the internals of
 benchmarking script works, you can check out programs/benchzstd.c
 
 For example: say you have made a change that you believe improves the speed of zstd level 1. The
-very first thing you should use to assess whether you actually achieved any sort of improvement
+very first thing you should use to asses whether you actually achieved any sort of improvement
 is `zstd -b`. You might try to do something like this. Note: you can use the `-i` option to
 specify a running time for your benchmark in seconds (default is 3 seconds).
 Usually, the longer the running time, the more stable your results will be.
@@ -299,24 +249,24 @@ this method of evaluation will not be sufficient.
 ### Profiling
 There are a number of great profilers out there. We're going to briefly mention how you can
 profile your code using `instruments` on mac, `perf` on linux and `visual studio profiler`
-on Windows.
+on windows.
 
 Say you have an idea for a change that you think will provide some good performance gains
 for level 1 compression on Zstd. Typically this means, you have identified a section of
 code that you think can be made to run faster.
 
 The first thing you will want to do is make sure that the piece of code is actually taking up
-a notable amount of time to run. It is usually not worth optimizing something which accounts for less than
+a notable amount of time to run. It is usually not worth optimzing something which accounts for less than
 0.0001% of the total running time. Luckily, there are tools to help with this.
 Profilers will let you see how much time your code spends inside a particular function.
-If your target code snippet is only part of a function, it might be worth trying to
-isolate that snippet by moving it to its own function (this is usually not necessary but
+If your target code snippit is only part of a function, it might be worth trying to
+isolate that snippit by moving it to its own function (this is usually not necessary but
 might be).
 
-Most profilers (including the profilers discussed below) will generate a call graph of
-functions for you. Your goal will be to find your function of interest in this call graph
-and then inspect the time spent inside of it. You might also want to look at the annotated
-assembly which most profilers will provide you with.
+Most profilers (including the profilers dicusssed below) will generate a call graph of
+functions for you. Your goal will be to find your function of interest in this call grapch
+and then inspect the time spent inside of it. You might also want to to look at the
+annotated assembly which most profilers will provide you with.
 
 #### Instruments
 We will once again consider the scenario where you think you've identified a piece of code
@@ -330,23 +280,23 @@ Instruments.
     * You will want a benchmark that runs for at least a few seconds (5 seconds will
     usually be long enough). This way the profiler will have something to work with
     and you will have ample time to attach your profiler to this process:)
-    * I will just use benchzstd as my benchmarmking script for this example:
+    * I will just use benchzstd as my bencharmking script for this example:
 ```
 $ zstd -b1 -i5 <my-data> # this will run for 5 seconds
 ```
 5. Once you run your benchmarking script, switch back over to instruments and attach your
 process to the time profiler. You can do this by:
     * Clicking on the `All Processes` drop down in the top left of the toolbar.
-    * Selecting your process from the dropdown. In my case, it is just going to be labeled
+    * Selecting your process from the dropdown. In my case, it is just going to be labled
     `zstd`
     * Hitting the bright red record circle button on the top left of the toolbar
-6. You profiler will now start collecting metrics from your benchmarking script. Once
+6. You profiler will now start collecting metrics from your bencharking script. Once
 you think you have collected enough samples (usually this is the case after 3 seconds of
 recording), stop your profiler.
 7. Make sure that in toolbar of the bottom window, `profile` is selected.
 8. You should be able to see your call graph.
     * If you don't see the call graph or an incomplete call graph, make sure you have compiled
-    zstd and your benchmarking script using debug flags. On mac and linux, this just means
+    zstd and your benchmarking scripg using debug flags. On mac and linux, this just means
     you will have to supply the `-g` flag alone with your build script. You might also
     have to provide the `-fno-omit-frame-pointer` flag
 9. Dig down the graph to find your function call and then inspect it by double clicking
@@ -365,7 +315,7 @@ Some general notes on perf:
 counter statistics. Perf uses a high resolution timer and this is likely one
 of the first things your team will run when assessing your PR.
 * Perf has a long list of hardware counters that can be viewed with `perf --list`.
-When measuring optimizations, something worth trying is to make sure the hardware
+When measuring optimizations, something worth trying is to make sure the handware
 counters you expect to be impacted by your change are in fact being so. For example,
 if you expect the L1 cache misses to decrease with your change, you can look at the
 counter `L1-dcache-load-misses`
@@ -375,6 +325,57 @@ counter `L1-dcache-load-misses`
 
 TODO
 
+
+## Setting up continuous integration (CI) on your fork
+Zstd uses a number of different continuous integration (CI) tools to ensure that new changes
+are well tested before they make it to an official release. Specifically, we use the platforms
+travis-ci, circle-ci, and appveyor.
+
+Changes cannot be merged into the main dev branch unless they pass all of our CI tests.
+The easiest way to run these CI tests on your own before submitting a PR to our dev branch
+is to configure your personal fork of zstd with each of the CI platforms. Below, you'll find
+instructions for doing this.
+
+### travis-ci
+Follow these steps to link travis-ci with your github fork of zstd
+
+1. Make sure you are logged into your github account
+2. Go to https://travis-ci.org/
+3. Click 'Sign in with Github' on the top right
+4. Click 'Authorize travis-ci'
+5. Click 'Activate all repositories using Github Apps'
+6. Select 'Only select repositories' and select your fork of zstd from the drop down
+7. Click 'Approve and Install'
+8. Click 'Sign in with Github' again. This time, it will be for travis-pro (which will let you view your tests on the web dashboard)
+9. Click 'Authorize travis-pro'
+10. You should have travis set up on your fork now.
+
+### circle-ci
+TODO
+
+### appveyor
+Follow these steps to link circle-ci with your girhub fork of zstd
+
+1. Make sure you are logged into your github account
+2. Go to https://www.appveyor.com/
+3. Click 'Sign in' on the top right
+4. Select 'Github' on the left panel
+5. Click 'Authorize appveyor'
+6. You might be asked to select which repositories you want to give appveyor permission to. Select your fork of zstd if you're prompted
+7. You should have appveyor set up on your fork now.
+
+### General notes on CI
+CI tests run every time a pull request (PR) is created or updated. The exact tests
+that get run will depend on the destination branch you specify. Some tests take
+longer to run than others. Currently, our CI is set up to run a short
+series of tests when creating a PR to the dev branch and a longer series of tests
+when creating a PR to the master branch. You can look in the configuration files
+of the respective CI platform for more information on what gets run when.
+
+Most people will just want to create a PR with the destination set to their local dev
+branch of zstd. You can then find the status of the tests on the PR's page. You can also
+re-run tests and cancel running tests from the PR page or from the respective CI's dashboard.
+
 ## Issues
 We use GitHub issues to track public bugs. Please ensure your description is
 clear and has sufficient instructions to be able to reproduce the issue.
@@ -384,105 +385,7 @@ disclosure of security bugs. In those cases, please go through the process
 outlined on that page and do not file a public issue.
 
 ## Coding Style
-It's a pretty long topic, which is difficult to summarize in a single paragraph.
-As a rule of thumbs, try to imitate the coding style of
-similar lines of codes around your contribution.
-The following is a non-exhaustive list of rules employed in zstd code base:
-
-### C90
-This code base is following strict C90 standard,
-with 2 extensions : 64-bit `long long` types, and variadic macros.
-This rule is applied strictly to code within `lib/` and `programs/`.
-Sub-project in `contrib/` are allowed to use other conventions.
-
-### C++ direct compatibility : symbol mangling
-All public symbol declarations must be wrapped in `extern “C” { … }`,
-so that this project can be compiled as C++98 code,
-and linked into C++ applications.
-
-### Minimal Frugal
-This design requirement is fundamental to preserve the portability of the code base.
-#### Dependencies
-- Reduce dependencies to the minimum possible level.
-  Any dependency should be considered “bad” by default,
-  and only tolerated because it provides a service in a better way than can be achieved locally.
-  The only external dependencies this repository tolerates are
-  standard C libraries, and in rare cases, system level headers.
-- Within `lib/`, this policy is even more drastic.
-  The only external dependencies allowed are `<assert.h>`, `<stdlib.h>`, `<string.h>`,
-  and even then, not directly.
-  In particular, no function shall ever allocate on heap directly,
-  and must use instead `ZSTD_malloc()` and equivalent.
-  Other accepted non-symbol headers are `<stddef.h>` and `<limits.h>`.
-- Within the project, there is a strict hierarchy of dependencies that must be respected.
-  `programs/` is allowed to depend on `lib/`, but only its public API.
-  Within `lib/`, `lib/common` doesn't depend on any other directory.
-  `lib/compress` and `lib/decompress` shall not depend on each other.
-  `lib/dictBuilder` can depend on `lib/common` and `lib/compress`, but not `lib/decompress`.
-#### Resources
-- Functions in `lib/` must use very little stack space,
-  several dozens of bytes max.
-  Everything larger must use the heap allocator,
-  or require a scratch buffer to be emplaced manually.
-
-### Naming
-* All public symbols are prefixed with `ZSTD_`
-  + private symbols, with a scope limited to their own unit, are free of this restriction.
-    However, since `libzstd` source code can be amalgamated,
-    each symbol name must attempt to be (and remain) unique.
-    Avoid too generic names that could become ground for future collisions.
-    This generally implies usage of some form of prefix.
-* For symbols (functions and variables), naming convention is `PREFIX_camelCase`.
-  + In some advanced cases, one can also find :
-    - `PREFIX_prefix2_camelCase`
-    - `PREFIX_camelCase_extendedQualifier`
-* Multi-words names generally consist of an action followed by object:
-  - for example : `ZSTD_createCCtx()`
-* Prefer positive actions
-  - `goBackward` rather than `notGoForward`
-* Type names (`struct`, etc.) follow similar convention,
-  except that they are allowed and even invited to start by an Uppercase letter.
-  Example : `ZSTD_CCtx`, `ZSTD_CDict`
-* Macro names are all Capital letters.
-  The same composition rules (`PREFIX_NAME_QUALIFIER`) apply.
-* File names are all lowercase letters.
-  The convention is `snake_case`.
-  File names **must** be unique across the entire code base,
-  even when they stand in clearly separated directories.
-
-### Qualifiers
-* This code base is `const` friendly, if not `const` fanatical.
-  Any variable that can be `const` (aka. read-only) **must** be `const`.
-  Any pointer which content will not be modified must be `const`.
-  This property is then controlled at compiler level.
-  `const` variables are an important signal to readers that this variable isn't modified.
-  Conversely, non-const variables are a signal to readers to watch out for modifications later on in the function.
-* If a function must be inlined, mention it explicitly,
-  using project's own portable macros, such as `FORCE_INLINE_ATTR`,
-  defined in `lib/common/compiler.h`.
-
-### Debugging
-* **Assertions** are welcome, and should be used very liberally,
-  to control any condition the code expects for its correct execution.
-  These assertion checks will be run in debug builds, and disabled in production.
-* For traces, this project provides its own debug macros,
-  in particular `DEBUGLOG(level, ...)`, defined in `lib/common/debug.h`.
-
-### Code documentation
-* Avoid code documentation that merely repeats what the code is already stating.
-  Whenever applicable, prefer employing the code as the primary way to convey explanations.
-  Example 1 : `int nbTokens = n;` instead of `int i = n; /* i is a nb of tokens *./`.
-  Example 2 : `assert(size > 0);` instead of `/* here, size should be positive */`.
-* At declaration level, the documentation explains how to use the function or variable
-  and when applicable why it's needed, of the scenarios where it can be useful.
-* At implementation level, the documentation explains the general outline of the algorithm employed,
-  and when applicable why this specific choice was preferred.
-
-### General layout
 * 4 spaces for indentation rather than tabs
-* Code documentation shall directly precede function declaration or implementation
-* Function implementations and its code documentation should be preceded and followed by an empty line
-
 
 ## License
 By contributing to Zstandard, you agree that your contributions will be licensed

LICENSE

@@ -2,7 +2,7 @@ BSD License
 
 For Zstandard software
 
-Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved.
+Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:
@@ -14,9 +14,9 @@ are permitted provided that the following conditions are met:
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
 
- * Neither the name Facebook, nor Meta, nor the names of its contributors may
-   be used to endorse or promote products derived from this software without
-   specific prior written permission.
+ * Neither the name Facebook nor the names of its contributors may be used to
+   endorse or promote products derived from this software without specific
+   prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

Makefile

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2015-2020, Yann Collet, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the
@@ -8,9 +8,6 @@
 # You may select, at your option, one of the above-listed licenses.
 # ################################################################
 
-# verbose mode (print commands) on V=1 or VERBOSE=1
-Q = $(if $(filter 1,$(V) $(VERBOSE)),,@)
-
 PRGDIR   = programs
 ZSTDDIR  = lib
 BUILDIR  = build
@@ -29,12 +26,11 @@ VOID = /dev/null
 # fail on other tested distros (ubuntu, debian) even
 # without manually specifying the TARGET_SYSTEM.
 TARGET_SYSTEM ?= $(OS)
-CP ?= cp
 
 ifneq (,$(filter Windows%,$(TARGET_SYSTEM)))
-  EXT =.exe
+EXT =.exe
 else
-  EXT =
+EXT =
 endif
 
 ## default: Build lib-release and zstd-release
@@ -49,28 +45,28 @@ allmost: allzstd zlibwrapper
 
 # skip zwrapper, can't build that on alternate architectures without the proper zlib installed
 .PHONY: allzstd
-allzstd: lib
-	$(Q)$(MAKE) -C $(PRGDIR) all
-	$(Q)$(MAKE) -C $(TESTDIR) all
+allzstd: lib-all
+	$(MAKE) -C $(PRGDIR) all
+	$(MAKE) -C $(TESTDIR) all
 
 .PHONY: all32
 all32:
 	$(MAKE) -C $(PRGDIR) zstd32
 	$(MAKE) -C $(TESTDIR) all32
 
-.PHONY: lib lib-release lib-mt lib-nomt
-lib lib-release lib-mt lib-nomt:
-	$(Q)$(MAKE) -C $(ZSTDDIR) $@
+.PHONY: lib lib-release libzstd.a
+lib lib-release lib-all :
+	@$(MAKE) -C $(ZSTDDIR) $@
 
 .PHONY: zstd zstd-release
 zstd zstd-release:
-	$(Q)$(MAKE) -C $(PRGDIR) $@
-	$(Q)ln -sf $(PRGDIR)/zstd$(EXT) zstd$(EXT)
+	@$(MAKE) -C $(PRGDIR) $@
+	cp $(PRGDIR)/zstd$(EXT) .
 
 .PHONY: zstdmt
 zstdmt:
-	$(Q)$(MAKE) -C $(PRGDIR) $@
-	$(Q)$(CP) $(PRGDIR)/zstd$(EXT) ./zstdmt$(EXT)
+	@$(MAKE) -C $(PRGDIR) $@
+	cp $(PRGDIR)/zstd$(EXT) ./zstdmt$(EXT)
 
 .PHONY: zlibwrapper
 zlibwrapper: lib
@@ -79,16 +75,20 @@ zlibwrapper: lib
 ## test: run long-duration tests
 .PHONY: test
 DEBUGLEVEL ?= 1
-test: MOREFLAGS += -g -Werror
+test: MOREFLAGS += -g -DDEBUGLEVEL=$(DEBUGLEVEL) -Werror
 test:
-	DEBUGLEVEL=$(DEBUGLEVEL) MOREFLAGS="$(MOREFLAGS)" $(MAKE) -j -C $(PRGDIR) allVariants
+	MOREFLAGS="$(MOREFLAGS)" $(MAKE) -j -C $(PRGDIR) allVariants
+	$(MAKE) -C $(TESTDIR) $@
+	ZSTD=../../programs/zstd $(MAKE) -C doc/educational_decoder test
+
+## shortest: same as `make check`
+.PHONY: shortest
+shortest:
 	$(MAKE) -C $(TESTDIR) $@
-	ZSTD=../../programs/zstd $(MAKE) -C doc/educational_decoder $@
 
 ## check: run basic tests for `zstd` cli
 .PHONY: check
-check:
-	$(Q)$(MAKE) -C $(TESTDIR) $@
+check: shortest
 
 .PHONY: automated_benchmarking
 automated_benchmarking:
@@ -97,10 +97,10 @@ automated_benchmarking:
 .PHONY: benchmarking
 benchmarking: automated_benchmarking
 
-## examples: build all examples in `examples/` directory
+## examples: build all examples in `/examples` directory
 .PHONY: examples
 examples: lib
-	$(MAKE) -C examples all
+	CPPFLAGS=-I../lib LDFLAGS=-L../lib $(MAKE) -C examples/ all
 
 ## manual: generate API documentation in html format
 .PHONY: manual
@@ -117,11 +117,9 @@ man:
 contrib: lib
 	$(MAKE) -C contrib/pzstd all
 	$(MAKE) -C contrib/seekable_format/examples all
-	$(MAKE) -C contrib/seekable_format/tests test
 	$(MAKE) -C contrib/largeNbDicts all
-	$(MAKE) -C contrib/externalSequenceProducer all
-	cd build/single_file_libs/ ; ./build_decoder_test.sh
-	cd build/single_file_libs/ ; ./build_library_test.sh
+	cd contrib/single_file_libs/ ; ./build_decoder_test.sh
+	cd contrib/single_file_libs/ ; ./build_library_test.sh
 
 .PHONY: cleanTabs
 cleanTabs:
@@ -129,33 +127,30 @@ cleanTabs:
 
 .PHONY: clean
 clean:
-	$(Q)$(MAKE) -C $(ZSTDDIR) $@ > $(VOID)
-	$(Q)$(MAKE) -C $(PRGDIR) $@ > $(VOID)
-	$(Q)$(MAKE) -C $(TESTDIR) $@ > $(VOID)
-	$(Q)$(MAKE) -C $(ZWRAPDIR) $@ > $(VOID)
-	$(Q)$(MAKE) -C examples/ $@ > $(VOID)
-	$(Q)$(MAKE) -C contrib/gen_html $@ > $(VOID)
-	$(Q)$(MAKE) -C contrib/pzstd $@ > $(VOID)
-	$(Q)$(MAKE) -C contrib/seekable_format/examples $@ > $(VOID)
-	$(Q)$(MAKE) -C contrib/seekable_format/tests $@ > $(VOID)
-	$(Q)$(MAKE) -C contrib/largeNbDicts $@ > $(VOID)
-	$(Q)$(MAKE) -C contrib/externalSequenceProducer $@ > $(VOID)
-	$(Q)$(RM) zstd$(EXT) zstdmt$(EXT) tmp*
-	$(Q)$(RM) -r lz4 cmakebuild mesonbuild install
+	@$(MAKE) -C $(ZSTDDIR) $@ > $(VOID)
+	@$(MAKE) -C $(PRGDIR) $@ > $(VOID)
+	@$(MAKE) -C $(TESTDIR) $@ > $(VOID)
+	@$(MAKE) -C $(ZWRAPDIR) $@ > $(VOID)
+	@$(MAKE) -C examples/ $@ > $(VOID)
+	@$(MAKE) -C contrib/gen_html $@ > $(VOID)
+	@$(MAKE) -C contrib/pzstd $@ > $(VOID)
+	@$(MAKE) -C contrib/seekable_format/examples $@ > $(VOID)
+	@$(MAKE) -C contrib/largeNbDicts $@ > $(VOID)
+	@$(RM) zstd$(EXT) zstdmt$(EXT) tmp*
+	@$(RM) -r lz4
 	@echo Cleaning completed
 
 #------------------------------------------------------------------------------
 # make install is validated only for Linux, macOS, Hurd and some BSD targets
 #------------------------------------------------------------------------------
-ifneq (,$(filter Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD DragonFly NetBSD MSYS_NT% CYGWIN_NT% Haiku AIX,$(shell sh -c 'MSYSTEM="MSYS" uname') ))
+ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD DragonFly NetBSD MSYS_NT Haiku))
 
 HOST_OS = POSIX
-
-MKDIR ?= mkdir -p
+CMAKE_PARAMS = -DZSTD_BUILD_CONTRIB:BOOL=ON -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON -DZSTD_ZLIB_SUPPORT:BOOL=ON -DZSTD_LZMA_SUPPORT:BOOL=ON -DCMAKE_BUILD_TYPE=Release
 
 HAVE_COLORNEVER = $(shell echo a | egrep --color=never a > /dev/null 2> /dev/null && echo 1 || echo 0)
 EGREP_OPTIONS ?=
-ifeq ($(HAVE_COLORNEVER), 1)
+ifeq ($HAVE_COLORNEVER, 1)
 EGREP_OPTIONS += --color=never
 endif
 EGREP = egrep $(EGREP_OPTIONS)
@@ -166,7 +161,7 @@ EGREP = egrep $(EGREP_OPTIONS)
 ## list: Print all targets and their descriptions (if provided)
 .PHONY: list
 list:
-	$(Q)TARGETS=$$($(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null \
+	@TARGETS=$$($(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null \
 		| awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' \
 		| $(EGREP) -v  -e '^[^[:alnum:]]' | sort); \
 	{ \
@@ -179,42 +174,36 @@ list:
 	    done \
 	} | column -t -s $$'\t'
 
-.PHONY: install armtest usan asan uasan msan asan32
+.PHONY: install armtest usan asan uasan
 install:
-	$(Q)$(MAKE) -C $(ZSTDDIR) $@
-	$(Q)$(MAKE) -C $(PRGDIR) $@
+	@$(MAKE) -C $(ZSTDDIR) $@
+	@$(MAKE) -C $(PRGDIR) $@
 
 .PHONY: uninstall
 uninstall:
-	$(Q)$(MAKE) -C $(ZSTDDIR) $@
-	$(Q)$(MAKE) -C $(PRGDIR) $@
+	@$(MAKE) -C $(ZSTDDIR) $@
+	@$(MAKE) -C $(PRGDIR) $@
 
 .PHONY: travis-install
 travis-install:
 	$(MAKE) install PREFIX=~/install_test_dir
 
-.PHONY: clangbuild-darwin-fat
-clangbuild-darwin-fat: clean
-	clang -v
-	CXX=clang++ CC=clang CFLAGS+="-Werror -Wconversion -Wno-sign-conversion -Wdocumentation -arch arm64" $(MAKE) zstd-release
-	mv programs/zstd programs/zstd_arm64
-	CXX=clang++ CC=clang CFLAGS+="-Werror -Wconversion -Wno-sign-conversion -Wdocumentation -arch x86_64" $(MAKE) zstd-release
-	mv programs/zstd programs/zstd_x64
-	lipo -create programs/zstd_x64 programs/zstd_arm64 -output programs/zstd
-
-.PHONY: gcc5build gcc6build gcc7build clangbuild m32build armbuild aarch64build ppcbuild ppc64build
+.PHONY: gcc5build
 gcc5build: clean
 	gcc-5 -v
-	CC=gcc-5 $(MAKE) all MOREFLAGS="-Werror $(MOREFLAGS)"
+	CC=gcc-5 $(MAKE) all MOREFLAGS="-Werror"
 
+.PHONY: gcc6build
 gcc6build: clean
 	gcc-6 -v
-	CC=gcc-6 $(MAKE) all MOREFLAGS="-Werror $(MOREFLAGS)"
+	CC=gcc-6 $(MAKE) all MOREFLAGS="-Werror"
 
+.PHONY: gcc7build
 gcc7build: clean
 	gcc-7 -v
-	CC=gcc-7 $(MAKE) all MOREFLAGS="-Werror $(MOREFLAGS)"
+	CC=gcc-7 $(MAKE) all MOREFLAGS="-Werror"
 
+.PHONY: clangbuild
 clangbuild: clean
 	clang -v
 	CXX=clang++ CC=clang CFLAGS="-Werror -Wconversion -Wno-sign-conversion -Wdocumentation" $(MAKE) all
@@ -227,131 +216,109 @@ armbuild: clean
 	CC=arm-linux-gnueabi-gcc CFLAGS="-Werror" $(MAKE) allzstd
 
 aarch64build: clean
-	CC=aarch64-linux-gnu-gcc CFLAGS="-Werror -O0" $(MAKE) allzstd
+	CC=aarch64-linux-gnu-gcc CFLAGS="-Werror" $(MAKE) allzstd
 
 ppcbuild: clean
-	CC=powerpc-linux-gnu-gcc CFLAGS="-m32 -Wno-attributes -Werror" $(MAKE) -j allzstd
+	CC=powerpc-linux-gnu-gcc CFLAGS="-m32 -Wno-attributes -Werror" $(MAKE) allzstd
 
 ppc64build: clean
-	CC=powerpc-linux-gnu-gcc CFLAGS="-m64 -Werror" $(MAKE) -j allzstd
+	CC=powerpc-linux-gnu-gcc CFLAGS="-m64 -Werror" $(MAKE) allzstd
 
-.PHONY: armfuzz aarch64fuzz ppcfuzz ppc64fuzz
 armfuzz: clean
-	CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static MOREFLAGS="-static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)" $(MAKE) -C $(TESTDIR) fuzztest
+	CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static MOREFLAGS="-static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
 
 aarch64fuzz: clean
 	ld -v
-	CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static MOREFLAGS="-static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)" $(MAKE) -C $(TESTDIR) fuzztest
+	CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static MOREFLAGS="-static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
 
 ppcfuzz: clean
-	CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static MOREFLAGS="-static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)" $(MAKE) -C $(TESTDIR) fuzztest
+	CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static MOREFLAGS="-static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
 
 ppc64fuzz: clean
-	CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS="-m64 -static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)" $(MAKE) -C $(TESTDIR) fuzztest
+	CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS="-m64 -static" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) fuzztest
 
-.PHONY: cxxtest gcc5test gcc6test armtest aarch64test ppctest ppc64test
+.PHONY: cxxtest
 cxxtest: CXXFLAGS += -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror
 cxxtest: clean
 	$(MAKE) -C $(PRGDIR) all CC="$(CXX) -Wno-deprecated" CFLAGS="$(CXXFLAGS)"   # adding -Wno-deprecated to avoid clang++ warning on dealing with C files directly
 
 gcc5test: clean
 	gcc-5 -v
-	$(MAKE) all CC=gcc-5 MOREFLAGS="-Werror $(MOREFLAGS)"
+	$(MAKE) all CC=gcc-5 MOREFLAGS="-Werror"
 
 gcc6test: clean
 	gcc-6 -v
-	$(MAKE) all CC=gcc-6 MOREFLAGS="-Werror $(MOREFLAGS)"
+	$(MAKE) all CC=gcc-6 MOREFLAGS="-Werror"
 
 armtest: clean
 	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
-	$(MAKE) -C $(TESTDIR) test CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS="-Werror -static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)"
+	$(MAKE) -C $(TESTDIR) test CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS="-Werror -static" FUZZER_FLAGS=--no-big-tests
 
 aarch64test:
 	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
-	$(MAKE) -C $(TESTDIR) test CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS="-Werror -static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)"
+	$(MAKE) -C $(TESTDIR) test CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS="-Werror -static" FUZZER_FLAGS=--no-big-tests
 
 ppctest: clean
 	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
-	$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS="-Werror -Wno-attributes -static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)"
+	$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS="-Werror -Wno-attributes -static" FUZZER_FLAGS=--no-big-tests
 
 ppc64test: clean
 	$(MAKE) -C $(TESTDIR) datagen   # use native, faster
-	$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS="-m64 -static $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)"
+	$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS="-m64 -static" FUZZER_FLAGS=--no-big-tests
 
-.PHONY: arm-ppc-compilation
 arm-ppc-compilation:
-	$(MAKE) -C $(PRGDIR) clean zstd CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS="-Werror -static $(MOREFLAGS)"
-	$(MAKE) -C $(PRGDIR) clean zstd CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS="-Werror -static $(MOREFLAGS)"
-	$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS="-Werror -Wno-attributes -static $(MOREFLAGS)"
-	$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS="-m64 -static $(MOREFLAGS)"
+	$(MAKE) -C $(PRGDIR) clean zstd CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS="-Werror -static"
+	$(MAKE) -C $(PRGDIR) clean zstd CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS="-Werror -static"
+	$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS="-Werror -Wno-attributes -static"
+	$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS="-m64 -static"
 
 regressiontest:
 	$(MAKE) -C $(FUZZDIR) regressiontest
 
 uasanregressiontest:
-	$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS="-O3 -fsanitize=address,undefined -Werror" CXXFLAGS="-O3 -fsanitize=address,undefined -Werror"
+	$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS="-O3 -fsanitize=address,undefined" CXXFLAGS="-O3 -fsanitize=address,undefined"
 
 msanregressiontest:
-	$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS="-O3 -fsanitize=memory -Werror" CXXFLAGS="-O3 -fsanitize=memory -Werror"
+	$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS="-O3 -fsanitize=memory" CXXFLAGS="-O3 -fsanitize=memory"
 
-update_regressionResults : REGRESS_RESULTS_DIR := /tmp/regress_results_dir/
-update_regressionResults:
-	$(MAKE) -j -C programs zstd
-	$(MAKE) -j -C tests/regression test
-	$(RM) -r $(REGRESS_RESULTS_DIR)
-	$(MKDIR) $(REGRESS_RESULTS_DIR)
-	./tests/regression/test                         \
-        --cache  tests/regression/cache             \
-        --output $(REGRESS_RESULTS_DIR)/results.csv \
-        --zstd   programs/zstd
-	echo "Showing results differences"
-	! diff tests/regression/results.csv $(REGRESS_RESULTS_DIR)/results.csv
-	echo "Updating results.csv"
-	$(CP) $(REGRESS_RESULTS_DIR)/results.csv tests/regression/results.csv
+# run UBsan with -fsanitize-recover=signed-integer-overflow
+# due to a bug in UBsan when doing pointer subtraction
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63303
 
-
-# run UBsan with -fsanitize-recover=pointer-overflow
-# this only works with recent compilers such as gcc 8+
 usan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=undefined -Werror $(MOREFLAGS)"
+	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=undefined -Werror"
 
 asan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=address -Werror $(MOREFLAGS)"
+	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=address -Werror"
 
 asan-%: clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=address -Werror $(MOREFLAGS)" $(MAKE) -C $(TESTDIR) $*
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=address -Werror" $(MAKE) -C $(TESTDIR) $*
 
 msan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=memory -fno-omit-frame-pointer -Werror $(MOREFLAGS)" HAVE_LZMA=0   # datagen.c fails this test for no obvious reason
+	$(MAKE) test CC=clang MOREFLAGS="-g -fsanitize=memory -fno-omit-frame-pointer -Werror" HAVE_LZMA=0   # datagen.c fails this test for no obvious reason
 
-msan-%:
-	$(MAKE) clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=memory -fno-omit-frame-pointer -Werror $(MOREFLAGS)" FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)" $(MAKE) -j -C $(TESTDIR) HAVE_LZMA=0 $*
+msan-%: clean
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=memory -fno-omit-frame-pointer -Werror" FUZZER_FLAGS=--no-big-tests $(MAKE) -C $(TESTDIR) HAVE_LZMA=0 $*
 
 asan32: clean
-	$(MAKE) -C $(TESTDIR) test32 CC=clang MOREFLAGS="-g -fsanitize=address $(MOREFLAGS)"
+	$(MAKE) -C $(TESTDIR) test32 CC=clang MOREFLAGS="-g -fsanitize=address"
 
 uasan: clean
-	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=address,undefined -Werror $(MOREFLAGS)"
+	$(MAKE) test CC=clang MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=address,undefined -Werror"
 
 uasan-%: clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=address,undefined -Werror $(MOREFLAGS)" $(MAKE) -C $(TESTDIR) $*
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize-recover=signed-integer-overflow -fsanitize=address,undefined -Werror" $(MAKE) -C $(TESTDIR) $*
 
 tsan-%: clean
-	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=thread -Werror $(MOREFLAGS)" $(MAKE) -C $(TESTDIR) $* FUZZER_FLAGS="--no-big-tests $(FUZZER_FLAGS)"
+	LDFLAGS=-fuse-ld=gold MOREFLAGS="-g -fno-sanitize-recover=all -fsanitize=thread -Werror" $(MAKE) -C $(TESTDIR) $* FUZZER_FLAGS=--no-big-tests
 
-.PHONY: apt-install
 apt-install:
-	# TODO: uncomment once issue 3011 is resolved and remove hack from Github Actions .yml
-	# sudo apt-get update
 	sudo apt-get -yq --no-install-suggests --no-install-recommends --force-yes install $(APT_PACKAGES)
 
-.PHONY: apt-add-repo
 apt-add-repo:
 	sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
 	sudo apt-get update -y -qq
 
-.PHONY: ppcinstall arminstall valgrindinstall libc6install gcc6install gcc7install gcc8install gpp6install clang38install
 ppcinstall:
 	APT_PACKAGES="qemu-system-ppc qemu-user-static gcc-powerpc-linux-gnu" $(MAKE) apt-install
 
@@ -379,72 +346,52 @@ gpp6install: apt-add-repo
 clang38install:
 	APT_PACKAGES="clang-3.8" $(MAKE) apt-install
 
+# Ubuntu 14.04 ships a too-old lz4
+lz4install:
+	[ -e lz4 ] || git clone https://github.com/lz4/lz4 && sudo $(MAKE) -C lz4 install
+
 endif
 
 
-ifneq (,$(filter MSYS%,$(shell sh -c 'MSYSTEM="MSYS" uname') ))
+ifneq (,$(filter MSYS%,$(shell uname)))
 HOST_OS = MSYS
+CMAKE_PARAMS = -G"MSYS Makefiles" -DCMAKE_BUILD_TYPE=Debug -DZSTD_MULTITHREAD_SUPPORT:BOOL=OFF -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON
 endif
 
+
 #------------------------------------------------------------------------
 # target specific tests
 #------------------------------------------------------------------------
-ifneq (,$(filter MSYS POSIX,$(HOST_OS)))
-
-CMAKE ?= cmake
-CMAKE_PARAMS = -DZSTD_BUILD_CONTRIB:BOOL=ON -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON -DZSTD_ZLIB_SUPPORT:BOOL=ON -DZSTD_LZMA_SUPPORT:BOOL=ON
-
-ifneq (,$(filter MSYS%,$(shell sh -c 'MSYSTEM="MSYS" uname')))
-CMAKE_PARAMS = -G"MSYS Makefiles" -DZSTD_MULTITHREAD_SUPPORT:BOOL=OFF -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON
-endif
-
-.PHONY: cmakebuild
+ifneq (,$(filter $(HOST_OS),MSYS POSIX))
 cmakebuild:
-	$(CMAKE) --version
-	$(RM) -r cmakebuild install
-	$(MKDIR) cmakebuild install
-	cd cmakebuild; $(CMAKE) -Wdev -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_FLAGS="-Werror -O0" -DCMAKE_INSTALL_PREFIX=install $(CMAKE_PARAMS) ../build/cmake
-	$(CMAKE) --build cmakebuild --target install -- -j V=1
-	cd cmakebuild; ctest -V -L Medium
+	cmake --version
+	$(RM) -r $(BUILDIR)/cmake/build
+	mkdir $(BUILDIR)/cmake/build
+	cd $(BUILDIR)/cmake/build; cmake -DCMAKE_INSTALL_PREFIX:PATH=~/install_test_dir $(CMAKE_PARAMS) ..
+	$(MAKE) -C $(BUILDIR)/cmake/build -j4;
+	$(MAKE) -C $(BUILDIR)/cmake/build install;
+	$(MAKE) -C $(BUILDIR)/cmake/build uninstall;
+	cd $(BUILDIR)/cmake/build; ctest -V -L Medium
 
-MESON ?= meson
-NINJA ?= ninja
-
-.PHONY: mesonbuild
-mesonbuild:
-	$(MESON) setup \
-		--buildtype=debugoptimized \
-		-Db_lundef=false \
-		-Dauto_features=enabled \
-		-Dbin_programs=true \
-		-Dbin_tests=true \
-		-Dbin_contrib=true \
-		-Ddefault_library=both \
-		build/meson mesonbuild
-	$(NINJA) -C mesonbuild/
-	$(MESON) test -C mesonbuild/ --print-errorlogs
-	$(MESON) install -C mesonbuild --destdir staging/
-
-.PHONY: c89build gnu90build c99build gnu99build c11build bmix64build bmix32build bmi32build staticAnalyze
 c89build: clean
 	$(CC) -v
-	CFLAGS="-std=c89 -Werror -Wno-attributes -Wpedantic -Wno-long-long -Wno-variadic-macros -O0" $(MAKE) lib zstd
+	CFLAGS="-std=c89 -Werror" $(MAKE) allmost  # will fail, due to missing support for `long long`
 
 gnu90build: clean
 	$(CC) -v
-	CFLAGS="-std=gnu90 -Werror -O0" $(MAKE) allmost
+	CFLAGS="-std=gnu90 -Werror" $(MAKE) allmost
 
 c99build: clean
 	$(CC) -v
-	CFLAGS="-std=c99 -Werror -O0" $(MAKE) allmost
+	CFLAGS="-std=c99 -Werror" $(MAKE) allmost
 
 gnu99build: clean
 	$(CC) -v
-	CFLAGS="-std=gnu99 -Werror -O0" $(MAKE) allmost
+	CFLAGS="-std=gnu99 -Werror" $(MAKE) allmost
 
 c11build: clean
 	$(CC) -v
-	CFLAGS="-std=c11 -Werror -O0" $(MAKE) allmost
+	CFLAGS="-std=c11 -Werror" $(MAKE) allmost
 
 bmix64build: clean
 	$(CC) -v
@@ -463,5 +410,5 @@ bmi32build: clean
 staticAnalyze: SCANBUILD ?= scan-build
 staticAnalyze:
 	$(CC) -v
-	CC=$(CC) CPPFLAGS=-g $(SCANBUILD) --status-bugs -v $(MAKE) zstd
+	CC=$(CC) CPPFLAGS=-g $(SCANBUILD) --status-bugs -v $(MAKE) allzstd examples contrib
 endif

Package.swift

@@ -1,36 +0,0 @@
-// swift-tools-version:5.0
-// The swift-tools-version declares the minimum version of Swift required to build this package.
-
-import PackageDescription
-
-let package = Package(
-    name: "zstd",
-    platforms: [
-        .macOS(.v10_10), .iOS(.v9), .tvOS(.v9)
-    ],
-    products: [
-        // Products define the executables and libraries a package produces, and make them visible to other packages.
-        .library(
-            name: "libzstd",
-            targets: [ "libzstd" ])
-    ],
-    dependencies: [
-        // Dependencies declare other packages that this package depends on.
-        // .package(url: /* package url */, from: "1.0.0"),
-    ],
-    targets: [
-        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
-        // Targets can depend on other targets in this package, and on products in packages this package depends on.
-        .target(
-            name: "libzstd",
-            path: "lib",
-            sources: [ "common", "compress", "decompress", "dictBuilder" ],
-            publicHeadersPath: ".",
-            cSettings: [
-                .headerSearchPath(".")
-            ])
-    ],
-    swiftLanguageVersions: [.v5],
-    cLanguageStandard: .gnu11,
-    cxxLanguageStandard: .gnucxx14
-)

README.md

@@ -4,21 +4,23 @@ __Zstandard__, or `zstd` as short version, is a fast lossless compression algori
 targeting real-time compression scenarios at zlib-level and better compression ratios.
 It's backed by a very fast entropy stage, provided by [Huff0 and FSE library](https://github.com/Cyan4973/FiniteStateEntropy).
 
-Zstandard's format is stable and documented in [RFC8878](https://datatracker.ietf.org/doc/html/rfc8878). Multiple independent implementations are already available.
-This repository represents the reference implementation, provided as an open-source dual [BSD](LICENSE) OR [GPLv2](COPYING) licensed **C** library,
+The project is provided as an open-source dual [BSD](LICENSE) and [GPLv2](COPYING) licensed **C** library,
 and a command line utility producing and decoding `.zst`, `.gz`, `.xz` and `.lz4` files.
 Should your project require another programming language,
-a list of known ports and bindings is provided on [Zstandard homepage](https://facebook.github.io/zstd/#other-languages).
+a list of known ports and bindings is provided on [Zstandard homepage](http://www.zstd.net/#other-languages).
 
 **Development branch status:**
 
 [![Build Status][travisDevBadge]][travisLink]
+[![Build status][AppveyorDevBadge]][AppveyorLink]
 [![Build status][CircleDevBadge]][CircleLink]
 [![Build status][CirrusDevBadge]][CirrusLink]
 [![Fuzzing Status][OSSFuzzBadge]][OSSFuzzLink]
 
-[travisDevBadge]: https://api.travis-ci.com/facebook/zstd.svg?branch=dev "Continuous Integration test suite"
-[travisLink]: https://travis-ci.com/facebook/zstd
+[travisDevBadge]: https://travis-ci.org/facebook/zstd.svg?branch=dev "Continuous Integration test suite"
+[travisLink]: https://travis-ci.org/facebook/zstd
+[AppveyorDevBadge]: https://ci.appveyor.com/api/projects/status/xt38wbdxjk5mrbem/branch/dev?svg=true "Windows test suite"
+[AppveyorLink]: https://ci.appveyor.com/project/YannCollet/zstd-p0yf0
 [CircleDevBadge]: https://circleci.com/gh/facebook/zstd/tree/dev.svg?style=shield "Short test suite"
 [CircleLink]: https://circleci.com/gh/facebook/zstd
 [CirrusDevBadge]: https://api.cirrus-ci.com/github/facebook/zstd.svg?branch=dev
@@ -29,35 +31,37 @@ a list of known ports and bindings is provided on [Zstandard homepage](https://f
 ## Benchmarks
 
 For reference, several fast compression algorithms were tested and compared
-on a desktop featuring a Core i7-9700K CPU @ 4.9GHz
-and running Ubuntu 24.04 (`Linux 6.8.0-53-generic`),
+on a server running Arch Linux (`Linux version 5.5.11-arch1-1`),
+with a Core i9-9900K CPU @ 5.0GHz,
 using [lzbench], an open-source in-memory benchmark by @inikep
-compiled with [gcc] 14.2.0,
+compiled with [gcc] 9.3.0,
 on the [Silesia compression corpus].
 
 [lzbench]: https://github.com/inikep/lzbench
-[Silesia compression corpus]: https://sun.aei.polsl.pl//~sdeor/index.php?page=silesia
+[Silesia compression corpus]: http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
 [gcc]: https://gcc.gnu.org/
 
 | Compressor name         | Ratio | Compression| Decompress.|
 | ---------------         | ------| -----------| ---------- |
-| **zstd 1.5.7 -1**       | 2.896 |   510 MB/s |  1550 MB/s |
-| brotli 1.1.0 -1         | 2.883 |   290 MB/s |   425 MB/s |
-| [zlib] 1.3.1 -1         | 2.743 |   105 MB/s |   390 MB/s |
-| **zstd 1.5.7 --fast=1** | 2.439 |   545 MB/s |  1850 MB/s |
-| quicklz 1.5.0 -1        | 2.238 |   520 MB/s |   750 MB/s |
-| **zstd 1.5.7 --fast=4** | 2.146 |   665 MB/s |  2050 MB/s |
-| lzo1x 2.10 -1           | 2.106 |   650 MB/s |   780 MB/s |
-| [lz4] 1.10.0            | 2.101 |   675 MB/s |  3850 MB/s |
-| snappy 1.2.1            | 2.089 |   520 MB/s |  1500 MB/s |
-| lzf 3.6 -1              | 2.077 |   410 MB/s |   820 MB/s |
+| **zstd 1.4.5 -1**       | 2.884 |   500 MB/s |  1660 MB/s |
+| zlib 1.2.11 -1          | 2.743 |    90 MB/s |   400 MB/s |
+| brotli 1.0.7 -0         | 2.703 |   400 MB/s |   450 MB/s |
+| **zstd 1.4.5 --fast=1** | 2.434 |   570 MB/s |  2200 MB/s |
+| **zstd 1.4.5 --fast=3** | 2.312 |   640 MB/s |  2300 MB/s |
+| quicklz 1.5.0 -1        | 2.238 |   560 MB/s |   710 MB/s |
+| **zstd 1.4.5 --fast=5** | 2.178 |   700 MB/s |  2420 MB/s |
+| lzo1x 2.10 -1           | 2.106 |   690 MB/s |   820 MB/s |
+| lz4 1.9.2               | 2.101 |   740 MB/s |  4530 MB/s |
+| **zstd 1.4.5 --fast=7** | 2.096 |   750 MB/s |  2480 MB/s |
+| lzf 3.6 -1              | 2.077 |   410 MB/s |   860 MB/s |
+| snappy 1.1.8            | 2.073 |   560 MB/s |  1790 MB/s |
 
-[zlib]: https://www.zlib.net/
-[lz4]: https://lz4.github.io/lz4/
+[zlib]: http://www.zlib.net/
+[LZ4]: http://www.lz4.org/
 
 The negative compression levels, specified with `--fast=#`,
-offer faster compression and decompression speed
-at the cost of compression ratio.
+offer faster compression and decompression speed in exchange for some loss in
+compression ratio compared to level 1, as seen in the table above.
 
 Zstd can also offer stronger compression ratios at the cost of compression speed.
 Speed vs Compression trade-off is configurable by small increments.
@@ -120,27 +124,14 @@ Dictionary gains are mostly effective in the first few KB. Then, the compression
 
 ## Build instructions
 
-`make` is the officially maintained build system of this project.
-All other build systems are "compatible" and 3rd-party maintained,
-they may feature small differences in advanced options.
-When your system allows it, prefer using `make` to build `zstd` and `libzstd`.
-
 ### Makefile
 
 If your system is compatible with standard `make` (or `gmake`),
 invoking `make` in root directory will generate `zstd` cli in root directory.
-It will also create `libzstd` into `lib/`.
 
 Other available options include:
 - `make install` : create and install zstd cli, library and man pages
-- `make check` : create and run `zstd`, test its behavior on local platform
-
-The `Makefile` follows the [GNU Standard Makefile conventions](https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html),
-allowing staged install, standard flags, directory variables and command variables.
-
-For advanced use cases, specialized compilation flags which control binary generation
-are documented in [`lib/README.md`](lib/README.md#modular-build) for the `libzstd` library
-and in [`programs/README.md`](programs/README.md#compilation-variables) for the `zstd` CLI.
+- `make check` : create and run `zstd`, tests its behavior on local platform
 
 ### cmake
 
@@ -150,18 +141,6 @@ to create `zstd` binary, and `libzstd` dynamic and static libraries.
 
 By default, `CMAKE_BUILD_TYPE` is set to `Release`.
 
-#### Support for Fat (Universal2) Output
-
-`zstd` can be built and installed with support for both Apple Silicon (M1/M2) as well as Intel by using CMake's Universal2 support.
-To perform a Fat/Universal2 build and install use the following commands:
-
-```bash
-cmake -B build-cmake-debug -S build/cmake -G Ninja -DCMAKE_OSX_ARCHITECTURES="x86_64;x86_64h;arm64"
-cd build-cmake-debug
-ninja
-sudo ninja install
-```
-
 ### Meson
 
 A Meson project is provided within [`build/meson`](build/meson). Follow
@@ -184,17 +163,6 @@ You can build and install zstd [vcpkg](https://github.com/Microsoft/vcpkg/) depe
 The zstd port in vcpkg is kept up to date by Microsoft team members and community contributors.
 If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
 
-### Conan
-
-You can install pre-built binaries for zstd or build it from source using [Conan](https://conan.io/). Use the following command:
-
-```bash
-conan install --requires="zstd/[*]" --build=missing
-```
-
-The zstd Conan recipe is kept up to date by Conan maintainers and community contributors.
-If the version is out of date, please [create an issue or pull request](https://github.com/conan-io/conan-center-index) on the ConanCenterIndex repository.
-
 ### Visual Studio (Windows)
 
 Going into `build` directory, you will find additional possibilities:
@@ -208,30 +176,18 @@ Going into `build` directory, you will find additional possibilities:
 You can build the zstd binary via buck by executing: `buck build programs:zstd` from the root of the repo.
 The output binary will be in `buck-out/gen/programs/`.
 
-### Bazel
-
-You easily can integrate zstd into your Bazel project by using the module hosted on the [Bazel Central Repository](https://registry.bazel.build/modules/zstd).
-
-## Testing
-
-You can run quick local smoke tests by running `make check`.
-If you can't use `make`, execute the `playTest.sh` script from the `src/tests` directory.
-Two env variables `$ZSTD_BIN` and `$DATAGEN_BIN` are needed for the test script to locate the `zstd` and `datagen` binary.
-For information on CI testing, please refer to `TESTING.md`.
-
 ## Status
 
-Zstandard is currently deployed within Facebook and many other large cloud infrastructures.
-It is run continuously to compress large amounts of data in multiple formats and use cases.
+Zstandard is currently deployed within Facebook. It is used continuously to compress large amounts of data in multiple formats and use cases.
 Zstandard is considered safe for production environments.
 
 ## License
 
-Zstandard is dual-licensed under [BSD](LICENSE) OR [GPLv2](COPYING).
+Zstandard is dual-licensed under [BSD](LICENSE) and [GPLv2](COPYING).
 
 ## Contributing
 
-The `dev` branch is the one where all contributions are merged before reaching `release`.
-If you plan to propose a patch, please commit into the `dev` branch, or its own feature branch.
-Direct commit to `release` are not permitted.
+The "dev" branch is the one where all contributions are merged before reaching "master".
+If you plan to propose a patch, please commit into the "dev" branch, or its own feature branch.
+Direct commit to "master" are not permitted.
 For more information, please read [CONTRIBUTING](CONTRIBUTING.md).

SECURITY.md

@@ -1,15 +0,0 @@
-# Reporting and Fixing Security Issues
-
-Please do not open GitHub issues or pull requests - this makes the problem immediately visible to everyone, including malicious actors. Security issues in this open source project can be safely reported via the Meta Bug Bounty program:
-
-https://www.facebook.com/whitehat
-
-Meta's security team will triage your report and determine whether or not is it eligible for a bounty under our program.
-
-# Receiving Vulnerability Notifications
-
-In the case that a significant security vulnerability is reported to us or discovered by us---without being publicly known---we will, at our discretion, notify high-profile, high-exposure users of Zstandard ahead of our public disclosure of the issue and associated fix.
-
-If you believe your project would benefit from inclusion in this list, please reach out to one of the maintainers.
-
-<!-- Note to maintainers: this list is kept [here](https://fburl.com/wiki/cgc1l62x). -->

TESTING.md

@@ -22,12 +22,12 @@ They consist of the following tests:
   - `tests/playTests.sh --test-large-data`
   - Fuzzer tests: `tests/fuzzer.c`, `tests/zstreamtest.c`, and `tests/decodecorpus.c`
 - `tests/zstreamtest.c` under Tsan (streaming mode, including multithreaded mode)
-- Valgrind Test (`make -C tests test-valgrind`) (testing CLI and fuzzer under `valgrind`)
+- Valgrind Test (`make -C tests valgrindTest`) (testing CLI and fuzzer under valgrind)
 - Fuzzer tests (see above) on ARM, AArch64, PowerPC, and PowerPC64
 
 Long Tests
 ----------
-Long tests run on all commits to `release` branch,
+Long tests run on all commits to `master` branch,
 and once a day on the current version of `dev` branch,
 on TravisCI.
 They consist of the following tests:
@@ -40,4 +40,5 @@ They consist of the following tests:
 - Versions test (ensuring `zstd` can decode files from all previous versions)
 - `pzstd` with asan and tsan, as well as in 32-bits mode
 - Testing `zstd` with legacy mode off
+- Testing `zbuff` (old streaming API)
 - Entire test suite and make install on macOS

appveyor.yml

@@ -0,0 +1,289 @@
+# Following tests are run _only_ on master branch
+# To reproduce these tests, it's possible to push into a branch `appveyorTest`
+# or a branch `visual*`, they will intentionnally trigger `master` tests
+
+-
+  version: 1.0.{build}
+  branches:
+    only:
+    - master
+    - appveyorTest
+    - /visual*/
+  environment:
+    matrix:
+    - COMPILER: "gcc"
+      HOST:     "mingw"
+      PLATFORM: "x64"
+      SCRIPT:   "make allzstd MOREFLAGS=-static && make -C tests fullbench-lib"
+      ARTIFACT: "true"
+      BUILD:    "true"
+    - COMPILER: "gcc"
+      HOST:     "mingw"
+      PLATFORM: "x86"
+      SCRIPT:   "make allzstd MOREFLAGS=-static"
+      ARTIFACT: "true"
+      BUILD:    "true"
+    - COMPILER: "clang"
+      HOST:     "mingw"
+      PLATFORM: "x64"
+      SCRIPT:   "MOREFLAGS='--target=x86_64-w64-mingw32 -Werror -Wconversion -Wno-sign-conversion' make allzstd"
+      BUILD:    "true"
+
+    - COMPILER: "gcc"
+      HOST:     "mingw"
+      PLATFORM: "x64"
+      SCRIPT:   ""
+      TEST:     "cmake"
+
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "x64"
+      CONFIGURATION: "Debug"
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "Win32"
+      CONFIGURATION: "Debug"
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "x64"
+      CONFIGURATION: "Release"
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "Win32"
+      CONFIGURATION: "Release"
+
+  install:
+  - ECHO Installing %COMPILER% %PLATFORM% %CONFIGURATION%
+  - SET PATH_ORIGINAL=%PATH%
+  - if [%HOST%]==[mingw] (
+      SET "PATH_MINGW32=C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin" &&
+      SET "PATH_MINGW64=C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin" &&
+      COPY C:\msys64\usr\bin\make.exe C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin\make.exe &&
+      COPY C:\msys64\usr\bin\make.exe C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin\make.exe
+    )
+  - IF [%HOST%]==[visual] IF [%PLATFORM%]==[x64] (
+      SET ADDITIONALPARAM=/p:LibraryPath="C:\Program Files\Microsoft SDKs\Windows\v7.1\lib\x64;c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\lib\amd64;C:\Program Files (x86)\Microsoft Visual Studio 10.0\;C:\Program Files (x86)\Microsoft Visual Studio 10.0\lib\amd64;"
+    )
+
+  build_script:
+  - if [%HOST%]==[mingw] (
+      ( if [%PLATFORM%]==[x64] (
+        SET "PATH=%PATH_MINGW64%;%PATH_ORIGINAL%"
+      ) else if [%PLATFORM%]==[x86] (
+        SET "PATH=%PATH_MINGW32%;%PATH_ORIGINAL%"
+      ) )
+    )
+  - if [%HOST%]==[mingw] if [%BUILD%]==[true] (
+      make -v &&
+      sh -c "%COMPILER% -v" &&
+      ECHO Building zlib to static link &&
+      SET "CC=%COMPILER%" &&
+      sh -c "cd .. && git clone --depth 1 --branch v1.2.11 https://github.com/madler/zlib" &&
+      sh -c "cd ../zlib && make -f win32/Makefile.gcc libz.a"
+      ECHO Building zstd &&
+      SET "CPPFLAGS=-I../../zlib" &&
+      SET "LDFLAGS=../../zlib/libz.a" &&
+      sh -c "%SCRIPT%" &&
+      ( if [%COMPILER%]==[gcc] if [%ARTIFACT%]==[true]
+          ECHO Creating artifacts &&
+          ECHO %cd% &&
+          lib\dll\example\build_package.bat &&
+          make -C programs DEBUGFLAGS= clean zstd &&
+          cd programs\ && 7z a -tzip -mx9 zstd-win-binary-%PLATFORM%.zip zstd.exe &&
+          appveyor PushArtifact zstd-win-binary-%PLATFORM%.zip &&
+          cp zstd.exe ..\bin\zstd.exe &&
+          git clone --depth 1 --branch master https://github.com/facebook/zstd &&
+          cd zstd &&
+          git archive --format=tar master -o zstd-src.tar &&
+          ..\zstd -19 zstd-src.tar &&
+          appveyor PushArtifact zstd-src.tar.zst &&
+          certUtil -hashfile zstd-src.tar.zst SHA256 > zstd-src.tar.zst.sha256.sig &&
+          appveyor PushArtifact zstd-src.tar.zst.sha256.sig &&
+          cd ..\..\bin\ &&
+          7z a -tzip -mx9 zstd-win-release-%PLATFORM%.zip * &&
+          appveyor PushArtifact zstd-win-release-%PLATFORM%.zip
+      )
+    )
+  - if [%HOST%]==[visual] (
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2008 %PLATFORM%\%CONFIGURATION% in %APPVEYOR_BUILD_FOLDER% &&
+      ECHO *** &&
+      msbuild "build\VS2008\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v90 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2008\bin\%PLATFORM%\%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2008/bin/%PLATFORM%/%CONFIGURATION%/*.exe &&
+      COPY build\VS2008\bin\%PLATFORM%\%CONFIGURATION%\fuzzer.exe tests\fuzzer_VS2008_%PLATFORM%_%CONFIGURATION%.exe &&
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2010 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "build\VS2010\zstd.sln" %ADDITIONALPARAM% /m /verbosity:minimal /property:PlatformToolset=v100 /p:ForceImportBeforeCppTargets=%APPVEYOR_BUILD_FOLDER%\build\VS2010\CompileAsCpp.props /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      msbuild "build\VS2010\zstd.sln" %ADDITIONALPARAM% /m /verbosity:minimal /property:PlatformToolset=v100 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      COPY build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\fuzzer.exe tests\fuzzer_VS2010_%PLATFORM%_%CONFIGURATION%.exe &&
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2012 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v110 /p:ForceImportBeforeCppTargets=%APPVEYOR_BUILD_FOLDER%\build\VS2010\CompileAsCpp.props /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v110 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      COPY build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\fuzzer.exe tests\fuzzer_VS2012_%PLATFORM%_%CONFIGURATION%.exe &&
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2013 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v120 /p:ForceImportBeforeCppTargets=%APPVEYOR_BUILD_FOLDER%\build\VS2010\CompileAsCpp.props /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v120 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      COPY build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\fuzzer.exe tests\fuzzer_VS2013_%PLATFORM%_%CONFIGURATION%.exe &&
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2015 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v140 /p:ForceImportBeforeCppTargets=%APPVEYOR_BUILD_FOLDER%\build\VS2010\CompileAsCpp.props /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v140 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      COPY build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\fuzzer.exe tests\fuzzer_VS2015_%PLATFORM%_%CONFIGURATION%.exe &&
+      COPY build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe tests\
+    )
+
+  test_script:
+  - ECHO Testing %COMPILER% %PLATFORM% %CONFIGURATION%
+  - SET "CC=gcc"
+  - SET "CXX=g++"
+  - if [%TEST%]==[cmake] (
+      mkdir build\cmake\build &&
+      cd build\cmake\build &&
+      cmake -G "Visual Studio 14 2015 Win64" .. &&
+      cd ..\..\.. &&
+      make clean
+    )
+  - SET "FUZZERTEST=-T30s"
+  - if [%HOST%]==[visual] if [%CONFIGURATION%]==[Release] (
+      CD tests &&
+      SET ZSTD_BIN=./zstd.exe&&
+      SET DATAGEN_BIN=./datagen.exe&&
+      sh -e playTests.sh --test-large-data &&
+      fullbench.exe -i1 &&
+      fullbench.exe -i1 -P0 &&
+      fuzzer_VS2012_%PLATFORM%_Release.exe %FUZZERTEST% &&
+      fuzzer_VS2013_%PLATFORM%_Release.exe %FUZZERTEST% &&
+      fuzzer_VS2015_%PLATFORM%_Release.exe %FUZZERTEST%
+    )
+
+
+# The following tests are for regular pushes
+# into `dev` or some feature branch
+# There run less tests, for shorter feedback loop
+
+-
+  version: 1.0.{build}
+  environment:
+    matrix:
+    - COMPILER: "gcc"
+      HOST:     "cygwin"
+      PLATFORM: "x64"
+    - COMPILER: "gcc"
+      HOST:     "mingw"
+      PLATFORM: "x64"
+      SCRIPT:   "CPPFLAGS=-DDEBUGLEVEL=2 CFLAGS=-Werror make -j allzstd DEBUGLEVEL=2"
+    - COMPILER: "gcc"
+      HOST:     "mingw"
+      PLATFORM: "x86"
+      SCRIPT:   "CFLAGS=-Werror make -j allzstd"
+    - COMPILER: "clang"
+      HOST:     "mingw"
+      PLATFORM: "x64"
+      SCRIPT:   "CFLAGS='--target=x86_64-w64-mingw32 -Werror -Wconversion -Wno-sign-conversion' make -j allzstd"
+
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "x64"
+      CONFIGURATION: "Debug"
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "Win32"
+      CONFIGURATION: "Debug"
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "x64"
+      CONFIGURATION: "Release"
+    - COMPILER: "visual"
+      HOST:     "visual"
+      PLATFORM: "Win32"
+      CONFIGURATION: "Release"
+
+  install:
+  - ECHO Installing %COMPILER% %PLATFORM% %CONFIGURATION%
+  - SET PATH_ORIGINAL=%PATH%
+  - if [%HOST%]==[cygwin] (
+      ECHO Installing Cygwin Packages &&
+      C:\cygwin64\setup-x86_64.exe -qnNdO -R "C:\cygwin64" -g -P ^
+        gcc-g++,^
+        gcc,^
+        cmake,^
+        make
+    )
+  - if [%HOST%]==[mingw] (
+      SET "PATH_MINGW32=C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin" &&
+      SET "PATH_MINGW64=C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin" &&
+      COPY C:\msys64\usr\bin\make.exe C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin\make.exe &&
+      COPY C:\msys64\usr\bin\make.exe C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin\make.exe
+    )
+  - IF [%HOST%]==[visual] IF [%PLATFORM%]==[x64] (
+      SET ADDITIONALPARAM=/p:LibraryPath="C:\Program Files\Microsoft SDKs\Windows\v7.1\lib\x64;c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\lib\amd64;C:\Program Files (x86)\Microsoft Visual Studio 10.0\;C:\Program Files (x86)\Microsoft Visual Studio 10.0\lib\amd64;"
+    )
+
+  build_script:
+  - ECHO Building %COMPILER% %PLATFORM% %CONFIGURATION%
+  - if [%HOST%]==[cygwin] (
+      set CHERE_INVOKING=yes &&
+      set CC=%COMPILER% &&
+      C:\cygwin64\bin\bash --login -c "
+        set -e;
+        cd build/cmake;
+        CFLAGS='-Werror' cmake -G 'Unix Makefiles' -DCMAKE_BUILD_TYPE=Debug -DZSTD_BUILD_TESTS:BOOL=ON -DZSTD_FUZZER_FLAGS=-T30s -DZSTD_ZSTREAM_FLAGS=-T30s .;
+        make -j4;
+        ctest -V -L Medium;
+      "
+    )
+  - if [%HOST%]==[mingw] (
+      ( if [%PLATFORM%]==[x64] (
+        SET "PATH=%PATH_MINGW64%;%PATH_ORIGINAL%"
+      ) else if [%PLATFORM%]==[x86] (
+        SET "PATH=%PATH_MINGW32%;%PATH_ORIGINAL%"
+      ) ) &&
+      make -v &&
+      sh -c "%COMPILER% -v" &&
+      set "CC=%COMPILER%" &&
+      sh -c "%SCRIPT%"
+    )
+  - if [%HOST%]==[visual] (
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2015 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v140 /p:ForceImportBeforeCppTargets=%APPVEYOR_BUILD_FOLDER%\build\VS2010\CompileAsCpp.props /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      msbuild "build\VS2010\zstd.sln" /m /verbosity:minimal /property:PlatformToolset=v140 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      DIR build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe &&
+      MD5sum build/VS2010/bin/%PLATFORM%_%CONFIGURATION%/*.exe &&
+      COPY build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\fuzzer.exe tests\fuzzer_VS2015_%PLATFORM%_%CONFIGURATION%.exe &&
+      COPY build\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe tests\
+    )
+
+
+  test_script:
+  - ECHO Testing %COMPILER% %PLATFORM% %CONFIGURATION%
+  - if [%HOST%]==[mingw] (
+      set "CC=%COMPILER%" &&
+      make check
+    )

build/VS2008/fullbench/fullbench.vcproj

@@ -463,7 +463,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File

build/VS2008/fuzzer/fuzzer.vcproj

@@ -483,7 +483,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File
@@ -511,7 +511,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zdict.h"
+				RelativePath="..\..\..\lib\dictBuilder\zdict.h"
 				>
 			</File>
 			<File

build/VS2008/zstd/zstd.vcproj

@@ -356,10 +356,6 @@
 				RelativePath="..\..\..\programs\dibio.c"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\programs\lorem.c"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\lib\dictBuilder\cover.c"
 				>
@@ -387,10 +383,6 @@
 			<File
 				RelativePath="..\..\..\programs\fileio.c"
 				>
-			</File>
-			<File
-                RelativePath="..\..\..\programs\fileio_asyncio.c"
-                >
 			</File>
 			<File
 				RelativePath="..\..\..\lib\compress\fse_compress.c"
@@ -488,10 +480,6 @@
 				RelativePath="..\..\..\programs\zstdcli.c"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\programs\zstdcli_trace.c"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\lib\compress\zstdmt_compress.c"
 				>
@@ -567,7 +555,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zdict.h"
+				RelativePath="..\..\..\lib\dictBuilder\zdict.h"
 				>
 			</File>
 			<File
@@ -583,7 +571,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File

build/VS2008/zstdlib/zstdlib.vcproj

@@ -495,7 +495,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File
@@ -523,7 +523,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zdict.h"
+				RelativePath="..\..\..\lib\dictBuilder\zdict.h"
 				>
 			</File>
 			<File

build/VS2010/datagen/datagen.vcxproj

@@ -157,8 +157,6 @@
   <ItemGroup>
     <ClCompile Include="..\..\..\programs\util.c" />
     <ClCompile Include="..\..\..\programs\datagen.c" />
-    <ClCompile Include="..\..\..\programs\lorem.c" />
-    <ClCompile Include="..\..\..\tests\loremOut.c" />
     <ClCompile Include="..\..\..\tests\datagencli.c" />
   </ItemGroup>
   <ItemGroup>

build/VS2010/fullbench-dll/fullbench-dll.vcxproj

@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{00000000-1CC8-4FD7-9281-6B8DBB9D3DF8}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>fullbench-dll</RootNamespace>
+    <OutDir>$(SolutionDir)bin\$(Platform)_$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)bin\obj\$(RootNamespace)_$(Platform)_$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(IncludePath);$(SolutionDir)..\..\lib;$(SolutionDir)..\..\programs;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib\common;$(UniversalCRT_IncludePath);</IncludePath>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(IncludePath);$(SolutionDir)..\..\lib;$(SolutionDir)..\..\programs;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib\common;$(UniversalCRT_IncludePath);</IncludePath>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(IncludePath);$(SolutionDir)..\..\lib;$(SolutionDir)..\..\programs;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib\common;$(UniversalCRT_IncludePath);</IncludePath>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(IncludePath);$(SolutionDir)..\..\lib;$(SolutionDir)..\..\programs;$(SolutionDir)..\..\lib\legacy;$(SolutionDir)..\..\lib\common;$(UniversalCRT_IncludePath);</IncludePath>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <EnablePREfast>false</EnablePREfast>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Platform)_$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>libzstd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <EnablePREfast>false</EnablePREfast>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Platform)_$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>libzstd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <EnablePREfast>false</EnablePREfast>
+      <TreatWarningAsError>false</TreatWarningAsError>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Platform)_$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>libzstd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>false</TreatWarningAsError>
+      <EnablePREfast>false</EnablePREfast>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalLibraryDirectories>$(SolutionDir)bin\$(Platform)_$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>libzstd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\lib\common\xxhash.c" />
+    <ClCompile Include="..\..\..\programs\util.c" />
+    <ClCompile Include="..\..\..\programs\timefn.c" />
+    <ClCompile Include="..\..\..\programs\datagen.c" />
+    <ClCompile Include="..\..\..\programs\benchfn.c" />
+    <ClCompile Include="..\..\..\tests\fullbench.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\lib\zstd.h" />
+    <ClInclude Include="..\..\..\programs\datagen.h" />
+    <ClInclude Include="..\..\..\programs\benchfn.h" />
+    <ClInclude Include="..\..\..\programs\util.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\libzstd-dll\libzstd-dll.vcxproj">
+      <Project>{00000000-94d5-4bf9-8a50-7bd9929a0850}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

build/VS2010/fullbench/fullbench.vcxproj

@@ -170,7 +170,6 @@
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
-    <ClCompile Include="..\..\..\lib\compress\zstd_preSplit.c" />
     <ClCompile Include="..\..\..\lib\compress\zstdmt_compress.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
@@ -184,7 +183,6 @@
     <ClCompile Include="..\..\..\programs\util.c" />
     <ClCompile Include="..\..\..\programs\timefn.c" />
     <ClCompile Include="..\..\..\programs\datagen.c" />
-    <ClCompile Include="..\..\..\programs\lorem.c" />
     <ClCompile Include="..\..\..\programs\benchfn.c" />
     <ClCompile Include="..\..\..\tests\fullbench.c" />
   </ItemGroup>
@@ -192,7 +190,7 @@
     <ClInclude Include="..\..\..\lib\zstd.h" />
     <ClInclude Include="..\..\..\lib\common\fse.h" />
     <ClInclude Include="..\..\..\lib\common\huf.h" />
-    <ClInclude Include="..\..\..\lib\zstd_errors.h" />
+    <ClInclude Include="..\..\..\lib\common\zstd_errors.h" />
     <ClInclude Include="..\..\..\lib\common\zstd_internal.h" />
     <ClInclude Include="..\..\..\lib\common\pool.h" />
     <ClInclude Include="..\..\..\lib\common\threading.h" />

build/VS2010/fuzzer/fuzzer.vcxproj

@@ -170,7 +170,6 @@
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
-    <ClCompile Include="..\..\..\lib\compress\zstd_preSplit.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
@@ -197,7 +196,7 @@
     <ClInclude Include="..\..\..\lib\common\huf.h" />
     <ClInclude Include="..\..\..\lib\common\xxhash.h" />
     <ClInclude Include="..\..\..\lib\common\zstd_internal.h" />
-    <ClInclude Include="..\..\..\lib\zstd_errors.h" />
+    <ClInclude Include="..\..\..\lib\common\zstd_errors.h" />
     <ClInclude Include="..\..\..\lib\zstd.h" />
     <ClInclude Include="..\..\..\lib\compress\zstd_compress.h" />
     <ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
@@ -212,7 +211,7 @@
     <ClInclude Include="..\..\..\lib\compress\zstdmt_compress.h" />
     <ClInclude Include="..\..\..\lib\decompress\zstd_ddict.h" />
     <ClInclude Include="..\..\..\lib\dictBuilder\divsufsort.h" />
-    <ClInclude Include="..\..\..\lib\zdict.h" />
+    <ClInclude Include="..\..\..\lib\dictBuilder\zdict.h" />
     <ClInclude Include="..\..\..\lib\dictBuilder\cover.h" />
     <ClInclude Include="..\..\..\lib\legacy\zstd_legacy.h" />
     <ClInclude Include="..\..\..\programs\datagen.h" />

build/VS2010/libzstd-dll/libzstd-dll.rc

@@ -32,11 +32,11 @@ BEGIN
     BEGIN
         BLOCK "040904B0"
         BEGIN
-            VALUE "CompanyName", "Meta Platforms, Inc."
+            VALUE "CompanyName", "Yann Collet, Facebook, Inc."
             VALUE "FileDescription", "Zstandard - Fast and efficient compression algorithm"
             VALUE "FileVersion", ZSTD_VERSION_STRING
             VALUE "InternalName", "libzstd.dll"
-            VALUE "LegalCopyright", "Copyright (c) Meta Platforms, Inc. and affiliates."
+            VALUE "LegalCopyright", "Copyright (c) 2013-present, Yann Collet, Facebook, Inc."
             VALUE "OriginalFilename", "libzstd.dll"
             VALUE "ProductName", "Zstandard"
             VALUE "ProductVersion", ZSTD_VERSION_STRING

build/VS2010/libzstd-dll/libzstd-dll.vcxproj

@@ -34,7 +34,6 @@
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
-    <ClCompile Include="..\..\..\lib\compress\zstd_preSplit.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
@@ -45,6 +44,9 @@
     <ClCompile Include="..\..\..\lib\decompress\zstd_decompress.c" />
     <ClCompile Include="..\..\..\lib\decompress\zstd_decompress_block.c" />
     <ClCompile Include="..\..\..\lib\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\lib\deprecated\zbuff_common.c" />
+    <ClCompile Include="..\..\..\lib\deprecated\zbuff_compress.c" />
+    <ClCompile Include="..\..\..\lib\deprecated\zbuff_decompress.c" />
     <ClCompile Include="..\..\..\lib\dictBuilder\cover.c" />
     <ClCompile Include="..\..\..\lib\dictBuilder\fastcover.c" />
     <ClCompile Include="..\..\..\lib\dictBuilder\divsufsort.c" />
@@ -62,11 +64,12 @@
     <ClInclude Include="..\..\..\lib\common\threading.h" />
     <ClInclude Include="..\..\..\lib\common\bitstream.h" />
     <ClInclude Include="..\..\..\lib\common\error_private.h" />
-    <ClInclude Include="..\..\..\lib\zstd_errors.h" />
+    <ClInclude Include="..\..\..\lib\common\zstd_errors.h" />
     <ClInclude Include="..\..\..\lib\common\mem.h" />
     <ClInclude Include="..\..\..\lib\common\fse.h" />
     <ClInclude Include="..\..\..\lib\common\huf.h" />
     <ClInclude Include="..\..\..\lib\common\xxhash.h" />
+    <ClInclude Include="..\..\..\lib\deprecated\zbuff.h" />
     <ClInclude Include="..\..\..\lib\legacy\zstd_legacy.h" />
     <ClInclude Include="..\..\..\lib\legacy\zstd_v01.h" />
     <ClInclude Include="..\..\..\lib\legacy\zstd_v02.h" />
@@ -170,6 +173,7 @@
       <WarningLevel>Level4</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>ZSTD_DLL_EXPORT=1;ZSTD_MULTITHREAD=1;ZSTD_LEGACY_SUPPORT=5;WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>

build/VS2010/libzstd/libzstd.vcxproj

@@ -34,7 +34,6 @@
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
-    <ClCompile Include="..\..\..\lib\compress\zstd_preSplit.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
@@ -45,6 +44,9 @@
     <ClCompile Include="..\..\..\lib\decompress\zstd_decompress.c" />
     <ClCompile Include="..\..\..\lib\decompress\zstd_decompress_block.c" />
     <ClCompile Include="..\..\..\lib\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\lib\deprecated\zbuff_common.c" />
+    <ClCompile Include="..\..\..\lib\deprecated\zbuff_compress.c" />
+    <ClCompile Include="..\..\..\lib\deprecated\zbuff_decompress.c" />
     <ClCompile Include="..\..\..\lib\dictBuilder\cover.c" />
     <ClCompile Include="..\..\..\lib\dictBuilder\fastcover.c" />
     <ClCompile Include="..\..\..\lib\dictBuilder\divsufsort.c" />
@@ -62,11 +64,12 @@
     <ClInclude Include="..\..\..\lib\common\threading.h" />
     <ClInclude Include="..\..\..\lib\common\bitstream.h" />
     <ClInclude Include="..\..\..\lib\common\error_private.h" />
-    <ClInclude Include="..\..\..\lib\zstd_errors.h" />
+    <ClInclude Include="..\..\..\lib\common\zstd_errors.h" />
     <ClInclude Include="..\..\..\lib\common\mem.h" />
     <ClInclude Include="..\..\..\lib\common\fse.h" />
     <ClInclude Include="..\..\..\lib\common\huf.h" />
     <ClInclude Include="..\..\..\lib\common\xxhash.h" />
+    <ClInclude Include="..\..\..\lib\deprecated\zbuff.h" />
     <ClInclude Include="..\..\..\lib\legacy\zstd_legacy.h" />
     <ClInclude Include="..\..\..\lib\legacy\zstd_v01.h" />
     <ClInclude Include="..\..\..\lib\legacy\zstd_v02.h" />
@@ -163,6 +166,7 @@
       <WarningLevel>Level4</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>ZSTD_MULTITHREAD=1;ZSTD_LEGACY_SUPPORT=5;WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>

build/VS2010/zstd.sln

@@ -7,6 +7,11 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fuzzer", "fuzzer\fuzzer.vcx
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fullbench", "fullbench\fullbench.vcxproj", "{61ABD629-1CC8-4FD7-9281-6B8DBB9D3DF8}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fullbench-dll", "fullbench-dll\fullbench-dll.vcxproj", "{00000000-1CC8-4FD7-9281-6B8DBB9D3DF8}"
+	ProjectSection(ProjectDependencies) = postProject
+		{00000000-94D5-4BF9-8A50-7BD9929A0850} = {00000000-94D5-4BF9-8A50-7BD9929A0850}
+	EndProjectSection
+EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "datagen", "datagen\datagen.vcxproj", "{037E781E-81A6-494B-B1B3-438AB1200523}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libzstd", "libzstd\libzstd.vcxproj", "{8BFD8150-94D5-4BF9-8A50-7BD9929A0850}"

build/VS2010/zstd/zstd.rc

@@ -32,11 +32,11 @@ BEGIN
     BEGIN
         BLOCK "040904B0"
         BEGIN
-            VALUE "CompanyName", "Meta Platforms, Inc."
+            VALUE "CompanyName", "Yann Collet, Facebook, Inc."
             VALUE "FileDescription", "Zstandard - Fast and efficient compression algorithm"
             VALUE "FileVersion", ZSTD_VERSION_STRING
             VALUE "InternalName", "zstd.exe"
-            VALUE "LegalCopyright", "Copyright (c) Meta Platforms, Inc. and affiliates."
+            VALUE "LegalCopyright", "Copyright (c) 2013-present, Yann Collet, Facebook, Inc."
             VALUE "OriginalFilename", "zstd.exe"
             VALUE "ProductName", "Zstandard"
             VALUE "ProductVersion", ZSTD_VERSION_STRING

build/VS2010/zstd/zstd.vcxproj

@@ -35,7 +35,6 @@
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_literals.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_sequences.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_compress_superblock.c" />
-    <ClCompile Include="..\..\..\lib\compress\zstd_preSplit.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_double_fast.c" />
     <ClCompile Include="..\..\..\lib\compress\zstd_lazy.c" />
@@ -63,24 +62,21 @@
     <ClCompile Include="..\..\..\programs\datagen.c" />
     <ClCompile Include="..\..\..\programs\dibio.c" />
     <ClCompile Include="..\..\..\programs\fileio.c" />
-    <ClCompile Include="..\..\..\programs\fileio_asyncio.c" />
-    <ClCompile Include="..\..\..\programs\lorem.c" />
     <ClCompile Include="..\..\..\programs\zstdcli.c" />
-    <ClCompile Include="..\..\..\programs\zstdcli_trace.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\..\lib\common\pool.h" />
     <ClInclude Include="..\..\..\lib\common\threading.h" />
     <ClInclude Include="..\..\..\lib\common\xxhash.h" />
     <ClInclude Include="..\..\..\lib\compress\zstdmt_compress.h" />
-    <ClInclude Include="..\..\..\lib\zdict.h" />
+    <ClInclude Include="..\..\..\lib\dictBuilder\zdict.h" />
     <ClInclude Include="..\..\..\lib\dictBuilder\cover.h" />
     <ClInclude Include="..\..\..\lib\dictBuilder\divsufsort.h" />
     <ClInclude Include="..\..\..\lib\common\fse.h" />
     <ClInclude Include="..\..\..\lib\common\huf.h" />
     <ClInclude Include="..\..\..\lib\zstd.h" />
     <ClInclude Include="..\..\..\lib\common\zstd_internal.h" />
-    <ClInclude Include="..\..\..\lib\zstd_errors.h" />
+    <ClInclude Include="..\..\..\lib\common\zstd_errors.h" />
     <ClInclude Include="..\..\..\lib\compress\zstd_compress.h" />
     <ClInclude Include="..\..\..\lib\compress\zstd_compress_literals.h" />
     <ClInclude Include="..\..\..\lib\compress\zstd_compress_sequences.h" />
@@ -116,7 +112,6 @@
     <RootNamespace>zstd</RootNamespace>
     <OutDir>$(SolutionDir)bin\$(Platform)_$(Configuration)\</OutDir>
     <IntDir>$(SolutionDir)bin\obj\$(RootNamespace)_$(Platform)_$(Configuration)\</IntDir>
-    <InstructionSet>NotSet</InstructionSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -190,7 +185,6 @@
       <PreprocessorDefinitions>ZSTD_MULTITHREAD=1;ZSTD_LEGACY_SUPPORT=5;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <TreatWarningAsError>true</TreatWarningAsError>
       <EnablePREfast>false</EnablePREfast>
-      <EnableEnhancedInstructionSet>$(InstructionSet)</EnableEnhancedInstructionSet>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -207,7 +201,6 @@
       <PreprocessorDefinitions>ZSTD_MULTITHREAD=1;ZSTD_LEGACY_SUPPORT=5;WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <TreatWarningAsError>true</TreatWarningAsError>
       <EnablePREfast>false</EnablePREfast>
-      <EnableEnhancedInstructionSet>$(InstructionSet)</EnableEnhancedInstructionSet>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -227,7 +220,6 @@
       <EnablePREfast>false</EnablePREfast>
       <TreatWarningAsError>false</TreatWarningAsError>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <EnableEnhancedInstructionSet>$(InstructionSet)</EnableEnhancedInstructionSet>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -250,7 +242,6 @@
       <EnablePREfast>false</EnablePREfast>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <AdditionalOptions>/DZSTD_MULTITHREAD %(AdditionalOptions)</AdditionalOptions>
-      <EnableEnhancedInstructionSet>$(InstructionSet)</EnableEnhancedInstructionSet>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>

build/VS_scripts/build.VSPreview.cmd

@@ -1,7 +0,0 @@
-@echo off
-
-rem build 32-bit
-call "%~p0%build.generic.cmd" preview Win32 Release v143
-
-rem build 64-bit
-call "%~p0%build.generic.cmd" preview x64 Release v143

build/VS_scripts/build.generic.cmd

@@ -2,7 +2,7 @@
 
 IF "%1%" == "" GOTO display_help
 
-SETLOCAL ENABLEDELAYEDEXPANSION
+SETLOCAL
 
 SET msbuild_version=%1
 
@@ -19,34 +19,29 @@ GOTO build
 :display_help
 
 echo Syntax: build.generic.cmd msbuild_version msbuild_platform msbuild_configuration msbuild_toolset
-echo   msbuild_version:          VS installed version (latest, VS2012, VS2013, VS2015, VS2017, VS2019, VS2022, ...)
+echo   msbuild_version:          VS installed version (VS2012, VS2013, VS2015, VS2017, ...)
 echo   msbuild_platform:         Platform (x64 or Win32)
 echo   msbuild_configuration:    VS configuration (Release or Debug)
-echo   msbuild_toolset:          Platform Toolset (v100, v110, v120, v140, v141, v142, v143, ...)
+echo   msbuild_toolset:          Platform Toolset (v100, v110, v120, v140, v141)
 
 EXIT /B 1
 
 :build
 
 SET msbuild="%windir%\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe"
+SET msbuild_vs2017community="%programfiles(x86)%\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin\MSBuild.exe"
+SET msbuild_vs2017professional="%programfiles(x86)%\Microsoft Visual Studio\2017\Professional\MSBuild\15.0\Bin\MSBuild.exe"
+SET msbuild_vs2017enterprise="%programfiles(x86)%\Microsoft Visual Studio\2017\Enterprise\MSBuild\15.0\Bin\MSBuild.exe"
 IF %msbuild_version% == VS2013 SET msbuild="%programfiles(x86)%\MSBuild\12.0\Bin\MSBuild.exe"
 IF %msbuild_version% == VS2015 SET msbuild="%programfiles(x86)%\MSBuild\14.0\Bin\MSBuild.exe"
-IF %msbuild_version% == VS2017 SET vswhere_params=-version [15,16) -products *
-IF %msbuild_version% == VS2017Community SET vswhere_params=-version [15,16) -products Community
-IF %msbuild_version% == VS2017Enterprise SET vswhere_params=-version [15,16) -products Enterprise
-IF %msbuild_version% == VS2017Professional SET vswhere_params=-version [15,16) -products Professional
-IF %msbuild_version% == VS2019 SET vswhere_params=-version [16,17) -products *
-IF %msbuild_version% == VS2022 SET vswhere_params=-version [17,18) -products *
-REM Add the next Visual Studio version here.
-IF %msbuild_version% == latest SET vswhere_params=-latest -products *
-IF %msbuild_version% == preview SET vswhere_params=-prerelease -products *
-
-IF NOT DEFINED vswhere_params GOTO skip_vswhere
-SET vswhere="%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe"
-FOR /F "USEBACKQ TOKENS=*" %%F IN (`%vswhere% !vswhere_params! -requires Microsoft.Component.MSBuild -find MSBuild\**\Bin\MSBuild.exe`) DO (
-	SET msbuild="%%F"
+IF %msbuild_version% == VS2017Community SET msbuild=%msbuild_vs2017community%
+IF %msbuild_version% == VS2017Professional SET msbuild=%msbuild_vs2017professional%
+IF %msbuild_version% == VS2017Enterprise SET msbuild=%msbuild_vs2017enterprise%
+IF %msbuild_version% == VS2017 (
+	IF EXIST %msbuild_vs2017community% SET msbuild=%msbuild_vs2017community%
+	IF EXIST %msbuild_vs2017professional% SET msbuild=%msbuild_vs2017professional%
+	IF EXIST %msbuild_vs2017enterprise% SET msbuild=%msbuild_vs2017enterprise%
 )
-:skip_vswhere
 
 SET project="%~p0\..\VS2010\zstd.sln"
 

build/cmake/CMakeLists.txt

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the
@@ -7,75 +7,197 @@
 # in the COPYING file in the root directory of this source tree).
 # ################################################################
 
-cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.9 FATAL_ERROR)
+  
+# As of 2018-12-26 ZSTD has been validated to build with cmake version 3.13.2 new policies. 
+# Set and use the newest cmake policies that are validated to work 
+set(ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION "3") 
+set(ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION "13") #Policies never changed at PATCH level
+if("${CMAKE_MAJOR_VERSION}" LESS 3)
+  set(ZSTD_CMAKE_POLICY_VERSION "${CMAKE_VERSION}") 
+elseif( "${ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION}" EQUAL "${CMAKE_MAJOR_VERSION}" AND 
+        "${ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION}" GREATER "${CMAKE_MINOR_VERSION}")
+    set(ZSTD_CMAKE_POLICY_VERSION "${CMAKE_VERSION}") 
+else() 
+    set(ZSTD_CMAKE_POLICY_VERSION "${ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION}.${ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION}.0") 
+endif()
+cmake_policy(VERSION ${ZSTD_CMAKE_POLICY_VERSION})
+
+set(CMAKE_BUILD_WITH_INSTALL_RPATH on)
 
-#-----------------------------------------------------------------------------
-# Setup CMake environment
-#-----------------------------------------------------------------------------
-set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
-
-# Define project paths
 set(ZSTD_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../..")
 set(LIBRARY_DIR ${ZSTD_SOURCE_DIR}/lib)
+# Parse version
+include(GetZstdLibraryVersion)
+GetZstdLibraryVersion(${LIBRARY_DIR}/zstd.h zstd_VERSION_MAJOR zstd_VERSION_MINOR zstd_VERSION_PATCH)
 
-#-----------------------------------------------------------------------------
-# Configure CMake policies and version
-#-----------------------------------------------------------------------------
-include(ZstdVersion)
+if( CMAKE_MAJOR_VERSION LESS 3 )
+  ## Provide cmake 3+ behavior for older versions of cmake
+  project(zstd)
+  set(PROJECT_VERSION_MAJOR ${zstd_VERSION_MAJOR})
+  set(PROJECT_VERSION_MINOR ${zstd_VERSION_MINOR})
+  set(PROJECT_VERSION_PATCH ${zstd_VERSION_PATCH})
+  set(PROJECT_VERSION "${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}.${zstd_VERSION_PATCH}")
+  enable_language(C)   # Main library is in C
+  enable_language(CXX) # Testing contributed code also utilizes CXX
+else()
+  project(zstd
+    VERSION "${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}.${zstd_VERSION_PATCH}"
+    LANGUAGES C   # Main library is in C
+              CXX # Testing contributed code also utilizes CXX
+    )
+endif()
+message(STATUS "ZSTD VERSION: ${zstd_VERSION}")
+set(zstd_HOMEPAGE_URL "http://www.zstd.net")
+set(zstd_DESCRIPTION  "Zstandard is a real-time compression algorithm, providing high compression ratios.")
 
-#-----------------------------------------------------------------------------
-# Project declaration
-#-----------------------------------------------------------------------------
-project(zstd
-    VERSION "${ZSTD_FULL_VERSION}"
-    LANGUAGES C ASM  # Main library is in C and ASM
-    HOMEPAGE_URL "${zstd_HOMEPAGE_URL}"
-    DESCRIPTION "${zstd_DESCRIPTION}"
-)
-
-#-----------------------------------------------------------------------------
-# Build type configuration
-#-----------------------------------------------------------------------------
+# Set a default build type if none was specified
 if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to 'Release' as none was specified.")
   set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui
   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 
-#-----------------------------------------------------------------------------
-# Include standard modules
-#-----------------------------------------------------------------------------
 include(GNUInstallDirs)
 
 #-----------------------------------------------------------------------------
-# Display installation information
+# Add extra compilation flags
+#-----------------------------------------------------------------------------
+include(AddZstdCompilationFlags)
+ADD_ZSTD_COMPILATION_FLAGS()
+
+# Always hide XXHash symbols
+add_definitions(-DXXH_NAMESPACE=ZSTD_)
+
+#-----------------------------------------------------------------------------
+# Installation variables
 #-----------------------------------------------------------------------------
 message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
 message(STATUS "CMAKE_INSTALL_LIBDIR: ${CMAKE_INSTALL_LIBDIR}")
 
 #-----------------------------------------------------------------------------
-# Configure build options
+# Options
 #-----------------------------------------------------------------------------
-include(ZstdOptions)
+
+# Legacy support
+option(ZSTD_LEGACY_SUPPORT "LEGACY SUPPORT" OFF)
+
+if (ZSTD_LEGACY_SUPPORT)
+    message(STATUS "ZSTD_LEGACY_SUPPORT defined!")
+    add_definitions(-DZSTD_LEGACY_SUPPORT=5)
+else ()
+    message(STATUS "ZSTD_LEGACY_SUPPORT not defined!")
+    add_definitions(-DZSTD_LEGACY_SUPPORT=0)
+endif ()
+
+# Multi-threading support
+option(ZSTD_MULTITHREAD_SUPPORT "MULTITHREADING SUPPORT" ON)
+
+if (ZSTD_MULTITHREAD_SUPPORT)
+    message(STATUS "ZSTD_MULTITHREAD_SUPPORT is enabled")
+else ()
+    message(STATUS "ZSTD_MULTITHREAD_SUPPORT is disabled")
+endif ()
+
+option(ZSTD_BUILD_PROGRAMS "BUILD PROGRAMS" ON)
+option(ZSTD_BUILD_CONTRIB "BUILD CONTRIB" OFF)
+
+# Respect the conventional CMake option for enabling tests if it was specified on the first configure
+if (BUILD_TESTING)
+    set(ZSTD_BUILD_TESTS_default ON)
+else()
+    set(ZSTD_BUILD_TESTS_default OFF)
+endif()
+option(ZSTD_BUILD_TESTS "BUILD TESTS" ${ZSTD_BUILD_TESTS_default})
+if (MSVC)
+    option(ZSTD_USE_STATIC_RUNTIME "LINK TO STATIC RUN-TIME LIBRARIES" OFF)
+endif ()
 
 #-----------------------------------------------------------------------------
-# Configure compilation flags
+# External dependencies
 #-----------------------------------------------------------------------------
-include(AddZstdCompilationFlags)
-ADD_ZSTD_COMPILATION_FLAGS(ON ZSTD_ENABLE_CXX ON)
+if (ZSTD_MULTITHREAD_SUPPORT AND UNIX)
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+    find_package(Threads REQUIRED)
+    if(CMAKE_USE_PTHREADS_INIT)
+        set(THREADS_LIBS "${CMAKE_THREAD_LIBS_INIT}")
+    else()
+        message(SEND_ERROR "ZSTD currently does not support thread libraries other than pthreads")
+    endif()
+endif ()
 
 #-----------------------------------------------------------------------------
-# Configure dependencies
+# Add source directories
 #-----------------------------------------------------------------------------
-include(ZstdDependencies)
+add_subdirectory(lib)
+
+option(ZSTD_PROGRAMS_LINK_SHARED "PROGRAMS LINK SHARED" OFF)
+
+if (ZSTD_BUILD_PROGRAMS)
+    if (NOT ZSTD_BUILD_STATIC AND NOT ZSTD_PROGRAMS_LINK_SHARED)
+        message(SEND_ERROR "You need to build static library to build zstd CLI")
+    elseif(NOT ZSTD_BUILD_SHARED AND ZSTD_PROGRAMS_LINK_SHARED)
+        message(SEND_ERROR "You need to build shared library to build zstd CLI")
+    endif ()
+
+    add_subdirectory(programs)
+endif ()
+
+if (ZSTD_BUILD_TESTS)
+    enable_testing()
+    if (NOT ZSTD_BUILD_STATIC)
+        message(SEND_ERROR "You need to build static library to build tests")
+    endif ()
+
+    add_subdirectory(tests)
+endif ()
+
+if (ZSTD_BUILD_CONTRIB)
+    add_subdirectory(contrib)
+endif ()
 
 #-----------------------------------------------------------------------------
-# Configure build targets
+# Add clean-all target
 #-----------------------------------------------------------------------------
-include(ZstdBuild)
+add_custom_target(clean-all
+   COMMAND ${CMAKE_BUILD_TOOL} clean
+   COMMAND rm -rf ${CMAKE_BINARY_DIR}/
+)
 
 #-----------------------------------------------------------------------------
-# Configure package generation
+# Generate Package Config files
+#
+# This section is based on the boiler plate code from:
+# https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#creating-packages
 #-----------------------------------------------------------------------------
-include(ZstdPackage)
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfigVersion.cmake"
+    VERSION ${zstd_VERSION}
+    COMPATIBILITY SameMajorVersion
+    )
+
+# A Package Config file that works from the build directory
+export(EXPORT zstdExports
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/zstdTargets.cmake"
+    NAMESPACE zstd::
+    )
+configure_file(zstdConfig.cmake
+    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfig.cmake"
+    COPYONLY
+    )
+
+# A Package Config file that works from the installation directory
+set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/zstd)
+install(EXPORT zstdExports
+    FILE zstdTargets.cmake
+    NAMESPACE zstd::
+    DESTINATION ${ConfigPackageLocation}
+    )
+install(FILES
+    zstdConfig.cmake
+    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfigVersion.cmake"
+    DESTINATION ${ConfigPackageLocation}
+    )

build/cmake/CMakeModules/AddZstdCompilationFlags.cmake

@@ -1,18 +1,7 @@
+include(CheckCXXCompilerFlag)
 include(CheckCCompilerFlag)
-if(CMAKE_CXX_COMPILER)
-    include(CheckCXXCompilerFlag)
-endif()
 
-if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.18)
-    set(ZSTD_HAVE_CHECK_LINKER_FLAG true)
-else ()
-    set(ZSTD_HAVE_CHECK_LINKER_FLAG false)
-endif ()
-if (ZSTD_HAVE_CHECK_LINKER_FLAG)
-    include(CheckLinkerFlag)
-endif()
-
-function(EnableCompilerFlag _flag _C _CXX _LD)
+function(EnableCompilerFlag _flag _C _CXX)
     string(REGEX REPLACE "\\+" "PLUS" varname "${_flag}")
     string(REGEX REPLACE "[^A-Za-z0-9]+" "_" varname "${varname}")
     string(REGEX REPLACE "^_+" "" varname "${varname}")
@@ -23,93 +12,44 @@ function(EnableCompilerFlag _flag _C _CXX _LD)
             set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_flag}" PARENT_SCOPE)
         endif ()
     endif ()
-    if (_CXX AND CMAKE_CXX_COMPILER)
+    if (_CXX)
         CHECK_CXX_COMPILER_FLAG(${_flag} CXX_FLAG_${varname})
         if (CXX_FLAG_${varname})
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_flag}" PARENT_SCOPE)
         endif ()
     endif ()
-    if (_LD)
-        # We never add a linker flag with CMake < 3.18. We will
-        # implement CHECK_LINKER_FLAG() like feature for CMake < 3.18
-        # or require CMake >= 3.18 when we need to add a required
-        # linker flag in future.
-        #
-        # We also skip linker flags check for MSVC compilers (which includes
-        # clang-cl) since currently check_linker_flag() doesn't give correct
-        # results for this configuration,
-        # see: https://gitlab.kitware.com/cmake/cmake/-/issues/22023
-        if (ZSTD_HAVE_CHECK_LINKER_FLAG AND NOT MSVC)
-            CHECK_LINKER_FLAG(C ${_flag} LD_FLAG_${varname})
-        else ()
-            set(LD_FLAG_${varname} false)
-        endif ()
-        if (LD_FLAG_${varname})
-            set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${_flag}" PARENT_SCOPE)
-            set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${_flag}" PARENT_SCOPE)
-        endif ()
-    endif ()
 endfunction()
 
-macro(ADD_ZSTD_COMPILATION_FLAGS _C _CXX _LD)
-    # We set ZSTD_HAS_NOEXECSTACK if we are certain we've set all the required
-    # compiler flags to mark the stack as non-executable.
-    set(ZSTD_HAS_NOEXECSTACK false)
-
+macro(ADD_ZSTD_COMPILATION_FLAGS)
     if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang" OR MINGW) #Not only UNIX but also WIN32 for MinGW
-        # It's possible to select the exact standard used for compilation.
-        # It's not necessary, but can be employed for specific purposes.
-        # Note that zstd source code is compatible with both C++98 and above
-        # and C-gnu90 (c90 + long long + variadic macros ) and above
-        # EnableCompilerFlag("-std=c++11" false true) # Set C++ compilation to c++11 standard
-        # EnableCompilerFlag("-std=c99" true false)   # Set C compilation to c99 standard
-        if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND MSVC)
-            # clang-cl normally maps -Wall to -Weverything.
-            EnableCompilerFlag("/clang:-Wall" _C _CXX false)
-        else ()
-            EnableCompilerFlag("-Wall" _C _CXX false)
-        endif ()
-        EnableCompilerFlag("-Wextra" _C _CXX false)
-        EnableCompilerFlag("-Wundef" _C _CXX false)
-        EnableCompilerFlag("-Wshadow" _C _CXX false)
-        EnableCompilerFlag("-Wcast-align" _C _CXX false)
-        EnableCompilerFlag("-Wcast-qual" _C _CXX false)
-        EnableCompilerFlag("-Wstrict-prototypes" _C false false)
+        #Set c++11 by default
+        EnableCompilerFlag("-std=c++11" false true)
+        #Set c99 by default
+        EnableCompilerFlag("-std=c99" true false)
+        EnableCompilerFlag("-Wall" true true)
+        EnableCompilerFlag("-Wextra" true true)
+        EnableCompilerFlag("-Wundef" true true)
+        EnableCompilerFlag("-Wshadow" true true)
+        EnableCompilerFlag("-Wcast-align" true true)
+        EnableCompilerFlag("-Wcast-qual" true true)
+        EnableCompilerFlag("-Wstrict-prototypes" true false)
         # Enable asserts in Debug mode
         if (CMAKE_BUILD_TYPE MATCHES "Debug")
-            EnableCompilerFlag("-DDEBUGLEVEL=1" _C _CXX false)
+            EnableCompilerFlag("-DDEBUGLEVEL=1" true true)
         endif ()
-        # Add noexecstack flags
-        # LDFLAGS
-        EnableCompilerFlag("-Wl,-z,noexecstack" false false _LD)
-        # CFLAGS & CXXFLAGS
-        EnableCompilerFlag("-Qunused-arguments" _C _CXX false)
-        EnableCompilerFlag("-Wa,--noexecstack" _C _CXX false)
-        # NOTE: Using 3 nested ifs because the variables are sometimes
-        # empty if the condition is false, and sometimes equal to false.
-        # This implicitly converts them to truthy values. There may be
-        # a better way to do this, but this reliably works.
-        if (${LD_FLAG_WL_Z_NOEXECSTACK})
-            if (${C_FLAG_WA_NOEXECSTACK})
-                if (${CXX_FLAG_WA_NOEXECSTACK})
-                    # We've succeeded in marking the stack as non-executable
-                    set(ZSTD_HAS_NOEXECSTACK true)
-                endif()
-            endif()
-        endif()
     elseif (MSVC) # Add specific compilation flags for Windows Visual
 
         set(ACTIVATE_MULTITHREADED_COMPILATION "ON" CACHE BOOL "activate multi-threaded compilation (/MP flag)")
         if (CMAKE_GENERATOR MATCHES "Visual Studio" AND ACTIVATE_MULTITHREADED_COMPILATION)
-            EnableCompilerFlag("/MP" _C _CXX false)
+            EnableCompilerFlag("/MP" true true)
         endif ()
         
         # UNICODE SUPPORT
-        EnableCompilerFlag("/D_UNICODE" _C _CXX false)
-        EnableCompilerFlag("/DUNICODE" _C _CXX false)
+        EnableCompilerFlag("/D_UNICODE" true true)
+        EnableCompilerFlag("/DUNICODE" true true)
         # Enable asserts in Debug mode
         if (CMAKE_BUILD_TYPE MATCHES "Debug")
-            EnableCompilerFlag("/DDEBUGLEVEL=1" _C _CXX false)
+            EnableCompilerFlag("/DDEBUGLEVEL=1" true true)
         endif ()
     endif ()
 
@@ -120,6 +60,7 @@ macro(ADD_ZSTD_COMPILATION_FLAGS _C _CXX _LD)
              CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
         if( ${flag_var} )
             separate_arguments(${flag_var})
+            list(REMOVE_DUPLICATES ${flag_var})
             string(REPLACE ";" " " ${flag_var} "${${flag_var}}")
         endif()
     endforeach ()

build/cmake/CMakeModules/JoinPaths.cmake

@@ -1,23 +0,0 @@
-# This module provides function for joining paths
-# known from most languages
-#
-# SPDX-License-Identifier: (MIT OR CC0-1.0)
-# Copyright 2020 Jan Tojnar
-# https://github.com/jtojnar/cmake-snips
-#
-# Modelled after Python’s os.path.join
-# https://docs.python.org/3.7/library/os.path.html#os.path.join
-# Windows not supported
-function(join_paths joined_path first_path_segment)
-    set(temp_path "${first_path_segment}")
-    foreach(current_segment IN LISTS ARGN)
-        if(NOT ("${current_segment}" STREQUAL ""))
-            if(IS_ABSOLUTE "${current_segment}")
-                set(temp_path "${current_segment}")
-            else()
-                set(temp_path "${temp_path}/${current_segment}")
-            endif()
-        endif()
-    endforeach()
-    set(${joined_path} "${temp_path}" PARENT_SCOPE)
-endfunction()

build/cmake/CMakeModules/ZstdBuild.cmake

@@ -1,42 +0,0 @@
-# ################################################################
-# ZSTD Build Targets Configuration
-# ################################################################
-
-# Always build the library first (this defines ZSTD_BUILD_STATIC/SHARED options)
-add_subdirectory(lib)
-
-# Validate build configuration after lib options are defined
-if(ZSTD_BUILD_PROGRAMS)
-    if(NOT ZSTD_BUILD_STATIC AND NOT ZSTD_PROGRAMS_LINK_SHARED)
-        message(SEND_ERROR "Static library required to build zstd CLI programs")
-    elseif(NOT ZSTD_BUILD_SHARED AND ZSTD_PROGRAMS_LINK_SHARED)
-        message(SEND_ERROR "Shared library required to build zstd CLI programs")
-    endif()
-endif()
-
-if(ZSTD_BUILD_TESTS AND NOT ZSTD_BUILD_STATIC)
-    message(SEND_ERROR "Static library required to build test suite")
-endif()
-
-# Add programs if requested
-if(ZSTD_BUILD_PROGRAMS)
-    add_subdirectory(programs)
-endif()
-
-# Add tests if requested
-if(ZSTD_BUILD_TESTS)
-    enable_testing()
-    add_subdirectory(tests)
-endif()
-
-# Add contrib utilities if requested
-if(ZSTD_BUILD_CONTRIB)
-    add_subdirectory(contrib)
-endif()
-
-# Clean-all target for thorough cleanup
-add_custom_target(clean-all
-    COMMAND ${CMAKE_BUILD_TOOL} clean
-    COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_BINARY_DIR}/
-    COMMENT "Performing complete clean including build directory"
-)

build/cmake/CMakeModules/ZstdDependencies.cmake

@@ -1,30 +0,0 @@
-# ################################################################
-# ZSTD Dependencies Configuration
-# ################################################################
-
-# Function to handle HP-UX thread configuration
-function(setup_hpux_threads)
-    find_package(Threads)
-    if(NOT Threads_FOUND)
-        set(CMAKE_USE_PTHREADS_INIT 1 PARENT_SCOPE)
-        set(CMAKE_THREAD_LIBS_INIT -lpthread PARENT_SCOPE)
-        set(CMAKE_HAVE_THREADS_LIBRARY 1 PARENT_SCOPE)
-        set(Threads_FOUND TRUE PARENT_SCOPE)
-    endif()
-endfunction()
-
-# Configure threading support
-if(ZSTD_MULTITHREAD_SUPPORT AND UNIX)
-    if(CMAKE_SYSTEM_NAME MATCHES "HP-UX")
-        setup_hpux_threads()
-    else()
-        set(THREADS_PREFER_PTHREAD_FLAG ON)
-        find_package(Threads REQUIRED)
-    endif()
-    
-    if(CMAKE_USE_PTHREADS_INIT)
-        set(THREADS_LIBS "${CMAKE_THREAD_LIBS_INIT}")
-    else()
-        message(SEND_ERROR "ZSTD currently does not support thread libraries other than pthreads")
-    endif()
-endif()

build/cmake/CMakeModules/ZstdOptions.cmake

@@ -1,68 +0,0 @@
-# ################################################################
-# ZSTD Build Options Configuration
-# ################################################################
-
-# Legacy support configuration
-option(ZSTD_LEGACY_SUPPORT "Enable legacy format support" ON)
-
-if(ZSTD_LEGACY_SUPPORT)
-    message(STATUS "ZSTD_LEGACY_SUPPORT enabled")
-    set(ZSTD_LEGACY_LEVEL 5 CACHE STRING "Legacy support level")
-    add_definitions(-DZSTD_LEGACY_SUPPORT=${ZSTD_LEGACY_LEVEL})
-else()
-    message(STATUS "ZSTD_LEGACY_SUPPORT disabled")
-    add_definitions(-DZSTD_LEGACY_SUPPORT=0)
-endif()
-
-# Platform-specific options
-if(APPLE)
-    option(ZSTD_FRAMEWORK "Build as Apple Framework" OFF)
-endif()
-
-# Android-specific configuration
-if(ANDROID)
-    set(ZSTD_MULTITHREAD_SUPPORT_DEFAULT OFF)
-    # Handle old Android API levels
-    if((NOT ANDROID_PLATFORM_LEVEL) OR (ANDROID_PLATFORM_LEVEL VERSION_LESS 24))
-        message(STATUS "Configuring for old Android API - disabling fseeko/ftello")
-        add_compile_definitions(LIBC_NO_FSEEKO)
-    endif()
-else()
-    set(ZSTD_MULTITHREAD_SUPPORT_DEFAULT ON)
-endif()
-
-# Multi-threading support
-option(ZSTD_MULTITHREAD_SUPPORT "Enable multi-threading support" ${ZSTD_MULTITHREAD_SUPPORT_DEFAULT})
-
-if(ZSTD_MULTITHREAD_SUPPORT)
-    message(STATUS "Multi-threading support enabled")
-else()
-    message(STATUS "Multi-threading support disabled")
-endif()
-
-# Build component options
-option(ZSTD_BUILD_PROGRAMS "Build command-line programs" ON)
-option(ZSTD_BUILD_CONTRIB "Build contrib utilities" OFF)
-option(ZSTD_PROGRAMS_LINK_SHARED "Link programs against shared library" OFF)
-
-# Test configuration
-if(BUILD_TESTING)
-    set(ZSTD_BUILD_TESTS_default ON)
-else()
-    set(ZSTD_BUILD_TESTS_default OFF)
-endif()
-option(ZSTD_BUILD_TESTS "Build test suite" ${ZSTD_BUILD_TESTS_default})
-
-# MSVC-specific options
-if(MSVC)
-    option(ZSTD_USE_STATIC_RUNTIME "Link to static runtime libraries" OFF)
-endif()
-
-# C++ support (needed for tests)
-set(ZSTD_ENABLE_CXX ${ZSTD_BUILD_TESTS})
-if(ZSTD_ENABLE_CXX)
-    enable_language(CXX)
-endif()
-
-# Set global definitions
-add_definitions(-DXXH_NAMESPACE=ZSTD_)

build/cmake/CMakeModules/ZstdPackage.cmake

@@ -1,42 +0,0 @@
-# ################################################################
-# ZSTD Package Configuration
-# ################################################################
-
-include(CMakePackageConfigHelpers)
-
-# Generate version file
-write_basic_package_version_file(
-    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfigVersion.cmake"
-    VERSION ${zstd_VERSION}
-    COMPATIBILITY SameMajorVersion
-)
-
-# Export targets for build directory
-export(EXPORT zstdExports
-    FILE "${CMAKE_CURRENT_BINARY_DIR}/zstdTargets.cmake"
-    NAMESPACE zstd::
-)
-
-# Configure package for installation
-set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/zstd)
-
-# Install exported targets
-install(EXPORT zstdExports
-    FILE zstdTargets.cmake
-    NAMESPACE zstd::
-    DESTINATION ${ConfigPackageLocation}
-)
-
-# Configure and install package config file
-configure_package_config_file(
-    zstdConfig.cmake.in
-    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfig.cmake"
-    INSTALL_DESTINATION ${ConfigPackageLocation}
-)
-
-# Install config files
-install(FILES
-    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfig.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/zstdConfigVersion.cmake"
-    DESTINATION ${ConfigPackageLocation}
-)

build/cmake/CMakeModules/ZstdVersion.cmake

@@ -1,31 +0,0 @@
-# ################################################################
-# ZSTD Version Configuration
-# ################################################################
-
-# Setup CMake policy version
-set(ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION "3")
-set(ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION "13")
-
-# Determine appropriate policy version
-if("${ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION}" EQUAL "${CMAKE_MAJOR_VERSION}" AND
-   "${ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION}" GREATER "${CMAKE_MINOR_VERSION}")
-    set(ZSTD_CMAKE_POLICY_VERSION "${CMAKE_VERSION}")
-else()
-    set(ZSTD_CMAKE_POLICY_VERSION "${ZSTD_MAX_VALIDATED_CMAKE_MAJOR_VERSION}.${ZSTD_MAX_VALIDATED_CMAKE_MINOR_VERSION}.0")
-endif()
-
-cmake_policy(VERSION ${ZSTD_CMAKE_POLICY_VERSION})
-
-# Parse version from header file
-include(GetZstdLibraryVersion)
-GetZstdLibraryVersion(${LIBRARY_DIR}/zstd.h zstd_VERSION_MAJOR zstd_VERSION_MINOR zstd_VERSION_PATCH)
-
-# Set version variables
-set(ZSTD_SHORT_VERSION "${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}")
-set(ZSTD_FULL_VERSION "${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}.${zstd_VERSION_PATCH}")
-
-# Project metadata
-set(zstd_HOMEPAGE_URL "https://facebook.github.io/zstd")
-set(zstd_DESCRIPTION "Zstandard is a real-time compression algorithm, providing high compression ratios.")
-
-message(STATUS "ZSTD VERSION: ${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}.${zstd_VERSION_PATCH}")

build/cmake/README.md

@@ -1,13 +1,13 @@
 # Cmake contributions
 
 Contributions to the cmake build configurations are welcome. Please
-use case sensitivity that matches modern (i.e. cmake version 2.6 and above)
+use case sensitivity that matches modern (ie. cmake version 2.6 and above)
 conventions of using lower-case for commands, and upper-case for
 variables.
 
 ## How to build
 
-As cmake doesn't support command like `cmake clean`, it's recommended to perform an "out of source build".
+As cmake doesn't support command like `cmake clean`, it's recommended to perform a "out of source build".
 To do this, you can create a new directory and build in it:
 ```sh
 cd build/cmake
@@ -37,52 +37,10 @@ cmake -LH ..
 Bool options can be set to `ON/OFF` with `-D[option]=[ON/OFF]`. You can configure cmake options like this:
 ```sh
 cd build/cmake/builddir
-cmake -DZSTD_BUILD_TESTS=ON -DZSTD_LEGACY_SUPPORT=OFF ..
+cmake -DZSTD_BUILD_TESTS=ON -DZSTD_LEGACY_SUPPORT=ON ..
 make
 ```
 
-**Apple Frameworks**
-It's generally recommended to have CMake with versions higher than 3.14 for [iOS-derived platforms](https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html#id27).
-```sh
-cmake -S. -B build-cmake -DZSTD_FRAMEWORK=ON -DCMAKE_SYSTEM_NAME=iOS
-```
-Or you can utilize [iOS-CMake](https://github.com/leetal/ios-cmake) toolchain for CMake versions lower than 3.14
-```sh
-cmake -B build -G Xcode -DCMAKE_TOOLCHAIN_FILE=<Path To ios.toolchain.cmake> -DPLATFORM=OS64 -DZSTD_FRAMEWORK=ON
-```
-
-### how to use it with CMake FetchContent
-
-For all options available, you can see it on <https://github.com/facebook/zstd/blob/dev/build/cmake/lib/CMakeLists.txt>
-```cmake
-include(FetchContent)
-
-set(ZSTD_BUILD_STATIC ON)
-set(ZSTD_BUILD_SHARED OFF)
-
-FetchContent_Declare(
-    zstd
-    URL "https://github.com/facebook/zstd/releases/download/v1.5.5/zstd-1.5.5.tar.gz"
-    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
-    SOURCE_SUBDIR build/cmake
-)
-
-FetchContent_MakeAvailable(zstd)
-
-target_link_libraries(
-    ${PROJECT_NAME}
-    PRIVATE
-    libzstd_static
-)
-
-# On windows and macos this is needed
-target_include_directories(
-    ${PROJECT_NAME}
-    PRIVATE
-    ${zstd_SOURCE_DIR}/lib
-)
-```
-
 ### referring
 [Looking for a 'cmake clean' command to clear up CMake output](https://stackoverflow.com/questions/9680420/looking-for-a-cmake-clean-command-to-clear-up-cmake-output)
 

build/cmake/contrib/CMakeLists.txt

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the

build/cmake/contrib/gen_html/CMakeLists.txt

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2015-present, Yann Collet, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the

build/cmake/contrib/pzstd/CMakeLists.txt

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2016-present, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the
@@ -18,20 +18,13 @@ set(PZSTD_DIR ${ZSTD_SOURCE_DIR}/contrib/pzstd)
 include_directories(${PROGRAMS_DIR} ${LIBRARY_DIR} ${LIBRARY_DIR}/common ${PZSTD_DIR})
 
 add_executable(pzstd ${PROGRAMS_DIR}/util.c ${PZSTD_DIR}/main.cpp ${PZSTD_DIR}/Options.cpp ${PZSTD_DIR}/Pzstd.cpp ${PZSTD_DIR}/SkippableFrame.cpp)
-target_compile_features(pzstd PRIVATE cxx_std_11)
 set_property(TARGET pzstd APPEND PROPERTY COMPILE_DEFINITIONS "NDEBUG")
 set_property(TARGET pzstd APPEND PROPERTY COMPILE_OPTIONS "-Wno-shadow")
 
-if (ZSTD_BUILD_SHARED)
-    set(ZSTD_LIB libzstd_shared)
-else()
-    set(ZSTD_LIB libzstd_static)
-endif()
-
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 if (CMAKE_USE_PTHREADS_INIT)
-  target_link_libraries(pzstd ${ZSTD_LIB} ${CMAKE_THREAD_LIBS_INIT})
+    target_link_libraries(pzstd libzstd_shared ${CMAKE_THREAD_LIBS_INIT})
 else()
     message(SEND_ERROR "ZSTD currently does not support thread libraries other than pthreads")
 endif()

build/cmake/lib/CMakeLists.txt

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2015-present, Yann Collet, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the
@@ -7,75 +7,49 @@
 # in the COPYING file in the root directory of this source tree).
 # ################################################################
 
-project(libzstd C ASM)
+project(libzstd)
 
 set(CMAKE_INCLUDE_CURRENT_DIR TRUE)
 option(ZSTD_BUILD_STATIC "BUILD STATIC LIBRARIES" ON)
 option(ZSTD_BUILD_SHARED "BUILD SHARED LIBRARIES" ON)
-option(ZSTD_BUILD_COMPRESSION "BUILD COMPRESSION MODULE" ON)
-option(ZSTD_BUILD_DECOMPRESSION "BUILD DECOMPRESSION MODULE" ON)
-option(ZSTD_BUILD_DICTBUILDER "BUILD DICTBUILDER MODULE" ON)
-option(ZSTD_BUILD_DEPRECATED "BUILD DEPRECATED MODULE" OFF)
-
-set(ZSTDLIB_VISIBLE "" CACHE STRING "Visibility for ZSTDLIB API")
-set(ZSTDERRORLIB_VISIBLE "" CACHE STRING "Visibility for ZSTDERRORLIB_VISIBLE API")
-set(ZDICTLIB_VISIBLE "" CACHE STRING "Visibility for ZDICTLIB_VISIBLE API")
-set(ZSTDLIB_STATIC_API "" CACHE STRING "Visibility for ZSTDLIB_STATIC_API API")
-set(ZDICTLIB_STATIC_API "" CACHE STRING "Visibility for ZDICTLIB_STATIC_API API")
-
-set_property(CACHE ZSTDLIB_VISIBLE PROPERTY STRINGS "" "hidden" "default" "protected" "internal")
-set_property(CACHE ZSTDERRORLIB_VISIBLE PROPERTY STRINGS "" "hidden" "default" "protected" "internal")
-set_property(CACHE ZDICTLIB_VISIBLE PROPERTY STRINGS "" "hidden" "default" "protected" "internal")
-set_property(CACHE ZSTDLIB_STATIC_API PROPERTY STRINGS "" "hidden" "default" "protected" "internal")
-set_property(CACHE ZDICTLIB_STATIC_API PROPERTY STRINGS "" "hidden" "default" "protected" "internal")
 
 if(NOT ZSTD_BUILD_SHARED AND NOT ZSTD_BUILD_STATIC)
     message(SEND_ERROR "You need to build at least one flavor of libzstd")
 endif()
 
+# Define library directory, where sources and header files are located
+include_directories(${LIBRARY_DIR} ${LIBRARY_DIR}/common)
+
 file(GLOB CommonSources ${LIBRARY_DIR}/common/*.c)
 file(GLOB CompressSources ${LIBRARY_DIR}/compress/*.c)
 file(GLOB DecompressSources ${LIBRARY_DIR}/decompress/*.c)
-if (MSVC)
-    add_compile_options(-DZSTD_DISABLE_ASM)
-else ()
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|AMD64.*|x86_64.*|X86_64.*" AND ${ZSTD_HAS_NOEXECSTACK})
-        set(DecompressSources ${DecompressSources} ${LIBRARY_DIR}/decompress/huf_decompress_amd64.S)
-    else()
-        add_compile_options(-DZSTD_DISABLE_ASM)
-    endif()
-endif ()
 file(GLOB DictBuilderSources ${LIBRARY_DIR}/dictBuilder/*.c)
 file(GLOB DeprecatedSources ${LIBRARY_DIR}/deprecated/*.c)
 
-file(GLOB PublicHeaders ${LIBRARY_DIR}/*.h)
+set(Sources
+        ${CommonSources}
+        ${CompressSources}
+        ${DecompressSources}
+        ${DictBuilderSources}
+        ${DeprecatedSources})
+
 file(GLOB CommonHeaders ${LIBRARY_DIR}/common/*.h)
 file(GLOB CompressHeaders ${LIBRARY_DIR}/compress/*.h)
 file(GLOB DecompressHeaders ${LIBRARY_DIR}/decompress/*.h)
 file(GLOB DictBuilderHeaders ${LIBRARY_DIR}/dictBuilder/*.h)
 file(GLOB DeprecatedHeaders ${LIBRARY_DIR}/deprecated/*.h)
 
-set(Sources ${CommonSources})
-set(Headers ${PublicHeaders} ${CommonHeaders})
-if (ZSTD_BUILD_COMPRESSION)
-    set(Sources ${Sources} ${CompressSources})
-    set(Headers ${Headers} ${CompressHeaders})
-endif()
-if (ZSTD_BUILD_DECOMPRESSION)
-    set(Sources ${Sources} ${DecompressSources})
-    set(Headers ${Headers} ${DecompressHeaders})
-endif()
-if (ZSTD_BUILD_DICTBUILDER)
-    set(Sources ${Sources} ${DictBuilderSources})
-    set(Headers ${Headers} ${DictBuilderHeaders})
-endif()
-if (ZSTD_BUILD_DEPRECATED)
-    set(Sources ${Sources} ${DeprecatedSources})
-    set(Headers ${Headers} ${DeprecatedHeaders})
-endif()
+set(Headers
+        ${LIBRARY_DIR}/zstd.h
+        ${CommonHeaders}
+        ${CompressHeaders}
+        ${DecompressHeaders}
+        ${DictBuilderHeaders}
+        ${DeprecatedHeaders})
 
 if (ZSTD_LEGACY_SUPPORT)
     set(LIBRARY_LEGACY_DIR ${LIBRARY_DIR}/legacy)
+    include_directories(${LIBRARY_LEGACY_DIR})
 
     set(Sources ${Sources}
             ${LIBRARY_LEGACY_DIR}/zstd_v01.c
@@ -97,91 +71,32 @@ if (ZSTD_LEGACY_SUPPORT)
             ${LIBRARY_LEGACY_DIR}/zstd_v07.h)
 endif ()
 
-if (MSVC AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
+if (MSVC)
     set(MSVC_RESOURCE_DIR ${ZSTD_SOURCE_DIR}/build/VS2010/libzstd-dll)
     set(PlatformDependResources ${MSVC_RESOURCE_DIR}/libzstd-dll.rc)
-else()
-    set(PlatformDependResources)
 endif ()
 
-# Explicitly set the language to C for all files, including ASM files.
-# Our assembly expects to be compiled by a C compiler, and is only enabled for
-# __GNUC__ compatible compilers. Otherwise all the ASM code is disabled by
-# macros.
-if(NOT CMAKE_ASM_COMPILER STREQUAL CMAKE_C_COMPILER)
-    set_source_files_properties(${Sources} PROPERTIES LANGUAGE C)
-endif()
-
-macro (add_definition target var)
-    if (NOT ("${${var}}" STREQUAL ""))
-        target_compile_definitions(${target} PUBLIC "${var}=__attribute__((visibility(\"${${var}}\")))")
-    endif ()
-endmacro ()
-
-# Define directories containing the library's public headers
-set(PUBLIC_INCLUDE_DIRS ${LIBRARY_DIR})
-set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} /I \"${LIBRARY_DIR}\"")
 # Split project to static and shared libraries build
 set(library_targets)
 if (ZSTD_BUILD_SHARED)
     add_library(libzstd_shared SHARED ${Sources} ${Headers} ${PlatformDependResources})
-    target_include_directories(libzstd_shared INTERFACE $<BUILD_INTERFACE:${PUBLIC_INCLUDE_DIRS}>)
     list(APPEND library_targets libzstd_shared)
     if (ZSTD_MULTITHREAD_SUPPORT)
-        target_compile_definitions(libzstd_shared PUBLIC ZSTD_MULTITHREAD)
+        set_property(TARGET libzstd_shared APPEND PROPERTY COMPILE_DEFINITIONS "ZSTD_MULTITHREAD")
         if (UNIX)
             target_link_libraries(libzstd_shared ${THREADS_LIBS})
         endif ()
-    endif ()
-    add_definition(libzstd_shared ZSTDLIB_VISIBLE)
-    add_definition(libzstd_shared ZSTDERRORLIB_VISIBLE)
-    add_definition(libzstd_shared ZDICTLIB_VISIBLE)
+    endif()
 endif ()
 if (ZSTD_BUILD_STATIC)
     add_library(libzstd_static STATIC ${Sources} ${Headers})
-    target_include_directories(libzstd_static INTERFACE $<BUILD_INTERFACE:${PUBLIC_INCLUDE_DIRS}>)
     list(APPEND library_targets libzstd_static)
     if (ZSTD_MULTITHREAD_SUPPORT)
-        target_compile_definitions(libzstd_static PUBLIC ZSTD_MULTITHREAD)
+        set_property(TARGET libzstd_static APPEND PROPERTY COMPILE_DEFINITIONS "ZSTD_MULTITHREAD")
         if (UNIX)
             target_link_libraries(libzstd_static ${THREADS_LIBS})
         endif ()
     endif ()
-    add_definition(libzstd_static ZSTDLIB_VISIBLE)
-    add_definition(libzstd_static ZSTDERRORLIB_VISIBLE)
-    add_definition(libzstd_static ZDICTLIB_VISIBLE)
-    add_definition(libzstd_static ZSTDLIB_STATIC_API)
-    add_definition(libzstd_static ZDICTLIB_STATIC_API)
-endif ()
-if (ZSTD_BUILD_SHARED AND NOT ZSTD_BUILD_STATIC)
-    if (NOT BUILD_SHARED_LIBS)
-        message(WARNING "BUILD_SHARED_LIBS is OFF, but ZSTD_BUILD_SHARED is ON and ZSTD_BUILD_STATIC is OFF, which takes precedence, so libzstd is a shared library")
-    endif ()
-    add_library(libzstd INTERFACE)
-    target_link_libraries(libzstd INTERFACE libzstd_shared)
-    list(APPEND library_targets libzstd)
-endif ()
-if (ZSTD_BUILD_STATIC AND NOT ZSTD_BUILD_SHARED)
-    if (BUILD_SHARED_LIBS)
-        message(WARNING "BUILD_SHARED_LIBS is ON, but ZSTD_BUILD_SHARED is OFF and ZSTD_BUILD_STATIC is ON, which takes precedence, is set so libzstd is a static library")
-    endif ()
-    add_library(libzstd INTERFACE)
-    target_link_libraries(libzstd INTERFACE libzstd_static)
-    list(APPEND library_targets libzstd)
-endif ()
-if (ZSTD_BUILD_SHARED AND ZSTD_BUILD_STATIC)
-    # If both ZSTD_BUILD_SHARED and ZSTD_BUILD_STATIC are set, which is the
-    # default, fallback to using BUILD_SHARED_LIBS to determine whether to
-    # set libzstd to static or shared.
-    if (BUILD_SHARED_LIBS)
-        add_library(libzstd INTERFACE)
-        target_link_libraries(libzstd INTERFACE libzstd_shared)
-        list(APPEND library_targets libzstd)
-    else ()
-        add_library(libzstd INTERFACE)
-        target_link_libraries(libzstd INTERFACE libzstd_static)
-        list(APPEND library_targets libzstd)
-    endif ()
 endif ()
 
 # Add specific compile definitions for MSVC project
@@ -195,7 +110,7 @@ if (MSVC)
 endif ()
 
 # With MSVC static library needs to be renamed to avoid conflict with import library
-if (MSVC OR (WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT MINGW))
+if (MSVC)
     set(STATIC_LIBRARY_BASE_NAME zstd_static)
 else ()
     set(STATIC_LIBRARY_BASE_NAME zstd)
@@ -207,28 +122,8 @@ if (ZSTD_BUILD_SHARED)
             libzstd_shared
             PROPERTIES
             OUTPUT_NAME zstd
-            VERSION ${ZSTD_FULL_VERSION}
+            VERSION ${zstd_VERSION_MAJOR}.${zstd_VERSION_MINOR}.${zstd_VERSION_PATCH}
             SOVERSION ${zstd_VERSION_MAJOR})
-
-    if (ZSTD_FRAMEWORK)
-        set_target_properties(
-                libzstd_shared
-                PROPERTIES
-                FRAMEWORK TRUE
-                FRAMEWORK_VERSION "${ZSTD_FULL_VERSION}"
-                PRODUCT_BUNDLE_IDENTIFIER "github.com/facebook/zstd"
-                XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
-                PUBLIC_HEADER "${PublicHeaders}"
-                OUTPUT_NAME "zstd"
-                XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY ""
-                XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "NO"
-                XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO"
-                MACOSX_FRAMEWORK_IDENTIFIER "github.com/facebook/zstd"
-                MACOSX_FRAMEWORK_BUNDLE_VERSION "${ZSTD_FULL_VERSION}"
-                MACOSX_FRAMEWORK_SHORT_VERSION_STRING "${ZSTD_SHORT_VERSION}"
-                MACOSX_RPATH TRUE
-                RESOURCE ${PublicHeaders})
-    endif ()
 endif ()
 
 if (ZSTD_BUILD_STATIC)
@@ -237,52 +132,37 @@ if (ZSTD_BUILD_STATIC)
             PROPERTIES
             POSITION_INDEPENDENT_CODE On
             OUTPUT_NAME ${STATIC_LIBRARY_BASE_NAME})
-
-    if (ZSTD_FRAMEWORK)
-        set_target_properties(
-                libzstd_static
-                PROPERTIES
-                FRAMEWORK TRUE
-                FRAMEWORK_VERSION "${ZSTD_FULL_VERSION}"
-                PRODUCT_BUNDLE_IDENTIFIER "github.com/facebook/zstd/${STATIC_LIBRARY_BASE_NAME}"
-                XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
-                PUBLIC_HEADER "${PublicHeaders}"
-                OUTPUT_NAME "${STATIC_LIBRARY_BASE_NAME}"
-                XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY ""
-                XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "NO"
-                XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO"
-                MACOSX_FRAMEWORK_IDENTIFIER "github.com/facebook/zstd/${STATIC_LIBRARY_BASE_NAME}"
-                MACOSX_FRAMEWORK_BUNDLE_VERSION "${ZSTD_FULL_VERSION}"
-                MACOSX_FRAMEWORK_SHORT_VERSION_STRING "${ZSTD_SHORT_VERSION}"
-                MACOSX_RPATH TRUE
-                RESOURCE ${PublicHeaders})
-    endif ()
 endif ()
 
-# pkg-config
-include(JoinPaths) # can be replaced by cmake_path(APPEND) in CMake 3.20
-set(PREFIX "${CMAKE_INSTALL_PREFIX}")
-set(EXEC_PREFIX "\${prefix}")
-join_paths(LIBDIR "\${exec_prefix}" "${CMAKE_INSTALL_LIBDIR}")
-join_paths(INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
-set(LIBS_PRIVATE "${THREADS_LIBS}")
-set(VERSION "${zstd_VERSION}")
+if (UNIX)
+    # pkg-config
+    set(PREFIX "${CMAKE_INSTALL_PREFIX}")
+    set(LIBDIR "${CMAKE_INSTALL_LIBDIR}")
+    set(INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
+    set(VERSION "${zstd_VERSION}")
+    add_custom_target(libzstd.pc ALL
+            ${CMAKE_COMMAND} -DIN="${LIBRARY_DIR}/libzstd.pc.in" -DOUT="libzstd.pc"
+            -DPREFIX="${PREFIX}" -DLIBDIR="${LIBDIR}" -DINCLUDEDIR="${INCLUDEDIR}" -DVERSION="${VERSION}"
+            -P "${CMAKE_CURRENT_SOURCE_DIR}/pkgconfig.cmake"
+            COMMENT "Creating pkg-config file")
 
-configure_file("${LIBRARY_DIR}/libzstd.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/libzstd.pc" @ONLY)
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libzstd.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/libzstd.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+endif ()
 
 # install target
-install(FILES ${PublicHeaders} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+install(FILES
+    "${LIBRARY_DIR}/zstd.h"
+    "${LIBRARY_DIR}/deprecated/zbuff.h"
+    "${LIBRARY_DIR}/dictBuilder/zdict.h"
+    "${LIBRARY_DIR}/dictBuilder/cover.h"
+    "${LIBRARY_DIR}/common/zstd_errors.h"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
 
 install(TARGETS ${library_targets}
     EXPORT zstdExports
     INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
     ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
     LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-    BUNDLE DESTINATION "${CMAKE_INSTALL_BINDIR}"
-    FRAMEWORK DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT runtime OPTIONAL
-    PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
     )
 
 # uninstall target

build/cmake/lib/pkgconfig.cmake

@@ -0,0 +1 @@
+configure_file("${IN}" "${OUT}" @ONLY)

build/cmake/programs/CMakeLists.txt

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2015-present, Yann Collet, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the
@@ -7,7 +7,7 @@
 # in the COPYING file in the root directory of this source tree).
 # ################################################################
 
-project(programs C)
+project(programs)
 
 set(CMAKE_INCLUDE_CURRENT_DIR TRUE)
 
@@ -32,19 +32,12 @@ if (MSVC)
     set(PlatformDependResources ${MSVC_RESOURCE_DIR}/zstd.rc)
 endif ()
 
-file(GLOB ZSTD_PROGRAM_SRCS "${PROGRAMS_DIR}/*.c")
-if (MSVC AND ZSTD_PROGRAMS_LINK_SHARED)
-    list(APPEND ZSTD_PROGRAM_SRCS ${LIBRARY_DIR}/common/pool.c ${LIBRARY_DIR}/common/threading.c)
-endif ()
-
-add_executable(zstd ${ZSTD_PROGRAM_SRCS})
+add_executable(zstd ${PROGRAMS_DIR}/zstdcli.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${PROGRAMS_DIR}/fileio.c ${PROGRAMS_DIR}/benchfn.c ${PROGRAMS_DIR}/benchzstd.c ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/dibio.c ${PlatformDependResources})
 target_link_libraries(zstd ${PROGRAMS_ZSTD_LINK_TARGET})
 if (CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
     target_link_libraries(zstd rt)
 endif ()
-install(TARGETS zstd
-  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-  BUNDLE DESTINATION "${CMAKE_INSTALL_BINDIR}")
+install(TARGETS zstd RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
 
 if (UNIX)
     add_custom_target(zstdcat ALL ${CMAKE_COMMAND} -E create_symlink zstd zstdcat DEPENDS zstd COMMENT "Creating zstdcat symlink")
@@ -80,11 +73,9 @@ if (UNIX)
         ${CMAKE_CURRENT_BINARY_DIR}/zstdless.1
         DESTINATION "${MAN_INSTALL_DIR}")
 
-    add_executable(zstd-frugal ${PROGRAMS_DIR}/zstdcli.c
-        ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c
-        ${PROGRAMS_DIR}/fileio.c ${PROGRAMS_DIR}/fileio_asyncio.c)
+    add_executable(zstd-frugal ${PROGRAMS_DIR}/zstdcli.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${PROGRAMS_DIR}/fileio.c)
     target_link_libraries(zstd-frugal ${PROGRAMS_ZSTD_LINK_TARGET})
-    set_property(TARGET zstd-frugal APPEND PROPERTY COMPILE_DEFINITIONS "ZSTD_NOBENCH;ZSTD_NODICT;ZSTD_NOTRACE")
+    set_property(TARGET zstd-frugal APPEND PROPERTY COMPILE_DEFINITIONS "ZSTD_NOBENCH;ZSTD_NODICT")
 endif ()
 
 # Add multi-threading support definitions

build/cmake/tests/.gitignore

@@ -3,4 +3,5 @@ datagen
 fullbench
 fuzzer
 paramgrill
+zbufftest
 

build/cmake/tests/CMakeLists.txt

@@ -1,6 +1,6 @@
 # ################################################################
 # zstd - Makefile
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (C) Yann Collet 2014-present
 # All rights reserved.
 #
 # BSD license
@@ -27,7 +27,7 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 # You can contact the author at :
-#  - zstd homepage : https://facebook.github.io/zstd/
+#  - zstd homepage : http://www.zstd.net/
 # ################################################################
 
 project(tests)
@@ -50,30 +50,24 @@ set(PROGRAMS_DIR ${ZSTD_SOURCE_DIR}/programs)
 set(TESTS_DIR ${ZSTD_SOURCE_DIR}/tests)
 include_directories(${TESTS_DIR} ${PROGRAMS_DIR} ${LIBRARY_DIR} ${LIBRARY_DIR}/common ${LIBRARY_DIR}/compress ${LIBRARY_DIR}/dictBuilder)
 
-add_executable(datagen ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/lorem.c ${TESTS_DIR}/loremOut.c ${TESTS_DIR}/datagencli.c)
+add_executable(datagen ${PROGRAMS_DIR}/datagen.c ${TESTS_DIR}/datagencli.c)
 target_link_libraries(datagen libzstd_static)
 
 #
 # fullbench
 #
-add_executable(fullbench ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/lorem.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${PROGRAMS_DIR}/benchfn.c ${PROGRAMS_DIR}/benchzstd.c ${TESTS_DIR}/fullbench.c)
-if (NOT MSVC)
-    target_compile_options(fullbench PRIVATE "-Wno-deprecated-declarations")
-endif()
+add_executable(fullbench ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${PROGRAMS_DIR}/benchfn.c ${PROGRAMS_DIR}/benchzstd.c ${TESTS_DIR}/fullbench.c)
 target_link_libraries(fullbench libzstd_static)
-add_test(NAME fullbench COMMAND "$<TARGET_FILE:fullbench>" ${ZSTD_FULLBENCH_FLAGS})
+add_test(NAME fullbench COMMAND fullbench)
 
 #
 # fuzzer
 #
 add_executable(fuzzer ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${TESTS_DIR}/fuzzer.c)
-if (NOT MSVC)
-    target_compile_options(fuzzer PRIVATE "-Wno-deprecated-declarations")
-endif()
 target_link_libraries(fuzzer libzstd_static)
 AddTestFlagsOption(ZSTD_FUZZER_FLAGS "$ENV{FUZZERTEST} $ENV{FUZZER_FLAGS}"
     "Semicolon-separated list of flags to pass to the fuzzer test (see `fuzzer -h` for usage)")
-add_test(NAME fuzzer COMMAND "$<TARGET_FILE:fuzzer>" ${ZSTD_FUZZER_FLAGS})
+add_test(NAME fuzzer COMMAND fuzzer ${ZSTD_FUZZER_FLAGS})
 # Disable the timeout since the run time is too long for the default timeout of
 # 1500 seconds and varies considerably between low-end and high-end CPUs.
 # set_tests_properties(fuzzer PROPERTIES TIMEOUT 0)
@@ -81,38 +75,32 @@ add_test(NAME fuzzer COMMAND "$<TARGET_FILE:fuzzer>" ${ZSTD_FUZZER_FLAGS})
 #
 # zstreamtest
 #
-add_executable(zstreamtest ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${TESTS_DIR}/seqgen.c ${TESTS_DIR}/zstreamtest.c ${TESTS_DIR}/external_matchfinder.c)
-if (NOT MSVC)
-    target_compile_options(zstreamtest PRIVATE "-Wno-deprecated-declarations")
-endif()
+add_executable(zstreamtest ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${TESTS_DIR}/seqgen.c ${TESTS_DIR}/zstreamtest.c)
 target_link_libraries(zstreamtest libzstd_static)
 AddTestFlagsOption(ZSTD_ZSTREAM_FLAGS "$ENV{ZSTREAM_TESTTIME} $ENV{FUZZER_FLAGS}"
     "Semicolon-separated list of flags to pass to the zstreamtest test (see `zstreamtest -h` for usage)")
-add_test(NAME zstreamtest COMMAND "$<TARGET_FILE:zstreamtest>" ${ZSTD_ZSTREAM_FLAGS})
+add_test(NAME zstreamtest COMMAND zstreamtest ${ZSTD_ZSTREAM_FLAGS})
 
 #
 # playTests.sh
 #
-AddTestFlagsOption(ZSTD_PLAYTESTS_FLAGS "$ENV{PLAYTESTS_FLAGS}"
+AddTestFlagsOption(ZSTD_PLAYTESTS_FLAGS "--test-large-data"
     "Semicolon-separated list of flags to pass to the playTests.sh test")
-add_test(NAME playTests COMMAND sh -c "\"${TESTS_DIR}/playTests.sh\" ${ZSTD_PLAYTESTS_FLAGS}")
-find_program(UNAME uname) # Run script only in unix shell environments
-if (ZSTD_BUILD_PROGRAMS AND UNAME)
+add_test(NAME playTests COMMAND sh -c "${TESTS_DIR}/playTests.sh" ${ZSTD_PLAYTESTS_FLAGS})
+if (ZSTD_BUILD_PROGRAMS)
     set_property(TEST playTests APPEND PROPERTY ENVIRONMENT
         "ZSTD_BIN=$<TARGET_FILE:zstd>"
         "DATAGEN_BIN=$<TARGET_FILE:datagen>"
         )
 else()
-    message(STATUS "Disabling playTests.sh test because requirements not met")
+    message(STATUS "Disabling playTests.sh test because ZSTD_BUILD_PROGRAMS is not enabled")
     set_tests_properties(playTests PROPERTIES DISABLED YES)
 endif()
 
 # Label the "Medium" set of tests (see TESTING.md)
 set_property(TEST fuzzer zstreamtest playTests APPEND PROPERTY LABELS Medium)
 
-add_executable(paramgrill ${PROGRAMS_DIR}/benchfn.c ${PROGRAMS_DIR}/benchzstd.c ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/lorem.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${TESTS_DIR}/paramgrill.c)
 if (UNIX)
+    add_executable(paramgrill ${PROGRAMS_DIR}/benchfn.c ${PROGRAMS_DIR}/benchzstd.c ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${TESTS_DIR}/paramgrill.c)
     target_link_libraries(paramgrill libzstd_static m) #m is math library
-else()
-    target_link_libraries(paramgrill libzstd_static)
 endif ()

build/cmake/zstdConfig.cmake

@@ -0,0 +1 @@
+include("${CMAKE_CURRENT_LIST_DIR}/zstdTargets.cmake")

build/cmake/zstdConfig.cmake.in

@@ -1,10 +0,0 @@
-@PACKAGE_INIT@
-
-include(CMakeFindDependencyMacro)
-if(@ZSTD_MULTITHREAD_SUPPORT@ AND "@UNIX@")
-  find_dependency(Threads)
-endif()
-
-include("${CMAKE_CURRENT_LIST_DIR}/zstdTargets.cmake")
-
-check_required_components("zstd")

build/meson/contrib/pzstd/meson.build

@@ -18,8 +18,7 @@ pzstd_sources = [join_paths(zstd_rootdir, 'programs/util.c'),
   join_paths(zstd_rootdir, 'contrib/pzstd/SkippableFrame.cpp')]
 pzstd = executable('pzstd',
   pzstd_sources,
-  cpp_args: pzstd_warning_flags,
+  cpp_args: [ '-DNDEBUG', '-Wno-shadow', '-pedantic' ],
   include_directories: pzstd_includes,
-  dependencies: [ libzstd_internal_dep, thread_dep ],
-  override_options: ['b_ndebug=true'],
+  dependencies: [ libzstd_dep, thread_dep ],
   install: true)

build/meson/lib/meson.build

@@ -14,7 +14,8 @@ libzstd_includes = [include_directories(join_paths(zstd_rootdir,'lib'),
   join_paths(zstd_rootdir, 'lib/common'),
   join_paths(zstd_rootdir, 'lib/compress'),
   join_paths(zstd_rootdir, 'lib/decompress'),
-  join_paths(zstd_rootdir, 'lib/dictBuilder'))]
+  join_paths(zstd_rootdir, 'lib/dictBuilder'),
+  join_paths(zstd_rootdir, 'lib/deprecated'))]
 
 libzstd_sources = [join_paths(zstd_rootdir, 'lib/common/entropy_common.c'),
   join_paths(zstd_rootdir, 'lib/common/fse_decompress.c'),
@@ -30,7 +31,6 @@ libzstd_sources = [join_paths(zstd_rootdir, 'lib/common/entropy_common.c'),
   join_paths(zstd_rootdir, 'lib/compress/zstd_compress_literals.c'),
   join_paths(zstd_rootdir, 'lib/compress/zstd_compress_sequences.c'),
   join_paths(zstd_rootdir, 'lib/compress/zstd_compress_superblock.c'),
-  join_paths(zstd_rootdir, 'lib/compress/zstd_preSplit.c'),
   join_paths(zstd_rootdir, 'lib/compress/zstdmt_compress.c'),
   join_paths(zstd_rootdir, 'lib/compress/zstd_fast.c'),
   join_paths(zstd_rootdir, 'lib/compress/zstd_double_fast.c'),
@@ -44,16 +44,10 @@ libzstd_sources = [join_paths(zstd_rootdir, 'lib/common/entropy_common.c'),
   join_paths(zstd_rootdir, 'lib/dictBuilder/cover.c'),
   join_paths(zstd_rootdir, 'lib/dictBuilder/fastcover.c'),
   join_paths(zstd_rootdir, 'lib/dictBuilder/divsufsort.c'),
-  join_paths(zstd_rootdir, 'lib/dictBuilder/zdict.c')]
-
-# really we need anything that defines __GNUC__ as that is what ZSTD_ASM_SUPPORTED is gated on
-# but these are the two compilers that are supported in tree and actually handle this correctly
-# Otherwise, explicitly disable assembly.
-if [compiler_gcc, compiler_clang].contains(cc_id)
-  libzstd_sources += join_paths(zstd_rootdir, 'lib/decompress/huf_decompress_amd64.S')
-else
-  add_project_arguments('-DZSTD_DISABLE_ASM', language: 'c')
-endif
+  join_paths(zstd_rootdir, 'lib/dictBuilder/zdict.c'),
+  join_paths(zstd_rootdir, 'lib/deprecated/zbuff_common.c'),
+  join_paths(zstd_rootdir, 'lib/deprecated/zbuff_compress.c'),
+  join_paths(zstd_rootdir, 'lib/deprecated/zbuff_decompress.c')]
 
 # Explicit define legacy support
 add_project_arguments('-DZSTD_LEGACY_SUPPORT=@0@'.format(legacy_level),
@@ -84,8 +78,7 @@ libzstd_c_args = []
 if cc_id == compiler_msvc
   if default_library_type != 'static'
     libzstd_sources += [windows_mod.compile_resources(
-      join_paths(zstd_rootdir, 'build/VS2010/libzstd-dll/libzstd-dll.rc'),
-      include_directories: libzstd_includes)]
+      join_paths(zstd_rootdir, 'build/VS2010/libzstd-dll/libzstd-dll.rc'))]
     libzstd_c_args += ['-DZSTD_DLL_EXPORT=1',
       '-DZSTD_HEAPMODE=0',
       '-D_CONSOLE',
@@ -119,53 +112,21 @@ libzstd = library('zstd',
   libzstd_sources,
   include_directories: libzstd_includes,
   c_args: libzstd_c_args,
-  gnu_symbol_visibility: 'hidden',
   dependencies: libzstd_deps,
   install: true,
   version: zstd_libversion)
 
 libzstd_dep = declare_dependency(link_with: libzstd,
-  include_directories: join_paths(zstd_rootdir,'lib')) # Do not expose private headers
-
-# we link to both:
-# - the shared library (for public symbols)
-# - the static library (for private symbols)
-#
-# this is needed because internally private symbols are used all the time, and
-# -fvisibility=hidden means those cannot be found
-if get_option('default_library') == 'static'
-  libzstd_static = libzstd
-  libzstd_internal_dep = declare_dependency(link_with: libzstd,
   include_directories: libzstd_includes)
-else
-  if get_option('default_library') == 'shared'
-    libzstd_static = static_library('zstd_objlib',
-      objects: libzstd.extract_all_objects(recursive: true),
-      build_by_default: false)
-  else
-    libzstd_static = libzstd.get_static_lib()
-  endif
-
-  if cc_id == compiler_msvc
-    # msvc does not actually support linking to both, but errors out with:
-    #   error LNK2005: ZSTD_<foo> already defined in zstd.lib(zstd-1.dll)
-    libzstd_internal_dep = declare_dependency(link_with: libzstd_static,
-      include_directories: libzstd_includes)
-  else
-    libzstd_internal_dep = declare_dependency(link_with: libzstd,
-      # the static library must be linked after the shared one
-      dependencies: declare_dependency(link_with: libzstd_static),
-      include_directories: libzstd_includes)
-  endif
-endif
 
 pkgconfig.generate(libzstd,
   name: 'libzstd',
   filebase: 'libzstd',
   description: 'fast lossless compression algorithm library',
   version: zstd_libversion,
-  url: 'https://facebook.github.io/zstd/')
+  url: 'http://www.zstd.net/')
 
 install_headers(join_paths(zstd_rootdir, 'lib/zstd.h'),
-  join_paths(zstd_rootdir, 'lib/zdict.h'),
-  join_paths(zstd_rootdir, 'lib/zstd_errors.h'))
+  join_paths(zstd_rootdir, 'lib/deprecated/zbuff.h'),
+  join_paths(zstd_rootdir, 'lib/dictBuilder/zdict.h'),
+  join_paths(zstd_rootdir, 'lib/common/zstd_errors.h'))

build/meson/meson.build

@@ -10,27 +10,19 @@
 
 project('zstd',
   ['c', 'cpp'],
-  license: 'BSD-3-Clause OR GPL-2.0-only',
+  license: ['BSD', 'GPLv2'],
   default_options : [
-    # There shouldn't be any need to force a C standard convention for zstd
-    # but in case one would want that anyway, this can be done here.
-    # 'c_std=gnu99',
-    # c++11 standard is useful for pzstd
+    'c_std=gnu99',
     'cpp_std=c++11',
-    'buildtype=release',
-    'warning_level=3',
-    # -Wdocumentation does not actually pass, nor do the test binaries,
-    # so this isn't safe
-    #'werror=true'
+    'buildtype=release'
   ],
-  version: run_command(
-    find_program('GetZstdLibraryVersion.py'), '../../lib/zstd.h',
-    check: true).stdout().strip(),
-  meson_version: '>=0.50.0')
+  version: 'DUMMY',
+  meson_version: '>=0.47.0')
 
 cc = meson.get_compiler('c')
 cxx = meson.get_compiler('cpp')
 pkgconfig = import('pkgconfig')
+python3 = import('python').find_installation()
 windows_mod = import('windows')
 
 host_machine_os = host_machine.system()
@@ -47,6 +39,16 @@ compiler_msvc = 'msvc'
 
 zstd_version = meson.project_version()
 
+zstd_h_file = join_paths(meson.current_source_dir(), '../../lib/zstd.h')
+GetZstdLibraryVersion_py = files('GetZstdLibraryVersion.py')
+r = run_command(python3, GetZstdLibraryVersion_py, zstd_h_file)
+if r.returncode() == 0
+  zstd_version = r.stdout().strip()
+  message('Project version is now: @0@'.format(zstd_version))
+else
+  error('Cannot find project version in @0@'.format(zstd_h_file))
+endif
+
 zstd_libversion = zstd_version
 
 # =============================================================================
@@ -65,6 +67,7 @@ zstd_docdir = join_paths(zstd_datadir, 'doc', meson.project_name())
 
 # Built-in options
 use_debug = get_option('debug')
+buildtype = get_option('buildtype')
 default_library_type = get_option('default_library')
 
 # Custom options
@@ -86,14 +89,9 @@ feature_lz4 = get_option('lz4')
 # Dependencies
 # =============================================================================
 
-libm_dep = cc.find_library('m', required: false)
-if host_machine_os == os_windows
-  thread_dep = dependency('', required: false)
-  use_multi_thread = not feature_multi_thread.disabled()
-else
-  thread_dep = dependency('threads', required: feature_multi_thread)
-  use_multi_thread = thread_dep.found()
-endif
+libm_dep = cc.find_library('m', required: bin_tests)
+thread_dep = dependency('threads', required: feature_multi_thread)
+use_multi_thread = thread_dep.found()
 # Arguments in dependency should be equivalent to those passed to pkg-config
 zlib_dep = dependency('zlib', required: feature_zlib)
 use_zlib = zlib_dep.found()
@@ -108,23 +106,17 @@ use_lz4 = lz4_dep.found()
 
 add_project_arguments('-DXXH_NAMESPACE=ZSTD_', language: ['c'])
 
-pzstd_warning_flags = []
 if [compiler_gcc, compiler_clang].contains(cc_id)
-  common_warning_flags = [ '-Wundef', '-Wshadow', '-Wcast-align', '-Wcast-qual' ]
-  pzstd_warning_flags = ['-Wno-shadow', '-Wno-deprecated-declarations']
+  common_warning_flags = [ '-Wextra', '-Wundef', '-Wshadow', '-Wcast-align', '-Wcast-qual' ]
   if cc_id == compiler_clang
+    # Should use Meson's own --werror build option
+    #common_warning_flags += '-Werror'
     common_warning_flags += ['-Wconversion', '-Wno-sign-conversion', '-Wdocumentation']
   endif
-  noexecstack_flags = ['-Wa,--noexecstack' ]
-  noexecstack_link_flags = ['-Wl,-z,noexecstack']
-  cc_compile_flags = cc.get_supported_arguments(common_warning_flags + noexecstack_flags + ['-Wstrict-prototypes'])
-  cxx_compile_flags = cxx.get_supported_arguments(common_warning_flags + noexecstack_flags)
+  cc_compile_flags = cc.get_supported_arguments(common_warning_flags + ['-Wstrict-prototypes'])
+  cxx_compile_flags = cxx.get_supported_arguments(common_warning_flags)
   add_project_arguments(cc_compile_flags, language : 'c')
   add_project_arguments(cxx_compile_flags, language : 'cpp')
-  cc_link_flags = cc.get_supported_link_arguments(noexecstack_link_flags)
-  cxx_link_flags = cxx.get_supported_link_arguments(noexecstack_link_flags)
-  add_project_link_arguments(cc_link_flags, language: 'c')
-  add_project_link_arguments(cxx_link_flags, language: 'cpp')
 elif cc_id == compiler_msvc
   msvc_compile_flags = [ '/D_UNICODE', '/DUNICODE' ]
   if use_multi_thread
@@ -142,7 +134,7 @@ endif
 
 subdir('lib')
 
-if bin_programs or bin_tests
+if bin_programs
   subdir('programs')
 endif
 

build/meson/meson_options.txt

@@ -10,11 +10,11 @@
 
 # Read guidelines from https://wiki.gnome.org/Initiatives/GnomeGoals/MesonPorting
 
-option('legacy_level', type: 'integer', min: 0, max: 7, value: 5,
+option('legacy_level', type: 'integer', min: 0, max: 7, value: '5',
   description: 'Support any legacy format: 7 to 1 for v0.7+ to v0.1+')
 option('debug_level', type: 'integer', min: 0, max: 9, value: 1,
   description: 'Enable run-time debug. See lib/common/debug.h')
-option('backtrace', type: 'feature', value: 'disabled',
+option('backtrace', type: 'boolean', value: false,
   description: 'Display a stack backtrace when execution generates a runtime exception')
 option('static_runtime', type: 'boolean', value: false,
   description: 'Link to static run-time libraries on MSVC')
@@ -27,7 +27,7 @@ option('bin_contrib', type: 'boolean', value: false,
   description: 'Enable contrib build')
 
 option('multi_thread', type: 'feature', value: 'enabled',
-  description: 'Enable multi-threading when pthread or Windows is detected')
+  description: 'Enable multi-threading when pthread is detected')
 option('zlib', type: 'feature', value: 'auto',
   description: 'Enable zlib support')
 option('lzma', type: 'feature', value: 'auto',

build/meson/programs/meson.build

@@ -14,27 +14,17 @@ zstd_programs_sources = [join_paths(zstd_rootdir, 'programs/zstdcli.c'),
   join_paths(zstd_rootdir, 'programs/util.c'),
   join_paths(zstd_rootdir, 'programs/timefn.c'),
   join_paths(zstd_rootdir, 'programs/fileio.c'),
-  join_paths(zstd_rootdir, 'programs/fileio_asyncio.c'),
   join_paths(zstd_rootdir, 'programs/benchfn.c'),
   join_paths(zstd_rootdir, 'programs/benchzstd.c'),
   join_paths(zstd_rootdir, 'programs/datagen.c'),
-  join_paths(zstd_rootdir, 'programs/lorem.c'),
-  join_paths(zstd_rootdir, 'programs/dibio.c'),
-  join_paths(zstd_rootdir, 'programs/zstdcli_trace.c')]
+  join_paths(zstd_rootdir, 'programs/dibio.c')]
 
-zstd_deps = [ libzstd_internal_dep ]
 zstd_c_args = libzstd_debug_cflags
-
-zstd_frugal_deps = [ libzstd_internal_dep ]
-zstd_frugal_c_args = [ '-DZSTD_NOBENCH', '-DZSTD_NODICT', '-DZSTD_NOTRACE' ]
-
 if use_multi_thread
-  zstd_deps += [ thread_dep ]
   zstd_c_args += [ '-DZSTD_MULTITHREAD' ]
-  zstd_frugal_deps += [ thread_dep ]
-  zstd_frugal_c_args += [ '-DZSTD_MULTITHREAD' ]
 endif
 
+zstd_deps = [ libzstd_dep ]
 if use_zlib
   zstd_deps += [ zlib_dep ]
   zstd_c_args += [ '-DZSTD_GZCOMPRESS', '-DZSTD_GZDECOMPRESS' ]
@@ -52,8 +42,7 @@ endif
 
 export_dynamic_on_windows = false
 # explicit backtrace enable/disable for Linux & Darwin
-have_execinfo = cc.has_header('execinfo.h', required: use_backtrace)
-if not have_execinfo
+if not use_backtrace
   zstd_c_args += '-DBACKTRACE_ENABLE=0'
 elif use_debug and host_machine_os == os_windows  # MinGW target
   zstd_c_args += '-DBACKTRACE_ENABLE=1'
@@ -63,8 +52,7 @@ endif
 if cc_id == compiler_msvc
   if default_library_type != 'static'
     zstd_programs_sources += [windows_mod.compile_resources(
-      join_paths(zstd_rootdir, 'build/VS2010/zstd/zstd.rc'),
-      include_directories: libzstd_includes)]
+      join_paths(zstd_rootdir, 'build/VS2010/zstd/zstd.rc'))]
   endif
 endif
 
@@ -73,27 +61,19 @@ zstd = executable('zstd',
   c_args: zstd_c_args,
   dependencies: zstd_deps,
   export_dynamic: export_dynamic_on_windows, # Since Meson 0.45.0
-  build_by_default: bin_programs,
-  install: bin_programs)
-
-if not bin_programs
-  # we generate rules to build the programs, but don't install anything
-  # so do not continue to installing scripts and manpages
-  subdir_done()
-endif
+  install: true)
 
 zstd_frugal_sources = [join_paths(zstd_rootdir, 'programs/zstdcli.c'),
   join_paths(zstd_rootdir, 'programs/timefn.c'),
   join_paths(zstd_rootdir, 'programs/util.c'),
-  join_paths(zstd_rootdir, 'programs/fileio.c'),
-  join_paths(zstd_rootdir, 'programs/fileio_asyncio.c')]
+  join_paths(zstd_rootdir, 'programs/fileio.c')]
 
 # Minimal target, with only zstd compression and decompression.
 # No bench. No legacy.
 executable('zstd-frugal',
   zstd_frugal_sources,
-  dependencies: zstd_frugal_deps,
-  c_args: zstd_frugal_c_args,
+  dependencies: libzstd_dep,
+  c_args: [ '-DZSTD_NOBENCH', '-DZSTD_NODICT' ],
   install: true)
 
 install_data(join_paths(zstd_rootdir, 'programs/zstdgrep'),

build/meson/tests/meson.build

@@ -21,6 +21,7 @@ FUZZER_FLAGS = ['--no-big-tests']
 FUZZERTEST = '-T200s'
 ZSTREAM_TESTTIME = '-T90s'
 DECODECORPUS_TESTTIME = '-T30'
+ZSTDRTTEST = ['--test-large-data']
 
 # =============================================================================
 # Executables
@@ -28,72 +29,70 @@ DECODECORPUS_TESTTIME = '-T30'
 
 test_includes = [ include_directories(join_paths(zstd_rootdir, 'programs')) ]
 
-testcommon_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'),
-  join_paths(zstd_rootdir, 'programs/lorem.c'),
-  join_paths(zstd_rootdir, 'programs/util.c'),
-  join_paths(zstd_rootdir, 'programs/timefn.c'),
-  join_paths(zstd_rootdir, 'programs/benchfn.c'),
-  join_paths(zstd_rootdir, 'programs/benchzstd.c')]
-
-testcommon = static_library('testcommon',
-  testcommon_sources,
-  # needed due to use of private symbol + -fvisibility=hidden
-  link_with: libzstd_static)
-
-testcommon_dep = declare_dependency(link_with: testcommon,
-  dependencies: libzstd_deps,
-  include_directories: libzstd_includes)
-
-datagen_sources = [join_paths(zstd_rootdir, 'tests/datagencli.c'),
-  join_paths(zstd_rootdir, 'tests/loremOut.c')]
+datagen_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'),
+  join_paths(zstd_rootdir, 'tests/datagencli.c')]
 datagen = executable('datagen',
   datagen_sources,
   c_args: [ '-DNDEBUG' ],
   include_directories: test_includes,
-  dependencies: testcommon_dep,
+  dependencies: libzstd_dep,
   install: false)
 
-fullbench_sources = [join_paths(zstd_rootdir, 'tests/fullbench.c')]
+fullbench_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'),
+  join_paths(zstd_rootdir, 'programs/util.c'),
+  join_paths(zstd_rootdir, 'programs/timefn.c'),
+  join_paths(zstd_rootdir, 'programs/benchfn.c'),
+  join_paths(zstd_rootdir, 'programs/benchzstd.c'),
+  join_paths(zstd_rootdir, 'tests/fullbench.c')]
 fullbench = executable('fullbench',
   fullbench_sources,
   include_directories: test_includes,
-  dependencies: testcommon_dep,
+  dependencies: libzstd_dep,
   install: false)
 
-fuzzer_sources = [join_paths(zstd_rootdir, 'tests/fuzzer.c')]
+fuzzer_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'),
+  join_paths(zstd_rootdir, 'programs/util.c'),
+  join_paths(zstd_rootdir, 'programs/timefn.c'),
+  join_paths(zstd_rootdir, 'tests/fuzzer.c')]
 fuzzer = executable('fuzzer',
   fuzzer_sources,
   include_directories: test_includes,
-  dependencies: [ testcommon_dep, thread_dep ],
+  dependencies: libzstd_dep,
   install: false)
 
-zstreamtest_sources = [
+zstreamtest_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'),
+  join_paths(zstd_rootdir, 'programs/util.c'),
+  join_paths(zstd_rootdir, 'programs/timefn.c'),
   join_paths(zstd_rootdir, 'tests/seqgen.c'),
-  join_paths(zstd_rootdir, 'tests/zstreamtest.c'),
-  join_paths(zstd_rootdir, 'tests/external_matchfinder.c')]
+  join_paths(zstd_rootdir, 'tests/zstreamtest.c')]
 zstreamtest = executable('zstreamtest',
   zstreamtest_sources,
   include_directories: test_includes,
-  dependencies: testcommon_dep,
+  dependencies: libzstd_dep,
   install: false)
 
-paramgrill_sources = [join_paths(zstd_rootdir, 'tests/paramgrill.c')]
+paramgrill_sources = [join_paths(zstd_rootdir, 'programs/benchfn.c'),
+  join_paths(zstd_rootdir, 'programs/timefn.c'),
+  join_paths(zstd_rootdir, 'programs/benchzstd.c'),
+  join_paths(zstd_rootdir, 'programs/datagen.c'),
+  join_paths(zstd_rootdir, 'programs/util.c'),
+  join_paths(zstd_rootdir, 'tests/paramgrill.c')]
 paramgrill = executable('paramgrill',
   paramgrill_sources,
   include_directories: test_includes,
-  dependencies: [ testcommon_dep, libm_dep ],
+  dependencies: [ libzstd_dep, libm_dep ],
   install: false)
 
 roundTripCrash_sources = [join_paths(zstd_rootdir, 'tests/roundTripCrash.c')]
 roundTripCrash = executable('roundTripCrash',
   roundTripCrash_sources,
-  dependencies: [ testcommon_dep ],
+  dependencies: [ libzstd_dep ],
   install: false)
 
 longmatch_sources = [join_paths(zstd_rootdir, 'tests/longmatch.c')]
 longmatch = executable('longmatch',
   longmatch_sources,
-  dependencies: [ libzstd_internal_dep ],
+  dependencies: [ libzstd_dep ],
   install: false)
 
 invalidDictionaries_sources = [join_paths(zstd_rootdir, 'tests/invalidDictionaries.c')]
@@ -112,18 +111,26 @@ if 0 < legacy_level and legacy_level <= 4
     install: false)
 endif
 
-decodecorpus_sources = [join_paths(zstd_rootdir, 'tests/decodecorpus.c')]
+decodecorpus_sources = [join_paths(zstd_rootdir, 'programs/util.c'),
+  join_paths(zstd_rootdir, 'programs/timefn.c'),
+  join_paths(zstd_rootdir, 'tests/decodecorpus.c')]
 decodecorpus = executable('decodecorpus',
   decodecorpus_sources,
   include_directories: test_includes,
-  dependencies: [ testcommon_dep, libm_dep ],
+  dependencies: [ libzstd_dep, libm_dep ],
   install: false)
 
-poolTests_sources = [join_paths(zstd_rootdir, 'tests/poolTests.c')]
+poolTests_sources = [join_paths(zstd_rootdir, 'programs/util.c'),
+  join_paths(zstd_rootdir, 'programs/timefn.c'),
+  join_paths(zstd_rootdir, 'tests/poolTests.c'),
+  join_paths(zstd_rootdir, 'lib/common/pool.c'),
+  join_paths(zstd_rootdir, 'lib/common/threading.c'),
+  join_paths(zstd_rootdir, 'lib/common/zstd_common.c'),
+  join_paths(zstd_rootdir, 'lib/common/error_private.c')]
 poolTests = executable('poolTests',
   poolTests_sources,
   include_directories: test_includes,
-  dependencies: [ testcommon_dep, thread_dep ],
+  dependencies: [ libzstd_dep, thread_dep ],
   install: false)
 
 checkTag_sources = [join_paths(zstd_rootdir, 'tests/checkTag.c')]
@@ -137,38 +144,24 @@ checkTag = executable('checkTag',
 # =============================================================================
 
 if tests_supported_oses.contains(host_machine_os)
-  valgrind_prog = find_program('valgrind', ['/usr/bin/valgrind'], required: false)
+  valgrind_prog = find_program('valgrind', ['/usr/bin/valgrind'], required: true)
   valgrindTest_py = files('valgrindTest.py')
-  if valgrind_prog.found()
   test('valgrindTest',
     valgrindTest_py,
     args: [valgrind_prog.path(), zstd, datagen, fuzzer, fullbench],
     depends: [zstd, datagen, fuzzer, fullbench],
     timeout: 600) # Timeout should work on HDD drive
-  endif
 endif
 
 if host_machine_os != os_windows
   playTests_sh = find_program(join_paths(zstd_rootdir, 'tests/playTests.sh'), required: true)
-
-  # add slow tests only if the meson version is new enough to support
-  # test setups with default-excluded suites
-  if meson.version().version_compare('>=0.57.0')
-    matrix = {'fast': [], 'slow': ['--test-large-data']}
-  else
-    matrix = {'fast': []}
-  endif
-
-  foreach suite, opt: matrix
-    test('test-zstd-'+suite,
+  test('test-zstd',
     playTests_sh,
-      args: opt,
+    args: ZSTDRTTEST,
     env: ['ZSTD_BIN=' + zstd.full_path(), 'DATAGEN_BIN=./datagen'],
-      depends: [datagen, zstd],
-      suite: suite,
+    depends: [datagen],
     workdir: meson.current_build_dir(),
     timeout: 2800) # Timeout should work on HDD drive
-  endforeach
 endif
 
 test('test-fullbench-1',
@@ -193,6 +186,10 @@ test('test-zstream-1',
   zstreamtest,
   args: ['-v', ZSTREAM_TESTTIME] + FUZZER_FLAGS,
   timeout: 240)
+test('test-zstream-2',
+  zstreamtest,
+  args: ['-mt', '-t1', ZSTREAM_TESTTIME] + FUZZER_FLAGS,
+  timeout: 120)
 test('test-zstream-3',
   zstreamtest,
   args: ['--newapi', '-t1', ZSTREAM_TESTTIME] + FUZZER_FLAGS,
@@ -207,11 +204,3 @@ test('test-decodecorpus',
   args: ['-t', DECODECORPUS_TESTTIME],
   timeout: 60)
 test('test-poolTests', poolTests) # should be fast
-
-if meson.version().version_compare('>=0.57.0')
-  add_test_setup('fast',
-    is_default: true,
-    exclude_suites: ['slow'])
-  add_test_setup('slow',
-    exclude_suites: ['fast'])
-endif

build/meson/tests/valgrindTest.py

@@ -21,7 +21,7 @@ def valgrindTest(valgrind, datagen, fuzzer, zstd, fullbench):
 
   if subprocess.call([*VALGRIND_ARGS, zstd],
                      stdout=subprocess.DEVNULL) == 0:
-    raise subprocess.SubprocessError('zstd without argument should have failed')
+    raise subprocess.CalledProcessError('zstd without argument should have failed')
 
   with subprocess.Popen([datagen, '-g80'], stdout=subprocess.PIPE) as p1, \
        subprocess.Popen([*VALGRIND_ARGS, zstd, '-', '-c'],
@@ -30,7 +30,7 @@ def valgrindTest(valgrind, datagen, fuzzer, zstd, fullbench):
     p1.stdout.close()  # Allow p1 to receive a SIGPIPE if p2 exits.
     p2.communicate()
     if p2.returncode != 0:
-      raise subprocess.SubprocessError()
+      raise subprocess.CalledProcessError()
 
   with subprocess.Popen([datagen, '-g16KB'], stdout=subprocess.PIPE) as p1, \
        subprocess.Popen([*VALGRIND_ARGS, zstd, '-vf', '-', '-c'],
@@ -39,7 +39,7 @@ def valgrindTest(valgrind, datagen, fuzzer, zstd, fullbench):
     p1.stdout.close()
     p2.communicate()
     if p2.returncode != 0:
-      raise subprocess.SubprocessError()
+      raise subprocess.CalledProcessError()
 
   with tempfile.NamedTemporaryFile() as tmp_fd:
     with subprocess.Popen([datagen, '-g2930KB'], stdout=subprocess.PIPE) as p1, \
@@ -48,7 +48,7 @@ def valgrindTest(valgrind, datagen, fuzzer, zstd, fullbench):
       p1.stdout.close()
       p2.communicate()
       if p2.returncode != 0:
-        raise subprocess.SubprocessError()
+        raise subprocess.CalledProcessError()
 
     subprocess.check_call([*VALGRIND_ARGS, zstd, '-vdf', tmp_fd.name, '-c'],
                           stdout=subprocess.DEVNULL)
@@ -60,7 +60,7 @@ def valgrindTest(valgrind, datagen, fuzzer, zstd, fullbench):
       p1.stdout.close()
       p2.communicate()
       if p2.returncode != 0:
-        raise subprocess.SubprocessError()
+        raise subprocess.CalledProcessError()
 
   subprocess.check_call([*VALGRIND_ARGS, fuzzer, '-T1mn', '-t1'])
   subprocess.check_call([*VALGRIND_ARGS, fullbench, '-i1'])

build/single_file_libs/.gitignore

@@ -1,10 +0,0 @@
-
-# build artifacts
-zstddeclib.c
-zstdenclib.c
-zstd.c
-zstd.h
-zstd_errors.h
-
-# test artifacts
-temp*

build/single_file_libs/build_decoder_test.sh

@@ -1,91 +0,0 @@
-#!/bin/sh
-
-# Temporary compiled binary
-OUT_FILE="tempbin"
-
-# Optional temporary compiled WebAssembly
-OUT_WASM="temp.wasm"
-
-# Source files to compile using Emscripten.
-IN_FILES="examples/emscripten.c"
-
-# Emscripten build using emcc.
-emscripten_emcc_build() {
-  # Compile the same example as above
-  CC_FLAGS="-Wall -Wextra -Wshadow -Werror -Os -g0 -flto"
-  emcc $CC_FLAGS -s WASM=1 -I. -o $OUT_WASM $IN_FILES
-  # Did compilation work?
-  if [ $? -ne 0 ]; then
-    echo "Compiling ${IN_FILES}: FAILED"
-    exit 1
-  fi
-  echo "Compiling ${IN_FILES}: PASSED"
-  rm -f $OUT_WASM
-}
-
-# Emscripten build using docker.
-emscripten_docker_build() {
-  docker container run --rm \
-    --volume $PWD:/code \
-    --workdir /code \
-    emscripten/emsdk:latest \
-    emcc $CC_FLAGS -s WASM=1 -I. -o $OUT_WASM $IN_FILES
-  # Did compilation work?
-  if [ $? -ne 0 ]; then
-      echo "Compiling ${IN_FILES} (using docker): FAILED"
-    exit 1
-  fi
-  echo "Compiling ${IN_FILES} (using docker): PASSED"
-  rm -f $OUT_WASM
-}
-
-# Try Emscripten build using emcc or docker.
-try_emscripten_build() {
-  which emcc > /dev/null
-  if [ $? -eq 0 ]; then
-    emscripten_emcc_build
-    return $?
-  fi
-
-  which docker > /dev/null
-  if [ $? -eq 0 ]; then
-    emscripten_docker_build
-    return $?
-  fi
-
-  echo "(Skipping Emscripten test)"
-}
-
-# Amalgamate the sources
-./create_single_file_decoder.sh
-# Did combining work?
-if [ $? -ne 0 ]; then
-  echo "Single file decoder creation script: FAILED"
-  exit 1
-fi
-echo "Single file decoder creation script: PASSED"
-
-# Compile the generated output
-cc -Wall -Wextra -Wshadow -Werror -Os -g0 -o $OUT_FILE examples/simple.c
-# Did compilation work?
-if [ $? -ne 0 ]; then
-  echo "Compiling simple.c: FAILED"
-  exit 1
-fi
-echo "Compiling simple.c: PASSED"
-
-# Run then delete the compiled output
-./$OUT_FILE
-retVal=$?
-rm -f $OUT_FILE
-# Did the test work?
-if [ $retVal -ne 0 ]; then
-  echo "Running simple.c: FAILED"
-  exit 1
-fi
-echo "Running simple.c: PASSED"
-
-# Try Emscripten build if emcc or docker command is available.
-try_emscripten_build
-
-exit 0

build/single_file_libs/build_library_test.sh

@@ -1,98 +0,0 @@
-#!/bin/sh
-
-# Where to find the sources (only used to copy zstd.h)
-ZSTD_SRC_ROOT="../../lib"
-
-# Temporary compiled binary
-OUT_FILE="tempbin"
-
-# Optional temporary compiled WebAssembly
-OUT_WASM="temp.wasm"
-
-# Source files to compile using Emscripten.
-IN_FILES="zstd.c examples/roundtrip.c"
-
-# Emscripten build using emcc.
-emscripten_emcc_build() {
-  # Compile the same example as above
-  CC_FLAGS="-Wall -Wextra -Wshadow -Werror -Os -g0 -flto"
-  emcc $CC_FLAGS -s WASM=1 -I. -o $OUT_WASM $IN_FILES
-  # Did compilation work?
-  if [ $? -ne 0 ]; then
-    echo "Compiling ${IN_FILES}: FAILED"
-    exit 1
-  fi
-  echo "Compiling ${IN_FILES}: PASSED"
-  rm -f $OUT_WASM
-}
-
-# Emscripten build using docker.
-emscripten_docker_build() {
-  docker container run --rm \
-    --volume $PWD:/code \
-    --workdir /code \
-    emscripten/emsdk:latest \
-    emcc $CC_FLAGS -s WASM=1 -I. -o $OUT_WASM $IN_FILES
-  # Did compilation work?
-  if [ $? -ne 0 ]; then
-      echo "Compiling ${IN_FILES} (using docker): FAILED"
-    exit 1
-  fi
-  echo "Compiling ${IN_FILES} (using docker): PASSED"
-  rm -f $OUT_WASM
-}
-
-# Try Emscripten build using emcc or docker.
-try_emscripten_build() {
-  which emcc > /dev/null
-  if [ $? -eq 0 ]; then
-    emscripten_emcc_build
-    return $?
-  fi
-
-  which docker > /dev/null
-  if [ $? -eq 0 ]; then
-    emscripten_docker_build
-    return $?
-  fi
-
-  echo "(Skipping Emscripten test)"
-}
-
-# Amalgamate the sources
-./create_single_file_library.sh
-# Did combining work?
-if [ $? -ne 0 ]; then
-  echo "Single file library creation script: FAILED"
-  exit 1
-fi
-echo "Single file library creation script: PASSED"
-
-# Copy the header to here (for the tests)
-cp "$ZSTD_SRC_ROOT/zstd.h" examples/zstd.h
-cp "$ZSTD_SRC_ROOT/zstd_errors.h" examples/zstd_errors.h
-
-# Compile the generated output
-cc -Wall -Wextra -Werror -Wshadow -pthread -I. -Os -g0 -o $OUT_FILE zstd.c examples/roundtrip.c
-# Did compilation work?
-if [ $? -ne 0 ]; then
-  echo "Compiling roundtrip.c: FAILED"
-  exit 1
-fi
-echo "Compiling roundtrip.c: PASSED"
-
-# Run then delete the compiled output
-./$OUT_FILE
-retVal=$?
-rm -f $OUT_FILE
-# Did the test work?
-if [ $retVal -ne 0 ]; then
-  echo "Running roundtrip.c: FAILED"
-  exit 1
-fi
-echo "Running roundtrip.c: PASSED"
-
-# Try Emscripten build if emcc or docker command is available.
-try_emscripten_build
-
-exit 0

build/single_file_libs/combine.py

@@ -1,234 +0,0 @@
-#!/usr/bin/env python3
-
-# Tool to bundle multiple C/C++ source files, inlining any includes.
-# 
-# Note: there are two types of exclusion options: the '-x' flag, which besides
-# excluding a file also adds an #error directive in place of the #include, and
-# the '-k' flag, which keeps the #include and doesn't inline the file. The
-# intended use cases are: '-x' for files that would normally be #if'd out, so
-# features that 100% won't be used in the amalgamated file, for which every
-# occurrence adds the error, and '-k' for headers that we wish to manually
-# include, such as a project's public API, for which occurrences after the first
-# are removed.
-# 
-# Todo: the error handling could be better, which currently throws and halts
-# (which is functional just not very friendly).
-# 
-# Author: Carl Woffenden, Numfum GmbH (this script is released under a CC0 license/Public Domain)
-
-import argparse, re, sys
-
-from pathlib import Path
-from typing import Any, List, Optional, Pattern, Set, TextIO
-
-# Set of file roots when searching (equivalent to -I paths for the compiler).
-roots: Set[Path] = set()
-
-# Set of (canonical) file Path objects to exclude from inlining (and not only
-# exclude but to add a compiler error directive when they're encountered).
-excludes: Set[Path] = set()
-
-# Set of (canonical) file Path objects to keep as include directives.
-keeps: Set[Path] = set()
-
-# Whether to keep the #pragma once directives (unlikely, since this will result
-# in a warning, but the option is there).
-keep_pragma: bool = False
-
-# Destination file object (or stdout if no output file was supplied).
-destn: TextIO = sys.stdout
-
-# Set of file Path objects previously inlined (and to ignore if reencountering).
-found: Set[Path] = set()
-
-# Compiled regex Pattern to handle "#pragma once" in various formats:
-# 
-#   #pragma once
-#     #pragma once
-#   #  pragma once
-#   #pragma   once
-#   #pragma once // comment
-# 
-# Ignoring commented versions, same as include_regex.
-# 
-pragma_regex: Pattern = re.compile(r'^\s*#\s*pragma\s*once\s*')
-
-# Compiled regex Pattern to handle the following type of file includes:
-# 
-#   #include "file"
-#     #include "file"
-#   #  include "file"
-#   #include   "file"
-#   #include "file" // comment
-#   #include "file" // comment with quote "
-# 
-# And all combinations of, as well as ignoring the following:
-# 
-#   #include <file>
-#   //#include "file"
-#   /*#include "file"*/
-# 
-# We don't try to catch errors since the compiler will do this (and the code is
-# expected to be valid before processing) and we don't care what follows the
-# file (whether it's a valid comment or not, since anything after the quoted
-# string is ignored)
-# 
-include_regex: Pattern = re.compile(r'^\s*#\s*include\s*"(.+?)"')
-
-# Simple tests to prove include_regex's cases.
-# 
-def test_match_include() -> bool:
-    if (include_regex.match('#include "file"')   and
-        include_regex.match('  #include "file"') and
-        include_regex.match('#  include "file"') and
-        include_regex.match('#include   "file"') and
-        include_regex.match('#include "file" // comment')):
-            if (not include_regex.match('#include <file>')   and
-                not include_regex.match('//#include "file"') and
-                not include_regex.match('/*#include "file"*/')):
-                    found = include_regex.match('#include "file" // "')
-                    if (found and found.group(1) == 'file'):
-                        print('#include match valid')
-                        return True
-    return False
-
-# Simple tests to prove pragma_regex's cases.
-# 
-def test_match_pragma() -> bool:
-    if (pragma_regex.match('#pragma once')   and
-        pragma_regex.match('  #pragma once') and
-        pragma_regex.match('#  pragma once') and
-        pragma_regex.match('#pragma   once') and
-        pragma_regex.match('#pragma once // comment')):
-            if (not pragma_regex.match('//#pragma once') and
-                not pragma_regex.match('/*#pragma once*/')):
-                    print('#pragma once match valid')
-                    return True
-    return False
-
-# Finds 'file'. First the list of 'root' paths are searched, followed by the
-# currently processing file's 'parent' path, returning a valid Path in
-# canonical form. If no match is found None is returned.
-# 
-def resolve_include(file: str, parent: Optional[Path] = None) -> Optional[Path]:
-    for root in roots:
-        found = root.joinpath(file).resolve()
-        if (found.is_file()):
-            return found
-    if (parent):
-        found = parent.joinpath(file).resolve();
-    else:
-        found = Path(file)
-    if (found.is_file()):
-        return found
-    return None
-
-# Helper to resolve lists of files. 'file_list' is passed in from the arguments
-# and each entry resolved to its canonical path (like any include entry, either
-# from the list of root paths or the owning file's 'parent', which in this case
-# is case is the input file). The results are stored in 'resolved'.
-# 
-def resolve_excluded_files(file_list: Optional[List[str]], resolved: Set[Path], parent: Optional[Path] = None) -> None:
-    if (file_list):
-        for filename in file_list:
-            found = resolve_include(filename, parent)
-            if (found):
-                resolved.add(found)
-            else:
-                error_line(f'Warning: excluded file not found: {filename}')
-
-# Writes 'line' to the open 'destn' (or stdout).
-# 
-def write_line(line: str) -> None:
-    print(line, file=destn)
-
-# Logs 'line' to stderr. This is also used for general notifications that we
-# don't want to go to stdout (so the source can be piped).
-# 
-def error_line(line: Any) -> None:
-    print(line, file=sys.stderr)
-
-# Inline the contents of 'file' (with any of its includes also inlined, etc.).
-# 
-# Note: text encoding errors are ignored and replaced with ? when reading the
-# input files. This isn't ideal, but it's more than likely in the comments than
-# code and a) the text editor has probably also failed to read the same content,
-# and b) the compiler probably did too.
-# 
-def add_file(file: Path, file_name: str = None) -> None:
-    if (file.is_file()):
-        if (not file_name):
-            file_name = file.name
-        error_line(f'Processing: {file_name}')
-        with file.open('r', errors='replace') as opened:
-            for line in opened:
-                line = line.rstrip('\n')
-                match_include = include_regex.match(line);
-                if (match_include):
-                    # We have a quoted include directive so grab the file
-                    inc_name = match_include.group(1)
-                    resolved = resolve_include(inc_name, file.parent)
-                    if (resolved):
-                        if (resolved in excludes):
-                            # The file was excluded so error if the compiler uses it
-                            write_line(f'#error Using excluded file: {inc_name} (re-amalgamate source to fix)')
-                            error_line(f'Excluding: {inc_name}')
-                        else:
-                            if (resolved not in found):
-                                # The file was not previously encountered
-                                found.add(resolved)
-                                if (resolved in keeps):
-                                    # But the include was flagged to keep as included
-                                    write_line(f'/**** *NOT* inlining {inc_name} ****/')
-                                    write_line(line)
-                                    error_line(f'Not inlining: {inc_name}')
-                                else:
-                                    # The file was neither excluded nor seen before so inline it
-                                    write_line(f'/**** start inlining {inc_name} ****/')
-                                    add_file(resolved, inc_name)
-                                    write_line(f'/**** ended inlining {inc_name} ****/')
-                            else:
-                                write_line(f'/**** skipping file: {inc_name} ****/')
-                    else:
-                        # The include file didn't resolve to a file
-                        write_line(f'#error Unable to find: {inc_name}')
-                        error_line(f'Error: Unable to find: {inc_name}')
-                else:
-                    # Skip any 'pragma once' directives, otherwise write the source line
-                    if (keep_pragma or not pragma_regex.match(line)):
-                        write_line(line)
-    else:
-        error_line(f'Error: Invalid file: {file}')
-
-# Start here
-parser = argparse.ArgumentParser(description='Amalgamate Tool', epilog=f'example: {sys.argv[0]} -r ../my/path -r ../other/path -o out.c in.c')
-parser.add_argument('-r', '--root', action='append', type=Path, help='file root search path')
-parser.add_argument('-x', '--exclude',  action='append', help='file to completely exclude from inlining')
-parser.add_argument('-k', '--keep', action='append', help='file to exclude from inlining but keep the include directive')
-parser.add_argument('-p', '--pragma', action='store_true', default=False, help='keep any "#pragma once" directives (removed by default)')
-parser.add_argument('-o', '--output', type=argparse.FileType('w'), help='output file (otherwise stdout)')
-parser.add_argument('input', type=Path, help='input file')
-args = parser.parse_args()
-
-# Fail early on an invalid input (and store it so we don't recurse)
-args.input = args.input.resolve(strict=True)
-found.add(args.input)
-
-# Resolve all of the root paths upfront (we'll halt here on invalid roots)
-if (args.root):
-    for path in args.root:
-        roots.add(path.resolve(strict=True))
-
-# The remaining params: so resolve the excluded files and #pragma once directive
-resolve_excluded_files(args.exclude, excludes, args.input.parent)
-resolve_excluded_files(args.keep,    keeps,    args.input.parent)
-keep_pragma = args.pragma;
-
-# Then recursively process the input file
-try:
-    if (args.output):
-        destn = args.output
-    add_file(args.input)
-finally:
-    if (destn):
-        destn.close()

build/single_file_libs/create_single_file_decoder.sh

@@ -1,19 +0,0 @@
-#!/bin/sh
-
-# Where to find the sources
-ZSTD_SRC_ROOT="../../lib"
-
-# Amalgamate the sources
-echo "Amalgamating files..."
-# Using the faster Python script if we have 3.8 or higher
-if python3 -c 'import sys; assert sys.version_info >= (3,8)' 2>/dev/null; then
-  ./combine.py -r "$ZSTD_SRC_ROOT" -x legacy/zstd_legacy.h -o zstddeclib.c zstddeclib-in.c
-else
-  ./combine.sh -r "$ZSTD_SRC_ROOT" -x legacy/zstd_legacy.h -o zstddeclib.c zstddeclib-in.c
-fi
-# Did combining work?
-if [ $? -ne 0 ]; then
-  echo "Combine script: FAILED"
-  exit 1
-fi
-echo "Combine script: PASSED"

build/single_file_libs/create_single_file_library.sh

@@ -1,19 +0,0 @@
-#!/bin/sh
-
-# Where to find the sources
-ZSTD_SRC_ROOT="../../lib"
-
-# Amalgamate the sources
-echo "Amalgamating files..."
-# Using the faster Python script if we have 3.8 or higher
-if python3 -c 'import sys; assert sys.version_info >= (3,8)' 2>/dev/null; then
-  ./combine.py -r "$ZSTD_SRC_ROOT" -x legacy/zstd_legacy.h -o zstd.c zstd-in.c
-else
-  ./combine.sh -r "$ZSTD_SRC_ROOT" -x legacy/zstd_legacy.h -o zstd.c zstd-in.c
-fi
-# Did combining work?
-if [ $? -ne 0 ]; then
-  echo "Combine script: FAILED"
-  exit 1
-fi
-echo "Combine script: PASSED"

contrib/VS2005/fullbench/fullbench.vcproj

@@ -390,7 +390,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File

contrib/VS2005/fuzzer/fuzzer.vcproj

@@ -426,7 +426,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File
@@ -454,7 +454,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zdict.h"
+				RelativePath="..\..\..\lib\dictBuilder\zdict.h"
 				>
 			</File>
 			<File

contrib/VS2005/zstd/zstd.vcproj

@@ -362,10 +362,6 @@
 			<File
 				RelativePath="..\..\..\programs\fileio.c"
 				>
-			</File>
-			<File
-                RelativePath="..\..\..\programs\fileio_asyncio.c"
-                >
 			</File>
 			<File
 				RelativePath="..\..\..\lib\compress\fse_compress.c"
@@ -458,7 +454,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File
@@ -486,7 +482,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zdict.h"
+				RelativePath="..\..\..\lib\dictBuilder\zdict.h"
 				>
 			</File>
 			<File

contrib/VS2005/zstdlib/zstdlib.vcproj

@@ -371,6 +371,18 @@
 				RelativePath="..\..\..\lib\common\xxhash.c"
 				>
 			</File>
+			<File
+				RelativePath="..\..\..\lib\deprecated\zbuff_common.c"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\lib\deprecated\zbuff_compress.c"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\lib\deprecated\zbuff_decompress.c"
+				>
+			</File>
 			<File
 				RelativePath="..\..\..\lib\dictBuilder\zdict.c"
 				>
@@ -446,7 +458,7 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zstd_errors.h"
+				RelativePath="..\..\..\lib\common\zstd_errors.h"
 				>
 			</File>
 			<File
@@ -474,7 +486,11 @@
 				>
 			</File>
 			<File
-				RelativePath="..\..\..\lib\zdict.h"
+				RelativePath="..\..\..\lib\common\zbuff.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\..\lib\dictBuilder\zdict.h"
 				>
 			</File>
 			<File

contrib/diagnose_corruption/Makefile

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2019-present, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the

contrib/diagnose_corruption/check_flipped_bits.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * Copyright (c) 2019-present, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under both the BSD-style license (found in the

contrib/docker/Dockerfile

@@ -1,13 +1,13 @@
 # Dockerfile
 # First image to build the binary
-FROM alpine@sha256:69665d02cb32192e52e07644d76bc6f25abeb5410edc1c7a81a10ba3f0efb90a as builder
+FROM alpine as builder
 
 RUN apk --no-cache add make gcc libc-dev
 COPY . /src
 RUN mkdir /pkg && cd /src && make && make DESTDIR=/pkg install
 
 # Second minimal image to only keep the built binary
-FROM alpine@sha256:69665d02cb32192e52e07644d76bc6f25abeb5410edc1c7a81a10ba3f0efb90a
+FROM alpine
 
 # Copy the built files
 COPY --from=builder /pkg /

contrib/externalSequenceProducer/.gitignore

@@ -1,2 +0,0 @@
-# build artifacts
-externalSequenceProducer

contrib/externalSequenceProducer/Makefile

@@ -1,40 +0,0 @@
-# ################################################################
-# Copyright (c) Yann Collet, Meta Platforms, Inc.
-# All rights reserved.
-#
-# This source code is licensed under both the BSD-style license (found in the
-# LICENSE file in the root directory of this source tree) and the GPLv2 (found
-# in the COPYING file in the root directory of this source tree).
-# ################################################################
-
-PROGDIR = ../../programs
-LIBDIR  = ../../lib
-
-LIBZSTD = $(LIBDIR)/libzstd.a
-
-CPPFLAGS+= -I$(LIBDIR) -I$(LIBDIR)/compress -I$(LIBDIR)/common
-
-CFLAGS  ?= -O3
-CFLAGS  += -std=gnu99
-DEBUGFLAGS= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
-            -Wstrict-aliasing=1 -Wswitch-enum \
-            -Wstrict-prototypes -Wundef -Wpointer-arith \
-            -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \
-            -Wredundant-decls
-CFLAGS  += $(DEBUGFLAGS) $(MOREFLAGS)
-
-default: externalSequenceProducer
-
-all: externalSequenceProducer
-
-externalSequenceProducer: sequence_producer.c main.c $(LIBZSTD)
-	$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@
-
-.PHONY: $(LIBZSTD)
-$(LIBZSTD):
-	$(MAKE) -C $(LIBDIR) libzstd.a CFLAGS="$(CFLAGS)"
-
-clean:
-	$(RM) *.o
-	$(MAKE) -C $(LIBDIR) clean > /dev/null
-	$(RM) externalSequenceProducer

contrib/externalSequenceProducer/README.md

@@ -1,14 +0,0 @@
-externalSequenceProducer
-=====================
-
-`externalSequenceProducer` is a test tool for the Block-Level Sequence Producer API.
-It demonstrates how to use the API to perform a simple round-trip test.
-
-A sample sequence producer is provided in sequence_producer.c, but the user can swap
-this out with a different one if desired. The sample sequence producer implements
-LZ parsing with a 1KB hashtable. Dictionary-based parsing is not currently supported.
-
-Command line :
-```
-externalSequenceProducer filename
-```

contrib/externalSequenceProducer/main.c

@@ -1,108 +0,0 @@
-/*
- * Copyright (c) Yann Collet, Meta Platforms, Inc.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-#define ZSTD_STATIC_LINKING_ONLY
-#include "zstd.h"
-#include "zstd_errors.h"
-#include "sequence_producer.h" // simpleSequenceProducer
-
-#define CHECK(res)                                      \
-do {                                                    \
-    if (ZSTD_isError(res)) {                            \
-        printf("ERROR: %s\n", ZSTD_getErrorName(res));  \
-        return 1;                                       \
-    }                                                   \
-} while (0)                                             \
-
-int main(int argc, char *argv[]) {
-    int retn = 0;
-    if (argc != 2) {
-        printf("Usage: externalSequenceProducer <file>\n");
-        return 1;
-    }
-
-    ZSTD_CCtx* const zc = ZSTD_createCCtx();
-
-    int simpleSequenceProducerState = 0xdeadbeef;
-
-    // Here is the crucial bit of code!
-    ZSTD_registerSequenceProducer(
-        zc,
-        &simpleSequenceProducerState,
-        simpleSequenceProducer
-    );
-
-    {
-        size_t const res = ZSTD_CCtx_setParameter(zc, ZSTD_c_enableSeqProducerFallback, 1);
-        CHECK(res);
-    }
-
-    FILE *f = fopen(argv[1], "rb");
-    assert(f);
-    {
-        int const ret = fseek(f, 0, SEEK_END);
-        assert(ret == 0);
-    }
-    size_t const srcSize = ftell(f);
-    {
-        int const ret = fseek(f, 0, SEEK_SET);
-        assert(ret == 0);
-    }
-
-    char* const src = malloc(srcSize + 1);
-    assert(src);
-    {
-        size_t const ret = fread(src, srcSize, 1, f);
-        assert(ret == 1);
-        int const ret2 = fclose(f);
-        assert(ret2 == 0);
-    }
-
-    size_t const dstSize = ZSTD_compressBound(srcSize);
-    char* const dst = malloc(dstSize);
-    assert(dst);
-
-    size_t const cSize = ZSTD_compress2(zc, dst, dstSize, src, srcSize);
-    CHECK(cSize);
-
-    char* const val = malloc(srcSize);
-    assert(val);
-
-    {
-        size_t const res = ZSTD_decompress(val, srcSize, dst, cSize);
-        CHECK(res);
-    }
-
-    if (memcmp(src, val, srcSize) == 0) {
-        printf("Compression and decompression were successful!\n");
-        printf("Original size: %lu\n", srcSize);
-        printf("Compressed size: %lu\n", cSize);
-    } else {
-        printf("ERROR: input and validation buffers don't match!\n");
-        for (size_t i = 0; i < srcSize; i++) {
-            if (src[i] != val[i]) {
-                printf("First bad index: %zu\n", i);
-                break;
-            }
-        }
-        retn = 1;
-    }
-
-    ZSTD_freeCCtx(zc);
-    free(src);
-    free(dst);
-    free(val);
-    return retn;
-}

contrib/externalSequenceProducer/sequence_producer.c

@@ -1,80 +0,0 @@
-/*
- * Copyright (c) Yann Collet, Meta Platforms, Inc.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#include "zstd_compress_internal.h"
-#include "sequence_producer.h"
-
-#define HSIZE 1024
-static U32 const HLOG = 10;
-static U32 const MLS = 4;
-static U32 const BADIDX = 0xffffffff;
-
-size_t simpleSequenceProducer(
-  void* sequenceProducerState,
-  ZSTD_Sequence* outSeqs, size_t outSeqsCapacity,
-  const void* src, size_t srcSize,
-  const void* dict, size_t dictSize,
-  int compressionLevel,
-  size_t windowSize
-) {
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    size_t seqCount = 0;
-    U32 hashTable[HSIZE];
-
-    (void)sequenceProducerState;
-    (void)dict;
-    (void)dictSize;
-    (void)outSeqsCapacity;
-    (void)compressionLevel;
-
-    {   int i;
-        for (i=0; i < HSIZE; i++) {
-            hashTable[i] = BADIDX;
-    }   }
-
-    while (ip + MLS < iend) {
-        size_t const hash = ZSTD_hashPtr(ip, HLOG, MLS);
-        U32 const matchIndex = hashTable[hash];
-        hashTable[hash] = (U32)(ip - istart);
-
-        if (matchIndex != BADIDX) {
-            const BYTE* const match = istart + matchIndex;
-            U32 const matchLen = (U32)ZSTD_count(ip, match, iend);
-            if (matchLen >= ZSTD_MINMATCH_MIN) {
-                U32 const litLen = (U32)(ip - anchor);
-                U32 const offset = (U32)(ip - match);
-                ZSTD_Sequence const seq = {
-                    offset, litLen, matchLen, 0
-                };
-
-                /* Note: it's crucial to stay within the window size! */
-                if (offset <= windowSize) {
-                    outSeqs[seqCount++] = seq;
-                    ip += matchLen;
-                    anchor = ip;
-                    continue;
-                }
-            }
-        }
-
-        ip++;
-    }
-
-    {   ZSTD_Sequence const finalSeq = {
-            0, (U32)(iend - anchor), 0, 0
-        };
-        outSeqs[seqCount++] = finalSeq;
-    }
-
-    return seqCount;
-}

contrib/externalSequenceProducer/sequence_producer.h

@@ -1,26 +0,0 @@
-/*
- * Copyright (c) Yann Collet, Meta Platforms, Inc.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- * You may select, at your option, one of the above-listed licenses.
- */
-
-#ifndef MATCHFINDER_H
-#define MATCHFINDER_H
-
-#define ZSTD_STATIC_LINKING_ONLY
-#include "zstd.h"
-
-size_t simpleSequenceProducer(
-  void* sequenceProducerState,
-  ZSTD_Sequence* outSeqs, size_t outSeqsCapacity,
-  const void* src, size_t srcSize,
-  const void* dict, size_t dictSize,
-  int compressionLevel,
-  size_t windowSize
-);
-
-#endif

contrib/freestanding_lib/freestanding.py

@@ -1,774 +0,0 @@
-#!/usr/bin/env python3
-# ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under both the BSD-style license (found in the
-# LICENSE file in the root directory of this source tree) and the GPLv2 (found
-# in the COPYING file in the root directory of this source tree).
-# You may select, at your option, one of the above-listed licenses.
-# ##########################################################################
-
-import argparse
-import contextlib
-import os
-import re
-import shutil
-import sys
-from typing import Optional
-
-
-INCLUDED_SUBDIRS = ["common", "compress", "decompress"]
-
-SKIPPED_FILES = [
-    "common/mem.h",
-    "common/zstd_deps.h",
-    "common/pool.c",
-    "common/pool.h",
-    "common/threading.c",
-    "common/threading.h",
-    "common/zstd_trace.h",
-    "compress/zstdmt_compress.h",
-    "compress/zstdmt_compress.c",
-]
-
-XXHASH_FILES = [
-    "common/xxhash.c",
-    "common/xxhash.h",
-]
-
-
-class FileLines(object):
-    def __init__(self, filename):
-        self.filename = filename
-        with open(self.filename, "r") as f:
-            self.lines = f.readlines()
-
-    def write(self):
-        with open(self.filename, "w") as f:
-            f.write("".join(self.lines))
-
-
-class PartialPreprocessor(object):
-    """
-    Looks for simple ifdefs and ifndefs and replaces them.
-    Handles && and ||.
-    Has fancy logic to handle translating elifs to ifs.
-    Only looks for macros in the first part of the expression with no
-    parens.
-    Does not handle multi-line macros (only looks in first line).
-    """
-    def __init__(self, defs: [(str, Optional[str])], replaces: [(str, str)], undefs: [str]):
-        MACRO_GROUP = r"(?P<macro>[a-zA-Z_][a-zA-Z_0-9]*)"
-        ELIF_GROUP = r"(?P<elif>el)?"
-        OP_GROUP = r"(?P<op>&&|\|\|)?"
-
-        self._defs = {macro:value for macro, value in defs}
-        self._replaces = {macro:value for macro, value in replaces}
-        self._defs.update(self._replaces)
-        self._undefs = set(undefs)
-
-        self._define = re.compile(r"\s*#\s*define")
-        self._if = re.compile(r"\s*#\s*if")
-        self._elif = re.compile(r"\s*#\s*(?P<elif>el)if")
-        self._else = re.compile(r"\s*#\s*(?P<else>else)")
-        self._endif = re.compile(r"\s*#\s*endif")
-
-        self._ifdef = re.compile(fr"\s*#\s*if(?P<not>n)?def {MACRO_GROUP}\s*")
-        self._if_defined = re.compile(
-            fr"\s*#\s*{ELIF_GROUP}if\s+(?P<not>!)?\s*defined\s*\(\s*{MACRO_GROUP}\s*\)\s*{OP_GROUP}"
-        )
-        self._if_defined_value = re.compile(
-            fr"\s*#\s*{ELIF_GROUP}if\s+defined\s*\(\s*{MACRO_GROUP}\s*\)\s*"
-            fr"(?P<op>&&)\s*"
-            fr"(?P<openp>\()?\s*"
-            fr"(?P<macro2>[a-zA-Z_][a-zA-Z_0-9]*)\s*"
-            fr"(?P<cmp>[=><!]+)\s*"
-            fr"(?P<value>[0-9]*)\s*"
-            fr"(?P<closep>\))?\s*"
-        )
-        self._if_true = re.compile(
-            fr"\s*#\s*{ELIF_GROUP}if\s+{MACRO_GROUP}\s*{OP_GROUP}"
-        )
-
-        self._c_comment = re.compile(r"/\*.*?\*/")
-        self._cpp_comment = re.compile(r"//")
-
-    def _log(self, *args, **kwargs):
-        print(*args, **kwargs)
-
-    def _strip_comments(self, line):
-        # First strip c-style comments (may include //)
-        while True:
-            m = self._c_comment.search(line)
-            if m is None:
-                break
-            line = line[:m.start()] + line[m.end():]
-
-        # Then strip cpp-style comments
-        m = self._cpp_comment.search(line)
-        if m is not None:
-            line = line[:m.start()]
-
-        return line
-
-    def _fixup_indentation(self, macro, replace: [str]):
-        if len(replace) == 0:
-            return replace
-        if len(replace) == 1 and self._define.match(replace[0]) is None:
-            # If there is only one line, only replace defines
-            return replace
-
-
-        all_pound = True
-        for line in replace:
-            if not line.startswith('#'):
-                all_pound = False
-        if all_pound:
-            replace = [line[1:] for line in replace]
-
-        min_spaces = len(replace[0])
-        for line in replace:
-            spaces = 0
-            for i, c in enumerate(line):
-                if c != ' ':
-                    # Non-preprocessor line ==> skip the fixup
-                    if not all_pound and c != '#':
-                        return replace
-                    spaces = i
-                    break
-            min_spaces = min(min_spaces, spaces)
-
-        replace = [line[min_spaces:] for line in replace]
-
-        if all_pound:
-            replace = ["#" + line for line in replace]
-
-        return replace
-
-    def _handle_if_block(self, macro, idx, is_true, prepend):
-        """
-        Remove the #if or #elif block starting on this line.
-        """
-        REMOVE_ONE = 0
-        KEEP_ONE = 1
-        REMOVE_REST = 2
-
-        if is_true:
-            state = KEEP_ONE
-        else:
-            state = REMOVE_ONE
-
-        line = self._inlines[idx]
-        is_if = self._if.match(line) is not None
-        assert is_if or self._elif.match(line) is not None
-        depth = 0
-
-        start_idx = idx
-
-        idx += 1
-        replace = prepend
-        finished = False
-        while idx < len(self._inlines):
-            line = self._inlines[idx]
-            # Nested if statement
-            if self._if.match(line):
-                depth += 1
-                idx += 1
-                continue
-            # We're inside a nested statement
-            if depth > 0:
-                if self._endif.match(line):
-                    depth -= 1
-                idx += 1
-                continue
-
-            # We're at the original depth
-
-            # Looking only for an endif.
-            # We've found a true statement, but haven't
-            # completely elided the if block, so we just
-            # remove the remainder.
-            if state == REMOVE_REST:
-                if self._endif.match(line):
-                    if is_if:
-                        # Remove the endif because we took the first if
-                        idx += 1
-                    finished = True
-                    break
-                idx += 1
-                continue
-
-            if state == KEEP_ONE:
-                m = self._elif.match(line)
-                if self._endif.match(line):
-                    replace += self._inlines[start_idx + 1:idx]
-                    idx += 1
-                    finished = True
-                    break
-                if self._elif.match(line) or self._else.match(line):
-                    replace += self._inlines[start_idx + 1:idx]
-                    state = REMOVE_REST
-                idx += 1
-                continue
-
-            if state == REMOVE_ONE:
-                m = self._elif.match(line)
-                if m is not None:
-                    if is_if:
-                        idx += 1
-                        b = m.start('elif')
-                        e = m.end('elif')
-                        assert e - b == 2
-                        replace.append(line[:b] + line[e:])
-                    finished = True
-                    break
-                m = self._else.match(line)
-                if m is not None:
-                    if is_if:
-                        idx += 1
-                        while self._endif.match(self._inlines[idx]) is None:
-                            replace.append(self._inlines[idx])
-                            idx += 1
-                        idx += 1
-                    finished = True
-                    break
-                if self._endif.match(line):
-                    if is_if:
-                        # Remove the endif because no other elifs
-                        idx += 1
-                    finished = True
-                    break
-                idx += 1
-                continue
-        if not finished:
-            raise RuntimeError("Unterminated if block!")
-
-        replace = self._fixup_indentation(macro, replace)
-
-        self._log(f"\tHardwiring {macro}")
-        if start_idx > 0:
-            self._log(f"\t\t  {self._inlines[start_idx - 1][:-1]}")
-        for x in range(start_idx, idx):
-            self._log(f"\t\t- {self._inlines[x][:-1]}")
-        for line in replace:
-            self._log(f"\t\t+ {line[:-1]}")
-        if idx < len(self._inlines):
-            self._log(f"\t\t  {self._inlines[idx][:-1]}")
-
-        return idx, replace
-
-    def _preprocess_once(self):
-        outlines = []
-        idx = 0
-        changed = False
-        while idx < len(self._inlines):
-            line = self._inlines[idx]
-            sline = self._strip_comments(line)
-            m = self._ifdef.fullmatch(sline)
-            if_true = False
-            if m is None:
-                m = self._if_defined_value.fullmatch(sline)
-            if m is None:
-                m = self._if_defined.match(sline)
-            if m is None:
-                m = self._if_true.match(sline)
-                if_true = (m is not None)
-            if m is None:
-                outlines.append(line)
-                idx += 1
-                continue
-
-            groups = m.groupdict()
-            macro = groups['macro']
-            op = groups.get('op')
-
-            if not (macro in self._defs or macro in self._undefs):
-                outlines.append(line)
-                idx += 1
-                continue
-
-            defined = macro in self._defs
-
-            # Needed variables set:
-            # resolved: Is the statement fully resolved?
-            # is_true: If resolved, is the statement true?
-            ifdef = False
-            if if_true:
-                if not defined:
-                    outlines.append(line)
-                    idx += 1
-                    continue
-
-                defined_value = self._defs[macro]
-                is_int = True
-                try:
-                    defined_value = int(defined_value)
-                except TypeError:
-                    is_int = False
-                except ValueError:
-                    is_int = False
-
-                resolved = is_int
-                is_true = (defined_value != 0)
-
-                if resolved and op is not None:
-                    if op == '&&':
-                        resolved = not is_true
-                    else:
-                        assert op == '||'
-                        resolved = is_true
-
-            else:
-                ifdef = groups.get('not') is None
-                elseif = groups.get('elif') is not None
-
-                macro2 = groups.get('macro2')
-                cmp = groups.get('cmp')
-                value = groups.get('value')
-                openp = groups.get('openp')
-                closep = groups.get('closep')
-
-                is_true = (ifdef == defined)
-                resolved = True
-                if op is not None:
-                    if op == '&&':
-                        resolved = not is_true
-                    else:
-                        assert op == '||'
-                        resolved = is_true
-
-                if macro2 is not None and not resolved:
-                    assert ifdef and defined and op == '&&' and cmp is not None
-                    # If the statement is true, but we have a single value check, then
-                    # check the value.
-                    defined_value = self._defs[macro]
-                    are_ints = True
-                    try:
-                        defined_value = int(defined_value)
-                        value = int(value)
-                    except TypeError:
-                        are_ints = False
-                    except ValueError:
-                        are_ints = False
-                    if (
-                            macro == macro2 and
-                            ((openp is None) == (closep is None)) and
-                            are_ints
-                    ):
-                        resolved = True
-                        if cmp == '<':
-                            is_true = defined_value < value
-                        elif cmp == '<=':
-                            is_true = defined_value <= value
-                        elif cmp == '==':
-                            is_true = defined_value == value
-                        elif cmp == '!=':
-                            is_true = defined_value != value
-                        elif cmp == '>=':
-                            is_true = defined_value >= value
-                        elif cmp == '>':
-                            is_true = defined_value > value
-                        else:
-                            resolved = False
-
-                if op is not None and not resolved:
-                    # Remove the first op in the line + spaces
-                    if op == '&&':
-                        opre = op
-                    else:
-                        assert op == '||'
-                        opre = r'\|\|'
-                    needle = re.compile(fr"(?P<if>\s*#\s*(el)?if\s+).*?(?P<op>{opre}\s*)")
-                    match = needle.match(line)
-                    assert match is not None
-                    newline = line[:match.end('if')] + line[match.end('op'):]
-
-                    self._log(f"\tHardwiring partially resolved {macro}")
-                    self._log(f"\t\t- {line[:-1]}")
-                    self._log(f"\t\t+ {newline[:-1]}")
-
-                    outlines.append(newline)
-                    idx += 1
-                    continue
-
-            # Skip any statements we cannot fully compute
-            if not resolved:
-                outlines.append(line)
-                idx += 1
-                continue
-
-            prepend = []
-            if macro in self._replaces:
-                assert not ifdef
-                assert op is None
-                value = self._replaces.pop(macro)
-                prepend = [f"#define {macro} {value}\n"]
-
-            idx, replace = self._handle_if_block(macro, idx, is_true, prepend)
-            outlines += replace
-            changed = True
-
-        return changed, outlines
-
-    def preprocess(self, filename):
-        with open(filename, 'r') as f:
-            self._inlines = f.readlines()
-        changed = True
-        iters = 0
-        while changed:
-            iters += 1
-            changed, outlines = self._preprocess_once()
-            self._inlines = outlines
-
-        with open(filename, 'w') as f:
-            f.write(''.join(self._inlines))
-
-
-class Freestanding(object):
-    def __init__(
-            self, zstd_deps: str, mem: str, source_lib: str, output_lib: str,
-            external_xxhash: bool, xxh64_state: Optional[str],
-            xxh64_prefix: Optional[str], rewritten_includes: [(str, str)],
-            defs: [(str, Optional[str])], replaces: [(str, str)],
-            undefs: [str], excludes: [str], seds: [str], spdx: bool,
-    ):
-        self._zstd_deps = zstd_deps
-        self._mem = mem
-        self._src_lib = source_lib
-        self._dst_lib = output_lib
-        self._external_xxhash = external_xxhash
-        self._xxh64_state = xxh64_state
-        self._xxh64_prefix = xxh64_prefix
-        self._rewritten_includes = rewritten_includes
-        self._defs = defs
-        self._replaces = replaces
-        self._undefs = undefs
-        self._excludes = excludes
-        self._seds = seds
-        self._spdx = spdx
-
-    def _dst_lib_file_paths(self):
-        """
-        Yields all the file paths in the dst_lib.
-        """
-        for root, dirname, filenames in os.walk(self._dst_lib):
-            for filename in filenames:
-                filepath = os.path.join(root, filename)
-                yield filepath
-
-    def _log(self, *args, **kwargs):
-        print(*args, **kwargs)
-
-    def _copy_file(self, lib_path):
-        suffixes = [".c", ".h", ".S"]
-        if not any((lib_path.endswith(suffix) for suffix in suffixes)):
-            return
-        if lib_path in SKIPPED_FILES:
-            self._log(f"\tSkipping file: {lib_path}")
-            return
-        if self._external_xxhash and lib_path in XXHASH_FILES:
-            self._log(f"\tSkipping xxhash file: {lib_path}")
-            return
-
-        src_path = os.path.join(self._src_lib, lib_path)
-        dst_path = os.path.join(self._dst_lib, lib_path)
-        self._log(f"\tCopying: {src_path} -> {dst_path}")
-        shutil.copyfile(src_path, dst_path)
-
-    def _copy_source_lib(self):
-        self._log("Copying source library into output library")
-
-        assert os.path.exists(self._src_lib)
-        os.makedirs(self._dst_lib, exist_ok=True)
-        self._copy_file("zstd.h")
-        self._copy_file("zstd_errors.h")
-        for subdir in INCLUDED_SUBDIRS:
-            src_dir = os.path.join(self._src_lib, subdir)
-            dst_dir = os.path.join(self._dst_lib, subdir)
-
-            assert os.path.exists(src_dir)
-            os.makedirs(dst_dir, exist_ok=True)
-
-            for filename in os.listdir(src_dir):
-                lib_path = os.path.join(subdir, filename)
-                self._copy_file(lib_path)
-
-    def _copy_zstd_deps(self):
-        dst_zstd_deps = os.path.join(self._dst_lib, "common", "zstd_deps.h")
-        self._log(f"Copying zstd_deps: {self._zstd_deps} -> {dst_zstd_deps}")
-        shutil.copyfile(self._zstd_deps, dst_zstd_deps)
-
-    def _copy_mem(self):
-        dst_mem = os.path.join(self._dst_lib, "common", "mem.h")
-        self._log(f"Copying mem: {self._mem} -> {dst_mem}")
-        shutil.copyfile(self._mem, dst_mem)
-
-    def _hardwire_preprocessor(self, name: str, value: Optional[str] = None, undef=False):
-        """
-        If value=None then hardwire that it is defined, but not what the value is.
-        If undef=True then value must be None.
-        If value='' then the macro is defined to '' exactly.
-        """
-        assert not (undef and value is not None)
-        for filepath in self._dst_lib_file_paths():
-            file = FileLines(filepath)
-
-    def _hardwire_defines(self):
-        self._log("Hardwiring macros")
-        partial_preprocessor = PartialPreprocessor(self._defs, self._replaces, self._undefs)
-        for filepath in self._dst_lib_file_paths():
-            partial_preprocessor.preprocess(filepath)
-
-    def _remove_excludes(self):
-        self._log("Removing excluded sections")
-        for exclude in self._excludes:
-            self._log(f"\tRemoving excluded sections for: {exclude}")
-            begin_re = re.compile(f"BEGIN {exclude}")
-            end_re = re.compile(f"END {exclude}")
-            for filepath in self._dst_lib_file_paths():
-                file = FileLines(filepath)
-                outlines = []
-                skipped = []
-                emit = True
-                for line in file.lines:
-                    if emit and begin_re.search(line) is not None:
-                        assert end_re.search(line) is None
-                        emit = False
-                    if emit:
-                        outlines.append(line)
-                    else:
-                        skipped.append(line)
-                        if end_re.search(line) is not None:
-                            assert begin_re.search(line) is None
-                            self._log(f"\t\tRemoving excluded section: {exclude}")
-                            for s in skipped:
-                                self._log(f"\t\t\t- {s}")
-                            emit = True
-                            skipped = []
-                if not emit:
-                    raise RuntimeError("Excluded section unfinished!")
-                file.lines = outlines
-                file.write()
-
-    def _rewrite_include(self, original, rewritten):
-        self._log(f"\tRewriting include: {original} -> {rewritten}")
-        regex = re.compile(f"\\s*#\\s*include\\s*(?P<include>{original})")
-        for filepath in self._dst_lib_file_paths():
-            file = FileLines(filepath)
-            for i, line in enumerate(file.lines):
-                match = regex.match(line)
-                if match is None:
-                    continue
-                s = match.start('include')
-                e = match.end('include')
-                file.lines[i] = line[:s] + rewritten + line[e:]
-            file.write()
-
-    def _rewrite_includes(self):
-        self._log("Rewriting includes")
-        for original, rewritten in self._rewritten_includes:
-            self._rewrite_include(original, rewritten)
-
-    def _replace_xxh64_prefix(self):
-        if self._xxh64_prefix is None:
-            return
-        self._log(f"Replacing XXH64 prefix with {self._xxh64_prefix}")
-        replacements = []
-        if self._xxh64_state is not None:
-            replacements.append(
-                (re.compile(r"([^\w]|^)(?P<orig>XXH64_state_t)([^\w]|$)"), self._xxh64_state)
-            )
-        if self._xxh64_prefix is not None:
-            replacements.append(
-                (re.compile(r"([^\w]|^)(?P<orig>XXH64)[\(_]"), self._xxh64_prefix)
-            )
-        for filepath in self._dst_lib_file_paths():
-            file = FileLines(filepath)
-            for i, line in enumerate(file.lines):
-                modified = False
-                for regex, replacement in replacements:
-                    match = regex.search(line)
-                    while match is not None:
-                        modified = True
-                        b = match.start('orig')
-                        e = match.end('orig')
-                        line = line[:b] + replacement + line[e:]
-                        match = regex.search(line)
-                if modified:
-                    self._log(f"\t- {file.lines[i][:-1]}")
-                    self._log(f"\t+ {line[:-1]}")
-                file.lines[i] = line
-            file.write()
-
-    def _parse_sed(self, sed):
-        assert sed[0] == 's'
-        delim = sed[1]
-        match = re.fullmatch(f's{delim}(.+){delim}(.*){delim}(.*)', sed)
-        assert match is not None
-        regex = re.compile(match.group(1))
-        format_str = match.group(2)
-        is_global = match.group(3) == 'g'
-        return regex, format_str, is_global
-
-    def _process_sed(self, sed):
-        self._log(f"Processing sed: {sed}")
-        regex, format_str, is_global = self._parse_sed(sed)
-
-        for filepath in self._dst_lib_file_paths():
-            file = FileLines(filepath)
-            for i, line in enumerate(file.lines):
-                modified = False
-                while True:
-                    match = regex.search(line)
-                    if match is None:
-                        break
-                    replacement = format_str.format(match.groups(''), match.groupdict(''))
-                    b = match.start()
-                    e = match.end()
-                    line = line[:b] + replacement + line[e:]
-                    modified = True
-                    if not is_global:
-                        break
-                if modified:
-                    self._log(f"\t- {file.lines[i][:-1]}")
-                    self._log(f"\t+ {line[:-1]}")
-                file.lines[i] = line
-            file.write()
-
-    def _process_seds(self):
-        self._log("Processing seds")
-        for sed in self._seds:
-            self._process_sed(sed)
-
-    def _process_spdx(self):
-        if not self._spdx:
-            return
-        self._log("Processing spdx")
-        SPDX_C = "// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause\n"
-        SPDX_H_S = "/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */\n"
-        for filepath in self._dst_lib_file_paths():
-            file = FileLines(filepath)
-            if file.lines[0] == SPDX_C or file.lines[0] == SPDX_H_S:
-                continue
-            for line in file.lines:
-                if "SPDX-License-Identifier" in line:
-                    raise RuntimeError(f"Unexpected SPDX license identifier: {file.filename} {repr(line)}")
-            if file.filename.endswith(".c"):
-                file.lines.insert(0, SPDX_C)
-            elif file.filename.endswith(".h") or file.filename.endswith(".S"):
-                file.lines.insert(0, SPDX_H_S)
-            else:
-                raise RuntimeError(f"Unexpected file extension: {file.filename}")
-            file.write()
-
-
-
-    def go(self):
-        self._copy_source_lib()
-        self._copy_zstd_deps()
-        self._copy_mem()
-        self._hardwire_defines()
-        self._remove_excludes()
-        self._rewrite_includes()
-        self._replace_xxh64_prefix()
-        self._process_seds()
-        self._process_spdx()
-
-
-def parse_optional_pair(defines: [str]) -> [(str, Optional[str])]:
-    output = []
-    for define in defines:
-        parsed = define.split('=')
-        if len(parsed) == 1:
-            output.append((parsed[0], None))
-        elif len(parsed) == 2:
-            output.append((parsed[0], parsed[1]))
-        else:
-            raise RuntimeError(f"Bad define: {define}")
-    return output
-
-
-def parse_pair(rewritten_includes: [str]) -> [(str, str)]:
-    output = []
-    for rewritten_include in rewritten_includes:
-        parsed = rewritten_include.split('=')
-        if len(parsed) == 2:
-            output.append((parsed[0], parsed[1]))
-        else:
-            raise RuntimeError(f"Bad rewritten include: {rewritten_include}")
-    return output
-
-
-
-def main(name, args):
-    parser = argparse.ArgumentParser(prog=name)
-    parser.add_argument("--zstd-deps", default="zstd_deps.h", help="Zstd dependencies file")
-    parser.add_argument("--mem", default="mem.h", help="Memory module")
-    parser.add_argument("--source-lib", default="../../lib", help="Location of the zstd library")
-    parser.add_argument("--output-lib", default="./freestanding_lib", help="Where to output the freestanding zstd library")
-    parser.add_argument("--xxhash", default=None, help="Alternate external xxhash include e.g. --xxhash='<xxhash.h>'. If set xxhash is not included.")
-    parser.add_argument("--xxh64-state", default=None, help="Alternate XXH64 state type (excluding _) e.g. --xxh64-state='struct xxh64_state'")
-    parser.add_argument("--xxh64-prefix", default=None, help="Alternate XXH64 function prefix (excluding _) e.g. --xxh64-prefix=xxh64")
-    parser.add_argument("--rewrite-include", default=[], dest="rewritten_includes", action="append", help="Rewrite an include REGEX=NEW (e.g. '<stddef\\.h>=<linux/types.h>')")
-    parser.add_argument("--sed", default=[], dest="seds", action="append", help="Apply a sed replacement. Format: `s/REGEX/FORMAT/[g]`. REGEX is a Python regex. FORMAT is a Python format string formatted by the regex dict.")
-    parser.add_argument("--spdx", action="store_true", help="Add SPDX License Identifiers")
-    parser.add_argument("-D", "--define", default=[], dest="defs", action="append", help="Pre-define this macro (can be passed multiple times)")
-    parser.add_argument("-U", "--undefine", default=[], dest="undefs", action="append", help="Pre-undefine this macro (can be passed multiple times)")
-    parser.add_argument("-R", "--replace", default=[], dest="replaces", action="append", help="Pre-define this macro and replace the first ifndef block with its definition")
-    parser.add_argument("-E", "--exclude", default=[], dest="excludes", action="append", help="Exclude all lines between 'BEGIN <EXCLUDE>' and 'END <EXCLUDE>'")
-    args = parser.parse_args(args)
-
-    # Always remove threading
-    if "ZSTD_MULTITHREAD" not in args.undefs:
-        args.undefs.append("ZSTD_MULTITHREAD")
-
-    args.defs = parse_optional_pair(args.defs)
-    for name, _ in args.defs:
-        if name in args.undefs:
-            raise RuntimeError(f"{name} is both defined and undefined!")
-
-    # Always set tracing to 0
-    if "ZSTD_NO_TRACE" not in (arg[0] for arg in args.defs):
-        args.defs.append(("ZSTD_NO_TRACE", None))
-        args.defs.append(("ZSTD_TRACE", "0"))
-
-    args.replaces = parse_pair(args.replaces)
-    for name, _ in args.replaces:
-        if name in args.undefs or name in args.defs:
-            raise RuntimeError(f"{name} is both replaced and (un)defined!")
-
-    args.rewritten_includes = parse_pair(args.rewritten_includes)
-
-    external_xxhash = False
-    if args.xxhash is not None:
-        external_xxhash = True
-        args.rewritten_includes.append(('"(\\.\\./common/)?xxhash.h"', args.xxhash))
-
-    if args.xxh64_prefix is not None:
-        if not external_xxhash:
-            raise RuntimeError("--xxh64-prefix may only be used with --xxhash provided")
-
-    if args.xxh64_state is not None:
-        if not external_xxhash:
-            raise RuntimeError("--xxh64-state may only be used with --xxhash provided")
-
-    Freestanding(
-        args.zstd_deps,
-        args.mem,
-        args.source_lib,
-        args.output_lib,
-        external_xxhash,
-        args.xxh64_state,
-        args.xxh64_prefix,
-        args.rewritten_includes,
-        args.defs,
-        args.replaces,
-        args.undefs,
-        args.excludes,
-        args.seds,
-        args.spdx,
-    ).go()
-
-if __name__ == "__main__":
-    main(sys.argv[0], sys.argv[1:])

contrib/gen_html/Makefile

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2016-present, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the
@@ -40,7 +40,7 @@ gen_html: gen_html.cpp
 
 $(ZSTDMANUAL): gen_html $(ZSTDAPI)
 	echo "Update zstd manual in /doc"
-	./gen_html$(EXT) $(LIBVER) $(ZSTDAPI) $(ZSTDMANUAL)
+	./gen_html $(LIBVER) $(ZSTDAPI) $(ZSTDMANUAL)
 
 .PHONY: manual
 manual: gen_html $(ZSTDMANUAL)

contrib/gen_html/gen_html.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * Copyright (c) 2016-present, Przemyslaw Skibinski, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under both the BSD-style license (found in the
@@ -211,7 +211,6 @@ int main(int argc, char *argv[]) {
 
     ostream << "<html>\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-1\">\n<title>" << version << "</title>\n</head>\n<body>" << endl;
     ostream << "<h1>" << version << "</h1>\n";
-    ostream << "Note: the content of this file has been automatically generated by parsing \"zstd.h\" \n";
 
     ostream << "<hr>\n<a name=\"Contents\"></a><h2>Contents</h2>\n<ol>\n";
     for (size_t i=0; i<chapters.size(); i++)

contrib/largeNbDicts/Makefile

@@ -1,5 +1,5 @@
 # ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Copyright (c) 2018-present, Yann Collet, Facebook, Inc.
 # All rights reserved.
 #
 # This source code is licensed under both the BSD-style license (found in the

contrib/largeNbDicts/README.md

@@ -15,19 +15,11 @@ Command line :
 largeNbDicts [Options] filename(s)
 
 Options :
--z          : benchmark compression (default) 
--d          : benchmark decompression 
 -r           : recursively load all files in subdirectories (default: off)
 -B#          : split input into blocks of size # (default: no split)
 -#           : use compression level # (default: 3)
 -D #         : use # as a dictionary (default: create one)
 -i#          : nb benchmark rounds (default: 6)
---nbBlocks=#: use # blocks for bench (default: one per file) 
---nbDicts=# : create # dictionaries for bench (default: one per block) 
+--nbDicts=#  : set nb of dictionaries to # (default: one per block)
 -h           : help (this text)
- 
-Advanced Options (see zstd.h for documentation) : 
---dedicated-dict-search
---dict-content-type=#
---dict-attach-pref=#
 ```

contrib/largeNbDicts/largeNbDicts.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * Copyright (c) 2018-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under both the BSD-style license (found in the
@@ -19,7 +19,7 @@
 /*---  Dependencies  ---*/
 
 #include <stddef.h>   /* size_t */
-#include <stdlib.h>   /* malloc, free, abort, qsort*/
+#include <stdlib.h>   /* malloc, free, abort */
 #include <stdio.h>    /* fprintf */
 #include <limits.h>   /* UINT_MAX */
 #include <assert.h>   /* assert */
@@ -39,7 +39,6 @@
 #define BLOCKSIZE_DEFAULT 0  /* no slicing into blocks */
 #define DICTSIZE  (4 KB)
 #define CLEVEL_DEFAULT 3
-#define DICT_LOAD_METHOD ZSTD_dlm_byCopy
 
 #define BENCH_TIME_DEFAULT_S   6
 #define RUN_TIME_DEFAULT_MS    1000
@@ -157,6 +156,7 @@ createDictionaryBuffer(const char* dictionaryName,
     }
 }
 
+
 /*! BMK_loadFiles() :
  *  Loads `buffer`, with content from files listed within `fileNamesTable`.
  *  Fills `buffer` entirely.
@@ -449,12 +449,12 @@ static void freeCDictCollection(cdict_collection_t cdictc)
 }
 
 /* returns .buffers=NULL if operation fails */
-static cdict_collection_t createCDictCollection(const void* dictBuffer, size_t dictSize, size_t nbCDict, ZSTD_dictContentType_e dictContentType, ZSTD_CCtx_params* cctxParams)
+static cdict_collection_t createCDictCollection(const void* dictBuffer, size_t dictSize, size_t nbCDict, int cLevel)
 {
     ZSTD_CDict** const cdicts = malloc(nbCDict * sizeof(ZSTD_CDict*));
     if (cdicts==NULL) return kNullCDictCollection;
     for (size_t dictNb=0; dictNb < nbCDict; dictNb++) {
-        cdicts[dictNb] = ZSTD_createCDict_advanced2(dictBuffer, dictSize, DICT_LOAD_METHOD, dictContentType, cctxParams, ZSTD_defaultCMem);
+        cdicts[dictNb] = ZSTD_createCDict(dictBuffer, dictSize, cLevel);
         CONTROL(cdicts[dictNb] != NULL);
     }
     cdict_collection_t cdictc;
@@ -577,13 +577,11 @@ typedef struct {
     cdict_collection_t dictionaries;
 } compressInstructions;
 
-compressInstructions createCompressInstructions(cdict_collection_t dictionaries, ZSTD_CCtx_params* cctxParams)
+compressInstructions createCompressInstructions(cdict_collection_t dictionaries)
 {
     compressInstructions ci;
     ci.cctx = ZSTD_createCCtx();
     CONTROL(ci.cctx != NULL);
-    if (cctxParams)
-      ZSTD_CCtx_setParametersUsingCCtxParams(ci.cctx, cctxParams);
     ci.nbDicts = dictionaries.nbCDict;
     ci.dictNb = 0;
     ci.dictionaries = dictionaries;
@@ -624,10 +622,10 @@ size_t compress(const void* src, size_t srcSize, void* dst, size_t dstCapacity,
     compressInstructions* const ci = (compressInstructions*) payload;
     (void)dstCapacity;
 
-    ZSTD_CCtx_refCDict(ci->cctx, ci->dictionaries.cdicts[ci->dictNb]);
-    ZSTD_compress2(ci->cctx,
+    ZSTD_compress_usingCDict(ci->cctx,
                     dst, srcSize,
-            src, srcSize);
+                    src, srcSize,
+                    ci->dictionaries.cdicts[ci->dictNb]);
 
     ci->dictNb = ci->dictNb + 1;
     if (ci->dictNb >= ci->nbDicts) ci->dictNb = 0;
@@ -651,55 +649,25 @@ size_t decompress(const void* src, size_t srcSize, void* dst, size_t dstCapacity
     return result;
 }
 
-typedef enum {
-  fastest = 0,
-  median = 1,
-} metricAggregatePref_e;
 
-/* compareFunction() :
- * Sort input in decreasing order when used with qsort() */
-int compareFunction(const void *a, const void *b)
-{
-  double x = *(const double *)a;
-  double y = *(const double *)b;
-  if (x < y)
-    return 1;
-  else if (x > y)
-    return -1;
-  return 0;
-}
-
-double aggregateData(double *data, size_t size,
-                     metricAggregatePref_e metricAggregatePref)
-{
-  qsort(data, size, sizeof(*data), compareFunction);
-  if (metricAggregatePref == fastest)
-    return data[0];
-  else /* median */
-    return (data[(size - 1) / 2] + data[size / 2]) / 2;
-}
-
-static int benchMem(slice_collection_t dstBlocks, slice_collection_t srcBlocks,
+static int benchMem(slice_collection_t dstBlocks,
+                    slice_collection_t srcBlocks,
                     ddict_collection_t ddictionaries,
-                    cdict_collection_t cdictionaries, unsigned nbRounds,
-                    int benchCompression, const char *exeName,
-                    ZSTD_CCtx_params *cctxParams,
-                    metricAggregatePref_e metricAggregatePref)
+                    cdict_collection_t cdictionaries,
+                    unsigned nbRounds, int benchCompression)
 {
     assert(dstBlocks.nbSlices == srcBlocks.nbSlices);
-    if (benchCompression) assert(cctxParams);
 
     unsigned const ms_per_round = RUN_TIME_DEFAULT_MS;
     unsigned const total_time_ms = nbRounds * ms_per_round;
 
-    double *const speedPerRound = (double *)malloc(nbRounds * sizeof(double));
+    double bestSpeed = 0.;
 
     BMK_timedFnState_t* const benchState =
             BMK_createTimedFnState(total_time_ms, ms_per_round);
 
     decompressInstructions di = createDecompressInstructions(ddictionaries);
-    compressInstructions ci =
-        createCompressInstructions(cdictionaries, cctxParams);
+    compressInstructions ci = createCompressInstructions(cdictionaries);
     void* payload = benchCompression ? (void*)&ci : (void*)&di;
     BMK_benchParams_t const bp = {
         .benchFn = benchCompression ? compress : decompress,
@@ -715,7 +683,6 @@ static int benchMem(slice_collection_t dstBlocks, slice_collection_t srcBlocks,
         .blockResults = NULL
     };
 
-    size_t roundNb = 0;
     for (;;) {
         BMK_runOutcome_t const outcome = BMK_benchTimedFn(benchState, bp);
         CONTROL(BMK_isSuccessful_runOutcome(outcome));
@@ -725,59 +692,16 @@ static int benchMem(slice_collection_t dstBlocks, slice_collection_t srcBlocks,
         double const dTime_sec = (double)dTime_ns / 1000000000;
         size_t const srcSize = result.sumOfReturn;
         double const speed_MBps = (double)srcSize / dTime_sec / (1 MB);
-        speedPerRound[roundNb] = speed_MBps;
+        if (speed_MBps > bestSpeed) bestSpeed = speed_MBps;
         if (benchCompression)
-            DISPLAY("Compression Speed : %.1f MB/s \r", speed_MBps);
+            DISPLAY("Compression Speed : %.1f MB/s \r", bestSpeed);
         else
-            DISPLAY("Decompression Speed : %.1f MB/s \r", speed_MBps);
+            DISPLAY("Decompression Speed : %.1f MB/s \r", bestSpeed);
 
         fflush(stdout);
         if (BMK_isCompleted_TimedFn(benchState)) break;
-        roundNb++;
     }
     DISPLAY("\n");
-    /* BMK_benchTimedFn may not run exactly nbRounds iterations */
-    double speedAggregated =
-        aggregateData(speedPerRound, roundNb + 1, metricAggregatePref);
-    free(speedPerRound);
-    
-    if (metricAggregatePref == fastest)
-      DISPLAY("Fastest Speed : %.1f MB/s \n", speedAggregated);
-    else
-      DISPLAY("Median Speed : %.1f MB/s \n", speedAggregated);
-
-    char* csvFileName = malloc(strlen(exeName) + 5);
-    strcpy(csvFileName, exeName);
-    strcat(csvFileName, ".csv");
-    FILE* csvFile = fopen(csvFileName, "r");
-    if (!csvFile) {
-        csvFile = fopen(csvFileName, "wt");
-        assert(csvFile);
-        fprintf(csvFile, "%s\n", exeName);
-        /* Print table headers */
-        fprintf(
-            csvFile,
-            "Compression/Decompression,Level,nbDicts,dictAttachPref,metricAggregatePref,Speed\n");
-    } else {
-        fclose(csvFile);
-        csvFile = fopen(csvFileName, "at");
-        assert(csvFile);
-    }
-
-    int cLevel = -1;
-    int dictAttachPref = -1;
-    if (benchCompression) {
-      ZSTD_CCtxParams_getParameter(cctxParams, ZSTD_c_compressionLevel,
-                                   &cLevel);
-      ZSTD_CCtxParams_getParameter(cctxParams, ZSTD_c_forceAttachDict,
-                                   &dictAttachPref);
-    }
-    fprintf(csvFile, "%s,%d,%ld,%d,%d,%.1f\n",
-            benchCompression ? "Compression" : "Decompression", cLevel,
-            benchCompression ? ci.nbDicts : di.nbDicts, dictAttachPref,
-            metricAggregatePref, speedAggregated);
-    fclose(csvFile);
-    free(csvFileName);
 
     freeDecompressInstructions(di);
     freeCompressInstructions(ci);
@@ -792,11 +716,11 @@ static int benchMem(slice_collection_t dstBlocks, slice_collection_t srcBlocks,
  *  dictionary : optional (can be NULL), file to load as dictionary,
  *              if none provided : will be calculated on the fly by the program.
  * @return : 0 is success, 1+ otherwise */
-int bench(const char **fileNameTable, unsigned nbFiles, const char *dictionary,
-          size_t blockSize, int clevel, unsigned nbDictMax, unsigned nbBlocks,
-          unsigned nbRounds, int benchCompression,
-          ZSTD_dictContentType_e dictContentType, ZSTD_CCtx_params *cctxParams,
-          const char *exeName, metricAggregatePref_e metricAggregatePref)
+int bench(const char** fileNameTable, unsigned nbFiles,
+          const char* dictionary,
+          size_t blockSize, int clevel,
+          unsigned nbDictMax, unsigned nbBlocks,
+          unsigned nbRounds, int benchCompression)
 {
     int result = 0;
 
@@ -847,18 +771,18 @@ int bench(const char **fileNameTable, unsigned nbFiles, const char *dictionary,
     /* dictionary determination */
     buffer_t const dictBuffer = createDictionaryBuffer(dictionary,
                                 srcs.buffer.ptr,
-                                srcSlices.capacities, srcSlices.nbSlices,
+                                srcs.slices.capacities, srcs.slices.nbSlices,
                                 DICTSIZE);
     CONTROL(dictBuffer.ptr != NULL);
 
-    ZSTD_CDict* const cdict = ZSTD_createCDict_advanced2(dictBuffer.ptr, dictBuffer.size, DICT_LOAD_METHOD, dictContentType, cctxParams, ZSTD_defaultCMem);
+    ZSTD_CDict* const cdict = ZSTD_createCDict(dictBuffer.ptr, dictBuffer.size, clevel);
     CONTROL(cdict != NULL);
 
     size_t const cTotalSizeNoDict = compressBlocks(NULL, dstSlices, srcSlices, NULL, clevel);
     CONTROL(cTotalSizeNoDict != 0);
     DISPLAYLEVEL(3, "compressing at level %u without dictionary : Ratio=%.2f  (%u bytes) \n",
                     clevel,
-                    (double)totalSrcSlicesSize / (double)cTotalSizeNoDict, (unsigned)cTotalSizeNoDict);
+                    (double)totalSrcSlicesSize / cTotalSizeNoDict, (unsigned)cTotalSizeNoDict);
 
     size_t* const cSizes = malloc(nbBlocks * sizeof(size_t));
     CONTROL(cSizes != NULL);
@@ -867,21 +791,21 @@ int bench(const char **fileNameTable, unsigned nbFiles, const char *dictionary,
     CONTROL(cTotalSize != 0);
     DISPLAYLEVEL(3, "compressed using a %u bytes dictionary : Ratio=%.2f  (%u bytes) \n",
                     (unsigned)dictBuffer.size,
-                    (double)totalSrcSlicesSize / (double)cTotalSize, (unsigned)cTotalSize);
+                    (double)totalSrcSlicesSize / cTotalSize, (unsigned)cTotalSize);
 
     /* now dstSlices contain the real compressed size of each block, instead of the maximum capacity */
     shrinkSizes(dstSlices, cSizes);
 
     unsigned const nbDicts = nbDictMax ? nbDictMax : nbBlocks;
 
-    cdict_collection_t const cdictionaries = createCDictCollection(dictBuffer.ptr, dictBuffer.size, nbDicts, dictContentType, cctxParams);
+    cdict_collection_t const cdictionaries = createCDictCollection(dictBuffer.ptr, dictBuffer.size, nbDicts, clevel);
     CONTROL(cdictionaries.cdicts != NULL);
 
     ddict_collection_t const ddictionaries = createDDictCollection(dictBuffer.ptr, dictBuffer.size, nbDicts);
     CONTROL(ddictionaries.ddicts != NULL);
 
     if (benchCompression) {
-        size_t const dictMem = ZSTD_sizeof_CDict(cdictionaries.cdicts[0]);
+        size_t const dictMem = ZSTD_estimateCDictSize(dictBuffer.size, ZSTD_dlm_byCopy);
         size_t const allDictMem = dictMem * nbDicts;
         DISPLAYLEVEL(3, "generating %u dictionaries, using %.1f MB of memory \n",
                         nbDicts, (double)allDictMem / (1 MB));
@@ -891,13 +815,11 @@ int bench(const char **fileNameTable, unsigned nbFiles, const char *dictionary,
         buffer_collection_t resultCollection = createBufferCollection_fromSliceCollection(srcSlices);
         CONTROL(resultCollection.buffer.ptr != NULL);
 
-        result = benchMem(dstSlices, resultCollection.slices, ddictionaries,
-                          cdictionaries, nbRounds, benchCompression, exeName,
-                          cctxParams, metricAggregatePref);
+        result = benchMem(dstSlices, resultCollection.slices, ddictionaries, cdictionaries, nbRounds, benchCompression);
 
         freeBufferCollection(resultCollection);
     } else {
-        size_t const dictMem = ZSTD_estimateDDictSize(dictBuffer.size, DICT_LOAD_METHOD);
+        size_t const dictMem = ZSTD_estimateDDictSize(dictBuffer.size, ZSTD_dlm_byCopy);
         size_t const allDictMem = dictMem * nbDicts;
         DISPLAYLEVEL(3, "generating %u dictionaries, using %.1f MB of memory \n",
                         nbDicts, (double)allDictMem / (1 MB));
@@ -907,9 +829,7 @@ int bench(const char **fileNameTable, unsigned nbFiles, const char *dictionary,
         buffer_collection_t resultCollection = createBufferCollection_fromSliceCollectionSizes(srcSlices);
         CONTROL(resultCollection.buffer.ptr != NULL);
 
-        result = benchMem(resultCollection.slices, dstSlices, ddictionaries,
-                          cdictionaries, nbRounds, benchCompression, exeName,
-                          NULL, metricAggregatePref);
+        result = benchMem(resultCollection.slices, dstSlices, ddictionaries, cdictionaries, nbRounds, benchCompression);
 
         freeBufferCollection(resultCollection);
     }
@@ -987,15 +907,9 @@ int usage(const char* exeName)
     DISPLAY ("-#          : use compression level # (default: %u) \n", CLEVEL_DEFAULT);
     DISPLAY ("-D #        : use # as a dictionary (default: create one) \n");
     DISPLAY ("-i#         : nb benchmark rounds (default: %u) \n", BENCH_TIME_DEFAULT_S);
-    DISPLAY ("-p#         : print speed for all rounds 0=fastest 1=median (default: 0) \n");
     DISPLAY ("--nbBlocks=#: use # blocks for bench (default: one per file) \n");
     DISPLAY ("--nbDicts=# : create # dictionaries for bench (default: one per block) \n");
     DISPLAY ("-h          : help (this text) \n");
-    DISPLAY (" \n");
-    DISPLAY ("Advanced Options (see zstd.h for documentation) : \n");
-    DISPLAY ("--dedicated-dict-search\n");
-    DISPLAY ("--dict-content-type=#\n");
-    DISPLAY ("--dict-attach-pref=#\n");
     return 0;
 }
 
@@ -1010,7 +924,6 @@ int main (int argc, const char** argv)
 {
     int recursiveMode = 0;
     int benchCompression = 1;
-    int dedicatedDictSearch = 0;
     unsigned nbRounds = BENCH_TIME_DEFAULT_S;
     const char* const exeName = argv[0];
 
@@ -1025,10 +938,6 @@ int main (int argc, const char** argv)
     size_t blockSize = BLOCKSIZE_DEFAULT;
     unsigned nbDicts = 0;  /* determine nbDicts automatically: 1 dictionary per block */
     unsigned nbBlocks = 0; /* determine nbBlocks automatically, from source and blockSize */
-    ZSTD_dictContentType_e dictContentType = ZSTD_dct_auto;
-    ZSTD_dictAttachPref_e dictAttachPref = ZSTD_dictDefaultAttach;
-    ZSTD_ParamSwitch_e prefetchCDictTables = ZSTD_ps_auto;
-    metricAggregatePref_e metricAggregatePref = fastest;
 
     for (int argNb = 1; argNb < argc ; argNb++) {
         const char* argument = argv[argNb];
@@ -1038,17 +947,12 @@ int main (int argc, const char** argv)
         if (!strcmp(argument, "-r")) { recursiveMode = 1; continue; }
         if (!strcmp(argument, "-D")) { argNb++; assert(argNb < argc); dictionary = argv[argNb]; continue; }
         if (longCommandWArg(&argument, "-i")) { nbRounds = readU32FromChar(&argument); continue; }
-        if (longCommandWArg(&argument, "-p")) { metricAggregatePref = (int)readU32FromChar(&argument); continue;}
         if (longCommandWArg(&argument, "--dictionary=")) { dictionary = argument; continue; }
         if (longCommandWArg(&argument, "-B")) { blockSize = readU32FromChar(&argument); continue; }
         if (longCommandWArg(&argument, "--blockSize=")) { blockSize = readU32FromChar(&argument); continue; }
         if (longCommandWArg(&argument, "--nbDicts=")) { nbDicts = readU32FromChar(&argument); continue; }
         if (longCommandWArg(&argument, "--nbBlocks=")) { nbBlocks = readU32FromChar(&argument); continue; }
         if (longCommandWArg(&argument, "--clevel=")) { cLevel = (int)readU32FromChar(&argument); continue; }
-        if (longCommandWArg(&argument, "--dedicated-dict-search")) { dedicatedDictSearch = 1; continue; }
-        if (longCommandWArg(&argument, "--dict-content-type=")) { dictContentType = (int)readU32FromChar(&argument); continue; }
-        if (longCommandWArg(&argument, "--dict-attach-pref=")) { dictAttachPref = (int)readU32FromChar(&argument); continue; }
-        if (longCommandWArg(&argument, "--prefetch-cdict-tables=")) { prefetchCDictTables = (int)readU32FromChar(&argument); continue; }
         if (longCommandWArg(&argument, "-")) { cLevel = (int)readU32FromChar(&argument); continue; }
         /* anything that's not a command is a filename */
         nameTable[nameIdx++] = argument;
@@ -1066,22 +970,10 @@ int main (int argc, const char** argv)
         nameTable = NULL;  /* UTIL_createFileNamesTable() takes ownership of nameTable */
     }
 
-    ZSTD_CCtx_params* cctxParams = ZSTD_createCCtxParams();
-    ZSTD_CCtxParams_init(cctxParams, cLevel);
-    ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_enableDedicatedDictSearch, dedicatedDictSearch);
-    ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_nbWorkers, 0);
-    ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_forceAttachDict, dictAttachPref);
-    ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_prefetchCDictTables, prefetchCDictTables);
-
-    int result =
-        bench(filenameTable->fileNames, (unsigned)filenameTable->tableSize,
-              dictionary, blockSize, cLevel, nbDicts, nbBlocks, nbRounds,
-              benchCompression, dictContentType, cctxParams, exeName,
-              metricAggregatePref);
+    int result = bench(filenameTable->fileNames, (unsigned)filenameTable->tableSize, dictionary, blockSize, cLevel, nbDicts, nbBlocks, nbRounds, benchCompression);
 
     UTIL_freeFileNamesTable(filenameTable);
     free(nameTable);
-    ZSTD_freeCCtxParams(cctxParams);
 
     return result;
 }

contrib/linux-kernel/0000-cover-letter.patch

@@ -0,0 +1,122 @@
+From 308795a7713ca6fcd468b60fba9a2fca99cee6a0 Mon Sep 17 00:00:00 2001
+From: Nick Terrell <terrelln@fb.com>
+Date: Tue, 8 Aug 2017 19:20:25 -0700
+Subject: [PATCH v5 0/5] Add xxhash and zstd modules
+
+Hi all,
+
+This patch set adds xxhash, zstd compression, and zstd decompression
+modules. It also adds zstd support to BtrFS and SquashFS.
+
+Each patch has relevant summaries, benchmarks, and tests.
+
+Best,
+Nick Terrell
+
+Changelog:
+
+v1 -> v2:
+- Make pointer in lib/xxhash.c:394 non-const (1/5)
+- Use div_u64() for division of u64s (2/5)
+- Reduce stack usage of ZSTD_compressSequences(), ZSTD_buildSeqTable(),
+  ZSTD_decompressSequencesLong(), FSE_buildDTable(), FSE_decompress_wksp(),
+  HUF_writeCTable(), HUF_readStats(), HUF_readCTable(),
+  HUF_compressWeights(), HUF_readDTableX2(), and HUF_readDTableX4() (2/5)
+- No zstd function uses more than 400 B of stack space (2/5)
+
+v2 -> v3:
+- Work around gcc-7 bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81388
+  (2/5)
+- Fix bug in dictionary compression from upstream commit cc1522351f (2/5)
+- Port upstream BtrFS commits e1ddce71d6, 389a6cfc2a, and 6acafd1eff (3/5)
+- Change default compression level for BtrFS to 3 (3/5)
+
+v3 -> v4:
+- Fix compiler warnings (2/5)
+- Add missing includes (3/5)
+- Fix minor linter warnings (3/5, 4/5)
+- Add crypto patch (5/5)
+
+v4 -> v5:
+- Fix rare compression bug from upstream commit 308047eb5d (2/5)
+- Fix bug introduced in v3 when working around the gcc-7 bug (2/5)
+- Fix ZSTD_DStream initialization code in squashfs (4/5)
+- Fix patch documentation for patches written by Sean Purcell (4/5)
+
+Nick Terrell (5):
+  lib: Add xxhash module
+  lib: Add zstd modules
+  btrfs: Add zstd support
+  squashfs: Add zstd support
+  crypto: Add zstd support
+
+ crypto/Kconfig             |    9 +
+ crypto/Makefile            |    1 +
+ crypto/testmgr.c           |   10 +
+ crypto/testmgr.h           |   71 +
+ crypto/zstd.c              |  265 ++++
+ fs/btrfs/Kconfig           |    2 +
+ fs/btrfs/Makefile          |    2 +-
+ fs/btrfs/compression.c     |    1 +
+ fs/btrfs/compression.h     |    6 +-
+ fs/btrfs/ctree.h           |    1 +
+ fs/btrfs/disk-io.c         |    2 +
+ fs/btrfs/ioctl.c           |    6 +-
+ fs/btrfs/props.c           |    6 +
+ fs/btrfs/super.c           |   12 +-
+ fs/btrfs/sysfs.c           |    2 +
+ fs/btrfs/zstd.c            |  432 ++++++
+ fs/squashfs/Kconfig        |   14 +
+ fs/squashfs/Makefile       |    1 +
+ fs/squashfs/decompressor.c |    7 +
+ fs/squashfs/decompressor.h |    4 +
+ fs/squashfs/squashfs_fs.h  |    1 +
+ fs/squashfs/zstd_wrapper.c |  151 ++
+ include/linux/xxhash.h     |  236 +++
+ include/linux/zstd.h       | 1157 +++++++++++++++
+ include/uapi/linux/btrfs.h |    8 +-
+ lib/Kconfig                |   11 +
+ lib/Makefile               |    3 +
+ lib/xxhash.c               |  500 +++++++
+ lib/zstd/Makefile          |   18 +
+ lib/zstd/bitstream.h       |  374 +++++
+ lib/zstd/compress.c        | 3484 ++++++++++++++++++++++++++++++++++++++++++++
+ lib/zstd/decompress.c      | 2528 ++++++++++++++++++++++++++++++++
+ lib/zstd/entropy_common.c  |  243 +++
+ lib/zstd/error_private.h   |   53 +
+ lib/zstd/fse.h             |  575 ++++++++
+ lib/zstd/fse_compress.c    |  795 ++++++++++
+ lib/zstd/fse_decompress.c  |  332 +++++
+ lib/zstd/huf.h             |  212 +++
+ lib/zstd/huf_compress.c    |  770 ++++++++++
+ lib/zstd/huf_decompress.c  |  960 ++++++++++++
+ lib/zstd/mem.h             |  151 ++
+ lib/zstd/zstd_common.c     |   75 +
+ lib/zstd/zstd_internal.h   |  263 ++++
+ lib/zstd/zstd_opt.h        | 1014 +++++++++++++
+ 44 files changed, 14756 insertions(+), 12 deletions(-)
+ create mode 100644 crypto/zstd.c
+ create mode 100644 fs/btrfs/zstd.c
+ create mode 100644 fs/squashfs/zstd_wrapper.c
+ create mode 100644 include/linux/xxhash.h
+ create mode 100644 include/linux/zstd.h
+ create mode 100644 lib/xxhash.c
+ create mode 100644 lib/zstd/Makefile
+ create mode 100644 lib/zstd/bitstream.h
+ create mode 100644 lib/zstd/compress.c
+ create mode 100644 lib/zstd/decompress.c
+ create mode 100644 lib/zstd/entropy_common.c
+ create mode 100644 lib/zstd/error_private.h
+ create mode 100644 lib/zstd/fse.h
+ create mode 100644 lib/zstd/fse_compress.c
+ create mode 100644 lib/zstd/fse_decompress.c
+ create mode 100644 lib/zstd/huf.h
+ create mode 100644 lib/zstd/huf_compress.c
+ create mode 100644 lib/zstd/huf_decompress.c
+ create mode 100644 lib/zstd/mem.h
+ create mode 100644 lib/zstd/zstd_common.c
+ create mode 100644 lib/zstd/zstd_internal.h
+ create mode 100644 lib/zstd/zstd_opt.h
+
+--
+2.9.3

contrib/linux-kernel/0001-lib-Add-xxhash-module.patch

@@ -0,0 +1,862 @@
+From a4b1ffb6e89bbccd519f9afa0910635668436105 Mon Sep 17 00:00:00 2001
+From: Nick Terrell <terrelln@fb.com>
+Date: Mon, 17 Jul 2017 17:07:18 -0700
+Subject: [PATCH v5 1/5] lib: Add xxhash module
+
+Adds xxhash kernel module with xxh32 and xxh64 hashes. xxhash is an
+extremely fast non-cryptographic hash algorithm for checksumming.
+The zstd compression and decompression modules added in the next patch
+require xxhash. I extracted it out from zstd since it is useful on its
+own. I copied the code from the upstream XXHash source repository and
+translated it into kernel style. I ran benchmarks and tests in the kernel
+and tests in userland.
+
+I benchmarked xxhash as a special character device. I ran in four modes,
+no-op, xxh32, xxh64, and crc32. The no-op mode simply copies the data to
+kernel space and ignores it. The xxh32, xxh64, and crc32 modes compute
+hashes on the copied data. I also ran it with four different buffer sizes.
+The benchmark file is located in the upstream zstd source repository under
+`contrib/linux-kernel/xxhash_test.c` [1].
+
+I ran the benchmarks on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.
+The VM is running on a MacBook Pro with a 3.1 GHz Intel Core i7 processor,
+16 GB of RAM, and a SSD. I benchmarked using the file `filesystem.squashfs`
+from `ubuntu-16.10-desktop-amd64.iso`, which is 1,536,217,088 B large.
+Run the following commands for the benchmark:
+
+    modprobe xxhash_test
+    mknod xxhash_test c 245 0
+    time cp filesystem.squashfs xxhash_test
+
+The time is reported by the time of the userland `cp`.
+The GB/s is computed with
+
+    1,536,217,008 B / time(buffer size, hash)
+
+which includes the time to copy from userland.
+The Normalized GB/s is computed with
+
+    1,536,217,088 B / (time(buffer size, hash) - time(buffer size, none)).
+
+
+| Buffer Size (B) | Hash  | Time (s) | GB/s | Adjusted GB/s |
+|-----------------|-------|----------|------|---------------|
+|            1024 | none  |    0.408 | 3.77 |             - |
+|            1024 | xxh32 |    0.649 | 2.37 |          6.37 |
+|            1024 | xxh64 |    0.542 | 2.83 |         11.46 |
+|            1024 | crc32 |    1.290 | 1.19 |          1.74 |
+|            4096 | none  |    0.380 | 4.04 |             - |
+|            4096 | xxh32 |    0.645 | 2.38 |          5.79 |
+|            4096 | xxh64 |    0.500 | 3.07 |         12.80 |
+|            4096 | crc32 |    1.168 | 1.32 |          1.95 |
+|            8192 | none  |    0.351 | 4.38 |             - |
+|            8192 | xxh32 |    0.614 | 2.50 |          5.84 |
+|            8192 | xxh64 |    0.464 | 3.31 |         13.60 |
+|            8192 | crc32 |    1.163 | 1.32 |          1.89 |
+|           16384 | none  |    0.346 | 4.43 |             - |
+|           16384 | xxh32 |    0.590 | 2.60 |          6.30 |
+|           16384 | xxh64 |    0.466 | 3.30 |         12.80 |
+|           16384 | crc32 |    1.183 | 1.30 |          1.84 |
+
+Tested in userland using the test-suite in the zstd repo under
+`contrib/linux-kernel/test/XXHashUserlandTest.cpp` [2] by mocking the
+kernel functions. A line in each branch of every function in `xxhash.c`
+was commented out to ensure that the test-suite fails. Additionally
+tested while testing zstd and with SMHasher [3].
+
+[1] https://phabricator.intern.facebook.com/P57526246
+[2] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/test/XXHashUserlandTest.cpp
+[3] https://github.com/aappleby/smhasher
+
+zstd source repository: https://github.com/facebook/zstd
+XXHash source repository: https://github.com/cyan4973/xxhash
+
+Signed-off-by: Nick Terrell <terrelln@fb.com>
+---
+v1 -> v2:
+- Make pointer in lib/xxhash.c:394 non-const
+
+ include/linux/xxhash.h | 236 +++++++++++++++++++++++
+ lib/Kconfig            |   3 +
+ lib/Makefile           |   1 +
+ lib/xxhash.c           | 500 +++++++++++++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 740 insertions(+)
+ create mode 100644 include/linux/xxhash.h
+ create mode 100644 lib/xxhash.c
+
+diff --git a/include/linux/xxhash.h b/include/linux/xxhash.h
+new file mode 100644
+index 0000000..9e1f42c
+--- /dev/null
++++ b/include/linux/xxhash.h
+@@ -0,0 +1,236 @@
++/*
++ * xxHash - Extremely Fast Hash algorithm
++ * Copyright (C) 2012-2016, Yann Collet.
++ *
++ * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are
++ * met:
++ *
++ *   * Redistributions of source code must retain the above copyright
++ *     notice, this list of conditions and the following disclaimer.
++ *   * Redistributions in binary form must reproduce the above
++ *     copyright notice, this list of conditions and the following disclaimer
++ *     in the documentation and/or other materials provided with the
++ *     distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
++ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
++ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
++ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ * This program is free software; you can redistribute it and/or modify it under
++ * the terms of the GNU General Public License version 2 as published by the
++ * Free Software Foundation. This program is dual-licensed; you may select
++ * either version 2 of the GNU General Public License ("GPL") or BSD license
++ * ("BSD").
++ *
++ * You can contact the author at:
++ * - xxHash homepage: http://cyan4973.github.io/xxHash/
++ * - xxHash source repository: https://github.com/Cyan4973/xxHash
++ */
++
++/*
++ * Notice extracted from xxHash homepage:
++ *
++ * xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
++ * It also successfully passes all tests from the SMHasher suite.
++ *
++ * Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2
++ * Duo @3GHz)
++ *
++ * Name            Speed       Q.Score   Author
++ * xxHash          5.4 GB/s     10
++ * CrapWow         3.2 GB/s      2       Andrew
++ * MumurHash 3a    2.7 GB/s     10       Austin Appleby
++ * SpookyHash      2.0 GB/s     10       Bob Jenkins
++ * SBox            1.4 GB/s      9       Bret Mulvey
++ * Lookup3         1.2 GB/s      9       Bob Jenkins
++ * SuperFastHash   1.2 GB/s      1       Paul Hsieh
++ * CityHash64      1.05 GB/s    10       Pike & Alakuijala
++ * FNV             0.55 GB/s     5       Fowler, Noll, Vo
++ * CRC32           0.43 GB/s     9
++ * MD5-32          0.33 GB/s    10       Ronald L. Rivest
++ * SHA1-32         0.28 GB/s    10
++ *
++ * Q.Score is a measure of quality of the hash function.
++ * It depends on successfully passing SMHasher test set.
++ * 10 is a perfect score.
++ *
++ * A 64-bits version, named xxh64 offers much better speed,
++ * but for 64-bits applications only.
++ * Name     Speed on 64 bits    Speed on 32 bits
++ * xxh64       13.8 GB/s            1.9 GB/s
++ * xxh32        6.8 GB/s            6.0 GB/s
++ */
++
++#ifndef XXHASH_H
++#define XXHASH_H
++
++#include <linux/types.h>
++
++/*-****************************
++ * Simple Hash Functions
++ *****************************/
++
++/**
++ * xxh32() - calculate the 32-bit hash of the input with a given seed.
++ *
++ * @input:  The data to hash.
++ * @length: The length of the data to hash.
++ * @seed:   The seed can be used to alter the result predictably.
++ *
++ * Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
++ *
++ * Return:  The 32-bit hash of the data.
++ */
++uint32_t xxh32(const void *input, size_t length, uint32_t seed);
++
++/**
++ * xxh64() - calculate the 64-bit hash of the input with a given seed.
++ *
++ * @input:  The data to hash.
++ * @length: The length of the data to hash.
++ * @seed:   The seed can be used to alter the result predictably.
++ *
++ * This function runs 2x faster on 64-bit systems, but slower on 32-bit systems.
++ *
++ * Return:  The 64-bit hash of the data.
++ */
++uint64_t xxh64(const void *input, size_t length, uint64_t seed);
++
++/*-****************************
++ * Streaming Hash Functions
++ *****************************/
++
++/*
++ * These definitions are only meant to allow allocation of XXH state
++ * statically, on stack, or in a struct for example.
++ * Do not use members directly.
++ */
++
++/**
++ * struct xxh32_state - private xxh32 state, do not use members directly
++ */
++struct xxh32_state {
++	uint32_t total_len_32;
++	uint32_t large_len;
++	uint32_t v1;
++	uint32_t v2;
++	uint32_t v3;
++	uint32_t v4;
++	uint32_t mem32[4];
++	uint32_t memsize;
++};
++
++/**
++ * struct xxh32_state - private xxh64 state, do not use members directly
++ */
++struct xxh64_state {
++	uint64_t total_len;
++	uint64_t v1;
++	uint64_t v2;
++	uint64_t v3;
++	uint64_t v4;
++	uint64_t mem64[4];
++	uint32_t memsize;
++};
++
++/**
++ * xxh32_reset() - reset the xxh32 state to start a new hashing operation
++ *
++ * @state: The xxh32 state to reset.
++ * @seed:  Initialize the hash state with this seed.
++ *
++ * Call this function on any xxh32_state to prepare for a new hashing operation.
++ */
++void xxh32_reset(struct xxh32_state *state, uint32_t seed);
++
++/**
++ * xxh32_update() - hash the data given and update the xxh32 state
++ *
++ * @state:  The xxh32 state to update.
++ * @input:  The data to hash.
++ * @length: The length of the data to hash.
++ *
++ * After calling xxh32_reset() call xxh32_update() as many times as necessary.
++ *
++ * Return:  Zero on success, otherwise an error code.
++ */
++int xxh32_update(struct xxh32_state *state, const void *input, size_t length);
++
++/**
++ * xxh32_digest() - produce the current xxh32 hash
++ *
++ * @state: Produce the current xxh32 hash of this state.
++ *
++ * A hash value can be produced at any time. It is still possible to continue
++ * inserting input into the hash state after a call to xxh32_digest(), and
++ * generate new hashes later on, by calling xxh32_digest() again.
++ *
++ * Return: The xxh32 hash stored in the state.
++ */
++uint32_t xxh32_digest(const struct xxh32_state *state);
++
++/**
++ * xxh64_reset() - reset the xxh64 state to start a new hashing operation
++ *
++ * @state: The xxh64 state to reset.
++ * @seed:  Initialize the hash state with this seed.
++ */
++void xxh64_reset(struct xxh64_state *state, uint64_t seed);
++
++/**
++ * xxh64_update() - hash the data given and update the xxh64 state
++ * @state:  The xxh64 state to update.
++ * @input:  The data to hash.
++ * @length: The length of the data to hash.
++ *
++ * After calling xxh64_reset() call xxh64_update() as many times as necessary.
++ *
++ * Return:  Zero on success, otherwise an error code.
++ */
++int xxh64_update(struct xxh64_state *state, const void *input, size_t length);
++
++/**
++ * xxh64_digest() - produce the current xxh64 hash
++ *
++ * @state: Produce the current xxh64 hash of this state.
++ *
++ * A hash value can be produced at any time. It is still possible to continue
++ * inserting input into the hash state after a call to xxh64_digest(), and
++ * generate new hashes later on, by calling xxh64_digest() again.
++ *
++ * Return: The xxh64 hash stored in the state.
++ */
++uint64_t xxh64_digest(const struct xxh64_state *state);
++
++/*-**************************
++ * Utils
++ ***************************/
++
++/**
++ * xxh32_copy_state() - copy the source state into the destination state
++ *
++ * @src: The source xxh32 state.
++ * @dst: The destination xxh32 state.
++ */
++void xxh32_copy_state(struct xxh32_state *dst, const struct xxh32_state *src);
++
++/**
++ * xxh64_copy_state() - copy the source state into the destination state
++ *
++ * @src: The source xxh64 state.
++ * @dst: The destination xxh64 state.
++ */
++void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state *src);
++
++#endif /* XXHASH_H */
+diff --git a/lib/Kconfig b/lib/Kconfig
+index 6762529..5e7541f 100644
+--- a/lib/Kconfig
++++ b/lib/Kconfig
+@@ -192,6 +192,9 @@ config CRC8
+ 	  when they need to do cyclic redundancy check according CRC8
+ 	  algorithm. Module will be called crc8.
+
++config XXHASH
++	tristate
++
+ config AUDIT_GENERIC
+ 	bool
+ 	depends on AUDIT && !AUDIT_ARCH
+diff --git a/lib/Makefile b/lib/Makefile
+index 40c1837..d06b68a 100644
+--- a/lib/Makefile
++++ b/lib/Makefile
+@@ -102,6 +102,7 @@ obj-$(CONFIG_CRC4)	+= crc4.o
+ obj-$(CONFIG_CRC7)	+= crc7.o
+ obj-$(CONFIG_LIBCRC32C)	+= libcrc32c.o
+ obj-$(CONFIG_CRC8)	+= crc8.o
++obj-$(CONFIG_XXHASH)	+= xxhash.o
+ obj-$(CONFIG_GENERIC_ALLOCATOR) += genalloc.o
+
+ obj-$(CONFIG_842_COMPRESS) += 842/
+diff --git a/lib/xxhash.c b/lib/xxhash.c
+new file mode 100644
+index 0000000..aa61e2a
+--- /dev/null
++++ b/lib/xxhash.c
+@@ -0,0 +1,500 @@
++/*
++ * xxHash - Extremely Fast Hash algorithm
++ * Copyright (C) 2012-2016, Yann Collet.
++ *
++ * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions are
++ * met:
++ *
++ *   * Redistributions of source code must retain the above copyright
++ *     notice, this list of conditions and the following disclaimer.
++ *   * Redistributions in binary form must reproduce the above
++ *     copyright notice, this list of conditions and the following disclaimer
++ *     in the documentation and/or other materials provided with the
++ *     distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
++ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
++ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
++ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
++ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++ *
++ * This program is free software; you can redistribute it and/or modify it under
++ * the terms of the GNU General Public License version 2 as published by the
++ * Free Software Foundation. This program is dual-licensed; you may select
++ * either version 2 of the GNU General Public License ("GPL") or BSD license
++ * ("BSD").
++ *
++ * You can contact the author at:
++ * - xxHash homepage: http://cyan4973.github.io/xxHash/
++ * - xxHash source repository: https://github.com/Cyan4973/xxHash
++ */
++
++#include <asm/unaligned.h>
++#include <linux/errno.h>
++#include <linux/compiler.h>
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/string.h>
++#include <linux/xxhash.h>
++
++/*-*************************************
++ * Macros
++ **************************************/
++#define xxh_rotl32(x, r) ((x << r) | (x >> (32 - r)))
++#define xxh_rotl64(x, r) ((x << r) | (x >> (64 - r)))
++
++#ifdef __LITTLE_ENDIAN
++# define XXH_CPU_LITTLE_ENDIAN 1
++#else
++# define XXH_CPU_LITTLE_ENDIAN 0
++#endif
++
++/*-*************************************
++ * Constants
++ **************************************/
++static const uint32_t PRIME32_1 = 2654435761U;
++static const uint32_t PRIME32_2 = 2246822519U;
++static const uint32_t PRIME32_3 = 3266489917U;
++static const uint32_t PRIME32_4 =  668265263U;
++static const uint32_t PRIME32_5 =  374761393U;
++
++static const uint64_t PRIME64_1 = 11400714785074694791ULL;
++static const uint64_t PRIME64_2 = 14029467366897019727ULL;
++static const uint64_t PRIME64_3 =  1609587929392839161ULL;
++static const uint64_t PRIME64_4 =  9650029242287828579ULL;
++static const uint64_t PRIME64_5 =  2870177450012600261ULL;
++
++/*-**************************
++ *  Utils
++ ***************************/
++void xxh32_copy_state(struct xxh32_state *dst, const struct xxh32_state *src)
++{
++	memcpy(dst, src, sizeof(*dst));
++}
++EXPORT_SYMBOL(xxh32_copy_state);
++
++void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state *src)
++{
++	memcpy(dst, src, sizeof(*dst));
++}
++EXPORT_SYMBOL(xxh64_copy_state);
++
++/*-***************************
++ * Simple Hash Functions
++ ****************************/
++static uint32_t xxh32_round(uint32_t seed, const uint32_t input)
++{
++	seed += input * PRIME32_2;
++	seed = xxh_rotl32(seed, 13);
++	seed *= PRIME32_1;
++	return seed;
++}
++
++uint32_t xxh32(const void *input, const size_t len, const uint32_t seed)
++{
++	const uint8_t *p = (const uint8_t *)input;
++	const uint8_t *b_end = p + len;
++	uint32_t h32;
++
++	if (len >= 16) {
++		const uint8_t *const limit = b_end - 16;
++		uint32_t v1 = seed + PRIME32_1 + PRIME32_2;
++		uint32_t v2 = seed + PRIME32_2;
++		uint32_t v3 = seed + 0;
++		uint32_t v4 = seed - PRIME32_1;
++
++		do {
++			v1 = xxh32_round(v1, get_unaligned_le32(p));
++			p += 4;
++			v2 = xxh32_round(v2, get_unaligned_le32(p));
++			p += 4;
++			v3 = xxh32_round(v3, get_unaligned_le32(p));
++			p += 4;
++			v4 = xxh32_round(v4, get_unaligned_le32(p));
++			p += 4;
++		} while (p <= limit);
++
++		h32 = xxh_rotl32(v1, 1) + xxh_rotl32(v2, 7) +
++			xxh_rotl32(v3, 12) + xxh_rotl32(v4, 18);
++	} else {
++		h32 = seed + PRIME32_5;
++	}
++
++	h32 += (uint32_t)len;
++
++	while (p + 4 <= b_end) {
++		h32 += get_unaligned_le32(p) * PRIME32_3;
++		h32 = xxh_rotl32(h32, 17) * PRIME32_4;
++		p += 4;
++	}
++
++	while (p < b_end) {
++		h32 += (*p) * PRIME32_5;
++		h32 = xxh_rotl32(h32, 11) * PRIME32_1;
++		p++;
++	}
++
++	h32 ^= h32 >> 15;
++	h32 *= PRIME32_2;
++	h32 ^= h32 >> 13;
++	h32 *= PRIME32_3;
++	h32 ^= h32 >> 16;
++
++	return h32;
++}
++EXPORT_SYMBOL(xxh32);
++
++static uint64_t xxh64_round(uint64_t acc, const uint64_t input)
++{
++	acc += input * PRIME64_2;
++	acc = xxh_rotl64(acc, 31);
++	acc *= PRIME64_1;
++	return acc;
++}
++
++static uint64_t xxh64_merge_round(uint64_t acc, uint64_t val)
++{
++	val = xxh64_round(0, val);
++	acc ^= val;
++	acc = acc * PRIME64_1 + PRIME64_4;
++	return acc;
++}
++
++uint64_t xxh64(const void *input, const size_t len, const uint64_t seed)
++{
++	const uint8_t *p = (const uint8_t *)input;
++	const uint8_t *const b_end = p + len;
++	uint64_t h64;
++
++	if (len >= 32) {
++		const uint8_t *const limit = b_end - 32;
++		uint64_t v1 = seed + PRIME64_1 + PRIME64_2;
++		uint64_t v2 = seed + PRIME64_2;
++		uint64_t v3 = seed + 0;
++		uint64_t v4 = seed - PRIME64_1;
++
++		do {
++			v1 = xxh64_round(v1, get_unaligned_le64(p));
++			p += 8;
++			v2 = xxh64_round(v2, get_unaligned_le64(p));
++			p += 8;
++			v3 = xxh64_round(v3, get_unaligned_le64(p));
++			p += 8;
++			v4 = xxh64_round(v4, get_unaligned_le64(p));
++			p += 8;
++		} while (p <= limit);
++
++		h64 = xxh_rotl64(v1, 1) + xxh_rotl64(v2, 7) +
++			xxh_rotl64(v3, 12) + xxh_rotl64(v4, 18);
++		h64 = xxh64_merge_round(h64, v1);
++		h64 = xxh64_merge_round(h64, v2);
++		h64 = xxh64_merge_round(h64, v3);
++		h64 = xxh64_merge_round(h64, v4);
++
++	} else {
++		h64  = seed + PRIME64_5;
++	}
++
++	h64 += (uint64_t)len;
++
++	while (p + 8 <= b_end) {
++		const uint64_t k1 = xxh64_round(0, get_unaligned_le64(p));
++
++		h64 ^= k1;
++		h64 = xxh_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;
++		p += 8;
++	}
++
++	if (p + 4 <= b_end) {
++		h64 ^= (uint64_t)(get_unaligned_le32(p)) * PRIME64_1;
++		h64 = xxh_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
++		p += 4;
++	}
++
++	while (p < b_end) {
++		h64 ^= (*p) * PRIME64_5;
++		h64 = xxh_rotl64(h64, 11) * PRIME64_1;
++		p++;
++	}
++
++	h64 ^= h64 >> 33;
++	h64 *= PRIME64_2;
++	h64 ^= h64 >> 29;
++	h64 *= PRIME64_3;
++	h64 ^= h64 >> 32;
++
++	return h64;
++}
++EXPORT_SYMBOL(xxh64);
++
++/*-**************************************************
++ * Advanced Hash Functions
++ ***************************************************/
++void xxh32_reset(struct xxh32_state *statePtr, const uint32_t seed)
++{
++	/* use a local state for memcpy() to avoid strict-aliasing warnings */
++	struct xxh32_state state;
++
++	memset(&state, 0, sizeof(state));
++	state.v1 = seed + PRIME32_1 + PRIME32_2;
++	state.v2 = seed + PRIME32_2;
++	state.v3 = seed + 0;
++	state.v4 = seed - PRIME32_1;
++	memcpy(statePtr, &state, sizeof(state));
++}
++EXPORT_SYMBOL(xxh32_reset);
++
++void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed)
++{
++	/* use a local state for memcpy() to avoid strict-aliasing warnings */
++	struct xxh64_state state;
++
++	memset(&state, 0, sizeof(state));
++	state.v1 = seed + PRIME64_1 + PRIME64_2;
++	state.v2 = seed + PRIME64_2;
++	state.v3 = seed + 0;
++	state.v4 = seed - PRIME64_1;
++	memcpy(statePtr, &state, sizeof(state));
++}
++EXPORT_SYMBOL(xxh64_reset);
++
++int xxh32_update(struct xxh32_state *state, const void *input, const size_t len)
++{
++	const uint8_t *p = (const uint8_t *)input;
++	const uint8_t *const b_end = p + len;
++
++	if (input == NULL)
++		return -EINVAL;
++
++	state->total_len_32 += (uint32_t)len;
++	state->large_len |= (len >= 16) | (state->total_len_32 >= 16);
++
++	if (state->memsize + len < 16) { /* fill in tmp buffer */
++		memcpy((uint8_t *)(state->mem32) + state->memsize, input, len);
++		state->memsize += (uint32_t)len;
++		return 0;
++	}
++
++	if (state->memsize) { /* some data left from previous update */
++		const uint32_t *p32 = state->mem32;
++
++		memcpy((uint8_t *)(state->mem32) + state->memsize, input,
++			16 - state->memsize);
++
++		state->v1 = xxh32_round(state->v1, get_unaligned_le32(p32));
++		p32++;
++		state->v2 = xxh32_round(state->v2, get_unaligned_le32(p32));
++		p32++;
++		state->v3 = xxh32_round(state->v3, get_unaligned_le32(p32));
++		p32++;
++		state->v4 = xxh32_round(state->v4, get_unaligned_le32(p32));
++		p32++;
++
++		p += 16-state->memsize;
++		state->memsize = 0;
++	}
++
++	if (p <= b_end - 16) {
++		const uint8_t *const limit = b_end - 16;
++		uint32_t v1 = state->v1;
++		uint32_t v2 = state->v2;
++		uint32_t v3 = state->v3;
++		uint32_t v4 = state->v4;
++
++		do {
++			v1 = xxh32_round(v1, get_unaligned_le32(p));
++			p += 4;
++			v2 = xxh32_round(v2, get_unaligned_le32(p));
++			p += 4;
++			v3 = xxh32_round(v3, get_unaligned_le32(p));
++			p += 4;
++			v4 = xxh32_round(v4, get_unaligned_le32(p));
++			p += 4;
++		} while (p <= limit);
++
++		state->v1 = v1;
++		state->v2 = v2;
++		state->v3 = v3;
++		state->v4 = v4;
++	}
++
++	if (p < b_end) {
++		memcpy(state->mem32, p, (size_t)(b_end-p));
++		state->memsize = (uint32_t)(b_end-p);
++	}
++
++	return 0;
++}
++EXPORT_SYMBOL(xxh32_update);
++
++uint32_t xxh32_digest(const struct xxh32_state *state)
++{
++	const uint8_t *p = (const uint8_t *)state->mem32;
++	const uint8_t *const b_end = (const uint8_t *)(state->mem32) +
++		state->memsize;
++	uint32_t h32;
++
++	if (state->large_len) {
++		h32 = xxh_rotl32(state->v1, 1) + xxh_rotl32(state->v2, 7) +
++			xxh_rotl32(state->v3, 12) + xxh_rotl32(state->v4, 18);
++	} else {
++		h32 = state->v3 /* == seed */ + PRIME32_5;
++	}
++
++	h32 += state->total_len_32;
++
++	while (p + 4 <= b_end) {
++		h32 += get_unaligned_le32(p) * PRIME32_3;
++		h32 = xxh_rotl32(h32, 17) * PRIME32_4;
++		p += 4;
++	}
++
++	while (p < b_end) {
++		h32 += (*p) * PRIME32_5;
++		h32 = xxh_rotl32(h32, 11) * PRIME32_1;
++		p++;
++	}
++
++	h32 ^= h32 >> 15;
++	h32 *= PRIME32_2;
++	h32 ^= h32 >> 13;
++	h32 *= PRIME32_3;
++	h32 ^= h32 >> 16;
++
++	return h32;
++}
++EXPORT_SYMBOL(xxh32_digest);
++
++int xxh64_update(struct xxh64_state *state, const void *input, const size_t len)
++{
++	const uint8_t *p = (const uint8_t *)input;
++	const uint8_t *const b_end = p + len;
++
++	if (input == NULL)
++		return -EINVAL;
++
++	state->total_len += len;
++
++	if (state->memsize + len < 32) { /* fill in tmp buffer */
++		memcpy(((uint8_t *)state->mem64) + state->memsize, input, len);
++		state->memsize += (uint32_t)len;
++		return 0;
++	}
++
++	if (state->memsize) { /* tmp buffer is full */
++		uint64_t *p64 = state->mem64;
++
++		memcpy(((uint8_t *)p64) + state->memsize, input,
++			32 - state->memsize);
++
++		state->v1 = xxh64_round(state->v1, get_unaligned_le64(p64));
++		p64++;
++		state->v2 = xxh64_round(state->v2, get_unaligned_le64(p64));
++		p64++;
++		state->v3 = xxh64_round(state->v3, get_unaligned_le64(p64));
++		p64++;
++		state->v4 = xxh64_round(state->v4, get_unaligned_le64(p64));
++
++		p += 32 - state->memsize;
++		state->memsize = 0;
++	}
++
++	if (p + 32 <= b_end) {
++		const uint8_t *const limit = b_end - 32;
++		uint64_t v1 = state->v1;
++		uint64_t v2 = state->v2;
++		uint64_t v3 = state->v3;
++		uint64_t v4 = state->v4;
++
++		do {
++			v1 = xxh64_round(v1, get_unaligned_le64(p));
++			p += 8;
++			v2 = xxh64_round(v2, get_unaligned_le64(p));
++			p += 8;
++			v3 = xxh64_round(v3, get_unaligned_le64(p));
++			p += 8;
++			v4 = xxh64_round(v4, get_unaligned_le64(p));
++			p += 8;
++		} while (p <= limit);
++
++		state->v1 = v1;
++		state->v2 = v2;
++		state->v3 = v3;
++		state->v4 = v4;
++	}
++
++	if (p < b_end) {
++		memcpy(state->mem64, p, (size_t)(b_end-p));
++		state->memsize = (uint32_t)(b_end - p);
++	}
++
++	return 0;
++}
++EXPORT_SYMBOL(xxh64_update);
++
++uint64_t xxh64_digest(const struct xxh64_state *state)
++{
++	const uint8_t *p = (const uint8_t *)state->mem64;
++	const uint8_t *const b_end = (const uint8_t *)state->mem64 +
++		state->memsize;
++	uint64_t h64;
++
++	if (state->total_len >= 32) {
++		const uint64_t v1 = state->v1;
++		const uint64_t v2 = state->v2;
++		const uint64_t v3 = state->v3;
++		const uint64_t v4 = state->v4;
++
++		h64 = xxh_rotl64(v1, 1) + xxh_rotl64(v2, 7) +
++			xxh_rotl64(v3, 12) + xxh_rotl64(v4, 18);
++		h64 = xxh64_merge_round(h64, v1);
++		h64 = xxh64_merge_round(h64, v2);
++		h64 = xxh64_merge_round(h64, v3);
++		h64 = xxh64_merge_round(h64, v4);
++	} else {
++		h64  = state->v3 + PRIME64_5;
++	}
++
++	h64 += (uint64_t)state->total_len;
++
++	while (p + 8 <= b_end) {
++		const uint64_t k1 = xxh64_round(0, get_unaligned_le64(p));
++
++		h64 ^= k1;
++		h64 = xxh_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;
++		p += 8;
++	}
++
++	if (p + 4 <= b_end) {
++		h64 ^= (uint64_t)(get_unaligned_le32(p)) * PRIME64_1;
++		h64 = xxh_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
++		p += 4;
++	}
++
++	while (p < b_end) {
++		h64 ^= (*p) * PRIME64_5;
++		h64 = xxh_rotl64(h64, 11) * PRIME64_1;
++		p++;
++	}
++
++	h64 ^= h64 >> 33;
++	h64 *= PRIME64_2;
++	h64 ^= h64 >> 29;
++	h64 *= PRIME64_3;
++	h64 ^= h64 >> 32;
++
++	return h64;
++}
++EXPORT_SYMBOL(xxh64_digest);
++
++MODULE_LICENSE("Dual BSD/GPL");
++MODULE_DESCRIPTION("xxHash");
+--
+2.9.3

contrib/linux-kernel/0003-btrfs-Add-zstd-support.patch

@@ -0,0 +1,740 @@
+From 8a9dddfbf6551afea73911e367dd4be64d62b9fd Mon Sep 17 00:00:00 2001
+From: Nick Terrell <terrelln@fb.com>
+Date: Mon, 17 Jul 2017 17:08:39 -0700
+Subject: [PATCH v5 3/5] btrfs: Add zstd support
+
+Add zstd compression and decompression support to BtrFS. zstd at its
+fastest level compresses almost as well as zlib, while offering much
+faster compression and decompression, approaching lzo speeds.
+
+I benchmarked btrfs with zstd compression against no compression, lzo
+compression, and zlib compression. I benchmarked two scenarios. Copying
+a set of files to btrfs, and then reading the files. Copying a tarball
+to btrfs, extracting it to btrfs, and then reading the extracted files.
+After every operation, I call `sync` and include the sync time.
+Between every pair of operations I unmount and remount the filesystem
+to avoid caching. The benchmark files can be found in the upstream
+zstd source repository under
+`contrib/linux-kernel/{btrfs-benchmark.sh,btrfs-extract-benchmark.sh}`
+[1] [2].
+
+I ran the benchmarks on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.
+The VM is running on a MacBook Pro with a 3.1 GHz Intel Core i7 processor,
+16 GB of RAM, and a SSD.
+
+The first compression benchmark is copying 10 copies of the unzipped
+Silesia corpus [3] into a BtrFS filesystem mounted with
+`-o compress-force=Method`. The decompression benchmark times how long
+it takes to `tar` all 10 copies into `/dev/null`. The compression ratio is
+measured by comparing the output of `df` and `du`. See the benchmark file
+[1] for details. I benchmarked multiple zstd compression levels, although
+the patch uses zstd level 1.
+
+| Method  | Ratio | Compression MB/s | Decompression speed |
+|---------|-------|------------------|---------------------|
+| None    |  0.99 |              504 |                 686 |
+| lzo     |  1.66 |              398 |                 442 |
+| zlib    |  2.58 |               65 |                 241 |
+| zstd 1  |  2.57 |              260 |                 383 |
+| zstd 3  |  2.71 |              174 |                 408 |
+| zstd 6  |  2.87 |               70 |                 398 |
+| zstd 9  |  2.92 |               43 |                 406 |
+| zstd 12 |  2.93 |               21 |                 408 |
+| zstd 15 |  3.01 |               11 |                 354 |
+
+The next benchmark first copies `linux-4.11.6.tar` [4] to btrfs. Then it
+measures the compression ratio, extracts the tar, and deletes the tar.
+Then it measures the compression ratio again, and `tar`s the extracted
+files into `/dev/null`. See the benchmark file [2] for details.
+
+| Method | Tar Ratio | Extract Ratio | Copy (s) | Extract (s)| Read (s) |
+|--------|-----------|---------------|----------|------------|----------|
+| None   |      0.97 |          0.78 |    0.981 |      5.501 |    8.807 |
+| lzo    |      2.06 |          1.38 |    1.631 |      8.458 |    8.585 |
+| zlib   |      3.40 |          1.86 |    7.750 |     21.544 |   11.744 |
+| zstd 1 |      3.57 |          1.85 |    2.579 |     11.479 |    9.389 |
+
+[1] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-benchmark.sh
+[2] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/btrfs-extract-benchmark.sh
+[3] http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
+[4] https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-4.11.6.tar.xz
+
+zstd source repository: https://github.com/facebook/zstd
+
+Signed-off-by: Nick Terrell <terrelln@fb.com>
+---
+v2 -> v3:
+- Port upstream BtrFS commits e1ddce71d6, 389a6cfc2a, and 6acafd1eff
+- Change default compression level for BtrFS to 3
+
+v3 -> v4:
+- Add missing includes, which fixes the aarch64 build
+- Fix minor linter warnings
+
+ fs/btrfs/Kconfig           |   2 +
+ fs/btrfs/Makefile          |   2 +-
+ fs/btrfs/compression.c     |   1 +
+ fs/btrfs/compression.h     |   6 +-
+ fs/btrfs/ctree.h           |   1 +
+ fs/btrfs/disk-io.c         |   2 +
+ fs/btrfs/ioctl.c           |   6 +-
+ fs/btrfs/props.c           |   6 +
+ fs/btrfs/super.c           |  12 +-
+ fs/btrfs/sysfs.c           |   2 +
+ fs/btrfs/zstd.c            | 432 +++++++++++++++++++++++++++++++++++++++++++++
+ include/uapi/linux/btrfs.h |   8 +-
+ 12 files changed, 468 insertions(+), 12 deletions(-)
+ create mode 100644 fs/btrfs/zstd.c
+
+diff --git a/fs/btrfs/Kconfig b/fs/btrfs/Kconfig
+index 80e9c18..a26c63b 100644
+--- a/fs/btrfs/Kconfig
++++ b/fs/btrfs/Kconfig
+@@ -6,6 +6,8 @@ config BTRFS_FS
+ 	select ZLIB_DEFLATE
+ 	select LZO_COMPRESS
+ 	select LZO_DECOMPRESS
++	select ZSTD_COMPRESS
++	select ZSTD_DECOMPRESS
+ 	select RAID6_PQ
+ 	select XOR_BLOCKS
+ 	select SRCU
+diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
+index 128ce17..962a95a 100644
+--- a/fs/btrfs/Makefile
++++ b/fs/btrfs/Makefile
+@@ -6,7 +6,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
+ 	   transaction.o inode.o file.o tree-defrag.o \
+ 	   extent_map.o sysfs.o struct-funcs.o xattr.o ordered-data.o \
+ 	   extent_io.o volumes.o async-thread.o ioctl.o locking.o orphan.o \
+-	   export.o tree-log.o free-space-cache.o zlib.o lzo.o \
++	   export.o tree-log.o free-space-cache.o zlib.o lzo.o zstd.o \
+ 	   compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \
+ 	   reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \
+ 	   uuid-tree.o props.o hash.o free-space-tree.o
+diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
+index d2ef9ac..4ff42d1 100644
+--- a/fs/btrfs/compression.c
++++ b/fs/btrfs/compression.c
+@@ -704,6 +704,7 @@ static struct {
+ static const struct btrfs_compress_op * const btrfs_compress_op[] = {
+ 	&btrfs_zlib_compress,
+ 	&btrfs_lzo_compress,
++	&btrfs_zstd_compress,
+ };
+
+ void __init btrfs_init_compress(void)
+diff --git a/fs/btrfs/compression.h b/fs/btrfs/compression.h
+index 87f6d33..2269e00 100644
+--- a/fs/btrfs/compression.h
++++ b/fs/btrfs/compression.h
+@@ -99,8 +99,9 @@ enum btrfs_compression_type {
+ 	BTRFS_COMPRESS_NONE  = 0,
+ 	BTRFS_COMPRESS_ZLIB  = 1,
+ 	BTRFS_COMPRESS_LZO   = 2,
+-	BTRFS_COMPRESS_TYPES = 2,
+-	BTRFS_COMPRESS_LAST  = 3,
++	BTRFS_COMPRESS_ZSTD  = 3,
++	BTRFS_COMPRESS_TYPES = 3,
++	BTRFS_COMPRESS_LAST  = 4,
+ };
+
+ struct btrfs_compress_op {
+@@ -128,5 +129,6 @@ struct btrfs_compress_op {
+
+ extern const struct btrfs_compress_op btrfs_zlib_compress;
+ extern const struct btrfs_compress_op btrfs_lzo_compress;
++extern const struct btrfs_compress_op btrfs_zstd_compress;
+
+ #endif
+diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
+index 3f3eb7b..845d77c 100644
+--- a/fs/btrfs/ctree.h
++++ b/fs/btrfs/ctree.h
+@@ -270,6 +270,7 @@ struct btrfs_super_block {
+ 	 BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |		\
+ 	 BTRFS_FEATURE_INCOMPAT_BIG_METADATA |		\
+ 	 BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |		\
++	 BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD |		\
+ 	 BTRFS_FEATURE_INCOMPAT_RAID56 |		\
+ 	 BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |		\
+ 	 BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA |	\
+diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
+index 080e2eb..04632f4 100644
+--- a/fs/btrfs/disk-io.c
++++ b/fs/btrfs/disk-io.c
+@@ -2828,6 +2828,8 @@ int open_ctree(struct super_block *sb,
+ 	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
+ 	if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
+ 		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
++	else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)
++		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD;
+
+ 	if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
+ 		btrfs_info(fs_info, "has skinny extents");
+diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
+index fa1b78c..b9963d9 100644
+--- a/fs/btrfs/ioctl.c
++++ b/fs/btrfs/ioctl.c
+@@ -327,8 +327,10 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
+
+ 		if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
+ 			comp = "lzo";
+-		else
++		else if (fs_info->compress_type == BTRFS_COMPRESS_ZLIB)
+ 			comp = "zlib";
++		else
++			comp = "zstd";
+ 		ret = btrfs_set_prop(inode, "btrfs.compression",
+ 				     comp, strlen(comp), 0);
+ 		if (ret)
+@@ -1466,6 +1468,8 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
+
+ 	if (range->compress_type == BTRFS_COMPRESS_LZO) {
+ 		btrfs_set_fs_incompat(fs_info, COMPRESS_LZO);
++	} else if (range->compress_type == BTRFS_COMPRESS_ZSTD) {
++		btrfs_set_fs_incompat(fs_info, COMPRESS_ZSTD);
+ 	}
+
+ 	ret = defrag_count;
+diff --git a/fs/btrfs/props.c b/fs/btrfs/props.c
+index 4b23ae5..20631e9 100644
+--- a/fs/btrfs/props.c
++++ b/fs/btrfs/props.c
+@@ -390,6 +390,8 @@ static int prop_compression_validate(const char *value, size_t len)
+ 		return 0;
+ 	else if (!strncmp("zlib", value, len))
+ 		return 0;
++	else if (!strncmp("zstd", value, len))
++		return 0;
+
+ 	return -EINVAL;
+ }
+@@ -412,6 +414,8 @@ static int prop_compression_apply(struct inode *inode,
+ 		type = BTRFS_COMPRESS_LZO;
+ 	else if (!strncmp("zlib", value, len))
+ 		type = BTRFS_COMPRESS_ZLIB;
++	else if (!strncmp("zstd", value, len))
++		type = BTRFS_COMPRESS_ZSTD;
+ 	else
+ 		return -EINVAL;
+
+@@ -429,6 +433,8 @@ static const char *prop_compression_extract(struct inode *inode)
+ 		return "zlib";
+ 	case BTRFS_COMPRESS_LZO:
+ 		return "lzo";
++	case BTRFS_COMPRESS_ZSTD:
++		return "zstd";
+ 	}
+
+ 	return NULL;
+diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
+index 12540b6..c370dea 100644
+--- a/fs/btrfs/super.c
++++ b/fs/btrfs/super.c
+@@ -513,6 +513,14 @@ int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
+ 				btrfs_clear_opt(info->mount_opt, NODATASUM);
+ 				btrfs_set_fs_incompat(info, COMPRESS_LZO);
+ 				no_compress = 0;
++			} else if (strcmp(args[0].from, "zstd") == 0) {
++				compress_type = "zstd";
++				info->compress_type = BTRFS_COMPRESS_ZSTD;
++				btrfs_set_opt(info->mount_opt, COMPRESS);
++				btrfs_clear_opt(info->mount_opt, NODATACOW);
++				btrfs_clear_opt(info->mount_opt, NODATASUM);
++				btrfs_set_fs_incompat(info, COMPRESS_ZSTD);
++				no_compress = 0;
+ 			} else if (strncmp(args[0].from, "no", 2) == 0) {
+ 				compress_type = "no";
+ 				btrfs_clear_opt(info->mount_opt, COMPRESS);
+@@ -1227,8 +1235,10 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
+ 	if (btrfs_test_opt(info, COMPRESS)) {
+ 		if (info->compress_type == BTRFS_COMPRESS_ZLIB)
+ 			compress_type = "zlib";
+-		else
++		else if (info->compress_type == BTRFS_COMPRESS_LZO)
+ 			compress_type = "lzo";
++		else
++			compress_type = "zstd";
+ 		if (btrfs_test_opt(info, FORCE_COMPRESS))
+ 			seq_printf(seq, ",compress-force=%s", compress_type);
+ 		else
+diff --git a/fs/btrfs/sysfs.c b/fs/btrfs/sysfs.c
+index c2d5f35..2b6d37c 100644
+--- a/fs/btrfs/sysfs.c
++++ b/fs/btrfs/sysfs.c
+@@ -200,6 +200,7 @@ BTRFS_FEAT_ATTR_INCOMPAT(mixed_backref, MIXED_BACKREF);
+ BTRFS_FEAT_ATTR_INCOMPAT(default_subvol, DEFAULT_SUBVOL);
+ BTRFS_FEAT_ATTR_INCOMPAT(mixed_groups, MIXED_GROUPS);
+ BTRFS_FEAT_ATTR_INCOMPAT(compress_lzo, COMPRESS_LZO);
++BTRFS_FEAT_ATTR_INCOMPAT(compress_zstd, COMPRESS_ZSTD);
+ BTRFS_FEAT_ATTR_INCOMPAT(big_metadata, BIG_METADATA);
+ BTRFS_FEAT_ATTR_INCOMPAT(extended_iref, EXTENDED_IREF);
+ BTRFS_FEAT_ATTR_INCOMPAT(raid56, RAID56);
+@@ -212,6 +213,7 @@ static struct attribute *btrfs_supported_feature_attrs[] = {
+ 	BTRFS_FEAT_ATTR_PTR(default_subvol),
+ 	BTRFS_FEAT_ATTR_PTR(mixed_groups),
+ 	BTRFS_FEAT_ATTR_PTR(compress_lzo),
++	BTRFS_FEAT_ATTR_PTR(compress_zstd),
+ 	BTRFS_FEAT_ATTR_PTR(big_metadata),
+ 	BTRFS_FEAT_ATTR_PTR(extended_iref),
+ 	BTRFS_FEAT_ATTR_PTR(raid56),
+diff --git a/fs/btrfs/zstd.c b/fs/btrfs/zstd.c
+new file mode 100644
+index 0000000..607ce47
+--- /dev/null
++++ b/fs/btrfs/zstd.c
+@@ -0,0 +1,432 @@
++/*
++ * Copyright (c) 2016-present, Facebook, Inc.
++ * All rights reserved.
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public
++ * License v2 as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++ * General Public License for more details.
++ */
++#include <linux/bio.h>
++#include <linux/err.h>
++#include <linux/init.h>
++#include <linux/kernel.h>
++#include <linux/mm.h>
++#include <linux/pagemap.h>
++#include <linux/refcount.h>
++#include <linux/sched.h>
++#include <linux/slab.h>
++#include <linux/zstd.h>
++#include "compression.h"
++
++#define ZSTD_BTRFS_MAX_WINDOWLOG 17
++#define ZSTD_BTRFS_MAX_INPUT (1 << ZSTD_BTRFS_MAX_WINDOWLOG)
++#define ZSTD_BTRFS_DEFAULT_LEVEL 3
++
++static ZSTD_parameters zstd_get_btrfs_parameters(size_t src_len)
++{
++	ZSTD_parameters params = ZSTD_getParams(ZSTD_BTRFS_DEFAULT_LEVEL,
++						src_len, 0);
++
++	if (params.cParams.windowLog > ZSTD_BTRFS_MAX_WINDOWLOG)
++		params.cParams.windowLog = ZSTD_BTRFS_MAX_WINDOWLOG;
++	WARN_ON(src_len > ZSTD_BTRFS_MAX_INPUT);
++	return params;
++}
++
++struct workspace {
++	void *mem;
++	size_t size;
++	char *buf;
++	struct list_head list;
++};
++
++static void zstd_free_workspace(struct list_head *ws)
++{
++	struct workspace *workspace = list_entry(ws, struct workspace, list);
++
++	kvfree(workspace->mem);
++	kfree(workspace->buf);
++	kfree(workspace);
++}
++
++static struct list_head *zstd_alloc_workspace(void)
++{
++	ZSTD_parameters params =
++			zstd_get_btrfs_parameters(ZSTD_BTRFS_MAX_INPUT);
++	struct workspace *workspace;
++
++	workspace = kzalloc(sizeof(*workspace), GFP_KERNEL);
++	if (!workspace)
++		return ERR_PTR(-ENOMEM);
++
++	workspace->size = max_t(size_t,
++			ZSTD_CStreamWorkspaceBound(params.cParams),
++			ZSTD_DStreamWorkspaceBound(ZSTD_BTRFS_MAX_INPUT));
++	workspace->mem = kvmalloc(workspace->size, GFP_KERNEL);
++	workspace->buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
++	if (!workspace->mem || !workspace->buf)
++		goto fail;
++
++	INIT_LIST_HEAD(&workspace->list);
++
++	return &workspace->list;
++fail:
++	zstd_free_workspace(&workspace->list);
++	return ERR_PTR(-ENOMEM);
++}
++
++static int zstd_compress_pages(struct list_head *ws,
++		struct address_space *mapping,
++		u64 start,
++		struct page **pages,
++		unsigned long *out_pages,
++		unsigned long *total_in,
++		unsigned long *total_out)
++{
++	struct workspace *workspace = list_entry(ws, struct workspace, list);
++	ZSTD_CStream *stream;
++	int ret = 0;
++	int nr_pages = 0;
++	struct page *in_page = NULL;  /* The current page to read */
++	struct page *out_page = NULL; /* The current page to write to */
++	ZSTD_inBuffer in_buf = { NULL, 0, 0 };
++	ZSTD_outBuffer out_buf = { NULL, 0, 0 };
++	unsigned long tot_in = 0;
++	unsigned long tot_out = 0;
++	unsigned long len = *total_out;
++	const unsigned long nr_dest_pages = *out_pages;
++	unsigned long max_out = nr_dest_pages * PAGE_SIZE;
++	ZSTD_parameters params = zstd_get_btrfs_parameters(len);
++
++	*out_pages = 0;
++	*total_out = 0;
++	*total_in = 0;
++
++	/* Initialize the stream */
++	stream = ZSTD_initCStream(params, len, workspace->mem,
++			workspace->size);
++	if (!stream) {
++		pr_warn("BTRFS: ZSTD_initCStream failed\n");
++		ret = -EIO;
++		goto out;
++	}
++
++	/* map in the first page of input data */
++	in_page = find_get_page(mapping, start >> PAGE_SHIFT);
++	in_buf.src = kmap(in_page);
++	in_buf.pos = 0;
++	in_buf.size = min_t(size_t, len, PAGE_SIZE);
++
++
++	/* Allocate and map in the output buffer */
++	out_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
++	if (out_page == NULL) {
++		ret = -ENOMEM;
++		goto out;
++	}
++	pages[nr_pages++] = out_page;
++	out_buf.dst = kmap(out_page);
++	out_buf.pos = 0;
++	out_buf.size = min_t(size_t, max_out, PAGE_SIZE);
++
++	while (1) {
++		size_t ret2;
++
++		ret2 = ZSTD_compressStream(stream, &out_buf, &in_buf);
++		if (ZSTD_isError(ret2)) {
++			pr_debug("BTRFS: ZSTD_compressStream returned %d\n",
++					ZSTD_getErrorCode(ret2));
++			ret = -EIO;
++			goto out;
++		}
++
++		/* Check to see if we are making it bigger */
++		if (tot_in + in_buf.pos > 8192 &&
++				tot_in + in_buf.pos <
++				tot_out + out_buf.pos) {
++			ret = -E2BIG;
++			goto out;
++		}
++
++		/* We've reached the end of our output range */
++		if (out_buf.pos >= max_out) {
++			tot_out += out_buf.pos;
++			ret = -E2BIG;
++			goto out;
++		}
++
++		/* Check if we need more output space */
++		if (out_buf.pos == out_buf.size) {
++			tot_out += PAGE_SIZE;
++			max_out -= PAGE_SIZE;
++			kunmap(out_page);
++			if (nr_pages == nr_dest_pages) {
++				out_page = NULL;
++				ret = -E2BIG;
++				goto out;
++			}
++			out_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
++			if (out_page == NULL) {
++				ret = -ENOMEM;
++				goto out;
++			}
++			pages[nr_pages++] = out_page;
++			out_buf.dst = kmap(out_page);
++			out_buf.pos = 0;
++			out_buf.size = min_t(size_t, max_out, PAGE_SIZE);
++		}
++
++		/* We've reached the end of the input */
++		if (in_buf.pos >= len) {
++			tot_in += in_buf.pos;
++			break;
++		}
++
++		/* Check if we need more input */
++		if (in_buf.pos == in_buf.size) {
++			tot_in += PAGE_SIZE;
++			kunmap(in_page);
++			put_page(in_page);
++
++			start += PAGE_SIZE;
++			len -= PAGE_SIZE;
++			in_page = find_get_page(mapping, start >> PAGE_SHIFT);
++			in_buf.src = kmap(in_page);
++			in_buf.pos = 0;
++			in_buf.size = min_t(size_t, len, PAGE_SIZE);
++		}
++	}
++	while (1) {
++		size_t ret2;
++
++		ret2 = ZSTD_endStream(stream, &out_buf);
++		if (ZSTD_isError(ret2)) {
++			pr_debug("BTRFS: ZSTD_endStream returned %d\n",
++					ZSTD_getErrorCode(ret2));
++			ret = -EIO;
++			goto out;
++		}
++		if (ret2 == 0) {
++			tot_out += out_buf.pos;
++			break;
++		}
++		if (out_buf.pos >= max_out) {
++			tot_out += out_buf.pos;
++			ret = -E2BIG;
++			goto out;
++		}
++
++		tot_out += PAGE_SIZE;
++		max_out -= PAGE_SIZE;
++		kunmap(out_page);
++		if (nr_pages == nr_dest_pages) {
++			out_page = NULL;
++			ret = -E2BIG;
++			goto out;
++		}
++		out_page = alloc_page(GFP_NOFS | __GFP_HIGHMEM);
++		if (out_page == NULL) {
++			ret = -ENOMEM;
++			goto out;
++		}
++		pages[nr_pages++] = out_page;
++		out_buf.dst = kmap(out_page);
++		out_buf.pos = 0;
++		out_buf.size = min_t(size_t, max_out, PAGE_SIZE);
++	}
++
++	if (tot_out >= tot_in) {
++		ret = -E2BIG;
++		goto out;
++	}
++
++	ret = 0;
++	*total_in = tot_in;
++	*total_out = tot_out;
++out:
++	*out_pages = nr_pages;
++	/* Cleanup */
++	if (in_page) {
++		kunmap(in_page);
++		put_page(in_page);
++	}
++	if (out_page)
++		kunmap(out_page);
++	return ret;
++}
++
++static int zstd_decompress_bio(struct list_head *ws, struct compressed_bio *cb)
++{
++	struct workspace *workspace = list_entry(ws, struct workspace, list);
++	struct page **pages_in = cb->compressed_pages;
++	u64 disk_start = cb->start;
++	struct bio *orig_bio = cb->orig_bio;
++	size_t srclen = cb->compressed_len;
++	ZSTD_DStream *stream;
++	int ret = 0;
++	unsigned long page_in_index = 0;
++	unsigned long total_pages_in = DIV_ROUND_UP(srclen, PAGE_SIZE);
++	unsigned long buf_start;
++	unsigned long total_out = 0;
++	ZSTD_inBuffer in_buf = { NULL, 0, 0 };
++	ZSTD_outBuffer out_buf = { NULL, 0, 0 };
++
++	stream = ZSTD_initDStream(
++			ZSTD_BTRFS_MAX_INPUT, workspace->mem, workspace->size);
++	if (!stream) {
++		pr_debug("BTRFS: ZSTD_initDStream failed\n");
++		ret = -EIO;
++		goto done;
++	}
++
++	in_buf.src = kmap(pages_in[page_in_index]);
++	in_buf.pos = 0;
++	in_buf.size = min_t(size_t, srclen, PAGE_SIZE);
++
++	out_buf.dst = workspace->buf;
++	out_buf.pos = 0;
++	out_buf.size = PAGE_SIZE;
++
++	while (1) {
++		size_t ret2;
++
++		ret2 = ZSTD_decompressStream(stream, &out_buf, &in_buf);
++		if (ZSTD_isError(ret2)) {
++			pr_debug("BTRFS: ZSTD_decompressStream returned %d\n",
++					ZSTD_getErrorCode(ret2));
++			ret = -EIO;
++			goto done;
++		}
++		buf_start = total_out;
++		total_out += out_buf.pos;
++		out_buf.pos = 0;
++
++		ret = btrfs_decompress_buf2page(out_buf.dst, buf_start,
++				total_out, disk_start, orig_bio);
++		if (ret == 0)
++			break;
++
++		if (in_buf.pos >= srclen)
++			break;
++
++		/* Check if we've hit the end of a frame */
++		if (ret2 == 0)
++			break;
++
++		if (in_buf.pos == in_buf.size) {
++			kunmap(pages_in[page_in_index++]);
++			if (page_in_index >= total_pages_in) {
++				in_buf.src = NULL;
++				ret = -EIO;
++				goto done;
++			}
++			srclen -= PAGE_SIZE;
++			in_buf.src = kmap(pages_in[page_in_index]);
++			in_buf.pos = 0;
++			in_buf.size = min_t(size_t, srclen, PAGE_SIZE);
++		}
++	}
++	ret = 0;
++	zero_fill_bio(orig_bio);
++done:
++	if (in_buf.src)
++		kunmap(pages_in[page_in_index]);
++	return ret;
++}
++
++static int zstd_decompress(struct list_head *ws, unsigned char *data_in,
++		struct page *dest_page,
++		unsigned long start_byte,
++		size_t srclen, size_t destlen)
++{
++	struct workspace *workspace = list_entry(ws, struct workspace, list);
++	ZSTD_DStream *stream;
++	int ret = 0;
++	size_t ret2;
++	ZSTD_inBuffer in_buf = { NULL, 0, 0 };
++	ZSTD_outBuffer out_buf = { NULL, 0, 0 };
++	unsigned long total_out = 0;
++	unsigned long pg_offset = 0;
++	char *kaddr;
++
++	stream = ZSTD_initDStream(
++			ZSTD_BTRFS_MAX_INPUT, workspace->mem, workspace->size);
++	if (!stream) {
++		pr_warn("BTRFS: ZSTD_initDStream failed\n");
++		ret = -EIO;
++		goto finish;
++	}
++
++	destlen = min_t(size_t, destlen, PAGE_SIZE);
++
++	in_buf.src = data_in;
++	in_buf.pos = 0;
++	in_buf.size = srclen;
++
++	out_buf.dst = workspace->buf;
++	out_buf.pos = 0;
++	out_buf.size = PAGE_SIZE;
++
++	ret2 = 1;
++	while (pg_offset < destlen && in_buf.pos < in_buf.size) {
++		unsigned long buf_start;
++		unsigned long buf_offset;
++		unsigned long bytes;
++
++		/* Check if the frame is over and we still need more input */
++		if (ret2 == 0) {
++			pr_debug("BTRFS: ZSTD_decompressStream ended early\n");
++			ret = -EIO;
++			goto finish;
++		}
++		ret2 = ZSTD_decompressStream(stream, &out_buf, &in_buf);
++		if (ZSTD_isError(ret2)) {
++			pr_debug("BTRFS: ZSTD_decompressStream returned %d\n",
++					ZSTD_getErrorCode(ret2));
++			ret = -EIO;
++			goto finish;
++		}
++
++		buf_start = total_out;
++		total_out += out_buf.pos;
++		out_buf.pos = 0;
++
++		if (total_out <= start_byte)
++			continue;
++
++		if (total_out > start_byte && buf_start < start_byte)
++			buf_offset = start_byte - buf_start;
++		else
++			buf_offset = 0;
++
++		bytes = min_t(unsigned long, destlen - pg_offset,
++				out_buf.size - buf_offset);
++
++		kaddr = kmap_atomic(dest_page);
++		memcpy(kaddr + pg_offset, out_buf.dst + buf_offset, bytes);
++		kunmap_atomic(kaddr);
++
++		pg_offset += bytes;
++	}
++	ret = 0;
++finish:
++	if (pg_offset < destlen) {
++		kaddr = kmap_atomic(dest_page);
++		memset(kaddr + pg_offset, 0, destlen - pg_offset);
++		kunmap_atomic(kaddr);
++	}
++	return ret;
++}
++
++const struct btrfs_compress_op btrfs_zstd_compress = {
++	.alloc_workspace = zstd_alloc_workspace,
++	.free_workspace = zstd_free_workspace,
++	.compress_pages = zstd_compress_pages,
++	.decompress_bio = zstd_decompress_bio,
++	.decompress = zstd_decompress,
++};
+diff --git a/include/uapi/linux/btrfs.h b/include/uapi/linux/btrfs.h
+index 9aa74f3..378230c 100644
+--- a/include/uapi/linux/btrfs.h
++++ b/include/uapi/linux/btrfs.h
+@@ -255,13 +255,7 @@ struct btrfs_ioctl_fs_info_args {
+ #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL	(1ULL << 1)
+ #define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS	(1ULL << 2)
+ #define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO	(1ULL << 3)
+-/*
+- * some patches floated around with a second compression method
+- * lets save that incompat here for when they do get in
+- * Note we don't actually support it, we're just reserving the
+- * number
+- */
+-#define BTRFS_FEATURE_INCOMPAT_COMPRESS_LZOv2	(1ULL << 4)
++#define BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD	(1ULL << 4)
+
+ /*
+  * older kernels tried to do bigger metadata blocks, but the
+--
+2.9.3

contrib/linux-kernel/0004-squashfs-Add-zstd-support.patch

@@ -0,0 +1,306 @@
+From 46bf8f6d30d6ddf2446c110f122482b5e5e16933 Mon Sep 17 00:00:00 2001
+From: Sean Purcell <me@seanp.xyz>
+Date: Mon, 17 Jul 2017 17:08:59 -0700
+Subject: [PATCH v5 4/5] squashfs: Add zstd support
+
+Add zstd compression and decompression support to SquashFS. zstd is a
+great fit for SquashFS because it can compress at ratios approaching xz,
+while decompressing twice as fast as zlib. For SquashFS in particular,
+it can decompress as fast as lzo and lz4. It also has the flexibility
+to turn down the compression ratio for faster compression times.
+
+The compression benchmark is run on the file tree from the SquashFS archive
+found in ubuntu-16.10-desktop-amd64.iso [1]. It uses `mksquashfs` with the
+default block size (128 KB) and and various compression algorithms/levels.
+xz and zstd are also benchmarked with 256 KB blocks. The decompression
+benchmark times how long it takes to `tar` the file tree into `/dev/null`.
+See the benchmark file in the upstream zstd source repository located under
+`contrib/linux-kernel/squashfs-benchmark.sh` [2] for details.
+
+I ran the benchmarks on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.
+The VM is running on a MacBook Pro with a 3.1 GHz Intel Core i7 processor,
+16 GB of RAM, and a SSD.
+
+| Method         | Ratio | Compression MB/s | Decompression MB/s |
+|----------------|-------|------------------|--------------------|
+| gzip           |  2.92 |               15 |                128 |
+| lzo            |  2.64 |              9.5 |                217 |
+| lz4            |  2.12 |               94 |                218 |
+| xz             |  3.43 |              5.5 |                 35 |
+| xz 256 KB      |  3.53 |              5.4 |                 40 |
+| zstd 1         |  2.71 |               96 |                210 |
+| zstd 5         |  2.93 |               69 |                198 |
+| zstd 10        |  3.01 |               41 |                225 |
+| zstd 15        |  3.13 |             11.4 |                224 |
+| zstd 16 256 KB |  3.24 |              8.1 |                210 |
+
+This patch was written by Sean Purcell <me@seanp.xyz>, but I will be
+taking over the submission process.
+
+[1] http://releases.ubuntu.com/16.10/
+[2] https://github.com/facebook/zstd/blob/dev/contrib/linux-kernel/squashfs-benchmark.sh
+
+zstd source repository: https://github.com/facebook/zstd
+
+Signed-off-by: Sean Purcell <me@seanp.xyz>
+Signed-off-by: Nick Terrell <terrelln@fb.com>
+---
+v3 -> v4:
+- Fix minor linter warnings
+
+v4 -> v5:
+- Fix ZSTD_DStream initialization code in squashfs
+- Fix patch documentation to reflect that Sean Purcell is the author
+
+ fs/squashfs/Kconfig        |  14 +++++
+ fs/squashfs/Makefile       |   1 +
+ fs/squashfs/decompressor.c |   7 +++
+ fs/squashfs/decompressor.h |   4 ++
+ fs/squashfs/squashfs_fs.h  |   1 +
+ fs/squashfs/zstd_wrapper.c | 151 +++++++++++++++++++++++++++++++++++++++++++++
+ 6 files changed, 178 insertions(+)
+ create mode 100644 fs/squashfs/zstd_wrapper.c
+
+diff --git a/fs/squashfs/Kconfig b/fs/squashfs/Kconfig
+index ffb093e..1adb334 100644
+--- a/fs/squashfs/Kconfig
++++ b/fs/squashfs/Kconfig
+@@ -165,6 +165,20 @@ config SQUASHFS_XZ
+
+ 	  If unsure, say N.
+
++config SQUASHFS_ZSTD
++	bool "Include support for ZSTD compressed file systems"
++	depends on SQUASHFS
++	select ZSTD_DECOMPRESS
++	help
++	  Saying Y here includes support for reading Squashfs file systems
++	  compressed with ZSTD compression.  ZSTD gives better compression than
++	  the default ZLIB compression, while using less CPU.
++
++	  ZSTD is not the standard compression used in Squashfs and so most
++	  file systems will be readable without selecting this option.
++
++	  If unsure, say N.
++
+ config SQUASHFS_4K_DEVBLK_SIZE
+ 	bool "Use 4K device block size?"
+ 	depends on SQUASHFS
+diff --git a/fs/squashfs/Makefile b/fs/squashfs/Makefile
+index 246a6f3..6655631 100644
+--- a/fs/squashfs/Makefile
++++ b/fs/squashfs/Makefile
+@@ -15,3 +15,4 @@ squashfs-$(CONFIG_SQUASHFS_LZ4) += lz4_wrapper.o
+ squashfs-$(CONFIG_SQUASHFS_LZO) += lzo_wrapper.o
+ squashfs-$(CONFIG_SQUASHFS_XZ) += xz_wrapper.o
+ squashfs-$(CONFIG_SQUASHFS_ZLIB) += zlib_wrapper.o
++squashfs-$(CONFIG_SQUASHFS_ZSTD) += zstd_wrapper.o
+diff --git a/fs/squashfs/decompressor.c b/fs/squashfs/decompressor.c
+index d2bc136..8366398 100644
+--- a/fs/squashfs/decompressor.c
++++ b/fs/squashfs/decompressor.c
+@@ -65,6 +65,12 @@ static const struct squashfs_decompressor squashfs_zlib_comp_ops = {
+ };
+ #endif
+
++#ifndef CONFIG_SQUASHFS_ZSTD
++static const struct squashfs_decompressor squashfs_zstd_comp_ops = {
++	NULL, NULL, NULL, NULL, ZSTD_COMPRESSION, "zstd", 0
++};
++#endif
++
+ static const struct squashfs_decompressor squashfs_unknown_comp_ops = {
+ 	NULL, NULL, NULL, NULL, 0, "unknown", 0
+ };
+@@ -75,6 +81,7 @@ static const struct squashfs_decompressor *decompressor[] = {
+ 	&squashfs_lzo_comp_ops,
+ 	&squashfs_xz_comp_ops,
+ 	&squashfs_lzma_unsupported_comp_ops,
++	&squashfs_zstd_comp_ops,
+ 	&squashfs_unknown_comp_ops
+ };
+
+diff --git a/fs/squashfs/decompressor.h b/fs/squashfs/decompressor.h
+index a25713c..0f5a8e4 100644
+--- a/fs/squashfs/decompressor.h
++++ b/fs/squashfs/decompressor.h
+@@ -58,4 +58,8 @@ extern const struct squashfs_decompressor squashfs_lzo_comp_ops;
+ extern const struct squashfs_decompressor squashfs_zlib_comp_ops;
+ #endif
+
++#ifdef CONFIG_SQUASHFS_ZSTD
++extern const struct squashfs_decompressor squashfs_zstd_comp_ops;
++#endif
++
+ #endif
+diff --git a/fs/squashfs/squashfs_fs.h b/fs/squashfs/squashfs_fs.h
+index 506f4ba..24d12fd 100644
+--- a/fs/squashfs/squashfs_fs.h
++++ b/fs/squashfs/squashfs_fs.h
+@@ -241,6 +241,7 @@ struct meta_index {
+ #define LZO_COMPRESSION		3
+ #define XZ_COMPRESSION		4
+ #define LZ4_COMPRESSION		5
++#define ZSTD_COMPRESSION	6
+
+ struct squashfs_super_block {
+ 	__le32			s_magic;
+diff --git a/fs/squashfs/zstd_wrapper.c b/fs/squashfs/zstd_wrapper.c
+new file mode 100644
+index 0000000..eeaabf8
+--- /dev/null
++++ b/fs/squashfs/zstd_wrapper.c
+@@ -0,0 +1,151 @@
++/*
++ * Squashfs - a compressed read only filesystem for Linux
++ *
++ * Copyright (c) 2016-present, Facebook, Inc.
++ * All rights reserved.
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2,
++ * or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * zstd_wrapper.c
++ */
++
++#include <linux/mutex.h>
++#include <linux/buffer_head.h>
++#include <linux/slab.h>
++#include <linux/zstd.h>
++#include <linux/vmalloc.h>
++
++#include "squashfs_fs.h"
++#include "squashfs_fs_sb.h"
++#include "squashfs.h"
++#include "decompressor.h"
++#include "page_actor.h"
++
++struct workspace {
++	void *mem;
++	size_t mem_size;
++	size_t window_size;
++};
++
++static void *zstd_init(struct squashfs_sb_info *msblk, void *buff)
++{
++	struct workspace *wksp = kmalloc(sizeof(*wksp), GFP_KERNEL);
++
++	if (wksp == NULL)
++		goto failed;
++	wksp->window_size = max_t(size_t,
++			msblk->block_size, SQUASHFS_METADATA_SIZE);
++	wksp->mem_size = ZSTD_DStreamWorkspaceBound(wksp->window_size);
++	wksp->mem = vmalloc(wksp->mem_size);
++	if (wksp->mem == NULL)
++		goto failed;
++
++	return wksp;
++
++failed:
++	ERROR("Failed to allocate zstd workspace\n");
++	kfree(wksp);
++	return ERR_PTR(-ENOMEM);
++}
++
++
++static void zstd_free(void *strm)
++{
++	struct workspace *wksp = strm;
++
++	if (wksp)
++		vfree(wksp->mem);
++	kfree(wksp);
++}
++
++
++static int zstd_uncompress(struct squashfs_sb_info *msblk, void *strm,
++	struct buffer_head **bh, int b, int offset, int length,
++	struct squashfs_page_actor *output)
++{
++	struct workspace *wksp = strm;
++	ZSTD_DStream *stream;
++	size_t total_out = 0;
++	size_t zstd_err;
++	int k = 0;
++	ZSTD_inBuffer in_buf = { NULL, 0, 0 };
++	ZSTD_outBuffer out_buf = { NULL, 0, 0 };
++
++	stream = ZSTD_initDStream(wksp->window_size, wksp->mem, wksp->mem_size);
++
++	if (!stream) {
++		ERROR("Failed to initialize zstd decompressor\n");
++		goto out;
++	}
++
++	out_buf.size = PAGE_SIZE;
++	out_buf.dst = squashfs_first_page(output);
++
++	do {
++		if (in_buf.pos == in_buf.size && k < b) {
++			int avail = min(length, msblk->devblksize - offset);
++
++			length -= avail;
++			in_buf.src = bh[k]->b_data + offset;
++			in_buf.size = avail;
++			in_buf.pos = 0;
++			offset = 0;
++		}
++
++		if (out_buf.pos == out_buf.size) {
++			out_buf.dst = squashfs_next_page(output);
++			if (out_buf.dst == NULL) {
++				/* Shouldn't run out of pages
++				 * before stream is done.
++				 */
++				squashfs_finish_page(output);
++				goto out;
++			}
++			out_buf.pos = 0;
++			out_buf.size = PAGE_SIZE;
++		}
++
++		total_out -= out_buf.pos;
++		zstd_err = ZSTD_decompressStream(stream, &out_buf, &in_buf);
++		total_out += out_buf.pos; /* add the additional data produced */
++
++		if (in_buf.pos == in_buf.size && k < b)
++			put_bh(bh[k++]);
++	} while (zstd_err != 0 && !ZSTD_isError(zstd_err));
++
++	squashfs_finish_page(output);
++
++	if (ZSTD_isError(zstd_err)) {
++		ERROR("zstd decompression error: %d\n",
++				(int)ZSTD_getErrorCode(zstd_err));
++		goto out;
++	}
++
++	if (k < b)
++		goto out;
++
++	return (int)total_out;
++
++out:
++	for (; k < b; k++)
++		put_bh(bh[k]);
++
++	return -EIO;
++}
++
++const struct squashfs_decompressor squashfs_zstd_comp_ops = {
++	.init = zstd_init,
++	.free = zstd_free,
++	.decompress = zstd_uncompress,
++	.id = ZSTD_COMPRESSION,
++	.name = "zstd",
++	.supported = 1
++};
+--
+2.9.3

contrib/linux-kernel/0005-crypto-Add-zstd-support.patch

@@ -0,0 +1,424 @@
+From 308795a7713ca6fcd468b60fba9a2fca99cee6a0 Mon Sep 17 00:00:00 2001
+From: Nick Terrell <terrelln@fb.com>
+Date: Wed, 2 Aug 2017 18:02:13 -0700
+Subject: [PATCH v5 5/5] crypto: Add zstd support
+
+Adds zstd support to crypto and scompress. Only supports the default
+level.
+
+Signed-off-by: Nick Terrell <terrelln@fb.com>
+---
+ crypto/Kconfig   |   9 ++
+ crypto/Makefile  |   1 +
+ crypto/testmgr.c |  10 +++
+ crypto/testmgr.h |  71 +++++++++++++++
+ crypto/zstd.c    | 265 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 5 files changed, 356 insertions(+)
+ create mode 100644 crypto/zstd.c
+
+diff --git a/crypto/Kconfig b/crypto/Kconfig
+index caa770e..4fc3936 100644
+--- a/crypto/Kconfig
++++ b/crypto/Kconfig
+@@ -1662,6 +1662,15 @@ config CRYPTO_LZ4HC
+ 	help
+ 	  This is the LZ4 high compression mode algorithm.
+
++config CRYPTO_ZSTD
++	tristate "Zstd compression algorithm"
++	select CRYPTO_ALGAPI
++	select CRYPTO_ACOMP2
++	select ZSTD_COMPRESS
++	select ZSTD_DECOMPRESS
++	help
++	  This is the zstd algorithm.
++
+ comment "Random Number Generation"
+
+ config CRYPTO_ANSI_CPRNG
+diff --git a/crypto/Makefile b/crypto/Makefile
+index d41f033..b22e1e8 100644
+--- a/crypto/Makefile
++++ b/crypto/Makefile
+@@ -133,6 +133,7 @@ obj-$(CONFIG_CRYPTO_USER_API_HASH) += algif_hash.o
+ obj-$(CONFIG_CRYPTO_USER_API_SKCIPHER) += algif_skcipher.o
+ obj-$(CONFIG_CRYPTO_USER_API_RNG) += algif_rng.o
+ obj-$(CONFIG_CRYPTO_USER_API_AEAD) += algif_aead.o
++obj-$(CONFIG_CRYPTO_ZSTD) += zstd.o
+
+ ecdh_generic-y := ecc.o
+ ecdh_generic-y += ecdh.o
+diff --git a/crypto/testmgr.c b/crypto/testmgr.c
+index 7125ba3..8a124d3 100644
+--- a/crypto/testmgr.c
++++ b/crypto/testmgr.c
+@@ -3603,6 +3603,16 @@ static const struct alg_test_desc alg_test_descs[] = {
+ 				.decomp = __VECS(zlib_deflate_decomp_tv_template)
+ 			}
+ 		}
++	}, {
++		.alg = "zstd",
++		.test = alg_test_comp,
++		.fips_allowed = 1,
++		.suite = {
++			.comp = {
++				.comp = __VECS(zstd_comp_tv_template),
++				.decomp = __VECS(zstd_decomp_tv_template)
++			}
++		}
+ 	}
+ };
+
+diff --git a/crypto/testmgr.h b/crypto/testmgr.h
+index 6ceb0e2..e6b5920 100644
+--- a/crypto/testmgr.h
++++ b/crypto/testmgr.h
+@@ -34631,4 +34631,75 @@ static const struct comp_testvec lz4hc_decomp_tv_template[] = {
+ 	},
+ };
+
++static const struct comp_testvec zstd_comp_tv_template[] = {
++	{
++		.inlen	= 68,
++		.outlen	= 39,
++		.input	= "The algorithm is zstd. "
++			  "The algorithm is zstd. "
++			  "The algorithm is zstd.",
++		.output	= "\x28\xb5\x2f\xfd\x00\x50\xf5\x00\x00\xb8\x54\x68\x65"
++			  "\x20\x61\x6c\x67\x6f\x72\x69\x74\x68\x6d\x20\x69\x73"
++			  "\x20\x7a\x73\x74\x64\x2e\x20\x01\x00\x55\x73\x36\x01"
++			  ,
++	},
++	{
++		.inlen	= 244,
++		.outlen	= 151,
++		.input	= "zstd, short for Zstandard, is a fast lossless "
++			  "compression algorithm, targeting real-time "
++			  "compression scenarios at zlib-level and better "
++			  "compression ratios. The zstd compression library "
++			  "provides in-memory compression and decompression "
++			  "functions.",
++		.output	= "\x28\xb5\x2f\xfd\x00\x50\x75\x04\x00\x42\x4b\x1e\x17"
++			  "\x90\x81\x31\x00\xf2\x2f\xe4\x36\xc9\xef\x92\x88\x32"
++			  "\xc9\xf2\x24\x94\xd8\x68\x9a\x0f\x00\x0c\xc4\x31\x6f"
++			  "\x0d\x0c\x38\xac\x5c\x48\x03\xcd\x63\x67\xc0\xf3\xad"
++			  "\x4e\x90\xaa\x78\xa0\xa4\xc5\x99\xda\x2f\xb6\x24\x60"
++			  "\xe2\x79\x4b\xaa\xb6\x6b\x85\x0b\xc9\xc6\x04\x66\x86"
++			  "\xe2\xcc\xe2\x25\x3f\x4f\x09\xcd\xb8\x9d\xdb\xc1\x90"
++			  "\xa9\x11\xbc\x35\x44\x69\x2d\x9c\x64\x4f\x13\x31\x64"
++			  "\xcc\xfb\x4d\x95\x93\x86\x7f\x33\x7f\x1a\xef\xe9\x30"
++			  "\xf9\x67\xa1\x94\x0a\x69\x0f\x60\xcd\xc3\xab\x99\xdc"
++			  "\x42\xed\x97\x05\x00\x33\xc3\x15\x95\x3a\x06\xa0\x0e"
++			  "\x20\xa9\x0e\x82\xb9\x43\x45\x01",
++	},
++};
++
++static const struct comp_testvec zstd_decomp_tv_template[] = {
++	{
++		.inlen	= 43,
++		.outlen	= 68,
++		.input	= "\x28\xb5\x2f\xfd\x04\x50\xf5\x00\x00\xb8\x54\x68\x65"
++			  "\x20\x61\x6c\x67\x6f\x72\x69\x74\x68\x6d\x20\x69\x73"
++			  "\x20\x7a\x73\x74\x64\x2e\x20\x01\x00\x55\x73\x36\x01"
++			  "\x6b\xf4\x13\x35",
++		.output	= "The algorithm is zstd. "
++			  "The algorithm is zstd. "
++			  "The algorithm is zstd.",
++	},
++	{
++		.inlen	= 155,
++		.outlen	= 244,
++		.input	= "\x28\xb5\x2f\xfd\x04\x50\x75\x04\x00\x42\x4b\x1e\x17"
++			  "\x90\x81\x31\x00\xf2\x2f\xe4\x36\xc9\xef\x92\x88\x32"
++			  "\xc9\xf2\x24\x94\xd8\x68\x9a\x0f\x00\x0c\xc4\x31\x6f"
++			  "\x0d\x0c\x38\xac\x5c\x48\x03\xcd\x63\x67\xc0\xf3\xad"
++			  "\x4e\x90\xaa\x78\xa0\xa4\xc5\x99\xda\x2f\xb6\x24\x60"
++			  "\xe2\x79\x4b\xaa\xb6\x6b\x85\x0b\xc9\xc6\x04\x66\x86"
++			  "\xe2\xcc\xe2\x25\x3f\x4f\x09\xcd\xb8\x9d\xdb\xc1\x90"
++			  "\xa9\x11\xbc\x35\x44\x69\x2d\x9c\x64\x4f\x13\x31\x64"
++			  "\xcc\xfb\x4d\x95\x93\x86\x7f\x33\x7f\x1a\xef\xe9\x30"
++			  "\xf9\x67\xa1\x94\x0a\x69\x0f\x60\xcd\xc3\xab\x99\xdc"
++			  "\x42\xed\x97\x05\x00\x33\xc3\x15\x95\x3a\x06\xa0\x0e"
++			  "\x20\xa9\x0e\x82\xb9\x43\x45\x01\xaa\x6d\xda\x0d",
++		.output	= "zstd, short for Zstandard, is a fast lossless "
++			  "compression algorithm, targeting real-time "
++			  "compression scenarios at zlib-level and better "
++			  "compression ratios. The zstd compression library "
++			  "provides in-memory compression and decompression "
++			  "functions.",
++	},
++};
+ #endif	/* _CRYPTO_TESTMGR_H */
+diff --git a/crypto/zstd.c b/crypto/zstd.c
+new file mode 100644
+index 0000000..9a76b3e
+--- /dev/null
++++ b/crypto/zstd.c
+@@ -0,0 +1,265 @@
++/*
++ * Cryptographic API.
++ *
++ * Copyright (c) 2017-present, Facebook, Inc.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of the GNU General Public License version 2 as published by
++ * the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it will be useful, but WITHOUT
++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
++ * more details.
++ */
++#include <linux/crypto.h>
++#include <linux/init.h>
++#include <linux/interrupt.h>
++#include <linux/mm.h>
++#include <linux/module.h>
++#include <linux/net.h>
++#include <linux/vmalloc.h>
++#include <linux/zstd.h>
++#include <crypto/internal/scompress.h>
++
++
++#define ZSTD_DEF_LEVEL	3
++
++struct zstd_ctx {
++	ZSTD_CCtx *cctx;
++	ZSTD_DCtx *dctx;
++	void *cwksp;
++	void *dwksp;
++};
++
++static ZSTD_parameters zstd_params(void)
++{
++	return ZSTD_getParams(ZSTD_DEF_LEVEL, 0, 0);
++}
++
++static int zstd_comp_init(struct zstd_ctx *ctx)
++{
++	int ret = 0;
++	const ZSTD_parameters params = zstd_params();
++	const size_t wksp_size = ZSTD_CCtxWorkspaceBound(params.cParams);
++
++	ctx->cwksp = vzalloc(wksp_size);
++	if (!ctx->cwksp) {
++		ret = -ENOMEM;
++		goto out;
++	}
++
++	ctx->cctx = ZSTD_initCCtx(ctx->cwksp, wksp_size);
++	if (!ctx->cctx) {
++		ret = -EINVAL;
++		goto out_free;
++	}
++out:
++	return ret;
++out_free:
++	vfree(ctx->cwksp);
++	goto out;
++}
++
++static int zstd_decomp_init(struct zstd_ctx *ctx)
++{
++	int ret = 0;
++	const size_t wksp_size = ZSTD_DCtxWorkspaceBound();
++
++	ctx->dwksp = vzalloc(wksp_size);
++	if (!ctx->dwksp) {
++		ret = -ENOMEM;
++		goto out;
++	}
++
++	ctx->dctx = ZSTD_initDCtx(ctx->dwksp, wksp_size);
++	if (!ctx->dctx) {
++		ret = -EINVAL;
++		goto out_free;
++	}
++out:
++	return ret;
++out_free:
++	vfree(ctx->dwksp);
++	goto out;
++}
++
++static void zstd_comp_exit(struct zstd_ctx *ctx)
++{
++	vfree(ctx->cwksp);
++	ctx->cwksp = NULL;
++	ctx->cctx = NULL;
++}
++
++static void zstd_decomp_exit(struct zstd_ctx *ctx)
++{
++	vfree(ctx->dwksp);
++	ctx->dwksp = NULL;
++	ctx->dctx = NULL;
++}
++
++static int __zstd_init(void *ctx)
++{
++	int ret;
++
++	ret = zstd_comp_init(ctx);
++	if (ret)
++		return ret;
++	ret = zstd_decomp_init(ctx);
++	if (ret)
++		zstd_comp_exit(ctx);
++	return ret;
++}
++
++static void *zstd_alloc_ctx(struct crypto_scomp *tfm)
++{
++	int ret;
++	struct zstd_ctx *ctx;
++
++	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
++	if (!ctx)
++		return ERR_PTR(-ENOMEM);
++
++	ret = __zstd_init(ctx);
++	if (ret) {
++		kfree(ctx);
++		return ERR_PTR(ret);
++	}
++
++	return ctx;
++}
++
++static int zstd_init(struct crypto_tfm *tfm)
++{
++	struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
++
++	return __zstd_init(ctx);
++}
++
++static void __zstd_exit(void *ctx)
++{
++	zstd_comp_exit(ctx);
++	zstd_decomp_exit(ctx);
++}
++
++static void zstd_free_ctx(struct crypto_scomp *tfm, void *ctx)
++{
++	__zstd_exit(ctx);
++	kzfree(ctx);
++}
++
++static void zstd_exit(struct crypto_tfm *tfm)
++{
++	struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
++
++	__zstd_exit(ctx);
++}
++
++static int __zstd_compress(const u8 *src, unsigned int slen,
++			   u8 *dst, unsigned int *dlen, void *ctx)
++{
++	size_t out_len;
++	struct zstd_ctx *zctx = ctx;
++	const ZSTD_parameters params = zstd_params();
++
++	out_len = ZSTD_compressCCtx(zctx->cctx, dst, *dlen, src, slen, params);
++	if (ZSTD_isError(out_len))
++		return -EINVAL;
++	*dlen = out_len;
++	return 0;
++}
++
++static int zstd_compress(struct crypto_tfm *tfm, const u8 *src,
++			 unsigned int slen, u8 *dst, unsigned int *dlen)
++{
++	struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
++
++	return __zstd_compress(src, slen, dst, dlen, ctx);
++}
++
++static int zstd_scompress(struct crypto_scomp *tfm, const u8 *src,
++			  unsigned int slen, u8 *dst, unsigned int *dlen,
++			  void *ctx)
++{
++	return __zstd_compress(src, slen, dst, dlen, ctx);
++}
++
++static int __zstd_decompress(const u8 *src, unsigned int slen,
++			     u8 *dst, unsigned int *dlen, void *ctx)
++{
++	size_t out_len;
++	struct zstd_ctx *zctx = ctx;
++
++	out_len = ZSTD_decompressDCtx(zctx->dctx, dst, *dlen, src, slen);
++	if (ZSTD_isError(out_len))
++		return -EINVAL;
++	*dlen = out_len;
++	return 0;
++}
++
++static int zstd_decompress(struct crypto_tfm *tfm, const u8 *src,
++			   unsigned int slen, u8 *dst, unsigned int *dlen)
++{
++	struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
++
++	return __zstd_decompress(src, slen, dst, dlen, ctx);
++}
++
++static int zstd_sdecompress(struct crypto_scomp *tfm, const u8 *src,
++			    unsigned int slen, u8 *dst, unsigned int *dlen,
++			    void *ctx)
++{
++	return __zstd_decompress(src, slen, dst, dlen, ctx);
++}
++
++static struct crypto_alg alg = {
++	.cra_name		= "zstd",
++	.cra_flags		= CRYPTO_ALG_TYPE_COMPRESS,
++	.cra_ctxsize		= sizeof(struct zstd_ctx),
++	.cra_module		= THIS_MODULE,
++	.cra_init		= zstd_init,
++	.cra_exit		= zstd_exit,
++	.cra_u			= { .compress = {
++	.coa_compress		= zstd_compress,
++	.coa_decompress		= zstd_decompress } }
++};
++
++static struct scomp_alg scomp = {
++	.alloc_ctx		= zstd_alloc_ctx,
++	.free_ctx		= zstd_free_ctx,
++	.compress		= zstd_scompress,
++	.decompress		= zstd_sdecompress,
++	.base			= {
++		.cra_name	= "zstd",
++		.cra_driver_name = "zstd-scomp",
++		.cra_module	 = THIS_MODULE,
++	}
++};
++
++static int __init zstd_mod_init(void)
++{
++	int ret;
++
++	ret = crypto_register_alg(&alg);
++	if (ret)
++		return ret;
++
++	ret = crypto_register_scomp(&scomp);
++	if (ret)
++		crypto_unregister_alg(&alg);
++
++	return ret;
++}
++
++static void __exit zstd_mod_fini(void)
++{
++	crypto_unregister_alg(&alg);
++	crypto_unregister_scomp(&scomp);
++}
++
++module_init(zstd_mod_init);
++module_exit(zstd_mod_fini);
++
++MODULE_LICENSE("GPL");
++MODULE_DESCRIPTION("Zstd Compression Algorithm");
++MODULE_ALIAS_CRYPTO("zstd");
+--
+2.9.3